ACM ICPC Praktikum

1
ACM ICPC Praktikum

• Kapitel 10 Graphalgorithmen

2
Übersicht

• Bäume
• Minimale Spannbäume
• Zusammenhang
• Kürzeste Wege
• Kreise
• Planare Graphen
• Netzwerkfluss und bipartites Matching

3
Bäume

• Ein Baum ist ein zusammen-hängender Graph, der
  keine Kreise enthält.
• Jeder Baum mit n Knoten hat also genau n-1
  Kanten.
• Ein Baum hat oft einen ausge-zeichneten Knoten,
  der die Wurzel repräsentiert.
• Jeder Knoten mit Grad 1 im Baum heißt Blatt.

4
Bäume

• Gewurzelter Baumgerichteter Baum, in dem jeder
  Knoten bis auf Wurzel Eingrad 1 hat.
• Binärer BaumJeder Knoten hat Ausgrad 2 oder 0.
• Spannbaum eines Graphen G(V,E) Teilgraph von
  G, der ein Baum ist und alle Knoten von G
  enthält.

5
Minimaler Spannbaum

• Gegeben Graph G(V,E) mit Kantenkosten cE ! IR
• Gesucht Spannbaum T in G mit minimaler Summe der
  Kantenkosten
• Algorithmen Starte mit leerer Kantenmenge.
  Wiederhole, bis Spannbaum erreicht
• Kruskal füge Kante mit minimalem Gewicht unter
  Wahrung der Kreisfreiheit hinzu
• Prim erweitere Baum um minimale Kante

6
Prims Algorithmus

• define MAXV 100 / maximum number of vertices /
• define MAXDEGREE 50 / maximum outdegree of a
  vertex /
• typedef struct
• int v / neighboring vertex /
• int weight / edge weight /
• edge
• typedef struct
• edge edgesMAXV1MAXDEGREE / adjacency info
  /
• int degreeMAXV1 / outdegree of each vertex
  /
• int nvertices / number of vertices in the
  graph /
• int nedges / number of edges in the graph /
• graph

7
Prims Algorithmus

1. int parentMAXV / discovery
   relation /
2. prim(graph g, int start)
4. int i,j / counters /
5. bool intreeMAXV / is the vertex in the tree
   yet? /
6. int distanceMAXV / distance vertex is from
   start /
7. int v / current vertex to process /
8. int w / candidate next vertex /
9. int weight / edge weight /
10. int dist / best current distance from start
    /
11. for (i1 iltg-gtnvertices i)
12. intreei FALSE
13. distancei MAXINT
14. parenti -1
16. distancestart 0

8
Prims Algorithmus

• while (intreev FALSE)
• intreev TRUE
• for (i0 iltg-gtdegreev i)
• w g-gtedgesvi.v
• weight g-gtedgesvi.weight
• if ((distancew gt weight) (intreew
  FALSE))
• distancew weight
• parentw v
• v 1
• dist MAXINT
• for (i1 iltg-gtnvertices i)
• if ((intreei FALSE) (dist gt
  distancei))
• dist distancei
• v i

9
Prims Algorithmus

• main()
• graph g
• int i
• read_graph(g,FALSE)
• prim(g,1)
• printf("Out of Prim\n")
• for (i1 iltg.nvertices i)
• /printf(" d parentd\n",i,parenti)/
• find_path(1,i,parent)
• printf("\n")

10
MST Probleme

• Maximum Spanning Tree Maximiere Kosten eines
  Spannbaums.
• Minimum Product Spanning Tree Minimiere Produkt
  der Kantenkosten( minimiere Summe der
  Logarithmen)
• Minimum Bottleneck Spanning Tree Minimiere
  maximale Kantenkosten(MST minimiert auch max.
  Kantenkosten)

11
Zusammenhang

• Ein ungerichteter (gerichteter) Graph ist (stark)
  zusammenhängend, wenn es einen ungerichteten
  (gerichteten) Weg zwischen zwei beliebigen
  Knotenpaaren gibt.
• Jeder Graph, der auch nach Löschung eines
  beliebigen Knotens noch zusammenhängend ist,
  heißt zweifach zusammenhängend.
• Eine Kante, dessen Löschung den Graphen in zwei
  Teilgraphen zerteilt, heißt Brücke.

12
Test auf Zusammenhang

• Einfacher Zusammenhang DFS, BFS
• Starker Zusammenhang Finde gerichteten Kreis
  mittels DFS. Schrumpfe solch einen Kreis zu einem
  einzelnen Knoten und wiederhole, bis kein
  gerichteter Kreis mehr gefunden. Ergibt einzelnen
  Knoten Graph start zusammenhängend.
• k-facher Zusammenhang Teste, ob jedes Knotenpaar
  Fluss der Größe gtk hat.

13
Kürzeste Wege

• Gegeben Graph G(V,E) mit Kantenkosten cE ! IR
• Weg von v nach w ist kürzester Weg, wenn Summe
  der Kantenkosten minimal.
• Single-source-shortest-path DijkstraIdee
  arbeite ähnlich zu Prim, um einen
  kürzeste-Wege-Baum aufzubauen
• All-pairs-shortest-path Floyd-WarshallIdee
  verwende Matrixmultiplikation

14
Dijkstras Algorithmus

1. int parentMAXV / discovery
   relation /
2. dijkstra(graph g, int start) / was
   prim(g,start) /
4. int i,j / counters /
5. bool intreeMAXV / is the vertex in the tree
   yet? /
6. int distanceMAXV / distance vertex is from
   start /
7. int v / current vertex to process /
8. int w / candidate next vertex /
9. int weight / edge weight /
10. int dist / best current distance from start
    /
11. for (i1 iltg-gtnvertices i)
12. intreei FALSE
13. distancei MAXINT
14. parenti -1
16. distancestart 0

15
Dijkstras Algorithmus

• while (intreev FALSE)
• intreev TRUE
• for (i0 iltg-gtdegreev i)
• w g-gtedgesvi.v
• weight g-gtedgesvi.weight
• if (distancew gt (distancevweight))
• distancew distancevweight
• parentw v
• v 1
• dist MAXINT
• for (i1 iltg-gtnvertices i)
• if ((intreei FALSE) (dist gt
  distancei))
• dist distancei
• v i

16
Dijkstras Algorithmus

• main()
• graph g
• int i
• read_graph(g,FALSE)
• dijkstra(g,1)
• for (i1 iltg.nvertices i)
• find_path(1,i,parent)
• printf("\n")

17
Floyd-Warshall Algorithmus

• define MAXV 100 / maximum number of vertices
  /
• define MAXDEGREE 50 / maximum outdegree of a
  vertex /
• define MAXINT 100007
• typedef struct
• int v / neighboring vertex /
• int weight / edge weight /
• bool in / is the edge "in" the solution? /
• edge
• typedef struct
• edge edgesMAXVMAXDEGREE / adjacency info
  /
• int degreeMAXV / outdegree of each vertex
  /
• int nvertices / number of vertices in the
  graph /
• int nedges / number of edges in the graph /
• graph
• typedef struct

18
Floyd-Warshall Algorithmus

• initialize_adjacency_matrix(adjacency_matrix g)
• int i,j / counters /
• g -gt nvertices 0
• for (i1 iltMAXV i)
• for (j1 jltMAXV j)
• g-gtweightij MAXINT
• read_adjacency_matrix(adjacency_matrix g, bool
  directed)
• int i / counter /
• int m / number of edges /
• int x,y,w / placeholder for edge and weight
  /
• initialize_adjacency_matrix(g)
• scanf("d d\n",(g-gtnvertices),m)

19
Floyd-Warshall Algorithmus

• print_graph(adjacency_matrix g)
• int i,j / counters /
• for (i1 iltg-gtnvertices i)
• printf("d ",i)
• for (j1 jltg-gtnvertices j)
• if (g-gtweightij lt MAXINT)
• printf(" d",j)
• printf("\n")
• print_adjacency_matrix(adjacency_matrix g)
• int i,j /
  counters /
• for (i1 iltg-gtnvertices i)
• printf("3d ",i)

20
Floyd-Warshall Algorithmus

1. floyd(adjacency_matrix g)
3. int i,j / dimension counters /
4. int k / intermediate vertex counter /
5. int through_k / distance through vertex k /
6. for (k1 kltg-gtnvertices k)
7. for (i1 iltg-gtnvertices i)
8. for (j1 jltg-gtnvertices j)
9. through_k g-gtweightikg-gtweightkj
10. if (through_k lt g-gtweightij)
11. g-gtweightij through_k

21
Floyd-Warshall Algorithmus

1. main()
3. adjacency_matrix g
4. read_adjacency_matrix(g,FALSE)
5. print_graph(g)
6. floyd(g)
7. print_adjacency_matrix(g)

22
Kreise

• Alle Graphen, die keine Bäume sind, enthalten
  Kreise.
• Eulerkreis Kreis, der jede Kante genau einmal
  durchläuft.
• Hamiltonscher Kreis Kreis, der jeden Knoten
  genau einmal durchläuft.

23
Eulerkreis

• Eulerkreis im ungerichteten GraphenExistiert,
  wenn alle Knoten geraden Grad haben.Algorithmus
  Beginne bei beliebigem Knoten, erweitere Kreis um
  beliebige Kante, bis wieder am Ausgangspunkt.Wied
  erholung ergibt kantendisjunkte Kreise, die
  beliebige verschmolzen werden können.
• Eulerkreis im gerichteten GraphenExistiert,
  falls für jeden Knoten der Eingrad gleich dem
  Ausgrad ist. Dann wie oben.

24
Hamiltonscher Kreis

• NP-vollständiges Problem, d.h. es gibt aller
  Voraussicht nach keinen Polynomialzeitalgorithmus
  dafür.
• Backtracking (mittels Durchlauf aller möglichen
  Knotenpermutationen) kann verwendet werden, falls
  Graph genügend klein ist.

25
Planare Graphen

• Ein Graph ist planar, falls die Knoten und Kanten
  so in 2D-Raum eingebettet werden können, dass es
  keine Kantenüberschneidungen gibt.
• Ein Baum ist ein planarer Graph.
• Sei n Anzahl Knoten, m Anzahl Kanten und f Anzahl
  Facetten, dann gilt n-mf2.
• Jeder planare Graph erfüllt m lt 3n-6.
• Ein Graph ist planar genau dann, wenn er keinen
  K3,3 oder K5 als Graphminor enthält.

26
Netzwerkfluss

• Gegeben gerichteter Graph G(V,E) mit
  Kantenkapazitäten cE ! IR und Quell-Ziel-Paar
  (s,t)
• Gesucht Fluss fE ! IR mit maximalem Flusswert
  von s nach t.
• Fluss f ist legal, falls
• ?(u,v) f(u,v) ?(v,w) f(v,w) für alle v 2 V n
  s,t
• f(e) lt c(e) für alle e 2 E
• Flusswert von f ist ?(s,w) f(s,w) - ?(u,s) f(u,s)

27
Netzwerkfluss

• O.B.d.A. sei G ein einfacher gerichteter Graph,
  ansonsten Transformation
• Residuales Netzwerk von f G(V,E) mit cE !
  IR, wobei c(u,v)c(u,v)-f(u,v) falls (u,v) 2 E,
  c(u,v) f(v,u) falls (v,u) 2 E, und sonst
  c(u,v) 0.

neu
28
Netzwerkfluss

• Augmentierender Pfad p(v1,,vk) in G Pfad mit
  positiven Kantenkosten
• Residuale Kapazität von p cp mini c(vi,vi1)
• Neuer Fluss f fp f(u,v) f(u,v)cp falls
  (u,v) 2 p undf(u,v) f(u,v)-cp falls (v,u) 2 p
• Es gilt Flusswert von f gt Flusswert von f und f
  maximal , kein augm. Pfad in G

29
Ford-Fulkerson Algorithmus

• define MAXV 100 / maximum number of vertices
  /
• define MAXDEGREE 50 / maximum outdegree of a
  vertex /
• typedef struct
• int v / neighboring vertex /
• int capacity / capacity of edge /
• int flow / flow through edge /
• int residual / residual capacity of edge /
• edge
• typedef struct
• edge edgesMAXVMAXDEGREE / adjacency info
  /
• int degreeMAXV / outdegree of each vertex
  /
• int nvertices / number of vertices in the
  graph /
• int nedges / number of edges in the graph /
• flow_graph

30
Ford-Fulkerson Algorithmus

• main()
• flow_graph g / graph to analyze /
• int source, sink / source and sink vertices
  /
• int flow / total flow /
• int i / counter /
• scanf("d d",source,sink)
• read_flow_graph(g,TRUE)
• netflow(g,source,sink)
• print_flow_graph(g)
• flow 0
• for (i0 iltg.nvertices i)
• flow g.edgessourcei.flow
• printf("total flow d\n",flow)

31
Ford-Fulkerson Algorithmus

1. initialize_graph(g)
2. flow_graph g / graph to initialize /
4. int i / counter /
5. g -gt nvertices 0
6. g -gt nedges 0
7. for (i0 iltMAXV i) g-gtdegreei 0
9. read_flow_graph(g,directed)
10. flow_graph g / graph to initialize /
11. bool directed / is this graph directed? /
13. int i / counter /
14. int m / number of edges /
15. int x,y,w / placeholder for edge and weight
    /
16. initialize_graph(g)

32
Ford-Fulkerson Algorithmus

• insert_flow_edge(flow_graph g, int x, int y,
  bool directed, int w)
• if (g-gtdegreex gt MAXDEGREE)
• printf("Warning insertion(d,d) exceeds
  degree bound\n",x,y)
• g-gtedgesxg-gtdegreex.v y
• g-gtedgesxg-gtdegreex.capacity w
• g-gtedgesxg-gtdegreex.flow 0
• g-gtedgesxg-gtdegreex.residual w
• g-gtdegreex
• if (directed FALSE)
• insert_flow_edge(g,y,x,TRUE,w)
• else
• g-gtnedges

33
Ford-Fulkerson Algorithmus

1. edge find_edge(flow_graph g, int x, int y)
3. int i / counter /
4. for (i0 iltg-gtdegreex i)
5. if (g-gtedgesxi.v y)
6. return( g-gtedgesxi )
7. return(NULL)
9. add_residual_edges(flow_graph g)
11. int i,j / counters /
12. for (i1 iltg-gtnvertices i)
13. for (j0 jltg-gtdegreei j)
14. if (find_edge(g,g-gtedgesij.v,i) NULL)

34
Ford-Fulkerson Algorithmus

1. print_flow_graph(flow_graph g)
3. int i,j / counters /
4. for (i1 iltg-gtnvertices i)
5. printf("d ",i)
6. for (j0 jltg-gtdegreei j)
7. printf(" d(d,d,d)",g-gtedgesij.v,
8. g-gtedgesij.capacity,
9. g-gtedgesij.flow,
10. g-gtedgesij.residual)
11. printf("\n")
14. bool processedMAXV / which vertices have been
    processed /
15. bool discoveredMAXV / which vertices
    have been found /
16. int parentMAXV / discovery relation /

35
Ford-Fulkerson Algorithmus

• initialize_search(g)
• flow_graph g / graph to traverse /
• int i /
  counter /
• for (i1 iltg-gtnvertices i)
• processedi FALSE
• discoveredi FALSE
• parenti -1

36
Ford-Fulkerson Algorithmus

1. bfs(flow_graph g, int start)
3. queue q / queue of vertices to visit /
4. int v / current vertex /
5. int i / counter /
6. init_queue(q)
7. enqueue(q,start)
8. discoveredstart TRUE
9. while (empty(q) FALSE)
10. v dequeue(q)
11. process_vertex(v)
12. processedv TRUE
13. for (i0 iltg-gtdegreev i)
14. if (valid_edge(g-gtedgesvi) TRUE)
15. if (discoveredg-gtedgesvi.v FALSE)
16. enqueue(q,g-gtedgesvi.v)
17. discoveredg-gtedgesvi.v TRUE

37
Ford-Fulkerson Algorithmus

• bool valid_edge(edge e)
• if (e.residual gt 0) return (TRUE)
• else return(FALSE)
• process_vertex(v)
• int v / vertex to process /
• process_edge(x,y)
• int x,y / edge
  to process /

38
Ford-Fulkerson Algorithmus

1. find_path(start,end,parents)
2. int start / first vertex on path /
3. int end / last vertex on path /
4. int parents / array of parent pointers /
6. if ((start end) (end -1))
7. printf("\nd",start)
8. else
9. find_path(start,parentsend,parents)
10. printf(" d",end)
13. int path_volume(flow_graph g, int start, int
    end, int parents)
15. edge e / edge in question /
16. edge find_edge()
17. if (parentsend -1) return(0)

39
Ford-Fulkerson Algorithmus

1. augment_path(flow_graph g, int start, int end,
   int parents, int volume)
3. edge e / edge in question /
4. edge find_edge()
5. if (start end) return
6. e find_edge(g,parentsend,end)
7. e-gtflow volume
8. e-gtresidual - volume
10. e find_edge(g,end,parentsend)
11. e-gtresidual volume
12. augment_path(g,start,parentsend,parents,volume)
    

40
Ford-Fulkerson Algorithmus

1. netflow(flow_graph g, int source, int sink)
3. int volume / weight of the augmenting path
   /
4. add_residual_edges(g)
5. initialize_search(g)
6. bfs(g,source)
7. volume path_volume(g, source, sink, parent)
8. while (volume gt 0)
9. augment_path(g,source,sink,parent,volume)
10. initialize_search(g)
11. bfs(g,source)
12. volume path_volume(g, source, sink, parent)

41
Anwendungen

• Maximum Matching in bipartiten Graphen.
• Gegeben Graph G(V,E)
• Matching Teilmenge E ½ E, so dass jeder Knoten
  max. Grad 1 hat.
• G bipartit genau dann, wenn zweifärbbar (d.h.
  zwei Farben reichen, Knoten so zu färben, dass
  keine zwei adjazenten Knoten dieselbe Farbe haben)