Firefighting on Trees

02/06/2019 ∙ by Pierre Coupechoux, et al. ∙ CNRS RMIT University 0

In the Firefighter problem, introduced by Hartnell in 1995, a fire spreads through a graph while a player chooses which vertices to protect in order to contain it. In this paper, we focus on the case of trees and we consider as well the Fractional Firefighter game where the amount of protection allocated to a vertex lies between 0 and 1. While most of the work in this area deals with a constant amount of firefighters available at each turn, we consider three research questions which arise when including the sequence of firefighters as part of the instance. We first introduce the online version of both Firefighter and Fractional Firefighter, in which the number of firefighters available at each turn is revealed over time. We show that a greedy algorithm on finite trees is 1/2-competitive for both online versions, which generalises a result previously known for special cases of Firefighter. We also show that the optimal competitive ratio of online Firefighter ranges between 1/2 and the inverse of the golden ratio. Next, given two firefighter sequences, we discuss sufficient conditions for the existence of an infinite tree that separates them, in the sense that the fire can be contained with one sequence but not with the other. To this aim, we study a new purely numerical game called targeting game. Finally, we give sufficient conditions for the fire to be contained, expressed as the asymptotic comparison of the number of firefighters and the size of the tree levels.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction and Definitions

1.1 Context

Since it was formally introduced by B. Hartnell in 1995 ([18], cited in [13]) the firefighting problem - Firefighter - has raised the interest of many researchers. While this game started as a very simple model for fire spread and containment problems for wildfires, it can also represent any kind of threat able to spread sequentially in a network (diseases, viruses, rumours, flood …).

It is a deterministic discrete-time one-player game defined on a graph. In the beginning, a fire breaks out on a vertex and at each step, if not blocked, the fire spreads to all adjacent vertices. In order to contain the fire, the player is given a number of firefighters at each turn and can use them to protect vertices which are neither burning nor already protected. The game terminates when the fire cannot spread any further. In the case of finite graphs the aim is to save as many vertices as possible, while in the infinite case, the player wins if the game finishes, which means that the fire is contained.

This problem and its variants give rise to a generous literature; the reader is referred to [13] for a broad presentation of the main research directions. A significant amount of theoretical work deals with its complexity and approximability behaviour in various classes of graphs [6, 8, 12, 15] and its parametrised complexity (e.g. [5, 8]). In particular, when one firefighter is available at each turn it is known to be polynomially solvable in some classes of graphs, which include graphs of maximum degree 3 if the fire breaks out on a vertex of degree at most 2 [12], interval graphs, permutation graphs and split graphs [15]. However it is known to be very hard, even in some restrictive cases. In particular, the case of trees was revealed to be very rich and a lot of research focuses on it. The problem, with the same number of firefighters at each turn, is NP-hard on finite trees of maximum degree 3 [12], as well as in even more restricted cases [6]; the reader is also referred to [9] for further complexity results. Regarding approximation results on trees, a greedy strategy was first shown to be a -approximation algorithm  [17] if a fixed number of firefighters is available at each turn. For a single firefighter, a -approximation algorithm is proposed in  [8] for the problem in trees. This ratio was improved in [19] for ternary trees and, very recently, a polynomial time approximation scheme was obtained in trees [1]; which essentially closes the question of approximating the firefighter problem in trees with one firefighter and motivates considering some generalisations. The problem is hard to approximate within on general graphs and with a single firefighter [3].

Most papers on this subject deal with a constant firefighter sequence. In fact, the problem was originally defined with one firefighter per turn. The case of infinite grids is of particular interest and has led to the model being extended by varying the available resources per turn. The change was motivated by the fact that a fire of any size on a 2-dimensional infinite grid can be contained with two firefighters per turn but not with one [14, 24]. In order to refine these results, M.-E. Messinger started considering periodic firefighter sequences [23] while more general sequences are considered in [11]

. A related research direction investigates integer linear programming models for the problem, especially on trees 

[1, 16, 22]. This line of research makes very natural a relaxed version where the amount of firefighters available at each turn is any non-negative number and the amount allocated to vertices lies between 0 and 1. A vertex with a protection less than 1 is partially protected and its unprotected part can burn partially and transmit only its fraction of fire to the adjacent vertices. Thus, the may take any non-negative value. This defines a variant game called Fractional Firefighter which was introduced in [14].

1.2 Our contribution

The main thread of this paper is the focus on general firefighter sequences, which raises three specific research questions. We address these questions when a single fire spreads throughout a rooted tree.

First, we introduce an online version of both Firefighter and Fractional firefighter where the sequence of firefighters is revealed over time (online) while the graph (a tree in our case) is known from the start. To our knowledge, this is the first attempt at analysing online firefighter problems. Although our motivation is mainly theoretical, this paradigm is particularly natural in emergency management where one has to make quick decisions despite lack of information. Any progress in this direction tells us how lack of information impacts the quality of the solution. Note that a version of the game introduced in [7] also models a lack of information. In that version, rather than the firefighting resources, the missing information is where the fire will spread. Also, they propose randomised analyses to maximise the expected number of saved vertices while we use worst case analyses expressed in terms of competitive ratios.

A second question, the separating problem, deals specifically with infinite trees. Separating two given firefighter sequences means finding an infinite tree on which the fire can be contained with one sequence but not the other.

The third question deals with criteria for the fire to be contained based on the asymptotic behaviours of the firefighter sequence and the size of the levels in the tree. Unlike the first two questions, it has already been investigated in other papers (e.g., [10, 20]) for Firefighter with firefighter sequences of the form .

The paper is organised as follows: in Section 2 we define formally Firefighter and Fractional Firefighter as well as their online versions. Section 3 deals with competitive analysis when the fire spreads in a finite tree and the firefighter sequence is revealed online. We first generalise an analysis of a greedy algorithm known only in special cases of Firefighter to Fractional Firefighter. For the offline case, it answers an open question proposed in [13, 16]. Then we propose improved competitive algorithms for online Firefighter with a small total number of firefighters while establishing that the greedy approach is optimal in the general case. The last two sections (Section 4 and Section 5) both deal with the infinite case. Section 4 deals with our second question. Considering the class of spherically symmetric trees where all vertices at the same level have the same degree, we express the separation problem as a purely numerical one-player game, which we call the targeting game. We propose two sufficient conditions for the existence of a winning strategy. Section 5 deals with our third question. We establish sufficient conditions for containing the fire expressed as asymptotic comparisons of the number of available firefighters and the size of the levels in the tree. In the online case, for a particular class of trees the level size of which grows linearly, we also give a sufficient condition to contain the fire.

1.3 Some notations

Given a tree rooted in , and will denote the vertex set and the edge set of , respectively. Given two vertices and , denotes that is an ancestor of (or is a descendant of ) and denotes that either or . For any vertex , let denote the sub-tree induced by and its descendants. Let denote the -th level of rooted in , where . For a finite tree rooted in , the height is the maximum length of a path from to a leaf. If , we have . The weight of a vertex is the number of vertices of . When no ambiguity may occur, we will simply write .

We denote by the tree obtained from by contracting all vertices from levels and into a new root vertex : for all and , every edge is contracted and every edge gives rise to an edge . For , will denote the iteration of applied to : all vertices from levels to are contracted into a single vertex denoted by which becomes the new root.

Given a predicate , we denote by

the associated characteristic function so that

if is true and otherwise.

2 Problems and preliminary results

2.1 Firefighter and Fractional Firefighter

An instance of the Fractional Firefighter is defined by a triple , where is a finite graph, is the vertex where the fire breaks out and is the non-negative firefighter sequence, ( indicates the amount of protection that can be placed at turn ). Note that the game could be extended by allowing negative values for , however, we will exclude pyromaniac firefighters from this paper, with one exception in Section 4.2 for the purpose of simplifying a proof. Let denote the cumulative amount of firefighters received: .

Turn is the initial state where is burning and all other vertices are unprotected, and corresponds to the different rounds of the game. At each turn and for every vertex , the player decides which amount of protection to add to , with . Throughout the game, for every vertex the part of which is burning at turn is denoted by , with , and for all . Similarly the cumulative protection received by vertex is with for all . Both and are non-decreasing sequences with for all and . At each turn , the player’s choice of is subject to the constraints , and . The new protection of is . The fire then spreads following the rule


where denotes the open neighbourhood of . The game finishes when the fire stops spreading (i.e. for all ).

The standard Firefighter problem is similar to Fractional Firefighter, but with the additional constraint that the

are all binary variables. It follows that

and are also binary. In this case, we require that the firefighter sequence has integral values.

We will now show that both versions of the game always terminate on a finite graph . Let denote the maximum length of an induced path in with extremity , we have:

Proposition 1.

The maximum number of turns before a game of Firefighter or Fractional Firefighter on a finite graph will terminate is .


First, we show by induction on that:

For all , for all vertex , if , then there is an induced path of length such that is non-increasing along the path.

For and , if then is a neighbour of and . The path is of length 1.

Suppose the property holds at turn and that for some . Necessarily, receives the additional amount of fire from a neighbour :

We necessarily have since otherwise and we would have the following contradiction:

Applying to the induction hypothesis, there is an induced path such that is non-increasing. Since, , we have .

Also, for all , and are not adjacent since otherwise, we would have the following contradiction:

It follows that the path obtained by adding the edge to is an induced path which satisfies the required property.
Thus, if for some , we have . Consequently, the fire can no longer spread at turn .

Conversely, let be an induced path with extremity of length . If and if the complement of is protected during the first turn, the game will terminate in exactly turns. ∎

Example 1.

On a perfect binary tree of height , given one firefighter per turn, the length of (Fractional) Firefighter is exactly , whatever the player’s strategy (this will be an immediate consequence of Proposition 4).

2.2 Simplification for Trees

In this paper, we focus on the case of trees. Given an instance , where is a tree, will be considered rooted in . In order to remove trivial cases, we will exclude algorithms which place at turn more protection on a vertex than the part of that would burn if no protection were placed starting from turn . If is finite, Proposition 1 implies that the game will end in at most turns. We consider that it has exactly turns, eventually with empty turns where no firefighters are allocated towards the end of the game.

Solutions on trees have a very specific structure. Indeed, it immediately follows from Equation 1 that, when playing on a tree, at each turn , the amounts of fire are non-increasing along any path from the root, which means that the fire will only spread outwards from the root. Also, for every vertex in for some , the amount of fire can no longer increase after turn . Hence, no protection is placed in at turn . Note also that for any solution which allocates a positive amount of protection at turn to a vertex , allocating the same amount of protection to the parent of instead strictly improves the performance. Indeed, if vertex can still burn, so can its parent. So we may consider only algorithms that play in at turn . For an optimal algorithm, this property was emphasised in [17].

This holds for both Firefighter and Fractional Firefighter on trees. For such an algorithm, and the values of and will not change after turn for . Hence, the index may be dropped by denoting and for . A solution is then characterised by the values . For any solution , while represents the amount of protection received directly, vertex also receives protection through its ancestors, the amount of which is denoted by (used in Section 3.1). Since we only consider algorithms that play in at turn and do not place extraneous protection, for any vertex , . Also, for any vertex , we have and by summing Equation 1 from to , we deduce that .

Any solution for Firefighter or Fractional Firefighter will satisfy the constraints:

In [22], a specific boolean linear model has been proposed for solving Firefighter on a tree involving these constraints. Solving Fractional Firefighter on corresponds to solving the relaxed version of this linear program.

2.3 Online version

Online optimisation [4] is a generalisation of approximation theory which represents situations where the information is revealed over time and one needs to make irrevocable decisions. Following the definitions of [2], we now introduce online versions of Firefighter and Fractional Firefighter on trees. The graph and starting point of the fire are known from the start by the player, but the firefighter sequence is revealed over time, i.e., at step the player does not know any request with . This set-up can be seen as a game between the online player (or algorithm) and an oblivious adversary. At each turn , the oblivious adversary reveals and then the player chooses where to allocate this resource. We refer to the usual case, where is known in advance by the player, as offline.

Let us consider an online algorithm for one of the two problems and let us play the game on a finite tree until the fire stops spreading. The value achieved by the algorithm, defined as the amount of saved vertices, is measured against the best value performed by an algorithm which knows in advance the sequence . In the present case, it is simply the optimal value of the offline instance, referred to as the offline optimal value, denoted by when considering the online Firefighter ( stands for “Integral”) and for the online Fractional Firefighter. We will call such an algorithm, able to see the future and guaranteeing the value or for online Firefighter and Fractional Firefighter.

Algorithm is said to be -competitive, , for the online Firefighter (resp. Fractional Firefighter) if for every instance, (resp. ); is also called a competitive ratio guaranteed by . An online algorithm will be called optimal if it guarantees the best possible competitive ratio. It should be noted that to calculate the competitive ratio, it is necessary to evaluate the worst case of all the adversary’s possible choices. This is actually like considering a malicious adversary instead of an ignorant one.

The arguments given in Section 2.2, to justify considering only algorithms that play in at turn , are still valid for online algorithms; thus we will only consider such online algorithms. Let us start with a reduction:

Proposition 2.

We can reduce online (Fractional) Firefighter on trees to instances where .


If for all such that , then the instance is equivalent to the instance . ∎

In the infinite case we do not define competitive ratios, but only ask whether the fire can be contained by an online algorithm. Sections 3.2 and 3.1 deal with the finite case while Section 5.2 deals with a class of infinite trees.

3 Online Firefighting on Finite Trees

3.1 Competitive analysis of a Greedy algorithm

Greedy algorithms are usually very good candidates for online algorithms, sometimes the only known approach. Mainly two different greedy algorithms have been considered in the literature for Firefighter on a tree [13] and they are both possible online strategies in our set-up. The degree greedy strategy prioritises saving vertices of large degree; it has been shown in [6] that it cannot guarantee any approximation ratio on trees, even for a constant firefighter sequence. A second greedy algorithm, introduced in [17] for an integral sequence , maximises at each turn the total weight of the newly protected vertices. We generalise it to any firefighter sequence for both the integral and the fractional problems. Let denote the greedy algorithm that selects at each turn an optimal solution of the linear program with variables and constraints :

An optimal solution of is obtained by ordering vertices of level by non-increasing weight and taking them one by one in this order and greedily assigning to vertex the value . Note that is valid for both Firefighter and Fractional Firefighter.

It was shown in [17] that the greedy algorithm on trees gives a -approximation of the restriction of Firefighter when a single firefighter is available at each turn. They claim that this approximation ratio remains valid for a fixed number of firefighters at each turn. We extend this result to any firefighter sequence , integral or not. Since is an online algorithm, the performance can also be seen as a competitive ratio for the online version.

Theorem 1.

The greedy algorithm is -competitive for both online Firefighter and Fractional Firefighter on finite trees.


Let us first consider the fractional case with an online instance of Fractional Firefighter on a tree.

Let and be the amounts of firefighters placed on vertex by and , respectively. We have and .

Recall that and . We split into two non-negative quantities, , where is the part of already protected by through the ancestors of , while is the part of which, when added on top of , exceeds . So, if , we have . The general formula is:

We now claim that , and prove it by induction. Since , it holds for the root . Assuming that the inequality holds for a vertex , let be a child of . If , then we directly have:

Else, and using and , the inequality holds for ; which completes the proof of the claim. Thus:

Since , by changing the order of summation on both sides, we obtain:


Let us now consider the coefficients . We claim that the coefficients with satisfy the constraints and of : indeed for , we have and satisfies constraint . For note that .

Hence, and therefore:


Finally, since , we conclude from Equations 3 and 2 that .
Hence the Greedy algorithm is -competitive for the online Fractional Firefighter problem. Since the greedy algorithm gives an integral solution if has integral values and since , it is also -competitive for the Firefighter problem. This concludes the proof of Theorem 1.

Conjecture 2.3 in [16] (which is also Conjecture 3.5 in [13]) claims that there is a constant such that the optimal value of Fractional Firefighter on trees is at most times the optimal value of Firefighter. It was supported by extensive experimental tests [16], but finding such a constant and proving the ratio is one of the open problems proposed in [13] (Problem 7). Theorem 1 can be expressed as , which shows that is such a constant:

Corollary 1.

In Fractional Firefighter on trees, the amount of vertices saved is at most twice the maximum number of vertices saved in Firefighter.

3.2 Improved Competitive Algorithm for Firefighter

In this section, we investigate possible improvements for online strategies for Firefighter on finite trees. Let denote the golden ratio, satisfying .

For any integer , we denote by the best possible competitive ratio for online Firefighter on finite trees if at most firefighters are available in the entire game. We have:

where denotes the set of finite rooted trees, the set of online algorithms for Firefighter on finite trees and denotes the set of positive integers.

Note that in the definition of , and depend on . Also, the maximum and the minimum are well defined since on a finite tree , the set of possible ratios is finite. An online algorithm, choosing for any fixed a strategy which achieves this maximum, will be -competitive for instances with at most firefighters. Such an algorithm is optimal for these instances.

The sequence is non-increasing. We define ; again, the index stands for Integral and refers to the Firefighter problem.

Remark 1.

The limit is the greatest competitive ratio that can be reached on any tree. Indeed, given a finite tree , it suffices to consider the instances with at most firefighters.

In this section, we give an online algorithm for instances of Firefighter on a finite tree that is optimal (i.e., -competitive) if at most two firefighters are presented. Based on Proposition 2, we may assume . If , one firefighter will be called the first and the other one the second. An online instance is then characterised by when the second firefighter is presented. It can be never if only one firefighter is presented or at the first turn if . Note that this later case is trivial since an online algorithm can make the same decision as by assigning both firefighters to two unburnt vertices of maximum weights. Our algorithm works also in this case and will make this optimal decision.

Lemma 1.

Let and be two vertices of maximum weights in . If , there is an optimal offline algorithm for Firefighter which places the first firefighter on either or .


If the first firefighter is placed on by an optimal offline algorithm, since at most two firefighters are available, , burns completely. Hence, replacing by when assigning the first firefighter would produce another optimal solution (necessarily ). ∎

We suppose has this property. However, even if , he will not necessarily choose ; as illustrated by the graph (Figure 1) where if the firefighter sequence is , then ’s needs to protect during the first turn. Note also that, when the root is of degree at least 3, the second firefighter is not necessarily in .

We now consider Algorithm 1 and assume that the adversary will reveal at most two firefighters. The algorithm works on an updated version of the tree: if one vertex is protected, then the corresponding sub-tree is removed and all the burnt vertices are contracted into the new root so that the algorithm always considers vertices of level 1 in . Before starting the online process, the algorithm computes the weights of all vertices. The weights of the unburnt vertices do not change when updating . The value of , required in line 9, can be computed during the initial calculation of weights and easily updated with . For the sake of clarity, we do not detail all updates in the algorithm.

In this section only, for any vertex and any , we denote by a vertex of maximum weight in , i.e. among the descendants of which are in level (or itself if ). We also define for all via:

0:  A finite tree with root - An online adversary.
1:  ; Compute ,
2:  ;
3:  {Start of the online process}
4:  At each turn, after the fire spreads, is updated - burnt vertices are contracted to ;
5:  If several firefighters are presented at the same time, we consider them one by one in the following lines;
6:  if a new Firefighter is presented and has at least one child then
7:     if  then
8:        Let and denote two children of with maximum weight and ( if has only one child);
9:        if  then
10:           Place the first firefighter on ;
11:        else
12:           Place the first firefighter on ;
13:        ;
14:     else
15:        Place the firefighter on a child of of maximum weight
Algorithm 1
Theorem 2.

Algorithm 1 is a -competitive online algorithm for online Firefighter with at most two firefighters available. It is optimal for this case.


While Algorithm 1 runs feasibly on any instance, we limit the analysis to the case where at most two firefighters are available. If the adversary does not present any firefighter before the turn , both Algorithm 1 and cannot save any vertex and, by convention, the competitive ratio is 1.

Let us suppose that at least one firefighter is presented at some turn ; the tree still has at least one unburnt vertex. During the first turns, the instance is updated to . In the updated instance, at least one firefighter is presented during the first turn and the root has at least one child. Proposition 2 ensures that it is equivalent to the original instance.

If the root has only one child, line 8 gives and Algorithm 1 selects at line 10. In the updated instance, all vertices are saved; so the competitive ratio is equal to 1.

Else, we have with (line 8). If the adversary presents a single firefighter for the whole game, then Algorithm 1 protects either or . Meanwhile, will protect , saving vertices. If , then we have:


So Algorithm 1 protects (line 9), guaranteeing a competitive ratio of 1. Otherwise, if , even placing the firefighter on guarantees a ratio of at least .

Suppose now that the adversary presents two firefighters. We consider two cases.
Case (i): If Algorithm 1 places the first firefighter on at line 10, and if the adversary presents the second firefighter at turn , then the algorithm will save , for some such that For the same instance, will save for some and . If the two values are different (the optimal one is strictly better), then necessarily and . In this case the criterion of line 9 ensures that the related competitive ratio is at least .
Case (ii): Suppose now that Algorithm 1 places the first firefighter on at line 12, and say the adversary presents the second firefighter at turn . Lines 8 and 9 ensure that:


Hence, we have , since in the opposite case, Equation 4 would hold. Algorithm 1 now saves , for such that . Meanwhile, selects and, if it exists, for some , for a total of vertices saved. If , then , by definition of , and thus:


Finally, if , then and the competitive ratio to evaluate is . We claim that the following holds:


If , then and since , . Hence: and therefore:

Now, if , we get: and therefore:

In both cases, since , we obtain Equation 7. Now, Equations 5 and 7 imply that in case (ii), when , we also have Together with Equation 6, this concludes case (ii) and shows that Algorithm 1 is -competitive. ∎

Even though complexity analyses are not usually proposed for online algorithms, it is worth noting that line 9 only requires the weights of vertices in and the maximum weight per level in and . Hence, Algorithm 1 requires to choose the position of the first firefighter and altogether.

We conclude this section with a hardness result justifying that the greedy algorithm is optimal and that Algorithm 1 is optimal if at most two firefighters are available. These hardness results will all be derived from the graphs (Figure 1).





















Figure 1: Graph
Proposition 3.

For all , more precisely:
(i) , which means that the greedy algorithm is optimal for Firefighter in finite trees;
(ii) , which means that Algorithm 1 is optimal if at most two firefighters are available;
(iii) .


Theorem 1 shows that . Given integers such that , we define the graph as shown in Figure 1. We will assume that .

(i) Let us consider an online algorithm for . As established in Section 2.3 we can assume that the online algorithm plays in at turn . If , the algorithm will protect either or . If is selected and the firefighter sequence is , our online algorithm protects the branch of and one of the chains, while the optimal offline algorithm protects and the star. Its performance is then . If, however, is protected instead during the first turn and if the firefighter sequence is , the online algorithm protects the branch of and one vertex of the star whilst the optimal algorithm protects the branch of as well as the chains, minus vertices. If , for large values of , the online algorithm which protects is more performant and its competitive ratio is . Having shows that . Since the greedy algorithm guarantees , we have .

(ii) Consider the graphs . If the online algorithm protects , the adversary selects the sequence , whereas if the online algorithm protects , is selected. In both cases, the performance tends to when .

(iii) If at most 4 firefighters are available, the graph gives an example where cannot be reached. Indeed, if and the online algorithm protects , then the adversary will select the sequence , as in the proof of (i), for a performance of . If the online algorithm protects , since firefighters are limited to 4, the adversary will select , for a performance of . This second choice is slightly better; however . ∎

We have also proved that there is a -competitive algorithm if three firefighters are presented (i.e., ). This algorithm is similar to Algorithm 1 in that it places the first firefighter on one of the three largest branches and greedily places each of the other two on the largest branch available at the time they are presented. However, our proof involves a much more technical case-by-case analysis, and will not be detailed here.

4 Separating Firefighter Sequences

4.1 Definitions

We now consider the fractional firefighter problem on infinite graphs. We say that a sequence of firefighters is weaker than (or is stronger than ) if , and we write . If we also have , is said to be strictly weaker than and we write .

Lemma 2.

If the fire can be contained in the instance and if , then the fire can also be contained in by an online algorithm that knows in advance.


Given a winning strategy in the instance , if firefighters are available, we contain the fire by protecting the same vertices, possibly earlier than in the initial strategy. ∎

However, if , for Fractional Firefighter, it is not always the case that there is an infinite graph such that the fire can be contained in but not in (see Example 2). We call such a a separating graph for and , and we say that separates and in turns if the fire can be contained in turns for but not for . In this section, we give sufficient conditions for the existence of a separating graph.

Example 2.

Let , and , . Although , no graph separates those two sequences.

Note that for Firefighter, the problem is trivial, as shown in Corollary 2.

4.2 Spherically Symmetric Trees

Given a sequence