Abstract 1 Introduction 2 An 𝟖-Approximation Algorithm for (𝟏,𝒒)-𝐅𝐆𝐂 3 An 𝑶(𝐥𝐨𝐠𝒌𝒖𝒎𝒊𝒏)-Approximation Algorithm for Cap-𝒌-ECSS References

Improved Approximation Algorithms for Capacitated Network Design and Flexible Graph Connectivity

Ishan Bansal ORCID Amazon, Bellevue, WA, USA Joe Cheriyan ORCID Department of Combinatorics and Optimization, University of Waterloo, Canada Sanjeev Khanna ORCID Department of Computer and Information Science, University of Pennsylvania, Philadelphia, PA, USA Miles Simmons ORCID Department of Combinatorics and Optimization, University of Waterloo, Canada
Abstract

We present improved approximation algorithms for some problems in the related areas of Capacitated Network Design and Flexible Graph Connectivity.

In the Cap-k-ECSS problem, we are given a graph G=(V,E) whose edges have non-negative costs and positive integer capacities, and the goal is to find a minimum-cost edge-set F such that every non-trivial cut of the graph G=(V,F) has capacity at least k. Let n=|V| and let umin (respectively, umax) denote the minimum (respectively, maximum) capacity of an edge; assume that umaxk. We present an O(log(k/umin))-approximation algorithm for the Cap-k-ECSS problem, asymptotically improving upon the previous best approximation ratio of min(O(logn),k,2umax,6k/umin) whenever log(k/umin)=o(logn) and umax is sufficiently large.

In the (p,q)-Flexible Graph Connectivity problem, denoted (p,q)-FGC, the input is a graph G=(V,E) where E is partitioned into safe and unsafe edges, and the goal is to find a minimum-cost edge-set F such that the subgraph G=(V,F) remains p-edge connected upon removal of any q unsafe edges from F. We present an 8-approximation algorithm for the (1,q)-FGC problem that improves upon the previous best approximation ratio of (q+1).

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 O(1)-approximation algorithm for the CoverSmallCuts 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 (p,q)-FGC. Specifically, we give Cook reductions that preserve approximation ratios within O(1) factors between the (2,q)-FGC problem and the 2-CoverSmallCuts 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, f-Connectivity problem, Flexible Graph Connectivity, Knapsack-cover inequalities
Category:
Track A: Algorithms, Complexity and Games
Funding:
Ishan Bansal: This work is external and does not relate to the position at Amazon.
Joe Cheriyan: Supported in part by NSERC grant RGPIN-2024-04473.
Sanjeev Khanna: Supported in part by NSF award CCF-2402284 and AFOSR award FA9550-25-1-0107.
Copyright and License:
[Uncaptioned image] © Ishan Bansal, Joe Cheriyan, Sanjeev Khanna, and Miles Simmons; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Approximation algorithms analysis
Related Version:
Full Version: https://doi.org/10.48550/arXiv.2411.18809
Acknowledgements:
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 Puppis

1 Introduction

Given a graph G=(V,E) 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 2-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-k-ECSS problem where we are given a graph G=(V,E) 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 k or more. Let n=|V| and let umin (respectively, umax) denote the minimum (respectively, maximum) capacity of an edge; assume that umaxk. One of the earliest approximation algorithms for the Cap-k-ECSS problem is due to Goemans et al. [9], and it achieves an approximation ratio of min{2k,|E|}. The best approximation ratio known is min(O(logn),k,2umax,6k/umin), 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 (1,q)-FGC problem where the goal is to ensure that the network remains connected even after the failure of up to q unsafe edges. We mention that the (1,q)-FGC problem can be modeled as a special case of the Cap-k-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 “(1,q)-FGC” as an abbreviation for “the (1,q)-FGC 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 LPopt 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-k-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 O(logn) approximation algorithm for Cap-k-ECSS. Boyd et al. [5] gave a min{k,2umax}-approximation algorithm for Cap-k-ECSS, and Bansal [3], based on previous work by Bansal et al. [4] and Williamson et al. [21], gave a (6k/umin)-approximation algorithm for Cap-k-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 FGC model. Boyd et al. [5] introduced a generalization called the (p,q)-FGC model. Boyd et al. [5] presented a 4-approximation algorithm for (p,1)-FGC based on the primal-dual method of Williamson, Goemans, Mihail & Vazirani (WGMV) [21], and a (q+1)-approximation algorithm for (1,q)-FGC; moreover, they gave an O(qlogn)-approximation algorithm for (p,q)-FGC. 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 O(p)-approximation algorithms for, respectively, (p,2), (p,3) and (2p,4)-FGC, and an O(q)-approximation algorithm for (2,q)-FGC. Bansal et al. [4], among other results, give an O(1)-approximation algorithm for (p,2)-FGC; moreover, they give a 16-approximation algorithm for a related problem called CoverSmallCuts. Nutov [17] improves the approximation ratio for CoverSmallCuts from 16 to 10. Bansal [3], and later Nutov [18], give a 6-approximation algorithm for CoverSmallCuts; also, see [20]. Bansal [3] gives an O(1)-approximation algorithm for (p,3)-FGC. 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 (p,q)-Steiner-Connectivity Preservation problem. Ibrahimpur & Vegh [13] give an O(logn)-approximation algorithm for (p,q)-FGC.

1.2 Capacitated Network Design and the Cap-𝒌-ECSS problem

The Cap-k-ECSS problem is as follows: Given an undirected graph G=(V,E) with edge costs c0E and edge capacities u0E, find a minimum-cost edge-set FE such that the capacity of any cut in (V,F) is at least k. Let umin (respectively, umax) denote the minimum (respectively, maximum) capacity of an edge in E, and assume (w.l.o.g.) that umaxk.

For a graph G=(V,E) and a set of nodes SV, the cut of S, denoted by δ(S), refers to the set of edges that have exactly one end-node in S. Whenever we use the term “cut δ(S)” we mean that S is a subset of V(G). We call a cut δ(S) non-trivial if S is a nonempty, proper subset of V, that is, if SV.

The following integer program formulates the Cap-k-ECSS problem. It can be viewed as the natural “cut covering” formulation of the problem. It has a binary variable xe for each edge e, with the meaning that an edge e is picked iff xe=1, and, for each non-trivial cut, it has a constraint stating that the capacity of the picked edges in the cut is k.

min eEcexe (IP: CapkECSS)
s.t. eEδ(S)uexek SV
xe{0,1} eE

The LP (linear programming) relaxation of the above integer program is obtained by replacing xe{0,1} by 0xe1, eE. The following well-known example shows that the LP relaxation has an integrality ratio of Ω(k); similar examples are given in [6, 7].

Example 1.

The graph G consists of two nodes u,v, and a pair of parallel edges e1,e2 between the two nodes. Edge e1 has cost zero and capacity k1, and edge e2 has cost one and capacity k. A feasible solution of the integer program has cost one since the edge e2 must be chosen in any feasible solution. On the other hand, a feasible solution x to the LP relaxation of cost 1/k is given by xe1=1,xe2=1/k. Hence, the integrality ratio of the LP relaxation is k for this example. Thus, we face an obstruction for the task of designing any approximation algorithm that achieves approximation ratio o(k) 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 FGC as a way to model network design problems where edges have non-uniform reliability. Boyd, Cheriyan, Haddadan and Ibrahimpur [5] introduced a generalization of FGC, called the (p,q)-Flexible Graph Connectivity problem, denoted (p,q)-FGC, where p is an integer denoting the connectivity requirement, and q is an integer denoting the robustness requirement. An instance of (p,q)-FGC consists of an undirected graph G=(V,E), where E 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 c0E. A subset FE of edges is feasible for the (p,q)-FGC problem if for any set F consisting of at most q unsafe edges, the subgraph (V,FF) remains p-edge connected. The objective is to find a feasible solution F that minimizes c(F)=eFce.

The following linear program gives a lower bound on the optimal value for (p,q)-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 (p,q)-FGC instance. Assign a capacity of (p+q) to each safe edge and a capacity of p to each unsafe edge. Let k=p(p+q) and view the capacitated graph as an instance of the Cap-k-ECSS problem. In general, observe that a feasible solution of the (p,q)-FGC instance corresponds to a feasible solution of the Cap-k-ECSS instance, but not vice-versa. (When either p=1 or q=1, then a feasible solution of the Cap-k-ECSS instance corresponds to a feasible solution of the (p,q)-FGC instance.) Each edge e𝒮𝒰 has a variable xe.

min e𝒮𝒰cexe (1)
s.t. e𝒮δ(S)(p+q)xe+e𝒰δ(S)(p)xep(p+q) SV (2)
0xe1 e𝒮𝒰 (3)

Unfortunately, similarly to the LP relaxation for Cap-k-ECSS, the above LP relaxation has a large integrality ratio, even for the special case of (1,q)-FGC. Example 1 can be modified such that for p=1 and q>0, the above LP relaxation has integrality ratio (q+1).

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-k-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-k-ECSS problem and the (1,q)-FGC 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 O(1) approximation algorithm for the so-called CoverSmallCuts 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-k-ECSS and (1,q)-FGC 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-k-ECSS problem, strengthening (IP: CapkECSS).

For any non-trivial cut δ(S) and a subset of the edges AE, the following is a valid inequality for all integer solutions of (IP: CapkECSS).

eEδ(S)Aue(A,S)xeD(A,S),

where D(A,S)=max{0,keδ(S)Aue} and ue(A,S)=min{ue,D(A,S)}. (By plugging in A=, we get the constraint eEδ(S)uexek, which is a constraint of (IP: CapkECSS).) Intuitively, the added knapsack-cover inequalities for a cut δ(S) and edge-set A ensure that if a high-capacity edge is being used to cover δ(S) and, moreover, δ(S) is covered by some of the edges in A, then the capacity of the high-capacity edge is reduced to the remaining requirement, namely, ku(Aδ(S)). These inequalities “cut off” poor solutions x of the original LP relaxation (i.e., the one without KCI) such that some high-capacity edge f has a small fractional value for xf (i.e., 0<xf1). In particular, for Example 1 (at the end of section 1.2), consider the knapsack-cover inequality for the cut δ(S) where S={u} and A={e1}. We have D(A,S)=max{0,k(k1)}=1 and ue2(A,S)=min{ue2,D(A,S)}=min{k,1}=1, hence, this inequality is eδ(S)Aue(A,S)xeD(A,S) which is xe21. Clearly, the fractional solution xe1=1,xe2=1/k is “cut off” by this inequality.

We add these inequalities to (IP: CapkECSS) to obtain the following LP relaxation of the Cap-k-ECSS problem.

min eEcexe (KCLP: CapkECSS)
s.t. eEδ(S)Aue(A,S)xeD(A,S) SV,AE
0xe1 eE

Observe that this LP has a number of constraints that is exponential in the size of the input instance (of Cap-k-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 (p,q)-FGC problem.

1.4.2 The 𝐂𝐨𝐯𝐞𝐫𝐒𝐦𝐚𝐥𝐥𝐂𝐮𝐭𝐬 problem

We follow the notation from [4, Section 1.3]. In an instance of the CoverSmallCuts problem, we are given an undirected capacitated graph G=(V,E) with edge-capacities u0E, a set of links L(V2) with costs c0L, and a threshold λ0. A subset FL of links is said to cover a node-set S if there exists a link eF with exactly one end-node in S. The objective is to find a minimum-cost FL that covers each non-empty SV with u(δE(S))<λ. Let 𝒞={SV:u(δE(S))<λ}. Then we have the following covering LP relaxation of the problem.

min fLcfxf (LP: Cover Small Cuts)
subject to: fLδ(S)xf1 S𝒞
0xf1 fL

The following result is due to Bansal, [3]; also, see Nutov [18].

Proposition 2.

Given an instance of CoverSmallCuts, the WGMV primal-dual algorithm, [21], finds a feasible solution of cost 6LPopt in polynomial time, where LPopt denotes the optimal value of (LP: Cover Small Cuts).

In the 2-CoverSmallCuts problem, the inputs are the same as above, namely, G=(V,E),u,L,c,λ. A subset FL of links is said to two-cover a node-set S if |Fδ(S)|2, that is, if there exist a pair of (distinct) links e,eF such that each of e and e has exactly one end-node in S. The objective is to find a minimum-cost FL that two-covers each non-empty SV with u(δE(S))<λ.

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 f-connectivity. In this problem, we are given an undirected graph G=(V,E) on n nodes with nonnegative costs c0E on the edges and a requirement function f:2V0 on subsets of nodes. The algorithmic goal is to find an edge-set JE with minimum cost c(J):=eJce such that for all cuts δ(S),SV, we have |δ(S)J|f(S). A function f is called weakly supermodular if f(V)=0, and for all A,BV, either f(A)+f(B)f(AB)+f(BA), or f(A)+f(B)f(AB)+f(AB).

Assuming that the function f is weakly supermodular, integral, and has a positive value for some SV, Jain [14] presented a 2-approximation algorithm for the f-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 O(logk/umin) approximation algorithm for the Cap-k-ECSS problem. Thus, we asymptotically improve upon the previous best approximation ratio of min(O(logn),k,2umax,6k/umin) whenever log(k/umin)=o(logn) and umax is sufficiently large.

Theorem 3.

There is a polynomial-time algorithm that, given an instance of Cap-k-ECSS, computes a vector x 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 O(log(k/umin))opt.

Before sketching our approximation algorithm for general instances of Cap-k-ECSS, let us focus on the special case of two capacities 1 and k. Let E(1) be the set of unit-capacity edges, and let E(k) be the set of edges of capacity k. For expository reasons (and glossing over some critical points), let us assume that we can find, in polynomial time, an optimal solution x of (KCLP: CapkECSS), the LP with KCI. Thus, we have c(x)=LPopt, where c(x)=ecexe is the cost of x. Let Ehigh(1)={eE(1):xe1/2}; this is the set of unit-capacity edges that are assigned values of 1/2 or more by the LP solution x. Let Elow(1)=E(1)Ehigh(1) (the set of unit-capacity edges with x-values less than 1/2). We call a non-trivial cut δ(S) a small cut if

|Ehigh(1)δ(S)|+eElow(1)δ(S)2xe<k;

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 k even after rounding up edges in Ehigh(1) to have x-value one and scaling up the x-value of each edge in Elow(1) by factor 2. We construct an instance of CoverSmallCuts with small cuts as defined above, and we define the link-set of this instance to be E(k). To handle the small cuts, we apply the knapsack-cover inequalities to show that the solution x restricted to edges of capacity k and scaled up by a factor of 2 (i.e., 2xE(k)) constitutes a feasible solution to the LP relaxation of the CoverSmallCuts instance. This is the critical point where our algorithm and analysis relies on the knapsack-cover inequalities. We can thus pick a set Epicked(k) of edges of capacity k by applying the 6-approximation algorithm of [3, 4, 21] to this instance of the CoverSmallCuts problem; note that the cost of Epicked(k) is at most 6 times the cost of 2xE(k). After this step, we contract the connected components formed by the edges in Epicked(k), and get a new instance that does not have any small cuts. Since there are no small cuts, every non-trivial cut δ(S) satisfies the inequality |Ehigh(1)δ(S)|+eElow(1)δ(S)2xek. Therefore, we get a feasible solution for the LP relaxation of the f-connectivity problem where f(S)=k for every non-empty set SV, by picking all edges in Ehigh(1) and scaling up x restricted to Elow(1) by a factor of 2. Since f is weakly supermodular, we can apply Jain’s iterative rounding method [14] to solve this f-connectivity problem and obtain a 2-approximate solution, giving us an integral solution whose cost is at most 4 times the cost of x restricted to unit-capacity edges. Thus, we get an integral solution whose total cost is at most 62LPopt.

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 Ebig denote the latter set. Then we defined an instance of CoverSmallCuts whose small cuts were defined using the low-capacity edges and rounding up (and/or scaling up) the fractional capacity contribution uexe of each of these edges e; moreover, we defined the links (of the CoverSmallCuts instance) to be the high-capacity edges. The small cuts identified above are precisely the cuts where the LP solution x has not invested sufficient fractional capacity in the low-capacity edges to cover the cuts. For these cuts, the knapsack-cover inequalities ensured that x restricted to the high-capacity edges and scaled up by a small constant, say, η, (i.e., ηxEbig) forms a feasible solution to the LP relaxation of the CoverSmallCuts instance. Based on this, we applied the 6-approximation algorithm of [3, 4, 21] to find a set of high-capacity edges of cost 6ηc(xEbig) that covers all the small cuts.

Now, let us sketch an extension of the above method that gives an O(logk)-approximation algorithm for Cap-k-ECSS. As above, let us assume that we can find, in polynomial time, an optimal solution x of (KCLP: CapkECSS), the LP with KCI. Thus, we have c(x)=LPopt. Throughout the execution of the algorithm, we maintain a set of edges Ecur acting as our current solution. We begin with Ecur={eE:xe1/2}. Define T=logk and for j=1,2,,T, define Ej={eE:xe<1/2 and ue2j}. Ideally, we wish to apply T iterations, and, in each iteration, we wish to apply the above algorithmic lever O(1) times. In more detail, in the ith-iteration, we could take the edges of capacity 2Ti to be the low-capacity edges and the edges of capacity >2Ti to be the high-capacity edges; that is, ETi is the set of low-capacity edges and EETi is the set of high-capacity edges. Then, we could define an instance of CoverSmallCuts where we could define the small-cuts to be the non-trivial cuts δ(S) such that (eEcurδ(S)ue)+(eETiδ(S)2uexe)<k, and we could take the link-set (for the CoverSmallCuts instance) to be the set of high-capacity edges, EETi. Although we can apply the algorithmic lever and find an integral cover of the small cuts using the edges in EETi such that the cost of the integral cover is O(1)c(xEETi), we run into a difficulty. The capacity of an edge in EETi could be as small as Θ(2Ti), hence, by adding just one of these edges to a small cut δ(S) we cannot guarantee that the capacity of δ(S) is augmented to become k. 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 O(logk)LPopt. Moreover, we improve the approximation ratio from O(logk) to O(log(k/umin)).

Recall that the (1,q)-FGC problem can be formulated as a special case of Cap-k-ECSS with two capacities (the unsafe edges have unit capacity and the safe edges have capacity k=(q+1)). Clearly, the O(1)-approximation algorithm sketched above applies to the (1,q)-FGC problem. Our next result improves the approximation ratio to 8, thus improving on the previous best (q+1)-approximation algorithm for (1,q)-FGC, [5].

Theorem 4.

There is a polynomial-time algorithm that, given an instance of (1,q)-FGC, computes a vector x of cost at most opt that possibly satisfies only a subset of the constraints of (KCLP:(1,q)-FGC), and rounds it to a feasible integer solution of cost at most 8opt.

Moreover, we present O(1)-approximate reductions between the (2,q)-FGC problem and the 2-CoverSmallCuts 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 2-CoverSmallCuts that runs in polynomial time is available. Then there is an algorithm for (2,q)-FGC that runs in polynomial time and returns a feasible (integer) solution of cost (4(ρ+1)+8)opt.

Theorem 6.

Suppose a ρ-approximation algorithm for (2,q)-FGC that runs in polynomial time is available. Then there is an algorithm for 2-CoverSmallCuts that runs in polynomial time and returns a feasible (integer) solution of cost (ρ+2)opt.

1.6 Organization of the Paper

For the sake of readability and accessibility, we present our 8-approximation algorithm for (1,q)-FGC in the next section, and we defer the presentation of our improved approximation algorithm for Cap-k-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 8-approximation algorithm for the (1,q)-FGC problem. For the convenience of the reader, the presentation in this section is independent of the rest of the paper. For a graph G=(V,E) and SV, the cut δ(S) refers to the set of edges that have exactly one end-node in S; δ(S) is called a non-trivial cut if SV. (Whenever we use the term “cut δ(S)” we mean that S is a subset of V(G).) We use the term small cut to mean a non-trivial cut δ(S) 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 e𝒰 has capacity ue=1, and each safe edge e𝒮 has capacity ue=(q+1). The natural LP relaxation then seeks to minimize the total cost of edges subject to the constraint that SV, we have e𝒮δ(S)(q+1)xe+e𝒰δ(S)xe(q+1).

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 (1,q)-FGC, and vice versa. However, it is also easy to show that this LP has integrality ratio (q+1) by adapting Example 1 given at the end of section 1.2.

To get around this obstruction, we strengthen the LP relaxation of (1,q)-FGC using the knapsack-cover inequalities to obtain the following stronger LP. Intuitively, the added knapsack-cover inequalities for a cut δ(S) ensure that if a safe edge is being used to cover δ(S) and, moreover, δ(S) is partly covered by unsafe edges, say, by of them, then the capacity of the safe edge is reduced to (q+1).

min eEcexe (KCLP:(1,q)-FGC)
s.t. e𝒮δ(S)(q+1)xe+e𝒰δ(S)xe(q+1) SV
eEδ(S)Aue(A,S)xeD(A,S) SV,AE
0xe1 eE,

where D(A,S)=max{0,(q+1){ueeAδ(S)}}, and ue(A,S)=min{ue,D(A,S)}. We mentioned above that Ibrahimpur & Vegh [13] have presented a polynomial-time separation subroutine for the knapsack-cover inequalities for the (p,q)-FGC 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 A and a collection of sets 𝒞 (in polynomial time) such that, as long as the knapsack-cover inequalities hold for A and all S𝒞, we will be able to execute our rounding algorithm. Using this, we will design a polynomial-time approximation algorithm for (1,q)-FGC.

In this section, let α denote the best approximation ratio known for the CoverSmallCuts problem. We will design an (α+2)-approximation algorithm for the (1,q)-FGC problem. As of now, we have (α+2)=8, since α=6, due to [3, 4, 21]; also see [18].

Let LPopt denote the optimal value of (KCLP:(1,q)-FGC), the LP with the knapsack-cover inequalities. Using binary search for LPopt together with the ellipsoid algorithm and our polynomial-time subroutines, we will find a vector x with cost c(x)=ecexe such that c(x)LPopt and x satisfies the constraints of (KCLP:(1,q)-FGC) specified in the next lemma (though x could violate other constraints of (KCLP:(1,q)-FGC)). Then, we will “round” x to an integer solution of cost (α+2)c(x). Thus, we will find an integer solution of cost (α+2)LPopt (even though we will not compute the precise value of LPopt). 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 x (that is a candidate solution of (KCLP:(1,q)-FGC)) and a value z either finds a violated constraint of the LP or else verifies that c(x)z and, moreover, x satisfies the following two properties:

  1. (P1)

    e𝒮δ(S)(q+1)xe+e𝒰δ(S)xe(q+1)SV.

  2. (P2)

    Let A={e𝒰|xe2(α+2)}. For any non-empty SV, if e𝒮δ(S)(q+1)xe+e𝒰δ(S)xe2(q+1), then eEδ(S)Aue(A,S)xeD(A,S).

Proof.

Essentially, we will describe a polynomial-time separation oracle that identifies any violations of properties (P1) and (P2). Given a vector x, we first check that eEcexez. If not, we return this as a violated constraint. Otherwise, let G^=(V^,E^) be the capacitated graph where V^=V,E^=E, and each edge eE^ is assigned a capacity of uexe. We can now check that the capacity of a minimum-cut of G^ is at least (q+1) using a polynomial-time global minimum-cut algorithm [19]. If not, we return a global minimum cut in G^ as a violated constraint. Otherwise, we know that (P1) is satisfied, and we proceed to verify (P2) with respect to the set A={e𝒰|xe2(α+2)}.

By Karger’s result [15], there are at most O(n4) cuts of capacity at most 2(q+1) (i.e., at most twice the capacity of a minimum cut), and, moreover, we can enumerate all such cuts of G^ in polynomial time [16]. By iterating over each of the O(n4) cuts, we can now verify, in polynomial time, that the knapsack-cover inequalities are satisfied w.r.t. the set A. 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 nO(1) iterations of feasibility verification [10]. The outer loop of our algorithm runs a binary search for LPopt (see the discussion at the end of this section).

Corollary 8.

There is a polynomial-time algorithm that computes a vector x of cost c(x)LPopt such that x satisfies properties (P1) and (P2); possibly, x violates some of the other constraints of (KCLP:(1,q)-FGC).

The Rounding Algorithm.

Given a value z and a vector x of cost c(x)z that satisfies properties (P1) and (P2) (see Lemma 7), Algorithm 1, presented below, rounds it to an integer solution of cost at most (α+2)z. Below, we describe the main idea of our rounding scheme.

Recall that our LP relaxation assigns capacity ue=1 for each unsafe edge e𝒰 and capacity ue=(q+1) to each safe edge e𝒮. We call a non-trivial cut δ(S) a small cut if |𝒰1δ(S)|+e𝒰2δ(S)(α+2)2xe<(q+1) where 𝒰1={e𝒰:xe2(α+2)}, and 𝒰2=𝒰𝒰1. To handle the presence of small cuts, we first construct an instance of CoverSmallCuts with the specified small cuts and with link-set the set of safe edges; then, via Lemma 9, we show that the vector x restricted to safe edges and scaled up by a factor of (α+2)α (i.e., (α+2)αx𝒮) constitutes a feasible solution to the LP relaxation of the CoverSmallCuts instance. We can thus pick a set 𝒮1 of safe edges by applying the α-approximation algorithm to the CoverSmallCuts instance; note that the cost of 𝒮1 is at most α times the cost of (α+2)αx𝒮. After this step, we contract the connected components formed by the edges in 𝒮1, and get a new instance that does not have any small cuts. Since there are no small cuts, every non-trivial cut δ(S) satisfies the inequality |𝒰1δ(S)|+e𝒰2δ(S)(α+2)2xe(q+1). Therefore, we get a feasible solution for the LP relaxation of the f-connectivity problem where f(S)=q+1 for every non-empty set SV, by picking all edges in 𝒰1 and scaling up x restricted to 𝒰2 by a factor of (α+2)/2. Since f is weakly supermodular, we can apply Jain’s iterative rounding method [14] to solve this f-connectivity problem and obtain a 2-approximate solution, giving us an integral solution whose cost is at most (α+2) times the cost of x𝒰 (see Lemma 10). Thus, we get an integral solution whose total cost of safe and unsafe edges is at most (α+2) times LPopt.

Algorithm 1 (α+2)-approximate solution to (1,q)-FGC.

The next two lemmas formalize the key properties of the solution x that are used in the rounding scheme above, allowing us to show that it returns a feasible integral solution of cost at most (α+2)c(x).

Lemma 9.

In step 2 of Algorithm 1, a feasible fractional solution to the CoverSmallCuts instance is given by x^e=min{1,(α+2)αxe} for e𝒮.

Proof.

Consider any small cut δ(S). We will establish the lemma by considering two cases.

First, consider the case that e𝒮δ(S)(q+1)xe+e𝒰δ(S)xe>2(q+1). Since δ(S) is a small cut, we have

e𝒰1δ(S)xe+e𝒰2δ(S)xe|𝒰1δ(S)|+e𝒰2δ(S)(α+2)2xe<(q+1).

Since e𝒮δ(S)(q+1)xe+e𝒰δ(S)xe>2(q+1), it follows that e𝒮δ(S)(q+1)xe(q+1), hence, e𝒮δ(S)xe1. Thus, e𝒮δ(S)x^e1.

Now suppose that e𝒮δ(S)(q+1)xe+e𝒰δ(S)xe2(q+1). Then, by (P2), the cut δ(S) satisfies the knapsack-cover inequality w.r.t. the set A=𝒰1:

e𝒮δ(S)ue(A,S)xe+e𝒰2δ(S)ue(A,S)xeD(A,S),

where D(A,S)=max{0,(q+1){ueeAδ(S)}}=max{0,(q+1)|𝒰1δ(S)|}, and ue(A,S)=min{ue,D(A,S)}.

Moreover, since δ(S) is a small cut, we have |𝒰1δ(S)|+e𝒰2δ(S)(α+2)2xe<(q+1). We rewrite this inequality as e𝒰2δ(S)(α+2)2ue(A,S)xe<D(A,S), which is the same as e𝒰2δ(S)ue(A,S)xe<2(α+2)D(A,S). Thus, by the knapsack-cover inequality, we have e𝒮δ(S)ue(A,S)xeα(α+2)D(A,S). By definition, ue(A,S)D(A,S), hence, we have e𝒮δ(S)(α+2)αD(A,S)xeD(A,S). Therefore, e𝒮δ(S)x^e1, completing the proof.

Lemma 10.

In step 3 of Algorithm 1, a feasible fractional solution to the f-connectivity problem is given by xe=(α+2)2xe for e𝒰2.

Proof.

By way of contradiction, suppose that the claim does not hold. Then for some non-trivial cut δ(S), we have (q+1)|𝒮1δ(S)|+|𝒰1δ(S)|+e𝒰2δ(S)(α+2)2xe<(q+1). This implies that the cut δ(S) is a small cut in step 2 of Algorithm 1. Hence, step 2 ensures (via CoverSmallCuts) that |𝒮1δ(S)|1 and so (q+1)|𝒮1δ(S)|(q+1). This is a contradiction.

The output of Algorithm 1 is feasible for the (1,q)-FGC problem by Lemmas 910. The cost of the edges in 𝒰1 is (α+2)2e𝒰1cexe since xe2(α+2) for each edge e in 𝒰1. Additionally, the cost of the edges in 𝒮1 is (α+2)e𝒮1cexe 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 e𝒰2(2)((α+2)/2)cexe=(α+2)e𝒰2cexe, by Lemma 10. Therefore, the cost of the solution returned by Algorithm 1 is at most (α+2)c(x).

The outer loop of our algorithm runs a binary search for LPopt, but note that we are not using a “true” polynomial-time separation subroutine. Given a vector x (a candidate solution to (KCLP:(1,q)-FGC)), our subroutine either finds that x violates one of the constraints specified in Lemma 7 or else it rounds x to an integer solution of cost (α+2)c(x), where c(x)=ecexe. The binary search for LPopt starts with the interval [0,c(E)], where c(E)=ece. Assume that the instance has a feasible integer solution, let opt denote the cost of an optimal integer solution, and assume that 0<optc(E).

In an arbitrary iteration, the binary search calls the ellipsoid algorithm with the additional constraint ecexez, where the current interval is [c,hc] and z=c+hc2. (The binary search maintains the invariant: LPopt>c and there exists an integer solution of cost (α+2)hc.) 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 x with c(x)z and an integer solution of cost (α+2)c(x). The binary search continues as usual, that is, in case (1) it replaces the current interval [c,hc] by the upper half-interval [c+hc2,hc], and in case (2) it replaces the current interval by the lower half-interval [c,c+hc2]. The binary search terminates when the current interval [final,hfinal] is sufficiently small. Clearly, the LP with the additional constraint ecexefinal is infeasible, and the algorithm found an integer solution of cost (α+2)hfinal. Hence, LPopt>final and the last integer solution found by the algorithm has cost (α+2)(LPopt+(hfinalfinal)).

See 4

3 An 𝑶(𝐥𝐨𝐠𝒌𝒖𝒎𝒊𝒏)-Approximation Algorithm for Cap-𝒌-ECSS

In this section, we present an O(log(k/umin))-approximation algorithm for Cap-k-ECSS that runs in polynomial time assuming k/umin|V(G)|=n. Note that when k/umin>n, then the previously known approximation algorithm of [7] for Cap-k-ECSS achieves an approximation ratio of O(logn)O(log(k/umin)).

Let us recall a few terms & notation from previous sections. For a graph G=(V,E) and SV, the cut δ(S) refers to the set of edges that have exactly one end-node in S; δ(S) is called a non-trivial cut if SV. (Whenever we use the term “cut δ(S)” we mean that S is a subset of V(G).) We use the term small cut to mean a non-trivial cut δ(S) with capacity below a specified threshold-value, say, λ.

Let LPopt denote the optimal value of (KCLP: CapkECSS), the LP with the knapsack-cover inequalities. Similarly to section 2, we use binary search for LPopt together with the ellipsoid algorithm and our polynomial-time subroutines to find a vector x with cost c(x)=ecexe such that c(x)LPopt and x satisfies the constraints of (KCLP: CapkECSS) specified in the proof of Lemma 11 (though x could violate other constraints of (KCLP: CapkECSS)). Then, we will round x to an integer solution of cost O(log(k/umin))c(x). Thus, we will find an integer solution of cost O(log(k/umin))LPopt, even though we will not compute the precise value of LPopt. 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 x satisfies all the constraints of (KCLP: CapkECSS). In section 3.6 below, we explain that we can easily remove this assumption.

Figure 1: Illustration of buckets. Note that T=logk.

Throughout the execution of the rounding algorithm, we will maintain a set of edges Ecur acting as our current solution. We begin with Ecur={eE:xe1/2}. Define T=logk and for j=1,2,,T, define Ej={eE:xe<1/2 and ue2j}; thus, the edge-sets ETET1,ET1ET2,,E3E2,E2E1,E1 form a partition of the edges in EEcur into T buckets based on the capacities; let us call the set ETi+1ETi the i-th bucket (and E1 is the T-th bucket). See Figure 1 for an illustration.

Our algorithm will have T iterations and each iteration (except for the first and the last) will have two phases. During phase 1 of iteration i, we will round some of the edges in the i-th bucket, i.e., some of the edges in the set ETi+1ETi. Note that an edge e in the i-th bucket has capacity 2Ti<ue2Ti+1. Informally speaking, in phase 1, we want to augment cuts of very small capacity with edges of capacity 2Ti, and, in general, we need Θ(k/2Ti) rounds of augmentation to achieve capacity k; thus, phase 1 has Θ(k/2Ti) sub-iterations. During phase 2 of iteration i, we will round some of the edges in E(ETiEcur).

Next, we present pseudo-code for the rounding algorithm, followed by explanation and analysis of the main steps.

Algorithm 2 O(log(k/umin))-approximate solution to Cap-k-ECSS.

For every non-trivial cut δ(S), we will maintain the following invariants for all iterations i=2,,(T1) (i.e., except the first and the last iteration):

  1. (1)

    At the beginning of iteration i, EcurETi+1= and

    eEcurδ(S)ue+eETi+1δ(S)2uexek.

    We note that iteration 1 ensures that this invariant holds at the start of iteration 2.

  2. (2)

    At the end of phase 1 of iteration i,

    eEcurδ(S)ue+eETiδ(S)2uexek2Ti+12Ti.
  3. (3)

    At the end of iteration i, which is also the end of phase 2 of iteration i, EcurETi=, and

    eEcurδ(S)ue+eETiδ(S)2uexek.

    Observe that invariant (3) for iteration i is the same as invariant (1) for iteration i+1.

3.1 Iteration 1

In this iteration, we consider the family of small cuts δ(S) where

eEcurδ(S)ue+eET1δ(S)2uexe<k

We will cover these cuts using edges in EET1Ecur. Consider any one of these small cuts δ(S). Since δ(S) is a small cut, we have eET1δ(S)2uexe<k(eEcurδ(S)ue)=ku(Ecurδ(S)), hence, we have eET1δ(S)uexe<(ku(Ecurδ(S)))/2. Consider the knapsack-cover inequality for one of these small cuts δ(S) and the set A=Ecur, eEδ(S)Aue(A,S)xeD(A,S), where D(A,S)=(ku(Ecurδ(S))) and ue(A,S)=min{ue,D(A,S)}. By the above inequality and the knapsack-cover inequality, each of these small cuts δ(S) satisfies the inequality e(EET1Ecur)δ(S)min{ue,D(A,S)}xe>D(A,S)/2, which implies the inequality e(EET1Ecur)δ(S)D(A,S)xe>D(A,S)/2. Thus 2xEET1Ecur is feasible for the CoverSmallCuts problem implying that we incur a cost of at most 62c(xETET1) here. We run the 6-approximation algorithm for CoverSmallCuts, [3, 4, 21], and use the edge-set returned by that algorithm to augment Ecur. We repeat one more time, i.e., we again consider all cuts δ(S) where eEcurδ(S)ue+eET1δ(S)2uexe<k and cover these cuts using edges in EET1Ecur, incurring a further cost of 62c(xEET1). 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 CoverSmallCuts considered in this step. This means we would have added at least two edges that cover this cut, each of capacity at least k/2, 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 EcurETi+1= and eEcurue+eETi+12uexek. We will run multiple sub-iterations within this phase. The first sub-iteration is described below.

Consider the family of small cuts δ(S) where eEcurδ(S)ue+eETiδ(S)2uexe<2Ti. We will cover these cuts using edges in ETi+1ETiEcur. For these small cuts δ(S), we have

e(ETi+1ETiEcur)δ(S)2uexek2Ti

(this inequality is obtained by subtracting the inequality defining the small cuts from the inequality of invariant (1), namely, eEcurδ(S)ue+eETi+1δ(S)2uexek). Observe that e(ETi+1ETiEcur)δ(S)2xe (k2Ti)/2Ti+1, because ue2Ti+1 for all edges in ETi+1. Thus, 2xETi+1ETiEcur2Ti+1/(k2Ti) is feasible for the CoverSmallCuts problem. We run the 6-approximation algorithm for CoverSmallCuts, [3, 4, 21], and use the edge-set returned by that algorithm to augment Ecur. After this, there are no non-trivial cuts δ(S) with eEcurδ(S)ue+eETiδ(S)2uexe<2Ti since we would have covered any such cut by an edge from ETi+1ETiEcur, and all these edges have capacity at least 2Ti. Next, we shift the threshold in the definition for small cuts to 22Ti, and then to 32Ti, …, all the way until ^2Ti where ^=(k2Ti+1)/2Ti. This would imply that ^2Tik2Ti+12Ti. We describe these sub-iterations in more detail now.

For =1,2,,^, consider the family of small cuts δ(S) where

eEcurδ(S)ue+eETiδ(S)2uexe<2Ti.

Since invariant (1) is true (and we have only increased the LHS of invariant (1) during the phase), we have e(ETi+1ETiEcur)δ(S)2uexek2Ti. Since ue2Ti+1 for all edges in ETi+1, we have e(ETi+1ETiEcur)δ(S)2xe(k2Ti)/2Ti+1. Thus, 2xETi+1ETiEcur2Ti+1/(k2Ti) is feasible for our instance of CoverSmallCuts. We run the 6-approximation algorithm for CoverSmallCuts, [3, 4, 21], and use the edge-set returned by that algorithm to augment Ecur. Then, we move on to the next sub-iteration. At the end of the last sub-iteration (with =^), we have

eEcurδ(S)ue+eETiδ(S)2uexe(^)2Tik2Ti+12Ti,

and so invariant (2) is maintained. Let us analyze the cost we incurred in this phase.

The cost we incur is at most 62c(xETi+1ETi)2Ti+1(1k2Ti+1k22Ti++1k^2Ti). We bound this last sum as follows. Note that ^2Tik2Ti+1 and so k^2Ti2Ti+1

1k2Ti+1k22Ti++1k^2Ti
=1k^2Ti+1k^2Ti+2Ti+1k^2Ti+22Ti+1k^2Ti+(^1)2Ti
12Ti+1+=1^11k^2Ti+2Ti
12Ti+1+0^11k^2Ti+2Tid()
=12Ti+1+12Ti(log(k2Ti)log(k^2Ti))
12Ti+1+12Ti(log(k)log(2Ti+1)) (using the inequality k^2Ti2Ti+1)
=O(log(k/2Ti+1)2Ti)

Thus, the cost incurred in this phase is
62(2Ti+1/2Ti)O(log(k/2Ti+1))c(xETi+1ETi).

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 δ(S), we have eEcurδ(S)ue+eETiδ(S)2uexek2Ti+12Ti. We will add more edges from EETiEcur to these cuts, if needed, to increase the capacity to k. Note that all edges in EETiEcur have capacity at least 2Ti 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 δ(S) where eEcurδ(S)ue+eETiδ(S)2uexe<k. Then, by the knapsack-cover inequalities, 2xEETiEcur is feasible for the CoverSmallCuts instance. Indeed for each of these small cuts δ(S), we have eETiδ(S)uexe<(keEcurδ(S)ue)/2=(ku(Ecurδ(S)))/2. The knapsack-cover inequality then implies that e(EETiEcur)δ(S)D(A,S)xe>D(A,S)/2, where A=Ecur and D(A,S)=ku(Ecurδ(S)). We run the 6-approximation algorithm for CoverSmallCuts, [3, 4, 21], and use the edge-set returned by that algorithm to augment Ecur. This incurs a cost of at most 62c(x). We repeat three times, adding the approximate solution of the CoverSmallCuts instance to Ecur and incur a cost of at most 362c(x). At the end of this phase, for every non-trivial cut δ(S), we have eEcurδ(S)ue+eETiδ(S)2uexek. 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 δ(S):

eEcurδ(S)ue+eE1δ(S)2uexek.

Now, we apply Jain’s iterative rounding method to round the edges in E1, incurring a cost of at most (2max{ue:eE1})c(xE1)=4c(xE1).

3.5 Total Cost

We calculate the total cost incurred separately for each iteration. In iteration 1, we incur a cost of O(1)c(x); this includes the term {eE:xe1/2}2cexe (due to the initial Ecur). In phase 1 of iterations i=2,,T1, we incur a total cost of

O(1)i=2T1log(k/2Ti+1)c(xETi+1ETi)O(logk)c(x).

In phase 2 of iterations i=2,,T1, we incur a cost of i=2T1O(1)c(x)O(T)c(x)O(logk)c(x). Finally the cost incurred in iteration T is O(1)c(x). Thus the total cost incurred is O(logk)c(x).

Observe that if the minimum capacity umin over all edges in E is greater than 2, then the algorithm stops at an earlier iteration. In fact, it stops at an iteration ifinal where 2Tifinal<umin2Tifinal+1. Since T=logk, we obtain that ifinal=O(log(k/umin)). In such a scenario, the total cost incurred in phase 1 of iterations i=2,,ifinal, is

O(1)i=2ifinallog(k/2Ti+1)c(xETi+1ETi)
O(1)i=2ifinallog(k/umin)c(xETi+1ETi) (since umin2Tifinal+1)
O(log(k/umin))c(x).

Similarly the total cost incurred in phase 2 of iterations i=2,,ifinal is i=2ifinalO(1)c(x)O(ifinal)c(x)O(log(k/umin))c(x). Thus the overall cost is O(log(k/umin))c(x).

3.6 Solving the LP Relaxation

Clearly, our rounding algorithm runs in polynomial time, provided an optimal (and feasible) solution x 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 A and a collection of sets 𝒞 such that, as long as the knapsack-cover inequalities hold for A and all S𝒞, we will be able to execute our rounding algorithm.

Lemma 11.

There is a polynomial-time algorithm that, given a vector x (that is a candidate solution of (KCLP: CapkECSS)) and a value z, either finds a violated constraint of the LP or else verifies that c(x)z and, moreover, for every iteration i, i=1,,(T1), x satisfies the property that 2xEETiEcur is feasible for the LP relaxations of the CoverSmallCuts instances created in steps 1(b) and 2(c) of Algorithm 2.

Proof.

Given a candidate vector x and a candidate objective value z, we first check that eEcexez (see the discussion on binary search at the end of section 2). If not, we return this as a violated constraint. Otherwise, let G^=(V^,E^) be the capacitated graph where V^=V,E^=E, and each edge eE^ is assigned a capacity of uexe. We can now check that the capacity of a minimum cut in G^ is at least k using a polynomial-time global minimum-cut algorithm [19]. If not, we return a global minimum cut in G^ as a violated constraint.

By Karger’s result [15], we know that there are at most O(n4) cuts of capacity at most 2k (i.e., at most twice the capacity of a minimum cut), and, moreover, we can enumerate all such cuts of G^ in polynomial time [16]. By iterating over each of the O(n4) cuts, we can then verify in polynomial time that the knapsack-cover inequalities are satisfied w.r.t. the set A=Ecur in each of the steps 1(b) and 2(c) for cuts whose capacity is at most 2k. 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 δ(S) such that eδ(S)uexe>2k.

In this case, we note that in step 1(b), by the definition of small cuts, we have eEcurδ(S)ue+eET1δ(S)2uexe<k. But then since the total capacity of this cut is at least 2k, it follows that e(EET1Ecur)δ(S)uexe>k. Since uek for every edge eE, it follows that e(EET1Ecur)δ(S)xe>1. Thus 2xEET1Ecur is feasible on this cut for the CoverSmallCuts instance. A similar argument can be used to show that in step 2(c), if we have a small cut δ(S) with eδ(S)uexe>2k, then 2xEETiEcur is feasible for the CoverSmallCuts instance. Specifically, by the definition of small cuts, we have eEcurδ(S)ue+eETiδ(S)2uexe<k. As the total capacity is at least 2k, it follows that e(EETiEcur)δ(S)uexe>k, and since uek for every edge eE, e(EETiEcur)δ(S)xe>1. Thus 2xEETiEcur is feasible on this cut for the CoverSmallCuts 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 x given by the Ellipsoid algorithm (without any modification). As the rounding progresses, the only thing that changes is the definition of the set A=Ecur 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 nO(1) iterations of feasibility verification [10], it must be the case that after at most nO(1) re-starts of the rounding process, we arrive at a solution x to (KCLP: CapkECSS) of value at most LPopt such that the solution satisfies the property that 2xEETiEcur is feasible for the CoverSmallCuts instances created in steps 1(b) and 2(c).

 Remark 12.

We mention that the analysis of phase 1 of iteration i (i=2,,(T1)) (i.e., step 2(a) of iteration i) 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 O(logn)-Approximation Algorithm for (p,q)-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.