Exam 1 Solutions. Jonathan Turner 10/4/01 9/27/01. CS 541 Algorithms and Programs. Be neat and concise, but complete.

Transcription

1 CS 541 Algorithms and rograms Exam 1 Solutions Jonathan Turner 10/4/01 9/27/01 Be neat and concise, but complete. 1. (15 points) State the general greedy method for finding minimum spanning trees. Show that Kruskal s algorithm is a special case of the general greedy method. The general greedy method applies one of the following two coloring steps until all edges are colored. On completion, the blue edges form a minimum spanning tree. Blue rule. Find a cut crossed by no blue edges and at least one uncolored edge. Select a minimum weight uncolored edge crossing the cut and color it blue. Red rule. Find a cycle with no red edges and at least one uncolored edge. Select an uncolored edge of maximum weight from the cycle and color it red. Kruskal s algorithm goes through the edges in non-decreasing order of their weight. On finding an edge that joins two separate blue trees, it colors it blue. This is a proper application of the blue rule, since the cut defined by placing one of the blue trees on one side of the cut and all other vertices on the other side, constitutes a cut that we can apply the blue rule to. Since the edge under consideration is a minimum weight uncolored edge, it is also minimum weight among edges crossing the cut. When Kruskal s algorithm finds an edge joining two vertices in the same blue tree, it colors it red. This is a proper application of the red rule, since the edge and the tree path joining its endpoints form a cycle that the red rule can be applied to. Since the edge being considered, is the only uncolored edge, in the cycle and the edges are considered in non-decreasing weight order, it must be a maximum weight edge in the cycle. 2. (10 points) The correctness of any data structure operation depends on its maintaining certain essential properties of the data structure. The data portion of the class declaration for the C++ implementation of the data structure is shown below. What properties of the data must be maintained by programs that operate on it? class dheap { int N; // max number of items in heap int n; // number of items in heap int d; // base of heap item *h; // {h[1],...,h[n] is set of items int *pos; // pos[i] gives position of i in h keytyp *kvec; // kvec[i] is key of item i... ; d>1, 0 n N, for 2 i n, kvec[i/d] kvec[i], for 1 i n, pos[h[i]] = i

2 3. (12 points) Let d(n) denote the running time of rim s algorithm using d-heaps, where the value of d is chosen dynamically to give the best overall running time. Let F(n) denote the running time of rim s algorithm, using Fibonacci heaps. Which of the following statements is true? Justify your answers. d is O( F) when m = 3n. This is true, since d = O(m (log n)/log(2+m/n)) = O(n log n) and F = Ω(m+ n log n) = Ω(n log n). d is O( F) when m = n 2 /4. This is true, since d = O(m (log n)/log(2+m/n)) = O(n 2 ) and F = Ω(m+ n log n) = Ω(n 2 ). d is O( F) when m = n (log n) 2. This is false, since d = Ω(m (log n)/log(2+m/n)) = Ω(n (log n) 3 /log log n) and F = O(m+ n log n) = O(n (log n) 2 ) and n (log n) 3 /log log n grows more quickly than n (log n) 2 does. d is O( F) when m = n 3/2. This is true, since d = O(m (log n)/log(2+m/n)) = O(n 3/2 ) and F = Ω(m+ n log n) = Ω(n 3/2 )

3 4. (15 points) Suppose you are given an edge-weighted graph using the wgraph data structure and a minimum spanning tree for that graph, represented using a vector of parent pointers. Now suppose that the weight of one of the non-tree edges is changed. Describe an O(n) time algorithm to modify the spanning tree, to reflect the change in the edge weight. You may describe your algorithm in words, but be complete and precise. Be sure to explain what changes are made to the vector of parent pointers. You may want to draw a picture and explain your algorithm using the picture. r The algorithm is illustrated at left. Let {u,v be the edge whose weight is being changed. w First we follow parent pointers from u to the root, marking each vertex as we go. We then follow parent pointers from v to the root, stopping at the first marked vertex, w. This will be the nearest common ancestor of u and v. min wt edge on tree path from u to v. if new w(u,v)<w(s,t) then reverse parent pointers between u s t Next, we follow parent pointers from u to w and from v to w, in order to find the min weight edge {s,t on the tree path from u to v. In the figure, this is assumed to be on the path from u to w. The case where the min weight edge lies on the path from v to w is similar. and s. modified edge If w(s,t) is no larger than w(u,v) we don t need to make u v any change to the tree. However, if w(u,v)<w(s,t), then if new w(u,v)<w(s,t) we need to replace {s,t with {u,v. In the case shown in make p(u)=v. the figure, this is done by letting p(u)=v and reversing the parent pointers on the path from u to s. This can be done in a single pass along the tree path, so long as we are careful to save the old parent of each vertex in a temporary variable, before changing its parent pointer to point to the vertex that was previously its child. These steps can all be done in O(n) time, since we are just traversing a constant number of tree paths, doing constant work at each node and the length of each tree path is O(n)

4 5. (10 points) The figure below shows a Fibonacci heap. Show the state of the data structure after performing a deletemin operation. key, rank d 2,3 l 4,2 b 3,1 a 4,3 p 6,0 f 5,1 r 7,0 i 5,2 o 6,0 n 7,0 e 5,0 g 9,0 h 8,2 c 7,0 q 3,0 m 7,0 k 5,0 denotes a set mark bit s 6,0 p 6,0 b 3,1 a 4,3 l 4,2 o 6,0 f 5,1 n 7,0 e 5,0 g 9,0 r 7,0 i 5,2 h 8,2 c 7,0 q 3,0 m 7,0 k 5,0 s 6,0-4 -

5 6. (15 points) Suppose that in the amortized analysis of the partition data structure with path compression, we defined level(x) = (rank(p(x)) rank(x)) 1/2. Give an upper bound on the final value of fcredit for this case, by modifying the original analysis. Show the details of your modified analysis. Also, give a lower bound on rank(p(x)) in terms of level(x) and rank(x). Since rank(x) lg n, it follows the level(x) (lg n) 1/2. Since it is also non-negative, there are 1+(lg n) 1/2 distinct values that level(x) can have. Since fcredit is incremented only for vertices x that have no proper ancestor y with level(y)=level(x), the number of different vertices for which fcredit is incremented during a top level find is at most equal to the number of distinct values of the level function. Thus, after m operations on the partition data structure, fcredit m(1+(lg n) 1/2 ). From the definition of level(x), we have level(x) 1+(rank(p(x)) rank(x)) 1/2. So, rank(p(x)) rank(x) + (level(x) 1)

6 7. (10 points) The bottleneck capacity of a path in a graph with edge weights is the weight of the smallest weight edge on the path. The objective of the largest bottleneck path problem is to find paths for which the bottleneck capacity is largest. Define a largest bottleneck path tree to be a spanning tree, rooted at a source vertex s, in which all paths are largest bottleneck paths. Show how to modify the theorem shown below, so that it applies to largest bottleneck path trees. Theorem. Let T be a spanning tree with root s of a directed graph G. Define distance(v) to be the length of the path from s to v in T. T is a shortest path tree if and only if, distance(w) distance(v) + length(v,w), for every edge [v,w] in G. The revised theorem is shown below. Theorem. Let T be a spanning tree with root s of a directed graph G. Define distance(v) to be the bottleneck capacity of the path from s to v in T. T is a largest bottleneck path tree if and only if, distance(w) min {distance(v), length(v,w), for every edge [v,w] in G. A C++ implementation of Dijkstra s algorithm appears below. Show how to modify it so that all the paths in the tree that is returned are shortest bottleneck paths. The changes are marked in bold below void spt_dijkstra(wdigraph& G, vertex u, vertex p[], int d[]) { // Find a shortest bottleneck path tree of G using Dijkstra's // algorithm and return it in p as an array of parent pointers, // with d giving the shortest bottleneck path distances. vertex v,w; edge e; dheap S(G.n,max(3,G.m/G.n)); for (v = 1; v <= G.n; v++) { p[v] = Null; d[v] = 0; p[u] = u; d[u] = INT_MAX; S.insert(u,-d[u]); while (!S.empty()) { v = S.deletemin(); for (e = G.firstout(v); e!= Null; e = G.nextout(e)) { if (G.w(e) < 0) fatal("spt_dijkstra: negative length edge"); w = G.head(e); if (S.member(w) && min(d[v],g.w(e)) > d[w]) { d[w] = min(d[v],g.w(e)); p[w] = v; S.changekey(w,d[w]); else if (!S.member(w) && p[w] == Null) { p[w] = v; d[w] = min(d[v],g.w(e)); S.insert(w,d[w]); p[u] = Null; return; - 6 -

7 - 7 -