definities recursieve datastructuren college 13 plaatjes soorten Graph = ( V, E ) V vertices, nodes, objecten, knopen, punten

Transcriptie

1 recursieve datastructuren college graphs definities Graph = ( V, E ) V vertices, nodes, objecten, knopen, punten E edges, arcs, kanten, pijlen, lijnen verbinding tussen knopen Voorbeelden steden en verbindingswegen objecten en inheritance relaties mensen en familiebanden het internet: computers en communicatiekanalen FSM... soorten algemeen: een edge verbindt twee knopen d.w.z. E P ( V x V ) of ( u, v ) E u, v V directed, digraph plaatjes a picture paints a words... veel verschillende manieren van tekenen ( u, v ) is geordend ( b.v. eenrichtingsstraat, inheritance,.. ) kant van u naar v impliceert niet een kant van v naar u u heet origin, bron; v heet destination, doel undirected ( u, v ) is niet geordend, soms schrijf je u, v ( u, v ) E ( v, u ) E door alles dubbel op te slaan te simuleren met directed weighted Amsterdam Utrecht Den Bosch Arnhem Nijmegen Zutphen er hangt een waarde aan een edge ( b.v. afstand, kosten,.. ) labelled iedere knoop heeft unieke naam ( b.v. naam van stad,.. ) Venlo

2 meer definities vertices are adjacent, buren, if they are endpoints of an edge outgoing edges: all directed edges with node as origin outdegree, uitgraad: aantal outgoing edges incoming edges: all directed edges with node as destination indegree, ingraad: aantal incoming edges degree, graad: number of incident edges degree = indegree + outdegree paden pad, path rijtje knopen waarbij er steeds een kant is tussen opeenvolgende knopen cycle pad met zelfde begin en eindpunt simple path iedere knoop maar één keer in het pad, bevat geen cycles directed path bevat alleen directed edges in de goede richting forest, bos graaf zonder cycles verbonden een graaf is verbonden, connected, als er 'n pad is tussen ieder paar knopen uit die graaf verbinding hoeft niet uniek te zijn er mogen cycles in zitten Amsterdam Utrecht Den Bosch Zutphen Arnhem Nijmegen Venlo verschil met bomen boom acyclic graaf met tussen ieder paar knopen precies één cycle-vrij pad d.w.z. een samenhangend bos gerichte boom directed acyclic graph with a root er is één cyclevrij pad van de root naar iedere andere knoop indegree ( root ) = indegree ( andere knoop ) = een boom is dus een speciaal soort graaf

3 subgraph graph H is subgraph van G indien H = ( V H, E H ) G = ( V G, E G ) V H V G E H E G iedere graaf is dus een subgraaf van zichzelf spanning subgraaf knopen gelijk, kanten deelverzameling V H = V G E H E G net voldoende kanten om alle knopen te bereiken spanning tree een spanning subgraaf die boom is representaties verschillende mogelijkheden beste keuze hangt af van probleem directed graph is meestal het handigst undirected als directed in twee richtingen enkele mogelijkheden: als bomen als rijen van knopen en edges als verbindingsmatrix... simple graph geen self-loop: edge van de vorm ( x, x ) iedere edge ( x, y ) hooguit één keer, niet meerdere directe wegen voorbeelden representatie graph met boomknopen A C knopen en edges knopen = A, B, C, D, E edges = (A,A), (A,B), (B,D), (B,E), (C,E), (D,E), (E,B), (E,D) E B D met boom knopen A E C verbindings matrix naar van A B C D E A B B D C D E +handig, hergebruik van bestaand dingen +uitgaande gerichte kanten prima als pointer te representeren maar lastig om alle knopen te bezoeken soms zelfs onmogelijk niet samenhangend gericht naar beginpunt lastig om een bepaalde knoop te vinden voor n algemene graaf dus geen goed idee

4 graph met boomknopen problemen op te lossen met rij van kopen vaak handiger om index in rij te gebruiken dan pointer aantal knopen en max aantal kanten is vast typedef int KnoopID; class Knoop public: KnoopID kanten [ maxoutdegree ]; int outdegree; ; class Graph public: Knoop knopen [ nknopen ]; ; nummertje tussen en nknopen lijsten lossen dit probleem op aantal kanten dat echt bestaat graph als rij van knopen en kanten class Knoop... ; typedef int KnoopID; class Kant public: nummertje tussen KnoopID origin, dest; en nknopen ; class Graph public: Knoop knopen [ nknopen ]; Kant kanten [ nkanten ]; ; simpel, direct volgens theorie, grootte kan ook dynamisch zoeken van kanten bij knoop is O ( nkanten ) verbindingsmatrix tabel met kanten geef knopen weer een nummertje sla in matrix op of er een verbinding is bool edges [ nknopen ] [ nknopen ] ; lekker direct kan ook gewicht zijn maar meerdere directe wegen kan niet voor graph met weinig verbindingen inefficiënt b.v. kaart van Manhattan ( New York ) avenues, straten dus kruisingen en verbindingsstraten verbindingsmatrix van kruisingen: matrix met.. elementen, meer dan factor te veel! sparse matrix sla per knoop de uitgaande edges op eenvoudig om uitgaande edges te vinden class Graph KnoopID **edges; // eigenlijk KnoopID edges[maxv][maxd]; int *degree; // eigenlijk int degree [maxv]; int nedges, maxv, maxd; public: Graph ( char filename [] ); grootte dynamisch, maken met new void insertedge ( int x, int y, bool directed ); friend ostream& operator << ( ostream& os, Graph& g ); ;

5 algoritmen veel bekende algoritmen voor graphen graph traversal Breadth-first search Depth-first search principe gelijk aan bomen, nu knopen kleuren om te zien waar je geweest bent kortste paden zoeken componenten bepalen... sommige problemen nog niet (efficiënt) opgelost TSP: kortste pad dat alle knopen bezoekt MST: Minimum Spanning Tree weighted graph: G = ( V, E ); E = ( v, u, W ) zoek de goedkoopste manier om alle knopen te verbinden dit is natuurlijk een boom uit een cycle kan een verbinding weg alle knopen moeten verbonden worden, dus geen bos voorbeelden: kabel voor tv en internet, waterleiding,.. twee standaard algoritmen Krukskal Prim ( of Prim-Jarník ) van ieder algoritme weer wat variaties MST volgens Prim kleur verbonden knopen, tree-knopen begin op een vrij te kiezen knoop kleur die knoop er zijn nog geen verbindingen MST volgens Prim altijd lokaal beste kiezen is een greedy algoritme hier werkt dat goed voorwaarde is wel dat het gewicht nooit negatief is om efficiënt de goedkoopste verbinding te kunnen kiezen administreren we per knoop de goedkoopste verbinding

6 struct Edge KnoopID k; int w; ; weighted graph structuur i.p.v. kaal KnoopID class Graph Edge **edges; int *degree; int nedges, maxv, maxd; leest graph uit file public: Graph ( char filename [ ] ); void insertedge ( int x, int y, int w, bool directed=true ); friend ostream& operator << ( ostream& os, Graph& g ); friend KnoopID* prim ( Graph& g, KnoopID start, int& v, int& t ); ; edge toevoegen void Graph :: insertedge ( int x, int y, int v, bool directed ) if ( degree [ x ] < maxd ) edges [ x ] [ degree [ x ] ]. k = y; edges [ x ] [ degree [ x ] ]. w = v; degree [ x ] += ; nedges += ; if (!directed && x!= y) insertedge ( y, x, v ); else cout << "insertedge(" << x << "," << y << "," << v << ") past niet meer\n"; afdrukken van graph per knoop de edges voor iedere edge destination en gewicht ostream& operator << ( ostream& os, Graph& g ) for ( int n=; n<g.maxv; n+= ) os << n << ": "; for ( int v=; v<g. degree [ n ]; v+= ) os << g.edges[n][v].k << "," << g.edges[n][v].w << " "; os << endl; return os; MST volgens Prim soort dynamic programming gebruik rij voor kortste edge naar non-tree nodes kleur knopen in boolean rij functie Prim levert rij met ouders op geeft lengte en totaal gewicht via reference argumenten

7 begin in knoop korter pad gevonden

8

9 eindelijk een afstand bekend klaar! Prim in C++ KnoopID* prim ( Graph& g, KnoopID start, int& size, int& totaal ) size = g.maxv; totaal = ; bool * intree = newbool [ size ]; int * dist = newint [ size ]; KnoopID * parent = new KnoopID [ size ]; for ( int i=; i<size; i+= ) intree [ i ] = false; dist [ i ] = INF; parent [ i ] = -; KnoopID v = start; dist [ v ] = ; Prim : edge toevoegen while (! intree [ v ] ) intree [ v ] = true; totaal += dist [ v ]; beste edge en ouder aanpassen for ( int j=; j<g.degree [ v ]; j+= ) KnoopID k = g. edges [ v ] [ j ]. k; int w = g. edges [ v ] [ j ]. w; if ((! intree [ k ] ) && dist [ k ] > w ) dist [ k ] = w; parent [ k ] = v; Dijkstra

10 Prim beste nieuwe edge zoeken greedy algoritmen int d = INF; for ( int n=; n<size; n+= ) if (! intree [ n ] && dist [ n ] < d ) d = dist [ n ]; v = n; return parent; zoek kortste verbinding veel gebruikt om beste te zoeken idee: kies dat wat lokaal het beste lijkt altijd redenatie nodig waarom het werkt tegenvoorbeeld: kortste pad van x naar y begin in x volg steeds de goedkoopste edge totdat we in y zijn A zelfs als we cycles voorkomen X Y werkt dit niet B MST volgens Kruskal geef iedere knoop z n eigen cluster while ( meer dan cluster ) verbind klusters via de goedkoopste edge ook dit is een greedy algoritme while ( meer dan cluster ) verbind klusters via goedkoopste edge

11 ,,, while ( meer dan cluster ) verbind klusters via goedkoopste edge while ( meer dan cluster ) verbind klusters via goedkoopste edge,,,,,,, while ( meer dan cluster ) verbind klusters via goedkoopste edge while ( meer dan cluster ) verbind klusters via goedkoopste edge

12 ,,,,,,,,,,, while ( meer dan cluster ) verbind klusters via goedkoopste edge while ( meer dan cluster ) verbind klusters via goedkoopste edge,,,,,,,,,,,,,,, while ( meer dan cluster ) verbind klusters via goedkoopste edge while ( meer dan cluster ) verbind klusters via goedkoopste edge

13 ,,,,,,,,, klaar! als de graph niet samenhangend is while ( meer dan cluster ) vind je zo wel alle componenten verbind klusters via goedkoopste edge kortste pad gegeven unweighted graph wat is het kortste pad tussen knopen breadth first search zal het netjes vinden gegeven weigthed graph kortste pad is niet meer goedkoopste pad Dijkstra s algoritme: voeg steeds de de goedkoopste knoop toe bijna gelijk aan Prim s algoritme distance bevat de afstanden pad vinden door parents te volgen Dijkstra shortest path algorithm berekent kortste afstand tot wortel voor alle knopen in de graph dist [ u ] is afstand tot gekleurde knopen in het begin D [ v ] = D [ u ] =, voor u v als er geen direct pad is selecteer ongekleurde knoop met kleinste D [ u ] pas afstand van alle buren van u aan: edge relaxation: verbeter gaandeweg de schatting if ( D[u] + W(u,z) < D[z] ) D[z] = D[u] + W(u,z) lijkt op dynamic programming Dijkstra in C++ while (! intree [ v ] ) intree [ v ] = true; for ( int j=; j<g.degree [ v ]; j+= ) KnoopID k = g. edges [ v ] [ j ]. k; int w = g. edges [ v ] [ j ]. w; if ( dist [ k ] > dist [ v ] + w ) dist [ k ] = dist [ v ] + w; parent [ k ] = v; anders dan Prim Prim

14 # knopen, max degree, #kanten graph voorbeeld knoopouder afstand Prim # knopen, max degree, #kanten graph prim: voorbeeld De ouders, is root : : - : : : : : : : : Totaal gewicht is Dijkstra: Afstanden vanaf : : : : : : : : : : pad van naar pad van naar met gewicht met gewicht wat hebben we gedaan graphen komen vaak voor enkele representaties en algoritmen representatie van graphen met pointers, verbindingen per knoop of matrix beste keuze hangt van doel en algoritme af enkele bekende algoritmen Prim, Kruskal, Dijkstra, Floyd, Ford-Fulkerson er bestaan vele variaties er is literatuur over nog veel meer algoritmen nauwelijks in dictaat of ons boek