Burn and Win

Pradeesha Ashok1 , Sayani Das2 , Lawqueen Kanesh3 , Saket Saurabh2,4 ,

Avi Tomar1(B) , and Shaily Verma2
1
International Institute of Information Technology Bangalore, Bengaluru, India
{pradeesha,Avi.Tomar}@iiitb.ac.in
2
The Institute of Mathematical Sciences, Chennai, India
{sayanidas,saket,shailyverma}@imsc.res.in
3
Indian Institute of Technology Jodhpur, Jodhpur, India
[email protected]
4
University of Bergen, Bergen, Norway

Abstract. Given a graph G and an integer k, the Graph Burning

problem asks whether the graph G can be burned in at most k rounds.
Graph burning is a model for information spreading in a network, where
we study how fast the information spreads in the network through its
vertices. In each round, the fire is started at an unburned vertex, and
fire spreads from every burned vertex to all its neighbors in the subse-
quent round burning all of them and so on. The minimum number of
rounds required to burn the whole graph G is called the burning number
of G. Graph Burning is NP-hard even for the union of disjoint paths.
Moreover, Graph Burning is known to be W[1]-hard when parameter-
ized by the burning number and para-NP-hard when parameterized by
treewidth. In this paper, we prove the following results:
– In this paper, we give an explicit algorithm for the problem parame-
terized by treewidth, τ and k, that runs in time k2τ 4k 5τ nO(1) . This
also gives an FPT algorithm for Graph Burning parameterized by
burning number for apex-minor-free graphs.
– Y. Kobayashi and Y. Otachi [Algorithmica 2022] proved that the
problem is FPT parameterized by distance to cographs and gave a
double exponential time FPT algorithm parameterized by distance
to split graphs. We improve these results partially and give an FPT
algorithm for the problem parameterized by distance to cographs ∩
split graphs (threshold graphs) that runs in 2O(t ln t) time.
– We design a kernel of exponential size for Graph Burning in trees.
– Furthermore, we give an exact algorithm to find the burning number
of a graph that runs in time 2n nO(1) , where n is the number of
vertices in the input graph.

Keywords: Burning number · fixed-parameter tractability ·

treewidth · threshold graphs · exact algorithm

1 Introduction
Given a simple undirected graph G = (V, E), the graph burning problem is defined
as follows. Initially, at round t = 0, all the nodes are unburned. At each round t ≥ 1,
c The Author(s), under exclusive license to Springer Nature Switzerland AG 2023
S.-Y. Hsieh et al. (Eds.): IWOCA 2023, LNCS 13889, pp. 36–48, 2023.
https://doi.org/10.1007/978-3-031-34347-6_4
 Burn and Win 37

one new unburned vertex is chosen to burn, if such a node exists, and is called a fire
source. When a node is burned, it remains burned until the end of the process. Once
a node is burned in round t, its unburned neighbors become burned in round t + 1.
The process ends when there are no unburned vertices in the graph. The burning
number of a graph G is the minimum number of rounds needed to burn the whole
graph G, denoted by b(G). The sources chosen in each round form a sequence of
vertices called a burning sequence of the graph. Let {b1 , b2 , · · · , bk } be a burning
sequence of graph G. For v ∈ V, Nk [v] denotes the set of all vertices within distance
k from v, including v. Then, 1≤i≤k Nk−i [bi ] = V .
Given a graph G and an integer k, the Graph Burning problem asks if
b(G) ≤ k? This problem was first introduced by Bonato, Janssen, and Roshanbin
[3,4,13]. For any graph G with radius r and diameter d, (d + 1)1/2  ≤ b(G) ≤
r + 1. Both bounds are tight, and paths achieve the lower bound.
The Graph Burning is not only NP-complete on general graphs but for
many restricted graph classes. It has been shown that Graph Burning is NP-
complete when restricted to trees of maximum degree 3, spider and path-forests
[1]. It was also shown that this problem is NP-complete for caterpillars of max-
imum degree 3 [8,12]. In [7], authors have shown that Graph Burning is NP-
complete when restricted to interval graphs, permutation graphs, or disk graphs.
Moreover, the Graph Burning problem is known to be polynomial time solv-
able on cographs and split graphs [10].
The burning number has also been studied in directed graphs. Computing the
burning number of a directed tree is NP-hard. Furthermore, the Graph Burning
problem is W[2]-complete for directed acyclic graphs [9]. For further information
about Graph Burning, the survey by Bonato [2] can be referred to.
The parameterized complexity of Graph Burning was first studied by
Kare and Reddy [10]. They showed that Graph Burning on connected graphs
is fixed-parameter tractable parameterized by distance to cluster graphs and
by neighborhood diversity. In [11], the authors showed that Graph Burning
is fixed-parameter tractable when parameterized by the clique-width and the
maximum diameter among all connected components, which also implies that
Graph Burning is fixed-parameter tractable parameterized by modular-width,
by tree-depth, and by distance to cographs. They also showed that this prob-
lem is fixed-parameter tractable parameterized by distance to split graphs. It
has also been shown that Graph Burning parameterized by solution size, k,
is W[2]-complete. The authors also showed that Graph Burning parameter-
ized by vertex cover number does not admit a polynomial kernel unless NP ⊆
coNP/poly.
Our Results: In Sect. 2 we add all the necessary definitions. In Sect. 3, we
use nice tree decomposition of G to give an FPT algorithm for Graph Burn-
ing parameterized by treewidth and solution size. This result also implies that
Graph Burning parameterized by burning number is FPT on apex-minor-free
graphs. In Sect. 4, we show that Graph Burning is fixed-parameter tractable
when parameterized by distance to cographs ∩ split graphs, also known as thresh-
old graphs, which partially improve the results given in [11]. In Sect. 5, we design
38 P. Ashok et al.

an exponential kernel for Graph Burning in trees. In Sect. 6, we give a non

trivial exact algorithm for finding the burning number in general graphs.

2 Preliminaries
We consider the graph, G = (V, E), to be simple, finite, and undirected throughout
this paper. G[V \X] represents the subgraph of G induced by V \X. NG (v) repre-
sents the set of neighbors of the vertex v in graph G. We simply use N (v) if there is
no ambiguity about the corresponding graph. NG [S] = {u : u ∈ NG (v), ∀v ∈ S}.
For v ∈ V , Nk [v] denotes the set of all vertices within distance k from v, including v
itself. N1 [v] = N [v], the closed neighborhood of v. For any pair of vertices u, v ∈ V ,
distG (v, u) represents the length of the shortest path between vertices u and v in
G. The set {1, 2, · · · , n} is denoted by [n]. For definitions related to parameterized
complexity, refer the book by Cygan et al. [5].
A graph G is an apex graph if G can be made planar by removing a vertex.
For a fixed apex graph H, a class of graphs S is apex-minor-free if every graph
in S does not contain H as a minor. A threshold graph can be built from a single
vertex by repeatedly performing the following operations.
(i) Add an isolated vertex.
(ii) Add a dominating vertex, i.e., add a vertex that is adjacent to every other
vertex.
Thus for a threshold graph G, there exists an ordering of V (G) such that any
vertex is either adjacent to every vertex that appears before that in the ordering
or is adjacent to none of them.

3 Parameterized by Treewidth and Burning Number

We prove the following result in this section.
Theorem 1. Graph Burning is FPT for apex-minor-free graphs when param-
eterized by burning number.
To prove this result, we first give an FPT algorithm for Graph Burn-
ing parameterized by treewidth+burning number. For definitions and notations
related to treewidth, refer the book by Cygan et al. [5].

Theorem 2. Graph Burning admits an FPT algorithm that runs in

k 2τ 4k 5τ nO(1) time, when parameterized by the combined parameter, treewidth
τ and burning number k.

Proof. We use dynamic programming over a nice tree decomposition T of G. We

shall assume a nice tree decomposition of G of width τ is given.
We use the following notation as in [5]. For every node t in the nice tree
decomposition, we define Gt to be a subgraph of G where Gt = (Vt , Et = {e :
e is introduced in the subtree of t}). Vt is the union of all vertices introduced in
 Burn and Win 39

the bags of the subtree rooted at t. For a function f : X → Y and α ∈ Y , we

define a new function fv→α : X ∪ {v} → Y as follows:

f (x), when x = v
fv→α (x) =
α, when x = v

We define subproblems on every node t ∈ V (T ). We consider the partitioning

of the bag Xt by a mapping Ψ : Xt → {B, R, W }, where B, R, and W respec-
tively represent assigning black, grey, and white colors to vertices. Intuitively, a
black vertex represents a fire source, a grey vertex is not yet burned, and a white
vertex is burned by another fire source through a path that is contained in Gt .
Each vertex is further assigned two integer values by two functions F S : Xt → [k]
and D : Xt → [k − 1] ∪ {0}. For a vertex v ∈ Xt , F S(v) intuitively stores the
index of the fire source that will burn v, and D(v) stores the distance between
the fire source and v.
Let S be the set {∗, ↑, ↓}. For every bag, we consider an array γ ∈ S k . Here
the entries in γ represent the location of each fire source with respect to the bag
Xt . More precisely, for 1 ≤ i ≤ k, γ[i] is ∗ when the i-th fire source is in Xt , is
↓ when the i-th fire source is in Vt \ Xt and ↑ otherwise.
For a tuple f [t, γ, F S, D, Ψ ], we define that a burning sequence of G realizes
the tuple if the fire sources in the burning sequence match γ i.e., for 1 ≤ i ≤ k,
the i-th fire source is in Xt , Vt \ Xt and V \ Vt if γ[i] is ∗, ↓ and ↑ respectively
and the following conditions are met.

1. A black vertex v ∈ Xt is part of the burning sequence at index F S(v).

2. A white vertex v ∈ Xt is burned by a fire source with index F S(v) by a path
of length D(v) that lies entirely in Gt .
3. A grey vertex v ∈ Xt is not burned in Gt .
4. For a vertex v in Vt \ Xt , v is either burned or there exists a path from v to
a grey vertex u ∈ Xt such that F S(u) + D(u) + distG (u, v) ≤ k.

We now define a sub-problem f [t, γ, F S, D, Ψ ] that returns T rue if and only if

there exists a burning sequence that realizes [t, γ, F S, D, Ψ ]. From the above def-
inition, it is easy to see that G admits a burning sequence of length k if and only
if f [t, γ, F S, D, Ψ ], where t is the root node (and therefore empty), γ contains all
entries as ↓ and F S, D, Ψ are null, returns T rue.
A tuple (t, F S, D, γ, Ψ ) is valid if the following conditions hold for every
vertex v ∈ Xt .

– Ψ (v) = B if and only if D(v) = 0 and γ[i] = ∗, where i = F S(v).

– Ψ (v) = W , if and only if D(v) > 0 and γ[i] = ∗ or γ[i] =↓, where i = F S(v).
– For all vertices v, D(v) ≤ k − F S(v).
– For all 1 ≤ i ≤ k such that γ[i] = ∗, there exists exactly one vertex v in Xt
such that F S(v) = i and D(v) = 0.

For an invalid tuple, f [.], by default, returns F alse. We now define the values of
f [.] for different types of nodes in T .
40 P. Ashok et al.

Leaf Node: In this case, Xt = ∅. So f [t, γ, F S, D, Ψ ] returns T rue if γ[i] =↑,

for all 1 ≤ i ≤ k and F S, D, Ψ are null functions. Otherwise, this returns F alse.
Introduce Vertex Node: Let v be the vertex being introduced and t be the
only child node of t such that v ∈ / Xt and Xt = Xt ∪ {v}.
⎧
⎪  
⎨f [t , γ , F S|Xt , D|Xt , Ψ|Xt ], if Ψ (v) = B

f [t, γ, F S, D, Ψ ] = f [t , γ, F S|Xt , D|Xt , Ψ|Xt ], if Ψ (v) = R
⎪
⎩
F alse, if Ψ (v) = W
In the recurrence, γ  is the same as γ except that γ  [F S(v)] =↑. The correctness
of the recurrence follows from the fact that v is an isolated vertex in Gt and v
is not present in Gt .
Forget Vertex Node: Let t be the only child node of t such that ∃v ∈
/ Xt and
Xt = Xt ∪ {v}.
We now give the recurrence as follows.

⎧ 
⎪
⎪ f [t , γγ[i]→∗ , F Sv→i , Dv→0 , Ψv→B ]
⎪
⎪ :
⎪i γ[i]=↓
⎪  f [t , γ, F Sv→i , Dv→j , Ψv→W ]
⎪
⎪
⎪
⎨i : γ[i]=↑,
f [t, γ, F S, D, Ψ ] = 1≤j≤k−i

⎪
⎪
⎪
⎪ f [t , γ, F Sv→F S(w) , Dv→j , Ψv→R ]
⎪
⎪ 1≤j≤k
⎪
⎪
⎪ ∃w∈Xt such that
⎩j≤k−F S(w),D(w)=j−dist G (v,w)
and Ψ (w)=R

In the last case, we consider the case where v is burned by a path P that lies
outside Gt , at least partially. The feasibility of P is tracked by a vertex w ∈ Xt
that is closer to the fire source in P 1 .

Lemma 1. [*] The recurrence for Forget Vertex Node is correct.

Introduce Edge Node: Let t be an introduce edge node with child node t
and let (u, v) be the edge introduced at t. We compute the value of f based on
the following cases.

1. If Ψ (u) = Ψ (v) = R, set f [t, γ, F S, D, Ψ ] = f [t , γ, F S, D, Ψ ]

2. If F S(u) + D(u) = F S(v) + D(v), set f [t, γ, F S, D, Ψ ] = f [t , γ, F S, D, Ψ ]
3. If F S(u) + D(u) + 1 = F S(v) + D(v) and F S(u) = F S(v), set
f [t, γ, F S, D, Ψ ] = f [t , γ, F S, D, Ψ ]
4. If Ψ (v) ∈ {B, W }, Ψ (u) = W, F S(u) = FS(v) and D(u) = D(v) + 1, then set
f [t, γ, F S, D, Ψ ] = f [t , γ, F S, D, Ψu→R ] f [t , γ, F S, D, Ψ ]
5. For all other cases, set f [t, γ, F S, D, Ψ ] = F alse

Lemma 2. [*] The recurrence for Introduce Edge Node is correct.

1
Proofs of results that are marked with [*] are omitted due to the space constraint.
 Burn and Win 41

Join Node: Let t be a join node and t1 , t2 be the child nodes of t such that
Xt = Xt1 = Xt2 . We call tuples [t1 , γ1 , F S, D, Ψ1 ] and [t2 , γ2 , F S, D, Ψ2 ] as
[t, γ, F S, D, Ψ ]-consistent if the following conditions hold.
For all values of i, 1 ≤ i ≤ k,

if γ[i] = ∗ then γ1 [i] = γ2 [i] = ∗

if γ[i] =↑ then γ1 [i] = γ2 [i] =↑
if γ[i] =↓ then either γ1 [i] =↓, γ2 [i] =↑ or γ1 [i] =↑, γ2 [i] =↓

For all v ∈ Xt ,

if Ψ (v) = B then Ψ1 (v) = Ψ2 (v) = B

if Ψ (v) = R then Ψ1 (v) = Ψ2 (v) = R
if Ψ (v) = W then (Ψ1 (v), Ψ2 (v)) ∈ {(W, W ), (W, R), (R, W )}

We give a short intuition for the above. The cases where γ[i] = ∗ and γ[i] =↑
are easy to see. When γ[i] =↓, the i-th fire source is below the bag. By the
property of the tree decomposition, Vt1 \ Xt and Vt2 \ Xt are disjoint. Therefore,
exactly one of γ1 [i] and γ2 [i] is set to ↓. Similarly, Ψ (v) = B and Ψ (v) = R are
easy to see. When Ψ (v) = W , the vertex is already burned below. Here again,
there are two possibilities: v is burned in exactly one of Gt1 and Gt2 and v is
burned in both of them (possibly by different paths). Therefore, (Ψ1 (v), Ψ2 (v)) ∈
{(W, W ), (W, R), (R, W )}.
Then, the recurrence is as follows, where the OR operations are done over
all pairs of tuples, which are [t, γ, F S, D, Ψ ]-consistent.

f [t, γ, F S, D, Ψ ] = (f [t1 , γ1 , F S, D, Ψ1 ] ∧ f [t2 , γ2 , F S, D, Ψ2 ])

Lemma 3. [*] The recurrence for Join node is correct.

Running Time: Note that we can compute each entry for f [·] in time k 2τ 3k 3τ
nO(1) , except for join nodes. For join nodes, we require extra time as we are com-
puting over all possible consistent tuples. Let (γ, γ1 , γ2 ) and (Ψ, Ψ1 , Ψ2 ) be such
that (t1 , γ1 , F S, D, Ψ1 ) and (t2 , γ2 , F S, D, Ψ2 ) are (t, γ, F S, D, Ψ ) consistent then,
∀i ∈ [k], (γ[i], γ1 [i], γ2 [i]) ∈ {(∗, ∗, ∗), (↑, ↑, ↑), (↓, ↓, ↑), (↓, ↑, ↓)} and ∀v ∈ Xt ,
(Ψ [v], Ψ1 [v], Ψ2 [v]) ∈ {(B, B, B), (R, R, R), (W, W, W ), (W, W, R), (W, R, W )}.
Therefore, the total number of consistent tuples over all join nodes is upper
bounded by k 2τ 4k 5τ nO(1) . Hence the running time of the algorithm can be
bounded by k 2τ 4k 5τ nO(1) . 

For apex-minor-free graphs, the treewidth is bounded by the diameter of the
graph, as shown in [6]. It has been established that the diameter of a graph is
bounded by a function of the burning number of the graph [4]. As a result, the
treewidth of apex-minor-free graphs is bounded by a function of the burning
number. This observation, along with Theorem 2, proves Theorem 1.
42 P. Ashok et al.

4 Parameterized by Distance to Threshold Graphs

In this section, we give an FPT algorithm for Graph Burning parameterized
by the distance to threshold graphs. Recall that the problem is known to be
in FPT; the paper [11] shows that Graph Burning is FPT parameterized
by distance to cographs and gives a double-exponential time FPT algorithm
when parameterized by distance to split graphs. Since both these parameters
are smaller than the distance to threshold graphs that are precisely the graphs
in graph-class cographs ∩ split, these results imply fixed-parameter tractability
when the distance to threshold graphs is a parameter. Here, we give an FPT
algorithm that runs in single-exponential time, which improves the previously
known algorithms. We will consider a connected graph G = (V, E) and a subset
X ⊆ V with |X| = t, such that the induced subgraph G[V \ X] is a threshold
graph. It is assumed that the set X is given as part of the input.
Theorem 3. Graph Burning on G can be solved in time t2t nO(1) .
Proof. Since G[V \X] is a threshold graph, there exists an ordering Π of vertices
such that every vertex is either a dominating vertex or an isolated vertex for the
vertices preceding it in Π. Let vd ∈ V \ X be the last dominating vertex in
Π and (D, I) be the partition of V \ X such that D is a set that contains the
vertices in Π till the vertex vd and I is the set containing all remaining vertices.
Thus, in G[V \ X], I is a maximal set of isolated vertices.
We observe that G can be burned in at most t + 3 steps. In at most t steps,
we set each vertex in X as a fire source. Since every vertex in I has at least
one neighbor in X, all vertices in I are burned in at most t + 1 steps. Similarly,
since at least one vertex from D has a neighbor in X and D induces a graph of
diameter 2, every vertex in D is burned in at most t + 3 steps. Therefore, we
assume k < t + 3 for the rest of the proof.
For a valid burning sequence of length k of the graph G, for every vertex
v ∈ V , let (f s(v), d(v)) be a pair where 1 ≤ f s(v) ≤ k and 0 ≤ d(v) ≤ k − f s(v),
such that f s(v) is the index of the fire source that burns the vertex v and d(v)
is the distance between that fire source and v. It also implies that v is going to
burn at the (f s(v) + d(v))-th round. When two fire sources can simultaneously
burn v in the same round, f s(v) is assigned the index of the earlier fire source.
The basic idea of the algorithm is to guess the pair (f s(v), d(v)) for every v ∈ X
and then extend this guess into a valid burning sequence for G in polynomial
time.
Consider two families of functions F = {f s : X → [k]} and D = {d : X →
{0} ∪ [k − 1]} on X. A pair (f s, d) ∈ F × D corresponds to a guess that decides
how a vertex in X is burnt. We further extend this to an augmented guess by
guessing the fire sources in D. We make the following observation based on the
fact that every pair of vertices in D is at a distance at most two since vd is
adjacent to every vertex in D.
Observation 1. There can be at most two fire sources in D. Moreover, if there
are two fire sources in D, they are consecutive in the burning sequence.
 Burn and Win 43

Thus, an augmented guess can be considered as extending the domain of the

functions f s and d to X ∪ D where D ⊆ D and 0 ≤ |D| ≤ 2. Note that, for all
v ∈ D , d(v) = 0 since we are only guessing the fire sources in D.
An augmented guess is considered valid if the following conditions are true.

1. For all v in the domain of the functions, 0 ≤ d(v) ≤ k − f s(v).

2. For all 1 ≤ i ≤ k, there exists at most one vertex v such that f s(v) = i and
d(v) = 0.
3. For all u, v in the domain of the functions, |(f s(u) + d(u)) − (f s(v) + d(v))| ≤
distG (u, v).

Algorithm 1 gives the procedure to extend a valid augmented guess to a valid

burning sequence by identifying the firesources in I. Specifically, Algorithm 1
takes a valid augmented guess as input and returns YES if it can be extended
to a burning sequence of length k.

Algorithm 1.
1: for 1 ≤ i < k such that v such that f s(v) = i and d(v) = 0 do
2: Xi = {v ∈ X : f s(v) = i, d(v) = 1}
3: if Xi is not empty then
4: Ii = {u ∈ I : Xi ⊆ N (u)}; Fi = Ii
5: for u ∈ Ii do
6: if there exists w ∈ N (u) \ Xi such that (f s(w) + d(w) = i + 2) ∨ (f s(w) +
d(w) = i − 1) ∨ (f s(w) = i + 1 ∧ d(w) = 0) then
7: Delete u from Fi .
8: if (i = k − 1) then
9: if Fi is not empty then
10: Let v be an arbitrary vertex in Fi . Set v as the i-th fire source.
11: else return NO.
12: else
13: F  = {u ∈ Fi : ∀w ∈ N (u) \ Xi , f s(w) + d(w) = k}
14: if |F  | > 2 then return NO.
15: else if F  = ∅ then
16: set an arbitrary vertex in F  as the i-th fire source.
17: else
18: set an arbitrary vertex in Fi as the i-th fire source.
19: if CheckValidity() = True then
20: Return YES.
21: else return NO.

Lemma 4. Algorithm 1 is correct.

Proof. It is enough to prove that the fire sources in I are correctly identified.
For every 1 ≤ i < k such that the i-th fire source is not “discovered” yet,
we consider the vertices in Xi . Ii ⊆ I is the set of vertices adjacent to every
44 P. Ashok et al.

vertex in Xi . The i-th fire source, if exists, should be one of the vertices from
Ii . The algorithm further considers a set Fi that is obtained from Ii by filtering
out vertices that cannot be the i-th fire source. Specifically, the set Fi contains
vertices v such that, Xi ⊆ N (v) and for all w ∈ N (v) \ Xi , i ≤ f s(w) + d(w) ≤
i + 1. We shall show that a vertex outside this set cannot be the i-th fire source.
Let v ∈ Ii and w ∈ N (v) \ Xi . For all u ∈ Xi , f s(u) + d(u) = i + 1 and
distG (u, w) ≤ 2, since they have a common neighbor v. By the constraint given
in the definition of a valid augmented guess, i − 1 ≤ f s(w) + d(w) ≤ i + 3. If
f s(w) + d(w) ≥ i + 2, then f s(v) + d(v) ≥ i + 1 and v is not the i-th fire source.
Also, if f s(w) + d(w) = i − 1, then f s(w) < i and v is not the i-th fire source
since an earlier fire source can burn v in the i-th round. Further, if v is the i-th
fire source, then the case where f s(w) = i + 1 and d(w) = 0 is not possible
since w will be burned by v in the (i + 1)-th round. Note that, by definition, if a
vertex v can be burned simultaneously by two different fire sources, then f s(v)
is assigned the index of the earlier fire source. Thus, the i-th fire source, if exists,
should belong to the set Fi .
Assume i < k − 1. Let v1 and v2 be arbitrary vertices in the set Fi and let v1
be the i-th fire source in a burning sequence γ of G. Now, we will prove that a
sequence γ  obtained by replacing v1 with v2 as the i-th fire source in γ is also a
valid burning sequence. Note that, in γ, Xi is exactly the set of vertices that are
burned by v1 in the (i + 1)-th round since any other neighbor of v1 is burned in
the i-th or (i + 1)-th round by a different fire source. Now, since Xi ⊆ N (v2 ), Xi
is burned in the (i + 1)-th round by γ  also. Also, any other neighbor of v1 or v2
is burned in the i-th or (i + 1)-th round by a fire source that is not the i-th fire
source, which also ensures v1 gets burned before the k-th round. Hence, if there
exists a fire source in Ii , then any arbitrary vertex in Ii can be the fire source.
Assume i = k − 1. Now we consider the subset F  = {u ∈ Fi : ∀w ∈
N (u) \ Xi , f s(w) + d(w) = k} of Fi . A vertex in F  can be burned only if it is
the k-th or (k − 1)-th fire source. Hence, we return No if |F  | > 2. Otherwise an
arbitrary vertex is set as the (k − 1)-th fire source.
Finally, once the fire sources are set, we can check the validity of the burning
sequence in polynomial time. 

Extending a valid augmented guess can be done in polynomial time. Thus the
running time of the algorithm is determined by the number of valid augmented
guesses which is bounded by t2t nO(1) . 


5 A Kernel for Trees

In this section, we design a kernel for the Graph Burning problem on trees.
Let (T, k) be the input instance of Graph Burning where T is a tree. First, we
arbitrarily choose a vertex r ∈ V (T ) to be the root and make a rooted tree. Let
L0 , L1 , L2 , . . . , Lp be the levels of tree T rooted at r, where L0 = {r}. To give
a kernel, we give a marking procedure to mark some vertices in each level and
show that we can remove the unmarked vertices. In bottom-up fashion, starting
from the last level, in each iteration, we mark at most k + 1 children for each
 Burn and Win 45

vertex in the level, and we remove the subtree rooted at any unmarked children.
Observe that while doing that, we maintain the connectedness of the tree. We
show that the removal of subtrees rooted on unmarked vertices does not affect
the burning number of the tree. Let Tz be the subtree rooted at a vertex z and
Mi be the set of marked vertices at level Li .
Marking Procedure: For all i ∈ [p], we initialise Mi = ∅. For a fixed i, i ∈ [p],
do as follows: For each vertex x ∈ Lp−i , mark at most k + 1 children of x such
that the depth of the subtrees rooted on marked children is highest and add
them into Mp−i+1 .

Reduction Rule 1. If z ∈ Lp−i such that z ∈

/ Mp−i , then remove the subtree
Tz .

Lemma 5. The Reduction Rule 1 is safe.

Proof. To show the safeness of Reduction Rule 1, we show that (T, k) is a Yes-
instance of Graph Burning if and only if (T − Tz , k) is a Yes-instance.
For the forward direction, assume that (T, k) is a Yes-instance. Note that
T − Tz is a tree. Let (b1 , b2 , . . . , bk ) be a burning sequence for T . If any of the bi
belongs to Tz , then we replace bi by placing a fire source on the first unburned
ancestor of z in T − Tz . Therefore, we can have a burning sequence of size k.
Hence, (T − Tz , k) is a Yes-instance.
For the backward direction, assume that (T − Tz , k) is a Yes-instance, and
we need to show that (T, k) is a Yes-instance. Let P (z) be the parent of vertex z
in T . Suppose that x1 , x2 , . . . , xk+1 be the set of marked children (neighbors) of
P (z). We have to show that any vertex u in the subtree Tz can also be burned
by the same burning sequence.
Since the burning number of T − Tz is k, there is at least one marked child xj
of P (z) such that there is no fire source placed in the subtree Txj . Observe that
there exists a vertex u in the subtree Txj such that the distances d(u, P (z))
and d(u , P (z)) are the same since the height of Txj is at least the height of
subtree Tz by the marking procedure. Let the vertex u get burned by a fire
source s. Note that the fire source s is either placed on some ancestor of xj or
some subtree rooted at a sibling of xj . In both cases, the s-u path contains the
vertex P (z). Since d(u, P (z)) = d(u , P (z)), the vertex u also gets burned by the
same fire source in the same round. Thus, every vertex in Tz can be burned by
some fire source from the same burning sequence as T \ Tz . Hence, (T, k) is also
a Yes-instance. 


Iteratively, for each fixed value of i, i ∈ [p] (starting from i = 1), We apply
the marking procedure once, and the Reduction Rule 1 exhaustively for each
unmarked vertex. After the last iteration (i = p), we get a tree T  . Observe that
we can complete the marking procedure in polynomial time, and the Reduction
Rule 1 will be applied at most n times. Therefore, we can obtain the kernel T 
in polynomial time.
46 P. Ashok et al.

Kernel Size: Note that the obtained tree T  is a (k + 1)-ary tree. Let b1 be
the first fire source in T  ; then we know that b1 will burn vertices up to (k − 1)
distance. Therefore, we count the maximum number of vertices b1 can burn.
First, note that b1 will burn the vertices in the subtree rooted at b1 up to
height k − 1. Let n0 be the number of vertices in the subtree rooted at b1 . It
k−1
follows that n0 ≤ (k+1)k −1 , that is, n0 ≤ (k + 1)k−1 . Note that b1 also burns
the vertices on the path between b1 to root r up to distance k −1 and the vertices
rooted on these vertices. Let P = b1 v1 v2 . . . vk−1 . . . r be b1 -r path in T  . Then b1
also burns the vertices in the subtree rooted at vi , say Tvi , upto height k − 1 − i,
where i ∈ [k −1]. Let ni = |V (Tvi )|. Therefore, for any i ∈ [k −1], ni ≤ (k +1)k−1
as ni < n0 . Thus, the total number of vertices b1 can burn is at most (k + 1)k .
Since each fire source bi can burn only fewer vertices than the maximum number
of vertices that can be burned by source b1 , the total number of vertices any
burning sequence of size k can burn is at most (k + 1)k+1 .
Therefore, if there are more than (k + 1)k+1 vertices in T  , then we can
conclude that (T, k) is a No-instance of Graph Burning problem. This gives
us the following result.
Theorem 4. In trees, Graph Burning admits a kernel of size (k + 1)k+1 .

6 Exact Algorithm
In this section, we design an exact algorithm for the Graph Burning problem.
Here, we reduce the Graph Burning problem to the shortest path problem in
a configuration graph.
Construction of a Configuration Graph: Given a graph G = (V, E), we
construct a directed graph G = (V  , E  ) as follows:
(i) For each set S ⊆ V (G), add a vertex xS ∈ V  .
(ii) For each pair of vertices xS , xS  ∈ V  such that there exists a vertex w ∈
/S
and NG [S] ∪ {w} = S  , add an arc from xS to xS  .
We call the graph G as the configuration graph of G.

a {a} x{a,b}
xφ x{b} x{b,c} x{a,b,c}
b
x{c}
c x{a,c}

G G

Fig. 1. An illustration of G , the configuration graph of G.

Figure 1 shows an example of a configuration graph.

We have constructed G in such a way that a shortest path between the
vertices xS and xT , where S = ∅ and T = V (G), gives a burning sequence for
the original graph G. The following result proves this fact.
 Burn and Win 47

Lemma 6. [*] Let G = (V  , E  ) be the configuration graph of a given graph G

and S = ∅ and T = V (G). There exists a path of length k between the vertices
xS and xT in G if and only if there is a burning sequence for G of size k.

Lemma 6 shows that a shortest path between xS and xT in G gives the burn-
ing sequence for graph G with minimum length. Thus, we can find a minimum
size burning sequence in two steps:

(i) We construct a configuration graph G from G.

(ii) Find a shortest path between the vertices xS and xT in G , where S = ∅
and T = V (G).

Observe that we can construct the graph G in (|V (G )| + |E(G )|)-time and find
a shortest path in G in O(|V (G )| + |E(G )|)-time. We know that |V (G )| = 2n
and note that the total degree (in-degree+out-degree) of each vertex in G is at
most n. Therefore, |E(G )| ≤ n · 2n . Therefore, the total running time of the
algorithm is 2n nO(1) . Thus, we have proved the next theorem.

Theorem 5. Given a graph G, the burning number of G can be computed in

2n nO(1) time, where n is the number of vertices in G.

References
1. Bessy, S., Bonato, A., Janssen, J., Rautenbach, D., Roshanbin, E.: Burning a graph
is hard. Discret. Appl. Math. 232, 73–87 (2017)
2. Bonato, A.: A survey of graph burning. arXiv preprint arXiv:2009.10642 (2020)
3. Bonato, A., Janssen, J., Roshanbin, E.: Burning a graph as a model of social
contagion. In: Bonato, A., Graham, F.C., Prałat, P. (eds.) WAW 2014. LNCS,
vol. 8882, pp. 13–22. Springer, Cham (2014). https://doi.org/10.1007/978-3-319-
13123-8_2
4. Bonato, A., Janssen, J., Roshanbin, E.: How to burn a graph. Internet Math.
12(1–2), 85–100 (2016)
5. Cygan, M., et al.: Parameterized Algorithms, vol. 5. Springer, Heidelberg (2015)
6. Eppstein, D.: Diameter and treewidth in minor-closed graph families. Algorithmica
27, 275–291 (2000)
7. Gupta, A.T., Lokhande, S.A., Mondal, K.: NP-completeness results for graph burn-
ing on geometric graphs. arXiv preprint arXiv:2003.07746 (2020)
8. Hiller, M., Koster, A.M., Triesch, E.: On the burning number of p-caterpillars. In:
Gentile, C., Stecca, G., Ventura, P. (eds.) Graphs and Combinatorial Optimization:
from Theory to Applications, pp. 145–156. Springer, Cham (2021). https://doi.org/
10.1007/978-3-030-63072-0_12
9. Janssen, R.: The burning number of directed graphs: bounds and computational
complexity. arXiv preprint arXiv:2001.03381 (2020)
48 P. Ashok et al.

10. Kare, A.S., Vinod Reddy, I.: Parameterized algorithms for graph burning prob-
lem. In: Colbourn, C.J., Grossi, R., Pisanti, N. (eds.) IWOCA 2019. LNCS, vol.
11638, pp. 304–314. Springer, Cham (2019). https://doi.org/10.1007/978-3-030-
25005-8_25
11. Kobayashi, Y., Otachi, Y.: Parameterized complexity of graph burning. Algorith-
mica 1–15 (2022)
12. Land, M.R., Lu, L.: An upper bound on the burning number of graphs. In: Bon-
ato, A., Graham, F.C., Prałat, P. (eds.) WAW 2016. LNCS, vol. 10088, pp. 1–8.
Springer, Cham (2016). https://doi.org/10.1007/978-3-319-49787-7_1
13. Roshanbin, E.: Burning a graph as a model for the spread of social contagion.
Ph.D. thesis, Dalhousie University (2016)