יותר

מטריצת סמיכות לפוליגונים המשתמשים ב- Java

מטריצת סמיכות לפוליגונים המשתמשים ב- Java


אני מנסה ליצור מטריצת סמיכות מקבוצה של מצולעים. כלומר, יש לי חבורה של מצולעים ואני רוצה לזהות לאילו מצולעים יש קצה משותף או "לגעת" זה בזה. ברגע שאני מוצא את המידע הזה, אני רוצה ליצור מטריצה ​​n x n שמציינת אם כל מצולע זה נוגע או לא נוגע במצולע השני. משהו כזה:

פולי 1 פולי 2 פולי 3 פולי 1 0 1 0 פולי 2 1 0 1 פולי 3 0 1 0

זו המטרה בכל מקרה. תהיתי אם מישהו מכיר חבילת ג'אווה או משהו שיכול לעזור לי לעשות זאת. קראתי כמה פוסטים בנושא זה באמצעות VBA אבל אני תוהה אם ניתן להשתמש ב- Java Eclipse למטרה זו מכיוון שאני צריך ליישם את מטריצת הסמיכות בתוכנית גדולה יותר שאני כותב ב- Java.

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


שיניתי את יישום Floyd-Warshall שלך לאתחול נכון של adjMat עבור האלמנטים האלכסוניים של מטריצת הסמיכות, שאמורה להיות בעלת ערך 0. שיניתי גם את שיטת floydWarshall כדי לא להקצות מחדש את adjMat, שכבר הוקצה ב- main שיטה. הסרתי גם שיחה כפולה ל- floydWarshall בשיטת arrayCondenser שלך. שיניתי גם את שיטת arrayCondenser לחישוב המערך המעובה והוספתי שיטת printCondensedGrid להצגת המערך המרוכז:

אני מאמין שהאתחול שלהלן (עבר לשיטת אתחול) צריך לשקף את התמונה שלך בצורה מדויקת יותר.

בשורות שוות יש קצוות מכל צומת לצומת מימין. בשורות משונות יש קצוות מכל צומת לצומת משמאלו. בכל עמודה אחידה יש ​​קצוות מכל צומת לצומת שמתחת. בכל עמודה מוזרה, יש קצוות מכל צומת לצומת שלמעלה.

שיניתי גם את ממדי המטריצה ​​כדי לשקף את העובדה שיש 100 צמתים, ולא 99.

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

הן אתחול והן testInit נקראות מתוך main.

לַעֲרוֹך: יישמתי את הצעתו של ג'ין להשתמש במטריצת 100 X 4 שבה 4 המספרים מייצגים את כיווני N, S, E, W, כי אלה הם הכיוונים היחידים בהם יכולים להתקיים קישורים. ג'ין הציע 4 סיביות, אך השתמשתי ב -4 מיקומי מערך אשר צורכים יותר מקום, אך שמתי את הצמתים הסמוכים בפועל במיקומים אלה (אם הם לא אפס).

אם ברצונך לשמור על האינדקס המקורי שלך, תוכל לשנות את הצהרות if בשיטת האתחול כך:


שיעורים

מחברים: ג'סטין בלנפורד, פריץ קסלר, איימי גריפין, דיוויד אוסאליבן, תוכנית MGIS, אוניברסיטת פנסילבניה.

מודול תוכנת הקורס הזה הוא חלק מהיוזמה OER של מכללת פן סטייט למכללת כדור הארץ ומדעי המינרלים.

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


מציאת אורכי נתיב בכוח מטריצת הסמיכות של גרף לא מכוון

הכרתי מהספר של מארק ניומן - רשתות: מבוא (עמוד 137, שוויון: 6.31) שאם $ A $ היא מטריצת הסמיכות של גרף, אז $ ij

תוכן

לגרף פשוט עם סט קודקוד U = <u1, …, uנ >, מטריצת הסמיכות היא מטריצה ​​A × n מרובעת כך שהרכיב שלה Aij הוא אחד כשיש קצה מהקודקוד uאני לקודקוד uי , ואפס כשאין קצה. [1] האלמנטים האלכסוניים של המטריצה ​​כולם אפסיים, מכיוון שאסור לקצות מקודקוד לעצמו (לולאות) בגרפים פשוטים. לפעמים גם שימושי בתורת הגרפים האלגברית להחליף את האלמנטים הלא -אפסיים במשתנים אלגבריים. [2] ניתן להרחיב את אותו מושג לרב -גרפים וגרפים עם לולאות על ידי אחסון מספר הקצוות בין כל שני קודקודים במרכיב המטריצה ​​המתאים, ועל ידי התרת אלמנטים אלכסוניים ללא אפס. ניתן לספור לולאות פעם אחת (כקצה בודד) או פעמיים (כשתי מקרים בקצה הקודקוד), כל עוד מתקיימת מוסכמה עקבית. גרפים לא מכוונים משתמשים לעתים קרובות במוסכמה השנייה של ספירת לולאות פעמיים, בעוד שגרפים מכוונים בדרך כלל משתמשים במוסכמה הקודמת.

מתוך גרף דו -צדדי עריכה

ניתן לכתוב את מטריצת הסמיכות A של גרף דו -צדדי אשר לשני חלקיו יש קודקודים r ו- s ניתן לכתוב בצורה

איפה B הוא r × ש מטריצה ​​ו- 0r,r ו- 0ש,ש מייצגים את r × r ו ש × ש אפס מטריצות. במקרה זה, המטריצה ​​הקטנה B מייצגת באופן ייחודי את הגרף, ואת החלקים הנותרים של A ניתן למחוק כמיותר. לפעמים B נקרא מטריצה ​​דו צדדית.

רשמית, תן ז = (U, ו, ה) להיות גרף דו -צדדי עם חלקים U = <u1, …, ur >, ו = <v1, …, vש > וקצוות ה. מטריצת הדו -כיווניות היא r × ש 0–1 מטריצה ​​B שבה באני,י = 1 אם ורק אם (uאני, vי) ∈ ה .

אם G הוא גרף דו -צדדי או גרף משוקלל, אז האלמנטים באני, י נחשב למספר הקצוות בין הקודקודים או למשקל הקצה (uאני, vי), בהתאמה.

מטריצת הסמיכות של גרף דו -מפלסי אינה חד -מודרית לחלוטין. המשמעות היא שהגורם של כל תת מטריצה ​​מרובעת שלה הוא -1, 0 או +1.

וריאציות עריכה

א (א, ב, ג) -מטריצת סמיכות A של גרף פשוט יש אאני,י = א אם (אני, י) הוא קצה, b אם הוא לא, ו- c באלכסון. מטריצת הסמיכות לסיידל היא מטריצת (-1, 1, 0) -סמיכות. מטריצה ​​זו משמשת בלימוד גרפים ושני גרפים רגילים. [3]

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

עריכת גרפים לא מכוונים

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

הקואורדינטות הן 0–23.
שדות לבנים הם אפסים, שדות צבעוניים הם כאלה.

עריכת גרפים מכוונים

מטריצת הסמיכות של גרף מכוון יכולה להיות אסימטרית. אפשר להגדיר את מטריצת הסמיכות של גרף מכוון או כך

  1. אלמנט שאינו אפס אij מציין קצה מ- i עד j או
  2. זה מצביע על קצה מ- j ל- i.

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

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

הקואורדינטות הן 0–23.
כפי שהגרף מכוון, המטריצה ​​אינה בהכרח סימטרית.

עריכת גרפים טריוויאליים

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

עריכת ספקטרום

מטריצת הסמיכות של גרף פשוט לא מכוון היא סימטרית, ולכן יש לה מערך שלם של ערכים עצמיים אמיתיים ובסיס וקטור עצמי אורטוגונלי. קבוצת הערכים העצמיים של הגרף היא ספֵּקטרוּם של הגרף. [7] מקובל לציין את הערכים העצמיים ב- λ 1 ≥ λ 2 ≥ ⋯ ≥ λ n. < displaystyle lambda _ <1> geq lambda _ <2> geq cdots geq lambda _.>

עבור גרפים d -רגילים, d הוא הערך העצמי הראשון של A עבור הווקטור v = (1,…, 1) (קל לבדוק שזה ערך עצמי וזה המקסימום בגלל הגבול לעיל). ריבוי הערך העצמי הזה הוא מספר המרכיבים המחוברים של G, בפרט λ 1 & gt λ 2 < displaystyle lambda _ <1> & gt lambda _ <2>> עבור גרפים מחוברים. ניתן להראות כי עבור כל ערך עצמי λ i < displaystyle lambda _>, ההיפך שלו -λ i = λ n + 1 -i < displaystyle - lambda _= lambda _> הוא גם ערך עצמי של A אם G הוא גרף דו -צדדי. [8] בפרט - d הוא ערך עצמי של גרפים דו -מפלגתיים.

איזומורפיזם ומשתנים עריכה

נניח שני גרפים מכוונים או לא מכוונים ז1 ו ז2 עם מטריצות סמיכות א1 ו א2 ניתנים. ז1 ו ז2 הם איזומורפיים אם ורק אם קיימת מטריצת תמורה P כזו

באופן מיוחד, א1 ו א2 דומים ולכן יש להם את אותו פולינום מינימלי, פולינום אופייני, ערכים עצמיים, קובע ועקבות. אלה יכולים אפוא לשמש כמשתנים איזומורפיזם של גרפים. עם זאת, שני גרפים עשויים להכיל את אותה מערך הערכים העצמיים אך לא להיות איזומורפיים. [9] אומרים כי אופרטורים לינארים כאלה הם איזוספקטרליים.

מטריקס סמכויות עריכה

אם A היא מטריצת הסמיכות של הגרף G המכוון או הלא מכוון, אז המטריצה א נ (כלומר, תוצר המטריצה ​​של n עותקים של A) יש פרשנות מעניינת: האלמנט (אני, י) נותן את מספר ההליכות (מכוונות או לא מכוונות) באורך n מקודקוד i לקודקוד j. אם n הוא המספר השלם הבלתי -שלילי הקטן ביותר, כך שעבור i, j, האלמנט (אני, י) של א נ הוא חיובי, אז n הוא המרחק בין קודקוד i לקודקוד j. זה מרמז, למשל, שמספר המשולשים בגרף G לא מכוון הוא בדיוק העקוב של א 3 חלקי 6. ניתן להשתמש במטריצת הסמיכות כדי לקבוע אם הגרף מחובר או לא.

מטריצת הסמיכות עשויה לשמש כמבנה נתונים לייצוג גרפים בתוכנות מחשב לצורך מניפולציה של גרפים. מבנה הנתונים האלטרנטיבי העיקרי, הנמצא בשימוש גם ביישום זה, הוא רשימת הסמיכות. [10] [11]

מכיוון שכל ערך במטריצת הסמיכות דורש רק ביט אחד, ניתן לייצגו בצורה קומפקטית מאוד, ולתפוס רק | ו | 2 /8 בתים לייצוג גרף מכוון, או (על ידי שימוש בפורמט משולש ארוז ואחסון רק החלק המשולש התחתון של המטריצה) בערך | ו | 2/16 בתים לייצוג גרף לא מכוון. למרות שניתן לייצג מעט יותר תמציתי, שיטה זו מתקרבת לגבול התחתון -תיאורטי של המספר המינימלי של הביטים הדרושים לייצוג כל הגרפים n -vertex. [12] לאחסון גרפים בקובצי טקסט, ניתן להשתמש בפחות סיביות לבייט כדי להבטיח שכל הבייטים הם תווי טקסט, למשל באמצעות ייצוג Base64. [13] מלבד הימנעות משטח מבוזבז, קומפקטיות זו מעודדת יישוב התייחסות. עם זאת, עבור גרף דליל גדול, רשימות סמיכות דורשות פחות שטח אחסון, מכיוון שהן אינן מבזבזות מקום לייצוג קצוות שהם לֹא מתנה. [11] [14]

צורה חלופית של מטריצת סמיכות (אשר, עם זאת, דורשת כמות גדולה יותר של שטח) מחליפה את המספרים בכל אלמנט במטריצה ​​עם מצביעים לאובייקטים של קצוות (כאשר קיימים קצוות) או מצביעות null (כאשר אין קצה). [14] אפשר גם לאחסן משקל קצה ישירות במרכיבי מטריצת סמיכות. [11]

מלבד הפשרה בחלל, מבני הנתונים השונים מאפשרים גם פעולות שונות. מציאת כל הקודקודים הסמוכים לקודקוד נתון ברשימת סמיכות היא פשוטה כמו קריאת הרשימה, ולוקח זמן ביחס למספר השכנים. עם מטריצת סמיכות, במקום זאת יש לסרוק שורה שלמה, שלוקחת זמן רב יותר, ביחס למספר הקודקודים בתרשים כולו. מאידך גיסא, ניתן לקבוע בבת אחת בדיקת אם יש קצה בין שני קודקודים נתונים בעזרת מטריצת סמיכות, תוך דרישת זמן ביחס למידה המינימלית של שני הקודקודים עם רשימת הסמיכות. [11] [14]


סמיכות לכלי WinBUGS

הכלי Adjacency For WinBUGS הוא התאמה אישית של ArcMap. הכלי מעבד באופן איטרטיבי כל מצולע בתוך שכבה שנבחרה ויוצר קובץ טקסט של סמיכות מצולעת כאשר כל מצולע מזוהה על ידי ערך Adj_ID ייחודי. הפלט של כלי זה משמש ב- WinBUGS (יחידת ביו -סטטיסטיקה MRC קיימברידג ') על -ידי ההפצות האוטורגרסיביות המותנות של car.normal, car.l1 ו- mv.car.

"עבדנו עם סוג של מודלים הנקראים מודלים של ספירה מרחבית היררכית (http://www.umesc.usgs.gov/terrestrial/migratory_birds/bird_conservation.html). דגמים אלה מצוידים בשיטות שרשרת מארקוב מונטה קרלו ב- WinBUGS. כדי להתאים את הפוטנציאל לקורלציה מרחבית בין התגובות, אנו משתמשים במרכיב אוטוריגרסיבי מותנה במרחב (CAR מרחבית). מכונית מרחבית זו דורשת מטריצת סמיכות, כלומר מטריצה ​​המתייחסת ליחידת שטח אחת לאוסף של יחידות שטח שכנות. דרישה למטריצה ​​זו היא סימטריה. GeoBUGS בתוך תוכנת WinBUGS יכולה להקל על יצירת מטריצת סמיכות זו, אך נראה לנו הרבה יותר נוח לבצע את כל פעולות המיפוי שלנו ב- ArcGIS. ככזה, כלי שמקל על יצירת מטריצת הסמיכות לשימוש ב- WinBUGS הוא השימושי ביותר. "
ד"ר וויין טוגמרטין

  1. שמור את הקובץ: AdjacencyForWinBUGS.zip לכונן הקשיח המקומי שלך
  2. חלץ תוכן
  3. לחץ לחיצה כפולה AdjacencyForWinBUGS.esriAddIn קוֹבֶץ
  4. לִפְתוֹחַ ArcMap 10
  5. הקלק על ה התאמה אישית התפריט וה התאמה אישית של מצב ... פריט
  6. על התאמה אישית שיח לחץ על פקודות כרטיסייה
  7. גלול למטה ולחץ על Fox Tools ב- קטגוריות רשימה
  8. לגרור את סמיכות ל- WinBUGS כפתור לסרגל הכלים ב ArcMap 10 מִמְשָׁק

איור 1. ה סמיכות ל- WinBUGS דו שיח.

  1. לחץ על AdjacencyForWinBUGS כפתור לפתיחת סמיכות ל- WinBUGS דיאלוג (איור 1).
  2. בחר קובץ צורה של מצולע הניתן לעריכה.
  3. לחץ על לְדַפדֵף כפתור ולזהות את ספריית הפלט.
  4. נְקִישָׁה בסדר לַחְצָן.
  5. ביצוע התוכנית:
    1. התיקייה שצוין על ידי המשתמש ב- ספריית פלט תיבת הטקסט נוצרת.
      1. שם התיקיה יהיה בעל המבנה הבא: ספריית זיהוי משתמש + שם שכבה +_ סמוך_+ מספר איטרטיבי.
      2. תווים בשם התיקיה החדשה הבעייתיים ל- ArcMap יוחלפו בתווים תחתונים.
      3. דמויות בעייתיות כוללות

      1. Raw.txt: כל שורה בקובץ הפלט מכילה רשימת מספרים. המספר הראשון ברשימה הוא ה- Adj_ID של מצולע הקלט כל המספרים הבאים ברשימה הם Adj_ID ערכים של מצולעים הסמוכים למצולע הקלט. רק מצולע הקלט Adj_ID יירשם אם אין לו שכנים סמוכים.
      2. Adj.txt: זהה ל Raw.txt קובץ עם יוצא מן הכלל אחד, המוביל Adj_ID הערך של מצולע הקלט מושמט. אם למצולע הקלט אין שכנים סמוכים, אז נכנסת שורה ריקה.
      3. Num.txt: מכיל את מספר השכנים עבור כל מצולע קלט.
      4. SumNumNeigh.txt: סכום הערכים הכלולים ב- Num.txt.

      השפעת מדע UMESC

      החישוב הבייסיאני הופך לאמצעי חשוב יותר ויותר לניתוח סטטיסטי של נתונים. שיטות אלה מתאימות היטב לדגמן נתונים מורכבים, כולל נתונים מרחביים, ותוכנות כגון WinBUGS ו- R קיימות כדי להקל על חישובים אלה. למרבה הצער, נתונים מרחביים מורכבים אלה דורשים הכנה קפדנית לניתוח נכון. כלי הסמיכות מקל על ניתוח זה על ידי עיצוב קל של נתונים מרחביים ב- ArcGIS, מערכת המידע הגאוגרפית השולטת בעולם. כלים כגון כלי הסמיכות מסייעים לגשר על פער המידע בין תוכנות סטטיסטיות למערכות מידע גיאוגרפיות.


      מטריצת סמיכות לפוליגונים באמצעות Java - מערכות מידע גיאוגרפיות

      גרף הוא מבנה נתונים המורכב משני המרכיבים הבאים:
      1. קבוצה סופית של קודקודים הנקראת גם כצמתים.
      2. קבוצה סופית של זוג מסודר של הטופס (u, v) הנקרא קצה. הצמד מסודר מכיוון (u, v) אינו זהה ל- (v, u) במקרה של גרף מכוון (di-graph). צמד הצורה (u, v) מציין שיש קצה מקודקוד u לקודקוד v. הקצוות עשויים להכיל משקל/ערך/עלות.
      גרפים משמשים לייצוג יישומים רבים בחיים האמיתיים: גרפים משמשים לייצוג רשתות. הרשתות עשויות לכלול נתיבים ברשת עירונית או טלפונית או במעגל. גרפים משמשים גם ברשתות חברתיות כמו linkedIn, Facebook. לדוגמה, בפייסבוק, כל אדם מיוצג עם קודקוד (או צומת). כל צומת הוא מבנה ומכיל מידע כמו מזהה אדם, שם, מין ואזור. ראה זאת ליישומים נוספים של גרף.
      להלן דוגמה של גרף לא מכוון עם 5 קודקודים.

      השניים הבאים הם הייצוגים הנפוצים ביותר של גרף.
      1. מטריקס שכנות
      2. רשימת סמיכות
      ישנם ייצוגים אחרים כמו גם, מטריצת ההיארעות ורשימת ההיארעות. הבחירה בייצוג הגרף היא ספציפית למצב. זה תלוי לחלוטין בסוג הפעולות שיש לבצע ובנוחות השימוש.
      מטריקס שכנות:
      Matrix Adjacency הוא מערך דו ממדי בגודל V x V כאשר V הוא מספר הקודקודים בגרף. תן למערך הדו מימד להיות adj [] [], adj adj [i] [j] = 1 מציין שיש קצה מקודקוד i לקודקוד j. מטריצת סמיכות לגרף לא מכוון היא תמיד סימטרית. מטריצת Adjacency משמשת גם לייצוג גרפים משוקללים. אם adj [i] [j] = w, אז יש קצה מקודקוד i לקודקוד j עם משקל w.

      מטריצת הסמיכות של גרף הדוגמה לעיל היא:

      יתרונות: ייצוג קל יותר ליישום ולעקוב אחריו. הסרת קצה לוקחת זמן O (1). שאילתות כמו האם יש קצה מקודקוד ‘u ’ ועד קודקוד ‘v ’ יעילות וניתנות לביצוע O (1).
      חסרונות: צורכת יותר מקום O (V^2). גם אם הגרף דליל (מכיל פחות מספר קצוות), הוא צורך את אותו שטח. הוספת קודקוד היא זמן O (V^2).
      אנא ראה זאת לקבלת יישום לדוגמא של פייתון של מטריצת סמיכות.
      רשימת סמיכות:
      נעשה שימוש במערך של רשימות. גודל המערך שווה למספר הקודקודים. תן למערך להיות מערך []. מערך כניסה [i] מייצג את רשימת הקודקודים הסמוכים ל- אניקודקוד ה. ייצוג זה יכול לשמש גם לייצוג גרף משוקלל. ניתן לייצג את משקולות הקצוות כרשימות זוגות. להלן ייצוג רשימת הסמיכות של הגרף לעיל.

      שים לב שביישום שלהלן, אנו משתמשים במערכים דינאמיים (וקטור ב- C ++/ArrayList בג'אווה) כדי לייצג רשימות סמיכות במקום הרשימה המקושרת. ליישום הווקטור יש יתרונות של ידידותיות למטמון.


      יישום גרף רשימת סמיכות כללית

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

      אבל מה שיש לי עד כה. וזה מיושם ב- Java. הוא בעצם מחלקת edgeNode בעלת סוג כללי ומשקל-במקרה שהגרף אכן משוקלל.

      יש לי מחלקת גרפים הכוללת רשימת קצוות ערך למספר האנכיות וערך int לקצוות וכן ערך בוליאני אם הוא מכוון או לא. השאלה מעלה את השאלה הראשונה שלי, אם הגרף אכן מכוון, האם לא אמור להיות לי ערך במחלקת edgeNode שלי? או שאני פשוט צריך להוסיף קודקודים נוספים ל- LinkedList שלי? זה מרמז שגרף מכוון גדול פי 2 כמו גרף לא מכוון?

      לבסוף למישהו יש דרך סטנדרטית לאתחל את הגרף? חשבתי לקרוא בקובץ תחום צינורות אבל זה כל כך 1997.

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

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

      מצאתי הדרכה מקוונת זו הדרכת גרף שיש בה אובייקט מחבר. נראה לי שזה אוסף של קודקודים שמצביעים זה לזה. אז יהיה לך A ו- B לכל אחד מהם משקלים וכן הלאה, והיית מוסיף זאת לרשימה ולרשימת המחברים הזו לתרשים שלך. זה נראה לי קצת מסורבל וקצת מזלזל בקונספט של רשימת הסמיכות? האם אני טועה וזהו פתרון חדש?

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


      מציאת הנתיב הקצר ביותר בגרף ללא חיבור מלא המחובר

      אני מנסה לפתור בעיה שבה יש לי רשימה של קואורדינטות דו-ממדיות, ואני רוצה למצוא את הדרך הקצרה ביותר המחברת את כולן.

      בהתחלה חשבתי שמדובר במקרה של בעיה של איש מכירות נוסע:

      • אתה לא צריך לחזור לעיר ההתחלתית, שאני מאמין ש- TSP רוצה שתעשי זאת.
      • במישור הדו-ממדי הזה שבו אנו עובדים עם מדד המרחק האוקלידי, מחזיק אי-השוויון במשולש, שלאלגוריתמי ה- TSP הרגילים לא אכפת מהם, אם אני זוכר נכון.
      • אין כלל 'אתה יכול לבקר בצומת פעם אחת' בבעיה זו 'הדרך הקצרה ביותר' יכולה ליצור עץ.

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

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


      הצהרות שדה אובייקט

      אז אתה לא צריך לציין קונסטרוקטור בכלל.

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

      משתנים מיותרים

      למה לטרוח עם numVertices? למה לא

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

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

      אתה לא צריך להשתמש בזה. עם שדות אובייקטים בג'אווה אלא אם יש התנגשות בין משתנה/פרמטר מקומי לשדה אובייקט. אתה יכול. זה יעבוד מצוין. אבל אתה לא צריך לעשות זאת. יש המגלים שהוא הופך את הקוד לקריא יותר בכך שהוא מצביע על כך שמשתנה מסוים הוא שדה אובייקט ולא משהו מקומי. ההעדפה האישית שלי היא לעזוב אותו אלא אם יש צורך.

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

      ניב לא עקבי

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

      כך או כך, יש לך רק קצוות בגרף בין שני קודקודים בגרף.

      עכשיו, במקום לבדוק תמיד נוכחות, אנו מניחים שדברים יהיו שם עד שיגידו שהם לא. שינוי זה בדפוס כמעט תמיד עובד כאשר מכיל keykey מיד אחריו get.

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

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


      צפו בסרטון: Uniform Cost Search