# The minimum vulnerability problem on specific graph classes

## Abstract

Suppose that each edge *e* of an undirected graph *G* is associated with three nonnegative integers \(\mathsf{cost}(e)\), \(\mathsf{vul}(e)\) and \(\mathsf{cap}(e)\), called the cost, vulnerability and capacity of *e*, respectively. Then, we consider the problem of finding \(k\) paths in *G* between two prescribed vertices with the minimum total cost; each edge *e* can be shared without any cost by at most \(\mathsf{vul}(e)\) paths, and can be shared by more than \(\mathsf{vul}(e)\) paths if we pay \(\mathsf{cost}(e)\), but cannot be shared by more than \(\mathsf{cap}(e)\) paths even if we pay the cost for *e*. This problem generalizes the disjoint path problem, the minimum shared edges problem and the minimum edge cost flow problem for undirected graphs, and it is known to be NP-hard. In this paper, we study the problem from the viewpoint of specific graph classes, and give three results. We first show that the problem is NP-hard even for bipartite outerplanar graphs, 2-trees, graphs with pathwidth two, complete bipartite graphs, and complete graphs. We then give a pseudo-polynomial-time algorithm for bounded treewidth graphs. Finally, we give a fixed-parameter algorithm for chordal graphs when parameterized by the number \(k\) of required paths.

### Keywords

Bounded treewidth graph Chordal graph Fixed parameter tractability Graph algorithm Minimum vulnerability problem## 1 Introduction

*V*(

*G*) and

*E*(

*G*) the vertex set and edge set of

*G*, respectively. Suppose that each edge \(e \in E(G)\) is associated with three nonnegative integers \(\mathsf{cost}(e)\), \(\mathsf{vul}(e)\) and \(\mathsf{cap}(e)\), called the

*cost*,

*vulnerability*and

*capacity*of

*e*, respectively. Let \({\mathcal {P}}\) be a multi-set of paths in

*G*. Then, for each edge \(e \in E(G)\), we define \(\mu (e, {\mathcal {P}})\) to be the number of paths in \({\mathcal {P}}\) that contain

*e*, and define \(\lambda (e, {\mathcal {P}})\), called the

*penalty*of

*e*on \({\mathcal {P}}\), as follows:

*e*can be shared without any cost by at most \(\mathsf{vul}(e)\) paths in \({\mathcal {P}}\), and cannot be shared by more than \(\mathsf{cap}(e)\) paths even if we pay the cost for

*e*. Then, the

*penalty*of \({\mathcal {P}}\), denoted by \(\lambda ({\mathcal {P}})\), is defined as \(\lambda ({\mathcal {P}}) = \sum _{e \in E(G)} \lambda (e, {\mathcal {P}})\).

*G*with two specified vertices \(v_s, v_t \in V(G)\) and a nonnegative integer \(k\), the

*minimum vulnerability problem*is to find a set \({\mathcal {P}}\) consisting of \(k\) (not necessarily distinct) paths in

*G*between \(v_s\) and \(v_t\), called \(v_s v_t\)

*-paths*in short, such that the penalty \(\lambda ({\mathcal {P}})\) of \({\mathcal {P}}\) is minimized. (See Fig. 1 as an example.) We denote by \(\mathsf{OPT}_{k} (G, v_s, v_t)\), in short by \(\mathsf{OPT}_{k}(G)\), the optimal value of the minimum vulnerability problem for a given graph

*G*. This problem arises in the context of communication network design, reliable multicast communications, and distributed communication protocols (Assadi et al. 2012; Omran et al. 2013; Yang et al. 2005a, b).

### 1.1 Known and related results

The minimum vulnerability problem was originally defined on digraphs (i.e., directed graphs, in which each edge is given as an ordered pair of vertices called *arcs*) (Assadi et al. 2012), in which we wish to find \(k\) directed paths from \(v_s\) to \(v_t\). The problem on digraphs generalizes the *k*-edge-disjoint paths problem, the minimum shared edges problem (Assadi et al. 2012; Omran et al. 2013; Ye et al. 2013) and the minimum edge cost flow problem (Garey and Johnson 1979; Krumke et al. 1998) as follows: (In this paper, we denote by *n* the number of vertices in a graph *G*, and by *m* the number of edges or arcs in *G*.)

#### 1.1.1 The *k*-edge-disjoint paths problem

This problem corresponds to the minimum vulnerability problem on digraphs restricted to the case where \(\mathsf{cap}(e) = 1\) for all arcs *e* in a given digraph. The problem is known to be solvable in polynomial time (Goldberg and Rao 1998). However, the problem of finding edge-disjoint paths between distinct multiple pairs of \(v_s\) and \(v_t\) is known to be NP-hard even for series-parallel (undirected) graphs (Nishizeki et al. 2001).

#### 1.1.2 The minimum shared edges problem

This problem corresponds to the minimum vulnerability problem on digraphs restricted to the case where \(\mathsf{cost}(e)=1\), \(\mathsf{vul}(e) = 1\) and \(\mathsf{cap}(e) = k\) for all arcs *e* in a given digraph. The problem is known to be NP-hard (Omran et al. 2013), and admits no \(2^{\log ^{1-\varepsilon } n}\)-factor approximation for any constant \(\varepsilon > 0\), unless \(\mathrm{NP} \subseteq \mathrm{DTIME}(n^{\mathrm{polylog}~n})\) (Omran et al. 2013). On the other hand, Assadi et al. (2012) showed that the minimum shared edges problem can be approximated in polynomial time within a factor of \(\min \{ n^{\frac{3}{4}} , m^{\frac{1}{2}} \}\), or a factor of \(\lfloor k/2 \rfloor \). Furthermore, the problem admits a fully polynomial-time approximation scheme (FPTAS) for series-parallel digraphs (Krumke et al. 1998; Omran et al. 2013).

*G*with bounded treewidth, there is a pseudo-polynomial-time algorithm for the minimum shared edges problem (Ye et al. 2013) whose running time is

*G*. (The definition of treewidth will be given in Sect. 3.)

#### 1.1.3 The minimum edge cost flow problem

This problem corresponds to the minimum vulnerability problem on digraphs restricted to the case where \(\mathsf{vul}(e) = 0\) for all arcs *e* in a given digraph. This problem is known to be strongly NP-hard even for bipartite digraphs (Krumke et al. 1998), and admits no \(2^{\log ^{1-\varepsilon } n}\)-factor approximation for any constant \(\varepsilon > 0\), unless \(\mathrm{NP} \subseteq \mathrm{DTIME}(n^{\mathrm{polylog}~n})\) (Even et al. 2005).

The minimum edge cost flow problem remains NP-hard even for series-parallel graphs (Krumke et al. 1998), but it admits an FPTAS for series-parallel digraphs (Krumke et al. 1998).

#### 1.1.4 The minimum vulnerability problem

We now explain known results for our problem. Since the minimum vulnerability problem on digraphs is a generalization of the minimum shared edges problem and the minimum edge cost flow problem, all hardness results obtained for the latter two problems hold for our problem on digraphs, too. Furthermore, the strong NP-hardness proof given in Krumke et al. (1998) can be easily extended to bipartite undirected graphs, and hence the minimum vulnerability problem remains strongly NP-hard even for bipartite undirected graphs.

However, this relation does not hold in the other direction, that is, algorithms obtained for the three problems above do not always work for the minimum vulnerability problem even on undirected graphs. Thus, Assadi et al. (2012) developed an \(O \bigl (n^3 m^{2(k-1)} \bigr )\)-time algorithm which exactly solves the minimum vulnerability problem on any digraph for the case where all arcs *e* have identical positive vulnerability \(\mathsf{vul}(e) = r\ge 1\). They also gave an approximation result for the case where \(r\ge 0\): The best known approximation ratio is \(\lfloor \frac{k}{r+1} \rfloor \) for general digraphs (Assadi et al. 2012). As far as we know, these are the only positive results known for the minimum vulnerability problem on digraphs.

### 1.2 Our contributions

In this paper, we study the minimum vulnerability problem on undirected graphs from the viewpoint of specific graph classes, and mainly give the following three results. (We will later define the graph classes mentioned below.)

First, we show that the problem remains NP-hard for every family of graphs having a non-cut vertex of large (unbounded) degree, even if \(\mathsf{cap}(e) \ge 1\) and \(\mathsf{vul}(e) \ge 1\) hold for all edges *e* in a graph *G*. This hardness proof yields NP-hardness for some specific classes of graphs such as bipartite outerplanar graphs, 2-trees, graphs with pathwidth two, complete bipartite graphs, and complete graphs. Therefore, it is very unlikely that the problem can be solved in polynomial time even for these very restricted graph classes. It is important to notice that this hardness result holds under the condition of non-zero capacity and non-zero vulnerability, because otherwise any graph can be represented as a complete graph by appropriately choosing edge-costs.

Second, we give a pseudo-polynomial-time algorithm for bounded treewidth graphs, which form a super-class of outerplanar graphs; note that our algorithm works also for the case where \(\mathsf{cap}(e) = 0\) or \(\mathsf{vul}(e) = 0\) holds for some edges *e*. Thus, this algorithm solves the minimum shared edges problem and the minimum edge cost flow problem for undirected graphs with bounded treewidth, too. Furthermore, our algorithm improves the best running time known for the minimum shared edges problem on undirected graphs with bounded treewidth (Ye et al. 2013).

Third, by taking the number \(k\) of required \(v_s v_t\)-paths as a parameter, we give a fixed-parameter algorithm (i.e., an algorithm whose running time can be bounded by \(f(k) \cdot n^{O(1)}\) for some computable function *f* depending only on *k*) for chordal graphs *G* such that \(\mathsf{vul}(e) \ge 1\) holds for all edges \(e \in E(G)\). Note that the problem is NP-hard for chordal graphs, because chordal graphs form a super-class of complete graphs.

An early version of the paper has been presented in Aoki et al. (2014).

## 2 Computational hardness

In this section, we systematically show NP-hardness of the minimum vulnerability problem for several graph classes. We indeed consider the following decision version of the minimum vulnerability problem: Given an undirected graph *G* with two specified vertices \(v_s, v_t\in V(G)\) associated with three nonnegative integers \(\mathsf{cost}(e)\), \(\mathsf{vul}(e)\) and \(\mathsf{cap}(e)\) for each edge \(e \in E(G)\), and two nonnegative integers \(k\) and *c*, is there a set \({\mathcal {P}}\) consisting of \(k\)\(v_s v_t\)-paths on *G* such that the penalty \(\lambda ({\mathcal {P}})\) of \({\mathcal {P}}\) is at most *c*?

We give a polynomial-time reduction from Knapsack (Garey and Johnson 1979). In an instance of Knapsack, we are given a set \(A\) of \(n_a\) items \(a_{1}, a_{2}, \ldots , a_{n_a}\), a positive integer weight \(w(a_{i})\) and a positive integer profit \(p(a_{i})\) for each item \(a_{i} \in A\), and two positive integers \(c\) and \(d\). Then, the Knapsack problem is to determine whether there exists a subset \(A'\subseteq A\) such that the total weight of \(A'\) is at most \(c\) and the total profit of \(A'\) is at least \(d\). This problem is known to be NP-complete (Garey and Johnson 1979). Then, we have the following theorem.

**Theorem 1**

Suppose that we are given an instance of Knapsack with \(n_a\) items, for any integer \(n_a\ge 1\). Then, it can be reduced to the decision version of the minimum vulnerability problem for any graph *G* which has a non-cut vertex of degree exactly \(n_a\) and satisfies both \(\mathsf{cap}(e) \ge 1\) and \(\mathsf{vul}(e) = r\) for all \(e \in E(G)\), where \(r \ge 0\) is any fixed constant. Furthermore, this reduction can be done in time polynomial in |*V*(*G*)|.

*Proof*

Given an instance of Knapsack with \(n_a\) items, we construct the corresponding instance of the minimum vulnerability problem, for a graph *G* having a non-cut vertex *v* of degree exactly \(n_a\).

First, we set *v* as \(v_t\), and set \(n_a\) vertices adjacent to \(v_t\) as \(v_i\), \(1 \le i \le n_a\), corresponding to each item \(a_{i} \in A\). Then, let \(v_s= v_1\). We set three integers \(\mathsf{cost}(e)\), \(\mathsf{vul}(e)\) and \(\mathsf{cap}(e)\) for each edge \(e \in E(G)\), as follows: Let \(r\ge 1\) be any fixed constant. For each *i*, \(1 \le i \le n_a\), we set \(\mathsf{cost}((v_i, v_t)) = w(a_{i})\) and \(\mathsf{cap}((v_i, v_t)) = r+ p(a_{i})\). For the other edges *e* in *G*, we set \(\mathsf{cost}(e) = 0\) and \(\mathsf{cap}(e) = n_ar+ d\). Also, for all edges *e*, we set \(\mathsf{vul}(e) = r\). Finally, we set the number \(k\) of required \(v_s v_t\)-paths as \(k= n_ar+ d\), and the upper bound *c* on the penalty as the same upper bound on the total weight (i.e., capacity) of Knapsack. Clearly, this construction can be done in time polynomial in |*V*(*G*)|.

We now show that a given instance of Knapsack is a yes-instance if and only if the corresponding instance of the decision version of the minimum vulnerability problem is a yes-instance.

Suppose that a given instance of Knapsack is a yes-instance. Then, there exists a set \(A'\subseteq A\) such that \(\sum ^{}_{ a_{i} \in A'} w(a_{i}) \le c\) and \(\sum ^{}_{ a_{i} \in A'} p(a_{i}) \ge d\). In this case, a feasible solution of the corresponding instance can be obtained by the following steps. First, for each vertex \(v_i\), \(1 \le i \le n_a\), we choose the number \(r\) of \(v_sv_t\)-paths that pass through the edge \((v_i, v_t)\). Since \(v_t= v\) is a non-cut vertex, we can always find such \(v_sv_t\)-paths. Furthermore, since the vulnerability of \((v_i, v_t)\) is set to \(r\) and the cost of each edge not adjacent to \(v_t\) is set to zero, there is no penalty for these \(n_ar\) paths. Then, for each item \(a_{i} \in A'\), we additionally choose the number \(p(a_{i})\) of \(v_sv_t\)-paths via the corresponding vertex \(v_i\), and pay the cost for each of an edge \((v_i, v_t)\). Thus, the total penalty is \(\sum ^{}_{a_{i} \in A'} \mathsf{cost}((v_i, v_t)) = \sum ^{}_{a_{i} \in A'} w(a_{i}) \le c\). Since \(\sum ^{}_{a_{i} \in A'} p(a_{i}) \ge d\), the total number of chosen \(v_sv_t\)-paths is at least \(n_ar+ d= k\). Therefore, the chosen \(v_sv_t\)-paths form a feasible solution, and hence the corresponding instance of the minimum vulnerability problem is a yes-instance.

*G*such that the penalty \(\lambda ({\mathcal {P}})\) of \({\mathcal {P}}\) is at most \(c\). Let \(B\subseteq V(G)\) be the set of all vertices \(v_i\), \(1 \le i \le n_a\), in

*G*such that the edge \((v_i, v_t)\) incident to \(v_i\) is passed through by more than \(r\) paths in \({\mathcal {P}}\). Namely, we have to pay the cost for \((v_i, v_t)\) if and only if \(v_i \in B\). Let \(A'\) be the set of all items in \(A\) that correspond to the vertices in \(B\). Then, we have \(\sum ^{}_{a_{i} \in A'} w(a_{i}) = \sum ^{}_{v_i \in B} \mathsf{cost}((v_i, v_t))\), and hence \(\sum ^{}_{a_{i} \in A'} w(a_{i}) \le c\). Since we pay the costs for the edges \((v_i, v_t)\) such that \(v_i \in B\), the total number of \(v_s v_t\)-paths passing through these edges is more than \(\sum ^{}_{v_i \in B} \mathsf{vul}((v_i, v_t))\) and at most \(\sum ^{}_{v_i \in B} \mathsf{cap}((v_i, v_t))\). On the other hand, we do not pay the costs for the other edges adjacent to \(v_t\), and hence the total number of \(v_s v_t\)-paths passing through these edges is at most \(\sum ^{}_{v_i \in V(G) \setminus B} \mathsf{vul}((v_i, v_t))\). In total, we have

By Theorem 1, the minimum vulnerability problem is NP-hard for every graph class such that, for any integer \(n_a \ge 1\), it includes a graph, having a non-cut vertex of degree exactly \(n_a\), whose size is a polynomial in \(n_a\). Then, we have the following corollary. (See also Fig. 2.)

**Corollary 1**

- (a)
bipartite outerplanar graphs;

- (b)
2-trees;

- (c)
graphs with pathwidth two;

- (d)
complete bipartite graphs; and

- (e)
complete graphs.

## 3 Algorithm for bounded treewidth graphs

In this section, we give an algorithm for bounded treewidth graphs.

*tree-decomposition*of a graph

*G*is a pair \(\langle \{ X_i : i \in V_T\} , T\rangle \), where \(T=(V_T,E_T)\) is a rooted tree, such that the following four conditions (1)–(4) hold (Bodlaender 1996):

- (1)
each \(X_i\) is a subset of

*V*(*G*), and is called a*bag*; - (2)
\(\bigcup _{i \in V_T} X_i = V(G)\);

- (3)
for each edge \((u,v) \in E(G)\), there is at least one node \(i \in V_T\) such that \(u,v \in X_i\); and

- (4)
for each vertex \(v \in V(G)\), the set \(\{ i \in V_T: v \in X_i\}\) induces a connected component (subtree) in \(T\).

*G*in Fig. 3a. We will refer to a

*node*in \(V_T\) in order to distinguish it from a vertex in

*V*(

*G*). The

*width*of a tree-decomposition \(\langle \{ X_i : i \in V_T\} , T\rangle \) is defined as \(\max \{|X_i|-1 : i \in V_T\}\), and the

*treewidth*of

*G*is the minimum \(t\) such that

*G*has a tree-decomposition of width \(t\). We denote by \(\mathsf{tw}(G)\) the treewidth of

*G*.

Recall that the minimum vulnerability problem is NP-hard even for outerplanar graphs and for 2-trees (Corollary 1), which are of treewidth at most two. Therefore, unless \(\mathrm{P} = \mathrm{NP}\), the problem admits no polynomial-time algorithm even for bounded treewidth graphs. In this section, we thus give a pseudo-polynomial-time algorithm for bounded treewidth graphs.

**Theorem 2**

Let *G* be a graph whose treewidth is bounded by a fixed constant \(t\). Then, \(\mathsf{OPT}_{k}(G)\) can be computed in time \(n (k+1)^{O \left( t^{t+{4}} \right) }\), where \(n = |V(G)|\).

As a proof of Theorem 2, we give such an algorithm in the remainder of this section. Our algorithm can be easily modified so that it actually finds \(k\)\(v_s v_t\)-paths on *G* with the minimum penalty \(\mathsf{OPT}_{k}(G)\).

*G*, we may assume that \((v_s, v_t) \in E(G)\); if \((v_s, v_t) \not \in E(G)\), then add \((v_s, v_t)\) to

*E*(

*G*) and set \(\mathsf{cap}((v_s, v_t)) = 0\). The treewidth of the resulting graph is bounded by \(\mathsf{tw}(G) + 2\). From now on, let

*G*be the resulting graph such that \((v_s, v_t) \in E(G)\). Then, we have

### 3.1 Nice tree-decomposition

*G*is called a

*nice tree-decomposition*if the following conditions (5)–(11) hold (Bodlaender 1996):

- (5)
\(X_{0} = \{ v_s, v_t\}\) for the root \(0\) of \(T\);

- (6)
\(|V_T|= O(n)\);

- (7)
every node in \(V_T\) has at most two children in \(T\);

- (8)
if a node \(i \in V_T\) has two children

*l*and*r*, then \(X_i = X_l = X_r\); - (9)if a node \(i \in V_T\) has only one child
*j*, then\(|X_i| = |X_j|-1\) and \(X_i \subset X_j\) (such a node

*i*is called a*forget*node); or\(|X_i| = |X_j|+1\) and \(X_i \supset X_j\) (such a node

*i*is called an*introduce*node);

- (10)
for each edge \((u, v) \in E(G)\), there is a leaf \(i \in V_T\) such that \(u, v \in X_{i}\); and

- (11)
the bag of every leaf in \(T\) consists of exactly two vertices in

*V*(*G*).

*G*in Fig. 3a whose treewidth is three. Let \(t^\prime \) be a fixed constant. Then, for a given graph

*G*, there is a linear-time algorithm which either outputs \(\mathsf{tw}(G) > t^\prime \) or gives a nice tree-decomposition of

*G*whose width is at most \(t^\prime \) (Bodlaender 1996). Therefore, we may assume without loss of generality that

*G*and its nice tree-decomposition are both given.

Let \(\langle \{ X_i : i \in V_T\} , T\rangle \) be a nice tree-decomposition of *G*. Then, by the condition (10) of a nice tree-decomposition, for each edge \(e = (u,v) \in E(G)\), there exist some leaf bags consisting of both *u* and *v*. We arbitrarily choose one of them, say \(X_i\), and call it the *representation* of *e* which is denoted as \(\mathsf{rep}(e) = i\).

*i*of \(T\), we recursively define the vertex set \(V_{i} \subseteq V(G)\) and the edge set \(E_{i} \subseteq E(G)\), similar to the way used in Isobe et al. (1999), Ye et al. (2013), as follows:

- (a)
if

*i*is a leaf, then let \(V_{i} = X_{i}\) and \(E_{i} = \{ e \in E(G) : \mathsf{rep}(e) = i\}\); - (b)
if

*i*is an internal node having only one child*j*, then let \(V_{i} = V_{j} \cup X_{i}\) and \(E_{i} = E_{j}\), where \(V_{j}\) and \(E_{j}\) are the vertex and edge sets for*j*, respectively; and - (c)
if

*i*is an internal node having two children \(l\) and \(r\), then let \(V_{i} = V_{l} \cup V_{r}\) and \(E_{i} = E_{l} \cup E_{r}\), where \(V_{l}\) and \(E_{l}\) are the vertex and edge sets for \(l\), respectively, and \(V_{r}\) and \(E_{r}\) are the vertex and edge sets for \(r\), respectively.

*i*of \(T\), we denote by \(G_{i}\) the graph with vertex set \(V_{i}\) and edge set \(E_{i}\), that is, \(G_{i} = (V_{i}, E_{i})\). It is important to notice that, since the representation \(\mathsf{rep}(e)\) is a leaf in \(T\) for any edge \(e \in E(G)\), no edge is newly introduced by an internal node in \(T\). Furthermore, since we have chosen only one leaf \(\mathsf{rep}(e)\) for each edge

*e*, there is no edge that is contained in both \(E_{r}\) and \(E_{l}\) for any internal node

*i*with two children \(l\) and \(r\).

### 3.2 Ideas and definitions

*i*of \(T\), let \({\mathcal {S}}(X_{i})\) be the set of all permutations of the vertices in \(X_{i}\), and let \({\mathcal {A}}(X_{i})\) be the set of all \((|X_{i}|-1)\)-tuples of nonnegative integers at most \(k\); recall that \(k\) denotes the number of required \(v_sv_t\)-paths. A path

*P*in \(G_{i}\) joining two vertices \(v, v' \in X_{i}\) is

*inner*if \(V(P) \setminus \{v ,v' \} \subseteq V_i \setminus X_{i}\). For a pair of \(\varvec{s} = (v_1, v_2, \ldots , v_{|X_{i}|}) \in {\mathcal {S}}(X_{i})\) and \(\varvec{a} = (a_1, a_2, \ldots , a_{|X_{i}| -1}) \in {\mathcal {A}}(X_{i})\), a set \({\mathcal {P}}\) of paths in \(G_{i}\) is called an \((\varvec{s}, \varvec{a})\)

*-path set*if \(|{\mathcal {P}}| = \sum ^{|X_{i}|-1}_{j =1} a_j \) and \({\mathcal {P}}\) has exactly \(a_j\) inner \(v_j v_{j+1}\)-paths for each

*j*, \(1 \le j \le |X_{i}| -1\). Figure 4b illustrates an \((\varvec{s}, \varvec{a})\)-path set corresponding to \({\mathcal {P}}\) in Fig. 4a, where \(\varvec{s} = (v_1, v_3, v_4, v_5, v_2)\) and \(\varvec{a} = (0, 2, 3, 0)\). Let \(\pi (X_{i})\) be a set of pairs \((\varvec{s}_j, \varvec{a}_j)\) such that \(\varvec{s}_j \in {\mathcal {S}}(X_{i})\) and \(\varvec{a}_j \in {\mathcal {A}}(X_{i})\). Then the set \(\pi (X_{i}) = \{ (\varvec{s}_1, \varvec{a}_1), (\varvec{s}_2, \varvec{a}_2), \ldots , (\varvec{s}_{|\pi (X_{i})|}, \varvec{a}_{|\pi (X_{i})|}) \}\) is

*active*if there exists a set \(\mathcal {P}\) of inner paths in \(G_{i}\) and a partition \({\mathcal {P}}_{1}, {\mathcal {P}}_{2}, \ldots , {\mathcal {P}}_{|\pi (X_{i})|}\) of \(\mathcal {P}\) such that each \({\mathcal {P}}_{j}\), \(1 \le j \le |\pi (X_{i})|\), forms an \((\varvec{s}_j, \varvec{a}_j)\)-path set. Such a set \(\mathcal {P}\) is called a \(\pi (X_{i})\)

*-path set*. Finally, for a set \(\pi (X_{i})\), we define

Our algorithm computes \(\lambda (\pi (X_{i}))\) for all sets \(\pi (X_{i})\) for each bag \(X_{i}\) of \(T\), from the leaves of \(T\) to the root 0 of \(T\), by means of dynamic programming. Then, \(\mathsf{OPT}_{k}(G)\) can be computed at the root 0 from the values \(\lambda (\pi (X_{0}))\), as described in Sect. 3.3.

### 3.3 Algorithm

In this subsection, we explain how to compute all values \(\lambda (\pi (X_{i}))\) for each node \(i\in V_T\) of \(T\) and all sets \(\pi (X_{i})\) for \(X_{i}\). More specifically, we first compute all values \(\lambda (\pi (X_{i}))\) for each leaf \(i\) of \(T\), and then compute \(\lambda (\pi (X_{i}))\) for each internal node \(i\) in \(T\). Finally, after computing all values \(\lambda (\pi (X_{0}))\) for the root 0 of \(T\), we compute \(\mathsf{OPT}_{G}(k)\).

#### 3.3.1 The node *i* is a leaf in \(T\)

- (i)
\(\pi (X_{i}) = \{ (\varvec{s}, \varvec{a}) \}\) such that \(\varvec{s}\) is either \((v_1, v_2)\) or \((v_2,v_1)\), \(\varvec{a} = (a_1)\), and \(a_1 \le \mathsf{cap}(e)\); and

- (ii)
\(\pi (X_{i}) = \{ (\varvec{s}, \varvec{a}), (\varvec{s}^\prime , \varvec{a}^\prime ) \}\) such that \(\varvec{s} = (v_1, v_2)\), \(\varvec{a} = (a_1)\), \(\varvec{s}^\prime = (v_2, v_1)\), \(\varvec{a}^\prime = (a_1^\prime )\), and \(a_1 + a_1^\prime \le \mathsf{cap}(e)\).

#### 3.3.2 The node *i* is an internal node

Since \(\langle \{ X_i : i \in V_T\} , T\rangle \) is a nice tree-decomposition of *G* and the node *i* is an internal node, *i* has two children, is a forget node, or is an introduce node. Therefore, we have the following three cases to consider.

- (i)
\(|\pi (X_{l})| = |\pi (X_{r})| = |\pi (X_{i})|\); and

- (ii)
let \(q = |\pi (X_{i})|\), then the pairs in \(\pi (X_{i})\), \(\pi (X_{l})\) and \(\pi (X_{r})\) can be ordered as \(\{ (\varvec{s}_1, \varvec{a}_1), (\varvec{s}_2, \varvec{a}_2), \ldots , (\varvec{s}_{q}, \varvec{a}_{q}) \}\), \(\{ (\varvec{s}_{l_1}, \varvec{a}_{l_1}), (\varvec{s}_{l_2}, \varvec{a}_{l_2}), \ldots , (\varvec{s}_{l_q}, \varvec{a}_{l_q}) \}\) and \(\{ (\varvec{s}_{r_1}, \varvec{a}_{r_1}), (\varvec{s}_{r_2}, \varvec{a}_{r_2}), \ldots , (\varvec{s}_{r_q}, \varvec{a}_{r_q}) \}\), respectively, such that \(\varvec{s}_j = \varvec{s}_{l_j} = \varvec{s}_{r_j}\) and \(\varvec{a}_j = \varvec{a}_{l_j} + \varvec{a}_{r_j}\) for all

*j*, \(1 \le j \le q\), where \(\varvec{a}_{l_j} + \varvec{a}_{r_j}\) is defined as the addition of each pair of corresponding elements in \(\varvec{a}_{l_j}\) and \(\varvec{a}_{r_j}\).

**Case 2** The node *i* is a forget node.

*i*, and let

*v*be the vertex such that \(X_{j} \setminus X_{i} = \{ v \}\). Let \(\pi (X_{j}) \in 2^{{\mathcal {S}}(X_{j}) \times {\mathcal {A}}(X_{j})}\) and \((\varvec{s}^\prime , \varvec{a}^\prime ) \in \pi (X_{j})\) with \(\varvec{s}^\prime = (v^\prime _1, v^\prime _2, \ldots , v^\prime _{|X_{j}|})\) and \(\varvec{a}^\prime = (a^\prime _1, a^\prime _2, \ldots ,\)\(a^\prime _{|X_{j}| -1})\). We denote by \({\mathsf {ind}}(\varvec{s}^\prime , v)\) the index such that \(v^\prime _{{\mathsf {ind}}(\varvec{s}^\prime , v)} = v\) in \(\varvec{s}^\prime \). Note that

*v*appears in any \(\varvec{s}^\prime \in {\mathcal {S}}(X_{j})\) exactly once, and hence \({\mathsf {ind}}(\varvec{s}^\prime , v)\) is well defined. In addition, we may assume that \({\mathsf {ind}}(\varvec{s}^\prime , v) \not \in \{ 1, |X_{j}| \}\) in this case, because both \(v_s\) and \(v_t\) are contained in the bag \(X_{0}\) for the root 0 of

*T*. We denote by \(\varvec{s}^\prime \setminus v\) the sequence obtained from \(\varvec{s}^\prime \) by deleting

*v*, that is, \(\varvec{s}^\prime \setminus v = (v^\prime _1, v^\prime _2, \ldots , v^\prime _{{\mathsf {ind}}(\varvec{s}^\prime , v)-1}, v^\prime _{{\mathsf {ind}}(\varvec{s}^\prime , v)+1}, \ldots , v^\prime _{|X_{j}|})\), and by \(\varvec{a}^\prime \setminus v\) the sequence obtained from \(\varvec{a}^\prime \) by deleting \(a_{{\mathsf {ind}}(\varvec{s}^\prime , v)}^\prime \), that is, \(\varvec{a}^\prime \setminus v = (a^\prime _1, a^\prime _2, \ldots , a^\prime _{{\mathsf {ind}}(\varvec{s}^\prime , v)-1}, a^\prime _{{\mathsf {ind}}(\varvec{s}^\prime , v)+1}, \ldots , a^\prime _{|X_{j}|-1})\). Then, a set \(\pi (X_{i}) \in 2^{{\mathcal {S}}(X_{i}) \times {\mathcal {A}}(X_{i})}\) is active if and only if there exists an active set \(\pi (X_{j})\in 2^{{\mathcal {S}}(X_{j}) \times {\mathcal {A}}(X_{j})}\) such that

- (i)
\(a^\prime _{{\mathsf {ind}}(\varvec{s}^\prime , v)-1} = a^\prime _{{\mathsf {ind}}(\varvec{s}^\prime , v)}\) for each pair \((\varvec{s}^\prime , \varvec{a}^\prime ) \in \pi (X_{j})\); and

- (ii)
\(\sum \varvec{a}^\prime \setminus v = \varvec{a}\) for each \((\varvec{s}, \varvec{a}) \in \pi (X_{i})\), where the summation is taken over all pairs \((\varvec{s}^\prime , \varvec{a}^\prime ) \in \pi (X_{j})\) such that \(\varvec{s}^\prime \setminus v = \varvec{s}\).

**Case 3** The node *i* is an introduce node.

*i*, and let

*v*be the vertex such that \(X_{i} \setminus X_{j} = \{ v \}\). Recall that, by the construction of the corresponding subgraph \(G_{i}\), no edge is newly introduced by any internal node in \(T\). Since

*v*is introduced at this node

*i*, the subgraph \(G_{i}\) contains no inner \(v v^\prime \)-path for any vertex \(v^\prime \in X_{i} \setminus \{ v\}\). Thus, a set \(\pi (X_{i})\in 2^{{\mathcal {S}}(X_{i}) \times {\mathcal {A}}(X_{i})}\) is active if and only if the following two conditions hold:

- (i)
\(a_{{\mathsf {ind}}(\varvec{s}, v)-1} = a_{{\mathsf {ind}}(\varvec{s}, v)} = 0\) for each pair \((\varvec{s}, \varvec{a}) \in \pi (X_{i})\), where \(\varvec{a} = (a_1, a_2, \ldots , a_{|X_{i}|-1})\) and regard \(a_{0} = a_{|X_{i}|} = 0\) if \({\mathsf {ind}}(\varvec{s}, v) \in \{ 1, |X_{i}| \}\); and

- (ii)
the set \(\pi (X_{j})\in 2^{{\mathcal {S}}(X_{j}) \times {\mathcal {A}}(X_{j})}\) obtained from the set \(\pi (X_{i})\) as follows is active in \(G_{j}\): \(\pi (X_{j}) = \{ (\varvec{s} \setminus v, \varvec{a}' ) \mid (\varvec{s}, \varvec{a}) \in \pi (X_{i}) \}\), where \(\varvec{a}' = \sum \varvec{a}^{\prime \prime } \setminus v\) by taking the summation over all pairs \((\varvec{s}^{\prime \prime }, \varvec{a}^{\prime \prime }) \in \pi (X_{i})\) such that \(\varvec{s}^{\prime \prime } \setminus v = \varvec{s} \setminus v\).

#### 3.3.3 The node *i* is the root \(0\) of \(T\)

- (i)
\(\pi (X_{0}) = \{ (\varvec{s}, \varvec{a}) \}\) such that \(\varvec{a} = (a_1)\) and \(a_1 = k\); and

- (ii)
\(\pi (X_{0}) = \{ (\varvec{s}, \varvec{a}), (\varvec{s}^\prime , \varvec{a}^\prime ) \}\) such that \(\varvec{a} = (a_1)\), \(\varvec{a}^\prime = (a_1^\prime )\) and \(a_1 + a_1^\prime = k\).

### 3.4 Running time

*O*(1) time for each set \(\pi (X_{i})\). Therefore, the values \(\lambda (\pi (X_{i}))\) for all active sets \(\pi (X_{i}) \in 2^{{\mathcal {S}}(X_{i}) \times {\mathcal {A}}(X_{i})}\) can be computed in \((k+ 1)^{O \left( t^{t+{4}}\right) }\) time. By the condition (6) of a nice tree-decomposition, \(T\) has

*O*(

*n*) leaves; one can thus compute \(\lambda (\pi (X_{i}))\) for all leaves of \(T\) in \(n (k+ 1)^{O \left( t^{t+{4}}\right) }\) time.

Similarly, for each internal node \(i\in V_T\), each of the update formulas in Sect. 3.3.2 can be computed in \(( k+ 1)^{O \left( t^{t+{4}}\right) }\) time for each set \(\pi (X_{i})\). Therefore, the values \(\lambda (\pi (X_{i}))\) for all active sets \(\pi (X_{i}) \in 2^{{\mathcal {S}}(X_{i}) \times {\mathcal {A}}(X_{i})}\) can be computed in \((k+ 1)^{O \left( t^{t+{4}}\right) }\) time for each internal node \(i\). By the condition (6) of a nice tree-decomposition, \(T\) has *O*(*n*) internal nodes, and hence one can compute the values \(\lambda (\pi (X_{i}))\) for all internal nodes of \(T\) in \(n (k+ 1)^{O \left( t^{t+{4}}\right) }\) time.

Finally, recall that \(|X_{0}| = 2\) for the root \(0\) of \(T\). Therefore, according to Sect. 3.3.3 one can compute \(\mathsf{OPT}_{k}(G)\) in *O*(*k*) time from the values \(\lambda (\pi (X_{0}))\).

In this way, our algorithm runs in \(n (k+ 1)^{O \left( t^{t+{4}}\right) }\) time in total. This completes the proof of Theorem 2.

## 4 Fixed-parameter algorithm for chordal graphs

A graph *G* is *chordal* if every cycle in *G* of length at least four has a chord, which is an edge joining non-consecutive vertices in the cycle (Brandstädt et al. 1999).

We have shown in Corollary 1 that the minimum vulnerability problem is NP-hard for complete graphs, which form a subclass of chordal graphs, even when \(\mathsf{vul}(e) \ge 1\) and \(\mathsf{cap}(e) \ge 1\) hold for all edges \(e \in E(G)\). In this section, we thus give a fixed-parameter algorithm for chordal graphs when parameterized by the number \(k\) of required \(v_s v_t\)-paths.

**Theorem 3**

Let *G* be a chordal graph with *n* vertices and *m* edges such that \(\mathsf{vul}(e) \ge 1\) and \(\mathsf{cap}(e) \ge 1\) hold for all edges \(e \in E(G)\). Then, \(\mathsf{OPT}_{k}(G)\) can be computed in time \(m + n (k+1)^{O \left( k^{3k+2} \right) }\).

As a proof of Theorem 3, we give such an algorithm in the remainder of this section. Let \({\mathcal {C}}_G\) be the set of all maximal cliques in a graph *G*, and let \({\mathcal {C}}_{v} \subseteq {\mathcal {C}}_G\) be the set of all maximal cliques that contain a vertex \(v \in V(G)\). It is known that *G* is chordal if and only if there exists a tree *T* such that each node of *T* corresponds to a maximal clique in \({\mathcal {C}}_G\) and the subgraph of *T* induced by \({\mathcal {C}}_{v}\) is connected for every vertex \(v \in V(G)\) (Gavril 1974). Such a tree is called a *clique tree* of *G*, and it can be constructed in linear time (Spinrad 2003, Sect. 15.1). Indeed, a clique tree of a chordal graph *G* is a tree-decomposition of *G*.

Consider any clique \(X\) in a graph *G*. Let \(G_X\) be the graph obtained from *G* by contracting all vertices in \(X\) into a single vertex \(v_X\). Each resulting edge \((v, v_X)\), \(v \in V(G_X)\setminus \{ v_X\}\), has the same values of cost, vulnerability and capacity as its original edge; let \(v_s= v_X\) if \(v_s\in V(X)\); and let \(v_t= v_X\) if \(v_t\in V(X)\). Then, we have the following lemma; note that the lemma holds for any graph (which is not necessarily chordal).

**Lemma 1**

Let *G* be a graph such that \(\mathsf{vul}(e) \ge 1\) and \(\mathsf{cap}(e) \ge 1\) hold for all edges \(e \in E(G)\). Suppose that *G* has a clique \(X\) such that \(|V(X)| \ge 3k\). Then, \(\mathsf{OPT}_{k} (G, v_s, v_t) = \mathsf{OPT}_{k} (G_X, v_s, v_t)\).

*Proof*

We first prove that \(\mathsf{OPT}_{k} (G, v_s, v_t) \ge \mathsf{OPT}_{k} (G_X, v_s, v_t)\) holds. Let \({\mathcal {P}}^*\) be a set of \(k\)\(v_sv_t\)-paths as an optimal solution in *G*. For each \(v_sv_t\)-path \(P \in {\mathcal {P}}^*\), the edge set \(E(P) \setminus E(X)\) clearly forms a \(v_sv_t\)-path in \(G_X\). Since every edge in \(G_X\) has the same values of cost, vulnerability and capacity as its corresponding edge in *G*, we can obtain a set \({\mathcal {P}}_X\) of \(k\)\(v_sv_t\)-paths in \(G_X\) such that \(\lambda ({\mathcal {P}}_X) = \lambda ({\mathcal {P}}^*)\). Thus, we have \(\mathsf{OPT}_{k} (G_X, v_s, v_t) \le \lambda ({\mathcal {P}}_X) = \lambda ({\mathcal {P}}^*) = \mathsf{OPT}_{k} (G, v_s, v_t)\), as claimed.

We then prove that \(\mathsf{OPT}_{k} (G, v_s, v_t) \le \mathsf{OPT}_{k} (G_X, v_s, v_t)\) holds. Let \({\mathcal {P}}_X^*\) be a set of \(k\)\(v_sv_t\)-paths as an optimal solution in \(G_X\). Then, we will construct a set \({\mathcal {P}}\) of \(k\)\(v_sv_t\)-paths in *G* from \({\mathcal {P}}_X^*\) such that \(\lambda ({\mathcal {P}}) = \lambda ({\mathcal {P}}_X^*)\). For each \(v_sv_t\)-path \(P_X\in {\mathcal {P}}_X^*\), there are the following two cases to consider.

**Case 1**\(P_X\) does not pass through \(v_X\). (See Fig. 6.)

*P*in

*G*. Therefore, we simply add the path

*P*to \({\mathcal {P}}\).

**Case 2**\(P_X\) passes through \(v_X\). (See Fig. 7.)

In this case, the edges in \(P_X\) form at most two paths in *G*: one is a \(v_sv_1\)-path \(P_1\) and the other is a \(v_2v_t\)-path \(P_2\) for some pair of vertices \(v_1, v_2 \in V(X)\).

If \(v_1 = v_2\), then \(E(P_1) \cup E(P_2)\) forms a \(v_sv_t\)-path *P* in *G*. Therefore, we simply add the path *P* to \({\mathcal {P}}\).

If \(v_1 \ne v_2\), then we choose an arbitrary vertex \(u \in V(X)\) which is not on any path in the current set \({\mathcal {P}}\) and is not an endpoint of any edge that corresponds to an edge appears in the paths in \({\mathcal {P}}_X^*\). Since \(|{\mathcal {P}}_X^*| = k\), there are at most \(2k\) edges which are incident to \(v_X\) and appear in the paths in \({\mathcal {P}}_X^*\). Since \(|V(X)| \ge 3k\), there are at least \(|V(X)| - 2k\ge k\) vertices in \(X\) which can be chosen as such a vertex *u* in total; thus, we can always choose *u*. Recall that \(X\) is a clique in *G*, and hence by adding two edges \(e_1 = (v_1, u)\) and \(e_2 = (u, v_2)\), we can join \(P_1\) with \(P_2\) and obtain a \(v_sv_t\)-path *P* in *G*. We add *P* to \({\mathcal {P}}\). Recall that \(\mathsf{vul}(e_1) \ge 1\), \(\mathsf{cap}(e_1) \ge 1\), \(\mathsf{vul}(e_2) \ge 1\), and \(\mathsf{cap}(e_2) \ge 1\). Furthermore, by the choice of *u*, we know that these two edges \(e_1\) and \(e_2\) are not used by any other \(v_sv_t\)-paths in \({\mathcal {P}}\). Thus, we do not need to pay the costs for these edges.

This completes the construction of the set \({\mathcal {P}}\) of \(k\)\(v_sv_t\)-paths in *G* from \({\mathcal {P}}_X^*\) such that \(\lambda ({\mathcal {P}}) = \lambda ({\mathcal {P}}_X^*)\). Then, we have \(\mathsf{OPT}_{k} (G, v_s, v_t) \le \lambda ({\mathcal {P}}) = \lambda ({\mathcal {P}}_X^*) = \mathsf{OPT}_{k} (G_X, v_s, v_t)\), as claimed. \(\square \)

We are now ready to prove Theorem 3.

### 4.1 Proof of Theorem 3

*G*. Recall that a clique tree \(T\) of a chordal graph

*G*is a tree-decomposition of

*G*such that each node of \(T\) corresponds to a maximal clique in

*G*. Therefore, we can apply Lemma 1 to any node

*i*of

*T*such that \(|X_{i}| \ge 3k\). Then, one can easily observe that \(\mathsf{tw}(G_{X_i}) \le \mathsf{tw}(G)\), where \(G_{X_i}\) is the graph obtained from

*G*by contracting all vertices in \(X_{i}\) into a single vertex; by repeatedly applying Lines 6–7, we eventually obtain a tree-decomposition (clique tree) \(T\) such that all nodes \(i \in V_T\) satisfy \(|X_{i}| \le 3k-1\) and hence the treewidth is bounded by \(3k-2\). Then, using Theorem 2 one can correctly compute \(\mathsf{OPT}_{k} (G, v_s, v_t)\).

We finally estimate the running time of \(\mathsf{Alg}(G, v_s, v_t, k)\). Recall that Line 1 can be done in linear time (Spinrad 2003). Since a clique tree has *O*(*n*) nodes, Lines 6–7 can be executed in linear time in total. Since Lines 2–3 are executed for the graph whose treewidth is bounded by \(3k-2\), by Theorem 2 these lines can be done in \(n(k+1)^{O \left( k^{3k+2} \right) }\) time.

This completes the proof of Theorem 3.

## 5 Concluding remark

In this paper, we have studied the minimum vulnerability problem from the viewpoint of specific graph classes. We note that our algorithm for bounded treewidth graphs can be easily modified for the problem on digraphs. It remains open to develop a fixed-parameter algorithm for the problem on general graphs. Also, the complexity status for the problem on cacti is open.

## Notes

### Acknowledgments

Magnús M. Halldórsson and Christian Konrad are supported by Icelandic Research Fund Grant-of-Excellence No. 120032011. Takehiro Ito is partially supported by JSPS KAKENHI 25330003.

### Compliance with ethical standards

### Conflict of Interest

The authors declare that they have no conflict of interest.

### References

- Aoki Y, Halldórsson BV, Halldórsson MM, Ito T, Konrad C, Zhou X (2014) The minimum vulnerability problem on graphs. In: Proc. COCOA 2014, LNCS 8881, pp. 299–313Google Scholar
- Assadi S, Emamjomeh-Zadeh E, Norouzi-Fard A, Yazdanbod S, Zarrabi-Zadeh H (2012) The minimum vulnerability problem. In: Proc. ISAAC 2012, LNCS 7676, pp. 382–391Google Scholar
- Bodlaender HL (1996) A linear-time algorithm for finding tree-decompositions of small treewidth. SIAM J Comput 25:1305–1317MathSciNetCrossRefMATHGoogle Scholar
- Brandstädt A, Le VB, Spinrad JP (1999) Graph classes: a survey. SIAM, PhiladelphiaCrossRefMATHGoogle Scholar
- Even G, Kortsarz G, Slany W (2005) On network design problems: fixed cost flows and the covering Steiner problem. ACM Trans Algorithms 1:74–101MathSciNetCrossRefMATHGoogle Scholar
- Garey MR, Johnson DS (1979) Computers and intractability: a guide to the theory of NP-completeness. Freeman, San FranciscoMATHGoogle Scholar
- Gavril F (1974) The intersection graphs of subtrees in trees are exactly the chordal graphs. J Comb Theory Ser B 16:47–56MathSciNetCrossRefMATHGoogle Scholar
- Goldberg AV, Rao S (1998) Beyond the flow decomposition barrier. J ACM 45:783–797MathSciNetCrossRefMATHGoogle Scholar
- Isobe S, Zhou X, Nishizeki T (1999) A polynomial-time algorithm for finding total colorings of partial \(k\)-trees. Int J Found Comput Sci 10:171–194MathSciNetCrossRefMATHGoogle Scholar
- Krumke SO, Noltemeier H, Schwarz S, Wirth H-C, Ravi R (1998) Flow improvement and network flows with fixed costs. Proc OR 1998:158–167MathSciNetMATHGoogle Scholar
- Nishizeki T, Vygen J, Zhou X (2001) The edge-disjoint path problem is NP-complete for series-parallel graphs. Discret Appl Math 115:177–186MathSciNetCrossRefMATHGoogle Scholar
- Omran MT, Sack J-R, Zarrabi-Zadeh H (2013) Finding paths with minimum shared edges. J Combin Optim 26:709–722MathSciNetCrossRefMATHGoogle Scholar
- Spinrad JP (2003) Efficient graph representations. American Mathematical Society, ProvidenceCrossRefMATHGoogle Scholar
- Yang B, Yang M, Wang J, Zheng SQ (2005a) Minimum cost paths subject to minimum vulnerability for reliable communications. Proc ISPAN 2005:334–339Google Scholar
- Yang M, Wang J, Qi X, Jiang Y (2005b) On finding the best partial multicast protection tree under dual-homing architecture. In: Proc IEEE HPSR, pp. 128–132Google Scholar
- Ye ZQ, Li YM, Lu HQ, Zhou X (2013) Finding paths with minimum shared edges in graphs with bounded treewidth. Proc FCS 2013:40–46Google Scholar