1 Grafalgoritmer I

2 Plan Grafer - definition - anvendelser - terminologi - eksempler på grafproblemer Grafgennemgang - dybde-først-gennemgang - bredde-først-gennemgang Sammenhæng - 2-sammenhæng - (foren-og-find)

3 Grafer En graf er et nyttigt abstrakt begreb. Intuitiv definition: En graf er en mængde af objekter og forbindelser imellem disse. Matematisk definition: En graf G = (V,E) består af en endelig mængde af knuder, V, og en endelig mængde af kanter, E, hvor hver kant forbinder to af knuderne (E  V x V). A B C G F D E H I V = {A, B, C, D, E, F, G, H, I} E = {(A,B),(A,C),(A,F),(A,G),(D,E),(D,F),(E,F),(E,G),(H,I)}

4 Anvendelsesområder Alt, hvad der involverer relationer imellem objekter, kan modelleres ved hjælp af en graf Trafiknetværk: Knuder: byer, vejkryds Kanter: veje Projektplanlægning: Knuder: delopgaver Kanter: præcedenser (A skal udføres før B) Objektorienteret design (UML-diagrammering): Knuder: klasser/objekter Kanter: nedarvning, aggregering eller associering Programsystemer: Knuder: rutiner Kanter: rutine A kan kalde rutine B Organiske molekyler: Knuder: atomer Kanter: bindinger Elektriske kredsløb: Knuder: komponenter Kanter: ledninger

5 Terminologi En orienteret graf er en graf, hvor alle kanter er orienterede. En ikke-orienteret graf er en graf, hvor ingen kanter er orienterede. H I Hvis rækkefølgen af en kants endeknuder har betydning, kaldes kanten for orienteret. Dette angives på den grafiske repræsentation ved at kanten forsynes med en pil. Endeknuderne kaldes da for henholdsvis begyndelsesknuden og slutknuden. H I En kants 2 knuder kaldes endeknuder for kanten.

6 Terminologi (fortsat) En vej er en liste af knuder, hvor successive knuder er forbundet med en kant. En vej kaldes simpel, hvis ingen knude gentages. En cykel er en vej, der er simpel, bortset fra at den første og sidste knude er den samme. A B C G F D E Cykler: FDEF, AFEGA og AFDEGA.

7 Terminologi (fortsat) En graf G’ = (V’,E’) er en delgraf af G = (V,E), hvis V’  V  og E’  E. En graf kaldes sammenhængende, hvis der for enhver knude findes en vej til enhver anden knude. En graf, der ikke er sammenhængende, består af sammenhængende delgrafer, også kaldet komponenter. A B C G F D E H I 2 komponenter

8 Et træ er en sammenhængende graf uden cykler. En mængde af disjunkte træer kaldes en skov. Et udspændende træ for en graf G er en delgraf af G, der indeholder alle grafens knuder, og som udgør et træ. Terminologi (fortsat) Graf G Udspændende træ for G

9 Terminologi (fortsat) En graf, hvor enhver knude er forbundet med enhver anden knude, kaldes for komplet. [ for en ikke-orienteret graf: E = V*(V-1)/2) ] En tynd graf er en graf med relativt få kanter. En tæt graf er en graf med relativt mange kanter. En vægtet graf er en graf, hvor kanterne er forsynet med talværdier, kaldet vægte. [ vægtene repræsenterer normalt omkostninger ]

10 Basale grafproblemer Veje: Er der en vej fra knude A til knude B? Cykler: Indeholder grafen en cykel? Sammenhæng (udspændende træ): Er der for hver knude en vej til enhver anden knude? 2-sammenhæng: Vil grafen blive usammenhængende, hvis en af knuderne (og de tilstødende kanter) fjernes? Planaritet: Kan grafen tegnes, uden at to kanter krydser hinanden?

11 Basale grafproblemer (fortsat) Korteste vej: Hvilken vej er den korteste mellem knude A og knude B? Længste vej: Hvilken vej er den længste mellem knude A og knude B? Minimalt udspændende træ: Hvad er den billigste måde at forbinde alle knuder? Hamilton-cykel: Er der en cykel, som indeholder samtlige knuder? Den rejsende sælgers problem: Hvilken Hamilton-cykel er den billigste? Isomorfi: Symboliserer to grafrepræsentationer den samme graf?

12 Repræsentation af grafer Grafer er abstrakte matematiske objekter. Algoritmer må arbejde med konkrete repræsentationer. Mange mulige repræsentationer. Valget er bestemt af algoritmer og graftyper (tynde/tætte, vægtede/uvægtede, orienterede/ikke-orienterede). I det følgende gennemgås 3 repræsentationer: (1) kantmængde (2) nabomatrix (3) nabolister

13 (1) Kantmængde-repræsentation A B C G F D E H I endNode[0][0] = A, endNode[0][1] = G endNode[1][0] = A, endNode[1][1] = B endNode[2][0] = A, endNode[2][1] = C endNode[3][0] = E, endNode[3][1] = D endNode[4][0] = F, endNode[4][1] = D endNode[5][0] = H, endNode[5][1] = I endNode[6][0] = F, endNode[6][1] = E endNode[7][0] = A, endNode[7][1] = F endNode[8][0] = G, endNode[8][1] = E

14 class Graph { int V, E, endNode[][]; void read() { V = IO.readInt(); E = IO.readInt(); endNode = new int[E][2]; for (int i = 0; i < E; i++) { endNode[i][0] = IO.readInt(); endNode[i][1] = IO.readInt(); } Oprettelse af kantmængde Her identificeres knuderne ved heltal. Hvis knuderne er navngivet ved tegnstrenge kan metoderne index og name defineres int index(String nodeName) String name(int nodeIndex)

15 Kantmængde-repræsentation ved hjælp af kant-objekter class Graph { int V, E; Vector edges; void read() { V = IO.readInt(); E = IO.readInt(); edges = new Vector(E); for (int i = 1; i <= E; i++) edges.addElement( new Edge(IO. readInt(), IO. readInt()); } class Edge { int v1, v2; Edge(int a, int b) { v1 = a; v2 = b; } }

16 (2) Nabomatrix-repræsentation A B C D E F G H I A B C D E F G H I A B C G F D E H I Bemærk. Dobbelt repræsentation af hver kant, hvis grafen er ikke-orienteret.

17 class Graph { int V, E; boolean a[][]; void read() { V = IO.readInt(); E = IO.readInt(); a = new boolean[V+1][V+1]; for (int x = 1; x <= V; x++) a[x][x] = true; for (int i = 1; i <= E; i++) { int x = IO.readInt(); int y = IO.readInt(); a[x][y] = a[y][x] = true; } Oprettelse af nabomatrix

18 class Graph { int V, E; BitSet a[]; void read() { V = IO.readInt(); E = IO.readInt(); a = new BitSet[V+1]; for (int x = 1; x <= V; x++) { a[x] = new BitSet(V+1); a[x].set(x); } for (int i = 1; i <= E; i++) { int x = IO.readInt(); int y = IO.readInt(); a[x].set(y); a[y].set(x); } Repræsentation ved hjælp af Javas class BitSet a[x].get(y) : Er ( x, y ) kant i grafen?

19 A: B: C: D: E: F: G: H: I: (3) Naboliste-repræsentation A B C G F D E H I FCB G A A FE GFD AED E A I H Bemærk. Dobbelt repræsentation af hver kant, hvis grafen er ikke-orienteret.

20 Oprettelse af nabolister class Node { int v; Node next; Node(int vv; Node nn) { v = vv; next = nn; } } class Graph { int V, E; Node adj[], z; void read() { V = IO.readInt(); E = IO.readInt(); adj = new Node[V+1]; z = new Node(0, null); z.next = z; for (int i = 1; i <= V; i++) adj[i] = z; for (int i = 1; i <= E; i++) { int x = IO.readInt(); int y = IO.readInt(); adj[x] = new Node(y, adj[x]); adj[y] = new Node(x, adj[y]); }

21 Sammenligning af repræsentationer Pladskrav: Kantmængde:O(E (+V)) Nabomatrix:O(V 2 ) Nabolister: O(V + E) Repræsentation påvirker algoritmers effektivitet. Værste tilfælde: Er der en kant fra knude A til knude B? Kantmængde: O(E) Nabomatrix: O(1) Nabolister: O(V) Er der en kant fra knude A? Kantmængde: O(E) Nabomatrix O(V) Nabolister: O(1)

22 Mål: at besøge enhver knude i grafen. Dybde-først-gennemgang: Rekursiv algoritme: * Mærk alle knuder “ubesøgt” (unseen). * Ved besøg af en knude k: Mærk knuden “besøgt” Besøg (rekursivt) alle ubesøgte knuder, der er forbundet med k. * Besøg knude 1. Besøg derefter en ubesøgt knude. Fortsæt indtil alle knuder er besøgt. Systematisk gennemgang af grafer Løser nogle simple grafproblemer: sammenhæng, cykler (hvordan?) Basis for løsning af nogle vanskelige grafproblemer: 2-sammenhæng, planaritet

23 void visit(int k) { // adjacency matrix val[k] = ++id; for (int t = 1; t <= V; t++) if (a[k][t] && val[t] == unseen) visit(t); } void visit(int k) { // adjacency lists val[k] = ++id; for (Node t = adj[k]; t != z; t = t.next) if (val[t.v] == unseen) visit(t.v); } void search() { int k; for (k = 1; k <= V; k++) val[k] = unseen; id = 0;// number of visited nodes for (k = 1; k <= V; k++) if (val[k] == unseen) visit(k); } Implementering af dybde-først-gennemgang

24 Dybde-først-gennemgang af en komponent A: F C B G B: A C: A D: F E E: G F D F: A E D G: E A A B C G F D E A B C G F D E A B C G D E F A B C D G E F A B D C G E F A B C G D E F

25 Dybde-først-gennemgang af en graf repræsenteret ved nabolister kræver tid proportional med V + E Dybde-først-gennemgang af en komponent udgør et dybde-først-træ Dybde-først-gennemgang af en graf repræsenteret ved en nabomatrix kræver tid proportional med V 2 A F C B E D G

26 Ikke-rekursiv dybde-først-gennemgang Arrayet val benyttes til nummerering af knuderne i den rækkefølge, de besøges. Knuder med val -værdi -1 er på stakken (og dermed set), men er endnu ikke blevet besøgt. Knuder med val -værdi unseen (= 0 ) er endnu ikke set. Stack stack = new Stack(V); void visit(int k) { // adjacency lists stack.push(k); while (!stack.empty()) { k = stack.pop(); val[k] = ++id; for (Node t = adj[k]; t != z; t = t.next) if (val[t.v] == unseen) { stack.push(t.v); val[t.v] = -1; }

27 A: F C B G B: A C: A D: F E E: G F D F: A E D G: E A Dybde-først-gennemgang med eksplicit stak A B C G D E F A B C G F D E GBCFGBCF A B C G F D E EBCFEBCF A B C G D E F DBCFDBCF A B C D G E F BCFBCF A B C G D E F CFCF A B C G D E F F

28 Stak-baseret dybde-først-træ Er ikke det samme træ som ved rekursiv dybde-først-gennemgang. Hvorfor? Svar: Algoritmerne adskiller sig ved deres behandling af knuder, der støder op til besøgte knuder: Rekursiv: besøg knuden straks Stakbaseret: behandl knuden som besøgt, men besøg den først, når den afstakkes A G C E D F B A F C B E D G

29 void visit(int k) { // adjacency lists stack.push(k); val[k] = ++id; while (!stack.empty()) { k = stack.peek(); Node t; for (t = adj[k]; t != z && val[t.v] != unseen; t = t.next) ; if (t == z) stack.pop(); else { k = t.v; stack.push(k); val[k] = ++id; } Alternativ ikke-rekursiv dybde-først-gennemgang Stakkens benyttes til at huske de knuder, der har ført til den aktuelle knude. Besøgsrækkefølgen er den samme som ved den rekursive udgave af visit.

30 Hvis stakken erstattes med en kø, fremkommer bredde-først-gennemgang. void visit(int k) { // adjacency lists queue.put(k); while (!queue.empty()) { k = queue.get(); val[k] = ++id; for (Node t = adj[k]; t != z; t = t.next) if (val[t.v] == unseen) { queue.put(t.v); val[t.v] = -1; } Bredde-først-gennemgang

31 A: F C B G B: A C: A D: F E E: G F D F: A E D G: E A Bredde-først-gennemgang A B C G D E F A B C G F D E F C B G A B C G F D E C B G E D A B C G D E F B G E D A B C G D E F G E D A B C G D E F E D A B C G D E F D

32 Bredde-først-gennemgang af en komponent udgør et bredde-først-træ A F CB E D G

33 Dybde-først versus bredde-først Dybde-først start aktuel Bredde-først start aktuel

34 En 2-sammenhængende graf er en graf uden artikulationspunkter. Dybde-først-gennemgang kan benyttes til at finde grafens sammenhængende komponenter. Hver gang visit kaldes fra search, besøges samtlige knuder i en sammen-hængende komponent. Dybde-først-gennemgang kan også benyttes til at afgøre om en graf er 2-sammenhængende. En graf siges at være 2- sammenhængende, hvis der ikke findes nogen knude, hvor en sletning medfører en usammenhængende graf. Et knude i en sammenhængende graf kaldes et artikulationspunkt, hvis en sletning af knuden medfører, at grafen opdeles i 2 eller flere sammenhængende komponenter. Sammenhæng

35 Eksempel på en ikke-2-sammenhængende graf Artikulationspunkter: A, G, H og J. En 2-sammenhængende komponent af en graf er en maksimal delmængde af kanter, for hvilken den tilsvarende delgraf er 2-sammenhængende. 2-sammenhængende komponenter: {(A,F),(A,C),(A,G),(C,G),(E,G),(D,E),(E,F),(D,F)} {(G,L),(G,J),(J,L),(J,M),(L,M)} {(A,B)} {(G,H)} {(H,I)} {(J,K)} A B C G F D E H I J K L M

36 En grafs artikulationspunkter kan bestemmes ved dybde-først-gennemgang A BF E D G C H I L MK J En knude er et artikulationspunkt, hvis blot én af dens sønner og alle dennes efterkommere ikke er forbundet (via en stiplet linie) med en knude højere oppe i træet. Roden er et artikulationspunkt, hvis den har to eller flere sønner.

37 Metoden returnerer det mindste val -værdi for sete og besøgte knuder (knuden nærmest roden). Artikulationspunkterne udskrives undervejs. Ændring af metoden visit int visit(int k) { Node t; val[k] = ++id; int min = id; for (t = adj[k]; t != z; t = t.next) if (val[t.v] == unseen) { int m = visit(t.v); if (m < min) min = m; if (m >= val[k]) IO.println(name(k)); } else if (val[t.v] < min) min = val[t.v]; return min;} Test på rod udeladt

38 Klassen Edge indføres: Bestemmelse af 2-sammenhængende komponenter (opgave 30.4 i lærebogen) class Edge { int v1, v2; Edge(int a, int b) { v1 = a; v2 = b; } public boolean equals(Object o) { Edge e = (Edge) o; return (v1 == e.v1 && v2 == e.v2) || (v1 == e.v2 && v2 == e.v1); } public String toString() { return "(" + name(v1) + ", " + name(v2) + ")"; } } Dernæst ændres metoden visit. En stak benyttes til at bestemme de 2-sammenhængende komponenter.

39 int visit(int k) { val[k] = ++id; int min = id; for (Node t = adj[k]; t != z; t = t.next) { Edge e = new Edge(k, t.v); if (!stack.contains(e)) stack.push(e); if (val[t.v] == unseen) { int m = visit(t.v); if (m < min) min = m; if (m >= val[k]) { Edge x; do { x = (Edge) stack.pop(); IO.print(x + " "); } while (!x.equals(e)); IO.println(); } else if (val[t.v] < min) min = val[t.v]; } return min; }

40 Repræsentation af 2-sammenhængende komponenter int visit(int k, Vector components) {. if (m >= val[k]) { Vector component = new Vector(); Edge x; do { x = (Edge) stack.pop(); component.addElement(x); } while (!x.equals(e)); components.addElement(component); }. }

41 Foren-og-find (ækvivalensklasser, komponenter) public class EQ { private int dad[]; EQ(int size) { dad = new int[1+size]; } public boolean find(int x, int y, boolean doit) { int i = x, j = y; while (dad[i] > 0) i = dad[i]; while (dad[j] > 0) j = dad[j]; if (doit && i != j) dad[j] = i; return (i != j); } Princip: hver ækvivalensklasse repræsenteres som et træ.

42 find løber op igennem et eller to træer (tester om den samme rod nås). Hvis doit == true, og der er tale om to forskellige træer, sammenkædes disse: eller bedst

43 Forbedret find public boolean find(int x, int y, boolean doit) { int t, i = x, j = y; while (dad[i] > 0) i = dad[i]; while (dad[j] > 0) j = dad[j]; // path compression while (dad[x] > 0) { t = x; x = dad[x]; dad[t] = i; } while (dad[y] > 0) { t = y; y = dad[y]; dad[t] = j; } if (doit && i != j) // weight balancing if (dad[j] < dad[i]) { dad[j] += dad[i] - 1; dad[i] = j; } else { dad[i] += dad[j] - 1; dad[j] = i; } return (i != j); }

44 void union(int p, int q) { int i = find(p), j = find(q); if (i == j) return; if (size[i] < size[j]) { dad[i] = dad[p] = j; size[j] += size[i]; } else { dad[j] = dad[q] = i; size[i] += size[j]; } } int find(int p) { return dad[p] == p ? p : (dad[p] = find(dad[p])); } Alternativ implementering

45 Ugeseddel november november Læs kapitel 31 og 32 i lærebogen (side ) Løs følgende opgaver 1. Opgave 29.1 og Opgave 30.1 og 30.2.