מבני נתונים בס"ד, ט' אדר א' תשע"א: שעור 1 אדמיניסטרציה ד"ר אלכס סמורודניצקי, רוס 210, שני 5:30 4:15. ציון: בחינת מגן 20%. תרגילים: 14 13, מורידים את האחד הכי גרוע. 10% מהציון. אתר: www.cs.huji.ac.il/~dast סיכומים לפנות למתרגלים. סיפורים, מוטיבציה זהו קורס ראשון מתוך שלושה שמתעסק באלגוריתמים: מבני נתונים, אלגוריתמים בסיסיים, "מימוש" במסגרת של מבני נתונים. אלגוריתמים, אלגוריתמים מתקדמים יותר. חישוביות. יעילות של אלגוריתמים, היררכיה, בעיות N P קשות. אלגוריתם: סדרת פעולות לבצוע משימה \ פתרון בעיה נתונה. מבנה נתונים: צורת שמירת מידע המאפשרת כמה פעולות בסיסיות: הכנסת מידע: אלגוריתם פשוט, הוצאת מידע, עדכון מידע. 1. אלגוריתמי מיון. 2. מבני נתונים. 3. אלגוריתמים חשובים: (א) דחיסת מידע. (ב) אלגוריתמים גרפיים. (ג) פונקציות גיבוב.hashing אליפות כדורגל עם 8 קבוצות. יש שתי שיטות: 1
1. שיטת הליגה: כל קבוצה מתחרה נגד כל הקבוצות האחרות. הנתונים מאוחסנים בטבלה 8 8 (האלכסון הראשי ריק). 2. שיטת הגביע: נחלק ל 4 זוגות, נחלק את המנצחים לזוגות, ואז הזוג המנצח יתחרו ביניהם. אלו שני אלגוריתמים לארגן תחרות. נרצה לשאול את השאלות הבאות: 1. איזה אלגוריתם יותר טוב? תלוי במטרה שלי. 2. נניח שהמטרה היא לבחור את האלופה. הגביע טוב יותר. משימה אלגוריתמית: בנה מודל של המציאות (הגדרת מטרות מדוייקות): לתכנן אלגוריתם. ואז צריך להוכיח את הנכונות שלו, ולנתח את המחיר. ננתח את הזמן ומספר המשחקים עבור n קבוצות. נתחיל עם המקרה הפשוט, n. = 2 k ) ( משחקים. n 2 = n(n 1) 2 1. בשיטת הליגה יש לנו.2 בשיטת הגביע יש לנו 1 n.2 k 1 + 2 k 2 +... + 1 = 2 k 1 = כמה סיבובים (n) T נצטרך?.1 בשיטת הליגה 1 n.t (n) = 2. בשיטת הגביע בכל שלב (יום משחק) מספר הקבוצות שנשארות קטן פי 2, ולכן עבור n = 2 k נצטרך k סיבובים כדי להגיע לקבוצה המנצחת. כלומר log 2 n משחקים. מה יקרה אם n אי זוגי? ) (, ולכן.T (n) = n n משחקים, מתוך 2 n 1 2 1. בשיטת הליגה, בכל סיבוב יש לנו 2. בשיטת הגביע, n אינו חזקה של 2, ולכן צריך להגדיר את האלגוריתם קצת אחרת: אם בשלב מסויים יש לנו מספר אי זוגי של קבוצות, יש קבוצה שתעלה אוטומטית לשלב הבא. למה: כל מספר טבעי n נמצא בין 2 חזקות עוקבות של k+1 :2.2 k n < 2.(2 k k הוכחה: סדרת המספרים..., 2k,... 2, 1, שואפת ל עם.k ) נקבע,n יהי k מקסימלי כך ש n.2 k אזי k+1.2 k n < 2 נשים לב כי 2 k n ולכן T (n).n < 2 k+1 2n מקיימת + 1 k,k = T ( 2 k) T (n) T ( 2 k+1) = כלומר log 2 n 2 = log 2 n 1 T ( 2 k) T (n) T ( 2 k+1) log 2 n + 1 = log 2 2n אלגוריתמי מיון: נתון מערך של n מספרים ממשיים. (n).a (1),..., a צריך למיין אותם בסדר עולה, כלומר להחזיר מערך (n).a (1) a (2)... a 2
1. אלגוריתם מיון בועות. :Bubble Sort (a) For i = 1 to n - 1 i. For j = 1 to n - i A. if (a(j) > a(j+1)) then swap a(j) and a(j+1). צריך: (א) להוכיח נכונות: באינדוקציה על i. טענה: לכל i, אחרי האיטרציה ה iית, במקומות n i+1,..., n עומדים i המספרים הגדולים, ממויינים בסדר הנכון. אם נוכיח זאת, זה יהיה נכון בפרט עבור 1 n i, = ז"א במקומות, n...,2 יעמדו המספרים הגדולים ממויינים לפי הסדר וזה יגיד שכל המערך ממויין. בדיקת הטענה: עבור = 1,i אנו עוברים על 1 n,j = 1,..., ומחליפים את (j) a עם 1) + (j a אם 1) + (j.a (j) > a נניח שהאיבר הגדול נמצא במקום,k מרגע שנגיע אליו, תמיד נחליף אותו עם הבא אחריו עד שהוא יגיע למקום n. בשלב האינדוקציה נניח שהטענה נכונה עבור i, נוכיח עבור + 1 i. אנו מניחים שכל המקומות מימין (n n) i + 1... כבר טופלו. אנו מבצעים את אותה הפעולה על n. התאים השמאליים, ונעביר את האיבר הגדול ביותר מביניהם למקום ה i n i (ב) לנתח מחיר: ניתן לכל פעולה מחיר של 1: קידום משתנה, השוואה, והחלפה. אזי ( ) n 1 n i n i n (n 1) T (n) = 1 + (1 + 1 + 1) = (n 1)+3 (n i) = (n 1)+3 2 i=1 j=1 יש לנו בעיה עם ההנחה שנותנת מחירים לבעיות, ולכן נכניס את הסימונים i=1 האסימפטוטיים, T (n) n 2 או 2).T (n) = Θ ( n בס"ד, ט"ז אדר א' תשע"א: שיעור 2 רקורסיה מיון בועות: נתון מערך (n),a [1,..., n] = a (1),..., a וצריך למיין אותו. האלגוריתם משבוע שעבר: 1. For i = 1 to n - 1 (a) For j = 1 to n - i i. if (a(j) > a(j+1)) then 3
A. swap a(j) and a(j+1). נרשום כעת את האלגוריתם הרקורסיבי: Bubble Sort A [1,..., n] 1. IF n = 1 return A [1,..., n] 2. else (a) Bubble A [1,..., n] (b) Bubble Sort A [1,..., n 1] Bubble A [1,..., k] 1. For j = 1 to k 1 do (a) if a (j) > a (j + 1) i. swap a (j), a (j + 1) ניתוח האלגוריתם:.1 נכונות:.V 2. זמן ריצה: נסמן (n) T את זמן הריצה של האלגוריתם על [n A.,1]..., משוואת רקורסיה של (n) T היא: (n),t (n) = T (n 1)+Θ עם תנאי התחלה (1) Θ.T (n) = טענה: 2).T (n) = Θ ( n (צריך למצוא קבועים כך ש.(a n 2 T (n) an 2 1. הוכחה איטרטיבית: T (n) T (n 1) + cn T (n 2) + c (n 1) + cn... T (1) + 2c + 3c +... nc = n [ ] n (n + 1) = d + c i = d + c 1 d n 2 2 i=2 כאשר d),d = max (c, ולכן 2).T (n) = O ( n באותו אופן נוכיח 2),T (n) = Ω ( n ובסה"כ 2) T (n) = Θ ( n מש"ל. 2. הוכחה באינדוקציה לטענה (ניסוח מדויק עם קבועים של הטענה): יהי d קבוע כך T (n) T (n 1) + d n אזי.T (n) d n 2 שמתקיים T (1) d (א) עבור = 1 :n.t (1) d = d 1 2 4
(ב) נניח שהטענה נכונה עבור n ונוכיח עבור + 1 n: T (n + 1) T (n) + d (n + 1) dn 2 + d (n + 1) = d ( n 2 + n + 1 ) d ( n 2 + 2n + 1 ) = = d (n + 1) 2 טענה לא נכונה: (n).t (n) = O הוכחה באינדוקציה:.1 עבור = 1,n.V,T (1) = O (1).2 (n).t (n) = T (n 1) + O (n) = O (n 1) + O (n) = O הרמאות במעבר האחרון, אנו משנים את הקבוע לכל n, ומגדילים אותו ז"א אין לנו קבוע יחיד. Merge Sort A [1,..., n]: 1. if n = 1 return A [1,..., n] 2. else (a) Merge Sort A [ ] 1,..., n 2 (b) Merge Sort A [ n ( 2 + 1,..., n] (c) Merge A [ ] [ 1,..., n 2, A n 2 + 1..., n]) אלגוריתם :Merge Sort (נניח (n = 2 k Merge (B [1,..., m], C [1,..., m]) A [1,..., 2m]: Θ (n) T (n) = 2T ( n. 2) + Θ (n) T (1) = Θ (1) משוואת הרקורסיה: טענה: n).t (n) = Θ (n log בס"ד, כ"ג אדר א' תשע"א: שעור 3 עץ הרקורסיה בכל רמה סכום הפעולות הוא n, כאשר הרמה של העץ הוא.log n את הטענה במדויק. יהי n. = 2 k נניח כי מתקיימת ( לצורך הוכחה באינדוקציה ננסח n ) T (n) 2T + d n, אזי,T (n) d n log n + d n משוואת רקורסיה 2 T (1) d בפרט n) T (n) = O (n log (הטענה n) T (n) = Ω (n log וההוכחה שלה דומות). הוכחה: צריך להוכיח עבור n = 2 k כי מתקיים.T ( 2 k) d 2 k k + d 2 k נראה זאת 5 באינדוקציה על k.
.1 עבור = 0 :k.t (1) d 0 + d 1 = d 2. נעבור מ k ל 1 + k: T ( 2 k+1) 2T ( 2 k) + d 2 k+1 2 ( d 2 k k + d 2 k) + d 2 k+1 = = d 2 k+1 k + d 2 k+1 + d 2 k+1 = d2 k+1 (k + 1) + d 2 k+1 הוכחנו כי n) T (n) = O (n log עבור n שהוא חזקה של.2 טענה: n) T (n) = O (n log לכל.n הוכחה: קיים k כך שמתקיים. n 2 2k n 2 k+1 2n אנו יודעים ש T (n) T ( 2 k+1) c 2 k+1 (k + 1) c (2n) log (2n) c n log n (המרצה ניסה להחליק את העובדה ש ( n ) T מונוטונית עולה ניתן לבצע זאת ע"י הגדלת המערך לחזקה של 2). שיטת "הפרד ומשול" Divide and Conquer לפתרון בעיות אלגוריתמיות זו שיטה לפתרון הבעיה המחלקת את הבעיה למספר בעיות יותר קטנות, ומגיעה לפתרון של הבעיה הגדולה ע"י פתרון כל הבעיות הקטנות ושילוב הפתרונות האלו לפתרון הבעיה הכללית (דוגמא: אלגוריתם מיון מיזוג). הערה: לא כל בעיה ניתן לפתור בצורה כזו. משפט האב לאלגוריתמים רקורסיביים: נתונה בעיה בגודל n. נניח כי אנו מצליחים לפתור אותה ע"י חלוקה ל a בעיות בגודל n כ"א. נניח כי עלות החיבור של הפתרונות לבעיות b החלקיות לפתרון הבעיה הכוללת היא (k Θ ( n אז אנו יודעים את הדבר הבא לגבי (n) T: נסמן.q = a b k יש שלושה מקרים:.T (n) = Θ ( n k) אזי,q < 1.1.T (n) = Θ ( n k log n ) אזי,q = 1.2.T (n) = Θ ( n ) log b a > 1.3,q אזי T (1) = Θ (1). אם נתבונן בעץ הרקורסיה: ( n ) משוואת הרקורסיה היא k) T (n) = at + Θ ( n b ברמה העליונה יש לי nk פעולות לחיבור. ברמה השניה יש לי a בעיות בגודל, n b ולכן השילוב 6
. n ( n השילוב ) k b בעיות, בגודל a 2 בשלב השלישי יש a2.a = שלהם הוא b b k nk = qn k ( n ) k יעלה.a 2 = q 2 n k גובה העץ הוא.r = log b n אם נחבר את כל הרמות נקבל b 2.q תלויה בפרמטר S = r i=0 qi ההתנהגות של הטור.T (n) = n k r i=0 qi.t (n) = Θ ( n k) ולכן נעריך,S i=0 qi = Θ (1) אזי,q < 1.1.T (n) = Θ ( n k log n ) לכן נעריך.S = r + 1 = Θ (log n) אזי,q = 1.2.n מכאן נעריך חזקה כלשהי של.S = qr+1 1 = Θ (q r ) אזי,q > 1.3 q 1 T (1) = Θ (1) ( n ) הוכחה של משפט האב באינדוקציה: בהינתן נוסחת רקורסיה מדוייקת (k T (n) = at + Θ ( n b O ( n k) q < 1 נוכיח כי = 1 q.t (n) = O ( n k log n ) O ( n ) log b a q > 1,n = b r q כלומר d T (n) עבור נוכיח את המקרה > 1.q נראה כי q 1 nlog b a :r באינדוקציה על T (b r q ) d q 1 ar.t (b r ) d q q 1 ar d בעצם נוכיח טענה חזקה יותר: q 1 brk.t (1) d = d q q 1.1 עבור = 0 :r d q 1 2. מעבר מ r ל 1 + r: T ( b r+1) at (b r ) + d b (r+1)k ad qar b rk + db (r+1)k = q 1 = dq ( ) ad q 1 ar+1 q 1 brk db (r+1)k = dq ( qb k ) d q 1 ar+1 q 1 brk db (r+1)k = = dq ( ) qd q 1 ar+1 q 1 b(r+1)k db (r+1)k = dq ( ) q q 1 ar+1 q 1 1 db (r+1)k = = dq q 1 ar+1 1 q 1 db(r+1)k 7 בס"ד, ר"ח אדר ב' תשע"א: שעור 4
מיון: בפעם הקודמת ניתחנו סיטואציה כללית של שיטת הפרד ומשול בקשר לבעיית המיון, Quick Sort(A [1..n]): 1. if n = 1 return A 2. else (a) m Partition (A [1..n]) (b) Quick Sort (A [1..m 1]) (c) Quick Sort (A [m + 1..n]) והוכחנו משפט כללי על הסיבוכיות. מיון מהיר :quick sort מחלק את המערך, לנקודת אמצע, כך שכל המקומות לפניה קטנים: ([n..1] Partition A) ממנה, וכל המקומות אחריה גדולים ממנה. T (n) = T (m 1) + T (n m) + Θ (n). זמן הריצה: T (1) = 1 ( n ).1 נניח ש n זוגי,,m = n נקבל (n) T (n) = 2T + Θ כמו,merge sort ולכן 2 2.T (n) = Θ (n log n).2 אם,m = n אז נקבל (n),t (n) = T (n 1) + Θ כמו מיון בועות, בו.T (n) = Θ ( n 2).3 נניח כי תמיד,cn m (1 c) n כאשר < 0.5 c <,0 כפי שראינו בתרגיל, יש לנו עץ לא מאוזן, עם d log n רמות (d קבוע שתלוי ב c ). למה להתעסק בזה, אין לנו ודאות מה יקרה? תשובה אפשרית: יש פתרון טוב יותר ממיון מיזוג. (המיזוג יותר יקר מהחלוקה עם הפיבוט). לא באמת נכון. נניח שאנו רוצים לחלק אנשים לתחרות בשיטת גביע הדרך להתגבר על חוסר איזון אפשרי היא בעזרת בחירה מקרית. טענה: בחירה מקרית של הציר בכל שלב באלגוריתם מיון מהיר מבטיחה n) T (n) = Θ (n log בסיכוי מאוד גבוה. 8
9 חסמים תחתונים על זמן ריצה של אלגוריתמי מיון. טענה: כל אלגוריתם למיון מקיים T, (n) n בתנאי שגישה לכל תא במערך עולה לפחות (1) Ω פעולות. הוכחה: התשובה או הפלט הניתן ע"י אלגוריתם מיון הוא סדור חדש של איברים במערך (במילים אחרות, תמורה של n},....({1, תמורה σ S n היא פונקציה n}, n} {1,...,... {1, חח"ע, ו! n. S n = נאמר כי האלגוריתם מחזיר תמורה σ S n אם אחרי המיון.A [σ (1)] < A [σ (2)] <... < A [σ (n)] נניח כי האלגוריתם עושה m < n פעולות, זאת אומרת, יש מקום אחד במערך שהאלגוריתם לא ניגש אליו. נסמן אותו ב n k 1. אז לא יתכן שקיבלנו תשובה נכונה כי המקום של [k] A אינו מוכרע. משפט: לכל אלגוריתם מיון המשתמש רק בהשוואות בין איברי המערך, זמן הריצה הוא.Ω (n log n) הוכחה:.1 האלגוריתם מחזיר תמורה.σ S n 2. נתאר את הריצה של האלגוריתם בעזרת עץ השוואות: נשווה a 1 מול 3 n a. מכאן יש לי התפצלות ל 2 מקרים. על סמך כל השוואה אנחנו מתפצלים לשתי אפשרויות, עד שנחליט שמספיק לנו: הגענו ל σ 1 S n יחידה המתאימה להשוואות. ייתכנו השוואות שיובילו למסלול עמוק, וכאלו שיובילו למסלול קצר יחסית. (א) בעלים של העץ נמצאות כל התמורות האפשריות סה"כ!n עלים. (ב) זמן הריצה הוא גובה העץ אורך המסלול הארוך ביותר מהשורש לעלה. 3. למה: לעץ בינארי בגובה h יש לכל היותר 2 h עלים. הוכחה: באינדוקציה על h: (א) עבור = 0 h, יש עלה בודד, כלומר 2 0 עלים. (ב) מעבר האינדוקציה: נניח כי הטענה נכונה לעצים בגובה לכל היותר h, עץ בגובה + 1 h מתפרק לשני עצים בגובה h. לפי הנחת האינדוקציה, ב T 1, T 2 יש לכל
היותר 2 h עלים. לכן העלים של T הם סכום העלים בשני העצים, והוא לכל היותר.2 2 h = 2 h+1 4. לפי שתי האבחנות והלמה מתקיים כי גובה h של ההשוואות של אלגוריתם המיון מקיים ( n ) 2 h n ( n )n n! h log n! = log i log i log 2 = n 2 2 log n = Ω (n log n) 2 i=1 i= n 2 בס"ד ז' אדר ב' תשע"א: שעור 5 מבני נתונים מופשטים :Abstract Data Types מבנה שמאפשר לשמור קבוצה דינמית של איברים. מאפשר להכניס איבר, להוציא איבר (לפי קריטריון מסויים), לעדכן איבר, ולבצע שאילתא על איבר (האם נמצא ומה ערכו). בד"כ נרצה גם אפשרות לקחת קבוצה בלי מבנה, ולבנות ממנה מבנה (מעבר מקבוצה ללא מבנה לקבוצה עם מבנה המאפשר פעולות יעילות). דוגמאות: מחסנית Stack מאפשרת הכנסת איבר,push והוצאת איבר pop בשיטת.LIFO צריך להבדיל בין ADT לבין מימוש שיכול להינתן ע"י מערך או רשימה. תור מאפשר הכנסת איבר (1) Θ, והוצאת איבר (1) Θ בשיטת.FIFO המימוש יכול להינתן ע"י מערך לדוגמא. עץ קדימויות :Priority Queue (ערימה זו דרך לממש עץ קדימויות): נתון אוסף של תהליכים במחשב עם קדימויות שונות. אנו מעוניינים: א. לתחזק את התור. ב. בכל שלב לדעת להחליט איזה תהליך לבצע. בעץ קדימויות נרצה לבצע את הפעולות הבאות בצורה יעילה: 1. ערך של האיבר המקסימלי (ז"א הקדימות המקסימלית). 2. הוצאת האיבר המקסימלי. 3. עדכון ערך (הגדלת ערך). 4. הכנסת איבר חדש. 5. בניית המבנה. ניתן לממש תור קדימויות ע"י מערך ממויין לפי הקדימויות. מחיר הפעולות הנדרשות: 10
11 1. ערך האיבר המקסימלי (1) Θ: מחזירים את האיבר במקום n. 2. הוצאת האיבר המקסימלי (1) Θ: נוציא את האיבר האחרון במערך, ונוריד את המצביע לסוף המערך. 3. עדכון ערך: אנחנו צריכים להזיז את איברי המערך כדי למיין אותו. זה דורש (n) Θ. זה לא טוב, נחפש מימון טוב יותר. ניתן מימוש של תור קדימויות ע"י מבנה אחר (הערמה) שיאפשר את ביצוע הפעולות 4 1 בזמן.O (n) ובניית הערמה בזמן,O (log n) הגדרות בתורת הגרפים:.1 גרף E),G = (V, כאשר V קבוצת הקודקודים, E V V אוסף זוגות של קודקודים שהן הצלעות של G. מסלול בגרף רשימת קודקודים v 1,..., v k כך שלכל 1 k i,1.(v i, v i+1 ) E גרף G הוא קשיר אם קיים מסלול בין כל שני קודקודים. מסלול בגרף נקרא מסלול פשוט אם אינו חוזר על קודקודים. מעגל בגרף זה אוסף קודקודים v 1,..., v k כך שלכל 1 k,(v i, v i+1 ) E 1 i וגם.(v 1, v k ) E 2. עץ (E T,V) הוא גרף קשיר ללא מעגלים פשוטים באורך 3 (מעגל פשוט לא חוזר על קודקודים). עץ עם שורש זה עץ עם קודקוד מיוחד (שורש). (נתייחס מעכשיו רק לעצים עם שורש) בעל התכונות הבאות: יש מסלול פשוט יחיד בין כל שני קודקודים בעץ. עומק של קודקוד בעץ הוא אורך המסלול מהשורש של הקודקוד הזה. רמה k של עץ כל הקודקודים בעומק k. קודקוד w הוא ההורה parent של קודקוד u, אם במסלול (היחיד) מהשורש ל u, w הוא הקודם המיידי ל u. u ייקרא בן של w. 3. עץ בינארי הוא עץ שלכל קודקוד שלו יש לכל היותר 2 בנים. עלה בעץ זה קודקוד ללא ילדים.
4. עץ בינארי שלם זה עץ בינארי שלכל קודקוד שאינו עלה יש 2 בנים, וגם כל העלים נמצאים באותו עומק. 5. עץ בינארי כמעט שלם זה עץ בינארי שכל הרמות שלו פרט לרמה האחרונה מלאות וברמה האחרונה יכולים להיות חסרים מספר עלים מימין. הגדרה: ערמה זה עץ בינארי כמעט שלם עם ערכים בקודקודים, בעל תכונות הערימה: אם u. גדול מהערך של w אז הערך של u הוא הורה של w מימוש של ערמה ע"י במערך באופן הבא: הבנים של תא i הם תאים + 1 2i,2i, באופן i שקול ההורה של i הוא התא. 2 תכונות הערמה: לכל A [i] A [2i],i וגם 1] + [2i.A [i] A הפעולות בתור קדימויות הממומש ע"י ערמה במערך: Heap-Max(A) (a) return A [1] Extract-Max 1. ערך האיבר המקסימלי: (1) Θ: 2. הוצאת הערך המקסימלי מהמערך: בס"ד כ"א אדר ב' תשע"א: שעור 6 (a) return A [1] (in the end) (b) A [1] A [HeapSize (A)] (c) HeapSize (d) Max-Heapify(A, 1) כל הפעולות קבועות חוץ מהאחרונה שתתבצע בסדר גודל של (n Θ, (log באופן הבא: נתחיל מהשורש, ואם הוא גדול מאחד הבנים שלו, נחליף אותו עם הבן הגדול יותר, וברקורסיה נחלחל כלפי מטה עד שנקבל שוב ערמה. תור קדימויות: מבנה נתונים מופשט ) (ADT שמאפשר בצורה יעילה את הפעולות.max (A).1.Extract max (A).2 12.increase_key(A, x).3
.insert(a, x)..4 המימוש של תור קדימויות מתבצע ע"י ערמה :(Heap) עץ בינארי כמעט שלם. עם ערכים בקודקודים ועם תכונת ערימה: לכל קודקוד x, הערך של x גדול מערכי בניו. ערמה ממומשת ע"י מערך [n A,,1]..., כאשר הערך של השורש מוכנס ל [ 1 ] A, וממשיכים ברקורסיה לפי הכלל הבא: בניו של הקודקוד שנמצא ב [ i ] A מוכנסים ל [ 1 + 2i] A. [2i], A תכונת הערמה מתורגמת לתכונה של המערך עם המימוש 1] + [2i.A [i] A [2i], A בעצם אנחנו משתמשים במערך ממויין חלקית, אבל חושבים עליו בתור עץ. בהינתן עץ בינארי ניתן קידוד לקודקודים של העץ בצורה הבאה: 1 (root) B, (x) 0.B (r son of x) B (x) 1,B (l son of x) B כעת נחשב את הקידוד לפי בסיס בינארי, ונכניס כל צומת לתא המתאים במערך. באופן דומה, בהינתן מערך נרשום כל אינדקס בבסיס בינארי, והוא יאמר לנו לאן אנחנו הולכים בעץ. תכונות של המספור הבינארי (x) :B : x B.1 אורך הקידוד (x) B שווה ל + 1 (x).depth 2. בכל רמה של העץ, המספרים (x) B עולים משמאל לימין. 3. עבור עץ בינארי כמעט שלם, המספרים (x) B עוברים על הערכים, n...,2,1 (הגדרה שקולה של עץ בינארי כמעט שלם). 4. (x) B הכתובת של המקודם של x במערך המממש את הערימה. מסקנה: הגובה ) T) h של עץ בינארי כמעט שלם עם n איברים מקיים.log 2 n h (T ) log 2 n + 3 הוכחה: נשתמש בתכונות של המספור הבינארי. העומק (n) h (t) = depth ששווה לפי תכונה 1 לאורך הייצוג הבינארי של n ועוד 1. וזה נמצא בין log n לבין 1+n log לפי הטענה הבאה: טענת עזר: בינאריות. כדי להציג מספר n בצורה בינארית נצטרך בין log n ל 1 + n log ספרות הוכחה: נרשום k+1,2 k n < 2 אזי אורך הייצוג של 2 k הוא + 1,k ושל k+1 2 הוא + 2,k לכן אורך הייצוג s הוא + 2 n log n 1 < k s k + 1 < log (התבלבלתי כאן קצת עם התוספת של קבועים המרצה אמר שזה לא משנה). בעיה: נתון מערך [n A 1]... בלי שום תכונות. נרצה לייצר ממנו מערך. 13
.1 נמיין את.A עלות n).ω (n log 2. נגדיר B בתוך הערמה לעתיד, ונעשה ([i] insert(b, A לכל האיברים: ככל הידוע לנו, המחיר של זה הוא (n Ω. n) log Build_max_heap(A) 3. אלגוריתם יעיל יותר: n =length(a) for i = n to 1 max_heapify(a [i,..., n], A [i]) טענה: האלגוריתם מייצר ערימה חוקית בזמן (n) Θ. הוכחה: 1. נכונות: (k max_heapify(x, מקבל x שורש של עץ בינארי כמעט שלם שמקיים את תכונות הערמה מלבד השורש, ומייצר ערימה חוקית. נראה באינדוקציה יורדץ על i כי אחרי האיטרציה עם + 1 i,n המערך n] A [i,..., מקיים את תכונת הערימה (לכל תת ערימה המשוכנת בו). בסופו של דבר עבור = 1 i נקבל שאחרי האיטרציה מספר n המערך n] A [1,..., מקיים את תכונת הערימה. (א) עבור i: = n המערך [n] A הוא ערימה באופן ריק. (ב) נניח נכונות ל i+1, ונוכיח נכונות ל i : כל תת ערימה המשוכנת במערך [n A i] +,1..., היא ערימה חוקית, ולכן גם הערימה שקודקודה i מקיימת את התכונה, למעט הקודקוד (כי,2i). 2i + 1 > i אם נבצע max_heapify על הקודקוד, נקבל שגם הוא יקיים את תכונת הערימה, וכעת כל תת ערימה במערך [n A,i]..., מקיימת את תכונת הערימה. 2. נראה כי זמן הריצה של האלגוריתם הוא (n) Ω ((n) O. ברור): נשים לב כי זמן ריצה של ביצוע אחד של max_heapify הוא #swaps 3 2. + לכן זמן הריצה הכולל.T (n) n נשים לב כי מספר i=1 (3 #swaps (i) + 2) = 2n + 3 n i=1 #swaps (i) ההחלפות זהה למספר הפעמים שקודקודים יכולים "לעלות". לכן.T (n) 2n + 3 n מס' הפעמים שקודקוד j עולה הוא לכל j=1 # {j moves up} היותר (j) D depth כאשר D עומק העץ כולו, ו ( j ) d הוא עומק j בסיום האלגוריתם. 14
לכן צריך להעריך את n (D d (j)) j=1 D d=0 2 d (D d) = k=d d = cn + 2 = O (n) D D 2 D k k = 2 D k2 k cn + k=0 k=0 k2 k = k=0 (למה k2 k מתכנס ל 2? ההסבר מהשיעור מסובך לרישום, אבל מספיק שנדע שהוא מתכנס (מאינפי) כדי לדעת שהוא קבוע). בס"ד כ"ח אדר ב' תשע"א: שעור 7 עצי חיפוש בינאריים :BST ראינו בתרגיל עץ בינארי עם ערכים בקודקודים המקיים שכל ערך ב (( x ) T (right גדול מהערך ב x, וכל ערך ב (( x ) T (left קטן מהערך של x. ניתן לבצע פעולות רבות על,BST בזמן שהוא קבוע כפול גובה העץ. בשיעור הזה נדגים עצי חיפוש בינאריים מאוזנים בעלי גובה לוגריתמי. לכן כל הפעולות שלמדנו ייקחו זמן לוגריתמי. עצי :(Adelson-Velskii-Lardis 1962) AVL הגדרה: עץ בינארי ייקרא עץ AVL אם לכל קודקוד x בעץ, מתקיים. h (T (right (x))) h (T (left (x))) 1 דוגמאות: 1. עץ בינארי שלם הוא עץ.AVL 2. שרשרת בגובה 2 היא לא,AVL נגדיר גובה של עץ ריק = 1. אזי תת העץ השמאלי של השורש הוא בגובה 1, ותת העץ הימני הוא בגובה 1. נוכיח כי הגובה של עץ AVL לוגריתמי במספר הקודקודים. נסמן ב n את מספר הקודקודים. ב k את הגובה. נרצה להוכיח כי (n k. = O (log במקום זה נראה כי k),n = Ω ( a כאשר > 1 a (נוכל לבחור 1.61.(a נזכור כי בעץ בינארי שלם.n = Ω ( 2 k) נסמן n k מספר הקודקודים המינימלי של עץ AVL בגובה k. נגדיר רקורסיה על הסדרה.n 2 = 4,n 0 = 1, n 1 = 2 אזי: ונראה כי היא עולה אקספוננציאלית ב k. {n k } 15
למה: לכל k מתקיים.n k+1 > n k הוכחה: נתבונן בעץ T בגובה + 1 k עם 1+k n. יש לו לפחות בן אחד בגובה k, גם הוא תת עץ,AVL ולכן בעל n k קודקודים לפחות (זה בעצם בדיוק, כי אחרת ניתן להחליף אותו בעץ AVL מינימלי בגובה k, ולקבל עץ קטן יותר). אם נוסיף את השורש של T, יש לנו לפחות + 1 k n קודקודים. מסקנה: מבנה של עץ AVL מינימלי בגובה + 1 k: יש לנו שורש, עם בן אחד שהוא עץ AVL מינימלי בגובה k, ובן נוסף שהוא עץ AVL מינימלי בגובה 1 k. לכן יש לנו נוסחת נסיגה:.n k+1 = n k + n k 1 + 1 נעשה חילוף משתנה, ונגדיר סדרה חדשה: 1+ k G. k = n נקבל רקורסיה יותר מוכרת לסדרה 1 5. 1 ולכן < 1 2 5 2.G k+1 = G k + G k 1 :G k סדרת פיבונצ'י המקורית:... 5, = 0, 1, 1, 2, 3,,F ולכן k+3.g k = F (.F k = 1 1 + ) k ( 5 1 ) k 5 טענת עזר: 5 2 2 5 + 1 <,1 ואלו 1 ϕ = 2 מסקנה: נשים לב כי 1.61 ϕ =.G k, n k = Ω ( ϕ k) לכן גם,F k > 1 5 ( לכן k) ϕ k 1 ) = Ω ( ϕ הוכחת הטענה: נתבונן באוסף כל הסדרות..., 1 a 0, a המקיימות k 1 : a k+1 = a k + a.( ) נגדיר הפעולות חיבור וכפל בקבוע.).., 1.c (a 0, a 1,...) = (ca 0, ca גם הסדרה החדשה מקיימת את הרקורסיה.( ) נגדיר.).., 1 (a 0, a 1,...) + (b 0, b 1,...) = (a 0 + b 0, a 1 + b שגם היא מקיימת את ( ). הרעיון העיקרי: נמצא שתי סדרות כנ"ל,α β המקיימות את ( ) שקל להבין את המבנה שלהם. נמצא שני קבועים c 1, c 2 כך ש,c 1 α + c 2 β = F כלומר מספיק לבדוק כי c 1 α 0 + c 2 β 0 = 0 : ( ) (סדרה המקיימת את ( ) מוגדרת ע"י שני האיברים הראשונים). c 1 α 1 + c 2 β 1 = 1 את הסדרות,α β נחפש בין סדרות הנדסיות, כלומר נבדוק מתי סדרה (k ( x מקיימת את x k+1 = x k + x k 1 x 2 = x + 1 x = 1 ± 5 162 ( ), כלומר
1 + ) k 5 זה נותן לנו שתי סדרות הנדסיות המקיימות את הרקורסיה ( ): 2 (,α k = ( 1 ) 5 2 = k β. נותר לנו למצוא את הקבועים c 1, c 2 שיקיימו את מערכת המשוואות.c 1 = 1 5, c 2 = 1 5 ( ). פותרים את המערכת ומוכיחים את הטענה ע"י אלגוריתמית נראה איך לבצע פעולות insert, delete על עץ חיפוש בינארי בעל תכונת AVL ולשמור על תכונה זו. פעולת :insert פעולת הכנסה שמפירה את תנאי האיזון יכולה להשפיע על הקודקודים שהם אבות קדמונים של הקודקוד החדש. האלגוריתם מכניס קודקוד חדש בצורה הרגילה של,BST ואח"כ יעבור על המסלול מהקודקוד החדש לשורש, ויתקן במידה ונמצאה הפרה של תנאי.AVL נשים לב כי ניתן לראות הפרה רק אחרי שעולים לפחות פעמיים. נראה כי כשאנחנו מתקנים את ההפרה הראשונה, אנו שומרים על הגובה המקורי של העץ ששורשו בקודקוד המופר, ולכן אין צורך להמשיך לטפס הלאה. התיקון מתחלק ל 4 מקרים, לפי המיקום של הקודקוד המוכנס יחסית לקודקוד בו נזהה את ההפרה הראשונה. 1. :LL אם נרד מהשורש המופר לקודקוד החדש, בתחילת המסלול נרד פעמיים שמאלה. נסמן: B הקודקוד המופר. (B).Br = right (B).A = left באופן דומה נסמן h עבר מגובה T (Al) וכי T. אנו יודעים כי הקודקוד החדש נמצא ב ( Al ).Al, Ar לגובה + 1 h. לכן בהכרח הגובה של (Ar) T הוא h (אם הוא היה + 1 h, B לא מופר, ואם בגובה 1 h, היתה הפרה כבר ב A ). באופן דומה הגובה של Br הוא h בדיוק, כדי לקבל הפרה ב B. נסובב את העץ כך ש A הוא השורש, בניו הם,Al, B והבנים של B הם.Ar, Br צריך לראות כי זהו עץ AVL תקין בגובה + 2 h (הגובה המקורי). באופן דומה ניתן לטפל בשאר המקרים (תרגיל). בס"ד כ"ז ניסן תשע"א, י"ב בעומר: שעור 9 בשיעור 8 על הסתברות לא הייתי. 17 אלגוריתם לדחיסת מידע
בעיה: נתון קובץ כתוב אנגלית. רוצים לשמור אותו בצורה בינארית (לצורך שמירה במחשב \ שליחה בערוץ תקשורת). מה הצורה הטובה ביותר לעשות זאת. אנחנו מחפשים: 1. קידוד הניתן לפיענוח (הטקסט ניתן לשחזור). 2. קידוד הקצר ביותר. דוגמא: נתון טקסט הכתוב בעזרת 6 אותיות (f a) עם הצפיפות הבאה: a b c d e f קובץ באורך 100,000 אותיות תדירות ב % 45 13 12 16 9 5 קידוד אחיד 000 001 010 011 100 101 300, 000bits אורך משתנה 0 101 100 111 1101 1100 224, 000bits בעיה אפשרית: יש מצבים בלי פענוח יחיד. למשל עבור 1101 c a,,1 b,101 לא נוכל לדעת האם 1101 הוא קידוד של ab או של c. הגדרה: צופן חסר רישא (חסר תחילית) הוא צופן שבו קידוד של אף אות אינו התחלה של קידוד של אות אחרת. דוגמא הצופן באורך משתנה שראינו חסר רישא ומאפשר פענוח בצורה מאוד פשוטה. למשל 0 0 101 1101 עבור, נראה ש a = 0, ברגע שהגענו לרצף מוכר, אנו שמים את האות, a a b e ומתחילים מחדש. בסה"כ מקודד לנו.aabe נתאר קידוד באופן הבא: אנחנו מתחילים משורש של העץ. פנייה שמאלה משמעותה 0, פנייה ימינה משמעותה 1. בעזרת עץ בינארי נתאר גם את הקידוד: הקידוד של כל אות ניתן ע"י המסלול מהשורש אל האות, וגם את הפענוח: בהינתן רצף ביטים נלך על העץ לפי ההוראות של הרצף עד שנגיע לאות. תמיד נדבר על עצים בינאריים המתאימים לצפנים שבהם האותיות נמצאות בעלים של העץ. זה מבטיח: 1. תכונת צופן חסר תחילית. 2. כל צופן חסר רישא ניתן לתאר ע"י עץ כזה. סימונים והגדרות: נתונה קבוצת אותיות A. = n A, נתון קובץ F הכתוב באותיות מ A. נסמן ב ( c ) f את הצפיפות באחוזים של האות c ב F. בהינתן צופן T, נגדיר (c) l את אורך הקידוד של c המוגדר ע"י T, ששוה לאורך המסלול ב T מהשורש לעלה המכיל את c. נשים.L (T ) = F c A לב כי אורך הקידוד של F שווה ל ( c ) f (c) l 100 הבעיה היא למצוא T הממזער את ) T) L. הבחנות: 18
.1 אם (y) f (x) < f אז (y) l (x) l עבור T אופטימלי. 2. לשתי אותיות עם הצפיפות הנמוכה ביותר קיים עץ אופטימלי שיש בו לשתי אותיות אלה אותו אורך קידוד. הרעיון של הופמן: בכל שלב נאחד את שתי האותיות הכי נדירות לאות חדשה שצפיפותה היא סכום הצפיפויות של שתי האותיות הללו. בדוגמא שלנו: נחבר את,e f לקודקוד חדש בעל צפיפות 14, שבניו הם,e. f באופן דומה נחבר את,b c לאות חדשה עם צפיפות 25. עכשיו נאחד את d עם,e, f ובשלב הבא נאחד את b, c עם.d, e, f בס"ד י"ח אייר תשע"א, ל"ג בעומר: שעור 11 lookup (k).o (1) insert (k) delete (k) חסר שעור 10 מיום י"א אייר. פונקציות גיבוב.(hash) נדרש מילון,ADT המספק לנו דוגמא: ציוני בוחן של סטודנטים: מפתחות מספרי ת.ז., ולכל מפתח צמוד ערך הציון. 1. פתרון ראשון: קובץ excel בסדר עולה וליד כל ת.ז. הציון. נקבל (n Ω (log עבור הפעולות (חיפוש בינארי)..2 פתרון "טוב יותר": למספר את ת.ז. במספרים, m...,1, כאשר,m N אבל (N),m = O ולהכניס את הציונים למערך באורך m. ואז כל הפעולות מתבצעות באופן הבא: כדי להכניס ציון של מפתח k ניגש ישירות לתא [k] A. הבעיה: איך נזכור את ההתאמה בין הת"ז למספרים, m...?1,.3 פתרון טוב ראשון: נגדיר פונקציה 1} m h : {i.d.} {0,..., באופן הבא: h.h (k) = k mod m תיקרא פונקצית גיבוב. יש לנו יעילות במקום (N),m = O וכל הפעולות הן (1) O. מה קורה עם התנגשויות? אם כמה מפתחות k 1,..., k t נופלים לאותו תא במערך, נוציא מתא זה רשימה מקושרת המכילה את כל המפתחות k. 1,..., k t מחיר הפעולות יהיה (t) O לפי אורך הרשימה הספציפית אליה הגיבוב הפנה. המטרה היא למצוא פונקצית גיבוב שתיצור רשימות קצרות. 19
מה קורה אם להרבה מפתחות k יש אותו ערך מודולו m? לא ניתן לפסול זאת, ובמקרה זה נגיע למצב שאחרי גיבוב כל הפעולות עולות (N) Ω. 4. נבנה פונקציה "מכוערת" יותר, שבה הסיכוי להתנגשויות קטן יותר. למשל הפונקציה 5 + 1 ). זו פונקציה טובה, אך גם m,h (k) = (γk γk ) כאשר γ אי רציונלי (בד"כ 2 לה כפי שנראה, ניתן לבנות קלט S רע, שיביא לרשימות מקושרות ארוכות. 5. ננסה פונקצית גיבוב מקרית: נניח כי יש לנו S, = N ומערך [m..1] A. אנו לוקחים כל פעם מפתח, ושולחים אותו לתא בצורה אקראית. היתרון: הרשימות המקושרות יהיו קצרות באופן טיפוסי (נוכיח), החסרון: פונקציה מטופשת, כי לא נדע לאן שלחנו כל מפתח. נגדיר Z i להיות אורך הרשימה המקושרת היוצאת מהתא i של המערך. זה משתנה מקרי התלוי בבחירות של פונקצית הגיבוב. בסה"כ יש לנו Z 1,..., Z m מ"מ.,Z i,k = 1 h (k) = i 0 o.w..e [Z i ] = N m למה: לכל i m,1 הוכחה: נגדיר מ"מ עבור m},i {1,..., ועבור,k S נגדיר,E [Z i,k ] = 1 m מתקיים.Z i = k S Z i,k ברור כי.Z i,k Ber.E [Z i ] = k S E [Z i,k] = k S ( ) 1 m 1 לכן m = N m ראינו עד כה שני סוגים של פתרונות עבור פונקציות גיבוב: 1. פתרונות דטרמיניסטיים (מודולו, הפונקציה המכוערת). 2. פתרון מקרי פנוקציית גיבוב מקרית. רע לא נוכל לזכור את ערכי הפונקציה. נראה כי לכל פונקציית גיבוב דטרמיניסטית ישנם קלטים היוצרים תחת הפונקציה הזו רשימות מקושרות ארוכות: למה: יהי U עולם המפתחות, ו { m.h : U {1,..., נניח כי. U Nm אז קיימת תת קבוצה של מפתחות S, U כך ש N S = שכולם נשלחים לאותו תא ע"י h (שובך היונים). הוכחה: נחלק את U למחלקות שקילות לפי התוצאה של h. יש לנו m מחלקות שקילות, ולא ייתכן שכולן בגודל קטן מ N. 20
פתרון לכל הבעיות: משפחה אוניברסלית של פונקציות גיבוב. הגדרה: m}} H = {h : U {1,..., היא משפחה אוניברסלית של פונקציות גיבוב אם לכל שני מפתחות שונים,x y U מתקיים = 1 (y)}.p h H {h (x) = h כעת לא משנה m מה הקלט, התוחלת של אורך הרשימות היא קטנה. הערה: זו משפחה קטנה ופשוטה של פונקציות גיבוב שהתנהגותן מבחינת התנגשויות דומה לזו של פונקצית גיבוב מקרית. 1. העובדה שהמשפחה הזו קטנה, תאפשר חישוב פשוט (שאין לפונקציות מקריות). 2. "מקריות" תוביל לרשימות מקושרות קצרות ללא תלות בקלט. למה: תהי H משפחה אוניברסלית של פונקציות גיבוב. תהי S. = N S, U אזי לכל x S מתקיים בממוצע על פונקציות h, H אורך הרשימה המקושרת אליה ישתייך x הוא לכל היותר + N.1 m הוכחה: נגדיר מ"מ (h) L x אורך הרשימה המקושרת של x תחת פונקצית הגיבוב h. צריכים להוכיח כי.E [L x ] 1 + N לכל,y S נגדיר משתנה עזר (h) C x,y האם m ) 1 ( = (h),l x לכן y S C x,y, (h) וכן,C x,y (h) Ber מתקיים.h (x) = h (y) m E [L x ] = y S E [C x,y] = 1 x y S m + 1 = N 1 m + 1.m = 2 r נמספר כל k U וכל } r,m {1,..., 2 נתאים קידוד בניה של משפחה אוניברסלית של פונקציות גיבוב: בה"כ נניח כי. U = 2 l ב 1} l, {0, 1} r.{0, פונקציות גיבוב יהיו פונקציות.h : F l 2 F r 2 נבנה פונקציות כאלו ע"י מטריצות מסדר.(h M r,l (F 2 )).r l כאשר.h : v hv נגדיר ) 2 H. = M r,l F) טענה: H זו משפחה אוניברסלית של פונקציות גיבוב. בהינתן הטענה בהינתן קלט S U באורך N, נבחר מטריצה מקרית h H (נגריל כל קואורדינטה), ואז נבצע גיבוב על S בעזרת הפונקציה h. בס"ד כ"ה אייר תשע"א, מ' בעומר פונקציות גיבוב: נניח כי מרחב המפתחות U, = 2 l וכי m. = 2 r הגדרנו משפחה של פונקציות F l 2 F r 2 ע"י מטריצות ) 2,M M r l (F ופונקציה.h M : x Mx עבור.(Mx) i = l j=1 a ijx j מתקיים M = (a ij ) 21
הגדרה: H היא משפחה אוניברסלית של פונקציות גיבוב אם לכל x y מתקיים.P h H {h (x) = h (y)} 1 m טענה: המשפחה )} 2 H = {h M : M M r l (F היא משפחה אוניברסלית. הוכחה: נראה כי לכל :P {h (x) = h (y)} = P {Mx = My} = 1 2 r,x y F l 2.P M Mr l {Mx = My} = P M {M (x y) = 0} = P M,z 0 {Mz = 0} למה: לכל 0 z Fl 2 מתקיים.P M {Mz} = 1 2 r אם נוכיח את הלמה, זה יסיים את ההוכחה..(Mz) ז"א המאורע { 1 =... = (Mz) r הוכחת הלמה: נשים לב ש 0 = Mz אם"ם = 0 l }.{(Mz) i = 0} = j=1 a ijz j נתבונן במאורע = 0.{Mz = 0} = r i=1 {(Mz) i ( ) = 0} 1 נזכור כי בחירה מקרית של M היא בחירה של כל אחת מהקואורדינטות a ij Ber { 2 l } { } { }.P j=1 a ijz j = 0 = P באופן בלתי תלוי. לכן = 0 ij j:z j =1 a ijz j = 0 = P M j:z j =1 a נראה כי הביטוי j:z j 1= a ij הוא 0 בסיכוי. 1 2 אם יש רק מחובר אחד, אז הוא מקיים זאת, כי כל בית a ij נבחר להיות 0 בסיכוי אחד. עבור > 1 k מחוברים, נחלק את הסכום לסכום של 1 k מחוברים, שהסכום שלו הוא b, והמחובר האחרון ששוה ל b בסיכוי חצי, ו b 1.P M {(Mz) i.1 2 בסה"כ הוכחנו כי = 1 2 0} = בסיכוי חצי. לכן הסכום כולו הוא 0 בסיכוי P {Mz = 0} = P ( r ) {(Mz) i = 0} = i=1 מאחר ושורות M נבחרות באופן ב"ת, לכן r P {(Mz) i = 0} = i=1 r i=1 1 2 = 1 2 r = m אלגוריתמים על גרפים בעיה: נתונה רשת (אוסף של קודקודים עם צלעות לדוגמא רשת כבישים המחברים ערים בישראל). המטרה למצוא תת רשת המאפשרת להגיע מכל מקום, בעלת מחיר מינימלי. במונחים של גרפים: נתון גרף קשיר (E G =,V) על הקודקודים, ופונקצית מחיר e E W קשיר, וכך ש ( e ) T = (V, E כך ש ( E E המטרה למצוא.W : E R + מינימלי בתנאי זה (נקרא למחיר ) T) W). בניסוח נוסף: המטרה למצוא תת גרף קשיר.W (T ) = e E W (e) מינימלי, כאשר W (T ) בעל,G של T = (V, E ) אינטואיטיבית, בפתרון האופטימלי T אין מעגלים. וזה מוביל אותנו להגדרה: 22
23 הגדרה: עץ פורש של גרף G הוא תת גרף T קשיר וחסר מעגלים. טענה: 1. בכל גרף קשיר יש עץ פורש. 2. לכל עץ פורש יש 1 n צלעות. 3. כל גרף קשיר על n קודקודים עם 1 n צלעות הוא עץ פורש. הוכחה: נשתמש בהגדרה של רכיב קשירות בגרף: C V הוא רכיב קשירות אם v 1, v 2 C יש מסילה מ v 1 ל,v 2 ולכל v C, w V \C אין מסילה מ v ל w. למה: H גרף עם חלוקה לרכיבי קשירות H, = C i ומוסיפים ל H צלע (y e, =,x) אזי: 1. אם,x y שייכים לאותו רכיב קשירות אזי בגרף החדש יש מעגל. 2. אם,x y אינם שייכים לאותו רכיב קשירות, לא הוספנו מעגל בגרף. הוכחת הלמה: 1. נניח כי,x y שייכים לאותו רכיב קשירות, והוספנו צלע חדשה {y e, =,x} מכיוון ש C קשיר, יש ב C כבר יש מסלול בין x ל y. קיבלנו שני מסלולים שונים בין x ל y ולכן קיבלנו מעגל..2 נניח,x C 1, y C 2 וב H אין מעגלים. נראה כי הצלע y} {x, לא מוסיפה מעגל. נניח בשלילה כי קיים מעגל בגרף החדש, המעגל הזה חייב להכיל את הצלע {y,x}, ולכן חייב לתת שני מסלולים זרים בצלעות בין x ל y. אבל,x y נמצאים בשני רכיבי קשירות שונים של H ולכן כל מסלול ביניהם, חייב לעבור דרך הצלע {y,x}, בסתירה. הוכחת הטענה: 1. בכל גרף קשיר G יש עץ פורש T: נבנה את T בצורה איטרטיבית: נאתחל E. = φ בכל שלב נתבונן ברכיבי הקשירות של T, ונוסיף צלע המחברת בין שני רכיבי קשירות שונים בגרף ) E T. =,V) עד שנקבל רכיב קשירות יחיד. לאחר האיטרציה ה k מתקיים: (א). E = k (ב) בגרף ) E (V, יש n k רכיבי קשירות. (ג) אם > 1 k n, קיימת צלע E\E e המחברת שני רכיבי קשירות שונים.
לפי החלק השלישי, נוכל להוסיף צלעות כל עוד > 1 k n, ולפי הלמה הקודמת מכיוון שכל צלע מחברת שני רכיבי קשירות, היא לא מוסיפה מעגל, ולכן הגרף ) E T =,V) הינו חסר מעגלים. עבור 1 n k = נקבל גרף עם רכיב קשירות אחד חסר מעגלים. בס"ד ג' סיון תשע"א, מ"ז בעומר: שיעור 13 בעיה: נתון גרף קשיר לא מכוון E), V = n,g = (V, עם פונקצית מחיר + R.W : E המטרה למצוא עץ ) T T =,V) E כך ש E E T בעל מחיר מינימלי. כאשר.W (T ) = e E T W (e) טענה: קיים עץ פורש ) T.E T E,T = (V, E הגדרה: קבוצת קודקודים C V היא רכיב קשירות בגרף ) H H = (V, E אם: 1. לכל,x y C ניתן להגיע מ x ל y על צלעות ב E. H.2 לכל,x C,z C לא ניתן להגיע מ x ל z. הוכחנו למה :1 יהי ) H H = (V, E עם m רכיבי קשירות..V = C i תהי.e = (x, y) V V \E H אזי יש שתי אפשרויות: 1. y,x שייכים לאותו רכיב קשירות C, אזי הוספת הצלע e ל H סוגרת מעגל. 2. אם,x y שייכים לרכיבי קשירות שונים הוספת הצלע e אינה סוגרת מעגל, ואף מקטינה את מספר רכיבי הקשירות ב 1. הוכחת הטענה: נגדיר את E T בצורה איטרטיבית: נגדיר.T 0 = (V, E 0 ), E 0 = φ בשלב ה i i < n) (1 נתבונן ברכיבי הקשירות של הגרף i 1.T תהי i 1 e E\E שמחברת בין 2 רכיבי קשירות שונים של 1 i T (צריך להוכיח כי קיימת כזו). נגדיר {e} E, i = E 1 i ונגדיר ) i.t i = (V, E נחזיר את n 1,T נראה כי n 1 T הוא עץ פורש. נראה באינדוקציה על i, כי מתקיימים 3 דברים:.1 אם מספר רכיבי הקשירות בגרף ) i 1 T i=1 = (V, E גדול מ 1, קיימת צלע e E המחברת שני רכיבי קשירות שונים.. E i = i.2.3 מספר רכיבי הקשירות ב T i הוא.n i 24
נשים לב כי אם (3), (2), (1) מתקיימים, נוכל להריץ את האלגוריתם 1 n שלבים, ואז לגרף 1 n T יש רכיב קשירות בודד ולכן הוא קשיר. כמו כן מכיוון שבכל שלב הוספנו צלע המחברת רכיבי קשירות שונים, לא ייצרנו מעגלים לפי למה 1, ולכן 1 n T = T הוא עץ פורש. הוכחת (3), (2), :(1) 1. נניח בשלילה כי בשלב מסויים עבור i < n 1 אין צלע המחברת 2 רכיבי קשירות שונים, ומספר רכיבי הקשירות >1. יהיה C 1, C 2 שני רכיבי קשירות שונים, ויהי x. C 1, y C 2 ז"א מעכשיו כל צלע תעבור בתוך רכיב הקשירות שלה, ולעולם לא נוכל להגיע מ x ל y, וזה בסתירה לקשירות של G. = 0.2 φ, E 0 = וכי + 1 i 1 E i = E i 1 {e} = E (נשים לב כי תמיד בוחרים.(e E\E i 1 3. יהי C i מספר רכיבי הקשירות ב C. 0 = n T. i לפי למה 1, מכיוון שכל פעם מוסיפים צלע המחברת שני רכיבי קשירות שונים, i 1 + 1.C i = C טענה 2: לכל עץ פורש בגרף עם n קודקודים יש 1 n צלעות. טענה :3 יהי ) H H = (V, E גרף קשיר עם 1 V צלעות אזי H הוא עץ. האלגוריתם של קרוסקל Kruscal למציאת עץ פורש מינימלי: נאתחל.T 0 = (V, E 0 ),E 0 = φ בכל שלב i נבחר i 1,e E\E שאינה סוגרת מעגל, ושמשקלה מינימלי בתנאי זה. נגדיר {e},e i = E i 1 ו (.T i = (V, E i נחזיר את n 1 T (אלגוריתם חמדן.(greedy עלות האלגוריתם ניתן לתחזק מבנה נתונים (ערימה מתוחכמת) המאפשר את ביצוע האלגוריתם בזמן (( V ) O. E ) log משפט: האלגוריתם של קרוסקל מחזיר עץ פורש מינימלי. הגדרות: לצורך המשפט נשתמש בכמה הגדרה: חתך בגרף הוא חלוקה של קודקודים לשתי קבוצות, V. = S V S\ הגדרה: צלע e E נמצאת בחתך אם t},e = {s, כך ש S \.s S, t V הגדרה: הצלע e היא צלע קלה בחתך אם e נמצאת בחתך, ומשקלה מינימלי בין כל הצלעות בחתך. הגדרה: החתך (S\,S) V מכבד קבוצת צלעות A, אם לכל e e, A אינה צלע בחתך. 25
משפט עזר: תהי A E תת קבוצה של צלעות של עץ פורש מינימלי. יהי (S\,S) V חתך המכבד את A. תהי E צלע קלה בחתך, אזי קבוצת הצלעות A E היא תת קבוצה של צלעות של עץ פורש מינימלי. הוכחה: נניח כי צלע e מחברת בין קודקוד x S לקודקוד y. V S\ נתבונן בעץ מינימלי T המכיל את A. בתוך T יש מסלול בין x ל y. ולכן קיימת e בתוך הצלעות של T המחברת בין S ל S \.V מתקיים e / A כי החתך מכבד את,A וכן ) (e W (e) W כי e היא צלע קלה בחתך. נוריד מ T את הצלע.e הגרף מתפרק לשני רכיבי קשירות V = C 1 C 2 כאשר,x C 1 y C 2 (בעץ T יש מסלול יחיד בין,x, y הורדת e על המסלול הזה מפרידה בין,x, y ועכשיו לא נוכל להגיע מזה לזה). עכשיו נוסיף את הצלע e המחברת בין C. 1, C 1 לכן קבלנו גרף קשיר חדש {e}.t = T \ {e } הגרף T הוא עץ כי הוספת הצלע e לא יוצרת מעגל כי e מחברת רכיבי קשירות שונים. קבלנו כי T הוא עץ פורש. נשים לב כי T A. {e} נותר להוכיח כי T הוא עץ פורש מינימלי: מכיוון ש { e } {,T = T \ {e לכן ) (T,W (T ) = W (T )+W (e) W (e ) W אבל T הוא עץ פורש מינימלי, לכן גם T עץ פורש מינימלי. הוכחה של משפט קרוסקל: נראה כי לכל i < n 1, קיים עץ פורש מינימלי T i המכיל את קבוצת הצלעות E. i אם כן העץ 1 n Tn 1 = T יהיה עץ פורש מינימלי. נראה באינדוקציה על i: עבור = 0,i זה ברור. נניח ל 1 i, ונוכיח ל i : נגדיר 1 i A. = E תהי e הצלע שהאלגוריתם בוחר להוסיף ל.(C 1, V \C 1 ) נגדיר חתך T שונים. בגרף i 1 C 1, מחברת שני רכיבי קשירות C 2 e.e i 1 נשים לב ש e היא צלע קלה בחתך, והחתך מכבד את A לכן נוכל להשתמש במשפט העזר ולומר כי קיים עץ פורש מינימלי המכיל את {e}.e i = E i 1 {e} = A 26