מבני נתונים ואלגוריתמים - מחברת קורס/גרפים/אלגוריתמים למציאת עפ"מ/תרגילים

מתוך ויקיספר, אוסף הספרים והמדריכים החופשי
קפיצה לניווט קפיצה לחיפוש


שימוש בקשת הזולה ביותר בגרף[עריכה]

שאלה[עריכה]

נתון גרף לא-מכוון וקשיר , וכן טבלת עלויות על הקשתות Edge-Costs. ידוע שקיימת קשת כלשהי כך שEdge-Costs[e] < Edge-Costs[e'] לכל קשת . במילים אחרות, היא הקשת הזולה ביותר (ממש).

אנא הוכח או הפרך את הטענה הבאה. הקשת שייכת לכל עפ"מ של .


שימו לב:

משפט הקשת הקלה - קשת בטוחה מוכיח לכשלעצמו רק שקיים עפ"מ המכיל את . השאלה מתייחסת לטענה חזקה יותר מכך.

תשובה[עריכה]

נניח שהטענה אינה נכונה, ו אינה חלק מקשתות העפ"מ. נניח ש יוצאת מצומת כלשהו. כפי שציינו בעבר, נוכל לצייר את העפ"מ כך ש הוא השורש שלו. הציור הבא מראה זאת. ילדי הם העצים .‏ , שאיננה חלק מהעפ"מ, ולכן מצויירת בקו מקווקוו, יוצאת מ ומגיעה לצומת כלשהו ב.

שימוש בקשת הקלה ביותר בגרף.

אך, כפי שהתרשים מראה, זה בלתי אפשרי. היות שכל קשת יקרה מ, אז גם הקשת המחברת בין ל יקרה מ. אפשר לראות בנקל שהחלפת שתי הקשתות תיצור עץ זול יותר מהעפ"מ (מה שכמובן בלתי אפשרי).

חוסר שימוש בקשת היקרה ביותר במעגל[עריכה]

שאלה[עריכה]

נתון גרף לא-מכוון וקשיר , וכן טבלת עלויות על הקשתות Edge-Costs. בגרף יש מעגל, כלומר מסלול (פשוט) שמתחיל ומסתיים באותו צומת. ידוע שקיימת קשת כלשהי כך שEdge-Costs[e] > Edge-Costs[e'] לכל קשת במעגל. במילים אחרות, היא הקשת היקרה ביותר (ממש) במעגל.

אנא הוכח שהקשת אינה שייכת לאף עפ"מ של .

תשובה[עריכה]

בתרשים הבא מצויירים צמתי המעגל, (הקשתות אינן מצויירות וכך גם שאר הצמתים). נניח שהקשת היא הקשת .

מעגל בבניית עפ"מ - מצב המעגל ההתחלתי.

נניח בשלילה ש אכן שייכת לעפ"מ. אפשר לבנות את העפ"מ ע"י הוספת קשתות בסדר שרירותי (באופן שקול: לאחר שקובעים את קשתות העפ"מ, אפשר לתאר אותן בסדר שרירותי). נניח לכן ש אחרונה. כמה עצים יש בדיוק לפני הוספת ? יש בהכרח שני עצים. לו היה עץ יחיד, הוספת היתה מייצרת מעגל, ולו היו שלושה (או יותר) עצים, קשת אחת לא היתה יכולה לחבר ביניהם.

נניח לכן שיש כרגע שני עצים: עץ אדום ועץ שחור. נניח ש שייך לעץ השחור. אז בהכרח שייך לעץ האדום (מדוע?). התרשים הבא מראה זאת.

מעגל בבניית עפ"מ - מצב המעגל לפני הוספת הקשת האחרונה.

נשים לב שאם שייך לעץ השחור ו לעץ האדום, אז בהכרח יש כך ש שייך לעץ השחור אך שייך לעץ האדום.

מעגל בבניית עפ"מ - קשת טובה יותר מהקשת האחרונה.

הקשת שייכת למעגל, ולכן בהכרח זולה מ (מדוע?). לכן ברור שנקבל עפ"מ זול יותר (ממש) אם בצעד האחרון נשתמש ב במקום ב, דבר שסותר את הנחתנו ש נמצאת בעפ"מ.

תנאי לעפ"מ יחידי[עריכה]

שאלה[עריכה]

נתון גרף לא-מכוון וקשיר , וכן טבלת עלויות לקשתות Weights. ידוע שאין שתי קשתות בעלות אותו המשקל: לכל שתי קשתות ו, בהכרח Weights[e1] ≠ Weights[e2]. אנא הוכח או הפרך את הטענה הבאה: לגרף קיים עץ פורש מינימום יחידי.

תשובה[עריכה]

תשובה שגויה ע"י שימוש באלגוריתם Kruskal[עריכה]

כדאי לדעת:

אלגוריתם Kruskal פועל כך. ראשית הוא ממיין את קשתות הגרף על פי העלות (או המשקל, תלוי בהגדרה), ולאחר מכן הוא בוחר קשתות מעצים שונים על פי סדר המיון.

להלן הוכחה שגויה לקיום עפ"מ יחידי:

הוכחה: נשים לב שאם הקשתות בעלות משקלים שונים, תוצאת המיון נקבעת חד משמעית, ולכן יש רק עפ"מ יחיד שאלגוריתם Kruskal יחזיר. לכן יש עפ"מ יחיד.

מש"ל.PNG

תשובה זו אינה נכונה, מפני שהיא מתייחסת לאלגוריתם Kruskal בלבד. אפשר עדיין לטעון, לדוגמה, שאלגוריתם Prim יחזיר עפ"מ שונה במקרה זה (בהמשך נראה שזה בלתי אפשרי, אלא שאי אפשר להסיק זאת מהטענה שהוצגה עד עתה).

תשובה שגויה ע"י שימוש לא נכון באינדוקציה[עריכה]

להלן הוכחה שגויה באינדוקציה:


הוכחה: האינדוקציה היא על מספר הצמתים, .

(בסיס האינדוקציה) כאשר אז יש צומת יחיד והעפ"מ בוודאי יחידי.

(מעבר האינדוקציה), ניקח צומת כלשהו , ונמצא את העפ"מ של הצמתים . קבוצה זו קטנה ב1 מ, ולכן יש לה עפ"מ יחידי. נותר לחבר את ל, וברור שנעשה זאת דרך הקשת הזולה ביותר בין לבין צומת ב.

מעבר אינדוקציה שגוי לעפ"מ יחדי.


מש"ל.PNG

מדוע ההוכחה שגויה? היא מוכיחה שיש עפ"מ יחיד מבין העפ"מים בהם יוצאת קשת יחידה מ. היא כלל אינה סותרת את קיומו של עפ"מ כמו בתרשים הבא, שלכאורה יכול להיות אופטימאלי גם כן:

סתירה מעבר אינדוקציה שגוי לעפ"מ יחדי.


כדאי לדעת:

חדי העין יזהו שאין הבדל ממשי בין הטעות כאן לבין הטעות הקודמת. האינדוקציה כאן היא למעשה הפעלת אלגוריתם Prim תחת הנחות שגויות שמקבלת תוצאה כללית לגבי כל העפ"מים האפשריים.

תשובה ע"י שיקול הקשת הזולה ביותר בגרף[עריכה]

ראשית נוכיח את המשפט הבא.



משפט:

נניח ש הוא גרף, הם שני צמתים, ו היא קשת.

"כווץ" גרף בין שני צמתים - לפני

נגדיר כעת את הגרף כגרף המתקבל מ"כיווץ" ו לצומת יחיד, .

"כווץ" גרף בין שני צמתים - אחרי

נגדיר כ את קשתות העפ"מ ב. אז קשתות עפ"מ זה יחד עם ,‏ כלומר ,‏ הם בהכרח קשתות העץ הזול ביותר הפורס את מבין העצים הפורשים שמשתמשים ב.



הוכחה: ראשית ברור שהתוצאה היא עץ. נניח ש ו הם שני צמתים. קל לראות שאם יש מסלול מ ל ב המשתמש בקשתות בלבד , אז יש מסלול מ ל ב המשתמש בקשתות בלבד. קל לראות שאם מכיל מעגל, אז גם מכיל מעגל.

כעת ברור גם שמדובר בעץ הזול ביותר. נניח שיש עץ פורש זול יותר . אז גם עץ פורש זול יותר ב, דבר שסותר את הנחתנו ש היא קבוצת קשתות עפ"מ.

מש"ל.PNG


בעזרת המשפט הקודם נוכל להוכיח שיש עפ"מ יחידי באינדוקציה (הפעם בצורה נכונה).


הוכחה: האינדוקציה היא על מספר הצמתים, .

(בסיס האינדוקציה) כאשר אז יש צומת יחיד והעפ"מ בוודאי יחידי.

(מעבר האינדוקציה) ניקח את הקשת הקלה ביותר בגרף . כבר הוכחנו שקשת זו היא חלק מכל עפ"מ. כעת "נכווץ" את הגרף ע"י הפיכת שני הצמתים, ו, לצומת יחיד. מהנחת האינדוקציה נובע שקיים כעת עפ"מ יחיד (שהרי מספר הצמתים ירד ב1). המשפט הקודם אומר שקשתות כל עפ"מ שהתקבל בגרף המכווץ, יחד עם , הן בדיוק קשתות העפ"מ בגרף המקורי. נובע לכן שיש עפ"מ יחיד.

מש"ל.PNG

תשובה ע"י שיקול הקשת היקרה ביותר במעגל[עריכה]

נניח בשלילה שיש שני עפ"מים שונים: ו. היות שהעפ"מים שונים אך מספר קשתותיהם שווה, קיימת בהכרח קשת השייכת ל אך לא ל. הוספת קשת זו ל בהכרח תיצור מעגל. נגדיר כ את הקשת הכבדה ביותר על פני המעגל, וניזכר שקשת זו איננה חלק מאף עפ"מ. כעת אם , אז אינה עפ"מ; מצד שני, אם , אז אינה עפ"מ. בכל מקרה, לא ייתכן מעגל כזה, ולכן בהכרח אין שני עפ"מים שונים.

מציאת עפ"מ בגרף בעל קשתות בתחום שלם קטן[עריכה]

שאלה[עריכה]

נתון גרף לא-מכוון וקשיר בייצוג רשימה, וטבלת עלויות לקשתות Edge-Costs.‏ הוא מספר שלם חיובי כלשהו, שאינו גדל עם שאר נתוני הבעיה (כגון מספר הצמתים והקשתות). ידוע שלכל קשת מחיר בתחום . אנא מצא אלגוריתם יעיל למציאת עץ פורש מינימום בגרף כגון זה.

תשובה[עריכה]

נתבונן בפסוודו-קוד של אלגוריתם Kruskal. נשים לב ש7 ממיינת את הקשתות לפי עלותן. במקרה זה, עפ"י נתוני השאלה, נוכל למיין את הקשתות בזמן לינארי ע"י שימוש במיון ספירה. מעבר לכך לא נשנה כלום.

כעת אם נסתכל באלגוריתם, נוכל לראות בנקל שהסיבוכיות היא רק במקרה הגרוע.

קבוצת היזון חוזר[עריכה]

שאלה[עריכה]

נתון גרף לא-מכוון וקשיר , וכן טבלת עלויות על הקשתות Edge-Costs.


הגדרה:

קבוצת קשתות היא קבוצת קשתות היזון חוזר אם לאחר הסרתה, חסר מעגלים; במילים אחרות, הקבוצה היא קבוצת קשתות היזון חוזר אם הוא יער.


בשאלה זו הינך מתבקש למצוא אלגוריתם יעיל המקבל גרף ומחזיר קבוצת היזון חוזר זולה ככל האפשר.


רמז

אל תתמקד בקבוצה , אלא בקבוצה המשלימה אותה, . אם היא קבוצת קשתות ההיזון החוזר הזולה ביותר - מהי ?‏ אם היא קבוצת קשתות ההיזון החוזר הזולה ביותר - איך תוכל למצוא את הקבוצה המשלימה לה ביעילות?

תשובה[עריכה]

ראשית נאפיין את בעזרת התנאי שניתן על .



משפט:

אם היא קבוצת ההיזון החוזר הזולה ביותר, אז היא קבוצת קשתות עץ פורש מקסימום.


נסמן כ את מחיר כל קשת (כלומר Edge-Costs[e]), ונסמן כאת סך משקל הקשתות, .


הוכחה: הקבוצה , היא, עפ"י ההגדרה, הקבוצה המביאה למינימום את


כך שחסרת מעגלים. במילים אחרות, הקבוצה היא הקבוצה כך שהקבוצה היא הקבוצה היקרה ביותר שעדיין חסרת מעגלים, ולכן היא היער היקר ביותר. אבל קל לראות שאם איננה עץ, אז יש קבוצה חסרת מעגלים יקרה לפחות כמוה (הגרף קשיר, ולכן תהיה לפחות עוד קשת אחת המחברת שני עצים ממנה).

מש"ל.PNG

נמצא, לכן, דרך יעילה למצוא עץ פורש מקסימום בגרף.

נסמן כ את מחיר הקשת היקרה ביותר פלוס 1 (כלומר ),‏ ונסמן לכל קשת ,‏ .



משפט:

אם נבנה טבלה Edge-Costs'כל שלכל קשת ,‏ Edge-Costs'[e] , ונריץ אלגוריתם עץ פורש מינימום עם Edge-Costs', אז קבוצת הקשתות שתוחזר תהווה קשתות לעץ פורש מקסימום עם Edge-Costs.



הוכחה: נשים לב שכל חיובי ממש (לפי הבניה), ולכן נוכל להריץ אלגוריתם עץ פורש מינימום עם Edge-Costs', והקבוצה שתוחזר לנו תהיה קבוצה בת גודל . בנוסף,





נוכל, לכן, לפתור את הבעיה בשלבים הבאים:

  1. נבנה את טבלת העלויות Edge-Costs'(בסיבוכיות ).
  2. נריץ את אלגוריתם Prim עם Edge-Costs' (בסיבוכיות ).
  3. נמצא את הקשתות שלא הוחזרו מאלגוריתם Prim (בסיכוכיות ).

הסיבוכיות הכוללת היא .

מש"ל.PNG

הוכחת אלגוריתם Prim[עריכה]

שאלה[עריכה]

להלן הפסוודו-קוד של אלגוריתם Prim, המוצא עץ פורש מינימום.

# Takes a connected undirected graph (G) and a cost table (W)
# Returns the cost of a set of edges E' such that (V(G), E') is 
#	a MST (minimum spanning tree).
MST-Prim(G, Edge-Costs)
1	pq = Make-Priority-Queue()
	
2	Min-Costs = Make-Array(Length(V(G)))
3	Used = Make-Array(Length(V(G)))
	
4	s = V[1]
	
5	for u in V(G)
6		Min-Costs[u] = u == s? 0 : 
7		Used[u] = False
8		Insert(pq, u)
		
9	total-cost = 0	
		
10	while Size(pq) < 0
11		u = Delete(pq)
12		Used[u] = True
	
13		total-cost = total-cost + Min-Costs[u]
	
14		for v in A(G, u)
15			if Min-Costs[v] < Edge-Costs[ (u, v) ] and Used[v] === False
16				Min-Costs[v] = Edge-Costs[ (u, v) ]
17				Decrease-Key(pq, v)
	                	
18	return total-cost


האתחול דומה מאד לזה שבאלגוריתם Dijkstra.‏ 1-8 דוחפות את כל הצמתים לתור קדימויות pq, ומאתחלות את Min-Costs כך שצומת המוצא הוא s. ההבדלים הם במערך Used,‏ ובמשמעות Min-Costs;‏ Used[u] מתאר האם כבר חיברנו את u לעץ של צומת המוצא s == V[1], וMin-Costs[u] מתאר את המחיר הזול ביותר (הידוע) שיעלה לחבר את u לעץ של צומת המוצא s.

כעת בלולאה 10-17 מוצאים כל פעם את הצומת u כך שu אינו בעץ של צומת המוצא s, אך עלות הוספתו היא הנמוכה ביותר. מעדכנים את העלות הכוללת ב13, ומחזירים עלות כוללת זו ב18 עם היציאה מהלולאה.

  1. אנא הוכח שהאלגוריתם מחזיר את מחירו של עפ"מ בהנתן לו גרף קשיר.
  2. אנא תאר את השינויים הנדרשים כך שהפונקציה תחזיר את קבוצת קשתות עפ"מ כלשהו (בהנתן גרף קשיר).


הנחיות לסעיף הראשון

הוכח (באינדוקציה) שכאשר מוצא צומת מpq ב11, אז Min-Costs[u] שווה בדיוק למחיר הקשת הזולה ביותר המחברת בין צומת כלשהו בעץ שאליו שייך לצומת כלשהו מחוץ לעץ - ואותו הצומת שמחוץ לעץ הוא אכן u. הסק שמדובר בקשת קלה. בהסתמך על זאת, טען שהאלגוריתם הוא למעשה מימוש של "אלגוריתם" Grow MST.

תשובה[עריכה]

1[עריכה]

ראשית נשנה מעט את אלגוריתם Prim:

MST-Prim(G, Edge-Costs)
1	pq = Make-Priority-Queue()
	
2	Min-Costs = Make-Array(Length(V(G)))
3	Used = Make-Array(Length(V(G)))
	
4	s = V[1]
	
5	for u in V(G)
6		Min-Costs[u] = u == s? 0 : 
7		Used[u] = False
8		Insert(pq, u)
		
9	V' = Make-List()
		
10	while Size(pq) > 0
11		u = Delete(pq)
12		Used[u] = True
	
13		Insert(V', u)
	
14		total-cost = total-cost + Min-Costs[u]
	
15		for v in A(G, u)
16			if Min-Costs[v] > Edge-Costs[ (u, v) ] and Used[v] == False
17				Min-Costs[v] = Edge-Costs[ (u, v) ]
18				Decrease-Key(pq, v)

השינויים היחידים הם ב9 וב13: אנו מחזיקים רשימה מקושרת V' המכילה את קבוצת הצמתים שצירפנו לעץ הפורש שאליו שייך s. בכל שלב נצרף את הצומת מחוץ לV' שהוא הזול ביותר להוספה (כלומר שהוא מחובר בקשת הזולה ביותר המחברת בין צומת בV' לצומת מחוץ לV').

כשמתבוננים בקוד ומבינים אותו כך, קל לראות שהאלגוריתם למעשה מממש את "אלגוריתם" Grow MST. קל להראות זאת פורמלית באינדוקציה - ההוכחה דומה מאד לאלגוריתם Kruskal.

2[עריכה]

שוב נשנה מעט את אלגוריתם Prim:

# Takes a connected undirected graph (G) and a cost table (W)
# Returns a set of edges E' such that (V(G), E') is 
#	a MST (minimum spanning tree).
MST-Prim(G, Edge-Costs)
1	pq = Make-Priority-Queue()
	
2	Min-Costs = Make-Array(Length(V(G)))
3	Neighbor = Make-Array(Length(V(G)))
4	Used = Make-Array(Length(V(G)))
	
5	s = V[1]
	
6	for u in V(G)
7		Min-Costs[u] = u == s? 0 : 
8		Neighbor[u] = u == s? 0 : 
9		Used[u] = False
10		Insert(pq, u)
		
11	E' = Make-List()
		
12	while Size(pq) > 0
13		u = Delete(pq)
14		Used[u] = True
	
15		if Neighbor[u] != 
16			Insert(E', (Neighbor[u], u) )
	
17		total-cost = total-cost + Min-Costs[u]
	
18		for v in A(G, u)
19			if Min-Costs[v] > Edge-Costs[ (u, v) ] and Used[v] == False
20				Min-Costs[v] = Edge-Costs[ (u, v) ]
21				Neighbor[v] = u
22				Decrease-Key(pq, v)
	                	
23	return E'

ההסבר וההוכחה כמעט זהים לאלה שבסעיף הקודם.