Fast Exponential-Time Algorithms to solve NP-complete ... - Lita

Fast Exponential-Time Algorithms/52Fast Exponential-Time Algorithmsto solve NP-complete problems exactlyDieter KratschLaboratoire d’Informatique Théorique et AppliquéeUniversité Paul Verlaine - Metz57000 Metz Cedex 01FranceCIRM workshop on graph decompositions - Marseille, FranceApril 7–11, 2008

2/52Fast Exponential-Time AlgorithmsIntroductionMotivationHow to attack NP-hard problemsVarious techniques have been developped to attack NP-hardproblems :approximation algorithmsparameterized algorithmsrandomized algorithmsrestricted inputsexponential-time algorithms

3/52Fast Exponential-Time AlgorithmsIntroductionMotivationExact Exponential-Time Algorithmsone of the oldest methodsdating back to the early sixtiesDavis, Putnam (1960) and Held, Karp (1962)tries to cope with NP-completeness in the strongest senseanalysis of worst-case running time

52Fast Exponential-Time AlgorithmsIntroductionMotivationHow good can exponential algorithms be ?For all inputs of size n, can we reach worst-case running timeO(n!)O(2 n2 )O(10 n )O(2 n )O(c n ) for some constant c ≥ 1 sufficiently close to 1or even a subexponential algorithm ? ?

52Fast Exponential-Time AlgorithmsIntroductionMotivationWhy Studying Exponential-Time Algorithms ?certain applications require exact solutions of NP-hardproblemsapproximation algorithms and fixed parameter algorithms arenot always satisfactoryreduction of the base of the exponential running time, sayfrom O(2 n ) to O(1.4 n ), increases the size of the instancessolvable within a given amount of time by a constantmultiplicative factorrunning a given exponential algorithm on a faster computercan enlarge the mentioned size only by an additive factorleads to a better understanding of NP-hard problemsinitiates interesting new combinatorial and algorithmicchallenges

6/52Fast Exponential-Time AlgorithmsIntroductionHistorySome Old AlgorithmsBefore 1990TSP O ∗ (2 n ) Held, Karp (1962)COLORING O(2.4422 n ) Lawler (1976)3-COLORING O(1.4422 n ) Lawler (1976)3-SAT O(1.6181 n ) Speckenmeyer,Monien (1985)INDEPEDENT SET O(1.2108 n ) Robson (1986)

7/52Fast Exponential-Time AlgorithmsIntroductionHistorySome New AlgorithmsLast DecadeBANDWIDTH O ∗ (10 n ) Feige, Kilian (2000)3-SAT O(1.4802 n ) Dantsin et al. (2002)MAXIMUM CUT O(1.7315 n ) Williams (ICALP 2004)TREEWIDTH O(1.9601 n ) Fomin et al. (ICALP 2004)3-COLORING O(1.3289 n ) Beigel, Eppstein (2005)DOMINATING SET O(1.5137 n ) Fomin et al. (ICALP 2005)COLORING O ∗ (2 n ) Björklund, Husfeldt (FOCS 2006)

8/52Fast Exponential-Time AlgorithmsIntroductionHistoryOutline1 Introduction2 Independence and Coloring3 Dynamic Programming4 Iterative Compression5 Inclusion Exclusion6 Branching7 Conclusions

9/52Fast Exponential-Time AlgorithmsIndependence and ColoringIndependent sets in graphsIndependent SetsDefinition (Independent Set)Let G = (V , E) be a graph. A subset I ⊆ V of vertices of G is anindependent set of G if no two vertices in I are adjacent.Definition (Maximum Independent Set (MIS))Given a graph G = (V , E), compute an maximum independent setof G.abdcfe

9/52Fast Exponential-Time AlgorithmsIndependence and ColoringIndependent sets in graphsIndependent SetsDefinition (Independent Set)Let G = (V , E) be a graph. A subset I ⊆ V of vertices of G is anindependent set of G if no two vertices in I are adjacent.Definition (Maximum Independent Set (MIS))Given a graph G = (V , E), compute an maximum independent setof G.abdcfe

10/52Fast Exponential-Time AlgorithmsIndependence and ColoringColoring a graphColoringDefinition (Coloring)A function c : V → {1, 2, ..., k} is a proper coloring of a graphG = (V , E) if uv ∈ E implies c(u) ≠ c(v)Definition (Minimum Coloring)Given a graph G = (V , E), compute a coloring of G with thesmallest number of colors.abdcfe

10/52Fast Exponential-Time AlgorithmsIndependence and ColoringColoring a graphColoringDefinition (Coloring)A function c : V → {1, 2, ..., k} is a proper coloring of a graphG = (V , E) if uv ∈ E implies c(u) ≠ c(v)Definition (Minimum Coloring)Given a graph G = (V , E), compute a coloring of G with thesmallest number of colors.abdcfe

11/52Fast Exponential-Time AlgorithmsDynamic ProgrammingDynamic ProgrammingClassical algorithm design techniqueO(n 2 2 n ) time algorithm for TSP [Held,Karp ; 1962]O(2.4422 n ) time algorithm for Coloring [Lawler ; 1967]

2/52Fast Exponential-Time AlgorithmsDynamic ProgrammingLawler’s Coloring AlgorithmLet G = (V , E). For every X ⊆ V , compute col(G, X ) := χ(G[X ])by increasing cardinality of X .col(G, ∅) = 0col(G, X ) = 1 + min{col(G, X − S) :S maximal independent set of G[X ]}Thus χ(G) = col(G, V ).

13/52Fast Exponential-Time AlgorithmsDynamic ProgrammingAnalysis of Running TimeA graph on i vertices has at most 3 i/3 maximal independent setsand they can be listed in time O ∗ (3 i/3 ).Thus up to a polynomial factor the running time isn∑i=0( ni)3 i/3 = (1 + 3√ 3) nThe running time of Lawler’s coloring algorithm is O(2.4422 n ).

14/52Fast Exponential-Time AlgorithmsIterative CompressionIterative CompressionNew algorithm design techniqueincremental algorithmIntroduced for parameterized algorithmsReed, Smith, Vetta [2004] : Odd cycle transversal

5/52Fast Exponential-Time AlgorithmsIterative CompressionNotationinput graph G = (V , E)v 1 , v 2 , . . . , v n sequence of the vertices of Gfor all i = 1, 2, . . . , n, V i = {v 1 , v 2 , . . . , v i } and G i = G[V i ]B i maximum independent set of G i , i.e. |B i | = α(G i )A i = V i \ B i

6/52Fast Exponential-Time AlgorithmsIterative CompressionBasic ApproachFor i = 1, 2, . . . , n, compute α(G i ) and a maximum independentset B i of G i . Thus B n is a maximum independent set of G n = G.Compression (Expansion) : Given a maximum independent set B iof G i , compute a maximum independent set of G i+1 = G i + v i+1 .How are we making use of the maximum independent set B i ?

6/52Fast Exponential-Time AlgorithmsIterative CompressionBasic ApproachFor i = 1, 2, . . . , n, compute α(G i ) and a maximum independentset B i of G i . Thus B n is a maximum independent set of G n = G.Compression (Expansion) : Given a maximum independent set B iof G i , compute a maximum independent set of G i+1 = G i + v i+1 .How are we making use of the maximum independent set B i ?

7/52Fast Exponential-Time AlgorithmsIterative CompressionCompression (Expansion)Two possible cases1. α(G i+1 ) = α(G i ) and B i+1 = B i .2. α(G i+1 ) = α(G i ) + 1, v i+1 ∈ B i+1 . ThusB i+1 = {v i+1 } ∪ A ′ ∪ B ′ , where A ′ ⊆ A i , B ′ ⊆ B i and A ′independent set.To find out whether α(G i+1 ) = α(G i ) + 1, compute for everymaximal independent set A ′ of G[A i − N[v i+1 ]] in time O(n 2.5 ) amaximum independent set of the bipartite graphG[(A ′ ∪ B i ) − N[v i+1 ]].

8/52Fast Exponential-Time AlgorithmsIterative CompressionSpeed up the CompressionLet |A i | = an and |B i | ≤ (1 − a)n. Depending on the value of a :1. Either check all at most 3 an/3 maximal independent sets A ′ ofG[A i ]2. Or check all independent sets A ′ ⊆ A i − N[v i+1 ] with |A ′ | ≤ |B i |Running times (up to polynomial factor) :1. (3 a/3 ) n2. ( )an(1−a)nBalancing with a ≈ 0.8 : MAXIMUM INDEPENDENT SET can besolved without Branching in time O(1.3196 n ).

19/52Fast Exponential-Time AlgorithmsInclusion ExclusionInclusion Exclusion MethodOld method to design exponential-time algorithmsIntroduced by Karp 1982 (or earlier)Based on inclusion-exclusion principle of countingSolving optimization or decision problems by counting

0/52Fast Exponential-Time AlgorithmsInclusion ExclusionBjörklund-Husfeldt-Koivisto AlgorithmU set of size nS family of subsets of U, enumerable in time O ∗ (2 n )S[X ] = {S ∈ S : S ∩ X = ∅}s[X ] = |S[X ]|S (i) = {S ∈ S : |S| = i} subfamily of i-setss (i) [X ] = |S (i) [X ]| number of i-sets avoiding X

21/52Fast Exponential-Time AlgorithmsInclusion ExclusionInclusion Exclusion FormulaFor a positive integer k, let c k = c k (S) denote the number of(possibly overlapping) k-covers, that is the number of ways tochoose S 1 , S 2 , . . . , S k ∈ S with replacement such thatS 1 ∪ S 2 ∪ · · · ∪ S k = U.The number of k-covers c k can be computed as followsInclusion Exclusion Formulac k = ∑ (−1) |X | s[X ] kX ⊆U

2/52Fast Exponential-Time AlgorithmsInclusion ExclusionComputing all s[X ]’s in time and space O ∗ (2 n )Build a table with 2 n entries containing s[X ] for all X ⊆ U. Thenevaluate the inclusion-exclusion formula in time O ∗ (2 n ).For instance, for every subset W ⊆ U disjoint from X , lets W [X ] denote the number of sets S ∈ S such that W ⊆ Sand S ∩ X = ∅.s W [X ] = s W [X ∪ {v}] + s W ∪{v} [X ] holds for all mutuallydisjoint X , W , and vcompute s[X ] = s ∅ [X ] recursively in time O ∗ (2 n ) and spaceO ∗ (2 n )

23/52Fast Exponential-Time AlgorithmsBranchingBranching Algorithmsone of the major techniques to design exponential-timealgorithmstypically polynomial space algorithmDavis, Putnam (1960) ; Tarjan, Trojanowski (1977)difficult to analyse the worst case running time

4/52Fast Exponential-Time AlgorithmsBranchingBranch & ReduceBranch & Reduce AlgorithmsBranch & Reduce algorithms(also called backtracking or search tree algorithms) :recursively applied to problem instances using Branching rulesand Reduction rules.Branching rules : solving the problem by recursively solvingsmaller instancesReduction rules :- simplify the instance- (typically) reduce the size of the instance

5/52Fast Exponential-Time AlgorithmsBranchingSearch TreesSearch TreesSearch Tree :used to illustrate and analyse an execution of a Branch &Reduce algorithmnodes : assigns to each node a solved problem instanceroot : assigns the input to the rootchild : each instance (subproblem) reached by a branching ruleis assigned to a child (of the node of the original problem)

6/52Fast Exponential-Time AlgorithmsBranchingSearch TreesA search treeV1SelectDiscardV2V4SDSDV3V5SDSD

7/52Fast Exponential-Time AlgorithmsBranchingTime AnalysisAnalysisAnalysing Branch & Reduce algorithms :Correctness and (Worst Case) Running TimeAnalysis of the Running Time :To obtain an Upper Bound on the maximum number of nodesof the search tree (for an input of size n) :1 Define a Measure for a problem instance.2 Lower bound the progress made by the algorithm at eachbranching step.3 Compute the collection of recurrences for all branching andreduction rules.4 Solve all those recurrences (to obtain a running time of theform O(αi n ) for each).5 Take the worst case over all solutions.See the surveys [Woeginger (2003), Fomin et al. (2005)].

7/52Fast Exponential-Time AlgorithmsBranchingTime AnalysisAnalysisAnalysing Branch & Reduce algorithms :Correctness and (Worst Case) Running TimeAnalysis of the Running Time :To obtain an Upper Bound on the maximum number of nodesof the search tree (for an input of size n) :1 Define a Measure for a problem instance.2 Lower bound the progress made by the algorithm at eachbranching step.3 Compute the collection of recurrences for all branching andreduction rules.4 Solve all those recurrences (to obtain a running time of theform O(αi n ) for each).5 Take the worst case over all solutions.See the surveys [Woeginger (2003), Fomin et al. (2005)].

7/52Fast Exponential-Time AlgorithmsBranchingTime AnalysisAnalysisAnalysing Branch & Reduce algorithms :Correctness and (Worst Case) Running TimeAnalysis of the Running Time :To obtain an Upper Bound on the maximum number of nodesof the search tree (for an input of size n) :1 Define a Measure for a problem instance.2 Lower bound the progress made by the algorithm at eachbranching step.3 Compute the collection of recurrences for all branching andreduction rules.4 Solve all those recurrences (to obtain a running time of theform O(αi n ) for each).5 Take the worst case over all solutions.See the surveys [Woeginger (2003), Fomin et al. (2005)].

7/52Fast Exponential-Time AlgorithmsBranchingTime AnalysisAnalysisAnalysing Branch & Reduce algorithms :Correctness and (Worst Case) Running TimeAnalysis of the Running Time :To obtain an Upper Bound on the maximum number of nodesof the search tree (for an input of size n) :1 Define a Measure for a problem instance.2 Lower bound the progress made by the algorithm at eachbranching step.3 Compute the collection of recurrences for all branching andreduction rules.4 Solve all those recurrences (to obtain a running time of theform O(αi n ) for each).5 Take the worst case over all solutions.See the surveys [Woeginger (2003), Fomin et al. (2005)].

7/52Fast Exponential-Time AlgorithmsBranchingTime AnalysisAnalysisAnalysing Branch & Reduce algorithms :Correctness and (Worst Case) Running TimeAnalysis of the Running Time :To obtain an Upper Bound on the maximum number of nodesof the search tree (for an input of size n) :1 Define a Measure for a problem instance.2 Lower bound the progress made by the algorithm at eachbranching step.3 Compute the collection of recurrences for all branching andreduction rules.4 Solve all those recurrences (to obtain a running time of theform O(αi n ) for each).5 Take the worst case over all solutions.See the surveys [Woeginger (2003), Fomin et al. (2005)].

7/52Fast Exponential-Time AlgorithmsBranchingTime AnalysisAnalysisAnalysing Branch & Reduce algorithms :Correctness and (Worst Case) Running TimeAnalysis of the Running Time :To obtain an Upper Bound on the maximum number of nodesof the search tree (for an input of size n) :1 Define a Measure for a problem instance.2 Lower bound the progress made by the algorithm at eachbranching step.3 Compute the collection of recurrences for all branching andreduction rules.4 Solve all those recurrences (to obtain a running time of theform O(αi n ) for each).5 Take the worst case over all solutions.See the surveys [Woeginger (2003), Fomin et al. (2005)].

8/52Fast Exponential-Time AlgorithmsBranchingA Simple Branching AlgorithmThe Algorithm sis1 int sis(G = (V , E)) {2 if(|V | = 0) return 0 ;3 choose a vertex v of minimum degree in G4 return 1 + max{sis(G − N[y]) : y ∈ N[v]} ;5 }

9/52Fast Exponential-Time AlgorithmsBranchingA Simple Branching AlgorithmAnalysis of the worst case running timeClassical Analysis and Standard Measure(i.e. the measure of the input size is the number of vertices ofthe input graph).Recurrence :T (n) ≤ (d + 1) · T (n − d − 1),where d is the degree of the chosen vertex v.Solution of recurrence : O((d + 1) n/(d+1) ), being maximumfor d = 2,Running time of sis : O(3 n/3 ).

30/52Fast Exponential-Time AlgorithmsBranchingHistoryBranching Algorithms for Maximum Independent SetPolynomial Space AlgorithmsO(1.2600 n ) Tarjan, Trojanowski (1977)O(1.2346 n ) Jian (1986)O(1.2278 n ) Robson (1986)Exponential Space AlgorithmsO(1.2109 n ) Robson (1986)O(1.1893 n ) Robson (2001) unpublished

1/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.The Maximum Independent Set Algorithm of Fomin et al.Maximum Independent Setsimple Branch & Reduce algorithmrunning time O(1.2202 n )polynomial spacetime analysis based on Measure and Conquerlower bound of Ω(1.1224 n ) for the (unknown) worst caserunning time of the algorithmthe (known) running time of such Branch & Reduce algorithmmight be “far” from the (unknown) worst case running time of thealgorithm

31/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.The Maximum Independent Set Algorithm of Fomin et al.Maximum Independent Setsimple Branch & Reduce algorithmrunning time O(1.2202 n )polynomial spacetime analysis based on Measure and Conquerlower bound of Ω(1.1224 n ) for the (unknown) worst caserunning time of the algorithmthe (known) running time of such Branch & Reduce algorithmmight be “far” from the (unknown) worst case running time of thealgorithm

2/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.The simple Branch & Reduce algorithm of Fomin et al.int mis(G) {(0) if (|V (G)| ≤ 1) return |V (G)| ;(1) if (∃ component C ⊂ G)return mis(C)+mis(G − C) ;(2) if (∃ nodes v and w : N[w] ⊆ N[v])return mis(G − {v}) ;(3) if (∃ a node v with d(v) = 2)return 1+mis(˜G(v)) ;(4) select a node v of maximum degree, which minimizes |E(N(v))| ;return max{mis(G − {v} − M(v)), 1+mis(G − N[v])} ;}

33/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Folding a vertex of degree twoSuppose v has degree two and its neighbors u 1 and u 2 arenon-adjacent. Folding the node v of G is the process oftransforming G into a new graph ˜G = ˜G(v) by :(1) adding a new node u 12 ;(2) adding edges between u 12 and the nodes in N(u 1 ) ∪ N(u 2 ) ;(3) removing N[v].Lemma (Folding)For any graph G and for any node v of G with degree two and twonon-adjacent neighbors :α(G) = 1 + α(˜G(v)).

33/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Folding a vertex of degree twoSuppose v has degree two and its neighbors u 1 and u 2 arenon-adjacent. Folding the node v of G is the process oftransforming G into a new graph ˜G = ˜G(v) by :(1) adding a new node u 12 ;(2) adding edges between u 12 and the nodes in N(u 1 ) ∪ N(u 2 ) ;(3) removing N[v].Lemma (Folding)For any graph G and for any node v of G with degree two and twonon-adjacent neighbors :α(G) = 1 + α(˜G(v)).

4/52ertices of degree at most two are alwFast Exponential-Time AlgorithmsBranchingAlgorithm of Fomin et al.The following simple property holdsAn Exampleolding of a vertex v.v1 23 4 5⇒ 123 4 5

5/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Advantages and Disadvantages of FoldingWhy using folding ?The domination rule (2) and Folding (3) guarantee that thecurrent graph has minimum degree 3 whenever the only branchingrule (4) is applied.Disadvantages of foldingFolding may increase the degree of the graph, and thus cannot beused for algorithms on graphs of bounded degree.Folding makes it impossible to use Memorization.

36/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.MirroringDefinitionGiven a node v, a mirror of v is a node u ∈ N 2 (v) such thatN(v) \ N(u) is a (possibly empty) clique. We denote by M(v) theset of mirrors of v.When discarding a node v, one can also discard its mirrors as wellwithout modifying the maximum independent set size.Lemma (Mirroring)For any graph G and for any node v of G :α(G) = max{α(G − {v} − M(v)), 1 + α(G − N[v])}.

36/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.MirroringDefinitionGiven a node v, a mirror of v is a node u ∈ N 2 (v) such thatN(v) \ N(u) is a (possibly empty) clique. We denote by M(v) theset of mirrors of v.When discarding a node v, one can also discard its mirrors as wellwithout modifying the maximum independent set size.Lemma (Mirroring)For any graph G and for any node v of G :α(G) = max{α(G − {v} − M(v)), 1 + α(G − N[v])}.

e discard a vertex v, we can discar7/52f v is a vertex u ∈ N (v) such that NFast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.(v) the set of mirrors of v. ExampSome Examplesigure 4 Example of mirrors: u is avvuu

x v, we can discard its mirrors as w7/52N (v) such that N(v) \ N(u) is a (pFast Exponential-Time AlgorithmsBranchingThe Algorithm Fomin et al.irrors of v. Examples of mirrors areSome Examplesof mirrors: u is a mirror of v.vvvuuu

d its mirrors as well without modif7/52N(v) \ N(u) is a (possibly empty) clFast Exponential-Time AlgorithmsBranchingThe Algorithm Fomin et al.ples of mirrors are given in Figure 4Some Examplesmirror of v.vvvuu

well without modifying the maximum7/52possibly empty) clique. We denote bFast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.e given in Figure 4. Intuitively, wheSome Examplesvvu

8/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Measure & ConquerA standard analysis of the worst case running time would establishrunning time O(1.3251 n ) for the algorithm. [Tarjan, TrojanowskiO(1.2600 n ) ! !]A better choice of the measure of a problem instance mayallow to obtain a better upper bound on the worst caserunning time of the same algorithm.Thus a nonstandard measure is a tool to improve theanalysis of the worst case running time of Branch & Reducealgorithms.

38/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Measure & ConquerA standard analysis of the worst case running time would establishrunning time O(1.3251 n ) for the algorithm. [Tarjan, TrojanowskiO(1.2600 n ) ! !]A better choice of the measure of a problem instance mayallow to obtain a better upper bound on the worst caserunning time of the same algorithm.Thus a nonstandard measure is a tool to improve theanalysis of the worst case running time of Branch & Reducealgorithms.

39/52Note that k = k(G) ≤ |V |, hence α k ≤ α n .Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Choice of the Measuren i := number of nodes of degree i in Gn ≥i := number of nodes of degree at least i in GTo analyze the maximum number of nodes of the search treegenerated for an instance G = (V , E), the following measurek = k(G) is used :Measurek(G) = ∑ i≥0w i n i ≤ nThe weights w i ∈ (0, 1] will be fixed such that the base of theexponential upper bound of the running time is minimized.[A computer is needed to do this.]

40/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Constraints and Linear RecurrencesAnalyzing the reduction rules (2) and (3)leads to constraints for the choice of the w i ’sDue to the domination rule (2) and the folding rule (3), when webranch, we can assume that, for every node w :(i) deg(w) ≥ 3 ;(ii) w is not dominated and does not dominate any other node.Analyzing the main branching rule (4)establishes a system of linear recurrences for any fixed choice ofthe w i ’s

1/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Analyzing the Main Branching Rule ISuppose we branch at a given node v, withN(v) = {u 1 , u 2 , . . . , u d } and d i = d(u i ).We denote by m i = m i (v) the number of nodes of degree i inN(v) :m i = |{u ∈ N(v) : d(u) = i}|.Let p h = p h (v) be the number of nodes in N 2 (v) which haveexactly h neighbors in N(v) :p h = |{w ∈ N 2 (v) : |N(w) ∩ N(v)| = h}|.Note that (at least) the nodes corresponding to p d−1 and p d aremirrors of v. Additionally, the number of edges between N(v) andN 2 (v) is p = p(v) = ∑ dh=1 h p h.We also define m ≥i = ∑ j≥i m j and p ≥h = ∑ j≥h p j.

2/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Analyzing the Main Branching Rule IILet P[k] be the maximum number of subproblems generated for aninstance of measure k.Reduction of the measure of the problem when discarding a vertexv :∆ OUT = ∆ OUT (v) ≥w d + p d w d + p d−1 w max{3, d−1} +d∑m i ∆ w i .Reduction of the measure of a problem when selecting a vertex v :w d +∆ IN = ∆ IN (v) ≥d∑m i w i + p 1 ∆ w d +i=3i=3d∑p h w max{3,h} .h=2

43/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.System of Recurrences for the Main Branching RuleSystem of RecurrencesFor all m i and p h such that ∑ di=3 m i = dand ∑ dh=1 h p h = d + m 3 :P[k] ≤ P[k − ∆ OUT ] + P[k − ∆ IN ].Fortunately this can be restricted to a finite number of recurrencesby arguing that we may assume d ≤ 7.

4/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Optimizing the WeightsConsider an assignment of the weights w 3 , w 4 , w 5 , and w 6 whichsatisfies the initial assumptions and the constraints.It turns out that the number of subproblems that need to besolved for a problem of measure k is P[k] ≤ α k , where α > 1 isthe largest real root of the set of equationsα k = α k−∆ OUT+ α k−∆ IN.Thus the estimation of the running time reduces to choosing theweights w minimizing α = α(w) (we refer to Eppstein’s work onquasi-convex programming for a general treatment of such aproblem).

45/52Fast Exponential-Time AlgorithmsBranchingThe Algorithm of Fomin et al.Analysis of the Running TimeToolsMeasure & Conquer based analysis of the running timeprogram based on randomized local search to computeoptimal values of the w i ’ssophisticated analysisRunning TimeThe algorithm of Fomin et al. has running time O(1.2202 n ). Thisis the best known running time of a polynomial space algorithm tocompute a maximum independent set.

46/52Fast Exponential-Time AlgorithmsSort and SearchSort and SearchOld method to design exponential-time algorithmsIntroduced by Horowitz, Sahni 1974Typical running time O(2 n/2 ) = O(1.4142 n )

47/52Fast Exponential-Time AlgorithmsSplit and ListSplit and ListNew method to design exponential-time algorithmsIntroduced by Williams 2004Typical running time O(2 2.376 n/3 ) = O(1.7315 n )Resembles Sort and Search

48/52Fast Exponential-Time AlgorithmsTreewidth BasedTreewidth Based AlgorithmsTechnique for designing exponential-time algorithmsmainly for special graph classesplanar graphs, graphs of maximum degree 3Example : 2 n/6 time algorithm to compute a maximumindependent set in graphs of degree at most 3

49/52Fast Exponential-Time AlgorithmsConclusionsOpen QuestionsFundamental open questions :polynomial vs. exponential spacefaster deterministic algorithms for 3-SATbetter tools to analyze the running time ofbranching algorithmsapplications in enumerative combinatorics

Fast Exponential-Time AlgorithmsConclusionsMerci !

Fast Exponential-Time AlgorithmsConclusionsFor Further Reading IFomin, F.V., F. Grandoni, and D. Kratsch,Measure and conquer : Domination - A case study,Proc. of ICALP 2005, LNCS 3380, (2005), pp. 192–203.Fomin, F.V., F. Grandoni, and D. Kratsch,Some New Techniques in Design and Analysis of Exact (Exponential)Algorithms,Bulletin of the EATCS, 87, (2005), pp. 47–77.Moon, J. W., and L. Moser,On cliques in graphs,Israel J. Math., 3, (1965), pp. 23–28.Robson, J. M.,Finding a maximum independent set in time O(2 n/4 ),Tech. Rep. 1251-01, LaBRI, Université Bordeaux I, 2001.Tarjan, R.E., and A.E. Trojanowski,Finding a maximum independent set,SIAM Journal on Computing 6 (1977), pp. 537–546.

Fast Exponential-Time AlgorithmsConclusionsFor Further Reading IIWilliams, R.,A new algorithm for optimal constraint 2-satisfaction and its implications,Theoretical Computer Science 348 (2005), pp. 357-365.Woeginger, G. J.,Exact algorithms for NP-hard problems : A survey,Combinatorial Optimization - Eureka, You Shrink !, LNCS 2570, (2003),pp. 185–207.