# A Parameterized Algorithm for Bounded-Degree Vertex Deletion

## Abstract

The -bounded-degree vertex deletion problem, to delete at most vertices in a given graph to make the maximum degree of the remaining graph at most , finds applications in computational biology, social network analysis and some others. It can be regarded as a special case of the -hitting set problem and generates the famous vertex cover problem. The -bounded-degree vertex deletion problem is NP-hard for each fixed . In terms of parameterized complexity, the problem parameterized by is W[2]-hard for unbounded and fixed-parameter tractable for each fixed . Previously, (randomized) parameterized algorithms for this problem with running time bound are only known for . In this paper, we give a uniform parameterized algorithm deterministically solving this problem in time for each . Note that it is an open problem whether the -hitting set problem can be solved in time for . Our result answers this challenging open problem affirmatively for a special case. Furthermore, our algorithm also gets a running time bound of for the case that , improving the previous deterministic bound of .

Key words. Parameterized algorithms, Graph algorithms, Bounded-degree vertex deletion, Hitting set

## 1 Introduction

The -bounded-degree vertex deletion problem is a natural generation of the famous vertex cover problem, which is one of the best studied problems in combinatorial optimization. An application of the -bounded-degree vertex deletion problem in computational biology is addressed by Fellows et. al. [5]: A clique-centric approach in the analysis of genetic networks based on micro-array data can be modeled as the -bounded-degree vertex deletion problem. The problem also plays an important role in the area of property testing [12]. Its “dual problem”– the -plex problem was introduced in 1978 by Seidman and Foster [14] and it becomes an important problem in social network analysis now [1].

The -bounded-degree vertex deletion problem is also extensively studied in theory, especially in parameterized complexity. It has been shown that the problem parameterized by the size of the deletion set is W[2]-hard for unbounded and fixed-parameter tractable for each fixed [5]. Betzler et. al. [2] also studied the parameterized complexity of the problem with respect to the treewidth of the graph. The problem is FPT with parameters and and W[2]-hard with only parameter . Fellows et. al. [5] generated the NT-theorem for the vertex cover problem to the -bounded-degree vertex deletion problem, which can imply a linear vertex kernel for the problem with and a polynomial vertex kernel for each fixed . A linear vertex kernel for the case that was developed in [4]. Recently, a refined generation of the NT-theorem was proved [17], which can get a linear vertex kernel for each fixed .

In terms of parameterized algorithms, the case that , i.e., the vertex cover problem, can be solved in time now [3]. When , the problem is known as the vertex cover problem. Tu [15] gave an -time algorithm and the running time bound was improved to by Wu [16] and to by Katrenič [11]. When , the problem is known as the co-path/cycle problem. For this problem, there is an -time deterministic algorithm [4] and an -time randomized algorithm [6]. For , a simple branch-and-reduce algorithm that tries all possibilities for a -star in the graph gets the running time bound of . In fact, the -bounded-degree vertex deletion problem can be regarded as a special case of the -hitting set problem and the latter problem has been extensively studied in parameterized algorithms [13, 7, 8, 9]. For a graph , we regard each vertex in the graph as an element and each -star as a set of size (a vertex of degree will form sets). Then the -bounded-degree vertex deletion problem in becomes an instance of the -hitting set problem. There are several parameterized algorithms for the -hitting set problem running in time [13, 9], where is a function of . It leaves as an interesting open problem whether the -hitting set problem can be solved in time. Note that it is marked in [9] that “ seems an unsurpassable lower bound”. By using fastest algorithms for the -hitting set problem, we can get an algorithm with running time bound of with for each fixed .

In this paper, we design a uniform algorithm for the -bounded-degree vertex deletion problem, which achieves the running time bound of for each . Although our problem is a special case of the -hitting set problem, the above bound is not easy to reach. We need a very careful analysis and some good graph structural properties. It is also worthy to mention that our algorithm also works on the case that and runs in time, improving the previous deterministic bound of [4] and comparable with the previous randomized bound of [6].

## 2 Preliminaries

Let be a simple undirected graph, and be a subset of vertices. The subgraph induced by is denoted by , and is written as . We may simply use to denote the set of a single vertex . Let denote the set of neighbors of , i.e., the vertices in adjacent to a vertex , and denote by . The degree of a vertex is defined to be . A graph of maximum degree is also called a degree- graph. For an integer , a star with vertices is called a -star. A set of vertices is called a -deletion set of a graph , if has maximum degree at most . In our problem, we want to find a -deletion set of size at most in a graph. Formally, our problem is defined as following.

-Bounded-Degree Vertex Deletion

Instance: A graph and two nonnegative integers and .

Question: To decide whether there is a subset of vertices such that
and the induced graph has maximum degree at most .

In the above definition, is also called a solution set.

### 2.1 Some basic properties

The following lemmas are basic structural properties used to design branching rules in our algorithms.

###### Lemma 1

Let be a vertex of degree in a graph . Any -deletion set contains either or neighbors of .

A vertex dominates a vertex if all vertices of degree in are also in . Note that in this definition, we do not require .

###### Lemma 2

If a vertex of degree dominates a neighbor of it, then there is a minimum -deletion set containing at least one vertex in .

Proof. Since is of degree , any -deletion set contains at least one vertex in . Assume that contains only in . We can see that is still a -deletion set and . Thus, the lemma holds. ∎

###### Lemma 3

If a vertex dominates a vertex of degree , then there is a minimum -deletion set containing at least one neighbor of .

Proof. Since dominates and is of degree , we know that is a neighbor of . Any -deletion set contains at least one vertex in since it is of degree . Assume that . We can see that is a -deletion set containing a neighbor of and . Thus, the lemma holds. ∎

If there is a vertex of degree dominating a neighbor of it or being dominated by another vertex, we say that the graph has a proper domination. Note that if a vertex of degree has at most one neighbor of degree , then is dominated by and then there is a proper domination. In fact, we have:

###### Lemma 4

If a graph has no proper domination, then each vertex of degree in it has at least two nonadjacent neighbors of degree .

### 2.2 Branch-and-search algorithms

Our algorithm is a typical branch-and-search algorithm.
In our algorithm, we search a solution for an instance by recursively
branching on the current
instance into several smaller instances until the instances become trivial instances.
Each simple branching operation creates a recurrence relation.
Assume that the branching operation branches on an instance with parameter into branches such that
in the -th branch the parameter decreases by
at least . Let denote the worst size of the search tree to search a solution to any instance with parameter . We get a recurrence relation ^{2}

The largest root of the function is called the branching factor of the recurrence relation. Let be the maximum branching factor among all branching factors in the algorithm. The size of the search tree that represents the branching process of the algorithm applied to an instance with parameter is given by . More details about the analysis and how to solve recurrences can be found in the monograph [10].

## 3 The idea and organization of the algorithm

Our purpose is to design a branch-and-search algorithm for the -bounded-degree vertex deletion problem such that the branching factor of each recurrence relation with respective to the parameter is at most . Lemma 1 provides a simple branching rule: for a vertex of degree , branching by either including or each set of neighbors of to the solution set. We will show that when , this simple branching operation is good enough to get a branching factor for each (See Step 1 in Section 4). Thus, we can use this operation to deal with vertices of degree . Lemma 1 for a degree-() vertex can be interpreted as: at least one vertex in is in a -deletion set. This branching operation will only get a branching factor of for this case. But when there is a proper domination in a degree-() graph, we still can branch with branching factor , since we can ignore one branch by Lemma 2 and Lemma 3. The detailed analysis is given in Step 2 in Section 4. When the graph is of maximum degree and has no proper domination, we need to use more structural properties.

To find a -deletion set in a degree- graph is equivalent to find a vertex subset intersecting for each degree-() vertex . If there are some vertices in for two degree- vertices and , some information may be useful for us to design a good branching rule. Note that for two adjacent degree- vertices and , there are at least two vertices in the intersection of and . Lemma 4 guarantees that each degree- vertex has at least two nonadjacent degree- neighbors if a degree- graph has no proper domination. So we will focus on adjacent degree- vertices.

We define three relations between two degree-() vertices. A pair of adjacent degree-() vertices is a good pair if they have at least one and at most common neighbors. A pair of adjacent degree-() vertices is a close pair if they have exactly common neighbors. A pair of nonadjacent degree-() vertices is a similar pair if they have the same neighbor set. We have a good branching rule to deal with good pairs. See Step 3 in Section 4. After dealing with all good pairs, for any pair of adjacent degree-() vertices, either it is a close pair or the two vertices have no common neighbor. We do not have a simple branching rule with branching factor for these two cases. Then we change to consider three adjacent degree-() vertices.

Let and be three degree-() vertices such that is adjacent to and . We find that the hardest case is that exact one pair of vertices in is a close or similar pair, for which we still can not get a branching factor . We call this case a bad case. If no pair of vertices in is a close or similar pair, we call a proper triple of degree-() vertices. Our idea is to avoid bad cases and only branch on proper triples.

Consider four degree-() vertices and such that there is an edge between and for . If at most one pair of vertices in is a close or similar pair, then at least one of and will be a proper triple. Thus the only left cases are that at least two pairs of vertices in are close or similar pairs. Luckily, we find good branching rules to deal with them. When both of and are close pairs, is called a close triple. See Figure 1(a) for an illustration of close triple. Our algorithm deals with close triples in Step 4 in Section 4. When both of and are close pairs, is called a type-I close quadruple. See Figure 1(b) for an illustration of type-I close quadruple. Our algorithm deals with type-I close quadruples in Step 5 in Section 4. When both of and are similar pairs, is called a type-II close quadruple. See Figure 1(c) for an illustration of type-II close quadruple. Our algorithm deals with type-II close quadruples in Step 6 in Section 4. When has one close pair and one similar pair, we can see that there is always a close triple in it. Therefore, we have considered all possible cases. The last step of our algorithm is then to deal with proper triples.

## 4 The algorithm and its analysis

We are ready to describe the whole algorithm. Our algorithm works for any but can only achieve the running time bound of for each . Our algorithm is a recursive algorithm containing seven major steps, each of which will branch on the current instance into several sub-instances and invoke the algorithm itself on each sub-instance. Next, we describe these steps. When we introduce one step, we assume that all pervious steps can not be applied anymore. For the purpose of presentation, we will analyze the correctness and running time of each step after describing it.

Step 1 (Vertices of degree )

If there is a vertex of degree in the graph, we branch on into branches according to Lemma 1 by either including or each set of neighbors of to the solution set.

In the branch where is included to the solution set, we delete from the graph and decrease the parameter by 1. In the branch where a set of neighbors of are included to the solution set, we delete from the graph and decrease the parameter by . For this operation, we get a recurrence relation

(1) |

Let denote the branching factor of (1).

###### Lemma 5

If , the branching factor of (1) satisfies that

(2) |

A proof of this lemma can be found the full version of this paper. It is easy to verify that for . After Step 1, the graph has maximum degree .

Step 2 (Proper dominations)

If a vertex of degree is dominated by a vertex (or dominates a neighbor of it), we branch on into branches by including each vertex in (or ) to the solution set. The correctness of this step is based on Lemma 2 and Lemma 3.

In each branch, a vertex is included to the solution set and decreases by 1. Vertex is of degree since the graph has maximum degree at most after Step 1. We get a recurrence relation

the branching factor of which is .

Step 3 (Good pairs of degree-() vertices)

Recall that a pair of adjacent degree-() vertices is a good pair if they have at least one and at most common neighbors. we use the following branching rule to deal with a good pair . Let , and . Assume that and have common neighbors. Note that for any -degree deletion set , if does not contain any vertex in , then contains at least one vertex in and one vertex in . We branch into branches. In the first branches each vertex in is included to the solution set; and in the last branches each pair of vertices in and is included to the solution set. In each branch, if vertices are included to the solution set, then the parameter in this branch decreases by . This branching operation gives a recurrence relation

the branching factor of which is

It is easy to verify that when , the branching factor is at most .

Step 4 (Close triples of degree-() vertices)

Recall that a pair of adjacent degree-() vertices is a close pair if they have exactly common neighbors. The formal definition of close triple is that: the set of three degree-() vertices and is called a close triple if and are two close pairs and and are not adjacent. According to the definition of close triples, we can see that . For a close triple , we observe the following. Vertex (resp., ) is adjacent to a degree - vertex (resp., ) by Lemma 4. Let . For any -degree deletion set , if , then contains either and a vertex in (since must contain a vertex in and a vertex in ) or and a vertex in (since must contain a vertex in and a vertex in ). Then we can branch by either including each vertex in to the solution set or including each of , and to the solution set. This branching operation gives a recurrence relation

the branching factor of which is

It is easy to verify that when , the branching factor is less than .

Step 5 (Type-I close quadruples of degree-() vertices)

A set of four degree-() vertices is called a type-I close quadruple if induces a cycle or a path of 4 vertices, and and are two close pairs. Let and . When the graph has no proper dominations, good pairs or close triples, it holds that .

Let be an arbitrary -degree deletion set. Our branching rule for type-I close quadruples is different for the cases whether induces a cycle or a path.

Case 1. induces a cycle of 4 vertices: We consider the following different subcases.

Case 1.1. : Then and . For this case, we included each pair of vertices in and to the solution set to create branches, each of which decreases by 2.

Case 1.2. or : Then , otherwise no vertex in or would be in and then would not be a -degree deletion set. Furthermore, if , then is still a -degree deletion set of the same size, since , is adjacent to all vertices in and . So for this case, we include to the solution set for each to create branches, each of which decreases by 2.

Case 1.3. or : Then . For the same reason, we include to the solution set for each to create branches, each of which decreases by 2.

Case 1.4. : Then is a -degree deletion set of size not greater than that of , since . For this case, we can simply include to the solution set.

The branching operation gives a recurrence relation

(3) |

the branching factor of which is .

Case 2. induces a path of 4 vertices: Let and , where it is possible that . We observe the following different cases.

Case 2.1. does not contain any vertex in : Then contains at least one vertex in and at least one vertex in , since must contain at least one vertex in and at least one vertex in . If , then is still a -degree deletion set with , since . Otherwise, it holds either or . If , then since must contain at least one vertex in . If , then since must contain at least one vertex in . So for this case, we conclude that there is a solution contains one of , and . In our algorithm, we generate three branches by including each of , and to the solution set. In each of the three branches, the parameter decreases by .

Case 2.2. does not contain any vertex in but contain some vertex in : Since , we know that contains at least one vertex in . If , then is still a -degree deletion set. The reason relies on that , is adjacent to each vertex in , and contains at least one vertex in . So for this case, there is a solution contains one vertex in . In our algorithm, we create branches by including to the solution each pair of vertices and such that and . In each of the branches, the parameter decreases by .

Case 2.3. does not contain any vertex in but contain some vertex in : For the same reason in Case 2.2, there is a solution contains one vertex in . In our algorithm, we create branches by including to the solution each pair of vertices and such that and . In each of the branches, the parameter decreases by .

Case 2.4. contains some vertex in and some vertex in : For this case, Our algorithm simply generates branches by including to the solution each pair of vertices and such that and . In each of the branches, the parameter decreases by .

The above branching operation gives a recurrence relation

the branching factor of which is .

Step 6 (Type-II close quadruples of degree-() vertices)

Two nonadjacent degree-() vertices are similar if they have the same neighbor set. A set of four degree-() vertices is called a type-II close quadruple if and are two similar pairs and there is an edge between and for . Note that there must be an edge between and since is a similar pair. So as a type-II close quadruple, always induces a cycle of 4 vertices.

Let be a type-II close quadruple. We use to denote and to denote . Note that it holds , if we assume that there is no good pairs or close triples. Let be a -degree deletion set. We consider the following different subcases.

Case 1. : Then and . For this case, we included each pair of vertices in and to the solution set to create branches, each of which decreases by 2.

Case 2. or : Then , otherwise would not be a -degree deletion set since no vertex in or is in . Furthermore, if , then is still a -degree deletion set of the same size. So for this case, we include to the solution set for each to create branches, each of which decreases by 2.

Case 3. or : Then . For the same reason, we include to the solution set for each to create branches, each of which decreases by 2.

Case 4. : Then is a -degree deletion set of size not greater than , since . For this case, we can simply include to the solution set.

The branching operation gives a recurrence relation

the branching factor of which is .

Step 7 (Proper triples of degree-() vertices)

A set of three degree-() vertices is called a proper triple if induces a path and no pair of vertices in is close or similar.

###### Lemma 6

Let be a graph of maximum degree for any integer . If has no proper dominations, good pairs, close triples, type-I close quadruples or type-II close quadruples, then has some proper triples.

A proof of this lemma can be found in the full version.

For a proper triple in a graph having none of dominated vertices, good pairs, close triples, type-I close quadruples and type-II close quadruples, we have the following properties: , and .

Let , , , and . Since is not a similar pair, we know that . Let be a -deletion set. To design our branching rule, we consider the following different cases.

Case 1. : We simply include to the solution set and the parameter decreases by 1. For all the remaining cases, we assume that .

Case 2. and : We simply include and to the solution set and the parameter decreases by 2.

Case 3. and : For the case, . We create branches by including and each vertex in to the solution set and the parameter in each branch decreases by 2.

Case 4. and : For the case, . We create branches by including and each vertex in to the solution set and the parameter in each branch decreases by 2.

Case 5. : Then must contains (i) a vertex in and (ii) either a vertex in or two vertices from and respectively. Our algorithm generates branches. Each of the first branches includes a vertex in and a vertex in to the solution set and the parameter decreases by 2. The last branches are generated by including each triple to the solution set, where the parameter decreases by 3.

The above branching operation gives a recurrence relation

(4) |

where .

###### Lemma 7

When , the branching factor of (4) is at most for each .

A proof of this lemma can be found in the full version.

### 4.1 The results

Lemma 6 guarantees that when the graph has a vertex of degree , one of the above seven steps can be applied. When , the branching factor in each of the seven steps is at most . Thus,

###### Theorem 4.1

The -bounded-degree vertex deletion problem for each can be solved in time.

Note that all the seven steps of our algorithm work for . In the first six steps, we still can get branching factors at most for . In Step 7, when and , (4) becomes

which has a branching factor of 3.0645. This is the biggest branching factor in the algorithm. Then

###### Theorem 4.2

The co-path/cycle problem can be solved in time.

Note that previously the co-path/cycle problem could only be solved deterministically in time [4].

## 5 Concluding remarks

In this paper, by studying the structural properties of graphs, we show that the -bounded-degree vertex deletion problem can be solved in time for each . Our algorithm is the first nontrivial parameterized algorithm for the -bounded-degree vertex deletion problem with .

Our problem is a special case of the -hitting set problem. It is still left as an open problem that whether the -hitting set problem can be solved in time. Our result is a step toward to this interesting open problem. However, our method can not be extended to the -hitting set problem directly, since some good graph structural properties do not hold in the general -hitting set problem.

### Footnotes

- email: myxiao@gmail.com
- In fact, we may simply write a recurrence relation as . This difference will only affect a constant behind in the finial running time.

### References

- B. Balasundaram, S. Butenko, I.V. Hicks: Clique relaxations in social network analysis: The maximum k-plex problem. Operations Research 59(1) (2011) 133–142.
- N. Betzler, R. Bredereck, R. Niedermeier, J. Uhlmann: On bounded-degree vertex deletion parameterized by treewidth, Discrete Applied Mathematics 160(1-2) (2012) 53–60.
- J. Chen, I.A. Kanj, G. Xia: Improved upper bounds for vertex cover, Theoretical Computer Science 411 (2010) 3736–3756.
- Z.-Z. Chen, M. Fellows, B. Fu, H. Jiang, Y. Liu, L. Wang, B. Zhu: A linear kernel for co-path/cycle packing, in: Proceedings of the 6th International Conference on Algorithmic Aspects in Information and Management (AAIM ¡¯10), LNCS 6124, Springer, (2010) 90–102.
- M. R. Fellows, J. Guo, H. Moser, and R. Niedermeier: A generalization of Nemhauser and Trotter’s local optimization theorem. Journal of Computer and System Sciences 77(2011) 1141–1158.
- Q. Feng, J. Wang, S. Li, J. Chen: Randomized parameterized algorithms for -Packing and Co-Path Packing problems. J. Comb. Optim. 29(1) (2015) 125–140.
- H. Fernau: A top-down approach to search-trees: Improved algorithmics for 3-Hitting Set, Algorithmica 57 (2010) 97–118.
- H. Fernau: Parameterized algorithms for d-HITTING SET: The weighted case, Theor. Comput. Sci. 411(16–18) (2010) 1698–1713.
- H. Fernau: Parameterized algorithmics for d-Hitting Set, International Journal of Computer Mathematics 87(14) (2010) 3157–3174.
- F. V. Fomin and D. Kratsch: Exact Exponential Algorithms, Springer (2010)
- J.Katrenič: A faster FPT algorithm for 3-path vertex cover. Information Processing Letters. 116(4): 273–278(2016)
- I. Newnan and C. Sohler: Every proerty of hyperfinite graphs is testable, SIAM Journal on Computing 42(3) (2013) 1095–1112.
- R. Niedermeier and P. Rossmanith: An efficient fixed-parameter algorithm for 3-Hitting Set, J. Discrete Algorithms 1 (2003) 89–102.
- S. B. Seidman and B. L. Foster: A graph-theoretic generalization of the clique concept. Journal of Mathematical Sociology 6 (1978) 139–154.
- J. Tu: A fixed-parameter algorithm for the vertex cover P3 problem, Information Processing Letters 115 (2015) 96–99.
- B. Wu: A Measure and Conquer Approach for the Parameterized Bounded Degree-One Vertex Deletion, In: COCOON 2015, LNCS 9198, (2015) 469–480.
- M. Xiao: On a generalization of Nemhauser and Trotter’s local optimization theorem. In: ISAAC 2015, LNCS 9472, (2015) 442–452.