Parameterized Measure & Conquer for Problems with No Small Kernels

Algorithmica (2012) 64:189–212DOI 10.1007/s00453-011-9566-6

Parameterized Measure & Conquer for Problemswith No Small Kernels

Daniel Binkele-Raible · Henning Fernau

Received: 29 October 2010 / Accepted: 23 August 2011 / Published online: 14 September 2011© Springer Science+Business Media, LLC 2011

Abstract Measure & Conquer (M&C) is a prominent technique for analyzing exactalgorithms for computationally hard problems, in particular, graph problems. It triesto balance worse and better situations within the algorithm analysis. This has led,e.g., to algorithms for MINIMUM VERTEX COVER with a running time of O(cn) forsome constant c ≈ 1.2, where n is the number of vertices in the graph.

Several obstacles prevent the application of this technique in parameterized al-gorithmics, making it rarely applied in this area. However, these difficulties can behandled in some situations. We will exemplify this with two problems related to VER-TEX COVER, namely CONNECTED VERTEX COVER and EDGE DOMINATING SET.For both problems, several parameterized algorithms have been published, all basedon the idea of first enumerating minimal vertex covers. Using M&C in this contextwill allow us to improve on the hitherto published running times. In contrast to someof the earlier suggested algorithms, ours will use polynomial space.

1 Introduction

Measure & Conquer (M&C) is nowadays a standard approach for developing and an-alyzing (in most cases, quite simple) exact exponential-time algorithms for compu-tationally hard problems, in particular, for graph problems; see [14] for an overview.It tries to balance worse and better situations within the algorithm analysis. For ex-ample, there are now algorithms for MINIMUM DOMINATING SET with search treesizes estimated only slightly larger than 1.5n (see [14, 31, 33]), contrasting the naïveenumerative algorithm that considers 2n cases.

D. Binkele-Raible · H. Fernau (�)FB 4—Abteilung Informatik, Univ. Trier, 54286 Trier, Germanye-mail: fernau@informatik.uni-trier.de

D. Binkele-Raiblee-mail: raible@informatik.uni-trier.de

190 Algorithmica (2012) 64:189–212

The application of this technique is less frequent in parameterized algorithmics.The reasons for this are various; let us make these clear with the example of VERTEX

COVER in mind.

1. M&C tries to balance worse and better situations within the algorithm analysis.How is this achieved? The branching itself may create (local) situations for whichbetter algorithms exist, and an appropriately defined measure can profit from this.For instance, many (branching) algorithms work better on graphs with a boundeddegree. Since the removal of a vertex reduces the degrees of its neighbors, it isoften possible to reduce the measure by more than one in the branch that deletes avertex from the graph. Observe that this happens if a vertex is put into the cover.This works fine as long as we measure the running time in, say, the number ofvertices, n. In that case, we might think that each vertex receives a budget of 1at the very beginning, and the so-called measure of a graph simply sums up allvertex budgets. We furthermore assume that a vertex of degree d has (at least) abudget of ωd , with 0 ≤ ω0 ≤ ω1 ≤ · · · ≤ 1 being monotonously increasing withthe degree d . Upon deleting a vertex x of degree d , the sketched measure drops byωd + ∑

v∈N(x)(ωdeg(v) − ωdeg(v)−1). However, if we measure in some parameterk upperbounding the size of a vertex cover, then it is hard to justify why or whenthe measure can profit of some vertices which are (finally) not put into the cover.Reducing a parameterized measure in such a case would be like a credit on thefuture, and we should pay it back if we do not put this vertex later into the cover.This may lead to problems since we should never increase the measure during therun of the algorithm.

2. Having decided on the first issue, i.e., having defined some reasonable measure toestimate the search tree size, we have to be careful that there is a polynomial-timeanswer when this measure reaches or drops below zero. Notice this is no problemfor the classical search tree analysis found in the area of exact exponential-timealgorithms, as a measure of zero either indicates that the graph is empty or that ithas been reduced to a trivial instance. Using a measure as sketched in the previousitem, e.g., with 0 = ω0 < ω1, in the now classical setting of the analysis of mod-erately exponential-time algorithms (see [15]), a measure of zero occurs if andonly if the graph contains no edges. Moreover, it is not possible at all that such ameasure attains negative values. When a parameterized measure reaches or dropsbelow zero, it is less obvious how the instance looks like. So, a separate analysismust be given in that case.

3. We must ensure that the measure will not increase upon applying reduction rules(orwe must restrict their use). While this is also an issue in the area of exact al-gorithms, this seems to be more involved in the parameterized setting. A simpleexample will be discussed in Sect. 2.

Hence, M&C techniques are rarely found in parameterized algorithmics. Someearlier papers combine a small problem kernel with an exact algorithm analyzed byM&C, but this approach is not feasible for CONNECTED VERTEX COVER, since nopolynomial-size kernel exists for this problem, unless the polynomial hierarchy col-lapses to the third level; see [6]. Only few examples for such an amortized genuinelyparameterized search tree analysis are known, the first one being one on VERTEX

Algorithmica (2012) 64:189–212 191

COVER on subcubic graphs [4]. As it is well-known, VERTEX COVER possesses alinear vertex kernel. This fact was later used by I. Razgon [30] to improve on thementioned parameterized algorithm for VERTEX COVER on subcubic graphs, pre-senting a sophisticated M&C analysis of an exact exponential-time algorithm. This isan important observation, since S. Gaspers [18] formulated the following challenge:“However, it would be very interesting to see a parameterized M&C analysis for aproblem that does not have a linear kernel.” Our contribution delivers the first ex-amples of a successful application of parameterized M&C to problems (most likely)having no linear kernels.1

There seems to be one further common feature of the hitherto published algorithmswhose analysis uses parameterized M&C: The measure could always be somehow lo-cated within the graph. This is true both for algorithms working on subcubic graphs(as in [4, 10, 12]) and for algorithms looking for spanning trees with additional prop-erties (as in [5, 10, 21, 28]). This is one possibility to address problem (1) describedabove. However, this kind of solution is quite problem-specific. For instance, in algo-rithms for finding a spanning tree with a maximum number of leaves, it is clear thatleaves in a graph will belong to any valid solution, so that branching can profit fromcreating leaves, although they are not yet attached to the spanning tree created so far.Here, we present measures that cannot be localized in the described way. Generallyspeaking, “global measures” seem to offer more flexibility and wider applicability.So, besides some technical contributions for problems related to VERTEX COVER

(as described below), this paper also shows some new methodological insights thatreach beyond.

We will show how to overcome these difficulties with two problems related toVERTEX COVER, namely CONNECTED VERTEX COVER and EDGE DOMINATING

SET. For both problems, several parameterized algorithms have already been devel-oped, all based on the idea of first enumerating minimal vertex covers and then pro-ducing solutions to the requested problem. Using M&C in this context will allowus to improve on the hitherto published running times. The common presentation ofboth algorithms should also highlight the similarities of both problems. In contrast tosome of the earlier suggested algorithms, ours will use polynomial space only.

We will freely use standard terminology from graph theory and from parameter-ized algorithms in what follows. For instance, N(v) denotes the open neighborhoodof v, deg(v) = |N(v)| the degree of v, G[X] is the graph induced by the vertex set X,�(G) the maximum degree of graph G, etc. We would like to remind the readerabout the goal of developing these algorithms: We aim at obtaining a valid solutionset (here: a connected vertex cover or an edge dominating set) of size at most k withan algorithm that is based on a search tree with at most ck leaves, where c > 1 issome hopefully small constant. We also assume that the amount of work associatedto each node of the search tree is polynomial-time only. This results in running timesof O∗(ck), referring to O(nd · ck) (with d being a constant, independent of n andof k). Hence, we are aiming at developing fixed-parameter algorithms; see [7, 24] forfurther reading.

1Regarding EDGE DOMINATING SET, D. Lokshtanov said: “Resolving whether edge dominating set has

an o(k2) (vertex) kernel gives 100$ from me.” according to [34].

192 Algorithmica (2012) 64:189–212

We should mention that for both problems, a parameterized algorithms’ race2 hasbeen going on now for years, competing for the fastest running times. In [20], anO∗(6k) algorithm for CONNECTED VERTEX COVER (CVC) has been established.Here, k is an upper bound on the size of the connected vertex cover one aims to find.This was improved in [11] to O∗(2.9316k) and in [22] further to O∗(2.7606k). Usingthe M&C approach, we will further lower the running time to O∗(2.4882k) by pre-senting a parameterized algorithm for CVC. All the mentioned algorithms consumepolynomial space only. To the knowledge of the authors, no previous results havebeen published that solve the natural question whether MIN-CVC can be solved intime less than �∗(2n), with n being the number of vertices of the input graph (whichwould correspond to a trivial enumeration algorithm). We solve this question affir-matively, exhibiting an relatively straightforward analysis of a slight variation of ouralgorithm, based on the ideas of [29], showing an upperbound on the running time ofO∗(1.8698n).

For EDGE DOMINATING SET (EDS), E. Prieto in her PhD thesis [27] obtained akernel of quadratic size for MINIMUM MAXIMAL MATCHING (i.e., INDEPENDENT

EDGE DOMINATING SET), a problem that is basically the same as EDS, see [35],which leads to an algorithm of running time O∗(ck2

) by naïve enumeration, follow-ing kernelization. This was considerably improved in [8] to O∗(2.6162k) (using poly-nomial space). A further improvement for EDS was exhibited in [32], providing animproved parameterized analysis of an algorithm of Fomin et al. [13] who obtainedan upper bound of O ∗ (2.4181k), yielding a running time of O∗(2.4178k), with thesame amount of space consumption. We will here describe another polynomial-spacealgorithm that runs in time O∗(2.3819k).

2 Parameterized Branching and Measure & Conquer

The Measure & Conquer approach requires the definition of an appropriate measurethat should express the progress we can make by branching and by applying reduc-tion rules. For example, consider the classical VERTEX COVER problem. Here, weare given a graph and a parameter k, and we are asked to find a set of at most k

vertices whose removal will leave only isolated vertices. The usual way to handlea simple search tree algorithm that preferably branches on high-degree vertices andalso exhaustively applies the well-known Degree-0, Degree-1 and Degree-2 Rulescan be expressed as follows in the terminology of a measure (also known as a poten-tial function):

φ(G,C,F ) = kfix − |C| − |F |Here, (G, k) is the original instance. In contrast to the classical approach for theanalysis of branching algorithms, kfix does not change during the run of the algorithmbut is fixed with the original input parameter kfix = k at the beginning. Notice thatthe “current graph” G[C,F ] can be obtained from G, C, and F , where C is the(partial) vertex cover solution found and fixed so far, and F is the set of Folding Rule

2Also testified by the Parameterized Newsletter edited by F. Rosamond twice a year.

Algorithmica (2012) 64:189–212 193

applications, after eliminating isolated vertices (Degree-0 Rule). Recall the Degree-2Rule (as discussed in [1]): (a) If there is a degree-two vertex u (in G[C,F ]) withadjacent neighbors, v and w, then there is a vertex cover of optimal size that includesboth of these neighbors. Hence, we can put v,w into C. (b) [Folding Rule] If thereis a degree-two vertex u (in G[C,F ]), whose neighbors, v and w, are non-adjacent,then u can be folded by contracting edges {u,v} and {u,w}. We can keep track of thisfolding by storing u into F . This models that he vertex cover number of the graphobtained by the folding operation is the vertex cover number of the graph before thefolding minus one. At the very beginning, C = F = ∅, so φ = kfix = k. During therun of the algorithm, |C| and |F | will increase, decreasing the measure accordingly.The classical naïve branching algorithm will choose a vertex x in G[C,F ] and eitherput x into the cover or all of its neighbors. Due to the reduction rules reflected in themeasure, this branching will take place on vertices of degree three at worst. Clearly,when φ drops below zero, we face a NO-instance. This is far less clear if we use amore elaborate measure that might already reduce when, e.g., vertices of degree threeare created, because “soon” reduction rules trigger or “finally” graphs of maximumdegree two evolve, which are solvable in polynomial time. What if the measure dropsbelow zero now?

We will discuss this in the following with two related problems: CONNECTED

VERTEX COVER and EDGE DOMINATING SET.

3 First Case Study: Connected Vertex Cover CVC

In this section we will present a parameterized algorithm for CONNECTED VERTEX

COVER.

3.1 Problem Definition and a Simple Property

Given a graph G = (V ,E), a set V ′ ⊆ V of cardinality at most k is sought such thatV ′ is a vertex cover which induces a connected subgraph of G. More formally:

CONNECTED VERTEX COVER (CVC)Given: A graph G = (V ,E), and the parameter, an integer k.We ask: Find V ′ ⊆ V such that for all e ∈ E we have V ′ ∩e = ∅, |V ′| ≤ k, and G[V ′]is connected.

On this topic, numerous works have been done already. For instance, the ones ofH. Fernau and D. Manlove [11] and of D. Mölle, S. Richter and P. Rossmanith [22]achieved running times of O∗(2.9316k) and O∗(2.7606k), respectively. Both arebased on listing all minimal vertex covers of size up to k. Then in a second phase,more vertices are added to the vertex cover to achieve connectedness. The same strat-egy is followed here. In addition, we use a more flexible measure which enables usto better balance the two phases.

As in the course of the forthcoming recursive algorithm vertices will be fixed tobelong to the future solution, we focus on an annotated version of our problem:

194 Algorithmica (2012) 64:189–212

ANNOTATED CONNECTED VERTEX COVER (ACVC)Given: A graph G = (V ,E), a subset Q ⊆ V , and the parameter, an integer k.We ask: Find V ′ ⊆ V such that for all e ∈ E we have V ′ ∩ e = ∅, |V ′| ≤ k, Q ⊆ V ′and G[V ′] is connected.

Members of Q are also called dedicated CVC-vertices, and Q is named the dedi-cated partial cover.

The following (easy) lemma will help us to justify some of the branching rules ofthe forthcoming algorithm.

Lemma 1 Let V ′ be a connected vertex cover. Assume that t ∈ V ′ is not a cut-vertexof G = (V ,E). If Gt := G[V ′ \ {t}] consists of exactly two components specified bytheir sets of vertices, V ′

1 and V ′2, and if N(t) ⊆ V ′, then there is a connected vertex

cover V ′′ with t ∈ V ′′ and |V ′′| ≤ |V ′|.

Proof Observe that V ′1 ∪ V ′

2 is a vertex cover by N(t) ⊆ V ′. If it is also connectedthen the claim is shown. Otherwise, as t is not a cut-vertex, there is a vertex z ∈ V ′such that V ′

1 ∪ V ′2 ∪ {z} is a connected vertex cover. �

3.2 Reduction Rules

We introduce the following reduction rules:

Deg1: Let u ∈ V \ Q such that N(u) = {v}. Then delete u and set Q := Q ∪ {v}.CutVertex: Let u ∈ V \ Q such that G[V \ {u}] contains at least two components.Then set Q := Q ∪ {u}.Deg2a: Let u ∈ V \ Q such that deg(u) = 2. Then delete u and set Q := Q ∪ N(u).Contract: If there are u,v ∈ Q such that {u,v} ∈ E then contract {u,v} (substitut-ing double edges by simple ones). The vertex [uv] obtained by identifying u and v

replaces {u,v} in Q.Deg2b: Let u ∈ Q such that N(u) = {x1, x2}, i.e., deg(u) = 2. Assume that N(u) ∩Q = ∅. Then delete u and introduce the edge {x1, x2}.

As in the introductory VERTEX COVER example with the folding rule, the last twolisted reduction rules actually decrease the parameter k of the ACVC instance withthe classical understanding of an analysis of a parameterized algorithm; here, thiseffect is modeled by keeping k fixed (in the measure) and subtracting the number ofthese rule applications. With this understanding, the following is not hard to derive.To make this distinction even clearer, we distinguish between the classical parameterk (as in the definition of ACVC above), the parameter kfix fixed at the beginning ofthe Measure & Conquer analysis, and the counters #Contract and #Deg2b that keeptrack of the number of applications of Contract and Deg2b, respectively. So, wemaintain the invariant

kfix = k + |Q| + #Contract + #Deg2b,

where Q denotes the current (partial) CVC solution (as in the annotation of ACVC).

Lemma 2 The reduction rules are sound.

Algorithmica (2012) 64:189–212 195

Proof In the following arguments, let C be a solution to ACVC of minimum cardi-nality.

Deg1: Any connected vertex set C with u ∈ C (and necessarily v ∈ C) is not mini-mum as C \ {u} is smaller.CutVertex: Otherwise, we cannot reach a connected solution.Deg2a: We will show that in all cases, N(u) ⊆ C and u ∈ C holds without loss ofgenerality, hence validating that we set Q := Q ∪ N(u). (a) If u ∈ C, then clearlyN(u) ⊆ C, since C is a vertex cover. So, suppose (b) u ∈ C. Due to Lemma 1 inorder to falsify our claim, N(u) ⊆ C must be false, i.e., there is one h ∈ N(u) \ C.Since C is connected and u ∈ C, h is unique. Note that N(h) ∩ (C \ {u}) = ∅ byDeg1. Thus, (C \ {u}) ∪ {h} is a connected vertex cover of the same cardinality,leading us back to case (a).Contract: Let G′ be the graph obtained by applying the reduction rule. Let C′ bea CVC of G′ with |C′| ≤ k − 1 that contains the dedicated CVC-vertices. Clearly,C = (C′ − [uv]) ∪ {u,v} is a vertex cover. Moreover, |C| ≤ k. We have to argue forthe connectedness of G[C]. Since [uv] is a dedicated CVC-vertex, [uv] ∈ C′. Twosub-cases occur: (a) |C′| = 1: Now, C = {u,v} is clearly a connected vertex coverof G. (b) |C′| > 1. Consider C = (C′ − [uv]) ∪ {u,v}. Since G′[C′] is connected,there is a vertex x ∈ C′ that is a neighbor of [uv]. Hence, x ∈ C is a neighbor of u orv in G, showing that G[C] is connected. The converse direction is similarly proven.Deg2b: Let G′ be the graph evolved from the application of the rule. If C′ is aconnected vertex cover for G′ then |C′ ∩ {x1, x2}| ≥ 1. Thus, C′ ∪ {u} is a connectedvertex cover for G of size |C| + 1. If C is a connected vertex cover for G, then|C ∩ {x1, x2}| ≥ 1. Thus, C \ {u} is a connected vertex cover for G′. �

Let Bij := {u ∈ V \ Q | |N(u) ∩ Q| = i, |N(u)| = j} and B≥ij := ⋃

i′≥i,j ′≥j Bi′j ′ .

Note that in a reduced instance B01 = B11 = B02 = B12 = B22 = ∅ due to reduc-tion rules Deg1, CutVertex and Deg2a. Now, we can present Algorithm 1. Observethat we can solve CVC by calling Algorithm 1, for all h ∈ V , with the sets Q = {h}and I = ∅ and the parameter kfix = k. We point out that I is only used for reasons ofbookkeeping within the algorithm to ensure a controlled application of rule Deg2b.Mostly, the branching is done into two cases, also called binary branching. The pri-orities according which the branching is performed are chosen in order to allow for agood analysis of an upper bound of the running time of the algorithm.

3.3 The Branching Algorithm and its Correctness

The lemmas below are needed as an intermediate step towards demonstrating thecorrectness of Algorithm 1.

Lemma 3 Deg2b is applied in Step 1 of Algorithm 1 if and only if in the previousrecursive call, branching was performed at a vertex v ∈ (B13 ∪ B23) such that thereexisted a vertex u ∈ (N(v) \ Q) with deg(u) = 3 (prior to branching in Step 12), butthere was no edge {x1, x2} ∈ E with N(v) \ Q = {x1, x2}.

196 Algorithmica (2012) 64:189–212

Algorithm 1 An Algorithm for ANNOTATED CONNECTED VERTEX COVER

Input: A connected graph G = (V ,E), a subset ∅ � Q ⊆ V , an integer kfix and aset I ⊆ V .Output: A set V ′ ⊂ V such that Q ⊆ V ′, G[V ′] is connected and V ′ is a vertex cover.Procedure: SolveCVC(G,Q,kfix,I )

1: Apply Deg2b on every u ∈ I (delete u and add {x1, x2} where N(u) = {x1, x2}).2: I := ∅.3: Apply the reduction rules CutVertex, Deg1, Deg2a and Contract exhaustively

with priorities corresponding to the given order.4: if |Q| + #Contract + #Deg2b > kfix or G is disconnected then5: return NO6: else if V = Q then7: return YES8: else if ∃v ∈ B≥

14 such that N(v) \ Q = ∅ then {Begin Phase I}9: Branch binary by (a) setting Q := Q ∪ {v}

(b) deleting v and setting Q := Q ∪ N(v).10: else if B13 ∪ B23 = ∅ then11: Choose v ∈ (B13 ∪ B23) according to the following priorities:12: 1. I. ∃{x1, x2} ∈ E : N(v)\Q = {x1, x2} or II. ∃u ∈ (N(v)\Q) : deg(u) = 3.

13:Branch binary: (a) set Q := Q ∪ {v}; (b) set X := N(v) \ Q, G :=G − v, Q := Q ∪ X and I := {u | u ∈ X ∧ |N(u)| = 2 ∧ N(u) ∩ Q = ∅}.

14: 2. v ∈ B23

15:Choose u ∈ (N(v) \ Q) and branch binary:(a) set Q := Q∪{u}; (b) set X := N(u), G := G−u and Q := Q∪X.

16: 3. v ∈ B13. Let N(v) \ Q = {b, c} with b = c.17: 3.1 ∃r ∈ N(b) ∩ N(c) where r = v. Branch into four cases.

18:

(a) Q := Q∪{b, c}, G := G−v; (b) Q := Q∪{v}∪N(b), G := G−b;(c) Q := Q∪{v, b}∪N(c), G := G−c; (d) Q := Q∪{v, b, c}∪N(r),G := G − r .

19: 3.2 N(b) ∩ N(c) = {v}. Branch into four cases.

20:

(a) Q := Q ∪ {b, c}, G := G − v; (b) Q := Q ∪ {v, b};(c) Q := Q ∪ {v, c} ∪ N(b), G := G − b; (d) Q := Q ∪ {v} ∪ N(b) ∪N(c), G := G − {b, c}.

21: else {Begin Phase II}22: Apply the Steiner-Tree-Algorithm of [23] with Q as the terminal set.23: end if

Proof Deg2b is applied in Step 1 of Algorithm 1 if and only if the auxiliary set vari-able I is non-empty. The only place where I is possibly assuming any non-emptyvalue is in Step 13 of the previous recursive call. Consider the situation prior tobranching, i.e., in Step 12 of the previous recursive call. Clearly, v ∈ (B13 ∪ B23).With priority, the case that finds an edge {x1, x2} ∈ E with N(v) \ Q = {x1, x2} isconsidered. In Step 13 (part (b)), all the neighborhood of N(v) (stored in X) is putinto Q, so that in particular {x1, x2} ⊆ Q. Hence, {x1, x2} ∩ I = ∅. But since therewas at least one Q-vertex in N(v) in Step 12, I = ∅. In fact, the only way that Deg2bcould trigger on some vertex from I ⊆ X is that deg(u) = 3 in Step 12, since u hasdegree two after deleting v. �

Algorithmica (2012) 64:189–212 197

Lemma 4 In Step 6 of Algorithm 1, i.e., in particular before the beginning of Phase I,we have that (a) Q = ∅ and (b) G is connected.

Proof The claim is true for the first invocation of Algorithm 1 as we have Q = {h}for some h ∈ V .

(a) Note that the only reduction rules that actually delete vertices from Q areContract (Case 1) and Deg2b (Case 2). In Case 1, an edge consisting of two verticesfrom Q is contracted. Thus, afterwards Q contains at least one vertex. In Case 2,note that Deg2b only is applied in Step 1 in a very restricted setting, guided by theset variable I . This set I has been constructed in Step 13 of the previous recursivecall. In that step, I ⊆ X and X ⊆ Q by construction. Hence, I ⊆ Q in the currentcall of Algorithm 1. Due to Lemma 3, in the previous recursive call, branching wasperformed at a vertex v ∈ (B13 ∪ B23), so that in Step 12 there must have been at leastone neighbor d of v with d ∈ Q. Note that this vertex d is not affected by Step 1,since d /∈ I . Thus in Step 2, Q = ∅.

(b) Otherwise, Step 4 failed. �

Lemma 5 Algorithm 1 solves ACVC correctly.

Proof By Lemma 2, the reduction rules are sound. We now show that if no case inPhase I applies, then the Steiner-Tree-Algorithm in Phase II can be used. Firstly, if thefirst part of the or-statement in Step 4 applies, then the number of vertices that shouldbe put into the cover is greater than kfix. Note that any Contract or Deg2b-applicationimplicitly puts a vertex (which is not present in the current graph) in the final vertexcover, but this has not been accounted for in the dedicated partial cover Q. Thus, wecorrectly answer NO. Secondly, if V = Q then by Contract and Lemma 4(b) we have|V | = 1. Thus, we have a trivial instance and can return YES.

Otherwise, there is a vertex h ∈ V \ Q. Additionally we can require that N(h) ∩Q = ∅ by Lemma 4. If there is at least one such vertex h where N(h) ⊆ Q then wehave h ∈ ⋃

z,�:�>max{2,z} Bz� due to the reduction rules. Thus, some case in Phase Iapplies. If for all such h we have N(h) ⊆ Q, then Q is an independent vertex coverby Contract. The final task is to find some minimum cardinality set B ⊆ V \ Q suchthat G[Q ∪ B] is connected. This is now the Steiner-Tree problem and therefore weapply an appropriate existing algorithm for this task (Phase II).

Any branching is exhaustive except the one in Step 18.We turn to Step 18. Here in the last recursive call (d) we delete r and therefore

any solution C with v, b, c, r ∈ C is not considered. But notice that by Lemma 1 asolution C no greater in size is guaranteed with v ∈ C as G[C \ {v}] consists of twocomponents. C is found in the recursive call (a) in Step 18. �

3.4 Run Time Analysis

We use a rather simple measure:

φ(G,Q) := kfix − ω · |Q| − c where ω ≤ 0.5

Here c = #Contract + #Deg2b, i.e., it counts the number of Contract and Deg2bapplications. Observe that c counts the number of vertices of the original instance

198 Algorithmica (2012) 64:189–212

fixed to be in Q which are not present anymore in the current instance. Therefore,a decrease of the initial budget kfix by an amount of c is justified. The followinglemma is important yet clear.

Lemma 6 No reduction rule application increases the measure φ(G,Q).

Proof Observe that the deletion of a vertex u ∈ V \Q leaves φ(G,Q) unchanged andits addition to Q decreases the measure. Thus, the claim is true for Deg1, Deg2a andCutVertex. After the application of Contract or Deg2b the set Q decreased by oneelement. On the other hand c went up by one. Hence, there is a decrease of (1−ω). �

Here we like to point out the following observation: Once we have φ(G,Q) < 0during our algorithm, Steps 4–5 of Algorithm 1 apply and NO is returned. Thus,φ(G,Q) indeed can be used to derive a running time of the form O∗(ck). To this end,the two phases of the algorithm are separately assessed, although the measure analysisapplies to both phases. The typical branching algorithm analysis using Measure &Conquer is done in Phase I. In that analysis, so-called branching vectors are derived,for instance, (1,3ω). This corresponds to the following recurrence that bounds thesize T (φ) of a search tree whose root is associated with the measure φ: T (φ) ≤T (φ − 1) + T (φ − 3ω). Notice that for each ω ≤ 0.5, our analysis yields a validupper bound on the size of the search tree, measured in the number of leaves. Theconcrete value of ω is chosen to find a small upper bound. The branching vectorsare derived by analysing how the measure drops between the situation in Step 8 ofAlgorithm 1 in two successive (recursive) calls.

Phase II J. Nederlof [23] showed that the STEINER TREE problem can be solvedin time O∗(2�), where � = |Q| is the number of given terminals, using polynomialspace only. But note that by

φ(G,Q) := kfix − ω · � − c ≥ kfix − ω · � − (kfix − �) = (1 − ω) · �

we can upper bound Step 22 in Algorithm 1 by O∗(21

1−ωφ(G,Q)). Observe that we

used the fact that kfix − � ≥ c, which is due to Step 4.

Phase I We now have to find the branching vectors in case Algorithm 1 is calledrecursively:

Step 9 For v ∈ Bij , we derive the branching vector (i · (1 − ω) + ω, (j − i) · ω),where i ≥ 1, j ≥ 4 and i < j . Observe that we only need to consider branchingvectors for j = 4. Any branching vector where j > 4 is dominated by one of thelatter. So, the relevant branching vectors are: (1,3ω) (for i = 1), (2−ω,2ω) (fori = 2), and (3 − 2ω,ω) (for i = 3).

Step 13 I. If N(v) \ Q = {x1, x2} and {x1, x2} ∈ E, then in the second branch Con-tract is triggered on x1 and x2, resulting in a reduction of 1 + ω with respect toφ(G,Q). Thus, the branching vector (1,1 + ω) is derived (note that I = ∅ dueto Lemma 3).

Algorithmica (2012) 64:189–212 199

II(a). Assume v ∈ B13 and (due to the previous case) {x1, x2} ∈ E. Let x1 ∈ Bs3where 0 ≤ s ≤ 2. Then the following branching vectors are entailed:If s ≥ 1, ((1 − ω) + ω,2ω + (1 − ω)) = (1,ω + 1) andif s = 0, ((1 − ω) + ω,ω + 1) = (1,ω + 1).Note that in the last derived branching vector (in the second branch) Deg2b ap-plies in the subsequent recursive call as I = ∅, cf. Lemma 3.II(b). Assume v ∈ B23. Consider {x1} = N(v)\Q, x1 ∈ Bs3. By the same analysisas in the previous case we arrive at the following branching vectors:If s ≥ 1, (2 · (1 − ω) + ω,ω + (1 − ω)) = (2 − ω,1) andif s = 0, (2 · (1 − ω) + ω,1) = (2 − ω,1).

Step 15 Note that deg(u) ≥ 4 due to Step 12 and that N(u) ∩ Q = ∅ due to Step 8.Hence, the branching vector (ω,4ω+2 · (1−ω)) = (ω,2+2ω) is entailed. Notethe application of Contract in the second part of the branch.

Step 16 If {b, c} ∩ (B13 ∪ B23) = ∅, we would have chosen to branch on b or on c inStep 12. Hence, deg(b) ≥ 4, deg(c) ≥ 4. Moreover, (N(b) ∪ N(c)) ∩ Q = ∅, asotherwise we would have branched on b or on c in Step 8. This scenario appliesto the analysis of Steps 18 and 20 below.

Step 18 Firstly, suppose N(r) ∩ Q = ∅. Then a branching vector (2ω,2 + 2ω,

3 + 2ω,3) follows due to the application of Contract with respect to r in thesecond and third part of the branching. Secondly, if N(r) ∩ Q = ∅ we get abranching vector (2ω,1 + 3ω,2 + 3ω,3 + ω). Note that the additional amountof ω in the last entry is due to the fact that |N(r) \ ({c, b} ∪ Q)| ≥ 1 because ofDeg2a.

Step 20 This case yields a branching vector of (2ω,2,2+3ω,1+6ω). Notice that inCases (b) and (c), Contract is triggered twice. Moreover, in (c) we find |N(c) \(Q ∪ {v, b})| ≥ 3, which explains why the measure drops by at least 2 + 3ω inthat case. As N(b) ∩ N(c) = {v}, |(N(b) ∪ N(c)) \ (Q ∪ {v})| ≥ 6, which showsthe decrease of at least 1 + 6ω of the measure in the last branch, where v is againinvolved in a Contract application.

On the basis of the above discussion, we get the main result of this section.

Theorem 1 CONNECTED VERTEX COVER can be solved in time O∗(2.4882k) andO∗(1.8658n), using polynomial space.

Proof By choosing ω = 0.23956, the maximum branching number of the abovebranching vectors is 2.4882. Additionally, by the choice of ω the running time ofPhase II can be upper bounded by O∗(2.4882k). To achieve the running time upperbound in terms of n we use a method of [29]: By invoking Algorithm 1 for every1 ≤ k′ ≤ n/2 + α where α = 0.1842n and by iterating over any set S with maximumsize n/2−α and checking if V \S forms a CVC, we get the bound of O∗(1.8658n). �

In this case study we have seen that with some moderate effort, we could achievean improved running time for an already broadly studied problem. This was possibleeven though the basic method did not change substantially. We first branched towardscreating a vertex cover and then in a second phase additional vertices had to be addedfor the sake of connectivity. This case study showed what an impact a proper chosen

200 Algorithmica (2012) 64:189–212

measure can have for the understanding of the problem and the designed algorithm.Let us also mention the cases which determine the running time: 1. Step 20 and 2.

Phase II.

4 Second Case Study: Edge Dominating Set

4.1 Definitions and a Simple Case

An edge dominating set is a set of edges D with the property that every other edgeshares at least one endpoint with an edge from D. We focus on:

k-EDGE DOMINATING SET (k-EDS)Given: A graph G = (V ,E), and the parameter, an integer k.We ask: Find E′ ⊆ E such that for all e ∈ E we have e ∩ (

⋃e′∈E′ e′) = ∅, |E′| ≤ k.

Note that any solution E′ to k-EDS has the property that V (E′) = (⋃

e′∈E′ e′) is avertex cover of size at most 2|E′|. This fact was used by H. Fernau [8] to design anO∗(2.6181k)-algorithm. This algorithm is based on enumerating all minimal vertexcovers of size no more than 2k. A similar exponential time algorithm was developedby J.M.M. van Rooij and H.L. Bodlaender [32] consuming O∗(1.3226n) time. Webasically analyze a parameterized variant of their algorithm enriched by two specialbranching cases. Thus, during the course of the algorithm we handle a set L of ver-tices which is supposed to be covered by the final edge dominating set. Therefore, wepresent an annotated version of k-EDS.

k-ANNOTATED EDGE DOMINATING SET (k-AEDS)Given: A graph G = (V ,E), a set L ⊆ V , and the parameter, an integer k.We ask: Find E′ ⊆ E, |E′| ≤ k, L ⊆ V (E′), with e ∩ V (E′) = ∅ for any e ∈ E.

The corresponding minimization problem is called MINIMUM AEDS. We call agiven annotated instance redundant if G[V \ L] exclusively consists of componentsC1, . . . ,C� which are either single vertices or edges, i.e., these components are K1’sand K2’s.

Our algorithm (presented in the following subsection) relies on the following fact:

Lemma 7 (Fernau [8]) Given a redundant instance, MINIMUM AEDS can be solvedin polynomial time.

For the convenience of the reader, we sketch the construction in the following. LetG = (V ,E) and a set L ⊆ V specify a redundant instance of MINIMUM AEDS. LetEI be the isolated edges in G. Let (G′,L′), G′ = (V ′,E′), be obtained from (G,L)

by setting: V ′ = V \ V (EI ), E′ = E \ EI , and L′ = L \ V (EI ). Clearly, if D is aminimum AEDS for (G′,L′), then D ∪ EI is a minimum AEDS for (G,L), andvice versa. Let E2 collect the isolated edges in G′[V ′ \ L′]. Now, if D is a minimumAEDS for (G′,L′), then there is also a minimum AEDS D′ for (G′,L′) with D′ ∩E2 = ∅ (∗), because G′ is redundant and G′ contains no isolated edges. Let G′′ be

Algorithmica (2012) 64:189–212 201

obtained from G′ by contracting all edges e ∈ E2 into vertices xe; let X2 denote thecorresponding set of new vertices. Let L′′ = L′ ∪X2. Let LI be the isolated vertices inG′′[L′′]. Compute a minimum edge cover C in G′′[L′′ \ LI ]. For each vertex x fromLI , let CI contain an arbitrary edge ex covering x. Then, because of (∗), D′ = C ∪CI

is a minimum AEDS for (G′,L′), from which we can obtain a minimum AEDS D

for (G,L) as described above.3

4.2 The Branching Algorithm

We now present Algorithm 2, which lists all minimal vertex covers V C of size atmost 2k until a redundant instance is reached. This redundant instance is solved inpolynomial time using Lemma 7, yielding a solution S ⊆ E. Note that U and Us formthe set L given in the definition of k-AEDS. For instance, Phase I is the classicalbranching for solving or enumerating vertex covers: Either a vertex is in the cover(here, it is put into U ), or all neighbors must be in the cover (are put into U ).

We improve on the running time shown in [8] by providing a special treatment ofpaths and cycles, i.e., graphs of maximum degree two, as already suggested in [32].Actually, we further distinguish between two phases when branching on compo-nents of maximum degree two, namely Phase II and Phase III, in order to allowfor a Measure & Conquer approach based on analyzing different phases of the al-gorithm within the measure. Such an approach might be of broader interest and haspreviously been applied for the Measure & Conquer analysis of algorithms for MAX-IMUM 2-SATISFIABILITY and related problems; see [2, 19].

As usual, a path in a graph G = (V ,E) can be described as a sequence p =(p1, . . . , p�) of vertices, where {pi,pi+1} ∈ E, with 1 ≤ i < �. If, in addition,{p�,p1} ∈ E, then p forms a cycle. We say that p induces a path component, if theonly edges in G with endpoints in {p1, . . . , p�} are {pi,pi+1}, with 1 ≤ i < �.

4.3 Correctness

Notice that any recursive branching step in Algorithm 2 is exhaustive except the onein Step 7. Here case (a) should be considered. In addition to p1, also p3 is adjoinedto U which has to be justified. Note that if p3 ∈ U then it follows that p2,p4 have tobe adjoined yielding a non-minimal solution. If both p1,p3 ∈ U then p2,p4 have tobe deleted for the sake of minimality.

Notice also that vertices that are not taken into the vertex cover during the enu-meration phase (and hence go into the complement, i.e., an independent set) can bedeleted whenever it is guaranteed that all their neighbors (in the current graph) aremoved into the vertex cover.

Let X�(B) := {p := (p1, . . . , p�) | p induces a path component in G[V \ B]}. Forexample, X1(B) collects the isolated vertices in G[V \ B]. In a sense, � = 1 is thesmallest meaningful value of �; however, the case � = 0 will be useful as a kind ofboundary case in the following. The measure is defined as follows:

3The last three sentences follow a somewhat simplified construction due to J.M.M. van Rooij and H.L.Bodlaender [32].

202 Algorithmica (2012) 64:189–212

Algorithm 2 An Algorithm for k-Edge Dominating SetInput: A graph G = (V ,E) and the parameter k.Output: YES if a solution to k-EDS exists, NO otherwise.

SolveEDS(G,∅,∅); this procedure is described in the following.

Procedure: SolveEDS(G,U,Us )

1: if λ(G,U,Us) < 0 (the measure λ is defined in (1)) then2: return NO3: else if �(G[V \ (U ∪ Us)]) ≥ 3 then {Begin Phase I}4: Branch (a) U := U ∪ {v} and (b) U := U ∪ N(v), G := G − v.5: else if G[V \ (U ∪ Us)] has a cycle component induced by (p1, . . . , p�), � ≥ 3

then {Begin Phase II}6: if � = 4 then7: Branch (a) Delete p2,p4, U := U ∪ {p1,p3}; (b) Delete p1, U := U ∪

{p2,p4}.8: else if � = 6 then9: Branch (a) U := U ∪ {p1,p4}; (b) Delete p4, U := U ∪ {p1,p3,p5}; and

(c) Delete p1, U := {p2,p6}.10: else11: Branch (a) U := U ∪ {p1}; (b) Delete p1, U := U ∪ {p2,p�}.12: end if13: else if G[V \ (U ∪ Us)] has a path component induced by (p1, . . . , p�), � ≥ 4

then14: Branch (a) U := U ∪ {p3}; (b) Delete p3, U := U ∪ {p2,p4}.15: else if G[V \ (U ∪ Us)] has a path component induced by (p1,p2,p3)

then {Begin Phase III}16: Branch (a) Us := Us ∪ {p2}; (b) Delete p2, Us := Us ∪ {p1,p3}.17: else {Begin Phase IV}18: Solve the problem in polynomial time by using the algorithm of [8] according

to Lemma 7.19: end if

λ(G,U,Us) := 2kfix − ω · |U | − (2 − ω)|Us |

− χ(�(G[V \ (U ∪ Us)]) ≤ 2) ·(∑

i≥0

γi · |Xi(U ∪ Us)|)

(1)

where ω = 0.8909, γ0 = γ1 = 0, γ2 = 1, γ3 = 0, γ4 = 0.2365 and γj = 0.3505 forj ≥ 5 and χ is the indicator function. Note that the initial budget 2kfix is only de-creased by adjoining vertices to U or Us (as kfix remains fixed from the beginning).Note that once G[V \ U ] consists only of three-vertex-paths the vertices adjoined tothe vertex cover are collected in Us (and no longer in U ). Observe that any vertex inU is only counted by a fraction of ω instead of 1. On the other hand, the vertices inUs are counted by 2 − ω > 1. Thus, the Us -vertices are overestimated. But it is alsotrue that the vertices from a three-vertex-path are surrounded by U -vertices. In the

Algorithmica (2012) 64:189–212 203

analysis we show that the overestimation of the Us -vertices can be compensated bythe underestimation of the U -vertices due to this fact.

In contrast to the previous case study, it is now not so clear how to answer if themeasure drops below zero. This is handled by the following lemma.

Lemma 8 If in Step 1 of Algorithm 2 λ(G,U,Us) < 0, then there is no annotatededge dominating set ED extending L := U ∪ Us with |ED| ≤ kfix.

Proof Assume that λ(G,U,Us) < 0. Notice that this is equivalent to:

2kfix < ω · |U | + (2 − ω)|Us | + χ(�(G[V \ (U ∪ Us)]) ≤ 2)

·(∑

i≥0

γi · |Xi(U ∪ Us)|)

If λ(G,U,Us) < 0 was found in Step 1 of Algorithm 2 due to a recursive call fromPhase I, then this means that 2kfix < ω · |U |, assuming that �(G[V \ (U ∪Us)]) ≥ 3,so that the statement immediately follows, since ω ≤ 1 and U collects the vertexcover vertices that should be the basis for the edge dominating set.

So, we can assume in the following that we are either facing recursive calls fromPhases II or III, or the very last call from Phase I (that destroyed the very last vertexof high degree). We are proving the assertion by way of contradiction. Suppose thecontrary and let ED be a solution to kfix-AEDS. Let VED = (

⋃e′∈ED e′) and note

that L ⊆ VED . Define GED = (VED,ED).If λ(G,U,Us) < 0 happens after a recursive call from Phase II or as the last call

from Phase I (as described above), but not from Phase III, we have: Since ED isan edge dominating set, we know that for each i ≥ 2 and for all paths induced by(p1, . . . , pi) ∈ Xi(U ∪ Us), there exists some 1 ≤ j ≤ i such that pj ∈ VED . Hence,

|Xi(U ∪ Us)| ≤ |V (Xi(U ∪ Us)) ∩ VED| (✮1)

Notice that, since we are in Phase II (at least we left Phase I), we know that �(G[V \(U ∪ Us)]) ≤ 2 and, moreover, Us = ∅. Hence, λ(G,U,Us) < 0 means that 2kfix <

ω · |U | + (∑

i≥0 γi · |Xi(U ∪ Us)|). Furthermore, we deduce:

2kfix < ω · |U | +(∑

i≥0

γi · |Xi(U ∪ Us)|)

✮1,✮4≤ |U | +(∑

i≥2

γi · |V (Xi(U ∪ Us)) ∩ VED|)

≤ |U | +(∑

i≥2

|V (Xi(U ∪ Us)) ∩ VED|)

✮5≤ |VED|

We were also using that γ0 = γ1 = 0 (✮4) and that ED covers U ∪ Us (✮5).So we should discuss in details the case when λ(G,U,Us) < 0 happens after a re-

cursive call of the third Phase. Assume that GED has c components. Let B1, . . . ,Bc

204 Algorithmica (2012) 64:189–212

be the components of GED . Observe that, w.l.o.g., GED is acyclic and hence|VED| ≤ kfix +c. Let Cs := {Bi | V (Bi)∩Us = ∅} and let m : VED → (VED ∪{−1}),−1 /∈ VED , be defined as follows:

1. For any Bi ∈ Cs pick exactly one x ∈ V (Bi) ∩ Us and let its image m(x) be anarbitrary neighbor of x in GED .

2. The image of any other vertex is −1.

This notation easily extends to sets by setting m(B) = {m(v) | v ∈ B}.Let M = {u,v ∈ VED | m(u) = v} and observe that |Cs | = |M|

2 (✮Cs,M).Consider now u ∈ Us with m(u) = −1. Then there exists a path (p1,p2,p3) in

G[V \ U ] that contains u.Assume that m(u) ∈ U . Thus, summing up for u and m(u) the vertices are counted

by two in VED , whereas we decremented λ by ω + (2 − ω) = 2 (✮2), which justifiesthe mentioned overestimation of Us -vertices by the measure in this case.

Notice that m(u) ∈ U is the case in particular if u = p1. In that case, u has beenadjoined to Us in case (b) of Step 16. Since p2 got deleted, p2 ∈ VED . Since p2 ∈VED , we have m(u) ∈ U . The case u = p3 is symmetric.

So, the only case that is left over is u = p2 arising from case a) of Step 16, withm(p2) /∈ U . Assume, w.l.o.g., m(p2) = p1 (note that (N(p2) \ {p1,p3}) ⊆ U ). Dueto the branching, p1 /∈ Us . Hence, p1 ∈ V (X1(U ∪ Us)). Then, in λ both verticestogether were counted by (2−ω), while in VED they both together have been countedby two (✮3). This seems to be an invalid argument at first glance, but will be justifiedbelow. All this has to be considered more formally. Let R := {x ∈ Us | m(x) = −1}and note that

R = Us \ {z ∈ Us | m(z) ∈ U or m(z) ∈ (V (X1(U ∪ Us)) ∩ VED)}and that

M \ Us = (m(Us) ∩ U) ∪ (m(Us) ∩ (V (X1(U ∪ Us)) ∩ VED)

as we are facing Phase III and because of the reasoning leading to ✮2 and to ✮3.Also note that R ∩ M = ∅ and therefore

|R| = |Us \ M|= |Us | − |M \ Us |

≤∣∣∣∣

⋃

Bi∈Cs

E(G[Bi])∣∣∣∣ + |Cs | − |M \ Us |

✮Cs ,M=∣∣∣∣

⋃

Bi∈Cs

E(G[Bi])∣∣∣∣ − |Cs |

≤ |ED| − c ≤ kfix − c (✮7)

We are ready to summarize our findings:

2kfix < ω · |U | + (2 − ω)|Us | +(∑

i≥0

γi · |Xi(U ∪ Us)|)

Algorithmica (2012) 64:189–212 205

✮1,✮4,✮6≤ ω · |U | + (2 − ω)|Us | + |=:C

︷ ︸︸ ︷(V (X2(U ∪ Us)) ∩ VED) |

✮2,✮3≤ |U | + |=:A

︷ ︸︸ ︷m(Us) ∩ U | + |

=:B︷ ︸︸ ︷m(Us) ∩ (

V (X1(U ∪ Us)) ∩ VED

) |+ |V (X1(U ∪ Us)) ∩ VED| + 2 · |R| + |C|

✮7≤ |U | + |A| + |B| + |C| + |R| + |V (X1(U ∪ Us)) ∩ VED| + (kfix − c)

✮9≤ |VED| + (kfix − c)

We use the fact that in Phase III, we have⋃

i≥4 Xi(U ∪Us) = ∅ and γ0 = γ1 = γ3 = 0(✮6). So, C is the only part that does not cancel out from the big sum in the first line.Moreover, γ2 ≤ 1.

For the second line, we use that U can be split into those vertices which are pairedup with Us -vertices via m (see ✮2) and those which are not paired; in the lattercase, we use ω ≤ 1. Hence, ω · |U | + (2 − ω) · |{x ∈ Us | m(x) ∈ U}| ≤ |U | + |A|.Moreover,

|{x ∈ Us | m(x) /∈ U}| ≤ |R| + |{x ∈ Us | m(x) ∈ V (X1(U ∪ Us)) ∩ VED}|.Using ✮3 and the natural mappings from {x ∈ Us | m(x) ∈ V (X1(U ∪ Us)) ∩ VED}into B and into V (X1(U ∪ Us)) ∩ VED , the second line can be deduced.

Note that VED ⊃ U ∪ R ∪m−1(A ∪ B) and m−1(A), m−1(B) and R are pairwisedisjoint (✮9). We explain the third last inequality in more details. Observe that anyvertex t from m−1(A ∪ B) is counted by an amount of one in |VED| but by an amountof (2 −ω) in λ. This presents a potential danger. Note that m(t) ∈ (A ∪ B) and Us =m−1(A ∪ B) ∪ R. Either t finds its partner in U or in V (X1(U ∪ Us)) ∩ VED . Thus,the drop of (1 − ω) with respect to t is compensated by the increase due to m(t). Inother words,

(1 − ω)|m−1(A ∪ B)| = (1 − ω)(|A| + |B|)≤ (1 − ω)(|U | + |V (X1(U ∪ Us)) ∩ VED|).

By the inequality above we finally derive kfix + c < |VED|, a contradiction. �

4.4 Run Time Analysis

We will consider each step in Algorithm 2 where recursive calls are made:

Step 4 Here we adjoin one vertex in the first and three vertices in the second branch-ing case to U . Thus, a branching vector (ω,3 · ω) is entailed.

Step 7 Here we adjoin two vertices in the first and two vertices in the second branch-ing case to U . Thus, a branching vector (2 · ω,2 · ω) can be derived.

Step 9 Here we adjoin two vertices in the first, three vertices in the second and twovertices in the third branching case to U . In the first case also two K2’s in G[V \

206 Algorithmica (2012) 64:189–212

(U ∪Us)] are produced and thus |X2(U ∪Us)| is increased by two. Thus, a branch-ing vector (2 · ω + 2,3ω,2ω) can be deduced.

Step 11 � = 3, � = 5 or � ≥ 7: In the first case we adjoin a vertex to U , but also createa path with � − 1 vertices which means that |X�−1(U ∪ Us)| increases by one. Thesecond case adjoins two vertices to U and creates a path with � − 3 vertices. Thisyields the branching vector (ω + γ�−1,2ω + γ�−3).

Step 14 The first case puts one vertex into U and creates a path with two verticesand another one with � − 3 vertices. On the other hand, a path with � vertices isdestroyed. The second case puts two vertices into U , creates a path with � − 4vertices and destroys one with � vertices. This yields as branching vector (ω − γ� +1 + γ�−3,2ω − γ� + γ�−4).

Step 16 The first case increases |Us | by one the second by two and hence (2 − ω,2 ·(2 − ω)) is the corresponding branching vector.

Note that in Phase I the paths in G[U ∪ Us] are not counted in λ. This is importantas otherwise due to branching in Step 4 of Algorithm 2 a P5 can result in a P4 byvertex deletion. Due to this the measure would be raised by an amount of γ5 −γ4 > 0and the given branching vector would not be appropriate. Note that upon enteringPhase II, λ is not increased. By the above running time analysis we can conclude thefollowing theorem. We point out that once again only a finite set of branching vectorshas to be considered. Namely, in the running time analysis of Steps 11 and 14 we canrestrict our considerations only to cases where � ≤ 9.

Theorem 2 EDGE DOMINATING SET can be solved in time O∗(1.54332k) ⊆O∗(2.3819k) consuming polynomial space.

The last running time analysis showed once more that with an appropriate measurea better running time can be proven. This method also allowed us to identify a cycle oflength six in G[V \ (U ∪ Us)] (Step 9 in Algorithm 2) as the critical case. Therefore,a special branching rule for this case has been invented. This is a further point wherewe gained on the running time.

5 Further Implications

We are going to sketch further implications of our findings in two directions: firstly,we are discussing the possibility to use exponential space to speed up our exponen-tial time algorithms; then, we are discussing problem variants that include rationalweights.

5.1 Using Exponential Space

The authors of [32] showed how to solve k-EDS in time O∗(2.4178k) with the samespace consumption. We indicate how their approach can be used to obtain a furtherslight running time improvement.

Theorem 3 Provided exponential space, EDGE DOMINATING SET can be solved intime O∗(2.373k).

Algorithmica (2012) 64:189–212 207

Proof We first modify algorithm 2 in line 5 which is the beginning of Phase II. Beforechecking line 5 (i.e., line 3 failed) we check whether |U | ≤ αk where α = 0.7865. Ifso we solve the instance by means of creating a path decomposition of size |U | + 2.According to [32], this consumes O∗(3αk) ⊆ O∗(2.373k) time and the same amountof space.

Otherwise we have |U | > αk and therefore we know that we have at most a bud-get of 2k − αk to spend during Phases II and III. The maximum branching numberof these phases is 1.5433. Also we know that we have spent a budget of (at least) αk

during Phase I which has a branching number of 1.5359. Thus, we have an overallrunning time of O∗(1.5359αk · 1.54332k−αk) ⊆ O∗(2.373k), (only) a slight improve-ment over what we obtained when using polynomial space. �

Clearly, in practice, algorithms using polynomial space only should be preferredover those needing exponential space. Notice that it might be tempting to re-analyzeour Algorithm 2 completely in order to obtain new parameter values for ω and γi .However, since we still branch on vertices of degree three, so that this part of theanalysis, including the value of ω, is untouched. As explained in the proof, the influ-ence of the possible switch to the tree decomposition based phase is only on scalingthe budget down, the parameters γi should be unchanged, as well.

5.2 Adding Weights

Our EDGE DOMINATING SET algorithm can be modified to cope with rationalweights we ≥ 1 associated to an edge e, as described in [8], again using polyno-mial space only. This is due to the fact that weighted redundant instances remainpolynomial time solvable and that λ(G,U,Us) can be also used for its running timeanalysis.

For the sake of completeness, let us make this reasoning more explicit here. So,we are facing the situation that we want to find a minimum edge dominating set ED

in a given graph G = (V ,E) with an edge-weight function ω : E → Q≥1, e �→ we;moreover, we are given a vertex set L and we have to satisfy L ⊆ V (ED). This spec-ifies an instance of MINIMUM ANNOTATED WEIGHTED EDGE DOMINATING SET,or MINIMUM AWEDS for short. Of specific interest are again weighted redundantinstances, i.e., G[V \ L] exclusively consists of components C1, . . . ,C� which areeither single vertices or edges. Similar to Sect. 4.1, we can first transform (G,ω,L)

a into a graph G = (V , E) with edge weight function ω and with a set R of distin-guished vertices, where the task is to find a minimum weight edge set that covers R.Following [8], we call the corresponding problem GENERALIZED WEIGHTED EDGE

COVER, or GWEC for short.More precisely, we would first (again) eliminate the isolated edges EI from G,

yielding an equivalent instance (G′,ω′,L′) of MINIMUM AWEDS. Let E2 collectthe isolated edges in G′[V ′ \ L′]. Let G′′ = (V ′′,E′′) be obtained from G′ by con-tracting all edges e ∈ E2 into vertices xe; let X2 denote the corresponding set of newvertices. Moreover, we add vertices ye (with Y2 denoting the corresponding set ofnew vertices) and edges xeye with weight ω′(e); for simplicity, we call such an edgexeye again e, so that we can easily identify E′′ with E′. Observe that then, ω′′ = ω′.

208 Algorithmica (2012) 64:189–212

Let L′′ = L′ ∪ X2. Compute a minimum generalized weighted edge cover C in G′′with L′′ being the set of distinguished vertices. Then, C can be viewed as a minimumAWEDS for the instance (G′,ω′,L′). So, C ∪ EI would be a minimum AWEDS forthe original instance (G,ω,L).

It is known (see [25]) that MINIMUM WEIGHTED EDGE COVER can be optimallysolved in polynomial (cubic) time. Based on this result, J. Plesník gave a cubic timealgorithm for a generalization of the problem we are interested in, see [26]; below, wegive a shorter construction for a cubic time algorithm for GENERALIZED MINIMUM

WEIGHTED EDGE COVER, directly based on [25].Let us now describe how to solve GWEC, given an instance (G,ω,R), i.e.,

G = (V ,E) with edge weight function ω and with a set R of distinguished ver-tices. As explained in [8], we cannot restrict our attention to the induced graphG[R] = (R,ER) as we could do in the unweighted case. In addition, we considerthe following edges. For each x ∈ R, let ex be the edge incident with x that has low-est weight amongst all edges incident with x and not contained in ER . If all edgesincident with x are contained in ER , then ex is undefined. So, we add all such edgesex to G[R] to obtain a graph G′ = (V ′,E′) with R ⊆ V ′ and ER ⊆ E′. Now, weidentify all vertices in V ′ \ R to get one new vertex r , so that we obtain a graphG′′ = (V ′′,E′′) with V ′′ = R ∪ {r}. The edge weight function is accordingly adaptedand also called ω. Let f be the function that maps edges from E′ onto edges fromE′′ (by the described identification).

Proposition 1 (G,ω,R) has a minimum generalized weighted edge cover of weightωopt if and only if either (G[R],ω) or (G′′,ω) has a minimum weighted edge coverof weight ωopt .

Proof Let C be a minimum generalized weighted edge cover covering R. Withoutloss of generality, edges from C that are not contained in G[R] could be the edges ofthe form ex chosen as described above. If C contains no edges of the form ex , then C

is also a minimum weighted edge cover for G[R]. If C contains edges of the form ex ,then f (C) is a minimum weighted edge cover for G′′.

Conversely, a set C that is a feasible edge cover for G[R] is also a feasible gener-alized edge cover for (G,R). Similarly, an edge set C (containing no edges outsideof E′) such that f (C) is a feasible edge cover of G′′ is also a feasible generalizededge cover for (G,R). Taking the cover of lowest weight ensures to produce a mini-mum generalized weighted edge cover for (G,ω,R). �

Corollary 1 WEIGHTED EDGE DOMINATING SET can be solved in timeO∗(2.3819k) consuming polynomial space.

Corollary 2 Provided exponential space, WEIGHTED EDGE DOMINATING SET canbe solved in time O∗(2.373k).

In [8], the question was raised if the techniques presented there would also extendto WEIGHTED INDEPENDENT EDGE DOMINATING SET, also known as WEIGHTED

MINIMUM MAXIMAL MATCHING. This was affirmatively answered in [32]. More

Algorithmica (2012) 64:189–212 209

specifically, they provide a solution to GENERALIZED WEIGHTED INDEPENDENT

EDGE COVER and show how to incorporate this into an algorithm for WEIGHTED

MINIMUM MAXIMAL MATCHING. We can integrate this also as a building blockinto our algorithms, which shows:

Corollary 3 WEIGHTED MINIMUM MAXIMAL MATCHING can be solved inO∗(2.3819k) time consuming polynomial space.

Corollary 4 Provided exponential space, WEIGHTED MINIMUM MAXIMAL

MATCHING can be solved in time O∗(2.373k).

6 Conclusions

6.1 A Brief Summary

We have focused on the development of parameterized algorithms for two alreadywell-studied problems, based on the M&C paradigm. We achieved running time up-perbounds considerably better compared to previous attempts, although we did notchange the principal ideas of the underlying algorithms. We like to emphasize oncemore that this settles a challenge formulated by S. Gaspers, where he asked if theparameterized M&C methodology could be applied to problems that do not admitlinear (vertex) kernels.

Let us point to the similarity of both considered problems, CONNECTED VERTEX

COVER and EDGE DOMINATING SET, not only from the algorithms that have beenpresented for both problems. Namely, if G admits a connected vertex cover of size k,then it also admits a connected edge dominating set (also known as a tree cover)of size k − 1 and vice versa. This was observed before; see, e.g., [17]. It allows usto compare the running time of both algorithms: Namely, it can be assumed thatthe size of a minimum edge dominating set is considerably smaller than that of aminimum tree cover, so that our algorithm for EDGE DOMINATING SET will showresults much faster than our algorithm for CONNECTED VERTEX COVER, assumingthat both are applied to the same graph and used to find a minimum solution (bygradually increasing the parameter).

6.2 Prospects and Open Questions

The natural question arises what other problems can be dealt with by an approachthat first enumerates solutions to a related problem and then, in a second phase, usesthese solutions to solve the actual problem, so that we can balance both phases us-ing M&C. TOTAL VERTEX COVER and related problems defined in [11] are natu-ral candidates, since these have similar properties as CONNECTED VERTEX COVER

studied in this paper. In fact, the analysis presented in [11] can be seen as a sortof precursor of the methodology presented in this paper, but its wider applicabilitywas not anticipated there. So, no nice parameterized algorithm for t -TOTAL VER-TEX COVER for any t > 1 is known. Like CONNECTED VERTEX COVER, presum-ably none of these problems have polynomial-size problem kernels; see [9]. Hence,

210 Algorithmica (2012) 64:189–212

the algorithm described in [11] (together with [9]) can be also seen as an answerto the question of S. Gaspers [18]. In the context of this paper, it might be also in-teresting to consider connectivity constraints attached to EDGE DOMINATING SET,e.g., TOTAL EDGE DOMINATING SET. Another interesting line of research is to con-sider weighted variants of all these problems. As noticed above, our algorithm forEDGE DOMINATING SET transfers to the weighted case. But what about connectiv-ity constraints, as with CONNECTED EDGE DOMINATING SET or with CONNECTED

VERTEX COVER? This might also yield interesting insights about the parameter-ized complexity approach as opposed to approximation algorithms, as WEIGHTED

CONNECTED VERTEX COVER is (most likely) not in APX, while WEIGHTED CON-NECTED EDGE DOMINATING SET is; see [16]. Notice that the algorithm that wegave for the unweighted CVC variant does not that easily transfer, since, for exam-ple, the Degree-1 rule is no longer valid. There is also always the natural question onfurther improving the presented algorithms. This might be possible, in particular, forrestricted graph classes. For instance, EDGE DOMINATING SET on bipartite graphs isalso known as MATRIX DOMINATION (details of the problem definition and the cor-responding transformation can be found in [8, 35]). Can algorithms exploit the bipar-titeness condition and hence improve the bound that follows with this paper? Finally,let us raise the question whether the M&C techniques, combined with parameterizedalgorithmics, can lead to improvements for the best-studied FPT problem, which isVERTEX COVER itself. First thoughts indicate that such improvements may be pos-sible, since an appropriate notion of phases is definable, based on classifying graphsby their maximum degree.

Earlier Versions A preliminary version of this paper appeared in the IPEC 2010proceedings (see [3]), with some details dating back to an IWPEC conference paperfrom 2006; see [8].

Acknowledgements We are grateful for the comments of the referees that helped to improve the pre-sentation of the material.

References

1. Abu-Khzam, F.N., Collins, R.L., Fellows, M.R., Langston, M.A., Sutters, W.H., Symons, C.T.: Ker-nelization algorithms for the vertex cover problem: theory and experiments. In: Arge, L., Italiano,G.F., Sedgewick, R. (eds.) Proceedings of the Sixth Workshop on Algorithm Engineering and Ex-periments and the First Workshop on Analytic Algorithmics and Combinatorics pp. 62–69. SIAM,Philadelphia (2004)

2. Binkele-Raible, D., Fernau, H.: A new upper bound for Max-2-SAT: a graph-theoretic approach.J. Discrete Algorithms 8, 388–401 (2010)

3. Binkele-Raible, D., Fernau, H.: Enumerate and measure, improving parameter budget management.In: Raman, V., Saurabh, S. (eds.) Parameterized and Exact Computation (IPEC 2010). Lecture Notesin Computer Science, vol. 6478, pp. 38–49. Springer, Berlin (2010)

4. Chen, J., Kanj, I.A., Xia, G.: Labeled search trees and amortized analysis: improved upper bounds forNP-hard problems. Algorithmica 43, 245–273 (2005)

5. Daligault, J., Gutin, G., Kim, E.J., Yeo, A.: FPT algorithms and kernels for the directed k-leaf problem.J. Comput. Syst. Sci. 76, 144–152 (2010)

6. Dom, M., Lokshtanov, D., Saurabh, S.: Incompressibility through colors and IDs. In: Albers, S.,Marchetti-Spaccamela, A., Matias, Y., Nikoletseas, S.E., Thomas, W. (eds.) International Colloquiumon Automata, Languages and Programming (ICALP 2009), Part I. Lecture Notes in Computer Sci-ence, vol. 5555, pp. 378–389. Springer, Berlin (2009)

Algorithmica (2012) 64:189–212 211

7. Downey, R.G., Fellows, M.R.: Parameterized Complexity. Springer, Berlin (1999)8. Fernau, H.: Edge dominating set: efficient enumeration-based exact algorithms. In: Bodlaender, H.L.,

Langston, M. (eds.) International Workshop on Parameterized and Exact Computation (IWPEC 2006).Lecture Notes in Computer Science, vol. 4169, pp. 142–153. Springer, Berlin (2006)

9. Fernau, H., Fomin, F.V., Philip, G., Saurabh, S.: The curse of connectivity: t -total vertex (edge) cover.In: Thai, M.T., Sahni, S. (eds.) International Computing and Combinatorics Conference (COCOON2010). Lecture Notes in Computer Science, vol. 6196, pp. 34–43. Springer, Berlin (2010)

10. Fernau, H., Gaspers, S., Raible, D.: Exact and parameterized algorithms for Max Internal SpanningTree. In: Paul, C., Habib, M. (eds.) Graph-Theoretic Concepts in Computer Science (WG 2009).Lecture Notes in Computer Science, vol. 5911, pp. 100–111. Springer, Berlin (2010). Long versionaccepted for publication with Algorithmica

11. Fernau, H., Manlove, D.F.: Vertex and edge covers with clustering properties: Complexity and algo-rithms. J. Discrete Algorithms 7, 149–167 (2009)

12. Fernau, H., Raible, D.: Exact algorithms for maximum acyclic subgraph on a superclass of cubicgraphs. In: Nakano, S.-I., Rahman, Md.S. (eds.) Workshop on Algorithms and Computation (WAL-COM 2008). Lecture Notes in Computer Science, vol. 4921, pp. 144–156. Springer, Berlin (2008)

13. Fomin, F.V., Gaspers, S., Saurabh, S., Stepanov, A.A.: On two techniques of combining branchingand treewidth. Algorithmica 54, 181–207 (2009)

14. Fomin, F.V., Grandoni, F., Kratsch, D.: A Measure & Conquer approach for the analysis of exactalgorithms. J. ACM 56(5) (2009)

15. Fomin, F.V., Kratsch, D.: Exact Exponential Algorithms. Texts in Theoretical Computer Science.Springer, Berlin (2010)

16. Fujito, T.: On approximability of the independent/connected edge dominating set problems. Inf. Pro-cess. Lett. 79, 261–266 (2001)

17. Fujito, T., Doi, T.: A 2-approximation NC algorithm for connected vertex cover and tree cover. Inf.Process. Lett. 90, 59–63 (2004)

18. Gaspers, S.: Measure & Conquer for parameterized branching algorithms. Parameterized ComplexityNews from September 2009 (pp. 5–6)

19. Gaspers, S., Sorkin, G.B.: A universally fastest algorithms for Max 2-Sat, Max 2-CSP, and everythingin between. In: Symposium on Discrete Algorithms (SODA 2009), pp. 606–615. ACM Press, NewYork (2009)

20. Guo, J., Niedermeier, R., Wernicke, S.: Parameterized complexity of vertex cover variants. TheoryComput. Syst. 41, 501–520 (2007)

21. Kneis, J., Langer, A., Rossmanith, P.: A new algorithm for finding trees with many leaves. In: In-ternational Symposium on Algorithms and Computation (ISAAC 2008). Lecture Notes in ComputerScience, vol. 5369, pp. 270–281. Springer, Berlin (2008)

22. Mölle, D., Richter, S., Rossmanith, P.: Enumerate and expand: improved algorithms for connectedvertex cover and tree cover. Theory Comput. Syst. 43, 234–253 (2008)

23. Nederlof, J.: Fast polynomial-space algorithms using Möbius inversion: improving on Steiner tree andrelated problems. In: Albers, S., Marchetti-Spaccamela, A., Matias, Y., Nikoletseas, S.E., Thomas, W.(eds.) International Colloquium on Automata, Languages and Programming (ICALP 2009), Part I.Lecture Notes in Computer Science, vol. 5555, pp. 713–725. Springer, Berlin (2009)

24. Niedermeier, R.: Invitation to Fixed-Parameter Algorithms. Oxford University Press, London (2006)25. Plesník, J.: Equivalence between the minimum covering problem and the maximum matching prob-

lem. Discrete Math. 49, 315–317 (1984)26. Plesník, J.: Constrained weighted matchings and edge coverings in graphs. Discrete Appl. Math. 92,

229–241 (1999)27. Prieto, E.: Systematic kernelization in FPT algorithm design. PhD thesis, The University of Newcastle,

Australia (2005)28. Raible, D., Fernau, H.: An amortized search tree analysis for k-LEAF SPANNING TREE. In: van

Leeuwen, J., Muscholl, A., Peleg, D., Pokorný, J., Rumpe, B. (eds.) Theory and Practice of ComputerScience, Software Seminar (SOFSEM 2010). Lecture Notes in Computer Science, vol. 5901, pp. 672–684. Springer, Berlin (2010)

29. Raman, V., Saurabh, S., Sikdar, S.: Improved exact exponential algorithms for vertex bipartization andother problems. In: Coppo, M., Lodi, E., Pinna, G.M. (eds.) Italian Conference on Theoretical Com-puter Science (ICTCS 2005). Lecture Notes in Computer Science, vol. 3701, pp. 375–389. Springer,Berlin (2005)

30. Razgon, I.: Faster computation of maximum independent set and parameterized vertex cover forgraphs with maximum degree 3. J. Discrete Algorithms 7(2), 191–212 (2009)

212 Algorithmica (2012) 64:189–212

31. van Rooij, J.M.M., Bodlaender, H.L.: Design by Measure and Conquer, a faster exact algorithm fordominating set. In: Albers, S., Weil, P. (eds.) International Symposium on Theoretical Aspects ofComputer Science (STACS 2008). LIPIcs, vol. 1, pp. 657–668. Schloss Dagstuhl—Leibniz-Zentrumfür Informatik, Hamburg (2008)

32. van Rooij, J.M.M., Bodlaender, H.L.: Exact algorithms for edge domination. In: Grohe, M., Nieder-meier, R. (eds.) Parameterized and Exact Computation (IWPEC 2008). Lecture Notes in ComputerScience, vol. 5018, pp. 214–225. Springer, Berlin (2008). Details on the parameterized algorithm canbe found in the TR version. The long version was accepted for publication with Algorithmica

33. van Rooij, J.M.M., Nederlof, J., van Dijk, T.C.: Inclusion/exclusion meets Measure and Conquer.In: Fiat, A., Sanders, P. (eds.) Algorithms—ESA 2009, 17th Annual European Symposium. LectureNotes in Computer Science, vol. 5757, pp. 554–565. Springer, Berlin (2009)

34. Truss, A., Weller, M.: Lessons in magic: AGAPE Spring School (May 24–29, Corsica). ParameterizedComplexity News from September 2009 (pp. 2–3; supplemented by Fig. 1 on p. 1)

35. Yannakakis, M., Gavril, F.: Edge dominating sets in graphs. SIAM J. Appl. Math. 38, 364–372 (1980)