Faster Heuristics for Graph Burning
aa r X i v : . [ c s . D S ] A ug Faster Heuristics for Graph Burning
Rahul Kumar Gautam, Anjeneya Swami Kare, and S. Durga Bhavani
School of Computer and Information Sciences,University of Hyderabad,Hyderabad, India
Abstract.
Graph burning is a process of information spreading throughthe network by an agent in discrete steps. The problem is to find an opti-mal sequence of nodes which have to be given information so that the net-work is covered in least number of steps. Graph burning problem is NP-Hard for which two approximation algorithms and a few heuristics havebeen proposed in the literature. In this work, we propose three heuristics,namely, Backbone Based Greedy Heuristic (BBGH), Improved CuttingCorners Heuristic (ICCH) and Component Based Recursive Heuristic(CBRH). These are mainly based on Eigenvector centrality measure.BBGH finds a backbone of the network and picks vertex to be burnedgreedily from the vertices of the backbone. ICCH is a shortest path basedheuristic and picks vertex to burn greedily from best central nodes. Theburning number problem on disconnected graphs is harder than on theconnected graphs. For example, burning number problem is easy on apath where as it is NP-Hard on disjoint paths. In practice, large net-works are generally disconnected and moreover even if the input graphis connected, during the burning process the graph among the unburnedvertices may be disconnected. For disconnected graphs, ordering of thecomponents is crucial. Our CBRH works well on disconnected graphs asit prioritizes the components. All the heuristics have been implementedand tested on several bench-mark networks including large networks ofsize more than K nodes. The experimentation also includes comparisonto the approximation algorithms. The advantages of our algorithms arethat they are much simpler to implement and also several orders fasterthan the heuristics proposed in the literature.
An application of information spread can be seen in public health campaigns.For instance in the case of covid pandemic, the health workers are struggling toget the information reach every house in order to spread awareness and preventcornona virus spread. Take the scenario of one health-worker endeavour. Shecontacts a family in the village and explains the precautions to be taken up toprotect oneself from the contagious infection and persuades that family to helpspread awareness among their acquaintances. We assume that all the memberswho can be influenced by a family are covered in one step of the awarenessampaign. In the burning number context, all those nodes that are covered arecalled as the ’burning’ nodes. Next she has to approach another new familyoutside this circle of influence to spread the message. The whole process happensin discrete steps. Hence it is important to detect an optimal sequence of familiesto be approached by the health worker that would ensure coverage of the entirevillage for propagating the information in minimum time. In paper [12], a similarapplication of passing information during emergency is discussed. Suppose apiece of information has to be sent to all the nodes in a network by a satellite.The satellite informs nodes (hubs) in discrete time steps. All the informed nodescommunicate to their neighbours in parallel. Once a node is informed it is deemedto be in informed state. Process stops when all the nodes are informed.Graphs are popular representations that model the social networks of the realworld. Let G ( V, E ) be a graph where V is set of nodes depicting people, E denoterelationship among the nodes. Initially all nodes are in unburned (uninformed)state. Given time steps t , t , t · · · t b − , at t one node is set to fire from outside.It starts burning and spreads the fire to its neighbours in a step wise fashion.During the process of burning, it is assumed that either the node is set onfire directly, called as source of fire, or node is burning by catching fire from aneighbour or it is not yet burnt. At i th time step, a new unburned node is set onfire from outside and all those nodes which have caught fire at t i − , burn theirneighbours. The process stops when the entire graph is burning, that is, or all thenodes have received information. Thus the task is to find the minimum sequenceof nodes that have to be chosen as sources of fire, that are directly burned fromoutside. It is desirable to spread the information through the network, or burnall the nodes of the network quickly. So the goal is to minimize the numberof sources. The minimum number of steps needed to burn the entire graph orthe length of the optimal burning sequence is called the burning number of thegraph. The burning number of the graph G is denoted by bn ( G ) . Let us considergraph in Fig. 1. The vertex sequences [7 , , , , [4 , , and [3 , , are validburning sequences, where as the sequence [7 , , is not a burning sequence. Theburning number of the graph is , as the graph does not have burning sequenceof length less than . Fig. 1.
An example graph, The vertex sequence [4 , , is an optimal burningsequence. The burning number of the graph is .There are a few problems related to graph burning proposed in the literature. K -centre problem [10], is one in which the K centres are chosen simultaneouslyas sources of fire. As a result the nodes burn in parallel and hence very quickly.The K-centres problem is also NP-hard. The Firefighter problem [9] is a comple-entary version of the graph burning problem, in which a firefighter protects anode to reduce spread of fire in the graph. At each time step, the firefighter selectsa node through which he can protect maximum number of nodes. On the otherhand, in graph burning, a node is selected in such a way that it can burn a max-imum number of nodes. Therefore the firefighter defends and in graph burningthe source of fire burns. Active influence spreading in social networks [6,7,15]is the problem of selection of seed sets that can influence as many nodes aspossible. In this paper, we propose three heuristics for the Graph Burning problem. The proposed heuristics are tested on some real world data sets andtheir performance is compared to the existing heuristics.
Bonato et al. [2] introduced the
Graph Burning problem and the parame-ter burning number . They have studied the properties of
Graph Burning andproposed bounds for burning number. Bessy et al. [24] proved that the decisionversion of the
Graph Burning problem is NP-Complete. There has been lot ofattention paid towards studying the
Graph Burning problem from theoreticalpoint of view. The complexity and the algorithms for the
Graph Burning prob-lem for special graph classes was studied in [3,11,21,23,24]. The characterizationand bounds for burning number was studied in [1,2,3,5,13,17,19,20]. Approxima-tion algorithms for the burning number problem was studied in [4,5,13,24]. Pa-rameterized complexity of the
Graph Burning problem was studied in [14,16].Šimon et al. [12] proposed heuristics for the
Graph Burning problem.They have studied the
Graph Burning problem empirically using both realworld data sets as well as synthetic data sets. They proposed three heuris-tics based on Eigenvector centrality, namely Maximum Eigenvector CentralityHeuristic (MECH), Cutting Corners Heuristic (CCH) and Greedy Algorithmwith Forward-Looking Search Strategy Heuristic (GFSSH). The MECH is agreedy heuristic, at each iteration it selects a (central) node with maximumeigenvector centrality. In CCH, at each iteration, first it finds a set of cornernodes of the graph, using these corner nodes, a set of central nodes are selectedbased on eigenvector centrality. Among these central nodes a best central nodeis selected using weighted aggregated sum product assessment (WASPAS) algo-rithm. In GFSSH a set of central nodes are generated and at each iteration abest central node is selected by combining greedy heuristic and forward lookingsearch.Šimon et al. [12] also implemented the -approximation algorithm ( -APRX)of Bonato et al. [4] to compare the performance of their heuristics. They havetested the heuristics on some synthetic tree data sets also, however they didnot implement the -approximation algorithm ( -APRX) for trees of Bonato etal. [4]. As stated in [4], the -approximation algorithm can also be used to com-pute an upper bound on burning number of any graph. If G is the original graphand T be any spanning tree of G then bn ( G ) ≤ bn ( T ) . So the -approximationalgorithm for trees can also be used to compute an upper bound on the burn-ng number of the graph. However the computed upper bound need not be a -approximation of the original graph.Recently, Farokh et al. [8] proposed six heuristics for the Graph Burning problem. Their heuristics are not based on Eigenvector centrality. They call thevertices in the burning sequence as activators. The first four heuristics are basedon different strategies to obtain the first activator and the rest of the activators.First activator is either a central node or it is selected randomly. The rest ofthe activators are selected such that each vertex has a unique activator. In otherwords reduce overlapping among the circle around the activators. The other twoheuristics are based on diameter, DFS and BFS of the graph.We propose three heuristics for the
Graph Burning problem. The heuris-tics are based on eigenvector centrality. We propose the following heuristics:Backbone Based Greedy Heuristic (BBGH), Improved Cutting Corners Heuris-tic (ICCH) and Component Based Recursive Heuristic (CBRH). We have alsoimplemented both -approximation and -approximation algorithms of Bonatoet al. [4]. We compare our implemented heuristics with GFSSH, the best perform-ing heuristic of Šimon et al. [12]. We also compare performance of our algorithmswith the results of Farokh et al. [8].Note that both [12] and [8] tested their heuristics on smaller data sets. Wetest our heuristics on bigger data sets as well. For example, some of the data setswe used are DIMACS, BOSHLIB, Facebook blue verified pages friends network,DBLP-citation network and huge graphs with size more than , nodes likeGemsec-Deezer(HR) (music friendship network in Europe). All three heuristicsare performing equally well on all the data sets. Our heuristics are faster thanthe GFSSH of Šimon et al. [12] and efficient compared to heuristics of Farokh etal. [8]. Moreover our heuristics are easy to implement.The rest of the paper is organized as follows: In Section 3, we discuss greedyheuristics. The Backbone Based Greedy Heuristic (BBGH) is discussed in Sec-tion 3.1. The Improved Cutting Corners Heuristic (ICCH) is discussed in Sec-tion 3.2. In Section 3.3, we discuss the Component Based Recursive Heuristic(CBRH). In Section 4, we discuss our results and some observations. We giveconclusions In Section 5. We consider the following decision version of the
Graph Burning , which asksto check if the graph G can be burned in at most b time steps. If we have an algo-rithm for Burn-Graph ( G, b ) , we can use binary search to compute minimum b for which the Burn-Graph ( G, b ) returns true. As the Graph Burning is NP -hard, we can not expect to have a exact polynomial time algorithm for Burn-Graph ( G, b ) . In this paper, we propose heuristics for Burn-Graph ( G, b ) . Theheuristics for Burn-Graph ( G, b ) , if it returns true , it means that the algorithmis successful in finding a burning sequence of length at most b . If it returns f alse ,it means that the algorithm failed to find a burning sequence of length at most b . Note that, in the later case, the graph can still be burned in at most b steps. urn-Graph ( G, b ) : Input : A graph G = ( V, E ) and a positive integer b . Question : Does the graph have a burning sequence of length at most b ?We propose three heuristics for Burn-Graph ( G, b ) . First two are greedy innature and the third one is a component based recursive algorithm. First wediscuss the greedy algorithms and then the recursive algorithm.At the outset, the process underlying the greedy algorithms is as shown inAlgorithm 1. At each iteration, the function getBestCentralN ode () extractsan unburned vertex to burn next. The two heuristics differ in the procedure getBestCentralN ode () . Algorithm 1:
Graph Burning algorithm
Input : G = ( V, E ) and a positive integer b Output:
Returns true if algorithm finds a burning sequence of length at most bor false otherwise BURN-GRAPH( G , b ) begin G ′ ( V ′ , E ′ ) ←− G ( V, E ) BS [0 ..b − ⊲ An array to represent burning sequence for j ← to b − do bestNode ←− getBestCentralNode ( G ′ , b − j − BS [ j ] ←− bestNode S ←− N b − j − G ′ [ bestNode ] V ′ ←− V ′ \ S G ′ ←− G ′ [ V ′ ] if V ′ = ∅ then for k ← to j do print( BS [ k ] ) return true return false We call a longest path starting at a node with minimum centrality value andcontaining nodes with high centrality values as the backbone path. A node on thebackbone path can potentially burn more vertices. With this intuition we proposethe Backbone Based Greedy Heuristic (BBGH). We extract the backbone pathand for each vertex in the backbone path, we see how many vertices the vertexcan burn, if we burn the vertex in the current time step. The vertex which leadsto maximum number of burned vertices is chosen as the best central node. Herethe crucial step is: how to extract the backbone path?. lgorithm 2:
Backbone Based Greedy Heuristic
Input : G = ( V, E ) and a non-negative integer r Output:
Returns Best central node getBestCentralNode( G, r ) begin C [0 ..q − ←− getComponents ( G ) bbP ath [0 ..n − ⊲ An array to represent vertices in backbone path bbLength ← bbCenrality ← foreach comp ∈ C do path [0 ..l − ← getBackboneP ath ( comp ) pathCentrality ← P v ∈ path ( centrality ( v )) if bbLength = l and pathCentrality > bbCenrality then bbCenrality ← pathCentrality bbpath ← path else if bbLength < l then bbLength ← l bbCenrality ← pathCentrality bbP ath ← path max ← bestNode ← null foreach vertex v ∈ bbpath in decreasing order of centrality do S ← N rG [ bestNode ] if | S | > max then max ← | S | bestNode ← v return bestNode A backbone path is a longest path starting at a node with minimum centralityand containing nodes with high centrality values. To compute backbone pathwe use BFS traversal. We compute BFS tree rooted at a node with minimumcentrality value. In this rooted tree we look at the nodes at highest depth, therecan be more than one such node. For all these nodes we consider shortest pathfrom the root to the node and compute average centrality of all the nodes in thepath. A path with maximum average centrality is considered as the backbonepath. The procedure getBackboneP ath () returns a path.Let us take backbone path as an array bbP ath . For each vertex v ∈ bbP ath indecreasing order of centrality values, compute S = N rG ′ [ v ] , set of all the verticeswhich are at a distance at most r from v . Then whichever node gives maximum | S | value, will become the best central node. If the graph is disconnected, thenbackbone path of each component is extracted and which ever vertex of thesebackbone paths gives maximum | S | value, we return that vertex as the bestcentral node. The complete algorithm is shown in Algorithm 2. Working of theBBGH is shown in Table 1 with an example. Note that, for the graph given in able 1. Trace of BBGH, the Algorithms 1 and 2. For each iteration verticesshown in red color are not part of the graph G . The estimated burning numberof the graph is . Original Graph ( G ) 1234 5 6 7 8 9 10 11 12 13 14 15 1617 18 19 2021 22 23 2425 26272829 3031 32333435 363738 39 40414243 444546471 st Iteration: Graph is connected and hence it has a single component. Backbone path bbpath = [16 , , , , , , , , , , , , , , , and best central node is for radius . Here, by radius we mean the number of remaining steps in the burning sequence.)After st Iteration nd Iteration: Graph has two components and backbone path bbpath = [6 , , , , , andbest central node is for radius .After nd Iteration rd Iteration: Graph has two components and backbone path bbpath = [16 , , and bestcentral node is for radius .After rd Iteration th Iteration: Graph has one component and backbone path bbpath = [6] and best centralnode is for radius .After th Iteration able 1, GFSSH of Šimon et al. [12] gives a burning sequence of size , where asour BBGH burns the graph in time steps. Šimon et al. [12], presented heuristic called Cutting Corner Heuristic (CCH).Their algorithm has O ( mn ) time complexity. We present a similar heuristic whichalso runs in worst case O ( mn ) time. However our algorithm is easy to implementand runs faster in practice as we avoid computation of average path length andcall to weighted aggregated sum product assessment (WASPAS) method.Let r be the number of time steps available to burn the graph. We start bycomputing the centrality values. Let u be the node with maximum centrality.We remove the r neighborhood of u , that is, all the vertices in the set N rG [ u ] from the graph G . If the resulting graph is empty, then we return the vertex u as the best central node. Otherwise, let the resulting graph have q components,say C [0] , C [1] , · · · , C [ q − . For each component C [ i ] , ≤ i < q , we take theminimum centrality vertex (say v i ) of the component C [ i ] and compute shortestpath from u to v i and let the shortest path be denoted by P [ i ] . We visualize P [0] , P [1] , · · · , P [ q − as a matrix (multi-list), where each P [ i ] is treated asa row in the matrix. Now for each column of the matrix, we pick r nodes indecreasing order of degree. If c is the number of columns of the matrix, we willget at most r ∗ c such nodes. For each of these nodes, we compute S = N rG [ . ] value. Then whichever node gives maximum | S | value, will become the bestcentral node. The process is depicted in the Algorithm 3. Working of the ICCHis shown in Table 2 with an example. From our results, we observe that ourICCH performs better than the CCH of Šimon et al. [12]. lgorithm 3: Improved Cutting Corners Heuristic
Input : G = ( V, E ) and a non-negative integer r Output:
Returns Best central node getBestCentralNode( G , r ) begin v ←− argmax v ∈ V { centrality [ v ] } S ←− N rG [ v ] C [0 , , · · · q − ←− getComponents ( G ′ ) if q = 0 then return v matrix [][] ⊲ A two dimentional array (multi-list) to store verticesin the paths for j ← to q − do src ←− argmin u ∈ C [ j ] { centrality [ u ] } path ←− getShortestP ath ( G, v, src ) matrix [ j ] ←− path capacity ←− | S | bestNode ←− v for each column c ∈ matrix do topNodes ←− getT oprNodesByDegree ( c ) ⊲ This function return alist of top r nodes in decreasing order of degree for w ∈ topNodes do S ←− N rG [ w ] if capacity ≤ | S | then capacity ←− | S | bestNode ←− w return bestNode If the graph is disconnected, choosing of a component to burn a vertex can makea difference. Let us consider the graphs in Fig. 2 and Fig. 3. These graphs havetwo components. Let us see the following criterion to select the component toburn a vertex.1.
Component with maximum size:
If we choose component with max-imum number of vertices, we need a burning sequence of length to burnthe graph in Fig. 2 and we need a burning sequence of length to burn thegraph in Fig. 3. But the actual burning number of the graph in Fig. 3 is .2. Component with maximum path length:
If we choose component withmaximum path length, we need a burning sequence of length to burn thegraph in Fig. 2 and we need a burning sequence of length to burn thegraph in Fig. 3. But the actual burning number of the graph in Fig. 2 is . able 2. Trace of ICCH, the Algorithms 1 and 3. For each iteration verticesshown in red color are not part of the graph G . The estimated burning numberof the graph is . Original Graph ( G ) 1234 5 6 7 8 9 10 11 12 13 14 15 1617 18 19 2021 22 23 2425 26272829 3031 32333435 363738 39 40414243 444546471 st Iteration: graph is connected and hence it has a single component. We get node asthe next node to burn for radius .After st Iteration nd Iteration: We get node as the next node to burn for radius .After nd Iteration rd Iteration: We get node as the next node to burn for radius .After rd Iteration
For the graph given in Fig. 2, the Backbone Based Greedy Heuristic will choosethe component with vertex set { , , · · · , } and vertex is chosen as the bestcentral node. Now we can see that we require time steps to burn the graph. Butthe burning number of the graph is . The optimum burning sequence chooses avertex from the second component. Note that even if graph is connected in thebeginning, in the subsequent iterations the graph can be disconnected and thissituation can arise. Therefore choosing a component is very crucial. Thereforethe question is what is the criteria to select the best component of the graph.Ideally we should choose a component that has maximum burning number. Fig. 2.
An example disconnected graph. The burning number of the graph is . Fig. 3.
An example disconnected graph. The burning number of the graph is .In the Component Based Recursive algorithm, we recursively run the Back-bone Based Greedy Heuristic and which ever component leads to maximum burn-ing number, we choose such a component. For each component the algorithmrecursively estimates the burning number of the component. During the recur-sive calls, burning number computed for a component is stored in a dictionaryto avoid redundant recursive calls. The component with maximum estimatedburning number is selected and from which best central node is selected. Theprocess is described in the Algorithm 4. For the example considered in Table 1,the trace of the algorithm is very similar that of Algorithm 2.Our BBGH and ICCH fails to compute optimal burning sequence of eithergraph in Fig. 2 or Fig. 3. But our CBRH computes optimal burning sequence forboth the graphs. For the connected graph given in Fig. 4, our CBRH computesthe optimal burning number but our other two heuristics, BBGH, ICCH andGFSSH of Šimon et al. [12] fail to compute optimal burning sequence. Thisconcludes the significance of our ICCH. Fig. 4.
An example graph, The vertex sequence [13 , , , , is an optimalburning sequence. The burning number of the graph is . lgorithm 4: Component Based Recursive Heuristic
Input : G = ( V, E ) , a positive integer b and a dictionary D Output:
Returns the length of minimal burning sequence of size at most b or-1 if algorithm fails to find burning sequence of length at most b. Notethat the algorithm prints the burning sequence as well. EstimateBurningNumber( G , b , D ) begin bn ←− − for i ← b down to do G ′ ( V ′ , E ′ ) ←− G ( V, E ) BS [0 ..b − ⊲ An array to represent burning sequence for j ← to i − do C [0 ..q − ←− getComponents ( G ′ ) bestComp ←− C [0] max ←− − bg ←− − if q > then for k ← to q − do if C [ k ] ∈ D then bg ←− D [ C [ k ]] ⊲ D is a dictionary with componentas the key and burning number as the value else bg ←− EstimateBurningNumber ( C [ k ] , i, D ) D [ C [ k ]] ←− bg if max < bg then max ←− bg bestComp ←− C [ k ] bbP ath ←− getBackboneP ath ( bestComp ) max ←− bestNode ←− null for each vertex v ∈ bbpath do S ←− N i − j − bestComp [ v ] if | S | > max then max ←− | S | bestNode ←− v BS [ j ] ←− bestNode S ←− N i − j − bestComp [ bestNode ] V ′ ←− V ′ \ S G ′ ←− G ′ [ V ′ ] if V ′ = φ then bn ←− i break if V ′ = φ then return bn return bn Results and Discussion
We tested our heuristics on the following data sets:1. The Network Data Repository [22] – Netscience – Polblogs – Reed98 – Mahindas – Cite-DBLP2. Stanford large network dataset collection (SNAP Datasets) [18] – Chameleon – TVshow – Ego-Facebook – Squirrel – Politician – Government – Crocodile – Gemsec-Deezer(HR)We also generated random trees and tested the performance of the algo-rithms. All the heuristics are implemented in Python programming language.The algorithms have been implemented on a system with processor Intel Core i , processor speed of . GHz having dual core and GB RAM.We compare performance of our heuristics with those of [12] and [8]. The Ta-ble 3 shows the estimated values of the burning number for various algorithms.We have compared our results with -approximation and -approximation algo-rithms of Bonato et al. [4], GFSSH, the best performing heuristic of [12] . Wehave also listed the number of recursive calls made by our Component BasedRecursive Heuristic. It can be observed that, at the outset the algorithm lookslike an exponential algorithm, but in practice the number of recursive calls madeis very less even for bigger graphs. Note that for all the social networking datasets and other data sets that have been considered in this paper, the diameter(radius) of the graph is very small. The burning number of a graph with radius r is at most r + 1 . As the radius of the graphs is very small, improving the burningby even a small number is tough. From Table 3 we observe that our heuristicsare competitive to the best heuristic of Šimon et. al. [12]. Table 4 shows therunning time comparison of our heuristics with that of GFSSH, the best per-forming heuristic of [12]. Our heuristics are faster than that of [12]. Note thatboth Šimon et. al. [12] and Farokh et al. [8] tested their heuristics on smallerdata sets. As our heuristics are faster, they take lesser time on even bigger datasets.While comparing with heuristics of Farokh et al. [8], it can be seen thatour heuristics give better results for some of the graphs. The Table 5 shows thecomparison of performance of our heuristics with that of [8]. We requested their code and run on our machine. able 3.
Comparison of estimated burning number of approximation algo-rithms [4], GFSSH of [12] and our heuristics. The last column shows the numberof recursive calls made by CBRH. *-For Netscience and Mahindas data sets, [12]quoted burning number as , however when we run their program on our machinewe got and respectively. NetworkSource Name |V| |E| - A P R X - A P R X G F SS H [ ] BB G H I CC H C B R H C B R H C a ll s Network DataRepository Netscience 379 914 12 10 7* 7 7 7 23Polblogs 643 2K 9 10 6 6 6 6 8Reed98 962 18K 6 8 4 4 4 4 46Mahindas 1258 7513 9 8 5* 5 5 5 68Cite-DBLP 12.6K 49.7K 120 82 41 41 41 41 146SNAP Data set Chameleon 2.2K 31.4K 9 10 6 6 6 6 43TVshow 3.8K 17.2K 18 16 10 10 10 10 49Ego-Facebook 4K 88K 9 6 4 4 4 4 110Squirrel 5K 198K 9 10 6 6 6 6 19Politician 5.9K 41.7K 12 12 7 7 7 7 9Government 7K 89.4K 9 10 6 6 6 6 7Crocodile 11K 170K 12 10 6 6 6 6 40Gemsec-Deezer(HR) 54K 498K 12 12 7 7 7 7 92Randomlygenerated Barabasi-Albert 1K 3K 6 8 4.9 4.9 4.9 4.9 8Erdos-Renyi 1K 6K 6 8 5 5 5 5 1
Table 4.
Comparison of running times of our heuristics with GFSSH of [12]
NetworkSource Name |V| |E| GF-SSH [12]BBGH CBRH ICCH
Network DataRepository Netscience 379 914 2m <1s 1s <1sPolblogs 643 2K 3s <1s 2s 1sReed98 962 18K 5s 3s 5s 3sMahindas 1258 7513 6s <1s 23s 3sCite-DBLP 12.6K 49.7K 3m 8s 39s 2m 22sSNAP Data set Chameleon 2.2K 31.4K 25s 8s 20s 16sTVshow 3.8K 17.2K 30s 7s 15s 22sEgo-Facebook 4K 88K 1m 17s 22s 16sSquirrel 5K 198K 3m 5s 40s 1m 40s 34sPolitician 5.9K 41.7K 1m 14s 17s 32sGovernment 7K 89.4K 1m 13s 20s 32s 50sCrocodile 11K 170K 5m 2m 36s 4m 42sGemsec-Deezer(HR) 54K 498K 1h 20m 2m 36s 47m 7mRandomlygenerated Barabasi-Albert 1K 3K 2m 1s 2s 1sErdos-Renyi 1K 6K 6m 1s 3s <1s
In this paper, we proposed three heuristics for
Graph Burning problem, namely,Backbone Based Greedy Heuristic (BBGH), Improved Cutting Corners Heuristic(ICCH) and Component Based Recursive Heuristic (CBRH). Firstly, we showa need for each heuristic by constructing the required example graphs. That is,we show a graph for which BBGH finds a better burning number compared toGFSSH; a graph on which ICCH finds a better burning number than BBGH and able 5.
Comparison of estimated burning number of heuristics of [8] and ourheuristics.
Name |V| |E| Max.deg Avg.deg c t r - H a l f c t r - f a r R a nd - H a l f R nd - F a r D F S - p a t h D - B F S - P a t h BB G H C B R H I CC H c-fat200-1 200 1534 17 15 11 8 9 7 8 8 7 7 7c-fat200-2 200 3235 34 32 6 6 6 5 5 6 5 5 5c-fat200-5 200 8473 86 84 4 4 4 4 4 3 3 3 3c-fat500-1 500 4459 20 17 12 11 12 10 15 17 9 9 10c-fat500-10 500 46627 188 186 4 4 4 4 4 4 3 3 3c-fat500-2 500 9139 38 36 9 8 9 8 11 8 7 7 7c-fat500-5 500 23191 95 92 6 6 6 6 5 6 5 5 5 finally need for the recursive algorithm of CBRH, where CBRH manages to finda better burning number than the other heuristics.We show through extensive experimentation that BBGH turns out to bethe fastest among all the heuristics and several orders faster than the heuristicGFSSH of Šimon et al. which is one of the latest heuristics proposed for thisproblem as shown in Table 4. To give an example, on the largest network of thebenchmark data set with size K, BBGH gave burning number of in m s as compared to h m taken by GFSSH. ICCH follows as a close second bydelivering the result in minutes. Lastly, the recursive heuristic though is slowerthan our other heuristics it runs faster than GFSSH on most of the large datasets. It shows a way to prioritize the ordering of selection of components in orderto obtain optimal burning number. Further, we also show the superior resultsobtained by our proposed heuristics on other data sets experimented by Farokhet al. in Table 5.We feel that the techniques used in the paper can be extended to activeinfluence spreading problems like, Target Set Selection, Perfect Seed Set andPerfect Evangelic Set problems. References
1. Bessy, S., Bonato, A., Janssen, J., Rautenbach, D., Roshanbin, E.: Bounds on theburning number. Discrete Applied Mathematics 235, 16–22 (2018)2. Bonato, A., Janssen, J., Roshanbin, E.: Burning a graph as a model of socialcontagion. In: Algorithms and Models for the Web Graph, WAW 2014. LectureNotes in Computer Science, Springer3. Bonato, A., Janssen, J., Roshanbin, E.: How to burn a graph. Internet Mathematics12(1-2), 85–100 (2016)4. Bonato, A., Kamali, S.: Approximation algorithms for graph burning. In: The-ory and Applications of Models of Computation. TAMC 2019. Lecture Notes inComputer Science, Springer5. Bonato, A., Lidbetter, T.: Bounds on the burning numbers of spiders and path-forests. Theoretical Computer Science 794, 12–19 (2019). Cordasco, G., Gargano, L., Rescigno, A., Vaccaro, U.: Evangelism in social net-works: Algorithms and complexity. Networks 71(4), 346–357 (2016)7. Cordasco, G., Gargano, L., Rescigno, A.A.: Active influence spreading in socialnetworks. Theoretical Computer Science 764, 15–29 (2019)8. Farokh, Z.R., Tahmasbi, M., Tehrani, Z.H.R.A., Buali, Y.: New heuristics for burn-ing graphs. ArXiv abs/2003.09314 (2020)9. Finbow, S., Macgillivray, G.: The firefighter problem: A survey of results, directionsand questions. The Australasian Journal of Combinatorics [electronic only] 43, 57–77 (2009)10. Garcia, J., Menchaca, R., Sanchez, J., Menchaca, R.: Local search algorithms forthe vertex k-center problem. IEEE Latin America Transactions 16(6), 1765–1771(2018)11. Gupta, A.T., Lokhande, S., Mondal, K.: NP-completeness results for graph burningon geometric graphs. arXiv preprint arXiv:2003.07746 (2020)12. Šimon, M., Huraj, L., Luptáková, I., Pospíchal, J.: Heuristics for spreading alarmthroughout a network. Applied Sciences 9, 3269 (2019)13. Kamali, S., Miller, A., Zhang, K.: Burning two worlds: Algorithms for burningdense and tree-like graphs. In: Theory and Practice of Computer Science, SOFSEM2020), publisher = Lecture Notes in Computer Science, Springer pages = 113-124,year = 202014. Kare, A.S., Reddy, I.V.: Parameterized algorithms for graph burning problem.In: International Workshop on Combinatorial Algorithms. pp. 304–314. Springer(2019)15. Kempe, D., Kleinberg, J., Tardos, E.: Maximizing the spread of influence througha social network. In: Proceedings of the Ninth ACM SIGKDD International Con-ference on Knowledge Discovery and Data Mining (KDD’03). p. 137–146 (2003)16. Kobayashi, Y., Otachi, Y.: Parameterized complexity of graph burning. ArXivabs/2007.08811 (2020)17. Land, M.R., Lu, L.: An upper bound on the burning number of graphs. In: Interna-tional Workshop on Algorithms and Models for the Web-Graph. pp. 1–8. Springer(2016)18. Leskovec, J., Krevl, A.: SNAP Datasets: Stanford large network dataset collection. http://snap.stanford.edu/datahttp://snap.stanford.edu/data