F9 Läsanvisning: kap 10 + dessa OH (Obs att OH bilderna tar upp mer än boken) intro till grafer (bara handskrivet och tavla) definitioner och terminologi representationer djupet först bredden först Nästa gång: mer grafer (kap 10)! uppspännande träd! minimala uppspännande träd! Prims algoritm Näst nästa gång:! Kruskals algoritm! kortaste vägar en till alla! Dijkstras algoritm Grafer 1 1
träd dag graf Träd Dag Graf Träd har en implicit riktning på bågarna nedåt En dag är en riktad graf utan cykler ( Directed, Acyklic Graph ). Den är generellare än träd men mindre generell än grafer. En dag kan användas för att representera aritmetiska uttryck med gemensamma deluttryck, partiella ordningar i AOV nätverk (se topologisk sortering) mm. AOV = Activity On Vertex AOE = Activty On Edge är vanligare. En graf modellerar allmänna relationer. Den består av noder, som representerar objekt, och bågar som representerar relationer mellan objekten. Dessa har ofta en en vikt. Grafer 1 2
Grafer definitioner och terminologi En graf G = (V, E) består av 2 mängder - noder, V, (vertices, points, hörn) och - bågar, E, (edges, arcs, lines, kanter). Noderna representerar ofta objekt, (tex städer) bågarna relationer mellan objekten (tex avstånd). Noderna som ingår i en båge säges vara förbundna (adjacent) och säges vara grannar (neighbours) till varandra. (angränsande, närliggande) En graf kan vara riktad (directed) eller oriktad (undirected) En graf kan vara viktad (weighted) eller oviktad (not weighted=>vikt=1). Grafer 1 3
båge och vikt nod, båge och vikt är ganska vida begrepp eftersom grafer modellerar relationer: vikt: ofta avstånd, kostnad, grad av något... Euklidiska avstånd (traditionella avstånd) Manhattan avstånd (avståndet en bil måste fara på tex Manhattan) Hamming avstånd (minsta antalet substitutioner som krävs för att omvandla något till något annat) tid graden av något! vänskap eller annan social norm! troslikhet! släktskap kostnaden att ta sig mellan noderna grann-information och många fler Grafer 1 4
En väg (path) är: Vägar en sekvens av noder där två intilliggande noder i sekvensen har en båge mellan sig. Enkel väg (simple) - alla noder är olika Hamiltonsk väg enkel väg som besöker alla noder exakt en gång (jmf TSP som är billigaste sådana vägen). Euler väg väg som besöker alla bågar exakt en gång. Grafer 1 5
Cykler Cykel en väg med längd 1 som startar och slutar på samma ställe (ej nödvändigtvis enkel väg) ( 3 för oriktade grafer) En enkel cykel cykel där v 1 är den enda upprepade noden, kallas också en krets (circut) vanligen tillåter man inte självloopar i en graf Grafer 1 6
(starkt) sammanhängande - (strongly) connected Två noder i en (di)graf sägs vara sammanhängande om det finns en väg mellan dem (ev. i flera steg). Om varje par av noder i en (di)graf är sammanhängande så sägs grafen vara (starkt) sammanhängande ( all in one piece ) (minst n respektive n-1 bågar) En riktad graf är sammanhängande om den är det betraktad som oriktad graf. Ej (starkt) sammanhängande sammanhängande (dock ej starkt) starkt sammanhängande ej starkt sammanh. sammanhängande komponenter av en graf sammanhängande = sammankopplad = sammanbunden Grafer 1 7
Komplett graf I en komplett graf finns det en båge mellan varje par av noder. Maximala antalet bågar i en oriktad graf med n = V noder är n(n-1)/2. (riktad: n(n-1), n 2 om man tillåter självloopar) Om en graf har exakt så många bågar sägs den alltså vara komplett. n e 1 0 2 1 3 3 4 6 5 4+3+2+1...... n 1 n 1+2+3+...+n-1 = i=1 i = n(n-1)/2 Grafer 1 8
ytterligare terminologi En nods grad är antalet bågar som utgår från den. För riktade talar man om in/ut grad. Acyklisk graf innehåller inte någon cykel Träd specialfall av graf, är en oriktad, sammanhängande och acyklisk graf ------------- Grafens ordning = antalet noder och Grafens storlek = antalet bågar. Grafens densitet = antalet bågar/maximala antalet bågar (för riktad graf med självloopar) e = E, n = V Grafer 1 9
Representation av grafer Efterföljarmatris: (adjacency matrix) (eller föregångarmatris så klart) en riktad, viktad graf: 5 1 3 2 7 3 motsvarande EM: 1 2 3 1 2 3 1-1 - 1-7 - 2 1-1 2 5-3 3 - - - 3 - - - Här använder vi en n x n matris som lagrar förbindelse ( det finns en väg ) eller vikt (tex kostnad, avstånd) mellan noderna. + tidskomplexitet för åtkomst/insättning= O(1) - alla grannar till tar O(n) - minneskravet är Ω(n 2 ) även för en gles graf - tex utskrift tar också Ω(n 2 ) Grafer 1 10
Representation av grafer Efterföljarlista: (adjacency list) motsvarande EL: 5 1 3 2 7 3 1 2 3 2 7 1 5 3 3 här använder vi en accessvektor och länkade listor med grannarna och avstånden till dom. - tidskomplexitet för åtkomst, wc = O(n) + alla grannar till tar max O(n), ofta bättre - insättning tar wc=o(n) - minneskravet är O(n+e) (n+2e för oriktad) - utskrift tar Ω(n+e) lämpligare om antalet bågar är litet e<n 2 /2 Grafer 1 11
Även om dessa två är de vanligaste så finns det många fler tex: Infallande matris: (incidence matrix) e 1 e 1 2 2 3 e 3 e 4 e 1 e 2 e 3 e 4 n 1 1 - u u n 2 u u 1 - n 3-1 - 1 Grafer 1 12
Vilken skall väljas? Hur stor kommer din graf att bli? Matriser fungerar bara för relativt små grafer Hur gles är grafen? Gles graf => E-lista Vilka egenskaper vill du ha? tex så är det bättre med EL om du skall göra DFS som vill ha alla grannar till Skall grafen ändras mycket och hur? Minne: antag riktad graf med vikter. E-Llista: Vektorn behöver n platser (heltal), varje nod i listan minst 2 heltal och det finns e sådana noder: n + 2e E-matris: n 2 Listan lönar sig alltså då n + 2e n 2 => e (n 2 -n)/2 n 2 /2-n/2 - Man kan representera förbindelse med en binär bit => e n 2 /(2x32) - Om grafen är oriktad kan man halvera matrisen. Grafer 1 13
Vi behöver en klass för en båge public class Edge { private int source; private int dest; private double weight; public Edge(int source, int dest){.} public Edge(int source, int dest, double w) {.} public int getsource() {.} public int getdest() {.} public double getweight() {.} public String tostring() {.} Return true if two edges are equal. Edges are equal if the source and destination are equal. Weight is not considered. public boolean equals(object obj){.} } Return a hash code for an edge. The hash code is the source shifted left 16 bits exclusive or with the dest public int hashcode() { return (source << 16) ^ dest; } Grafer 1 14
Och ett interface A graph is a set of vertices and a set of edges. Vertices are represented by int's from 0 to n-1. Edges are ordered pairs of vertices. Each implementation of the Graph interface should provide a constructor that specifies the number of vertices and whether or not the graph is directed. @author Koffman and Wolfgang public interface Graph { int getnumv(); boolean isdirected(); void insert(edge edge); boolean isedge(int source, int dest); //if there is no edge return an //edge with Double.POSITIVE_INFINITY Edge getedge(int source, int dest); } Iterator<Edge> edgeiterator( int source); (public är underförstått i ett interface) Grafer 1 15
Och sedan bygger vi en hierarki public abstract class AbstractGraph implements Graph { private int numv; private boolean directed; public AbstractGraph(int numv, boolean directed) {...} public int getnumv() {...} public boolean isdirected() {...} public void loadedgesfromfile( BufferedReader br) throws IOException {...} public static Graph creategraph( BufferedReader br, boolean isdirected, String type) throws IOException {...} Grafer 1 16
This concrete class uses an array of lists to represent the edges. public class ListGraph extends AbstractGraph { private List<Edge>[] edges; // ------------------------ public ListGraph(int numv, boolean directed) { super(numv, directed); edges = new List[numV]; for (int i = 0; i < numv; i++) { edges[i]=new LinkedList<Edge>(); } } // ------------------------ public boolean isedge(int source, int dest) { return edges[source].contains( new Edge(source, dest)); } // ------------------------ public Iterator<Edge> edgeiterator(int source) { return edges[source].iterator(); } Grafer 1 17
public void insert(edge edge) { edges[edge.getsource()].add(edge); if (!isdirected()) { edges[edge.getdest()].add( new Edge( edge.getdest(), edge.getsource(), edge.getweight())); } } // ------------------------ public Edge getedge(int source, int dest) { Edge target = new Edge(source, dest, Double.POSITIVE_INFINITY); } } for (Edge edge : edges[source]){ if (edge.equals(target)) // Desired edge found, return it return edge; } // All edges for source checked. // Desired edge not found return target; // or null or exc. Grafer 1 18
Algoritmer Ett av de mest fundamentala sakerna vi vill göra är att gå igenom alla noder och bågar i grafen. Vi måste se till att vi bara besöker varje båge/nod en gång annars blir algoritmen ineffektiv. Vi måste göra det systematiskt så vi inte missar någon nod. Vi håller reda på hur långt vi kommit med bearbetningen av en nod genom att låta den vara i ett av tre tillstånd: ej besök än eller oupptäckt (unvisited, undiscovered) besöks nu eller upptäckt ( (being) visited, discovered) färdig besökt eller behandlad (finished visiting, processed) En nod passerar dessa tillstånd Grafer 1 19
Djupet Först Sökning Dfs är ett sätt att besöka (räkna upp) alla noder i en graf (jmf med preorder för träd. dfs är ej unik. Ide: 1) börja var som helst 2) sök djupare så länge det går 3) backtracka 4) börja om på nytt om det behövs E F B A G D C dfs(e) E 1 F 2 3 B 4 A 6 G D 5 C dfs(a)+ dfs(e) E 4 5 F G 3 B D 2 1 A C Grafer 1 20
Start up: 8 for v in 1..n loop dfs pseudokod 9 mark v as unvisited end loop 10 for v in 1..n loop 11 if v unvisited 12 dfs(v) end if end loop --------------------------- pseudocode dfs(vertex: u) vertex: v 1 mark u as visited 2...//process u here (preorder) or after the loop 3 for each vertex v on adjlist(u) 4 if v is unvisited 5 dfs(v) end if end for 6...//process u here (postorder) or before loop 7 mark u as processed end dfs Grafer 1 21
Komplexitet Antag att vi har en E-lista, e bågar, n noder initieringen tar 8-9: n 10-12: n + rekursiva anrop dfs tar: 1, 7 konstant 2, 6 beror på vad vi vill göra, antag konstant 3-5 loopen går totalt, över alla sina varv, ett varv per båge så vi kan inte ha fler anrop av dfs än e (inklusive anropen från 12) Detta plus looparna 8 och 10 ger oss O(n+e) = O(max(n,e)) n är normalt < e Grafer 1 22
Dfs i oriktade grafer Ungefär som för riktade, se vänsta fig BFS bredden först sökning Alla efterföljare till en nod besöks innan man går djupare i grafen, högra fig. 1 bak bak 5 2 4 3 Grafer 1 23
BFS psudocode 1 tag en obesökt nod i grafen och lägg in den i en kö samt markera den besökt 2 tag bort första noden ur kön samt lägg in alla dess obesökta grannar i kön samt markera dem besökta samt lägg bågen mellan noden och dess grannar i en lista med uppspännande trädet 3 om kön inte är tom så upprepa 2 4 om det finns fler noder så upprepa 1 kön uppsp. trädet 1 2, 3 {1-2, 1-3} 3, 4 {1-2, 1-3, 2-4} 4 {1-2, 1-3, 2-4} {1-2, 1-3, 2-4} O(max(n, e) Grafer 1 24