מבוא למדעי המחשב

מבוא למדעי המחשב גרפים 1

תוכן עניינים סיכום ביניים

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

תוכן עניינים סיכום ביניים גרפים

גרפים הגדרה אינטואיטיבית קבוצה של קדקודים nodes) או (vertices חלקם מקושרים זה לזה בעזרת קשתות (edges) הקשתות יכול להיות מכוונות או לא-מכוונות גרף בו הקשתות מכוונות נקרא גרף מכוון. גרף בו הקשתות לא מכוונות נקרא גרף לא מכוון בגרף לא מכוון לקשתות אין כיוון בגרף לא מכוון אין קשתות עצמיות

גרפים הגדרה פורמלית גרף הוא זוג סדור (VVVVV),GG = כאשר 0 VV היא קבוצה של קדקודים EE VV XX VV היא קבוצה של קשתות בין הקדקודים הנ"ל דוגמה VV = {0,1,2,3 EE = { 0,3, 1,2, 3,1,{2,3 (nn 1) לשם פשטות תמיד נניח שבגרף בן nn קדקודים הקדקודים ממוספרים בין 0 ל-

גרפים כמה מושגים 0 דרגה של קדקוד מספר הקשתות שנוגעות בקדקוד למשל, = 2 dddddddddddd(1) שכנים של קדקוד הקדקודים שבינם לבין הקדקוד עוברת קשת למשל, = 2,3 1 nnnnnnnnhbbbbbbbb מסלול בגרף רשימה של קדקודים שבין כל שניים עוקבים עוברת קשת למשל, > 1,2,3,0,3,1 <

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף

המחלקה Edge public class Edge { public final int left; public final int right; public Edge(int left, int right) { this.left = left; this.right = right; קדקוד מיוצג פשוט על ידי מספר שלם (אובייקט מהמחלקה (Integer קשת תיוצג באמצעות המחלקה edge שמשמאל public String tostring() { return {" + left + ", " + right + ";

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף הממשק Graph

public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset(); הממשק Graph

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף הממשק Graph ייצוג של גרפים

ייצוג גרפים 0 שתי שיטות נפוצות (Adjacency Lists) (Adjacency Matrix) רשימות שכנים מטריצת שכנים יש שיטות נוספות Adjacency Lists Adjacency Matrix 0 1 2 3 0 3 0 false false false true 1 2 2 3 1 3 1 2 false false true true false true false true 3 0 2 1 3 true true true false

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

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

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

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

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

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

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

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף הממשק Graph ייצוג של גרפים מחלקות אבסטרקטיות המחלקה AbstractGraph

שדה ובנאי המחלקה AbstractGraph public abstract class AbstractGraph implements Graph { protected final int nvertices; public AbstractGraph(int nvertices) { this.nvertices = nvertices; public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה AbstractGraph protected final int nvertices;... public int numberofvertices() { return nvertices; // Default implementation public int numberofedges() { return edgeset().size(); // Default implementation public int degree(int v) { return neighborsof(v).size(); public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה AbstractGraph protected final int nvertices;... // Default implementation public Set<Integer> neighborsof(int v) { Set<Integer> adj = new SetAsLinkedList<>(); for (int u = 0; u < nvertices; u = u + 1) if (u!= v && containsedge(u, v)) adj.add(u); return adj; containsedge זורק חריגה במקרה ש- u=v (נראה בהמשך) public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset(); c

שיטות המחלקה AbstractGraph protected final int nvertices;... // Default implementation public Set<Edge> edgeset() { Set<Edge> edges = new SetAsLinkedList<>(); for (int u = 0; u < nvertices - 1; u = u + 1) for (int v = u + 1; v < nvertices; v = v + 1) if (containsedge(u, v)) edges.add(new Edge(u, v)); return edges; public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה AbstractGraph protected final int nvertices;... public String tostring() { return "G=([" + 0 + ".. " + (nvertices - 1) + "], " + edgeset() + ")"; public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה AbstractGraph protected final int nvertices;... public boolean equals(object x) { if (!(x instanceof Graph)) return false; Graph other = (Graph) x; return this.nvertices == other.numberofvertices() && this.edgeset().equals(other.edgeset()); public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה AbstractGraph protected final int nvertices;... public abstract boolean containsedge(int u, int v); public abstract void addedge(int u, int v); public abstract void removeedge(int u, int v); לא חובה להכריז, הן כבר מוכרזות בממשק public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה AbstractGraph protected final int nvertices;... protected boolean edgecheck(int u, int v) { return u >= 0 && u < nvertices && v >= 0 && v < nvertices && u!= v; public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף הממשק Graph ייצוג של גרפים מחלקות אבסטרקטיות המחלקה AbstractGraph המחלקה GraphAsAdjacencyMatrix

שדה המחלקה GraphAsAdjacencyMatrix ובנאי פשוט public class GraphAsAdjacencyMatrix extends AbstractGraph { private boolean[][] edges; public GraphAsAdjacencyMatrix(int nvertices) { super(nvertices); edges = new boolean[nvertices][nvertices]; public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

המחלקה GraphAsAdjacencyMatrix בנאי מעתיק private boolean[][] edges;... public GraphAsAdjacencyMatrix(Graph other) { this(other.numberofvertices()); Set<Edge> otheredges = other.edgeset(); for (Edge e : otheredges) addedge(e.left, e.right); public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה GraphAsAdjacencyMatrix private boolean[][] edges;... public boolean containsedge(int u, int v) { if (!edgecheck(u, v)) throw new IllegalArgumentException(); return edges[u][v]; public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה GraphAsAdjacencyMatrix private boolean[][] edges;... public void addedge(int u, int v) { if (!edgecheck(u, v)) throw new IllegalArgumentException(); edges[u][v] = true; edges[v][u] = true; public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

שיטות המחלקה GraphAsAdjacencyMatrix private boolean[][] edges;... public void removeedge(int u, int v) { if (!edgecheck(u, v)) throw new IllegalArgumentException(); edges[u][v] = false; edges[v][u] = false; public interface Graph { int numberofvertices(); int numberofedges(); boolean containsedge(int u, int v); void addedge(int u, int v); void removeedge(int u, int v); int degree(int u); Set<Integer> neighborsof(int u); Set<Edge> edgeset();

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף הממשק Graph ייצוג של גרפים מחלקות אבסטרקטיות המחלקה AbstractGraph המחלקה GraphAsAdjacencyMatrix המחלקה GraphAlgorithm

המחלקה האבסטרקטית GraphAlgorithm כדי לפעול על גרפים נגדיר מחלקה אבסטרקטית שתשמש כאופרטור של גרפים הבנאי מקבל כפרמטר את הגרף האלגוריתם ממומש על ידי דריסה של השיטה האבסטרקטית runalgorithm מחלקה אחת יכולה לממש אלגוריתם לבדיקת קשירות של גרף מחלקה אחרת יכולה לממש אלגוריתם שבודק אם יש מעגלים בגרף public abstract class GraphAlgorithm { protected Graph g; public GraphAlgorithm(Graph g) { this.g = g; public abstract Object runalgorithm();

המחלקה EvenDegreesAlgorithm מרחיבה את GraphAlgorithm ומגדירה אובייקט שבודק אם הדרגה של גרף נתון היא זוגית (דרגת כל הקדקודים בגרף זוגית) public class EvenDegreesAlgorithm extends GraphAlgorithm { public EvenDegreesAlgorithm(Graph g) { super(g); public Object runalgorithm() { for (int u = 0; u < g.numberofvertices(); u = u + 1) if (g.degree(u) % 2!= 0) return false; return true;

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף הממשק Graph ייצוג של גרפים מחלקות אבסטרקטיות המחלקה AbstractGraph המחלקה GraphAsAdjacencyMatrix המחלקה GraphAlgorithm קשירות

קשירות נאמר שגרף הוא קשיר אם בין כל זוג קדקודים בגרף עובר מסלול לא קשיר קשיר 0 6 0 1 2 1 2 7 3 4 5 3 4 5

בדיקת קשירות של גרף 0 1 2 3 7 4 5 6 נתחיל את הבדיקה מקדקוד כלשהו (נניח קדקוד 0) ואז ברקורסיה בסיום נסמן שביקרנו בו נסרוק את שכניו עבור כל שכן שעדיין לא ביקרנו בו (לא סומן) נתחיל ברקורסיה בדיקה חדשה מהשכן הזה אם כל הקדקודים סומנו הגרף קשיר אחרת הגרף לא קשיר

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף הממשק Graph ייצוג של גרפים מחלקות אבסטרקטיות המחלקה AbstractGraph המחלקה GraphAsAdjacencyMatrix המחלקה GraphAlgorithm קשירות המחלקה ConnectivityAlgorithm

private boolean isreachedall(boolean[] visited) { for (boolean isvisited : visited) if (!isvisited) return false; return true; המחלקה ConnectivityAlgorithm מרחיבה את GraphAlgorithm ומגדירה אובייקט שבודק אם גרף נתון הוא גרף קשיר public class ConnectivityAlgorithm extends GraphAlgorithm { public ConnectivityAlgorithm(Graph g) { super(g); public Object runalgorithm() { boolean[] visited = new boolean[g.numberofvertices()]; dfs(0, visited); return isreachedall(visited); private void dfs(int u, boolean[] visited) { visited[u] = true; for (Integer v : g.neighborsof(u)) if (!visited[v]) dfs(v, visited);

דוגמת הרצה public static void main(string[] args) { Graph g = new GraphAsAdjacencyMatrix(10); for (int u = 0; u < g.numberofvertices(); u = u + 1) g.addedge(u, (u + 1) % g.numberofvertices()); System.out.println(g); GraphAlgorithm ca = new ConnectivityAlgorithm(g); System.out.println(ca.runAlgorithm()); // true g.removeedge(0, 1); System.out.println(ca.runAlgorithm()); // true g.removeedge(4, 5); System.out.println(ca.runAlgorithm()); // false

תוכן עניינים סיכום ביניים גרפים קדקוד וקשת של גרף הממשק Graph ייצוג של גרפים מחלקות אבסטרקטיות המחלקה AbstractGraph המחלקה GraphAsAdjacencyMatrix המחלקה GraphAlgorithm קשירות המחלקה ConnectivityAlgorithm המבנים שראינו

המבנים שראינו ושניראה בהמשך interface: Graph implements GraphAlgorithm extends AbstractGraph EvenDegreesAlgorithm extends ConnectivityAlgorothm GraphAsAdjacencyMatrix EulerPathAlgorithm GraphAsAdjacencyLists