CS Yaxin.Huang.HWM10- Solution

Transcription

1 Q1(Exercise ) (1) The algorithm for the adjacency-list: Assuming that the input of the algorithm is an array A[1..n], which contains V elements. Each index represents a node in the graph, and each element is a pointer to the list of nodes which is the end of edges from the node of this index. (So this adjacency-list is exactly the same as the one described in section 22.1.) The algorithm designed below will output the square of the directed graph in the form of adjacency-list. SQUARE-GRAPH-ADJ-LIST(A) let B[1..n] be a new array n = A.length for i = 1 to n adj-node-ptr = A[i] //A pointer to travel the list of //nodes adjacent to node i. while adj-node-ptr!= NIL if (*adj-node-ptr) not in the adj-list of B[i] //linear search add (*adj-node-ptr) to the head of list B[i] //(*adj-node-ptr) denotes the node index adj-adj-ptr = A[(*adj-node-ptr)] //the next while-loop explores the nodes adjacent //to node (*adj-node-ptr) while adj-adj-ptr!= NIL if (*adj-adj-ptr) not in the adj-list of B[i] add (*adj-adj-ptr) to the head of list B[i] adj-adj-ptr = adj-adj-ptr.next adj-node-ptr = adj-node-ptr.next return B Running time analysis: The graph has V nodes and E edges. The for loop needs to examine V nodes. The first while loop examines the nodes adjacent to node i and the second while loop examines the nodes adjacent to the nodes that are adjacent to node i. Therefore, each directed edge is at most examined twice. Because the insertion always happens at the head of the list, we only need O(1) time to finish the insertion. The two bold if need to do searching in the adjacency list. In the worst case, when the graph is fully connected, all together you need to search O( V * E ) times.

2 The running time of this algorithm is O( V * E ). (2) The algorithm for the adjacency-matrix: Assuming that the input of the algorithm is a matrix A[1..n, 1..n]. If there is an edge from node u to node v, then A[u,v] is 1, otherwise it is 0. SQUARE-GRAPH-ADJ-MATRIX(A,n) // 1... n is the indices of nodes // A[u,v] denotes there is a directed edge (u,v) in G let B[1..n, 1..n] be a new table for i = 1 to n for j = 1 to n if A[i,j] == 1 B[i,j] = 1 for k = 1 to n if A[j,k] == 1 B[i,k] = 1 return B Running time analysis: There are V nodes in graph G and E edges. The first for loop examines every node in graph G. So this for loop has to execute V times. The second for loop also needs to execute V times. If there is an edge from the adjacent node to another adjacent-adjacent nodes, then the third for loop needs to be executed. Thus, the third for loop in total needs to be executed at most E times. The running time is O(2 V + E ). Q2(Exercise )

3 Given the graph above, it can be represented by an adjacency-list as: A B C (or C B) B D E (or D E) C D E (or D E) C NIL E NIL For example we choose A as the source, then we may have these trees because the different orders of vertices in the adjacency-list: And here is one tree consisting of shortest paths and it has these edges: (A B) (B D) (A C) (C E), you can see that non of the trees produced by BFS starting from A is the tree with shortest paths to each vertices. Q3(Exercise ) There are two types of professional wrestlers: babyfaces ( good guys ) and heels ( bad guys ). Between any pair of professional wrestlers, there may or may not be a rivalry. Suppose we have n professional wrestlers and we have a list of r pairs of wrestlers for which there are rivalries. Give an O.n C r/-time algorithm that determines whether it is possible to designate some of the wrestlers as babyfaces and the remainder as heels such that each rivalry is between a babyface and a heel. If it is possible to perform such a designation, your algorithm should produce

4 it. The rivalries between the wrestlers can be represented by an undirected graph. If there is a rivalry between wrestler u and wrestler v, then there exists an edge (u,v) in the graph G. And so this problem can be solve by doing some modifications on BFS. The input A is an array, and each index denotes a vertex. It is the same representation as the adjacency-list introduced in section Each element in A is an object, which has the fields : color, d, π and adj. (adj is the pointer to the adjacency-list). BFS-DESIGNATION(A) n = A.length let B[1..n] be a new array //B is to store the result of the designation. //true is babyface, false is heel. for i from 1 to n A[i].color = WHITE A[i].d = A[i].π = NIL B[i] = NIL // NIL represents no designation s = the index of the node with the most out-edges //here we need θ( V ) time to search s. A[s].color = GRAY A[s].d = 0 A[s].π = NIL B[s] = true //assign it as the babyface let Q be a new queue(empty). ENQUEUE(Q,s) while Q is nonempty u = DEQUEUE(Q) for each vertex index v in the list that A[u].adj points to: if A[v].color == WHILE A[v].color = GRAY A[v].d = A[u].d + 1 A[v].π = u if B[v] == NIL B[v] = not B[u] if B[v] == false if B[u] == false return false //no way to designate if B[u] == true return false

5 return B //B is the final designation Q4(Exercise ) Rewrite the procedure DFS, using a stack to eliminate recursion. The input of the algorithm below is a graph G, who has the DFS-STACK-VERSION(G) let S be a new empty stack let Q be a new empty set //here we use a set to maintain the unvisited vertices //so we don t need coloring for each vertex u belongs to G.V u.π = NIL add u to Q time = 0 while Q is nonempty if EMPTY(S) == true u = pick one vertex from Q u.d = time u.π = NIL PUSH(S, u) v = TOP(S) //This will only return the value // of the top element if G.Adj[v] is nonempty for each vertex u belongs to G.Adj[v] kick out u from Q //need to do searching here u.d = time u.π = v PUSH(S, u) v.f = time POP(V) Q5(Exercise )Modify the pseudocode for depth-first search so that it prints out every edge in the directed graph G, together with its type. Show what modifications, if any, you need to make if G is undirected.

6 DFS-directed-print-edge(G) for each vertex u belongs to G.V u.color = WHITE u.π = NIL time = 0 for each vertex u belongs to G.V if u.color == WHITE DFS-VISIT-directed-print-edge(G,u) DFS-VISIT-directed-print-edge(G,u) u.d = time u.color = GRAY for each v belongs to G.Adj[u] if v.color == WHITE v.π = u print (u,v) tree edge DFS-VISIT-directed-print-edge(G,v) if v.color == GRAY print (u,v) back edge // v.color == BLACK if u.d < v.d print (u,v) forward edge print (u,v) cross edge u.color = BLACK u.f = time If given an undirected graph, the code in the blue box should be modified into this one: for each v belongs to G.Adj[u] if v.color == WHITE v.π = u print (u,v) tree edge DFS-VISIT-directed-print-edge(G,v) print (u,v) back edge Because according to the theorem 22.10, in an undirected graph, every edge is either a tree edge or a back edge.

7 Q6(Exercise ) Show that we can use a depth-first search of an undirected graph G to identify the connected components of G, and that the depth-first forest contains as many trees as G has connected components. More precisely, show how to modify depth-first search so that it assigns to each vertex v an integer label v.cc between 1 and k, where k is the number of connected components of G, such that u.cc = v.cc if and only if u and v are in the same connected component. DFS-CC(G) for each vertex u belongs to G.V u.color = WHITE u.π = NIL u.cc = 0 time = 0 cc-counter = 0 for each vertex u belongs to G.V if u.color == WHITE cc-counter = cc-counter + 1 DFS-VISIT-directed-print-edge(G,u) DFS-VISIT-CC(G,u) u.cc = cc-counter u.d = time u.color = GRAY for each v belongs to G.Adj[u] if v.color == WHITE v.π = u DFS-VISIT-directed-print-edge(G,v) u.color = BLACK u.f = time Q7(Exercise )Another way to perform topological sorting on a directed acyclic graph G = (V,E) is to repeatedly find a vertex of in-degree 0, output it, and remove it and all of its outgoing edges from the graph. Explain how to implement this idea so that it runs in time O(V+E). What happens to this algorithm if G has cycles? TOPOLOGICAL-SORT-BY-IN-DEGREE(G) for each vertex v belongs to G.V θ( V ) v.in-degree = 0 //initialization finished The second for loop: O( V + E ) because all for each vertex v belongs to G.V the edges are inspected once, and all the ptr = G.Adj[v] vertices have been searched its adj-list once.

8 //ptr now points to the head of v s adj-list while ptr!= NIL (*ptr).in-degree = (*ptr).in-degree + 1 //(*ptr) represents the vertex which //ptr points to ptr = ptr.next let Q be a new set equal to G.V let A[1.. V ] be a new array i = 1 this while loop: O( V + E ) while Q is nonempty if there is a vertex u with in-degree == 0 pick u from Q //Now u is not in Q return false //no way to make a // topological ordering A[i] = u ptr = G.Adj[u] while ptr!= NIL (*ptr).in-degree = (*ptr).in-degree - 1 return A If G has cycles, then the algorithm will return false to tell us that it cannot find a topological ordering for the graph, because if G has cycles, in the second while loop, you will come to the situation that no vertices in G has an in-degree equal to zero. The running time of the algorithm is O(V+E). Q8: Two special vertices s and t in the undirected graph G=(V,E) have the following property: any path from s to t has at least 1 + V /2 edges. Show that all paths from s to t must have a common vertex v (not equal to either s or t) and give an algorithm with running time O(V+E) to find such a node v. Because the statement of the problem, there cannot be only one path from s to t. (1) Proof: Any path from s to t has at least 1+ V /2 edges. There are at least V /2 vertices on the path from s to v (excluding s and v). Assuming that the vertices between s and t in two different paths are distinct, i.e., no two vertices are identical in this two paths except s and t. Then there will be at least V distinct vertices, which is a contradiction because we only have V - 2 vertices left. (2) Algorithm: Q9((Extra credit 25) Problem 22-3.)

9 Q10((Extra credit 25) Problem 22-4.) Q11(Exercise )Show that if an edge (u,v) is contained in some minimum spanning tree, then it is a light edge crossing some cut of the graph. Proof: Let Tu and Tv be two trees produced by a cut of the minimum spanning tree. So the edge (u,v) now is crossing the cut, together with some other possible edges are also crossing the cut. Assuming that there is an edge (a,b) whose weight w(a,b) is smaller than w(u,v), then (a,b) can be the light edge which link Tu and Tv together to become a minimum spanning tree and the minimum spanning tree containing (u,v) is no longer a MST -- which is a contradiction. Therefore, if an edge (u,v) is contained in some minimum spanning tree, then it is a light edge crossing some cut of the graph. Q12(Exercise ) Suppose that we represent the graph G = (V,E) as an adjacency matrix. Give a simple implementation of Prim s algorithm for this case that runs in O(V 2 ) time. The input of the algorithm is an adjacency matrix, where the element of G[i,j] is if there is no edge between vertex i and vertex j. If the element is a positive integer, then there is an edge with the weight indicated by that integer existing between vertex i and vertex j. MST-PRIM-ADJ-MATRIX(G, V,r) //G is the input matrix, V is the number of vertices, //r is the source. let A[1.. V ] be a new empty min-heap //every element of A is an object containing these //fields: index, key, π for i = 1 to V This for loop contributes an // u is an object O( V ) running time. u.index = i if i == r u.key = 0 u.key = u.π = NIL MIN-HEAP-INSERT(A,u) // This insertion is done // according to u.key while A is nonempty i = HEAP-EXTRACT-MIN(A) // i is the object, // whose key value is minimum. for j = 1 to V if G.Adj-Matrix[i.index][j]!=

10 if the object with index j is in Q and G.Adj-Matrix[i.index][j] < A[j].key A[j].π = i.index A[j].key = G.Adj-Matrix[i.index][j] The bold while loop and the nested for loop together contribute an O( V 2 ) running time. Running time analysis: As the annotations beside the code, the algorithm together has an O( V 2 ) running time. Something needed to be added up here is, the bold while loop has to inspect V vertices and the nested bold for loop will inspect V vertices to see if they are adjacent to the current vertex. Thus, together the while loop contributes an O( V 2 ) running time. Q13(Exercise ) Suppose that all edge weights in a graph are integers in the range from 1 to V. How fast can you make Kruskal s algorithm run? What if the edge weights are integers in the range from 1 to W for some constant W? Here we use counting-sort to sort the edges of G.E into nondecreasing order by weight w. (1) Because counting-sort sorts n integers with range 1 to k in O(n+k) time, sorting E edges with the weight ranging from 1 to V will need O( E + V ) time. Then the Kruskal s algorithm will have an O(E+V+ElgV) = O(V+ElgV) running time. (2) Use counting-sort to sort E edges whose weight ranging from 1 to W will need an O( E +W) running time. Then the Kruskal s algorithm will have an O(E+W+ElgV) = O(W+ElgV) running time. Q14(Exercise ) Suppose that all edge weights in a graph are integers in the range from 1 to V. How fast can you make Prim s algorithm run? What if the edge weights are integers in the range from 1 to W for some constant W? No matter the range of the weights is 1 to V or 1 to W, there is no way to speed up MST-PRIM. So the running time of Prim s algorithm is O(E+VlgV) by using Fibonacci heap. Q15((Extra credit 40 pts) Problem 23-1.) Q16((Extra credit 30 pts) Exercise ) Q17(Extra credit 30 pts) Write the code for Kruskal algorithm in a language of your choice. You will first have to read on the disjoint sets datastructures and operations (Chapter 21 in the book) for an efficient implementation of Kruskal trees.