Parameterized Complexity of Critical Node Cuts

Parameterized Complexity of Critical Node Cuts

Danny Hermelin Department of Industrial Engineering and Management, Ben-Gurion University, Israel
hermelin@bgu.ac.il, moshe@exchange.bgu.ac.il, baraknav@post.bgu.ac.il
Moshe Kaspi Department of Industrial Engineering and Management, Ben-Gurion University, Israel
hermelin@bgu.ac.il, moshe@exchange.bgu.ac.il, baraknav@post.bgu.ac.il
Christian Komusiewicz Institut für Softwaretechnik und Theoretische Informatik, TU Berlin, Germany
christian.komusiewicz@tu-berlin.de
Barak Navon Department of Industrial Engineering and Management, Ben-Gurion University, Israel
hermelin@bgu.ac.il, moshe@exchange.bgu.ac.il, baraknav@post.bgu.ac.il
Abstract

We consider the following graph cut problem called Critical Node Cut (CNC): Given a graph on vertices, and two positive integers and , determine whether has a set of vertices whose removal leaves with at most connected pairs of vertices. We analyze this problem in the framework of parameterized complexity. That is, we are interested in whether or not this problem is solvable in time (i.e., whether or not it is fixed-parameter tractable), for various natural parameters . We consider four such parameters:

  • The size of the required cut.

  • The upper bound on the number of remaining connected pairs.

  • The lower bound on the number of connected pairs to be removed.

  • The treewidth of .

We determine whether or not CNC is fixed-parameter tractable for each of these parameters. We determine this also for all possible aggregations of these four parameters, apart from . Moreover, we also determine whether or not CNC admits a polynomial kernel for all these parameterizations. That is, whether or not there is an algorithm that reduces each instance of CNC in polynomial time to an equivalent instance of size , where is the given parameter.

\addtokomafont

title \addtokomafontdisposition

1 Introduction

In a polio virus struck Israel. The virus spread in alarming speed, creating a nationwide panic of parents concerned about the well-being of their children. It was obvious to the Israeli health department that vaccinating all Israeli children is not a practical solution in the given time frame. Thus it became clear that some areas of the country should be vaccinated first in order to stop the spread of the virus as quickly as possible. Let us represent a geographic area as a vertex of a graph, and the roads between areas as edges of the graph. In this setting, vaccinating an area corresponds to deleting a certain vertex from the graph. Thus, the objective of stopping the virus from spreading translates to minimizing the number of connected pairs (two vertices which are in the same component) in the corresponding graph after applying the vaccination.

This scenario can be modeled by the following graph-theoretic problem which we call Critical Node Cut (CNC). In this problem, we are given an undirected simple graph and two integers and . The objective is to determine whether there exists a set of at most vertices in , such that the graph which results from removing from , contains at most connected pairs. In this sense, the cut is considered critical since removing it from leaves few (at most ) connected pairs. For convenience purposes, throughout the paper we will count ordered connected pairs; i.e., pairs , , where and belong to same connected component in .

The goal of CNC is thus, roughly speaking, to destroy the connectivity of a given graph as much as possible given a certain budget for deleting vertices. From this point of view, CNC fits nicely to the broad family of graph-cut problems. Graph-cut problems have been studied widely and are among the most fundamental problems in algorithmic research. Examples include Min Cut, Max Cut, Multicut, Multiway Cut, Feedback Vertex Set, and Vertex Cover (see e.g. [21] for definitions of these problems). The latter is the special case of CNC with . Since Vertex Cover is arguably the most important problem in the theory of algorithmic design for NP-hard problems, CNC provides a natural test bed to see which of the techniques from this theory can be extended, and to what extent.

Previous Work and Applications.

The CNC problem has been studied from various different angles. The problem was shown to be NP-complete in [3] (although its NP-completeness follows directly from the much earlier NP-completeness result for Vertex Cover). In trees, a weighted version of CNC is NP-complete whereas the unweighted version can be solved in polynomial time [15]. The case of bounded treewidth can be solved using dynamic programming in time, where is the number of vertices in the graph and is its treewidth [1]. Local search [3] and simulated annealing [30] were proposed as heuristic algorithms for CNC. Finally, in [31] an approximation algorithm based on randomized rounding was developed.

Due to its generic nature, the CNC problem has been considered above in various different application settings. One example application is the virus vaccination problem discussed above [3]. Other interesting applications include protecting a computer/communication network from corrupted nodes, analyzing anti-terrorism networks [25], measuring centrality in brain networks [23], insulin signaling [29], and protein-protein interaction network analysis [8].

Our Results.

From reviewing the literature mentioned above, it is noticeable that an analysis of CNC from the perspective of parameterized complexity [16] is lacking. The purpose of this paper is to remedy this situation. We examine CNC with respect to four natural parameters along with all their possible combined aggregations. The four basic parameters we examine are:

  • The size of the solution (i.e. the critical node cut) .

  • The bound on the number of connected pairs in the resulting graph .

  • The number of connected pairs to be removed from ; if is connected with vertices then .

  • The treewidth of .

Table 1 summarizes all we know regarding the complexity of CNC with respect to these four parameters and their aggregation.

Parameter Result
FPT P-Kernel
NO (Thm. 1) NO (Thm. 1)
NO NO
YES (Thm. 15) NO (Thm. 17)
NO (Thm. 5) NO (Thm. 17)
YES (Thm. 3) YES (Thm. 4)
YES (Thm. 15) NO (Thm. 17)
? NO (Thm. 17)
YES YES
YES (Thm. 12) NO
YES (Thm. 15) NO (Thm. 17)
YES YES
YES (Thm. 3) YES (Thm. 4)
YES (Thm. 15) NO (Thm. 17)
YES YES
YES YES
Table 1: Summary of the complexity results for Critical Node Cut.

Let us briefly go through some of the trivial results given in the table above. First note that CNC with is precisely the Vertex Cover problem, which means that CNC is not in FPT (and therefore has no polynomial kernel) for parameter unless P=NP. This also implies that the problem is unlikely to admit a polynomial kernel even when parameterized by , since such a kernel would imply a polynomial kernel for Vertex Cover parameterized by the treewidth  which is known to cause the collapse of the polynomial hierarchy [6, 18]. Next, notice that if our input graph has no isolated vertices, we have , and therefore CNC is FPT and has a polynomial kernel (as isolated vertices can safely be discarded). This of course means that the same applies for parameters , , and .

Our first result, stated in Theorem 1, shows that CNC parameterized by is W[1]-hard. Thus, CNC is unlikely to have an FPT algorithm under this parameterization. We then show in Theorem 3 and Theorem 4, that when considering as a parameter, we can extend two classical Vertex Cover techniques to the CNC problem. Our main technical result is stated in Theorem 5, where we prove that CNC is W[1]-hard with respect to , the treewidth of the input graph. This is somewhat surprising since not many graph cut problems are known to be W[1]-hard when parameterized by treewidth. Also, the result complements nicely the -time algorithm of [1] by showing that this algorithm cannot be improved substantially. We complement this algorithm from the other direction by showing in Theorem 12 that CNC can be solved in time. Finally, we show in Theorem 15 and Theorem 17 that CNC is FPT with respect to , and has no polynomial kernel even if , , and are taken together as parameters.

Related Work.

This paper belongs to a recent extensively explored line of research in parameterized complexity where various types of graph cut problems are analyzed according to various natural problem parameterizations. This line of research can perhaps be traced back to the seminal paper of Marx [26] who studied five such problems, and in the process introduced the fundamental notion of important separators. This paper paved the way to several parameterized results for various graph cut problems, including Multicut [9, 22, 24, 26, 27, 28, 32], MultiwayCut [12, 13, 14, 22, 26, 32], and Steiner Multicut [10]. A particularly closely related problem to CNC is the so-called Vertex Integrity problem where we want to remove vertices from a graph such that the largest connected component in the remaining graph has a bounded number of vertices. Fellows and Stueckle [20] were the first to analyze this problem from a parameterized point of view. We refer the reader to [17] for a detailed overview of the known results on this problem.

2 Parameters and

We now consider the parameters and for CNC. We will show that the problem is W-hard for the former parameterization, while for the latter is in FPT and admits a polynomial kernel; the proofs are deferred to the appendix.

Theorem 1.

Critical Node Cut is W[1]-hard with respect to .

Proof.

We present a reduction111A somewhat similar reduction for related problems was given for example by Marx [26]. from the Clique problem: Given a graph on vertices, and a parameter , determine whether has a pairwise adjacent subset of vertices. Let be an instance of Clique. We construct , the graph of our CNC instance, as follows: We replace each edge in by a simple edge-gadget. This is done by replacing the edge by parallel edges, and then subdividing each of the new edges once. The newly inserted subdivision vertices are referred to as dummy vertices. We then add an edge in between each pair of nonadjacent vertices of . Finally, we set .

We claim that the graph has a clique of size if and only if the graph has vertices whose removal deletes

connected pairs in , where .

We begin with the easier direction: Suppose is a clique of size in , and let  denote the  many dummy vertices that have both neighbors in . Removing in results in the deletion of connected pairs from : A total of

  • connected pairs which involve only vertices of ,

  • pairs which involve one vertex from  and one vertex from ,

  • which involve only vertices from , and

  • connected pairs that involve one vertex of  and one vertex of .

Conversely, suppose that is a cut that removes connected pairs in . Observe that if contains a subset of dummy vertices, then we can replace with an arbitrary equally sized set of non-dummy vertices without decreasing . Thus, we can assume that contains only non-dummy vertices. Furthermore, notice that when we remove a non-dummy vertex  (i.e., a vertex of ), then the only connected pairs that are deleted are the ones which either involve  or possibly dummy vertices that are neighbors of . This is because every pair of vertices from is either connected by an edge or by an edge-gadget in . Now, for every set  of size , removing  deletes exactly connected pairs that contain exactly one vertex from . Thus, the only way to delete connected pairs in is to isolate  dummy vertices. This is only possible if we remove  vertices which are pairwise connected by edge-gadgets; these correspond to vertices that form a clique in . ∎

We next show that the above result holds also for some restricted subclasses. A split graph is a graph in which the vertices can be partitioned into a clique and an independent set. We slightly modify the construction in the proof of Theorem 1 by adding all the edges missing between every pair of non-dummy vertices. In this way, the vertices of form a clique and the dummy vertices form an independent set, while all arguments in the proof above still hold. For a fixed integer , a graph is called -degenerate if each of its subgraphs has a vertex with a degree of at most . For (i.e. a forest), the CNC problem has a polynomial algorithm based on dynamic programming [15]. We modify the construction in the proof above by subdividing all the edges except those that are adjacent to dummy vertices. This results in a -degenerate graph, and also a bipartite graph with one side containing all vertices of and the other containing all the (old and “new”) dummy vertices. Let  denote the number of vertices in the new graph . Again,  has a set of  vertices such that removing these vertices deletes  pairs if and only if  has a clique of size . This can be seen as follows. The only vertices that can be come disconnected by removing at most  vertices are the dummy vertices. Thus, there is a solution in which no dummy vertex is removed: If its neighbors are both removed, then removing  does not destroy any other pair. Otherwise, the same number of connected pairs can be deleted by removing one of the neighbors instead, as they are still connected even if  is removed. Thus, all removed vertices correspond again to vertices of the Clique instance. Now the remaining part of the proof is exactly the same as in Theorem 1 except that now removing a pair of vertices that are nonadjacent in the Clique instance isolates one “new” vertex, but this is still much less than the  isolated dummy vertices in the case of vertices that are adjacent in the Clique instance.

Corollary 2.

Critical Node Cut remains W[1]-hard with respect to even if the input graph is split, bipartite, or -degenerate for any fixed .

We next consider the parameter . We will show that the basic techniques known for the case of , i.e., the Vertex Cover problem, can be extended to the case where . First, a simple branching strategy can be developed into an FPT algorithm for the parameter .

Theorem 3.

Critical Node Cut is FPT with respect to .

Proof.

Let be an instance of CNC, and let denote the number of vertices in . Observe that if there exists a of size such that has at most connected pairs, then has at most edges. Using this observation we will solve an auxiliary problem in order to determine whether has a solution. The objective of our auxiliary problem is to determine whether there exist vertices such that has at most edges. Observe that we can solve this problem using the bounded search tree technique. For an arbitrary edge , we recursively branch on each of the following instances , , and . Here,  denotes the graph obtained by removing the edge  (and not the graph obtained by removing the two endpoints of ). This process continues recursively until no edges remain, or .

An important attribute of this search tree algorithm is that it enumerates all the possible minimal solutions. Therefore, after applying the above algorithm, we obtain the set of all the minimal solutions to our auxiliary problem. If there exists a solution to our CNC instance, then is also a solution for the auxiliary problem but not necessarily a minimal solution. We apply brute force on each minimal solution in to check if it is possible to extend it into a solution for CNC. If this is not possible for every solution in , then our CNC instance has no solution.

To analyze the running time of the algorithm described above, note that solving our auxiliary problem requires time, and the size of the set of all minimal solutions generated by this algorithm is bounded by . Let us next bound the running-time required for processing each minimal solution: Assume  contains vertices, leaving us a budget of vertices for our critical node cut. Now we can discard isolated vertices in since these are irrelevant, and obtain a graph with at most vertices. If , then all vertices can be deleted. Otherwise, checking each possible way to extend into a critical node cut requires time, and the running time of the entire algorithm is . ∎

The running time can be improved by using a more elaborate approach in the last step. For example, isolated edges can be dealt with in a dynamic programming subroutine. Then the remaining instance on which brute-force has to be applied has at most  vertices. Next, we show that a simple “high-degree rule” leads to a polynomial kernel.

Theorem 4.

Critical Node Cut has a polynomial kernel with respect to .

Proof.

Let be an instance of CNC. We will show a polynomial reduction from to an equivalent instance of CNC such that the number of vertices in is polynomial in . Our algorithm is in the same spirit of Buss’s classical Vertex cover kernel [11]. We construct by iteratively applying a high-degree rule until it can no longer be applied: Start with . Note that a vertex with more than neighbors must be in any critical node cut of size . Thus, our high-degree rule checks if there is a vertex with degree at least in the graph, and if so, it removes it and decreases by one. Once all high degree vertices are removed, we remove all isolated vertices to obtain . Clearly, this reduction runs in polynomial time. Moreover, is a yes-instance iff .

Let us next bound the number of vertices in . Suppose there is a of at most vertices where has at most connected pairs. We partition the remaining vertices of into two sets and , . The set contains all isolated vertices in , while contains the non-isolated vertices of . Clearly , since otherwise there would be more than connected pairs in . Now, since has no isolated vertices by construction, each vertex of  is adjacent to at least one vertex of . Moreover, since each vertex of  has at most neighbors, and has at most vertices, this implies that . Thus,

and the theorem is proved. ∎

3 Parameter

In this section we will show that CNC is unlikely to be fixed-parameter tractable when parameterized by . This implies that we cannot substantially improve on the algorithm of [1]. Since we will not directly use the notion of treewidth and tree decompositions, we refer to [4] for their definition.

Theorem 5.

Critical Node Cut is W[1]-hard with respect to the treewidth  of the input graph.

Our proof of the theorem above is via the well-known multicolored clique technique [19] which utilizes generic gadget structure to construct a reduction from the W[1]-complete Multicolored Clique problem: Given an undirected simple graph with vertices and edges, a coloring function of the vertices of , and a parameter , determine whether has a clique which includes exactly one vertex from each color. Throughout the section we use to denote an arbitrary input to Multicolored Clique. As usual in parameterized reductions, we can assume that and are sufficiently larger than any fixed constant, and is sufficiently larger than .

In the multicolored clique technique, we construct selection gadgets which encode the selection of vertices and edges of (one per each color class and pair of color classes, respectively), and validation gadgets which ensure that the vertices and edges selected indeed form a clique in . In our reduction below, we will force any feasible solution to delete a large number of vertices from the constructed CNC instance in order to reach the required bound on the number of remaining connected pairs. We will ensure that such a solution always leaves very large components which encode the selection of edges in . The bound on the number of connected pairs will require all these huge components to have equal size, which in turn can only happen if the edges selected in are edges between the same set of vertices (implying that these vertices form a clique in ). In what follows, we use to denote the instance of CNC that we construct, where is the input graph, is the size of the required cut, and is the bound on the number of connected pairs. Note that for our proof to go through, we will also need to show that the treewidth of is bounded by some function in .

Connector gadgets: To each vertex , we assign two unique integer identifiers: and , where . Our selection gadgets are composed from gadgets which we call connector gadgets. A connector gadget corresponds to a vertex of , and can be of low order or high order. A low order connector gadget corresponding to a vertex consists of a clique of size and an independent set of size which have all edges between them; that is, it is a complete split graph on these two sets of vertices. Similarly, a high order connector gadget corresponding to is a complete split graph on a clique of size and an independent set of size .

We refer to the clique in a connector gadget as the core of the gadget, and to the remaining vertices as the guard of the gadget. Only vertices in the core will be adjacent to vertices outside the gadget. Notice that the huge independent set in the core contributes to a large number of connected pairs in , and one can delete all these connected pairs only by adding all core vertices to the solution cut. Below we use this property to help us control solutions for our CNC instance.

Selection gadgets: The graph consists of a selection gadget for each vertex and edge in (see Figure 1): For a vertex , we will construct a -selection gadget as follows: First we add a clique of size  to , and then we connect all the vertices of to an additional independent set of vertices, which we call the dummy vertices of the -selection gadget. We next connect to gadget pairs, one pair for each color . Each pair consists of a low order and a high order connector gadget corresponding to . We let and respectively denote the core and guard of the connector gadget associated with color and of order . We connect to each connector gadget by adding all edges between all vertices of and , for each and .

For an edge , we will construct a -selection gadget as follows: First we add a vertex which we denote by to . We then connect to a low order and a high order connector gadget associated with , and to a low order and a high order connector gadget associated with , by adding all edges between vertex and the core vertices of these gadgets. We let and respectively denote the core and guard of the connector gadget corresponding to of order in the -selection gadget. Finally, we connect to an additional set of dummy neighbors of degree one in .

Validation gadgets: We next add the validation gadgets to , one for each ordered pair of distinct colors , . For such a pair , the -validation gadget simply consists of two cliques and , each of size . The validation is done through the connections of these two cliques to the remainder of the graph. Consider a -selection gadget for a vertex of color . We add all possible edges between and , and all edges between and . This is done for every vertex of color . Consider next a -selection gadget where and . We add all possible edges between and , and all possible edges between and . In this way, is connected to low order connector gadgets of vertex selection gadgets and to high order connector gadgets of edge selection gadgets, and is connected in the opposite way.

Figure 1: The connection of selection gadgets via a validation gadget. In the example, we consider a vertex with which is adjacent to a vertex with . The diagram depicts the pair of low and high connector gadgets associated with color in the -selection gadget that are connected to the -selection gadget. The remaining pairs of connector gadgets in the -selection gadget are not depicted. The rectangle boxes represent cliques and each ellipsis represents an independent set. The dotted lines depict a complete set of edges between two sets of vertices.

CNC instance: The graph of our CNC instance is thus composed of  validation cliques which have  vertices each,  vertex selection gadgets each of size , and edge selection gadgets which have vertices each. We finish the description of our reduction by setting , the size of the required critical node cut, to

and setting , the bound on the number of connected pairs, to

Lemma 6.

The graph has treewidth at most .

Proof.

In our proof we use two easy and well known facts about treewidth: The treewidth of a graph is the maximum treewidth of all its components, and adding vertices to a graph of treewidth at most results in a graph of treewidth at most . Using these two facts we get that a connector gadget has treewidth at most , since we add vertices to a graph of treewidth 0 (the independent set of vertices). From this we conclude that each selection gadget has treewidth at most , since we either add a clique of size or a single vertex to a graph whose connected components have treewidth bounded by . Therefore, since  itself is constructed by adding validation vertices to a graph whose connected components have treewidth at most , the lemma follows. ∎

From a multicolored clique to a critical node cut: Suppose has a solution, i.e., a multicolored clique of size . Then one can verify that the cut defined by

is of size , and contains exactly three types of non-trivial connected components:

  • components which include a clique of size along with dummy vertices.

  • components which include a single vertex of along with dummy vertices.

  • components which have vertices each.

Thus, has exactly connected pairs, and is indeed a solution to .

From a critical node cut to a multicolored clique: To complete the proof of Theorem 5, we show that if has a solution, i.e., a cut of size where has at most connected pairs, then has a multicolored clique of size . We do this, using a few lemmas that restrict the structure of solutions to our CNC instance. The first one of these, Lemma 7 below, shows that we can restrict our attention to cuts which include only core vertices of connector gadgets and vertices of .

Lemma 7.

If there is a solution to , then there is a solution to this instance which includes no guard vertices, no dummy vertices, and no validation vertices of .

Proof.

Let be a solution to . If includes any dummy vertex  of , then since  is a vertex whose neighborhood is a clique, we can replace  with one of its neighbors (which is a non-dummy vertex) or if  contains all of the neighbors of , we remove  from . In both cases, the number of connected pairs in is not decreased. Similarly, if  includes guard vertices, these can be safely replaced with core vertices.

Next, we show that  cannot contain any validation clique completely. To this end, note that a core of a connector gadget which is not completely included in  contributes more than  connected pairs in . This can be seen by counting the number of connected pairs between a single core vertex and all of its guard neighbors. Thus, since assuming a sufficiently large , the cut must include all but at most cores of connector gadgets in . But as each validation clique is of size (for sufficiently large ), we have , which means that if includes a validation clique it does not include enough cores. Thus, cannot completely contain any validation clique.

Finally, consider the case that contains a proper subset of some validation clique  in . Observe first that if the validation clique is not completely isolated in , then a vertex  can be safely replaced by a core vertex that is adjacent to  as  is not a cut vertex in . Thus, the only remaining case is that all vertices that have a neighbor in  are in . Then, deleting the vertices in  removes at most  connected pairs. By the choice of , and the number of core vertices,  cannot contain all core vertices. Consider a core vertex . Since  does not contain any guard vertices, adding  to  removes at least  connected pairs. Thus, we can remove all vertices of  from  and replace them by  without increasing the number of connected pairs in . Thus, there is a solution that contains no vertices of validation cliques. ∎

Assume that has a solution, and fix a solution as in Lemma 7. By the definition of , we know that the cut cannot include all connector gadgets. A connector gadget in induces a large number of connected pairs, at least , due to the guard vertices of the gadget. Let us therefore call a connected component in huge if it contains at least connected pairs. The next lemma shows that there can only be a certain number of these huge components in , and reveals some restriction on any solution cut . We call a maximal non-empty (but not necessarily proper) subset of a core in a partial core.

Lemma 8.

If is a solution to as in Lemma 7, then includes cores. Furthermore, there are precisely huge components in , each of which consists of a validation clique, two partial cores, and the two guard sets of the partial cores.

Proof.

Let denote all partial cores in . Note that since each core is of size (for sufficiently large ), the cut can include at most complete cores by definition of , and so . By Lemma 7, the graph contains all validation cliques. Let denote the components in that contain at least one validation clique, and let for each , . Observe that for any huge component in , we have .

Now, since the total number of validation cliques is , we have , and the total number of connected pairs in all the ’s is lower bounded by . Note that each partial core belongs to some and contributes at least vertices to its size (accounting for a single vertex of and all its guard neighbors), and therefore at least connected pairs. It can now be seen that since is concave and symmetric then it is minimized when the number of addends is as large as possible and all of the addends are of equal size. This happens when and each includes exactly two ’s, giving us . If or there is one that contains more then two ’s, then the sum will be at least . It follows that there are exactly huge components, that each have two ’s. These huge components contribute altogether at least connected pairs.

We have thus established that there are huge components in , and each includes a validation clique, two partial cores, and the guard sets adjacent to these partial cores which are not in according to Lemma 7. To see that the huge components contain nothing else recall first that the overall number of connected pairs in these huge components is at least . Thus, the number of further additional connected pairs in  is at most . Now, if contains other vertices, then by construction it must contain either a vertex from a clique  corresponding to a vertex  of , or a vertex  corresponding to an edge of . In either of these cases, this additional vertex is adjacent to at least  dummy vertices, implying that  has an additional number of  connected pairs, a contradiction. ∎

Slightly smaller than huge components are large components in which have at least connected pairs and fewer than connected pairs. Further smaller are big components which have at least connected pairs, and less than connected pairs.

Lemma 9.

If is a solution to as in Lemma 7, then includes exactly cliques corresponding to vertices , and there are precisely large components in .

Proof.

Note that . By Lemma 8, we know that contains huge components, and so these already account for connected pairs in . For every , if the clique corresponding to is not completely contained in , then there is a large component corresponding to in , since by Lemma 7, all dummy neighbors of are existent in . Furthermore, any large component in is of this form. Thus, if contains cliques corresponding to vertices of , then the number of connected pairs in is at least , a contradiction. Moreover, by our choice of , the cut cannot include cores (as is necessary by Lemma 8) and more than such cliques , since .

Lemma 10.

If is a solution to as in Lemma 7, then includes exactly vertices which correspond to edges in , and there are precisely big components in .

Proof.

Let us call each element in the set a -element. Thus, each -element belongs to its unique selection gadget in , and corresponds to either a vertex or an edge of . Moreover, each core is adjacent to exactly one -element. By Lemma 9 we know that contains -elements corresponding to vertices of . We next argue that it also contains -elements corresponding to edges of .

Consider a huge component  in . By Lemma 8 contains two partial cores and and  does not contain the unique -element that is adjacent to the two partial cores. Thus, the -element neighbors of exactly  partial cores are contained in . The set of cliques  promised by Lemma 9 accounts for at most such cores, as each  has exactly  neighboring cores in . Notice that by the choice of , after accounting for the vertices in required by Lemma 8 and Lemma 9, the remaining number of vertices is . Another -element representing a vertex requires , thus all remaining deleted -elements correspond to edges of . Now observe that each of them can account for at most four partial cores as they have exactly four neighboring cores in . Consequently, the number of deleted -elements that correspond to edges in  is at least . By the choice of , it is thus exactly . ∎

Lemma 11.

The set of vertices specified in Lemma 9 induces a multicolored clique in .

Proof.

Lemma 8, Lemma 9, and Lemma 10 together state that includes at least core vertices, at least vertices in cliques corresponding to vertices of , and at least vertices corresponding to edges of . By our selection of , all these lower bounds are in fact equalities. Thus, all but cliques , , are present in , and all but edges of are present in . All these vertices contribute at least connected pairs in , due to their dummy neighbors. Thus, by definition of , the total number of connected pairs from huge components in is .

Now, note that according to Lemma 8, includes exactly partial cores with no neighboring -elements. The set of cliques  ,promised by Lemma 9, accounts for at most partial cores, only if each vertex is of a different color. Moreover, the deleted -elements that correspond to edges in , promised by Lemma 10, accounts for at most partial cores, only if each edge corresponds to a different pair of colors. Consequently, the only way to remove the required number of neighboring -elements is if these upper bounds are met with equality. Thus, the vertices and edges corresponding to the removed -elements are of different colors, as required in a multicolored clique.

Finally, observe that due to the fact that we have accounted for all the vertices in , it is clear that each huge component consists of two complete (i.e. non-partial) cores. Thus, the size of each of these huge components is for . Therefore, the only way for the total number of connected pairs in all huge components to not exceed is if all huge components have equal size, i.e., exactly  vertices each. But this can happen only if we have in the pair of connector guards  and , in each huge component of , as this is the only way for the guard vertices to sum up to . Consequently, the set of edges selected in are edges between implying that they indeed form a clique. ∎

4 Parameter

If we combine the treewidth parameter  with the parameter for the number of connected pairs , then we obtain fixed-parameter tractability. This can be derived via an optimization variant of Courcelle’s theorem due to [2]. Using tree decompositions, we obtain a more efficient algorithm.

A nice tree decomposition [4] of a graph is a pair , where each element (called a bag) is a subset of , and is a rooted tree over . The pair is required to satisfy the following conditions:

  1. .

  2. For every edge , there is an with .

  3. For all , if lies on the path between and in , then .

  4. There are types of bags:

    1. A leaf bag which has no children in and contains a single vertex .

    2. An introduce bag which has a single child in with for some vertex .

    3. A forget bag which has a single child in with for some vertex .

    4. A join bag which has two children and in with .

Note that Conditions  define a tree decomposition and their combination with Condition  defines a nice tree decomposition. The width of a tree decomposition is the number of elements in the largest bag minus . The treewidth of is the minimum width of all the possible tree decompositions of . For a given graph with treewidth , one can obtain its nice tree decomposition in with bags [4, 5]. Thus, in proving the main result of this section, stated in the theorem below, we can assume that we are given as input a nice tree decomposition of width (and bags) of our input graph .

Theorem 12.

The Critical Node Cut problem is FPT with respect to .

Let be a bag from our nice tree decomposition, and let denote the subgraph of induced by the bag and all of its descendants in . We build a table for . Each entry in this table is denoted by , where , , and for all . The entry can either equal or . It equals iff there exist vertices in , , such that has at most connected pairs and is separated into components , with and for each , . If there is no such solution then the entry equals . Thus, an entry with value 1 corresponds to a partial solution that splits the bag in a very particular way. Note that are only the components that intersect the bag . Our algorithm calculates the tables of each node in the decomposition in a bottom-up fashion. Clearly, if each entry is computed correctly then one can infer whether there exists a solution to the CNC instance by examining the table at the root. Note that for each bag the size of the table is , thus if we show that calculating an entry can be done in FPT time, then we prove that our algorithm altogether runs in FPT time.

We will next show how to calculate for each possible type of bag . If is a leaf bag, then is composed of one vertex only, and therefore the computation in this case is trivial. If is a forget bag with a child such that for , then the entry will equal if and only if there exists in the table of an entry that equals . This is correct because the only difference between the entries is that , therefore it is excluded from its partition, yet it is still counted by the value as a member of the corresponding component. To complete the proof of Theorem 12, we show in the next two lemmas that we can efficiently calculate each entry in also if is an introduce or a join bag.

Lemma 13.

If is an introduce bag with child , then, given the table , an entry in can be calculated in  time.

Proof.

Let be the single vertex in , and consider an arbitrary entry

in the table of . There are three possible cases:

  1. . The entry in will equal iff in we have

  2. and is not adjacent to any vertex in . The only type of entry that might have value is an entry where for some , and . If this is the case then the current entry in will be iff we have

  3. and is adjacent to vertices of . By the properties of a tree decomposition, in the vertex can only have neighbors from . Let denote these neighbors. Then the only entries in that might have value 1 are entries with a subset that includes and all his neighbors. If the current entry in  is as such, then it will have value iff

    for an entry in where are precisely the subsets of that include neighbors of , ,