Boosting Data Reduction for the Maximum Weight Independent Set Problem Using Increasing Transformations
Alexander Gellner, Sebastian Lamm, Christian Schulz, Darren Strash, Bogdán Zaválnij
BBoosting Data Reduction for the Maximum Weight Independent SetProblem Using Increasing Transformations ∗ Alexander Gellner † , Sebastian Lamm † , Christian Schulz ‡ , Darren Strash § , Bogdán Zaválnij ¶ Abstract
Given a vertex-weighted graph, the maximum weightindependent set problem asks for a pair-wise non-adjacent set of vertices such that the sum of theirweights is maximum. The branch-and-reduce paradigmis the de facto standard approach to solve the problem tooptimality in practice. In this paradigm, data reductionrules are applied to decrease the problem size. Thesedata reduction rules ensure that given an optimumsolution on the new (smaller) input, one can quicklyconstruct an optimum solution on the original input.We introduce new generalized data reduction andtransformation rules for the problem. A key featureof our work is that some transformation rules can in-crease the size of the input. Surprisingly, these so-called increasing transformations can simplify the prob-lem and also open up the reduction space to yield evensmaller irreducible graphs later throughout the algo-rithm. In experiments, our algorithm computes sig-nificantly smaller irreducible graphs on all except oneinstance, solves more instances to optimality than pre-viously possible, is up to two orders of magnitude fasterthan the best state-of-the-art solver, and finds higher-quality solutions than heuristic solvers DynWVC andHILS on many instances. While the increasing trans-formations are only efficient enough for preprocessing atthis time, we see this as a critical initial step towards anew branch-and-transform paradigm. ∗ Partially supported by DFG grants SA 933/10-2 and byNational Research, Development and Innovation Office NKFIHFund No. SNN-135643. † Institute for Theoretical Informatics, Karlsruhe Institute ofTechnology, Karlsruhe, Germany. ‡ Faculty of Computer Science, University of Vienna, Vienna,Austria. § Department of Computer Science, Hamilton College, Clinton,NY, USA. ¶ Department of Combinatorics and Discrete Mathematics,Alfréd Rényi Institute of Mathematics, Budapest, Hungary.
Given a graph G = ( V, E ) and a weight function w : V → R + that assigns positive weights to ver-tices, the goal of the maximum weight independent set (MWIS) problem is to compute a set of pairwise non-adjacent vertices I ⊆ V , whose total weight is maxi-mum. The problem is N P -hard [17], and has a wide-range of practical applications in areas such as map la-beling [8, 18], coding theory [9, 35], combinatorial auc-tions [48], alignment of biological networks [5], workloadscheduling for energy-efficient scheduling of disks [14],computer vision [32], wireless communication [50], andprotein structure prediction [33].In practice, graphs with hundreds of vertices can besolved with traditional branch-and-bound methods [6, 7,10, 45]. However, until recently, even for medium-sizedsynthetic instances, the maximum weight independentset problem remained largely infeasible. In stark con-trast, the unweighted variants can be quickly solvedon large real-world instances—even with millions ofvertices—in practice, by using kernelization [13, 21, 42]or the branch-and-reduce paradigm [2]. Kernelizationiteratively applies reduction rules , thereby reducing thesize of the input graph until an irreducible graph is ob-tained. This irreducible graph is usually called a kernel if it has size bounded by a function of a specified inputparameter. A solution is then calculated on this irre-ducible graph and extended to a solution of the originalinstance by undoing the reduction rules. Branch-and-reduce takes this process to the extreme: reduction rulesare exhaustively applied before branching in a branch-and-bound algorithm. Branching then changes the re-maining instance, opening up the reduction space, al-lowing further reduction rules to be applied before thenext branching step. For those instances that can’t besolved exactly, high-quality (and often exact) solutionscan be found by combining kernelization with either lo-cal search [13, 15] or evolutionary algorithms [24].Recently, Lamm et al. [25] discovered new reductionrules for the weighted problem that, in practice, areoften able to calculate very small irreducible graphs ona wide number of instances. Surprisingly, the branch-and-reduce algorithm is able to solve a large number a r X i v : . [ c s . D S ] A ug f instances up to two orders of magnitude faster thanexisting (inexact) local search algorithms. However, thealgorithm still fails to compute small reduced graphs onsome instances [25]. This is mainly due to their veryspecialized nature that searches the graph for specificsubgraphs that can be removed. Our Results.
Unlike narrowly-defined data reduc-tion rules, we engineer new generalized data reductionand transformation rules. The transformation rules, incontrast to data reduction rules, can also increase thesize of the input. Surprisingly, this can simplify theproblem and also open up the reduction space to yieldeven smaller irreducible graphs later throughout the al-gorithm [3].More precisely, we engineer practically efficient vari-ants of the stability number data reduction rule (calledstruction). To the best of our knowledge, these are thefirst practical implementations of the weighted struc-tion rule that are able to handle a large variety of real-world instances. Our algorithm exploits the full poten-tial of the struction rule by also allowing the applica-tion of structions that may increase the number of ver-tices. These new rules are integrated in the state-of-the-art branch-and-reduce algorithm by Lamm et al. [25] –with and without the property that a data transforma-tion rule can increase the size of the input. Extensiveexperiments indicate that our algorithm calculates sig-nificantly smaller irreducible graphs than current state-of-the-art approach and, preprocessing with our trans-formations enables branch-and-reduce to solve many in-stances that were previously infeasible to solve to opti-mality.
In the following we will first give a short overview ofexisting work on both exact and heuristic procedures,especially outlining how kernelization and preprocessingmethods are used in state-of-the-art algorithms. Fur-thermore, we present a detailed overview of the struc-tion, as this transformation is the focus of this work.
Exact algorithms usually com-pute optimal solutions by systematically exploring thesolution space. A frequently used paradigm in exactalgorithms for combinatorial optimization problems iscalled branch-and-bound [36, 45]. In case of the MWISproblem, these types of algorithms compute optimal so-lutions by case distinctions in which vertices are eitherincluded into the current solution or excluded from it,branching into two or more subproblems and resulting ina search tree. Over the years, branch-and-bound meth-ods have been improved by new branching schemes orbetter pruning methods using upper and lower bounds to exclude specific subtrees [6, 7, 27]. In particular, War-ren and Hicks [45] proposed three branch-and-bound al-gorithms that combine the use of weighted clique coversand a branching scheme first introduced by Balas andYu [7]. Their first approach extends the algorithm byBabel [6] by using a more intricate data structures toimprove its performance. The second one is an adap-tation of the algorithm of Balas and Yu, which uses aweighted clique heuristic that yields structurally similarresults to the heuristic of Balas and Yu. The last algo-rithm is a hybrid version that combines both algorithmsand is able to compute optimal solutions on graphs withhundreds of vertices.In recent years, reduction rules have frequently beenadded to branch-and-bound methods yielding so-called branch-and-reduce algorithms [2]. These algorithms areable to improve the worst-case runtime of branch-and-bound algorithms by applications of reduction rules tothe current graph before each branching step. For theunweighted case, a large number of branch-and-reducealgorithms have been developed in the past. The cur-rently best exact solver [22], which won the PACE chal-lenge 2019 [22, 39, 43], uses a portfolio of branch-and-reduce/bound solvers for the complementary problems.However, for a long time, virtually no weighted reduc-tion rules were known, which is why hardly any branch-and-reduce algorithms exist for the MWIS problem.To the best of our knowledge, the first and onlybranch-and-reduce algorithm for the weighted case wasrecently presented by Lamm et al. [25]. The authorsfirst introduce two meta-reductions called neighborhoodremoval and neighborhood folding, from which theyderive a new set of weighted reduction rules. On thisfoundation a branch-and-reduce algorithm is developedusing pruning with weighted clique covers similar to theapproach by Warren and Hicks [45] for upper boundsand an adapted version of the ARW local search [4]for lower bounds. The experimental evaluation showsthat their algorithm can solve a large set of real-worldinstances and outperform state-of-the-art algorithms.Finally, there are exact procedures which are ei-ther based on other extension of the branch-and-boundparadigm, e.g. [40, 46, 47], or on the reformulation intoother
N P -complete problems, for which a variety ofsolvers already exist. For instance, Xu et al. [49] re-cently developed an algorithm called
SBMS , which cal-culates an optimal solution for a given MWVC instanceby solving a series of SAT instances.
A widely used heuristicapproach is local search, which usually computes aninitial solution and then tries to improve it by simpleinsertion, removal or swap operations. Although inheory local search generally offers no guarantees forthe solution’s quality, in practice they find high qualitysolutions significantly faster than exact procedures.For unweighted graphs, the iterated local search(ARW) by Andrade et al. [4], is a very successfulheuristic. It is based on so-called (1 , -swaps whichremove one vertex from the solution and add two newvertices to it, thus improving the current solution byone. Their algorithm uses special data structures whichfind such a (1 , -swap in linear time in the number ofedges or prove that none exists. Their algorithm is ableto find (near-)optimal solutions for small to medium-sized instances in milliseconds, but struggles on massiveinstances with millions of vertices and edges.The hybrid iterated local search (HILS) byNogueira et al. [34] adapts the ARW algorithm forweighted graphs. In addition to weighted (1 , -swaps,it also uses ( ω, -swaps that add one vertex v into thecurrent solution and exclude its ω neighbors. These twotypes of neighborhoods are explored separately usingvariable neighborhood descent (VND). In practice, theiralgorithm finds all known optimal solutions on well-known benchmark instances within milliseconds andoutperforms other state-of-the-art local searches.Two other local searches, DynWVC1 and Dyn-WVC2, for the equivalent minimum weight vertex coverproblem are presented by Cai et al. [12]. Their algo-rithms extend the existing FastWVC heuristic [29] bydynamic selection strategies for vertices to be removedfrom the current solution. In practice, DynWVC1 out-performs previous MWVC heuristics on map labelinginstances and large scale networks, and DynWVC2 pro-vides further improvements on large scale networks butperforms worse on map labeling instances.Recently, Li et al. [28] presented a local search al-gorithm for the minimum weight vertex cover (MWVC)problem, which is complementary to the MWIS prob-lem. Their algorithm applies reduction rules during theconstruction phase of the initial solution. Furthermore,they adapt the configuration checking approach [11] tothe MWVC problem which is used to reduce cycling, i.e.returning to a solution that has been visited recently.Finally, they develop a technique called self-adaptive-vertex-removing, which dynamically adjusts the num-ber of removed vertices per iteration. Experiments showthat algorithm outperforms state-of-the-art approacheson both graphs of up to millions of nodes and real-worldinstances. Originally the struction (STabilitynumber RedUCTION) was introduced by Ebeneg-ger et al. [16] and was later improved by Alexe et al. [3].This method is a graph transformation for unweighted graphs, that can be applied to an arbitrary vertex andreduces the stability number by exactly one. Thus,by successive application of the struction, the indepen-dence number of a graph can be determined. Ebeneg-ger et al. also show that there is an equivalence betweenfinding a maximum weight independent set and max-imizing a pseudo Boolean function, i.e. a real-valuedfunction with Boolean variables, which allows to derivethe struction as a special case. Finally, the authorspresent a generalization of the struction to weightedgraphs.On this basis, theoretical algorithms with polyno-mial time complexity for special graph classes have beendeveloped [3, 19, 20]. These algorithms use additionalreduction rules and a careful selection of vertices onwhich the struction is applied.Hoke and Troyon [23] developed another form ofthe weighted struction, using the same equivalencefound by Ebenegger et al. [16]. In particular, theyderive the revised weighted struction . However, thistype of struction can only be applied to claw-freegraphs: graphs without an induced three-leaf star.This transformation also removes a vertex v and itsneighborhood, but is able to create fewer new vertices,since these are only created for pairs of non-adjacentneighbors whose combined weight is greater than theweight of v .As far as we are aware, prior to this work, onlyfew experiments with struction variants exist and arelimited to only small instances: Ebenegger et al. andAlexe et al. evaluated the struction only on small graphswith less than a hundred vertices for the unweightedcase [3, 16]. Furthermore, for the weighted case, noneof the previously proposed struction variants has beenevaluated so far [3, 16, 23]. A graph G = ( V, E ) consists of a vertex set V andan edge set E ⊂ V × V . It is called undirected if foreach edge ( u, v ) ∈ E the edge set also contains ( v, u ) .We only consider undirected graphs without self loops,i.e. ( v, v ) (cid:54)∈ E , and therefore we denote edges bysets { u, v } . In addition, a graph is (vertex-) weighted ifa positive scalar weight w ( v ) is assigned to each vertex v ∈ V . The weight of a vertex set X ⊂ V is definedas w ( X ) = (cid:80) v ∈ X w ( x ) .A graph G (cid:48) = ( V (cid:48) , E (cid:48) ) is a subgraph of G = ( V, E ) if V (cid:48) ⊂ V and E (cid:48) ⊂ E ∩ ( V (cid:48) × V (cid:48) ) holds. Givena vertex set U ⊂ V the induced subgraph of U is thegraph G (cid:48) = ( U, E (cid:48) ) with E (cid:48) = E ∩ ( U × U ) and isdenoted by G [ U ] . Two vertices u, v are called adjacent if { u, v } ∈ E . The neighborhood N ( v ) of a vertex v isthe set of all vertices adjacent to v . N [ v ] = N ( v ) ∪{ v } is alled the closed neighborhood and N ( v ) = V \ N [ v ] the non-neighborhood of v . Finally, we denote the degree ofa vertex v is δ ( v ) = | N ( v ) | .For a given graph G = ( V, E ) , a vertex set I ⊂ V isan independent set if all vertices v ∈ I are pairwise notadjacent. An independent set is called maximal if it isnot a subset of another independent set and maximum if no other independent set has greater cardinality. Theindependence number α ( G ) = | I | , sometimes alsocalled stability number, of a graph G is the cardinality ofa maximum independent set I . Likewise, for a weightedgraph G an independent set I has maximum weight ,if there is no independent set I (cid:48) with a weight w ( I (cid:48) ) greater than w ( I ) . The weighted independence number α w ( G ) = w ( I ) of a weighted graph G is defined asthe weight of a maximum weight independent set I .For a given weighted graph G , the maximum weightindependent set problem (MWIS) seeks a maximumweight independent set. We nowpresent the original weighted struction introducedby Ebenegger et al. [16], on which we base ourstruction variants. In general, we apply a structionto a center vertex v and denote its neighborhoodby N ( v ) = { , , ..., p } . All variants we use remove v from the graph G , producing a new graph G (cid:48) , andreduce the weighted independence number of the graph G by its weight, i.e. α w ( G ) = α w ( G (cid:48) ) + w ( v ) .For ease of presentation, we first introduce a methodcalled layering . Layering describes the partitioning of agiven set M that contains vertices v x,y , that are indexedby two parameters x ∈ X, y ∈ Y . The sets X, Y either contain vertices or vertex sets. For k ∈ X alayer L k contains all vertices having k as first parameter,i.e. L k = { v x,y ∈ M : x = k } . Conversely, the layer of a vertex v x,y is L ( v x,y ) = k .In order to apply the original struction by Ebeneg-ger et al. [16], the center vertex v must have minimumweight among its closed neighborhood. The struction isthen applied by removing v and creating new verticesfor each pair i, j of non-adjacent vertices in N ( v ) . Toguarantee that we can obtain an MWIS I of G using anMWIS I (cid:48) of G (cid:48) with w ( I ) = w ( I (cid:48) ) + w ( v ) , we alsoinsert edges between the new and original vertices. Anexample of this type of struction is given in Figure 1(b).In the following, we provide a formal definition ofthe original struction: Reduction 1. (Original Struction)
Let v ∈ V be a vertex with minimum weight w ( v ) among its closedneighborhood. Transform the graph as follows: • Remove v , lower weight of each neighbor by w ( v ) • For each pair of non-adjacent neighbors x < y , cre-ate a new vertex v x,y with weight w ( v x,y ) := w ( v ) • Insert edges between v q,x , v r,y if either x and y areadjacent or L q (cid:54) = L r • Each vertex v x,y is also connected to vertex w ∈ V \ { v } adjacent to either x or y For a MWIS I (cid:48) of G (cid:48) we obtain a MWIS I of G as fol-lows: If I (cid:48) ∩ N ( v ) = ∅ applies, we have I = I (cid:48) ∪ { v } ,otherwise we remove the new vertices, i.e. I = I (cid:48) ∩ V .Furthermore we have α w ( G ) = α w ( G (cid:48) ) + w ( v ) . We now introduce three new struction variants: First,we deal with the fact that using the original weightedstruction, an MWIS in the transformed graph mightconsist of more vertices than in the original graph. Wedo so by using different weight assignments for the newvertices and inserting additional edges. Second, wepresent a generalization of the revised weighted struc-tion that can be applied to vertices of general graphswithout the need to fulfill specific weight constraints.However, this variant creates new vertices for indepen-dent sets in the neighborhood of a vertex v whose weightis greater than w ( v ) . Finally, we alleviate this issue bycreating new vertices only for a specific subset of theseindependent sets in the third variant. One caveat ofthe original struction is that the number of vertices thatare part of an MWIS in the transformed graph is gen-erally larger than in the original graph. The modifiedstruction tries to alleviate this issue by ensuring thatthe number of vertices of an MWIS stays the same inboth graphs. This is done by using a different weight as-signment and inserting additional edges. In particular,the newly created vertex for each pair of non-adjacentneighbors x, y ∈ N ( v ) with x < y is now assignedweight w ( v x,y ) = w ( y ) (instead of w ( v ) ). Furthermore,in addition to the edges created in the original struction,each neighbor k ∈ N ( v ) is connected to each vertex v x,y belonging to a different layer than k . Finally, N ( v ) is extended to a clique by adding edges between ver-tices x, y ∈ N ( v ) . For an MWIS I (cid:48) of G (cid:48) we now obtainan MWIS I of G as follows: If I (cid:48) ∩ N ( v ) = ∅ applies, wehave I = I (cid:48) ∪ { v } , otherwise we obtain I by replacingeach new vertex v x,y ∈ I (cid:48) with the original vertex v y ,i.e. I = ( I (cid:48) ∩ V ) ∪ { v y | v x,y ∈ I (cid:48) \ V } . As for the orig-inal struction, we have α w ( G ) = α w ( G (cid:48) ) + w ( v ) . Anexample of the modified struction is given in Figure 1(c).A proof of correctness can be found in Appendix B. (a) Original Graph ,
21 42 , , , (b) Original Struction , ,
32 42 , , (c) Modified Struction Figure 1: Application of original struction and modified struction. Vertices representing the same independentset in the different graphs are highlighted in gray.
The extendedstruction removes the weight restriction for the vertex v in the former variants. Unlike the previous twostructions, this variant considers independent sets ofarbitrary size in the neighborhood N ( v ) . In fact, wecreate new vertices for each independent set in G [ N ( v )] if its weight is greater than v . Note that this can resultin up to O (2 δ ( v ) ) new vertices. An example applicationof the extended struction can be found in Figure 2(b). Reduction 2. (Extended Weighted Struction)
Let v ∈ V be an arbitrary vertex and C the set ofall independent sets c in G [ N ( v )] with w ( c ) > w ( v ) .We derive the transformed graph G (cid:48) as follows: First,remove v together with its neighborhood and create anew vertex v c with weight w ( v c ) = w ( c ) − w ( v ) for each independent set c ∈ C . Each vertex v c is then connected to each non-neighbor w ∈ N ( v ) adjacent to at least one vertex in c . Finally, thevertices v c are connected with each other, forming aclique. For an MWIS I (cid:48) of G (cid:48) we obtain an MWIS I of G as follows: If I (cid:48) \ V = { v c } replace v c withthe vertices of the corresponding independent set c ,i.e. I = ( I (cid:48) ∩ V ) ∪ c , otherwise I = I (cid:48) ∪ { v } .Furthermore we have α w ( G ) = α w ( G (cid:48) ) + w ( v ) . A proof of correctness is in Appendix B.
The extended reduced struction is a variant of the ex-tended struction, which can potentially reduce the num-ber of newly created vertices. For this purpose, onlyindependent sets with weight “just” greater than w ( v ) are considered. In particular, this type of struction con-siders independent sets that have weight greater than w ( v ) , where each subset of this independent set hasweight less than w ( v ) . For this purpose, let C be theset of all independent sets in G [ N ( v )] and C (cid:48) ⊆ C be the subset of independent sets for which there is noindependent set in C that has a weight greater than w ( v ) and is a proper superset of C (cid:48) . We then use thesame construction as for the extended struction, butonly create new vertices for the set C (cid:48) . The resultingset of vertices is denoted by V C . However, since thisconstruction might not be valid anymore, we also addadditional vertices that are connected to each other byusing layering. To be more specific, for each pair of anindependent set c ∈ C (cid:48) and a vertex y ∈ N ( v ) wecreate a vertex v c,y with weight w ( v c,y ) = w ( y ) , if c can be extended by y , i.e. y is not adjacent to any ver-tex v (cid:48) ∈ c . We denote this set of vertices v c,y by V E .We then insert edges between two vertices v c,y , v c (cid:48) ,y (cid:48) ifthey either belong to different layers or y and y (cid:48) havebeen adjacent. Moreover, each vertex v c,y is connectedto each non-neighbor w ∈ N ( v ) , if w has been con-nected to either y or a vertex x ∈ c . Finally, weconnect each vertex v c to each vertex v c (cid:48) ,y belonging toa different layer than c . For an MWIS I (cid:48) of G (cid:48) we obtainan MWIS I of G as follows: If I (cid:48) ∩ V C = ∅ applies,we set I = I (cid:48) ∪ { v } . Otherwise, there is a singlevertex v c ∈ I (cid:48) ∩ V C that we replace with the vertices ofits independent set c . Moreover, we replace each ver-tex v c,y ∈ I (cid:48) ∩ V E with the vertex v y . Altogether wehave I = ( I (cid:48) ∩ V ) ∪ c ∪ { v y | v c,y ∈ I (cid:48) ∩ V E } . Further-more we have α w ( G ) = α w ( G (cid:48) ) + w ( v ) . An exampleapplication of the extended struction can be found inFigure 2(c). We now propose our two novel preprocessing algorithmsfor the MWIS problems based on the struction variantspresented in the previous section. Furthermore, wepresent how we integrate the different structions into theframework of Lamm et al. [25], both as a preprocessingstep and as a reduce step in branch-and-reduce, to (a) Original Graph , , , , ,
52 1 2 (b) Extended Struction ;52 1 2;42 6 ;41 (c) Extended Reduced Struc-tion
Figure 2: Application of extended struction and extended reduced struction. Vertices representing the sameindependent set in the different graphs are highlighted in gray. We assume some weight constraints in the originalgraph for the construction in b) and c): w (1) > w (0) , w (2) > w (0) and w (3) + w (4) + w (5) ≤ w (0) . Algorithm 1
Branch-and-Reduce Algorithm for MWIS input graph G = ( V, E ) , current solution weight c (initially zero), best solution weight W (initially zero) procedure Solve( G , c , W ) ( G, c ) ← Reduce ( G, c ) if W = 0 then W ← c + ILS( G ) if c + UpperBound( G ) ≤ W then return W if G is empty then return max {W , c } if G is not connected thenfor all G i ∈ Components( G ) do c ← c + Solve( G i , 0, 0) return max( W , c )( G , c ) , ( G , c ) ← Branch ( G, c ) {Run 1st case, update currently best solution} W ←
Solve ( G , c , W ) {Use updated W to shrink the search space} W ←
Solve ( G , c , W ) return W more quickly compute optimal solutions. This takesan initial step towards a more general branch-and-transform framework.Since the different forms of the weighted structiondo not necessarily reduce the number of vertices, wedivide them (and existing reduction rules) into threedifferent classes that are used throughout this paper:For decreasing transformations (reductions) the trans-formed graph G (cid:48) has less vertices than the originalgraph G . Note that all reduction rules used in theoriginal framework of Lamm et al. [25] belong in thisclass. Furthermore, we derive special cases of the struc-tions, which also belong to this type. Transformationswhere the number of vertices in the original graph staysthe same – but reduce the size and weight of MWIS – in the transformed graph are called plateau trans-formations . While plateau transformations cannot re-duce the size of the graph, they can potentially pro-duce new subgraphs which can then be reduced by other(decreasing) transformations. Finally, increasing trans-formations are transformations whose resulting graphhas more vertices than the original graph. Similar toplateau transformations, the idea is to reduce the re-sulting graph by further reduction rules and transforma-tions. However, since increasing structions can lead to alarger transformed graph, it is difficult to integrate theminto algorithms that only apply non-increasing transfor-mations. Inthis section we show how to obtain decreasing andplateau transformations from the four different formsof structions presented in Section 3.1. Based on these,an incremental preprocessing algorithm is proposed.In general, when applying any form of struction,the number of vertices of the transformed graph G (cid:48) depends on the number of removed and newly createdvertices. However, it is difficult to estimate the numberof resulting vertices in advance, since it varies dependingon the number of possible independent sets present inthe neighborhood of the center vertex. Thus, whenapplying a struction variant, we generally keep trackof the number of vertices that will be created. Ifthis number exceeds a given maximum value n max , wediscard the corresponding struction to ensure that nottoo many vertices are created.We begin by taking a closer look at the struc-turally similar original weighted struction and modifiedweighted struction. These variants reduce the number ofvertices by at most one, since they only remove the cen-er vertex v . Therefore, decreasing or plateau structionscan be obtained by setting n max = 0 or n max = 1 .However, note that this type of decreasing struction isalready covered by the isolated weight transfer proposedby Lamm et al. [25].Looking at the two remaining struction variants, wesee that they not only remove the center vertex v butalso its neighborhood N ( v ) . Thus, the size of the graphcan be reduced by up to δ ( v ) + 1 . Decreasing or plateaustructions can be obtained by using the correspondingstruction variant with n max = δ ( v ) or n max = δ ( v )+1 .The resulting rules can then easily be inte-grated into the kernelization algorithm used byLamm et al. [25]. However, since all struction vari-ants are very general reduction rules, they tend tobe expensive in terms of running time. We there-fore apply them after the faster localized reductionrules, but before the even more expensive critical setreduction. To be specific, we use the following re-duction rule order: R = [ Neighborhood Re-moval , Degree Two Fold , Clique Reduction , Domination , Twin , Clique Neighborhood Re-moval , Generalized Fold , Decreasing Struc-tion , Plateau Struction , Critical Weighted In-dependent Set ] . Next, we extendthe previous algorithm to also make use of increasingstructions. The main idea is to alternate betweencomputing an irreducible graph using the previous(non-increasing) algorithm and then applying increasingstructions while ensuring that the graph size does notincrease too much. The reasoning for this is that eventhough the graph size might increase, this can generatenew and potentially reducible subgraphs, thus leadingto an overall decrease in the graph size.In the following, we say that a graph K is betterthan a graph K (cid:48) if it has fewer vertices. However,our algorithm can easily be adapted to match otherquality criteria. Pseudocode for our algorithm is givenin Algorithm 2.Our algorithms maintains two graphs K and K (cid:63) . K (cid:63) is the best graph found so far, i.e. the graph with theleast number of vertices. K is the current graph, whichwe try to reduce to get a better graph K (cid:63) . Both graphs, K and K (cid:63) are initialized with the graph obtainedby applying the non-increasing reduction algorithm ofthe previous section. The algorithm then alternatesbetween two phases, a blow-up phase (Section 5.2.1)and a reduction phase . During the blow-up phase aset of increasing structions is applied to K , resultingin a new graph K (cid:48) . K (cid:48) is then reduced using the non-increasing algorithm, resulting in a graph K (cid:48)(cid:48) . Next, Algorithm 2
Cyclic Blow-Up Algorithm input graph G = ( V, E ) , unsuccessful iterationthreshold X ∈ [1 , ∞ ) procedure CyclicBlowUp( G , X ) K ← Reduce ( G ) K (cid:63) ← K count ← while | V ( K ) | < α · | V ( K (cid:63) ) | and count < X do K (cid:48) ← BlowUp ( K ) if K (cid:48) = K thenreturn K (cid:63) K (cid:48)(cid:48) ← Reduce ( K (cid:48) ) K ← Accept ( K (cid:48)(cid:48) , K ) if K < K (cid:63) then K (cid:63) ← K return K (cid:63) we have to decide whether or not to use K (cid:48)(cid:48) or K forthe next iteration. Note, that it can be advantageous toaccept a graph K (cid:48)(cid:48) even if it has more vertices than K to avoid local minima. Nonetheless, we decided to onlykeep K (cid:48)(cid:48) if it is less vertices than K as this strategyprovided better results during preliminary experiments.Finally, since we might not completely reduce the graph,we use a termination criterion, which will be discussedin Section 5.3. The starting point of theblow-up phase is an irreducible graph, where no morereductions (including decreasing structions) can be ap-plied. Next, we select a vertex v from a candidate set C .This candidate set consists of all vertices in the currentgraph which have not been explicitly excluded for selec-tion during the algorithm. Vertex selection is a crucialpart of our algorithm. Depending on the selected ver-tex the struction might create a large number of newvertices and the size of the transformed graph can in-crease drastically. Thus, we discuss possible selectionstrategies in the next section.Next, we apply a struction to the selected vertex v . As for our previous algorithm, we keep track of thenumber of newly created and deleted vertices duringthis step. In particular, if the struction would result inmore than n max vertices, it is aborted. In this case, thevertex v is excluded from the candidate set. The vertex v will become viable again as soon as the correspondingstruction would create another transformed graph, i.e.its neighborhood N ( v ) changed.After having applied a struction, we then proceedwith the subsequent reduction phase. It might also bepossible to apply more than one struction during a blow- p phase. However, one has to be careful to not let thesize of the graph grow too large. Vertex Selection Strategies.
The goal of thevertex selection procedure is to find an increasing struc-tion that results in a new graph, which can then be re-duced to an overall smaller graph. In general, it is verydifficult to estimate in advance to what extent the trans-formed graph can be reduced without actually perform-ing the reduction phase. Most of the following strate-gies therefore aim at increasing the size of the graph byonly a few vertices. The number of newly created ver-tices is determined by the number of independent setsin the neighborhood of v having a total greater weightthan v . In general, determining this number is N P -complete [38] and thus often infeasible to compute inpractice. In contrast, a much simpler selection strat-egy would be to choose vertices uniformly at random.However, this can lead to structions that significantlyincrease the graph size.Thus, in order to limit the size increase of astruction, we decided to use an approximation of theexact number of independent sets in the neighborhoodof v . In particular, we only consider independent setsup to a size of two. This results in a lower bound L for the number of independent sets [37] which can becomputed in O (∆ ) time. Since the lower bound L canbe far smaller than the actual number of newly createdvertices, we use an additional tightness-check : Thischeck is passed if less than L (cid:48) = (cid:100) β · L (cid:101) new verticeswith β ∈ (1 , ∞ ) are created by the correspondingstruction. Our strategy then works as follows: We selecta vertex v with a minimal increase and perform thetightness-check. If it fails, we know that at least L (cid:48) new vertices are created by the corresponding struction.Therefore L (cid:48) forms a tighter bound for the number ofnew vertices, and we reinsert v to C using the bound L (cid:48) . We then repeat this process until we find a vertexthat passes the tightness-check. In general, the size of K can decrease very slowly or even exhibit oscillatorybehavior. This can cause the algorithm to take a longtime to improve K (cid:63) or even not improve it at all.For this purpose, one needs an appropriate terminationcriterion. First, we want to avoid that the size of thecurrent graph K distances too much from that of thebest graph K (cid:63) . Therefore we abort the algorithm assoon as the size of the current graph exceeds the sizeof the best graph by a factor α ∈ [1 , ∞ ) , that isif | V ( K ) | ≥ α · V ( K (cid:63) ) . Additionally, we also countthe number of unsuccessful iterations, i.e. iterations inwhich the new graph has been rejected. Our secondcriterion aborts the algorithm if this value exceeds someconstant X ∈ [1 , ∞ ) . We now evaluate the impact and performance our pre-processing methods: First, we compare the performanceof our algorithms with the two configurations used inthe branch-and-reduce framework of Lamm et al. [25].For this purpose, we examine the sizes of the reducedgraphs, the number of instances solved, as well as thetime required to do so. Second, we perform a broadercomparison with other state-of-the-art algorithms, in-cluding heuristic approaches.
We ran all the ex-periments on a machine with four Octa-Core Intel XeonE5-4640 processors running at 2.4 GHz, 512 GB of mainmemory, 420 MB L3-Cache and 48256 KB L2-Cache.The machine runs Ubuntu 18.04.4 and Linux kernelversion 4.15.0-96. All algorithms were implemented inC++11 and compiled with g++ version 7.5.0 with op-timization flag -O3. All algorithms were executed se-quentially with a time limit of 1 000 seconds. The ex-periments for heuristic methods were performed withfive different random seeds. Furthermore, we present cactus plots types of plots, which show the number ofinstances solved over time.
For our evalua-tion, we use both the non-increasing algorithm, as wellas the cyclic blow-up algorithm. In particular, we usetwo different configurations of the cyclic blow-up algo-rithm: The first configuration, called C strong , aims toachieve small reduced graphs. For this purpose, we setthe number of unsuccessful blow-up phases to X = 64 ,the number of vertices that a struction is allowed tocreate to n max = d max = 512 . In our preliminary experiments, this con-figuration was always able to compute the smallest re-duced graphs. The second configuration, called C fast ,aims to achieve a good trade-off between the reducedgraph size and the time required to compute an opti-mal solution. Thus we set X = 25 , n max = 512 and d max = 64 . Finally, all our algorithms use β = 2 for thetightness-check during vertex selection, as well as thethe extended weighted struction, as this struction vari-ant achieved the best performance during preliminaryexperiments.To measure the impact of our preprocessing meth-ods on existing solvers, we add each configuration tothe branch-and-reduce framework by Lamm et al. [25].This results in three solvers, which we call Cyclic-Fast , Cyclic-Strong and
NonIncreasing in the fol-lowing. Note that each solver uses the correspondingconfiguration only for its initial preprocessing, whereasubsequent graph reductions only use decreasing trans-formations. Finally, we have replaced the ILS localsearch used in the original framework to compute lowerbounds with the hybrid iterated local search (
HILS )of Nogueira et al. [34]. This resulted in slightly betterruntimes during preliminary experiments, but had noimpact on the number of instances that were solved.
We test all algorithms on a largecorpus of sparse graphs, which mainly consists of in-stances found in previous works on the maximum(weight) independent set problem [4, 12, 25]. In partic-ular, this corpus consists of real-world conflict graphsthat were derived from OpenStreetMap (OSM) [1, 8,12], as well as a collection of large social networksfrom the Stanford Large Network Dataset Repository(SNAP) [26]. One caveat of this corpus is that mostits instances are unweighted. Following the example ofprevious work [12, 25, 29], we alleviate this issue by as-signing each vertex a random weight that is uniformlydistributed in the interval [1 , . Furthermore, we ex-tend this set of benchmark instances by also consider-ing instances stemming from dual graphs of well-knowntriangle meshes (mesh) [41], 3d meshes derived fromsimulations using the finite element method (FE), aswell as instances for the maximum weight clique prob-lem [44]. However, the complements of the maximumweight clique instances are only somewhat sparse—andmost are irreducible by our techniques. This behav-ior has already been observed by Akiba and Iwata [2]on similar instances. Therefore, we will omit these in-stances from our experiments. An overview of all in-stances considered is given in Appendix A. Webegin by comparing our three solvers presented in Sec-tion 6.1.1 with the two configurations, called
Basic-Sparse and
Basic-Dense of the branch-and-reduceframework outlined by Lamm et al. [25]. Our compar-ison is divided into two parts: First, we consider thesizes of the irreducible graphs after the initial reduc-tion phase. Second, we compare the number of solvedinstances and the time required to solve them. A com-plete overview of the reduced graph sizes and runningtimes for each algorithm is given in Appendix C.Table 1 shows the sizes of the irreducible graphsafter the initial reduction phase. Note that we omit
Basic-Dense as it always calculates equally sized orlarger graphs than
Basic-Sparse .First, we note that with the exception of fe_ocean , Cyclic-Strong always produces the smallest reducedgraphs. For this particular instance, the usage of thestruction limits the efficiency of the critical set reduc- tion, resulting in a larger reduced graphs. Furthermore,the greatest improvement can be found on the mesh in-stances, which are all completely reduced using
Cyclic-Strong . In comparison,
Basic-Sparse is not able toobtain an empty graph on a single of these instancesand ends up with reduced graphs consisting of up tothousands of vertices. Overall,
Cyclic-Strong is ableto achieve an empty reduced graph on of the in-stances tested – an additional instances comparedto the empty reduced graphs computed by Basic-Sparse .If we compare the reduced graphs of
Cyclic-Strong and
Cyclic-Fast we see that they alwayshave the same size on the mesh instances. However, thesize of the reduced instances computed by
Cyclic-Fast on the other instance families is up to a few thousandvertices larger. On the OSM instances for example,
Cyclic-Fast calculates a reduced graph that has thesame size as the one computed by
Cyclic-Strong ononly 16 out of 34 instances with the largest differencebeing 2 216 vertices.Next, we examine the number of solved instancesand the time required to solve them. For this purpose,Figure 3 shows cactus plots for the number of solvedinstances over time. First, we can see that
Cyclic-Strong was able to solve the most instances overall(68 out of 87 instances). To be more specific,
Cyclic-Strong was able to solve an additional 11 instancescompared to
Basic-Sparse and
Basic-Dense . Ofthese newly solved instances six are from the OSMfamily, three from the SNAP family and one additionalinstance from the FE family.Comparing the time that our algorithms requireto solve the instances with
Basic-Sparse and
Basic-Dense , we can see improvements on almost all in-stances. Our
Cyclic-Fast algorithm is able to find so-lutions up to an order of magnitude faster than
Basic-Sparse and
Basic-Dense on five mesh instances, 13OSM instances and three SNAP instances. On thetwo OSM instances pennsylvania-AM3 and utah-AM3 as well as the SNAP instance roadNet-CA , we are upto two orders of magnitude faster. We attribute thisincrease in performance to the much smaller reducedgraph size, as often a smaller graph size tends to resultin finding a solution faster. Furthermore, the general-ized fold reduction that is used in
Basic-Sparse and
Basic-Dense tends to increase the running time. Thus,we omitted this reduction rule from our algorithm.
Inthe following we provide a comparison of our algorithmswith heuristic state-of-the-art approaches. For thispurpose, we also include the two local searches
Dyn- raph n t r n t r n t r n t r n t r OSM instances
Basic-Dense Basic-Sparse NonIncreasing Cyclic-Fast Cyclic-Strong alabama-AM2
173 0.06 173 0.07 0 0.01 0 0.01 0 0.01 district-of-columbia-AM2 florida-AM3 georgia-AM3
861 8.99 861 10.14 796 0.08 587 0.69 425 12.84 greenland-AM3 new-hampshire-AM3
247 4.99 247 5.69 164 0.02 0 0.07 0 0.09 rhode-island-AM2 utah-AM3
568 8.21 568 8.97 396 0.03 0 0.09 0 0.40Empty graphs 0% (0/34) 0% (0/34) 11.8% (4/34) 41.2% (14/34) 50% (17/34)SNAP instances
Basic-Dense Basic-Sparse NonIncreasing Cyclic-Fast Cyclic-Strong as-skitter
26 584 25.82 8 585 36.69 3 426 4.75 2 782 5.50 2 343 6.80 ca-AstroPh email-EuAll p2p-Gnutella06 roadNet-PA
133 814 2.43 35 442 7.73 300 1.05 0 1.19 0 1.14 soc-LiveJournal1
60 041 236.88 29 508 213.74 4 319 22.27 3 530 24.13 1 314 37.77 web-Google wiki-Vote
477 0.03 0 0.02 0 0.02 0 0.02 0 0.02Empty graphs 58.1% (18/31) 67.7% (21/31) 67.7% (21/34) 80.6% (25/31) 80.6% (25/31)mesh instances
Basic-Dense Basic-Sparse NonIncreasing Cyclic-Fast Cyclic-Strong buddha
380 315 5.56 107 265 26.19 86 1.83 0 1.87 0 1.91 dragon
51 885 0.89 12 893 1.34 0 0.18 0 0.19 0 0.21 ecat
239 787 4.07 26 270 10.09 274 2.12 0 2.12 0 2.14Empty graphs 0% (0/15) 0% (0/15) 66.7% (10/15) 100% (15/15) 100% (15/15)FE instances
Basic-Dense Basic-Sparse NonIncreasing Cyclic-Fast Cyclic-Strong fe_ocean
141 283 1.05 0 5.94 138 338 8.90 138 134 9.61 138 049 10.78 fe_sphere
15 269 0.21 15 269 1.47 2 961 0.34 147 0.62 0 0.75Empty graphs 0% (0/7) 14.3% (1/7) 0% (0/7) 28.6% (2/7) 42.9% (3/7)
Table 1: Smallest irreducible graph found by each algorithm and time (in seconds) required to compute it. Rowsare highlighted in gray if one of our algorithms is able to obtain an empty graph.
Graph t max w max t max w max t max w max t max w max OSM instances DynWVC2 HILS Cyclic-Fast Cyclic-Strong alabama-AM2
174 309
174 309
174 309 district-of-columbia-AM2
209 132
209 132 florida-AM3
237 333
237 333
237 333 georgia-AM3
222 652
222 652
222 652
222 652 greenland-AM3
14 011
14 011 new-hampshire-AM3
116 060
116 060
116 060
116 060 rhode-island-AM2
184 596
184 596
184 596 utah-AM3
98 847
98 847
98 847
98 847
Solved instances 61.8% (21/34) 64.7% (22/34)Optimal weight 68.2% (15/22) 100.0% (22/22)SNAP instances DynWVC2 HILS Cyclic-Fast Cyclic-Strong as-skitter
124 137 365 ca-AstroPh
797 510
797 510
797 510 email-EuAl l 132.62
25 286 322
25 286 322
25 286 322
25 286 322 p2p-Gnutella06
548 612
548 612
548 612 roadNet-PA
61 731 589
61 731 589 soc-LiveJournal1
284 036 239 web-Google
56 326 504
56 326 504 wiki-Vote
500 079
500 079
500 079
500 079
Solved instances 90.3% (28/31) 90.3% (28/31)Optimal weight 28.6% (8/28) 57.1% (16/28)mesh instances DynWVC2 HILS Cyclic-Fast Cyclic-Strong buddha
57 555 880
57 555 880 dragon ecat
36 650 298
36 650 298
Solved instances 100.0% (15/15) 100.0% (15/15)Optimal weight 0.0% (0/15) 0.0% (0/15)FE instances DynWVC1 HILS Cyclic-Fast Cyclic-Strong fe_ocean fe_sphere
617 816
617 816
Solved instances 42.9% (3/7) 42.9% (3/7)Optimal weight 0.0% (0/3) 0.0% (0/3)
Table 2: Best solution found by each algorithm and time (in seconds) required to compute it. The global bestsolution is highlighted in bold. Rows are highlighted in gray if one of our exact solvers is able to solve thecorresponding instances. S o l v e d i n s t a n ce s mesh OSM − Time [s] S o l v e d i n s t a n ce s FE − Time [s]
SNAP Cyclic-FastCyclic-StrongNon-IncreasingBasic-DenseBasic-Sparse
Figure 3: Cactus plots for the different instance families and evaluated solvers.
WVC and
HILS in addition to the two branch-and-reduce algorithms
Basic-Sparse and
Basic-Dense .For
DynWVC we use both configurations
DynWVC1 and
DynWVC2 described by Cai et al. [12]. For all al-gorithms we compare both the best achievable weightedindependent set, as well as their convergence behaviorregarding solution quality. An overview of the max-imum weight and the minimum time required to ob-tain it is given in Table 2. Furthermore, for each ex-act algorithm the number of solved instances is shown,whereas for heuristic methods the number of instanceson which they are also able to find an optimal solution isgiven. However, note that the heuristic methods testedare not able to verify the optimality of the solutionthey computed. For the individual instance families,we list either
DynWVC1 or DynWVC2 depending onwhich of the two configurations provides better perfor-mance. Finally, we omit
Basic-Sparse , Basic-Dense and
NonIncreasing , as these are outperformed by ei-ther
Cyclic-Fast and
Cyclic-Strong as presentedin the previous section. A complete overview of thesolution sizes and running times for each algorithm isgiven in Appendix D.Considering the OSM family, we see that our algo-rithms are able to compute an optimal solution on 22 ofthe 34 instances tested. However,
HILS was also ableto calculate a solution of optimal size on all these in-stances. Considering the OSM family, we can see that
HILS calculates optimal solutions on all 22 of the 34instances that can be solved by our algorithm
Cyclic-Strong . In contrast,
DynWVC is only able to do so on 15 of the 22 instances. Furthermore, on ten of the re-maining 12 instances which our algorithms are not ableto solve,
HILS is able to calculate the best solution.Finally, when comparing the time required to computethe best solution, we find that
HILS generally performsbetter than the other algorithms.Looking at the SNAP instances, we have al-ready seen that
Cyclic-Fast and
Cyclic-Strong cansolve 28 of the 31 instances optimally. In contrast,
HILS can only calculate optimal solutions on 16 ofthese 28 instances. Furthermore,
DynWVC is ableto obtain optimal solutions on eight of the solved in-stances. For the three unsolved instances,
Cyclic-Strong computes the best solution on as-skitter and soc-LiveJournal1 , while
DynWVC1 obtains iton soc-pokec-relationships . In terms of runningtime, we can see that both
DynWVC and
HILS areoften orders of magnitude slower than our algorithms inachieving their optimal solution.On the mesh instances, we can observe a similarpattern as for the SNAP instances. Our algorithms
Cyclic-Fast and
Cyclic-Strong are able to solveall instances optimally and always need less than threeseconds to obtain them. On the other hand, none of theevaluated local searches is able to compute an optimalsolution on a single instance and are slower than ouralgorithms by orders of magnitude .Finally, on the FE family, neither
DynWVC nor
HILS are able to obtain a solution of equal weight onany of the three instances solved by our algorithms.However, considering the unsolved instances, our algo- ithms are only able to compute the best solution on fe_body . On all remaining instances, one of the two DynWVC configurations calculates the best solution.
In this work, we engineered two new algorithms for find-ing maximum weight independent sets. Our algorithmsuse novel transformations that make heavy use of thestruction method. In general, the struction method canbe classified as a transformation that reduces the inde-pendence number of a graph. One caveat of the struc-tion method is that it does not guarantee the size of thegraph reduces in tandem with its independence number,from which we derive so-called increasing transforma-tions. We introduced three different types of structionsthat aim to reduce the number of newly constructedvertices. We then derived special cases of these struc-tion variants that can be efficiently applied in practice.Our experimental evaluation indicates that our tech-niques outperform existing algorithms on a wide va-riety of instances. In particular, with the exceptionof a single instance, our transformations produce thesmallest-known reduced graphs and, when performedbefore branch-and-reduce, solve more instances than ex-isting exact algorithms—at times even solving instancesfaster than heuristic approaches. Of particular inter-est for future work is engineering increasing transfor-mations that are efficient enough to be used throughoutrecursion—a more general branch-and-transform tech-nique. Further work includes evaluating the conic re-duction [31] or clique reduction [30], which are similarto struction.
References [1]
OpenStreetMap . URL .[2] T. Akiba and Y. Iwata. Branch-and-reduceexponential/FPT algorithms in practice: Acase study of vertex cover.
Theoretical Com-puter Science , 609, Part 1:211–225, 2016.doi:10.1016/j.tcs.2015.09.023.[3] G. Alexe, P. L. Hammer, V. V. Lozin, andD. de Werra. Struction revisited.
Dis-crete applied mathematics , 132(1-3):27–46, 2003.doi:10.1016/S0166-218X(03)00388-3.[4] D. V. Andrade, M. G. Resende, and R. F. Werneck.Fast local search for the maximum independentset problem.
Journal of Heuristics , 18(4):525–547,2012. doi:10.1007/s10732-012-9196-4.[5] F. Ay, M. Kellis, and T. Kahveci. Submap: aligningmetabolic pathways with subnetwork mappings.
Journal of computational biology , 18(3):219–235,2011. doi:10.1089/cmb.2010.0280.[6] L. Babel. A fast algorithm for the maximum weightclique problem.
Computing , 52(1):31–38, 1994.doi:10.1007/BF02243394.[7] E. Balas and C. S. Yu. Finding a maximum cliquein an arbitrary graph.
SIAM Journal on Comput-ing , 15(4):1054–1068, 1986. doi:10.1137/0215075.[8] L. Barth, B. Niedermann, M. Nöllenburg, andD. Strash. Temporal map labeling: A new uni-fied framework with experiments. In
Proceedingsof the 24th ACM SIGSPATIAL International Con-ference on Advances in Geographic InformationSystems , GIS ’16, pages 23:1–23:10. ACM, 2016.doi:10.1145/2996913.2996957.[9] A. E. Brouwer, J. B. Shearer, N. J. A. Sloane, andW. D. Smith. A new table of constant weight codes.
IEEE Transactions on Information Theory , 36(6):1334–1380, 1990. doi:10.1109/18.59932.[10] S. Butenko and S. Trukhanov. Using critical setsto solve the maximum independent set problem.
Operations Research Letters , 35(4):519–524, 2007.doi:10.1016/j.orl.2006.07.004.[11] S. Cai, K. Su, and A. Sattar. Local searchwith edge weighting and configuration check-ing heuristics for minimum vertex cover.
Ar-tificial Intelligence , 175(9-10):1672–1696, 2011.doi:10.1016/j.artint.2011.03.003.[12] S. Cai, W. Hou, J. Lin, and Y. Li. Improvinglocal search for minimum weight vertex cover bydynamic strategies. In
Proceedings of the Twenty-Seventh International Joint Conference on Artifi-cial Intelligence (IJCAI 2018) , pages 1412–1418,2018. doi:10.24963/ijcai.2018/196.[13] L. Chang, W. Li, and W. Zhang. Comput-ing a near-maximum independent set in lineartime by reducing-peeling.
Proceedings of the 2017ACM International Conference on Managementof Data (SIGMOD ’17) , pages 1181–1196, 2017.doi:10.1145/3035918.3035939.[14] J. Chou, J. Kim, and D. Rotem. Energy-aware scheduling in disk storage systems. In , pages 423–433. IEEE, 2011.doi:10.1109/ICDCS.2011.40.[15] J. Dahlum, S. Lamm, P. Sanders, C. Schulz,D. Strash, and R. F. Werneck. Accelerating lo-cal search for the maximum independent set prob-lem. In A. V. Goldberg and A. S. Kulikov, ed-itors,
Experimental Algorithms (SEA 2016) , vol-ume 9685 of
LNCS , pages 118–133. Springer, 2016.doi:10.1007/978-3-319-38851-9_9.16] C. Ebenegger, P. Hammer, and D. De Werra.Pseudo-boolean functions and stability of graphs.In
North-Holland mathematics studies , volume 95,pages 83–97. Elsevier, 1984. doi:10.1016/S0304-0208(08)72955-4.[17] M. R. Garey, D. S. Johnson, and L. Stockmeyer.Some Simplified NP-Complete Problems. In
Pro-ceedings of the 6th ACM Symposium on Theory ofComputing , STOC ’74, pages 47–63. ACM, 1974.doi:10.1145/800119.803884.[18] A. Gemsa, M. Nöllenburg, and I. Rutter. Eval-uation of labeling strategies for rotating maps.In
Experimental Algorithms (SEA’14) , volume8504 of
LNCS , pages 235–246. Springer, 2014.doi:10.1007/978-3-319-07959-2_20.[19] P. L. Hammer, N. V. Mahadev, and D. de Werra.Stability in can-free graphs.
Journal of Com-binatorial Theory, Series B , 38(1):23–30, 1985.doi:10.1016/0095-8956(85)90089-9.[20] P. L. Hammer, N. V. R. Mahadev, and D. de Werra.The struction of a graph: Application to cn-free graphs.
Combinatorica , 5(2):141–147, 1985.doi:10.1007/BF02579377.[21] D. Hespe, C. Schulz, and D. Strash. Scal-able kernelization for maximum independentsets. In , pages 223–237. SIAM, 2018.doi:10.1137/1.9781611975055.19.[22] D. Hespe, S. Lamm, C. Schulz, and D. Strash.WeGotYouCovered: The winning solver from thePACE 2019 challenge, vertex cover track. In , pages 1–11. SIAM, 2020.doi:10.1137/1.9781611976229.1.[23] K. W. Hoke and M. Troyon. The struction al-gorithm for the maximum stable set problem re-visited.
Discrete Mathematics , 131(1-3):105–113,1994. doi:10.1016/0012-365X(94)90377-8.[24] S. Lamm, P. Sanders, C. Schulz, D. Strash, andR. F. Werneck. Finding near-optimal independentsets at scale.
Journal of Heuristics , 23(4):207–229,2017. doi:10.1007/s10732-017-9337-x.[25] S. Lamm, C. Schulz, D. Strash, R. Williger,and H. Zhang. Exactly solving the maximumweight independent set problem on large real-worldgraphs. In , pages 144–158. SIAM, 2019.doi:10.1137/1.9781611975499.12.[26] J. Leskovec and A. Krevl. SNAP Datasets: Stan-ford large network dataset collection. URL http://snap.stanford.edu/data , June 2014. [27] C.-M. Li, H. Jiang, and F. Manyà. On mini-mization of the number of branches in branch-and-bound algorithms for the maximum clique problem.
Computers & Operations Research , 84:1–15, 2017.doi:10.1016/j.cor.2017.02.017.[28] R. Li, S. Hu, S. Cai, J. Gao, Y. Wang, andM. Yin. Numwvc: A novel local search for min-imum weighted vertex cover problem.
Journal ofthe Operational Research Society , pages 1–12, 2019.doi:10.1080/01605682.2019.1621218.[29] Y. Li, S. Cai, and W. Hou. An efficient lo-cal search algorithm for minimum weighted vertexcover on massive graphs. In
Asia-Pacific Confer-ence on Simulated Evolution and Learning (SEAL2017) , volume 10593 of
LNCS , pages 145–157.2017. doi:10.1007/978-3-319-68759-9_13.[30] L. Lovász and M. D. Plummer.
Matching the-ory , volume 121 of
North-Holland MathematicsStudies , pages 471–482. North-Holland, 1986.doi:10.1016/S0304-0208(08)73648-X.[31] V. V. Lozin. Conic reduction of graphs for the sta-ble set problem.
Discrete Mathematics , 222(1-3):199–211, 2000. doi:10.1016/S0012-365X(99)00408-2.[32] T. Ma and L. J. Latecki. Maximum weight cliqueswith mutex constraints for video object segmen-tation. In , pages 670–677.IEEE, 2012. doi:10.1109/CVPR.2012.6247735.[33] F. Mascia, E. Cilia, M. Brunato, and A. Passerini.Predicting structural and functional sites in pro-teins by searching for maximum-weight cliques. In
Twenty-Fourth AAAI Conference on Artificial In-telligence , 2010.[34] B. Nogueira, R. G. S. Pinheiro, and A. Subra-manian. A hybrid iterated local search heuristicfor the maximum weight independent set prob-lem.
Optimization Letters , 12(3):567–583, 2018.doi:10.1007/s11590-017-1128-7.[35] K. J. Nurmela, M. K. Kaikkonen, and P. Ostergard.New constant weight codes from linear permutationgroups.
IEEE Transactions on Information The-ory , 43(5):1623–1630, 1997. doi:10.1109/18.623163.[36] P. R. Östergård. A fast algorithm for the maxi-mum clique problem.
Discrete Applied Mathemat-ics , 120(1-3):197–207, 2002. doi:10.1016/S0166-218X(01)00290-6.[37] A. S. P. Pedersen, P. D. Vestergaard, et al. Boundson the number of vertex independent sets in agraph.
Taiwanese Journal of Mathematics , 10(6):1575–1587, 2006. doi:10.11650/twjm/1500404576.
38] H. Prodinger and R. Tichy. Fibonacci numbersof graphs.
The Fibonacci Quarterly , 20(1):16–21,1982.[39] P. Prosser and J. Trimble.
Peaty: An exact solverfor the vertex cover problem , 2019.[40] S. Rebennack, M. Oswald, D. O. Theis, H. Seitz,G. Reinelt, and P. M. Pardalos. A branch and cutsolver for the maximum stable set problem.
Journalof combinatorial optimization , 21(4):434–457, 2011.doi:10.1007/s10878-009-9264-3.[41] P. V. Sander, D. Nehab, E. Chlamtac, andH. Hoppe. Efficient traversal of mesh edgesusing adjacency primitives.
ACM Transac-tions on Graphics (TOG) , 27(5):1–9, 2008.doi:10.1145/1409060.1409097.[42] D. Strash. On the power of simple reductionsfor the maximum independent set problem. InT. N. Dinh and M. T. Thai, editors,
Computingand Combinatorics (COCOON’16) , volume 9797of
LNCS , pages 345–356. 2016. doi:10.1007/978-3-319-42634-1_28.[43] S. Szabó and B. Zavalnij. Combining algorithmsfor vertex cover and clique search. In
Proceedingsof the 22nd International Multiconference INFOR-MATION SOCIETY – IS 2019, Volume I: Middle-European Conference on Applied Theoretical Com-puter Science , pages 71–74, 2019.[44] J. Trimble. Maximum weight clique instances. doi:10.5281/zenodo.848647, Aug. 2017.[45] J. S. Warren and I. V. Hicks. Combinatorialbranch-and-bound for the maximum weight inde-pendent set problem. 2006. URL .[46] D. Warrier.
A branch, price, and cut approachto solving the maximum weighted independent setproblem . PhD thesis, Texas A&M University, 2007.[47] D. Warrier, W. E. Wilhelm, J. S. Warren, andI. V. Hicks. A branch-and-price approach forthe maximum weight independent set problem.
Networks: An International Journal , 46(4):198–209, 2005. doi:10.1002/net.20088.[48] Q. Wu and J.-K. Hao. Solving the winner deter-mination problem via a weighted maximum cliqueheuristic.
Expert Systems with Applications , 42(1):355–365, 2015. doi:10.1016/j.eswa.2014.07.027.[49] H. Xu, T. S. Kumar, and S. Koenig. A newsolver for the minimum weighted vertex cover prob-lem. In
International Conference on AI and ORTechniques in Constriant Programming for Com-binatorial Optimization Problems , pages 392–405.Springer, 2016. doi:10.1007/978-3-319-33954-2_28. [50] X. Xu, S. Tang, and P.-J. Wan. Maximum weightedindependent set of links under physical interferencemodel. In
International Conference on WirelessAlgorithms, Systems, and Applications , pages 68–74. Springer, 2010. doi:10.1007/978-3-642-14654-1_8.
A Graph Properties
Graph | V | |E| fe_4elt2
11 143 65 636 fe_body
45 087 327 468 fe_ocean
143 437 819 186 fe_pwt
36 519 289 588 fe_rotor
99 617 1 324 862 fe_sphere
16 386 98 304 fe_tooth
78 136 905 182
Table 3: Properties of FE instances
Graph | V | |E| beethoven blob
16 068 48 204 buddha bunny
68 790 206 034 cow dragon
150 000 450 000 dragonsub
600 000 1 800 000 ecat
684 496 2 053 488 face
22 871 68 108 fandisk feline
41 262 123 786 gameguy
42 623 127 700 gargoyle
20 000 60 000 turtle
267 534 802 356 venus
Table 4: Properties of mesh instances raph | V | |E| as-skitter ca-AstroPh
18 772 396 100 ca-CondMat
23 133 186 878 ca-GrQc ca-HepPh
12 008 236 978 ca-HepTh email-Enron
36 692 367 662 email-EuAll
265 214 728 962 p2p-Gnutella04
10 876 79 988 p2p-Gnutella05 p2p-Gnutella06 p2p-Gnutella08 p2p-Gnutella09 p2p-Gnutella24
26 518 130 738 p2p-Gnutella25
22 687 109 410 p2p-Gnutella30
36 682 176 656 p2p-Gnutella31
62 586 295 784 roadNet-CA roadNet-PA roadNet-TX soc-Epinions1
75 879 811 480 soc-LiveJournal1 soc-Slashdot0811
77 360 938 360 soc-Slashdot0902
82 168 1 008 460 soc-pokec-relationships web-BerkStan
685 230 13 298 940 web-Google
875 713 8 644 102 web-NotreDame
325 729 2 180 216 web-Stanford
281 903 3 985 272 wiki-Talk wiki-Vote
Table 5: Properties of SNAP instances
Graph | V | |E| alabama-AM2 alabama-AM3 district-of-columbia-AM1 district-of-columbia-AM2
13 597 3 219 590 district-of-columbia-AM3
46 221 55 458 274 florida-AM2 florida-AM3 georgia-AM3 greenland-AM3 hawaii-AM2 hawaii-AM3
28 006 98 889 842 idaho-AM3 kansas-AM3 kentucky-AM2 kentucky-AM3
19 095 119 067 260 louisiana-AM3 maryland-AM3 massachusetts-AM2 massachusetts-AM3 mexico-AM3 new-hampshire-AM3 north-carolina-AM3 oregon-AM2 oregon-AM3 pennsylvania-AM3 rhode-island-AM2 rhode-island-AM3
15 124 25 244 438 utah-AM3 vermont-AM3 virginia-AM2 virginia-AM3 washington-AM2 washington-AM3
10 022 4 692 426 west-virginia-AM3
Table 6: Properties of OSM instances
B Proofs
Lemma B.1.
After using the modified weighted struc-tion, the equality α w ( G ) = α w ( G (cid:48) ) + w ( v ) holds.Proof. Any maximal independent set in G must containeither v or some nodes from N ( v ) . Let I be a maximumweight independent set in G , and α w ( G ) its weight.If v ∈ I , then there is an independent set I (cid:48) in G (cid:48) with weight α w ( G ) − w ( v ) , namely I (cid:48) = I \ v . If v / ∈ I , that is there are some nodes from N ( v ) in I ,then there is an independent set I (cid:48) in G (cid:48) with weight α w ( G ) − w ( v ) . Let denote the nodes from I that arein N ( v ) by { x, y , y , . . . , y p } , x < y < y < · · · < y p .The independent set I (cid:48) with weight α w ( G ) − w ( v ) canbe constructed, namely I (cid:48) = I \ { x, y , y , . . . , y p } ∪{ x (cid:48) , v (cid:48) x,y , v (cid:48) x,y , . . . , v (cid:48) x,y p } .Let I (cid:48) be a maximum weight independent setin G (cid:48) and α w ( G (cid:48) ) its weight. If any new nodes x (cid:48) , v (cid:48) x,y , v (cid:48) x,y , . . . , v (cid:48) x,y p ∈ I (cid:48) , then there is an indepen-dent set I in G with weight α w ( G (cid:48) ) + w ( v ) , namely I = I (cid:48) \ { x (cid:48) , v (cid:48) x,y , v (cid:48) x,y , . . . , v (cid:48) x,y p } ∪ { x, y , y , . . . , y p } .If there is no new node in I (cid:48) , then there is an inde-pendent set I in G with weight α w ( G (cid:48) ) + w ( v ) , namely I = I (cid:48) ∪ { v } . (cid:2) Lemma B.2.
After using the extended weighted struc-tion, the equality α w ( G ) = α w ( G (cid:48) ) + w ( v ) holds.Proof. Any maximal independent set in G must containeither v or some nodes from N ( v ) . Let I be a maximumweight independent set in G , and α w ( G ) its weight.If v ∈ I , then there is an independent set I (cid:48) in G (cid:48) with weight α w ( G ) − w ( v ) , namely I (cid:48) = I \ v . If v / ∈ I , that is there are some nodes from N ( v ) in I ,then there is an independent set I (cid:48) in G (cid:48) with weight α w ( G ) − w ( v ) . Let denote the nodes from I that arein N ( v ) by { u , u , . . . , u t } . The independent set I (cid:48) with weight α w ( G ) − w ( v ) can be constructed from I bydeleting nodes { u , u , . . . , u t } and adding the one newnode that corresponds to the independent set containingthese nodes.Let I (cid:48) be a maximum weight independent set in G (cid:48) and α w ( G (cid:48) ) its weight. If any new node y ∈ I (cid:48) (let nodes { u , u , . . . , u t } from G be the nodes that correspond tothe independent set that is represented by y ), then thereis an independent set I in G with weight α w ( G (cid:48) ) + w ( v ) ,namely I = I (cid:48) \ y ∪ { u , u , . . . , u t } . If there is no newnode in I (cid:48) , then there is an independent set I in G withweight α w ( G (cid:48) ) + w ( v ) , namely I = I (cid:48) ∪ { v } . (cid:2) Lemma B.3.
After using the extended reduced weightedstruction, the equality α w ( G ) = α w ( G (cid:48) ) + w ( v ) holds.Proof. Concludes from the proof for extended weightedstruction and the modified weighted struction. (cid:2) Branch-and-Reduce Comparison
Graph n t r t t n t r t t n t r t t n t r t t n t r t t FE instances
Basic-Dense Basic-Sparse NonIncreasing Cyclic-Fast Cyclic-Strong fe_4elt2 fe_body
16 107 0.69 - 15 992 3.40 - 1 162 0.16 - 625 0.44 - 553 0.94 - fe_ocean
141 283 1.05 - 0 5.94
138 338 8.90 - 138 134 9.61 - 138 049 10.78 - fe_pwt
34 521 0.46 - 34 521 2.70 - 25 550 0.78 - 20 241 1.80 - 14 107 5.65 - fe_rotor
98 271 9.80 - 98 271 24.47 - 91 946 4.80 - 91 634 4.82 - 89 647 11.11 - fe_sphere
15 269 0.21 - 15 269 1.47 - 2 961 0.34 - 147 0.62 fe_tooth
10 922 1.69 - 10 801 3.79 - 15 0.41 0.46 0 0.30
Basic-Dense Basic-Sparse NonIncreasing Cyclic-Fast Cyclic-Strong alabama-AM2
173 0.06 0.31 173 0.07 0.55 0 0.01 alabama-AM3 district-of-columbia-AM1
800 1.22 - 800 1.28 - 367 0.03 39.81 185 0.41 district-of-columbia-AM2 district-of-columbia-AM3
33 367 63.23 - 33 367 358.14 - 32 320 33.68 - 28 842 66.67 - 25 031 441.44 - florida-AM2
41 0.01 0.01 41 0.01 0.01 0 0.00 0.00 0 0.00 florida-AM3
267 42.26 45.05 georgia-AM3
861 8.99 892.17 861 10.14 - 796 0.08 25.97 587 0.69
425 12.84 32.53 greenland-AM3 hawaii-AM2
428 2.08 4.27 428 2.15 10.22 262 0.07 0.18 0 0.09 hawaii-AM3
24 436 70.38 - 24 436 743.04 - 24 184 98.22 - 22 997 118.52 - 21 087 632.02 - idaho-AM3 kansas-AM3
860 41.61 489.15 kentucky-AM2
442 2.05 11.85 442 2.19 67.28 183 0.20 0.39 0 0.22 kentucky-AM3
16 871 109.47 - 16 871 3 344.67 - 16 807 237.86 - 15 947 298.49 - 15 684 705.46 - louisiana-AM3
382 4.56 6.55 382 5.04 25.22 349 0.03 0.82 0 0.07 maryland-AM3
187 7.59 8.49 187 8.65 10.73 335 0.03 0.19 0 0.11 massachusetts-AM2
196 0.04 0.36 196 0.04 0.58 193 0.02 0.07 0 0.06 massachusetts-AM3 mexico-AM3
620 25.29 80.23 620 27.52 991.99 514 0.03
483 0.28 1.50 0 21.03 21.30 new-hampshire-AM3
247 4.99 6.19 247 5.69 15.89 164 0.02 0.17 0 0.07 north-carolina-AM3 oregon-AM2
35 0.04 0.05 35 0.05 0.05 0 0.01 oregon-AM3 pennsylvania-AM3
315 16.69 20.71 315 19.39 113.87 317 0.03 0.39 0 0.07 rhode-island-AM2 rhode-island-AM3
13 031 7.75 - 13 031 193.76 - 12 934 26.54 - 12 653 29.75 - 12 653 59.69 - utah-AM3
568 8.21 51.91 568 8.97 276.27 396 0.03 0.87 0 0.09 vermont-AM3 virginia-AM2
237 0.13 0.61 237 0.12 0.99 0 0.03 virginia-AM3 washington-AM2
382 0.24 5.31 382 0.18 8.58 171 0.05 0.37 0 0.06 washington-AM3 west-virginia-AM3
991 10.69 - 991 12.13 - 970 0.08 238.39 890 0.33
881 38.73 241.68
Table 7: Obtained irreducible graph sizes n , time t r (in seconds) needed to obtain them and total solving time t t (in seconds) on FE and OSMinstances. The global best solving time t t is highlighted in bold.Rows are highlighted in gray if one of our algorithms is able to obtain an emptygraph. raph n t r t t n t r t t n t r t t n t r t t n t r t t mesh instances Basic-Dense Basic-Sparse NonIncreasing Cyclic-Fast Cyclic-Strong beethoven blob buddha
380 315 5.56 - 107 265 26.19 67.85 86 1.83 2.74 0 1.87 bunny
24 580 0.34 - 3 290 0.56 0.89 0 0.12 cow dragon
51 885 0.89 - 12 893 1.34 3.83 0 0.18 dragonsub
218 779 2.60 - 19 470 4.15 5.66 506 1.03 2.08 0 1.13 ecat
239 787 4.07 - 26 270 10.09 12.93 274 2.12 3.16 0 2.12 face fandisk feline
14 817 0.20 - 2 743 0.25 0.47 0 0.08 0.09 0 0.08 gameguy
13 959 0.17 - 312 0.10 0.12 0 0.06 0.07 0 0.06 gargoyle turtle
91 624 1.17 - 16 095 1.92 4.98 186 0.42 0.65 0 0.41 venus
Basic-Dense Basic-Sparse NonIncreasing Cyclic-Fast Cyclic-Strong as-skitter
26 584 25.82 - 8 585 36.69 - 3 426 4.75 - 2 782 5.50 - 2 343 6.80 - ca-AstroPh ca-CondMat ca-GrQc ca-HepPh ca-HepTh email-Enron email-EuAll p2p-Gnutella04 p2p-Gnutella05 p2p-Gnutella06 p2p-Gnutella08 p2p-Gnutella09 p2p-Gnutella24 p2p-Gnutella25
10 0.01 0.02 0 0.01 0.02 0 0.01 p2p-Gnutella30 p2p-Gnutella31 roadNet-CA
234 433 3.96 - 66 406 20.51 437.62 478 2.14 5.70 0 2.42 roadNet-PA
133 814 2.43 - 35 442 7.73 23.86 300 1.05 2.24 0 1.19 roadNet-TX
153 985 2.65 - 40 350 10.49 24.30 882 1.23 3.98 0 1.32 soc-Epinions1 soc-LiveJournal1
60 041 236.88 - 29 508 213.74 - 4 319 22.27 - 3 530 24.13 - 1 314 37.77 - soc-Slashdot0811 soc-Slashdot0902 soc-pokec-relationships
926 346 299.11 - 898 779 1 013.39 - 808 542 188.57 - 807 412 217.83 - 807 395 388.57 - web-BerkStan
36 637 6.58 - 16 661 8.70 - 1 999 6.86 120.05 151 6.46
151 7.89 8.25 web-Google web-NotreDame
13 464 1.03 - 6 052 2.03 - 2 460 0.40 - 2 061 0.56
117 2.44 2.57 web-Stanford
14 153 1.81 - 3 325 2.45 - 112 2.25 2.50 0 1.80 wiki-Talk wiki-Vote
477 0.03 0.12 0 0.02 0.03 0 0.02
Table 8: Obtained irreducible graph sizes n , time t r (in seconds) needed to obtain them and total solving time t t (in seconds) on mesh and SNAPinstances. The global best solving time t t is highlighted in bold. Rows are highlighted in gray if one of our algorithms is able to obtain an emptygraph. State-of-the-Art Comparison
Graph t max w max t max w max t max w max t max w max t max w max t max w max FE instances DynWVC1 DynWVC2 HILS Cyclic-Fast Cyclic-Strong Non-Increasing fe_4elt2
428 029
428 029 fe_body fe_ocean fe_pwt fe_rotor fe_sphere
617 816
617 816 fe_tooth
OSM instances DynWVC1 DynWVC2 HILS Cyclic-Fast Cyclic-Strong Non-Increasing alabama-AM2
174 309
174 309
174 309
174 309 alabama-AM3
185 744
185 744
185 744
185 744 district-of-columbia-AM1
196 475
196 475
196 475
196 475
196 475
196 475 district-of-columbia-AM2
209 132
209 132 district-of-columbia-AM3
227 613 florida-AM2
230 595
230 595
230 595
230 595
230 595
230 595 florida-AM3
237 333
237 333
237 333
237 333 georgia-AM3
222 652
222 652
222 652
222 652
222 652
222 652 greenland-AM3
14 012 hawaii-AM2
125 284
125 284
125 284
125 284 hawaii-AM3
141 035 idaho-AM3
77 145
77 145
77 145 kansas-AM3
87 976
87 976
87 976
87 976
87 976
87 976 kentucky-AM2
97 397
97 397
97 397
97 397
97 397
97 397 kentucky-AM3
100 510
100 510 louisiana-AM3
60 024
60 024
60 024
60 024
60 024 maryland-AM3
45 496
45 496
45 496
45 496
45 496
45 496 massachusetts-AM2
140 095
140 095
140 095
140 095
140 095
140 095 massachusetts-AM3
145 866
145 866
145 866
145 866 mexico-AM3
97 663
97 663
97 663
97 663
97 663
97 663 new-hampshire-AM3
116 060
116 060
116 060
116 060
116 060
116 060 north-carolina-AM3
49 720
49 720
49 720
49 720
49 720 oregon-AM2
165 047
165 047
165 047
165 047
165 047
165 047 oregon-AM3
175 078
175 078
175 078 pennsylvania-AM3
143 870
143 870
143 870
143 870
143 870
143 870 rhode-island-AM2
184 596
184 596
184 596
184 596 rhode-island-AM3
201 758 utah-AM3
98 847
98 847
98 847
98 847
98 847 vermont-AM3
63 312
63 312
63 312 virginia-AM2
295 867
295 867
295 867
295 867 virginia-AM3
308 305
308 305
308 305
308 305 washington-AM2
305 619
305 619
305 619
305 619
305 619
305 619 washington-AM3
314 288 west-virginia-AM3
47 927
47 927
47 927
47 927
47 927
47 927
Table 9: Best solution found by each algorithm on FE and OSM instances and time (in seconds) required to compute it. The global best solutionis highlighted in bold. Rows are highlighted in gray if one of our exact solvers is able to solve the corresponding instances. raph t max w max t max w max t max w max t max w max t max w max t max w max mesh instances DynWVC1 DynWVC2 HILS Cyclic-Fast Cyclic-Strong Non-Increasing beethoven
238 794
238 794
238 794 blob
855 547
855 547
855 547 buddha
57 555 880
57 555 880
57 555 880 bunny cow
269 543
269 543
269 543 dragon dragonsub
32 213 898
32 213 898
32 213 898 ecat
36 650 298
36 650 298
36 650 298 face fandisk
463 288
463 288
463 288 feline gameguy gargoyle turtle
14 263 005
14 263 005
14 263 005 venus
305 749
305 749
305 749
SNAP instances DynWVC1 DynWVC2 HILS Cyclic-Fast Cyclic-Strong Non-Increasing as-skitter
124 137 365 ca-AstroPh
797 510
797 510
797 510
797 510 ca-CondMat ca-GrQc
286 489
286 489
286 489
286 489
286 489
286 489 ca-HepPh
581 039
581 039
581 039
581 039 ca-HepTh
562 004
562 004
562 004
562 004 email-Enron email-EuAll
25 286 322
25 286 322
25 286 322
25 286 322
25 286 322
25 286 322 p2p-Gnutella04
679 111
679 111
679 111
679 111
679 111 p2p-Gnutella05
554 943
554 943
554 943
554 943 p2p-Gnutella06
548 612
548 612
548 612
548 612 p2p-Gnutella08
434 577
434 577
434 577
434 577
434 577 p2p-Gnutella09
568 439
568 439
568 439
568 439
568 439
568 439 p2p-Gnutella24 p2p-Gnutella25 p2p-Gnutella30 p2p-Gnutella31 roadNet-CA
111 360 828
111 360 828
111 360 828 roadNet-PA
61 731 589
61 731 589
61 731 589 roadNet-TX
78 599 946
78 599 946
78 599 946 soc-Epinions1 soc-LiveJournal1
284 036 239 soc-Slashdot0811 soc-Slashdot0902 soc-pokec-relationships
83 223 668 web-BerkStan
43 907 482
43 907 482
43 907 482 web-Google
56 326 504
56 326 504
56 326 504 web-NotreDame
26 016 941
26 016 941
26 016 941 web-Stanford
17 792 930
17 792 930
17 792 930 wiki-Talk
235 837 346
235 837 346
235 837 346 wiki-Vote
500 079
500 079
500 079
500 079
500 079