פתרון למבחן במבני נתונים, מועד א', קיץ 2005 חלק א' שאלה 1 א. רכיב הקשירות החזק של קודקוד x בגרף מכוון הינו אוסף כל הקודקודים y שמקימים שיש מסלול מ- x ל- y וכן מסלול מy ל- x. טעויות נפוצות שכחו לכתוב שזה אוסף כל הקודקודים. חלק הגדירו הגדרה מאוד לא מדויקת כגון: נדרוש שאם יש מסלול מx ל- y אז יש גם להיפך. ב. התשובה היא n. כל קודקוד מופיע ברכיב הקשירות של עצמו מעצם ההגדרה. לא יתכנו שני קודקודים ברכיב קשירות אחד שכן זה ייצור מעגל: מסלול מהקודקוד הראשון לשני וחזרה. ענו 0 כי חשבו שרכיב קשירות לא יכול להיות בגודל 1. כמו כן יש כאלו שחשבו שצלע או מסלול הוא רכיב קשירות, וספרו צלעות או מסלולים. חלק א' שאלה 2. נתון האלגוריתם הבא: Nothing(A[left,,right]) 1. If right-left 1 print: "I am done!" 2. Else. Middle= (right+left)/2 (the integer part of it). Nothing(A[left,middle]) 5. Nothing(A[middle+1,right]) 6. Nothing(A[middle+1,right]) k עבור קלט באורך n (ההנחה בשאלה היא כי = 2 n עבור k טבעי כלשהו) סיבוכיות שורות 1 ו היא (1)O (מספר קבוע של פעולות) וסיבוכיות שורות -6 היא (2 / O(n עבור כל אחת משורות אלו. T ( n) = T ( n / 2) נוסחת הרקורסיה היא לפיכך: + c נפתור באמצעות נוסחת המאסטר כפי שנלמדה בשיעור (התקבלו גם צורות פתרון שונות): a=, b=2, k=0 a = = > 1 T(n)= Θ ( n log 2 ) k 0 b 2 חלק א' שאלה א. פונקציית גיבוב היא פונקציה מעולם מפתחות U למספרים m. 0. משפחה של פונקציות גיבוב H תקרא אוניברסלית אם לכל זוג מפתחות K1 K2 בעולם U מתקיים שאם בוחרים פונקציה h מהמשפחה.m/1 הינה לכל היותר h(k1)=h(k2) באקראי אזי ההסתברות שמתקיים H הגדרה שקולה: לכל זוג מפתחות מתקיים שמספר הפונקציות המקיימות את השויון שלעיל הוא לכל היותר H /m. החלפת סדר כמתים. קודם בוחרים את הפונקציה ואז את המפתחות... מסתכלים על מפתחות אקראיים... חוסר הבנה של מה המילה הסתברות אומרת בהקשר הפשוט שצריך כאן. ב. משפחה זו אינה אוניברסלית. דוגמא לשני מפתחות שעבורן לא מתקיימת דרישת ההגדרה: כל זוג מפתחות שונים שהם שווים מודולו m למשל: m ו. 2m לכל זוג פרמטרים a b הפונקציה שנקבל תשלח את שני המפתחות לאותו מקום בטבלה:.h(m)=h(2m)=b mod m נסיון לחזור על ההוכחה שניתנה בכיתה ולהוכיח שהמשפחה אכן אוניברסלית. הטעות כאן היא שבכיתה הגענו למשוואה K1=K2mod p ומתוכה למסקנה שהמפתחות שווים
כי p גדול מגודל עולם המפתחות. אבל אם לוקחים מודולו m השוויון לא גורר שהמפתחות שווים, כלומר שיש פתרון יחיד למשוואה... להיפך, זה נותן את הדוגמא הנגדית: שני מפתחות שונים שהם שווים מודולו m חלק א' שאלה הקלט הגרוע ביותר הוא קלט שבו כל ערכי המערך הם לכל היותר 10 כך שהתנאי אף פעם לא מתקיים ותמיד נכנסים ללולאת ה- for. לולאת ה for לוקחת סיבוכיות O(r) ושאר הפעולות לוקחות (1)O. נחשב אם כך את ממוצע זמן הריצה עבור קלט כזה, על פני ההגרלות. r נקבל: n 1 n( n + 1) c T ( n) c r + O(1) = + O(1) = O( n) n r= 1 2n אי הבנה של הגדרת סיבוכיות אקראית. אפשרות אחת: לקחו את המקרה הגרוע ביותר גם בהגרלות וגם בקלטים. כלומר הניחו ש.r=n התוצאה זהה במקרה זה אבל הנימוק לא נכון ובמקרים אחרים תתכן תוצאה שונה לחלוטין! אפשרות אחרת: לקחו ממוצע גם על הקלטים וגם על ההגרלות. אבל לא ניתן להניח שהקלט מפולג אקראית... טעות קטנה נוספת: לא הוסיפו (1)O לסיבוכיות עבור הדברים שלוקחים זמן קבוע. חלק א' שאלה 5. א. ייצוג הגרף באמצעות רשימת שכנויות: מצב התור: s: [a,5],[d,50],[g,5] a: [b,5],[d,0] b: [c,5],[d,0] c: [d,5] d: [e,10] e: [b,8],[f,9] f: [g,6] g: Queue dist s a b C d e f g s 0 a,g,d 0 5 50 5 g,b,d 0 5 10 5 5 b,d 0 5 10 5 5 c,d 0 5 10 15 0 5 d 0 5 10 15 20 5 e 0 5 10 15 20 0 5 f 0 5 10 15 20 0 9 5 NULL 0 5 10 15 20 0 9 5 ב. למרות שבמקרה הכללי האלגוריתם של Dijkstra לא עובד על גרפים בעלי משקלי צלעות שליליים (גם כאלו שלא מכילים מעגלים שליליים!) לאחר שינוי משקל הצלע (s,g) ל 10- האלגוריתם עדיין יחשב נכון את המרחקים בגרף. הסיבה המלאה מתחלקת לשתים: I. האלגוריתם יחשב נכון את המרחק לקודקוד g מאחר והצלע השלילית היחידה בגרף הינה הצלע (s,g) אותה "יראה" האלגוריתם בצעד הראשון, כלומר לא קיימות בגרף צלעות שליליות על מסלולים אל g אשר תתגלנה לאלגוריתם רק לאחר שהוא כבר ביצע החלטות "חמדניות" עליהן הוא יתחרט מאוחר יותר..II אין בגרף צלעות יוצאות מ g ולכן חישוב המרחק אל g לא ישפיע על חישוב שאר המרחקים בגרף (הצלע (s,g) לא נמצאת על אף מסלול מ s אל קודקודים בגרף למעט על המסלול אל g).
חלק ב' חלק ב' שאלה 1. א. הגדרת עץ חיפוש בינארי: ישנן מספר הגדרות אפשריות לעץ בינארי, אחת מההגדרות שהתקבלו היא גרף מכוון קשיר וחסר מעגלים, בו קיים קודקוד מיוחד המכונה שורש ולכל קודקוד אחר בגרף מסלול יחיד מהשורש ובו דרגת היציאה 2. יש לשים לב כי ללא הדרישה של מסלול יחיד מהשורש אל שאר הקודקודים הגרף משמאל יכנס תחת ההגדרה של עץ בינארי. כדי לאפשר חיפוש בעץ נוספת הדרישה שכל קודקוד בעץ גדול מכל הקודקודים בתת העץ השמאלי שלו וקטן מכל הקודקודים בתת העץ הימני שלו. ניתן להתיר אי שוויון חלש באחד הצדדים 2 6 ( או ) אך לא בשניהם. טעות נפוצה הייתה ההגדרה על פיה כל קודקוד גדול מבנו השמאלי וקטן מבנו הימני. על פי הגדרה זו, העץ משמאל הינו עץ חיפוש בינארי. 1 8 ב. גובהו של עץ מוגדר כגובהו של הגבוה מבין בניו + 1. לשורש בעץ 2AVL שני תתי עצים כאשר הפרש הגובה המקסימאלי ביניהם הוא 2. לפיכך גובהו של הגבוה מבין תתי העצים של עץ 2AVL בגובה k יהיה או -k.,1-k גובהו של הנמוך מבין תתי העצים יהיה 2-k 1-k. עד עתה דיברנו באופן כללי על עצי,2AVL כעת נתמקד בחישוב n k מספר הקודקודים המינימאלי בעץ.k בגובה 2AVL ניתן כבר להסיק מההקדמה כי הביטוי לחישוב מספר הקודקודים המינימאלי בעץ 2AVL בגובה k הינו. n = n = 2 1 ו 2, n 0 nk כאשר תנאי הבסיס הינו = 1 = 1+ nk 1 + nk נתחיל ב טענת עזר: הביטוי n k מונוטוני עולה (ממש) ב k. הוכחה: עץ 2AVL בגובה k מורכב לכל הפחות מתת עץ אחד בגובה k-1 ומשורש n. n n + k k 1 1 > k 1 נוכיח כעת את נוסחת הרקורסיה באינדוקציה מלאה. נניח את נכונות הטענה עבור כל j<k ונוכיחה עבור n. k כפי שטענו קודם, לעץ 2AVL בגובה k תת עץ "גבוה" בגובה 1-k ותת עץ "נמוך" בגובה 2-k,1-k או (2AVL נובע מהגדרת גובהו של עץ ומתכונת ה (הדבר -k כדי שמספר הקודקודים בעץ יהיה מינימאלי, מספר הקודקודים בשני תתי העצים אשר בניו מהווים את שורשיהם חייב אף הוא להיות מינימאלי (אחרת נחליפם בתתי עצים בעלי מספר קודקודים רטן יותר, בסתירה להנחת מינימאליות העץ) בתת העץ ה"גבוה" יש אם כן על פי הנחת האינדוקציה קודקודים. n k 1 מטענת העזר שהוכחנו נובע שגובהו של תת העץ הנמוך הינו -k ומספר הקודקודים בו הוא לפיכך (שוב, על סמך הנחת האינדוקציה). בנוסף לקודקודי שני תתי העצים עלינו להוסיף את השורש (+1) ונובע כי n k n k n k 1 + 1 > nk 1 ג. בכדי לאפשר הכנסה, הוצאה וחיפוש של איברים בסיבוכיות של O(log(n)) נשתמש בעץ AVL המבטיח סיבוכיות אסימפטוטית זו עבור הפעולות הנ"ל (כזכור, עץ BST לא מבטיח זאת מאחר וגובהו במקרה הגרוע הינו O(n) וכך גם סיבוכיות הפעולות הנ"ל. בנוסף לשדות הרגילים בעץ AVL נוסיף שדה sum אשר יחזיק את סכום הקודקודים בתת העץ אשר הקודקוד מהווה את שורשו (כולל השורש). נראה כי תיחזוק שדה זה לא פוגע בסיבוכיות הפעולות.insert, delete & search את פעולת ה search אין צורך לשנות. בפעולת ה insert בכל פעם שנרד בעץ בדרך להכנסת איבר חדש נוסיף את ערכו לשדה sum של הקודקודים בהם נעבור בדרך (הוריו) יש כמובן להיות עדינים בעת ביצוע רוטציות (לא התבקשתם לספק קוד מלא אלא רק לתאר את ההבדלים מהאלגוריתם הבסיסי). עדכון delete יתבצע באופן דומה כאשר הפעם לאחר מחיקת איבר מהעץ, נעלה ממיקומו של האיבר הנמחק עד השורש ונפחית את ערכו של האיבר שמחקנו משדה ה sum של כל הקודקודים בדרך. סה"כ מספר הפעולות שהוספנו ב (delete) insert הוא לכל היותר פעולה אחת עבור כל קודקוד בו עברנו במורד (מעלה) העץ ובסך הכל O(log(n)) פעולות.
לגבי פעולת.sum(x,y) הפעולה צריכה להחזיר את סכום כל הקודקודים הגדולים מ x וקטנים או שווים ל y (טעות נפוצה הייתה ניסיון לחשב את סכום כל הקודקודים הגדולים מ x ועוד כל הקודקודים הקטנים מ y). לשם כך נשתמש בפונקצית עזר sum_bigger(z) המחזירה את סכום כל הקודקודים הגדולים ממש מ z. sum_bigger(z) sumb = 0 v search(z) // find the node z sumb sumb + v.right.sum // add the sum of nodes in the right subtree p parent(v); while p!= NULL if p.key > z sumb sumb + p.right.sum + p.key end-if v p; p parent(v) end-while return sumb סיבוכיות האלגוריתם sum_bigger הינה O(log(n)) מאחר והוא מבצע קריאה אחת ל search (בסיבוכיות של (O(log(n)) ולאחריה מטפסים במעלה העץ עד השורש ובכל קודקוד מבצעים מספר קבוע של פעולות. מספר הקודקודים בהם מבקרים בסה"כ הינו O(log(n)) ובכל אחד מהם מבצעים מספר פעולות קבוע, הסיבוכיות לפיכך הינה.O(log(n)) חישוב הסכום המבוקש הינו טריוויאלי כעת: sum(x,y) return sum_bigger(x) sum_bigger(y); סיבוכיות החישוב הינה O(log(n)) מאחר וביצענו סה"כ שתי קריאות ל,sum_bigger כאשר סיבוכיות כל אחת מהן הינה.O(log(n)) G z חלק ב' שאלה 2. א. הפרכה באמצעות דוגמא נגדית: T=MST(G ) z x y x y המרחק הממושקל ב G בין x ו y הוא אורך הצלע (x,y) =, בעוד העץ הפורש המינימאלי מכיל רק את הצלעות (z,y) ו (x,z) והמרחק ב T בין הקודקודים x ו y הוא 6 (סכום שתי הצלעות הנ"ל) אנשים שחשבו שאורך המסלול בגרף ממושקל הוא מספר הצלעות, או שהוא פשוט משקל הצלע. או: הראו קיום שני מסלולים, באורכים שונים בגרף... זו לא דוגמא נגדית כי המרחק בגרף נקבע על ידי המסלול המינימלי...1], ניתן למיין אותם n ] הינם מספרים שלמים בטווח b -ים i ב. רעיון האלגוריתם מאחר וידוע לנו כי ה באמצעות radix-sort בסיבוכיות של.O(n) במיון זה ניתן להסתכל על הקלט כעל מספר בעל d ספרות כל אחת בטווח k ואז הסיבוכיות הינה O(d(k+n)). כאן,=d k=n ייתן מיון ליניארי. כזכור למדנו שני
אלגוריתמים נוספים למיון ליניארי אך הם לא מתאימים למקרה הנ"ל. bucket-sort מניח התפלגות אחידה (או לפחות ידועה) של הקלט. דבר אשר לא מובטח לנו בשאלה ו counting-sort ממיין בזמן ליניארי במספר האיברים בקלט ובטווח המיספרים. מאחר והטווח הוא, n האלגוריתם יעבוד עבור מקרה זה בסיבוכיות של. n a i -ים בפני עצמם לא ניתן למיין בזמן b i םי- (את ה a i םי- על פי ה צריך להקפיד שממיינים את ה ליניארי מאחר ואין לנו אינפורמציה נוספת על הערכים, מה עוד שהדבר לא נחוץ לאלגוריתם) b, i כל שנותר לנו לעשות הוא לעבור על המערך b -ים i ממוינים על פי ערכי a i -ים וה כעת לאחר שה 1+i a עבור כל i בטווח [1 n..1 ]. במקרה ועבור אחד הזוגות התנאי אינו <b i ולבדוק שמתקיים ש מתקיים האלגוריתם יחזיר לא, אחרת יחזיר כן. יש לשים לב לאבחנה הבאה אשר מבטיחה את נכונות b -ים i ממוינים, מתקיים בהכרח b, i מאחר וה >= a j האלגוריתם במידה ולאחר המיון קיים j>i עבורו b k ובפרט הדבר מתקיים עבור k=j-1 ולפיכך האלגוריתם יזהה את ההפרה >= a j שגם עבור כל k>i גדול פסיאודו-קוד: [נניח כי הקלט מגיע בשני מערכים, A ו B. נחזיק את הנתונים ב"תאים" C בעלי שני שדות. שדה a ושדה b ונגדיר את יחס הסדר בין שני תאים להיקבע על פי יחס הסדר בין השדה b של התאים.] are_disjoint(a,b) for i=1 to n do C[i].a = A[i]; C[i].b = B[i]; end-for sort C according to field b using radix-sort for i=1:n-1 do if C[i].b >= C[i+1].a return false end-if end-for return true חלק מהאנשים לא עלו על רעיון המיון היותר יעיל והגיעו רק ל- nlogn. או שהשתמשו במיונים לא מתאימים לתנאי השאלה כמו bucket sort ו- sort. counting חלק מצאו אלגוריתמים הרבה פחות יעילים לעבור על כל זוגות הקטעים ריבועי. חלק הניחו שהקטעים ממוינים מלכתחילה... ג. בשאלה נתון גרף עם n קודקודים ו n צלעות (מספר הצלעות ליניארי במספר הקודקודים) כמו כן נתון 2..1]. התבקשתם למצוא תת קבוצה של הצלעות שמשקלי הצלעות הינם מספרים שלמים בטווח ] n (המסילות הפוטנציאליות) אשר יבטיחו כי ניתן יהיה להגיע לכל ה קודקודים (הערים) במחיר (משקל) כולל מינימאלי מחלק א' של השאלה יכולתם לנחש שהפיתרון כולל שימוש באלגוריתם למציאת MST (האלגוריתם של (Kruskal חלק ב' של השאלה סיפק רמז לגבי השימוש ב radix-sort למיון בזמן ליניארי.. כאמור, נתון לכם גרף קשיר עם משקלים על הצלעות וברצונכם למצוא תת קבוצה קשירה מינימאלית של הצלעות (עץ פורש) בעלת משקל כולל מינימאלי, או במילים אחרות עץ פורש מינימאלי. ניזכר באלגוריתם של :Kruskal
סיבוכיות שורות 2- הינה O(n) (מעבר אחד על כל הקודקודים) כאמור, נמיין את הצלעות באמצעות,radix-sort סיבוכיות שורה לפיכך הינה O(n) גם כן (נתון לנו כי מספר הצלעות הוא n) כעת נשתמש ב union-find עם כיווץ מסלולים, כפי שנלמד בכיתה. סיבוכיות שורות 5-8 היא לפיכך O(nlog*n) הסיבוכיות הכוללת של האלגוריתם היא לפיכך O(nlog*n) (שזה O(n) בקירוב טוב מאוד) להשתמש במיונים אחרים ופחות יעילים ולא להבין את הרמז של הסעיף הקודם... לא לשים לב שאפשר לשפר את קרוסקל בגלל תנאי השאלה. חלק השתמשו באלגוריתם דיקסטרה שבכלל לא מוצא עץ פורש מינימלי. חלק ב' שאלה א. האלגוריתם נכון. מוכיחים בעזרת :loop invariant האינואריאנט הוא שאחרי שרצנו עד המקום ה- j המערך במקומות 1 עד j הינו ערימת מקסימום. בסיס: איבר אחד הינו ערימת מקסימום. שלב המעבר: נניח שעד המקום ה- J יש ערימת מקסימום. כעת מפעפעים את האיבר הבא למעלה במעלה העץ. זה בדיוק מה שקורה בהכנסה של איבר חדש לערימת מקסימום קיימת. לכן אחרי הפעפוע נקבל ערימת מקסימום. אחרי n צעדים כל המערך הינו ערימת מקסימום. הבנת הנקרא! כמה אנשים חשבו שהפעפוע למטה... הרבה טעו בדוגמאות. כמה לא הבינו שהפעפוע הוא כל הדרך עד למעלה והוכיחו את הטענה הלא נכונה שמספיק פעפוע של צעד אחד למעלה... ב. האלגוריתם יעבור על האיברים בסדר BFS (יעבור על הערימה, רמה אחר רמה) ויפעפע איברים כלפי מעלה באמצעות.increase-key (יש להקפיד שכאשר מכניסים איברים חדשים לתור הם מוכנסים משמאל לימין בן שמאלי ולאחריו בן ימני) כזכור אלגוריתם ה BFS עובר על כל הקודקודים במרחק i מהראשית לפני שהוא מתחיל לסרוק קודקודים במרחק 1+i, כאשר נריץ את האלגוריתם על עץ מהשורש, האלגוריתם יעבור על כל הקודקודים רמה אחר רמה. פסיאודו-קוד: TreeBMH(tree) { Queue.enqueue(tree.root) while not Queue.isEmpty() do node Queue.dequeue() BubbleUp(node,tree) queue.enqueue(node.left) queue.enqueue(node.right)
} end-while BubbleUp(node,tree) { parent node.parent while parent!= null do if parent.key < node.key swap(key,parent) // swap the values end-if node parent parent node.parent end-while } הרבה מאוד אנשים לא עברו על הקלט בסדר הנכון, כלומר בסדר שלגביו הוכחה נכונות. במקום זה בחרו לעבור על העץ בצורת DFS כלומר ברקורסיה. האלגוריתם עדיין נכון אבל זה אינו האלגוריתם שהתבקשתם לכתוב עבורו פסיאודו קוד! כמו כן לא הוכחתם את נכונותו. הרבה שכחו לפעפע כל הדרך למעלה ופעפעו רק שלב אחד. כמה לא כתבו קוד עבור הפעפוע. ג. הסיבוכיות האסימפטוטית של האלגוריתם הינה הסיבוכיות האסימפטוטית של הקלט הגרוע ביותר. נסתכל קודם כל בחסם מלמעלה: כל פעפוע לוקח O(log(n)) ויש לנו לכל היותר כאורך המערך, לכן הסיבוכיות הינה ( O(nlognוזה נכון לכל קלט כולל הגרוע ביותר. כעת נראה שחסם זה הדוק על ידי כך שנראה שיש קלט שאכן לוקח סיבוכיות זו. זה נובע מכך שלמערך שממוין מקטן לגדול, כל אחד מהאיברים יצטרך לפעפע עד שורש העץ. בפרט, הרמה המלאה האחרונה כולה תצטרך לפעפע את כל גובה העץ (פחות אחד) מאחר שבעץ כמעט שלם מספר האיברים ברמה זו הוא לפחות רבע ממספר הקודקודים, נקבל סיבוכיות שהיא לפחות /n n) [log(n)-1] = Ω(n log ולכן אסימפטוטית זה הדוק. הרבה התבלבלו עם ניתוח של בניית ערימה. שם סוכמים על המרחק מהקודקוד לעלים, ולא לשורש! הרבה לא הבינו את מושג החסם ההדוק: חלק חשבו שמדובר בחסם מלמעלה על המקרה הגרוע ביותר, ומלמטה על המקרה הטוב ביותר. חלק עשו את הטעות העדינה הבאה: הראו חסם מלמעלה על ידי איזו שהיא פונקציה n log n למשל, ואז הראו חסם תחתון על הפונקציה! זה אינו חסם תחתון על סיבוכיות האלגוריתם, אלא על החסם העליון... חלק אכן ניסו לתת חסם תחתון על המקרה הגרוע ביותר, אך לא הסבירו מהו הקלט שעבורו באמת תמיד צריך לפעפע עד לשורש (הקלט הממוין, למשל.)