On Critical Node Problems with Vulnerable Vertices

. A vertex pair in an undirected graph is called connected if the two vertices are connected by a path. In the NP-hard Critical Node Problem (CNP), the input is an undirected graph G with integers k and x , and the question is whether one can transform G by deleting at most k vertices into a graph whose total number of connected vertex pairs is at most x . In this work, we introduce and study two NP-hard variants of CNP where a subset of the vertices is marked as vulnerable , and we aim to obtain a graph with at most x connected vertex pairs containing at least one vulnerable vertex. In the first variant, which generalizes CNP, we may delete vulnerable and non-vulnerable vertices. In the second variant, we may only delete non-vulnerable vertices. We perform a parameterized complexity study of both problems. For example, we show that both problems are FPT with respect to k + x . Furthermore, in the case of deletable vulnerable nodes, we provide a polynomial kernel for the parameter vc + k , where vc is the vertex cover number. In the case of non-deletable vulnerable nodes, we prove NP-hardness even when there is only one vulnerable node.


Introduction
Detecting important vertices in graphs is a central task in network analysis.There is an abundance of different formalizations of this natural task, many of which adopt the view that a vertex set is important if its removal severely affects the connectivity of the remaining graph [13].One concrete |A| y k vc diam x Figure 1: Dependencies between the considered parameters after preprocessing (see Section 2).If two parameters are connected by a solid line, then the parameter above is never smaller than the parameter below; if they are connected by a dotted line, then this relation holds only for CNP-V.
Related Work.Arulselvan et al. [4] showed that CNP is NP-complete; the NP-hardness follows also directly from the fact that CNP is a generalization of Vertex Cover (x = 0).As a consequence, CNP is NP-hard even on subcubic graphs.CNP is also NP-hard on split and bipartite graphs [1] and on power-law graphs [17].In contrast, CNP can be solved in polynomial time on trees [6] and, more generally, on graphs with constant treewidth [1].The parameterized complexity of CNP has been studied with respect to the parameters k, x, and the treewidth tw of G [12]: On the negative side, CNP is W [1]-hard with respect to k [12] or tw [12], and even with respect to k + tw [2].On the positive side, the problem is FPT with respect to k + x [12] and with respect to the parameter y [12] which is defined as ℓ − x, where ℓ is the number of connected pairs in G.In other words, for CNP, y is the minimum number of connected pairs we want to remove by deleting k vertices.Other formulations of graph modifications for limiting disease spreading consider for example edge deletions and limiting the size of the largest remaining connected component [8].For an overview of different formulations of critical vertex detection, refer to the survey of Lalou et al. [13].
Our Results.We study the parameterized complexity of the problems CNP-V and CNP-NDV with respect to a number of natural parameters.An overview of the parameters in our study and their relations is shown in Figure 1.Our main findings are as follows (an overview is given in Table 1).
We transfer the FPT-algorithm for k + x from CNP to the two new problems (Corollary 2, Theorem 5, Corollary 1).We then show that, while being solvable in polynomial time for constant values of x (Proposition 2), CNP-NDV is W [1]-hard with respect to x even when |A| = 1 (Theorem 2).In contrast, CNP-V is solvable in polynomial time for constant |A| (Proposition 3) and NP-hard already for x = 0 [12].Thus, the complexity of the two problems differs quite drastically with respect to very natural parameters.
We also study parameterization by the number y of deleted connected pairs containing at least one vulnerable vertex.Formally, let ρ be the number of connected pairs containing at least one vulnerable vertex.Then, ρ = x + y.Note that for CNP-V and CNP-NDV the definition of y is different than for CNP.The reason for this is that in CNP-V and CNP-NDV we are only interested in connected pairs containing at least one vulnerable vertex.We also observe a drastically different behavior for both problems by parameterization with y: CNP-V has a subexponential FPT-algorithm (Theorem 6) while CNP-NDV is W [1]-hard even with respect to k + y (Theorem 7).We remark that the algorithm for CNP-V with subexponential running time for parameter y improves on a previous algorithm for CNP with exponential running time in y [12].
Finally, we consider parameterizations using the vertex cover number vc of G.This is moti- vated by the fact that CNP is W [1]-hard with respect to the treewidth tw [2,12] and thus larger structural parameters need to be considered.We show that both problems are FPT with respect to vc (Theorem 8), and provide polynomial kernels for both problems parameterized by vc +x (for CNP-V) and vc +k + x (for CNP-NDV), respectively (Theorem 9).Further FPT results for parameters such as the neighborhood diversity of G or |V \ A| have been obtained in the first author's Master thesis [15].
Preliminaries.For two integers p and q, p ≤ q, we denote [p, q] := {p, . . ., q}.We consider undirected simple graphs G = (V, E) and let V (G) denote the vertex set and E(G) the edge set of a graph G.We use n G to denote the number of vertices and m G to denote the number of edges of G, we omit the subscript if G is clear from context.Two vertices u, v ∈ V are connected, if G contains a path P starting in u and ending in v.
A vertex cover of a graph G = (V, E) is a subset S ⊆ V such that every edge of G has at least one endpoint in S. For a graph G, the vertex cover number vc(G) is the size of a smallest vertex cover of G.If it is clear from the context to which graph we refer, we write vc instead of vc(G).
A branching rule for some problem L is a computable function that maps an instance I of L to a tuple of instances (I 1 , . . ., I t ) of L. A branching rule is called correct if I is a yes-instance of L if and only if there is some i ∈ {1, . . ., t} such that I i is a yes-instance of L. A reduction rule for some problem L is a computable function that maps an instance I of L to an instance I ′ of L. In some reduction rules, we write return yes or return no, which formally means that we return a constant-size yes-instance or no-instance, respectively.
Parameterized Complexity is the analysis of the complexity of problems depending on the input size |I| and a problem parameter k [5,7].A parameterized problem L is in XP if there is an algorithm with running time |I| f (k) that solves L; such an algorithm is called an XP-algorithm.That is, a problem is in XP if it can be solved in polynomial time whenever the parameter is constant.A parameterized problem L is fixed-parameter tractable (FPT) if there exists an algorithm with running time f (k)•|I| O(1) for some computable function f that solves L; such an algorithm is called an FPT-algorithm.An important tool in the development of parameterized algorithms is problem kernelization, which is a polynomial-time preprocessing by reduction rules.Formally, a problem L admits a problem kernel if there exists an algorithm that given any instance (I, k) of L computes an equivalent instance ( Here, g is some computable function only depending on k.The function g is called kernel size.A kernel has polynomial size if g is a polynomial.
A parameterized reduction of a parameterized problem L to a parameterized problem L ′ is an algorithm that maps any instance (I, for some computable functions f and g.If a parameterized problem is W [1]-hard, then it is assumed to be not fixed-parameter tractable.If there is a parameterized reduction from a W [1]-hard problem L to a parameterized problem L ′ , then the problem L ′ is W [1]-hard as well.
Organization.In Section 2 we provide simple basic observations on the studied problems.Afterwards, we consider the parameterized complexity.In Section 3.2 we study parameterization by the target vulnerability x.In Section 4, we study parameterization by the number of vulnerable connections y that shall be removed from the graph.Finally, in Section 5, we study structural parameterization by the vertex cover number of the input graph.

Basic Observations
In this section, we provide basic observations which we use throughout this work.We first describe how to compute the A-vulnerability of a given graph and a set of vulnerable vertices.Afterwards, we consider simple reduction rules, so that we may use additional assumptions regarding the input instances.Finally, we establish a technical term of component information and show that CNP-NDV is NP-hard.
Vulnerability.First, observe that the A-vulnerability of a graph can be computed in linear time via depth-first search.
Proof: In O(n + m) time all connected components can be computed using depth-first search.Then, for every connected component K, by iterating over all vertices of the connected component, the number of vulnerable vertices d and the size c := |K| of the connected component K can be computed in linear time.The A-vulnerability of the connected component K is The A-vulnerability of G is the sum of the A-vulnerability of the connected components.Altogether, we can compute the A-vulnerability of any given graph in O(n + m) time.□ For a constant k, CNP-V and CNP-NDV can thus be solved in polynomial time by trying all O(n k ) possibilities of deleting k vertices (in the case of CNP-NDV only deletions in V \ A are considered).
Recall that a critical node cut C is the set of removed vertices from the problem.For CNP-NDV at most x non-vulnerable vertices can be connected to vulnerable vertices in G−C.Thus, one can find a critical node cut by considering all O(n x ) possible sets B for these vertices, deleting all neighbors of A ∪ B, and checking whether the number of deletions is at most k and the A-vulnerability of the resulting graph is at most x.definition.
Reduction Rules.We provide a collection of simple reduction rules for CNP-V and CNP-NDV that establish useful instance properties and parameter relations.The first rule removes trivial components from the input.
Reduction Rule 1 Let I := (G, A, k, x) be an instance of CNP-V or CNP-NDV and let Z be a connected component of G.If Z contains no vulnerable vertex or Z is an isolated vulnerable vertex, then delete Z from G.
Reduction Rule 1 is safe since no vertex of Z is part of a vulnerable connection.For the remainder of this work, we assume that all instances of CNP-V and CNP-NDV are reduced with respect to Reduction Rule 1.The next rule identifies instances of CNP-V and CNP-NDV that are trivial because k is sufficiently large.
Reduction Rule 2 a) Let (G, A, k, x) be an instance of CNP-V.If y ≤ k, then return yes.b) Let (G, A, k, x) be an instance of CNP-NDV such that y ≤ k.If |V \ A| ≥ y, then return yes.
If |V \ A| < y, check if the number of vulnerable connections in G − (V \ A) is at most x.If this is the case, return yes.Otherwise, return no.
Lemma 2 Reduction Rule 2 is safe and can be exhaustively applied in O(n + m) time.
Proof: Safeness: Since the instance is reduced with respect to Reduction Rule 1, every vertex of the graph is in at least one vulnerable connection.Next, we show a) and b) separately.First, we prove a).We iteratively do the following y-times: If there is a vertex v such that at least one vulnerable connection contains v, then remove v from G. If there is no such vertex or G is empty, no vulnerable connection remains, and we have a yes-instance.Otherwise, we removed y < k vertices from G and we thereby removed y vulnerable connections from G. Thus, we have a yes-instance.
Second, we show b).Suppose that |V \ A| ≥ y.Since Reduction Rule 1 is applied exhaustively, for each vertex in |V \ A| we remove from G, we remove at least one vulnerable pair from G. Thus, we have a yes-instance.Otherwise, we have |V \A| < y.Since we can only remove vertices in V \A, we can now check whether G[A] has at most x vulnerable connections.
Running Time: Clearly, this rule can be exhaustively applied in linear time.□ In the remainder of this work, we assume that Reduction Rule 1 has been applied exhaustively.Thus, we may assume y > k throughout the rest of this work.
In the case of CNP-V, we can identify a further class of yes-instances.An instance of CNP-V with |A| ≤ k is a trivial yes-instance since adding all vulnerable vertices to a critical node cut destroys all vulnerable connections.
Reduction Rule 3 Let (G, A, k, x) be an instance of CNP-V.If |A| ≤ k, then return yes.
The final rule deals with the case where one vertex has too many vulnerable neighbors.The idea behind the rule is that a vertex that causes too many vulnerable connections in its neighborhood belongs to every possible critical node cut.vulnerable connections {w 1 , w 2 } with w 1 , w 2 ∈ N (v).Altogether there are at least vulnerable connections in G. Thus, every critical node cut contains v.
Running time: For every vertex in G, we can compute the number of neighbors in A in O(m+n) time.For CNP-NDV we then remove all vertices from V \ A that have sufficiently many neighbors in A. This is an exhaustive application of the rule since the vertex removal does not change the number of neighbors in A and also not the degree threshold for removal.For CNP-V, the procedure is slightly more complicated: we put all the vertices in a bucket queue, that is, a dynamic data structure of elements equipped with integral priorities, according to their number of neighbors in A with values ranging from 0 to |A|.We then consider the entries in this bucket queue by decreasing values starting with i = |A|.As long as i > k + √ 2x, we choose some vertex v with value i, remove v from G, update the values for all neighbors of v in O(|N (v)|) time, and decrement k.If there is no vertex with value i, then we decrement i.Overall, this procedure takes O(m + n) time. □ Throughout the remainder of this work, we assume that all instances are reduced with regard to the reduction rules stated above.We will thus make the following assumptions about instances of CNP-V and CNP-NDV: First, let (G, A, k, x) be an instance of CNP-V.We assume that every connected component of G contains a vertex from A (Reduction Rule 1), y > k (Reduction Rule 2), |A| > k (Reduction Rule 3), and Next, let (G, A, k, x) be an instance of CNP-NDV.Then, we assume that every connected component of G contains a vertex from A (Reduction Rule 1), y > k (Reduction Rule 2), and Recall that CNP-V and CNP-NDV can be solved in O(n k •(n+m)) time due to Proposition 1.By the parameter relations stated above, we obtain the following.
Component Information.We next show that CNP-V and CNP-NDV are solvable in polynomial time if we have additional information about the connected components of the input graph.We apply this fact to obtain efficient algorithms for both problems when the connected components are small.Let I := (G, A, k, x) be an instance of CNP-V or CNP-NDV, and let Z 1 , . . ., Z t ⊆ V be the connected components of the input graph G. Intuitively, a component information T [i, k ′ ] for some integers i ∈ [1, t] and k ′ ∈ [0, k] provides information on how small the number of vulnerable connections in Z i can be after k ′ vertex deletions.Formally, T [i, k ′ ] is defined as the minimal number of vulnerable connections in G[Z i ] − S among all subsets S ⊆ Z i of size exactly k ′ .If there is no such subset S containing exactly k ′ vertices that may be removed, we set We now show that CNP-V and CNP-NDV can be solved in polynomial time if we have a component table of the input instance.The algorithm was also described by Hermelin et al. [12] for CNP.

Lemma 4 Given an instance
Proof: Algorithm: Let Z 1 , . . ., Z t be the connected components of the input graph G.We show the lemma by providing a dynamic programming algorithm.In the dynamic programming table Q, each entry The recurrence to compute an entry for i > 1 is Here, we check all possibilities of k ′′ on how many deletions are done in the i-th connected component.If Q[t, k] ≤ x return yes.Otherwise, return no.
Running time: Component information will be utilized in Theorem 6 of Section 4 to provide an efficient FPTalgorithm with respect to y.
NP-Hardness of CNP-NDV.In contrast to CNP-V, the problem CNP-NDV is not an obvious generalization of Vertex Cover.We show the following by a simple reduction.
Theorem 1 CNP-NDV is NP-hard on planar graphs, even if the input graph has maximum degree 4.
Proof: We reduce from Independent Set where the input is a graph G and an integer κ and the question is whether there exists a set X of κ vertices which are pairwise nonadjacent.Independent Set is NP-hard on planar graphs with maximum degree 3 [11].
Construction: Let (G, κ) be an instance of Independent Set where G is a planar graph with maximum degree 3. We construct an instance (G ′ , A, k, x) of CNP-NDV as follows: Intuitively, we add a copy of each vertex in V to A, connecting each copy to its respective original by an edge.Formally, we set ) can be computed in polynomial time.Note that every vertex in G ′ , that is not in G has degree 1 and G ′ [V ] is isomorphic to G. Thus, G ′ is planar and has maximum vertex degree 4. It remains to show that the two instances are equivalent.
Correctness: Let (G, κ) be a yes-instance of Independent Set.Then, there exists an independent set I ⊆ V (G) of size κ.We show that the vertex set V \ I is a critical node cut: The size of As I is an independent set in G, I is an independent set in G ′ as well.Thus, there are exactly κ edges in the graph G ′ − (V \ I).More precisely the edges remaining in Conversely, let (G ′ = (V ′ , E ′ ), A, k, x) be a yes-instance of CNP-NDV.Thus, there exists a critical node cut C of size n G − κ.The graph G ′ − C contains κ vertices that are not vulnerable and by the construction of G ′ , each of them is adjacent to a vulnerable vertex.Thus, these are all vulnerable connections in G 3 Parameterization by the Targeted Vulnerability

Hardness for Non-Deletable Vulnerable Vertices
First, we consider parameterization by x alone.CNP-V is NP-hard for x = 0 since it is a generalization of Vertex Cover.Recall that in contrast CNP-NDV can be solved in polynomial time for constant x due to Proposition 2. We complement this result by showing that CNP-NDV is W [1]-hard with respect to x, even if G contains only one vulnerable vertex.
Theorem 2 CNP-NDV is W[1]-hard with respect to the parameter x, even if |A| = 1 and G has diameter 2.
Proof: We reduce from Cutting at Most k Vertices with Terminal.Here, the input is a graph G, a vertex s ∈ V (G), and two integers k and t.The question is whether there exists a vertex set S ⊆ V (G) of size at most k such that s ∈ S and |N (S)| ≤ t.Fomin et al. [9] showed that Cutting at Most k Vertices with Terminal is W[1]-hard with respect to k. Construction: Let (G, s, k, t) be an instance of Cutting at Most k Vertices with Terminal.Let G ′ be the graph obtained by adding a universal vertex ū to graph G.In polynomial time we compute the instance (G ′ , A := {s}, k Because of the universal vertex ū, the diameter of G ′ is 2. Correctness: Let (G, s, k, t) be a yes-instance of Cutting at Most k Vertices with Terminal.Let S with |S| ≤ k be the vertex set such that s ∈ S and Conversely, let (G ′ , A, k ′ , x) be a yes-instance of CNP-NDV.Therefore, there exists a vertex set C of size at most k ′ = t + 1 such that in G ′ − C there are at most x vulnerable connections.Thus, there are at most x other vertices in the connected component of s in G ′ − C. Now, we distinguish between the cases that ū is in C or not.
Case 1: ū ∈ C. Define S as the connected component of s in G ′ − C. It follows that S has size at most x + 1 and is a subset of V (G).The neighborhood of S in G is a subset of C \ {ū} of size at most t.Thus, S is a solution of Cutting at Most k Vertices with Terminal.
Case 2: ū ̸ ∈ C.There are at most k ′ + x + 1 vertices in G ′ , because every vertex that has not been cut is then in a vulnerable connection with x.Thus, G has at most k + t vertices and any set S of size k is a solution of Cutting at Most k Vertices with Terminal, as long as s ∈ S.
In both cases we proved that (G, s, k, t) is a yes-instance of Cutting at Most k Vertices with Terminal.□

A general FPT-Algorithm for k + x
In the following, we provide an FPT-algorithm for CNP-V and CNP-NDV parameterized by k+x.
To unify the description, we consider the following more general problem.Roughly speaking, we allow for a set of non-deletable vertices which do not have to be vulnerable.

CNP-VNDV
Input: A graph G = (V, E), two sets A, N , and two integers k, x ∈ N. Question: Is there a vertex set C ⊆ V \N of size at most k such that the A-vulnerability of G − C is at most x?
Observe that CNP-V is the special case of CNP-VNDV where N = ∅ and CNP-NDV is the special case of CNP-VNDV where N = A.
Hermelin et al. [12] showed that CNP can be solved in O(3 k+x • (x k+2 + n)) time.The idea of this algorithm is to branch for each edge {u, v} whether one of u and v is deleted or whether this is one of the x remaining connections.In the following, we use similar ideas to provide two search tree algorithms for the more general CNP-VNDV.The first algorithm solves instances of CNP-VNDV with A ⊆ N in O(2 k+x • (n + m)) time.This implies that CNP-NDV can be solved within the same running time.The second algorithm solves arbitrary instances of CNP-VNDV Moreover, since CNP is a special case of CNP-V this improves over the algorithm for CNP by Hermelin et al. [12].
The first algorithm is based on the following branching rule.The idea of the rule is that for each deletable vertex, we may either decide to delete the vertex, which reduces the deletion budget by one, or to make this vertex non-deletable.
Conversely, let I 1 or I 2 be a yes-instance of CNP-VNDV.First, suppose there exists a critical node cut C for the instance I 1 .Then, the set C ′ := C ∪ {v} is also a critical node cut for I. Second, suppose that I 2 be a yes-instance of CNP-VNDV and let C be the corresponding critical node cut.It directly follows that C is also a critical node cut for I. □ The idea of the first algorithm, which works for the special case of CNP-VNDV with A ⊆ N , is now to apply Branching Rule 1 in such a way that in the second branch we increase the Avulnerability of the subgraph that is induced by the non-deletable vertices.This allows us to bound the depth of the search tree.Proof: We use a search tree algorithm based on Branching Rule 1.Each node of the search tree corresponds to an instance of CNP-VNDV with A ⊆ N .At each search tree node, we perform the following steps.First, if k < 0 or the A-vulnerability of G[N ] is greater than x, we return no.Second, if the A-vulnerability of G is at most x, we return yes.Third, we choose a vertex v ∈ V (G) \ N which is connected to some vertex of A via a path containing only internal vertices of N and branch on vertex v using Branching Rule 1 (see Figure 2 for an illustration).
The correctness of this algorithm can be seen as follows.The first two steps identify trivial noor yes-instances and are obviously correct.For the third step, observe that such a vertex v must exist since 1) the A-vulnerability of G is larger than the A-vulnerability of G[N ] and every path connecting a vertex from A with a vertex from V (G) \ N starts in N since A ⊆ N .Thus, the correctness of the third step follows from Branching Rule 1.
The running time bound can be seen as follows.Branching is only performed while k ≥ 0 and x ≥ 0. Hence, the depth of the search tree is at most k + x: in the first branch deleting v decreases k by one and in the second branch adding v to N increases the A-vulnerability of G[N ] by at least one.Thus, the search tree has a size of O(2 k+x ).Also, note that the steps at each search tree node can be performed in linear time.Hence, the overall running time follows.
□ To provide an FPT-algorithm for the case when vulnerable vertices may be deleted, we make use of another branching rule.This is necessary because we may face the situation that there is no vertex in V (G) \ N whose addition to N increases the A-vulnerability of G[N ].For example, this is the case when N = ∅.The new rule is applied on edges with at least one deletable vertex.It considers all possibilities to either delete an endpoint of the edge or to add the endpoints to the set of non-deletable vertices.
Branching Rule 2 Let I := (G = (V, E), A, N, k, x) be an instance of CNP-VNDV and let {u, v} ∈ E be an edge of G with v / ∈ N .Then, I is a yes-instance of CNP-VNDV if and only if Lemma 6 Branching Rule 2 is correct.
Proof: Let I be a yes-instance of CNP-VNDV and let C be a critical node cut.If v ∈ C, then C \ {v} is a critical node cut for the instance (G − {v}, A, N, k − 1, x) and thus I 2 is a yesinstance.Now, if u ∈ C then u / ∈ N .Consequently, the branching rule creates the instance I 3 .The set C \ {u} is a critical node cut for the instance (G − {u}, A, N, k − 1, x) and thus I 3 is a yes-instance.Otherwise, if u, v / ∈ C, then I 1 is a yes-instance, as C is also a critical node cut for I 1 .Conversely, suppose that I 1 or I 2 or I 3 is a yes-instance of CNP-VNDV.First, assume that I 1 is a yes-instance of CNP-VNDV and let C be a corresponding critical node cut.Then, C is also a critical node cut for I. Second, if I 2 is a yes-instance with a critical node cut C, then because v / ∈ N , the set C ∪ {v} is a critical node cut for I. Finally, if I 3 is a yes-instance with a critical node cut C, then because of the condition for creating the instance I 3 , we know that u / ∈ N .Thus, C ∪ {u} is is a critical node cut for I. □ least one node which is not contained in N .Hence, we may apply Branching Rule 2 on this edge (see Figure 3 for an illustration).
The correctness of this algorithm can be seen as follows.The first two steps identify trivial noor yes-instances and are obviously correct.For the third step, we show that such an edge {u, v} must exist.Then, the correctness of the third step follows from Branching Rule 2. If V (G) \ N contains a vulnerable vertex v, then the edge {u, v} where u is any neighbor of v may be chosen.Otherwise, A ⊆ N and there exists a vertex v in V (G) \ N which is connected to a vertex in A via a path P whose other vertices are all from N , because the A-vulnerability of G[N ] is strictly smaller than the A-vulnerability of G.We may branch on the edge {u, v}, where u is the neighbor of v on P .Altogether, this shows the correctness of the algorithm.
The running time bound can be seen as follows.Branching is only performed while k ≥ 0 and x ≥ 0. Hence, the depth of the search tree is at most k + x: In the first branch, adding {u, v} to N increases the A-vulnerability of G[N ] by at least one; in the second and, possibly, third branch the value of k is decreased by one.Thus, the search tree has a size of O(3 k+x ) since each internal node has at most three children.Since the steps at each search tree node can be performed in O(n + m) time, the overall running time follows.□ Corollary 2 CNP-V can be solved in O(3 k+x • (n + m)) time.

An Alternative FPT-Algorithm for Deletable Vulnerable Vertices
In the following, we provide an algorithm that solves CNP-V in O(( 4 3 x + 2) k • (m + n)) time.This running time is preferable when x is much larger than k.The idea of the algorithm is that we search a set B of at most 4  3 x + 2 vertices of G such that the A-vulnerability of G[B] is larger than x.Then, if there exists a critical node cut C, at least one vertex of B is in C.

Theorem 5 An instance
Proof: We use a search tree algorithm.Each node of the search tree corresponds to an instance of CNP-V.At each search tree node, first exhaustively perform Reduction Rule 1 which removes connected components that do not contribute to the A-vulnerability.Then, if k < 0, return no.Otherwise, if the A-vulnerability of G is at most x, return yes.If all remaining connected components have size at most 3, then return the result of the algorithm of Proposition 4. Now, in the remaining case, compute a vertex set B on which we can branch as follows.Let Z 1 , . . ., Z q denote the connected components of G that have size at least 4. If G[Z 1 ∪ . . .∪ Z q ] has A-vulnerability at most x, then set B := Z 1 ∪ . . .∪ Z q .Otherwise, let i ≤ q be the smallest number such that G[Z 1 ∪ . . .∪ Z i ] has A-vulnerability at least x + 1.First, add Z 1 ∪ . . .∪ Z i−1 and some vulnerable vertex v of Z i to B. Then, add any vertex of Z i to B that has a neighbor in B until G[B] has A-vulnerability at least x + 1. Afterwards, branch on B as follows: If I v := (G−{v}, A, k−1, x) is a yes-instance of CNP-V for some vertex v of B, then return yes.Otherwise, return no.
To show the correctness of the algorithm, it is sufficient to show that the above-described branching is correct.
Claim 1 Let B be a vertex set computed as described above.Then, I is a yes-instance of CNP-V if and only if there exists a vertex v ∈ B such that I v is a yes-instance of CNP-V.

Proof.
Suppose that I is a yes-instance.We show that I has some critical node cut C that contains at least one vertex v of B. Then, I v is a yes-instance.If the A-vulnerability of G[B] is larger than x, then any critical node cut C of I must necessarily contain at least one vertex v of B. Otherwise, B contains by construction all vertices that are in connected components of size at least 4 in G. Let C be any critical node cut of I. Assume that C ∩ B = ∅.Then, C contains only vertices of connected components of size at most 3. Let u be any vertex of C and let v be any vulnerable vertex in B. Then, the set C ′ := (C ∪ {v}) \ {u} is a critical node cut: The deletion of u in G decreases the A-vulnerability by at most 3 and the deletion of v decreases the A-vulnerability by at least 3, since v is vulnerable and in a connected component of size at least 4. Thus, C ′ is a critical node cut of G that contains at least one vertex of B.
Conversely, assume that I v is a yes-instance of CNP-V for some vertex v ∈ B and let C ⊆ V (G − {v}) be a critical node cut of I v .Clearly, C ′ = C ∪ {v} is a critical node cut of I. ⋄ It remains to show the running time bound.At each search tree node, all steps until the computation of B can be performed in O(n + m) time.Now, the set B can also be computed in O(n + m) time: First, we can compute the A-vulnerability of all connected components Z j , 1 ≤ j ≤ q in total time O(n + m).From this, we can compute the index i and the A-vulnerability of G[Z 1 ∪ . . .∪ Z i−1 ].Now, for each vertex u of Z i that is added to B, we can compute in constant time the increase in A-vulnerability that is obtained by adding u.We may attribute the time needed to compute the instance I v to the search tree node that is created by the recursive call for searching I v .Hence, the total running time spent at each search tree node is O(n + m).
To bound the size of the search tree, first observe that the search tree has depth at most k, since one vertex is deleted in each recursive call and branching is only performed while k ≥ 0. The number of recursive calls is |B| and thus it remains to bound |B|.
Let v 1 , . . ., v i denote the initial vulnerable vertices added from each Z i , and let D := B \ {v 1 , . . ., v i } denote the other vertices in B. Note that D may contain vulnerable as well as nonvulnerable vertices.We have |D| ≤ x + 1, since the addition of each element in D to B increases the A-vulnerability of B by at least one.Thus, that is, the first i − 1 components contain at most x vertices from D. Each of these i − 1 connected components contains at least 3 vertices from D since we consider only connected components of size at least 4. Thus, i − 1 ≤ x/3.
Altogether, the size of the search tree is O(( 43 x + 2) k ).Thus, the overall running time of the algorithm is O(( 43 x + 2) k • (m + n)).□ After Reduction Rule 3 is applied, we can assume |A| > k for instances of CNP-V.Hence, we also obtain the following.
Corollary 4 CNP-V has an FPT-algorithm for the parameter |A| + x.
In this section, we consider the parametrization by y := ℓ − x, where ℓ is the A-vulnerability of the input graph.In other words, y counts how many vulnerable connections shall be removed.

An FPT Algorithm for Deletable Vulnerable Vertices
CNP is fixed-parameter tractable with respect to y [12], based on the following observations: If some connected component has more than y vertices, then we have a yes-instance, as we can delete y vulnerable connections by removing a single vertex.Afterward, we may compute the component information in O(2 y • y 2 • (n + m)) time and combine it using the dynamic programming algorithm presented also in Section 2. We now extend the FPT result to the more general CNP-V problem.Moreover, we improve the running time to a subexponential running time in y.
Theorem 6 CNP-V can be solved in 2 O( √ y log y) • n O(1) time.
Proof: Let I := (G, A, k, x) be an instance of CNP-V and let Z 1 , . . ., Z t be the connected components of G. Recall that we assume that I is reduced regarding Reduction Rule 1 and therefore each connected component has a non-empty intersection with A. Moreover, we assume that k ≥ 1 since otherwise we can solve I in polynomial time by computing the number of vulnerable connections of G.
We first assume that there exists a connected component Z i of size at least y + 1.Since we assume that every connected component of G contains some vertices from A, let v ∈ Z i ∩ A. Since |Z i | ≥ y + 1, we can remove at least y vulnerable connections by deleting v. Together with the fact that k ≥ 1 we conclude that I is a yes-instance.Throughout the rest of the proof, we assume that |Z i | ≤ y for every connected component of G.
In the remainder of the proof, we show that a component table is the minimum number of vulnerable connections in G[Z i ] that remain after deleting exactly k ′ vertices in Z i .With a component table at hand, we can then solve CNP-V in polynomial time due to Lemma 4.
Let Z i be a connected component.We now describe how to compute all component information We first consider the case where k < √ y.For each k ′ ∈ [0, k], we compute T [i, k ′ ] by iterating over all subsets S ⊆ Z i and computing the vulnerability of G Since k ≤ n in non-trivial instances, we can compute all component information , where c 1 corresponds to the vulnerable connections between the deleted vertices and c 2 corresponds to vulnerable connections between the deleted vertices and the remaining vertices in Z i .Then, since , the number of vulnerable connections is decreased by at least Since we assumed k ≥ √ y, we may immediately return yes if Z i satisfies the two constraints stated in the claim.For the rest of the proof, we may assume that this is not the case.Consequently, we have Consider the following cases.
Case 1: . We can then compute the component information of the connected component Z i by iterating over all subsets S ⊆ Z i and computing the number of vulnerable connections in G , there are at most 2  1) time.Since k ≤ n in non-trivial instances, we can compute all component information 1) time.
By the above, we can compute the component table 1) .Together with Lemma 4, we conclude that CNP-V can be solved within the claimed running time.□

Hardness for Non-Deletable Vulnerable Vertices
Now, we show that-in contrast to CNP-V-the CNP-NDV problem is W[1]-hard with respect to the parameter k + y.In the algorithm for CNP-V behind Theorem 6, we exploit that we may bound the size of a single connected component in the parameter y if one single vulnerable vertex lies in that component.This relies on the fact that the deletion of this vertex provides a critical node cut.Note that this is not possible in the case of CNP-NDV.We show that CNP-NDV is W[1]-hard for k + y even if the input graph consists of a single connected component with exactly one vulnerable vertex.We reduce from Clique which has as input graph G and an integer ℓ, and asks whether G contains a set of ℓ vertices that are pairwise adjacent.It is well-known that Clique is W[1]-hard with respect to ℓ [5,7].The reduction follows the spirit of a reduction of Fomin et al. [9] that shows W[1]-hardness of the Cutting at most k Vertices with Terminal problem.The reduction of Fomin et al. [9] already shows W [1]-hardness of CNP-NDV with respect to the parameter k, even if |A| = 1.We adapt the reduction to show hardness with respect to the larger parameter k + y.
Theorem 7 CNP-NDV is W[1]-hard with respect to the parameter k + y, even if |A| = 1 and the input graph has diameter 2. JGAA, 28(1) 1-26 (2024) 17 Proof: Construction: Let (G, ℓ) be an instance of Clique.We assume without loss of generality that ℓ ≤ n G .We construct an instance (G ′ , A, k, x) of CNP-NDV as follows: We start with a single vulnerable vertex d and set A := {d}.Then, we add ℓ + 1 neighbor-vertices to d and call this set N .We add a set H V of n G vertices to G ′ that corresponds to the vertex set V (G).We add an edge between every vertex of H V and every vertex of N .Furthermore, we add for every edge in G a vertex to G ′ and name that vertex set H E .For every edge {u, v} of G, connect the corresponding vertex of H E to the two vertices of H V that correspond to u and v. Finally, we add a universal vertex ū that is connected to every vertex of G ′ .The construction of G ′ is shown in Figure 4. We set k := ℓ + 1 and Then, y = ℓ 2 + ℓ + 1 as we are dealing with exactly one vulnerable vertex.Thus, k and y are polynomially bounded in ℓ.Moreover, |A| = |{d}| = 1 and the diameter of G ′ is 2 because of the universal vertex ū.The construction can be computed in polynomial time.
Intuition: We constructed G ′ so that there exists a vertex in G ′ for every vertex and every edge in G.The vertices of H V correspond to the n G vertices of G and the vertices of H E to the m G edges of G.As we can add at most k vertices to a critical node cut, we cannot add all vertices of N ∪ {ū} to a critical node cut.Consequently, the only vertices that can be separated from d without being in the critical node cut are in the vertex set H E .
Correctness: Let (G, ℓ) be a yes-instance of Clique.Thus, there is a set of vertices X ⊆ V (G) such that G[X] is a clique of size ℓ.Thus, G[X] contains ℓ 2 edges.Let Y be the set of these edges.We define the vertex set C that contains the ℓ vertices in H V that correspond to the vertices of X and the universal vertex ū of G ′ .The size of the set C is ℓ + 1 = k.Then, the ℓ 2 vertices in H E that correspond to Y are isolated and thus no longer connected to d.
Conversely, let (G ′ , A, k, x) be a yes-instance of CNP-NDV.Let C be a corresponding critical node cut.It follows that |C| ≤ k = ℓ + 1 and cutting C from G ′ deletes y vulnerable connections.Let Q ⊆ V (G ′ ) \ C be the set of vertices that are separated from d in G ′ − C. We observe that Q ⊆ H E , because the vertices of N ∪ {ū} are adjacent to d and every vertex of H V is connected to d via more than k vertex-disjoint paths.Furthermore, a vertex of Thus, the critical node cut C consists of ū and ℓ vertices of H V that are pairwise To avoid cluttered notation, we write ∆( S) instead of ∆ S ′ ( S) since S ′ will be clear from context.The deletion of ∆( S) splits the instance into two independent parts, one with the vertices from N p [ S], the other part containing the vertices from N p [S ′ \ S].The two parts can then be solved independently if we consider the optimal way to distribute the deletion budget between the two parts.
To simplify the description, we define T [S ′ , k ′ ] := +∞ for all k ′ < 0.Moreover, we set T [∅, k ′ ] := 0 for all k ′ ∈ [0, k].This is correct since the empty graph has A-vulnerability 0. Furthermore, we precompute an auxiliary table Q, where an entry Q[S ′ , k ′ ] is a lower bound of the A-vulnerability that we get when G(N p [S ′ ]) remains connected after the deletion of k ′ vertices.More precisely, let Q[S ′ , k ′ ] be the A-vulnerability of G ′ − D ′ where D ′ is computed by applying the algorithm from Lemma 7 to G ′ .Then, any connected graph obtained from G ′ by deleting at most For nonempty S ′ , we now compute T [S ′ , k ′ ] by the recurrence where δ( S) = |∆( S)| if ∆( S) contains no vertices of N and there are no edges with one endpoint in S and one endpoint in S ′ \ S, and δ( S) = k + 1, otherwise.That is, δ counts the number of vertex deletions that are necessary to disconnect S and S ′ \ S in G ′ if it is at all possible to disconnect the two sets without deleting vertices in N .Otherwise, the value of δ is sufficiently large to ensure that the equation evaluates to +∞.
To show the correctness of the recurrence, we prove the following two inequalities between the right-hand side and left-hand side of the equation.
(≥) Consider T [S ′ , k ′ ] and let C ′ ⊆ V (G ′ )\N be a set of size at most k ′ such that G ′ −C ′ has Avulnerability T [S ′ , k ′ ].Let Z be some connected component of G ′ − C ′ and let S := Z ∩ S be the set of the vertex cover nodes of Z. Since Z is a connected component in G ′ − C ′ , there are no edges between S and S ′ \ S and C ′ contains every vertex of G ′ with one neighbor in S and one in S ′ \ S, that is, every vertex of ∆( S).In G ′ −∆( S), the set N p [ S] is one connected component.Let k denote the number of vertices from N p [ S] that are deleted.Then, and by the definition of T .Altogether, we have for this particular choice of S and k.Therefore, T [S ′ , k ′ ] is also at least as large as the minimum over all choices for S and k.
(≤) Consider a set S and a number k minimizing   • k) entries as well and the time needed for filling T is dominated by the total number of different terms over which the minimum is taken.This number is 3 |S| • n O (1) since each such term corresponds to a 3-partition of S into S \ S ′ , S ′ \ S, and S. □ We can now use this algorithm to obtain a single-exponential FPT-algorithm for the vertex cover number of the input graph.
Proof: Let (G, A, N, k, x) be an instance of CNP-VNDV.The first step of the algorithm is to compute a minimum vertex cover S of G.This can be done in O(2 vc (n + m)) time using the standard search tree algorithm [5].Then, for each set D ⊆ (S \ N ) of size at most k, we create a branch where we assume that D is the set of vertex deletions in the vertex cover S. Consider one such branch.Let G ′ := G − D and let k ′ := k − |D|.Observe that S ′ := S \ D is a vertex cover of G ′ .The question is now whether there is a vertex set C ′ of size at most k ′ that avoids N ∪ S ′ such that G ′ − C ′ has A-vulnerability at most x.This is equivalent to solving the instance (G ′ , A, N ∪ S ′ , k ′ , x) and can be done in 3 1) time by Lemma 8.If |D| = i, then the running time for solving the instance is therefore 3 vc −i • n O (1) .Consequently, the overall running time for the branching is 1) .Using the binomial theorem, the overall running time for all possibilities of D is thus 4 vc • n O(1) time.□

On Problem Kernelization
Next, we show polynomial-size kernels for CNP-V parameterized by vc + x and for CNP-NDV parameterized by vc + k + x.To this end, we first make a simple observation on k and the vertex cover number of the input graph.Let (G, A, k, x) be an instance of CNP-V or CNP-NDV.For the rest of the section, we fix a vertex set S which is a 2-approximation of a minimum vertex cover of G, that is, |S| ≤ 2 • vc.Note that S can be computed in linear time.
Consider CNP-V.Removing S from G results in an edgeless graph and therefore, there are no vulnerable connections in G − S. Thus, we may immediately return yes if k is at least as big as the size of S.
Reduction Rule 5 Let (G, A, k, x) be an instance of CNP-V.Return yes, if k ≥ |S|.
After application of this rule, we may assume k < 2 • vc.Recall that we assume that the input instance of CNP-V is reduced with respect to Reduction Rules 1 and 4 and therefore we may assume that there are no isolated vertices and that |N (v) ∩ A| ≤ k + √ 2x for every vertex v.In the following, we show that we can use these assumptions to bound the size of A in vc +x.
Lemma 9 After Reduction Rules 1, 4, and 5 have been applied exhaustively, in an instance (G, A, k, x) of CNP-V, the set A contains less than 2 vc

□
Next, we define a subset B of the vertices.We provide two different definitions for CNP-V or CNP-NDV: For CNP-V, we define B := A ∪ S. For CNP-NDV, we define B := S. We call B the base.We then have |B| ≤ 2 • vc when we deal with an instance of CNP-NDV and by Lemma 9 we have |B| ≤ 2 vc •(2 vc + √ 2x+2) when we deal with an instance of CNP-V.It remains to bound the size of the set Y := V \ B. Note that Y is an independent set because B contains a vertex cover.Moreover, Y does not contain isolated vertices since the instance is reduced with respect to Reduction Rule 1.In the following, we provide a reduction rule that in instances of CNP-NDV helps us to handle vulnerable vertices in the set Y .After the reduction rule has been applied exhaustively, if a vertex v has a neighborhood of size at least k + x + 1, all neighbors of v are non-vulnerable.
Reduction Rule 6 Let (G, A, k, x) be an instance of CNP-NDV with base B. If a vertex v ∈ B has more than k + x neighbors of which one is vulnerable, then do the following: 1.If v ̸ ∈ A, then remove v from the graph and decrease k by one.Case 2: v ∈ A. It directly follows from Case 1 that, if v ∈ A, there exists no critical node cut for (G, A, k, x) that is disjoint from A. Hence, there is no critical node cut for (G, A, k, x) for the instance of CNP-NDV.Thus, we can return no.
Running time: Since each application of Reduction Rule 6 removes a vertex, it can be applied at most n times.For every vertex, we compute the size of the neighborhood and check whether one vertex is vulnerable in O(n) time.Thus, this reduction rule can be applied exhaustively in O(n 2 ) time.□ This reduction rule can only be applied on instances of CNP-NDV, because, if v ̸ ∈ A, we know that we have to add v to a critical node cut.However, in CNP-V there remain three options: we can add the vulnerable vertex d, or the vertex v, or both to a critical node cut.Thus, in order to avoid such a decision for instances of CNP-V, we added all vulnerable vertices to the base B.
In the last reduction rule, we use the Expansion Lemma.The Expansion Lemma was introduced by Prieto-Rodríguez [14].We use the formulation by Cygan et al. [5].Let H be a bipartite graph with vertex bipartition (R, T ).For a positive integer q, a set of edges M ⊆ E(H) is called a qexpansion of R into T , if every vertex of R is incident with exactly q edges of M and the edges in M are incident with exactly q • |R| vertices in T .
Lemma 11 (Expansion Lemma [5]) Let q ≥ 1 be a positive integer and H be a bipartite graph with vertex bipartition (R, T ) such that |T | ≥ q • |R| and there are no isolated vertices in T .Then, there exist nonempty vertex sets P ⊆ R and Q ⊆ T such that there is a q-expansion of P into Q and N H (Q) ⊆ P .Furthermore, the sets P and Q can be found in time polynomial in the size of H.
Since the Expansion Lemma can only be applied to bipartite graphs, in the next reduction rule we define a bipartite graph that is an induced subgraph of G.We apply the Expansion Lemma on the graph G ′ which contains the vertices V ′ := V (G) and the set of edges ).This is a bipartite graph, because we do not consider the edges within B and, by definition, Y is an independent set.Thus, G ′ is a bipartite graph with vertex bipartition (B, Y ).Now, we assume that Reduction Rules 1 and 6 are exhaustively applied.We start by showing that we can apply the Expansion Lemma.After Reduction Rule 1 has been applied exhaustively, all vertices in Y are adjacent to at least one vertex in B. Thus, all conditions for the Expansion Lemma are fulfilled.From the Expansion Lemma, we know that we can then find non-empty vertex sets P ⊆ B and Q ⊆ Y such that there is a k + x + 2-expansion of P into Q in polynomial time.Also, the sets fulfill N G (Q) ⊆ P .
For the rest of the proof, let v be an arbitrary but fixed vertex of Q.We show that (G, A, k, x) is a yes-instance of CNP-V or CNP-NDV, if and only if (G − {v}, A, k, x) is a yes-instance of the same problem.Observe that v is non-vulnerable: In an instance of CNP-V we defined A ⊆ B and thus A ∩ Y = ∅ and in particular A ∩ Q = ∅.In an instance of CNP-NDV, after Reduction Rule 6 has been applied exhaustively, a vertex of B with a neighbor in A ∩ Y has at most k + x neighbors.Thus, a described k + x + 2-expansion of Because G − {v} is an induced subgraph of G, C \ {v} is a critical node cut for (G − {v}, A, k, x) if C is a critical node cut for (G, A, k, x).
Conversely, let (G − {v}, A, k, x) be a yes-instance of CNP-V or CNP-NDV and let C be a corresponding critical node cut.From the Expansion Lemma, we know N (Q) ⊆ P .In (G−{v})−C there is no vulnerable connection {d, u} with d ∈ A and u ∈ P : Otherwise, for all w ∈ (N G (u) ∩ Q) \ ({v} ∪ C) also {d, w} is a vulnerable connection in (G − {v}) − C. By the definition of P and Q, the size of (N G (u) ∩ Q) is at least k + x + 1 and thus {u} ∪ ((N G (u) ∩ Q) \ ({v} ∪ C)) contains more than x vertices.This is a contradiction to C being a critical node cut.By the same argument, the sets A and P \ C are not connected in (G − {v}) − C. It follows that in (G − {v}) − C the sets P \ C and Q \ C are in connected components that do not contain a vulnerable vertex.Since N G (v) ⊆ P , the A-vulnerability of (G − {v}) − C is the A-vulnerability of G − C and C is also a critical node cut for (G, A, k, x).
Clearly, the rule can be performed in polynomial time.□ It remains to give a bound on the size of the computed kernel.To this end, consider the following lemma.We next argue why the bound from the previous lemma implies that CNP-V admits a polynomial kernel for parameterization by vc + x and that CNP-NDV admits a polynomial kernel for parameterization by vc +x + k.Recall that S is a 2-approximation of a vertex cover.
Second, consider CNP-NDV.Recall that B = S in this case.Hence, |B| ≤ 2 vc in this case.This implies a problem kernel with less than 2 • vc•(k+x+3) vertices for CNP-NDV.In summary, we obtain the following

Conclusion
We introduced two new critical node detection problems Critical Node Problem with Vulnerable Nodes (CNP-V) and Critical Node Problem with Non-Deletable Vulnerable Nodes (CNP-NDV), that take into account that we may be only interested in the number of connected pairs for a specified set of vulnerable vertices.We performed a parameterized complexity analysis for some of the most natural parameters and their combinations.
We left open, however, the complexity of several natural parameterizations.For example, is CNP-V FPT with respect to |A|?At the moment we only have an XP-algorithm for A and an FPT-algorithm for |A|+x.Moreover, does either problem admit a polynomial kernel for the vertex cover number vc?
A further interesting structural parameter is the feedback vertex number (fv) of the input graph.That is the minimum number of vertices that need to be removed to obtain a graph without cycles.Since fv never exceeds the vertex cover size, it is interesting to ask whether our results on parameterization by vc be transferred to this smaller parameter.Moreover, the feedback vertex number also measures the distance to a polynomial-time solvable case, since CNP-V and CNP-NDV can be solved in polynomial time on acyclic graphs [15].Thus, parameterization by fv is a distance-from-triviality parameterization.
It is also open whether CNP-NDV is FPT or W [1]-hard for parameterization by treewidth (tw).Recall that CNP is W [1]-hard for tw [2,12] and thus, the more general CNP-V is W[1]-hard for tw as well.However, this does not imply W [1]-hardness for CNP-NDV.Is it possible to adapt the reductions for CNP-NDV [2,12] so that they work for non-deletable vulnerable vertices or is a fundamentally new approach required?
Besides considering CNP-V and CNP-NDV, it is interesting to introduce vulnerable vertices for other natural critical node problems [13].For example, instead of defining the A-vulnerability via the number of vulnerable connections, one may consider centrality measures for vertex sets [3,10] to assess how exposed the vulnerable vertices are.Moreover, one may consider edge deletions instead of vertex deletions.For example, is it possible to adapt existing FPT results for related edge deletion problems [8] to problem versions with vulnerable vertices?
For a vertex set S, we let N (S) = {u | {u, v} ∈ E(G), v ∈ S} \ S and N [S] := S ∪ N (S) denote the open and closed neighborhood of S, respectively.For a vertex v, we denote N (v) := N ({v}) and N [v] := N [{v}].For a vertex set S, we let G[S] := (S, {{u, v} ∈ E(G) | u, v ∈ S}) denote the subgraph induced by S, and G − S := G[V (G) \ S] denote the subgraph of G obtained by deleting S and its incident edges.
Each entry can be computed in O(k) time by iterating over all possible values of k ′′ .Consequently, the algorithm has a running time of O(n • k 2 ).□ Observe that, for an instance where the input graph has maximum component size c for some constant c, a component table can be computed in O(2 c • (n + m)) = O(n) time by iterating over every subset of each connected component.Note that m ∈ O(n) for instances with constant maximum component size.Proposition 4 CNP-V and CNP-NDV can be solved in O(2 c • m + n • k 2 ) time, where c is the size of the largest connected component of the input graph.

Theorem 3
An instance I := (G, A, N, k, x) of CNP-VNDV with A ⊆ N can be solved in time O(2 k+x • (n + m)).

Figure 2 :
Figure 2: Illustration of the choice of the branching vertex in the proof of Theorem 3. Vulnerable vertices are black.The algorithm chooses either u or v as branching vertex.For both choices, adding the vertex to N increases the A-vulnerability of G[N ].

Theorem 4 Figure 3 :
Figure 3: Illustration of the choice of the edge {u, v} on which branching is performed in the proof of Theorem 4. Vulnerable vertices are black.Left: The algorithm may choose a vulnerable vertex v outside of N and some neighbor u.Right: If A ⊆ N , then the algorithm may choose any vertex v with a neighbor u ∈ N that is connected in G[N ] to some vulnerable vertex.

Figure 4 :
Figure 4: Construction of G ′ in the proof of Theorem 7.
] in the righthand side of the recurrence and observe that the value of the right-hand side is finite.Then, there exist a set C of at most k vertices and a set Ĉ of at most k− k−δ( S) vertices such that G ′ [N p [ S]]− C has A-vulnerability at most Q[ S, k] and G ′ [N p [S ′ \ S]]− Ĉ has A-vulnerability T [S ′ \ S, k ′ − k−δ( S)].Now, consider the set C ′ = C ∪ ∆( S) ∪ Ĉ.This set has size at most k + δ( S) +

2 .
If v ∈ A, then return no.Lemma 10 Reduction Rule 6 is safe and can be applied exhaustively in O(n 2 ) time.Proof: Safeness: Case 1: v ̸ ∈ A. We show that, if there is a critical node cut C for the instance (G, A, k, x), then v ∈ C. Let d be a vulnerable neighbor of v. Assume towards a contradiction that v ̸ ∈ C. Consequently, {d, w} is a vulnerable connection in G − C for every w ∈ N (v) \ C with d ̸ = w.Also, {d, v} is a vulnerable connection in G − C.By the requirements of the reduction rule, |N (v)| > k + x.It follows that |(N (v) \ {d}) \ C| ≥ x.Together with {d, v} in G − C, there are more than x vulnerable connections.We conclude that v ∈ C.

Table 1 :
Overview of our results.
and decrease k by 1. Reduction Rule 4 is safe and can be applied exhaustively in O(m + n) time.
1)time.Next, let k ≥ √ y.For this, we first identify a further case, where I is a yes-instance.
Proof.Since |Z i ∩ A| ≥ √ y and k ≥ √ y, we may delete √ y vulnerable vertices from Z i .This decreases the number of vulnerable connections by at least as 1) there are no edges between S and S \ S and 2) all vertices of G ′ that are not in N p [ S] or in N p [S ′ \ S] are contained in ∆( S).The running time for filling the tables can be bounded as follows.Table Q has O(2 |S| • k) entries, each of which can be computed in n O(1) time by Lemma 7. Table T has O(2 |S| Recall that S is a vertex cover of G with |S| ≤ 2 • vc.After Reduction Rule 1 has been applied exhaustively, every vertex of G is either in the vertex cover, or a neighbor of S.Then, with Reduction Rules 4 and 5 it follows that Proof:|A| = |S ∩ A| + |N (S) ∩ A| Reduction Rule 7 If the set Y contains at least (k + x + 2) • |B| vertices, then, in the graph G ′ compute non-empty vertex sets P ⊆ B and Q ⊆ Y such that there is a k + x + 2-expansion of P into Q.Remove an arbitrary vertex v ∈ Q from G.Lemma 12 For an instance of CNP-V or CNP-NDV, Reduction Rule 7 is safe and can be applied exhaustively in polynomial time.
Proof: Safeness: Let (G, A, k, x) be an instance of CNP-V or CNP-NDV with base B for which the inequality |Y | ≥ (k + x + 2) • |B| holds.