CSCI2100B Graph Jeffrey Yu@CUHK

1. CSCI2100B GraphJeffrey Yu@CUHK

2. Koenigsberg Bridge Problem • Königsberg in Prussia (now Kaliningrad in Russia) is a town. The town is set on both sides of the Pregel River, and includes two islands. There are seven bridges. • Can you start from any island and walk across all the bridges exactly once in returning to the starting island? Graph

3. Koenigsberg Bridge Problem • One walk is: . • This walk does not go across all 7 bridges, nor does it return to the same island. Graph

4. Eulerian Cycle • Leonhard Euler found it impossible in 1735 using graph for the problem. • Euler defines the degree of a node to be the number of edges incident to it. Euler shows that there is walk starting from any node, going through each edge exactly once and terminating at the start node iff the degree of each node is even. Graph

5. 0 1 2 3 0 1 2 3 0 0 1 2 1 2 • For a graph which has only even nodes, then you can start at any node and find a route which returns to the same node across all edges only once. • For a graph which has exactly two odd nodes, then you can construct a route which starts at one odd node and ends up at the other and goes through every edge once and once only. • For a graph that has more than two odd nodes, then there is no route that goes through every edge once and once only. G4 G1 G2 G2 3 3 Graph

6. Social Networks Graph

7. Location Based Social Networks Graph

8. GeoLife Trajectory • GPS trajectory data of 182 users in 2 years Graph

9. Financial Networks • We borrow £1.7 trillion, but we're lending £1.8 trillion. Confused? Yes, inter-nation finance is complicated..." Graph

10. 2 4 0 1 3 0 1 2 Tree G1 3 Graphs • A graph is G = (V, E)where Vis a finite and nonempty set of nodes (vertices), and Eis a finite and possibly empty set of edges. (An edge is a pair of nodes.) • We use V(G) and E(G) to denote the set of nodes and the set of edges of G, respectively. • Let n be the number of nodes in V(G), e.g., |V(G)|. • Let m be the number of edges in E(G), e.g., |E(G)| • Many books, use m to denote the number of edges. In this textbook, it uses e. • Tree is a graph. Graph

11. 0 1 2 G1 3 Undirected Graphs • A graph is an undirected graph, if there is no order in an edge. The two edges, (v0, v1) and (v1, v0), in a undirected graph represent the same edge. • An example: V(G1) = {0, 1, 2, 3}, E(G1) = {(0,1), (0,2), (0,3), (1,2), (1,3), (2,3)}. Graph

12. 0 1 G2 2 Directed Graphs • A graph is a directed graph if there is an order in an edge. The two edges, <v0, v1> and <v1, v0> in a directed graph represent two different edges. • An example: • V(G2) = {0, 1, 2}, • E(G2) = {<0, 1>, <1, 0>, <1, 2>}. Graph

13. 0 1 2 3 Graphs • There are many graphs. Here, we only consider the graphs with the following two restrictions. • No self-loops, (vi, vi), in an undirected graph or <vi, vi> in a directed graph. • No multiple occurrences of the same edge. Graph

14. 0 1 2 Graphs • Complete graph is a graph that has the maximum number of edges. • If an undirected graph has nodes, the maximum number of distinct unordered pairs is . • If a directed graph has nodes, the maximum number of distinct ordered pairs is . A complete directed graph with 3 nodes Graph

15. n = 4 n = 1 n = 2 n = 3 Complete Undirected Graphs • With all possible edges Graph

16. 0 1 2 3 0 (b) A subgraph of G 1 2 G 3 Graphs • Subgraph: A graph G' is a subgraph of G if V(G') V(G) and E(G') E(G). 0 2 3 (a) An undirected graph G (c) Another subgraph of G Graph

17. Graphs • For an edge (v0, v1) in an undirected graph, v0 and v1 are adjacent. The edge (v0, v1) is incident on nodes v0 and v1. • For an edge <v0, v1> in a directed graph, v0 is adjacent tov1 and v1 is adjacent fromv0. The edge <v0, v1> is incident on nodes v0 and v1. • The degree of a node is the number of edges incident to that node. • For a directed graph, in-degree of a node v is the number of edges <vi, v>, and out-degree of a node v is the number of edges <v, vi> where vi is any adjacent node of v. • If is the degree of a node in a graph G with nodes and edges, then the number of edges is: . Graph

18. 0 0 2 1 2 1 3 0 1 2 3 Graphs: Examples (2+2+2)/2 = 3 (2+1+2+1)/2 = 3 Graph

19. Paths • A path from node to node in a graph G is a sequence of nodes, , where and , such that there exist a sequence of edges • in an undirected graph , or • in a directed graph . • A simple path is a path in which all nodes are distinct. • A simplecycleis a simple path in which the first and the last nodes are the same. • The length of a path is the number of edges on it. • The definition of simple path is not the best, and the definition of cycle is a simple cycle in the textbook (page 269). Graph

20. 0 0 0 1 2 2 1 2 3 1 3 P = (0,1,2,0) P = (0,1,3,2,1,0,2) P = (1,0,3,2) P = (1,0,3,2,1) Paths in Graphs: Examples P = (1,0,2,3) P = (3,2,0,1) Graph

21. Review Trees (1) • In Chapter 5, the definition of a tree is a recursive definition. • A tree is a finite set of one or more nodes such that • There is a specially node called the root. • The remaining nodes are partitioned into disjoint sets where each of these sets is a tree. • We call the subtrees of the root. • It implies that there is an edge from the root to the root of a subtree. • By definition, a tree here implies a connected tree with direction (from parent node to a child node). Graph

22. Review Trees (2) • Based on the edges, we can define a path, and the length of a path. • The degree of a node defined on a tree is the number of subtrees (the number of child nodes). • Ancestors of a node, v, are the nodes on the path from the root to the node v excluding v itself. • Descendants of a node, v, are the nodes, u, if there is a path from v to u. • The level can be defined because there is a root. • The level of the root is 1, and the level of its child nodes are at level 2, and so no so forth. • For a tree, there is only one root. • A list is a special tree. Graph

23. Review Graphs • A graph is G = (V, E) where V is a finite and nonempty set of nodes (vertices), and E is a finite and possibly empty set of edges. (An edge is a pair of nodes.) • A tree is a special graph. • A tree only has one root. A graph may have many. • A root is defined as a node without in-coming edges. • The degree of a node defined on a tree is the out-degree of a node defined on a graph. • A tree has no cycles, but a graph may have many. • A node (except for the root) in a tree has one parent. A node in a graph may have many in-coming edges. So, there is no clear notion of parent in a graph. We use children, ancestors, and descendantson a graph, if the context is clear. Graph

24. Graph ADT • A nonempty set of nodes and a set of undirected edges, where each edge is a pair of nodes. (Refer to ADT 6.1, page 271.) • Functions: • GraphCreate(): return an empty graph. • GraphInsertVertex(G, v):return a graph G with vinserted, and vhas no incident edges. • GraphInsertEdge(G, v1, v2): return a graph G with a new edge between v1 and v2. • GraphDeleteVertex(G, v):return a graph G in which v and all edges incident to it are removed. • GraphDeleteEdge(G, v1, v2): return a graph G in which the edge (v1, v2)is removed. Leave the incident nodes in the graph. • BooleanIsEmpty(G): if G is empty return TRUEelse return FALSE. • List Adjacent(G, v): return a list of all nodes that are adjacent to v. Graph

25. Graph Representation: Adjacency Matrix • Let A[i][j] be an adjacency matrix. Graph

26. Graph Representation: Adjacency List typedefstruct _adjlist { int node; struct_adjlist *link; } adjlist; adjlist graph[MAX_NODES]; Graph

27. Nil Nil Nil Nil 3 1 2 3 2 0 1 3 0 1 2 0 Adjacency List • For an undirected graph with n nodes and m edges, this representation requires n head nodes and 2m list nodes. 0 1 2 3 Graph

28. 1 0 1 Adjacency List • Using the adjacency list for directed graphs, it is easy to find the out-degree of a node but harder to find the in-degree. • Use an additional inverse adjacency list. Nil 0 1 Nil 2 Nil (c) an inverse adjacency list Graph

29. Depth-First or Breadth-First • Given a graph (e.g., a social network), how do you distribute information from a node? Graph

30. Depth-First Search (Depth-First Traversal) • Given a graph G = (V, E) and a start node, v, visit allnodes in the graph that are reachable from the start node. • What do we mean by “all”? • What is the result? • By the name of Depth-First, it will traverse G as far as possible from the start node along a path, all the time. • What do we mean by “far”? • Is it really “far”? • Here, “far” is based on the length of the path traversing from v Graph

31. Depth-First Search (DFS) • Given a graph G = (V, E) and a start node, v, visit allnodes in the graph that are reachable from the start node. • The result is not unique by definition, if we do not define an order among out-going edges from a node. • Possible results: • v0, v1, v3, v7, v4, v5, v2, v6. • v0, v1, v4, v7, v6, v2, v5, v3. • … • How many? Graph

32. Depth-First Search • Consider pseudo code. (For pseudo code, refer to http://en.wikipedia.org/wiki/Pseudocode) • A pseudo code exampledfs(node v){ remember the node v we are about to visit, and output the node v; for (every node u that v and u are adjacent in G) if (we have not visited u before) dfs(u); } Graph

33. Depth-First Search • Give the data structures, and write it in C.typedefstruct _adjlist{int node;struct_adjlist *link;} adjlist;adjlist graph[MAX_NODES]; /* adjacency list */Boolean visited[MAX_NODES]; /* to remember visits */void dfs(int v){ adjlist *w; visited[v] = TRUE; printf("%d", v); for (w = &graph[v]; w != NULL; w = w->link) if (visited[w->node] == FALSE) dfs(w->node); } Graph

34. Depth First Search • Given the adjacency list and suppose the graph is stored as shown here. The answer is unique. Why? implementation dependent. • Start from v0: dfs order: v0, v1, v3, v7, v4, v5, v2, v6 Graph

35. n n Depth First Search • If a graph is represented by its adjacency lists, then we can determine the nodes adjacent to v by following a chain of links. Since dfs examines each node in the adjacency lists at most once, the time to complete the search is . • If the graph is represented by its adjacency matrix, then determining all nodes adjacent to v requires . Since we visit at most n nodes, the total time is . m Graph

36. Breadth-First Search (Breadth-First Traversal) • Given a graph G = (V, E) and a startnode, v, visit allnodes that are reachable from v in an order tovisit all nodes that are closerfirst before visiting the others. • By the name of Breadth-First, it will traverse G following the adjacency nodes. • The result is not unique by definition, if we do not define an order among out-going edges from a node. • Some possible results: • v0, v1, v2, v3, v4, v5, v6, v7. • v0, v2, v1, v6, v5, v4, v3, v7. Graph

37. Breadth-First Search (Pseudo Code) bfs(node v){ remember the node v we are about to visit, and output the node v; let q be a queue to remember the visiting order we have visited, and let it be empty initially. enqueuethe node v into q; while (the queue is not empty){ let v be the node dequeued from q; for (every node u that v and u are adjacent in G) if (we have not visited u before){ output the node u; enqueue u into q; remember we have visited u; } } }} Graph

38. Breadth-First Search (BFS) void bfs(int v){ queue *q; adjlist*w; printf("%d",v); visited[v] = TRUE; q = createQ(MAX_NODES); enqueue(q, v); while (!IsEmptyQ(q)) { v = dequeue(q); for (w = &graph[v]; w != NULL; w = w->link) if (visited[w->node] == FALSE) { printf("%d", w->node); enqueue(q, w->node); visited[w->node] = TRUE; } } } } Graph

39. Breadth-First Search • Given the adjacency list and suppose the graph is stored as shown here. The answer is unique. Why?implementation dependent. • Example: Start from v0: bfs order: v0, v1, v2, v3, v4, v5, v6, v7 Graph

40. Breadth-First Search • Since each node is placed on the queue exactly once, the whileloop is iterated at most times. • For adjacency list representation, this loop has a total cost of . • For the adjacency matrix representation, the while loop takes time for each node visited. Therefore, the total time is . Graph

41. 4 0 2 1 3 5 7 6 Connected Components • For an undirected graph G, a connected component of G is a subgraph where every two nodes are connected to each other by paths. • A graph G is connected, if every two nodes are connected. • We can check it using DFS or BFS starting from any node. G4 Graph

42. Spanning Trees • Suppose a graphG = (V, E) is connected, a spanning treeT = (Vt, Et) is a cycle-free subgraphof Gsuch that V = Vt and Et is a subset of E (Et E). • We want to reduce the number of edges, but maintain the connection information. • We can use either depth-first-search or breadth-first-search to get a spanning tree T for a graph G. Graph

43. Minimum Cost Spanning Tree • Given a graph G = (V, E), and assume that every edge in G is associated with a weight. • Such a graph is a weighted graph. • The cost of a spanning tree of a weighted graph is the sum of weights of its edges. • A minimum cost spanning tree is a spanning tree that has minimum cost. Graph

44. An Example of An Undirected Weighted Graph • The minimum spanning three is the one with the smallest cost among all possible spanning trees starting from every node in a graph! • It costs too much to check all! Graph

45. What should we do? • Do not find the minimum spanning tree after finding all possible spanning trees! • Create a tree, and add edges into the tree one by one repeatedly. • Prim’s Algorithm: Start with a 1-node and 0-edge tree and grow it into an n-node tree by repeatedly adding a node and an edge with the least cost. • Kruskal’sAlgorithm: Start with an n-node0-edgeforest. Consider edges in ascending order of cost. Select an edge if it does not form a cycle together with already selected edges. • A forestis a collection of disconnected trees. Graph

46. Prim's Algorithm G T u v • The algorithm (pseudo code) is outlined below. Let T be the minimum spanning tree we want to construct for graph G, and let T be an empty tree initially; Let TV be the set of nodes in T, and assume that it starts from a node, say node v0; while (Tis not a spanning tree yet) { let (u, v) be a smallest weight edge in G such that uis in TV and vis not in TV; if (there is no such edge) break from the while loop; add v to TV; add (u, v) to T; } if (T contains fewer than n-1 edges) there is no answer because T is not even a spanning tree. Graph

47. Minimum Cost Spanning Tree: Prim's Algorithm • Given an undirected weighted graph that contains nnodes. • The algorithm (pseudo code) is outlined below. T = {}; TV = {0}; /* start with node 0 */ while (T contains fewer than n-1 edges) { let (u, v) be a smallest weight edge in G such that u is in TV and v is not in TV; if (there is no such edge) break; add v to TV; add (u, v) to T; } if (T contains fewer than n-1 edges) printf("No spanning tree\n"); Graph

48. Prim’s Algorithm Graph

49. Kruskal's Algorithm • The algorithm (pseudo codes) is outlined below. Let T be the minimum spanning tree we want to construct for graph G, and let T be an empty tree. while (Tis not a spanning tree yet and there are still edges we can add into T from G) { choose the edge (v,w) from Gthat has the smallest weight, and do not consider the edge (v, w) again; if (the edge (v,w) does not create a cycle in T) add the edge (v,w) to T;/* if there is a cycle in T, then T is not a spanning tree */ } if (T contains fewer than n-1 edges) there is no answer because T is not even a spanning tree. Graph

50. Kruskal's Algorithm Graph