Speeding Up Enumeration Algorithms with Amortized Analysis

1. Speeding Up Enumeration Algorithms with Amortized Analysis Takeaki Uno (National Institute of Informatics, JAPAN)

2. Motivation & Goal • There have been proposed huge number of (output) polynomial time listing, enumeration, and generation algorithms <= Good construction schemes: Back tracking, Gray code, Binary partition, and Reverse search • But, there are relatively few studies on Speeding up those algorithms (reducing complexities)

3. Motivation & Goal (2) • Recently, enumeration algorithms are used 　　 in practical problems: data mining, bioinformatics, computational linguistics  Practical & theoretical fast algorithms are required • However, reducing time complexity ( per output ) is not easy

4. Motivation & Goal (3) • Reducing # of iterations 　 usually, hard ( or impossible if O(#output) ) • Reducing time complexity of iterations 　usually, difficult ( O(n5)  O(n4) is possible, but O(n)  O(log n), O(1) is hard ) 　Scheme using amortized analysis is required we propose a scheme with amortized analysis

5. Observation & Idea # small time long • Almost enumeration algorithms are based on recursive calls ( enumeration tree ) • Iterations on lower levels take less computation time • Lower levels have much iterations # large time short Move computation time from upper levels to lower levels ( computation time will be amortized )

6. How to Move? • The shape of enumeration tree depends on problems ( not like merge sort ) • Difficult to decide (1) to which iteration, and (2) how much amount …? Our rule is adaptive, (1) holds and receives (2)from parent to children, recursively (3) proportional to the computation time of children top-down

7. Bound by Amortized Analysis O(iter) : amortized computation time per iteration T(x) : computation time of iteration x T : maximum T(x) of bottom level iterations α >1 : a constant ^ Condition (1) If αT(x) - α ≤∑ T(y) 　　 for any x y is a child of x O(iter) = O ( T ) ^

8. Condition (1) does not hold If several x do not hold Condition (1): αT(x) - α≤ ∑ T(y) Some iterations receive 　　　much computation time from parents x If 　　x receives > αT(x) move computation time to all descendants of x

9. Bound by Amortized Analysis (2) T(x) Condition (2') If (# descendants of x )=Ω(T(x) ) (orT(x) - α≤∑ T(y) for any x ) y is a child of x # T(x) Condition (2) If αT(y) + α ≥ T(x) for any x and its child y, O(iter) = O ( T ×log( T(root)) ) ^

10. Undesired Occasion (case 1) a leaf iteration takes much computation time Tincreases (case 2) a parent takes much computation time than all the children Condition (1) (2')will be violated (case 3) a child takes fewcomputation time than other children Condition (2)will be violated ^

11. Procedure to Avoid In each iteration, we do Trimming: remove unnecessary parts of input of each iteration  for avoiding ( case 1 & 2 ) Balancing: take balance of computation time of children  for avoiding ( case 3 )

12. Results ( previous best  new ) Matchings Algorithm satisfying Condition (1) O(|V|)  O( 1 ) Matroid Bases Algorithm satisfying Condition (1)　　　　　 m :#elements O(mn)  O(1) ( oracle calls ) n :rank Directed spanning trees Trimming & balancing satisfying Condition (2') & (2) O( |V|1/2 )  O( log2|V| ) Bipartite Perfect matchings Trimming & balancing satisfying Condition (2') & (2) O( |V| )  O( log|V| )

13. Matchings E(v) v Input: Graph G = ( V, E ) Output: All matchings of G •Simple binary partition ( divide and conquer ) (1) Choose a max degree vertexv (2) For each e of E(v),Recursive call of G+(e) E(v): 　 Edges incident to v G+(e): Removal of e and edges adjacent to e Satisfies Condition (1) At bottom level, T(x) = O(1)  T = O(1) G+(e) e ^  O(1) per matching ( = per iteration )

14. Matroid Bases e1 Input: Matroid M = ( E, I ) Output: All bases of M (1) 　 Choose e1of E (2-a) If { e1, ei}are circuits for e2,…, ek Recursive calls of each M / ei and M＼{e1,…, ek} (2-b) If { e1, ei}are cuts for e2,…, ek Recursive calls of M / {e1,…, ek}and each M＼ei (2-c) Otherwise Recursive calls of M / e1and M＼e1 Satisfies Condition (1) At bottom level, T(x) = O(1) oracle calls e1,…, ek e3 e4 e2 e1  O(1) oracle calls per base ( = per iteration )

15. Directed Spanning Trees r Input: Directed Graph G = ( V, A ), a vertex r Output: All directed spanning trees of G rooted at r • Binary partition with Trimming and Balancing (1) Choose a vertexv (2) Partition E+(v) into E1and E2 (3)Recursive calls inputting G＼E1and G＼E2 E+(v): Out-going Arcs of v E+(v) v

16. Directed Spanning Trees (2) Trimming: (1)Remove arcs included in no directed spanning tree (2)Contract arcs included in all directed spanning trees Balancing: Choose v satisfying Condition (2) Satisfies Condition (2), (2') At bottom level, T(x) = O(log |V|)( = T ) ^  O( log2|V| ) per tree ( = per iteration )

17. Bipartite Perfect Matchings Input: Bipartite Graph G = ( V, E ) Output: All perfect matchings of G • Binary partition with Trimming and Balancing (1) Choose a vertexv (2) Partition E(v) into E1and E2 (3)Recursive calls inputting G＼E1and G＼E2 E(v) v

18. Bipartite Perfect Matchings (2) Trimming: Remove edges (a) included in no perfect matching (b) included in all perfect matchings (c) adjacent to edges of (b) Contract consecutive degree 2 vertices Balancing: Choose v satisfying Condition (2) Satisfies Condition (2), (2') At bottom level, T(x) = O(1) (= T ) ^  O( log |V| ) per perfect matching ( = per iteration )

19. Conclusion • Proposed a new amortized analysis • Proposed a new speeding up scheme ( trimming and balancing ) • Proposed fast enumeration algorithms for • mathings • matroid bases • directed spanning trees • bipartite perfect mathings

20. Future Works • Improve other algorithms • possible? undirected s-t paths minimal cuts of planer graphs directed paths of planer graphs • impossible? minimal cuts directed s-t paths stable sets