The Moving Firefighter Problem

Abstract

The original formulation of the firefighter problem defines a discrete-time process where a fire starts at a designated subset of the vertices of a graph G. At each subsequent discrete time unit, the fire propagates from each burnt vertex to all of its neighbors unless they are defended by a firefighter that can move between any pair of vertices in a single time unit. Once a vertex is burnt or defended, it remains in that state, and the process terminates when the fire can no longer spread. In this work, we present the moving firefighter problem, which is a generalization of the firefighter problem where the time it takes a firefighter to move from a vertex u to defend vertex v is determined by a function $\tau$. This new formulation models situations such as a wildfire or a flood, where firefighters have to physically move from their current position to the location of an entity they intend to defend. It also incorporates the notion that entities modeled by the vertices are not necessarily instantaneously defended upon the arrival of a firefighter. We present a mixed-integer quadratically constrained program (MIQCP) for the optimization version of the moving firefighter problem that minimizes the number of burnt vertices for the case of general finite graphs, an arbitrary set $F\subset V$ of vertices where the fire breaks out, a single firefighter, and metric time functions $\tau$.

1. Introduction

The firefighter problem was originally formulated by Bert Hartnell in 1995 [1]. It defines a discrete-time model of a diffusive process (e.g., a fire, a flood, an infectious disease, information, a computer virus, or an invasive species) on a graph $G=(V,E)$, where a fire breaks out at a set of vertices $F\subset V$. At each subsequent discrete time unit, the fire propagates from each burnt vertex to all of its neighbors unless they are defended by a firefighter. Once a vertex is burnt or defended, it remains in that state, and the process terminates when the fire can no longer spread. A solution to the problem defines the defending actions that have to be taken at each discrete time unit to optimally contain the spreading process by minimizing the number of burnt vertices or the time it takes to stop the diffusive process.

Over the years, the firefighter problem has gained growing relevance for its theoretical properties but also because it provides a simple model that can be used to study impactful phenomena such as the spreading and containment dynamics of viruses in social networks [2] and fires in oil terminals [3] and high-rise buildings [4].

Unfortunately, for the case of fighting actual fire outbreaks, the original formulation of the firefighter problem and its many variants and generalizations (e.g., [5,6,7,8,9,10,11,12,13,14,15,16,17,18]) fail to capture an important aspect that arises in more realistic scenarios, namely, that the process of transporting (or moving) a firefighter from her current location to defend an entity located at a different location may take a variable amount of time. In general, this time may be a function of the distance between the two locations and the particular properties of the terrain, the entity to be defended, and the firefighter herself. As a concrete example, when fighting a wildfire, any strategy has to consider the time it takes to move fire engines and perhaps heavy machinery to a given region and then defend that region by creating control lines containing no combustible material. This time may depend on many factors, such as the land topography and the type of fire engines. It is worth noting that designing efficient wildfire suppression strategies has become increasingly important. During the 2019/2020 bushfire season, the number of hectares burned in Australia surpassed 6.75 million [19], and 4.09 million hectares burned in the United States in 2020 [20]. In 2021, more than 75 thousand wildfire outbreaks were detected in the Amazon Rainforest [21].

In this work, we introduce the moving firefighter problem, which is a generalization of the firefighter problem that incorporates a function $\tau$ that determines the time it takes a firefighter to move from its current location at vertex $u\in V$ to defend another vertex $v\in V$. Similarly to the original formulation of the firefighter problem, in this generalization, we assume that the time it takes the fire to spread from a burnt vertex to its neighbors in the graph is constant.

We present a mixed-integer quadratically constrained program (MIQCP) for the optimized version of the moving firefighter problem that minimizes the number of burnt vertices for the case of general finite graphs, an arbitrary set $F\subset V$ of vertices where the fire breaks out, a single firefighter, and metric time functions $\tau$. We characterized the performance of the proposed solution through experiments on random graphs.

The rest of the paper is organized as follows. Section 2 presents a review of the extensive body of work on the firefighter problem and of its generalization and variants. Section 3 presents the formulation of the moving firefighter problem and the concepts and notation that are used throughout the paper. In this section, we also establish that the moving firefighter problem is indeed a generalization of the original firefighter problem, and hence, that it belongs to the class of $\mathcal{NP}$-hard problems. Section 4 presents the proposed exact solution. Section 5 presents the results of a series of experiments, and Section 6 presents our concluding remarks and future work.

2. Related Work

The firefighter problem has been extensively studied. It has been determined that it is $\mathcal{NP}$-hard for bipartite graphs [22], for cubic graphs [9], for trees of maximum degree three [22] and of pathwidth three [23], for co-bipartite graphs [23], and for unit disk graphs [24]. It has also been established that the problem is in P for caterpillars and P-trees [22], interval graphs, split graphs, permutation graphs, $P_k$-free graphs for fixed k [24], and if the fire breaks out at a vertex of degree at most two, for graphs of maximum degree three [25].

For the case of $b\ge 2$ firefighters, the problem is $\mathcal{NP}$-complete for trees of maximum degree $b+2$ and $\mathcal{NP}$-hard for the optimization version that maximizes the number of saved (unburnt) vertices for trees of maximum degree $b+3$ [11].

Regarding approximations, for the case of trees and a single firefighter, the greedy algorithm that every time selects the vertex that maximizes the number of protected vertices is a tight $1/2$-approximation [2,26]. There is also a ($1-1/e$)-approximation algorithm for rooted trees based on an LP-relaxation and randomized rounding [27]. The previous algorithm was used by Iwaikawa et al. to provide a 0.7144-approximation algorithm for ternary trees [28]. The problem is not $n^{1-ϵ}$-approximable on general graphs for any $ϵ\in (0,1)$ unless $P=NP$ [8]. More recently, Adjiashvili et al. [29] presented a polynomial-time approximation scheme (PTAS) for trees.

From a parameterized point of view, the problem is W[1]-hard on general graphs for $b\ge 1$ firefighters when parameterized by the number of saved vertices, protected vertices, and burned vertices [30].

Other generalizations of the firefighter problem include a version where the number of available firefighters at each time is not constant [7], a version where the objective is to protect a particular subset of the set of vertices $S\subseteq V$ [9,11], a version where the protection also propagates from each defended vertex to their non-burning neighbors [8,13], and a non-deterministic version where at each time the fire propagates to unprotected vertices with a given probability [14]. There is also a fractional version where vertices can be partially burned and protected, and partially burned vertices can propagate their fractions of the fire to their undefended or partially defended neighbors [5]. More recently, Coupechoux et al. introduced online versions of the firefighter and fractional firefighter problems where the number of available firefighters is revealed at each discrete time [16]. The k-firefighter problem is another generalization defined in terms of a two-player game where the fire propagates to at most k vertices in each round with the objective of burning as many vertices as possible while the firefighter defends vertices to contain the spread of the fire [6,10].

The geometric firefighter problem [12,15,17] is the closest variation to the moving firefighter problem because it considers the speed with which barriers are constructed to contain the fire. In this variation, the fire starts at a point inside a simple polygon $\mathcal{P}$ and circularly propagates at a constant speed. A firefighter sequentially builds a series of one-dimensional barriers at a constant speed, which can be different from the fire propagation speed, to contain the propagation of the fire. Barriers have to be built continuously before the fire reaches any of its points. The objective is to maximize the protected area of $\mathcal{P}$, namely, the area separated from the fire by the barriers. Similarly to the original firefighter problem, the geometric firefighter problem assumes that the firefighter can be instantaneously transported from the last position of a recently constructed barrier to the origin of the next barrier in the solution.

In the traveling firefighter problem, also referred to as the $L_2$-TSP (traveling salesman problem), a firefighter has to extinguish a set of wildfires located at positions modeled by vertices. The distance between vertices is defined by a function $d:V\times V\to {\mathbb{R}}_{\ge 0}$. A solution to this problem is a permutation of the vertices that minimize the total damage produced by the fires, which is a quadratic function of time elapsed from when the fires broke out to when the firefighter arrives [18].

Some other $\mathcal{NP}$-hard problems that resemble the firefighter problem are the graph burning problem (GBP) [31,32,33] and the influence maximization problem (IMP) [34,35,36]. However, while they seek the rapid diffusion of information, the firefighter problem seeks diffusion containment. Nevertheless, very recently, the authors of [37] used the integer linear programming formulation (ILP) of the firefighter problem presented in [6] to derive the first exact solution to the graph burning problem.

Table 1. Summary of related work.

Reference	Contributions
[1]	Hartnell introduces the Firefighter Problem (FP).
[9,11,22,23,24]	The FP is NP-hard for different graph families.
[22,24,25]	Instances where the FP is in P.
[8,26,27,28,29]	Approximation results for the FP.
[30]	The FP is W[1]-hard on general graphs with more than one firefighter.
[6]	Presents an integer linear program (ILP) for the FP.
[7]	Presents a version of the FP with a variable number of firefighters.
[9,11]	Present the S-Fire version of the FP, which aims to protect a subset of the vertices.
[8,13]	A version of the FP where the protection propagates from defended nodes.
[14]	Version of the FP with nondeterministic fire propagation.
[5]	Introduces the Fractional Firefighter Problem.
[16]	An Online version of the Fractional Firefighter Problem.
[6,10]	Examine a two-player version of the FP called the k-Firefighter.
[12,15,17]	The Geometric Firefighter Problem.
[18]	Presents the Traveling Firefighter Problem ($L_2$-TSP)
[31,32,33]	Investigate the relation between the FP and the Graph Burning Problem.

summarizes the main results discussed in this section.

3. The Moving Firefighter Problem

An instance of the moving firefighter problem ($MFP$) is defined as a 6-tuple $\langle G,F,$$a,\tau ,f,T_S\rangle$, where $G=(V,E)$ is a simple graph; $F\subset V$ is a subset of the vertices where the fire breaks out; a is the depot where the firefighters are initially stationed (also referred as anchor point); $\tau :V\cup \left\{a\right\}\times V\to {\mathbb{R}}_{\ge 0}$ is a function that determines the time it takes a firefighter to move from either the depot a or a vertex $u\in V$ to any other vertex $v\in V$, and to defend v. f is the number of firefighters, and $T_S>0$ is a constant that defines the time it takes for the fire to spread from a burnt vertex $u\in V$ to its unprotected neighbors in G.

From the assumption that the fire spreads uniformly at a constant rate, we can organize the time into time slots of length $T_S$. Each time slot defines a burning round, where at the beginning of each time slot, the fire propagates from burnt vertices to their neighbors in G unless they were defended by a firefighter. Once a vertex is burnt or defended, it remains in that state, and the process terminates when the fire can no longer spread. We will say that a vertex is protected if it is neither burning nor defended at the end of the process. The diffusive process starts at time slot 0 where only the vertices in F are burning.

For the case of a single firefighter, a feasible solution to the $MFP$ is a valid sequence $\mathcal{S}$ of vertices defended by the firefighter. We say that a sequence $\mathcal{S}=(a,u_1,\dots ,u_l)$ is valid if Equation (1) holds for each $i=1,2,\dots ,l$. In Equation (1), ${\beta }_{{\mathcal{S}}_i}$ is the time at which a vertex $u_i$ would be burned if the defending sequence $\mathcal{S}=(a,u_1,\dots ,u_l)$ were truncated to ${\mathcal{S}}_i=(a,u_1,\dots ,u_{i-1})$.

The purpose of Equation (1) is to restrict the space of feasible solutions to that where the firefighter has enough time to defend every vertex in the sequence before the fire reaches them.

$${\displaystyle \tau (a,u_1)+\sum _{k=1}^{i-1}\tau (u_k,u_{k+1})\le {\beta }_{{\mathcal{S}}_i}}$$

(1)

Figure 1 shows examples of an instance of the $MFP$ and of one of its solutions. The graph G is composed of the set of vertices $V=\{v_0,v_1,v_2,v_3,v_4,v_5,v_6,v_7,v_8,v_9\}$ and the set of edges $E=\{(v_0,v_2),(v_1,v_3),(v_2,v_3),$$(v_2,v_5),(v_3,v_4),(v_3,v_5),(v_3,v_6),(v_4,v_7),$$(v_5,v_6),(v_5,v_8),(v_6,v_9)\}$. The fire breaks out at vertices $F=\{v_0,v_1\}$, a single firefighter ($f=1$) is initially stationed at the depot a, and $T_S=1$. The depot and the vertices in V are in the Euclidean plane. The number on top of the vertices indicates their shortest hop distance to their closest vertex in F, which in this example equals the smallest time slot in which they can burn. The figure also shows a feasible solution $\mathcal{S}=(a,v_5,v_6,v_7)$ in which the firefighter moves from the depot a to defend vertex $v_5$, then moves to defend vertex $v_6$, and lastly moves to defend vertex $v_7$. For this defending sequence $\mathcal{S}$, the value of ${\beta }_{{\mathcal{S}}_1}$ equals 2 because vertex $v_5$ burns at time 2 when the truncated protecting sequence ${\mathcal{S}}_1=\left(a\right)$ is applied, ${\beta }_{{\mathcal{S}}_2}$ equals 2 because vertex $v_6$ burns at time 2 when the truncated protecting sequence ${\mathcal{S}}_2=(a,v_5)$ is applied, and similarly, ${\beta }_{{\mathcal{S}}_3}$ equals 3. $\mathcal{S}$ is a valid sequence because $\tau (a,v_5)=1.13\le {\beta }_{{\mathcal{S}}_1}=2$, $\tau (a,v_5)+\tau (v_5,v_6)=1.99\le {\beta }_{{\mathcal{S}}_2}=2$, and $\tau (a,v_5)+\tau (v_5,v_6)+\tau (v_6,v_7)=2.81\le {\beta }_{{\mathcal{S}}_3}=3$. The process ends after three burning rounds (at time slot three) because at that time, the fire can no longer spread. The value of this solution equals five because, at the end of the process, vertices $v_0,v_1,v_2,v_3$, and $v_4$ are burnt.

For the instance of Figure 1, the firefighter cannot choose to defend vertex $v_3$ because $\tau (a,v_3)=1.74>{\beta }_{{\mathcal{S}}_1^{\prime }}=1$ for sequence ${\mathcal{S}}^{\prime }=(a,v_3)$. It could defend $v_2$ because $\tau (a,v_2)=0.80<{\beta }_{{\mathcal{S}}_1^{″}}=1$ for a sequence ${\mathcal{S}}^{″}=(a,v_2)$, but in this case no other vertex could be defended, giving a feasible solution ${\mathcal{S}}^{″}=(a,v_2)$ of value nine. In these examples, the process also ends at time slot 3 when the fire can no longer spread.

For the case of $f>1$ firefighters, a feasible solution is a set of valid sequences $\mathbb{S}=\{{\mathcal{S}}_1,\dots ,{\mathcal{S}}_f\}$ of the vertices defended by each firefighter. In this case, ${\beta }_{{\mathcal{S}}_i}$ has to be extended to compute the time in which a vertex $u_i$ in a ${\mathcal{S}}_x\in \mathbb{S}$ is burnt if none of the defending sequences in $\mathbb{S}=\{S_1,\dots ,S_f\}$ includes vertices protected at a time posterior to $\tau (a,u_1)+{\sum }_{k=1}^{i-1}\tau (u_k,u_{k+1})$ for $u_k\in {\mathcal{S}}_x$.

The objective of the minimization version of the $MFP$ is to find a feasible solution that minimizes the number of burnt vertices at the end of the process.

The decision version of the moving firefighter problem for a single firefighter (1-MFP) is as follows.

Definition 1.

Decision version of the 1-MFP problem:Given an arbitrary instance $\langle G=(V,E),F,a,\tau ,1,T_S\rangle$ of 1-MFP and an integer $k\ge 1$, is there a valid sequence ${\mathcal{S}}_{moving}$ of vertices defended by the firefighter such that the number of burnt vertices at the end of the process is at most k?

1-MFP Is NP-Complete

In this section, we show that 1-MFP is NP-complete via a polynomial-time reduction (${\le }_P$) to the decision version of the firefighter problem for a single firefighter (1-FP), which can be defined as follows.

Definition 2.

Decision version of the 1-FP problem:Given an arbitrary instance $\langle G=(V,E),F\rangle$ of 1-FP, where $F\subset V$ is the set of vertices where the fire breaks out and an integer $k\ge 1$, is there a sequence ${\mathcal{S}}_{original}$ of vertices defended by the firefighter such that the number of burnt vertices at the end of the process is at most k?

We start with two preliminary lemmas.

Lemma 1.

Given an instance $\langle G,F\rangle$ of 1-FP, an instance $\langle G^{\prime },F^{\prime },a,\tau ,1,T_S=1\rangle$ of 1-MFP such that $G^{\prime }=G$, $F^{\prime }=F$, defending sequences ${\mathcal{S}}_{original}=(u_1,\dots ,u_l)$ for the instance of 1-FP, ${\mathcal{S}}_{moving}=(a,u_1^{\prime },\dots ,u_l^{\prime })$ with $u_i^{\prime }=u_i$ for each $u_i^{\prime }\in {\mathcal{S}}_{moving}$ for the instance of 1-MFP, and function ${\tau }_1(u,v)=1$ $\forall u\ne v$ with $u\in V\cup \left\{a\right\}$, $v\in V$ and ${\tau }_1(u,u)=0$ $\forall u\in V\cup \left\{a\right\}$. The discrete time $t_i$ in which a vertex $v_i$ in ${\mathcal{S}}_{original}=(u_1,\dots ,u_l)$ is defended equals the time $t_i^{\prime }=i$ in which its corresponding vertex $v_i^{\prime }$ is defended in ${\mathcal{S}}_{moving}=(a,u_1^{\prime },\dots ,u_l^{\prime })$.

Proof of Lemma 1. 

From the definition of ${\tau }_1$, we can observe that the time $\tau (a,u_1^{\prime })+{\sum }_{k=1}^{i-1}\tau (u_k^{\prime },u_{k+1}^{\prime })$ in which a vertex $u_i^{\prime }\in {\mathcal{S}}_{moving}$ is defended equals i. This is the same as the discrete-time in which the corresponding vertex $u_i$ is defended by ${\mathcal{S}}_{original}$, namely, i. □

Lemma 2.

Given an instance $\langle G,F\rangle$ of 1-FP, an instance $\langle G^{\prime },F^{\prime },a,\tau ,1,T_S=1\rangle$ of 1-MFP such that $G^{\prime }=G$, $F^{\prime }=F$, defending sequences ${\mathcal{S}}_{original}=(u_1,\dots ,u_l)$ for the instance of 1-FP, ${\mathcal{S}}_{moving}=(a,u_1^{\prime },\dots ,u_l^{\prime })$ with $u_i^{\prime }=u_i$ for each $u_i^{\prime }\in {\mathcal{S}}_{moving}$, for the instance of 1-MFP, and function ${\tau }_1(u,v)=1$ $\forall u\ne v$ with $u\in V\cup \left\{a\right\}$, $v\in V$, and ${\tau }_1(u,u)=0$ $\forall u\in V\cup \left\{a\right\}$. A vertex $v\in G$ burns at discrete time t if and only if its corresponding vertex $v^{\prime }\in G^{\prime }$ burns at the beginning of time slot t.

Proof of Lemma 2. 

If a vertex $v\in G$ burns at discrete time t, it means that there is a shortest path P of length t, from a vertex $r\in F$ to v that does not contain any vertex in the truncated protecting sequence ${\mathcal{S}}_{original}=(u_1,\dots ,u_t)$. Given that $G=G^{\prime }$, this shortest path P also exists in $G^{\prime }$ and does not contain vertices in ${\mathcal{S}}_{moving}=(u_1^{\prime },\dots ,u_t^{\prime })$. From Lemma 1, and because the fire propagates at the beginning of each time slot of length $T_S=1$, vertex $v^{\prime }$ has to burn at time t, a which equals the beginning of time slot t. A symmetric argument can be applied to show the other direction of the implication. □

Theorem 1.

1-MFP is NP-complete.

Proof of Theorem 1. 

We first show that the 1-MFP is an NP. Given an arbitrary instance $\langle G,F,a,\tau ,1,T_S\rangle$, $k\ge 1$, and a defending sequence $\mathcal{S}=(a,u_1,\dots ,u_l)$, a certifier algorithm can check in polynomial-time if (1) holds for each $u_i\in \mathcal{S}$, given that the firefighter defends each $u_i\in \mathcal{S}$ at time $\tau (a,u_1)+{\sum }_{k=1}^{i-1}\tau (u_k,u_{k+1})$. Then, the certifier algorithm can execute, also in polynomial-time, the firefighting process to verify that the number of burnt vertices is, in fact, at most k.

Now, we show that 1-FP ${\le }_P$ 1-MFP. Given an arbitrary instance $\langle G,F\rangle$ of 1-FP and an integer k, we construct an instance of 1-MFP as $\langle G^{\prime },F^{\prime },a,{\tau }_1,1,T_S=1\rangle$ with $G^{\prime }=G$, $F^{\prime }=F$, and ${\tau }_1(u,v)=1$ $\forall u\ne v$ with $u\in V\cup \left\{a\right\}$, $v\in V$ and ${\tau }_1(u,u)=0$ $\forall u\in V\cup \left\{a\right\}$. Constructing this instance of 1-MFP takes $\mathcal{O}\left(\right|V{|}^2)$ steps.

Next, we claim that there is a defending sequence ${\mathcal{S}}_{original}=(u_1,\dots ,u_l)$ for the instance of the 1-FP such that at most k vertices of G burn, if and only if there is a valid defending sequence ${\mathcal{S}}_{moving}(a,u_1^{\prime },\dots ,u_l^{\prime })$ with $u_i^{\prime }=u_i$ for each $u_i^{\prime }\in {\mathcal{S}}_{moving}$, for the instance of the 1-MFP such that at most k vertices burn in $G^{\prime }$.

(⇒) We first show that ${\mathcal{S}}_{moving}=(a,u_1^{\prime },\dots ,u_l^{\prime })$ is valid. Let us proceed by contradiction and assume that $u_j\in {\mathcal{S}}_{moving}$ is the vertex with the smallest index $j\in \{1,\dots ,l\}$ such that $\tau (a,u_1)+{\sum }_{k=1}^{j-1}\tau (u_k,u_{k+1})=j>{\beta }_{{\mathcal{S}}_j}$. However, from Lemma 1, we saw that the time a vertex in $G^{\prime }$ is defended by ${\mathcal{S}}_{moving}$ equals the discrete time its corresponding vertex in G is defended by ${\mathcal{S}}_{original}$. Since vertex $u_j$ is defended at discrete time j in the original firefighter process, it can not be burning at time j, which means that there is no path from a vertex $r\in F$ to $u_j$ of length j or shorter that does not contain a vertex in the truncated protecting sequence $(u_1,\dots ,u_{j-1})$. Since $G=G^{\prime }$, there is no such a path in $G^{\prime }$, and hence ${\beta }_{{\mathcal{S}}_j}>j$, a contradiction. From Lemma 2, at the end of the burning process, exactly the same number of vertices are burning in both instances. Therefore, if at most k vertices of G burn, then at most k vertices burn in $G^{\prime }$.

(⇐) Since ${\mathcal{S}}_{moving}=(a,u_1^{\prime },\dots ,u_l^{\prime })$ is valid for the 1-MFP instance, from Lemma 1 and 2, we know that all the vertices in ${\mathcal{S}}_{original}$ can be defended in the 1-FP instance. From Lemma 2, we also know that if at most k vertices of $G^{\prime }$ burn, then at most k vertices of G burn. □

Table 2. Summary of notation.

$\mathit{G}=(\mathit{V},\mathit{E})$	Input graph.
F	Set of vertices where the fire breaks out.
a	Firefighters’ depot or anchor point.
$\tau$	Travel time function.
f	Number of firefighters.
$T_S$	Length of the time slots (burning round).
$\langle G,F,$$a,\tau ,f,T_S\rangle$	Instance of the 1-MFP.
$\langle G,F\rangle$	Instance of the 1-FP.
$\mathcal{S}=(a,u_1,\dots ,u_l)$	Defending sequence.
${\beta }_{{\mathcal{S}}_i}$	Time when vertex $u_i$ burns, given the truncated defending sequence ${\mathcal{S}}_i=(a,u_1,\dots ,u_{i-1})$.
$\mathbb{S}=\{{\mathcal{S}}_1,\dots ,{\mathcal{S}}_f\}$	Set of defending sequences for $f>1$.
B	Upper bound on the number of burning rounds (or time slots).
D	Upper bound on the number of vertices defended within a single burning round.
$b_{i,j}$	Binary variable that indicates whether $v_i$ is burning at the j-th burning round.
$d_{i,j}$	Binary variable that indicates whether $v_i$ is defended at the j-th burning round.
$d_{j,i,k}^{\prime }$	Binary variable that indicates whether $v_i$ is defended at the k-th defense round of the j-th burning round.
$p_{j,i,k}$	Binary variable that indicates whether $v_i$ was the last defended vertex at the k-th defense round of the j-th burning round.
$t_j$	Continuous variable that indicates the time needed to carry out a defending sequence within the $j$-th burning round.
$\mathbf{b}$	$n\times B$ matrix that contains the $b_{i,j}$ binary variables.
$\mathbf{d}$	$n\times B$ matrix that contains the $d_{i,j}$ binary variables.
${{\mathbf{d}}^{\prime }}_j$	$n\times D$ matrix that contains the $d_{j,i,k}^{\prime }$ binary variables.
${\mathbf{p}}_j$	$n\times D$ matrix that contains the $p_{j,i,k}$ binary variables.

summarizes the notation used throughout the paper.

4. Mixed-Integer Quadratically Constrained Program for the 1-MFP

Expressions (2) to (23) define a mixed-integer quadratically constrained program (MIQCP) for the optimization version of the 1-MFP. This MIQCP is based on the integer linear program (ILP) for the original firefighter problem (FP). For simplicity, let us assume that vertices are labeled as $\{v_1,v_2,\dots ,v_n\}$. In addition, let us consider the anchor point, a, as an isolated vertex in the graph. This way, the fire cannot catch this special vertex, and inconsistencies are not added to the formulation. As in the original FP, the proposed MIQCP for the 1-MFP requires an upper bound B on the number of burning rounds (or time slots) at which the diffusive process finishes. However, unlike the original FP, it also requires an upper bound D on the number of vertices that are defended within a single burning round. We will say that defending a vertex during a burning round defines a defense round within that burning round. The length of the defense rounds is a function of $\tau$, and it is possible to have from 0 to D defense rounds in a given burning round.

The ILP for the original FP is relatively simple; it has $\mathcal{O}\left(nB\right)$ binary variables and $\mathcal{O}(nB\Delta )$ constraints, where $\Delta$ is the graph’s largest vertex degree. In contrast, our proposed MIQCP for the 1-MFP has $\mathcal{O}\left(nBD\right)$ binary variables, $\mathcal{O}(max\{\left|E\right|D,nBD\left\}\right)$ linear constraints, and $\mathcal{O}\left(nBD\right)$ quadratic constraints. Since B and D are upper bounded by n, the numbers of variables and constraints are upper bounded by $\mathcal{O}\left(n^3\right)$. In addition, this MIQCP assumes that function $\tau$ is normalized with respect to the length of the burning rounds (time slots), and hence that $T_S=1$.

$$\begin{array}{cc}\hfill \mathbf{min}& \sum _{i=1}^n{b}_{i,B}\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill \mathbf{s}.\mathbf{t}.& b_{i,j}\ge b_{i,j-1}\forall v_i\in V,\forall j\in [1,B]\hfill \end{array}$$

(3)

$$\begin{array}{cc}\hfill & d_{i,j}\ge d_{i,j-1}\forall v_i\in V,\forall j\in [1,B]\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill & b_{i,j}+d_{i,j}\le 1\forall v_i\in V,\forall j\in [1,B]\hfill \end{array}$$

(5)

$$\begin{array}{cc}\hfill & b_{i,j}+d_{i,j}\ge b_{k,j-1}\forall v_i\in V,\forall j\in [1,B],\forall v_k\in N\left(v_i\right)\hfill \end{array}$$

(6)

$$\begin{array}{cc}\hfill & d_{j,i,1}^{\prime }\ge d_{i,j-1}\forall v_i\in V,\forall j\in [1,B]\hfill \end{array}$$

(7)

$$\begin{array}{cc}\hfill & d_{j,i,D}^{\prime }=d_{i,j}\forall v_i\in V,\forall j\in [1,B]\hfill \end{array}$$

(8)

$$\begin{array}{cc}\hfill & d_{j,i,k}^{\prime }\ge d_{j,i,k-1}^{\prime }\forall v_i\in V,\forall j\in [1,B],\forall k\in [2,D]\hfill \end{array}$$

(9)

$$\begin{array}{cc}\hfill & p_{j,i,k}\ge d_{j,i,k}^{\prime }-d_{j,i,k-1}^{\prime }\forall v_i\in V,\forall j\in [1,B],\forall k\in [2,D]\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill & p_{j,i,1}\ge d_{j,i,1}^{\prime }-d_{i,j-1}\forall v_i\in V,\forall j\in [1,B]\hfill \end{array}$$

(11)

$$\begin{array}{cc}\hfill & \sum _{i=1}^n{p}_{j,i,k}=1\forall k\in [1,D],\forall j\in [1,B]\hfill \end{array}$$

(12)

$$\begin{array}{cc}\hfill & p_{j,i,k}\ge p_{j,i,k-1}·\left(1-\sum _{l=1}^n\left(d_{j,l,k}^{\prime }-d_{j,l,k-1}^{\prime }\right)\right)\forall v_i\in V,\forall j\in [1,B],\forall k\in [2,D]\hfill \end{array}$$

(13)

$$\begin{array}{cc}\hfill & p_{j,i,1}\ge p_{j-1,i,D}·\left(1-\sum _{l=1}^n\left(d_{j,l,1}^{\prime }-d_{l,j-1}\right)\right)\forall v_i\in V,\forall j\in [1,B]\hfill \end{array}$$

(14)

$$\begin{array}{cc}\hfill & t_j=t_{j-1}+\sum _{l=1}^n\left(\sum _{i=1}^n{p}_{j,i,1}·{\tau }_{l,i}\right)·p_{j-1,l,D}\forall j\in [1,B]\hfill \\ \hfill & +\sum _{k=2}^D\left(\sum _{l=1}^n\left(\sum _{i=1}^n{p}_{j,i,k}·{\tau }_{l,i}\right)·p_{j,l,k-1}\right)\hfill \end{array}$$

(15)

$$\begin{array}{cc}\hfill & t_j\le j\forall j\in [1,B]\hfill \end{array}$$

(16)

$$\begin{array}{cc}\mathbf{where}\hfill & t_0=0\hfill \end{array}$$

(17)

$$\begin{array}{cc}\hfill & d_{a,0}=1\hfill \end{array}$$

(18)

$$\begin{array}{cc}\hfill & d_{i,0}=0\forall v_i\in V\backslash \left\{a\right\}\hfill \end{array}$$

(19)

$$\begin{array}{cc}\hfill & b_{i,0}=\left\{\begin{array}{cc}1\hfill & ifi\in F\hfill \\ 0\hfill & ifi\notin F\hfill \end{array}\right.\forall v_i\in V\hfill \end{array}$$

(20)

$$\begin{array}{cc}\hfill & d_{0,i,k}^{\prime }=p_{0,i,k}=d_{i,0}\forall v_i\in V,\forall k\in [1,D]\hfill \end{array}$$

(21)

$$\begin{array}{cc}\hfill & b_{i,j},d_{i,j},p_{j,i,k},d_{j,i,k}^{\prime }\in \{0,1\}\forall v_i\in V,\forall j\in [1,B],\forall k\in [1,D]\hfill \end{array}$$

(22)

$$\begin{array}{cc}\hfill & t_j\in {\mathbb{R}}^{+}\forall j\in [1,B]\hfill \end{array}$$

(23)

The ILP for the FP problem only has two sets of binary variables, $b_{i,j}$ and $d_{i,j}$. Similarly, the main variables of the proposed MIQCP for the 1-MFP are $b_{i,j}$ and $d_{i,j}$ too. These variables report the state of each vertex i at the $j\mathrm{th}$ burning round, where $i\in [1,n]$ and $j\in [1,B]$. Thus, if a vertex $v_i$ is burnt at round j, then $b_{i,j}=1$; otherwise, $b_{i,j}=0$. If vertex $v_i$ is burnt at round j, it is because of one of the following reasons: it was originally burnt at some previous round (Constraint (3)), or it is in the neighborhood of some previously burnt vertex (Constraint (6)). In case vertex $v_i$ is defended at round j, then $d_{i,j}=1$; otherwise, $d_{i,j}=0$. A vertex that is defended at any round will remain in that state (Constraint (4)), and if a vertex is in the neighborhood of some previously burnt vertex, then it has to be either burned or defended (Constraint (6)). By Constraint (5), a vertex cannot be simultaneously burnt and defended. For further clarification, we can organize these variables in two $n\times B$ matrices (see Equations (24) and (25)), where matrix d can be further extended to matrices d’${}_j$ and p${}_j$ (see Equations (26) and (27)), where $j\in [1,B]$.

$$\begin{array}{c}\hfill \mathbf{b}=\left(\begin{array}{cccc}{b}_{1,0}& b_{1,1}& \cdots & b_{1,B}\\ b_{2,0}& b_{2,1}& \cdots & b_{2,B}\\ ⋮& ⋮& \ddots & ⋮\\ b_{n,0}& b_{n,1}& \cdots & b_{n,B}\end{array}\right)\end{array}$$

(24)

$$\begin{array}{c}\hfill \mathbf{d}=\left(\begin{array}{cccc}{d}_{1,0}& d_{1,1}& \cdots & d_{1,B}\\ d_{2,0}& d_{2,1}& \cdots & d_{2,B}\\ ⋮& ⋮& \ddots & ⋮\\ d_{n,0}& d_{n,1}& \cdots & d_{n,B}\end{array}\right)\end{array}$$

(25)

Given that the 1-MFP allows sequentially defending many vertices within a burning round, we added a set of variables $d_{j,i,k}^{\prime }$ in order to report the sequence of defended vertices, where $j\in [1,B]$, $i\in [1,n]$, and $k\in [1,D]$. In more detail, if vertex $v_i$ is defended at the $k\mathrm{th}$ defense round, within the $j\mathrm{th}$ burning round, then $d_{j,i,k}^{\prime }=1$; otherwise, $d_{j,i,k}^{\prime }=0$. Notice that D is an upper bound on the number of defended vertices within one burning round. We can organize these variables into B matrices of size $n\times D$. Thus, there is a matrix ${{\mathbf{d}}^{\prime }}_j$ for each $j\mathrm{th}$ burning round (see Equation (26)).

$$\begin{array}{c}\hfill {{\mathbf{d}}^{\prime }}_j=\left(\begin{array}{cccc}{d}_{1,1}^{\prime }& d_{1,2}^{\prime }& \cdots & d_{1,D}^{\prime }\\ d_{2,1}^{\prime }& d_{2,2}^{\prime }& \cdots & d_{2,D}^{\prime }\\ ⋮& ⋮& \ddots & ⋮\\ d_{n,1}^{\prime }& d_{n,2}^{\prime }& \cdots & d_{n,D}^{\prime }\end{array}\right)\end{array}$$

(26)

By Constraint (7), all vertices defended at the $(j-1)\mathrm{th}$ burning round stay defended at the beginning of the first defense round of the following burning round, which is reported in the first column of ${{\mathbf{d}}^{\prime }}_j$. By Constraint (8), the state of the defended vertices at the end of the $j\mathrm{th}$ burning round (column D of d’${}_j$) is copied into column j of matrix d. In other words, each column j of matrix d is a summary of what happens inside each matrix d’${}_j$. Similarly to Constraint (4), Constraint (9) indicates that once a vertex is defended at the $k\mathrm{th}$ defense round of the $j\mathrm{th}$ burning round, it will stay defended.

Constraints (10)–(12) describe the relationship between the binary variables $p_{j,i,k}$ and variables $d_{j,i,k}^{\prime }$. The goal of p${}_j$ is to report the last defended vertex at each defense round within each burning round. Notice that $p_{j,i,k}=1$ might mean two different things: vertex $v_i$ has been defended precisely at the $k\mathrm{th}$ defense round within burning round j (Constraints (10) and (11)), or vertex $v_i$ is the last vertex defended at some previous round. Constraint (12) guarantees that exactly one vertex is the last defended at each defense round. Please note that Constraint (18) establishes that the anchor point a is defended at the beginning of the process. For convenience, we can organize these variables in a matrix p${}_j$ for each burning round (see Equation (27)).

Constraints (13) and (14) guarantee that the information about the last defended vertex is copied into the following columns of p. When a new vertex becomes defended, these constraints are deactivated by making the right-hand side equal to zero. In this case, the subsequent columns are no longer a copy of the previous ones; instead, the currently defended vertex is updated. Constraints (15) and (16) guarantee that the time $t_j$ needed to carry out a sequence of defended vertices within the $j\mathrm{th}$ burning round does not exceed the current number j of time slots of the diffusive process. By these two constraints, Constraints (3) and (5)–(14), which define the relationship between the defended vertices and the dynamics of the diffusive process, the firefighter cannot defend a vertex that the fire has already spread to (which is consistent with Equation (1)).

$$\begin{array}{c}\hfill {\mathbf{p}}_j=\left(\begin{array}{cccc}{p}_{1,1}& p_{1,2}& \cdots & p_{1,D}\\ p_{2,1}& p_{2,2}& \cdots & p_{2,D}\\ ⋮& ⋮& \ddots & ⋮\\ p_{n,1}& p_{n,2}& \cdots & p_{n,D}\end{array}\right)\end{array}$$

(27)

The solution to an 1-MFP instance is obtained from the ${\mathbf{d}}^{\prime }$ matrices by sequentially scanning them for the first time that a value of one appears in a row of one of such matrices. Remember that the first time that a value of one appears in row i of the matrix ${{\mathbf{d}}^{\prime }}_j$ indicates that the vertex $v_i$ is defended at burning round j, and hence, that it is part of the resulting defending sequence $\mathcal{S}$. The ordering of the vertices in $\mathcal{S}$ is obtained from the burning and defense rounds where they were defended.

For further clarification, Figure 2 shows the value of each variable in the solution of the example instance from Figure 1. In this example, we follow the convention of placing the anchor point in the last row of the matrices. Column $j=0$ represents the process’ initial conditions where vertices $v_0$ and $v_1$ are the initial fire sources and the firefighter is located at the anchor point. The remaining columns of matrices $\mathbf{b}$ and $\mathbf{d}$ report the state of the vertices at the subsequent burning rounds. The resulting defending sequence $\mathcal{S}$ equals $(a,v_5,v_6,v_7)$ because the first value of one appears in the sixth row (the one corresponding to vertex $v_5$) of the first column of ${{\mathbf{d}}^{\prime }}_2$, the second value of one appears in the seventh row of ${{\mathbf{d}}^{\prime }}_3$, and the last value of one appears in the eighth row of the first column of ${{\mathbf{d}}^{\prime }}_3$. Time $t_1=0$ because no vertex is defended during the first burning round while $t_2=1.13+0.86=1.99$ because the firefighter moves from the anchor a to defend vertex $v_5$ and then from $v_5$ to defend $v_6$, which takes 1.99 units of time. Similarly, $t_3=2.81$ because that is the time needed to complete the whole defending sequence $\mathcal{S}=(a,v_5,v_6,v_7)$, which is optimal for this instance.

Regarding a MIQCP for the MFP with more than one firefighter, we conjecture that the number of variables and constraints might increase by an order of f. The precise formulation is left as future work.

5. Experimental Performance Evaluation

In this section, we present the results of a series of experiments that characterize the performance of the proposed MIQCP for the 1-MFP. The purpose was twofold: first, to evaluate the impacts of the size of the graph, the scale of function $\tau$, and the number of vertices where the fire breaks out on the value of the objective function and the MIQCP’s running time; second, to provide a set of optimally solved instances that can be used for future performance comparison analyses of heuristic or approximated solutions.

For these experiments, we generated instances $\langle G,F,a,\tau ,f,T_S\rangle$ of the 1-MFP, where the number of firefighters f equals one, the length of the time slots $T_S$ also equals one, the number of initial fires $\left|F\right|$ is in $\{1,3\}$, the graph $G=(V,E)$ with $\left|V\right|=n\in \{10,20,30,40\}$ is randomly generated, and its vertices and the anchor point are placed uniformly at random inside a $1\times 1\times 1$ cube. To obtain a random graph G of size n, we generated a series of graphs $G^{\prime }=(V^{\prime },E^{\prime })$ of size $n\le |V^{\prime }|<n+\lceil n/4\rceil$ following the Erdős–Rényi model with $p=2.5/n$, until finding a $G^{\prime }$ with a connected component of size n which is used as G. Lastly, $\tau$ is obtained from the Euclidean distances between the locations of the vertices and the anchor point.

We implemented the proposed MIQCP using Python and a commercial version of Gurobi 9.5.1 [38]. Although there are other optimization solvers, not all of them can solve MIQCP problems. Gurobi and CPLEX [39] are among the best solvers with such capabilities. From them, we selected Gurobi because it is one of the fastest optimization solvers to date. All the experiments were executed using a computer running Ubuntu 20.04 on an Intel Core i7-6700 processor of 3.40 GHz with 32 GB of RAM.

For the results presented here, we used optimal values of the two hyperparameters introduced in the MIQCP—namely, the upper bound B for the number of time slots needed to complete the diffusive process and the upper bound D for the maximum number of vertices that can be defended in a single time slot. These optimal values were determined experimentally for each instance. As discussed in Section 4, the values of these upper bounds significantly impact the performance of the MIQCP because they determine the number of constraints. It is also important to highlight that underestimating these values precludes the MIQCP from finding optimal and even correct solutions.

Figure 3 presents the running times needed to solve instances with increasing numbers of vertices and initial fires, and when scaling function $\tau$ by a factor $\lambda \in \{2,7\}$. The solid lines represent the average value computed over ten different random instances, and the shaded region represents the confidence interval for a confidence level of $95\%$. The results are as expected. From the figure, we can observe that the running time increases rapidly as the size of the graphs (n) increases because the numbers of linear ($\mathcal{O}(max\{\left|E\right|D,nBD\left\}\right)$) and quadratic ($\mathcal{O}\left(nBD\right)$) constraints increase as a function of n. We can also observe that the running time tends to be smaller with a larger number of initial burnt vertices ($\left|F\right|$) because the upper bound B on the number of time slots needed to complete the diffusive process also tends to be smaller as $\left|F\right|$ increases. The latter is because B is proportional to the length of the shortest paths from vertices in F to the remaining vertices in G. Lastly, the running time decreases as the value of $\lambda$ increases because the upper bound D on the number of vertices that can be defended in a single time slot decreases.

Figure 4 shows the average number of burnt vertices at the end of the diffusive processes when increasing the number of vertices, the number of initial fires, and the value of $\lambda$. As expected, the number of burnt vertices increases as the size of the graphs increases because, in general, the fire can propagate to a larger number of vertices. Increasing the number of initial fires increases the number of burnt vertices because the firefighter has to contain more than one diffusive process. This also reduces the objective function’s variability because having more than one initial fire makes the diffusive process less sensitive to the topological properties of the neighborhood where the fire breaks out. Lastly, the number of burnt vertices increases as the value of $\lambda$ increases because this has the effect of making the firefighter slower.

We performed experiments for graphs of size $n=50$, but unfortunately, most of the executions did not end within a predefined time budget of 24 h, and in many cases, experienced memory crashes. This indicates a need for more scalable solutions for the MFP.

6. Conclusions

We presented the moving firefighter problem (MFP), a generalization of the original firefighter problem (FP) presented by Hartnell, which incorporates a function $\tau$ that determines the time it takes a firefighter to move from vertex u to vertex v in the input graph to defend v. We argue that this generalization allows modeling more realistic situations where the time needed to defend an entity modeled by a vertex is not the same for all the entities and where there is either a physical or logical distance between each pair of entities. This new formulation has practical applications for studying the spread and containment dynamics in networks.

Using polynomial time reduction from the decision version of the original firefighter problem for a single firefighter 1-FP, we showed that the decision version of the moving firefighter problem for a single firefighter 1-MFP is indeed a generalization of the 1-FP, and hence, that it belongs to the NP-complete class of problems.

We presented a mixed-integer quadratically constrained program (MIQCP) for the optimization version of the 1-MFP with metric functions $\tau$ that have $\mathcal{O}\left(nBD\right)$ binary variables, $\mathcal{O}\left(B\right)$ real-valued variables, $\mathcal{O}(max\{\left|E\right|D,nBD\left\}\right)$ linear constraints, and $\mathcal{O}\left(nBD\right)$ quadratic constraints. B and D are upper bounds to the numbers of burning and defense rounds, respectively. To empirically characterize the performance of the MIQCP, we solved 160 randomly generated instances. The results revealed that the running time of the MIQCP strongly depends on finding adequate values for B and D.

Future work includes designing scalable solutions for the 1-MFP, solutions for instances with more than one firefighter, and solutions specifically tailored for particular topologies such as trees. We also intend to design approximation algorithms and characterize the approximability of the MFP.