Download presentation

Presentation is loading. Please wait.

Published byPrudence Smith Modified over 3 years ago

1
David Luebke 1 5/9/2015 CS 332: Algorithms Graph Algorithms

2
David Luebke 2 5/9/2015 Administrative ● Test postponed to Friday ● Homework: ■ Turned in last night by midnight: full credit ■ Turned in tonight by midnight: 1 day late, 10% off ■ Turned in tomorrow night: 2 days late, 30% off ■ Extra credit lateness measured separately

3
David Luebke 3 5/9/2015 Review: Graphs ● A graph G = (V, E) ■ V = set of vertices, E = set of edges ■ Dense graph: |E| |V| 2 ; Sparse graph: |E| |V| ■ Undirected graph: ○ Edge (u,v) = edge (v,u) ○ No self-loops ■ Directed graph: ○ Edge (u,v) goes from vertex u to vertex v, notated u v ■ A weighted graph associates weights with either the edges or the vertices

4
David Luebke 4 5/9/2015 Review: Representing Graphs ● Assume V = {1, 2, …, n} ● An adjacency matrix represents the graph as a n x n matrix A: ■ A[i, j] = 1 if edge (i, j) E (or weight of edge) = 0 if edge (i, j) E ■ Storage requirements: O(V 2 ) ○ A dense representation ■ But, can be very efficient for small graphs ○ Especially if store just one bit/edge ○ Undirected graph: only need one diagonal of matrix

5
David Luebke 5 5/9/2015 Review: Graph Searching ● Given: a graph G = (V, E), directed or undirected ● Goal: methodically explore every vertex and every edge ● Ultimately: build a tree on the graph ■ Pick a vertex as the root ■ Choose certain edges to produce a tree ■ Note: might also build a forest if graph is not connected

6
David Luebke 6 5/9/2015 Review: Breadth-First Search ● “Explore” a graph, turning it into a tree ■ One vertex at a time ■ Expand frontier of explored vertices across the breadth of the frontier ● Builds a tree over the graph ■ Pick a source vertex to be the root ■ Find (“discover”) its children, then their children, etc.

7
David Luebke 7 5/9/2015 Review: Breadth-First Search ● Again will associate vertex “colors” to guide the algorithm ■ White vertices have not been discovered ○ All vertices start out white ■ Grey vertices are discovered but not fully explored ○ They may be adjacent to white vertices ■ Black vertices are discovered and fully explored ○ They are adjacent only to black and gray vertices ● Explore vertices by scanning adjacency list of grey vertices

8
David Luebke 8 5/9/2015 Review: Breadth-First Search BFS(G, s) { initialize vertices; Q = {s};// Q is a queue (duh); initialize to s while (Q not empty) { u = RemoveTop(Q); for each v u->adj { if (v->color == WHITE) v->color = GREY; v->d = u->d + 1; v->p = u; Enqueue(Q, v); } u->color = BLACK; } What does v->p represent? What does v->d represent?

9
David Luebke 9 5/9/2015 Breadth-First Search: Example rstu vwxy

10
David Luebke 10 5/9/2015 Breadth-First Search: Example 0 rstu vwxy s Q:

11
David Luebke 11 5/9/2015 Breadth-First Search: Example 1 0 1 rstu vwxy w Q: r

12
David Luebke 12 5/9/2015 Breadth-First Search: Example 1 0 1 2 2 rstu vwxy r Q: tx

13
David Luebke 13 5/9/2015 Breadth-First Search: Example 1 2 0 1 2 2 rstu vwxy Q: txv

14
David Luebke 14 5/9/2015 Breadth-First Search: Example 1 2 0 1 2 2 3 rstu vwxy Q: xvu

15
David Luebke 15 5/9/2015 Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: vuy

16
David Luebke 16 5/9/2015 Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: uy

17
David Luebke 17 5/9/2015 Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: y

18
David Luebke 18 5/9/2015 Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: Ø

19
David Luebke 19 5/9/2015 BFS: The Code Again BFS(G, s) { initialize vertices; Q = {s}; while (Q not empty) { u = RemoveTop(Q); for each v u->adj { if (v->color == WHITE) v->color = GREY; v->d = u->d + 1; v->p = u; Enqueue(Q, v); } u->color = BLACK; } What will be the running time? Touch every vertex: O(V) u = every vertex, but only once (Why?) So v = every vertex that appears in some other vert’s adjacency list Total running time: O(V+E)

20
David Luebke 20 5/9/2015 BFS: The Code Again BFS(G, s) { initialize vertices; Q = {s}; while (Q not empty) { u = RemoveTop(Q); for each v u->adj { if (v->color == WHITE) v->color = GREY; v->d = u->d + 1; v->p = u; Enqueue(Q, v); } u->color = BLACK; } What will be the storage cost in addition to storing the graph? Total space used: O(max(degree(v))) = O(E)

21
David Luebke 21 5/9/2015 Breadth-First Search: Properties ● BFS calculates the shortest-path distance to the source node ■ Shortest-path distance (s,v) = minimum number of edges from s to v, or if v not reachable from s ■ Proof given in the book (p. 472-5) ● BFS builds breadth-first tree, in which paths to root represent shortest paths in G ■ Thus can use BFS to calculate shortest path from one vertex to another in O(V+E) time

22
David Luebke 22 5/9/2015 Depth-First Search ● Depth-first search is another strategy for exploring a graph ■ Explore “deeper” in the graph whenever possible ■ Edges are explored out of the most recently discovered vertex v that still has unexplored edges ■ When all of v’s edges have been explored, backtrack to the vertex from which v was discovered

23
David Luebke 23 5/9/2015 Depth-First Search ● Vertices initially colored white ● Then colored gray when discovered ● Then black when finished

24
David Luebke 24 5/9/2015 Depth-First Search: The Code DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; }

25
David Luebke 25 5/9/2015 Depth-First Search: The Code DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; } What does u->d represent?

26
David Luebke 26 5/9/2015 Depth-First Search: The Code DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; } What does u->f represent?

27
David Luebke 27 5/9/2015 Depth-First Search: The Code DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; } Will all vertices eventually be colored black?

28
David Luebke 28 5/9/2015 Depth-First Search: The Code DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; } What will be the running time?

29
David Luebke 29 5/9/2015 Depth-First Search: The Code DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; } Running time: O(n 2 ) because call DFS_Visit on each vertex, and the loop over Adj[] can run as many as |V| times

30
David Luebke 30 5/9/2015 Depth-First Search: The Code DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; } BUT, there is actually a tighter bound. How many times will DFS_Visit() actually be called?

31
David Luebke 31 5/9/2015 Depth-First Search: The Code DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; } So, running time of DFS = O(V+E)

32
David Luebke 32 5/9/2015 Depth-First Sort Analysis ● This running time argument is an informal example of amortized analysis ■ “Charge” the exploration of edge to the edge: ○ Each loop in DFS_Visit can be attributed to an edge in the graph ○ Runs once/edge if directed graph, twice if undirected ○ Thus loop will run in O(E) time, algorithm O(V+E) Considered linear for graph, b/c adj list requires O(V+E) storage ■ Important to be comfortable with this kind of reasoning and analysis

33
David Luebke 33 5/9/2015 DFS Example source vertex

34
David Luebke 34 5/9/2015 DFS Example 1 | | | | | | | | source vertex d f

35
David Luebke 35 5/9/2015 DFS Example 1 | | | | | | 2 | | source vertex d f

36
David Luebke 36 5/9/2015 DFS Example 1 | | | | |3 | 2 | | source vertex d f

37
David Luebke 37 5/9/2015 DFS Example 1 | | | | |3 | 4 2 | | source vertex d f

38
David Luebke 38 5/9/2015 DFS Example 1 | | | |5 |3 | 4 2 | | source vertex d f

39
David Luebke 39 5/9/2015 DFS Example 1 | | | |5 | 63 | 4 2 | | source vertex d f

40
David Luebke 40 5/9/2015 DFS Example 1 |8 | | |5 | 63 | 4 2 | 7 | source vertex d f

41
David Luebke 41 5/9/2015 DFS Example 1 |8 | | |5 | 63 | 4 2 | 7 | source vertex d f

42
David Luebke 42 5/9/2015 DFS Example 1 |8 | | |5 | 63 | 4 2 | 79 | source vertex d f What is the structure of the grey vertices? What do they represent?

43
David Luebke 43 5/9/2015 DFS Example 1 |8 | | |5 | 63 | 4 2 | 79 |10 source vertex d f

44
David Luebke 44 5/9/2015 DFS Example 1 |8 |11 | |5 | 63 | 4 2 | 79 |10 source vertex d f

45
David Luebke 45 5/9/2015 DFS Example 1 |128 |11 | |5 | 63 | 4 2 | 79 |10 source vertex d f

46
David Luebke 46 5/9/2015 DFS Example 1 |128 |1113| |5 | 63 | 4 2 | 79 |10 source vertex d f

47
David Luebke 47 5/9/2015 DFS Example 1 |128 |1113| 14|5 | 63 | 4 2 | 79 |10 source vertex d f

48
David Luebke 48 5/9/2015 DFS Example 1 |128 |1113| 14|155 | 63 | 4 2 | 79 |10 source vertex d f

49
David Luebke 49 5/9/2015 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f

50
David Luebke 50 5/9/2015 DFS: Kinds of edges ● DFS introduces an important distinction among edges in the original graph: ■ Tree edge: encounter new (white) vertex ○ The tree edges form a spanning forest ○ Can tree edges form cycles? Why or why not?

51
David Luebke 51 5/9/2015 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f Tree edges

52
David Luebke 52 5/9/2015 DFS: Kinds of edges ● DFS introduces an important distinction among edges in the original graph: ■ Tree edge: encounter new (white) vertex ■ Back edge: from descendent to ancestor ○ Encounter a grey vertex (grey to grey)

53
David Luebke 53 5/9/2015 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f Tree edgesBack edges

54
David Luebke 54 5/9/2015 DFS: Kinds of edges ● DFS introduces an important distinction among edges in the original graph: ■ Tree edge: encounter new (white) vertex ■ Back edge: from descendent to ancestor ■ Forward edge: from ancestor to descendent ○ Not a tree edge, though ○ From grey node to black node

55
David Luebke 55 5/9/2015 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f Tree edgesBack edgesForward edges

56
David Luebke 56 5/9/2015 DFS: Kinds of edges ● DFS introduces an important distinction among edges in the original graph: ■ Tree edge: encounter new (white) vertex ■ Back edge: from descendent to ancestor ■ Forward edge: from ancestor to descendent ■ Cross edge: between a tree or subtrees ○ From a grey node to a black node

57
David Luebke 57 5/9/2015 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f Tree edgesBack edgesForward edgesCross edges

58
David Luebke 58 5/9/2015 DFS: Kinds of edges ● DFS introduces an important distinction among edges in the original graph: ■ Tree edge: encounter new (white) vertex ■ Back edge: from descendent to ancestor ■ Forward edge: from ancestor to descendent ■ Cross edge: between a tree or subtrees ● Note: tree & back edges are important; most algorithms don’t distinguish forward & cross

59
David Luebke 59 5/9/2015 DFS: Kinds Of Edges ● Thm 23.9: If G is undirected, a DFS produces only tree and back edges ● Proof by contradiction: ■ Assume there’s a forward edge ○ But F? edge must actually be a back edge (why?) source F?

60
David Luebke 60 5/9/2015 DFS: Kinds Of Edges ● Thm 23.9: If G is undirected, a DFS produces only tree and back edges ● Proof by contradiction: ■ Assume there’s a cross edge ○ But C? edge cannot be cross: ○ must be explored from one of the vertices it connects, becoming a tree vertex, before other vertex is explored ○ So in fact the picture is wrong…both lower tree edges cannot in fact be tree edges source C?

61
David Luebke 61 5/9/2015 DFS And Graph Cycles ● Thm: An undirected graph is acyclic iff a DFS yields no back edges ■ If acyclic, no back edges (because a back edge implies a cycle ■ If no back edges, acyclic ○ No back edges implies only tree edges (Why?) ○ Only tree edges implies we have a tree or a forest ○ Which by definition is acyclic ● Thus, can run DFS to find whether a graph has a cycle

62
David Luebke 62 5/9/2015 DFS And Cycles ● How would you modify the code to detect cycles? DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; }

63
David Luebke 63 5/9/2015 DFS And Cycles ● What will be the running time? DFS(G) { for each vertex u G->V { u->color = WHITE; } time = 0; for each vertex u G->V { if (u->color == WHITE) DFS_Visit(u); } DFS_Visit(u) { u->color = GREY; time = time+1; u->d = time; for each v u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; time = time+1; u->f = time; }

64
David Luebke 64 5/9/2015 DFS And Cycles ● What will be the running time? ● A: O(V+E) ● We can actually determine if cycles exist in O(V) time: ■ In an undirected acyclic forest, |E| |V| - 1 ■ So count the edges: if ever see |V| distinct edges, must have seen a back edge along the way

Similar presentations

OK

1 7/2/2015 ITCS 6114 Graph Algorithms. 2 7/2/2015 Graphs ● A graph G = (V, E) ■ V = set of vertices ■ E = set of edges = subset of V V ■ Thus |E| =

1 7/2/2015 ITCS 6114 Graph Algorithms. 2 7/2/2015 Graphs ● A graph G = (V, E) ■ V = set of vertices ■ E = set of edges = subset of V V ■ Thus |E| =

© 2018 SlidePlayer.com Inc.

All rights reserved.

To ensure the functioning of the site, we use **cookies**. We share information about your activities on the site with our partners and Google partners: social networks and companies engaged in advertising and web analytics. For more information, see the Privacy Policy and Google Privacy & Terms.
Your consent to our cookies if you continue to use this website.

Ads by Google

Ppt on ozone layer protection Ppt on sets for class 11 cbse By appt only-movie Ppt on power system stability definition Ppt on nitrogen cycle and nitrogen fixation by lightning Ppt on hong kong airport Ppt on l&t finance Ppt on waxes are lipids Ppt on indian premier league Ppt on single phase and three phase dual converter travel