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

We introduce a problem that is a common generalization of the uncapacitated facility location and minimum latency (ML) problems, where facilities need to be opened to serve clients and also need to be sequentially activated before they can provide service. Formally, we are given a set \F of n facilities with facility-opening costs {f_i}, a set of m clients, and connection costs {c_{ij}} specifying the cost of assigning a client j to a facility i, a root node r denoting the depot, and a time metric d on \F\cup{r}. Our goal is to open a subset F of facilities, find a path P starting at r and spanning F to activate the open facilities, and connect each client j to a facility \phi(j)\in F, so as to minimize \sum_{i\in F}f_i +\sum_{clients j}(c_{\phi(j),j}+t_j), where t_j is the time taken to reach \phi(j) along path P. We call this the minimum latency uncapacitated facility location (MLUFL) problem. Our main result is an O(\log n\max{\log n,\log m})-approximation for MLUFL. We also show that any improvement in this approximation guarantee, implies an improvement in the (current-best) approximation factor for group Steiner tree. We obtain constant approximations for two natural special cases of the problem: (a) related MLUFL (metric connection costs that are a scalar multiple of the time metric); (b) metric uniform MLUFL (metric connection costs, unform time-metric). Our LP-based methods are versatile and easily adapted to yield approximation guarantees for MLUFL in various more general settings, such as (i) when the latency-cost of a client is a function of the delay faced by the facility to which it is connected; and (ii) the k-route version, where k vehicles are routed in parallel to activate the open facilities. Our LP-based understanding of MLUFL also offers some LP-based insights into ML, which we believe is a promising direction for obtaining improvements for ML.

💡 Research Summary

The paper introduces a novel optimization problem that simultaneously captures the essence of the uncapacitated facility location (UFL) problem and the minimum‑latency (ML) problem. In this Minimum‑Latency Uncapacitated Facility Location (MLUFL) model, we are given a set F of n potential facilities, each with an opening cost f_i, a set C of m clients, connection costs c_{ij} for assigning client j to facility i, a root depot r, and a metric d defined on F∪{r} that measures travel time. The decision variables are (i) which facilities to open, (ii) a tour P that starts at r and visits all opened facilities (thereby “activating” them), and (iii) an assignment φ of each client to an opened facility. The objective is

  ∑{i∈F′} f_i + ∑{j∈C} (c_{φ(j),j} + t_j),

where F′ is the set of opened facilities and t_j is the time at which the tour first reaches φ(j). Thus the cost combines a classic facility‑opening term, a standard client‑facility connection term, and a latency term that depends on the order in which facilities are visited.

LP formulation.
The authors propose a natural linear programming relaxation. For each facility i they introduce a binary variable y_i indicating whether i is opened. For each client‑facility pair (i,j) they have a fractional assignment variable x_{ij}. To capture the activation order they introduce time‑indexed variables z_{i,t} that indicate whether facility i is activated at time t (or earlier). The constraints enforce (a) each client is assigned to exactly one facility (∑i x{ij}=1), (b) a client can be assigned only to an opened facility (x_{ij} ≤ y_i), (c) the activation variables must be consistent with a feasible r‑rooted walk that visits the opened facilities (a flow‑based formulation reminiscent of the traveling‑salesman polytope). The objective is the linear combination of the three cost components.

Approximation algorithm.
The algorithm proceeds in two rounding stages. First, using the y_i values, the LP solution is filtered to obtain a “core” set of facilities. By selecting facilities whose y_i exceeds a threshold that is a power of two, the authors lose at most an O(log n) factor in the opening cost. Second, they must order these facilities along a tour. Here the key insight is that the latency part of the objective can be expressed as a group‑Steiner‑tree (GST) instance: each client j defines a group consisting of the facilities to which it could be assigned, and the tour must connect at least one facility from each group. The best known GST approximation is O(log n·log k) where k is the number of groups (here k = m). By embedding the core facilities into a GST instance and applying the GST algorithm, they obtain a tour whose latency cost is within O(log n·max{log n, log m}) of the LP optimum. Combining the two stages yields an overall approximation ratio of

  O(log n·max{log n, log m}).

Hardness connection.
A striking contribution is the reduction showing that any improvement over this bound would immediately improve the best known approximation for GST. Since GST is known to be hard to approximate within a factor better than Ω(log log n) under standard complexity assumptions, this connection suggests that the achieved bound may be close to optimal unless a breakthrough occurs for GST.

Special cases with constant factors.
The authors identify two natural subclasses where the logarithmic factors disappear.

1. Related MLUFL: The connection costs are a scalar multiple of the travel metric, i.e., c_{ij}=α·d(i,j). In this setting the same metric governs both latency and connection, allowing the use of a minimum‑spanning‑tree (MST) as a proxy for the tour. The MST provides a constant‑factor approximation for both components, yielding a constant‑factor overall algorithm.
2. Metric uniform MLUFL: The travel metric d is uniform (all pairwise distances are equal). The latency component reduces to the classic ML problem, for which a 3.59‑approximation is known. By coupling this with the standard UFL approximation for the opening/connection part, a constant‑factor algorithm for this subclass follows.

Extensions.
The LP framework is flexible enough to handle two important generalizations.
Latency functions: Instead of a linear latency term t_j, each client may have a non‑decreasing convex function g_j(t_j). By adding convexity constraints to the LP and rounding the same way, the same O(log n·max{log n, log m}) guarantee holds.
k‑route version: When k vehicles operate in parallel, the activation variables become multi‑commodity flows. Using known approximations for multi‑commodity flow routing, the authors obtain an O(k·log n·max{log n, log m}) approximation.

Implications for Minimum‑Latency.
Because MLUFL contains ML as a special case (set the facility opening and connection costs to zero), the LP‑based perspective sheds new light on ML itself. The authors argue that the GST‑based rounding could be refined for ML, potentially leading to improved constants or even sub‑logarithmic approximations.

Conclusion.
The paper delivers the first poly‑logarithmic approximation for the unified MLUFL problem, establishes a tight connection to the group‑Steiner‑tree problem, and provides constant‑factor algorithms for two practically relevant subclasses. Moreover, the LP‑based methodology is shown to be robust under extensions such as convex latency penalties and multiple parallel routes. The work opens several avenues: improving GST approximations would directly tighten MLUFL bounds; exploring stronger LP relaxations (e.g., Sherali‑Adams hierarchies) might reduce the logarithmic loss; and adapting the GST‑based rounding to pure minimum‑latency could yield breakthroughs for that long‑standing problem.