Chapter 9. Greedy Algorithms: Spanning Trees and Minimum Spanning Trees

Transcription

1 msc20 Intro to lgorithms hapter. Greedy lgorithms: Spanning Trees and Minimum Spanning Trees The concept is relevant to connected undirected graphs. Problem: Here is a diagram of a prison for political dissidents. The prisoners have been divided into seven groups as shown. spy plans to help all the prisoners escape by blowing up the gates in the prison walls. ue to the danger of this plan, he wants to destroy as few gates as possible and still allow all prisoners to escape. How many gates must be blasted to do this? The information can be represented as a graph, and the spanning tree will give the solution. 1. Spanning tree: a tree that contains all vertices in the graph. Number of nodes: V Number of edges: V -1 lgorithm to find a spanning tree (similar to finding the shortest path in unweighted graphs) ata structures needed: table (an array) T with size = number of vertices, where T i = parent of vertex v i djacency lists queue of vertices to be processed 1

2 lgorithm 1. hoose a vertex u and store it in the queue. Set a counter = 0, and T u = r (u would be the root of the tree) 2. While the queue is not empty and counter < V -1 do the following: Read a vertex v j from the queue. For each u k in the adjacency list of v j do the following If T k is empty, T k = v j, counter = counter + 1 store u k in the queue omplexity: O( + V ) - we process all edges and all nodes xample: the "prisoners" problem G H F G H F 2

3 2. Minimum Spanning Tree - Prim's algorithm Problem: gents,,,,, F, G, and H are political conspirators in what has become known as the "lottergate ffair". In order to coordinate their cover-up efforts, it is vital that each agent is able to communicate directly or indirectly with every other conspirator. Such communications involve a certain amount of risk to everyone. elow is the table of "risk factors" associated with direct communication between the indicated parties. ll other direct communications are too likely to expose the cover-up scheme. What is the least total risk involved in a connecting system? gent pairs F G F F G H H H Risk factors 8 7 Given: weighted graph. Find a spanning tree with the minimal sum of weights. The algorithm is similar to finding the shortest paths in weighted graphs. The difference is that we record in the table the length of the current edge, not the length of the path. ata structures needed: T[V][]: table with number of rows = number of vertices, and three columns: T i,1 = True if the vertex has been fixed in the tree False otherwise. This is necessary because the graph is not directed and without this information we may enter a cycle. T i,2 = the length of the edge from the parent to vertex v i, T i, = parent of vertex v i djacency lists priority queue of vertices to be processed. The priority of each vertex is determined by the weight of the edge that links the vertex to its parent. The priority may change if we change the parent. It does not matter which vertex is chosen, because all vertices have to be in the tree.

4 lgorithm: 1. Initialize first column to F, select a vertex s and store it in the priority queue with priority = 0, set T s,1 = 0, T s,2 = root 2. While there are vertices in the queue: eletemin a vertex v from the queue and set T v,1 = T For all adjacent vertices w: If T w,1 = T do nothing If T w,2 is empty: T w,2 = weight of edge (v,w) // stored in the adjacency list T w, = v // this is the parent insert w in the queue with priority = weight of (v,w) If T w,2 > weight of (v,w) Update T w,2 = weight of edge (v,w) Update the priority of w (this is done by updating the priority of an element in the queue - decreasekey operation. omplexity O(logV)) Update T w, = v t the end of the algorithm, the tree would be represented in the table with its edges {(T i,, v i ) i = 1, 2, V } omplexity O( log( V )). The complexity is determined by the eletemin operation and ecreasekey operation. oth operations have complexity O(log( V )). eletemin is performed V times - O( V log( V )), and ecreasekey in the worst case is performed for each examined edge, i.e. we have O( log( V )). Since O( V ) O( ) we obtain complexity O( log( V )). xample: The "conspirators" problem

5 The idea is to choose the best link for a vertex from a priority queue. ach vertex may be in three possible states: a. fixed - this is the best choice (fixed links are in red color in the diagrams) b. temporarily included in the tree (blue color in the diagrams) - we still may change its parent, if a better choice occurs. It becomes fixed when deleted from the priority queue. c. not being processed. (black) We start by choosing arbitrary vertex. Let's choose. is linked to (), () and (). The number in the parentheses shows the weight. (), () and ()are stored in the priority queue and three temporary links are created:

6 The best link is (,) with weight - () is deleted from the priority queue. Hence the link (,) is fixed. ll vertices adjacent to that are not fixed, are processed in the following way: a. If a vertex has not been included in the tree, it is stored in the priority queue with the weight of the link to its temporary parent. The parent (in this case ) is stored in a parent's table (not given here). b. If a vertex has been included in the tree with a temporary link, we compare the new weight with the weight of the temporary link. If the new link is better, we create a new temporary link and update the priority of the vertex in the priority queue. The vertices adjacent to are: (), () and (). is fixed has been already included temporarily linked to with weight. The link to has weight, not better, so we leave the as it is. has not been included in the tree. We create a temporary link (,) with weight, and store () in the priority queue.

7 Now the priority queue is: () () () Next from the priority queue comes () - linked to with weight. The link (,) becomes fixed. Then we examine the vertices adjacent to. has a temporary link to, however the link to is better. We create a new temporary link (,) weighted, and update the priority of in the priority queue. has a temporary link to weighted. The new link to is better, we create a new temporary link and update the priority of in the priority queue. The queue now is: (), () The currently built tree is: 7

8 Next from the priority queue we delete and fix the link (,). The vertices adjacent to are already fixed, nothing is done further. Next we read () from the priority queue (now it becomes empty) and fix the link (,). ll vertices adjacent to are fixed, the queue is empty, and the processing stops. The minimum spanning tree is: 8

9 Minimum Spanning Tree - Kruskal's lgorithm Kruskal's algorithm works with tree forests and the set of edges. ach vertex belongs to only one tree in the forest. Initially we build V trees consisting of one vertex only - each vertex is a tree of its own. The basic operation of the algorithm is to choose an edge (u,v) from the set of edges with minimal weight (and remove the edge from the set). This is implemented by storing the edges in a priority queue, with priority = the weight of the edge. a. If u and v belong to one and the same tree then we do nothing. b. If u and v belong to different trees, we link the trees by the edge This is being done until all the trees are combined into one tree only. The algorithm is implemented using operations on disjoint sets. ll the vertices are grouped into sets corresponding to the currently built trees. Since each vertex appears in one tree only, the sets are disjoint. Two set operations are used: a. comparison: ach vertex is associated with the disjoint set where it belongs. To find out whether two vertices are in the same tree, we need to find out if their disjoint sets are the same. b. union When we link the trees, the combine the two disjoint sets to form one set - corresponding to the new tree Implementation Union/find operations: based on trees - the unions are represented as trees - O(NlogN) complexity. The set of trees is implemented by an array. omplexity of Kruskal's algorithm detailed analysis will show O( V ) + O( log( )) + O( log( V )). We need O( V ) operations to build the initial forest with V trees each containing one node. The edges are stored in a priority queue and each time the smallest edge is retrieved, hence we need O( log( )) operations to process the edges. Finally, the disjoint set operations are implemented by a tree with V nodes, hence we need O( log( V )) operations (a comparison is performed for each edge in the worst case). isregarding the lower term O( V ) we get O( (log( V ) + log( )). t the worst case = O( V 2 ). Hence log( ) = O(log( V 2 )) = O(2log( V )) = O(log( V ). Thus we get complexity O( log( V )). On the other hand, V = O( ), hence we can reduce the complexity expression to O( log( )).

10 xample: Let's see how the algorithm works on the "conspirators" graph: The set of edges is ordered according to the weights: (,,), (,, ), (,, ), (,, ), (,, ), (,, ), (,, ) We start with trees, each containing only one vertex: Tree1 Tree2 Tree Tree Tree The best edge is (,,), and we combine Tree1 and Tree: Now we have: Tree2 Tree Tree Tree

11 The next edge deleted from the priority queue is (,, ) We combine now Tree2 and Tree Tree Tree Tree7 Next comes (,, ). belongs to Tree, belongs to Tree7. We combine now Tree and Tree7. Tree Tree8 The priority queue now is: (,, ), (,, ), (,, ), (,, ) Next comes (,, ) and belong to different trees, and we combine them into one tree: Tree 11

12 Tree contains all vertices. It is the minimum spanning tree of the graph. If the algorithm tracks the number of the vertices in the tree, the process will stop here. If the loop runs while the queue is not empty, the remaining three edges (,, ), (,, ), (,, ) will be processed. (,,): and are in one and the same tree, nothing is done. (,,): and are in one and the same tree. (,,) - same situation. We have obtained the same minimum spanning tree as with Prim's algorithm. Note however, that if (,,) was inserted in the priority queue before (,,), the tree would contain the link (,) instead of (,), and will be actually a list. There is nothing wrong - we are interested in the smallest tree no matter what its structure is. iscussion For sparse trees Kruskal's algorithm is better - since it is guided by the edges. For dense trees Prim's algorithm is better - the process is limited by the number of the processed vertices (first column in the table to be F in order to process, otherwise we skip the vertex) 12