Parameterized Power Vertex Cover

by   Eric Angel, et al.

We study a recently introduced generalization of the Vertex Cover (VC) problem, called Power Vertex Cover (PVC). In this problem, each edge of the input graph is supplied with a positive integer demand. A solution is an assignment of (power) values to the vertices, so that for each edge one of its endpoints has value as high as the demand, and the total sum of power values assigned is minimized. We investigate how this generalization affects the parameterized complexity of Vertex Cover. On the positive side, when parameterized by the value of the optimal P, we give an O*(1.274^P)-time branching algorithm (O* is used to hide factors polynomial in the input size), and also an O*(1.325^P)-time algorithm for the more general asymmetric case of the problem, where the demand of each edge may differ for its two endpoints. When the parameter is the number of vertices k that receive positive value, we give O*(1.619^k) and O*(k^k)-time algorithms for the symmetric and asymmetric cases respectively, as well as a simple quadratic kernel for the asymmetric case. We also show that PVC becomes significantly harder than classical VC when parameterized by the graph's treewidth t. More specifically, we prove that unless the ETH is false, there is no n^o(t)-time algorithm for PVC. We give a method to overcome this hardness by designing an FPT approximation scheme which gives a (1+epsilon)-approximation to the optimal solution in time FPT in parameters t and 1/epsilon.


page 1

page 2

page 3

page 4


Parameterized algorithm for 3-path vertex cover

In the 3-path vertex cover problem, the input is an undirected graph G a...

From Symmetry to Asymmetry: Generalizing TSP Approximations by Parametrization

We generalize the tree doubling and Christofides algorithm, the two most...

The Power of Amortized Recourse for Online Graph Problems

In this work, we study graph problems with monotone-sum objectives. We p...

FPT and kernelization algorithms for the k-in-a-tree problem

The three-in-a-tree problem asks for an induced tree of the input graph ...

On the Parameterized Complexity of the Connected Flow and Many Visits TSP Problem

We study a variant of Min Cost Flow in which the flow needs to be connec...

A faster algorithm for Vertex Cover parameterized by solution size

We describe a new algorithm for vertex cover with runtime O^*(1.25400^k)...

Extended MSO Model Checking via Small Vertex Integrity

We study the model checking problem of an extended 𝖬𝖲𝖮 with local and gl...

1 Introduction

In the classical Vertex Cover (VC) problem, we are given a graph and we aim to find a minimum cardinality cover of the edges, i.e. a subset of the vertices such that for every edge , at least one of its endpoints belongs to . Vertex Cover is one of the most extensively studied NP-hard problems in both approximation and parameterized algorithms, see WS11; N06.

In this paper, we study a natural generalization of the VC problem, which we call Power Vertex Cover (PVC). In this generalization, we are given an edge-weighted graph and we are asked to assign (power) values to its vertices. We say that an edge is covered if at least one of its endpoints is assigned a value greater than or equal to the weight of . The goal is to determine a valuation such that all edges are covered and the sum of all values assigned is minimized. Clearly, if all edge weights are equal to 1, then this problem coincides with VC.

Power Vertex Cover was recently introduced in Angel2015, motivated by practical applications in sensor networks (hence the term “power”). The main question posed in Angel2015 was whether this more general problem is harder to approximate than VC. It was then shown that PVC retains enough of the desirable structure of VC to admit a similar 2-approximation algorithm, even for the more general case where the power needed to cover the edge is not the same for and (a case referred to as Directed Power Vertex Cover (DPVC)).

The goal of this paper is to pose a similar question in the context of parameterized complexity: is it possible to leverage known FPT results for VC to obtain FPT algorithms for this more general version? We offer a number of both positive and negative results. Specifically:

  • When the parameter is the value of the optimal solution (and all weights are positive integers), we show an -time branching algorithm for PVC, and an -time algorithm for DPVC. Thus, in this case, the two problems behave similarly to classical VC.

  • When the parameter is the cardinality of the optimal solution, that is, the number of vertices to be assigned non-zero values, we show and -time algorithms for PVC and DPVC respectively, as well as a simple quadratic (vertex) kernel for DPVC, similar to the classical Buss kernel for VC. This raises the question of whether a kernel of order linear in can be obtained. We give some negative evidence in this direction, by showing that an LP-based approach is very unlikely to succeed. More strongly, we show that, given an optimal fractional solution to PVC which assigns value 0 to a vertex, it is NP-hard to decide if an optimal solution exists that does the same.

  • When the parameter is the treewidth of the input graph, we show through an FPT reduction from Clique that there is no algorithm for PVC unless the ETH is false. This is essentially tight, since we also supply an -time algorithm, where is the maximum degree of the graph, and is in stark contrast to VC, which admits an -time algorithm. We complement this hardness result with an FPT approximation scheme, that is, an algorithm which, for any returns a -approximate solution while running in time FPT in and . Specifically, our algorithm runs in time . We also generalize the -time algorithm for VC to an -time algorithm for PVC where is the maximum edge weight ( for VC).

Our results thus indicate that PVC occupies a very interesting spot in terms of its parameterized complexity. On the one hand, PVC carries over many of the desirable algorithmic properties of VC: branching algorithms and simple kernelization algorithms can be directly applied. On the other, this problem seems to be considerably harder in several (sometimes surprising) respects. In particular, neither the standard treewidth-based DP techniques, nor the Nemhauser-Trotter theorem can be applied to obtain results comparable to those for VC. In fact, in the latter case, the existence of edge weights turns a trivial problem (all vertices with fractional optimal value 0 are placed in the independent set) to an NP-hard one. Yet, despite its added hardness, PVC

in fact admits an FPT approximation scheme, a property that is at the moment known for only a handful of other W-hard problems. Because of all these, we view the results of this paper as a first step towards a deeper understanding of a natural generalization of

VC that merits further investigation.

Previous work

As mentioned, PVC and DPVC were introduced in Angel2015, where 2-approximation algorithms were presented for general graphs and it was proved that, like VC, the problem can be solved in polynomial time for bipartite graphs.

Vertex Cover is one of the most studied problems in FPT algorithms, and the complexity of the fastest algorithm as a function of has led to a long “race” of improving results, see Nied03; Chen05 and references therein. The current best result is a -time polynomial-space algorithm. Another direction of intense interest has been kernelization algorithms for VC, with the current best being a kernel with (slightly less than) vertices, see Lampis11; Fel03; Chleb08. Because of the importance of this problem, numerous variations and generalizations have also been thoroughly investigated. These include (among others): Weighted VC (where each vertex has a cost), see Nied03, Connected VC (where the solution is required to be connected), see Cygan12; MolleRR08, Partial VC (where the solution size is fixed and we seek to maximize the number of covered edges), see GuoNW07; Marx08, and Capacitated VC (where each vertex has a capacity of edges it can dominate), see DomLSV08; GuoNW07. Of these, all except Partial VC are FPT when parameterized by , while all except Capacitated VC are FPT when parameterized by the input graph’s treewidth . Partial VC is known to admit an FPT approximation scheme parameterized by , see Marx08, while Capacitated VC admits a bi-criteria FPT approximation scheme parameterized by , see Lampis14, that is, an algorithm that returns a solution that has optimal size, but may violate some capacity constraints by a factor .

In view of the above, and the results of this paper, we observe that PVC displays a different behavior than most VC variants, with Capacitated VC being the most similar. Note though, that for PVC we are able to obtain a (much simpler) -approximation for the problem, as opposed to the bi-criteria approximation known for Capacitated VC. This is a consequence of a “smoothness” property displayed by one problem and not the other, namely, that any solution that slightly violates the feasibility constraints of PVC can be transformed into a feasible solution with almost the same value. This property separates the two problems, motivating the further study of PVC.

2 Preliminaries

We use standard graph theory terminology. We denote by the order of a graph, by the set of neighbors of a vertex , by its degree, and by the maximum degree of the graph. We also use standard parameterized complexity terminology, and refer the reader to related textbook N06 for the definitions of notions such as FPT and kernel.

In the DPVC problem we are given a graph and for each edge two positive integer values and . A feasible solution is a function that assigns to each a value such that for all edges we have either or . If for all edges we have we say that we have an instance of PVC.

Both of these problems generalize Vertex Cover, which is the case where for all edges . In fact, there are simple cases where the problems are considerably harder.

Theorem 1

PVC is NP-hard in complete graphs, even if the weights are restricted to . It is even APX-hard in this class of graphs, as hard to approximate as VC.

The reduction is from VC. Start with an instance of vertex cover. Put weight 2 on edges of , add missing edges with weight 1. Add a new vertex adjacent to all other vertices with edges of weight 1. Then a vertex cover of size in the initial graph corresponds to a vertex cover of power in the final graph (put power 2 on vertices in the vertex cover, and power 1 to other vertices in ). The reverse is also true: in any solution all but one of the vertices must have power at least 1, and if is in a solution it can be replaced by another vertex. So is useless, and a solution of PVC takes all vertices of with power either 1 or 2; it has power , where is the number of vertices with power 2. These vertices must be a vertex cover of . So the -hardness follows.

For the approximation hardness, put weights instead of 2 of edges of . Then a solution of size in the initial graph corresponds to a solution of power in the final graph. Take for instance to transfer constant ratios.

As a consequence of the above, PVC is hard on any class of graphs that contains cliques, such as interval graphs. In the remainder we focus on classes that do not contain all cliques, such as graphs of bounded treewidth.

We will use the standard notion of tree decomposition (for an introduction to this notion see the survey by BK08). Given a graph a tree decomposition of is a tree such that every node has associated with it a set , called the bag of . In addition, the following are satisfied: ; for all there exists such that ; and finally for all the set is a connected sub-tree of . The width of a tree decomposition is defined as . The treewidth of a graph is the minimum treewidth of a tree decomposition of .

As is standard, when dealing with problems on graphs of bounded treewidth we will assume that a “nice” tree decomposition of the input graph is supplied with the input. In a nice tree decomposition the tree is a rooted binary tree and each node of the tree is of one four special types: Leaf nodes, which contain a single vertex; Join nodes, which have two children containing the same set of vertices as the node itself; Introduce nodes, which have one child and contain the same vertices as their child, plus one vertex; and Forget nodes, which have one child and contain the same vertices as their child, minus one vertex (see BK08 for more details).

3 Parameterizing by treewidth

3.1 Hardness for Treewidth

Theorem 2

If there exists an algorithm which, given an instance of PVC with treewidth , computes an optimal solution in time , then the ETH is false. This result holds even if all weights are polynomially bounded in .

Figure 1: Main gadgets of Theorem 2. Thick lines represent weight edges.

We describe a reduction from -Multicolored Independent Set. In this problem we are given a graph whose vertex set has been partitioned into cliques and we are asked if this graph contains an independent set of size . We assume without loss of generality that and that the vertices of each part are numbered . It is known that if an algorithm can solve this problem in time then the ETH is false.

Our reduction relies on two main gadgets, depicted in Figure 1. We first describe the choice gadget, depicted on the left side of the figure. This gadget contains two vertices that will be connected to the rest of the graph. In addition, it contains independent edges, each of which is given weight . Each edge has one of its endpoints connected to and the other to . The weights assigned are such that no two edges incident on have the same weight, and for each internal edge the weight of the edges connecting it to add up to .

The first step of our construction is to take independent copies of the choice gadget, and label the high-degree vertices and . As we will see, the idea of the reduction is that the power assigned to will encode the choice of vertices for the independent set in in the original graph.

We now consider the second gadget of the figure (the checker), which consists of a , all of whose edges have weight . We complete the construction as follows: for every edge of the original graph, if its endpoints are the -th vertex of and the -th vertex of , we add a copy of the checker gadget, where each of the vertices is connected to a distinct vertex of the . The weights are for the edges incident on respectively.

This completes the description of the graph. We now ask if there exists a power vertex cover with total cost at most , where is the number of edges of the original graph. Observe that the treewidth of the constructed graph is , because deleting the vertices turns the graph into a disconnected collection of s and s.

First, suppose that the original graph has an independent set of size . If the independent set contains vertex from the set , we assign the value to and to . Inside each choice gadget, we consider each edge incident on not yet covered, and we assign value to its other endpoint. Similarly, we consider each edge incident on not yet covered and assign value to its other endpoint. Since all weights are distinct and from , we will thus select vertices from the uncovered edges incident on and vertices from the uncovered edges incident on ; thus the total value spent on each choice gadget is . To see that this assignment covers also the weight edges inside the matching, observe that since the edges connecting each to have total weight , at least one is not covered by or , thus one of the internal endpoints is taken.

Let us now consider the checker gadgets. Recall that we have one such gadget for every edge. Consider an edge between the -th vertex of and the -th vertex of , so that the weights are those depicted in Figure 1. Because we started from an independent set of we know that for the values we have assigned at least one of the following is true: or , since these values correspond to the indices of the vertices of the independent set. Suppose without loss of generality that . Therefore, or . In the first case, the edge connecting to the is already covered, so we simply assign value to each of the three vertices of the not connected to . In the second case, we recall that we have assigned . Therefore the edge incident on is covered. Thus, in both cases we can cover all edges of the gadget for a total cost of . Thus, if we started from an independent set of the original graph we can construct a power vertex cover of total cost .

For the other direction, suppose that a vertex cover of cost at most exists. First, observe that since the checker gadget contains a of weight edges, any solution must spend at least to cover it. There are such gadgets, thus the solution spends at most on the remaining vertices.

Consider now the solution restricted to a choice gadget. A first observation is that there exists an optimal solution that assigns all degree 2 vertices values either or . To see this, suppose that one such vertex has value , and suppose without loss of generality that it is a neighbor of . We set its value to and the value of to . This is still a feasible solution of the same or lower cost.

Suppose that the optimal solution assigns total value at most to the vertices of a choice gadget. It cannot be using fewer than degree-two vertices, because then one of the internal weight edges will not be covered, thus it spends at least on such vertices. Furthermore, it cannot be using such vertices, because then it would have to assign 0 value to and some edges would not be covered. Therefore, the optimal solution uses exactly degree-two vertices, and assigns total value at most to . We now claim that the total value assigned to must be exactly . To see this, suppose that . The total number of edges covered by is then strictly less than . There exist therefore edges incident on which must be covered by other vertices. By the pigeonhole principle, two of them must be connected to the same edge. But since we only selected one of the two endpoints of this edge, one of the edges must be not covered.

Because of the above we can now argue that if the optimal solution has total cost at most it must assign value exactly to each checker gadget and to each choice gadget. Furthermore, this can only be achieved if for all . We can now see that selecting the vertex with index in in the original graph gives an independent set. To see this, suppose that and and suppose that an edge existed between the corresponding vertices in the original graph. It is not hard to see that in the checker gadget for this edge none of the vertices covers its incident edge. Therefore, it is impossible to cover every edge by spending exactly on this gadget.

3.2 Exact and Approximation Algorithms for Treewidth

In the previous section we showed that PVC is much harder than Vertex Cover, when parameterized by treewidth. This raises the natural question of how one may be able to work around this added complexity. Our first observation is that, using standard techniques, it is possible to obtain FPT algorithms for this problem by adding extra parameters. In particular, we show that the problem is FPT if, in addition to treewidth, we consider either the maximum weight of any edge, or the maximum degree as parameters.

Since the algorithms for these two parameterizations are essentially identical, we present a unified algorithm by considering a slightly different formulation of the problem. In List Directed Power Vertex Cover (LDPVC) we are given the same input as in DPVC as well as a function . We say that a solution is feasible if, in addition to satisfying the normal DPVC requirements, we also have for all that . In other words, in this version of the problem we are also given a function which lists the feasible power levels allowed for each vertex . In the remainder we denote by the maximum size of any set of feasible power levels, that is, .

Theorem 3

There exists an algorithm which, given an instance of LDPVC and a tree decomposition of width of the input graph, computes an optimal solution in time .

The algorithm uses well-known DP techniques, so we only sketch the details. Given a nice rooted tree decomposition of , see BK08, we compute a DP table for every bag, starting from the leaves. For every bag we consider every possible assignment of power values to the vertices of ; hence we consider at most such assignments, as each bag contains at most vertices, and each vertex has at most allowed assignments. For each such assignment we store the cost of the best solution that uses this assignment for the vertices of and covers all edges incident on vertices that only appear in bags below in the tree decomposition. It is not hard to see how to compute such a table for Join and Forget nodes. Finally, for Insert nodes, we consider every possible allowed value of the inserted vertex in combination with every power assignment for the vertices of the bag. For each such combination we check if all edges induced by the bag are covered. If that is the case, the cost of the solution is increased by the power level of the inserted vertex; otherwise we set it to to denote an infeasible solution.

Theorem 4

There exists an algorithm which, given an instance of DPVC and a tree decomposition of width of the graph, computes an optimal solution in time . Similarly, there exists an algorithm that performs the same in time .

The theorem follows directly from Theorem 3. In particular, if the maximum weight is , it suffices to only consider solutions where all power levels are in . Hence we can produce an equivalent instance of LDPVC by setting for all vertices and invoke Theorem 3. On the other hand, if the maximum degree is , the optimal solution to DPVC will use for each vertex one of possible power values: either we give this vertex power , or we give it power equal to the weight of one of its incident edges. By constructing the function in this way we can again invoke Theorem 3.

Theorem 4 indicates that the problem’s hardness for treewidth is not purely combinatorial; rather, it stems mostly from the existence of large numbers, which force the natural DP table to grow out of proportion. Using this intuition we are able to state the main algorithmic result of this section which shows that, in a sense, the problem’s W-hardness with respect to treewidth is “soft”: even if we do not add extra parameters, it is always possible to obtain in FPT time a solution that comes arbitrarily close to the optimal.

Theorem 5

There exists an algorithm which, given an instance of DPVC, and a tree decomposition of of width , for any , produces a -approximation of the optimal in time . Therefore, DPVC admits an FPT approximation scheme parameterized by treewidth.

Our strategy will be to reduce the given instance to an LDPVC instance where the size of all lists will be upper bounded by , without distorting the optimal solution too much. Then, we will invoke Theorem 3 to obtain the stated running time.

Before we begin, observe that for PVC, is already a lower bound on the value of the optimal solution. However, this is not the case for DPVC. We can, however, assume that we know the largest value used in the optimal solution (there are only possible choices for this value, so we can guess it). Let be this value. Now, we know that any edge with must be covered by , so we give vertex value and adjust the graph appropriately. In the process we produce a graph where the largest weight is and the optimal value is at least as high as .

Now, note that in general we cannot say anything about the relation between and , indeed it could be the case that the two are not even polynomially related. To avoid this, we will first “round down” all weights, so that we have . To begin with, suppose that (otherwise, all weights are polynomial in and we are done). For every edge we calculate a new weight . Observe that in the new instance we constructed the maximum weight is , so all we need to argue is that the optimal solution did not change much. Let denote the value of the optimal solution of the original instance and denote the optimal of the new instance. It is not hard to see that because if we take an optimal solution of and divide the value of each vertex by the same value we divided the edge weights, we will obtain a feasible solution. Suppose now that we have a solution of the new instance such that , for some . We can use it to obtain an almost equally good solution of the original instance as follows: for every vertex of assign it the value assigned to it by , multiplied by , and then add to it . The total cost of this solution is at most , where we have also used the assumption that .

We therefore assume in the remainder that we are given a DPVC instance with and optimal value . We construct an instance of LDPVC by using the same (weighted) graph and assigning to all vertices the list . In other words, the list of allowed power levels consists of all integer powers of that do not go above , and . The size of this list is , where we have used the fact that for sufficiently small we have , therefore the new instance can be solved optimally in the claimed running time by Theorem 3.

We observe that if we denote by the value of the optimal in the new LDPVC instance we have : the second inequality is trivial, while the first follows from the fact that any optimal solution to the DPVC instance can be transformed into a feasible solution of the LDPVC instance by replacing every power level with the value , or in other words, with the smallest integer power of which is higher than (this is because we can assume that the optimal solution of the DPVC never uses a power level above , and ). Hence, the solution produced by the algorithm of Theorem 3 can be transformed into a solution of the original instance with almost the same value.

Finally, we note that the running time in the theorem implies an FPT running time (parameterized by ) for the approximation scheme via standard arguments. First, if then the running time of the algorithm is actually polynomial, hence FPT, because we have , , therefore . If on the other hand then we have hence the running time is at most , which is also FPT.

4 Parameterizing by total power

We focus in this section on the standard parameterization: given an edge-weighted graph and an integer (the parameter), we want to determine if there exists a solution of total power at most . We first focus on PVC and show that it is solvable within time , thus reaching the same bound as VC (when parameterized by the solution value). We then tackle DPVC where a more involved analysis is needed, and we reach time .

4.1 Pvc

The algorithm for PVC is based on the following simple property.

Property 1

Consider an edge of maximum weight. Then, in any optimal solution either or .

This property can be turned into a branching rule: considering an edge of maximum weight, then either set (remove and incident edges), or set (remove and incident edges). This already shows that the problem is FPT, leading to an algorithm in time . To improve this and get the claimed bound, we also use the following reduction rule.

  1. Suppose that there is an edge with , and the maximum weight of other edges incident to or is . Then set , and do .

Property 2

(RR1) is correct.

Take a solution with the initial weights. Then or , and we get a solution on the modified instance by reducing the power of or by . Conversely, if we have a solution with the modified weights, either or , and we get a solution with the initial weights by adding power value to or to .

Now, consider the following branching algorithm.

Algorithm 1 STEP 1: While (RR1) is applicable, apply it; STEP 2: If return NO; If the graph has no edge return YES; STEP 3: If the maximum weight of edges is 1:      Apply an algorithm in time for VC; STEP 4: Take two adjacent edges and of maximum weight. Branch as follows: - either set (remove , set ); - or set (remove and , set ).

Theorem 6

Algorithm 1 solves PVC in time .

When (RR1) is no longer applicable, any edge of maximum weight is adjacent to another edge of the same (maximum) weight. So in Step 4 we can always find such a pair of edges . Then the validity of the algorithm follows from Properties 1 and 2. For the running time, the only step to look at is Step 4. When branching, the maximum weight is . In the first branch is reduced by at least 2, in the second branch by at least 4, and this gives a branching factor inducing a complexity smaller than the claimed bound.

4.2 Dpvc

For DPVC, the previous simple approach does not work. Indeed, there might be no pair of vertices such that both and . If we branch on a pair , the only thing that we know is that either , or . Setting a constraint corresponds to the following operation .

Definition 1

consists of decreasing each weight for by , and decreasing by .

Of course, if a weight becomes 0 or negative, then the edge is removed from the graph (it is covered by ).

In our algorithm, a typical branching will be to take an edge , and either to apply (and solve recursively), or to apply (and solve recursively). Another possibility is to set the power of a vertex to a certain power . In this case we must use to cover if . Formally:

Definition 2

consists of (1) setting , removing (and incident edges), (2) decreasing by , and (3) applying for all such that .

Using this, it is already easy to show that the problem is solvable in FPT-time . To reach the claimed bound of we need some more ingredients. Let and . We first define two reduction rules and one branching rule.

  1. If there exists such that , do where is such that .

  1. If there is with , for all , and for all , then set , and do .

  1. If there exists with , branch as follows: either , or .

Property 3

(RR2) and (RR3) are correct. (BR1) has a branching factor (at worst) .

For (RR2): It is never interesting to put , since we can cover all edges incident to by putting power at most on the neighbors of . So, we can assume that the power of is smaller than , meaning that covers .

For (RR3): Take a solution with the initial weights. Then or , and we get a solution on the modified instance by reducing the power of (or ) by 1. Conversely, if we have a solution with the modified weights, either or and we get a solution with the initial weights by adding power 1 to or .

For (BR1): When setting , we need to cover all edges incident to using the other extremity. Since , reduces by at least 5 in this branch (and at least 1 in the other branch).

Now, before giving the whole algorithm, we detail the case where the maximum weight is 2, where a careful case analysis is needed.

Lemma 1

Let us consider an instance where (1) (RR2) and (RR3) have been exhaustively applied, and (2) the maximum edge-weight is . Then there is a branching algorithm with branching factor (at worst) or .

Let us consider an instance where (1) (RR2) and (RR3) have been exhaustively applied, and (2) the maximum edge-weight is .

We show by a case analysis that we can reach branching factor at worst or .

If , then we apply . Otherwise, . Since (otherwise (RR2) applies), . In particular, the degree of is .

Note first that if for all we have , then we either (and we fix on neighbors of ), or , meaning that reduces by 2. This gives a branching factor at worst . Thus, we can assume in the sequel that there exists such that .

We need to consider several cases, taking a vertex (incident to an edge of weight 2) of maximum degree:

  1. If . Then since all edges have weight .

    1. If there is only one with : it is never interesting to put power 1 on . So we do either (and we fix 4), or and we fix 2.

    2. If there are three neighbors with : it is never interesting to set (instead set and give the extra power 1 to to cover ), so is covered by and without branching we do .

    3. If , . If both and have degree 1, then it is never interesting to take them, so we do without branching. Otherwise, suppose that has degree at least 2. Then we branch on : we do either (and we fix at least 3: 2 for and 1 for the other neighbor), or . But in this latter case it is never interesting to set (set and put extra power 1 on instead), so we also do . The branching factor is then at worst .

  2. If , with :

    1. Suppose first that and .

      If it is never interesting to set (set and put extra weight on instead), so we do either (and fix at least in the set of neighbors of ), or . We get a branching factor .

      Otherwise, . Since , . Then if , we do not need to branch, we do . Otherwise, for instance . We branch on : we do either and we fix at least 3 in , or but in this case it is never interesting to set (set , and put the extra weight 1 on instead), so we do . We get a branching factor .

    2. Now suppose that .

      If it is never interesting to set , so we do without branching. The only remaining case is .

      If has another neighbor such that : we branch on , by doing either , or by considering hence and . We get a branching factor .

      Otherwise, we have with , for all and for all . But this cannot occur thanks to Rule (RR3).

  3. If , . Then (since as mentioned before there exists such that ).

    1. If it is never interesting to set . As previously, we do either (and fix in ), or and reduce by two. So again we get a branching factor .

    2. If , it is never interesting to set , so we do .

    3. Otherwise, . Let us look at : it has degree 2 with and so this is a previous case with .

We are now ready to describe the main algorithm. denotes the set of vertices at distance 2 from .

Algorithm 2 STEP 1: While (RR2) or (RR3) is applicable, apply it; STEP 2: If return NO; If the graph has no edge return YES; STEP 3: If there is a vertex with : apply (BR1); STEP 4: If there exists with either , or and : branch by either , or ; STEP 5: If there exists of weight : - if and for all :       - either , and solve the problem on ;       - or ; - otherwise:       - either ;       - or , and for all ; STEP 6: If the maximum weight is at most 2, then branch as in Lemma 1.

In Step 5, when doing , as we will see in the proof becomes separated from the rest of the graph, ie. a connected component with at most 5 vertices, so we can find an optimal solution on it in constant time.

Theorem 7

Algorithm 2 solves DPVC in time .

Note that corresponds to branching factors and .

We have already seen that (RR2) and (RR3) are sound, and that (BR1) gives a branching factor .

For Step 4, if this gives in the worst case a branching factor . If and the branching factor is .

At this point (after Step 4) there cannot remain an edge with weight , since Step 4 would have been applied. If there is an edge with , then either (which is impossible since (BR1) would have been applied), or (which is impossible since (RR2) would have been applied). So, the maximum edge weight after step 4 is at most 3.

Thanks to Lemma 1, what remains to do is to focus on Step 5, with .

First, note that then (otherwise (RR2) or (BR1) would have been applied), and (otherwise Step 4 would have been applied).

We consider two cases.

  • If and for all . As explained in the algorithm, we branch on : either , or . If , all edges are covered, so is now disconnected from the rest of the graph. We can find (in constant time) the power to put on these vertices in order to optimally color the incident edges, as mentioned in the algorithm. Since we need power at least 2 for this ( has at least two neighbors since and ), globally reduces by at least 3. If , induces to perform for all . has at least 2 neighors since , and reduces by at least 2. Then, reduces by at least 3 in one branch, by at least 2 in the other, leading to a branching factor .

  • If , or if with at least one with : setting is only interesting if all neighbors of receive weight 0 - otherwise distributing the power 3 of on neighbors of to cover all edges is always at least as good. Then in this case we have to cover edges between and , so a power at least 2. Then either we have and in this case , or we set , for neighbors of , and we fix at least 2 in . In the first branch reduces by at least 1, in the other by at least 5, leading to a branching factor .

5 Parameterizing by the number of vertices

We now consider as parameter the number of vertices that will receive a positive value in the optimal solution. Note that by definition ; therefore, we expect any FPT algorithm with respect to to have the same or worse performance than the best algorithm for parameter .

Theorem 8

PVC is solvable in time . DPVC is solvable in time .

For PVC, Algorithm 1 can be easily adapted to deal with parameterization by : when branching, is reduced by 1 in the first branch, and by 2 in the second branch, so we have a branching factor in the worst case.

The case of DPVC is a bit more involved, but we can show that it is FPT as well. We will perform procedures and (without the modifications on of course), but we have to pay attention to the way we count the number of vertices in the solution (vertices with strictly positive power). Indeed, if we perform several on the same vertex , we have to count it (decrease ) only once. To do this, in the algorithm we decrease by one when a vertex (with positive weight) is removed from the graph. Then, when performing , we mark the vertex (but do not decrease by one yet) - initially no vertex is marked. When a marked vertex becomes of degree 0, then we remove it from the graph and decrease by one. Also, when performing an operation ( is removed), so we decrease by 1 if or if is marked.

Now, suppose first that there is a vertex of degree at least . To get a solution with at most vertices, necessarily must receive a positive power. More precisely, it must cover all but at most edges incident to it. Then in any solution with at most vertices, if we order the weights , in non increasing order . So in this case, we can safely apply . In the remaining instance, has degree at most .

We apply this reduction while possible, and get afterwards an instance where each vertex has degree at most . Then:

  • Take an edge such that . Let be the set of weights which are greater than or equal to .

  • Perform a branching with branches as follows: either (and recurse), or for each (and recurse).

Choosing to cover the edge corresponds to the first branch. Otherwise, we have to use to cover this edge. We consider all the possible weights that could be assigned to in an (optimal) solution. In each branch at least one vertex with positive power is removed ( in the first branch, in the others) so reduces by at least one. Since , we have a tree of arity at most and depth at most .

Following Theorem 8, a natural question is whether DPVC is solvable in single exponential time with respect to or not. This does not seem obvious. In particular, it is not clear whether DPVC is solvable in single exponential time with respect to the number of vertices , since the simple brute-force algorithm which guesses the value of each vertex needs time.

Interestingly, though we are not able to resolve these questions, we can show that they are actually equivalent.

Theorem 9

If there exists an -time algorithm for DPVC, for some constant , then there exists an -time algorithm for DPVC.

We describe a branching algorithm, which eventually needs to solve an instance of DPVC on vertices. We maintain three sets . Initially, and . The informal meaning is that we want to branch so that eventually becomes an independent set and a vertex cover of . In addition, we want to maintain the property that there are no edges between and (which is initially vacuously true).

As long as and there are still edges incident on we repeat the following rules:

  1. If there is a vertex such that there are no edges from to we set and .

  2. If there is an edge induced by we branch on which of the two vertices covers it in the optimal solution. In one branch, we perform , and set and . The other branch is symmetric for .

  3. If is an independent set, we select a vertex . Because of Step 1, we know that there are some edges connecting to . Let be the maximum weight among edges connecting to . We branch between two choices: either in the optimal or . In the first case we (observe that this removes all edges connecting to , therefore we can immediately apply Rule 1). In the second case, we and set and .

It is not hard to see that the branching described above cannot produce more than different outcomes. To see this, observe that any branching performed either increases or , while never decreasing either quantity. Therefore, the quantity increases in each branching step. However, this quantity has maximum value .

The branching algorithm above will stop either when has no incident edges, or when . In the latter case, we have selected that is the set of vertices that take positive values in our solution, so we can perform for any and , until no edges are incident on . We can now delete all the (isolated) vertices of , and we are left with a -vertex DPVC instance on , on which we use the assumed exponential-time algorithm.

6 Kernelization and linear programming

Moving to the subject of kernels, we first notice that the same technique as for VC gives a quadratic (vertex) kernel for DPVC when the parameter is (and therefore also when the parameter is ):

Theorem 10

There exists a kernelization algorithm for DPVC that produces a kernel with vertices.

Consider the following rules:

  • If there exists a vertex of degree at least , apply the procedure as previously (and mark the vertex).

  • If there exists a marked vertex of degree 0, remove it and do . If there is an unmarked vertex of degree 0, remove it.

Let be the graph obtained after this procedure. If return NO. Else, which is a kernel.

Suppose that the answer is YES. Then there exists a vertex cover of size at most , and each vertex has at most neighbors, and there is no isolated vertex, so . Hence, this gives a kernel of size for DPVC when parameterized by (so a kernel of size when parameterized by ).

We observe that the above theorem gives a bi-kernel also for PVC. We leave it as an open question whether a pure quadratic kernel exists for PVC.

Let us now consider the question whether the kernel of Theorem 10 could be improved to linear. A way to reach a linear kernel for VC

is by means of linear programming. We consider this approach now and show that it seems to fail for the generalization we consider here. Let us consider the following ILP formulation for

DPVC, where we have one variable per vertex ( is the power of ), and one variable () per edge . (resp. 0) means that (resp ) covers the edge.

Can we use the relaxation of this ILP to get a linear kernel? Let us focus on PVC, where the relaxation can be written in an equivalent simpler form111A solution of the relaxation of the former is clearly a solution of the latter. Conversely, if , set to get a solution of the former.:

Let us call this LP. We can show that, similarly as for VC, has the semi-integrality property: in an optimal (extremal) solution , for all . However, we cannot remove vertices receiving value 0, as in the case of VC. Indeed, there does exist vertices that receive weight 0 in the above relaxation which are in any optimal (integer) solution. To see this, consider two edges and both with weight 2, and a vertex adjacent to all 4 previous vertices with edges of weight 1. Then, there is only one optimal fractional solution, with , and . But any (integer) solution has value 5 and gives power 2 to or , to or , and weight 1 to . The difficulty is actually deeper, since we have the following.

Theorem 11

The following problem is NP-hard: given an instance of PVC, an optimal (extremal) solution of and such that , does there exists an optimal (integer) solution of PVC not containing ?

Take a graph which is an instance of VC. We build the following instance of PVC:

  • There is one vertex for each vertex in , and two vertices and for each edge in

  • and are linked with an edge of weight 2;

  • If is an edge of , then is adjacent to and is adjacent to in , both edges receiving weight 1.

As previously, an optimal solution in the relaxation RPVC is to give power 1 to each “edge-vertex” (