Improved Approximation Algorithms for Capacitated Network Design and Flexible Graph Connectivity
Abstract
We present improved approximation algorithms for some problems in the related areas of Capacitated Network Design and Flexible Graph Connectivity.
In the Cap--ECSS problem, we are given a graph whose edges have non-negative costs and positive integer capacities, and the goal is to find a minimum-cost edge-set such that every non-trivial cut of the graph has capacity at least . Let and let (respectively, ) denote the minimum (respectively, maximum) capacity of an edge; assume that . We present an -approximation algorithm for the Cap--ECSS problem, asymptotically improving upon the previous best approximation ratio of whenever and is sufficiently large.
In the -Flexible Graph Connectivity problem, denoted , the input is a graph where is partitioned into safe and unsafe edges, and the goal is to find a minimum-cost edge-set such that the subgraph remains -edge connected upon removal of any unsafe edges from . We present an -approximation algorithm for the problem that improves upon the previous best approximation ratio of .
Both of our results are obtained by using natural LP relaxations strengthened with the knapsack-cover inequalities, and then, during the rounding process, utilizing a recent -approximation algorithm for the problem. In the latter problem, the goal is to find a minimum-cost set of links such that each non-trivial cut of capacity less than a specified value is covered by a link. We also show that the problem of covering small cuts inherently arises in another variant of . Specifically, we give Cook reductions that preserve approximation ratios within factors between the problem and the problem; in the latter problem, each small cut needs to be covered by two links.
Keywords and phrases:
Approximation algorithms, Capacitated network design, Covering small cuts, Edge-connectivity of graphs, -Connectivity problem, Flexible Graph Connectivity, Knapsack-cover inequalitiesCategory:
Track A: Algorithms, Complexity and GamesFunding:
Ishan Bansal: This work is external and does not relate to the position at Amazon.Copyright and License:
![[Uncaptioned image]](x1.png)
2012 ACM Subject Classification:
Theory of computation Approximation algorithms analysisAcknowledgements:
We thank the anonymous reviewers and the ICALP PC for their comments. We are grateful to David Aleman Espinosa and Sharat Ibrahimpur for reading a preliminary version, and for their detailed comments.Editors:
Keren Censor-Hillel, Fabrizio Grandoni, Joël Ouaknine, and Gabriele PuppisSeries and Publisher:

1 Introduction
Given a graph whose edges have both costs and capacities, a fundamental task in network design is to find a spanning subgraph of minimum cost that satisfies some specified connectivity requirements. In this paper, we present results on two well-studied problems in the area of approximation algorithms pertaining to the design of networks with edge-connectivity requirements.
When all edges have the same capacity, a seminal result by Jain [14] provides a -approximation algorithm for the survivable network design problem (SNDP); see section 1.4.3 for further discussion.
In the more general setting, where edges have non-uniform capacities, the problem, referred to as capacitated network design, becomes more challenging. Our focus is on designing approximation algorithms for the special case called the Cap--ECSS problem where we are given a graph with a non-negative cost and a positive integer capacity for each edge, and the algorithmic goal is to find a minimum-cost spanning subgraph such that every non-trivial cut has capacity or more. Let and let (respectively, ) denote the minimum (respectively, maximum) capacity of an edge; assume that . One of the earliest approximation algorithms for the Cap--ECSS problem is due to Goemans et al. [9], and it achieves an approximation ratio of . The best approximation ratio known is , due to Goemans et al. [9], Chakrabarty et al. [7], Boyd et al. [5], and Bansal [3]. Moreover, there are no known hardness results that rule out the possibility of better asymptotic approximation ratios.
Another line of research called flexible graph connectivity (abbreviated as FGC), has emerged recently, motivated by natural questions in network design in the setting of robust optimization. Adjiashvili, Hommelsheim and Mühlenthaler [1] proposed an FGC model that distinguishes between safe (never-failing) and unsafe (failure-prone) edges. The algorithmic goal is to choose a set of edges of minimum cost that satisfies a (global) edge-connectivity requirement, while tolerating failures of up to a specified number of unsafe edges. A basic problem in this setting is the problem where the goal is to ensure that the network remains connected even after the failure of up to unsafe edges. We mention that the problem can be modeled as a special case of the Cap--ECSS problem.
In the rest of the introduction section, we first discuss related work, and then we formalize the problems studied in this paper. After that, we give an overview of the main tools and techniques underlying our results, followed by our results and discussion on two of our algorithms.
We may use abbreviations for some standard terms, e.g., we may use “” as an abbreviation for “the problem”. For each of the minimization problems (in network design or flexible graph connectivity), we use opt to denote the optimal value (i.e., the minimum cost of an integer solution), and LP to denote the optimal value of an LP relaxation. The context will resolve potential ambiguities.
1.1 Related Work
As mentioned above, research on approximation algorithms for Cap--ECSS was initiated by Goemans et al. [9]. Carr et al. [6], in a seminal paper, introduced a key algorithmic tool for capacitated network design based on the Knapsack-Cover Inequalities (KCI); we discuss KCI in more detail in section 1.4.1. More than a decade later, Chakrabarty et al. [7] used KCI to design an approximation algorithm for Cap--ECSS. Boyd et al. [5] gave a -approximation algorithm for Cap--ECSS, and Bansal [3], based on previous work by Bansal et al. [4] and Williamson et al. [21], gave a -approximation algorithm for Cap--ECSS.
The model of flexible graph connectivity originated from research in the area of robust optimization. Adjiashvili, Stiller and Zenklusen [2] introduced their model of bulk-robust combinatorial optimization, and designed some approximation algorithms. Later, Adjiashvili, Hommelsheim and Mühlenthaler [1] introduced the model. Boyd et al. [5] introduced a generalization called the model. Boyd et al. [5] presented a -approximation algorithm for based on the primal-dual method of Williamson, Goemans, Mihail & Vazirani (WGMV) [21], and a -approximation algorithm for ; moreover, they gave an -approximation algorithm for . Subsequently, several interesting results and approximation algorithms have been presented; we summarize some of these recent papers in chronological order. Chekuri and Jain [8] give -approximation algorithms for, respectively, , and -FGC, and an -approximation algorithm for . Bansal et al. [4], among other results, give an -approximation algorithm for ; moreover, they give a 16-approximation algorithm for a related problem called . Nutov [17] improves the approximation ratio for from 16 to 10. Bansal [3], and later Nutov [18], give a -approximation algorithm for ; also, see [20]. Bansal [3] gives an -approximation algorithm for . Hyatt-Denesik et al. [12], among other results, give approximation algorithms for unit-cost FGC problems with edge-connectivity requirements as well as for unit-cost FGC problems with vertex connectivity requirements. Hommelsheim et al. [11] study a model related to a generalization of FGC called the -Steiner-Connectivity Preservation problem. Ibrahimpur & Vegh [13] give an -approximation algorithm for .
1.2 Capacitated Network Design and the Cap--ECSS problem
The Cap--ECSS problem is as follows: Given an undirected graph with edge costs and edge capacities , find a minimum-cost edge-set such that the capacity of any cut in is at least . Let (respectively, ) denote the minimum (respectively, maximum) capacity of an edge in , and assume (w.l.o.g.) that .
For a graph and a set of nodes , the cut of , denoted by , refers to the set of edges that have exactly one end-node in . Whenever we use the term “cut ” we mean that is a subset of . We call a cut non-trivial if is a nonempty, proper subset of , that is, if .
The following integer program formulates the Cap--ECSS problem. It can be viewed as the natural “cut covering” formulation of the problem. It has a binary variable for each edge , with the meaning that an edge is picked iff , and, for each non-trivial cut, it has a constraint stating that the capacity of the picked edges in the cut is .
(IP: CapkECSS) | |||||
s.t. | |||||
The LP (linear programming) relaxation of the above integer program is obtained by replacing by , . The following well-known example shows that the LP relaxation has an integrality ratio of ; similar examples are given in [6, 7].
Example 1.
The graph consists of two nodes , and a pair of parallel edges between the two nodes. Edge has cost zero and capacity , and edge has cost one and capacity . A feasible solution of the integer program has cost one since the edge must be chosen in any feasible solution. On the other hand, a feasible solution to the LP relaxation of cost is given by . Hence, the integrality ratio of the LP relaxation is for this example. Thus, we face an obstruction for the task of designing any approximation algorithm that achieves approximation ratio by rounding this LP relaxation.
1.3 Flexible Graph Connectivity and the problem
Adjiashvili, Hommelsheim and Mühlenthaler [1] introduced the model of Flexible Graph Connectivity that we denote by as a way to model network design problems where edges have non-uniform reliability. Boyd, Cheriyan, Haddadan and Ibrahimpur [5] introduced a generalization of , called the -Flexible Graph Connectivity problem, denoted , where is an integer denoting the connectivity requirement, and is an integer denoting the robustness requirement. An instance of consists of an undirected graph , where is partitioned into a set of safe edges (edges that never fail) and a set of unsafe edges (edges that may fail), and nonnegative edge-costs . A subset of edges is feasible for the problem if for any set consisting of at most unsafe edges, the subgraph remains -edge connected. The objective is to find a feasible solution that minimizes .
The following linear program gives a lower bound on the optimal value for -FGC. Such LP relaxations are discussed in [5] and [8, Section 2]. To motivate the LP relaxation, consider an auxiliary capacitated graph that has the same set of nodes and the same set of edges as the graph of the -FGC instance. Assign a capacity of to each safe edge and a capacity of to each unsafe edge. Let and view the capacitated graph as an instance of the Cap--ECSS problem. In general, observe that a feasible solution of the -FGC instance corresponds to a feasible solution of the Cap--ECSS instance, but not vice-versa. (When either or , then a feasible solution of the Cap--ECSS instance corresponds to a feasible solution of the -FGC instance.) Each edge has a variable .
(1) | |||||
s.t. | (2) | ||||
(3) |
Unfortunately, similarly to the LP relaxation for Cap--ECSS, the above LP relaxation has a large integrality ratio, even for the special case of . Example 1 can be modified such that for and , the above LP relaxation has integrality ratio .
1.4 Techniques and Tools
In this subsection, we describe three of the known tools that we apply together to obtain our main results. Each of these tools has been used on its own (without the other tools) to obtain improvements in the approximation ratio of the Cap--ECSS problem, but, in our opinion, by combining these tools in the right way, we obtain striking improvements in the approximation ratios for the Cap--ECSS problem and the problem.
The first tool is the algorithmic use of the Knapsack-Cover Inequalities (KCI) for strengthening the LP relaxation of (IP: CapkECSS). This tool was introduced by Carr, Fleischer, Leung & Phillips [6]. The second tool is an approximation algorithm for the so-called problem. This tool was introduced by Bansal, Cheriyan, Grout & Ibrahimpur [4]. The third tool is Jain’s iterative rounding method, [14].
1.4.1 Knapsack-Cover Inequalities (KCI) for Capacitated Network Design
Our approximation algorithms for both Cap--ECSS and use the LP relaxations highlighted above as the starting point. However, to eliminate the integrality gap, we will strengthen these relaxations using knapsack-cover inequalities. We focus here on illustrating this tool for the Cap--ECSS problem, strengthening (IP: CapkECSS).
For any non-trivial cut and a subset of the edges , the following is a valid inequality for all integer solutions of (IP: CapkECSS).
where and . (By plugging in , we get the constraint , which is a constraint of (IP: CapkECSS).) Intuitively, the added knapsack-cover inequalities for a cut and edge-set ensure that if a high-capacity edge is being used to cover and, moreover, is covered by some of the edges in , then the capacity of the high-capacity edge is reduced to the remaining requirement, namely, . These inequalities “cut off” poor solutions of the original LP relaxation (i.e., the one without KCI) such that some high-capacity edge has a small fractional value for (i.e., ). In particular, for Example 1 (at the end of section 1.2), consider the knapsack-cover inequality for the cut where and . We have and , hence, this inequality is which is . Clearly, the fractional solution is “cut off” by this inequality.
We add these inequalities to (IP: CapkECSS) to obtain the following LP relaxation of the Cap--ECSS problem.
(KCLP: CapkECSS) | |||||
s.t. | |||||
Observe that this LP has a number of constraints that is exponential in the size of the input instance (of Cap--ECSS). Moreover, we do not know of any polynomial-time separation oracle for the entire set of knapsack-cover inequalities. Nevertheless, by following the cut-and-round approach employed by Carr, Fleischer, Leung & Phillips [6], one can round this LP in polynomial time to an approximately optimal integer solution via the ellipsoid method by designing efficient subroutines. See sections 2, 3, for details.
Recently, Ibrahimpur & Vegh [13] have presented a polynomial-time separation subroutine for the knapsack-cover inequalities for the problem.
1.4.2 The problem
We follow the notation from [4, Section 1.3]. In an instance of the problem, we are given an undirected capacitated graph with edge-capacities , a set of links with costs , and a threshold . A subset of links is said to cover a node-set if there exists a link with exactly one end-node in . The objective is to find a minimum-cost that covers each non-empty with . Let . Then we have the following covering LP relaxation of the problem.
(LP: Cover Small Cuts) | |||||
subject to: | |||||
The following result is due to Bansal, [3]; also, see Nutov [18].
Proposition 2.
Given an instance of , the WGMV primal-dual algorithm, [21], finds a feasible solution of cost in polynomial time, where LP denotes the optimal value of (LP: Cover Small Cuts).
In the problem, the inputs are the same as above, namely, . A subset of links is said to two-cover a node-set if , that is, if there exist a pair of (distinct) links such that each of and has exactly one end-node in . The objective is to find a minimum-cost that two-covers each non-empty with .
1.4.3 The -connectivity problem and Jain’s iterative rounding algorithm
In the context of approximation algorithms, several connectivity augmentation problems can be formulated in a general framework called -connectivity. In this problem, we are given an undirected graph on nodes with nonnegative costs on the edges and a requirement function on subsets of nodes. The algorithmic goal is to find an edge-set with minimum cost such that for all cuts , we have . A function is called weakly supermodular if , and for all , either , or .
Assuming that the function is weakly supermodular, integral, and has a positive value for some , Jain [14] presented a 2-approximation algorithm for the -connectivity problem.
We will apply Jain’s result (or its extension) in most of our algorithms.
1.5 Our results
Our first result is an approximation algorithm for the Cap--ECSS problem. Thus, we asymptotically improve upon the previous best approximation ratio of whenever and is sufficiently large.
Theorem 3.
There is a polynomial-time algorithm that, given an instance of Cap--ECSS, computes a vector of cost at most opt that possibly satisfies only a subset of the constraints of (KCLP: CapkECSS), and rounds it to a feasible integer solution of cost at most .
Before sketching our approximation algorithm for general instances of Cap--ECSS, let us focus on the special case of two capacities and . Let be the set of unit-capacity edges, and let be the set of edges of capacity . For expository reasons (and glossing over some critical points), let us assume that we can find, in polynomial time, an optimal solution of (KCLP: CapkECSS), the LP with KCI. Thus, we have , where is the cost of . Let ; this is the set of unit-capacity edges that are assigned values of or more by the LP solution . Let (the set of unit-capacity edges with -values less than ). We call a non-trivial cut a small cut if
in other words, a non-trivial cut is defined to be small if the fractional capacity contributed by the unit-capacity edges is less than the requirement of even after rounding up edges in to have -value one and scaling up the -value of each edge in by factor . We construct an instance of with small cuts as defined above, and we define the link-set of this instance to be . To handle the small cuts, we apply the knapsack-cover inequalities to show that the solution restricted to edges of capacity and scaled up by a factor of (i.e., ) constitutes a feasible solution to the LP relaxation of the instance. This is the critical point where our algorithm and analysis relies on the knapsack-cover inequalities. We can thus pick a set of edges of capacity by applying the -approximation algorithm of [3, 4, 21] to this instance of the problem; note that the cost of is at most times the cost of . After this step, we contract the connected components formed by the edges in , and get a new instance that does not have any small cuts. Since there are no small cuts, every non-trivial cut satisfies the inequality . Therefore, we get a feasible solution for the LP relaxation of the -connectivity problem where for every non-empty set , by picking all edges in and scaling up restricted to by a factor of . Since is weakly supermodular, we can apply Jain’s iterative rounding method [14] to solve this -connectivity problem and obtain a -approximate solution, giving us an integral solution whose cost is at most times the cost of restricted to unit-capacity edges. Thus, we get an integral solution whose total cost is at most .
Let us recap the new algorithmic lever we deployed above. We partitioned the edges according to their capacities into the set of low-capacity edges and the set of high-capacity edges; let denote the latter set. Then we defined an instance of whose small cuts were defined using the low-capacity edges and rounding up (and/or scaling up) the fractional capacity contribution of each of these edges ; moreover, we defined the links (of the instance) to be the high-capacity edges. The small cuts identified above are precisely the cuts where the LP solution has not invested sufficient fractional capacity in the low-capacity edges to cover the cuts. For these cuts, the knapsack-cover inequalities ensured that restricted to the high-capacity edges and scaled up by a small constant, say, , (i.e., ) forms a feasible solution to the LP relaxation of the instance. Based on this, we applied the -approximation algorithm of [3, 4, 21] to find a set of high-capacity edges of cost that covers all the small cuts.
Now, let us sketch an extension of the above method that gives an -approximation algorithm for Cap--ECSS. As above, let us assume that we can find, in polynomial time, an optimal solution of (KCLP: CapkECSS), the LP with KCI. Thus, we have . Throughout the execution of the algorithm, we maintain a set of edges acting as our current solution. We begin with . Define and for , define . Ideally, we wish to apply iterations, and, in each iteration, we wish to apply the above algorithmic lever times. In more detail, in the th-iteration, we could take the edges of capacity to be the low-capacity edges and the edges of capacity to be the high-capacity edges; that is, is the set of low-capacity edges and is the set of high-capacity edges. Then, we could define an instance of where we could define the small-cuts to be the non-trivial cuts such that , and we could take the link-set (for the instance) to be the set of high-capacity edges, . Although we can apply the algorithmic lever and find an integral cover of the small cuts using the edges in such that the cost of the integral cover is , we run into a difficulty. The capacity of an edge in could be as small as , hence, by adding just one of these edges to a small cut we cannot guarantee that the capacity of is augmented to become . Thus, our algorithm and analysis, presented in section 3, have further steps; a deeper analysis is required to show that our algorithm finds an integral solution of cost . Moreover, we improve the approximation ratio from to .
Recall that the problem can be formulated as a special case of Cap--ECSS with two capacities (the unsafe edges have unit capacity and the safe edges have capacity ). Clearly, the -approximation algorithm sketched above applies to the problem. Our next result improves the approximation ratio to , thus improving on the previous best -approximation algorithm for , [5].
Theorem 4.
There is a polynomial-time algorithm that, given an instance of , computes a vector of cost at most opt that possibly satisfies only a subset of the constraints of (KCLP:-FGC), and rounds it to a feasible integer solution of cost at most .
Moreover, we present -approximate reductions between the problem and the problem. The following two results summarize the two reductions; the details are omitted due to space constraints; see the arXiv version of this paper.
Theorem 5.
Suppose an LP relative -approximation algorithm for that runs in polynomial time is available. Then there is an algorithm for that runs in polynomial time and returns a feasible (integer) solution of cost .
Theorem 6.
Suppose a -approximation algorithm for that runs in polynomial time is available. Then there is an algorithm for that runs in polynomial time and returns a feasible (integer) solution of cost .
1.6 Organization of the Paper
For the sake of readability and accessibility, we present our -approximation algorithm for in the next section, and we defer the presentation of our improved approximation algorithm for Cap--ECSS to section 3. Due to space constraints, our remaining results are omitted but are presented in the arXiv version of this paper.
2 An -Approximation Algorithm for
This section presents a -approximation algorithm for the -FGC problem. For the convenience of the reader, the presentation in this section is independent of the rest of the paper. For a graph and , the cut refers to the set of edges that have exactly one end-node in ; is called a non-trivial cut if . (Whenever we use the term “cut ” we mean that is a subset of .) We use the term small cut to mean a non-trivial cut with capacity below a specified threshold-value, say, .
Our starting point is the natural LP relaxation that follows from taking a capacitated network design view of the problem where each unsafe edge has capacity , and each safe edge has capacity . The natural LP relaxation then seeks to minimize the total cost of edges subject to the constraint that , we have
It is easy to see that any feasible solution to this LP with zero/one values is a valid solution to a given instance of , and vice versa. However, it is also easy to show that this LP has integrality ratio by adapting Example 1 given at the end of section 1.2.
To get around this obstruction, we strengthen the LP relaxation of using the knapsack-cover inequalities to obtain the following stronger LP. Intuitively, the added knapsack-cover inequalities for a cut ensure that if a safe edge is being used to cover and, moreover, is partly covered by unsafe edges, say, by of them, then the capacity of the safe edge is reduced to .
(KCLP:-FGC) | |||||
s.t. | |||||
where , and . We mentioned above that Ibrahimpur & Vegh [13] have presented a polynomial-time separation subroutine for the knapsack-cover inequalities for the problem. Instead of using their method, we follow the algorithmic scheme of [6, 7], because we will use a similar algorithmic scheme in section 3 (to the best of our knowledge, there is no polynomial-time separation subroutine for the knapsack-cover inequalities in section 3). Our plan is to identify a subset of unsafe edges and a collection of sets (in polynomial time) such that, as long as the knapsack-cover inequalities hold for and all , we will be able to execute our rounding algorithm. Using this, we will design a polynomial-time approximation algorithm for .
In this section, let denote the best approximation ratio known for the problem. We will design an -approximation algorithm for the problem. As of now, we have , since , due to [3, 4, 21]; also see [18].
Let LP denote the optimal value of (KCLP:-FGC), the LP with the knapsack-cover inequalities. Using binary search for LP together with the ellipsoid algorithm and our polynomial-time subroutines, we will find a vector with cost such that and satisfies the constraints of (KCLP:-FGC) specified in the next lemma (though could violate other constraints of (KCLP:-FGC)). Then, we will “round” to an integer solution of cost . Thus, we will find an integer solution of cost (even though we will not compute the precise value of LP). We discuss our overall algorithm and the outer loop of binary search at the end of this section.
Lemma 7.
There is a polynomial-time algorithm that given a vector (that is a candidate solution of (KCLP:-FGC)) and a value either finds a violated constraint of the LP or else verifies that and, moreover, satisfies the following two properties:
-
(P1)
.
-
(P2)
Let For any non-empty , if , then
Proof.
Essentially, we will describe a polynomial-time separation oracle that identifies any violations of properties (P1) and (P2). Given a vector , we first check that . If not, we return this as a violated constraint. Otherwise, let be the capacitated graph where and each edge is assigned a capacity of . We can now check that the capacity of a minimum-cut of is at least using a polynomial-time global minimum-cut algorithm [19]. If not, we return a global minimum cut in as a violated constraint. Otherwise, we know that (P1) is satisfied, and we proceed to verify (P2) with respect to the set .
By Karger’s result [15], there are at most cuts of capacity at most (i.e., at most twice the capacity of a minimum cut), and, moreover, we can enumerate all such cuts of in polynomial time [16]. By iterating over each of the cuts, we can now verify, in polynomial time, that the knapsack-cover inequalities are satisfied w.r.t. the set . If not, we have found a violated constraint.
The next corollary follows from the above lemma and the well-known fact that the ellipsoid algorithm terminates after iterations of feasibility verification [10]. The outer loop of our algorithm runs a binary search for LP (see the discussion at the end of this section).
Corollary 8.
There is a polynomial-time algorithm that computes a vector of cost such that satisfies properties (P1) and (P2); possibly, violates some of the other constraints of (KCLP:-FGC).
The Rounding Algorithm.
Given a value and a vector of cost that satisfies properties (P1) and (P2) (see Lemma 7), Algorithm 1, presented below, rounds it to an integer solution of cost at most . Below, we describe the main idea of our rounding scheme.
Recall that our LP relaxation assigns capacity for each unsafe edge and capacity to each safe edge . We call a non-trivial cut a small cut if where , and . To handle the presence of small cuts, we first construct an instance of with the specified small cuts and with link-set the set of safe edges; then, via Lemma 9, we show that the vector restricted to safe edges and scaled up by a factor of (i.e., ) constitutes a feasible solution to the LP relaxation of the instance. We can thus pick a set of safe edges by applying the -approximation algorithm to the instance; note that the cost of is at most times the cost of . After this step, we contract the connected components formed by the edges in , and get a new instance that does not have any small cuts. Since there are no small cuts, every non-trivial cut satisfies the inequality . Therefore, we get a feasible solution for the LP relaxation of the -connectivity problem where for every non-empty set , by picking all edges in and scaling up restricted to by a factor of . Since is weakly supermodular, we can apply Jain’s iterative rounding method [14] to solve this -connectivity problem and obtain a -approximate solution, giving us an integral solution whose cost is at most times the cost of (see Lemma 10). Thus, we get an integral solution whose total cost of safe and unsafe edges is at most times LP.
The next two lemmas formalize the key properties of the solution that are used in the rounding scheme above, allowing us to show that it returns a feasible integral solution of cost at most .
Lemma 9.
In step 2 of Algorithm 1, a feasible fractional solution to the instance is given by for .
Proof.
Consider any small cut . We will establish the lemma by considering two cases.
First, consider the case that . Since is a small cut, we have
Since , it follows that , hence, . Thus, .
Now suppose that . Then, by (P2), the cut satisfies the knapsack-cover inequality w.r.t. the set :
where , and .
Moreover, since is a small cut, we have . We rewrite this inequality as , which is the same as . Thus, by the knapsack-cover inequality, we have . By definition, , hence, we have . Therefore, , completing the proof.
Lemma 10.
In step 3 of Algorithm 1, a feasible fractional solution to the -connectivity problem is given by for .
Proof.
By way of contradiction, suppose that the claim does not hold. Then for some non-trivial cut , we have This implies that the cut is a small cut in step 2 of Algorithm 1. Hence, step 2 ensures (via ) that and so . This is a contradiction.
The output of Algorithm 1 is feasible for the problem by Lemmas 9, 10. The cost of the edges in is since for each edge in . Additionally, the cost of the edges in is by Lemma 9 and our definition of . Lastly, the cost of the edges returned by Jain’s iterative rounding algorithm (in step 3 of Algorithm 1) is at most , by Lemma 10. Therefore, the cost of the solution returned by Algorithm 1 is at most .
The outer loop of our algorithm runs a binary search for LP, but note that we are not using a “true” polynomial-time separation subroutine. Given a vector (a candidate solution to (KCLP:-FGC)), our subroutine either finds that violates one of the constraints specified in Lemma 7 or else it rounds to an integer solution of cost , where . The binary search for LP starts with the interval , where . Assume that the instance has a feasible integer solution, let opt denote the cost of an optimal integer solution, and assume that .
In an arbitrary iteration, the binary search calls the ellipsoid algorithm with the additional constraint , where the current interval is and . (The binary search maintains the invariant: and there exists an integer solution of cost .) The ellipsoid algorithm calls our subroutine one or more times, and either (1) reports that the LP (with the additional constraint) is infeasible or else (2) it finds a vector with and an integer solution of cost . The binary search continues as usual, that is, in case (1) it replaces the current interval by the upper half-interval , and in case (2) it replaces the current interval by the lower half-interval . The binary search terminates when the current interval is sufficiently small. Clearly, the LP with the additional constraint is infeasible, and the algorithm found an integer solution of cost . Hence, and the last integer solution found by the algorithm has cost .
See 4
3 An -Approximation Algorithm for Cap--ECSS
In this section, we present an -approximation algorithm for Cap--ECSS that runs in polynomial time assuming . Note that when , then the previously known approximation algorithm of [7] for Cap--ECSS achieves an approximation ratio of .
Let us recall a few terms & notation from previous sections. For a graph and , the cut refers to the set of edges that have exactly one end-node in ; is called a non-trivial cut if . (Whenever we use the term “cut ” we mean that is a subset of .) We use the term small cut to mean a non-trivial cut with capacity below a specified threshold-value, say, .
Let LP denote the optimal value of (KCLP: CapkECSS), the LP with the knapsack-cover inequalities. Similarly to section 2, we use binary search for LP together with the ellipsoid algorithm and our polynomial-time subroutines to find a vector with cost such that and satisfies the constraints of (KCLP: CapkECSS) specified in the proof of Lemma 11 (though could violate other constraints of (KCLP: CapkECSS)). Then, we will round to an integer solution of cost . Thus, we will find an integer solution of cost , even though we will not compute the precise value of LP. At the end of this section, the proof of Lemma 11 discusses our overall algorithm in more detail.
Assumption.
In what follows, assume that the vector satisfies all the constraints of (KCLP: CapkECSS). In section 3.6 below, we explain that we can easily remove this assumption.
Throughout the execution of the rounding algorithm, we will maintain a set of edges acting as our current solution. We begin with . Define and for , define ; thus, the edge-sets form a partition of the edges in into buckets based on the capacities; let us call the set the -th bucket (and is the -th bucket). See Figure 1 for an illustration.
Our algorithm will have iterations and each iteration (except for the first and the last) will have two phases. During phase 1 of iteration , we will round some of the edges in the -th bucket, i.e., some of the edges in the set . Note that an edge in the -th bucket has capacity . Informally speaking, in phase 1, we want to augment cuts of very small capacity with edges of capacity , and, in general, we need rounds of augmentation to achieve capacity ; thus, phase 1 has sub-iterations. During phase 2 of iteration , we will round some of the edges in .
Next, we present pseudo-code for the rounding algorithm, followed by explanation and analysis of the main steps.
For every non-trivial cut , we will maintain the following invariants for all iterations (i.e., except the first and the last iteration):
-
(1)
At the beginning of iteration , and
We note that iteration ensures that this invariant holds at the start of iteration .
-
(2)
At the end of phase 1 of iteration ,
-
(3)
At the end of iteration , which is also the end of phase 2 of iteration , , and
Observe that invariant (3) for iteration is the same as invariant (1) for iteration .
3.1 Iteration 1
In this iteration, we consider the family of small cuts where
We will cover these cuts using edges in . Consider any one of these small cuts . Since is a small cut, we have , hence, we have . Consider the knapsack-cover inequality for one of these small cuts and the set , , where and . By the above inequality and the knapsack-cover inequality, each of these small cuts satisfies the inequality , which implies the inequality . Thus is feasible for the problem implying that we incur a cost of at most here. We run the -approximation algorithm for , [3, 4, 21], and use the edge-set returned by that algorithm to augment . We repeat one more time, i.e., we again consider all cuts where and cover these cuts using edges in , incurring a further cost of . Now, we will have necessarily satisfied invariant (3) at the end of this iteration. To see this, observe that if some cut violated this invariant, then this cut participated as a small cut in both instances of considered in this step. This means we would have added at least two edges that cover this cut, each of capacity at least , ensuring that invariant (3) holds.
3.2 Iteration Phase 1 (Step 2 (a) in Algorithm 2)
We are starting with invariant (1) at the beginning of this iteration (as this corresponds to the invariant (3) that holds at the end of the previous iteration). Hence we have and . We will run multiple sub-iterations within this phase. The first sub-iteration is described below.
Consider the family of small cuts where . We will cover these cuts using edges in . For these small cuts , we have
(this inequality is obtained by subtracting the inequality defining the small cuts from the inequality of invariant (1), namely, ). Observe that , because for all edges in . Thus, is feasible for the problem. We run the -approximation algorithm for , [3, 4, 21], and use the edge-set returned by that algorithm to augment . After this, there are no non-trivial cuts with since we would have covered any such cut by an edge from , and all these edges have capacity at least . Next, we shift the threshold in the definition for small cuts to , and then to , …, all the way until where . This would imply that . We describe these sub-iterations in more detail now.
For , consider the family of small cuts where
Since invariant (1) is true (and we have only increased the LHS of invariant (1) during the phase), we have Since for all edges in , we have Thus, is feasible for our instance of . We run the -approximation algorithm for , [3, 4, 21], and use the edge-set returned by that algorithm to augment . Then, we move on to the next sub-iteration. At the end of the last sub-iteration (with ), we have
and so invariant (2) is maintained. Let us analyze the cost we incurred in this phase.
The cost we incur is at most . We bound this last sum as follows. Note that and so
(using the inequality ) | |||
Thus, the cost incurred in this phase is
.
3.3 Iteration Phase 2 (Step 2 (b)-(d) in Algorithm 2)
We are beginning with invariant (2), which is valid at the end of phase 1, and thus for all non-trivial cuts , we have We will add more edges from to these cuts, if needed, to increase the capacity to . Note that all edges in have capacity at least and so at most three more edges need to be added. To do so, we employ the method we used in iteration 1.
Consider the family of small cuts where Then, by the knapsack-cover inequalities, is feasible for the instance. Indeed for each of these small cuts , we have . The knapsack-cover inequality then implies that , where and . We run the -approximation algorithm for , [3, 4, 21], and use the edge-set returned by that algorithm to augment . This incurs a cost of at most . We repeat three times, adding the approximate solution of the instance to and incur a cost of at most . At the end of this phase, for every non-trivial cut , we have This is precisely invariant (3) and we have completed this phase.
3.4 Iteration
At the beginning of the last iteration, by invariant (1), we have for any non-trivial cut :
Now, we apply Jain’s iterative rounding method to round the edges in , incurring a cost of at most .
3.5 Total Cost
We calculate the total cost incurred separately for each iteration. In iteration 1, we incur a cost of ; this includes the term (due to the initial ). In phase 1 of iterations , we incur a total cost of
In phase 2 of iterations , we incur a cost of . Finally the cost incurred in iteration is . Thus the total cost incurred is .
Observe that if the minimum capacity over all edges in is greater than 2, then the algorithm stops at an earlier iteration. In fact, it stops at an iteration where . Since , we obtain that . In such a scenario, the total cost incurred in phase 1 of iterations , is
(since ) | |||
Similarly the total cost incurred in phase 2 of iterations is . Thus the overall cost is .
3.6 Solving the LP Relaxation
Clearly, our rounding algorithm runs in polynomial time, provided an optimal (and feasible) solution to (KCLP: CapkECSS) is given. As in section 2, we would like solve (KCLP: CapkECSS) using the ellipsoid method, but, unfortunately, we do not know of any polynomial-time separation oracle for the entire set of knapsack-cover inequalities. Instead, we will iteratively (in polynomial time) identify a subset of edges and a collection of sets such that, as long as the knapsack-cover inequalities hold for and all , we will be able to execute our rounding algorithm.
Lemma 11.
There is a polynomial-time algorithm that, given a vector (that is a candidate solution of (KCLP: CapkECSS)) and a value , either finds a violated constraint of the LP or else verifies that and, moreover, for every iteration , , satisfies the property that is feasible for the LP relaxations of the instances created in steps 1(b) and 2(c) of Algorithm 2.
Proof.
Given a candidate vector and a candidate objective value , we first check that (see the discussion on binary search at the end of section 2). If not, we return this as a violated constraint. Otherwise, let be the capacitated graph where and each edge is assigned a capacity of . We can now check that the capacity of a minimum cut in is at least using a polynomial-time global minimum-cut algorithm [19]. If not, we return a global minimum cut in as a violated constraint.
By Karger’s result [15], we know that there are at most cuts of capacity at most (i.e., at most twice the capacity of a minimum cut), and, moreover, we can enumerate all such cuts of in polynomial time [16]. By iterating over each of the cuts, we can then verify in polynomial time that the knapsack-cover inequalities are satisfied w.r.t. the set in each of the steps 1(b) and 2(c) for cuts whose capacity is at most . If not, we have found a violated constraint. It remains then to handle the case when we are at step 1(b) or 2(c), and we have a small cut such that
In this case, we note that in step 1(b), by the definition of small cuts, we have . But then since the total capacity of this cut is at least , it follows that . Since for every edge , it follows that . Thus is feasible on this cut for the instance. A similar argument can be used to show that in step 2(c), if we have a small cut with then is feasible for the instance. Specifically, by the definition of small cuts, we have . As the total capacity is at least , it follows that , and since for every edge , . Thus is feasible on this cut for the instance.
Finally, if at any step of the rounding algorithm, we identify a violated constraint, then we restart the rounding algorithm from the very beginning. It is worth highlighting that the verification of knapsack-cover inequalities identified in steps 1(b) and 2(c) of the algorithm, is always done with respect to the solution given by the Ellipsoid algorithm (without any modification). As the rounding progresses, the only thing that changes is the definition of the set with respect to which we verify the knapsack-cover inequalities. So whenever a violated constraint is identified, it contributes to the iteration count of the ellipsoid algorithm. Since the ellipsoid algorithm terminates after iterations of feasibility verification [10], it must be the case that after at most re-starts of the rounding process, we arrive at a solution to (KCLP: CapkECSS) of value at most LP such that the solution satisfies the property that is feasible for the instances created in steps 1(b) and 2(c).
Remark 12.
We mention that the analysis of phase 1 of iteration (i.e., step 2(a) of iteration ) does not use the knapsack-cover inequalities, hence, Lemma 11 does not address step 2(a).
See 3
References
- [1] David Adjiashvili, Felix Hommelsheim, and Moritz Mühlenthaler. Flexible Graph Connectivity. Mathematical Programming, 192:409–441, 2022. doi:10.1007/s10107-021-01664-9.
- [2] David Adjiashvili, Sebastian Stiller, and Rico Zenklusen. Bulk-Robust combinatorial optimization. Math. Program., 149(1-2):361–390, 2015. doi:10.1007/s10107-014-0760-6.
- [3] Ishan Bansal. A Global Analysis of the Primal-Dual Method for Pliable Families. CoRR, abs/2308.15714, 2024. doi:10.48550/arXiv.2308.15714.
- [4] Ishan Bansal, Joseph Cheriyan, Logan Grout, and Sharat Ibrahimpur. Improved approximation algorithms by generalizing the primal-dual method beyond uncrossable functions. Algorithmica, 86(8):2575–2604, 2024. doi:10.1007/s00453-024-01235-2.
- [5] Sylvia C. Boyd, Joseph Cheriyan, Arash Haddadan, and Sharat Ibrahimpur. Approximation algorithms for flexible graph connectivity. Mathematical Programming, 2023. doi:10.1007/s10107-023-01961-5.
- [6] Robert D. Carr, Lisa K. Fleischer, Vitus J. Leung, and Cynthia A. Phillips. Strengthening integrality gaps for capacitated network design and covering problems. In Proceedings of the Eleventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’00, pages 106–115, USA, 2000. Society for Industrial and Applied Mathematics. URL: http://dl.acm.org/citation.cfm?id=338219.338241.
- [7] Deeparnab Chakrabarty, Chandra Chekuri, Sanjeev Khanna, and Nitish Korula. Approximability of Capacitated Network Design. Algorithmica, 72(2):493–514, 2015. doi:10.1007/s00453-013-9862-4.
- [8] Chandra Chekuri and Rhea Jain. Approximation Algorithms for Network Design in Non-Uniform Fault Models. In Proceedings of the 50th International Colloquium on Automata, Languages, and Programming, volume 261, article 36, pages 1–20, 2023. doi:10.4230/LIPIcs.ICALP.2023.36.
- [9] Michel X. Goemans, Andrew V. Goldberg, Serge A. Plotkin, David B. Shmoys, Éva Tardos, and David P. Williamson. Improved Approximation Algorithms for Network Design Problems. In Proceedings of the 5th Symposium on Discrete Algorithms, pages 223–232, 1994. URL: http://dl.acm.org/citation.cfm?id=314464.314497.
- [10] Martin Grötschel, László Lovász, and Alexander Schrijver. Geometric Algorithms and Combinatorial Optimization, volume 2 of Algorithms and Combinatorics. Springer Berlin, 1993. doi:10.1007/978-3-642-78240-4.
- [11] Felix Hommelsheim, Zhenwei Liu, Nicole Megow, and Guochuan Zhang. Protecting the Connectivity of a Graph under Non-uniform Edge Failures. CoRR, abs/2501.04540, 2025. doi:10.48550/arXiv.2501.04540.
- [12] Dylan Hyatt-Denesik, Afrouz Jabal Ameli, and Laura Sanità. Improved Approximations for Flexible Network Design. In Timothy M. Chan, Johannes Fischer, John Iacono, and Grzegorz Herman, editors, 32nd Annual European Symposium on Algorithms, ESA 2024, September 2-4, 2024, Royal Holloway, London, United Kingdom, volume 308 of LIPIcs, pages 74:1–74:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPIcs.ESA.2024.74.
- [13] Sharat Ibrahimpur and László A. Végh. An -Approximation Algorithm for -Flexible Graph Connectivity via Independent Rounding. CoRR, abs/2501.12549, 2025. doi:10.48550/arXiv.2501.12549.
- [14] Kamal Jain. A Factor 2 Approximation Algorithm for the Generalized Steiner Network Problem. Combinatorica, 21(1):39–60, 2001. doi:10.1007/s004930170004.
- [15] David R. Karger. Global min-cuts in RNC, and other ramifications of a simple min-cut algorithm. In Vijaya Ramachandran, editor, Proceedings of the Fourth Annual ACM/SIGACT-SIAM Symposium on Discrete Algorithms, 25-27 January 1993, Austin, Texas, USA, pages 21–30. ACM/SIAM, 1993. URL: http://dl.acm.org/citation.cfm?id=313559.313605.
- [16] Hiroshi Nagamochi, Kazuhiro Nishimura, and Toshihide Ibaraki. Computing All Small Cuts in an Undirected Network. SIAM Journal on Discrete Mathematics, 10(3):469–481, 1997. doi:10.1137/S0895480194271323.
- [17] Zeev Nutov. Improved approximation ratio for covering pliable set families. CoRR, 2024. doi:10.48550/arXiv.2404.00683.
- [18] Zeev Nutov. Tight analysis of the primal-dual method for edge-covering pliable set families. CoRR, abs/2504.03910, 2025. doi:10.48550/arXiv.2504.03910.
- [19] Alexander Schrijver. Combinatorial Optimization: Polyhedra and Efficiency, volume 24 of Algorithms and Combinatorics. Springer, Berlin Heidelberg New York, 2003.
- [20] Miles Simmons, Ishan Bansal, and Joe Cheriyan. A Bad Example for Jain’s Iterative Rounding Theorem for the Cover Small Cuts Problem. CoRR, abs/2504.13105, 2025. doi:10.48550/arXiv.2504.13105.
- [21] David P. Williamson, Michel X. Goemans, Milena Mihail, and Vijay V. Vazirani. A Primal-Dual Approximation Algorithm for Generalized Steiner Network Problems. Combinatorica, 15(3):435–454, 1995. doi:10.1007/BF01299747.