Two Dimension Measures: A New Algorithimic Method for Solving NP-Hard Problems Yang Liu

Outlines Why Exact Algorithms Why Fpt-algorithms Algorithmic techniques: branching search tree and two dimension braching search tree Previous works Future research

Why NP-Hard Problems Abundant aplications Methods of tackling NP-hard problems: 1. Exact algorithms. 2. parameterized algorithms 3. Approximation algorithms 4. Heuristics

Why Exact Algorithms Optimal Correct and meaningful for decision problems Subroutine for other methods Limitation of the improvements of processors

Practical Examples (1) The Rectlinear Steiner Tree problem Inputs of size up to 1000 Solved in 38 CPU hours.

Practical Examples (2) The TSP problem ( German15,112 towns In cpu years Sweden24,978 Towns In ,5000 km Circuit33,810In ,048,945 units, 15.7 cpu years Circuit85,900In cpu years

Outlines Why Exact Algorithms Why Fpt-algorithms Algorithmic technique: branching search tree and two dimensional braching search tree Previous works Proposed future research

Why FPT-algorithms Still hard to design practical exact algorithms in general An application may have a parameter k, small compared with input size n. This parameter can give a better bound on time complexity, like O(f(k)n c ).

Practical Fpt-algorithms (1) Type check: checking the compatibility of type declarations. Parameter k: the maximum nesting depth of the type declarations. Normally K<=6 Practical fpt-algorithm of time O(2 k n)

Practical Fpt-algorithms (2) Individual halotyping problem Paramters k 1 and k 2 K 1 <=n, but normally k 1 <=10 Usually k 2 <=19 Practical fpt-algorithm of complexity O(nk 2 2 k2 +mlogm+mk 1 )

Outlines Why Exact Algorithms Why Fpt-algorithms Algorithmic techniques: branching search tree and two dimension braching search tree Previous works Proposed future research

Algorithmic Techniques Kernelization, greedy localization, iterative compression, coloring coding, divide cand conquer, divide and coloring, branching search tree Dynamic programming, prunning the search tree, preprocess the data, local search, measure and conquer

Branching Search Tree m m2m2 m1m1 mpmp m’ m: measure f(m): number of subproblems (poly-time solvable)

Time Complexity of Branching Search Tree Complexity: O(c m poly(n))=O*(c m ). O*(c n ) refers to O(c n poly(n)).

Example: Exact Algorithm Finding Minimum Vertex Cover C Pick an edge xy, let measure m=#vertices m=n m 1 =n-1 m p =n-2 x in C x not in C y in C

Example: fpt-Algorithm Finding a vertex cover C of k vertices. Pick an edge xy, let measure m=#vertices needs to be in C m m 1 =m-1 m p =m-1 x in C x not in C y in C

Weakness of Branching Search Tree Only takes one measure Finding a feedback vertex set fvs of k vertices Choose a cycle and one vertex must be in fvs.

Two Dimensional Braching Search Tree Challenges: Finding two measures p,q how to bound f(p,q) Boundary conditions: new combinatorial properties Acheivements:  faster algorithms for some problems.

Outlines Why Exact Algorithms Why Fpt-algorithms Algorithmic technique: branching search tree and two dimensional braching search tree Previous works Proposed future research

3D Matching & 3-Set Packing a1a1 a2a2 anan b1b1 b2b2 bnbn c1c1 c2c2 cncn Symbols: a i, b i, c i a3a3 b3b3 c3c triples Set U of symbols, triple t= t1= and t2= conflicts if a i =b i for some i A matching: set of mutually non- conflicting triples. The maximum matching problem In the Karp’s list of NP-complete problems Generalization of graph matching

3D Matching & Packing Finding a matching of k triples ReferenceRandomDeterm Downey et al.O*((3k)!(3k) 9k+1 ) Chen et al.O*((5.7k) k ) KoutisO*( k )>O*( k ) Fellows et al.>O*(126 3k ) KneisO*(2.52 3k )O*(16 3k ) Chen et al.O*(2.52 3k )O*(12.8 3k ) Our resultO*(2.32 3k )O*(2.77 3k )

3D Matching & Packing For the k-packing problem, most algorithms in the table above apply. Our algorithm has complexity O*(4.61 3k ) Remark: Koutis gave a randomized algorithm of time O*(2 3k ) for both k- matching and k-packing problems

Multiway Cut

terminals

Multiway Cut terminals separator

Multiway Cut Applications: distributed computing, VLSI, computer vision and more Finding a separator of k vertices An algorithm of time O*(4 k ) the previous best algorithm of time

Feedback Vertex Set (undirected graphs)

Feedback vertex set Remaining graph is a forest

Finding an FVS of k vertices (undirected graphs) ReferenceComplexity Bodlaender, FellowsO*(17(k4)!) Dowey and FellowsO*((2k+1) k ) Raman et al.O*(max{12 k,(4logk) k }) Kanj et al.O*((2logk+2loglogk+18) k ) Raman et al.O*((12logk/loglogk+6) k ) Guo et al.O*(37.7 k ) Dehne et al.O*(10.6 k ) Our resultsO*(5 k )

Feedback Vertex Set (directed graphs)

Feedback vertex set Remaining graph is a DAG

Finding an FVS of k vertices (directed graphs) Question: fpt or not? Had been an open problem for over 15 years We developed an algorithm of time O*(4 k k!) with our new approach

Finding an FVS of k vertices (undirected graphs) ReferenceComplexity Bodlaender, FellowsO*(17(k4)!) Dowey and FellowsO*((2k+1) k ) Raman et al.O*(max{12 k,(4logk) k }) Kanj et al.O*((2logk+2loglogk+18) k ) Raman et al.O*((12logk/loglogk+6) k ) Guo et al.O*(37.7 k ) Dehne et al.O*(10.6 k ) Our resultsO*(5 k )

Finding an FVS of k vertices (directed graphs) Question: fpt or not? Had been open for over 15 years We developed an algorithm of time O*(4 k k!) Accepted by STOC 2008, JACM

Max Leaf (undirected graphs) Finding a Spanning tree With at least k leaves Equivalent to the minimum connected dominating set problem Applications: design of communication networks, circuit layouts, and distributed systems.

Finding a spanning tree with k leaves ReferenceComplexity BodlaenderO*((17k 4 )!) Downey and FellowsO*((2k) 4k ) Fellows et al.O*(14.23 k ) Bonsma et al.O*(9.49 k ) Bonsma and ZickfeldO*(6.75 k ) Our resultO*(4 k )

Out-branching Out-branching: a rooted tree such that there is a unique path from the root to a leaf.

Finding an out-branching with k leaves More difficult Graph minor theory on digraphs is not mature enough to solve this problem Properties are harder to prove for digraphs than for undirected graphs Shown to be fpt only recently

Finding an out-branching with k leaves for SCC and DAG for SCC and for DAG for digraphs Our results: O*(4 k ) Remark: Kenis et al. developed similar algorithm.

Max Leaf Finding a spanning tree of maximum leaves Equal to minimum connected dominating set Applications: design of communication networks, circuit layouts, and distributed systems.

Max Leaf on Digraphs Out-branching: a rooted tree such that there is a unique path from the root to a leaf. Max Leaf: finding an out-branching with maximum leaves Approximable within

Finding an out-branching with k leaves More difficult Graph minor theory on digraphs is not mature enough to solve this problem Some property is harder to prove for digraphs than for undirected graphs Shown to be fpt 15 years later

Finding an out-branching with k leaves for SCC and DAG for SCC and for DAG for digraphs Our results: O*(4 k )

Outlines Why Exact Algorithms Why Fpt-algorithms Algorithmic technique: branching search tree and two dimensional braching search tree Previous works Proposed future research

Multiway Cut Can we improve the algorithm of O*(4 k )? Is there any faster or simpler randomized algorithm? Is there any algebraic algorithms for this problem? Is the multi-cut problem fpt?

Feedback Vertex Set Can we improve the current best algorithms? Is there randomized algorithm better than O*(4 k )? Is there a deterministic algorithm of O*(4 k ) for the problem on undirected graphs? Is there O*(c k ) for the problem on digraphs? Is there any algebraic algorithm?

Max Leaf Is there any better algorithm? Is there any better algorithm for the problem on undirected graphs? Is there any faster or simple randomized algorithm? Is there any algebraic algorithm?

Two Dimension Measures: Further Study Algorithms by this technique has complexity around O*(4 k ) Can we do better? How? Can we apply this or similar technique to design exact algorithms?

Conclusion Two dimension measures branching search tree is powerful in design fpt- algorithms. Need improvement on this technique to design algorithms faster than O*(4 k ). Generalize this technique to design exact algorithms.

Questions? Thank You!