The Non-Uniform k-Center Problem

In this paper, we introduce and study the Non-Uniform k-Center problem (NUkC). Given a finite metric space $(X,d)$ and a collection of balls of radii $\{r_1\geq \cdots \ge r_k\}$, the NUkC problem is to find a placement of their centers on the metric space and find the minimum dilation $\alpha$, such that the union of balls of radius $\alpha\cdot r_i$ around the $i$th center covers all the points in $X$. This problem naturally arises as a min-max vehicle routing problem with fleets of different speeds. The NUkC problem generalizes the classic $k$-center problem when all the $k$ radii are the same (which can be assumed to be $1$ after scaling). It also generalizes the $k$-center with outliers (kCwO) problem when there are $k$ balls of radius $1$ and $\ell$ balls of radius $0$. There are $2$-approximation and $3$-approximation algorithms known for these problems respectively; the former is best possible unless P=NP and the latter remains unimproved for 15 years. We first observe that no $O(1)$-approximation is to the optimal dilation is possible unless P=NP, implying that the NUkC problem is more non-trivial than the above two problems. Our main algorithmic result is an $(O(1),O(1))$-bi-criteria approximation result: we give an $O(1)$-approximation to the optimal dilation, however, we may open $\Theta(1)$ centers of each radii. Our techniques also allow us to prove a simple (uni-criteria), optimal $2$-approximation to the kCwO problem improving upon the long-standing $3$-factor. Our main technical contribution is a connection between the NUkC problem and the so-called firefighter problems on trees which have been studied recently in the TCS community.


Introduction
Source location and vehicle routing problems are extremely well studied [19,23,9] in operations research. Consider the following location+routing problem: we are given a set of k ambulances with speeds s 1 , s 2 , . . . , s k respectively, and we have to find the depot locations for these vehicles in a metric space (X, d) such that any point in the space can be served by some ambulance as fast as possible. If all speeds were the same, then we would place the ambulances in locations S such that max v∈X d(v, S) is minimized -this is the famous k-center problem. Differing speeds, however, leads to non-uniformity, thus motivating the titular problem we consider. Definition 1.1 (The Non-Uniform k-Center Problem (NUkC)). The input to the problem is a metric space (X, d) and a collection of k balls of radii {r 1 ≥ r 2 ≥ · · · ≥ r k }. The objective is to find a placement C ⊆ X of the centers of these balls, so as to minimize the dilation parameter α such that the union of balls of radius α · r i around the ith center covers all of X. Equivalently, we need to find centers {c 1 , . . . , c k } to minimize max v∈X min k i=1 d(v,c i ) As mentioned above, when all r i 's are the same (and equal to 1 by scaling), we get the k-center problem. The k-center problem was originally studied by Gonzalez [10] and Hochbaum and Shmoys [13] as a clustering problem of partitioning a metric space into different clusters to minimize maximum intra-cluster distances. One issue (see Figure 1 for an illustration and refer to [11] for a more detailed explanation) with k-center (and also k-median/means) as an objective function for clustering is that it favors clusters of similar sizes with respect to cluster radii. However, in presence of qualitative information on the differing cluster sizes, the non-uniform versions of the problem can arguably provide more nuanced solutions. One such extreme special case was considered as the "clustering with outliers" problem [7] where some fixed number/fractions of points in the metric space need not be covered by the clusters. In particular, Charikar et al [7] consider (among many problems) the k-center with outlier problem (kCwO, for short) and show a 3-approximation for this problem. It is easy to see that kCwO is a special case of the NUkC problem when there are k balls of radius 1 and (the number of outliers) balls of radius 0.
Motivated by the aforementioned reasons (both from facility location as well as from clustering settings), we investigate the worst-case complexity of the NUkC problem. Gonzalez [10] and Hochbaum and Shmoys [13] give 2-approximations for the k-center problem, and also show that no better factor is possible unless P = NP. Charikar et al [7] give a 3-approximation for the kCwO problem, and this has been the best factor known for 15 years. Given these algorithms, it is natural to wonder if a simple O(1)-approximation exists for the NUkC problem. In fact, our first result shows a qualitative distinction between NUkC and these problems: constant-approximations are impossible for NUkC unless P=NP. Theorem 1.2. For any constant c ≥ 1, the NUkC problem does not admit a c-factor approximation unless P = N P , even when the underlying metric is a tree metric.
The hardness result is by a reduction from the so-called resource minimization for fire containment problem on trees (RMFC-T, in short), a variant of the firefighter problem. To circumvent the above hardness, we give the following bi-criteria approximation algorithm which is the main result of the paper, and which further highlights the connections with RMFC-T since our algorithms heavily rely on the recent algorithms for RMFC-T [3,1]. An (a, b)-factor bi-criteria algorithm for NUkC returns a solution which places at most a balls of each type (thus in total it may use as many as a · k balls), and the dilation is at most b times the optimum dilation for the instance which places exactly one ball of each type.  Furthermore, as we elucidate below, our techniques also give uni-criteria results when the number of distinct radii is 2. In particular, we get a 2-approximation for the kCwO problem and a (1+ √ 5)-approximation when there are only two distinct types of radii. Theorem 1.4. There is a 2-approximation for the kCwO problem. Theorem 1.5. There is a (1 + √ 5)-approximation for the NUkC problem when the number of distinct radii is at most 2.

Discussion on Techniques
Our proofs of Theorems 1.2 and 1.3 shows a strong connection between NUkC and the so-called resource minimization for fire containment problem on trees (RMFC-T, in short). This connection is one of the main findings of the paper, so we first formally define this problem. Definition 1.6 (Resource Minimization for Fire Containment on Trees (RMFC-T)). Given a rooted tree T as input, the goal is to select a collection of non-root nodes N from T such that (a) every root-leaf path has at least one vertex from N , and (b) max t |N ∩ L t | is minimized, where L t is the tth-layer of T , that is, the vertices of T at exactly distance t from the root.
To understand the reason behind the name, consider a fire starting at the root spreading to neighboring vertices each day; the RMFC-T problem minimizes the number of firefighters needed per day so as to prevent the fire spreading to the leaves of T .
It is NP-hard to decide if the optimum of RMFC-T is 1 or not [8,17]. Given any RMFC-T instance and any c > 1, we construct an NUkC instance on a tree metric such that in the "yes" case there is always a placement with dilation = 1 which covers the metric, while in the "no" case even a dilation of c doesn't help. Upon understanding our hardness construction, the inquisitive reader may wonder if the reduction also works in the other direction, i.e., whether we can solve NUkC using a reduction to RMFC-T problem. Unfortunately, we do not know if this is true even for two types of radii. However, as we explain below we still can use positive results for the RMFC-T problem to design good algorithms for the NUkC problem.
Indeed, we start off by considering the natural LP relaxation for the NUkC problem and describe an LP-aware reduction of NUkC to RMFC-T. More precisely, given a feasible solution to the LP-relaxation for the given NUkC instance, we describe a procedure to obtain an instance of RMFC-T defined by a tree T , with the following properties: (i) we can exhibit a feasible fractional solution for the LP relaxation of the RMFC-T instance, and (ii) given any feasible integral solution to the RMFC-T instance, we can obtain a feasible integral solution to the NUkC instance which dilates the radii by at most a constant factor. Therefore, an LP-based ρ-approximation to RMFC-T would immediately imply (ρ, O(1))-bicriteria approximation algorithms for NUkC. This already implies Theorem 1.4 and Theorem 1.5 since the corresponding RMFC-T instances have no integrality gap. Also, using a result of Chalermsook and Chuzhoy [3], we directly obtain an (O(log * n), O(1))-bicriteria approximation algorithm for NUkC.
Here we reach a technical bottleneck: Chalermsook and Chuzhoy [3] also show that the integrality gap of the natural LP relaxation for RMFC-T is Ω(log * n). When combined with our hardness reduction in Theorem 1.2 , this also implies a (Ω(log * n), c) integrality gap for any constant c > 1 for the natural LP relaxation for NUkC. That is, even if we allow a violation of c in the radius dilation, there is a Ω(log * n)integrality gap in terms of the violation in number of balls opened of each type.
However, very recently, Adjiashvili, Baggio and Zenklusen [1] show an improved O(1)-approximation for the RMFC-T problem. At a very high level, the main technique in [1] is the following. Given an RMFC-T instance, they carefully and efficiently "guess" a subset of the optimum solution, such that the natural LP-relaxation for covering the uncovered leaves has O(1)-integrality gap. However, this guessing procedure crucially uses the tree structure of T in the RMFC-T problem. Unfortunately for us though, we get the RMFC-T tree only after solving the LP for NUkC, which already has an Ω(log * n)-gap! Nevertheless, inspired by the ideas in [1], we show that we can also efficiently preprocess an NUkC instance, "guessing" the positions of a certain number of balls in an optimum solution, such that the standard LP-relaxation for covering the uncovered points indeed has O(1)-gap. We can then invoke the LP-aware embedding reduction to RMFC-T at this juncture to solve our problem. This is quite delicate, and is the most technically involved part of the paper.

Related Work and Open Questions
The k-center problem [10,13] and the k-center with outliers [7] probems are classic problems in approximation algorithms and clustering. These problems have also been investigated under various settings such as the incremental model [5,22], streaming model [4,22], and more recently in the map-reduce model [14,21]. Similarly, the k-median [6,15,20,2] and k-means [15,16,12,18] problems are also classic problems studied extensively in approximation algorithms and clustering. The generalization of k-median to a routing+location problem was also studied recently [9]. It would be interesting to explore the complexity of the non-uniform versions of these problems. Another direction would be to explore if the new non-uniform model can be useful in solving clustering problems arising in practice.

Hardness Reduction
In this section, we prove Theorem 1.2 based on the following NP-hardness [17] for RMFC-T.
Theorem 2.1. [17] Given a tree T whose leaves are at the same distance from the root, it is NP-hard to distinguish between the following two cases. YES: There is a solution to the RMFC-T instance of value 1. NO: All solutions to the RMFC-T instance has value 2.
Given an RMFC-T instance defined by tree T , we now describe the construction of our NUkC instance. Let h be the height of the tree, and let L t denote the vertices of the tree at distance exactly t from the root. So, the leaves constitute L h since all leaves are at the same distance from the root. The NUkC instance, I(T ), is defined by the metric space (X, d), and a collection of balls. The points in our metric space will correspond to the leaves of the tree, i.e., X = L h . To define the metric, we assign a weight d(e) = (2c + 1) h−i+1 for each edge whose one endpoint is in L i and the other in L i−1 ; we then define d be the shortest-path metric on X induced by this weighted tree. Finally, we set k = h, and define the k radii r 1 ≥ r 2 ≥ . . . ≥ r k iteratively as follows: define r k := 0, and for k ≥ i > 1, set r i−1 := (2c + 1) · r i + 2(2c + 1). This completes the NUkC instance. Before proceeding we make the simple observation: for any two leaves u and u with lca v ∈ L t , we have d(u, u ) = 2(2c + 1 + (2c + 1) 2 + · · · + (2c + 1) h−t ) = r t . The following lemma proves Theorem 1.2. Proof. Suppose T is in the YES case, and there is a solution to RMFC-T which selects at most 1 node from each level L t . If v ∈ L t is selected, then select a center c v arbitrarily from any leaf in the sub-tree rooted at v and open the ball of radius r t . We now need to show all points in X = L h are covered by these balls. Let u be any leaf; there must be a vertex v in some level L t in u's path to the root such that a ball of radius r t is opened at c v . However, d(u, c v ) ≤ d(u, v) + d(v, c v ) = 2r t and so the ball of radius 2r t around c v covers u. Now suppose T is in the NO case, and the NUkC instance has a solution with optimum dilation < 2c. We build a good solution for the RMFC-T instance N as follows: suppose the NUkC solution opens the radius < 2c · r t ball around center u. Let v be the vertex on the u-root path appearing in level L t . We then pick this node in N . Observe two things: first, this ball covers all the leaves in the sub-tree rooted at v since r t ≥ d(u, u ) for any such u . Furthermore, since the NUkC solution has only one ball of each radius, we get that |N ∩ L t | ≤ 1. Finally, since d(u, w) ≥ 2c · r t for all leaves w not in the sub-tree rooted at v, the ball of radius r t around u doesn't contain any leaves other than those rooted at v. Contra-positively, since all leaves w are covered in some ball, every leaf must lie in the sub-tree of some vertex picked in N . That is, N is a solution to RMFC-T with value = 1 contradicting the NO case.

LP-aware reduction from NUkC to RMFC-T
For reasons which will be apparent soon, we consider instances I of NUkC counting multiplicites. That is, we consider an instance to be a collection of tuples (k 1 , r 1 ), . . . , (k h , r h ) to indicate there are k i balls of radius r i . So h t=1 k t = k. Intuitively, the reason we do this is that if two radii r t and r t+1 are "close-by" then it makes sense to round up r t+1 to r t and increase k t , losing only a constant-factor loss in the dilation. LP-relaxation for NUkC. We now state the natural LP relaxation for a given NUkC instance I. For each point p ∈ X and radius type r i , we have an indicator variable x p,i ≥ 0 for whether we place a ball of radius r i centered at p. By doing a binary search on the optimal dilation and scaling, we may assume that the optimum dilation is 1. Then, the following linear program must be feasible. Below, we use B(q, r i ) to denote the set of points within distance r i from q.
Since we reduce fractional NUkC to fractional RMFC-T, we now state the natural LP relaxation for RMFC-T on a tree T of depth h + 1. In fact, we will work with the following budgeted-version of RMFC-T (which is equivalent to the original RMFC-T problem -for a proof, see [1]): Instead of minimizing the maximum number of "firefighters" at any level t (that is |N ∩ L t | where N is the chosen solution), suppose we specify a budget limit of k t on |N ∩ L t |. The goal is the minimize the maximum dilation of these budgets. Then the following is a natural LP relaxation for the budgeted RMFC-T problem on trees. Here L = L h is the set of leaves, and L t are the layer t-nodes. For a leaf node v, let P v denote the vertex set of the unique leaf-root path excluding the root.
The LP-aware Reduction to Tree metrics. We now describe our main reduction algorithm, which takes as input an NUkC instance I = {(X, d); (k 1 , r 1 ), . . . , (k h , r h )} and a feasible solution x to NUkC LP, and returns a budgeted RMFC-T instance I T defined by a tree T along with budgets for each level, and a feasible solution y to RMFC-T LP with dilation 1. The tree we construct will have height h + 1 and the budgeted RMFC-T instance will have budgets precisely k t at level 1 ≤ t ≤ h, and the budget for the leaf level is 0.
For clarity, throughout this section we use the word points to denote elements of the metric space in I, and the word vertices/nodes to denote the tree nodes in the RMFC-T instance that we construct. We build the tree T in a bottom-up manner, where in each round, we pick a set of far-away representative points (the distance scale increases as we move up the tree) and cluster all points to their nearest representative. This is similar to a so-called clustering step in many known algorithms for facility location (see, e.g. [6]), but whereas an arbitrary set of far-away representatives would suffice in the facility location algorithms, we need to be careful in how we choose this set to make the overall algorithm work. Formally, each vertex of the tree T is mapped to some point in X, and we denote the mapping of the vertices at level t by ψ t : L t → X. We will maintain that each ψ t will be injective, t is well defined for the range of ψ t . The complete algorithm runs in rounds h + 1 to 2 building the tree one level per round. To begin with, the ψ h+1 mapping is an arbitrary bijective mapping between L := L h+1 , the set of leaves of the tree, and the points of X (so, in particular, |L| = |X|). We may assume it to be the identity bijection. In each round t, the range of the mappings become progressively smaller, that is 1 . We call ψ t (L t ) as the winners at level t. We now describe round t. Let Cov t (p) := q∈B(p,rt) x q,t denote the fractional amount the point p is covered by radius r t balls in the solution x. Also define Cov ≥t (p) := s≥t Cov s (p) denoting the fractional amount p is covered by radius r t or smaller balls. Let Cov h+1 (p) = 0 for all p.
Algorithm 1 Round t of the LP-aware Reduction.
Input: Level L t , subtrees below L t , the mappings ψ s : L s → X for all t ≤ s ≤ h. Output: Level L t−1 , the connections between L t−1 and L t , and the mapping ψ t−1 .
Define A = ψ t (L t ) the set of points who are winners at level t.
(c) Create a new tree vertex w ∈ L t−1 corresponding to p and set ψ t−1 (w) := p. Call p a winner at level t − 1, and each q ∈ N (p) ⊆ A a loser to p at this level.
Finally, we add a root vertex and connect it to all vertices in L 1 . This gives us the final tree T and a solution y which assigns a value to all non-leaf, non-root vertices of the tree T . The following claim asserts well-definedness of the algorithm. Proof. The proof is via two claims for the two different set of inequalities. 1 We are using the notation ψ(X) := x∈X ψ(x).
Proof. Fix t. Let W t ⊆ X denote the winners at level t, that is, W t = ψ t (L t ). By definition of the algorithm, w∈Lt y w = p∈Wt Cov t (p). Now note that for any two points p, q ∈ W t , we have B(p, r t ) ∩ B(q, r t ) = ∅. To see this, consider the first point which enters A in the (t + 1)th round when L t was being formed. If this is p, then all points in the radius 2r t ball are deleted from A. Since the balls are disjoint, the second inequality of NUkC LP implies p∈Wt q∈B(p,rt) x q,t ≤ k t . The second summand in the LHS is precisely Cov t (p). Claim 3.3. For any leaf node w ∈ L, we have v∈Pw y v ≥ 1.
Proof. We start with an observation. Fix a level t and a winner point there is a leaf v in the subtree rooted at u corresponding to p. Moreover, by the way we formed our tree edges in step (d), we have that ψ s (w ) = p for all w in the (u, v)-path and hence w ∈[u,v]-path y w is precisely Cov ≥t (p). Now, for contradiction, suppose there is some leaf corresponding to, say point p, such that the root-leaf path has total y-assignment less than 1. Then, pick the point, among all such unsatisfied points p, who appears in a winning set W t with t as small as possible.
By the preceding observation, the total y-assignment p receives on its path from level h to level t is exactly Cov ≥t (p). Moreover, suppose p loses to q at level t − 1, i.e., ψ −1 t (p) is a child of ψ −1 t−1 (q). In particular, it means that q has also been a winner up to level t and so the total y-assignment on q's path upto level t is also precisely Cov ≥t (q). Additionally, since ψ −1 t−1 (q) became the parent node for ψ −1 t (p), we know that Cov ≥t (q) ≤ Cov ≥t (p) due to the way we choose winners in step (a) of the while loop. Finally, by our maximality assumption on p, we know that q is fractionally satisfied by the y-solution. Therefore, there is fractional assignment of at least (1 − Cov ≥t (q)) on q's path from nodes in level t − 1 to level 1. Putting these observations together, we get that the total fractional assignment on p's root-leaf path is at least Cov ≥t (p) + (1 − Cov ≥t (q)) ≥ 1, which results in the desired contradiction.
The following lemma shows that any good integral solution to the RMFC-T instance I T can be converted to a good integral solution for the NUkC instance I.
Then there is a solution to the NUkC instance I that opens, for each 1 ≤ t ≤ h, at most αk t balls of radius ≤ 2r ≥t ,where r ≥t := r t + r t+1 + · · · + r h .
Proof. Construct the NUkC solution as follows: for level 1 ≤ t ≤ h and every vertex w ∈ N ∩ L t , place the center at ψ t (w) of radius 2r ≥t . We claim that every point in X is covered by some ball. Indeed, for any p ∈ X, look at the leaf v = ψ h+1 (p), and let w ∈ N be a node in the root-leaf path. Let w ∈ L t for some t. Now observe that d(p, ψ t (w)) ≤ 2r ≥t ; this is because for any edge (u , v ) in the tree where u is in L t and is the parent of v , we have that d(ψ t+1 (v ), ψ t+1 (u )) < 2r t .
This completes the reduction, and we now prove a few results which follow easily from known results about the firefighter problem. Proof. Given any instance I of NUkC, we first club the radii to the nearest power of 2 to get an instance I with radii (k 1 , r 1 ), · · · , (k h , r h ) such that an (a, b)-factor solution for I is an (a, 2b)-solution for I. Now, by scaling, we assume that the optimal dilation for I is 1; we let x be the feasible solution to the NUkC LP. Then, using Algorithm 1, we can construct the tree I T and a feasible solution y to the RMFC-T LP. We can now use the following theorem of Chalermsook and Chuzhoy [3]: given any feasible solution to the RMFC-T LP, we can obtain a feasible set N covering all the leaves such that for all t, |N ∩ L t | ≤ O(log * n)k t . Finally, we can apply Lemma 3.4 to obtain a (O(log * n), 4) solution to I (since r ≥t ≤ 2r t ).
Proof of Theorem 1.4 and Theorem 1.5. We use the following claim regarding the integrality gap of RMFC-T LP for depth 2 trees. Claim 3.6. When h = 2 and k t 's are integers, given any fractional solution to RMFC-T LP, we can find a feasible integral solution as well.
Proof. Given a feasible solution y to RMFC-T LP, we need to find a set N such that |N ∩ L t | ≤ k t for t = 1, 2. There must exist at least one vertex w ∈ L 1 such that y w ∈ (0, 1) for otherwise the solution y is trivially integral. If only one vertex w ∈ L 1 is fractional, then since k 1 is an integer, we can raise this y w to be an integer as well. So at least two vertices w and w in L 1 are fractional. Now, without loss of generality, let us assume that |C(w)| ≥ |C(w )|, where C(w) is the set of children of w. Now for some small constant 0 < < 1, we do the following: y w := y w + , y w := y w − , ∀c ∈ C(w), y c := y c − , and ∀c ∈ C(w ), y c := y c + . Note that y(L 1 ) remains unchanged, y(L 2 ) can only decrease, and root-leaf paths still add to at least 1. We repeat this till we rule out all fractional values.
To see the proof of Theorem 1.4, note that an instance of the k-center with outliers problem is an NUkC instance with (k, 1), ( , 0), that is, r 1 = 1 and r 2 = 0. We solve the LP relaxation and obtain the tree and an RMFC-T solution. The above claim implies a feasible integral solution to RMFC-T since h = 2, and finally note that r ≥1 = r 1 for kCwO, implying we get a 2-factor approximation.
We end this section with a general theorem, which is an improvement over Lemma 3.4 in the case when many of the radius types are close to each other, in which case r ≥t could be much larger than r t . Indeed, the natural way to overcome this would be to group the radius types into geometrically increasing values as we did in the proof of Theorem 3.5. However, for some technical reasons we will not be able to bucket the radius types in the following section, since we would instead be bucketing the number of balls of each radius type in a geometric manner. Instead, we can easily modify Algorithm 1 to build the tree by focusing only on radius types where the radii grow geometrically.
Theorem 3.7. Given an NUkC instance I = {M = (X, d), (k 1 , r 1 ), (k 2 , r 2 ), . . . , (k h , r h )} and an LP solution x for NUkC LP, there is an efficient reduction which generates an RMFC-T instance I T and an LP solution y to RMFC-T LP, such that the following holds: (i) For any two tree vertices w ∈ L t and v ∈ L t where w is an ancestor of v (which means t ≤ t ), suppose p and q are the corresponding points in the metric space, i.e., p = ψ t (w) and q = ψ t (v), then it holds that d(p, q) ≤ 8 · r t .
(ii) Suppose there exists a feasible solution N to I T such that for all 1 ≤ t ≤ h, |N ∩ L t | ≤ αk t . Then there is a solution to the NUkC instance I that opens, for each 1 ≤ t ≤ h, at most αk t balls of radius at most 8 · r t .

Proof of Theorem 3.7
Both the algorithm as well as the proof are very similar, and we now provide them for completeness. At a high level, the only difference occurs when we identify and propagate winners: instead of doing it for each radius type, we identify barrier levels where the radius doubles, and perform the clustering step only at the barrier levels. We now present the algorithm, which again proceeds in rounds h + 1, h, h − 1, . . . , 2, but makes jumps whenever there are many clusters of similar radius type. To start with, define r h+1 = 0.
Algorithm 2 Round t of the Improved Reduction. Input: Level L t , subtrees below L t , the mappings ψ s : L s → X for all t ≤ s ≤ h. Output: Level L t−1 , the connections between L t−1 and L t , and the mapping ψ t−1 .
Let t = min s s.t.r s ≤ 2r t−1 be the type of the largest radius smaller than 2r t−1 . Define A = ψ t (L t ) the set of points who are winners at level t.  Our proof proceeds almost in an identical manner to those of Lemmas 3.1 and 3.4, but now our tree has an additional property that for any two nodes u ∈ L i and v ∈ L i where u is an ancestor of v, the distance between the corresponding points in the metric space p = ψ i (u) and q = ψ i (v) is at most d(p, q) ≤ 8r i , which was the property not true in the earlier reduction. This is easy to see because as we traverse a tree path from u to v, notice that each time we change winners, the distance between the corresponding points in the metric space decreases geometrically. This proves property (i) of Theorem 3.7. With this in hand, the remaining proofs to prove the second property are almost identical to the ones in Section 3 and we sketch them below for completeness. Proof. The proof is via two claims for the two different set of inequalities. Claim 3.9. For all 1 ≤ t ≤ h, we have w∈Lt y w ≤ k t . Proof. Fix a barrier level t. Let W t ⊆ X denote the winners at level t, that is, W t = ψ t (L t ). By definition of the algorithm, w∈Lt y w = p∈Wt Cov t (p). Now note that for any two points p, q ∈ W t , we have B(p, r t ) ∩ B(q, r t ) = ∅. To see this, consider the first point which enters A in the round (corresponding to the previous barrier) when L t was being formed. If this is p, then all points in the radius 2r t ball is deleted from A. Since the balls are disjoint, the second inequality of NUkC LP implies p∈Wt q∈Bt(p) x q,t ≤ k t . The second summand in the LHS is the definition of Cov t (p). The same argument holds for all levels t between two consecutive barrier levels t 1 and t 2 s.t. t 1 > t 2 , as the winner set remains the same, and the radius r t is only smaller than the radius r t 2 at the barrier t 2 .
Claim 3.10. For any leaf node w ∈ L, we have v∈Pw y v ≥ 1.
Proof. This proof is identical to that of Claim 3.3, and we repeat it for completeness. Fix a level t and a winner point p ∈ W t . Let u ∈ L t such that ψ t (u) = p. Since W t ⊆ W t+1 ⊆ · · · ⊆ W h , there is a leaf v in the subtree rooted at u corresponding to p. Moreover, by the way we formed our tree edges in step (d), we have that ψ s (w) = p for all w in the (u, v)-path and hence w ∈[u,v]-path y w is precisely Cov ≥t (p). Now, for contradiction, suppose there is some leaf corresponding to, say point p, such that the root-leaf path has total y-assignment less than 1. Then, pick the point, among all such unsatisfied points p, who appears in a winning set W t with t as small as possible.
By the preceding observation, the total y-assignment p receives on its path from level h to level t is exactly Cov ≥t (p). Moreover, suppose p loses to q at level t − 1, i.e., ψ −1 t (p) is a child of ψ −1 t−1 (q). In particular, it means that q has also been a winner up to level t and so the total y-assignment on q's path up to level t is also precisely Cov ≥t (q). Additionally, since ψ −1 t−1 (q) became the parent node for ψ −1 t (p), we know that Cov ≥t (q) ≤ Cov ≥t (p) due to the way we choose winners in step (a) of the while loop. Finally, by our maximality assumption on p, we know that q is fractionally satisfied by the y-solution. Therefore, there is fractional assignment of at least (1 − Cov ≥t (q)) on q's path from nodes in level t − 1 to level 1. Putting these observations together, we get that the total fractional assignment on p's root-leaf path is at least Cov ≥t (p) + (1 − Cov ≥t (q)) ≥ 1, which results in the desired contradiction.
Finally, the following lemma shows that any good integral solution to the RMFC-T instance I T can be converted to a good integral solution for the NUkC instance I. Lemma 3.11. Suppose there exists a feasible solution N to I T such that for all 1 ≤ t ≤ h, |N ∩ L t | ≤ αk t . Then there is a solution to the NUkC instance I that opens, for each 1 ≤ t ≤ h, at most αk t balls of radius at most 8r t .
Proof. Construct the NUkC solution as follows: for level 1 ≤ t ≤ h and every vertex w ∈ N ∩ L t , place the center at ψ t (w) of radius 8 · r t . We claim that every point in X is covered by some ball. Indeed, for any p ∈ X, look at the leaf v = ψ h+1 (p), and let w ∈ N be a node in the root-leaf path which covers it in the instance I T . By property (i) of Theorem 3.7, we have that the distance between ψ t (w) and p is at most 8 · r t , and hence the ball of radius 8 · r t around ψ t (w) covers p. The number of balls of radius type t is trivially at most αk t .

Getting an (O(1), O(1))-approximation algorithm
In this section, we improve our approximation factor on the number of clusters from O(log * n) to O(1), while maintaining a constant-approximation in the radius dilation. As mentioned in the introduction, this requires more ideas since using NUkC LP one cannot get any factor better than (O(log * n), O(1))-bicriteria approximation since any integrality gap for RMFC-T LP translates to a (Ω(log * n), Ω(1)) integrality gap for NUkC LP.
Our algorithm is heavily inspired by the recent paper of Adjiashvili et al [1] who give an O(1)approximation for the RMFC-T problem. In fact, the structure of our algorithms follows the same three "steps" of their algorithm. Given an RMFC-T instance, [1] first "compress" the input tree to get a new tree whose depth is bounded; secondly, [1] give a partial rounding result which saves "bottom heavy" leaves, that is, leaves which in the LP solution are covered by nodes from low levels; and finally, Adjiashvili et al [1] give a clever partial enumeration algorithm for guessing the nodes from the top levels chosen by the optimum solution. We also proceed in these three steps with the first two being very similar to the first two steps in [1]. However, the enumeration step requires new ideas for our problem. In particular, the enumeration procedure in [1] crucially uses the tree structure of the firefighter instance, and the way our reduction generates the tree for the RMFC-T instance is by using the optimal LP solution for the NUkC instance, which in itself suffers from the Ω(log * n) integrality gap. Therefore, we need to devise a more sophisticated enumeration scheme although the basic ideas are guided by those in [1]. Throughout this section, we do not optimize for the constants.

Part I: Radii Reduction
In this part, we describe a preprocessing step which decreases the number of types of radii. This is similar to Theorem 5 in [1].
Theorem 4.1. Let I be an instance of NUkC with radii {r 1 , r 2 , · · · , r k }. Then we can efficiently construct a new instance I with radii multiplicities (k 0 , r 0 ), ..., (k L , r L ) and L = Θ(log k) such that: (ii) If the NUkC instance I has a feasible solution, then there exists a feasible solution for I.
Proof. For an instance I, we construct the compressed instance I as follows. Partition the radii into Θ(log k) classes by defining barriers at r i = r 2 i for 0 ≤ i ≤ log k . Now to create instance I, we simply round up all the radii r j for 2 i ≤ j < 2 i+1 to the value r i = r 2 i . Notice that the multiplicity of r i is precisely 2 i (except maybe for the last bucket, where there might be fewer radii rounded up than the budget allowed).
Property (i) is just by construction of instance. Property (ii) follows from the way we rounded up the radii. Indeed, if the optimal solution for I opens a ball of radius r j around a point p, then we can open a cluster of radius r i around p, where i is such that 2 i ≤ j < 2 i+1 . Clearly the number of clusters of radius r i is at most 2 i because OPT uses at most one cluster of each radius r j .
For property (iii), suppose we have a solution S for I which opens α2 i clusters of radius β r i for all 0 ≤ i ≤ L. Construct a solution S for I as follows. For each 1 ≤ i ≤ L, let C i denote the set of centers where S opens balls of radius β r i . In the solution S, we also open balls at precisely these centers with 2α balls of radius r j for every 2 i−1 ≤ j < 2 i . Since |C i | ≤ α · 2 i , we can open a ball at every point in C i ; furthermore, since j < 2 i , we have r j ≥ r i and so we cover whatever the balls from S covered.
Finally, we also open the α clusters (corresponding to i = 0) of radius βr 1 = β r 0 at the respective centers C 0 where S opens centers of radius r 0 . Therefore, the total number of clusters of radius type is at most 2α with the exception of r 1 , which may have 3α clusters.

Part II: Satisfying Bottom Heavy Points
One main reason why the above height reduction step is useful, is the following theorem from [1] for RMFC-T instances on trees; we provide a proof sketch for completeness.

Theorem 4.2 ([1]
). Given a tree T of height h and a feasible solution y to (RMFC-T LP), we can find a feasible integral solution N to RMFC-T such that for all Proof. Let y be a basic feasible solution of (RMFC-T LP). Call a vertex v of the tree loose if y v > 0 and the sum of y-mass on the vertices from v to the root (inclusive of v) is < 1. Let V L be the set of loose vertices of the tree, and let V I be the set of vertices with y v = 1. Clearly N = V L ∪V I is a feasible solution: every leaf-toroot path either contains an integral vertex or at least two fractional vertices with the vertex closer to root being loose. Next we claim that |V L | ≤ h; this proves the theorem since |N ∩ L t | ≤ |V I ∩ L t | + |V L | ≤ k t + |V L |.
The full proof can be found in Lemma 6, [1] -here is a high level sketch. There are |L| + h inequalities in (RMFC-T LP), and so the number of fractional variables is at most |L| + h. We may assume there are no y v = 1 vertices. Now, in every leaf-to-root path there must be at least 2 fractional vertices, and the one closest to the leaf must be non-loose. If the closest fractional vertex to each leaf was unique, then that would account for |L| fractional non-loose vertices implying the number of loose vertices must be ≤ h. This may not be true; however, if we look at linearly independent set of inequalities that are tight, we can argue uniqueness as a clash can be used to exhibit linear dependence between the tight constraints. Theorem 4.3. Suppose we are given an NUkC instance I with radii multiplicities (k 0 , r 0 ), (k 1 , r 1 ), . . . , (k L , r L ) with budgets k i = 2 i for radius type r i , and an LP solution x to (NUkC LP) for I. Let τ = log log L, and suppose X ⊆ X be the points covered mostly by small radii, that is, let Cov ≥τ (p) ≥ 1 2 for every p ∈ X . Then, there is an efficient procedure round which opens at most O(k t ) balls of radius O( r t ) for τ ≤ t ≤ L, and covers all of X .
Proof. The procedure round works as follows: we partition the points of X into two sets, one set X U in which the points receive at least 1 4 of the coverage by clusters of radius r i where i ∈ {log log L, log log L + 1, . . . , log L}, and another set X B in which the points receive 1 4 coverage from clusters of levels t ∈ {log L + 1, log L + 2, . . . , L}. More precisely, X U := {p ∈ X : log L t=τ Cov t (p) ≥ 1/4}, and X B = X \ X B . Now consider the following LP-solution to (NUkC LP) for I restricted to X U : we scale x by a factor 4 and zero-out x on radii type r i for i / ∈ {log log L, . . . , log L}. By definition of X U this is a feasible fractional solution; furthermore, the LP-reduction algorithm described in Section 3 will lead to a tree T of height ≤ log L and fractional solution y for (RMFC-T LP) on T were each k i ≥ 2 log log L = log L. Applying Theorem 4.2, we can find an integral solution N with at most O(k i ) vertices at levels i ∈ {log log L, . . . , log L}. We can then translate this solution back using Theorem 3.7 to NUkC and find O(k t ) clusters of radius O( r t ) to cover all the points X U . A similar argument, when applied to the smaller radius types r t for t ∈ {log L, . . . , L} can cover the points in X B .
We now show how we can immediately also get a (very weakly) quasi-polynomial time O(1)-approximation for NUkC. Indeed, if we could enumerate the set of clusters of radii r t for 0 ≤ t < log log L, we can then explicitly solve an LP where all the uncovered points need to be fractionally covered by only clusters of radius type r t for t ≥ log log L. We can then round this solution using Corollary 4.3 to obtain the desired O(1)-approximation for the NUkC instance. Moreover, the time complexity of enumerating the optimal clusters of radii r t for 0 ≤ t < log log L is n O(log L) = n O(log log k) , since the number of clusters of radius at least r log log L is at most O(2 log log L ) = O(log L). Finally, there was nothing special in the proof of Theorem 4.3 about the choice of τ = log log L -we could set t = log (q) L to be the q th iterated logarithm of L, and obtain an O(q)-approximation. As a result, we get the following corollary. Note that this gives an alternate way to prove Theorem 3.5.

Part III: Clever Enumeration of Large Radii Clusters
In this section, we show how to obtain the (O(1), O(1))-factor bi-criteria algorithm. At a high level, our algorithm tries to "guess" the centers 2 A of large radius, that is r i for i ≤ τ := log log L = log log log k, which the optimum solution uses. However, this guessing is done in a cleverer way than in Corollary 4.4. In particular, given a guess which is consistent with the optimum solution (the initial "null set" guess is trivially consistent), our enumeration procedure generates a list of candidate additions to A of size at most 2 τ ≈ poly log logk (instead of n), one of which is a consistent enhancement of the guessed set A. This reduction in number of candidates also requires us to maintain a guess D of points where the optimum solution doesn't open centers. Furthermore, we need to argue that the "depth of recursion" is also bounded by poly log logk; this crucially uses the technology developed in Section 3. Altogether, we get the total time is at most (poly log logk) poly log logk = o(k) for large k.
We start with some definitions. Throughout, A and D represent sets of tuples of the form (p, t) where p ∈ X and t ∈ {0, 1, . . . , τ }. Given such a set A, we associate a partial solution S A which opens a ball of radius 22 r t at the point p. For the sake of analysis, fix an optimum solution OPT. We say the set A is consistent with OPT if for all (p, t) ∈ A, there exists a unique q ∈ X such that OPT opens a ball of radius r t at q and d(p, q) ≤ 11 r t . In particular, this implies that S A covers all points which this OPT-ball covers. We say the set D is consistent with OPT if for all (q, t) ∈ D, OPT doesn't open a radius r t ball at q (it may open a different radius ball at q though). Given a pair of sets (A,D), we define the minLevel of each point p as follows minLevel A,D (p) := 1 + arg max t {(q, t) ∈ D for all q ∈ B(p, r t )} If (A, D) is a consistent pair and minLevel A,D (p) = t, then this implies in the OPT solution, p is covered by a ball of radius r t or smaller. Next, we describe a nuanced LP-relaxation for NUkC. Fix a pair of sets (A, D) as described above. Let X G be the subset of points in X covered by the partial solution S A . Fix a subset Y ⊆ X \ X G of points. Define the following LP.
The following claim encapsulates the utility of the above relaxation. Proof. We describe a feasible solution to the above LP using OPT. Given OPT, define O to be the collection of pairs (q, t) where OPT opens a radius r t ball at point q. Note that the number of tuples in O with second term t is ≤ k t . Since A is consistent with OPT, for every (p, t) ∈ A, there exists a unique (q, t) ∈ O; remove all such tuples from O. Define x q,t = 1 for all other remaining tuples. By the uniqueness property, we see the second inequality of the LP is satisfied. We say a point p ∈ X is covered by (q, t) if p lies in the r t -radius ball around q. Since Y ⊆ X \ X G , and since the partial solution S A contains all points p which is covered by all the removed (q, t) tuples, we see that every point p ∈ Y is covered by some remaining (q, t) ∈ O. Since D is consistent with OPT, for every point p ∈ Y and t < minLevel A,D (p), if q ∈ B(p, r t ) then (q, t) / ∈ O. Therefore, the first inequality is also satisfied.
Finally, for convenience, we define a forbidden set F := {(p, i) : p ∈ X, 1 ≤ i ≤ τ } which if added to D disallows any large radii balls to be placed anywhere. Now we are ready to describe the enumeration Algorithm 3. We start with A and D being null, and thus vacuously consistent with OPT. The enumeration procedure ensures that: given a consistent (A, D) tuple, either it finds a good solution using LP rounding (Step 10), or generates candidate additions (Steps 18-20) to A or D ensuring that one of them leads to a larger consistent tuple. Note that Φ(∅, ∅) = 0. From the previous paragraph, we conclude that in both case (A) or (B), the potential increases by at least 1. Finally, for any consistent A, D we can upper bound Φ(A, D) as follows. Since A is consistent, |A| ≤ τ t=0 2 t ≤ 2 τ +1 = log L = log log k. The second term in Φ is at most 2 τ +1 · τ = log L log log L. Thus, in at most 2 log log k · log log log k < γ 0 steps we reach a consistent pair (A, D) with Step 10 true. Proof. Each single call of Enum is clearly polynomial time, and so we bound the number of recursive calls. Indeed, this number will be o(k). We first bound the number of recursive calls in a single execution of Enum(A, D, γ). For a fixed tuple (A, D), Algorithm 3, constructs trees T 0 , . . . , T τ in Step 17, using the reduction algorithm from Section 3. Let L tj represent the set of nodes at level j in the tree T t . Then P t = ψ t (L tt ) represents the set of points that are winners at level t in T t . Now for any tree T t , Algorithm 3 makes two recursive calls for each winner in P t (Step [19][20]. Let P AD = τ t=0 P t be the set of all the winners that the algorithm considers in a single call to Enum(A, D, γ). The total number of recursive calls in a single execution is therefore 2|P AD |. Now we claim that for a fixed tuple (A, D), the total number of winners is bounded. Claim 4.9. |P AD | ≤ 4 log log k · log log log k Proof. Consider a tree T t and the corresponding set P t as defined above. We use y (t) to denote the RMFC-T LP solution given along with the tree T t given by the reduction algorithm in Section 3. Let p ∈ P t be a winner at level t (and consequently, at level τ also), and suppose it is mapped to tree vertices w at level t and w at level τ . Then, by the way the tree was constructed and because p ∈ X T is top-heavy, we have u∈[w,w ]−path y (t) u ≥ 1 2 (Refer to the proof of Claim 3.3 for more clarity). So each winner at level t has a path down to level τ with fractional coverage at least 1 2 . But the total fractional coverage in the top part of the tree is at most the total budget, which is τ t=1 2 t ≤ 2 log L ≤ 2 log log k. Therefore, |P t | ≤ 4 log log k. Adding for all 1 ≤ t ≤ τ , gives |P AD | ≤ 4 log log k · t ≤ 4 log log k · log log log k.
Since the recursion depth γ 0 , the total number of recursive calls made to the Enum is loosely upper bounded by γ poly log logk 0 = o(k), thus completing the proof.