Quick Decoding and Encoding of Prüfer Strings: Exercises in Data Structures

Transcription

1 Quick Decoding and Encoding of Prüfer Strings: Exercises in Data Structures Bryant A. Julstrom Department of Computer Science St. Cloud State University St. Cloud, MN Abstract Cayley's Formula tells us that a complete undirected graph on n vertices has n n-2 distinct spanning trees. Prüfer's proof of this result establishes a one-to-one correspondence between the spanning trees on n vertices and the strings of length (n - 2) over an alphabet of n symbols. The proof describes two algorithms. One identifies the edges in the spanning tree corresponding to a string, and the other builds the string corresponding to a list of edges in a spanning tree. Naive implementations of these algorithms have times that are quadratic in the number n of vertices. Elaborating the data structures they use reduces both times to O(n log n). This paper describes these faster implementations. The data structures they use are familiar to any student who has completed CS2. They include priority queues implemented with heaps and adjacency lists implemented with trees.

2 1. Introduction A spanning tree of a connected, undirected graph G is a subgraph of G that connects all of G 's vertices and contains no cycles, as Figure 1 illustrates. Clearly the number of edges in a spanning tree must be one less than the number of vertices it connects. A complete graph on n vertices has all n(n-1)/2 possible edges. When a graph is complete, Cayley's Formula tells us that it has n n-2 distinct spanning trees [Cayley, 1889; Even, 1973, pp ]. Figure 1: A graph on a collection of vertices (a) and a spanning tree for that graph (b). Computer Science students generally encounter graphs, and write programs that represent and operate on them, in CS2, Data Structures. They will already have seen various structures based on and related to trees, such as binary search trees and priority queues implemented with heaps. The need to perform quickly operations that find, insert, and remove items motivates the introduction of these structures. In programs that operate on graphs, the graphs themselves can be represented in several ways. These include adjacency matrices, in which entry (i,j) indicates the presence or absence of the edge connecting vertices v i and v j, adjacency lists, in which there is, for each vertex, a list of the other vertices with which it forms edges, and simple lists of edges, which can be implemented as linked structures or in arrays. A constructive proof of Cayley's Formula, due to Prüfer [1918; Even, 1973, pp ], provides another representation for graphs that are spanning trees. Prüfer's proof establishes a one-to-one correspondence between spanning trees on n vertices and strings of length (n - 2) over an alphabet of n symbols; note that there are n n-2 such strings. The proof describes two algorithms. The first identifies the edges in a spanning tree from a string, and the second builds the string from the edges in the spanning tree. Thus these strings encode spanning trees. Prüfer strings have been used to represent spanning trees, for example, in genetic algorithms for computationally difficult problems that search spaces of spanning trees. These have included the rectilinear Steiner problem [Julstrom, 1993], the probabilistic minimum spanning tree problem [Abuali, Schoenefeld, and Wainwright, 1994], the degree-bounded minimum spanning tree problem

3 [Zhou and Gen, 1997], the time-dependent minimum spanning tree problem [Gargano, Edelson, and Koval, 1998], and a network design problem [Kim and Gen, 1999]. Such applications must identify the spanning trees Prüfer strings represent and encode spanning trees as Prüfer strings. Straightforward implementations of the two algorithms in Prüfer's proof have times that are O(n 2 ). Elaborating the data structures the algorithms use can reduce both times to O(n log n). This paper describes these faster implementations. The data structures they use include arrays, priority queues implemented with heaps, and adjacency lists implemented with trees. These structures are familiar to any student of CS2, and the resulting algorithms make interesting examples of their application. The following sections of this paper describe the Prüfer coding of spanning trees and the basic conversion algorithms; an efficient algorithm for building a list of edges from a Prüfer string, and an efficient algorithm for building a Prüfer string from a list of spanning tree edges. 2. The Prüfer coding of spanning trees Cayley's Formula establishes that a complete graph on n vertices has n n -2 distinct spanning trees. Prüfer's proof achieves this result constructively by describing a one-to-one correspondence between the spanning trees on n vertices and strings of length (n - 2) over an alphabet of n symbols. The symbols must be ordered, and one labels each vertex. Consider identifying the spanning tree (that is, the list of edges) that a Prüfer string represents. In particular, let s = a 1 a 2... a n-2 be a Prüfer string. The degree of a vertex in a graph is the number of edges in which the vertex participates. In the spanning tree corresponding to a Prüfer string, each vertex's degree is one plus the number of times its symbol appears in the string. The following algorithm identifies the tree's edges. scan the Prüfer string to initialize the vertices' degrees; for i from 1 to n-2 loop v <- the vertex with the smallest label whose degree is 1; (v,a i ) is a spanning tree edge; decrement the degrees of v and a i ; end loop; two vertices have degree 1; they form the last edge; For example, let the letters a through g label seven vertices, and consider the spanning tree on them represented by the Prüfer string bebbg. Counting the occurrences in the string of the vertices' labels and adding 1 to each count, the degrees of the vertices are:

4 The smallest-named vertex with degree 1 is a, and b is the string's first symbol, so (a,b) is an edge in the spanning tree. The degrees of both a and b are decremented to obtain Now the smallest-named vertex with degree 1 is c, so (c,e) is a spanning tree edge and the degrees of c and e are decremented. The process continues through three more iterations, identifying the edges (d,b), (e,b), and (b,g). At this point, the vertices' degrees are all zero except for f and g, which form the spanning tree's last edge. Figure 2 shows the resulting spanning tree. Figure 2: The spanning tree corresponding to the Prüfer string bebbg. A simple implementation of this algorithm holds the vertices' degrees in an array and scans that array (n - 2) times. On each iteration, it finds the smallest-named vertex with current degree 1. The array contains n entries, of course, so the implementation's time is O(n 2 ). Conversely, consider building a Prüfer string from a list of edges that form a spanning tree. Again, the vertices' degrees are crucial, and the algorithm's first step is to find them. scan the list of edges to initialize the vertices' degrees; for i from 1 to n-2 loop u <- the vertex of degree 1 with the smallest label; v <- the other vertex in u's edge; the i th Prüfer symbol is v; remove (u,v) from the list of edges; decrement the degrees of u and v; end loop; For example, we know that the edges (a,b), (b,e), (d,b), (e,c), (b,g), and (g,f) form a spanning tree on seven vertices labeled a through g. The vertex of degree 1 with the smallest label in this list is a, found in the edge (a,b); the edge's other vertex b is the first symbol in the tree's Prüfer string. After removing (a,b) from the list of edges, the smallest-labeled vertex of degree 1 is c; the other vertex of its edge, e, joins the Prüfer string, the edge leaves the list, and so on. The resulting string is, of course, bebbg.

5 Again, a simple implementation of this algorithm maintains an array of the vertices' degrees and a list of the spanning tree edges. Each of its (n - 2) iterations scans the array and the list, so the implementation's time is O(n 2 ). The following two sections describe how more sophisticated data structures---in particular, priority queues implemented with heaps and lists of vertices implemented with trees---can be used in implementations of these two algorithms whose times are O(n log n). 3. Efficiently decoding Prüfer strings In the algorithm that extracts the edges in a spanning tree from its Prüfer string, one vertex of each edge has in turn the smallest label among the vertices with current degree 1. If the algorithm identifies this vertex by scanning an array of the vertices' degrees, its time is O(n 2 ). The number of edges in a spanning tree on n vertices is always (n - 1) and each must be listed, so a faster version of this algorithm must more quickly identify the vertex of current degree 1 with the smallest label. To do this, the algorithm cannot scan the array of vertices' degrees and must maintain another data structure. That structure is a priority queue that holds the vertices whose current degrees are 1, and in which vertices with smaller labels have higher priority. In general, a priority queue holds a collection of items, each with an associated priority. When an item is removed from the queue (dequeued), it is always the item with the highest priority. When the queue is implemented in a binary heap, and the heap in turn is implemented in an array, the operations of dequeueing the highest-priority item and restoring the heap and of enqueueing a new item can each be carried out in time that is O(log n), where n is the number of items in the queue [Williams, 1964; Aho, Hopcroft, and Ullman, 1983, pp ; Manber, 1989, pp.68-70]. We elaborate the algorithm to include a priority queue of the vertices with current degree 1. Each vertex is enqueued when its degree falls to 1, and the next vertex dequeued always has the smallest label among the vertices with degree 1. In the following sketch of the algorithm, the Prüfer string is p[], and an array maintains the degrees of the vertices. scan p[] to initialize the vertices' degrees; enqueue the vertices with degree 1; for i from 1 to n-1 loop dequeue, and assign the dequeued vertex to v; (v,p[i]) is a spanning tree edge; decrement the degrees of v and p[i]; if the degree of p[i] is 1 then enqueue p[i]; end loop; dequeue twice to identify the vertices of the last edge;

6 Figure 3 shows this algorithm's two data structures---the array of the vertices' degrees and the priority queue, implemented in a heap, of the vertices with degree 1---after they have been initialized and before the first loop iteration as the algorithm decodes the Prüfer string bebbg. Figure 3: The array of vertices' degrees and the priority queue of vertices of degree 1, implemented with a heap, as the extended algorithm begins to decode the Prüfer string bebbg. In general, as the algorithm identifies the (n - 1) edges in the spanning tree a string of (n - 2) symbols represents, it enqueues and later dequeues each of the n vertices exactly once. Thus the priority queue never holds more than n items, the time for each enqueue and dequeue operation is O( log n), and the time of the entire algorithm is O(n log n). Indeed, the initial priority queue can be built in time that is O(n) [Wood, 1993, pp ], but this does not change the time of the loop. The Appendix gives C++ code for the algorithm. This algorithm can be used to generate random spanning trees efficiently. It is difficult to generate random spanning trees directly, but easy to generate random Prüfer strings. The decoding algorithm then makes explicit the edges in the corresponding spanning trees. 4. Efficiently encoding Prüfer strings The algorithm that writes a Prüfer string from a list of spanning tree edges also accumulates the degrees of the vertices and decrements them as the algorithm proceeds. It repeatedly identifies the vertex with the smallest label among those with degree 1, then appends to the string the other vertex of its edge and removes the edge from consideration. If simple linear searches identify each vertex and edge, the algorithm's time is O(n 2 ). To accelerate the algorithm, we again use a priority queue. This time, its elements are the remaining edges with one vertex of current degree 1. That vertex determines its edge's priority; smaller labels have higher priority. Now the algorithm can quickly identify the next edge to process and the next Prüfer symbol. However, after the algorithm dequeues an edge and identifies the next symbol for the Prüfer string, it decrements the degree of that symbol's vertex. When the vertex's degree falls to 1, the algorithm must enqueue the one remaining edge to which it belongs, but who is at its other end? Searching the list of edges takes too long; the algorithm must

7 keep track of the vertices with which each vertex shares an unprocessed edge, and it must update that information in logarithmic time. Thus we extend the algorithm with another data structure, an array of adjacency lists. For each vertex, there is a list of the vertices with which it shares edges, and the lists are implemented with trees. Initially, these lists represent the entire spanning tree. After the algorithm processes each edge, it removes from the array of lists the two entries that represent the edge. When a vertex's degree falls to 1, the one vertex remaining in its list (tree) is at the other end of its one remaining edge; it can be retrieved in constant time. The following sketch summarizes the resulting algorithm. initialize the vertices' degrees; build the adjacency lists; enqueue the edges one of whose vertices has degree 1; for i from 1 to n-2 loop dequeue the highest-priority edge (u,v); // u has degree 1. the i th Prüfer symbol is v; decrement the degrees of u and v; remove the vertices from each other's trees; if the degree of v is 1 then enqueue the edge formed of v and the one vertex remaining in its tree; end loop; No tree that implements an adjacency list can contain more than (n - 1) vertices. If the trees are binary search trees, the average-case times for insertions and deletions on them are O( log (n-1)); that is, O( log n) [Knuth, 1973, pp ; Aho, Hopcroft, and Ullman, 1983, pp ; Manber, 1989, pp.73-74]. In the worst case, all a tree's interior nodes have just one child, so that the tree is in fact a simple linked list and operations on it require linear time. Though such degenerate trees are rare [Knuth, 1973, p.427], we can ensure that operations' times are logarithmic by implementing the adjacency lists with trees whose shape properties are guaranteed. These include AVL trees [Adelson-Velskii and Landis, 1962; Knuth, 1973, pp ; Horowitz and Sahni, 1977, pp ], 2-3 trees [Horowitz and Sahni, 1977, pp ; Aho, Hopcroft, and Ullman, 1983, pp ; Wood, 1993, pp ], trees [Sedgewick, 1998, pp ], and red-black trees [Guibas and Sedgewick, 1978; Wood, 1993, pp ; Sedgewick, 1998, pp ]. Thus the algorithm uses three data structures: an array of the vertices' degrees, a priority queue of edges with one vertex of degree 1, and a set of adjacency lists. Figure 4 shows the structures just before the algorithm enters its main loop as it builds the Prüfer string corresponding to the spanning tree edges (a,b), (b,e), (d,b), (e,c), (b,g), and (g,f). The priority queue is implemented with a heap, and the adjacency lists are implemented with binary trees.

8 Figure 4: The three data structures in the extended algorithm that builds the Prüfer string from a list of spanning tree edges. The algorithm is about to enter its loop for the first time as it writes the Prüfer string corresponding to the edges (a,b), (b,e), (d,b), (e,c), (b,g), and (g,f). In the priority queue of edges, the first vertex listed in each edge has degree 1. The priority queue is implemented with a heap, and the adjacency lists are implemented with binary search trees. Does this proliferation of data structures result in a faster algorithm? Scanning the list of edges to build the array of degrees is O(n), since there are (n - 1) edges. Building the adjacency lists requires inserting 2(n - 1) vertices into them; each insertion is O( log n), so this step's time is O(n log n), and initializing the priority queue can be O(n), as observed above. The algorithm's main loop is executed (n - 2) times. Within it, an edge is dequeued, two vertices are removed from adjacency lists, and an edge may be enqueued. Each of these operations is O( log n), so the time of the loop and of the entire algorithm is reduced to O(n log n). Again, the Appendix contains C++ code for this version of the algorithm. 5. Conclusion Prüfer's proof of Cayley's Formula establishes a one-to-one correspondence between the spanning trees on n vertices and the strings of length (n - 2) over an alphabet of n ordered symbols associated with the vertices. It describes algorithms that identify the string corresponding to a given tree and the tree corresponding to a given string. Naive versions of these algorithms have times that are O(n 2 ), where n is the number of vertices the spanning tree connects. By elaborating the data structures the algorithms use, we have constructed versions whose times are O(n log n). Both algorithms depend on priority queues implemented with heaps, where removal of the highest-priority item and insertion of an arbitrary item can be carried out in time that is O( log n). The algorithm that builds a Prüfer string from a list of spanning tree edges also uses adjacency lists implemented with trees. Because these data structures typically appear in CS2, the algorithms make interesting examples in that course. More generally,

9 the algorithms illustrate the usefulness of priority queues in algorithms with greedy steps, like identifying the smallest-labeled vertex of degree 1. These algorithms' times do depend on the representation of the spanning tree. If it is maintained as an adjacency matrix, that matrix must be scanned in each algorithm, rendering the times for both O(n 2 ), regardless of efficiencies elsewhere. Appendix: Code This appendix presents C++ functions that implement the two algorithms developed above. In them, the integers from 0 to (n-1) label vertices, and a Prüfer string is an array of such integers. All arrays are indexed from zero. An edge is represented by a record containing two vertices' integers, and an array of these records holds a list of spanning tree edges. The following declarations apply: struct edge int v1; int v2; }; typedef edge edge_list[n-1]; typedef int prufer_string[n-2]; The following function identifies the edges in the spanning tree that a Prüfer string represents. In it, pqueue is a priority queue of integers. void p2list ( prufer_string p, edge_list edges ) pqueue q; // Priority queue of vertices of current degree 1 int degree[n]; // Array of vertices' current degrees int v; // A vertex // Find the initial degrees of the vertices: for (v=0; v < n; ++v) degree[v] = 1; for (int i=0; i<n-2; ++i) degree[p[i]] += 1; // Initialize the priority queue of vertices of degree 1: for (v=0; v < n; ++v) if ( degree[v] == 1 ) q.enqueue(v); // Identify the spanning tree edges: for (int i=0; i<n-2; ++i) q.dequeue(v); // The vertex of degree 1 with lowest number edges[i].v1 = v; edges[i].v2 = p[i];

10 } degree[v] = 0; degree[p[i]] -= 1; if ( degree[p[i]] == 1 ) q.enqueue(p[i]); } // Identify the last edge: q.dequeue(v); edges[n-2].v1 = v; q.dequeue(v); edges[n-2].v2 = v; The following function builds the Prüfer string that corresponds to a spanning tree. In it, edge_pq is a priority queue of edges, as Section 4 described, and bst is a binary search tree class, instantiated here with integers as elements, representing vertices. Then t[] is a collection of adjacency lists: an array of n of these trees. The bst function top() returns the value in the invoking tree's root node. void list2p ( edge_list edges, prufer_string p ) edge_pq q; // Priority queue of candidate edges bst<int> t[max]; // Array of BSTs of integers int degree[max]; // Array of vertices' degrees edge e; // An edge int u, v; // The dequeued edge's vertices // Initialize the array of degrees and the adjacency lists. for (int i=0; i<n; ++i) degree[i] = 0; for (int i=0; i<n-1; ++i) degree[edges[i].v1] += 1; // Find degrees of all vertices. degree[edges[i].v2] += 1; t[edges[i].v1].insert(edges[i].v2); // Vertices into BSTs. t[edges[i].v2].insert(edges[i].v1); } // Build heap of all edges that contain a vertex of degree 1. for (int i=0; i<n-1; ++i) if ( degree[edges[i].v1] == 1 ) q.enqueue(edges[i]); else if ( degree[edges[i].v2] == 1 ) swap(edges[i].v1, edges[i].v2); // Exchange the vertices q.enqueue(edges[i]); } // Build the Prüfer string. for (int i=0; i<n-2; ++i) q.dequeue(e); // Dequeue the front edge.

11 } } u = e.v1; v = e.v2; p[i] = v; degree[u] -= 1; degree[v] -= 1; t[u].remove(v); t[v].remove(u); if ( degree[v] == 1 ) e.v1 = v; e.v2 = t[v].top(); q.enqueue(e); } // "Inner" vertex joins p[]. // Decrement both degrees. // Remove v from u's BST. // Remove u from v's BST. // Enqueue any new candidate edge. // The last vertex in v s tree

12 References Abuali, F.N., Schoenefeld, D.A., & Wainwright, R.L. (1994). Designing telecommunications networks using genetic algorithms and probabilistic minimum spanning trees. In E. Deaton, D. Oppenheim, J. Urban, & H. Berghel (Eds.), Proceedings of the 1994 ACM Symposium on Applied Computing. New York: ACM Press, pp Adelson-Velskii, G.M., & Landis, E.M. (1962). An algorithm for the organization of information. Soviet Mathematics, 3, Aho, A.V., Hopcroft, J.E., & Ullman, J.D. (1983). Data Structures and Algorithms. Reading, MA: Addison-Wesley. Cayley, A. (1889). A theorem on trees. Quarterly Journal of Mathematics, 23, Even, S. (1973). Algorithmic Combinatorics. New York: The Macmillan Company. Gargano, M.L., Edelson, W., & Koval, O. (1998). A genetic algorithm with feasible search space for minimal spanning trees with time-dependent edge costs. In J. Koza, W. Banzhaf, K. Chellapilla, K. Deb, M. Dorigo, D.B. Fogel, M.H. Garzon, D.E. Goldberg, H. Iba, & R.L. Riolo (Eds.), Genetic Programming 1998: Proceedings of the Third Annual Conference. San Francisco, CA: Morgan Kaufmann, p.495. Guibas, L., & Sedgewick, R. (1978). A dichromatic framework for balanced trees. In Proceedings of the 19th IEEE Symposium on the Foundations of Computer Science, pp Horowitz, E., & Sahni, S. (1977). Fundamentals of Data Structures. Potomac, MD: Computer Science Press. Julstrom, B.A. (1993). A genetic algorithm for the rectilinear Steiner problem. In Stephanie Forrest (Ed.), Proceedings of the Fifth International Conference on Genetic Algorithms. San Mateo, CA: Morgan Kaufmann, pp Kim, J.R., & Gen, M. (1999). Genetic algorithm for solving bicriteria network topology design problem. In Proceedings of the 1999 IEEE Congress on Evolutionary Computation: Vol. 3. New York: IEEE Press, pp Knuth, D.E. (1973). The Art of Computer Programming. Volume 3: Sorting and Searching. Reading, MA: Addison-Wesley. Manber, U. (1989). Introduction to Algorithms: A Creative Approach. Reading, MA: Addison-Wesley.

13 Prüfer, H. (1918). Neuer beweis eines satzes ueber permutationen. Arch. Math. Phys., 27, Sedgewick R. (1998). Algorithms in C++ (3rd ed.). Reading, MA: Addison-Wesley. Williams, J.W.J. (1964). Algorithm 232: Heapsort. Communications of the ACM, 7(6), Wood, D. (1993). Data Structures, Algorithms, and Performance. Reading, MA: Addison-Wesley. Zhou, G., & Gen, M. (1997). Approach to degree-constrained spanning tree problem using genetic algorithm. Engineering Design and Automation, 3(2),