Asymptotic Quasi-Polynomial Time Approximation Scheme for Resource Minimization for Fire Containment

Resource Minimization Fire Containment (RMFC) is a natural model for optimal inhibition of harmful spreading phenomena on a graph. In the RMFC problem on trees, we are given an undirected tree G, and a vertex r where the fire starts at, called root. At each time step, the firefighters can protect up to B vertices of the graph while the fire spreads from burning vertices to all their neighbors that have not been protected so far. The task is to find the smallest B that allows for saving all the leaves of the tree. The problem is hard to approximate up to any factor better than 2 even on trees unless P = NP (King and MacGillivray in Discret Math 310(3):614–621, 2010). Chalermsook and Chuzhoy (In: Proceedings of the 21st annual ACM-SIAM symposium on discrete algorithms, SODA 2010, Austin, Texas, USA, 17–19 Jan 2010, SIAM, pp 1334–1349, 2010) presented a Linear Programming (LP) based O(log∗n)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log ^* n)$$\end{document} approximation for RMFC on trees that matches the integrality gap of the natural Linear Programming relaxation. This was recently improved by Adjiashvili et al. (ACM Trans Algorithms 15(2):20:1–20:33, 2019) to a 12-approximation through a combination of LP rounding along with several new techniques. In this paper we present an asymptotic QPTAS for RMFC on trees. More specifically, let ϵ>0\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\epsilon >0$$\end{document}, and I\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {I}$$\end{document} be an instance of RMFC where the optimum number of firefighters to save all the leaves is OPT(I)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$OPT(\mathcal {I})$$\end{document}. We present an algorithm which uses at most ⌈(1+ϵ)OPT(I)⌉\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\lceil (1+\epsilon )OPT(\mathcal {I})\rceil $$\end{document} many firefighters at each time step and runs in time nO(loglogn/ϵ)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$n^{O(\log \log n/\epsilon )}$$\end{document}. This suggests that the existence of an asymptotic PTAS is plausible especially since the exponent is O(loglogn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log \log n)$$\end{document}, not O(logn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log n)$$\end{document}. Our result combines a more refined height reduction lemma than the one in Adjiashvili et al. (2019) with LP rounding and dynamic programming to find the solution. We also apply our height reduction lemma to the algorithm provided in Adjiashvili et al. (2019) plus a more careful analysis to improve their 12-approximation and provide a polynomial time (5+ϵ\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$5+\epsilon $$\end{document})-approximation.

also apply our height reduction lemma to the algorithm provided in Adjiashvili et al.

Introduction
The Firefighter problem and a closely related problem named Resource Minimization Fire Containment (RMFC) are natural models for optimal inhibition of harmful spreading phenomena on a graph. The firefighter problem was formally introduced by Hartnell [9] and later Chalermsook and Chuzhoy [5] defined the RMFC problem. Since then, both problems have received a lot of attention in several research papers, even when the underlying graph is a spanning tree, which is one of the most-studied graph structures in this context and also the focus of this paper.
In both problems (when restricted to trees) we are given a graph G = (V , E), which is a spanning tree, and a vertex r ∈ V , called root. The problem is defined over discretized time steps. At time 0, a fire starts at r and spreads step by step to neighboring vertices. During each time step 1, 2, . . . any non-burning vertex u can be protected, preventing u from burning in any future time step.
In the RMFC problem the task is to determine the smallest number B ∈ Z ≥1 such that there is a protection strategy which protects B vertices at each time step while saving all the leaves from catching fire. In this context, B is referred to as the number of firefighters (or budget at each step). In the firefighters problem, given a fixed number of firefighters (i.e. number of vertices that can be protected at each time step) the goal is to find a strategy to maximize the number of vertices saved from catching the fire.
For RMFC on trees, King and MacGillivray [11] showed that it is NP-hard to decide whether one firefighter is sufficient or not. This means that there is no (efficient) approximation algorithm with an approximation factor strictly better than 2, unless P=NP. On the positive side, Chalermsook and Chuzhoy [5] presented an O(log * n)approximation 1 where n is the number of vertices. Their algorithm is based on a natural Linear Programming (LP) relaxation, which is a straightforward adaptation of the one previously used for the Firefighter problem on trees and essentially matches the integrality gap of the underlying LP (the integrality gap of the underlying LP is (log * n) [5]). Recently, Adjiashvili et al. [1] presented a 12-approximation for RMFC, which is the first constant factor approximation for the problem. Their result is obtained through a combination of the known LPs with several new techniques, which allows for efficiently enumerating subsets of super-constant size of a good solution to obtain stronger LPs. They also present a PT AS for the firefighter problem.

Our Results
In this paper our main focus is on RMFC problem. By using Linear Programming and dynamic programming techniques, we show how to approximate RMFC with a small additive error by presenting a quasi-polynomial time asymptotic approximation scheme (AQPTAS) for it. More specifically our main result is the following theorem: Theorem 1 For RMFC on trees and for any > 0 there is an algorithm that finds a solution using 1 + O( ) B firefighters with running time n O(log log n/ ) , where B is the optimal number of firefighters.
We will also show how applying our more refined height reduction lemma to the algorithm used by Adjiashvili et al. [1], plus a more careful analysis, leads to a better constant factor. In particular, we obtain the following: Theorem 2 For any > 0, there is a polynomial time (5 + )-approximation for the RMFC problem on trees.
Recall that the RMFC problem on trees does not admit better than 2-approximation unless P = NP [11]. However, this does not rule out the possibility of an additive approximation or an asymptotic PTAS. Our result is an indication that it is plausible that an asymptotic PTAS exists, especially since the exponent is O(log log n), not O(log n) as we don't know any natural problem that admits n O(log log n) algorithm but not polynomial time.
We start by introducing a more powerful height reduction transformation than the one used in [1] that allows for transforming the RMFC problem into a more compact and better structured form, by only losing a (1 + ) factor in terms of approximability. This transformation allows us to identify small substructures, over which we can optimize efficiently, and having an optimal solution to these subproblems we can define a residual LP with small integrality gap. Then we will show how to apply dynamic programming on the transformed instance to obtain a strategy to protect the nodes at each step to successfully contain the fire and save all the leaves with using only O( B) more firefighters at each step. We will apply our more delicate height reduction lemma to the previous combinatorial approach [1] to reach a better constant factor approximation in polynomial time, which is presented in Theorem 2.

Further Related Work
The Firefighter problem and RMFC, both restricted to trees, are known to be computationally hard problems. More precisely, Finbow, King, MacGillivray and Rizzi [7] showed the NP-hardness for the Firefighter problem on trees even when the maximum degree is three. For RMFC on trees, it is NP-hard to decide whether one firefighter is sufficient or not [11], which implies that the problem is hard to approximate to a factor better than 2.
Several approximation algorithms have been proposed for both of these problems. Hartnell and Li [8] proved that a natural greedy algorithm is a 1 2 -approximation for the Firefighter problem. Later, Cai, Verbin and Yang [3] improved this result to 1 − 1 e , using a natural LP relaxation and dependent randomized rounding. Then Anshelevich, Chakrabarty, Hate, and Swamy [2] showed that the Firefighter problem on trees can be interpreted as a monotone submodular function maximization (SFM) problem subject to a partition matroid constraint. This observation yields another (1− 1 e )-approximation by using a recent (1 − 1 e )-approximation for monotone SFM subject to a matroid constraint [4].
Chalermsook and Vaz [6] showed that, for any > 0, the canonical LP used for the Firefighter problem on trees has an integrality gap of 1 − 1 e + . This generalized a previous result by Cai, Verbin and Yang [3]. When restricted to some tree topologies this factor 1 − 1 e was later improved (see [10]) but, for arbitrary trees, that was the best known approximation factor for a few years.
Recently, Adjiashvili, Baggio and Zenklusen [1] have filled the gap between previous approximation ratios and hardness results for the Firefighter problem. In particular, they present approximation ratios that nearly match the hardness results, thus showing that the Firefighter problem can be approximated to factors that are substantially better than the integrality gap of the natural LP. Their results are based on several new techniques, which may be of independent interest.
Assuming a variant of the Unique Games Conjecture (UGC), the RMFC problem in general graphs is hard to approximate within any constant factor, according to a recent work by Lee [12] which is based on a general method of converting an integrality gap instance to a length-control dictatorship test for variants of the s-t cut problem. For further results and related work we refer the reader to [1].

Organization of the Paper
In Section 2 we start by introducing some preliminaries including a Linear Programming relaxation for the problem and then will provide a height reduction lemma. Section 3 will cover our main algorithm to obtain the asymptotic QPTAS. In Section 4 we will show how to apply our height reduction lemma to the previous combinatorial approach of [1] to improve their 12-approximation and provide a (5+ )approximation.

Preliminaries and Overview of the Algorithm
Recall that we are given a tree G = (V , E) rooted at a vertex r , from which we assume the fire starts. We denote by ⊆ V the set of all leaves of the tree. Given an instance I for RMFC and an integer parameter B ≥ 1, called the budget or the number of firefighters, at each time step we can "protect" up to B non-burning vertices. Such vertices are protected indefinitely. Our goal is to find the smallest B and a protection strategy such that all the leaves are saved from catching the fire. Observe that we say a vertex u is protected, if we directly place a firefighter in u, and a vertex v is saved when the fire does not reach to u, because of protecting some u on the unique v-r path. This smallest value of B is denoted by O PT (I).
Let L ∈ Z ≥1 be the depth of the tree, i.e. the largest distance, in terms of the number of edges, between r and any other vertex in G. After at most L time steps, the fire spreading process will halt. For ∈ [L] := {1, . . . , L}, let V ⊆ V be the set of all vertices of distance from r , which we call the -th level of the instance. We also use V ≤ = ∪ k=1 V k , and we define V ≥ , V < , and V > in the same way. Moreover, for each 1 ≤ < L and each u ∈ V , P u ⊆ V ≤ \ {r } denotes the set of all vertices on the unique u-r path except for the root r , and T u ⊆ V ≥ denotes the subtree rooted at u.

Linear Programming Relaxation
We use the following (standard) Linear Programming (LP) relaxation for the problem that is used in both [5] and [1].
Here x(U ) := u∈U x(u) for any U ⊆ V \ {r }. Note that with x ∈ {0, 1} V \{r } and B ∈ Z ≥0 we get an exact description of RMFC where x is the characteristic vector of the vertices to be protected and B is the budget. The first constraint enforces that for each leaf u, at least one vertex between u and r will be protected, which makes sure that the fire will not reach u. The second constraint ensures that the number of vertices protected after each time step is at most B · and makes sure that we are using no more than B firefighters per time step (see [5] for more details). Note that (as mentioned in [5]), there is an optimal solution to RMFC that protects, with the firefighters available at time step , only the vertices in V . Hence, we can change the above relaxation to one with the same optimal objective value by replacing the constraints Throughout the paper we use a lemma of [1] which basically says that any basic feasible solution of LP(2) (and also LP(1)) is sparse. This is proved for the polytope of the firefighters problem, but a very similary argument shows sparcity of this LP for RMFC (see proof of Lemma 7.1 in [1]). Consider any basic feasible solution x to LP(2). One can partition supp(x) = {v ∈ V \ {r } : x(v) > 0} into two parts: x-loose vertices and x-tight vertices. A vertex v ∈ V \ {r } is x-loose or simply loose if v ∈ supp(x) and x(P v ) < 1. All other vertices in supp(x), which are not loose, will be x-tight or simply tight. Lemma 1 (Lemma 3.1 in [1]) Let x be a vertex solution to LP (2) for RMFC, then the number of x-loose vertices is at most L, the depth of the tree.
We will use this property crucially in the design of our algorithm. Also, as noted in [1], we can work with a slightly more general version of the problem in which we have different numbers of budgets/firefighters at each time step: say B = m B (for some m ∈ Z ≥0 ) firefighters for each time step ∈ [L] while we are still minimizing B. Lemma 1 is valid for this generalization too.

Height Reduction
The technique of reducing the height of a tree at a small loss in cost (or approximation ratio) has been used in different settings and various problems (e.g. network design problems). For RMFC, Adjiashvili et al. [1] showed how one can reduce an instance of the problem to another instance where the height of the tree is only O(log n) at a loss of factor 2. In a sense, the tree will be compressed into a tree with only O(log n) levels. Here we introduce a more delicate version of that compression, which allows for transforming any instance to one on a tree with O( log n ) levels at a loss of 1 + in the approximation. Our compression is similar to that of [1] with an initial delay and ratio 1 + . One key property we achieve with compression, is that we can later use techniques with running time exponential in the depth of the tree.
Suppose that the initial instance is a tree with L levels and each level has a budget B . To compress the tree to a low height one, we will first do a sequence of what is called up-pushes. Each up-push acts on two levels 1 , 2 ∈ [L] with 1 < 2 of the tree, and moves the budget B 2 of level 2 up to 1 . This means the new budget of level 1 will be B 1 + B 2 and for level 2 it will be 0.
We will show that one can do a sequence of up-pushes such that: (i) the optimal objective value of the new instance is very close to the one of the original instance, and (ii) only O(log L/ ) levels have non-zero budgets. Finally, 0-budget levels can easily be removed through a simple contraction operation, thus leading to a new instance with only O(log L/ ) depth. The following theorem is a more powerful version of Theorem 4.1 in [1] with some improvements such as reducing the loss to only 1 + (instead of 2) and some differences in handling of the first levels.

) If the RMFC problem on G has a solution with budget B ∈ Z ≥0 at each level, then the RMFC problem on G has a solution with non-uniform budgets of B = B for each level < c, and a budget of B
(ii) Any solution to the RMFC problem on G , where each level < c has a budget of B = B and each level ≥ c has a budget of B = m · B can be transformed efficiently into an RMFC solution for G with budget (1 + 2 )B .
Proof We start by describing the construction of G = (V , E ) from G. We first change the budget assignment of the instance and then contract all 0-budgets levels.
We set i * to be the smallest integer such that (1 + ) i * ≥ 2(1+ ) 2 and we let c = (1 + ) i * . The set of levels L in which the transformed instance will have non-zero budget contains the first c − 1 levels of G and all the levels ≥ c of G such For all other levels / ∈ L we first do up-pushes. More precisely, the budget of these levels ∈ [L] \ L will be assigned to the closest level in L that is above (has smaller index than ). We then remove all 0-budget levels by contraction. For each vertex v in a level i = (1 + ) i ≥ c we will remove all vertices in the levels i < < i+1 = (1 + ) i+1 from its sub-tree and connect all the vertices in level i+1 of its sub-tree to v directly. This leads to a new tree G with a new set of leaves. Since our goal is to save all the leaves in the original instance, for each vertex v ∈ G such that v ∈ G has some leaves in its contracted sub-tree, we will mark v as a leaf in G and simply delete all its remaining subtree.
This finishes our construction of G = (V , E ) and it remains to show that both (i) and (ii) hold. Note that the levels in G correspond to levels of G in L: the first c levels of G are the same as the first c levels of G; for each > c, level in G is level Here we want to determine what will be the budget of each level of G . For each < c = (1 + ) i * , the level of G is the same as the level of G and has the same budget B = B, because these levels are not involved in up-pushes. For = c, all the budgets from level (1+ ) i * to (1+ ) i * +1 −1 in G are up-pushed to this level. This means that the budget for level To prove (ii), we use the following lemma: Lemma 2 For any two consecutive levels ≥ c and +1 in G , the difference between m and m +1 is relatively small. More precisely: Proof Based on the definition of m and m +1 we have: On the other hand: Also by our choice of c, d and i * = c − d we can conclude that: Combining (4) and (5) completes the proof.

Corollary 1
For each ≥ c and each budget B > 0: Notice that in the constructed graph G for each level ≥ c, we have B = m · B. Now consider the instance of the problem on graph G with budget (1 + 2 )B at each level. We will show that by doing some down-pushes on G (i.e. move the budget of each level to some level down) we can construct G again where the budget of each level is m · B, and this means that if G has a solution with budget m · B in each level, then G has a solution with uniform budget (1 + 2 )B .
Like before the set of levels L with non-zero budgets will be the same. Instead of up-pushes, we will down-push the budget from all levels / ∈ L to the closest level in L which is below (i.e has larger index than ). We will also down-push budget 2 B from each level < c to level = c.
By doing the same contraction, for each level < c we will have B = B and for each level > c we will have B = m −1 · (1 + 2 )B , which is greater than m · B based on the above lemma.
The only remaining level to consider is level = c. For this level, by doing downpushes, we will have budget B c = B + 2 B · c. Our claim is that this is not less than m c · B, which is equal to ( (1 + )c − c) · B (based on the definition of m c ): This will complete the proof of the theorem, because by considering these downpushes, any solution to the RMFC problem on G , where level ≥ c has a budget of B = m · B and level < c has a budget of B = B, can be transformed efficiently into an RMFC solution for G with budget (1 + 2 )B .
In the following we assume that the depth of the tree is not more than log n log(1+ ) + 2(1+ )

Overview of the Algorithm
Given an instance I, our first step of the algorithm is to use Theorem 3 to reduce I to an instance I with L = O(log n/ ) levels. Note that when we use B to refer to core budget for instance I we mean each level has budget m · B for ≥ c, and budget B for each level < c. Also, by O PT (I ) we mean the smallest value B such that I has a feasible solution with core budget B as above. By Theorem 3, if we find a solution with core budget B for I then it can be transformed to a solution for I with budget The difficult case is when B o is small compared to L. The difficulty lies in deciding which vertices are to be protected by the optimum solution in the top h levels of the tree for some h = O(log log n); as if one has this information then we can obtain a good approximation as in [1].
One way to do this would be to guess all the possible subsets of vertices that could be protected by the optimal solution in the first h levels of the tree, but this approach would have a running time far greater than ours. Still, we can solve the problem on instance I in quasi-polynomial time using a bottom-up dynamic programming approach. More precisely, starting with the leaves and moving up to the root, we compute for each vertex u ∈ V the following table. Consider a subset of the available budgets, which can be represented as a vector q ∈ [B 1 ] × ... × [B L ]. For each such vector q and node v, we want to know whether or not using budgets described by q for the subtree T v (subtree rooted at v) allows for disconnecting v from all the leaves below it, i.e. saving all the leaves in T v . Since L = O(log n/ ) and the size of each budget B is at most the number of vertices, the table size is n O(log n/ ) ). Moreover, it is easy to show that this table can be constructed bottom-up in quasi-polynomial time using an auxiliary table and another dynamic programming, to fill each cell of the table.
This approach would have the total running time of n O(log n/ ) , because of the size of the table. In order to reduce the running time to n O(log log n/ ) , we would consider each budget vector value rounded up to the nearest power of (1 + 2 (log n) 2 ). So, instead of O(n L ) = n O(log n/ ) many options for budget vectors q, we will have O((log n/ ) 3L ) = n O(log log n/ ) many options and we will show how by being more careful in our dynamic programming on these budget vectors we can still compute the table in time n O(log log n/ ) ; this leads to an approximation scheme (instead of the exact algorithm) for the instance I .

Asymptotic Approximation Scheme
As mentioned above, first we use the height reduction as discussed in the previous section to reduce the given instance I to a new one I with L = O( log n ) levels. We assume we have guessed a value B o ≥ O PT (I ). Recall that, as in the statement of Theorem 3, for some constants c, d (depending on ) the budget of each level We consider two cases: (I) when B o > L , and (II) when B o ≤ L . For the first case we show how we can find a solution with core budget at most (1 + )B o by rounding the standard Linear Programming relaxation. For the second case we show how we can use a bottom-up dynamic programming approach to find a quasi-polynomial time approximation scheme.

Easy Case: B o > L
In this case we consider LP(2) (with fixed B = B o ) for this instance. If x * is a feasible solution to this LP and B o > L then we add L ≤ B o extra budget (i.e. number of firefighters) to the first level which is enough to protect all the loose vertices. Since by using Lemma 1 we know that there are at most L loose vertices and we can protect them all in the first step using L extra firefighters.
It remains to show that by using a budget of m · B o at every level , for c ≤ ≤ L, and B o for < c, we can protect all the tight vertices and so all the leaves would be saved, by adding only L many extra firefighters to only the first level.
Observe that for each tight vertex v, either x(v) < 1, then we would have a loose vertex in P v , or x(v) = 1. In the first case v is already saved by protecting the loose vertices in the first step. If we only consider vertices with x(v) = 1, we can see that the solution is integral itself for these vertices. So we have rounded a fractional solution with B o > L to an integral one by using only B o more firefighters just in the first level. In this case we find a feasible solution with core budget B o + B o in polynomial time.

When B o ≤ L
Recall that we have a budget of B = B o < L/ for each level < c and B = m · B o ≤ m · L for each c ≤ ≤ L. We denote by q * the L-dimensional total budget vector that has q * [ ] = B for each 1 ≤ ≤ L. Also for each L-dimensional vector q ∈ [B 1 ] × [B 2 ] × ... × [B L ], we denote by Q(q) the set of all vectors q such that q ≤ q. Suppose that |Q(q * )| = m. We first describe a simpler (and easier to explain) dynamic programming with running time n O(log n/ ) . Then we change it to decrease the running time and have our final approximation scheme with running time n O(log log n/ ) .

First Algorithm
Our dynamic program (DP) consists of two DP's: an outer (main) DP and an inner DP. In our main DP table A we have an entry for each vertex v and each vector q ∈ Q(q * ). This entry, denoted by A[v, q], will store whether using budgets described by q for levels of T v allows for disconnecting v from all leaves below it or not.
More formally, if we assume v ∈ V , then A[v, q] would be true if and only if there is a strategy for T v such that (i) all the leaves in T v are saved, and (ii) the budget for levels of T v are given by vector q in indices + 1, . . . , L, 2 · m 3 ). We need to find A[r , q * ]. If this cell is true, then we can save all the leaves of the tree using q * as the budget vector for each level and if it is false, B o would not be enough.
The problem is that m could be large (m L = O(n)) and so the options we have for the budget of each level is O(n) and this will result in a run time that is much larger than wanted, as explained below. Recall that we can have This means that the total running time will be O(n L ) = n O(log n/ ) and this is an exact algorithm to solve the RMFC problem on instance I .

Reducing Budget Possibilities
To reduce the running time, we only consider budget vectors where each entry of the vector is a power of (1 + / log  RU (q)] is also true. So we only try to fill in entries of the table that correspond to vectors q where each entry is a power of (1 + ( / log n) 2 ). We show this can be done in time n O(log log n/ ) and the total loss in approximation is at most 1 + at the root of the tree.
From now on, we assume each vector q has entries that are powers of (1 + ( / log n) 2 ) and recall that Q(q) is the set of all such vectors q such that q ≤ q; we denote by Q (q) the set of all vectors q such that q ≤ q and each entry of q is a power of (1 + ( / log n) 2 ). Assume we have already calculated A[u j , q ] for every vector q ∈ Q (q).
If we try to compute A[v, q] from A[u j , q ]'s the same way, we need to calculate B[v, q , j] for each 1 ≤ j ≤ k and each time we round up the results of addition/subtractions (such as q − q ) to the nearest power of (1 + ( / log n) 2 ).

Reducing Height of Inner Table
To compute cell A [v, q] then this round-up operation could happen k = O(n) times and the approximation loss blows up. Instead, we consider a hypothetical full binary tree with root v and leaves (at the lowest level) being u 1 , . . . , u k ; this tree will have height O(log k) = O(log n). Then we define a cell in our auxiliary table for each internal node of this tree. See Figure 1 for an illustration.
More formally we would define a cell in our auxiliary table is supposed to determine if the budget vector q is enough for the subtrees rooted at u j 1 , . . . , u j 2 , where j 1 = 2 j · ( j − 1) + 1 and j 2 = min{2 j · j , k}, to save all the leaves in those subtrees, where the total budgets for the union of those subtrees is given by q .
Similar to what we did before, we can compute . At each step we are computing a cell in table B a round-up will be applied to make the result of vector subtraction to be a vector with entries being powers of (1 + ( / log n) 2 ). If we can find a q such that both B[v, q , j − 1, 2 j − 1] and B[v, RU (q − q ), j − 1, 2 j ] are true, then B[v, q , j, j ] would be true too. Also we can fill A[v, q] by checking the value of B[v, q i , log k , 1].
In the way we construct our auxiliary tables, while computing A [v, q], when v has k children, log k many round up operations have happened (going up the auxiliary tree with root v) to the solution we found for T v only in this step. This means that O(log k) ≤ O(log n) many round-ups could happen to compute entry A[v, q] and the total number of round-ups starting from the values of A[., .] at a leaf level to A[r , q] (for any q) would be at most L × log n ≤ log 2 n and at each round-up we increase our budget by a factor of (1 + ( / log n) 2 ). So the total approximation increase while computing the entries for A [r , .] would be at most: Observe that for every node v and subtree T v if there is a solution with budget vectors q then there is a solution with budget vector RU (q) as well. Using this fact we can find a solution with budget vector at most (1 + O( ))q * if there exists a solution with budget vector q * . This completes the proof of Theorem 1.

Polynomial (5 + )-Approximation for RMFC
In this section we show how the approach introduced in [1] can be adapted so that along with our height reduction lemma gives a (5 + )-approximation. We largely follow the proof of [1] only pointing out the main steps that need slight adjustments.
First we describe a very highlevel overview of the algorithm of [1]. They first prove a height reduction lemma loosing a factor 2. Then define The LP relaxation is to find minimum B ≥ 1 such that P B is non-empty. They show that one can round an LP solution with constant factor loss such that those leaves where they are "mostly" cut-off in the LP solution in the lower levels (i.e. they have a large x-load on the levels far away from the root) are saved. They then present a recursive LP-guided enumeration algorithm that finds a good solution for leaves that are mostly saved on the levels close to the root.
We follow the same paradigm, except we use our stronger height reduction lemma that has a (1 + ) factor loss (instead of 2). We deffine sets P B and P B similarly and let x ∈ P B an LP solution. We define W x as the set of leaves that are (fractionally) cut off from r largely on low levels, i.e. there is high x-value on P u on vertices far away from the root. We first start by recalling Theorem 4.2 from [1] which basically says that we can round an LP solution to an integral one by increasing the core budget B by a small constant such that W x can be saved.

Theorem 4 (modified version of Theorem 4.2 in [1])
Let B ∈ R ≥1 , μ ∈ (0, 1], and h = log 1+ L . Let x ∈ P B with value B and supp(x) ⊆ V >h , and we define W = {u ∈ |x(P u ) ≥ μ}. Then one can efficiently compute a set R ⊆ V >h such that: -R ∩ P u = ∅ ∀u ∈ W , and -There is an integral solution z = y 1 + y 2 , which is a combination of two integral solutions y 1 and y 2 with value B = 1 μ B and 1 respectively such that supp(y 1 ) ⊆ V >h and supp(y 2 ) ⊆ V ≤h .
Proof The proof would be very similar to the proof of Theorem 4.2 in [1], and the only difference is in providing the extra budget for protecting the loose vertices in V >h . They changed B to B + 1 at level h + 1 to provide this required budget. That was enough, because the budget in the reduced instance is B h+1 = 2 h+1 · B at this level, and so by this change 2 h = L many more firefighters are available and they are enough to protect all the loose vertices. But we need to change B to B + 1 on all levels 1 to h, to have L many more firefighters for protecting all the loose vertices. This is because our budget in the reduced instance is B = B when 1 ≤ < c and B = m · B when c ≤ ≤ L. So by this change, we should have c − 1 more firefighters in total for the first c − 1 levels and h =c m many more firefighters for levels c to h and the total would be (1 + ) h = L, which is enough to protect all the loose vertices. But the difference in our integral solution is that all the added budgets are from levels 1 to h (one for each level), and the remaining integral solution, which is 1 μ feasible, is the subset of V >h . This completes the proof of this theorem.
Similar to [1], we consider two cases based on how B compares to log L. When B ≥ log L, we will have a 3-approximation for the reduced instance, by first finding a optimum LP solution x ∈ P B . This is similar to Theorem 4.3 in [1] and consistent with our height reduction lemma:

Theorem 5 (modified version of Theorem 4.3 in [1]) There is an efficient algorithm that computes a feasible solution to a compressed instance of R M FC with budget at most 3B O PT (where B O PT is the optimal budget) when B ≥ log L.
Proof The proof is largely following Theorem 4.3 in [1]. Here is a short version adapted. Assume x ∈ P B is a fractional solution with value B. Then we use Theorem 4 and set μ = 1/2 to obtain an integral solution z, which saves W = {u ∈ |x(P u ) ≥ μ}, by core budget 1 at each level 1 ≤ ≤ h and 2B at each level h + 1 ≤ ≤ L. Note that we can now transfer the 1 unit of budget from the very first level = 1 to level h + 1 and change the core budget 2B to 2B + 1 on this level and remove that extra budget from the very first level. This is because these extra firefighters from levels 1 to h are supposed to protect the loose vertices, which are in V >h . By doing so we have an integral solution z such that the core budget is 0 in the first level, 1 in levels 2 to h, 2B + 1 at level h + 1, and 2B at level h + 2 to L. Now consider leaves \ W . If we write another LP similar to P B , but specifically to save only these leaves by only protecting the vertices in V ≤h , this LP would be feasible. Because all these vertices had x(P u )∩ V ≤h ≥ 0.5, and so, 2x restricted to the vertices in V ≤h , would be a feasible solution to this LP. Hence, we can find the optimal solution to this LP call it y. Based on Lemma 1, there would be at most h = log L many loose vertices all in V ≤h , and so by adding B > log L = h many firefighters in the first level we would be able to protect all these y-loose vertices. Then all other remaining vertices could be saved by core budget 2B. Putting these two solutions together (for saving W and \ W ) we have found an integral solution to save all the leaves, by having core budget 3B in the first level, 2B + 1 in levels 2 to h + 1, and 2B at the remaining levels. This completes the proof of this theorem.
So this theorem implies a 3-approximation for the case that B is relatively large (compared to log L). In the rest of this section we explain what to do for when B is small. We describe and use the terminology defined before Lemma 4.4 in [1]. Their algorithm has an enumeration over some specific pairs of sets of vertices and solves LPs where explicitly some vertex set A ⊆ V ≤h is to be part of protected vertices and some some excluded set D ⊆ V ≤h not being protected in the top levels of the tree. They define the following LP(A,D) for two disjoint sets A, D ⊆ V ≤h : to be the set of leaves cut off from the root by an x-load of at least μ = 1 1+ within bottom levels (we changed 2 3 to 1/(1 + ) from [1]). For each u ∈ \ W x , let f u ∈ V ≤h be the vertex closest to the root among all vertices in (P u ∩ V ≤h ) \ D, then define F x = { f u |u ∈ \ W x } \ A. As mentioned in [1], the main idea behind introducing F x is that to guess the vertices of O PT in the top levels, it is enough to focus on the vertices that are below some vertex in F x . It follows that no two vertices of F x lie on the same leaf-root path. Furthermore, every leaf u ∈ \ W x is part of the subtree T f for precisely one f ∈ F x . Also let us define  (A, D), we are actually saving W 1 . and for W 2 there is an integral solution with core budget B O PT , which is restricted to levels h + 1 to L. So the optimum solution to L P(A, V ≤h \ A) would not use more than (1 + )B O PT + B O PT as the core budget in levels h + 1 to L. This completes the first part of lemma. To round this fractional solution to an integral one which saves W x and W 2 (note that W 1 is saved already by the choice of A and D), we use the same technique as Theorem 4.
We need to first find an integral solution restricted to levels h 1 = log L to L that saves the leaves with y(P u ∩ V >h 1 ) ≥ 1 2(1+ ) by adding one core budget to levels 1 to h 1 and then write another LP restricted to levels h to h 1 . Then we find another integral solution restricted to levels h to h 1 by adding another core budget to levels 1 to h that saves all the remaining leaves, which for sure has y(P u ∩ V >h ∩ V ≤h 1 ) ≥ 1 2(1+ ) . Consider a vertex f u ∈ F x where u ∈ \ W x , since u is a leaf outside W x we have x(P u ∩ V ≤h ) > 1 − 1 . Because no two vertices of F x lie on the same leaf-root path, the sets T f u ∩ V ≤h are all disjoint for different f u ∈ F x and hence Considering the assumption B ≤ log L, then we have |F x | < (1+ ) log 2 L 2 . Notice that the number of different pairs in our list with label 1 is at most 2|F x |, and label 2 at most (2|F x |) 2 and so on. So the total size of our list would be O((2|F x |) γ ) which is polynomial considering L ≤ O(log n).
So, it remains to show that at least one pair in our list is satisfying the conditions of Lemma 3. For any clean pair (A, D) compatible with O PT , we define a potential function (A, D) ∈ Z ≥0 in the following way. For each u ∈ O PT ∩V ≤h , let d u ∈ Z ≥0 be the distance of u to the first vertex in A ∪ D ∪ {r } when following the unique u-r path. We define (A, D) = u∈O PT ∩V ≤h d u . Notice that as long as we have a triple (A, D, x) on our execution path that does not satisfy the conditions of Lemma 3, then the next triple (A , D , x ) on our execution path satisfies (A , D ) < (A, D). Hence, either we will encounter a triple on our execution path satisfying the conditions of Lemma 3 while still having a strictly positive potential, or we will encounter a triple (A, D, x) compatible with OPT and (A, D) = 0, which implies O PT ∩ V ≤ h = A and we thus correctly guessed all vertices of O PT ∩V ≤h implying that the conditions of Lemma 3 are satisfied for the triple (A, D, x). Since (A, D) ≥ 0 for any compatible clean pair (A, D), this implies that a triple satisfying the conditions of Lemma 3 will be encountered if the recursion depth γ is at least (∅, ∅). To evaluate (∅, ∅) we have to compute the sum of the distances of all vertices u ∈ O PT ∩ V ≤h to the root. The distance of u to the root is at most h since u ∈ V ≤h . Moreover, |O PT ∩ V ≤h | < (1 + ) (h+1) B O PT due to the budget constraints, implying that a triple fulfilling the conditions of Lemma 3 is encountered. This means that we are able to find a (5+ )-approximation for the reduced instance of the RMFC problem to have a (5 + )-approximation.

Conclusion
In this paper we presented an asymptotic QPTAS for RMFC on trees. More specifically, let > 0, and I be an instance of RMFC where the optimum number of firefighters is O PT (I). We presented an algorithm that uses at most (1 + )O PT (I) many firefighters at each step and runs in time n O(log log n/ ) . Our result combines a more refined height reduction lemma than the one in [1] by using dynamic programming to find the solution. We also provided a polynomial time (5 + )-approximation for the problem by applying our height reduction lemma to the algorithm provided in [1] as well as some minor changes to improve the best previously known 12-approximation.
We believe that it should be possible to have an asymptotic PTAS for the RMFC problem. Perhaps one way is to somehow guess the upper part of the optimal solution in polynomial time and then use the LP to round the solution for the height reduced instance for which we initially applied the height reduction lemma.