מבנה נתונים סיכומי הרצאות

מבנה נתונים סיכומי הרצאות 22 ביוני 2010 הערה לקראת המבחנים מרצה: דורית אהרונוב סוכם ע י: אור שריר פניות לתיקונים והערות: tnidtnid@gmail.com כרגע חסרים מספר דברים בסיכום, כמו פונקציות גיבוב, וכמובן שתמיד יתכנו טעויות נוספות שלא שמתי לב אליהן. במהלך תקופת המבחנים אני אשתדל לעדכן את הסיכומים מדי פעם, כאשר יתפנה לי זמן לתקן ולהוסיף להם חומר, ולכן מי שמוצא טעויות אני אשמח אם יודיע לי על כך במייל. גם אם הסיכומים לא יעתדכנו מיד בבנק האקדמי, הקישור הבא תמיד ישאר לגרסה הכי עדכנית (כאשר תאריך העדכון מופיע בדף הראשי): http://dl.dropbox.com/u/380910/class_notes/dast.pdf בהצלחה לכולם! תוכן עניינים 4 הרצאות I 4................................... הקדמה 1 4 נהלי הקורס............................. 1.1 4 מבני נתונים............................. 1.2 5......................... כלים בהם נשתמש 1.3 5................. דוגמא לבעיות שנתקל בהן בקורס 1.4 6.................................. סיבוכיות 2 6 מיון בועות.............................. 2.1 6........................ אלגוריתם 2.1.1 6.................. סיבוכיות האלגוריתם 2.1.2 7 סימונים אסימפטוטים.................. 2.1.3 7 שיטות טיפול באלגוריתמים רקורסיבים............... 2.2 8.................. השיטה האיטרטיבית 2.2.1 8............... ניחוש והוכחה באינדוקציה 2.2.2 9 מיון מיזוג Sort. Merge............... 2.2.3 1

10................ אלגוריתמי הפרד ומשול ומשפט האב 2.3 13........................ מיון ומודל ההשוואות 2.4 13......... טיפוס נתונים מופשט ADT Abstract Data Type 3 14 חזרה על עצים וגרפים........................ 3.1 14............................ תור קדימויות 3.2 18 עצי חיפוש בינאריים......................... 3.3 19................... חיפוש בעץ בינארי 3.3.1 19................... מינימום ומקסימום 3.3.2 19.................... עוקב של קודקוד 3.3.3 21.................... הכנסת איבר לעץ 3.3.4 21...................... מחיקת איבר 3.3.5 21.................. עצי חיפוש בינאריים מסוג AVL 3.4 22....................... מימוש העץ 3.4.1 24 רקע בהסתברות............................... 4 26...................... משתנה מקרי 4.0.2 27 דחיסת מידע קידודים........................... 5 27 מידע טקסטואלי קוד הופמן Code) (Huffman (1952)...... 5.1 29 מימוש.......................... 5.1.1 29 יעילות קוד הופמן.................... 5.1.2 30........................ אקראיות וסיבוכיות אקראית 6 30.......................... מיון מהיר אקראי 6.1 33....................... טבלאות גיבוב Table Hash 7 33....................... כיוונים למימוש הפתרון 7.1 33............... שלב ראשון: גיבוב רנדומלי 7.1.1 34................ שלב שני: פונקציית גיבוב 7.1.2 35.............. משפחה אוניברסלית של פונקציות גיבוב 7.2 35.................................... גרפים 8 35........................... ייצוג של גרפים 8.1 36 אלגוריתמים לסריקת גרפים..................... 8.2 36 חיפוש לרוחב Search. BFS Breadth First......... 8.3 38 אלגוריתם Dijkstra ( דייקסטרה )........... 8.3.1 39........... חיפוש לעומק DFS Depth First Search 8.4 40...................... מיון טופולוגי 8.4.1 40 אלגוריתם למיון טופולוגי של. DAG.......... 8.4.2 41 אלגוריתם. SCC.................... 8.4.3 41 עצים פורשים מינימליים Trees) (Minimum Spanning.......... 9 42 אלגוריתם קרוסקל ל MST..................... 9.1 43 אלגוריתם. Union-Find...................... 9.2 44.............................. על המבחן הסופי 10 44 החומר למבחן............................ 10.1 45............................ מבנה המבחן 10.2 2

45 תרגולים II 45.............. תרגול 1 01.03.2010 סימונים אסימפטוטים 11 46........ כללים לשימוש בסימונים האסימפטוטים 11.0.1 47.................. תרגול 2 09.03.2010 אלגורתמי מיון 12 47............. מיון ספירה Sort Counting 12.0.2 48.................... מיון Radix Sort 12.0.3 48................... מיון Bucket Sort 12.0.4 49........................... תרגול 3 16.03.2010 13 3

חלק I הרצאות 1 הקדמה הנושאים המכוסים בקורס הזה הם מאוד רחבים ומהווים הקדמה לאלגוריתמים, תכנות מונחה עצמים וכו וכו. כמעט בכל תחום קיים אספקט חישובי בהקשרים של איכסון ועיבוד מידע. 21.02.2010 1.1 נהלי הקורס שעת קבלה שעתיים בשבוע בימי רביעי מ 15:00 עד 17:00. תרגילים התרגילים מהווים %10 מהציון הסופי בקורס. יהיו 14 תרגילים ויש להגיש אותם אלקטרונית, כאשר כל שבוע ביום ראשון בלילה יפורסם התרגיל ויש להגישו להגיש עד ליום ראשון בשבוע לאחר מכן ב 12 בצהריים. בנוסף לבדיקת התרגילים יבוצעו ראיונות על תוכן התרגילים, כאשר בכל חודש ראיון אחד בו ישאלו שאלות על התרגילים שהוגשו עד הראיון לא מספיק להציג פתרון נכון אם בתרגיל הכתוב הפתרון לא מספק. בכל ראיון יהיו נוכחים 4 סטודנטים, ובדומה לחובת הגשת התרגילים, קיימת חובה לגשת ל 3 ראיונות במהלך הסמסטר, אחרת לא ניתן לגשת למבחן. אתר הקורס כתובת האתר: www.cs.huji.ac.il/~dast כל העדכונים בפורומים באתר הם מחייבים ויש לעקוב אחריהם. מבחן אמצע במאצע הקורס יתקיים מבחן אשר יהווה כ %20 מהציון הסופי כציון מגן. בונוסים ינתנו בונוסים בשיעורים ובתרגילים על שאלות מעניינות וכו. 1.2 מבני נתונים מבני נתונים שכבר ראינו: רשימה מקושרת מחסנית תור עץ חיפוש בינארי 4

וכו מבני נתונים נוספים: גרפים עצי חיפוש מאוזנים פונקציות גיבוב 1.3 כלים בהם נשתמש אינדוקציה רקורסיה משוואות הסתברות אנליזה סיבוכית הוכחות 1.4 דוגמא לבעיות שנתקל בהן בקורס על לוח משבצות 3 3 עם שני פרשים כחולים ושני פרשים כתומים הנמצאים בפינות הלוח (ראה איור). מהו מספר הצעדים המינימלי הנדרש להחלפת המיקום של הפרשים השחורים עם הלבנים רק באמצעות צעדים תקניים של פרשים. איור 1: בעיית פתיחה חילוף פרשים על לוח משבצות הבעיה הזו מקבילה לבעיה הבאה: על עיגול קיימות 8 נקודות כאשר על 4 מהנקודות האלו נמצאים הפרשים הנ ל במרווחים של נקודה בין כל שני פרשים, היכולים לנוע בקפיצות של 3 ונשאלת אותה השאלה להחלפת המיקומים של הפרשים הכתומים והכחולים. הפעם התשובה ברור 16 צעדים. 5

איור 2: בעיה מקבילה: חילוף פרשים הנמצאים על מעגל 2 סיבוכיות 2.1 מיון בועות 2.1.1 אלגוריתם הגדרה 2.1 פסאודו קוד היא צורה לכתיבת אלגוריתמים שהיא בין שפה כתובה לשפת תכנות. נכתוב את האלגוריתם למיון בועות באמצעות פסאודו קוד: אלגוריתם 1 מיון בועות for i = 1 to n - 1 do for j = 1 to n - i do if a(j) > a(j+1) then swap a(j) and a(j+1) 2.1.2 סיבוכיות האלגוריתם כאשר נמיין מערך בגודל N, נגדיר את זמן הריצת האלגוריתם עבור מערך זה כ ( n ) T. ניתן לראות כי ניתן הנוסחה המפורשת לפונקציה היא: T (n) = n 1 n i n 1 n 1 2 = 2 (n i) = 2 (n i) i=1 j=1 n 1 = 2 k = 2 k=1 i=1 n(n 1) 2 i=1 = n(n 1) = n 2 n 6

T (n) = באופן יותר מדוייק, נספור גם את קידום המשתנים כפעולות: n 1 n i n 1 n 1 n 1 1 + 5 = (1 + 5(n i)) = 1 + 5 i i=1 j=1 = (n 1) + 5 i=1 n(n 1) 2 = 5 2 n2 3 2 n 1 כביכול קיבלנו שתי תוצאות שונות, מכיוון שהסתכלנו על הבעיה ברמת פירוט שונה, אך בכל מקרה הפרמטר N יהיה בריבוע ללא קשר לרמת הפירוט בה נבחר. i=1 i=1 2.1.3 סימונים אסימפטוטים הגדרה 2.2 O גדול נגדיר ש ( f(nהיא (( O(g(nאם קיימים קבועים <,n C 0 כך ש. n > n 0 ( f(nלכל C g(n) דוגמאות:.n 0 = 1, C הוא נכון עבור = 1 n 2 n = O(n 2 ).n 0 = 1, C 5 הוא נכון עבור = 5 2 3 n2 3 2 n 1 = O(n2 ) ) O(n2 5 2 n2 + 3 2 n + 1 = אף הוא נכון! הגדרה 2.3 Ω נגדיר ש ( f(n היא Ω(g(n)) אם קיימים קבועים <,C n 0 0 כך ש.n לכל n 0 f(n) C g(n) הגדרה 2.4 Θ אם f(n) היא גם O(g(n)) וגם Ω(g(n)) אז נגדיר שהיא.Θ(g(n)) o נגדיר ש ( f(n היא o(g(n)) (זניחה ביחס ל ( g(n ), 2.5 הגדרה. lim f(n) אם = 0 n g(n) 2.2 שיטות טיפול באלגוריתמים רקורסיבים נמצא אלגוריתם רקורסיבי למיון בועות: 07.03.2010 Bubble Sort A[1,..., n] : Bubble A[1,..., n] Bubble Sort A[1,..., n 1] Bubble A[1,..., n] : אלגוריתם 2 מיון בועות רקורסיבי בעבע את האיבר הגדול ביותר במערך שמאלה... ועכשיו ננסה למצוא את פונקציית זמן הריצה של האלגוריתם: T (n) = T (n 1) + Θ(n) T (1) = Θ(1) 7

2.2.1 השיטה האיטרטיבית T (n 1) + c n T (n) T (n 1) + c n T (n 2) + c(n 1) + c n T (n 3) + c(n 2) + c(n 1) + c n. T (1) + c 2 + c 3 +... + c(n 1) + c n n [ ] n(n + 1) d + c j = d + c 1 2 j=2 = d + c 2 n2 + c 2 n c = O(n2 ) T (n) d + c 2 n2 + c 2 n c = Ω(n 2 ) באופן דומה עבור האגף השמאלי: ומשילוב שתי התוצאות נקבל כי הסיבוכויות של האלגוריתם היא ) 2.Θ(n 2.2.2 ניחוש והוכחה באינדוקציה ננחש ש ( O(n T (n) = הוכחה: (לא נכונה באינדוקציה) בסיס האינדוקציה הוא: = (1) T O(1) נניח כי הטענה נכונה עד nונוכיח עבור n: T (n) = T (n 1) + O(n) Assumption {}}{ = O(n 1) + O(n) = O(n) + O(n) = O(n) וקיבלנו כי אכן O(n) T (n) = בסתירה לסיבוכיות שמצאנו מקודם איפה הטעות? הקבועים המסתתרים תחת הסימון של O משתנים והנחת האינדוקציה לא צויינה באופן מפורש נתקן את המעברים: T (n + 1) From the recursion eq. {}}{ T (n) + d (n + 1) Assumption {}}{ c n + d(n + 1)? c (n + 1) ידוע: T (n) T (n 1) + d n נניח באינדוקציה: T (n) c n נוכיח עבור + 1 :n 8

הבעיה: לא ניתן לבצע את המעבר האחרון (עם סימן השאלה). הוכחה: (נכונה) נוכיח באינדוקציה ש ( T. (n) = O(n 2 ידוע: T (n) T (n 1) + d n ו d.t (1) ננסה להוכיח באינדוקציה: T (n) d n 2 1 2 d.t (1) d = בסיס האינדוקציה: צעד האינדוקציה: נניח ש T (n) d n 2 ונוכיח ש 1) 2 + d(n T (n + 1) שכן T (n + 1) T (n) + d(n + 1) d n 2 + d(n + 1) d(n 2 + n + 1) d(n 2 + 2n + 1) = d(n + 1) 2 2.2.3 מיון מיזוג Sort Merge אלגוריתם 3 מיון מיזוג Mergesort A[1,..., n]: Mergesort A[1,..., n 2 ] Mergesort A[ n 2 + 1,..., n] Merge (A[1,..., n 2 ], A[ n 2 + 1,..., n]) <- Θ(n) T (n) = 2T ( n 2 ) + Θ(n) נמצא את הסיבוכיות של האלגוריתם: נצייר את עץ הרקורסיה של האלגוריתם על מערך לדוגמא: 5 4 2 6 1 3 7 8 2 4 5 6 1 3 7 8 4 5 2 6 1 3 7 8 5 4 2 6 1 3 7 8 ובאופן דומה, נצייר את עץ לפי זמני ריצה: 9

איור 3: עץ רקורסיה לפי זמני ריצה קיימות (n) log 2 רמות בעץ וכל שורה שווה ל c n ולכן בסה כ = (n) T (n) = c n log c.θ(n log(n)) 2.3 אלגוריתמי הפרד ומשול ומשפט האב a, b כאשר n b נתונה בעיה בגודל n, וקיימת דרך לחלק את הבעיה ל a בעיות קטנות בגודל הם שלמים חיוביים. נגיד שעלות החיבור של a הפתרונות היא ) k Θ(n עבור k שלם חיובי. זמן הריצה של האלגוריתם שכזה הוא: ( n ) T (n) = a T + Θ(n k ) b T (1) = Θ(1) ננסה למצוא את זמן הריצה של משוואה כללית זו: ולפי עץ רקורסיה: T (n) = a T ( n b ) + c nk T (1) = c 10

איור 4: עץ רקורסיה לאלגוריתם הפרד ומשול c a l ( n ומספר השורות בעץ הוא (n) log b בנוסף בשורה b l ) k הסכום של כל שורה הוא האחרונה יש b(n).c a log נסכום את כל השורות: l = 0 cn k = cn k l = 1 c a ( ) ( n k b = cn k a ) b k l = 2. m = log b n c a 2 ( n b 2 ) k. =. c a m ( n b m ) k. T (n) = c n k m ( a ) l l=0 b = c nk k = cn k ( a b k ) 2 = cn k ( a b k ) m :q = a b ( k 1 q m+1 1 q קיימים שלושה מקרים עבור ) = Θ(n k ) ואז q < 1.1. T (n) = c n k m l=0 1 = c nk log b (n) = Θ(n k log(n)) ואז q = 1.2 m ( a ) [( l a ) m+1 ] T (n) = c n k = c n k b 1 ( k b k a ) l=0 b 1 [ k ( ab ) ]) m+1 = Θ (n k n k 1 k [ ( = Θ n k a ) m ] ] ] b k = Θ [n k am b km = Θ [n k am n k = Θ (a m ) = Θ ( a log n) b = Θ ( n log a) b > 1.3 q ואז 11

משפט 2.6 משפט האב הפתרונות הנ ל עבור (n) T לפי אלגוריתם הפרד ומשול. אם ) ( T, T (n) = a ונגדיר q = a אז n b k b + Θ(n k ).1 אם < 1 q מתקיים ) k T (n) = Θ(n.2 אם = 1 q מתקיים ) n T (n) = Θ ( n k log.3 אם > 1 q מתקיים a).t (n) = Θ ( n log b דוגמא: מיון מיזוג 1 = k a = b = 2, ואז = 1 q ולכן n).t (n) = Θ(n log 2 דוגמא: מיון בועות Θ(n) T (n) = T n) (1 + הוא לא אלגוריתם הפרד ומשול וכל ולא ניתן לפתור אותו כך! דוגמא: מיון מהיר (Quicksort) תזכורת: בוחרים איבר כלשהו במערכת, ומסדרים את המערך כך שכל האיברים הגדולים מהאיבר הנבחר נמצאים מעליו, וכל האיברים הקטנים ממנו נמצאים מתחתיו, וחוזרים על התהליך עבור כל תת מערך. Quicksort Quicksort A[left, right] :- if left < right then q partition[a] Quicksort [left, q-1] Quicksort [q+1, right] אלגוריתם 4 הסיבוכיות של החלוקה היא Θ(n) ולכן בסה כ: T (n) = T (q 1) + T (n q) + Θ(n) T (1) = Θ(1) T (n) = 2T ( n 2 המקרה הכי טוב: Θ(n) + ) המקרה הכי גרוע: Θ(n) T (n) = T (n 1) + ולכן ) 2.Ω(n log n) = T (n) = O(n = 1 10 c כך שבכל פעם בו נבחר איבר הוא יחלק את נניח כי קיים קבוע c, למשל, n 10, 9n ולכן המערך ל 10 T (n) = T ( n 10 ) + T ( 9 10 n) + Θ(n) < 2T ( 9 n) + Θ(n) 10 log 10 2 = b,k = 1, הפתרון הוא ) 9,O(n אבל מכיוון 10 9 וממשפט האב, כאשר = 2 a, ש 2 > 2,log 10/9 נתון זה לא משפר את הדיוק שלנו. אם נצייר את עץ הרקורסיה של האלגוריתם, ניראה כי העץ אינו מאוזן (כלומר חלק מהמסלולים מהשורש לעלים קצרים מגובה העץ). גובה העץ הינו,log 10/9 n ולכן ניתן לכתוב כי = (n O(n log 10/9.O(n log n) 12

2.4 מיון ומודל ההשוואות הגדרה 2.7 אלגוריתם מיון המשתמש בקלט אך ורק לשם השוואת שני ערכים, ומחליט על הפעולות הבאות רק על סמך תוצאת ההשוואה, ניקרא מיון במודל ההשוואות. משפט 2.8 הסיבוכיות של כל מיון במודל ההשוואות היא (n Ω(n log (כלומר, גם המיון הטוב והיעיל ביותר, לא יכול להיות בעל סיבוכיות הקטנה מ ( n.(θ(n log הוכחה: בשביל להוכיח את המשפט, ננסה למצוא מודל כללי המתאר את האלגוריתמים הללו. נעזר בעץ הכרעה Tree) :(Decision איור 5: עץ החלטה סיבוכיות של מיון השוואות היא לפחות אורך המסלול הכי ארוך ארוך מהקודקוד לעלה בעץ (גובה העץ h). נשים לב שבעץ יש לפחות!n עלים ומכיוון שהעץ הוא עץ בינארי אז קיימים בו לכל היותר 2 h עלים, ולכן 2 h #Leaf n! 2 h n! h log n! = log n + log(n 1) + log(n 2) +... + log 1 n 2 log n 2 = n 2 log n n = Ω(n log n) 2 3 טיפוס נתונים מופשט ADT Abstract Data Type דוגמאות: 1. מחסנית סדר האיברים הוא LIFO עם הפעולות push(element) pop(), וכו. 2. תור סדר האיברים האו F IF O עם הפעולות enqueue() dequeue(), וכו. 13

3.1 חזרה על עצים וגרפים הגדרה 3.1 נגדיר גרף G כקבוצה של קודקודים ושל צלעות המחברות בין בין שתי קודקודים בגרף. הגדרה 3.2 גרף מכוון הוא גרף בו קבוצת הצלעות מורכבות מזוגות סדורים של קודקודים (כלומר יש משמעות לסדר a) ((a, b) (b, הגדרה 3.3 גרף לא מכוון הוא גרף בו כל צלע היא פשוט זוג קודקודים ללא חשיבות לסדר. הגדרה 3.4 מסלול בגרף זו סדרת קודקודים v 1,..., v n כך שלכל i מ 1 עד 1 n קיים.(v i, v i+1 ) E הגדרה 3.5 עץ מכוון הוא גרף מכוון כך שאחד הקוקדקדים מסומן כשורש, וקיים מסלול אחד ויחיד מהשורש לכל קודקוד בגרף. הגדרה 3.6 דרגת יציאה של קודקוד היא מספר הבנים של קודקוד. הגדרה 3.7 עומק של קודקוד הוא אורך המסלול מהשורש אל הקודקוד. הגדרה 3.8 עלה הוא קודקוד שלא יוצאות ממנו צלעות. הגדרה 3.9 הורה של קודקוד הוא הקודקוד האחרון w במסלול מהקודקוד לשורש. הגדרה 3.10 גובה העץ הוא אורך המסלול הארוך ביותר משורש העץ לעלה כלשהו בעץ. הגדרה 3.11 עץ בינארי הוא עץ מכוון שדרגת קודקודיו היא לכל היותר 2. הגדרה 3.12 עץ מלא הוא עץ שבו לכל קודקוד דרגת היציאה היא 2 או 0. הגדרה 3.13 עץ מלאה הוא עץ שבו לכל העלים אותו עומק. הגדרה 3.14 עץ כמעט שלם הוא עץ שבו כל הרמות מלאות, מלבד הרמה האחרונה המלאה משמאל עד מקום מסויים (כמובן שעץ שלם הוא גם עץ כמעט שלם). טענה 3.15 גובהו של עץ כמעט שלם עם n קודקודים הוא n D. = log 2 3.2 תור קדימויות נרצה מבנה נתונים שישמור על איברים בעלי עדיפות כלשהי, כך שנוכל לעדכן את קדימות איברי התור, ותמיד כשנוציא איבר זה יהיה האיבר בעל הקדימות הגבוהה ביותר. נגדיר על כן את הפעולות הבאות: Max(A) מחזירה את האיבר הגדול ביותר בתור מבלי להוציא אותו. Extract_max(A) מחזירה את האיבר הגודל ביותר בתור ומוחקת אותו מהתור. (A Insert(k, הכנסת איבר חדש k לתוך התור. 14

x. לקדימות החדשה k מגדילה את הקדימות של האיבר Increase_key(x,,k (A על מנת לממש את התורה בצורה יעילה, נשתמש במבנה נתונים אחר הנקרא ערימה. הגדרה 3.16 ערימה (Heap) היא עץ בינארי כמעט שלם המקיימת את תכונת הערמה. איור 6: דוגמא לערימה הגדרה 3.17 תכונת הערמה היא A(i),i A(parent(i)), כלומר הקדימות של הורה של כל קודקוד גדולה מקדימות בניו. הגדרה 3.18 מספר האיברים בערימה הוא heapsize(a). n = ניתן לממש ערמה באמצעות מערך בגודל n (מספר האיברים בערימה) בשימוש בנוסחאות: נגדיר עתה את הפעולות הדרושות לנו: lef t(i) := 2i right(i) := 2i + 1 i parent(i) := 2 15

אלגוריתם 5 תור קימויות וערימה heap_max(a) := return A[1] extract_max(a) := max A(1) A(1) A(heapsize(A)) heapsize(a) heapsize(a)-1 max_heapify(a, 1) insert(a,k) := heapsize(a) heapsize(a)+1 A(heapsize(A)) increase_key(heapsize(a), k, A) increase_key(i, k, A) := if k < A(i) then error A(i) k while i>1 and A(parent(i)) > A(i) swap(a, i, parent(i)) i parent(i) (כאשר max_heapify מפעפע את האיבר ה i כלפי מטה, ובאופן דומה, increase_key מפעפע את האיבר כלפי מלא עד מיקומו לפי הערך החדש של המפתח) מספר אבחנות: 1. אבחנה א : כל קודקוד בעץ בינארי כמעט שלם הנו שורש של עץ בינארי כמעט שלם. 2. אבחנה ב : כל קודקוד בערימת מקסימום הנו שורש של ערימת מקסימום. 3. אבחנה ג : (נכונות של (max_heapify אם שני ילדיו של i שורשי ערימת מקסימום ו i שורש על עץ בינארי כמעט שלם, אז אחרי הפעלת (i i,max_heapify(a, הוא שורש של ערימת מקסימום נניח כי נתון לנו מערך קיים ונרצה ליצור ממנו ערמה. כיצד ניתן לעשות זאת? להכניס כל איבר במערך לתוך ערמה חדשה, ולכן הסיבכויות של דרך זו היא.Θ(n log n) ניתן למיין את המערך, וגם פעולה זו היא לכל הפחות (n.θ(n log מכיוון שאין צורך כי הערמה תהיה ממש ממוינת, ניתן להשתמש ב max_heapify בשביל לסדר את הערמה באופן הבא: 16

build_max_heap(a) := heapsize(a) length(a) for i n to 1 max_heapify(a, i) אלגוריתם 6 בניית ערמה ממערך מדוע אלגוריתם זה נכון? נוכיח באמצעות שמורת לולאה invariant).(loop הוכחה: שמורת הלולאה: אחרי הקריאה ה i ללואה, באלגוריתם הקודקודים,i..., n הם שורשי ערימות מקסימום. נוכיח ששמורשת הלולאה נכונה לכ i מ n עד 1. אתחול: i = n ברור שהקודקוד n הוא שורש של ערימת מקסימום (באופן ריק). שימור: נניח עבור i ונוכיח עבור 1 i. משמורת הלולאה עד, i ידוע ש ( A(n,(1)A..., הם שורשי ערימות מקסימום לפי הקריאה (i.max_heapif y(a, אחרי הקריאה, כל הקודקדוים שמחוץ לתת העץ ששורשו 1 i לא קרה להם כלום, ולכן הם עדין שורשי ערימות מקסימום עבור הקודקודים בתת העף ששורשו 1 i (לפי אבחנה א, 1 i שורש של עץ כמעט שלם, ובכל שמורת הלולאה עד i, ושני בניו שורשי ערימת מקסימום, ולכןן ניתן להפעיל את אבחנה ג ) ולכן 1 i הוא שורש של ערימת מקסימום. טענה 3.19 הסיבוכיות של בניית הערימה בצורה זו היא.Θ(n) הוכחה: עבור קודקוד בעומק d(i) הסיבוכיות של הקריאה ל y max_heapif היא.O(D d(i) + 1) כמה קודקודים בעומק d? הוא d 2 ולכן הסיבוכיות היא: T (n) C k=d d+1 {}}{ = C D 2 d (D d + 1) d=0 D 2 D k+1 k k=1 = C2 D+1 D k=1 k 2 k? C 2 n 17

D+1 1 :x = 1 2 בשביל לפתור את הבעיה, נעריך את הסכום, כאשר D+1 kx k = x k=1 D+1 = x = x k=1 kx k 1 (x k ) ( 1 ) 1 x 0<x<1 {}}{ x = (x k ) k=1 x (1 x) 2 = 2 ( ) {}}{ = x( x k ) k=1 D הראינו k=0 k 1 תיקון / המשך ההוכחה: בשיעור שעבר לא הוכחנו נכון כי (1)O 2 k = ש ( k = o(c k לכל > 1 c ובפרט ל 1.5 =.c קיים קבוע c וקיים k 0 כך ש kוגם k 0. k c 1.5 k הסכום D 1 k 2 k k=0 =O(1) {}}{ k 0 1 D k 2 k + k=0 k=k 0+1 c ( 1.5 2 ) k c k=0 ( ) k 3 4 lim k k k=0 : סכום של סדרה הנדסית, כאשר < 1 q ו 0=k qk q k q k +1 1 1 q k +1 = lim = lim = 1 k q 1 k 1 q 1 q c k=0 ( 3 4) k = c 1 1 4 = 4c ולכן בשימוש בסכום זה: 3.3 עצי חיפוש בינאריים עץ חיפוש בינארי הוא ADT עליו מוגדרות הפעולות: מקסימום max מינימום min קודם predecessor עוקב successor הכנסה insert מחיקה delete 18

הגדרה 3.20 תכונת עץ חיפוש בינארי לכל קודקוד x בעץ לכל (right(x)) y T מתקיים key(y) key(x) < ולכל (left(x)) z T מתקיים key(y),key(x) > כלומר כל הצאצאים הימניים של הקודקוד גדולים ממנו וכל הצאצאים השמאליים קטנים ממנו. הערה 3.21 כרגע אנו לא מטפלים במקרים בו נמצאים בעץ שני קודקודים בעלי אותו.key 3.3.1 חיפוש בעץ בינארי אלגוריתם 7 חיפוש בעץ בינארי if x = null return not found else if key(x) = k return x else if key(x) < k return tree_search(left(x), k) else return tree_search(right(x), k) סיבוכיות זמן הריצה היא O(h) כאשר h הוא גובה העץ. 3.3.2 מינימום ומקסימום Tree_Search(x,k):- Tree_minumum(x):- while left(x) null do x left(x) return x Tree_maximum(x):- while right(x) null do x left(x) return x אלגוריתם 8 מינימום ומקסימום וכמובן שגם הסיבוכיות של אלגוריתמים אלו היא.O(h) 3.3.3 עוקב של קודקוד הגדרה 3.22 האיבר הקטן ביותר בעץ שגודל מ x. טענה 3.23 העוקב y של x הוא: 1. אם ל x בן ימני, w, אזי y הוא המינימום של (w) T. 2. אם ל x אין בן ימני, אזי או ש x הוא המקסימום בעץ או שקיים y אב קדמון הכי נמוך של x כך שגם ילדו השמאלי אב קדמון של x או x עצמו, וקדקוד זה הוא העוקב. 19

למה 3.24 נניח x קודקוד בעץ חיפוש בינארי. אם z הוא קודקוד בעץ שלא בתת העץ (x) T אזי (x))].key(z) [min(t (x)), max(t הוכחה: (הלמה) לכל קודקוד בעץ קיים מסלול יחיד משורש העץ אל הקודקוד, ולכן קיימים רק המקרים הבאים לפיהם ממוקמים,x:,z w איור 7: הוכחה עבור כל מקרה הוכחה: (טענת העוקב).1 נסתכל על (x),t ברור שבתוך (x) min(right(x)) = min(w) T הוא העוקב של.x ומה עם שאר איבר העץ שלא בתוך (x) T? מוטענת העזר, כל האיברים האלה יושבים מחוץ לטווח min(w)],x]. 2. נתבונן ב ( y ) x T. מקיים שהוא max(left(y)) ולכן בתוך (y) y T. עוקב של x (כי T, כל האיברים שמחוץ ל ( y ) ולגבי המקסימלי מבין כל האיברים הקטנים מ y ) x טענת העזר אומרת שהם מחוץ לטווח [y.[max(lef t(y)), ועכשיו נוכל לכתוב את האלגוריתם עצמו כ: אלגוריתם 9 העוקב של קודקוד Tree_successor(x):- if right(x) null return Tree_min(right(x)) else y parent(x) while y null and x = right(y) x y y parent(x) return y 20

3.3.4 הכנסת איבר לעץ אלגוריתם 10 הכנסת איבר לעץ Tree_insert(T,Z):- y = parent(x) y null x root(t ) while x null do y x if key(z) < key(x) x lef t(x) else x right(x) parent(z) y if y = null root(t) = z else if key(z) < key(y) left(y) z else right(y) z 3.3.5 מחיקת איבר 1. אם ל x אין ילדים מחיקה פשוטה. 2. אם ל x ילד אחד, אז מוחקים את x ומחברים את הבן לאב של x. 3. אם ל x שני ילדים, ובפרט יש לו ילד ימני, אזי מטענת העוקב, לעקוב של x שהוא x. אין ילד שמאלי, נמחק את העוקב ונעביר אותו במקום min(right(x)) 3.4 עצי חיפוש בינאריים מסוג AVL מטרה: עצי חיפוש בינאריים מאוזניים, כלומר גובה העץ הוא (n k. = O(log תכונת :AVL כאשר הגובה של תת עץ הוא ),k(t אזי מתקיים עבור כל קודקוד בעץ כי. k(left(t )) l(right(t )) 1 מסוכמה: גובה של תת עץ ריק הוא 1. הגדרה 3.25 נגדיר n k להיות מספר הקודקודים המינמלי בעץ AVL בגובה k. לדוגמא:.n 2 = ו 4 n 1 = 2,n 0 = 1 טענה n k 3.26 הוא מונוטוני ממש ב k, כלומר לכל.n k < n k+1 k הוכחה: נניח ש T הוא עץ AVL בגובה + 1 k. ידוע שאחד מתתי העצים הוא בגובה k בדיוק, והשני או k או 1 k. בתת העץ ה i יש לפחות n k קודקודים, ובגלל מינימלית של העץ T, בתת העץ ה i יש בדיוק n k קודקודים, ולכן ב T יש לפחות + 1 k n קודקודים. 21

ננסה להגדיר נוסחה כללית ל nונשים k לב כי מתקיים 2 k + 1 n k = n 1 k + n ואם נגדיר + 1 k G k = n אזי נקבל כי n k + 1 = n k 1 + 1 + n k 2 + 1 G k = G k 1 + G k 2 ובעצם קיבלנו את נוסחת פיבונצ י, k 2 F k = F k 1 +f כאשר איברי הסדרה הם,1, 1, 2, 3, 5 ונשים לב כי =,2,3 5 i G ולכן יש הסתה של 3 אינדקסים ביחס למספרי פיבונצ י ונלכן נכתוב G k = F k+3 n k = F k+3 1 φ 1,2 Fכאשר k = 1 5 ( φ k 1 φ k 2) כזכור מהתרגיל, הנוסחה המפורשת למספרי פיבונאצי היא 1± 5 = 1,2,φ ולכן 2 הם הפתרונות של = 0 1 x x 2 כלומר 1 ( φ k 1 + 1 ) F k 1 ( φ k 1 1 ) 5 5 1 5 (φ k+3 1 + 1) 1 n k 1 5 ( φ k+3 1 1 ) 1 ולכן, עבור k מספיק גדול מתקיים כי n k cφ k 1 ולכן log n k k log φ 1 + log c k log n k log φ 1 log c log φ 1 k = O(log n k ) n k n = O(log n) 3.4.1 מימוש העץ נוסיף לכל קודקוד שדה חדש המציין את גובה תת העץ, ונגדיר את הפעולות הבאות: הכנסה: נכניס איבר x, ואחרי ההכנסה נעלה מ x אל השורש, ובכל קודקוד (כולל) נעדכן את שדה הגובה, ונבדוק שתכונת AV L מתקיימת, ונזהה את הקודקוד ה I שיש בו הפרה. בשביל לתקן את ההפרה נשתמש בעקרון הנקרא רוטציות, ונסתכל על מקרים שונים של העץ ועל הדרכים לתקן את העץ לאחר הוספת איבר חדש. 1. מקרה LL משתמשים ברוטציית.LL 22

איור 8: עץ המתאר את המקרה LL 2. עבור מקרה RR הוא בדיוק סימטרי ל LL. 3. מקרה,LR נבצע פעמיים את הרוטציה, פעם RR על A בשביל להגיע למקרה LL ואז רוטציית LL על B. איור 9: שלב ראשון של מקרה LR יתרונות של השיטה: 1. העץ נשאר עץ חיפוש בינארי 2. אחרי הרוטציה בכל הקודקודים בתת העץ המדובר אין הפרות של.AVL 23

3. לא הגדלנו את הגובה בהכנסה. בסה כ האלגוריתם באופן כלי הוא: נבדוק איזו רוטציה יש לבצע,RL, LR, RR, LL נבצעה וסיימנו. הסיבוכיות של האלגוריתם היא (n.o(log מחיקה: נטפל בבעיה שנוצרה ממחיקת קודקוד עם 0 או 1 ילדים. כמו בהכנסה אבל נמשיך לעלות במעלה העץ ולחשב ולתקן בכל פעם שנמצא הפרה של התנאי. הסיבוכיות היא.O(log(n)) 4 רקע בהסתברות דוגמאות כלליות להסתברות: 1. הסיכוי לקבת צבע (Flush) בחלוקת יד בפוקר הוא בערך 2 ל 1000. 2. הסיכוי שיהיה מחר גשם 3. הסיכוי שעוד הר געץ יתפרץ באיסלנד ב 30 השנים הבאות. 4. הזמן האופייני בין נפילות מעבדים במערת זו הנו 3 ימים. 5. בהינתן שהורה חולה במחלה גנטית כלשהי, מה הסיכוי שגם הילד שלא יחלה במחלה זו במהלך חייו? הגדרה 4.1 (מרחב הסתברות) נגדיר Ω היא קבוצה של מאורועות אלמנטריים, למשל עבור ) ( = Ω שהוא מספר הידיים האפשריות בפוקר. 52 דוגמא (1) לעיל 5 בנוסף נגדיר פונקציית הסתברות pr : Ω R כך שלכל w Ω מתקיים pr(ω) 0. ω Ω 1 ובנוסף = 1 pr(ω) ביחד, הקבוצה והפעולה שהגדרנו מגדירות את מרחב ההסתברות. הגדרה 4.2 מאורע הוא תת קבוצה של Ω..pr(A) = ω A הגדרה 4.3 ההסתברות של מאורע A היא pr(ω) דוגמא: הטלת שתי קוביות במשחק שש בש ω,ω pr(ω) = כמספר הזוגות האפשריים, ונגדיר כי ההתפלגות אחידה, כלומר Ω = 36. 1 36 נרצה למצוא את הסיכוי לאכל כלי משחק במרחק 2 (תחת ההנחה כי ניתן ללכת לפי כל קובייה), ולכן המאורע הוא 1)} = b.a = {(a, b) a = 2 b = 2 (a =.pr(a) = 12 36 = 1 3 ההסתברות של מאורע זה היא דוגמא: הטלת 3 מטבעות בהסתברות שווה = 8 3 = 2 Ω ונרצה למצוא את ההסתברות להטלת 3 מטבעות כך שכולם שווים (כלומר.pr(C) = 1 4 שלוש פעמים פלי או עץ) ולכן = 2 C ולכן הגדרה 4.4 מאורע משלים ל A מסומן ע י Ā והוא מייצג את כל המאורעות האלמנטריים שאינם ב A כלומר Ā. = Ω\A ההסתברות של המאורע המשלים הוא pr(a).pr(ā) = 1 24

הגדרה 4.5 חיתוך מאורעות B A כל המאורעות הנמצאים גם ב A וגם ב B. הגדרה 4.6 איחוד מאורעות A B כל המאורעות האלמנטריים שנמצאים לפחות באחת הקבוצות A או B. הגדרה 4.7 מאורעות זרים הם שני מאורעות,A B כך ש = B A (קבוצה ריקה) ואז נקבל כי pr(b).pr(a B) = pr(a) + הערה 4.8 צריך לשים לב כי הסתברות לפעמים נוגדת את האינטואיצה, למשל השאלה מה עדיף מליון דולר בוודאות או 2 מליון בסיכוי של 1 ל 2, ואותה השאלה רק הבחירה בין מליון 1 היא זהה מבחינת הבחירה שנעשה. 1 200 לעומת 2 מליון בהסתברות 100 דולר בהתסברות פרדוקס היומהולדת: ההסתברות שבכיתה של 60 תלמידים יש שני ימי הולדת זהים (כלומר ללא השנה) היא גדולה מ 99%! נניח שימי הולדת מפולגים באופן אחיד, ולכן אם Ω שווה לכל הרשימות האפשרויות באורך 60 של ימי הולדת שונים אז = 365 60 Ω. נגדיר את A להיוות כל הרשימות שיש בהן שני תאריכם שווים לפחות ואת B = Ā כל הרשימות שבהן כל התאריכים שונים. pr(b) = 365 364 306 365! 365 60 = 305!365 60 pr(b) < 1% pr(a) > 99% הגדרה 4.9 הסתברות מותנת היא ההסתברות לאירוע כלשהו בהינתן המידע על קיום (או אי קיום) של האירועים הקודמים לו. ההסתברות שיתקיים A בהינתן B מסומנת ע י.pr(A B) עבור מאורע אלמנטרי w ובהנחה שההתפלגות היא אחידה נקבל כי pr(w B) = 1 Ω B Ω = 1 B ועבור התפלגות כלשהי ולכן עבור מאורע כללי A נקבל pr(w B) = w B pr(w B) = w B 0 pr(w B) = pr(a B) = w A B pr(w) pr(b) pr(w B) pr(b) pr(w) pr(a B) = pr(b) pr(b) 25

דוגמא: בחזרה להטלת שתי קוביות..( 1 3 נניח שראינו שהקוביה הראשונה יצאה 1 (כאשר הסיכוי שזה יקרא הוא = 2 6 3 = 1 pr(a B) כי מה הסיכוי למאורע A כפי שהוגדר בדוגמא הקודמת, ובמקרה זה נותר רק לחשב את ההסתברות של הקוביה הנוספת שתהיה 1 או 2 ולכן הגדרה 4.10 מאורע A לא תלוי ב B אם ם מתקיים pr(a).pr(a B) = טענה 4.11 אם המאורע A לא תלוי ב B אז B לא תלוי ב A. הוכחה: לפי ההנחה מתקיים. 1 3 pr(a B) = pr(a B) = pr(a) pr(b) pr(a B) = pr(a)pr(b) ולכן אם נכתוב לפי ההגדרה את ההסתברות ל B בהינתן A נקבל: pr(b A) = pr(a B) pr(a) = pr(a)pr(b) pr(a) = pr(b) ולכן היחס הזה הוא יחס סימטרי. מסקנה 4.12 שני מאורעות הם בלתי תלויים אם ם מתקיים pr(a)pr(b).pr(a (B = 4.0.2 משתנה מקרי נתחיל עם דוגמא כללית. לאחר בדיקת מחברות הבחינה של תלמידים, חלק מהם התערבבו, והוחזרו לתלמידים אחרים. אם π היא פרמוטציה אקראית כלשהי ו X הוא מספר התלמידים שיקבלו את המחברת שלהם, אזי עבור פרמוטציה π מספר התלמידים שיקבלו את המחברת שלהם הוא מספר נקודות השבת בפרמוטציה, ולכן נקבל כי {1, 2, 3} 3 {1, 3, 2} 1 {2, 3, 1} 0 {2, 1, 3} 1 {3, 1, 2} 0 {3, 2, 1} 1 pr(x = 0) = 1 3, pr(x = 1) = 1 2, pr(x = 3) = 1 6 הגדרה 4.13 משתנה מקרי ממשי על מרחב הסתברות הוא פונקציה X : Ω R אותה נציב ב pr. 26

הגדרה 4.14 תוחלת של משתנה מקרי (Expectation) היא הכללה של הממוצע להתפלגויות לא אחידות: E(x) = X(ω) pr(ω) = pr(x = i) i ω Ω i {p x(ω)=p} טענה 4.15 התוכלת היא אופוראטור לינארי ולכ מתקיים כי ) E(Y.E(X + Y ) = E(X) + הוכחה: E(X + Y ) = ω Ω E(X + Y )(w) pr(ω) = ω Ω(X(ω) + Y (ω))pr(ω) = X(ω)pr(ω + Y (ω)pr(ω) ω Ω ω Ω = E(X) + E(Y ) 5 דחיסת מידע קידודים 5.1 מידע טקסטואלי קוד הופמן Code) (Huffman (1952) נרצה לשמור טקסט המורכב מ 26 אותיות במחשב, ולכן הקוד הכי פשוט הוא לייצג כל אות בעזרת אותו מספר ביטים, ולכן נדרשים 5 ביטים לייצוג כל אות, כלומר a = 00000 b = 00001 c = 00010. נשים לב כי קיימות אותיות החוזרות על עצמן בטקסט שוב ושוב בתדירות גבוהה, לעומת אותיות הנמצאות בטקסט לעיתים רחוקות, ולכן נוכל לתת לאותיות החוזרות על עצמן ייצוג קצר יותר, בעוד לאותיות הנדירות ייצוג ארוך יותר. הבעיה היא שאם לכל אות ייצוג בעל אורך שונה, איך נבדיל בין תחילת אות אחת לאחרת? לשם כך נעזר ב קוד חסר תחיליות. הגדרה 5.1 קוד חסר תחיליות הוא קידוד של האותיות, כך שהקידוד של כל אותו הוא אף פעם לא התחלת הקידוד של אות אחרת. נעזר בעץ הישמש אותנו כמילון לקידוד: 27

איור 10: עץ המייצג מילון ולכן אם נניח כי התפלגות האותיות היא: 0 45% a 101 13% b 100 12% c 111 16% d 1101 9% e 1100 5% f ולכן מספר הביטים הדרוש לייצוג הטקסט הוא (1 45% + 3 13% + 3 12% +...)n ובאופן כללי, עלות הקוד T היא L(T ) = f(c)l(c) c C כאשר C היא קבוצת האותיות, f(c) הוא שכיחות האות, ו( l(c הוא מספר הביטים הדרושים לייצוג האות. ולכן, עבור טקסט באורך L(T ) n n (בניגוד לקוד הפשוט, log C n בעוד בקוד הפשוט נקבל כי דרושים 3n ביטים למקרה של 6 אותיות, בקוד זה דרושים רק 2.24n. הקוד הנ ל נקרא קוד הופמן, כאשר צריך לבנות את המילון (העץ) מלמטה למעלה. 28

5.1.1 מימוש נעזרת בערימת מינימום, אותה נבנה מתוך האותיות המסודרות לפי השכיחויות שלהן, כאשר כל אות בערמה נייצג כעץ בעל איבר בודד. במשך האלגוריתם מוכנסים לתוכו עצים בהם יש יותר מאות אחת, ויחס הסדר מורכב לפי חיבור ההתפלגויות של האותיות בו, ולכן נוכל לכתוב את הקוד: אלגוריתם 11 קוד הופמן Huffman(C):- n c Q Build_min_heap(C) for i = 1 to n-1 allocate a new node Z left(z) extract_min(q) right(z) extract_min(q) key(z) key(left(z)) + key(right(z)) insert(q,z) return extract_min(q) כאשר הסיבוכיות של האלגוריתם הנ ל היא n. log n 5.1.2 יעילות קוד הופמן טענה 5.2 נתון C (אוסף אותיות עם שכיחויות) ונניח ש T הוא עץ המתאר קוד חסר תחיליות עבור C שנוצר מקידוד הופמן. W הוא עץ אחר המתאר קוד חסר תחיליות כלשהו (לאו דווקא של הופמן) עבור C. נרצה להוכיח כי קוד הופמן הוא הכי יעיל, כלומר.L(T ) L(W ) הוכחה: נניח ש ( f(b.f(a) < טענה א : אם W הוא קוד ללא תחיליות אופטימלי, אזי לכל,a b אם f(b) f(a) < אז מתקיים כי l(b).l(a) הוכחה: נניח בשלילה כי התנאי לא מתקיים, ולכן קיימים,a b כך ש ( f(b f(a) < ו l(b).l(a) < נייצר עץ אחר,W שבו מוחלפים,a, b ולכן L(W ) = f(c)l(c) + f(a)l(a) + f(b)l(b) c a,b L(W ) = c ab f(c)l(c) + f(a)l(b) + f(b)l(a) L(W ) L(W ) = f(a)l(b) + f(b)l(a) f(a)l(a) f(b)l(b) = <0 >0 {}}{{}}{ (f(a) f(b)) (l(b) l(a)) < 0 הגענו לסתירה לאופטימליות של W, ולכן טענת העזר מתקיימת. 29

טענה ב : עבור א ב C, כאשר 2 C, קיים עץ אופטמילי W כך ששתי האותיות עם השכיחות הנמוכה ביותר, מופיעות ברמה התחתונה בעץ ש אחיות (יש להן אותו הורה). הוכחה: נניח ש x היא האות עם השכיחות המינימלית, ולכן l(x) הכי ארוך (מטענה א ), כלומר x ברמה התחתונה בעץ. ל x יש אחות y, שכן W אופטמלי ולכן חייב להיות עץ מלא (אחרת יש קודקוד עם דרגה 1, ונוכל לקצר אותו ולקבל עץ עם עלות טובה יותר). אם y אינה האות עם השכיחות המינימלית הבא אחרי, אזי z, שהיא האותר הבאה אחרי x, גם היא ברמה התחתונה בעץ (מטענה א ) ולכן נולכ להחליף את y ו z ונקבל W עם אותה עלות. כעת נוכל להשתמש באינגוקציה כדי להוכיח את המשפט. במקרה = 2 C המצב ברור. נניח שהופמן הוא קוד חסר תחילות אופטמלי עבור n, ונוכיח עבור + 1 n. נניח בשלילה שיש לנו קוד יותר טוב מהופמן, ונסמן ב T את קוד הופמן עבור 1+n אותיות, וב W את הקוד האופטימלי עבור אותן אותיות, ולכן ) L(T.L(W ) < נסמן ב T, בתור העץ הנוצר בעזרת קוד הופעמן על C, כאשר C הוא בעל אותן אותיות ושכיחויות ב C חוץ מ y,x שהוחלפו ב z שקיבלה f(y).f(z) = f(x) + מהנחת האינדוקציה ) L(W.L(T ) L(T ) = c C = c x,y f(c)l(c) = = L(T ) + f(z) L(T ) = L(T ) + f(z) L(W ) = L(W ) + f(z) L(T ) L(W ) L(T ) + f(z) L(W ) + f(z) L(T ) L(W ) c x,y f(c)l(c) + f(x) f(z) L T (z)+1 {}}{ L T (z)+1 {}}{ l T (x) +f(y) l T (y) f(z) {}}{{}}{ f(c)l(c) + (f(x) + f(y)) L T (z) + f(x) + f(y) בסתירה לכך ש W הוא הקוד היותר טוב (ממש) מהופמן. דוגמא: נסתכל על טבלת ההתפלגויות של סוסים במרוצי סוסים לפי המקום הראשון, השני, השלישי ואחר. 6 אקראיות וסיבוכיות אקראית 6.1 מיון מהיר אקראי נזכר כי האלגוריתם עובד ע י בחירת איבר ציר כלשהו במערך, ולאחר מכאן לחלק את המערך כך שכל האיברים הקטנים מהציר נמצאים לפניו במערך, וכל האיברים הגדול מהציר 30

נמצאים אחריו במערך, ולכן מכיוון שהסיבוכיות של החלוקה היא Θ(n) אז הסיבוכיות הכללית היא T (n) = T (m 1) + T (n m) + Θ(n) כאשר m הוא המיקום הסופי של איבר הציר. ראינו כי כאשר m תמיד נופל בקצוות אז נקבל כי ) 2 T (n) = Θ(n (המקרה הגרוע ביותר), וכאשר m נופל תמיד באמצע אז נקבל (n T (n) = Θ n) log (המקרה הטוב ביותר). בתרגיל 3 ראינו כי ) 2,Ω (n log n) = T (n) = O(n וציינו כי בממוצע על פני כל הקלטים, ניתן להוכיח כי (n Θ(n log (אבל לא נוכיח עובדה זו בקורס זה), ולכן נרצה להשתמש בעובדה זו, כדי שכל קלט שנקבל יתנהג כאילו היה אקראי. במקום לבחור את הציר להיות האיבר הימני ביותר, מגרילים ערך כלשהו במערל בהסתברות אחידה. אבל איך נמצא זמן ריצה של אלגוריתם זה? נסמן במשתנה מקרי את זמן הריצה. מרחב המדגם איפה נפלה החלוקהבכל אכל אחד מצעדי האלגוריתם:.).., 3 (m 1, m 2, m המגדירה את פעולת האלגוריתם באופן אחיד. E(T (n)) = n m=1 1 n תוחלת זמן הריצה: Θ(n) [E(T (m 1)) + E (T (n m))] + טענה 6.1 (כללית) נניח ש,X Y שני משתנים מקריים, אז נגדיר E(X Y = y) = x X pr (X = x Y = y) ולכן E(X) = y E(X Y = y)p r(y = y) הוכחה: (כתרגיל) נשתמש בטענה זו, עבור (n) X = T ו M Y = (מיקום החלוקה) ולכן מלינאריות התוחלת נקבל כי n E(T (n)) = E [T (m 1) + T (n m) + Θ(n)] 1 n m=1 E (T (n)) = 2 n n 1 m=0 n 1 2 E (T (m)) + C 2 n E (T (n)) 2 n n m=0 U(n) = 2 n U(1) = C n 1 m=0 E (T (m)) + Θ (n) n 1 m=0 U(m) + C n E (T (m)) + C 1 n ולכן ונגדיר 31

כאשר עבור C = C 1, C 2 נקבל כי (n),u C2 (n) E(T (n)) U C1 ונשים לב כי זאת משוואת רקורסיה שלמה עם היסטוריה מלאה. איך פותרים משוואה שכזו? (1) nu(n) = 2 (2) (n + 1) U(n + 1) = 2 n 1 m=0 U(m) + Cn 2 n U(m) + C (n + 1) 2 m=0 (2) (1) (n + 1) U (n + 1) nu(n) = 2U(n) + C (2n + 1) (צריך להשלים את המעברים לעיל) 1+2n C ולכן החסם העליון הוא n+1 נפתור בשיטת האיטרציות, ונשים לב כי C 2C U(n + 1) n + 2 U(n) + 2C n + 1 n + 2 n + 1 n + 2 n + 1. n + 2 2 U(n + 1) (n + 2) 2c ( n + 1 U(n 1) + 2C n ( n + 1 n U. ) + 2C ( n U(n 2) + 2C n 1 ) ) + 2C + 2C U(1) + n + 2 2C +... + n + 2 3 n 2C + n + 2 n + 1 2C + n + 2 n + 2 2C Harmonic Serie {}}{ n+2 1 i i=2 }{{} 1 + 1 <1 {}}{ 1 2 + 1 3 }{{} 2 +.Θ(log n) = H(n) = n 1 i=1 1 i טענה 6.2 הוכחה: נוכיח רק עבור 1 m n = 2 ולכן <4 1 4 =1 {}}{ 1 4 + 1 5 + 1 6 + 1 7 } {{ } 3 +... 2 k 1 איברים ונסמן את הסכום של הבלוק ה k ב S k ולכן הבלוק ה k יתחיל ב ויהיו בו 2 k 1 S כי 2 k איברים כול גדולים צ ולכן 2 k+1 k ובנוסך 1 2 S k 1 1 2 log (n + 1) = m 2 H(n) m = log (n + 1) ולכן בסה כ קיבלנו כי n),u(n 1 ) = Θ (n log ולכן n) E(T (n)) = Θ (n log היא הסיבוכיות האקראית של מיון מהיר האקראי. 32

משפט 6.3 (מרקוב) בהינתן משתנה מקרי לא שליף X, אם נסמן E(X) = µ אז pr(x. λµ) 1 λ הוכחה: µ = E(x) = pr(x = x)x = pr (X = x) x + pr (X = x) x x X x<λµ x λµ pr (X = x) λµ 1 λ x λµ pr (X λµ) דדד 7 טבלאות גיבוב Table Hash נרצה להגדיר מילון כ ADT, ולכן נרצה להגדיר טיפוס נתונים היאפשר חיפוש הכנסה ומחיקה יעיל של צמדים של מפתח ומידע. 1. חיפוש יקח (1)O. דרישות: 2. אם N הוא מספר המפתחות, ו S הוא המקום בזיכרון לאכסון המפתחות, אז נרצה שיתקיים O(N).S = 7.1 כיוונים למימוש הפתרון 7.1.1 שלב ראשון: גיבוב רנדומלי נתון מערך בגודל m. נכניס כל מפתח למקום אקראי במערך ואם יש התנגשות, ניצור רשימה מקושרת. נרצה לחשב את תוחלת אורך הרשימה שבה { יושב מפתח j. לכל מפתח i בקלט נגדיר 1 i and j in the same position = ij Z ולכן מספר האיברים ברשימה משתנה מקרי 0 Otherwise של j הוא i Z ij ולכן ( ) E Z ij = E (Z ij ) i i E(Z ij ) = pr(z ij = 1) 1 + pr (Z ij = 0) 0 = 1 ( ) m E Z ij = N m i 33

ולכן, אם רוצים שכל שרשרת תהיה קצרה, חייבים לבחור (N) m. = Ω.α = N m = נקבל במקרה של גיבוב אקראי ש ( O(1 m = Θ (N) ואם נבחר α = N m נקרא פקטור העומס של המערך. הגדרה 7.1 7.1.2 שלב שני: פונקציית גיבוב על אף שהכנסה אקראית של האיברים למערכת\ מאפשרת למלא אותו בצורה אחידה ולכן ממלאת את הדרישה למקום, עוד אין לנו דרך לאחזר את הנתונים מהמערך בהינתן מפתח. על כן, נרצה להגדיר פונקציה המקבלת מפתח כלשהו, ומאחזרת מיקום בפיזור אחיד על המערך. איור 11: פונקציית גיבוב שיטת החלוקה:.h(k) = k mod m מצד אחד פונקציה זו מספקת את התנאי, מצד שני היא מאוד תלויה בקלט של המפתחות, כי עבור הרבה תתי קלטים יתקיים כי = ) 1 h(k,h(k 2 ), k 1 k 2 למשל עבור = 3 m אז כל המפתחות המסתיימים באותן 3 ספרות, או כל המפתחות שהם מהצורה k. m n שיטת ההכפלה: Ak ) h A (k) = m (Ak כאשר A מספר ממשי קבוע, ובאופן ספציפי +1 5 = A, כלומר יחס הזהב. גם שיטה זו תלויה בקלט הנשלח אליה, ולמשל כל 2 המפתחות מהצרה A 1 nk הנשלחים אל אפס. טענה 7.2 אם U > mn אזי לכל פונקציה m} h : U {1... יש אוף של N מפתחות ש h שולחת לאותו מקום בטבלה. הוכחה: לפי עקרון שובך היונים קיים מספר m אליו הפונקציה h שולחת + 1 N מפתחות. דרישה: נרצה שיטת גיבוב שתעבוד לכל קלט (מבלי להניח הנחות על הקלט). לשם כך, נשתמש בשיטת גיבוב הסתברותית שתבטיח יעילות (בהסתברות גבוהה) לכל קלט. 34

7.2 משפחה אוניברסלית של פונקציות גיבוב הגדרה m}} 7.3 H = {h : U {1... תקרא המשפחה האוניברסלית של פונקציית גיבוב,.pr h (h(x) = h(y)) 1 m אם מתקיים שלכל x, y U כאשר x y אז טענה 7.4 אם H משפחה אוניברסלית שכזו, אז אם K הוא אורך הרשימה (המחוברת לכל.E (K) 1 + N m תא במערך) אז הוכחה: כמקדם, נגדיר משתנים מקריים המציינים לכל,x y U מתקיים { 1 h(x) = h(y) C xy = 0 h(x) h(y) ( ) E(K x ) = E C xy = y y 1 + y x E (C xy ) = 1 + y x E (C xy ) E (C xy = 1) 1 + N 1 m 1 + N m ולכן Z p = {0,..., p 1} Z p = {1,..., p 1} h a,b (k) = ((a k + b) mod p) mod m K m = { h a,b : a Z p, b Z p } דוגמא: יהי p ראשוני U m ונסמן: ונגדיר עבור :b Z p, a Z p ולכן בשביל להגדיר פונקציית גיבוב, נדרש רק להגריל,a b מתוך הקבוצות הרלוונטיות. (צריך להשלים את השיעור של ה 23.05 על פוקנציות גיבוב) 8 גרפים גרף הוא זוג (E G =,V) כאשר V הוא אוסף הקודקודים ו E הוא אוסף הצלעות, שיכול להיות מכוון או לא מכוון (כלומר כל אפשר לנוע כל צלע בשני כיוונים). 8.1 ייצוג של גרפים ייצוג בעזרת רשימת שכנויות כלומר לכל קודקוד נשמר את רשימת הקודקודים המחוברים אליו ישירות באמצעות צלע: {v 1 } v 2... v k {v 2 }.... 35

ולכן הסיבוכיות מקום של הגרף היא ( E O. V ) + ייצוג בעזרת מטריצת שכנויות כלומר מטריצה בגודל V V ( כאשר בתא ה j,i יש 1 אם קיימת צלע בין v i ל v. j סיבוכיות המקום שלה הוא (2 V O. מתי כדי להשתמש בכל ייצוג? ( 1. אם (2 V E, = Θ כלומר בגרף צפוף, נשתמש בבד כ במטריצת שכנויות. 2. אם ( V ) E, = O כלומר גרף צלול, אז נשתמש ברשימת שכנויות. 8.2 אלגוריתמים לסריקת גרפים נרצה אלגוריתמים למציאת: 1. המסלול הכי קצר בין שתי נקודות. 2. מציאת מסלול ליציאה מתוך מבוך. 8.3 חיפוש לרוחב Search BFS Breadth First נעבור על הגרף כך שבשלב הראשון, נעבור על כל השכנים מדרגה ראשונה של קודקוד ההתחלה, בשלב השני נעבור על השכנים מדרגה שנייה וכן הלאה. BFS BFS(G,S):- forall v in V do dist(v) = dist(s) 0 previous(s) = nil Q Build_Queue({s}) while Q not empty u dequeue(q) forall w in (u, w) E if dist(w) == enqueue(q, w) dist(w) = dist(u)+1 previous(w) = u אלגוריתם 12 36

איור 12: גרף לדוגמא נגדיר תור מדרגתי עם ערך d להיות תור שבו כל ערכי dist לכל האברים בו מקיימים כך שאם w הוא האיבר הראשון בתור, אז dist(w) = d וכל שאר האיברים בתור הם בעלי ערך dist השווה ל d עד שהוא עובר ל 1 + d ונשאר כך. הגדרה 8.1 נגדיר (w δ,s) בתור המרחק האמיתי בגרף (ארוך המסלול הקצר ביותר בצלעות). טענה 8.2 לאחר הוצאת k קודקודים: 1. קיים d עבורו התור מדרגתי עם ערך d. 2. כמוכן לכל הקודקודים שהוצאנו מהתור או שעדיין בתור, ערך dist נכון, כלומר שווה ל ( w.δ (s, 3. כך הקודקודים שעוד לא נכנסו לתור = dist וכן δ עבורם יהיה 1 + d. הוכחה: נוכיח באינדוקציה בסיס: עבור = 1 :k.1 מתקיימת עם ערך = 1.d 2. עבור s וכל שכניוי dist באמת מכיל את δ. 3. כל השאר באמת = dist אחרי הוצאת S וגם δ שלהם 2 שכן אינם שכנים של S (קודקוד ההתחלה). 37

שלב האינדוקציה: נניח כי הטענות מתקיימות עבור k ונוכיח עבור + 1 k. טענה א : כל הקודקודים שהכנסנו הם עם + 1 d,dist = כלומר או שהתור נראה כך: או שהוא נראה כך: d,..., d, d + 1,..., d + 1 d + 1,..., d + 1 ובכל מקרה מדרגתי. טענה ב : נכון לכל הקודקודים שיצאו מקודם מהנחת האינדוקציה, וכן לקודקוד שהוצאנו בשלב ה 1 + k מהנחת האינדוקציה, וכן לכל הקודקודים שהיו בתור מקודם, לגבי הקודקודים החדשים שנכנסו באיטרציה ה 1 + k לתור עם = dist + 1 d. ידוע מ ג שה δ שלהם גדול (או שווה) מ 1 + d, אבל בגלל שהם שכנים של הקודקוד שכרגע הוצאנו שידוע לגבי ש δשלו שווה ל dist שלו השווה ל d מטענה ב ולכן קיים מסלול שלהם באורך + 1 d ולכ ה δ שהלם בדיוק + 1 d. טענה ג : לגבי כל הקודקודים שעוד לא נכנסו לתור, = dist (ברור), וצ ל שה δ שלהם גדול (או שווה) ל 1 + d (הערך המדרגתי החדש). אם הערך המדרגתי לא השתנה, אזי הטענה נכונה מטענה ג. אם הערך המדרגתי כן השתנה, אזי + 1 d d., ונרצה להראות שה δ שלהם 2 + d ויודעים מטענה ג ש 1 + d, אבל לא יכול להיות + 1 d, שכן אם כן, יש קודקוד שכן w כך ש δ d, = ומטענה ג w כבר עבר בתור או נמצא בתור כרגע. לא ייתכן כי הוא עבור בתור, וגם לא ייתכן שהוא נמצא גרע בתור. כל קודקוד שכבר עבר בתור כבר הכניס את כל השכנים שלו, ולכן לא יכול להיות שהקודקוד v כבר עבר בתור. סיבוכיות: לכל היותר כל קודקוד נכנס פעם אחת לתור ולכן O(Neighbors) ולכן הסיבוכיות היא ( E ).O ( V ) + O O (M)+ v V 8.3.1 אלגוריתם Dijkstra ( דייקסטרה ) מציאת משקלים קצרים בגרף ממושקל, ונגדיר (w l(u, בתור אורך הצלע. Dijkstra Dijkstra(G,S):- u V, dist(u), previous(u) nil dist(s)=0 Q build_min_heap(v) sorted by dist while Q not empty v extract_min(q) w, (u, w) E if dist(w) > dist(u)+l(u,w) dist(w) dist(u) + l(u,w) prev(w) = u decrease_key(q,w) אלגוריתם 13 38

טענה 8.3 (נכונות) R היא קבוצת כל הקודקודים שיצאו מהערמה..1 קיים ערך d כך ש d dist(w) כאשר w R ולכל קודקוד v R מתקיים.dist(v) d 2. לכל הקודקודים ב R והשכנים שלהם, ערך dist מכיל את אורך המסלול הנכון ב R. סיבוכיות: ) V O( V + E log הערה 8.4 האלגוריתמים של Bellman-Ford, Dikstra, BFS לא עובדים על גרפים עם משקולות שליליים, כי גם מסלול שמתחיל ארוך יותר, יכול להסתיים בצלעות שליליות אשר יקזזו את האורך ההתחלתי. 8.4 חיפוש לעומק DFS Depth First Search בשונה מ S,BF אלגוריתם זה מתקדם כמה שיותר רמות עד אשר אין לו עוד לאן להמשיך, ועל מנת לא לחזור על אותם קודקודים נסמן אותם. האלגוריתם מבוסס על :Explore visit(v)=1 previsit(v) ω, (v, ω) E if visited(ω)=0 then explore(ω) postvisit(v) אלגוריתם 14 אלגוריתם זה יגיע לכל הקודקודים שיש אלהם מסלול מ v. נניח שיש קודקוד z כך ש z.v v 1 v 2... v k ולכן נבנה את אלגוריתם DF S ע י DFS Explore Explore(G, v):- DFS(G):- v V visted(v)=0 v V if visited(v)==0 then explore(v) אלגוריתם 15 והסיבוכיו של האלגוריתם היא E ).O ( V + הגדרה 8.5 חורשת DF S כל העצים (המסלולים) המתקבלים תוך כדי החיפוש. הגדרה 8.6 רכיב קשירות בגרף לא מכוון קבוצה מקסימלית של קודקודים כך שיש מסלול בין כל שני קודקודים בתוכה. 39

נרצה למספר את רכיבי הקשירות, ונסמן גודל זה ב um,ccn ובנוסף נרצה לכתוב לכל קודקוד מי רכיב הקשירות שלו. האגוריתם הבא מוצא את רכיבי הקשירות בגרף לא מכוון: CC הגדרה 8.7 בגרף מכוון, נגדיר רכיב קשירות חזק ע י קבוצה מקסימלית של קודקודים בגרך מכוון כל שלכל שני קודקודים,x y בקבוצה, יש מסלול מ x ל y וגם מ y ל x. 8.4.1 מיון טופולוגי סדר על הקודקדוים כל שלכל צלע v,u) (v E מופיע אחרי u. מסקנה 8.8 אם יש מעגל אזי אין מיון טופולוגי (גרף ללא מעגלים מכוון נקרא גם Directed (Acyclic Graph - DAG הוכחה: נניח שיש מעגל ויש מיון טופולוגי, אזי v 0 v 1... v k v 0 ונניח ש v i הוא הקודקוד ה I במיון הטופולוגי. כל הקודקודים מופיעיםאחריו במיון הטופולוגי כולל 1 j v, אבל יש צלע במעגל מ 1 j v ל v. j 8.4.2 אלגוריתם למיון טופולוגי של DAG נוסיף לאלגוריתם DF S שדה של clock ובנוסף נשמור לכל קודקוד את ערך ה clock כאשר נכנס אליו לראשונה ויצאנו ממנוו לאחרונה, כלומר pre(v) clock clock++] אלגוריתם 16 CC(G):- ccnum = 0 DFS(G) ccn um ב S DF נוסיף + + לכל קריאה ל Explore ב S DF previsit(v):- postvisit(v):- post(v) clock clock++ אלגוריתם 17 כניסה ויציאה מקודקוד ב S DF לכל שני קודקודים,u v הצלע,u) (v E יכולה להיות: 1. צלעות בעץ 2. צלעות קדימה 3. צלעות אחורה 40

.4 סוג.Cross Edge על כן נוכל להגדיר לכל אינטרוול מה סוג הצלע: 1. אם interval(v) interval(u) < (או להפך) אז זהו מקרה 4..2 אם interval(v) interval(u) אז זהו מקרה.3.3 אם interval(u) interval(v) אז זהו מקרה 1 או.2 טענה 8.9 אם נריץ את DF S אז ה post בסדר יורד נותן מיון טופולוגי, ולאחר מכאן נמיין בעזרת מיון ספירה. הוכחה: צ ל שלכל צלע (v,u) מתקיים כי post(v).post(u) > נניח שהדענו ב S DF ל u לפני v, אז אנחנו במקרה interval(u) interval(v) ואכן.post(v) < post(u) נניח הגענו ל v לפני u, אז בגלל שזה DAG אז אנו במקרה interval(u).interval(v) < 8.4.3 אלגוריתם SCC טענה 8.10 גרף רכיבי הקשירות הוא.DAG טענה 8.11 אם נרציץ DF S על v, אז post המקסימלי הוא של קודקוד ברכיב קשירות שהוא מקור של גרף רכיבי הקשירות. טענה 8.12 אם יש צלע מ SCC לצלע C ל SCC ל C אזי ה post המקסימלי בתוך C גדול מה post המקסימלי ב C. G R הוא הגרף שבו כל הצלעות של G הפוכות. הגדרה 8.13 אלגוריתם: הרץ DF S על G. R נמיין את הקודקודים לפי סדר יורד של post בעזרת מיון ספירה ואז נקרא ל ( G ) CC שקורא לקודקודים לפי הסדר הזה. 9 עצים פורשים מינימליים Trees) (Minimum Spanning נסתכל על גרף לא מכוון E) G = (V, ו W : E R t בעלות מינמלית. הגדרה 9.1 עץ הוא גרף קשיר ללא מעגלים, ונגיד שקבוצת זוגות } V T = {(u, v), u, v הן עץ פורש ל G אם T E ו T עץ שקודקודיו הם V. הגדרה 9.2 עץ פורש T יקרא עץ פורש מינימלי אם לכל T עץ פורש מתקיים = ) T) ω. ω (e) ω (T ) טענה 9.3 בעץ על n קודקודים יש 1 n צלעות. 41

הוכחה: נתחיל מ n הקודקודים שהם n רכיבי קשירות, ונסוף בכל צעד מהעץ. כל צלע כזו מפחית את מספר רכיבי הקשירות באחד, שכל לא יכול להיות בתוך רכיב קשירות קיים (כי תיצור מעגל). טענה 9.4 (הפוכה) אם בגרף קשיר בין n קודקודים יש 1 n צלעות, אזי הוא עץ. הוכחה: נתון שהעץ קשיר, אז יתכן שאינו עץ כך שאם יש בו מעגל, נוריד צלעות עד שיהפוך לקשיר ללא מעגלים, כלומר לעץ. מהטענה הקודמת יש בעץ 1 n צלעות כלומר לא הורדנו אף צלע. 9.1 אלגוריתם קרוסקל ל MST נתחיל מקבוצה ריקה של צלעות X, ונמיין את הצלעות של העץ לפי משקלן בסדר עולה, ולכל צלע בעץ, נוסיף אותה לקבוצה X אלא אם כן סוגרת מעגל (ואם כך פשוט נזרוק אותה). הערה 9.5 אלגוריתם זה הוא אלגוריתם חמדן,(Greedy) מכיוון שבכל שלב הוא מנסה לקחת את הצלע הטובה ביותר עבור שלב זה בלבד ואינו מנסה להסתכל קדימה, או לחזור אחורה בשביל למצוא את הפתרון האופטימלי, וזו בתחת ההנחה כי אסטרטגיה זו תביא לפתרון טוב, ובמקרה זה לפתרון הטוב ביותר, כלומר לעץ הפורש המינימלי. הוכחה: (נכונות) נראה באינדוקציה שבכל שלב x מקיים שקיים T שהוא M ST כך ש.X T בשביל להוכיח את הנכונות, נעזר בתכונות החתך. חתך: חתך הוא חלוקה של הקודקודים לשתי קבוצות זרות, והצלעות בחתך הן הצלעות המקשרות בין הקודקדים של שתי הקבוצות. תכונת החתך: נניח ש E X כך ש X T כאשר T הוא.MST אם e צלע בחתך (חתך בין רכיבי הקשירות שנמצאו עד כה), ואף צלע ב X אינה צלע בחתך, ו e מינמלית (מבחינת המשקל) בחתך אזי {e} X קיים T שהוא MST כך ש T.X {e} הוכחת תכונת החתך: נתון Vל X 1, V 2 אין אף צלע בחתך, ונתון X T ו.MST T הוספנו ל X את {e} ורוצים למצוא T MST כך ש T.x {e} נניח ש { e } נמצא ב T, אזי נבחר את T להיות Tוסיימנו. נניח ש { e } לא נמצא ב,T ו e צלע בחתך, ונניח כי ) 2 e = (v 1, v כאשר 1 v T היו קשורים ב v 1, v 2 (כי e יש מעגל. נסתכל על הצלע T וב { e } V 1, v 2 V 2 והם משני צידי החתך), ולפי בחירתינו ) e) (e ω (e) ω מינימלית בחתך) ונבנה עכשיו את T כך: נוסיף ל T את e כך ש { {e.t {e} \ ב { {e T = T {e} \ יש 1 n צלעות, והוא קשיר כי הורדנו צלע } e} במעגל ולכן T עץ פורש. ω (T ) = ω (T ) + ω (e) ω (e ) מכיוון ש ( (e ω (e) < ω לא יתכן שכן אז ) (T ω (T ) < ω בסתירה ל MST T ולכן ) (e ω (e) = ω ולכן T באותו משקל כמו T ולכן הוא.MST 42

עתה בחזרה להוכחת הנכונות, צעד האינגו ציה הוא: אחרי k צלעות, X E ומניחים ש X T ו { e } X (כאשר e צלע מינימלית שלא סוגרת מעגל). צ ל T X {e } כאשר T הוא.MST נניח ש { e } שקרוסקל מוסיך בשלב ה 1 + k מחברת בין רכיב קשירות G 1 ל G 2 (לא יכול להיות באותו רכיב קשירות כי אז יווצר מעגל), ואז נבחר את החתך להיות בין G 1 וכל השאר, ולכן תכונת החתך מתקיימת ולכן T X. e} } מדוע e מינימלית בחתך? כי היא מינימלית בין כל הצלעות הנותרות, ובפרט עבור הצלעות שבחתך. עתה אחרי הוכחת הנכונות, נותרה עוד הבעיה שמציאת מעגל בגרף נתון היא (E) O, אבל אנו היינו רוצים לעשות זאת ב ( 1 ) O, ולשם כך נעבוד עם מבנה נתונים חדש,.Union-Find 9.2 אלגוריתם Union-Find נרצה מבנה נתונים לטיפול בקבוצות זרות ושהמבנה יתמוך בפעולות: Makeset(x) find(x) מציאת הנציג x. איחוד הקבוצות של Union(x) מבנה הנתונים הנ ל בנוי על עצים המיצגים קבוצות, כאשר שורש העץ הוא הנציג של הקבוצה, ונסמן (x) π בתור המצביע של קודקוד x להורה שלו בעץ. π(x) x rank(x) 0 אלגוריתם 18 Find Makeset Makeset(x):- Find(x):- while x π (x) do x π (x) return x אלגוריתם 19 43

Union Union(x, y):- r x find(x) r y find(y) if r x == r y return if rank(r x ) > rank(r y ) then אלגוריתם 20 else π (r y ) r x π (r x ) r y if rank(r x ) == rank (r y ) then rank(r y ) rank(r y ) + 1 טענה 9.6 לקודקוד עם דרגה k, מספר הקדוקדוים בתת העץ שלו (כולל הוא עצמו) גדולה או שווה ל 2. k הוכחה: בססי האינדו ציה בו = 0 k ברור. נניח שנכון עבור דרגה 1 k ונתבונן בקודקוד עם דרגה k, הדרגה עלתה ל k על ידי כך שאוחדו שני קודקודים (או שתי קבוצות) שניצגיהם קודקודים מדרגת = 1 k. לפי הנחת האינדוקציה, בכל עץ כזה יש לפחות 1 k 2 קודקודים. ולכן מספר הקודקודים 2 k ומתקיים.k log (# vertices) log n kruskal(g, w):- v V, makeset (v) QSort(E by w) X (u, v) E if f ind(v) f ind(u) then X X {(u, v)}, Union(u, v) אלגוריתם 21 קרוסקל אבל ניתן לייעל אלגוריתם זה אף יותר ע י שימוש ב Compressions P, ath ובשביל לחשב את היעילות של אלגוריתם זה, צריך להיעזר ב Complexity,Amortized כלומר חישוב העלות של מספר רב של פעולות לאורך זמן. 10 על המבחן הסופי אין דף נסחאות! 10.1 החומר למבחן יהיה תרגול חזרה ביום חמישי או שישי לפני המבחן 44

החומר למבחן כל התרגילים (כולל מספר 11), כל התרגולים וכל מה שהיה בשיעור. להיעזר מהסיכומים של סאשה, יש שם הרבה טעויות בפרקים האחרונים. להיעזר בספר שמקושר מהאתר (אחלה ספר). 10.2 מבנה המבחן המבנה יהיה כמו של מבחן האמצע רק יותר 4 שאלות ראשונה מתוך 5 של שאלות קטנות ו קלות 2 שאלות מתוך 3 של שאלות גדולות ובעלות מספר סעיפים (המלצה לפתור את הסעיפים לפי הסדר כי הם בנויים אחד על השני והולכים מהקל לקשה) חלק II תרגולים 11 תרגול 1 01.03.2010 סימונים אסימפטוטים תמיד כשנדבר על פונקציות המתארות זמן ריצה, מדובר בפונקציות חיוביות + R,f g : N. הגדרה 11.1 O גדול נגדיר ש ( f(nהיא (( O(g(nאם קיימים קבועים <,n C 0 כך ש. n > n 0 ( f(nלכל C g(n) אם = 10 19 f(n) אז מתקיים O(n) f(n) = כי עבור = 1 0 c = 10 19, n מתקיים. 0 10 19 10 19 n לדוגמא: c = 2, n 0 מתקיים אם f(n) = 2n אזי מתקיים O(n) f(n) = כי עבור = 1. 0 2n 2n אם f(n) = n 2 אזי ) 2 f(n) O(n כי לכל > 0 c מתקיים שאם n > c אזי. n 2 > c n הגדרה 11.2 Ω נגדיר ש ( f(n היא Ω(g(n)) אם קיימים קבועים <,C n 0 0 כך ש.n לכל n 0 f(n) C g(n) אם = 10 19 f(n) אזי מתקיים Ω(1) f(n) = כאשר = 1 0 c = 1, n ואז 19 10. 1 0 לדוגמא: n 0 = ו 1 c = 1 2 אם f(n) = n אזי מתקיים Ω(2n) f(n) = וגם Ω(n) 2n = עבור (עבור שני המקרים). אם f(n) = n אזי ) 2 f(n) Ω(n באופן דומה ל O. הגדרה 11.3 Θ אם f(n) היא גם O(g(n)) וגם Ω(g(n)) אז נגדיר שהיא.Θ(g(n)) 45

הגדרה lim n f(n) = L 11.4 אם ם לכל < ɛ R 0 קיים n 0 N כך שלכל n > n 0 מתקיים f(n) L < ɛ. הערה 11.5 לא כל פונקציה/סדרה מתכנסת כאשר n (למשל.( f(n) = sin n הערה 11.6 מכיוון שהפונקציות איתן אנו עובדים הן תמיד חיוביות, ניתן להשמיט את הערך המוחלט. o קטן נגדיר ש ( f(n היא o(g(n)) (זניחה ביחס ל ( g(n ), 11.7 הגדרה. lim f(n) אם = 0 n g(n) 11.0.1 כללים לשימוש בסימונים האסימפטוטים כל הסימונים האסימפטוטים הם טרנסזיטיביים. לדוגמא: = g(n) f(n) = O(g(n)),. O(h(n)) f(n) = O(h(n)) הסימונים האסימפטוטים מתנהגים כמו (אך לא ממש! זוהי רק אינטואיציה): f(n) = O(g(n)) f(n) g(n) f(n) = Ω(g(n)) f(n) g(n) f(n) = Θ(g(n)) f(n) g(n) f(n) = o(g(n)) f(n) < g(n) f(n) = o(g(n)) f(n) = O(g(n)) הכפלה בקבוע לא משפיע על הסימון האסימפטוטי. למשל Θ(g(n)) f(n) =. f(n) = Θ(c g(n)) ניתן להתעלם מפונקציות זניחות, כלומר: o(h(n)) f(n) = Θ(g(n)+h(n)), g(n) =. f(n) = Θ(h(n)) הוכחה: מכיוון ש (( Θ(g(n)+h(n f(n) = אזי קיימים קבועים > 0 2 c 1, c ו N n 1 כך שמתקיים: n > n!, c 1 (g(n) + h(n)) f(n) c 2 (g(n) + h(n)) ומכיוון ש ( g(n הוא אי שלילי אז מתקיים גם: n > n 1, c 1 h(n) f(n) c 2 (g(n) + h(n)) מכיוון ש (( o(h(n g(n) = אז קיים קבוע n 2 N כך שמתקיים: n > n 2, 0 g(n) h(n) 1 2 ולכן אם ניקח } 2 n > n 0 = max{n 1, n נדרש להשלים את ההוכחה מהמצגת! 46

גידול מעריכי (אקספוננציאלי) גדול מגידול פולינומי, או באופן פורמלי: = f(n). c > קבועים כלשהם ו 1 הם ו d c כאשר n d, g(n) = c n f(n) = o(g(n)) הוכחה: בשביל להוכיח את הטענה, נעזר בלמה הבאה: למה 11.8 קיימים קבועים > 0 2 c 1, c כך שמתקיים ) c1.c 2 log(n) = o(n הוכחה: באמצעות כלל לופיטל: c 2 log(n) lim n n c1 L Hopital {}}{ (c 2 log(n)) = lim n (n c1 ) c 2 n ln(2) = lim n c 1 n c1 1 = 0 הוכחה: (המשך הוכחת הטענה העיקרית) נשים לב כי n d = c log c (n) d = c d log(c) log(n).c c0 log(n) = c o(n) ולכן c 0 log(n) = o(n) ולכן מהלמה נובע כי c 0 = d log(c) יהי השלמת ההוכחה ע י הוכחת הטענה כי ) n c c0 log(n) = o(c מושארת כתרגיל. גידול פולינומי גדול מגידול לוגריתמי, או באופן פורמלי: = g(n) f(n) = (log(n)) c, o(g(n)) n d f(n) = כאשר > 0 d c, קבועים. הוכחה: מהלמה הקודמת נבוע כי ) c log(n) = o(n d ולכן ניתן להוכיח (תרגיל) כי. (log(n)) c = o(n d ) 12 תרגול 2 09.03.2010 אלגורתמי מיון קיימים שני סוגים עקריים של מיונים: מיוני השוואה ומיונים אחרים. מיוני השוואה שכבר ראינו עד כה: מיון בועות, מיזוג וכו. 12.0.2 מיון ספירה Sort Counting כאשר ידוע טווח הערכים של כל איבר במערך, נוכל למיין את המערך בסיבוכיות לינארית. הרעיון: ניצור מערך שכיחויות ניצור מערך חדש בגודל טווח הקלט, ובכל תא במערך נציין את מספר המופעים של הערך, ומערך זה מציין באופן חח ע את המערך הממויין. ממערך זה, נוכל ליצור מערך באותו הגודל הסוכם את הגדלים שבמערך השכיחויות (אם המערך היה,3,3 2 אז המערך החדש הוא,3).,6 8 המשמעות של המספר בכל מיקום במערך, הוא האינדקס הכי גבוה בו מופיע הערך (לפי המיקום במערך). בשימוש במערך העזר הזה ניתן לעבור על איברי המערך ולהעתיק אותם למערך חדש לפי האינדקסים המופיעים במערך העזר. 47