Facility Location with Client Latencies: Linear-Programming basedTechniques for Minimum-Latency Problems

Deeparnab Chakrabarty∗ Chaitanya Swamy†

Abstract

We introduce a problem that is a common generalization of the uncapacitated facility location (UFL)and minimum latency (ML) problems, where facilities not only need to be opened to serve clients, but alsoneed to be sequentially activated before they can provide service. This abstracts a setting where inventorydemanded by customers needs to be stocked or replenished at facilities from a depot or warehouse.Formally, we are given a set F of n facilities with facility-opening costs fi, a set D of m clients, andconnection costs cij specifying the cost of assigning a client j to a facility i, a root node r denoting thedepot, and a time metric d on F ∪ r. Our goal is to open a subset F of facilities, find a path P startingat r and spanning F to activate the open facilities, and connecting each client j to a facility φ(j) ∈ F ,so as to minimize

∑i∈F fi +

∑j∈D(cφ(j),j + tj), where tj is the time taken to reach φ(j) along path

P . We call this the minimum latency uncapacitated facility location (MLUFL) problem.Our main result is an O

(log n maxlog n, log m

)-approximation for MLUFL. Via a reduction to the

group Steiner tree (GST) problem, we show this result is tight in the sense that any improvement in theapproximation guarantee for MLUFL, implies an improvement in the (currently known) approximationfactor for GST. We obtain significantly improved constant approximation guarantees for two naturalspecial cases of the problem: (a) related MLUFL, where the connection costs form a metric that is ascalar multiple of the time metric; (b) metric uniform MLUFL, where we have metric connection costsand the time-metric is uniform. Our LP-based methods are fairly versatile and are easily adapted withminor changes to yield approximation guarantees for MLUFL (and ML) in various more general settings,such as (i) the setting where the latency-cost of a client is a function (of bounded growth) of the delayfaced by the facility to which it is connected; and (ii) the k-route version, where we can dispatch kvehicles in parallel to activate the open facilities.

Our LP-based understanding of MLUFL also offers some LP-based insights into ML. We obtain twonatural LP-relaxations for ML with constant integrality gap, which we believe shed new light upon theproblem and offer a promising direction for obtaining improvements for ML.

1 Introduction

Facility location and vehicle routing problems are two broad classes of combinatorial optimization problemsthat have been widely studied in the Operations Research community (see, e.g., [25, 32]), and have a widerange of applications. Both problems can be described in terms of an underlying set of clients that need to beserviced. In facility location problems, there is a candidate set of facilities that provide service, and the goalis to open some facilities and connect each client to an open facility so as to minimize some combinationof the facility-opening and client-connection costs. Vehicle routing problems consider the setting where avehicle (delivery-man or repairman) provides service, and the goal is to plan a route that visits (and henceservices) the clients as quickly as possible. Two common objectives considered are: (i) minimize the total

∗deepc@seas.upenn.edu. Dept. of Computer and Information Science, Univ. of Pennsylvania, Philadelphia, PA 19104.Most of the work was done as a postdoctoral fellow at the Dept. of Combinatorics and Optimization, Univ. Waterloo.

†cswamy@math.uwaterloo.ca. Dept. of Combinatorics and Optimization, Univ. Waterloo, Waterloo, ON N2L 3G1.Supported in part by NSERC grant 327620-09 and an Ontario Early Researcher Award.

1

length of the vehicle’s route, giving rise to the traveling salesman problem (TSP), and (ii) (adopting a client-oriented approach) minimize the sum of the client delays, giving rise to minimum latency (ML) problems.

These two classes of problems have mostly been considered separately. However, various logisticsproblems involve both facility-location and vehicle-routing components. For example, consider the follow-ing oft-cited prototypical example of a facility location problem: a company wants to determine where toopen its retail outlets so as to serve its customers effectively. Now, inventory at the outlets needs to bereplenished or ordered (e.g., from a depot); naturally, a customer cannot be served by an outlet unless theoutlet has the inventory demanded by it, and delays incurred in procuring inventory might adversely impactcustomers. Hence, it makes sense for the company to also keep in mind the latencies faced by the customerswhile making its decisions about where to open outlets, how to connect customers to open outlets, and inwhat order to replenish the open outlets, thereby adding a vehicle-routing component to the problem.

We propose a mathematical model that is a common generalization of the uncapacitated facility location(UFL) and minimum latency (ML) problems, and abstracts a setting (such as above) where facilities need tobe “activated” before they can provide service. Formally, as in UFL, we have a set F of n facilities, and aset D of m clients. Opening facility i incurs a facility-opening cost fi, and assigning a client j to a facilityi incurs connection cost cij . Taking a lead from minimum latency problems, we model activation delays asfollows. We have a root (depot) node r, and a time metric d on F ∪ r. A feasible solution specifies asubset F ⊆ F of facilities to open, a path P starting at r and spanning F along which the open facilities areactivated, and assigns each client j to an open facility φ(j) ∈ F . The cost of such a solution is∑

i∈F

fi +∑j∈D

(cφ(j)j + tj

)(1)

where tj = dP (r, φ(j)) is the time taken to reach facility φ(j) along path P . We refer to tj as client j’slatency cost. The goal is to find a solution with minimum total cost. We call this the minimum-latencyuncapacitated facility location (MLUFL) problem.

Apart from being a natural problem of interest, we find MLUFL appealing since it generalizes, or isclosely-related to, various diverse problems of interest (in addition to UFL and ML); our work yields newinsights on some of these problems, most notably ML (see “Our results”). One such problem, which capturesmuch of the combinatorial core of MLUFL is what we call the minimum group latency (MGL) problem. Here,we are given an undirected graph with metric edge weights de, subsets Gj of vertices called groups,and a root r; the goal is to find a path starting at r that minimizes the sum of the cover times of the groups,where the cover time of Gj is the first time at which some i ∈ Gj is visited on the path. Observe that MGLcan be cast as MLUFL with zero facility costs (where F = node-set \ r), where for each group Gj , wecreate a client j with cij = 0 if i ∈ Gj and ∞ otherwise. Note that we may assume that the groups aredisjoint (by creating multiple co-located copies of a node), in which case these cijs form a metric. MGLitself captures various other problems. Clearly, when each Gj is a singleton, we obtain the minimum latencyproblem. Also, given a set-cover instance, if we consider a graph whose nodes are (r and) the sets, create agroup Gj for each element j consisting of the sets containing it, and consider the uniform metric, then thisMGL problem is simply the min-sum set cover (MSSC) problem [16].

Our results and techniques. Our main result is an O(log n maxlog m, log n

)-approximation algorithm

for MLUFL (Section 2.1), which for the special case of MGL, implies an O(log2 n) approximation. Com-plementing this result, we prove (Theorem 2.9) that a ρ-approximation algorithm (even) for MGL yieldsan O(ρ log m)-approximation algorithm for the group Steiner tree (GST) problem [17] on n nodes andm groups. Thus, any improvement in our approximation ratio for MLUFL would yield a correspondingimprovement of GST, whose approximation ratio has remained at O(log2 n log m) for a decade [17]. More-over, combined with the result of [22] on the inapproximability of GST, this shows that MGL, and henceMLUFL with metric connection costs cannot be approximated to better than a Ω(log m)-factor unless NP ⊆ZTIME (npolylog(n)).

2

Given the above hardness result, we investigate certain well-motivated special cases of MLUFL andobtain significantly improved performance guarantees. In Section 2.2, we consider the case where theconnection costs form a metric, which is a scalar multiple of the d-metric (i.e., duv = cuv/M , whereM ≥ 1; the problem is trivial if M < 1). For example, in a supply-chain logistics problem, this models anatural setting where the connection of clients to facilities, and the activation of facilities both proceed alongthe same transportation network. We obtain a constant-factor approximation algorithm for this problem.

In Section 2.3, we consider the uniform MLUFL problem, which is the special case where the time-metric is uniform. Uniform MLUFL already generalizes MSSC (and also UFL). For uniform MLUFL withmetric connection costs (i.e., metric uniform MLUFL), we devise a 10.78-approximation algorithm. (Withoutmetricity, the problem becomes set-cover hard, and we obtain a simple matching O(log m)-approximation.)The chief novelty here lies in the technique used to obtain this result. We give a simple generic reduction(Theorem 2.12) that shows how to reduce the metric uniform MLUFL problem with facility costs to onewithout facility costs, in conjunction with an algorithm for UFL. This reduction is surprisingly robust andversatile and has other applications. For example, the same reduction yields an O(1)-approximation formetric uniform k-median (i.e., metric uniform MLUFL where at most k facilities may be opened), and thesame ideas lead to improved guarantees for the k-median versions of connected facility location [31], andfacility location with service installation costs [28].

We obtain our approximation bounds by rounding the optimal solution to a suitable linear-programming(LP) relaxation of the problem. This is interesting since we are not aware of any previous LP-based methodsto attack ML (as a whole). In Section 3, we leverage this to obtain some interesting insights about ML, whichwe believe cast new light on the problem. In particular, we present two LP-relaxations for ML, and prove thatthese have (small) constant integrality gap. Our first LP is a specialization of our LP-relaxation for MLUFL.Interestingly, the integrality-gap bound for this LP relies only on the fact that the natural LP relaxation forTSP has constant integrality gap (i.e., a ρ-integrality gap for the natural TSP LP relaxation translates to anO(ρ)-integrality gap). In contrast, the various known algorithms for ML [7, 10, 1] all utilize algorithms forthe arguably harder k-MST problem or its variants. Our second LP has exponentially-many variables, onefor every path (or tree) of a given length bound, and the separation oracle for the dual problem is a rooted path(or tree) orienteering problem: given rewards on the nodes and metric edge costs, find a (simple) path rootedat r of length at most B that gathers maximum reward. We prove that even a bicriteria approximation forthe orienteering problem yields an approximation for ML while losing a constant factor. This connectionbetween orienteering and ML is known [14]. But we feel that our alternate proof, where the orienteeringproblem appears as the separation oracle required to solve the dual LP, offers a more illuminating explanationof the relation between the approximability of the two problems. (In fact, the same relationship also holdsbetween MGL and “group orienteering.”)

We believe that the use of LPs opens up ML to new venues of attack. A good LP-relaxation is beneficialbecause it yields a concrete, tractable lower bound and handle on the integer optimum, which one canexploit to design algorithms (a point repeatedly driven home in the field of approximation algorithms). Also,LP-based techniques tend to be fairly versatile and can be adapted to handle more general variants of theproblem (more on this below). Our LP-rounding algorithms exploit various ideas developed for schedulingand facility-location problems (e.g., α-points) and polyhedral insights for TSP, which suggests that thewealth of LP-based machinery developed for these problems can be leveraged to obtain improvements forML. We suspect that our LP-relaxations are in fact better than what we have accounted for, and considerthem to be a promising direction for making progress on ML.

Section 4 showcases the flexibility afforded by our LP-based techniques, by showing that our algorithmsand analyses extend with little effort to handle various generalizations of MLUFL (and hence, ML). For exam-ple, consider the setting where the latency-cost of a client j is λ(time taken to reach the facility serving j),for some non-decreasing function λ(.). When λ is convex and has “growth” at most p (i.e., λ(cx) ≤ cpλ(x)),we derive an O

(max(p log2 n)p, p log n log m

)-approximation for MLUFL, an O

(2O(p)

)-approximation

3

for related MLUFL and ML, and an O(1)-approximation for metric uniform MLUFL. (Concave λs are eveneasier to handle.) This in turn leads to approximation guarantees for the Lp-norm generalization of MLUFL,where instead of the sum (i.e., L1-norm) of client latencies, the Lp-norm of the client latencies appears inthe objective function. The spectrum of Lp norms tradeoff efficiency with fairness, making the Lp-normproblem an appealing problem to consider. We obtain an O

(p log n maxlog n, log m

)-approximation for

MLUFL, and an O(1)-approximation for the other special cases. Another notable extension is the k-routeversion of the problem, where we may use k paths starting at r to traverse the open facilities. With one sim-ple modification to our LPs (and algorithms), all our approximation guarantees translate to this setting. As acorollary, we obtain a constant-factor approximation for the Lp-norm version of the k-traveling repairmenproblem [14] (the k-route version of ML).

Related work. To the best of our knowledge, MLUFL and MGL are new problems that have not beenstudied previously. There is a great deal of literature on facility location and vehicle routing problems (see,e.g., [25, 32]) in general, and UFL and ML, in particular, which are special cases of our problem, and welimit ourselves to a sampling of some of the relevant results. The first constant approximation guaranteefor UFL was obtained by Shmoys, Tardos, and Aardal [29] via an LP-rounding algorithm, and the currentstate-of-the-art is 1.5-approximation algorithm due to Byrka [8]. The minimum latency (ML) problem seemsto have been first introduced to the computer science community by Blum et al. [7], who gave a constant-factor approximation algorithm for it. Goemans and Kleinberg [19]improved the approximation factor to10.78, using a “tour-concatenation” lemma, which has formed a component of all subsequent algorithmsand improvements for ML. The current-best approximation factor for ML is 3.59 due to Chaudhuri, Godfrey,Rao and Talwar [10]. As mentioned earlier, MGL with a uniform time metric captures the min-sum setcover (MSSC) problem. This problem was introduced by Feige, Lovasz and Tetali [16], who gave a 4-approximation algorithm for the problem and a matching inapproximability result. Recently, Azar et al. [2]introduced a generalization of MSSC, for which Bansal et al. [5] obtained a constant-factor approximation.

If instead of adding up the latency cost of clients, we include the maximum latency cost of a client inthe objective function of MLUFL, then we obtain the min-max versions of MGL and MLUFL, which havebeen studied previously. The min-max version of MGL is equivalent to a “path-variant” of GST: we seek apath starting at r of minimum total length that covers every group. Garg, Konjevod, and Ravi [17] devisedan LP-rounding based O(log2 n log m)-approximation for GST, where n is the number of nodes and mis the number of groups. Charikar et al. [9] gave a deterministic algorithm with the same guarantee, andHalperin and Krauthgamer [22] proved an Ω(log2 m)-inapproximability result. The rounding techniqueof [17] and the deterministic tree-embedding construction of [9] (rather its improvement by [15]) are keyingredients of our algorithm for (general) MLUFL. The min-max version of MLUFL can be viewed a path-variant of connected facility location [27, 20]. The connected facility location problem, in its full generality,is essentially equivalent to GST [27]; however, if the connection costs form a metric, and the time- and theconnection-cost metrics are scalar multiples of each other, then various constant-factor approximations areknown [20, 31, 13].

Very recently, we have learnt that, independent of, and concurrent with, our work, Gupta et al. [21] alsopropose the minimum group latency (MGL) problem (which they arrive at in the course of solving a differentproblem), and obtain results similar to ours for MGL. They also obtain an O(log2 n)-approximation for MGL,and the reduction from GST to MGL with a log m-factor loss (see also [26]), and relate the approximabilityof the MGL and “group orienteering” problems. Their techniques are combinatorial and not LP-based, andit is not clear how these can be extended to handle facility-opening costs.

4

2 LP-rounding approximation algorithms for MLUFL

We can express MLUFL as an integer program and relax the integrality constraints to obtain a linear programas follows. We may assume that dii′ is integral for all i, i′ ∈ F ∪r. Let E denote the edge-set of the com-plete graph on F ∪ r and let dmax := maxe∈E de. Let T ≤ minn, mdmax be a known upper bound onthe maximum activation time of an open facility in an optimal solution. For every facility i, client j, and timet ≤ T, we have a variable yi,t indicating if facility i is opened at time t or not, and a variable xij,t indicatingwhether client j connects to facility i at time t. Also, for every edge e ∈ E and time t, we introduce a vari-able ze,t which denotes if edge e has been traversed by time t. Throughout, we use i to index the facilities inF , j to index the clients in D, t to index the time units in [T] := 1, . . . ,T, and e to index the edges in E.

min∑i,t

fiyi,t +∑j,i,t

(cij + t

)xij,t (P)

s.t.∑i,t

xij,t ≥ 1 for all j; xij,t ≤ yi,t for all i, j, t

∑e

deze,t ≤ t for all t (2)∑e∈δ(S)

ze,t ≥∑

i∈S,t′≤t

xij,t′ for all t, S ⊆ F , j (3)

xij,t, yi,t, ze,t ≥ 0 for all i, j, t, e; yi,t = 0 for all i, t with dir > t.

The first two constraints encode that each client is connected to some facility at some time, and that if aclient is connected to a facility i at time t, then i must be open at time t. Constraint (2) ensures that by timet no more than t “distance” is covered by the tour on facilities, and (3) ensures that if a client is connectedto i by time t, then the tour must have visited i by time t. We assume for now that T = poly(m), and showlater how to remove this assumption (Lemma 2.7, Theorem 2.8). Thus, (P) can be solved efficiently sinceone can efficiently separate over the constraints (3). Let (x, y, z) be an optimal solution to (P), and OPTdenote its objective value. For a client j, define C∗

j =∑

i,t cijxij,t, and L∗j =

∑i,t txij,t. We devise various

approximation algorithms for MLUFL by rounding (x, y, z) to an integer solution.In Section 2.1, we give a polylogarithmic approximation algorithm for (general) MLUFL (where the cijs

need not even form a metric). Complementing this result, we prove (Theorem 2.9) that a ρ-approximationalgorithm (not necessarily LP-based) for MLUFL yields an O(ρ log m)-approximation algorithm for the GSTproblem on n nodes and m groups. In Sections 2.2 and 2.3, we obtain significantly-improved approximationguarantees for various well-motivated special cases of MLUFL. Section 2.2 obtains a constant-factor approx-imation algorithm in the natural setting where the connection costs form a metric that is a scalar multipleof the time-metric. Section 2.3 considers the setting where the time-metric is the uniform metric. Our mainresult here is a constant-factor approximation for metric connection costs, which is obtained via a ratherversatile reduction of this uniform MLUFL problem to UFL and uniform MLUFL with zero-facility costs.

2.1 An O(log n · maxlog n, log m

)-approximation algorithm

We first give an overview. Let Nj = i ∈ F : cij ≤ 4C∗j be the set of facilities “close” to j, and define τj

as the earliest time t such that∑

i∈Nj ,t′≤t xij,t′ ≥ 23 . By Markov’s inequality, we have

∑i∈Nj

∑t xij,t ≥ 3

4and τj ≤ 12L∗

j . It is easiest to describe the algorithm assuming first that the time-metric d is a tree metric.Our algorithm runs in phases, with phase ` corresponding to time t` = 2`. In each phase, we compute arandom subtree rooted at r of “low” cost such that for every client j with τj ≤ t`, with constant probability,this tree contains a facility in Nj . To compute this tree, we utilize the rounding procedure of Garg-Konjevod-Ravi (GKR) for the group Steiner tree (GST) problem [17] (see Lemma 2.4), by creating a group for each

5

client j with τj ≤ t` comprising of, roughly speaking, the facilities in Nj . We open all the facilities includedin the subtree, and obtain a tour via the standard trick of doubling all edges and performing an Eulerian tourwith possible shortcutting. The overall tour is a concatenation of all the tours obtained in the various phases.For each client j, we consider the first tree that contains a facility from Nj (which must therefore be open),and connect j to such a facility.

Given the result for tree metrics, an oft-used idea to handle the case when d is not a tree metric is toapproximate it by a distribution of tree metrics with O(log n) distortion [15]. Our use of this idea is howevermore subtle than the typical applications of probabilistic tree embeddings. Instead of moving to a distributionover tree metrics up front, in each phase `, we use the results of [9, 15] to deterministically obtain a tree T`with edge weights dT`

(e), such that the resulting tree metric dominates d and∑

e=(i,i′) dT`(i, i′)ze,t` =

O(log n)∑

e deze,t` . As we show in Section 4, this deterministic choice allows to extend our algorithmand analysis effortlessly to the setting where the latency-cost in the objective function is measured by amore general function (e.g., the Lp-norm) of the client-latencies. The algorithm is described in detail asAlgorithm 1, and utilizes the following results. Let τmax = maxj τj .

Theorem 2.1 ([9, 15]) Given any edge weights zee∈E , one can deterministically construct a weightedtree T having leaf-set F ∪ r, leading to a tree metric, dT (·), such that, for any i, i′ ∈ F ∪ r, we have:(i) dT (i, i′) ≥ di,i′ , and (ii)

∑e=(i,i′)∈E dT (i, i′)zi,i′ = O(log n)

∑e deze.

Theorem 2.2 ([17]) Consider a tree T rooted at r with n leaves, subsets G1, . . . , Gp of leaves, and frac-tional values ze on the edges of T satisfying z(δ(S)) ≥ νj for every group Gj and node-set S such thatGj ⊆ S, where νj ∈

[12 , 1

]. There exists a randomized polytime algorithm, henceforth called the GKR

algorithm, that returns a rooted subtree T ′′ ⊆ T such that (i) Pr[e ∈ T ′′] ≤ ze for every edge e ∈ T ; and(ii) Pr[T ′′ ∩Gj = ∅] ≤ exp

(− νj

64 log2 n

)for every group Gj .

Algorithm 1 Given: a fractional solution (x, y, z) to (P) (with C∗j , L∗

j , Nj , and τj defined as above for each client j).

A1. In each phase ` = 0, 1, . . . ,N := dlog2(2τmax) + 4 log2 me, we do the following. Let t` = min2`,T.A1.1. Use Theorem 2.1 with edge weights ze,t`

to obtain a tree T` =(V (T`), E(T`)

). Extend T` to a tree T ′` by

adding a dummy leaf edge (i, vi) of cost fi to T` for each facility i. Let E′ = (i, vi) : i ∈ F.A1.2. Map the LP-assignment ze,t`

e∈E to an assignment z on the edges of T ′` by setting ze =∑e lies on the unique i-i′ path in T`

zii′,t`for all e ∈ E(T`), and ze =

∑t≤t`

yi,t for all e = (i, vi) ∈ E′. Notethat

∑e∈E(T`)

dT`(e)ze =

∑e=(i,i′) dT`

(i, i′)ze,t`= O(log n)

∑e deze,t`

= O(log n)t`.

A1.3. Define D` = j : τj ≤ t`. For each client j ∈ D`, we define the group N ′j = vi : i ∈ Nj. We

now compute a subtree T ′` of T ′` as follows. We obtain N := log2 m subtrees T ′′

1 , . . . , T ′′N . Each tree T ′′

r

is obtained by executing the GKR algorithm 192 log2 n times on the tree T ′` with groups N ′jj∈D`

, andtaking the union of all the subtrees returned. Note that we may assume that i ∈ T ′′

r iff (i, vi) ∈ T ′′r . Set

T ′` to be any tree in T ′′

1 , . . . , T ′′N satisfying (i)

∑(i,vi)∈E(T ′

`) fi ≤ 40 · 192 log2 n∑

(i,vi)∈E′ fizi,vi and (ii)∑e∈E(T ′

`)\E′ dT`(e) ≤ 40 · 192 log2 n

∑e∈E(T`)

dT`(e)ze; if no such tree exists, the algorithm fails.

A1.4. Now remove all the dummy edges from T ′` , open all the facilities in the resulting tree, and convert the

resulting tree into a tour Tour` traversing all the opened facilies. For every unconnected client j, we connectj to a facility in Nj if some such facility is open (and hence part of Tour`).

A2. Return the concatenation of the tours Tour` for ` = 0, 1, . . . ,N shortcutting whenever possible. This induces anordering of the open facilities. If some client is left unconnected, we say that the algorithm has failed.

Analysis. The algorithm may fail in steps A.1.3 and A2. Lemmas 2.4 and 2.5 bound the failure probabilityin each case by 1/ poly(m). To bound the expected cost conditioned on success, it suffices to bound theexpectation of the random variable that equals the cost incurred if the algorithm succeeds, and is 0 otherwise.

6

Since each client j is connected to a facility in Nj , the total connection cost is at most 4∑

j C∗j . To

bound the remaining components of the cost, we first show that in any phase `, the z-assignment definedabove “covers” each group in N ′

jj∈D`to an extent of at least 2

3 (Claim 2.3). Next, we show in Lemma 2.4that for every client j ∈ D`, the probability that a facility in Nj is included in the tree T ′

` , and hence openedin phase `, is at least 5

6 ·23 = 5

9 . The facility-cost incurred in a phase is O(log n)∑

i,t fiyi,t, and sinceτmax ≤ T = poly(m), the number of phases is O(log m), so this bounds the facility-opening cost incurred.Also, since the probability that j is not connected (to a facility in Nj) in phase ` decreases geometrically(at a rate less than 1/2) with ` when t` ≥ τj , one can argue that (a) with very high probability (i.e.,1− 1/ poly(m)), each client j is connected to some facility in Nj , and (b) the expected latency-cost of j isat most O(log n)

∑e∈E(T`)

dT`(e)ze = O(log2 n)τj .

Claim 2.3 Consider any phase `. For any subset S of nodes of the corresponding tree T ′` with r /∈ S, andany N ′

j ⊆ S where j ∈ D`, we have z(δ(S)) ≥∑

i∈Nj ,t≤t`xij,t ≥ 2/3 (where δ(S) denotes δT ′

`(S)).

Proof : Let R = S ∩ V (T`), and Y ⊆ F be the set of leaves in R. Then δ(S) = δT`(R) ∪

(δ(S) ∩ E′).

Let δE(Y ) = (i, i′) ∈ E : |i, i′| ∩ Y | = 1. Observe that z(δT`(R)) ≥

∑e∈δE(Y ) ze,t` . This is simply

because if we send zii′,t` flow along the unique (i, i′) path in T` for every (i, i′) ∈ δE(Y ), then we obtaina flow between Y and F ∪ r \ Y respecting the capacities zee∈E(T`), and of value equal to the RHSabove. Thus, the inequality follows because the capacity of any cut containing Y must be at least the valueof the flow. Since (x, y, z) satisfies (3), we further have that

∑e∈δE(Y ) ze,t` ≥

∑i∈Y,t≤t`

xij,t. So

z(δ(S)) ≥∑

e∈δT`(R)

ze,t` +∑

(i,vi)∈δ(S):i/∈Y

(∑t≤t`

yi,t

)≥

∑i∈Y,t≤t`

xij,t +∑

i∈Nj\Y,t≤t`

xij,t ≥∑

i∈Nj ,t≤t`

xij,t ≥23.

Lemma 2.4 In any phase `, with probability 1 − 1/ poly(m), we obtain the desired tree T ′` in step A1.3.

Moreover, Pr[T ′` ∩N ′

j 6= ∅] ≥ 5/9 for all j ∈ D`.

Proof : Consider any tree T ′′r obtained by executing the GKR algorithm 192 log2 n times and taking the

union of the resulting subtrees. For brevity, we denote∑

(i,vi)∈E(T ′′r ) fi by F (T ′′

r ), and∑

e∈E(T ′′r )\E′ dT`

(e)by d`(T ′′

r ).For j ∈ D`, let Er

j denote the event that T ′′r ∩ N ′

j is non-empty. By Theorem 2.2, we have Pr[Erj ] ≥

1 − exp(− νj

64 log2 n · 192 log n)≥ 1 − e−3νj ≥ (1 − e−3)νj ≥ 11/18. We also have that E

[F (T ′′

r )]≤

192 log2 n∑

(i,vi)∈E′ fizi,vi and E[d`(T ′′

r )]≤ 192 log2 n

∑e∈E(T`)

dT`(e)ze. Let Fr and Dr denote respec-

tively the events that F (T ′′r ) ≤ 40·192 log2 n

∑(i,vi)∈E′ fizi,vi , and d`(T ′′

r ) ≤ 40·192 log2 n∑

e∈E(T`)dT`

(e)ze.By Markov’s inequality each event happens with probability at least 39/40. Thus, for any j ∈ D`, we getthat

Pr[Erj |(Fr ∧Dr)] ≥ Pr[Er

j ∧ Fr ∧Dr] ≥ 1− (7/18 + 1/40 + 1/40) > 5/9. (4)

Now the probability that (Fr ∧Dr)c happens for all r = 1, . . . , N is at most (2/40)N ≤ 1/m4. Hence,with high probability, there is some tree T ′

` := Tr such that both Fr and Dr hold, and (4) shows thatPr[T ′

` ∩N ′j 6= ∅] ≥ 5/9 for all j ∈ D`.

Lemma 2.5 The probability that a client j is not connected by the algorithm is at most 1/m4. Let Lj bethe random variable equal to j’s latency-cost if the algorithm succeeds and 0 otherwise. Then E

[Lj

]=

O(log2 n)t`j, where `j (= dlog2 τje) is the smallest ` such that t` ≥ τj .

7

Proof : Let Pj be the random variable denoting the phase in which j gets connected; let Pj := N + 1 ifj remains unconnected. We have Pr[Pj ≥ `] ≤

(49

)(`−`j) for ` ≥ `j The algorithm proceeds for at least4 log2 m phases after phase `j , so Pr[j is not connected after N phases] ≤ 1/m4. Now,

Lj ≤∑`≤Pj

d(Tour`) ≤ 2∑`≤Pj

∑e∈E(T ′

`)\E′

dT`(e) = O(log n)

∑`≤Pj

∑e∈E(T`)

dT`(e)ze = O(log2 n)

∑`≤Pj

t`

so E[Lj

]= O(log2 n)

N∑`=0

Pr[Pj ≥ `] · t` ≤ O(log2 n)[ `j∑

`=0

t` +∑`>`j

t` ·(

49

)(`−`j)]= O(log2 n)t`j

.

Theorem 2.6 Algorithm 1 succeeds with probability 1−1/ poly(m), and returns a solution of expected costO

(log n ·maxlog n, log m

)·OPT .

Proof : Lemmas 2.4 and 2.5 show that the failure probability is 1/ poly(m). Let Y denote the cost incurredif the algorithm succeeds, and 0 otherwise. Since t`j

≤ 2τj = O(L∗j ) for each j, we have E

[Y

]=

O(log n ·maxlog n, log m

)·OPT by Lemma 2.5 and the preceding arguments.

Removing the assumption T = poly(m). We first argue that although (P) has a pseudopolynomialnumber of variables, one can compute a near-optimal solution to it in polynomial time (Lemma 2.7) by con-sidering only (integer) time-values that are powers of (1 + ε) (rouhgly speaking). Given ε > 0, define Tr =d(1 + ε)re, and let TS := T0,T1, . . . ,Tkwhere k is the smallest integer such that Tk ≥ minn, mdmax.Define T−1 = 0. Let (P)TS denote (P) when t ranges over TS.

Lemma 2.7 For any ε > 0, we can obtain a solution to (P) of cost at most (1+ε)OPT in time poly(input size, 1/ε).

Proof : We prove that the optimal value of (P)TS is at most (1 + ε)OPT . Since the size of (P)TS ispoly(input size, 1/ε) this proves the lemma.

We transform (x, y, z), an optimal solution to (P) to a feasible solution (x′, y′, z′) to (P)TS of cost atmost (1+ε)OPT . (In fact, the facility-opening and connection-costs remain unchanged, and the latency-costblows up by a (1+ε)-factor.) z′ is simply a restriction of z to the times in TS, that is, z′e,t = ze,t for each e, t ∈TS. Set x′ij,1 = xij,1, y′i,1 = yi,1 for all i and j. For each ` = 1, . . . , k, facility i, client j, we set x′ij,T`

=∑T`t=T`−1+1 xij,t and y′i,T`

=∑T`

t=T`−1+1 yi,t. It is clear that∑

t∈TS x′ij,t =∑

t xij,t and∑

t∈TS y′i,t =∑t yi,t for all i and j, and moreover for any T` ∈ TS, we have

∑t∈TS:t≤T`

x′ij,t =∑

t≤T`xij,t. It fol-

lows that (x′, y′, z′) is a feasible solution to (P)TS and∑

i,t∈TS fiy′i,t =

∑i,t fiyi,t,

∑j,i,t∈TS cijx

′ij,t =∑

j,i,t cijxij,t. To bound the latency cost, note that for any t > T`−1, we have T` ≤ (1 + ε)t, sofor any client j and facility i,

∑t∈TS tx′ij,t ≤ xij,1 + (1 + ε)

∑t>1 txij,t ≤ (1 + ε)

∑t txij,t. Thus,∑

j,i,t∈TS tx′ij,t ≤ (1 + ε)∑

j,i,t txij,t.

Let (x′, y′, z′) denote an optimal solution to (P)TS. The only changes to Algorithm 1 are in the definitionof the time t` and the number of phases N . (Of course we now work with (x′, y′, z′), and C∗

j , L∗j are

defined in terms of (x′, y′, z′) now.) The idea is to define t` so that one can “reach” the τj of every client jin O(log m) phases; thus, one can terminate in O(log m) phases and thereby obtain the same approximationon the facility-opening cost. Let L = (

∑j L∗

j )/m = (∑

j,i,t∈TS tx′ij,t)/m. For x ≤ Tk, define TS(x) to bethe earliest time in TS that is at least x; if x ≥ Tk, define TS(x) := Tk. Note that TS(x) ≤ (1 + ε)x for allx ≥ 0. We now define t` = TS(L ·2`), and set the number of phases toN :=

⌈log2(2τmax/L) + 4 log2 m

⌉.

Note that since τj = O(L∗j ), we have N = O(log m).

Theorem 2.8 For any ε > 0, Algorithm 1 with the above modifications succeeds with high probability andreturns a solution of expected cost O

(log n maxlog n, log m

)(1 + ε)OPT .

8

Proof : The analysis of the facility-opening and connection-cost is exactly as before (sinceN = O(log m)).Define `j as the smallest ` such that t` ≥ τj . Note that `j ≤

⌊log2(2τj/L)

⌋(this holds even when τj ≤

L). Hence, the probability that j is not connected after N phases is at most 1/m4. So as before, thefailure probability is at most 1/ poly(m). We have

∑`≤`j

t` ≤ (1 + ε)L∑

`≤`j2` ≤ 2(1 + ε)t`j

, and∑`>`j

t`(

49

)(`−`j) = O(t`j). Thus, the inequalities involving Lj and E

[Lj

]in Lemma 2.5 are still valid,

and we obtain the same bound on E[Lj

]as in Lemma 2.5. Note that t`j

≤ 2(1 + ε)τj = O(L∗j ) when

τj ≥ L. Thus,∑

j E[Lj

]≤ O(log2 n)

[m · L +

∑j:τj>t0

O(L∗j )

]= O(log2 n)L∗.

Inappproximability of MLUFL. We argue that any improvement in the guarantee obtained in Theorem 2.6would yield an improvement in the approximation factor for GST. We reduce GST to MGL, the special caseof MLUFL mentioned in Section 1, where we have groups Gj ⊆ F and the goal is to order the the facilitiesso as to minimize the sum of the covering times of the groups. (Note that Theorem 2.6 implies an O(log2 n)-approximation for MGL.) Recall that we may assume that the groups in MGL are disjoint, in which case theconnection costs form a metric.

Theorem 2.9 Given a ρn,m-approximation algorithm for MGL with (at most) n nodes and m groups, wecan obtain an O(ρn,m log m)-approximation algorithm for GST with n nodes and m groups. Thus, thepolylogarithmic inapproximability of GST [22] implies that MGL, and hence MLUFL even with metric con-nection costs, cannot be approximated to a factor better than Ω(log m), even when the time-metric arisesfrom a hierarchically well-separated tree, unless NP ⊆ ZTIME (npolylog(n)).

Our proof of the above theorem is LP-based and is deferred to Appendix A. Gupta et al. [21] indepen-dently arrived at the above theorem via a combinatorial proof.

2.2 MLUFL with related metrics

Here, we consider the MLUFL problem when the facilities, clients, and the root r are located in a commonmetric space that defines the connection-cost metric (on F ∪ D ∪ r), and we have duv = cuv/M for allu, v ∈ F∪D∪r. We call this problem, related MLUFL, and design an O(1)-approximation algorithm for it.

The algorithm follows a similar outline as Algorithm 1. As before, we build the tour on the openfacilities by concatenating tours obtained by “Eulerifying” trees rooted at r of geometrically increasinglength. At a high level, the improvement in the approximation arises because one can now obtain thesetrees without resorting to Theorems 2.1 and 2.2 and losing O(log n)-factors in process. Instead, sincethe d- and c- metrics are related, we can obtain a group Steiner tree on the relevant groups by using aSteiner tree algorithm (in a manner similar to the LP-rounding algorithms in [27, 20]). We now defineNj = i :

∑t xij,t > 0, cij ≤ 3C∗

j , and τj = 6L∗j . Ideally, in each phase `, we want to connect the Nj

groups for all j such that τj ≤ t` := 2`. But to obtain a low-cost solution, we do a facility-location-styleclustering of the set of clients with τj ≤ t` and build a tree T` that connects the Njs of only the clustercenters: we contract these Njs and build an MST (in the d-metric) on them, and then connect each Nj

internally (in the d-metric) using intracluster edges incident on j. Here we crucially exploit the fact that thed- and c-metrics are related.

Deciding which facilities to open is tricky because groups Nj and Nk created in different phases couldoverlap, and we could have C∗

j C∗k but τj τk; so if we open i ∈ Nj and use this to also serve k, then

we must connect i to some T` (without increasing its d-cost by much) where t` = O(τk). We consider thecollection C of cluster centers created in all the phases, and pick a maximal subset C′ ⊆ C that yields disjointclusters by greedily considering clusters in increasing C∗

j order. We open the cheapest facility in Nj for allj ∈ C′, and attach it to the tree T`, where ` is the earliest phase such that there is some cluster Nk created

9

in that phase that was removed (from C) when Nj was included in C′ (because Nk ∩Nj 6= ∅). Since d andc are related, one can bound the resulting increase in the d-cost of T`. Finally, we convert these augmentedT`-trees to tours and concatenate these tours.

We now describe the algorithm in detail. We have not sought to optimize the approximation ratio. Whenwe refer to an edge or a node below, we mean an edge or node of the complete graph on F ∪D∪r. Recallthat Nj = i :

∑t xij,t > 0, cij ≤ 3C∗

j , and τj = 6L∗j . So

∑i∈Nj

∑t xij,t ≥ 2

3 , and∑

i∈Nj ,t≤τjxij,t ≥

12 .

R1. For each time t` = 2`, where ` = 0, 1, . . . , dlog Te, we do the following. Define D` = j : τj ≤t` \

(⋃0≤`′<` C`′

)(where the union of an empty collection is ∅).

• (Clustering) We cluster the facilities in⋃

j∈D`Nj as follows. We pick j ∈ D` with smallest C∗

j valueand form a cluster around j consisting of the facilities in Nj . For every client k ∈ D` (including j)such that cjk ≤ 30C∗

k (note that C∗k ≥ C∗

j ), we remove k from D`, set σ(k) = j, and recurse onthe remaining clients in D` until no client is left in D`. Let C` denote the set of cluster centers (i.e.,j ∈ D` : σ(j) = j). Note that for two clients j and j′ in C`, Nj ∩Nj′ is ∅.

• (Building a group Steiner tree T` on Njj∈C`) We contract the clusters Nj for j ∈ C` into supern-

odes, and build a minimum spanning tree (MST) T ′′` connecting r and these supernodes. Next, weuncontract the supernodes, and for each j ∈ C`, we add edges joining j to every facility i ∈ Nj thathas an edge incident to it in T ′′` . This yields the tree T`.

R2. (Opening facilities) Let C =⋃

` C`. (Note that a client appears in at most one of the C` sets.) Wecannot open a facility in every cluster centered around a client in C, since for j ∈ C` and k ∈ C`′ , Nj

and Nk need not be disjoint. So we select a subset C′ ⊆ C such that for any two j, k in C′, the sets Nj

and Nk are disjoint. This is done as follows. We initialize C′ ← ∅. Pick the client j ∈ C with smallestC∗

j value and add it to C′. We delete from C every client k ∈ C (including j) such that Nk ∩Nj 6= ∅,setting nbr(k) = j, and recurse on the remaining set of clients until no client is left in C.

Consider each j ∈ C′. We open the facility i ∈ Nj with smallest fi. Let ` be the smallest index suchthat there is some k ∈ C` with nbr(k) = j. We connect i to T` by adding the facility edge (i, k) to it.Let T ′` denote T` augmented by all such facility edges.

R3. We obtain a tour connecting all the open facilities, by converting each tree T ′` into a tour, and concate-nating the tours for ` = 0, . . . , dTe (in that order).

R4. For every client j ∈ C, we assign j to the facility opened from Nnbr(j). For every client j /∈ C, weassign j to the same facility as σ(j).

Theorem 2.10 For related MLUFL, one can round (x, y, z) to get a solution with facility-opening cost atmost 3

2

∑i,t fiyi,t, where each client j incurs connection-cost at most 39C∗

j and latency-cost at most 64τj =384L∗

j . Thus, we obtain an O(1)-approximation algorithm for related MLUFL.

Proof : The clusters Nj for clients j ∈ C′ are disjoint; each such cluster has facility weight∑

i∈Nj

∑t yi,t ≥

23 , and we open the cheapest facility in the cluster.

Consider a client j, and let it be assigned to facility i. If j ∈ C′, then i ∈ Nj , and we have cij ≤ 3C∗j .

If j ∈ C \ C′ with nbr(j) = k, then i ∈ Nk and there is some facility i′ ∈ Nj ∩ Nk. So cij ≤ cik +ci′k + ci′j ≤ 2 · 3C∗

k + 3C∗j ≤ 9C∗

j . Finally, if j /∈ C and j′ = σ(j), then σ(j′) is also assigned to i, socij ≤ cij′ + cjj′ ≤ 9C∗

j′ + 30C∗j ≤ 39C∗

j .We next bound d(T`) and d(T ′` ) for any phase `. For any client j ∈ D` and any node-set S ⊇ Nj , r /∈ S,

we have∑

e∈δ(S) ze,t` ≥∑

i∈S,t≤t`xij,t ≥

∑i∈Nj ,t≤τj

xij,t ≥ 12 . Therefore, (2ze,t`) forms a fractional

10

Steiner tree of cost at most 2t` on the supernodes and r, and hence, d(T ′′` ) ≤ 4t` since it is well known thatthe cost of an MST is at most twice the cost of a fractional solution to the Steiner-tree LP. For j ∈ C`, letdegj denote the degree of the cluster Nj in T ′′` . Observe that if e is an edge of T ′′` joining Nj and Nk (soj, k ∈ C`), then ce ≥ 24 maxC∗

j , C∗k, since 30 maxC∗

j , C∗k ≤ cjk ≤ 3C∗

j + ce + 3C∗k . So the (d-) cost

of adding the additional edges to T ′′` is at most 1M ·

∑j∈C`

degj ·3C∗j ≤ d(T ′′` )/4, and hence, d(T`) ≤ 5t`.

Now consider the cost of adding facility edges to T` in step R2. For each facility edge (i, k) added, weknow that i ∈ Nnbr(k), k ∈ C`, and k is assigned to i. So we have cik ≤ 9C∗

k . Observe that each clientk ∈ C` is responsible for at most one such facility edge. So the d-cost of these facility edges is at most1M ·

∑j∈C`

9C∗j ≤ 1

M

∑j∈C`

degj ·9C∗j ≤ 3

4 · d(T ′′` ). Thus, d(T ′` ) ≤ d(T`) + 34 · d(T ′′` ) ≤ 8t`.

Finally, we prove that the latency cost of any client j is at most 64τj = 384L∗j . Let j be assigned

to facility i. Let ` be the smallest index such that j ∈ D`, so t` ≤ 2τj . We first argue that if i is partof the tree T ′`′ , then `′ ≤ `. If j ∈ C, this follows since we know that i ∈ Nnbr(j) and `′ = minr :∃k ∈ Cr with nbr(k) = nbr(j). If j /∈ C, then we know that σ(j) ∈ C` is also assigned to i, andso by the preceding argument, we again have that `′ ≤ `. Thus, the latency-cost of j is bounded by∑`′

r=0 2d(T ′r ) ≤ 16∑`′

r=0 tr ≤ 32t`′ ≤ 64τj .

2.3 MLUFL with a uniform time-metric

We now consider the special case of MLUFL, referred to as uniform MLUFL, where the time-metric d isuniform, that is, dii′ = 1 for all i, i′ ∈ F ∪ r. When the connection costs form a metric, we call it themetric uniform MLUFL. We consider the following simpler LP-relaxation of the problem, where the time tnow ranges from 1 to n.

min∑i,t

fiyi,t +∑j,i,t

(cij + t)xij,t subject to (Unif-P)

∑i,t

xij,t ≥ 1 ∀j; xij,t ≤ yi,t ∀i, j, t;∑

i

yi,t ≤ 1 ∀t; xij,t, yi,t ≥ 0 ∀i, j, t.

Let (x, y) be an optimal solution to (Unif-P), and OPT be its value. Let C∗j =

∑i,t cijxij,t, L∗

j =∑i,t txij,t. As stated in the introduction, uniform MLUFL generalizes: (i) set cover, when the facility and

connection costs are arbitrary; (ii) MSSC, when the facility costs are zero (ZFC MLUFL); and (iii) metricUFL, when the connection costs form a metric. We obtain approximation bounds for uniform MLUFL, ZFCMLUFL, and metric MLUFL (Theorems 2.11 and 2.14) that complement these observations.

The main result of this section is Theorem 2.12, which shows that a ρUFL-approximation algorithm forUFL and a γ-approximation algorithm for ZFC MLUFL (with metric connection costs) can be combined toyield a (ρUFL + 2γ)-approximation algorithm for metric uniform MLUFL. Taking ρUFL = 1.5 [8] and γ = 9(part (ii) of Theorem 2.11), we obtain a 19.5-approximation algorithm. We improve this to 10.773 by usinga more refined version of Theorem 2.12, which capitalizes on the asymmetric approximation bounds thatone can obtain for different portions of the total cost in UFL and ZFC MLUFL.

We note that by considering each (i, t) as a facility, since the connection costs cij + t form a metric, onecan view metric MLUFL as a variant of metric UFL, and use the ideas in [3] to devise an O(1)-approximationfor this variant. We instead present our alternate algorithm based on the reduction in Theorem 2.12, becausethis reduction is quite robust and versatile. In particular, it allows us to: (a) handle certain extensions ofthe problem, e.g., the setting where we have non-uniform latency costs (see Section 4), for which the abovereduction fails since we do not necessarily obtain metric connection costs, and (b) devise algorithms for theuniform latency versions of other facility location problems, where the cost of a facility does not dependon the client-set assigned to it (so one can assign a client to any open facility freely without affecting thefacility costs). For instance, consider uniform MLUFL with the restriction that at most k facilities may be

11

opened: our technique yields a (ρkMed + 2γ) approximation for this problem, using a ρkMed-approximationfor k-median.

Theorem 2.11 One can obtain:(i) an O(lnm)-approximation algorithm for uniform MLUFL with arbitrary facility- and connection- costs.(ii) a solution of cost at most 1

1−α

∑j C∗

j + 4α

⌈1α

⌉ ∑j L∗

j for ZFC MLUFL, for any parameter α ∈ (0, 1).Thus, setting α = 8

9 , yields solution of cost at most 9 ·OPT .

We defer the proof of Theorem 2.11 to the end of the section, and focus first on detailing the aforemen-tioned reduction.

Theorem 2.12 Given a ρUFL-approximation algorithm A1 for UFL, and a γ-approximation algorithm A2

for uniform ZFC MLUFL, one can obtain a (ρUFL+2γ)-approximation algorithm for metric uniform MLUFL.

Proof : Let I denote the metric uniform MLUFL instance, and O∗ denote the cost of an optimal integersolution. Let IUFL be the UFL instance obtained form I by ignoring the latency costs, and IZFC be the ZFCMLUFL instance obtained from I by setting all facility costs to zero. Let O∗

UFL and O∗ZFC denote respectively

the cost of the optimal (integer) solutions to these two instances. Clearly, we have O∗UFL, O

∗ZFC ≤ O∗. We

use A1 to obtain a near-optimal solution to IUFL: let F1 be the set of facilities opened and let σ1(j) denotethe facility in F1 to which client j is assigned. So we have

∑i∈F1

fi+∑

j cσ1(j)j ≤ ρUFL ·O∗UFL. We useA2

to obtain a near-optimal solution to IZFC: let F2 be the set of open facilities, σ2(j) be the facility to whichclient j is assigned, and π(i) be the position of facility i. So we have

∑j

(cσ2(j)j + π(σ2(j))

)≤ γ ·O∗

ZFC.We now combine these solutions as follows. For each facility i ∈ F2, let µ(i) ∈ F1 denote the facility

in F1 that is nearest to i. We open the set F = µ(i) : i ∈ F2 of facilities. The position of facilityi ∈ F is set to mini′∈F2:π(i′)=i π(i′). Each facility in F is assigned a distinct position this way, but somepositions may be vacant. Clearly we can always convert the above into a proper ordering of F where eachfacility i ∈ F occurs at position κ(i) ≤ mini′∈F2:π(i′)=i π(i′). Finally, we assign each client j to thefacility φ(j) = µ(σ2(j)) ∈ F . Note that κ(φ(j)) ≤ π(σ2(j)) (by definition). For a client j, we now havecφ(j)j ≤ cσ2(j)µ(σ2(j)) + cσ2(j)j ≤ cσ2(j)σ1(j) + cσ2(j)j ≤ cσ1(j)j + 2cσ2(j)j . Thus, the total cost of theresulting solution is at most

∑i∈F1

fi +∑

j

(cσ1(j)j + 2cσ2(j)j + π(σ2(j))

)≤ (ρUFL + 2γ) ·O∗.

We call an algorithm a (ρf , ρc)-approximation algorithm for UFL if given an LP-solution to UFL withfacility- and connection- costs F ∗ and C∗ respectively, it returns a solution of cost at most ρfF ∗ + ρcC

∗.Similarly, we say that an algorithm is a (γc, γl)-approximation algorithm for uniform ZFC MLUFL if givena solution to (P) with connection- and latency- costs C∗ and L∗ respectively, it returns a solution of cost atmost γcC

∗ + γlL∗. The proof of Theorem 2.12 easily yields the following more general result.

Corollary 2.13 One can combine a (ρf , ρc)-approximation algorithm for UFL, and a (γc, γl)-approximationalgorithm for uniform ZFC MLUFL, to obtain a solution of cost at most maxρf , ρc + 2γc, γl ·OPT .

Proof : The proof mimics the proof of Theorem 2.12. The only new observation is that (x, y) yields anLP-solution to (i) IUFL with facility cost

∑i,t fiyi,t and connection cost

∑j,i,t cijxij,t; and (ii) IZFC with

connection cost∑

j,i,t cijxij,t and latency cost∑

j,i,t txij,t. Thus, applying the construction in the proof ofTheorem 2.12 yields a solution of total cost at most

ρf

∑i,t

fiyi,t + (ρc + 2γc)∑j,i,t

cijxij,t + γl

∑j,i,t

txij,t ≤ maxρf , ρc + 2γc, γl ·OPT .

Combining the( ln(1/β)

1−β , 31−β

)-approximation algorithm for UFL [29] with the

(1

1−α , 4α

⌈1α

⌉)-approximation

algorithm for ZFC MLUFL (part (ii) of Theorem 2.11) gives the following result.

12

Theorem 2.14 For any α, β ∈ (0, 1), one can obtain a solution of cost max ln(1/β)

1−β , 31−β + 2

1−α , 4α

⌈1α

⌉·

OPT . Thus, taking α = 0.7426, β = 0.000021, we obtain a 10.773-approximation algorithm.

2.3.1 Proof of Theorem 2.11

The following lemma will often come in handy.

Lemma 2.15 Let (x, y) be a solution satisfying∑

i yi,t ≤ k for every time t, where k ≥ 0 is an integer, andall the other constraints of (Unif-P). Then, one can obtain a feasible solution (x′, y′) to (Unif-P) such that(i)

∑i,t fiy

′i,t =

∑i,t fiyi,t; (ii)

∑j,i,t cijx

′ij,t =

∑j,i,t cij xij,t; and (iii)

∑j,i,t tx′ij,t ≤ k ·

∑j,i,t txij,t.

Proof : For each time t, define St = (i, t) : yi,t > 0. The idea is to simply “spread out” the St sets. LetS0 =

⋃t St be an ordered list where all the (·, t) pairs are listed before any (·, t + 1) pair, and the pairs for

a given t (i.e., (i, t) ∈ St) are listed in arbitrary order. Let T0 =⌈∑

i,t yi,t

⌉. We divide the pairs in S0 into

T0 groups as follows. Initialize ` ← 1, S ← S0. For a set A of (i, t) pairs, we define the y-weight of A asy(A) =

∑(i,t)∈A yi,t, and the xj-weight of A as

∑(i,t)∈A xij,t. If 0 < y(S) ≤ 1, then we set G` = S to

end the grouping process. Otherwise, group G` includes all pairs of S, taken in order starting from the firstpair, stopping when the total y-weight of the included pairs becomes at least 1; all the included pairs are alsodeleted from S. If the y-weight of G` now exceeds 1, then we split the last pair (i, t) into two copies: weinclude the first copy in G` and retain the second copy in S, and distribute yi,t across the y-weight of the twocopies so that y(G`) is now exactly 1. (Thus, the new y-weight of S is precisely its old y-weight −1.) Also,for each client j, we distribute xij,t across the xj-weight of the two copies arbitrarily while maintaining thatthe xj-weight of each copy is at most its y-weight. We update `← ` + 1, and continue in this fashion withthe current (i.e., ungrouped) list of pairs S. Note that an (i, t) pair in S0 may be split into at most two copiesabove (that lie in consecutive groups). To avoid notational clutter, we call both these copies (i, t) and usey`

i,t to denote the y-weight of the copy in group G` (which is equal to the original yi,t if (i, t) is not split).Analogously, we use x`

ij,t to denote the xj-weight of the copy of (i, t) in group G`.For every facility i, client j, and ` = 1, . . . , T0, we set y′i,` =

∑t:(i,t)∈G`

y`i,t and x′ij,` =

∑t:(i,t)∈G`

x`ij,t,

so we have x′ij,` ≤ y′i,`. It is clear that∑

` y′i,` =∑

t yi,t and∑

` x′ij,` =∑

t xij,t for every facility i andclient j. Thus, (x′, y′) is feasible to (Unif-P), and parts (i) and (ii) of the lemma hold. To prove part (iii),note that if (some copy of) (i, t) is in G`, then ` ≤ kt, since then we have

(⋃`−1r=1 Gr

)⊂

⋃tt′=1 St′ and so

`− 1 < kt. Thus, for any client j, we have∑i,`

`x′ij,` =∑i,`

`( ∑t:(i,t)∈G`

x`ij,t

)=

∑i,t

∑`:(i,t)∈G`

`x`ij,t ≤

∑i,t

kt∑

`:(i,t)∈G`

x`ij,t = k ·

∑i,t

txij,t.

Proof of part (i) of Theorem 2.11 : We round the LP-optimal solution (x, y) by using filtering followed bystandard randomized rounding. Clearly, we may assume that

∑i′,t xi′j,t = 1 and yi,t = maxj xij,t for every

i, j, t. Also, we may assume that if∑

i yi,t+1 > 0, then∑

i yi,t = 1, because otherwise for some facility iand some ε > 0, we may decrease yi,t+1 by ε and increase yi,t by ε, and modify the xij,t+1, xij,tj valuesappropriately so as to maintain feasibility, without increasing the total cost. Define Nj = (i, t) : cij + t ≤2(C∗

j + L∗j ) for a client j. The algorithm is as follows.

U1. For each (i, t), we set Yi,t = 1 independently with probability min4 ln m · yi,t, 1.

U2. Considering each client j, if (i, t) ∈ Nj : Yi,t = 1 = ∅, then set Yij ,1 = 1 where ij is such thatfij = min(i,t)∈Nj

fi (note that (ij , 1) ∈ Nj). Let Sj = (i, t) ∈ Nj : Yi,t = 1 (which is non-empty).Assign each client j to the (i, t) pair in Sj with minimum cij + t value, i.e., set Xij,t = 1.

13

U3. Let K = maxt∑

i Yi,t. Use Lemma 2.15 to convert (X, Y ) into a feasible integer solution to (Unif-P).

Let Cj and Lj denote respectively the connection cost and latency cost of client j in (X, Y ). We arguethat (i) E

[∑i,t fiYi,t

]= O(lnm) ·

∑i,t fiyi,t, (ii) with probability 1, Cj + Lj ≤ 2(C∗

j + L∗j ) for every

client j, and (iii) K = O(lnm) with high probability, and in expectation. The theorem then follows fromLemma 2.15.

For any client j, we have∑

(i,t)∈Njxij,t ≥ 1

2 (by Markov’s inequality). Thus, fij ≤ 2∑

(i,t)∈Njfiyi,t

and Pr[∑

(i,t)∈NjYi,t = 0] is at most e−4 ln m· 1

2 = 1/m2. The expected cost of opening facilities instep U1 is clearly at most 4 ln m ·

∑i,t fiyi,t. The expected facility-opening cost in step U2 is at most

Pr[facility is opened in step U2]·∑

j fij ≤ m· 1m2 ·2m

∑i,t fiyi,t. So E

[∑i,t fiYi,t

]= O(lnm)·

∑i,t fiyi,t.

Since we always open some (i, t) pair in Nj , we have Cj + Lj ≤ 2(C∗j + L∗

j ) for every client j.Let S = t :

∑i yi,t > 0. Note that |S| ≤ 1 +

∑i,t yi,t ≤ 1 +

∑j,i,t xij,t = m + 1. After step U1,

we have E[∑

i Yi,t

]≤ 4 ln m for every time t ∈ S. Since the Yi,t random variables are independent, we

also have Pr[∑

i Yi,t > 8 ln m] ≤ 1/m2 for all t ∈ S (and also, E[maxt∈S

∑i Yi,t

]= O(lnm)). Thus,

after step U2, we have Pr[∑

i Yi,1 > 8 ln m] ≤ 1/m2 + 1/m and Pr[∑

i Yi,t > 8 ln m] ≤ 1/m2 for allt ∈ S, t > 1. Hence, Pr[K > 8 ln m] ≤ 2/m. (This also shows that E

[K

]= O(lnm).)

Proof of part (ii) of Theorem 2.11 : We round (x, y) by applying filtering [23] followed by Lemma 2.15 toreduce the problem to a MSSC problem, and then use the result of Feige et al. [16] to obtain a near-optimalsolution to this MSSC problem. Let

min∑j,t

txj,t s.t.∑

t

xj,t ≥ 1 ∀j, xj,t ≤∑

S:j∈S

yS,t ∀j, t,∑S

yS,t ≤ 1 ∀t, x, y ≥ 0. (P1)

denote the standard LP-relaxation of MSSC [16] (here j indexes the elements, S indexes the sets, and tindexes time). Feige et al. showed that given a solution (x, y) to (P1), one can obtain in polytime an integersolution of cost at most 4 ·

∑j,t txj,t.

The rounding algorithm for ZFC MLUFL is as follows. Define Nj = i : cij ≤ C∗j /(1 − α), so∑

i∈Nj ,t xij,t ≥ α. For all i, j, t, set yi,t = yi,t/α, and xij,t = xij,t/α if i ∈ Nj and xij,t = 0 otherwise.It is easy to see that (x, y) satisfies

∑i yi,t ≤ 1

α for all t, and all the other constraints of (Unif-P). We useLemma 2.15 to convert (x, y) to a feasible solution (x′, y′) to (Unif-P). Next, we extract a solution to (P1)from (x′, y′). We identify facility i with the set j : i ∈ Nj, and set xj,t =

∑i∈Nj

x′ij,t. Now (x, y′) is afeasible solution to (P1). Finally, we round (x, y′) to an integer solution. This yields the ordering y = (yi,t)of the facilities. For each client j, if j is first covered by set i (so i ∈ Nj) at time (or position) t in the MSSCsolution, then we set xij,t = 1.

Analysis. Since a client j is always assigned to a facility in Nj , the connection cost of j is bounded byC∗

j /(1 − α). To bound the latency cost, first we bound the cost of (x, y). Since we modify the assign-ment of a client j by transferring weight from farther facilities to nearer ones, it is clear that

∑i,t cij xij,t ≤∑

i,t cijxij,t. Also, clearly∑

j,i,t txij,t ≤ 1α ·

∑j,i,t txij,t. and

∑i yi,t ≤ 1

α . Thus, applying Lemma 2.15yields (x′, y′) satisfying

∑j,i,t tx′ij,t ≤

⌈1α

⌉1α ·

∑j,i,t txij,t. The result of [16] now implies that∑

j,i,t txij,t ≤ 4∑

j,t txj,t = 4∑

j,i,t tx′ij,t ≤ 4α

⌈1α

⌉ ∑j txij,t.

3 LP-relaxations and algorithms for the minimum-latency problem

In this section, we consider the minimum-latency (ML) problem and apply our techniques to obtain LP-based insights and algorithms for this problem. We give two LP-relaxations for ML with constant integrality

14

gap. The first LP (LP1) is a specialization of (P) to ML, and to bound its integrality gap, we only need thefact that the natural subtour elimination LP for TSP has constant integrality gap. The second LP (LP2P )has exponentially-many variables, one for every path (or tree) of a given length bound, and the separationoracle for the dual problem corresponds to an (path- or tree-) orienteering problem. We prove that even abicriteria approximation for the orienteering problem yields an approximation for ML while losing a constantfactor. (The same relationship also holds between MGL and “group orienteering”.) As mentioned in theIntroduction, we believe that our results shed new light on ML and opens up ML to new venues of attack.Moreover, as shown in Section 4 these LP-based techniques can easily be used to handle more generalvariants of ML, e.g., k-route ML with Lp-norm latency-costs (for which we give the first approximationalgorithm). We believe that our LP-relaxations are in fact (much) better than what we have accounted for,and conjecture that the integrality gap of both (LP1) and (LP2P ) is at most 3.59, which is the currently bestknown approximation factor for ML.

Let G = (D∪r, E) be the complete graph on N = |D|+1 nodes with edge weights de that form ametric. Let r be the root node at which the path visiting the nodes must originate. We use e to index E andj to index the nodes. In both LPs, we have variables xj,t for t ≥ djr to denote if j is visited at time t (wheret ranges from 1 to T); for convenience, we think of xj,t as being defined for all t, with xj,t = 0 if djr > t.(As in Section 2.1, one can move to a polynomial-size LP losing a (1 + ε)-factor.)

A compact LP. As before, we use a variable ze,t to denote if e has been traversed by time t.

min∑j,t

txj,t subject to (LP1)

∑t

xj,t ≥ 1 ∀j;∑

e

deze,t ≤ t ∀t;∑

e∈δ(S)

ze,t ≥∑t′≤t

xj,t′ ∀t, S ⊆ D, j; x, z ≥ 0.

Theorem 3.1 The integrality gap of (LP1) is at most 10.78.

Proof : Let (x, z) be an optimal solution to (LP1), and L∗j =

∑t txj,t. For α ∈ [0, 1], define the α-point

of j, τj(α), to be the smallest t such that∑

t′≤t xjt′ ≥ α. Let Dt(α) = j : τj(α) ≤ t. We round (x, z)as follows. We pick α ∈ (0, 1] according to the density function q(x) = 2x. At each time t, we utilize the32 -integrality-gap of the subtour-elimination LP for TSP and the parsimonious property (see [33, 30, 18, 6]),to round 2z

α and obtain a tour on r ∪Dt(α) of cost Ct(α) ≤ 3α ·

∑e deze,t ≤ 3t

α . We now use Lemma 3.2to combine these tours.

Lemma 3.2 ([19] paraphrased) Let Tour1, . . . ,Tourk be tours containing r, with Touri having cost Ci andcontaining Ni nodes, where N0 := 1 ≤ N1 ≤ . . . ≤ Nk = N . One can find a subset Touri1 , . . . ,Tourib=k

of tours, and a way of concatenating them that gives total latency at most 3.592

∑i Ci(Ni −Ni−1).

The tours we obtain for the different times are nested (as the Dt(α)s are nested). So∑

t≥1 Ct(α)(|Dt(α)|−|Dt−1(α)|) =

∑j

∑t:j∈Dt(α)\Dt−1(α) Ct(α) =

∑j Cτj(α)(α) ≤ 3

∑j

τj(α)α . Thus, using Lemma 3.2, and

taking expectation over α (note that E[ τj(α)

α

]≤ 2L∗

j ), we obtain that the total latency-cost is at most(3.59 · 3)

∑j L∗

j .

Note that in the above proof we did not need any procedure to solve k-MST or its variants, but ratherjust needed the integrality gap for the subtour-elimination LP to be a constant. Also, we can modify therounding procedure to ensure that (latency-cost of j) ≤ 18τj(0.5) for each client j, as follows. (Such aguarantee is useful to bound the total cost when its measured as an Lp norm for p > 1; see Section 4.)We now only consider times t` = 2`. Recall that for any α ∈ (0, 1), at each time t, we can obtain a touron r ∪ Dt(α) of cost Ct(α) ≤ 3t

α . We take this tour for t`, and traverse the resulting tour randomlyclockwise or anticlockwise (this choice can easily be derandomized), and concatenate all these tours. Let

15

`j(α) be the smallest ` such that t` ≥ τj(α). So the (expected) latency-cost of j is at most∑

`<`j(α)3t`α +

12 ·

3t`j(α)

α ≤4.5t`j(α)

α ≤ 9τj(α)α . Fixing α = 0.5, we obtain a 36-approximation with the per-client guarantee

that (latency-cost of j) ≤ 18τj(0.5) for each j.

An exponential-size LP: relating the orienteering and latency problems. Let Pt and Tt denote respec-tively the collection of all (simple) paths and trees rooted at r of length at most t. For each path P ∈ Pt, weintroduce a variable zP,t that indicates if P is the path used to visit the nodes with latency-cost at most t.

min∑j,t

txj,t (LP2P )

s.t.∑

t

xj,t ≥ 1 ∀j∑P∈Pt

zP,t ≤ 1 ∀t (5)

∑P∈Pt:j∈P

zP,t ≥∑t′≤t

xj,t′ ∀j, t (6)

x, z ≥ 0.

max∑

j

αj −∑

t

βt (LD2)

s.t. αj ≤ t +∑t′≥t

θj,t′ ∀j, t (7)

∑j∈P

θj,t ≤ βt ∀t, P ∈ Pt (8)

α, β, θ ≥ 0. (9)

(5) and (6) encode that at most one path may be chosen for any time t, and that every node j visited at timet′ ≤ t must lie on this path. (LD2) is the dual LP with exponentially many constraints. Let (LP2T ) be theanalogue of (LP2P ) with tree variables, where we have variables zQ,t for every Q ∈ Tt, and we replace alloccurrences of zP,t in (LP2P ) with zQ,t.

Separating over the constraints (8) involves solving a (rooted) path-orienteering problem: for every t,given rewards θj,t, we want to determine if there is a path P rooted at r of length at most t that gathersreward more than βt. A (ρ, γ)-path, tree approximation algorithm for the path-orienteering problem is analgorithm that always returns a path, tree rooted at r of length at most γ(length bound) that gathers rewardat least (optimum reward)/ρ. Chekuri et al. [11] give a (2+ε, 1)-path approximation algorithm, whereas [10]design a (1+ε, 1+ε)-tree approximation for orienteering (note that weighted orienteering can be reduced tounweighted orienteering with a (1+ε)-factor loss). We prove that even a (ρ, γ)-tree approximation algorithmfor orienteering can be used to obtain an O(ργ)-approximation for ML. First, we show how to compute anear-optimal LP-solution. Typically, one argues that, scaling the solution computed by the ellipsoid methodrun on the dual with the approximate separation oracle yields a feasible and near-optimal dual solution,and this is then used to obtain a near-optimal primal solution (see, e.g., [24]). However, in our case, wehave negative terms in the dual objective function, which makes our task trickier: if our (unicriteria) ρ-approximate separation oracle determines that (α, β, θ) is feasible, then although (α, ρβ, θ) is feasible to(LD2), one has no guarantee on the value of this dual solution. Instead, the notion of approximation weobtain for the primal solution computed involves bounded violation of the constraints.

Let(LP2(a,b)

P)

be (LP2P ) where we replace Pt by Pbt, and the RHS of (5) is now a. Let(LP2(a,b)

T)

be

defined analogously. Let OPTP be the optimal value of (LP2P ) (i.e.,(LP2(1,1)

P)). Note that OPTP is a

lower bound on the optimum latency.

Lemma 3.3 Given a (ρ, γ)-tree approximation for the orienteering problem, one can compute a feasiblesolution (x, z) to

(LP2(ρ,γ)

T)

of cost at most OPT .

16

Proof : Lemma 3.3 Define

Pfeas(ν; a, b) :=

(α, β, θ) : (7), (9),∑j∈P

θj,t ≤ βt ∀P ∈ Pbt,∑

j

αj − a∑

t

βt ≥ ν

,

Tfeas(ν; a, b) :=

(α, β, θ) : (7), (9),∑j∈Q

θj,t ≤ βt ∀Q ∈ Tbt,∑

j

αj − a∑

t

βt ≥ ν

.

Note that OPTP is the largest value of ν such that Pfeas(ν; 1, 1) is feasible. Given ν, (α, β, θ), if therewas an algorithm to either show (α, β, θ) ∈ Pfeas(ν; 1, 1) or exhibit a separating hyperplane, then usingthe ellipsoid method we could optimally solve for OPTP . However, such a separation oracle would solveorienteering exactly.

We use the (ρ, γ)-tree approximation algorithm to give an approximate separation oracle in the followingsense. Given ν, (α, β, θ), we either show (α, ρβ, θ) ∈ Pfeas(ν; 1, 1), or we exhibit a hyperplane separating(α, β, θ) and Tfeas(ν; ρ, γ). Note that Tfeas(ν; ρ, γ) ⊆ Pfeas(ν; 1, 1). Thus, for a fixed ν, the ellipsoidmethod in polynomial time, either certifies that Tfeas(ν; ρ, γ) is empty or returns a point (α, β, θ) with(α, ρβ, θ) ∈ Pfeas(ν; 1, 1). Let us describe the approximate separation oracle first, and then use the abovefact to prove the lemma. First, check if (

∑j αj − ρβt ≥ ν), (7), and (9) hold, and if not, we use the

appropriate inequality as the separating hyperplane between (α, β, θ) and Tfeas(ν; ρ, γ). Next, for each t,we run the (ρ, γ)-tree approximation on the orienteering problem specified by

(G, de

), root r, rewards

θj,t, and budget t. If for some t, we obtain a tree Q ∈ Tγt with reward greater than βt, then we return∑j∈Q θj,t ≤ βt as the separating hyperplane. If not, then for all paths P of length at most t in G, we have∑j∈P θj,t ≤ ρβt and thus (α, ρβ, θ) ∈ Pfeas(ν; 1, 1).We find the largest ν∗ (via binary search) such that the ellipsoid method run for ν∗ with our separation

oracle returns a solution (α∗, β∗, θ∗) with (α∗, ρβ∗, θ∗) ∈ Pfeas(ν∗; 1, 1); hence, we have ν∗ ≤ OPTP (byduality). Now for ε > 0, the ellipsoid method run for ν∗ + ε terminates in polynomial time certifying theinfeasibility of Tfeas(ν∗+ ε; ρ, γ). That is, it generates a polynomial number of inequalities of the form (7),(9), and (

∑j∈Q θj,t ≤ βt) where Q ∈ Tγt, which together with the inequality

∑j αj − ρ

∑t βt ≥ ν∗ + ε

constitute an infeasible system. Applying Farkas’ lemma, equivalently, we get a polynomial sized solution(x, z) to

(LP2(ρ,γ)

T)

that has cost at most ν∗ + ε. Taking ε small enough (something like 1/ exp(input size)so that ln(1/ε) is still polynomially bounded), this also implies that (x, z) has cost at most ν∗ ≤ OPTP .This completes the proof of the lemma.

Theorem 3.4 (i) A feasible solution (x, z) to(LP2(ρ,γ)

T)

(or the corresponding LP-relaxation for MGL) canbe rounded to obtain a solution of expected cost at most O(ργ) ·

∑j,t txj,t; (ii) A feasible solution (x, z) to(

LP2(ρ,γ)P

)can be rounded to obtain a solution of cost at most (3.59 · 2)ργ

∑j,t txj,t.

Proof : We prove part (i) first. (Note that for ML, the analysis leading to Theorem 3.1 already implies thatone can obtain a solution of cost at most 10.78ργ

∑j,t txj,t, because setting ze,t =

∑Q∈Tγt:e∈Q zQ,t yields

a solution (x, z) that satisfies∑

e deze,t ≤ ργt and all other constraints of (LP1).) We sketch a (randomized)rounding procedure that also works for MGL and yields improved guarantees. We may assume that eachzQ,t ∈ [0, 1]. At each time t` = 2`, ` = dlog2 T + 4 log2 me, we select at most dwt`e trees from Tbt` ,picking each Q ∈ Tγt` with probability zQ,t` . (We can always do this (efficiently) since for every time t,

the polytope z ∈ [0, 1]Tbt :∑

Q zQ,t ≤⌈∑

Q zQ,t

⌉ is integral.) We take the union of all these trees.

Note that expected cost of the resulting subgraph is at most wtγt` ≤ ργt`. We “Eulerify” the resultingsubgraph to obtain a tour for t` of cost at most 2ργt`, and concatenate these tours. The probability thatj is not visited (or covered) by the tour for t` is at most 1 −

∑t≤t`

xj,t, which implies that with high

17

probability, we obtain a tour spanning all nodes. Letting τj = tj(

23

), the expected latency-cost of j is at

most 2ργ(2τj + 2τj

∑k≥0(

23)k

)≤ 16ργτj .

To prove part (ii), we adopt a rounding procedure that again utilizes Lemma 3.2, and yields the statedbound (deterministically). Recall that τj(α) denotes the α-point of j. Let Dt(α) = j : τj(α) ≤ t. Forany α ∈ (0, 1), and time t, we now show to obtain a tour spanning Dt(α) ∪ r of cost at most 2ργt

α . Wecan then proceed as in the rounding procedure for Theorem 3.1 to argue that, for the tours we obtain, thequantity

∑i Ci(Ni − Ni−1) appearing in Lemma 3.2 is bounded by 2ργ

∑j

tj(α)α . Hence, choosing α as

before according to the distribution q(x) = 2x and taking expectations, we obtain a solution with the statedcost.

Let K be such that Kα, KzP,tP∈Pγt are integers. For each P with zP,t > 0, we create KzP,t copiesof each edge on P , and direct the edges away from r. Let AP,t denote the resulting arc-set. Note thatin At :=

⊎P :zP,t>0 AP,t, every node j ∈ D has in-degree at least its out-degree, and there are Kα arc-

disjoint paths from r to j for each j ∈ Dt(α). So applying Theorem 2.6 in Bang-Jensen et al. [4], one canobtain Kα arc-disjoint out-arborescences rooted at r, each containing all nodes of Dt(α). Thus, if we pickthe cheapest such arborescence and “Eulerify” it, we obtain a tour spanning Dt(α) ∪ r of cost at most2 ·Kργt · 1

Kα = 2ργtα .

In Appendix A, we prove an analogue of Lemma 3.3 for MGL. Combined with part (i) of Theorem LP2P ,this shows that (even) a bicriteria approximation for “group orienteering” yields an approximation for MGLwhile losing a constant factor.

4 Extensions

We now consider various well-motivated extensions of MLUFL, and show that our LP-based techniques andalgorithms are quite versatile and extend with minimal effort to yield approximation guarantees for thesemore general MLUFL problems. Our goal here is to emphasize the flexibility afforded by our LP-basedtechniques, and we have not attempted to optimize the approximation factors.

Monotone latency-cost functions with bounded growth, and higher Lp norms. Consider the general-ization of MLUFL, where we have a non-decreasing function λ(.) and the latency-cost of client j is givenby λ(time taken to reach the facility serving j); the goal, as before, is to minimize the sum of the facility-opening, client-connection, and client-latency costs. Say that λ has growth at most p if λ(cx) ≤ cpλ(x)for all x ≥ 0, c ≥ 1. It is not hard to see that for concave λ, we obtain the same performance guaranteesas those obtained in Section 2 (for λ(x) = x). So we focus on the case when λ is convex, and obtain anO

(max(p log2 n)p, p log n log m

)-approximation algorithm for convex latency functions of growth p. As

a corollary, we obtain an O(p log n maxlog n, log m

)-approximation for Lp-MLUFL, where we seek to

minimize the facility-opening cost + client-connection cost + the Lp-norm of client-latencies.

Theorem 4.1 There is an O(max(p log2 n)p, p log n log m

)-approximation algorithm for MLUFL with

convex monotonic latency functions of growth (at most) p.

Proof : We highlight the changes to the algorithm and analysis in Section 2.1. We again assume that T =poly(m) for convenience. This assumption can be dropped by proceeding as in Theorem 2.8; we do afterproving the theorem. The objective of (P) now changes to min

∑i,t fiyi,t+

∑j,i,t

(cij +λ(t)

)xij,t. The only

change to Algorithm 1 is that we now define t` = min2`/p,T and setN :=⌈p log2(21/pτmax) + 4 log2 m

⌉=

O(p log m). Define Lcostj =∑

i,t λ(t)xij,t. Note that we now have λ(τj) ≤ 12Lcostj . Define `j to be thefirst phase ` such that t` ≥ τj . Let the random variable Pj be as defined in Lemma 2.5. The failure probabil-ity of the algorithm is again at most 1/ poly(m). The facility-cost incurred in O(p log n log m)

∑i,t fiyi,t,

18

and the connection cost of client j is at most 4C∗j . We generalize Lemma 2.5 below to show that E

[Lj

]=

O((p log2 n)p

)λ(t`j

) ≤ O((2p log2 n)p

)· λ(τj), which yields the desired approximation. We have

Lj ≤ λ(∑`≤Pj

d(Tour`))≤ λ

(O(log2 n)

∑`≤Pj

t`)≤ O(log2p n)λ

(∑`≤Pj

t`),

so E[Lj

]≤ O(log2p n)

[λ(∑

`≤`jt`

)+

∑k≥1 Pr[Pj ≥ `j + k]λ

(∑`≤`j+k t`

)]. Now, Pr[Pj ≥ `j + k] ≤(

49

)k,∑

`≤`j+k t` ≤ t`j· 2k/p

1−2−1/p , and (21/p − 1) ≥ ln 2p . Plugging these in gives,

E[Lj

]= O(log2p n) · 2

(21/p − 1)p· λ(t`j

) ·∑k≥0

(49

)k2k = O

((p/ ln 2)p log2p n

)λ(t`j

).

Removing the assumption T = poly(m) in Theorem 4.1. As in the case of Theorem 2.8, to drop the as-sumption that T = poly(m), we (a) solve the LP considering only times in TS = T0, . . . ,Tk (where Tr =d(1 + ε)re); and (b) set t` = TS(L·2`/p) and the number of phases toN :=

⌈p log2(21/pτmax/L) + 4 log2 m

⌉,

where L = (∑

j,i,t txij,t)/m. Note thatN = O(p log m), and λ(L) ≤ (∑

j,i,t λ(t)xij,t)/m = (∑

j Lcostj)/m,which shows that the expected latency cost incurred for clients j with τj ≤ t0 is at most

∑j Lcostj .

Corollary 4.2 One can obtain an O(p log n maxlog n, log m

)-approximation algorithm for Lp-MLUFL.

Proof : As is standard, we enumerate all possible values of the Lp-norm of the optimal client latencies inpowers of 2, losing potentially another factor of 2 in the approximation factor. To avoid getting into issuesabout estimating the solution-cost for a given guess (since our algorithms are randomized), we proceed asfollows. For a given guess Lat, we solve (P) modifying the objective to be min

∑i,t fiyi,t +

∑j,i,t cijxij,t,

and we adding the constraint∑

j,i,t tpxij,t ≤ Latp. Among all such guesses and corresponding optimalsolutions, let (x, y, z) be the solution that minimizes

∑i,t fiyi,t +

∑j,i,t cijxij,t + Lat. Let OPT denote

this minimum value. Note that OPT ≤ 2O∗, where O∗ is the optimum value of the Lp-MLUFL instance.We apply Theorem 4.1 (with λ(x) = xp) to round (x, y, z). Let F , C, and L =

∑j Lj , denote respectively

the (random) facility-opening, connection-, and latency- cost of the resulting solution. The bounds in Theo-rem 4.1 imply that E

[(∑

j Lj)1/p]≤

(E

[∑j Lj

])1/p ≤ O(p log2 n)Lat, which combined with the boundson E

[F

]and E

[C

], shows that the expected total cost is O

(p log n maxlog n, log m

)OPT .

We obtain significantly improved guarantees for related MLUFL, metric uniform MLUFL, and ML with(convex) latency functions of growth p. For related MLUFL and ML, the analyses in Sections 2.2 and 3directly yield an O

(2O(p)

)-approximation guarantee since for both problems, we can (deterministically)

bound the delay of client j by O(α-point of j

)(for suitable α). For metric uniform MLUFL, we obtain

an O(1)-approximation bound as a consequence of Theorem 2.12: this follows because one can devisean O(1)-approximation algorithm for the zero-facility-cost version of the problem by adapting the ideasused in [3]. Thus, we obtain an O(1)-approximation for the Lp-versions of related-MLUFL, metric uniformMLUFL, and ML.

k-route MLUFL with length bounds. All our algorithms easily generalize to k-route length-boundedMLUFL, where we are given a budget B and we may use (at most) k paths starting at r of (d-) length atmost B to traverse the open facilities and activate them. This captures the scenario where one can use kvehicles in parallel, each with capacity B, starting at the root depot to activate the open facilities. Observethat with B =∞, we obtain a generalization of the k-traveling repairmen problem considered in [14].

We modify (P) by setting T = B and setting the RHS of (3) to kt. In Algorithm 1, we now obtain atour Tour` in phase ` of (expected length) O(log2 n)kt`. Each facility i ∈ Tour` satisfies

∑t≤t`

yi,t > 0,

19

so d(i, r) ≤ t`, and we may therefore divide Tour` into k tours of length at most O(log2 n)t`. Thus, weobtain the same guarantee on the expected cost incurred, and we violate the budget by an O(log2 n)-factor,that is, we get a bicriteria

(polylog, O(log2 n)

)-approximation. Similarly, for related MLUFL and ML, we

obtain an(O(1), O(1)

)-approximation. For ML, we may again use either (LP1) or (LP2P ): in both LPs

we set T = B; in (LP1), we now have the constraint∑

e deze,t ≤ kt, and in (LP2P ), the RHS of (5) isnow k. For metric uniform MLUFL, we modify (Unif-P) in the obvious way: we now have

∑t yi,t ≤ k for

each time t, and t now ranges from 1 to B. We can again apply Theorem 2.12 here to obtain a (unicriteria)O(1)-approximation algorithm: for the zero-facility-location problem (where we may now “open” at mostkB facilities), we can adapt the ideas in [3] to devise an O(1)-approximation algorithm.

Finally, these guarantees extend to latency functions of bounded growth (in the same way that guar-antees for MLUFL extend to the setting with latency functions). Thus, in particular, we obtain an O(1)-approximation algorithm for the Lp-norm k-traveling repairmen problem; this is the first approximationguarantee for this problem.

Non-uniform latency costs. We consider here the setting where each client j has a (possibly different)time-to-cost conversion factor λj , which measures j’s sensitivity to time delay (vs. connection cost); so thelatency cost of a client j is now given by λjtj , where tj is the delay faced by the facility serving j.

All our guarantees in Sections 2.2, 2.3, and 3 continue to hold in this non-uniform latency setting.In particular, we obtain a constant approximation guarantee for related metric MLUFL, metric uniformMLUFL, and ML. Notice that the metric uniform MLUFL problem cannot now be solved via a reductionto the metric-UFL variant discussed in Section 2.3; however we can still use Corollary 2.13 to obtain a10.773-approximation. For general MLUFL, it is not hard to see that our analysis goes through under thethe assumption T = poly(m). However, the scaling trick used to bypass this assumption leads to an extraO

(log(λmax

λmin))

factor in the approximation.Recall that the scaling factor L (in the definition of t`) in Section 2.1 was defined as

∑j L∗

j/m, whereL∗

j =∑

i,t txij,t. Now, L∗j =

∑i,t λjtxij,t, and we set L =

∑j L∗

j/∑

j λj . One can again argue that theexpected latency-cost of each client j is at most λj ·O(log2 n) ·max

L, τj, so we incur an O(log2 n)-factor

in the latency-cost. The number of phases, however, isN :=⌈log2(2τmax/L) + 4 log2 m

⌉, and 2τmax/L =

O( τmax

Pj λjP

j L∗j

) ≤ O(

mλmaxλmin

), which gives an extra log2(λmax/λmin) factor in the facility-opening cost.Finally, as before, these guarantees also translate to the k-route length-bounded versions of our problems.

References

[1] A. Archer, A. Levin, and D. Williamson. A faster, better approximation algorithm for the minimumlatency problem. SIAM J. Comput., 37(5):1472–1498, 2008.

[2] Y. Azar, I. Gamzu, and X. Yin. Multiple intents re-ranking. In Proceedings of 41st STOC, pages669–678, 2009.

[3] I. Baev, R. Rajaraman, and C. Swamy. Approximation algorithms for data placement problems. SIAMJournal on Computing, 38(4):1411–1429, 2008.

[4] J. Bang-Jensen, A. Frank, and B. Jackson. Preserving and increasing local edge-connectivity in mixedgraphs. SIAM Journal on Discrete Mathematics, 8(2):155–178, 1995.

[5] N. Bansal, A. Gupta, and R. Krishnaswamy. A constant factor approximation algorithm for generalizedmin-sum set cover. In Proceedings of 21st SODA, pages 1539–1545, 2010.

20

[6] D. Bienstock, M. Goemans, D. Simchi-Levi, and D. Williamson. A note on the prize collecting travel-ing salesman problem. Math. Program., 59:413–420, 1993.

[7] A. Blum, P. Chalasani, D. Coppersmith, B. Pulleyblank, P. Raghavan, and M. Sudan. The MinimumLatency Problem. In Proceedings of 26th STOC, pages 163–171, 1994.

[8] J. Byrka. An optimal bifactor approximation algorithm for the metric uncapacitated facility locationproblem. In Proceedings of the 10th APPROX, pages 29–43, 2007.

[9] M. Charikar, C. Chekuri, A. Goel, and S. Guha. Rounding via trees: deterministic approximationalgorithms for Group Steiner Trees and k-median. In Proeedings of the 30th STOC, pages 114–123,1998.

[10] K. Chaudhuri, P. B. Godfrey, S. Rao, and K. Talwar. Paths, Trees and Minimum Latency Tours. InProceedings of 44th FOCS, pages 36–45, 2003.

[11] C. Chekuri, N. Korula, and M. Pal. Improved algorithms for orienteering and related problems. InProceedings of 19th SODA, pages 661–670, 2008.

[12] F. Chudak and D. Shmoys. Improved approximation algorithms for the uncapacitated facility locationproblem. SIAM Journal on Computing, 33(1):1–25, 2003.

[13] F. Eisenbrand, F. Grandoni, T. Rothvoß, and G. Schafer. Approximating connected facility locationproblems via random facility sampling and core detouring. In Proceedings of 19th SODA, pages 1174–1183, 2008.

[14] J. Fakcharoenphol, C. Harrelson, and S. Rao The k-travelling repairman problem. ACM Trans. onAlg., Vol 3, Issue 4, Article 40, 2007.

[15] J. Fakcharoenphol, S. Rao, and K. Talwar. A tight bound on approximating arbitrary metrics by treemetrics. In Proceedings of 35th STOC, pages 448–455, 2003.

[16] U. Feige, L. Lovasz, and P. Tetali. Approximating min sum set cover. Algorithmica, 40(4):219–234,2004.

[17] N. Garg, G. Konjevod, and R. Ravi. A polylogarithmic approximation algorithm for the group Steinertree problem. Journal of Algorithms, 37(1):66–84, 2000.

[18] M. Goemans and D. Bertsimas. Survivable networks, linear programming relaxations and the parsi-monious property. Mathematical Programming, 60:145–166, 1993.

[19] M. Goemans and J. Kleinberg. An improved approximation ratio for the minimum latency problem.In Proceedings of 7th SODA, pages 152–158, 1996.

[20] A. Gupta, J. Kleinberg, A. Kumar, R. Rastogi, and B. Yener. Provisioning a virtual private network: Anetwork design problem for multicommodity flow. In Proceedings of the 33rd Annual ACM Symposiumon Theory of Computing, pages 389–398, 2001.

[21] A. Gupta, R. Krishnaswamy, V. Nagarajan, and R. Ravi. Approximation Algorithms for Optimal Deci-sion Trees and Adaptive TSP Problems. arXiv:1003.0722, to appear in ICALP 2010.

[22] E. Halperin and R. Krauthgamer. Polylogarithmic inapproximability. In Proceedings of 35th STOC,pages 585–594, 2003.

21

[23] J. H. Lin and J. S. Vitter. ε-approximations with minimum packing constraint violation. In Proceedingsof the 24th Annual ACM Symposium on Theory of Computing, pages 771–782, 1992.

[24] K. Jain, M. Mahdian, and M. Salavatipour. Packing Steiner trees. In Proceedings of 14th SODA, pages266–274, 2003.

[25] P. Mirchandani and R. Francis, eds. Discrete Location Theory. John Wiley and Sons, Inc., New York,1990.

[26] V. Nagarajan. Approximation Algorithms for Sequencing Problems. Ph.D. thesis, Tepper School ofBusiness, Carnegie Mellon University, 2009.

[27] R. Ravi and F. S. Selman. Approximation algorithms for the traveling purchaser problem and itsvariants in network design. In Proceedings of the 7th Annual European Symposium on Algorithms,pages 29–40, 1999.

[28] D. Shmoys, R. Levi, and C. Swamy. Facility location with service installation costs. In Proceedingsof 15th SODA, pages 1081–1090, 2004.

[29] D. B. Shmoys, E. Tardos, and K. I. Aardal. Approximation algorithms for facility location problems.In Proceedings of the 29th Annual ACM Symposium on Theory of Computing, pages 265–274, 1997.

[30] D. Shmoys and D. Williamson. Analyzing the Held-Karp TSP bound: a monotonicity property withapplication. Inf. Process. Lett., 35(6):281–285, 1990.

[31] C. Swamy and A. Kumar. Primal-dual algorithms for connected facility location problems. Algorith-mica, 40(4):245–269, 2004.

[32] P. Toth and D. Vigo, eds. The Vehicle Routing Problem. SIAM Monographs on Discrete Mathematicsand Applications, Philadelphia, 2002.

[33] L. Wolsey. Heuristic analysis, linear programming and branch and bound. Mathematical ProgrammingStudy, 13:121-134, 1980.

A Proofs omitted from the main body

Proof of Theorem 2.9 : Consider a GST instance(H = (V,E), r, dee∈E , Gj ⊆ V mj=1). Let n = |V |.

We may assume that H is the complete graph, d is a metric, and the groups are disjoint. We abbreivate ρn,m

to ρ below. Let Q denote the collection of all solutions to the path-variant of GST; that is, Q consists ofall paths starting at r that visit at least one node of each group. For a path Q ∈ Q and a group Gj , defineQj to be the portion of Q from r to the first node of Gj lying on Q. Let dj(Q) =

∑e∈Qj

de be the lengthof Qj ; that is, dj(Q) is the latency of group j along path Q. Consider the following LP-relaxation for thepath-variant of GST, and its dual. We have a variable xQ for every Q ∈ Q indicating if path Q is chosen.We use Q below to index the paths in Q.

min M (P’)

s.t.∑Q

dj(Q)xQ ≤M ∀j∑Q

xQ ≥ 1

x ≥ 0.

max α (D’)

s.t.∑

j

λjdj(Q) ≥ α ∀Q (10)∑j

λj ≤ 1

α, λ ≥ 0.

22

(P’) has an exponential number of variables. But observe that separating over the constraints (10) in thedual involves solving an MGL problem. The minimum value (over all Q ∈ Q) of the LHS of (10) is theoptimal value of the MGL problem defined by (Gj , λj), where we seek to minimize the weighted sum ofclient latency costs. (This weighted group latency problem can be reduced to the unweighted problem by“creating” λj copies of each group Gj (we can scale the λjs so that they are integral); equivalently (insteadof explicitly creating copies), one can simulate this copying-process in whatever algorithm one uses for(unweighted) MGL.) Thus, a ρ-approximation algorithm for MGL yields a ρ-approximate separation oraclefor (D’). Now, applying an argument similar to the one used by Jain et al. [24] shows that one can use thisto (also) obtain a ρ-approximate solution (x,M) to (P’).

We now use randomized rounding to round (x,M) and obtain a group Steiner tree of cost at mostO(log m)M . We pick path Q independently with probability min4 log m · xQ, 1. Let Q′ ⊆ Q denotethe collection of paths picked. Note that for every group Gj , we have

∑Q∈Q:dj(Q)≤2M xQ ≥ 1

2 . So astandard set-cover argument shows that with probability at least 1 − 1/m, for every j, there is some pathQ(j) ∈ Q′ such that dj(Q(j)) ≤ 2M . We may assume that

∑Q xQ = 1, so Chernoff bounds show

that |Q′| = O(log m) with overwhelming probability. The group Steiner tree T consists of the union ofall the Q

(j)j (sub)paths (deleting edges to remove cycles as necessary). Clearly, the cost of T is at most

|Q′| · 2M = O(log m)M . Note that T also yields a path of length O(log m)M starting at r and visiting allgroups, so the integrality gap of (P’) is O(log m).

Extension of Lemma 3.3 to MGL. Notice that we did not use anything specific to the minimum-latencyproblem in the proof, and so essentially the same proof also applies to MGL. Recall that in MGL, we havea set F of facilities and a d-metric on F ∪ r, and a collection of m groups Gj ⊆ F. Analogous to(LP2(a,b)

P), the LP-relaxation with path variables for MGL and its dual are as follows.

min∑j,t

txj,t (LP’(a,b)P )

s.t.∑

t

xj,t ≥ 1 ∀j∑P∈Pbt

zP,t ≤ a ∀t

∑P∈Pbt:Gj∩P 6=∅

zP,t ≥∑t′≤t

xj,t′ ∀j, t

x, z ≥ 0.

max∑

j

αj − a∑

t

βt (LD’P(a, b))

s.t. αj ≤ t +∑t′≥t

θj,t′ ∀j, t

∑j:Gj∩P 6=∅

θj,t ≤ βt ∀t, P ∈ Pbt (11)

α, β, θ ≥ 0.

The LP-relaxation(LP’(a,b)

T)

with tree variables is obtained by replacing Pbt with Tbt in (LP’(a,b)P ). The

orienteering problem that we need to solve now to separate over the constraints (11) is group orienteering:given a reward θj,t for each group Gj , we want to determine if there is a path (or tree) rooted at r of length atmost bt such that the total reward of the groups covered by it is more than βt. Given these changes, the proofthat one can obtain a feasible solution (x, y) to

(LP’(a,b)

T)

of cost at most the optimal value of(LP’(1,1)

P)

isas in the proof of Lemma 3.3.

23