EXHAUSTIVELY generating a class of combinatorial objects

Transcription

1 International Conference on Mechanical, Production and Materials Engineering (ICMPME') June 6-7,, Bangkok An Improving Scheme of Unranking t-ary Trees in Gray-code Order Ro Yu Wu, Jou Ming Chang, An Hang Chen, and Chun Liang Liu Abstract A t-ary tree is a rooted tree such that every internal node has exactly t disjoint subtrees. Recently, a concise representation called RD-sequences was introduced to represent t-ary trees and their generalization called non-regular trees. In particular, a loopless algorithm has been proposed by Wu et al. () for generating non-regular trees (and thus of t-ary trees) encoded by RD-sequences in a Gray-code order. In this paper, based on such a Gray-code order, we present an efficient unranking algorithm of t-ary trees with n internal nodes. The time complexity and space requirement in the algorithms are O(max{n, tn}) and O(tn), respectively. As a by-product, we have an improvement on unranking t-ary trees encoded by z- sequences in a Gray-code order. Index Terms Gray-code, ranking algorithms, t-ary trees, unranking algorithm I. INTRODUCTION EXHAUSTIVELY generating a class of combinatorial objects has attracted a lot of research due to the importance for many applications, e.g., searching for the desired object with a certain feature among all candidates, looking for a counterexample to some conjecture, or analyzing the average performance of an algorithm over all possible inputs. As usual, combinatorial objects are encoded as integer sequences so that these sequences can be generated in a particular order such as the lexicographic order [], [], [], [] or a Graycode order [], [5] [], [5], [7], [9]. For efficiency of generation, algorithms to generate objects in the lexicographic order are demanded to run in a constant amortized time. By contrast, algorithms to generate objects in a Gray-code are demanded to run in a constant time for each generation, i.e., a loopless algorithms. Accordingly, a loopless algorithm is implemented non-recursively by using, after the initialization of the first object, only assignment statements and if-thenelse statements. The reader is referred to [] for an excellent survey of generating combinatorial objects in Gray-code orders. Given a specific order on the class of combinatorial objects, a ranking algorithm is a function that determines the rank of a given object in the exhaustive generated list, and an unranking algorithm is one that generates the object (or its Ro-Yu Wu is with the Department of Industrial Management, Lunghwa University of Science and Technology, Taoyuan, Taiwan, ROC. ( eric@mail.lhu.edu.tw) Jou-Ming Chang and An-Hang Chen are with the Institute of Information and Decision Sciences, National Taipei College of Business, Taipei, Taiwan, ROC Chun-Liang Liu is with the Department of Humanity & Social Science, National Taiwan Normal University, Taipei, Taiwan, ROC representation) corresponding to a given rank. Trees are one of the most important and fundamental combinatorial objects in computer science. For t, a t-ary tree is a rooted tree such that every internal node has exactly t disjoint subtrees. Many algorithms have been developed for generating t-ary trees (as well as binary trees) with n internal nodes. Moreover, many ranking algorithms [], [], [], [], [], [], [6], [8], [] and unranking algorithms [], [], [], [], [6], [8] for diverse representations of t-ary trees with n internal nodes have been proposed. Among all representations of t-ary trees, a well-formed representation called z-sequences was first introduced by Zaks []. Roelants van Baronaigien [] and Xiang et al. [9] independently presented a loopless algorithm for generating t-ary trees encoded by z-sequences in a Graycode order. Based on such a Gray-code order, Ahmadi-Adl et al. [] recently presented O(tn )-time ranking and unranking algorithms. To the best of our knowledge, it seems that most of ranking and unranking algorithms for t-ary trees with n internal nodes require O(tn ) time and space. Recently, Wu et al. [8] introduced a new type of integer sequences called RD-sequences to represent t-ary trees and showed that, using such a representation in lexicographic order, both ranking and unranking problems for t-ary trees with n internal nodes can be solved in O(tn) time. Moreover, they showed that there is a complementary relationship between RD-sequences and z- sequences (see Theorem ). Indeed, RD-sequences have been used to represent a wider class of trees called non-regular trees [6], [7], i.e., ordered trees whose internal nodes have a pre-specified degree sequence called branching sequence in preorder. With the help of a coding tree structure, Wu et al. [7] presented a loopless algorithm to generate RDsequences of non-regular trees (and thus of t-ary trees) in a Gray-code order using n+o() space. Later on, Wu et al. [6] dealt with the ranking and unranking problems for non-regular trees encoded by RD-sequences in lexicographic order and showed that, given a prescribed branching sequence (s, s,..., s n ), both ranking and unranking problems can be solved in O(nS) time, where S = n i= (s i ). In this paper, based on the Gray-code order of t-ary trees encoded by RD-sequences in [7], we present an efficient unranking algorithm. The time complexity and space requirement in our algorithms are O(max{n, tn}) and O(tn), respectively. 8

2 International Conference on Mechanical, Production and Materials Engineering (ICMPME') June 6-7,, Bangkok II. PRELIMINARIES A. Representation of t-ary trees Wu et al. [8] defined a concise representation, called rightdistance sequences (abbreviated as RD-sequences), to describe t-ary trees. Let T be a t-ary tree with n internal nodes numbered from to n in preorder (i.e., visit the root and then recursively the subtrees of T from left to right). The rightdistance of an internal node i T, denoted by d i, is defined as follows: { if i = (i.e., the root of T ); d i = d p(i) + t k otherwise, where p(i) stands for the parent of node i and k is the rank of node i among all sons of p(i) (from left to right). Then, denote the sequence rd(t ) = (d, d,..., d n ) as the RD-sequence of T. A characterization has been pointed out in [8] that an integer sequence (d, d,..., d n ) is the RD-sequence of a t- ary tree if and only if d = and d i d i + t for i =,..., n. For example, Figure shows the -ary tree T with rd(t ) = (,,,,, ). T, we denote z i as the visited order of node i when both internal nodes and leaves of T are traversed in preorder. Then, the resulting sequence z(t ) = (z, z,..., z n ) is called the z- sequence of T. Note that every z-sequence satisfies z i < z i t(i ) +. For example, the z-sequence of the - ary tree T shown in Figure is z(t ) = (,, 5, 6,, 6). The following is the complementary relationship between RDsequences and z-sequences. Theorem : [8] If a t-ary tree is encoded as (d i, d,..., d n ) for RD-sequence and (z, z,..., z n ) for z- sequence, then d i + z i = t(i ) + for i =,,..., n. B. Loopless generation and Gray-code order In this section, we give the concept about the loopless Graycode generation algorithm for t-ary trees proposed in [7]. Let T t,n denote the set of all ( t-ary trees with n internal nodes. Recall that T t,n = tn+ ) tn+ n = tn ) (t )n+( n. To describe all t-ary trees in a systematic way, a coding tree called flipflap tree was introduced. A flip-flap tree, denoted by T t,n, is a rooted labeled tree with n levels constructed as follows: Fig.. A -ary tree with 6 internal nodes. Another way of presenting t-ary trees is the so-called z- sequences suggested by Zaks []. For each internal node i (i) The first level contains the only one node (i.e.,the root) with label ; (ii) Every node with label d in the ith level, i < n, has d + t sons labeled by,,..., d + t in the next level, where the sons are arranged in either,,..., d + t, (i.e., an up fragment) or, d + t,...,, (i.e., a down fragment). (iii) If the sons of a node x with label d are arranged in an up fragment, then the sons of its adjacency siblings (i.e., nodes with labels d and d + in the same level as x), if exist, are arranged in a down fragment, and vice versa Fig.. A flip-flap tree T,. 9

3 International Conference on Mechanical, Production and Materials Engineering (ICMPME') June 6-7,, Bangkok Accordingly, nodes on the boundary in every fragment are labeled by either or. And, the full labels along a path from the root to a leaf in T t,n indicate the RD-sequence of a t-ary tree. Moreover, a property showed that any two adjacent RD-sequences in the flip-flap tree differ in exactly one digit. Therefore, this provides the base for designing a loopless Gray-code generation algorithm. For example, Figure shows a flip-flap tree with respect to all -ary tees with internal nodes, where the first fragment in each level is a down fragment. Thus, the first RD-sequence appears in T, is (,,, ). Also, a path with bold lines from the root to a leaf in T, represents the -ary tees with RD-sequence (,,, ). A procedure called NextRD() is designed for generating the next RD-sequence in [7]. For t-ary trees, this procedure needs only n+o() space. Array d[..n] is used to store the current RD-sequence in the Gray-code order. Array c[..n] is for indicating the type of current fragment at level i for i n, where c[i] = indicates an up fragment and c[i] = indicates a down fragment. Array F [..n] is for keeping the track of positions to be processed. Initially, let i = n and for each j =,,..., n, set d[j] =, c[j] = and F [j] = j. When each time NextRD() is invoked, d[i] will be changed by increasing one or decreasing one which depends on the type of c[i] (where arithmetic is taken modulo d[i ] + t). If the current fragment is faced on a boundary, it changes the type of c[i], appoints the next changed position as i = F [n], and performs the updates of F [i], F [i ] and F [n]; otherwise, it merely keeps the next changed position as i = n. The algorithm terminates when the condition i = holds. The reader please refer to the details of the algorithm written by C++ in [7]. III. UNRANKING ALGORITHM We first observe that the largest label for nodes in the ith level of T t,n is (i )(t ). Also, if two nodes have the same label in the same level of T t,n, then they have the same degree (i.e., the number of children). This further implies that the numbers of leaves in the subtrees rooted at each of the two nodes are the same. Let A i,k denote the number of leaves in the subtree rooted at a node with label k in the ith level of T t,n. Obviously, A n,k = for k (n )(t ) and A n,k = t + k for k (n )(t ). In general, we have A i,k = t+k j= A i+,j () where i n and k (i )(t ). For the efficiency of computation, we define the following formula: B i,k = k A i,j () j= where i n and k (i )(t ). That is, the term B i,k indicates the total number of leaves for those subtrees rooted at nodes with labels from to k in the ith level of T t,n. Hence, a table built from Eq. () is named as the accumulation table with respect to T t,n. Wu et al. [8] gave the following closed-form for calculating the accumulation table. For i n and k (i )(t ), B i,k = k + mt + k + ( ) mt + k + where m = n i +. For instance, the accumulation table with respect to T, is shown below. i B i,k k We are now in a position to determine the rank of a t-ary tree in the Gray-code order of [7]. For a given t-ary tree T associated with the RD-sequence rd(t ) = (d, d,..., d n ), let x i denote the node with label d i in the flip-flap tree T t,n such that the full labels along the path x, x,..., x n represent the given RD-sequence. For each i =,,..., n, let R(i) be the rank of x i in the ith level of T t,n. Hereafter, the rank of a node in each level of T t,n is ordered from left to right and a ranking always starts with. Note that R() = and our ranking algorithm is to obtain R(n). Since each level of T t,n begins with a down fragment and the two types of fragments appear alternately, it is easy to check the following property. Proposition : For i < n, if the rank of a node in the ith level of T t,n is even (respectively, odd), then its sons are arranged in a down fragment (respectively, an up fragment). For each i =,..., n, we first set R(i) = and the computation of R(i) requires i updates by means of Eqs. () and (5). If i n and x i+ is not the first node in a fragment, let y i+ be the node with rank R(i + ) in the (i+)th level of T t,n. Then, for each j = i+,..., n, we update R(j) to represent the rank of the rightmost descendant of y i+ in the jth level of T t,n (including y i+ itself if j = i + ). Let l = n j + i +. By Proposition, there are two cases to compute R(j). If R(i) (mod), the sons of x i are arranged in a down fragment. In this case, we have m () R(j) = R(j) + (B l,di+(t ) B l,di+ + B l, ). () On the other hand, if R(i) (mod), the sons of x i are arranged in an up fragment. In this case, we have R(j) = R(j) + (B l,di+ B l, ). (5) The last term of the right hand side in each of Eqs. () and (5) is called the incremental change of R(j) in the update. The meanings of incremental changes are illustrated in Figure and Figure, respectively. We now provide a function called Unranking to convert a positive integer N to its corresponding RD-sequence of a t- ary tree with n internal nodes, where N < T t,n = B,. From Eqs. () and (5) we have known that a down fragment or an up fragment contributes an incremental change to R(j) 5

4 International Conference on Mechanical, Production and Materials Engineering (ICMPME') June 6-7,, Bangkok level x i d i x i a down fragment i+ d i+ + d i+ y i+ x i+ j old R(j) new R(j) n B,di+ B, B,di+(t ) level Fig.. Illustration of Eq. (). x i d i x i an up fragment x i+ i+ d i+ d i+ y i+ j n old R(j) new R(j) B,di+ B, Fig.. Illustration of Eq. (5). and to each of downward levels in T t,n. Thus, the basic ideal of the unranking function is to decompose N into a sequence of incremental changes of R(n). Initially, we set R(j) = for j =,..., n. Then, we determine the largest integer i on which B i, > N and set d j = for j i. Recall that d = is always true. A main loop in Unranking is designed for the decomposition of N, and indeed, it can also be used to compute d i+, d i+,..., d n. For each round of the main loop, according to the parity of R(i), we first check that the arrangement of the sons of x i is a down fragment or an up fragment. Then, we compute the incremental change of R(i + ) for determining the node x i+ in the (i + )th level of T t,n. For the case of a down fragment (respectively, an up fragment), if x i+ is the leftmost child (respectively, rightmost child) of x i, then we set d i+ =. Otherwise, we update N by subtracting the incremental change of R(n) from N, and in the meanwhile the term d i+ is determined. In addition, for j = i +,..., n, we update R(j) by using Eqs. () and (5). Once the main loop has terminated, the function outputs d, d,..., d n. The details of Unranking is shown below. 5

5 International Conference on Mechanical, Production and Materials Engineering (ICMPME') June 6-7,, Bangkok Function Unranking(N) begin for j = to n do R(j) = d j = ; i = n; while B i, N do i = i ; while i n do j = i + ; if R(i) (mod) then // a down fragment k = ; while N < B j,di +(t ) B j,k + B j, and k d i + t do k = k + ; if k = d i + t then // x i+ is the leftmost child of x i d j = ; else d j = k; N = N (B j,di +(t ) B j,k + B j,); for j = i + to n do l = n j + i + ; R(j) = R(j)+(B l,di +(t ) B l,k +B l, ); else // an up fragment k = d i + (t ); while N < B j,k B j, do k = k ; N = N (B j,k B j,); if k = d i + (t ) then // x i+ is the rightmost child of x i d j = ; else d j = k + ; for j = i + to n do l = n j + i + ; R(j) = R(j) + (B l,k B l, ); i = i + ; return d, d,..., d n; Example. Suppose we are given integers N =, n = and t =. We now perform Unranking(N). Initially, R() = R() = R() = R() =. Since B, = < N < B, = 55, we have d = and i = before entering the main loop with condition i n. There are three rounds to do in the main loop. When i = (i.e., j = ), since R() = is even, the sons of x are arranged in a down fragment. We can check N = < B, B, + B, = 55 + = 7 and k d + t = + (when k = ); N = B, B, + B, = = and k d + t = + (when k = ). Thus, d = k = and N = = 9. Moreover, we have R() = R() + B, B, + B, = + + =, R() = R() + B, B, + B, = + + =, R() = R()+B, B, +B, = =. In this case, the incremental change of R() is. When i = (i.e., j = ), since R() = is odd, the sons of x are arranged in an up fragment. We can check N = 9 < B, B, = 5 = (when k = d + ( ) = ); N = 9 B, B, = 8 = 5 (when k = ). Thus, N = 9 5 = and d = k + =. Moreover, we have R() = R() + B, B, = + = 6, R() = R() + B, B, = + 8 = 7. In this case, the incremental change of R() is 8 = 5. When i = (i.e., j = ), since R() = 6 is even, the sons of x are arranged in a down fragment. We can check N = < B,6 B, + B, = 7 + = 6 and k d + t = + (when k = ); N = < B,6 B, + B, = 7 + = 5 and k d + t = + (when k = ); N = B,6 B, + B, = 7 + = and k d + t = + (when k = ). Thus, d = k = and N = =. Moreover, we have R() = R() + B,6 B, + B, = =. In this case, the incremental change of R() is 7 + =. When i =, the main loop stops the running and the function outputs,,,. By using a similar argument as in the previous section, we will show that every element of the accumulation table in Unranking can be accessed in a constant time. For instance, we consider elements of the accumulation table in a statement marked with an upward triangle. Because all accessed elements occur in a set of certain columns and we take elements in a column from bottom to up, this can be done by using the preprocessing table described as before. For accessing elements of the accumulation table in some other place, we need the following two formulae which are easily derived from Eq. (): and B i,k+ = B i,k B i+,k+(t ) = B i,k (k + )(mt + k + ) (k + )(m(t ) + k + ) m(k + t) (k + )(mt + k) where m = n i +. Recall that before entering the main loop of Unranking, the element B i, (and thus all lower elements in the accumulation table) has been calculated and we have d i =. For each round in the main loop, we let j = i +. We claim that the element B j,dj is easy to obtain and it can be used as a reference in the next round if we keep the value. For a down fragment, the following condition in a while loop is tested: N < B j,di+(t ) B j,k + B j,. Thus, if k = d i + t (i.e., x i+ is the leftmost child of x i ), then B j,dj = B j, which is the last term of the right hand side in the condition. Otherwise, B j,dj = B j,k which is the middle term of the right hand side in the condition. For an up fragment, the following condition in a while loop is tested: N < B j,k B j,. Thus, if k = d i + (t ) (i.e., x i+ is the rightmost child of x i ), then B j,dj = B j, which is the last term of the right hand side in the condition. Otherwise, B j,dj = B j,k+ which can (6) (7) 5

6 International Conference on Mechanical, Production and Materials Engineering (ICMPME') June 6-7,, Bangkok be obtained from B j,k (i.e., the first term of the right hand side in the condition) by using Eq. (6). We now show how to access elements of the accumulation table in the statement marked with a rightward triangle. Clearly, there are three terms B j,di+(t ), B j,k and B j, in the statement. From above, we know that the term B j, has been acquired since j > i. Moreover, the term B j,k in the initial stage of the while loop (i.e, k = ) and each of succeeding stages can be obtained from Eq. (6) in a constant time. To access the term B j,di+(t ), it is easy to check Eq. (7) that if B i,di is known, then we can obtain B j,di+(t ) by taking j = i +. Since we have already shown that the element B i,di (i.e., B j,dj in the previous round) has been preserved in advance, the term B j,di+(t ) can be obtained in a constant time. Next, we show how to access elements of the accumulation table in the statement marked with a leftward triangle. Clearly, there are two terms B j,k and B j, in the statement, where k = d i + (t ) initially. Thus, a similar argument as the previous case shows that the two terms can be obtained in a constant time in the initial stage of the while loop. For all succeeding stages of the while loop, the term B j,k can be obtained from B j,k+ by using the transposition of Eq. (6), and thus it needs only a constant time. Accordingly, the unranking algorithm can be run in O(n(n+ t)) time. Again, since building the preprocessing table requires O(tn) time and space, we have the following theorem. Theorem : Given a positive integer N, determining the RD-sequence d, d,..., d n of a t-ary tree whose rank in a Gray-code order is N can be done in O(max{n, tn}) time and O(tn) space. IV. CONCLUSION In this paper, we present an unranking algorithms of t-ary trees with n internal nodes encoded by RD-sequences in a Gray-code order. The algorithm can be run in O(max{n, tn}) time and O(tn) space, respectively. As we have mentioned earlier, Roelants van Baronaigien [] and Xiang et al. [9] independently introduced a loopless Gray-code generation of t-ary trees encoded by z-sequences. Based on such a Graycode order, Ahmadi-Adl et al. [] recently proposed ranking and unranking algorithms that each can be run in O(tn ) time. Although it has been pointed out in [7] that there are at least n different ways to generate Gray-codes of t-ary trees with n internal nodes, we found that z-sequences generated in [], [9] and RD-sequences generated in [7] indeed realize the complementary relationship (as stated in Theorem ) for each generation. As a result, with a slight modification, our algorithm could make an improvement for unranking t-ary trees encoded by z-sequences in a Gray-code order. As a future work, an interesting and challenging problem is how to extend our proposed unranking algorithm for dealing with non-regular trees encoded by RD-sequences in a Graycode order. To the best of our knowledge, so far no such algorithms exists. REFERENCES [] H. Ahrabian and A. Nowzari-Dalini, Generation of t-ary trees with ballotsequences, International Journal of Computer Mathematics 8 () 9. [] A. Ahmadi-Adl, A. Nowzari-Dalini, and H. Ahrabian, Ranking and unranking algorithms for loopless generation of t-ary trees, Logic Journal of IGPL, 9 (). [] M.C. Er, A note on generating well-formed parenthesis strings lexicographically, The Computer Journal 6 (98) 5 7. [] M.C. Er, Lexicographic listing and ranking t-ary trees, The Computer Journal (987) [5] J.F. Korsh. Loopless generation of k-ary tree sequences, Information Processing Letters 5 (99) 7. [6] J.F. Korsh and P. LaFollette, Loopless generation of Gray codes for k-ary trees, Information Processing Letters 7 (999) 7. [7] J.F. Korsh and P. LaFollette, A loopless Gray code for rooted trees, ACM Transactions on Algorithms (6) 5 5. [8] J.F. Korsh and S. Lipschutz, Shift and loopless generation of k-ary trees, Information Processing Letters 65 (998) 5. [9] A. Proskurowski and F. Ruskey, Binary tree Gray codes, Journal of Algorithms 6 (985) 5 8. [] D. Roelants van Baronaigien, A loopless Gray-code algorithm for listing k-ary trees, Journal of Algorithms 5 () 7. [] D. Roelants van Baronaigien and F. Ruskey, Generating t-ary trees in A-order, Information Processing Letters 7 (988) 5. [] F. Ruskey, Generating t-ary trees lexicographically, SIAM Journal on Computing 7 (978) 9. [] C.D. Savage, A survey of combinatorial Gray codes, SIAM Review 9 (997) [] A.E. Trojanowaki, Ranking and listing algorithms for k-ary trees, SIAM Journal on Computing 7 (978) [5] V. Vajnovszki, Generating a Gray code for P-sequences, Journal of Mathematical Modelling and Algorithms (). [6] R.-Y. Wu, J.-M. Chang, and C.-H. Chang, Ranking and unranking of non-regular trees with a prescribed branching sequence, Mathematical and Computer Modelling 5 () 5. [7] R.-Y. Wu, J.-M. Chang, and Y.-L. Wang, Loopless Generation of nonregular trees with a prescribed branching sequence, The Computer Journal 5 () [8] R.-Y. Wu, J.-M. Chang, and Y.-L. Wang, Ranking and unranking of t- ary trees using RD-sequences, IEICE Transactions on Information and Systems, E9-D () 6. [9] L. Xiang, K. Ushijima, and C. Tang, Efficient loopless generation of Gray codes for k-ary trees, Information Processing Letters 76 () [] S. Zaks, Lexicographic generation of ordered trees, Theoretical Computer Science (98) 6 8. [] S. Zaks, Generation and ranking of k-ary trees, Information Processing Letters (98) 8. 5