Download presentation

Presentation is loading. Please wait.

Published byJoshua McDaniel Modified over 2 years ago

1
1 Graph Programming Gordon College

2
2 Graph Basics 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, notation u v –A weighted graph associates weights with either the edges or the vertices

3
3 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 ) Best for a dense representation –But, can be very efficient for small graphs Especially if stores just one bit per edge Undirected graph: only need one diagonal of matrix

4
4 Adjacency Matrix Example: 1 24 3 a d bc A1234 10110 20010 30000 40010

5
5 Adjacency List Adjacency list: for each vertex v V, store a list of vertices adjacent to v Example: –Adj[1] = {2,3} –Adj[2] = {3} –Adj[3] = {} –Adj[4] = {3} Storage: O(V+E) –Good for large, sparse graphs (e.g., planar maps) 1 24 3

6
6 Graph Searching Given: a graph G = (V, E), directed or undirected Goal: methodically explore (visit) 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

7
7 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. Emulates the level-order scan of a binary tree

8
8 Breadth-First Search 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 White Grey Black

9
9 Breadth-First Search BFS(G, s) { initialize vertices; Q = {s};// Q is a queue; 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? G - graph s - source vertex p is the predecessor d is the distance

10
10 Breadth-First Search: Example rstu vwxy

11
11 Breadth-First Search: Example 0 rstu vwxy s Q:

12
12 Breadth-First Search: Example 1 0 1 rstu vwxy w Q: r

13
13 Breadth-First Search: Example 1 0 1 2 2 rstu vwxy r Q: tx

14
14 Breadth-First Search: Example 1 2 0 1 2 2 rstu vwxy Q: txv

15
15 Breadth-First Search: Example 1 2 0 1 2 2 3 rstu vwxy Q: xvu

16
16 Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: vuy

17
17 Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: uy

18
18 Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: y

19
19 Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: Ø

20
20 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)

21
21 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 tree? Total space used: O(E)

22
22 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 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

23
23 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 –Emulates the postorder scan of a binary tree

24
24 Depth-First Search Vertices initially colored white Then colored gray when discovered Then black when finished

25
25 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; }

26
26 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? Discovery time

27
27 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? Finishing time

28
28 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?

29
29 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?

30
30 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

31
31 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?

32
32 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)

33
33 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 per edge if directed graph, twice if undirected Thus loop will run in O(E) time, algorithm O(V+E) –Considered linear for graph, because adj list requires O(V+E) storage

34
34 DFS Example source vertex

35
35 DFS Example 1 | | | | | | | | source vertex d f

36
36 DFS Example 1 | | | | | | 2 | | source vertex d f

37
37 DFS Example 1 | | | | |3 | 2 | | source vertex d f

38
38 DFS Example 1 | | | | |3 | 4 2 | | source vertex d f

39
39 DFS Example 1 | | | |5 |3 | 4 2 | | source vertex d f

40
40 DFS Example 1 | | | |5 | 63 | 4 2 | | source vertex d f

41
41 DFS Example 1 |8 | | |5 | 63 | 4 2 | 7 | source vertex d f

42
42 DFS Example 1 |8 | | |5 | 63 | 4 2 | 7 | source vertex d f

43
43 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?

44
44 DFS Example 1 |8 | | |5 | 63 | 4 2 | 79 |10 source vertex d f

45
45 DFS Example 1 |8 |11 | |5 | 63 | 4 2 | 79 |10 source vertex d f

46
46 DFS Example 1 |128 |11 | |5 | 63 | 4 2 | 79 |10 source vertex d f

47
47 DFS Example 1 |128 |1113| |5 | 63 | 4 2 | 79 |10 source vertex d f

48
48 DFS Example 1 |128 |1113| 14|5 | 63 | 4 2 | 79 |10 source vertex d f

49
49 DFS Example 1 |128 |1113| 14|155 | 63 | 4 2 | 79 |10 source vertex d f

50
50 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f

51
51 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?

52
52 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 tree edges form a spanning forest

53
53 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 tree edges form a spanning forest

54
54 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)

55
55 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 Tree edgesBack edges

56
56 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

57
57 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 Tree edgesBack edgesForward edges

58
58 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

59
59 DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f Tree edgesBack edgesForward edgesCross edges

60
60 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

Similar presentations

OK

CSC 201: Design and Analysis of Algorithms Lecture # 18 Graph Algorithms Mudasser Naseer 1 12/16/2015.

CSC 201: Design and Analysis of Algorithms Lecture # 18 Graph Algorithms Mudasser Naseer 1 12/16/2015.

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Download ppt on respiration in animals Ppt on magnetic refrigeration technology Ppt on bluetooth communication system Ppt on computer network topology Ppt on acid-base titration problems and solutions Ppt on front office department Ppt on disk formatting fails Ppt on life study of mathematical quotes Ppt on network switching device Ppt on blood stain pattern analysis equation