1. Nattee Niparnan

2. Graph  A pair G = (V,E)  V = set of vertices (node)  E = set of edges (pairs of vertices)  V = (1,2,3,4,5,6,7)  E = ((1,2),(2,3),(3,5),(1,4),(4, 5),(6,7)) 1 2 3 4 5 6 7

3. Term you should already know  directed, undirected graph  Weighted graph  Bipartite graph  Tree  Spanning tree  Path, simple path  Circuit, simple circuit  Degree

4. Representing a Graph  Adjacency Matrix  A = |V|x|V| matrix  a xy = 1when there is an edge connecting node x and node y  a xy = 0otherwise 1 2 3 4 5 01010 10110 01001 11001 00110 12345 1 2 3 4 5

5. Representing a Graph  Adjacency List  Use a list instead of a matrix  For each vertex, we have a linked list of their neighbor 1 2 3 4 5 124 2134...

6. Representing a Graph  Incidences Matrix  Row represent edge  Column represent node 1 2 3 4 5 11000 10010 01010 01100 00101 00011 12345

7. Depth First Search

8. Exploring a Maze

9. Exploring Problem

10. Depth-First-Search void explore(G, v) // Input: G = (V,E) is a graph; v  V // Output: visited[u] is set to true for all nodes u reachable from v { visited[v] = true previsit(v) for each edge (v,u)  E if not visited[u] explore(u) postvisit(v) }

11. Example Explore(A)

12. Extend to Graph Traversal  Traversal is walking in the graph  We might need to visit each component in the graph  Can be done using explore  Do “explore” on all non-visited node  The result is that we will visit every node  What is the difference between just looking into V (the set of vertices?)

13. Graph Traversal using DFS void dfs(G) { for all v  V visited[v] = false for all v  V if not visited[v] explore(v) }

14. Complexity Analysis  Each node is visited once  Each edge is visited twice  Why?  O( |V| + |E|)

15. Another Example

17. Connected Component

18. Connectivity in Undirected Graph

19. Connected Component Problem  Input:  A graph  Output:  Marking in every vertices identify the connected component  Let it be an array ccnum, indexed by vertices

20. Solution  Define global variable cc  In previsit(v)  ccnum[v] = cc  Before calling each explore  cc++

21. DFS visiting time

22. Ordering in Visit void previsit(v) pre[v] = clock++ void postvisit(v) post[v] = clock++

23. Ordering in Visit The interval for node u is [pre(u),post(u)] The inverval for u,v is either Contained disjointed Never intersect

24. DFS in Directed Graph

25. Type of Edge in Directed Graph

26. Directed Acyclic Graph (DAG)  A directed Graph without a cycle  Has “source”  A node having only “out” edge  Has “sink”  A node having only “in” edge  How can we detect that a graph is a DAG  What should be the property of “source” and “sink” ?

27. Solution  A directed graph is acyclic if and only if it has no back edge  Sink  Having lowest post number  Source  Having highest post number

28. Topological Sorting

29. Linearization of Graph

30. Linearization One possible linearization B,A,D,C,E,F Order of work that can be done w/o violating the causality constraints

31. Topological Sorting Problem

32. Topological Sorting  Do DFS  List node by post number (descending) 1,12 2,9 3,84,5 6,7 10,11

33. Breadth First Search

34. Distance of nodes  The distance between two nodes is the length of the shortest path between them S  A 1 S  C 1 S  B 2

35. DFS and Length  DFS finds all nodes reachable from the starting node  But it might not be “visited” according to the distance

36. Ball and Strings We can compute distance by proceeding from “layer” to “layer”

37. Shortest Path Problem (Undi, Unit)  Input:  A graph, undirected  A starting node S  Output:  A label on every node, giving the distance from S to that node

38. Breadth-First-Search  Visit node according to its layer procedure bfs(G, s) //Input: Graph G = (V,E), directed or undirected; vertex s  V //Output: visit[u] is set to true for all nodes u reachable from v for each v  V visited[v] = false visited[s] = true Queue Q = [s] //queue containing just s while Q is not empty v = Q.dequeue() previsit(v) visited[v] = true for each edge (v,u)  E if not visited[u] visited[u] = true Q.enqueue(u) postvisit(v)

39. Distance using BFS procedure shortest_bfs(G, s) //Input: Graph G = (V,E), directed or undirected; vertex s  V //Output: For all vertices u reachable from s, dist(u) is set to the distance from s to u. for all v  V dist[v] = -1 dist[s] = 0 Queue Q = [s] //queue containing just s while Q is not empty v = Q.dequeue() for all edges (v,u)  E if dist[u] = -1 dist[u] = dist[v] + 1 Q.enqueue(u) Use dist as visited

40. DFS by Stack procedure dfs(G, s) //Input: Graph G = (V,E), directed or undirected; vertex s  V //Output: visited[u] is true for any node u reachable from v for each v  V visited[v] = false visited[s] = true Stack S = [s] //queue containing just s while S is not empty v = S.pop() previsit(v) visited[v] = true for each edge (v,u)  E if not visited[u] visited[u] = true S.push(u) postvisit(v)

41. DFS vs BFS  DFS goes depth first  Trying to go further if possible  Backtrack only when no other possible way to go  Using Stack  BFS goes breadth first  Trying to visit node by the distance from the starting node  Using Queue