‫ממן ‪13‬‬

‫מגיש‪:‬יוגב שלמון ‪ ,‬ת‪.‬ז‪318403490 : .‬‬

‫)‪1‬‬
‫האלגוריתם שנראה דומה לאלגוריתם של צביעת מסילה‪ ,‬אבל אם שיפור של ביצוע שני שלבים‬
‫של האלגוריתם בסיבוב אחד‪ ,‬כלומר אחרי ‪ 3‬סיבובים נקבל )‪– O(log log log log log log n‬‬
‫צבעים כמו עשיית ‪ 6‬שלבים‪.‬‬
‫האלגוריתם‪:‬‬
‫נתאר מסילה מהצורה הבאה‪....…>-u->v->t>- :‬‬
‫בכל שלב כל קודקוד שולח את מספרו לשכניו(גם למעלה וגם למטה אם מסתכלים על כיוון‬
‫מסוים)‪ .‬האלגוריתם מתחיל בצורה רגילה כאשר נסתכל על קודקוד ‪ ,v‬הוא מחשב את המספר‬
‫החדש שלו כמו בצורה הרגילה הוא משווה את המספר שלו לקודקוד ‪ t‬נקרא לו ‪, v1‬עכשיו בגלל‬
‫שיש לו את המספר של קודקוד ‪ u‬הוא יכול לחשב גם את המספר ש‪ u‬יקבל כאשר הוא משווה‬
‫את עצמו ל‪ v‬נקרא לו ‪. v 2‬כלומר עכשיו ‪ v‬מחזיק שני מספרים אחד של עצמו ואחד של הקודקוד‬
‫שלפניו‪ ,‬וזה תקף לכל קודקוד במסילה שעושה אותה פעולה‪ ,‬עכשיו קודקוד ‪ v‬מחשב את המספר‬
‫כאשר הוא משווה את ‪ v1‬ל ‪ v 2‬כלומר המספר שיחושב באלגוריתם הרגיל בסיבוב שני‪.‬וזה יהיה‬
‫המספר החדש שלו לאחר סיבוב אחד‪ ,‬כל קודקוד במסילה פועל באופן הבא ולכן לאחר ‪3‬‬
‫סיבובים תתקבל צביעה של )‪O(log log log log log log n‬‬
‫ניתוח סיבוכיות‪:‬‬
‫זמן‪ :‬לפי ההגדרה נקבל זמן ריצה של ‪ 3‬סיבובים‪.‬‬
‫צבעים‪ :‬נקבל מספר של )‪ O(log log log log log log n‬צבעים‪.‬‬

‫‪)2‬‬
‫האלגוריתם‪:‬‬
‫נתחיל כך‪ ,‬נפרק את הגרף לקבוצות עם דרגה חסומה של ‪ ,3a‬לפי אלגוריתם פירוק שלמדנו‪ ,‬זמן‬
‫זה לוקח )‪ .O(log n‬עכשיו נצבע עם אלגוריתם של לינאל שצובע בזמן )‪ O(log*n‬ב )‪ O(∆2‬צבעים‪.‬‬
‫בגלל שיש לנו גרף מכוון עם דרגה מקסימלית של ‪ 3a‬מהפירוק‪ ,‬אפשר לבצע צביעה של‬
‫)‪ . O((3 a)2‬עכשיו נבצע רדוקציה ל‪ 3a-‬צבעים כאשר כל קבוצה בנפרד מבצעת את הצביעה‬
‫בתוך עצמה‪ .‬ניתן לעשות זאת ב)‪ O(a‬לפי אלגוריתם של ‪ Barenboim-elkin-goldenberg‬ואז‬
‫רדוקציה של ‪ Kuhn and wattenhofer‬שתוריד לצביעה של ‪ 3a‬חוקית בכל קבוצה שנוצרה‪.‬עכשיו‬
‫נתחיל מהקבוצה האחרונה שנוצרה ‪, H l‬כל הצלעות יוצאות לקודקודים בקבוצה‪ .‬ונסתכל על‬
‫הקבוצה לפני אחרונה‪ , H l−1‬כל הצלעות או יוצאות לקבוצה ‪ H l‬או לקבוצה הנוכחית‪ .‬נגדיר‬
‫צביעה חדשה לשני הקבוצות "ונחבר אותם" הצביעה מוגדרת כך‪:‬כל קודקוד בקבוצה ‪ H l‬מקבל‬
 ‫את הצביעה של ¿> ‪ ¿ 0 , H l‬כלומר ‪ 0‬והצביעה המקורית משלב קודם‪ .‬כל הקודקודים בקבוצה‬
‫‪ H l−1‬מסתכלים על הצלעות היוצאות שלהם לקבוצה ‪ , H l‬מכיוון שהדרגה המקסימלית היא ‪3a‬‬
‫אז קיים צבע שאין אותו בקבוצה ‪ H l‬וזה היה הצבע הנוסף שלהם והצבע החדש יוגדר‪:‬‬
‫¿ ¿ ‪ ¿ orignal ¿ new‬כלומר קיבלנו צביעה חוקית של ‪ .∆ 2‬מכיוון שכל קודקוד צבוע חוקית בתוך‬
‫עצמו ולפי הגדרת החיבור כל הקודקודים בקבוצות ‪ H l−1, H l‬שיש ביניהים צלעות גם חוקיים‪.‬‬
‫עכשיו לפי ההגדרה של אלגוריתם ‪ Barenboim-elkin-goldenberg‬כל הקודקודים בקבוצה ‪H l‬‬
‫ישארו באותו הצבע המקורי‪ ,‬ונוכל לעשות רדוקציה ל )‪ O(a‬בזמן )‪ O(a‬ואז רדוקציה של ‪Kuhn‬‬
‫‪ and wattenhofer‬שתיקח גם )‪ .O(a‬ולכן קיבלנו איחוד של הקבוצות ב)‪ O(a‬זמן לצביעה של ‪.3a‬‬
‫חוזרים על התהליך לכל הקבוצות‪ ,‬נשים לב שעכשיו מבחינת ‪ H l−2‬האיחוד של ‪ H l−1, H l‬שצבוע‬
‫ב‪ 3a‬צבעים הוא כמו ש ‪ H l−1‬הסתכלה על ‪ H l‬ולכן נוכל לבצע אותם שלבים עד שנקבל צביעה‬
‫של כל הגרף ב ‪ 3a‬צבעים‪.‬‬

‫ניתוח סיבוכיות‪:‬‬
‫זמן‪ :‬צביעה התחלתית של כל הקבוצות זה )‪ O(log n + log*n + a‬האיחוד של קבוצות לוקח )‪O(a‬‬
‫והוא נעשה ‪ log n‬פעמים ולכן סה"כ לוקח )‪ O(a*log n‬ביחד כל השלבים יקחו )‪ O(a*log n‬שזה‬
‫זמן הריצה של כל האלגוריתם‪.‬‬

‫‪)3‬‬
‫באלגוריתם נסתמך על שאלה ‪ ,2‬כלומר צביעה של גרף עם יעריות ‪ a‬ב ‪ 3a‬צבעים ב )‪.O(a*log n‬‬
‫האלגוריתם‪:‬‬
‫נסתכל על התת גרף המושרה ע"י קבוצת הקודקודים הצבועים באותו צבע מהתחום {‪}p,.…,1,2‬‬
‫נגדיר צבע זה בתור ‪ . u p‬לפי הגדרת השאלה יודעים שהיעריות של תת הגרף חסומה ע"י‬
‫)‪ ,O(a/p‬ולכן נוכל לצבוע את הגרף ב )‪ O(a/p‬צבעים ב )‪ O((a/p)*log n‬זמן לפי פתרון תרגיל ‪,2‬‬
‫נגדיר צבע זה בתור ‪ .uc‬כל קודקוד יהיה צבוע בצבע הבא‪ ,¿ uc ,u p> ¿ :‬ולכן סה"כ צבעים ‪.O(a) :‬‬
‫הוכחת נכונות‪:‬‬
‫כל שכן של קודקוד היה בתהחלה באותו צבע כמו שלו מהתחום {‪ }p…,1,2‬או שהיה שונה ממנו‪,‬‬
‫אם הוא מאותו התחום אז לפי הצביעה שהגדרנו ‪ uc‬יהיה שונה ולכן הצבעים היו שונים‪ ,‬אם הם‬
‫היו בצבע התחלתי שונה ‪ u p‬יהיה שונה‪ ,‬ולכן הצביעה חוקית‪.‬‬

‫ניתוח סיבוכיות‪:‬‬
‫זמן‪ :‬זמן הריצה הוא כמו של פתרון תרגיל ‪ ,2‬ולכן הוא )‪.O((a/p)*log n‬‬
 ‫‪)4‬‬
‫נתחיל מצביעה של קודקודי ‪ U‬כאשר נסתכל רק על הצלעות בתוך הקבוצה ‪ .U‬הצביעה תתבצע‬
‫ב ∆ √‪ , 3‬עושים פירוק ל ∆ √יערות‪ ,‬ואז צביעה ב ‪ 3‬צבעים‪ .‬סה"כ זמן )‪ O(log*n‬כנדרש בינתיים‪.‬‬
‫עכשיו נבצע גרסא לינאל בצורה שונה טיפה‪,‬נגדיר מספר ראשוני ‪ q‬כך ש ∆ ‪ ,2 ∆< q< 4‬נסתכל על‬
‫הפולינומים ממעלה ∆ √ ‪. q‬זה מספר גדול מ ∆ √‪ 3‬ולכן נוכל להתאים לכל פולינום צביעה יחודית‬
‫מהצביעה שחישבנו לקבוצה ‪ .U‬עכשיו כל קודקוד בקבוצה ‪,W‬מחשב נק אחת מהצורה {‪ }x,y‬לפי‬
‫פירוק מסוים כאשר ‪ x,y<q‬זה ניתן לעשות מכיוון שהטווח של {‪ }q,q‬הוא ¿)‪ O( ∆¿¿ 2‬לעומת‬
‫הטווח של ‪ W‬שהוא ‪ (∆)O‬את הפירוק אפשר להגדיר ש ‪ x*y=c‬כאשר ‪ c‬הוא הצבע המקורי של‬
‫הקודקוד ב‪ .W‬עכשיו נמשיך לפי לינאל‪ ,‬כל קודקוד בקבוצה ‪ U‬שולח את צבעו לשכניו ב‪ ,U‬וכל‬
‫קודקוד ב‪ W‬שולח את הצבע {‪ }x,y‬שחושב‪ .‬לכל קודקוד ב ‪ U‬יש ∆ √ חיתוכים על פולינומים של‬
‫קודקודים ב‪,U‬המקס של השכני הוא ∆ √ לפי השאלה ולכן יש ∆ התנגשויות עם קודקודי ‪ ,U‬ויש‬
‫מקס ∆ שכנים ב‪ W‬ל‪ ,U‬וכל שכן מייצג נקודה אחת ולכן סה"כ יש מקס ‪ ∆ 2‬התנגשויות‪ ,‬ולכן יש‬
‫קורדינטה אחת ‪ r‬מכיוון ש‪ 2 ∆< q‬ולכן הצבע החדש של קודקודי ‪ U‬יהיה מהצורה {)‪ }r,P(r‬כמות‬
‫הצבעים ב‪ U‬היא ‪ q 2< 16 ∆2‬שזה ‪ ( ∆2)O‬אנחנו מכוונים ל‪.(∆)O -‬‬

‫נמשיך לסיבוב נוסף כאשר נבחר פולינומים ממעלה של ‪ ,3‬כאשר ‪ ,( √ ∆)q=O‬ולכן כמות‬
‫הפולינומים השונים היא ‪ .q 4‬כל פולינום נחתך עם כל שכן ב‪ U‬ב‪ 3‬נק לכל היותר‪ ,‬נגדיר לכל‬
‫קודקוד ב‪ W‬מספר חדש {‪ }x,y‬באופן דומה לסיבוב הראשון‪ ,‬כאשר ‪ .x,y<q‬כאשר נפרק כך‪ x :‬ייצג‬
‫את המספר בצביעה המקורית של ‪ W‬חלקי ∆ √ ו – ‪ y‬ייצג ‪ √ ∆ mod‬כלומר ‪ x*√ ∆ +y = c‬כאשר ‪c‬‬
‫זה הצביעה המקורית‪ .‬ולכן הטווח של ‪ x‬יהיה ∆ √‪ .‬ומספר ההתנגשויות הכולל של קודקוד מ‪ U‬עם‬
‫קודקוד מ‪ W‬יהיה חסום ב ‪ ,x‬כלומר ∆ √‪.‬‬
‫נדרוש ש ‪ √ ∆ q>4‬מכיוון שכל קודקוד ב‪ U‬יש לכל היותר ‪ √ ∆ 3‬חיתוכים עם שכנים ב ‪ ,U‬ומספר‬
‫החיתוכים עם שכנים ב‪ W‬הוא ∆ √ ולכן יש קורדינטה אחת שאין בה התנגשות והצביעה {)‪}r,P(r‬‬
‫תיהיה הצביעה החדשה ולכן הגענו לסה"כ צביעה של כל הגרף ב ‪.(∆)O‬‬

‫‪)5‬‬
 ‫בגרף מישורי היעריות חסומה ע"י ‪ ,3‬כלומר ‪ .a<=3‬אפשר לפרק כל גרף ל ‪ q*a‬יעריות בזמן של‬
‫¿¿‬ ‫‪log n‬‬
‫=‪ . q‬נפרק ל‪ q*a‬יערות‪ ,‬כל יער ניתן לצבוע ב‪ 3-‬צבעים בזמן של‬ ‫(‪ O‬נגדיר את ‪)\3‬‬ ‫)‬
‫‪log q‬‬
‫)‪ , O(log*n‬סה"כ צבעים קיבלנו ‪ 3q∗a‬מכיוון שיש ‪ q*a‬יערות‪ .‬נחשב את כמות הצבעים לפי ‪a‬‬
‫שחסום ע"י ‪ 3‬ו ‪ q‬שהגדרנו‪ 3q∗a=3(log¿¿3 logn)=O ¿¿ :‬ולכן קיבלנו )‪ O(log n‬צבעים כנדרש בשאלה‪.‬‬
‫נחשב את סיבוכיות הזמן‪ :‬שלב הצביעה בהתחלה לוקח )‪ O(log*n‬שלב הפירוק לוקח ¿ ‪ O‬ולכן‬
‫סה"כ סיבוכיות היא ¿ ‪O‬‬

‫‪)6‬‬
‫נשתמש באלגוריתם המבוזר הרנדומי שלמדנו שצובע גרף ב ∆ ‪ 2‬צבעים )‪ , O( √ log n‬כל קודקוד‬
‫יסתכל על ה‪ log n‬צלעות שיוצאות ממנו‪ ,‬יחליט אם להשאיר את הצבע שלו אם הוא שונה מכל‬
‫הקודקודים האלו‪ ,‬ולכן לפי האלגוריתם כמות השכנים שכל פעם קודקוד מסתכל עליהים היא לכל‬
‫היותר ‪ log n‬ולפי ניתוח סיבוכיות של האלגוריתם ניתן (לא מתייחסים לשאר הקודקודים כרגע)‬
‫נוכל לצבוע ב‪ log n -‬צבעים בזמן )‪.O( √ log n‬‬
‫אבל‪:‬‬
‫יש בעיה באלגוריתם‪ ,‬אם קודקוד ‪ u‬בשלב מסוים בחר צבע‪ ,‬כלומר כל הקודקודים שהוא מסתכל‬
‫עליהים בחרו צבע שונה באותו סיבוב נסתכל על קודקוד ‪ v‬למשל שיש צלע מ‪ u‬ל‪ v‬עם אורנטציה‬
‫יוצאת‪ .‬לא בהכרח שקודקוד ‪ v‬יבחר את הצבע להיות הצבע הסופי באותו סיבוב‪ .‬ולכן אם בסיבוב‬
‫מאוחר יותר קודוקד ‪ v‬מסתכל על הקודקודים שבצלעות עם האורנטציה היוצאת ורואה שכל‬
‫שהצבע שלו שונה מכולם‪ ,‬הוא יכול בטעות לבחור אותו צבע כמו ‪ ,!u‬בנוסף בשלב הסופי של‬
‫האלגוריתם כאשר צובעים חלקים קשירים עם רדיוס מקסימלי של )‪ O( √ log n‬עם ‪ log n‬צבעים‬
‫באלגוריתם המקורי לכל רכיב יש ראש שלומד את הרכיב וצובע אותו אבל מכיוון שהוא יכול‬
‫ללמוד את כל השכנים של כל הקודקודים‪ ,‬אבל יש אותה בעיה‪ ,‬קודקוד מסתכל רק על השכנים‬
‫עם האורנטציה היוצאת‪ ,‬וקודקודים שבחרו צבע באחד הסיבובים ומסתכלים עליו לא נחשבים‬
‫כביכול ולכן יכול להיות מקרה של צביעה באותו צבע‪ ,‬מה שלא קורה באלגוריתם המקורי‪.‬‬
‫ולכן ניתוח הסיבוכיות לא מסתדר‪.‬‬
‫נתקן את האלגוריתם כך שהניתוח בכל שלב יהיה אותו דבר ולכן הוא יוכל לעבוד‪.‬‬
‫התיקון שנעשה הוא כך‪:‬‬
‫כל קודקוד יגידר לעצמו צבע <‪ >i,c‬כאשר ‪.O( √ log n)=<i<0‬‬
‫בכל סיבוב ‪ i‬קודקוד ‪ u‬שמגריל צבע מסוים ‪ c‬ששונה מכל הקודקודים שהוא מסתכל עליהים יגדיר‬
‫את הצבע שלו להיות <‪. >i,c‬ולכן אם בסיבוב ‪ j>i‬קודקוד ‪ v‬ש ‪ u‬הסתכל עליו מגריל אותו צבע ‪c‬‬
‫והוא שונה מכל הקודקודים שהוא מסתכל עליהים‪-‬שלא כוללים את ‪ u‬הוא יבחר את הצבע <‪>j,c‬‬
‫ששונה מהצבע <‪ ,>i,c‬ולכן הצביעה חוקית! בשלב האחרון כל רכיב יכול לבצע צביעה של של‬
‫עצמו כאשר הוא מגדיר את הצבע שלו להיות מספר הסיבוב האחרון‪ ,1+‬ולכן יוכל לצבוע את כל‬
 ‫הרכיב שלו כאשר הוא רק מתייחס לקודקודים שבתוך הרכיב‪ ,‬מכיוון שכל שאר הקודקודים בחרו‬
‫צבע בסיבוב מוקדם יותר‪.‬‬
‫סה"כ מספר הצבעים הוא )‪.O(log n √ log n‬מכיוון שהטווח של ‪ i‬הוא ‪ √ log n‬ואנחנו מגרילים‬
‫מספר בגודל של ‪ .log n‬זמן הריצה הוא )‪ O( √ log n‬לפי האלגוריתם המקורי‪.‬‬

‫‪)7‬‬
‫באלגוריתם הרגיל של צביעה של גרף ב )∆( ‪ 3O‬צריכים למצא אורנטצייה לכיוון הצלעות כדי לקבל‬
‫∆ עצים‪ .‬נגדיר את האורנטציה הפשוטה כך שצלעות יכוונו ל‪ ID‬גדול יותר‪ ,‬במודל שאנחנו‬
‫מתעסקים ה‪ ID-‬של כל קודקוד נשמר ב‪ ,ROM‬אנחנו נמספר את האורנטציה שיוצאת‪.‬המספור‬
‫יתבצע לפי מספר מהקטן לגדול‪ ,‬כלומר אם יוצאות צלעות ממני אם ‪ ID‬בסוך הצלעות של ‪5,4,7‬‬
‫אז המספור שיתקבל הוא ‪ 1,0,2‬בהתאמה‪.‬כל קודקוד מחזיק מידע ב‪ RAM‬לגבי כל הצלעות שלו‪,‬‬
‫כאשר לכל צלע יש אורנטציה(נכנסת יוצאת)‪,‬וצבע נוכחי לכל מספור של אורנטציה(כל הצלעות‬
‫שיוצאות)‪.‬כל סיבוב קודקוד שולח את ה‪ ID‬לכל שכניו‪,‬והצבע הנוכחי לפי כל האורנטציות שלו‬
‫(בהתחלה הערכים ריקים וצריכים אתחול כמובן זה יקרה תוך סיבוב אחד)‪ .‬כל סיבוב קודקוד‬
‫שולח ומקבל ערכים מכל שכניו‪ ,‬כאשר הוא מתייחס רק לאורנטציה יוצאת(כלומר קודקוד אב‬
‫ששולח לו את הצבע) – שאפשר לחשב נכונות כל פעם מחדש מבחינת הצבע‪.‬את הצביעה של‬
‫המסילה(עץ כביכול‪ )..‬נעשה לפי האלגוריתם המבוזר מתייצב במדריך הלמידה‪ ,‬אם קרתה‬
‫תקלה אנחנו עושים צביעה מחדש ומוסיפים סיבית של ‪.failure‬אנחנו מניחים שה‪ ID‬שנשלח כל‬
‫פעם הוא נכון‪ ,‬אבל האורנטציה יכלה להשתנות וגם הצבע יכל להשתנות כי זה ערכים שנשמרים‬
‫ב‪ RAM‬ולכן כל סיבוב נוכל לקבוע האם הערכים שיש לנו\קיבלנו מהשכנים נכונים‪ ,‬וזה נכון לכל‬
‫קודקוד בגרף‪ .‬כאשר מתגלה תקלה נוכל לזהות באותו סיבוב ולעשות צביעה מחדש‪ ,‬אם‬
‫האורנטציות\המספור\הצבע של האורנטצייה של קודקוד כלשהו השתנו‪ ,‬הוא ישלח לכל שכניו את‬
‫הצבעים שלו לפי כל האורנטציות‪ ,‬את האורנטציה בכל מקרה אפשר לחשב מחדש כל פעם‬
‫בקלות ולכן קודקודים יוכלו להתייחס בהתאם‪ ,‬אם הצבע שגוי‪ ,‬האלגוריתם שיש במדריך‬
‫מתמודד אם זה כפי שהסברנו מקודם‪ ,‬כאשר יש מספור שונה‪ ,‬הקודקוד יוכל לחשב מחדש את‬
‫המספור ולעשות צביעה מחדש למספור הנוכחי ולהתחיל צביעה מחדש לאורנטציה‪ ,‬הקודקודים‬
‫שקיבלו צבע יוכלו לבדוק האם הוא תקין מבחינתם לצביעה הנוכחית של האורנטציה‪ ,‬ולהתייחס‬
‫כמו באלגוריתם במדריך כלומר אם הצבע תקין להתייחס אליו אם לא אז לבצע צביעה מחדש‪.‬‬
‫כמו בהוכחת הנכונות של האלגוריתם המבוזר מתייצב במדריך הלמידה‪ ,‬אם בסיבוב אחד לא‬
‫קרתה תקלה אז הצביעה חוקית וקטנה ב )‪ O(log n‬כל פעם בכל עץ‪ ,‬עד שתגיע לצביעה של‬
‫)∆( ‪ ,3O‬כאשר יש תקלה שהצבע לא נכון‪ ,‬המספור של הצלעות השתנה ולכן נשלח צבע לא נכון‬
‫מתקיים אותו נוהל של תקלה באלגוריתם‪ ,‬מוסיפים סיבית ‪ failure‬ומחשבים צביעה לפי ה‪ID‬‬
‫מחדש‪ ,‬ולכן כל סיבוב הצביעה החוקית נשמרת‪ .‬לאחר )‪ O(log*n‬סיבובים מרגע סיום תקלות\‬
‫תקיפה במערכת הצביעה תתייצב שוב ל‪ 3O (∆) -‬צבעים‪.‬‬