An Improved Integrality Gap for Steiner Tree

TL;DR

This paper presents a combinatorial primal-dual algorithm that significantly improves the upper bound on the integrality gap of the bidirected cut relaxation for Steiner tree problems from 2 to 1.5, bringing it closer to the conjectured lower bound.

Contribution

It introduces a new combinatorial algorithm that tightens the upper bound on the integrality gap for Steiner tree relaxations, advancing theoretical understanding.

Findings

Upper bound on integrality gap improved to 3/2

Algorithm based on primal-dual schema

Brings upper bound closer to the conjectured lower bound

Abstract

A promising approach for obtaining improved approximation algorithms for Steiner tree is to use the bidirected cut relaxation (BCR). The integrality gap of this relaxation is at least $36/31$, and it has long been conjectured that its true value is very close to this lower bound. However, the best upper bound for general graphs was an almost trivial $2$. We improve this bound to $3/2$ by a combinatorial algorithm based on the primal-dual schema.

Equations

$${\rho }_k=\frac{(r+1)2^r+s}{r{2}^r+s}\le 1+\frac{1}{\lfloor {\log }_{2}k\rfloor }.$$

$$\sum _{e\in E}c(e)x_e$$

$$\sum _{e\in {\delta }^{+}(S)}{x}_e\ge 1,$$

$$x_e\ge 0,$$

$$\sum _{S\subseteq V\setminus \{r\},S\cap R\ne \varnothing }{y}_S$$

$$\sum _{\begin{array}{c}S:e\in {\delta }^{+}(S)\end{array}}{y}_S\le c(e),$$

$$y_S\ge 0,$$

$$d(S,\ell ):=\left|\left\{v\in S\cap \left(\bigcup _{S^{\prime }\in {\mathcal{S}}_{\ell }\setminus S}{S}^{\prime }\right)\right\}\right|$$

$$\Delta (S,\ell ):=\left|\{S^{\prime }\in {\mathcal{S}}_{\ell }|d(S^{\prime },\ell )\ge 2,S\cap S^{\prime }\ne \varnothing \}\right|$$

Full text

1 Introduction

In the Steiner tree problem, we are given an undirected graph $G(V,E)$, a cost function on the edges $c:E\rightarrow\mathbb{Q}_{\geq 0}$ and a subset of vertices $R\subseteq V$ called terminals. The objective is to find a tree $T$ of minimum cost $c(T):=\sum_{e\in E(T)}c(e)$, which connects all the terminals. In general, the solution might contain vertices that are not in $R$. These vertices are often called Steiner vertices. The essence of the problem lies in the case where the vertices are assumed to be the points of a metric space. Thus, we work on the metric completion of the input graph. The Steiner tree problem takes a central place in the field of approximation algorithms. It is a natural generalization of the minimum spanning tree problem and appears as a special case of a large number of network design problems that are of great interest.

The Steiner tree problem appears as an NP-hard problem in Karp’s classic paper [20]. In fact, it is NP-hard to find an approximation ratio better than $\frac{96}{95}$ [9, 10]. The fact that a minimum spanning tree on the terminals is twice the cost of an optimum solution has been exploited by early authors [14, 11, 19, 22, 23, 28] resulting in $2$-approximation algorithms (see also [29]). The first algorithm breaking the barrier of factor $2$ came from Zelikovsky [30] followed by a series of work [2, 24, 21, 18] resulting in the best purely combinatorial algorithm of factor $1+\frac{\ln{3}}{2}\approx 1.55$ by Robins and Zelikovsky [26, 27]. More recently, an LP-based algorithm was provided by Byrka et al. [4, 5] achieving the approximation ratio $\ln{4}\approx 1.39$, which stands as the current best result for approximating the problem.

All the aforementioned improved algorithms are concerned with the concept of a $k$-restricted Steiner tree. A component is a tree whose leaves are all from the set of terminals $R$. A $k$-component is a component having at most $k$ terminals as leaves. A $k$-restricted Steiner tree $T$ is a collection of components whose union induces a Steiner tree. In this case, the cost $c(T)$ of $T$ is the total cost of its components, counting the duplicated edges with their multiplicity. A theorem of Borchers and Du [3] states that in order to get a good approximation ratio for Steiner tree, it is sufficient to consider $k$-restricted Steiner trees provided that $k$ is large enough. In particular, let $\rho_{k}$ be the supremum of the ratio between the cost of an optimal $k$-restricted Steiner tree and the cost of an optimal Steiner tree with no restrictions.

Theorem 1**.**

[3] Given nonnegative integers $r$ and $s$ satisfying $k=2^{r}+s$ and $s<2^{r}$, we have

[TABLE]

Given an optimal solution with a set of components, a specific component is optimal for the problem induced by its terminals. Besides, contracting the vertices in a specific component creates a tree which is also optimal for the residual problem. Using these and Theorem 1, a natural approach for approximating Steiner tree is then following: Start from a minimum spanning tree on terminals (which is $2$-approximate), identify by some greedy selection criteria, a $k$-component to contract, remove redundant edges and iterate until there is no improvement. The early combinatorial algorithms together with the LP rounding algorithm of ratio $1.39$ using the directed-component cut relaxation (DCR) have used this general idea. One obvious disadvantage of this scheme is that it requires computing optimal $k$-components for large values of $k$. Although this can be done in polynomial-time, in order to attain the claimed approximation ratios, the running time has to be exorbitantly high. Another disadvantage is that the true nature of the algorithms are not fully apparent as there is, to the best of our knowledge, no way of constructing a tight example on which the algorithm is forced to give a solution with quality close to the proven bound.

It is clear by the foregoing discussion that the case for the Steiner tree problem with respect to approximability is rather unusual from what we have been used to see for some of the other fundamental combinatorial optimization problems. In the ideal setting, we have an LP relaxation for a problem together with an algorithm fully exploiting this relaxation in the sense that its approximation ratio is equal to the integrality gap of the relaxation. The approximation ratio of the algorithm is usually proven by comparing the cost of the solution to the optimum value of the LP relaxation or the value of a dual feasible solution. It is also not difficult to find a tight example for the algorithm, which would provide hints on improving the approximation ratio. A good example of this phenomenon is the more general Steiner forest problem with the undirected cut relaxation and the famous algorithms of [1, 17].

The most promising approach along this line for the Steiner tree problem is to use the bidirected cut relaxation (BCR), which we now describe. We first fix a root vertex $r\in R$. We then replace each edge $e=\{u,v\}\in V$ by two directed edges $(u,v)$ and $(v,u)$ each with cost $c(e)$. For a given cut $S\in V$, we define $\delta^{+}(S)=\{(u,v)\in E:u\in S,v\notin S\}$, i.e. the set of edges emanating from $S$. Then the following is a relaxation for the Steiner tree problem:

[TABLE]

The BCR has been known for more than half a century [12], yielding optimal results for finding minimum spanning trees and in general minimum cost branchings. There are results proving upper bounds on the integrality gap of the BCR for quasi-bipartite graphs. In particular, Rajagopalan and Vazirani [25] puts an upper bound of $\frac{3}{2}$. Chakrabarty, Devanur and Vazirani [6] puts an upper bound of $\frac{4}{3}$ (via an algorithm that does not run in strongly polynomial-time) for this class of graphs using a related relaxation they called simplex-embedding LP. Given the scarcity of the results thus far, the question of fully exploiting the BCR remains as a major open problem, especially given that the obtained approximation ratios are still far away from the best lower bound for the integrality gap. This is also related to one of the most important meta-problems in the field of approximation algorithms: the problem of whether one can always fully exploit a relaxation for a given problem, which was already mentioned by Vazirani in his book [29] in the Open Problems chapter, while discussing the Steiner tree problem and whether one can obtain a significantly better approximation ratio using the BCR: “A more general issue along these lines is to clarify the mysterious connection between the integrality gap of an LP-relaxation and the approximation factor achievable using it”.

This paper shows that the BCR can be exploited to a certain extent for general graphs.

Theorem 2**.**

The integrality gap of the BCR is at most $\frac{3}{2}$. Furthermore, there exists a polynomial-time primal-dual $\frac{3}{2}$-approximation algorithm for Steiner tree based on the BCR.

This result is an improvement upon the previous combinatorial best approximation ratio $1+\frac{\ln{3}}{2}\approx 1.55$. It is based on a combinatorial algorithm utilizing the primal-dual schema, and does not require solving an LP. In particular, we extend the canonical primal-dual schema with synchronous dual growth by introducing the following idea: Instead of continuing the growth of all unsatisfied duals, we stop some of the high-degree duals if they already “connect” to another high-degree dual via a Steiner vertex.

1.1 Related Work

A catalog of different LP relaxations for Steiner tree is given in [15]. Proving an integrality gap of smaller than $2$ using one of these relaxations has attracted much attention. An upper bound of $1.55$ was proven by [5] for the DCR. A simpler proof of this fact using an equivalent formulation appears in [7]. This upper bound was improved by [16] to $1.39$, which also proves an upper bound of $\frac{73}{60}$ for quasi-bipartite graphs (graphs in which there are no edges between the Steiner vertices), and provides a deterministic algorithm with the same performance ratio as that of [5] by solving the LP only once. This upper bound is also valid for the BCR as will be noted below. However, it is not obtained via the usual primal-dual schema.

The relationship between the BCR and the DCR has also been studied. One of the motivations for this is that using the BCR results in much more efficient algorithms due to its size. The first such result was given by [8], which shows that the two relaxations are equivalent on quasi-bipartite graphs. An efficient procedure converting a solution from the BCR to the DCR was then given by [16]. This equivalence is strengthened to the case of graphs that do not have a claw on Steiner nodes by [13]. These are instances which do not contain a Steiner vertex with three Steiner neighbors.

2 The Naive Primal-Dual Algorithm: 2-Approximation

The following is the dual of the BCR:

[TABLE]

We first present the straightforward primal-dual algorithm employing the well-known idea of growing dual variables (or simply duals) uniformly and synchronously at unit rate. In the course of the algorithm, given a running solution $T$, a cut $S$ (synonymously a dual) satisfying the following properties is called a minimal violated set over $T$:

$S\subseteq V\setminus\{r\},S\cap R\neq\emptyset$; 2. 2.

The degree of $S$ on $T$, $\delta_{T}(S):=|\delta^{+}(S)\cap T|=0$; 3. 3.

$S$ is minimal with respect to inclusion.

The running solution $T$ is initialized to $\emptyset$. The minimal violated sets are initially the singleton vertices in $R\setminus\{r\}$. The algorithm uniformly and synchronously grows the duals corresponding to these sets until a constraint in (BCR-D) corresponding to an edge (or simply an edge) becomes tight. The edge is then included into $T$, and the minimal violated sets over $T$ are recomputed. We conceive the growth of duals as a continuous process over time, with one unit cost covered in one unit of time. Accordingly, the grown duals are said to cover an edge, or some part of an edge it has grown over. The iterations continue until there is a directed path in $T$ from each terminal in $R\setminus\{r\}$ to $r$, i.e., $T$ is feasible. This is followed by the pruning phase, which is an execution of the so-called reverse-delete step utilized by many primal-dual algorithms. It considers deletion of the edges in $T$ ordered with non-increasing inclusion time. It discards an edge $e$ if $T\setminus\{e\}$ remains feasible.

We provide two example executions of the algorithm to point out its finer details. The first one underlines its difference from the usual application of the primal-dual schema using the undirected cut relaxation. The second one is an example showing that the algorithm cannot provide an approximation factor better than $2$. Figure 1(a) shows an input graph together with the initial minimal violated sets considered by the algorithm. We have the configuration in Figure 1(b) at time $t=1$ in which only the selected edges are shown. At this point, the minimal violated sets are $\{r_{1},s\}$, and $\{r_{2},s\}$. At time $t=\frac{3}{2}$, the algorithm arrives at a feasible solution as shown in Figure 1(c). On the edge taken in the interim, there are two distinct duals growing on the edge $(s,r)$, corresponding to the aforementioned minimal violated sets, so that it takes half unit of time to cover it. Note also that the edge $(r_{2},r)$ of cost $\frac{3}{2}+\epsilon$ is not selected, which is in contrast to an execution of the primal-dual schema using the undirected cut relaxation. The total value of all the duals (the ones in Figure 1(a) and Figure 1(b)) is $3$, which is equal to the cost of the directed edges from the terminals to $r$. Thus, the solution returned by the algorithm is optimal.

Figure 2 and Figure 3 depict another execution. Figure 2(a) shows the input graph together with the initial minimal violated sets. The terminals $r^{\prime}$ and $r^{\prime\prime}$ are connected to all the Steiner vertices $s_{1},\ldots,s_{k}$ with a cost of $1$, where $k$ is a large number. The terminal $r_{i}$ is connected to $s_{i}$, for $i\in\{1,\ldots,k\}$ with a cost of $1$. The cost of the edges $(s_{i},r)$ is $3-\epsilon$, for $i\in\{1,\ldots,k\}$. The augmentation phase selects all the edges directed to the root. On the edge $(s_{i},r)$, there are three duals growing in the time period $[1,2-\frac{\epsilon}{3}]$. These correspond to the cuts $\{r_{i},s_{i}\}$, $\{r^{\prime},s_{1},\ldots,s_{k}\}$, and $\{r^{\prime\prime},s_{1},\ldots,s_{k}\}$. In the pruning phase, none of the edges of cost $3-\epsilon$ is deleted, and $T$ is shown in Figure 2(b). Its cost is $(4-\epsilon)k+2$, whereas the optimal solution has cost $2k+5-\epsilon$, as shown in Figure 3.

3 The Algorithm with the Enhanced Primal-Dual Schema: 3/2-Approximation

The problem with the naive primal-dual schema is that there might be more than one high-degree dual (with respect to $T$) growing on an edge, as exemplified in the previous section. There is a simple modification, which forbids this, and in turn implies an improved approximation ratio. Let $\mathcal{S}_{\ell}$ be the set of duals to be grown at the beginning of an iteration $\ell$. Given a dual $S\in\mathcal{S}_{\ell}$, define

[TABLE]

For a dual $S$ with $d(S,\ell)\geq 2$, the dual degree of $S$ at iteration $\ell$, is defined to be

[TABLE]

To give an example, the duals $\{r^{\prime},s_{1},\ldots,s_{k}\}$ and $\{r^{\prime\prime},s_{1},\ldots,s_{k}\}$ in Figure 2(a) in the time period $[1,2-\frac{\epsilon}{3}]$ have both dual degree $1$. Form the graph of duals $G_{D}=(V_{D},E_{D})$ at iteration $\ell$ as follows. $V_{D}$ consists of duals $S$ with $\Delta(S,\ell)\geq 1$, and there is an edge in $E_{D}$ between $S$ and $S^{\prime}$ if they share at least one vertex, i.e., $S\cap S^{\prime}\neq\emptyset$. In this case, we say that $S$ and $S^{\prime}$ are adjacent to each other. The algorithm computes a maximal independent set on the graph of duals at each iteration, and stops the growth of all the duals that are not in this independent set. All the other duals continue to grow, and the pruning phase is applied as usual.

Proposition 3**.**

The running solution $T$ after the augmentation phase of Algorithm 2 is feasible.

Proof.

Let $S$ be a dual with $\Delta(S,\ell)\geq 1$ for some iteration $\ell$, and $y_{S}=0$ after the augmentation phase. By the maximality of the independent set computed by the algorithm at each iteration, $S$ is adjacent to some $S^{\prime}$ which grows in iteration $\ell$. Thus, the terminals in $S$ are connected to the root via the edges covered by $S^{\prime}$. ∎

Note that Algorithm 2 breaks the tight example given in Figure 2 and Figure 3. After time $t=1$, only one of the duals $\{r^{\prime},s_{1},\ldots,s_{k}\}$ and $\{r^{\prime\prime},s_{1},\ldots,s_{k}\}$ is grown. After this point, all the duals $\{r_{i},s_{i}\}$ grow concurrently only with this dual, thus having the freedom to grow until $t=\frac{5}{2}-\frac{\epsilon}{2}$. This results in the inclusion of all the edges $(r^{\prime},s_{i})$ before the costly edges $(s_{i},r)$, thereby finding the optimal solution.

3.1 Implementation Details

We give a straightforward polynomial-time implementation of the algorithm. More compact and faster implementations are possible, which is not the focus of this paper. During the course of the algorithm, we explicitly store all the vertices in a given minimal violated set. Initially, there are $|R|-1$ such lists, each containing a single vertex in $R\setminus\{r\}$. We also keep the edges in a list of size $O(|E|)$ with respect to non-decreasing inclusion time. In what follows, we do not describe the cost of computing a maximal independent set upon inclusion of a new edge, as it can be performed in linear time, and its complexity is subsumed by that of other operations.

We first describe how to select the next edge and how to update the minimal violated sets in the loop of the augmentation phase. In order to find the next tight edge, we keep a priority queue for edges. The key values of the edges are the times at which they will go tight. Initially, all the edges that are not incident to the terminals might be set to $\infty$, and the key values of the immediately accessible edges are set to their correct values by examining their costs. For each edge, we also keep a list of duals growing on that edge. This is convenient in updating the key values. The initialization of the priority queue takes $O(|E|)$ time. At each iteration, we extract the minimum from the priority queue and update all the other edges in the queue with the information obtained from the new set of minimal violated sets. This takes at most $O(|E|\log|V|)$ time, since we consider at most $|E|$ edges to update.

Upon inclusion of the edges in an iteration, we update the list of vertices in the sets by performing a standard graph traversal procedure such as BFS, which takes time $O((|E|+|V|)|R|)=O(|E||R|)$. Notice that not all of these sets might be minimally violated, i.e. there might be a set which is a proper subset of another. Initially declare all the sets active, i.e. consider them as minimal violated sets. In order to determine which one of these are actual minimal violated sets, we perform the following operation starting from the smallest cardinality set (assume that the lists keep their sizes). Compare the elements in the set with all the other sets, and if another set turns out to be a strict superset of this set, declare the larger set inactive, i.e. not a minimal violated set. Comparing sets can be performed in expected time $O(|V|)$ by hashing the values of one set and looping over the second set to see if they contain the same elements. Hence, for a single set, we spend $O(|V||R|)$ time in expectation. The total time requirement for this operation is then $O(|V||R|^{2})$. If the two sets compared are identical, we merge them into a new minimal violated set and declare it active (See Figure 4 for an example of this procedure and merging). The number of iterations is at most $O(|V|)$. So the execution of the whole loop takes time $O(|E||V|\log{|V|}+|E||V||R|+|V|^{2}|R|^{2})$ in expectation.

For each edge considered in the loop of the pruning phase, the algorithm checks if there is a path between $r$ and all the other terminals even if the edge is discarded. This takes time $O((|E|+|V|)|R|=O(|E||R|)$ with a standard graph traversal algorithm. Since there are at most $O(|E|)$ edges to consider, the total running time is $O(|E|^{2}|R|)$. Together with the augmentation phase then, the algorithm can overall be implemented in time $O(|E||V|\log{|V|}+|E|^{2}|R|+|V|^{2}|R|^{2})$.

4 Proof of Theorem 2

We start with the following lemma whose proof crucially uses the fact that the cost of an edge in both directions is the same.

Lemma 4**.**

Let $v$ and $v^{\prime}$ be vertices in $R\setminus\{r\}$. If there is a directed path from $v$ to $v^{\prime}$ covered by Algorithm 2 at time $t$, then the directed path from $v^{\prime}$ to $v$ is covered by Algorithm 2 at the same time $t$.

Proof.

Let $d(u,u^{\prime})$ denote the distance between $u$ and $u^{\prime}$ in $V$. Define $d:=\min_{u,u^{\prime}\in V}d(u,u^{\prime})$. Select some $\epsilon$ such that $0<\epsilon<d$. Scale all the edge costs in $E$ by $|R|/{\epsilon}$. In what follows, we argue on these new edge costs.

Given $w\in R\setminus\{r\}$, let $t(w)$ denote the time at which all the edges $(u,w)\in T$ are covered, i.e., the incoming edges to $w$. Define $t(G):=\max_{w}t(w)$. We argue by induction on $\ell(G):=\lfloor t(G)\rfloor$. The case $\ell=0$ is obvious. Assume the claim holds for some $\ell\geq 1$. Let $G_{w}$ be the graph obtained by reducing the costs of all the edges incident to $w$ by $|R|$. Since in general there are at most $|R|-1$ duals grown by the algorithm concurrently, there exists at least one $w\in R\setminus\{r\}$ such that $\ell(G_{w})\leq\ell-1$. Otherwise, we get a contradiction by reducing all the costs to [math] without changing $t(G)$. Let $w$ be such a vertex with $t(G)=t(w)$. Let $u\in V$ such that $(u,w)\in T$, and $p$ be a point on $(u,w)$ such that $d(p,w)=|R|$.

Suppose there is a single dual growing towards $w$ after time $t_{p}$ at which $p$ is covered. By the choice of $w$, $\lfloor t_{p}\rfloor\leq\ell-1$. Assuming the induction hypothesis, there remains the cost of $d(p,w)=|R|$, which is to be covered by two single duals in both directions, one of them being the dual that starts to grow from $w$ to $p$. Clearly, it takes the same amount of time to cover them.

Suppose now that there is a set $S$ of $k\geq 2$ duals growing towards $w$ after time $t_{p}$. Let $w^{\prime}\in R\setminus\{r\}$ be another terminal, $(u^{\prime},w^{\prime})\in T$, and $p^{\prime}$ be a point on $(u^{\prime},w^{\prime})$ such that $d(p^{\prime},w^{\prime})=|R|$. There is a single dual that starts to grow from $w$ to $p$, and a single dual that starts to grow from $w^{\prime}$ to $p^{\prime}$. Since there are $k$ duals that grow from $p$ to $w$ concurrently, to complete the induction, it remains to see that there are $k$ duals that grow from $p^{\prime}$ to $w^{\prime}$ concurrently. By the algorithm and the edge costs, all the $k-1$ duals in $S$ excluding the one containing $w^{\prime}$ are among these duals together with the one originating from $w$, making a total of $k$ duals. Conversely, any other dual among these duals must be in $S$. Thus, there are exactly $k$ duals that grow from $p^{\prime}$ to $w^{\prime}$ concurrently, which completes the induction and the proof. ∎

Lemma 5**.**

Let $S_{1},\ldots,S_{k}$ be cuts, $e=(v,w)$ be an edge such that $e\in\delta^{+}(S_{i})\cap T$, and $\delta_{T}(S_{i})\geq 2$, for all $i\in\{1,\ldots,k\}$. Then the following hold:

• •

$v\notin R$.

• •

There exists at most one $S_{i}$ growing on $e$ at a given time $t$.

Proof.

Consider the union $U$ of $\delta^{+}(S_{i})\cap T$, for all $i\in\{1,\ldots,k\}$, so that $e=(v,w)\in U$. Assume first for a contradiction that $v\in R$. It is clear by definition of the cuts that there exists $v^{\prime}\in R\cap S_{i}$ for some $i$ such that there is a directed path from $v^{\prime}$ to $v$ established by the algorithm at some time $t$. By Lemma 4, there is a directed path from $v$ to $v^{\prime}$ established by the algorithm at time $t$. Note next that $e$ is included into the running solution $T$ after time $t$, since otherwise we have a contradiction to the existence of $S_{i}$. Given this, $e$ becomes redundant, since its deletion is considered before the edges in $S_{i}$, and there exists a feasible solution including these edges and excluding $e$ (See Figure 5(a)). Given that $v\notin R$, the rest of the claim immediately follows by the algorithm, as there are no adjacent duals of dual degree at least $1$ growing at the same time (See Figure 5(b)). ∎

To complete the proof, we show that the ratio of $c(T)$ with the total value of the duals constructed by Algorithm 2 is bounded by $\frac{3}{2}$. Lemma 5 implies that a cut $S$ with $\delta_{T}(S)\geq 2$ grows concurrently on an edge with only duals of degree $1$ on $T$. Let $S_{1},\ldots,S_{k}$ be such degree-$1$ duals. Suppose $S$ and all the $S_{i}$ grow concurrently on the same set of edges $e_{i}=(v_{i},w_{i})$, respectively, for a time period $[t_{1},t_{2}]$, where $t=t_{2}-t_{1}$ is maximal in the sense that for $t^{\prime}>t$, there is no set of edges on which $S$ and $S_{i}$ grow concurrently on. Recall by Lemma 5 that none of the $v_{i}$ is in $R$. This implies the following:

• •

There exist degree-$1$ duals $S_{i}^{\prime}\subseteq S_{i}$ that have grown for a time period of length at least $t$ alone, i.e., without any other dual growing concurrently with it (See Figure 6(a) for an illustration).

• •

The mapping $(S,S_{i})\mapsto(S_{i}^{\prime},[t_{1},t_{2}])$ is an injection, so that each $(S_{i}^{\prime},[t_{1},t_{2}])$ is considered for a separate set of $S$ and $S_{i}$.

Otherwise, by the argument in the proof of Lemma 4, we derive a contradiction to the fact that $S$ and $S_{i}$ grow concurrently for a time period of length $t$, since in that case $S$ would transform into a larger cut before completing the time period. An illustration for this is given in Figure 6(b). Given this, the cost covered by $y_{S}$, $y_{S_{i}}$ and $y_{S_{i}^{\prime}}$ is $3kt$, whereas the sum of these duals is $(2k+1)t$. This analysis excludes all the remaining degree-$1$ duals, which obviously pay for the cost they cover. Since the constructed dual solution is feasible, this completes the proof of Theorem 2.

5 Tight Example

A tight example for the algorithm is given in Figure 7 and Figure 8, where $k$ is a large number. There is a single high-degree dual in this example, and the cost of the solution found by the algorithm is $(3-\epsilon)k+1$. The optimal solution has cost $2k+2-\epsilon$.