Parameterized Edge Dominating Set in Cubic

0 downloads 0 Views 256KB Size Report
Aug 17, 2011 - the graph, i.e., a subset of edges such that no pair of them share a common endpoint. Clearly, a maximal matching is an edge dominating set.

Parameterized Edge Dominating Set in Cubic Graphs Mingyu Xiao

Hiroshi Nagamochi

School of Computer Science and Engineering, University of Electronic Science and Technology of China, China, [email protected]

Department of Applied Mathematics and Physics, Graduate School of Informatics, Kyoto University, Japan, [email protected]

Abstract In this paper, we present an improved algorithm to decide whether a graph of maximum degree 3 has an edge dominating set of size k or not, which is based on enumerating vertex covers. We first enumerate vertex covers of size at most 2k and then construct an edge dominating set based on each vertex cover to find a satisfied edge dominating set. To enumerate vertex covers, we use a branch-and-reduce method, which will generate a search tree of size O(2.1479k ). Then we get the running time bound of the algorithm. Key words.

1

Parameterized Algorithm, Edge Dominating Set, Cubic Graphs

Introduction

Given a graph G = (V, E), an edge dominating set of the graph is a subset M ⊆ E of edges such that each edge in E − M is incident to at least one edge in M . The minimum edge dominating set problem (EDS) is to find an edge dominating set of minimum size. EDS is a basic graph problem and one of the early-known NP-hard problems [5]. It is related to many other important problems, such as matching problems in graphs. A matching in a graph is an independent subset of edges of the graph, i.e., a subset of edges such that no pair of them share a common endpoint. Clearly, a maximal matching is an edge dominating set. The maximum matching problem, to find a matching of maximum size in a graph, is a well-known problem that can be solved in polynomial time. However, the minimum maximal matching problem (MMM), to find a matching of minimum size such that no edge can be added into the matching to get another matching, is NP-hard. In fact, MMM is equivalent to EDS, since a minimum maximal matching is also a minimum edge dominating set and a minimum maximal matching can be constructed from any minimum edge dominating set in linear time. Therefore, many papers discuss these two problems together. EDS is also related to the famous vertex cover problem. A vertex cover in a graph is a subset of vertices the removal of which leaves no edges. The set of endpoints of all edges in any edge dominating set is a vertex cover, which lights a way to solve EDS by enumerating minimal vertex covers. To find an edge dominating set of size k, we may enumerate vertex covers of size at most 2k and construct edge dominating sets from the vertex covers. In fact, many previous exact and parameterized algorithms for EDS are on the basis of enumeration of vertex covers. In this paper, we further study EDS algorithms based on this framework and get an improved parameterized algorithm for the edge dominating set problem in graphs of maximum degree 3. In parameterized algorithms, given an edge dominating set instance I together with a parameter k, we are required to design an algorithm with running time f (k)poly(|I|) to decide whether the graph has an edge dominating set of size at most k, where f (k) is a function of parameter k and poly(|I|) is a polynomial of input size |I|. We use k-EDS to denote this problem. 1

Technical report 2011-005, February 8, 2011. Revised August 17, 2011

1

EDS is a basic problem introduced in Garey and Johnson’s work on NP-completeness [5]. Yannakakis and Gavril [16] further showed that EDS is NP-hard even in planar or bipartite graphs of maximum degree 3. Randerath and Schiermeyer [9] designed an O∗ (1.4423m )-time algorithm for EDS, where m is the number of edges in the graph and notation O∗ suppresses all polynomially bounded factors. The result was improved to O∗ (1.4423n ) by Raman et al. [8], where n is the number of vertices in the graph. Fomin et al. [4] further improved the result to O∗ (1.4082n ) by considering the treewidth of the graph. Rooij and Bodlaender [10] designed an O∗ (1.3226n )-time algorithm by using the ‘measure and conquer method.’ For k-EDS, Fernau [3] gave an O∗ (2.6181k )time algorithm. Fomin et al. [4] obtained an O∗ (2.4181k )-time and exponential-space algorithm based on dynamic programming on bounded treewidth graphs. Binkele-Raible and Fernau [2] further improved the running time to O∗ (2.3819k ). Now the best result is O∗ (2.3147k ) due to Xiao et al. [15]. Wang et al. [11] also studied the problem of enumerating weighted edge dominating sets of small size. For EDS in graphs of maximum degree 3, the best exact and parameterized algorithms are the O∗ (1.2721n )-time and O∗ (2.2306k )-time algorithms due to Xiao [14]. Xiao designed the parameterized algorithm by using a result of kernelization in graphs of maximum degree 3. In this paper, we improve the result of O∗ (2.2306k ) to O∗ (2.1479k ) by designing an algorithm based on enumeration of vertex covers. Note that recently there are many interesting results on basic graph NP-hard problems in sparse and low-degree graphs, such as the O∗ (1.0854n )-time algorithm for the maximum independent set problem in degree-3 graphs [1], the O∗ (1.1616k )-time algorithm for the k-vertex cover problem in degree-3 graphs [12], the O∗ (1.251n )-time algorithm for TSP in degree-3 graphs [6] and so on. This is the reason why we have special interests in the problem in graphs of maximum degree 3.

2

Enumeration-Based Algorithms

For a set M of edges, we use V (M ) to denote the set of vertices appearing in at least one edge in M . Many previous algorithms for the edge dominating set problem are based on enumeration of minimal vertex covers, such as the algorithms in [3, 10, 11, 4]. In this framework, we first find out a set C ∗ of vertices that is the vertex set V (M ) of a minimum edge dominating set M . Then we find a maximum matching M ∗ in the induced graph G[C ∗ ] and add an edge for every unmatched vertex in C ∗ to M ∗ to get a minimum edge dominating set. In fact, sometimes we may find a set C ∗ which is a proper subset of V (M ) such that the edge dominating set M still can be found from C ∗ in polynomial time. The vertex set C ∗ may not be easy to compute. We will enumerate minimal vertex covers to find C ∗ . This step may cause exponential time. Since all minimal vertex covers can be enumerated in O∗ (1.4423n ) time [7], we can solve EDS in O∗ (1.4423n ) time. For k-EDS, we may use a branch-and-reduce method to find vertex covers of size up to 2k by fixing part of a vertex cover. Assume that the size of a vertex cover to be constructed in addition to a fixed partial vertex cover is at most p (initially, p = 2k). For any vertex v, we can branch on it to generate two branches by either including v into the vertex cover or excluding v from the vertex cover. In the second branch, we should include all neighbors in N (v) of v into the vertex cover. Then we can get the following recurrence on p: C(p) ≤ C(p − 1) + C(p − |N (v)|),

(1)

where C(p) denotes the worst running time to enumerate minimal vertex covers up to size p in any graphs.1 1 Actually many algorithms for EDS may not enumerate all minimal vertex covers of size at most p completely. Instead it is guaranteed that they can find at least one vertex cover from which an edge dominating set of size at most k can be constructed in polynomial time if any. Then C(p) should be the worst running time to solve the corresponding problem.

2

If we always select a vertex of maximum degree to branch on, then we can branch on vertices of degree at least 2. By solving C(p) ≤ C(p − 1) + C(p − 2),

(2)

Fernau [3] showed that k-EDS can be solved in O∗ (1.6181p ) = O∗ (2.6181k ) time. The method of iteratively branching on vertices of maximum degree is simple and powerful. It is interesting to know whether we can get further improvement on this method. For example, if we can guarantee that the vertices to be branched on are of degree at least 3, then we can get recurrence C(p) ≤ C(p − 1) + C(p − 3),

(3)

which solves to O∗ (1.4656p ) = O∗ (2.1479k ). As far as we know, there is no complete proof for this claim. In this paper, we show that this improvement can be achieved for the problem in graphs of maximum degree 3. In this paper, we will use the branch-and-reduce method to find the vertex cover C ∗ of size at most p. For a subset C ⊆ V and an independent set I ⊆ V − C in G, an edge dominating set M is called a (C, I)-eds if C ⊆ V (M ) and I ∩ V (M ) = ∅ hold. To search the vertex cover V (M ) of a minimum (C, I)-eds M , we will keep track of a partition of the vertices of G in four sets: C, I, U1 and U2 (initially C = I = U1 = ∅ and U2 = V ) such that I is an independent set in G, and each connected component of G[U1 ] is a component of a clique of G[V \(C ∪ I)] (In our algorithm, G[U1 ] may also contain pseudo-cliques, which are defined in Section 4 and can just be regarded as cliques). The vertices in U1 ∪ U2 are called undecided vertices. Note that G[U1 ] may not be the set of all cliques in G[V \(C ∪ I)] or U2 may contain a vertex adjacent to I so that some cliques are allowed to exist in G[U2 ] in order to get an amortized time complexity. We use a five-tuple (G, C, I, U1 , U2 ) to denote the state described above. Rooij and Bodlaender proved the following lemma in [10]: Lemma 1 Given a five-tuple (G, C, I, U1 , U2 ), if U2 = ∅, a minimum (C, I)-eds M of G can be found in polynomial time. Lemma 1 implies that we can avoid branching on clique components in the graph to reduce the size of our search tree. Initially, let U2 = V (G) and C = I = U1 = ∅. While U2 ̸= ∅, pick up a vertex v of maximum degree d′ (v) in G[U2 ] and branch on it by including it into the vertex cover or not. In the first branch, we include v into C and reduce p by 1. In the second branch, we include v into I, include N (v) into C and reduce p by |N (v)|. In each branch, if we move any newly created clique component Q in G[U2 ] into U1 , then we can reduce p by |V (Q)| − 1, since at most one vertex in any clique will not be in the vertex cover. In this case, we have a recurrence C(p) ≤ C(p − 1 − qv ) + C(p − |N (v)| − qN (v) ),

(4)

where qv (resp., qN (v) ) denotes the sum of |V (Q)| − 1 over all cliques Q in G[U2 ] generated by removing v (resp., N (v)) from U2 . A cycle (resp., path) with l edges is called an l-cycle (resp., l-path). A component H of G[U2 ] is called a clique (resp., path and cycle) component if it is a clique (resp., path and cycle) and no other vertex in U2 is adjacent to a vertex in it. In particular, when H is an l-cycle (resp., l-path) in G[U2 ], the component is called an l-cycle component (resp., l-path component). Let d′ (v) denote the degree of a vertex v ∈ U2 in G[U2 ] whereas we denote the degree of v in G by d(v). A tail is a subgraph of G[U2 ] induced by two adjacent edges v0 v1 and v1 v2 such that d′ (v0 ) = 1, d′ (v1 ) = 2 and d′ (v2 ) ≥ 2. A vertex v ∈ U2 with d′ (v) = 3 is called good if it is adjacent to two other vertices u, u′ ∈ U2 with d′ (u) = d′ (u′ ) = 1.

3

3

Branching on Graphs of Maximum Degree 2

When the remaining graph G[U2 ] has a vertex v with d′ (v) = 3, we can branch on this vertex with recurrence (3) or a better one. In this section, we show that there are four types of graphs of maximum degree 2 for which our branching requires a recurrence worse than (3). This suggests that we need to avoid creating such a ‘bad component’ in G[U2 ] even when we branch on a vertex v with d′ (v) = 3. Before we identify ‘bad components,’ we first introduce two branching rules that will be used in our algorithm.

3.1

Branching rules

Branching on tails Recall that a tail v0 v1 v2 is a path such that d′ (v0 ) = 1, d′ (v1 ) = 2 and d′ (v2 ) ≥ 2. Branching on a tail v0 v1 v2 means branching on v2 . We have qv2 = 1 since v0 v1 is a clique component in G[U2 ] after removing v2 . Since d′ (v2 ) ≥ 2, it holds |N (v2 )| ≥ 2. By (4), we can get recurrence C(p) ≤ 2C(p − 2)

(5)

or a better recurrence by branching on a tail. Branching on 4-cycles Let C4 = v0 v1 v2 v3 be a 4-cycle in G[U2 ], where possibly d′ (vi ) = 3 for some vi . It has been shown that for each 4-cycle v0 v1 v2 v3 , any vertex cover in the graph contains either {v0 , v2 } or {v1 , v3 } [13]. Branching on a 4-cycle v0 v1 v2 v3 means to generate two branches by including either {v0 , v2 } or {v1 , v3 } into C. By branching on a 4-cycle, we can also get recurrence (5) or a better one. We remark that the above branchings of a tail or a 4-cycle may create a “bad component” defined below. To avoid the bad effect from bad components, our algorithm will actually branch on tails and 4-cycles that satisfy some more conditions.

3.2

Branching on paths and cycles

When the graph G[U2 ] has maximum degree 2, our algorithm will do in this way: branch on a tail or a 4-cycle if any; otherwise branch on a vertex v with d′ (v) = 2 by including it into either C or I. Lemma 2 If there is an l-path component Pl with l < 8 in G[U2 ], we can branch with the following recurrences to remove all vertices on Pl out of U2 : C(p) ≤ C(p − 1) + C(p − 2),

for l = 2,

(6)

C(p) ≤ C(p − 2) + C(p − 2),

for l = 3,

(7)

C(p) ≤ C(p − 2) + C(p − 3),

for l = 4,

(8)

C(p) ≤ 2C(p − 3) + C(p − 4),

for l = 5,

(9)

for l = 6, and

(10)

for l = 7.

(11)

C(p) ≤ C(p − 3) + 3C(p − 4), C(p) ≤ 3C(p − 4) + C(p − 5),

4

Proof. It is easy to see that (6), (7) and (8) hold for l ≤ 4. When l = 5, we first branch on v2 . In the branch of including v2 into the vertex cover, we get a clique component p0 p1 and a 2-path p3 p4 p5 . Then we can further reduce p by at least 1 from p0 p1 and branch with (6) on p3 p4 p5 . In the other branch of excluding v2 from the vertex cover, v1 and v3 are included into the vertex cover and we get two clique component p0 and p4 p5 . Then we can further reduce p by at least 1 from p4 p5 . By putting all above together, we get (9). When l = 6, no matter v2 is included into the vertex cover or not, we can reduce p by at least 2 directly. In the first branch, we need to further branch on a 3-path, and in the second branch, we need to further branch on a 2-path. Then we will get (10). When l = 7, after branching on v2 we will further branch on a 4-path and a 3-path in the two subbranch respectively, and we will get (11). In Lemma 2, recurrence (6) solves to C(p) = O(1.6181p ), recurrence (7) solves to C(p) = O(1.4143p ), recurrence (8) is covered by (7), recurrence (9) solves to C(p) = O(1.3954p ), recurrence (10) solves to C(p) = O(1.4527p ) and recurrence (11) solves to C(p) = O(1.3888p ). Only (6) is worse than (3). We also have the following result. Lemma 3 If there is an l-path component Pl with l ≥ 8 in G[U2 ], we can always branch with a recurrence better than (3) to remove all vertices on Pl out of U2 . Proof. For a path of length l ≥ 8, we can branch on a tail with (5) and leave a component of a path of length > 2 in each branch. Then we can further branch on the remaining path with (5) or a recurrence in Lemma 2 other than (6). In each step we can branch with a recurrence better than (3). Totally, we will get a recurrence better than (3). When there is an l-cycle component Cl in G[U2 ], our algorithm will deal with the component in the following way: if l = 3, then our algorithm will simply move C3 into U1 without branching since it is a clique; if l = 4, our algorithm will branch on the 4-cycle C4 ; and if l ≥ 5, our algorithm will arbitrarily select a vertex in Cl and branch on it, and then continue to branch on the resulting path component in each subbranch. These give us the following recurrences for Cl , l ≥ 4. Lemma 4 If there is an l-cycle component Cl with l < 10 in G[U2 ], we can always branch with the following recurrences to remove all vertices on Cl out of U2 : C(p) ≤ C(p − 2) + C(p − 2), C(p) ≤ 3C(p − 3),

for l = 4,

for l = 5,

(12) (13)

C(p) ≤ 2C(p − 3) + 2C(p − 4),

for l = 6,

(14)

C(p) ≤ 4C(p − 4) + C(p − 5),

for l = 7,

(15)

for l = 8, and

(16)

for l = 9.

(17)

C(p) ≤ 2C(p − 4) + 4C(p − 5), C(p) ≤ 5C(p − 5) + 2C(p − 6),

Proof. For l = 4, (12) is exactly same as (5). For l ∈ {5, 6, 7, 8}, after branching on a vertex v in the cycle, we will get a path component in each branch. We can further branch on the path with a recurrence in Lemma 2. Straightforward calculation gives the proofs of (13), (14), (15) and (16). When l = 9, in the branch where v is included into C, we will get a 7-path and we can further branch on this path with (11); in the branch where v is included into I, we will get a 5-path and we can further branch on this path with (9). By putting all these together, we get (17). In Lemma 4, recurrence (13) solves to C(p) = O(1.4423p ), recurrence (14) solves to C(p) = O(1.4946p ), recurrence (15) solves to C(p) = O(1.4709p ), recurrence (16) solves to C(p) = O(1.4736p ) and recurrence (17) solves to C(p) = O(1.4487p ). Only (14), (15) and (16) are worse than (3). 5

Lemma 5 If there is an l-cycle component Cl with l ≥ 10 in G[U2 ], we can always branch with a recurrence better than (3) to remove all vertices on Cl out of U2 . Proof. A straightforward calculation gives the proof of the cases of l ∈ {10, 11, 12, 13, 14}. When l ≥ 15, after branch on v in the cycle, we can further branch on tails twice in each branch, leaving any resulting i-path component with i > 2 unbranched. Then we get recurrence C(p) ≤ 4C(p − 1 − 4)+4C(p−2−4) = 4C(p−5)+4C(p−6), which is better than (3). For each of the remaining i-path component with i > 2, we can also branch on it with a recurrence better than (3). By putting them together, we will also get a recurrence better than (3). We call a 2-path component or an l-cycle component with l ∈ {6, 7, 8} a bad component. If we guarantee that after each branching operation no bad component is created in G[U2 ], then we can get the claimed improvement. Note that no bad component is newly created by any of the branching operations stated in Lemma 2, Lemma 3, Lemma 4 and Lemma 5. In fact, we will show that for many cases a clique component is also created in G[U2 ] whenever a bad component is created in G[U2 ]. We call such a clique component the saving clique of the bad component, and keep the saving clique until we branch on the bad component, where p is further reduced by 1 by moving the saving clique out U2 . This is the main idea of our algorithm. There are a finite number of local structures branching on which may generate bad components in a graph with degree bounded by 3. We will design different branching rules to deal with those local structures. Note that among the recurrences for all bad components, the recurrence (6) for 2-path components is the worst one in the sense that it holds max{2C(p−3)+2C(p−4), 4C(p−4)+C(p−5), 2C(p−4)+4C(p−5)} ≤ C(p−1)+C(p−2). To simplify the argument on analysis, sometimes when a bad component is created, we simply assume that it is a 2-path component to get the worst recurrence by branching on it with (6). Before presenting our algorithm, we introduce some techniques first.

4

Some Techniques

We introduce a new concept: ‘pseudo-clique.’ In our algorithm, we move a clique component from U2 to U1 without branching. A pseudo-clique is a connected graph similar to a clique. We can also move a pseudo-clique to U1 directly. Let Q be a connected graph in G[U2 ]. If there is a minimum (C, I)-eds M ′ such that for any connected component Qi in G[U1 ], |V (QI ) − V (M ′ )| ≤ 1, and also |V (Q) − V (M ′ )| ≤ 1, we call Q a pseudo-clique (by definition Q may depend on the current graph G[C ∪ U1 ]). Roughly speaking, a pseudo-clique has at most one vertex not in the vertex cover V (M ′ ) if such a solution M ′ exists. Any clique is always a pseudo-clique independently of the graph G[C ∪ U1 ]. We give an example of pseudo-clique: a 2-path component v0 v1 v2 in G[U2 ] is a pseudoclique if v1 has no neighbor in C (possibly it has a neighbor in I). It is easy to see that the sub algorithm in [10] to deal with clique components can also deal with with pseudo-cliques. Therefore, we can simply move pseudo-cliques into U1 . However, it is not easy to check pseudo-cliques in G[U2 ]. In this paper, we just consider pseudo-cliques of size 3. Sometimes it is easy to check if a 2-path component is a pseudo-clique or not in degree-3 graphs. This is a reason why we can attain the improvement for the problem in degree-3 graphs. The above example is a case of 2-path component v0 v1 v2 in G[U2 ] being a pseudo-clique (v1 has no neighbor in C). Another case is that v1 is adjacent to an edge uv known to be in the solution M ′ . Note that if v1 v is also in the solution M ′ (assume v1 is adjacent to v), then we can replace v1 v with v1 v2 in M ′ to get another solution of the same size. Otherwise, always at least two vertices of {v0 , v1 , v2 } will be in V (M ′ ). We know that v0 v1 v2 will be a pseudo-clique. Note that in the algorithm, we do not need to identify all pseudo-cliques of size 3 in G[U2 ]. We may also use the technique of amortized transfer of cliques. In some operation which generates cliques, we usually move all the generated cliques into U1 immediately. However, the recurrence 6

in the operation may still be good enough for our analysis if we do not include some clique uv into U1 in this step (we may reduce p less than 1 in some later branch). We keep the clique uv as the saving clique of any bad components created in this operation without including it into U1 . In the next step, we branch on the bad components after moving the saving clique uv into U1 . In our algorithm, when we save a clique at most two bad components will be created. By branching on the two bad components, we can get recurrence C(p) ≤ C(p − 2) + 2C(p − 3) + C(p − 4) or a better one. Since we can also reduce p by 1 by moving the saving clique uv into U1 . Then we can get recurrence C(p) ≤ C(p − 3) + 2C(p − 4) + C(p − 5) at least, which is better than (3).

5

The Algorithm

We call a cycle C in the graph G[U2 ] a leaf cycle if it contains exactly one vertex v ∈ V (C) with d′ (v) = 3. When we denote a leaf l-cycle by Cl = v0 v1 v2 · · · vl−1 , we always assume that d′ (v0 ) = 3 and u is the third neighbor of v0 . In our algorithm, we will first deal with leaf l-cycles with l ∈ {6, 7, 8}. When the graph G[U2 ] has no such kind of leaf l-cycles, we may use some techniques to avoid creating l-cycle components with l ∈ {6, 7, 8} in our algorithm. Then we only need to deal with 2-path components. For two integers x, y ≥ 0, a vertex v is called an (x, y) vertex, if removing v from G[U2 ] creates exactly x 2-path components, leaving no l-cycle component with l ∈ {6, 7, 8}, whereas removing N (v) creates exactly y 2-path components, again leaving no l-cycle component with l ∈ {6, 7, 8}. We assume that initially there is no bad component in G[U2 ], since an arbitrary edge from each bad component in a given graph G with C = I = ∅ can be directly included in a minimum (C, I)-eds M without branching, leaving no bad component in G[U2 ]. In our algorithm, we will effectively avoid creating bad components by saving cliques of size 2 for any newly created bad components in each step. The main steps of our algorithm are listed in Fig. 1. Note that any component of maximum degree 2 in G[U2 ] will be applied one of Steps 7-9. In the subsequent sections, we show that in each step, there is a branching rule such that its recurrence is not worse than (3) and no bad component is newly created. By definition, branching on a (0,0) vertex v with d′ (v) = 3 in Step 5 does not create a bad component and its recurrence is given by (3). Hence we shall investigate Steps 3-9.

5.1

Dealing with leaf 6-cycles in Step 3

Assume that the algorithm will branch on a leaf 6-cycle v0 v1 v2 v3 v4 v5 in G[U2 ] in Step 3. We assume that d′ (v0 ) = 3 and u is the third neighbor of v0 . It is easy to observe that either removing v0 or removing {v0 , u} can avoid creating a bad component. We distinguish the following two cases based on the observation. Case 1. No bad component is created after removing v0 from G[U2 ]: We branch in the following way. First, we branch on v3 by including it into either C or I (also including {v2 , v4 } into C in the second branch). Then in the first branch we further branch on v0 by including it into either C or I. We will get three subbranches. In the first subbranch, we include {v3 , v0 } into C, move {v1 , v2 , v4 , v5 } into U1 , and reduce p by 4, creating no bad component by the assumption. In the second subbranch, we include only {v3 , u, v5 } into C, include v0 into I, move only v4 into U1 (leaving {v1 , v2 } in U2 ), and reduce p by 3, keeping {v1 , v2 } as the saving cliques for any bad components newly created by removing {v0 , u}. In the third subbranch, we include {v2 , v4 } into C, include v3 into I and reduce p by 2, creating no bad component. Then we get the following recurrence C(p) ≤ C(p − 2) + C(p − 3) + C(p − 4),

(18)

which solves to O(1.4656p ). In the second subbranch, we keep a saving clique v1 v2 for the new bad components. Then in the next step we will directly include v1 into C and move v2 into U1 (note that v1 is adjacent to a vertex in I and we directly include v1 into C) and branch on the bad 7

Algorithm P EDS3(G, C, I, U1 , U2 , p) Input: A degree-3 graph G = (V, E), sets C, I, U1 and U2 partitioning V (initially C = I = U1 = ∅, U2 = V ), and an integer p (initially p = 2k). Output: A (C, I)-eds of size ≤ k in G if it exists. 1. While there is a clique component Q in G[U2 ], do move it into U1 and reduce p by |Q| − 1. 2. If p < 0, halt. 3. If there is a leaf 6-cycle or 7-cycle in G[U2 ], use the branching rules in Section 5.1 and Section 5.2 to branch on it. 4. Elseif there is a leaf 8-cycle in G[U2 ], we use the branching rules in Section 5.3 to branch on it. 5. Elseif there is a (0, 0) degree-3 vertex v in G[U2 ], branch on it. 6. Elseif there is a (3, 0) degree-3 vertex v in G[U2 ], use the branching rules in Section 5.4 to branch on it. 7. Elseif there is a good vertex or a tail in G[U2 ], use the branching rules in Section 5.5 to branch on it. 8. Elseif there is a 4-cycle v0 v1 v2 v3 in G[U2 ] such that at least one vertex in the cycle is a degree-2 vertex, branch on the 4-cycle. 9. Elseif the graph G[U2 ] is not an empty graph, use the branching rules in Section 5.7 to branch on a vertex v of maximum degree in G[U2 ]. 10. Compute a minimum (C, I)-eds M by Lemma 1 (here: U2 = ∅, C ∪ I ∪ U1 = V ) and return M .

Figure 1: Algorithm P EDS3(G, C, I, U1 , U2 , p) components created. Since d′ (u) ≤ 3, at most two bad components can be created in the second subbranch. By branching on these bad components, say 2-path components, we can get recurrence C(p) ≤ C(p − 2) + 2C(p − 3) + C(p − 4) (if l-cycle components with l ∈ {6, 7, 8} are created, we will get a better recurrence). Consider that we can also reduce p by 1 from the saving clique v1 v2 . Then we can get C(p) ≤ C(p − 3) + 2C(p − 4) + C(p − 5) at least to deal with all bad components created in this subbranch. This recurrence solves to C(p) = O(1.4253p ), which is better than (3). Therefore, when there is a saving clique, we can branch on all bad components in G[U2 ] with a recurrence better than (3). Case 2. No bad component is created after removing {v0 , u} from G[U2 ]: First, we branch on v3 by including it into either C or I (also including {v2 , v4 } into C in the second branch). Then in the first branch we further branch on v0 by including it into either C or I. We will get three subbranches. In the first subbranch, we include {v0 , v3 } into C, move only {v4 , v5 } into U1 , and reduce p by 3, keeping v1 v2 as the saving clique for any bad components newly created by removing v0 . In the second subbranch, we include {v3 , v1 , v5 , u} into C, include v0 into I, move {v2 , v4 } into U1 and reduce p by 4, where no bad component is created by the assumption. In the third subbranch, we include {v2 , v4 } into C, include v3 into I and reduce p by 2, creating no bad component. Analogously 8

with Case 1, we can branch on the new bad components with their saving clique, and we also get (18) without leaving any bad component in G[U2 ]. Lemma 6 If there is a leaf 6-cycle in G[U2 ], Algorithm P EDS3 can always branch with (18) or a better recurrence on it without creating any bad component in each branch.

5.2

Dealing with leaf 7-cycles in Step 3

Assume that the algorithm will branch on a leaf 7-cycle v0 v1 v2 v3 v4 v5 v6 in Step 3. We also let d′ (v0 ) = 3 and u be the third neighbor of v0 . It is easy to verify that either removing v0 or removing {v0 , u} can avoid creating a bad component. We distinguish the following two cases. Case 1. No bad component is created after removing v0 from G[U2 ]: First, we branch on v3 by including it into either C or I. Then in the first branch we further branch on v6 by including it into either C or I. We will get three subbranches, each of which creates no bad component. In the first subbranch, we include {v3 , v6 } into C, move {v4 , v5 } into U1 and reduce p by 3. In the second subbranch, we include {v3 , v5 , v0 } into C, include v6 into I, move {v1 , v2 , v4 } into U1 and reduce p by 4. In the third subbranch, we include {v2 , v4 } into C, include v3 into I and reduce p by 2. Finally, we will get (18). Case 2. No bad component is created after removing {v0 , u} from G[U2 ]: We branch on v0 by including it into either C or I with (3). In the first branch, we will get a 5-path component and possibly one bad component containing u. The worst case is that the bad component is a 2path. We will further branch on the two components with (9) and (6) at least and get a recurrence C(p′ ) ≤ 2C(p′ −3−1)+C(p′ −4−1)+2C(p′ −3−2)+C(p′ −4−2) = 2C(p′ −4)+3C(p′ −5)+C(p′ −6) for p′ = p−1 in this branch. In the second branch of including v0 into I, we will get a 3-path component but no bad component by the assumption. We will further branch on it with C(p′′ ) ≤ 2C(p′′ − 2) for p′′ = p − 3. By putting all these together, we get C(p) ≤ 2C(p − 1 − 4) + 3C(p − 1 − 5) + C(p − 1 − 6) + 2C(p − 3 − 2) = 4C(p − 5) + 3C(p − 6) + C(p − 7), which solves to O(1.4556p ). Lemma 7 If there is a leaf 7-cycle in G[U2 ], Algorithm P EDS3 can always branch with (18) or a better recurrence on it without creating any bad component in each branch.

5.3

Dealing with leaf 8-cycles in Step 4

After Step 3, there is neither a leaf 6-cycle nor a leaf 7-cycle in G[U2 ]. Assume that the algorithm will branch on a leaf 8-cycle v0 v1 v2 v3 v4 v5 v6 v7 in G[U2 ] in Step 4. We assume that d′ (v0 ) = 3 and u is the third neighbor of v0 . We still distinguish two cases. Case 1. No bad component is created after removing v0 from G[U2 ]: We branch in the following way. First, we branch on v1 by including it into either C or I with recurrence C(p) ≤ C(p − 1) + C(p − 2). In the first branch we will get a tail v2 v3 v4 and further branch on v4 with (5). In the second branch we get a 4-path component and further branch on it with (8). Totally, we get four branches, each of which will create no bad components. Then we get the following recurrence C(p) ≤ 2C(p − 3) + C(p − 4) + C(p − 5),

(19)

which solves to O(1.4656p ). Case 2. A bad component is created after removing v0 from G[U2 ]: Then there are only three possible configurations for the component H containing v0 , as shown in Fig. 2. (a) d′ (u) = 2 for the third neighbor u of v0 in H, as in Fig. 2(a): We branch on v0 by including it into either C or I and further branch on the 2-path component created in the first branch. Note that in the branch of including v0 into I, we reduce p by 4. Then we will get recurrence C(p) ≤ C(p − 1 − 1) + C(p − 1 − 2) + C(p − 4), which is same as (18), without leaving any bad component in each branch. 9

(a)

(b)

(c)

Figure 2: Components H containing a leaf 8-cycle of Case 2 in Step 4 (b) Vertex u is adjacent to vertices u1 and u2 with d′ (u1 ) = d′ (u2 ) = 1 in H, as in Fig. 2(b): Then u is a good vertex. We here show a “good branching rule” to deal with it. Note that if u1 u or u2 u is in a (C, I)-eds M , we can replace the edge with edge v0 u to get another (C, I)-eds of the same size. If none of edges u1 u, u2 u and v0 u is in the (C, I)-eds, then u is in I and {u1 , u2 , v0 } are in C. Then we can generate the following two branches. In the first branch, we include N (u) into C, include u into I and reduce p by 3. In the second branch, we include {v0 , u} into C and reduce p by 2. Then we get recurrence C(p) ≤ C(p − 2) + C(p − 3) without leaving any bad component in each branch. (c) Vertex u is also in a leaf 8-cycle in H, as in Fig. 2(c): We first branch on v0 by including it into either C or I. In the first branch, we reduce p by 1 and further branch on the created 8-cycle component with (16). In the second branch, we reduce p by 3 and get a 4-path component v2 v3 v4 v5 v6 . We further branch on the 4-path component with (8). Totally we will get recurrence C(p) ≤ 3C(p − 5) + 5C(p − 6), which solves to C(p) = O(1.4516p ). Lemma 8 If there is a leaf 8-cycle in G[U2 ], Algorithm P EDS3 can always branch with (18) or a better recurrence in Step 4 without creating any bad component in each branch.

5.4

Dealing with (3, 0) vertices in Step 5

Let v be the (3, 0) vertex in G[U2 ] selected by the algorithm in Step 6. It is easy to verify that the component H containing v has exactly 10 vertices. There are only four possible configurations for the component H, which are shown in Fig. 3. For each configuration, we have a different branching rule. Let M be a minimum (C, I)-eds for the current partition (C, I, U1 , U2 ). Case 1. d′ (a) = 3 for all neighbors a of v in H, as in Fig. 3(a): We generate four branches: v ̸∈ V (M ); va1 ∈ M ; va2 ∈ M ; and va3 ∈ M . In the first branch, we include v into I, include N (v) into C and move the remaining 6 vertices into U1 . Note that each ci ai bi , i ∈ {1, 2, 3} becomes a pseudo-clique when v is included into I before including N (v) into C. Then we can reduce p by at least 2 from each ci ai bi before including N (v) into C. Totally, we reduce p by 6 in this branch. In the second branch, we include {v, a1 } into C and move the remaining 8 vertices into U1 . Note that here a2 b2 c2 and a3 b3 c3 are both two pseudo-cliques since va1 ∈ M and va2 , va3 ̸∈ M can be assumed. We will reduce p by 4 from these two pseudo-cliques. In total we reduce p by 6 in this branch. In the third and fourth branches, we do in the same way as in the second branch. Then we can get recurrence C(p) ≤ 4C(p − 6), 10

(20)

Figure 3: Components H containing a (3, 0) vertex v in Step 6 which solves to C(p) = O(1.2600p ). Case 2. d′ (a2 ) = d′ (a3 ) = 3 for exactly two neighbors a2 and a3 of v in H, as in Fig. 3(b): We also generate four branches as we do in the same manner with the case of Fig. 3(a). In the first branch, we include v into I, include N (v) into C and move the remaining 6 vertices into U1 . Note that when v is included into I, each ci ai bi , i ∈ {2, 3} becomes a pseudo-clique and a1 b1 c1 also becomes a pseudo-clique (a1 is required to be in C since it is a neighbor of v and at least one of b1 and c1 should be in C). Then we can reduce p by at least 2 from each ci ai bi before including {a1 , a2 , a3 } into C. Totally, we reduce p by 6 in this branch. In the second branch, we include {v, a1 } into C and move the remaining 8 vertices into U1 . Note that c1 b1 is a clique, and a2 b2 c2 and a3 b3 c3 are two pseudo-cliques in the resulting graph. We will reduce p by 5 from these pseudo-cliques. Totally, we reduce p by 7 in this branch. In the third branch, we move pseudo-clique c3 a3 b3 into U1 and branch on the 2-path component. Therefore, we will get two subbranches by reducing p by either 5 or 6. The fourth branch is the same case as the third branch. Then we get recurrence C(p) ≤ 2C(p − 5) + 3C(p − 6) + C(p − 7),

(21)

which solves to C(p) = O(1.3648p ). Case 3. d′ (a) = 3 for at most one neighbor a of v in H, as in Fig. 3(c) and (d): We use a similar branching rule for the two configurations. The difference between them is only the amount of p being reduced. We first analyze the case where exactly one neighbor a3 of v is of degree 3 in H in Fig. 3(c). We generate four branches: include {b1 , b2 } into C; include b1 into C and b2 into I; include b1 into I and b2 into C; and include {b1 , b2 } into I. In the first branch, we further generate two subbranch by including v into either C or I. In the first subbranch, v ∈ V (M ) implies vai ∈ M , where we can assume that va3 ∈ M , since if vai (i ∈ {1, 2}) is in M we can replace it with edge va3 to obtain another (C, I)-eds with the same size. Hence we include {b1 , b2 , v, a3 } into C, move the remaining vertices into U1 , and reduce p by 4. In the second subbranch, we include {b1 , b2 , a1 , a2 , a3 } into C, include v into I, move the remaining vertices {b3 , c3 , c1 , c2 } into U1 , and reduce p by 6 (note that v is not in V (M ) and a3 is in V (M ), and then at least one of a3 b3 and a3 c3 is in M . Therefore we can reduce p by 1 from {b3 , c3 }. We can reduce p by 5 from {b1 , b2 , a1 , a2 , a3 } directly). In the second branch, we further generate two subbranches by including a3 into either C or I. In the first subbranch, we include {b1 , a2 , c2 , a3 } into C, include b2 into I, move the remaining vertices into U1 , and reduce p by 5 (4 from {b1 , a2 , c2 , a3 } and 1 from va1 ). In the second subbranch, 11

we include {b1 , a2 , c2 } ∪ N (a3 ) into C, include {b2 , a3 } into I, move the remaining vertices {c1 , a1 } into U1 , and reduce p by 6. The third branch is the same as the second branch. For the fourth branch, we also further branch into two subbranches by including a3 into either C or I. In the first subbranch, we include {a1 , c1 , a2 , c2 , a3 } into C, include {b1 , b2 } into I, move the remaining vertices into U1 , and reduce p by 6 (note that all the neighbors of a3 are not in C and a3 is in C. Any (C, I)-eds M needs to contain at least one neighbor of a3 , and this decreases p further by 1). In the second subbranch, we include {a1 , c1 , a2 , c2 } ∪ N (a3 ) into C, include {b1 , b2 , a3 } into I, and reduce p by 7. Therefore, we can get recurrence C(p) ≤ C(p − 4) + 3C(p − 5) + 3C(p − 6) + C(p − 7),

(22)

which solves to C(p) = O(1.4615p ). For the last case where d′ (a) = 2 for all neighbors a of v in H in Fig. 3(d), we have the following result. In the first branch, we reduce p by 2 from {b1 , b2 } and further generate two subbranches by reducing p by either 4 or 3 (2 from {v, a3 } and 1 from b3 c3 ). In the second and third branches, we reduce p by 3 and further generate two subbranches by reducing p by either 2 or 3. In the fourth branch, we reduce p by 4 and further generate two subbranches by reducing p by 2 respectively. Then we get recurrence C(p) ≤ 3C(p − 5) + 5C(p − 6),

(23)

which solves to C(p) = O(1.4516p ). Lemma 9 In Step 6, Algorithm P EDS3 can always branch with (22) or a better recurrence to deal with a (3, 0) degree-3 vertex without creating any bad component in each branch.

5.5

Branching rules in Step 7

In Step 7, there is neither (0, 0) nor (3, 0) degree-3 vertex in G[U2 ]. First consider the case where there is a good vertex v in G[U2 ]. Let u1 and u2 be the two neighbors of v with d′ (u1 ) = d′ (u2 ) = 1, and u3 be the third neighbor of v in G[U2 ]. If there is a good vertex v in G[U2 ], then we apply the good branching rule introduced in Section 5.2. Thus we branch by including either {v, u3 } or {u1 , u2 , u3 } into C. Note that in each branch, it is impossible to create two bad components, since otherwise G[U2 ] would have a (3, 0) vertex v or a leaf l-cycle component with l ∈ {6, 7, 8}. Then in each branch we get recurrence C(p′ ) ≤ C(p′ − 1) + C(p′ − 2) (p′ ∈ {p − 2, p − 3}) at least to deal with all bad components created. Together, we will get recurrence C(p) ≤ C(p − 3) + 2C(p − 4) + C(p − 5),

(24)

which solves to C(p) = O(1.4253p ). Next consider the case where there is a tail v0 v1 v2 but no good vertex in G[U2 ]. We will branch on v2 by including it into either C or I. We will show that the total number of bad components created in the two branches is at most two. Let H be the component in G[U2 ] containing v2 . It is impossible to create more than two bad components after removing v2 from H. We consider the following three cases. Case 1. Removing v2 creates two bad components: Note that no leaf l-cycle component with l ∈ {6, 7, 8} will be created. The two bad components can only be 2-paths. Then it is impossible to create any bad component after removing N (v2 ). By branching on v2 we will get two branches, in the first branch we further branch on the two bad components with C(p′ ) ≤ C(p′ − 2) + 2C(p′ − 3) + C(p′ − 4), where p′ = p − 2. In the second branch we reduce p by 3 without leaving any bad component. Then we get recurrence C(p) ≤ C(p − 2 − 2) + 2C(p − 2 − 3) + C(p − 2 − 4) + C(p − 3) = C(p − 3) + C(p − 4) + 2C(p − 5) + C(p − 6), which solves to C(p) = O(1.4409p ). 12

Case 2. Removing v2 creates one bad component: If d′ (v2 ) = 2, then the created bad component can only be a 2-path component, since there were no leaf l-cycle components with l ∈ {6, 7, 8}. Recall that there is no good vertex in G[U2 ]. Then H can only be a 5-path component, which is analyzed in Section 3. If d′ (v2 ) = 3, we will show that at most one bad component can be created after removing N (v2 ). Note that any bad component created by the branch of removing N (v2 ) will share vertices with the bad component created by the branch of removing v2 . Hence if two bad components are created after removing N (v2 ), then v2 needs to be adjacent to two vertices in an 8-cycle C in G[U2 ] before removing N (v2 ). It is easy to see that any vertex with degree d′ = 3 in the 8-cycle is a (0, 0) degree-3 vertex, which must have been eliminated in Step 5. Therefore, there is at most one bad component created after removing N (v2 ). In Case 2, we can always branch with (24) at least without leaving any bad components in any branch. Case 3. Removing v2 creates no bad component: If at most two bad components can be created after removing N (v2 ) from H, then we branch on v2 and further branch on the two bad components with C(p′ ) ≤ C(p′ − 2) + 2C(p′ − 3) + C(p′ − 4), where p′ = p − 3, at least in the second branch. Then we will get C(p) ≤ C(p − 2) + C(p − 3 − 2) + 2C(p − 3 − 3) + C(p − 3 − 4) = C(p − 2) + C(p − 5) + 2C(p − 6) + C(p − 7), which solves to C(p) = O(1.4197p ). Next assume that at least three bad components are created after removing N (v2 ) from H. We will show that H contains a tail v0′ v1′ v2′ such that removing v2′ from H creates no bad component whereas removing N (v2′ ) from H creates at most two bad components from H. Since more than two bad components are created after removing v2 , we know that d′ (v2 ) = 3. There is one bad component that is adjacent to only one neighbor of v2 . This bad component can only be a 2-path component, otherwise there would be a leaf l-cycle component with l ∈ {6, 7, 8}. Since there is no good vertex, we can assume that the 2-path component is given by v0′ v1′ v2′ and only v2′ is adjacent to a neighbor of v2 in H. Then v0′ v1′ v2′ is a tail in H such that no bad component is created after removing v2′ from H while at most two bad components can be created after removing N (v2′ ) from H, as claimed. Now we switch to branching on v2′ instead of v2 . Then we will get the above recurrence. Lemma 10 In Step 7, Algorithm P EDS3 can always branch with (18) or a better recurrence without creating any bad component in each branch.

5.6

Branching rules in Step 8

Let H be the component of G[U2 ] containing a 4-cycle v0 v1 v2 v3 selected by Step 8, where we assume d′ (v0 ) = 2. The algorithm will branch on v0 v1 v2 v3 by including either {v0 , v2 } or {v1 , v3 } into C. No bad component will be created after removing {v0 , v2 } from H, since in this step there is none of a good vertex, a tail and a leaf l-cycle component with l ∈ {6, 7, 8}. Also it is impossible to create more than one bad component after removing {v1 , v3 } from H. Then in this step, we can always branch with C(p) ≤ C(p − 2) + C(p − 2 − 1) + C(p − 2 − 2) = C(p − 2) + C(p − 3) + C(p − 4), which is (18), without creating any bad components in each branch. Lemma 11 In Step 8, Algorithm P EDS3 can always branch with (18) or a better recurrence without creating any bad component in each branch.

5.7

Branching rules in Step 9

We call a vertex v ∈ U2 with d′ (v) = 3 a demand vertex, if no l-cycle component with l ∈ {6, 7, 8} is created after removing any of v and N (v) from G[U2 ]. We show the following lemmas. Lemma 12 Let H be a connected component in G[U2 ] such that H has at least one vertex with degree d′ = 3, but contains no leaf l-cycle with l ∈ {6, 7, 8}. If there is no demand vertex in H, then the only possible configuration of H is given by the graph in Fig. 4. 13

Figure 4: A component H satisfying the condition in Lemma 12 Proof. Assume that H contains no demand vertex. Then for any vertex u with d′ (u) = 3 in H, an l-cycle component with l ∈ {6, 7, 8} will be created after removing one of u and N (u) from H. If there is a vertex v ∈ V (H) such that an l-cycle component C with l ∈ {6, 7, 8} is created after removing v, we will show that there also exists a demand vertex. It is easy to see that v is adjacent to at least two vertices in the cycle C, otherwise the cycle C would be a leaf cycle in H. Note that any vertex with degree d′ = 3 in the cycle is also adjacent to v. The number of vertices with degree d′ = 3 in the cycle is at most 3. Then C contains a vertex u with d′ (u) = 3 that is adjacent to any vertex in C with degree d′ = 2. After removing u, the three neighbors of u are still in the same component and one of them has degree d′ = 1. Therefore, no l-cycle component with l ∈ {6, 7, 8} can be created. After removing N (u), no l-cycle component with l ∈ {6, 7, 8} can be created either, since there is no leaf l-cycle with l ∈ {6, 7, 8} in H. Therefore, u is a demand vertex, a contradiction. Now we know that for each vertex u ∈ V (H) with d′ (u) = 3, an l-cycle component C with l ∈ {6, 7, 8} will be created after removing N (u) (while no l-cycle component C with l ∈ {6, 7, 8} will be created after removing u). We pick a vertex v ∈ V (H) with d′ (u) = 3, and assume that after removing N (v) an l-cycle component C with l ∈ {6, 7, 8} is created. Let v1 be a neighbor of v adjacent to at least a vertex in C. It is easy to see that no l-cycle component with l ∈ {6, 7, 8} can be created after removing N (v1 ). Then d′ (v1 ) = 2 in H. Therefore, for any neighbor of v, if it is adjacent to a vertex in C, then it has degree d′ = 2 in H. We know that there are at most three vertices with degree d′ = 3 in C. Now we look at a vertex u with d′ (u) = 3 in C. After removing N (u) from H, the remaining vertices in C are still connected, which will be in an l-cycle component C ′ with l ∈ {6, 7, 8} if such a component exists. Then after removing N (u) none of the remaining vertices in C can have degree d′ = 1. Therefore, in C no pair of vertices with degree d′ = 2 are adjacent to each other and then C can only be a 6-cycle. In this case, H can take only the configuration shown in Fig. 4. Lemma 13 In Step 9, any demand vertex in G[U2 ] is a (1, 0), (0, 1) or (0, 2) degree-3 vertex. Proof. Recall that in Step 9, every component in G[U2 ] contains none of a (0, 0) vertex, a (3, 0) vertex, a good vertex, a tail and a leaf l-cycle with l ∈ {6, 7, 8}. Let v be a demand vertex in G[U2 ]. If v is a (2, i) vertex in G[U2 ] (i ≥ 0), then G[U2 ] contains one of a tail, a good vertex and a leaf l-cycle with l ∈ {6, 7, 8}. If v is a (1, i) vertex in G[U2 ] (i ≥ 1), then the 2-path component created after removing N (v) was adjacent to exactly one neighbor of v, which implies that there would be a tail or a good vertex in G[U2 ], a contradiction. If v is a (0, 3) vertex in G[U2 ], we can see that the component containing v consists of exactly 13 vertices and every neighbor of v is a (0, 0) degree-3 vertex. If v is a (0, i) vertex in G[U2 ] (i ≥ 4), then there would be a tail or a good vertex in G[U2 ]. All of the above cases are impossible. Then the lemma holds. 14

In Step 9, we will select a vertex v of maximum degree d′ to branch on. Let H denote the component of G[U2 ] containing v. Lemma 12 and Lemma 13 guarantee that we only need to consider the following five cases to analyze the running time. Case 1. Vertex v is a vertex in component H as shown in Fig. 4: First we branch on v with (3). In the branch of removing N (v), we further branch on the 6-cycle component u0 u1 u2 u3 u4 u5 with (14). In the branch of removing v, we branch on u0 with (3), and in the subbranch of removing N (u0 ), we further branch on the 4-path component v1 u4 u3 u2 v3 with (8). By putting all these together we get recurrence C(p) ≤ 2C(p − 3 − 3) + 2C(p − 3 − 4) + C(p − 1 − 1) + C(p − 1 − 5) + C(p − 1 − 6) = 3C(p − 7) + 3C(p − 6) + C(p − 2), which solves to C(p) = O(1.4192p ). Note that in the subbranch where both v and u0 are included into C, we do not branch on the resulting graph, which is not a bad component. Case 2. Vertex v is a (1, 0) degree-3 vertex in H: Let abc be the 2-path component created after removing v. There are three possible configurations for the component H containing v, which are shown in Fig. 5. The component H in Fig. 5(b) and (c) contains a 4-cycle with at least one vertex of degree d′ = 2 vertex in it, which must have been eliminated in Step 8. We only need to consider the component H in Fig. 5(a). In this case, we claim that there is a minimum (C, I)-eds M such that v is in V (M ). If v is not in V (M ), then b must be in V (M ) and one of edges ab and bc incident to b must be in M . We can replace this edge with edge vb to obtain another (C, I)-eds with the same size, as claimed. Then we simply include v into C and reduce p by 1. Note that after removing v, at most two bad components can be created. Vertex v can be regarded as the save vertex for the bad components. By considering them together, we will get a recurrence better than (3).

Figure 5: Components H containing a (1, 0) degree-3 vertex v of Case 1 in Step 9 Case 3. Vertex v is a (0, 1) degree-3 vertex in H: Let u1 , u2 and u3 be the three neighbors of v, and abc be the 2-path component created after removing N (v). If a neighbor u of v is adjacent to two vertices in {a, b, c}, then u is a (0, 0) or (1, 0) vertex. We will branch on u. Otherwise there are three configurations for the component H, which are shown in Fig. 6. Note that in Fig. 6, vertices u1 , u2 and u3 are possibly vertices of degree d′ = 3. (a) Each of a, b and c has degree d′ = 2 in H as in Fig. 6(a): At least one of u2 and u3 has degree d′ = 3 in H, otherwise there would exist a leaf 6-cycle. If both of u2 and u3 have degree d′ = 3 in H, then u2 or u3 is a (0, 0) vertex. Then exactly one of u2 and u3 , say u2 , has degree d′ = 3 in H. We first branch on v with C(p) ≤ C(p − 1) + C(p − 3). In the second branch, we further branch on 2-path component abc with C(p′ ) ≤ C(p′ − 1) + C(p′ − 2) for p′ = p − 3. In the first branch, we will get a tail u3 cb. If the tail is in a path component of length 5 or 6, we will further branch on this path component with C(p′′ ) ≤ 2C(p′′ − 3) + C(p′′ − 4) or C(p′′ ) ≤ C(p′′ − 3) + 2C(p′′ − 4) + C(p′′ − 5) for p′′ = p − 1, without creating any bad component. Together, we will get recurrence C(p) ≤ 3C(p − 4) + 2C(p − 5) or C(p) ≤ 2C(p − 4) + 3(p − 5) + C(p − 6), each of which is better than (3). If the tail is not in any path component of length 5 or 6, then we can branch on b with C(p′′ ) ≤ 2C(p′′ −2) for p′′ = p−1, without creating any bad component. Together, 15

Figure 6: Components H containing a (0, 1) degree-3 vertex v of Case 2 in Step 9 we will get recurrence C(p) ≤ 2C(p − 3) + C(p − 4) + C(p − 5), which solves to C(p) = O(1.4656p ). (b) One of a and c has degree d′ = 1 in H as in Fig. 6(b): If one of u2 and u3 has degree d′ = 3, then b is a (0, 0) vertex, which must have been eliminated before. Then both of u2 and u3 have degree d′ = 2. We first branch on v with C(p) ≤ C(p − 1) + C(p − 3). In the first branch, we further on b with C(p′ ) ≤ C(p′ − 2) + C(p′ − 3) for p′ = p − 1, without creating any bad component. In the second branch, we further branch on 2-path component abc with C(p′′ ) ≤ C(p′′ − 1) + C(p′′ − 2) for p′′ = p − 3. Together, we will get recurrence C(p) ≤ C(p − 3) + 2C(p − 4) + C(p − 5). (c) Vertex b has degree d′ = 3 and each of a and c has degree d′ = 2 in H as in Fig. 6(c): All of u1 , u2 and u3 have degree d′ = 2 in H, since otherwise one of them would be a (0, 0) degree-3 vertex. Then H contains exactly 7 vertices. We will first branch on v with C(p) ≤ C(p − 1) + C(p − 3). In the first branch, we will further branch on b with C(p′ ) ≤ 2C(p′ − 3) for p′ = p − 1. In the second branch, we further branch on 2-path component abc with C(p′′ ) ≤ C(p′′ − 1) + C(p′′ − 2) for p′′ = p − 3. Then we will get recurrence C(p) ≤ 3C(p − 4) + C(p − 5). All of the above recurrences are not worse than (3). Case 4. Vertex v is a (0, 2) degree-3 vertex in H (to simplify the analysis we also assume that neither of (0, 1) and (1, 0) degree-3 vertices exists, and then all vertices with d′ = 3 in H are (0, 2) degree-3 vertices): We will show that there is only one possible configuration, as shown in Fig. 7, for the component H that all degree-3 vertices in it are (0, 2) degree-3 vertices. Let a, b and c be the three neighbors of v, and u0 u1 u2 and w0 w1 w2 be the two 2-path components created after removing N (v). Since there exists none of a good vertex, a tail and a (1, 0) vertex, there is a neighbor of v, say b, that is adjacent to both vertices in u0 u1 u2 and w0 w1 w2 . If b is adjacent to u1 (or w1 ), then it is easy to see that u1 (or w1 ) is a (0, 0) degree-3 vertex. Then we can assume that b is adjacent to u2 and w0 . Thereby b is also a (0, 2) degree-3 vertex. In this case, a and c are in two different 2-path components created after removing N (b). The only possible configuration for H is shown in Fig. 7, which contains exactly 9 vertices. We generate three branches for a (C, I)-eds M : v ∈ V (M ); v ̸∈ V (M ) and bu2 ∈ M ; and v ̸∈ V (M ) and bw0 ∈ M (note that one of bu2 and bw0 incident to b needs to be included in M if v ̸∈ V (M )). In the first branch, we include v into C and reduce p by 1, and can further branch on a tail with (5) without creating any bad component. Then we can branch with C(p′ ) ≤ 2C(p′ − 2) for p′ = p − 1 in this branch. In the second branch, we include {a, c, b, u2 } into C, move {u0 , u1 } into U1 , reduce p by 5 and further branch on 2-path w0 w1 w2 with (2). Then we will get recurrence C(p′′ ) ≤ C(p′′ − 1) + C(p′′ − 2) for p′′ = p − 5. In the third branch, we do in a similar manner with the second branch and also get recurrence C(p) ≤ C(p − 6) + C(p − 7). Totally, we can branch with C(p) ≤ 2C(p − 3) + 2C(p − 6) + 2C(p − 7), which solves to C(p) = (1.4568p ). Case 5. Vertex v has degree d′ = 2 in H: Then G[U2 ] is a collection of cycle components (without any l-cycle component with l ∈ {6, 7, 8}). We have discussed this case in Section 3.

16

Figure 7: A component H containing a (0, 2) degree-3 vertex v of Case 3 in Step 9 Lemma 14 In Step 9, Algorithm P EDS3 can always branch with (3) or a better recurrence without creating any bad component in each branch.

5.8

The Finial Result

According to Lemma 6 to Lemma 14, we get that our main result. Theorem 15 Algorithm P EDS3 can solve k-EDS in graphs of maximum degree 3 in O∗ (2.1479k ) time.

6

Concluding Remarks

In this paper, we have presented an improved algorithm to decide whether a graph of maximum degree 3 has an edge dominating set of size at most k. The algorithm is based on enumeration of vertex covers and the branch-and-reduce method. We first use a branch-and-reduce method to enumerate vertex covers of small size and then for each vertex cover we construct an edge dominating set. By applying some techniques, such as pseudo-cliques and amortization, we build up a search tree with recurrence relation C(p) ≤ C(p − 1) + C(p − 3) at least on the size p of the vertex cover for k-EDS in graphs of maximum degree 3. It is still left as open whether we can achieve this recurrence relation for k-EDS in general graphs.

References [1] Bourgeois, N., Escoffier, B., Paschos, V.T., van Rooij, J.M.M.: Maximum independent set in graphs of average degree at most three in O(1.08537n ). In: Theory and Applications of Models of Computation. LNCS 6108, Springer (2010) 373–384 [2] Binkele-Raible, D. and Fernau, H.: Enumerate and measure: improving parameter budget management. In Proceedings IPEC , LNCS 6478, Springer(2010), 38–49. [3] Fernau, H.: edge dominating set: Efficient enumeration-based exact algorithms. In Bodlaender, H., Langston, M., eds.: IWPEC. LNCS 4169, Springer-Verlag Berlin Heidelberg (2006) 142–153 [4] Fomin, F., Gaspers, S., Saurabh, S., Stepanov, A.: On two techniques of combining branching and treewidth. Algorithmica 54(2) (2009) 181–207 [5] Garey, M.R., Johnson, D.S.: Computers and intractability: A guide to the theory of NPcompleteness. Freeman, San Francisco (1979)

17

[6] Iwama, K., Nakashima, T.: An improved exact algorithm for cubic graph tsp. In Lin, G., ed.: COCOON. LNCS 4598, Springer (2007) 108–117 [7] Johnson, D., Yannakakis, M., Papadimitriou, C.: On generating all maximal independent sets. Information Processing Letters 27(3) (1988) 119–123 [8] Raman, V., Saurabh, S., Sikdar, S.: Efficient exact algorithms through enumerating maximal independent sets and other techniques. Theory of Computing Systems 42(3) (2007) 563–587 [9] Randerath, B., Schiermeyer, I.: Exact algorithms for minimum dominating set. Technical Report zaik 2005-501, Universit¨at zu K¨oln, Cologne, Germany (2005) [10] Rooij, J.M., Bodlaender, H.L.: Exact algorithms for edge domination. In Grohe, M., Niedermeier, R., eds.: IWPEC. LNCS 5018, Springer-Verlag Berlin Heidelberg (2008) 214–225 [11] Wang, J., Chen, B., Feng, Q., Chen, J.: An efficient fixed-parameter enumeration algorithm for weighted edge dominating set. In Deng, X., Hopcroft, J.E., Xue, J., eds.: FAW. LNCS 5598, Springer (2009) 237–250 [12] Xiao, M.: A note on vertex cover in graphs with maximum degree 3. In Thai, M.T., Sahni, S., eds.: COCOON. LNCS 6196, Springer (2010) 150–159 [13] Xiao, M.: A simple and fast algorithm for maximum independent set in 3-degree graphs. In: Rahman, Md.S. and Fujita, S. (Eds.): WALCOM. LNCS 5942, Springer (2010) 281–292 [14] Xiao, M.: Exact and parameterized algorithms for edge dominating set in 3-degree graphs, In (W. Wu, O. Daescu, eds.), Proceedings COCOA, LNCS 6509, Springer (2010), 387–400. [15] Xiao, M., Kloks, T., and Poon, S-H.: New Parameterized Algorithms for the Edge Dominating Set Problem. In F. Murlak and P. Sankowski (Eds.): MFCS 2011. LNCS 6907, Springer (2011) 604–615 [16] Yannakakis, M., Gavril., F.: Edge dominating sets in graphs. SIAM J. Appl. Math. 38(3) (1980) 364–372

18

Suggest Documents