A Fast Enumerating Algorithm for Edge Colorings in Bipartite Graphs

A Fast Enumerating Algorithm for Edge Colorings in Bipartite Graphs Yasuko MATSUI

∗

Takeaki UNO

†

Abstract : For a bipartite graph G = (V, E), an edge coloring of G is a way of coloring edges such that no vertex of G is incident to more than two edges of the same color. In this paper, we consider the problem of enumerating all edge colorings with the fewest number of colors, and propose a simple algorithm for the problem. By analyzing its complexities carefully, we prove that the algorithm runs in O(|V |N ) time where N is the number of minimum edge colorings in G. We also show its space complexity is O(|E| + |V |). Keywords : enumerating algorithm, listing, edge coloring

1

Introduction

Let G = (V (= V1 ∪V2 ), E) be a bipartite graph with vertex set V and edge set E composed of edges in V1 × V2 . Parallel edges are allowed in G. We denote the vertex set of G by V (G) and the edge set of G by E(G). We denote the numbers of vertices and edges of G by n and m. We also denote the maximum degree of the graph G by ∆(G) and the set of maximum degree vertices by Vˆ (G). For the graph G, we simply write its maximum degree by ∆. An edge coloring of G is a way of coloring all edges in G such that no pair of edges with the same color share their endpoints. We denote an edge coloring C by {M1 , M2 , ..., Mk } where Mi is the set of edges with the same color. All edges incident to a vertex have distinct colors, hence each Mi forms a matching. An edge coloring with the minimum number of colors is called a minimum edge coloring. In 1916, K¨onig [4] proved that a minimum edge coloring of a bipartite graph uses exactly ∆ colors. Here we deal with only those minimum edge colorings, and simply call them edge colorings. The current best time complexity algorithm for finding a minimum edge coloring is proposed by Cole and Hopcroft [1]. Their algorithm runs in O(m log n + n(log n)(log3 ∆)) time. The enumeration problem of edge colorings has been studied. Two edge colorings C1 and C2 are considered as same edge colorings if C1 = C2 = {M1 , M2, ..., Mk }, hence the problem is equivalent to enumeration of partitions of G by ∆ matchings. Several algorithms for the problem have been proposed by Y. Matsui and T. Matsui [6, 7]. Their current best one runs in O(m log n + n(log n)(log3 ∆) + min{n2 + m, m log n + ∗

Department of Mathematical Sciences, Faculty of Science, Tokai University, 1117, Kitakaname, Hiratsuka-shi, Kanagawa, Japan [email protected] † National Institute or Informatics, 2-1-2 Hitotsubashi, Chiyoda-ku, Tokyo, 101-8430, JAPAN. e-mail: [email protected]

1

n(log n)(log3 ∆)}N ) time and O(m∆) space [7], where N denotes the number of edge colorings in a given graph. Recently, many enumeration algorithms are improved by using techniques based on amortized analysis, compact output and etc. [2, 5, 3, 9, 10]. The improvements in [2, 5, 3, 9, 10] produced considerably fast algorithms such as running in O(1) time per output. Comparing those algorithms, the algorithms of Y. Matsui and T. Matsui are quite slow. Probably, there is possibility of improving the algorithms by using the techniques. In this paper, we propose a fast algorithm for enumerating edge colorings in a given graph. The algorithm is obtained by using the above techniques, amortized analysis and compact output. Even though our algorithm is quite simple, the time complexity O(nN) is considerably smaller than their algorithms. Our algorithm also attains a smaller memory complexity O(m + n) than O(nm) of theirs. In the following sections, we will describe our algorithm. In section 2, we describe the framework of our algorithm, and analyze its complexities in Section 3. In Section 4, we propose a way to reduce the memory complexity.

2

Framework of Enumeration Algorithm

In this section, we describe the framework of our algorithm. According to K¨onig’s theorem, an edge coloring with ∆ colors exists for any bipartite graph. Hence, in an edge coloring, each maximum degree vertex of G is incident to all ∆ colored edges. Conversely, for any matching that composes the edge coloring, any maximum degree vertex is incident to an edge of the matching. We call a matching covering all vertices of Vˆ covering matching of G. Any matching that composes a minimum edge coloring is a covering matching. Let F (G) be the set of edge colorings of G, M(G) be the set of covering matchings of G, and G \ M be the subgraph obtained by removing edges of M from G. We define F (G)/M = {C|C ∈ F (G), M ∈ C}. From K¨onig’s theorem we can see the following properties [7]. Property 1 For any M ∈ M(G), F (G)/M = {C ∪ {M}|C ∈ F (G \ M)}.
Property 2 For any e ∈ E incident to a vertex in Vˆ , displaystyleF (G) = M,e∈M,M ∈M(G) F (G)/M.

Property 3 For any M, M  ∈ M(G), there holds M ∩ M  = ∅ iff F (G)/M ∩ F (G)/M  = ∅. These properties lead the following enumeration way. (1) select an edge e incident to a maximum degree vertex (2) generate all covering matchings including e (3) for each generated covering matching M, enumerate edge colorings of G \ M. To enumerate covering matchings, an algorithm is proposed in [7]. Here we explain their enumeration method modified slightly in our way. For an edge e, let G \ e = (V, E \ {e}), and G+ (e) be the subgraph of G obtained by removing e and all edges adjacent to e. For a subgraph G of G, we define M(G ) by the set of covering matchings of G contained in G . These properties are shown in [7]. 2

Figure 1: The way of enumerating edge colorings. Emphasized lines are edges colored at the beginning of the enumeration.

Property 4 For any edge e, (1) {M|M ∈ M(G), e ∈ M} = {M ∪ {e}|M ∈ M(G+ (e))}, (2) {M|M ∈ M(G), e ∈ M}, = M(G \ e), (3) M(G) = {M ∪ {e}|M ∈ M(G+ (e))} ∪ M(G \ e), and (4) {M ∪ {e}|M ∈ M(G+ (e))} ∩ M(G \ e) = ∅. In this case, we have to notice that M(G+ (e)), M(G \ e) = ∅ does not always hold for any e. To avoid generating empty problem, we use the following approach. (1) find a covering matching M and a covering matching M  = M (3) e := an edge in M \ M  (4) enumerate covering matchings of G+ (e), and covering matchings of G \ e In this way, both generated graphs include at least one covering matching, M or  M . A covering matching M of a graph can be found in O(n) time if ∆ = 2 since G is composed of paths and cycles in this case. If ∆ > 2, it takes O(|Vˆ (G)|m + n) time [1]. Since there is a covering matching all whose edges are incident to maximum degree vertices (minimal covering matching), this can be reduced to O(|Vˆ (G)|2 ∆(G) + n). To find a covering matching M  = M, we introduce the followings. For a cycle C of G, if any two edges in C \ M are not adjacent, then we call C an alternating cycle. Similarly, for a path P of G, if any two edges in P \ M are not adjacent and the end edges of P are adjacent to no edge of M, then we call C an alternating path. In any alternating cycle and alternating path, edges of M and edges not in M appear alternatively. Let A(G, M) be the set of alternating cycles and alternating paths both whose endpoints are not in Vˆ (G). These are used to find another covering matching with the following lemma proved in [7]. Here MM  denotes the symmetric difference between M and M  . Lemma 1 (1) For any cycle and path (V , E  ) ∈ A(G, M), ME  is a covering matching of G. (2) There exists a covering matching M  = M if and only if A(G, M) = ∅. 3

s1 e^

V1 V2 s2 ˆ Figure 2: D(G, M) and an alternating path.

From this lemma, we can see that we need only way for finding an element of A(G, M). Let V¯ be the set of covered vertices in V1 \ Vˆ and uncovered vertices in V2 \ Vˆ . We define ˆ D(G, M) by a non-bipartite directed graph obtained from G as follows: (1) orient edges of M from V1 to V2 , and edges of E \ M from V2 to V1 (2) add a vertex s to V. (4) make arcs from s to non-isolated vertices of V¯ (5) make arcs from non-isolated vertices of V \ (Vˆ ∪ V¯ ) to s ˆ For any C ∈ A(G, M), C corresponds to a directed cycle of D(G, M) not including s if C is a cycle. If C is a path, the directed path corresponding to C is included in a ˆ ˆ M), directed cycle of D(G, M) including s. Conversely, for any directed cycle C  of D(G,    if C does not include s, then C corresponds to a cycle of A(G, M). If C includes s, then the directed path obtained by removing s and arcs incident to s from C  corresponds to ˆ an alternating path in A(G, M). Hence, by finding a directed cycle of D(G, M), we can obtain another covering matching in O(m + n) time and O(m + n) space. The algorithm of Y. Matsui and T. Matsui takes much time from the following reasons: (1) computation time for finding a covering matching is much for the number of edge colorings, hence amortized time complexity is not reduced. (2) In several iterations, the algorithm generates only one recursive call, hence the number of iterations is not proportional to the number of output. We modify the algorithm to avoid these. Here we describe our enumeration algorithm in the following. ALGORITHM: Enum Edge Coloring(G) Step 1: If (all edges are incident to an edge) or (M is a matching) then Output “edge coloring by adding ” and the unique edge coloring of G. Step 2: e := edge incident to a vertex in Vˆ such that an edge is not adjacent to e Step 3: M := a covering matching of G Step 4: If e ∈ M then find (V , E  ) ∈ A(G, M) including e ; M := MC Step 5: Call Enum Covering Matching (G+ (e), Vˆ (G), M) ALGORITHM: Enum Covering Matching(G, Vˆ (G), M) ˆ Step 1: If no directed cycle is in D(G, M) then 4

Step Step Step Step Step Step Step

2: Output “add” and edges of M 3: Call Enum Edge Coloring (G \ M) 4: Output “Delete” and edges of M 5: Else find (V , E  ) ∈ A(G, M) ; M  := ME  ; e := an edge in M \ M  6: Call Enum Covering Matching (G+ (e), Vˆ (G), M) 7: Call Enum Covering Matching (G \ e, Vˆ (G), M  ) 8: End If

In algorithm Enum Edge Coloring, Step 1 outputs an edge coloring if G includes only one edge coloring. Step 2 select an edge incident to a maximum degree vertex, and steps 3 and 4 find a covering matching including e. As we will see in the next section, the selecting rule in Step 2 decreases the number of iterations. To enumerate all covering matchings including e, Step 5 generates a subroutine call respect to G+ (e). In algorithm Enum Covering Matching, Step 3 generates a recursive call to enumerate edge colorings of G \ M if input graph includes only one covering matching. Otherwise, Steps 6 and 7 generate recursive calls enumerating covering matchings of G included in G+ (e) and G \ e, respectively. Step 2 and 4 output M before a recursive call and cancel the output after it, since M is included in all edge colorings output during the recursive call. By this, as we can see, output edge between two output edge colorings compose the symmetric difference between these edge colorings. This technique is called compact output method. This technique reduces computation time for outputting to n times the number of iterations. In the next section, we analyze the time complexity in detail, and prove that the algorithm terminates in O(nN) time.

3

Analysis of Time Complexity

In this section, we first bound the time complexity of an iteration, and the number of the iterations. We next bound the amortized time complexity of our algorithm. Let an iteration of our algorithm be an iteration of Enum Edge Coloring and all the iterations of Enum Covering Matchings to enumerate covering matchings for generating recursive calls of Enum Edge Coloring. Let us introduce the following rooted tree T = (V, E) called enumeration tree, which captures the movement of the algorithm. The root vertex of T is the start of the algorithm, which is the first iteration of Enum Edge Coloring. Two vertices of V are connected if and only if one of the vertices is called from the other. If an iteration generates no subroutine call, then the iteration outputs an edge coloring. Hence each leaf of T corresponds to an edge coloring (see Figure 1). For a vertex x of V, let Gx = (V, Ex ) denote the input graph of x, and ex denote the edge selected in Step 2. We denote the set of children of x by C(x), and computation time on x by T (x). There holds |C(x)| = |M(Gx )|. We next bound the number of iterations by proving the following lemma. Lemma 2 Assume that ∆ ≥ 3. Then for an edge e incident to a vertex of Vˆ , there exists only one covering matching of G including e if and only if all edges of G share at least one of their endpoints with e.

5

Proof : The ‘if’ part is obvious, thus we prove the ‘only if’ part by its contraposition. Let M be a covering matching containing e. From the assumption, the degree of any v ∈ Vˆ (G) is at least 2 in G+ (e) except for the endpoints of e. If an edge is not adjacent to e, G+ (e) contains at least one edge. We recall that G contains another covering matching including e if and only if A(G+ (e), M) = ∅. Let Ve be the set of endpoints of e, and v be a vertex V \ (Vˆ (G)∪Ve ). If G+ (e) includes ˆ + (e), M) no such vertex, let v be a vertex of Vˆ (G+ (e)). Apply depth-first search to D(G with starting from v. As vertices of Vˆ (G) \ Ve are incident to at least two edges of G+ (e), depth-first search does not terminate until it reaches to a vertex of V \ Vˆ (G) or a vertex which has already been visited. In each case, we obtain a path or cycle in A(G, M). Therefore G includes another covering matching including e. By this lemma, any edge selected in an iteration of Enum Edge Coloring is included in at least two covering matchings. Hence, if G includes at least two edge colorings, then the subroutine Enum Covering Matching generates at least two recursive calls. Therefore we can see that the number of iterations generated to enumerate edge colorings is at most 2N. Next, to bound the amortized computation time of the algorithm, we show the following lemma. Lemma 3 Any graph G with ∆ = 3 has at least |Vˆ (G)|/6 edge colorings. Proof : To prove the lemma, we first estimate the lower bound of the number of directed ˆ cycles in D(G, M). Let n be the number of non-isolated vertices in G. Since m is at least  ˆ M) has at least |Vˆ (G)| + n/2 + n − (3|Vˆ (G)| + (n − |Vˆ (G)|))/2 = |Vˆ (G)| + n /2, D(G, |Vˆ (G)| = 3n /2 arcs. An edge coloring of G includes two covering matchings having empty intersection, hence any edge of G is included in a covering matching and not included in a covering matching. This leads any edge of G to be included in a path or cycle of A(G, M). ˆ Therefore, any arc of D(G, M) is included in a directed cycle. ˆ M) with at Let Di = (Vi , Ei ), i = 1, ..., k be the strong connected components of D(G, ˆ least one arc. Note that any arc of D(G, M) is included in exactly one Di . For a Di , we set a directed graph C = (VC , EC ) to a directed cycle of Di . Now, the number of directed cycles in C is |EC |−|VC |+1. If Ei \EC = ∅, then the graph (Vi , Ei \EC ) contains a directed path P = (VP , EP ) whose endpoints are both included in C and whose internal vertices and edges are not in C since Di is strongly connected. P satisfies |EP \EC |−|VP \VC | = 1. By adding P to C, at least one directed cycle including P is generated since C is strongly connected. This addition does not make C non-strongly connected. |EC | − |VC | + 1 increases only one by this addition. Hence when EC = Ei holds, we have that the number ˆ M) includes at least of directed cycles in Di is at least |Ei | − |Vi | + 1. Therefore D(G, k    (|E | − |V | + 1) ≥ 3n /2 − n = n /2 directed cycles. i i i=1 Since any covering matching is included in an edge coloring of G and any edge coloring of G includes exactly 3 covering matchings, G includes at least n /6 ≥ |Vˆ (G)|/6 edge colorings. Using these, we obtain the following theorem. Theorem 1 The algorithm Enum Edge Coloring enumerates all edge colorings of G in O(m + nN) time and O(∆(m + n)) space. 6

e

Figure 3: A cycle generated by non-back arc e in H.

Proof : We first see the memory complexity. In each level of the recursive calls, the algorithm spends O(m + n) memory space for enumerating covering matchings. They are stored when a new covering matching is found and a recursive call occurs. Hence the memory complexity is bounded by O(∆(m + n)) since the depth of the enumeration tree is at most ∆. Next we bound the time complexity by an amortized analysis. Suppose that T (x) = O(n + |C(x)|n) if ∆(Gx ) < 3. Hence, we have 

T (x) = O(nN).

x∈calV ,∆(Gx ) 3 then k := k − 1 ; go to Step 2 After this process, we have 

T (x) =

x∈calV ,∆(Gx )≥3



Tx .

x∈calV ,∆(Gx )=3

We bound the computation time for these iterations by distributing computation time in the following way. The distribution is done in a top-down manner. Suppose the computation time on x is T (x) = C(|Vˆ (Gx )|2∆(Gx ) + |Ex | + 2n + |C(x)|(|Ex| + n)). At the first step, we distribute T (x) of the root vertex to all its children uniformly if ∆(Gx ) > 3, and to all its descendants if ∆(Gx ) = 3. In the kth step, for each vertex x such that the path from x to the root includes exactly k vertices, let Tp (x) be the computation time distributed from the parent of x to x in the (k − 1)th step. Then, we distribute T (x) + Tp(x) uniformly to all children of x. If C(x) =, we do not distribute. 7

For any child y of x, Ey = Ex \ M for a M ∈ M(G), |Ex | ≤ |Ey | + n and |Vˆ (Gx )| ≤ |Vˆ (Gy )|. Hence, if ∆(Gx ) > 3, T (x) = C(|Vˆ (Gx )|2 ∆(Gx ) + |Ex| + 2n + |C(x)|(|Ex| + n)) ≤ |C(x)| × C(|Vˆ (Gy )|2 (∆(Gy ) + 1) + (|Ey | + n + 2n) + (|Ey | + 2n)) 3 ≤ |C(x)| T (y). 2 Since |C(x)| ≤ 2 if C(x) = ∅, the child y of the root satisfies Tp(y) ≤ 34 T (y). Hence, by induction, we can see Tp (y) ≤ 3T (y)/2 for any vertex y with ∆(Gy ) ≥ 3. From the above, after the distribution, any vertex x of enumeration tree has O(n) computation time if ∆(Gx ) > 3, and O(|Vˆ (Gx )|2 + n + |C(x)|n) time otherwise. Note that if C(x) = ∅, then |Vˆ (Gx )| = 1 hence O(|Vˆ (Gx )|2 +n+|C(x)|n) = O(n). From Lemma 3, x with ∆(Gx ) = 3 has at least |Vˆ (Gx )| descendants. Thus, the sum of computation time over all iterations x with ∆(Gx ) = 3 is bounded by O(nN). In the next section, we modify the algorithm and reduce the memory complexity to O(m + n).

4

Technique for Reducing the Space Complexity

In this section, we show a technique for reducing the space complexity. In the previous section, we described an algorithm for finding all covering matchings which requires O(m+n) extra memory space in each level of the enumeration tree. This requires O(∆(m+n) memory. Moreover, since our enumeration algorithm is composed of two nested enumeration algorithms, for edge colorings and for covering matchings, the depth of the recursion may reach Θ(∆m). This also requires O(∆(m + n) memory. These are the memory-consuming parts. To reduce the memory complexity, we propose using an algorithm for covering matchings with no recursion. When a covering matching M is found, the algorithm stops the process and generates a recursive call with the graph obtained by removing M. After the recursive call terminates, the algorithm restarts the process. If the algorithm requires at most O(|M |) additional memory space to restart, the total memory complexity will be O(m + n). This is our idea. Suppose that each edge ei has an index i. By using indices, we transform our algorithm for enumerating covering matchings to an algorithm with no recursion. Let i be a counter. Let Ei be the set of edges whose indices are less than i. For a covering matching M of G, we define M(M, i) = {M  |M  ∈ M(G), M ∩ Ei = M  ∩ Ei }, A(G, M, i) = {P |P ∈ A(G, M), P ∩ Ei = ∅}, and ˆ E(G, i) = {e|e ∈ E \ Ei ,∃ P ∈ A(G, M, i), e ∈ P }. At the beginning of enumerating covering matching, we set the counter i to 0. Under this condition, M(M, i) = M(G), and A(G, M, i) = A(G, M). To generate subproblems, ˆ i). We can find ej in O(m + n) we use the edge ej with the minimum index among E(G, ˆ time by computing all the strongly connected components of D(G, M) after deleting arcs 8

8

3

2

9

5 7

1

10

6 4

8

9 7

10

4

Figure 4: Restoring the graph. Remove edges with indices 1, 2 and 3, and the edges incident to matching edges of them.

corresponding to edges of Ei . If M does not including ej , then we find P = (VP , EP ) ∈ A(G, M, i) and set M to MEP so that M includes ej . We put a mark to ej , and start enumerating all the covering matchings including ej , and all those not including ej . Instead of generating a recursive call, we set i to j + 1, and repeat the above process. Since ej has the minimum index, M(M, i) = M(G+ (e)) and A(G, M, i) = A(G+ (e), M). If A(G, M, i) = ∅, then |M(M, i)| = 1. To enumerate covering matchings to be enumerated by another recursive call, we set ei to the maximum index edge among marked edges, and i to j + 1. Then we find P = (VP , EP ) ∈ A(G, M, i) and set M to MEP so that M does not include ej . Before starting enumeration, we unmark ej not to restart with ej . We describe the details of our modified algorithm. ALGORITHM: Enum Edge Coloring2(G) Step 1: If (all edges are incident to an edge) or (M is a matching) then Output “edge coloring by adding ” and the unique edge coloring of G. Step 2: e := edge incident to a vertex in Vˆ such that an edge is not adjacent to e Step 3: M := a covering matching of G Step 4: i := 0 Step 5: If A(G, M, i) = ∅ then do Step 6: E := E \ M ; Output “add” and edges of M Step 7: Call Enum Edge Coloring2 (G \ M) Step 8: E := E ∪ M ; Output “Delete” and edges of M 9

Step Step Step Step Step Step Step Step

9: 10: 11: 12: 13: 14: 15: 16:

If no marked edge in E then return i := the maximum index among indices of marked edges ; unmark ei ; i := i+1 (VP , EP ) := an element of A(G, M, i) ; M := MEP ˆ Else ej := the minimum index edge among edges of E(G, i) If ej inM then (VP , EP ) := an element of A(G, M, i) ; M := MP Mark j ; i := j + 1 End if Go to Step 5

Theorem 2 The algorithm Enum Edge Coloring2 enumerates all edge colorings of G in O(nN) time and O(m + n) space. Proof : We can easily see that the time complexity of the algorithm does not increase by this modification. This algorithm requires memory space for G, M, i, and the marks of edges of M. In steps 6 through 8, we generate a recursive call of Enum Edge Coloring2 with G \ M. After terminating the recursive call, we restore all those variables, G, M, i, and the marks of edges of M. G can be restored by adding M to G \ M, which is the input of the recursive call. The others take at most O(|M |) memory space. Hence the total memory complexity required to enumerate all the edge colorings is O(m + n).

5

Conclusion

We propose an algorithm for enumerating all edge colorings in a bipartite graph G = (V, E) with n vertices and m edges. Careful analysis of our algorithm attains the time complexity O(nN) considerably smaller than that of existing algorithms O(m log n + n(log n)(log3 ∆) + min{n2 + m, m log n + n(log n)(log3 ∆)}N ) where ∆ denotes the maximum degree of G and N denotes the number of edge colorings in G. We also succeeded to reduce the memory complexity from O(m∆) to O(m + n) by avoiding deep recursion. The technique of amortized analysis in this paper is probably able to apply other enumeration algorithms, and further research reduces time complexity of other enumeration algorithms.

Acknowledgments We would like to thank Professor Akihisa Tamura of the University of Electro-Communications. We are also grateful to Professor Yoshiko T. Ikebe of the Science University of Tokyo for her advise.

References [1] R. Cole and J. Hopcroft, “On Edge Coloring Bipartite Graphs,” SIAM J. Comp. 11, pp.540-546 (1982). [2] D. Eppstein, “Finding the k Shortest Paths,” 35th Annual Symposium on Foundations of Computer Science, Santa Fe, New Mexico, 20-22 November, pp.154-165 (1994).

10

[3] H. N. Kapoor and H. Ramesh, “Algorithms for Generating All Spanning Trees of Undirected, Directed and Weighted Graphs,” Lec. Notes Comp. Sci. 519, SpringerVerlag, pp.461-472 (1992). ¨ [4] D. K¨onig, “Uber Graphen und ihre Anwendung auf Determinantentheorie und Mengenlhere,” Math. Ann. 77, pp.453-465 (1916). [5] A. Shioura, A. Tamura and T. Uno, “An Optimal Algorithm for Scanning All Spanning Trees of Undirected Graphs, ” SIAM J. Comp. 26, No. 3, pp.678-692 (1997). [6] Y. Yoshida, Matsui and T. Matsui, “Finding All the Edge Colorings in Bipartite Graphs,” T.IEE. Japan 114-C 4, pp.444-449 (1994) (in Japanese). [7] Y. Matsui and T. Matsui, “Enumeration Algorithm for the Edge Coloring Problem on Bipartite Graphs,” Lecture Notes in Computer Science 1120, Springer-Verlag, pp.18-26 (1996). [8] T. Uno, “Algorithms for Enumerating All Perfect, Maximum and Maximal Matchings in Bipartite Graphs,” Lecture Note in Computer Science 1350, Springer-Verlag, Algorithms and Computation, 92-101 (1997). [9] T. Uno, “A New Approach for Speeding Up Enumeration Algorithms,” Lecture Note in Computer Science 1533, Springer-Verlag, Algorithms and Computation, 287-296 (1998). [10] T. Uno, “A New Approach for Speeding Up Enumeration Algorithms and Its Application for Matroid Bases,” Lecture Note in Computer Science 1627, Springer-Verlag, Computing and Combinatorics, 349-359, (1999)

11