Designing Practical PTASes for Minimum Feedback Vertex Set in Planar Graphs

04/21/2018 ∙ by Glencora Borradaile, et al. ∙ Oregon State University 0

We present two algorithms for the minimum feedback vertex set problem in planar graphs: an O(n n) PTAS using a linear kernel and balanced separator, and a heuristic algorithm using kernelization and local search. We implemented these algorithms and compared their performance with Becker and Geiger's 2-approximation algorithm. We observe that while our PTAS is competitive with the 2-approximation algorithm on large planar graphs, its running time is much longer. And our heuristic algorithm can outperform the 2-approximation algorithm on most large planar graphs and provide a trade-off between running time and solution quality, i.e. a "PTAS behavior".

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

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

1 Introduction

The minimum feedback vertex set problem (FVS) asks for a minimum set of vertices in an undirected graph such that after removing this set the resulting graph has no cycle. This problem is one of Karp’s 21 original NP-Complete problems [25]

and has applications in different areas, such as deadlock recovery in operating systems and reducing computation in Bayesian inference 

[5]. The current best approximation ratio for FVS in general graphs is 2 due to Becker and Geiger [7] and Bafna, Berman and Fujito [3], both of which could also work for the vertex-weighted version of FVS. Chudak et al. [14] showed that the two algorithms can be explained in terms of the primal dual method and simplified the latter algorithm.

In planar graphs, the problem is still NP-hard [37], but we can obtain better approximation algorithms. A polynomial-time approximation scheme (PTAS) is a -approximation algorithm runs in polynomial time for any fixed . As far as we know, Kleinberg and Kumar [26] gave the first PTAS for FVS in planar graphs. Demaine and Hajiaghayi [16] gave a different PTAS for FVS in single-crossing-minor-free graphs through their bidimensionality theory. Cohen-Addad et al. [15] gave a PTAS for the vertex-weighted version of this problem in bounded-genus graphs. In our companion work [28], we showed that local search is also a PTAS for FVS in minor-free graphs.

Besides the above algorithms, researchers also proposed some heuristic algorithms for FVS and evaluated their performance in experiments. For example, Pardalos et al. [34] developed a greedy randomized adaptive search procedure for FVS, Brunetta et al. [11] proposed a system based on local search and a branch-and-cut algorithm, Zhang et al. [38] presented a variable depth-based local search algorithm with a randomized scheme, and Qin and Zhou [35] introduced a simulated annealing local search algorithm for FVS. However, all of these works focus on general graphs. Brunetta et al. [11] included planar graphs in their experiments, but their test planar graphs were not very large, having at most one thousand of vertices. So it is natural to ask the following question:

which algorithm is preferred for FVS on large planar graphs in practice?

One potential answer to this question is a PTAS. There are two reasons supporting this choice: theoretically, PTASes can provide the best approximation ratio; practically, it has been shown that PTASes can be made practical for the minimum dominating set problem [32], the Steiner tree problem [36] and the traveling salesman problem (TSP) [6] in large planar graphs. Unfortunately, we find that a simple PTAS for FVS does not find a more accurate solution than the 2-approximation algorithm in most real-world graphs and some synthetic graphs. For those test graphs where it can find better solutions, the improvement is less than 1 percent. Furthermore, the PTAS is much slower than the 2-approximation algorithm. So another question to ask is

can we obtain a practical algorithm that can find more accurate solutions than

the 2-approximation algorithm in large planar graphs?

In this work, we propose a heuristic algorithm and show that it can outperform the 2-approximation algorithm in real-world graphs and most large synthetic graphs.

1.1 Overview of Our Work

To answer the first question, we implemented Becker and Geiger’s 2-approximation algorithm [7] as our baseline, which is simpler than the algorithm of Bafna, Berman and Fujito [3]. In Section 3.1, we evaluate this implementation on some graphs where we can obtain optimal solutions or good lower bound for the optimal solutions. We find that the 2-approximation algorithm finds solutions that are very close to the optimal in these instances.

To outperform this baseline, in Section 2.3 we propose a simple-to-implement PTAS for FVS in planar graphs, which starts with a linear kernel for FVS (see Section 2.2) and then uses a balanced separator (see Section 2.3.1) applied recursively to decompose the graph into a set of small subgraphs in which we will solve the problem optimally. The approach based on balanced separators has been applied to obtain PTASes for the maximum independent set problem [30] and the minimum vertex cover problem [12] in planar graphs. However, this approach is criticized in literature for two reasons: (1) a good approximation ratio can only be obtained in very large graphs [13, 4, 16], and (2) it needs the size of the optimal solution to be linear w.r.t. the size of input graph [21]. We overcome both issues. For the first, we relate the error parameter to the largest size of the decomposed graphs instead of the size of the original graph, and the algorithm can provide good approximation ratio for any graph in this way. For the second, we use a linear kernel as a proxy to achieve the linear bound for the optimal solution. Since many problems [18, 19, 8] admit linear kernels in minor-free graphs, which is a more general graph family and admits balanced separators of sublinear size [2], we believe this approach could be applied more generally.

Other PTASes for planar FVS that have been proposed are either complicated to implement (relying on dynamic programming over tree decompositions) or not sufficiently efficient (having running time of the form ). Compared to those, our PTAS has some obvious advantages: (1) it only relies on some simple algorithmic components like the kernelization algorithm, which consists of a sequence of simple reduction rules, and balanced separators, which are known to be practical [1, 22, 20]; (2) it has very few parameters to optimize; (3) the constants behind the big notation are small enough and (4) its running time is theoretically faster than previous PTASes. Performance of this PTAS on different large planar graphs is discussed in Section 3.2. We also incorporated heuristic steps (Section 2.4.1) to improve its solution and analyzed the influence of the parameters of the heuristic. However, counter to the success stories for the Steiner tree and TSP PTASes, we find that the solution found by this PTAS does not outperform the precision of the 2-approximation algorithm significantly.

Although our PTAS does not outperform the 2-approximation algorithm significantly, we use it as inspiration to engineer a PTAS-like heuristic we call a Heuristic Approximation Scheme (HAS), that is a heuristic with a running-time/precision trade-off. Our HAS has two main steps. The first step (see Section 2.4.2) is a hybrid algorithm that alternates the reduction rules of the linear kernel and the greedy step of the 2-approximation algorithm. The second step (see Section 2.4.3) is a variant of local search. Many local search heuristics start with a feasible solution and repeatedly construct a smaller solution by replacing a subset of the original solution with another smaller subset of the non-solution vertices, if it is feasible. We notice that this could be inefficient, since there are too many ways to replace the subset and so only very small values of can be handled. Instead, we use a fixed-parameter tractable (FPT) algorithm to determine the replacement for . An algorithm is FPT if it can solve a given problem optimally in running time , where is given as a fixed parameter (such as the size of the optimal solution, as for FVS) and is an arbitrary computable function. This kind of algorithm is very efficient when the parameter is small. Now given a feasible solution, our local search heuristic will repeatedly improve the solution by selecting a set from the solution, constructing a graph as the union of the non-solution vertices and set , solving the problem in this graph optimally with the FPT algorithm, and replacing with the obtained optimal solution.

We implemented and evaluated HAS on different large planar graphs and analyzed the effects of its parameters (Section 3.3). Our result shows that even its first step is able to find better solutions than the 2-approximation algorithm on most of our test graphs and its second step improves these solutions further. As a result, the total improvement for all real-world graphs is at least 5 percent, which is more than 30000 vertices in the largest test graph.

We find that HAS is very flexible and provides a kind of “PTAS behavior”. Its first step is competitive w.r.t. the running time so we can obtain a good solution quickly. And its second step can be applied for a longer time to obtain a better solution when the running time is not strictly limited. Thus, it can provide a trade-off between the running time and the solution quality by choices of the number of local search iterations. Therefore, we believe this algorithm will be a better choice in practice.

2 The Algorithms for FVS in Planar Graphs

In this section, we briefly summarize the FVS algorithms we implemented for planar graphs: the 2-approximation algorithm of Becker and Geiger [7], Bonamy and Kowalik’s linear kernel [9] for FVS in planar graphs (with optimizing modifications that we designed), our new PTAS using this linear kernel and balanced planar separators, and our proposed Heuristic Approximation Scheme.

2.1 The 2-Approximation Algorithm

Becker and Geiger’s 2-approximation algorithm [7] works for vertex-weighted FVS in general graphs and consists of two steps: (1) computes a greedy solution and (2) removes vertices to obtain a minimal solution. In the first step, the algorithm assigns a score for each vertex (weight of the vertex divided by its degree), and repeatedly removes a vertex with minimum score from the graph and adds it to the greedy solution. Each time a vertex is removed, the scores of its neighbors are updated. In the second step, the algorithm tries to remove the vertices from the greedy solution in the reverse order in which they were added, to obtain a minimal feasible solution.

2.2 Kernelization Algorithm

A parameterized decision problem with a parameter admits a kernel if there is a polynomial time algorithm (where the degree of the polynomial is independent of ), called a kernelization algorithm, that outputs a decision-equivalent instance whose size is bounded by some function . If the function is linear in , then we say the problem admits a linear kernel.

Bonamy and Kowalik’s linear kernel for planar FVS [9] consists of a sequence of 17 reduction rules. Each rule replaces a particular subgraph with another (possibly empty) subgraph, and possibly marks some vertices that must be in an optimal solution. The first 12 rules are simple and sufficient to obtain a -kernel [9]. Since the remaining rules do not improve the kernel by much, and since Rule 12 is a rejecting rule111This is to return a trivial no-instance for the decision problems when the resulting graph has more than vertices., we only implement the first 11 rules, all of which are local and independent of the parameter . The algorithm starts by repeatedly applying the first five rules to the graph and initializes two queues: queue contains some vertex pairs that are candidates to check for Rule 6 and queue contains vertices that are candidates to check for the last five rules. While is not empty, the algorithm repeatedly applies Rule 6, reducing in each step. Then the algorithm repeatedly applies the remaining rules in order, reducing until is empty. After applying any rule, the algorithm updates both queues as necessary, and will apply the first five rules if applicable. See the original paper [9] for full details of the reduction rules.

We remark that in the original paper [9], the algorithm runs in expected time, and each rule can be detected in time for each candidate with a hash table. However, we choose to use a balanced binary search tree instead of a hash table for a better practical performance.

The original algorithm works for the decision problem, so when applying it to the optimization problem, we need an additional step, called lifting, to convert a kernel solution to a feasible solution for the original graph. If a reduction rule does not introduce new vertices, then the lifting step for it will be trivial. Otherwise, we need to handle the vertices introduced by reduction steps, if they appear in the kernel solution. Among all the reduction rules, there are two rules, namely Rule 8 and Rule 9, that will introduce new vertices into the graph. For Rule 8, the following observation, whose proof is provided in the appendix, shows that the new vertex can be avoided.

[] The new vertex introduced by Rule 8 can be replaced by a vertex from the original graph.

For Rule 9, we record in a structure the related vertices for each application of this rule, and store the structures in a list in the same order as we apply the rule. To lift the solution to the original graph, we store all the vertices of the solution in a balanced search tree and then check the structures in the reverse order to see if the recorded vertices in a structure are also in the solution. If there are involved vertices in the solution, we modify the solution according to the reversed Rule 9. Since Rule 9 decreases the size of the graph, it can be applied at most times. So there are at most structures to check, each of which contains only constant number of vertices. To check if a vertex in the solution we need time, so the total replacement can be done in time. Then the lifting step first add back all vertices marked by the kernelization algorithm which can be done in linear time and then replace the introduced new vertices with original vertices, which needs at most time. So lifting can be accomplished in time.

2.3 Polynomial-Time Approximation Scheme

In this section, we introduce a PTAS for FVS in planar graphs, using linear kernel and balanced separator.

2.3.1 Balanced Separator

A separator is a set of vertices, removing which will partition the graph into two parts. A separator is -balanced if those two parts both have at most an -fraction of the original vertex set. Lipton and Tarjan [29] first introduced a separator theorem for planar graphs, which says a planar graph with vertices admits a -balanced separator of size at most , and they gave a linear-time algorithm to compute such a balanced separator. This algorithm starts by computing a breadth-first search (BFS) tree for the graph, partitioning the vertices into levels. Then it tries to find the separator in three phases:

  1. if there is any BFS level satisfying the requirements, then it is returned as a result;

  2. if there is no such level, then the algorithm tries to find two BFS levels that can form a balanced separator together;

  3. if both previous phases fail, then the algorithm identifies two BFS levels and constructs a fundamental cycle222Given a spanning tree for a graph, a fundamental cycle consists of a non-tree edge and a path in the tree connecting the two endpoints of that edge. to separate the subgraph between these two levels, such that the union of these two levels and the fundamental cycle form a balanced separator.

Though we followed a textbook version [27] of this separator algorithm, our implementation still guarantees the bound for the size of the separator. We remark that we did not apply heuristics in our implementation for the separator algorithm. This is because we did not observe separator size improvement by some simple heuristics in the early stage of this work, and these heuristics may slow down the separator algorithm. Since our test graphs are large (up to 2 million vertices) and we will apply the algorithm recursively in our PTAS, these heuristics may slow down our PTAS even more.

2.3.2 PTAS for Planar FVS

Lipton and Tarjan [30] designed a PTAS for maximum independent set in planar graphs using their balanced separator, which depends on the fact that the input is already a constant-factor approximation to the maximum independent set and contains the optimal solution. Here we use the linear kernel as a proxy for the constant factor approximation that can be used to obtain a nearly optimal solution for FVS and relate the error parameter to the largest size of decomposed graphs instead of the size of the input graph as previous works [30, 12]. This idea can be used for other problems admitting linear kernels in graph families admitting balanced separators:

  1. Compute a linear kernel for the original graph , that is, is at most for some constant .

  2. Decompose the kernel by recursively applying the separator algorithm and remove the separators until each resulting graph has at most vertices for some constant . The union of all the separators has at most vertices for chosen appropriately.

  3. Solve the problem optimally for all the resulting graphs.

  4. Let be the union of all separators and all solutions of the resulting graphs. Lift to a solution for the original graph.

We obtain the following theorem, whose proof is provided in the appendix. [] There is an time PTAS for FVS in planar graphs. More specifically, the running time is where and is the error parameter.

2.4 Heuristics

In this subsection, we introduce some heuristics that can help improve the quality of the FVS solution. We first provide two heuristics that improve the quality of our PTAS solutions. Then we introduce a hybrid algorithm that combines the greedy method of the 2-approximation algorithm and the reduction rules of the kernelization algorithm. Finally, we use local search to improve the solution from any algorithm. Our proposed Heuristic Approximation Scheme is a combination of the hybrid algorithm and the local search heuristic.

2.4.1 Heuristic Improvements to PTAS

The solution from our PTAS may not be a minimal one, so we use the post-processing step from the 2-approximation algorithm to convert the final solution of the PTAS to a minimal one. This involves iterating through the vertices in the solution and trying to remove redundant vertices from the solution while maintaining feasibility. In fact, we only need to iterate through the vertices in separators, since vertices in the optimal solutions of small graphs are needed for feasibility.

We additionally apply the kernelization algorithm right after we compute a separator in Step (2). Note that there is a decomposition tree corresponding to the decomposition step, where each node corresponds to a subgraph in the decomposition step. To apply the second heuristic, we need to record the whole decomposition tree with all the corresponding separators such that we can lift the solutions in the right order. For example, if we want to lift a solution for a subgraph corresponding to some node in the decomposition tree, we first need to lift all solutions for the subgraphs corresponding to the children of node in the decomposition tree.

2.4.2 Hybrid Algorithm

We notice the cost for detecting applicable reduction rules for a candidate vertex is relatively low ( time), and each of these rules can reduce either the size of the graph or the size of the optimal solution. It is beneficial, therefore, to apply them as much as possible. When there are no applicable reductions in the current graph, we can remove a vertex greedily just as the 2-approximation algorithm does, and this will change the current graph such that there may be applicable reductions again. Based on this idea, we propose a hybrid algorithm which interleaves the 2-approximation algorithm and the kernelization algorithm:

  1. Compute a temporary solution by repeating the following two steps until the graph is empty.

    1. Apply reduction rules from the kernelization algorithm in order until there are no applicable rules.

    2. Remove a vertex of highest degree from the graph and add it into the temporary solution.

  2. Lift the temporary solution to a feasible solution for the original graph and then compute a minimal solution by removing redundant vertices from this solution.

The running time of the first step is similar to the running time of the kernelization algorithm since the greedy step can be seen as another “rule” added into the kernelization algorithm and it can be done in time if we store the degree information in a binary search tree. So the first step runs in time. The lifting step needs time, and to compute a minimal solution we need time as done in Becker and Geiger’s 2-approximation algorithm. So the total running time of our hybrid algorithm is .

2.4.3 Local Search

In our companion paper [28], we show that local search gives a PTAS for FVS in -minor-free graphs. The algorithm is not practical, with running time . We relax the conditions of the algorithm here. Assume we are given a feasible FVS solution for a planar graph , and we would like to improve this solution. To achieve this goal, we propose a local search heuristic. Assume we have a fixed parameter tractable (FPT) algorithm FA for the FVS problem (either for planar graphs or for general graphs). Then our local search with size consists of the following two steps.

  1. Select a subset of size from randomly.

  2. Run the algorithm FA on graph . Stop FA if a solution is not found in a reasonable amount of time. If FA finds a solution in graph , then return ; otherwise return .

The solution is a feasible solution for graph since is a forest and .

3 Experiments

In this section, we evaluate the performance of the algorithms described in the last section. We implemented those algorithms in C++ and the code is compiled with g++ (version 4.8.5) on the CentOS (version 7.3.1611) operating system. Our PTAS implementation is built on Boyer’s implementation333http://jgaa.info/accepted/2004/BoyerMyrvold2004.8.3/planarity.zip of Boyer and Myrvold’s planar embedding algorithm [10]. In our experiments, we also use the implementation444https://github.com/wata-orz/fvs of Iwata and Imanishi for FVS in general graphs, which is implemented in java and includes a linear-time kernel [23] and a branch-and-bound based FPT algorithm [24] for FVS in general graphs. The java version in our machine is 1.8.0 and our experiments were performed on a machine with Intel(R) Xeon(R) CPU (2.30GHz) running CentOS (version 7.3.1611) operating system.

To test the algorithms, we collect five different classes of graphs:

  • pace are the planar graphs used in PACE (The Parameterized Algorithms and Computational Experiments Challenge) 2016 Track B: Feedback Vertex Set;

  • random are random planar graphs generated by LEDA (version 6.4) [33];

  • triangu are triangulated random graphs generated by LEDA, whose outer faces are not triangulated;

  • grid are rectangular grid graphs;

  • The graphs NY, BAY, COL, NW, CAL, FLA, LKS, NE, E and W are road networks used in the 9th DIMACS Implementation Challenge—Shortest Paths [17]. We interpret each graph as a straight-line embedding and we add vertices whenever two edges intersect geometrically.

Since we are interested in the performance of the algorithms in large planar graphs, the synthetic graphs we generated have at least 450000 vertices. And the real network graphs have at least 260000 vertices. Although the pace graphs are smaller than that, we only use them to evaluate the 2-approximation algorithm since we can obtain optimal solutions of those small graphs. All the detailed experimental results, including solution sizes and running time, are also provided in the appendices.

3.1 The 2-Approximation Algorithm and Optimal Solution

To evaluate Becker and Geiger’s 2-approximation algorithm [7], we compare its solution with the optimal solution on graphs up to size 2000000. The optimal solution is obtained by applying the kernelization algorithm first and then the FPT algorithm implemented by Iwata and Imanishi. For each test graph, we run Iwata and Imanishi’s implementation for 30 seconds and stop it if it cannot terminate. Among all the test graphs, this method can solve 21 graphs of the 31 pace graphs, 9 graphs of the 10 random graphs. Although we cannot solve the large rectangular grid graphs by this method, we can apply Luccio’s [31] lower bound for the optimal solution in rectangular grids here. We observe that the solutions obtained by 2-approximation algorithm are very close to the optimal solutions for these test graphs. For pace graphs, the 2-approximation algorithm can solve 14 graphs optimally and the difference between the two solutions is at most three. The approximation ratio over all these graphs is at most 1.143, and this ratio is at most 1.001 for the grid graphs and at most 1.006 for these random graphs.

3.2 The PTAS and 2-Approximation Algorithm

Recall that the third step of our PTAS is to solve the problem on all the decomposed graphs optimally, which needs an exact algorithm for the problem. The trivial exact algorithm that enumerates each possible vertex subset can only solve a graph of size about 25 in a few seconds, with which the PTAS may not be able to give competitive solutions for large graphs. So we apply the exact algorithm described in the last subsection, which combines the kernelization algorithm and the FPT algorithm implemented by Iwata and Imanishi. In the early stage of this work, this exact algorithm did not find a solution for a pace graph of size 66 in 30 seconds. So we first set as 60 the largest size of the decomposed graphs and let the FPT algorithm run for at most 15 seconds. In this setting, all the decomposed graphs can be solved optimally in our experiments and we can evaluate the heuristics proposed for our PTAS. To do that, we compare three variants of our PTAS:

  • the vanilla variant is the vanilla version of our PTAS, for which no heuristic is applied;

  • the minimal variant applies the post processing heuristic to our PTAS, which will remove redundant vertices in separators;

  • the optimized variant applies both heuristics to our PTAS, which will apply kernelization algorithm whenever each separator is computed and removed during the decomposition step and always returns a minimal final solution.

The result is illustrated in Figure 1, where the solution size is normalized by the 2-approximation algorithm solutions. We observe that for the road network graphs, random graphs and triangu graphs, the optimized variant provides the best solutions among the three algorithms, which implies the two heuristics both help improve the solutions. However, for the grid graphs, the minimal variant gives the best results, which means the kernelization algorithm is not very helpful. We think this is because a large rectangular grid graph itself is already a -kernel by the lower bound for the optimal solution [31], and the kernelization algorithm can only remove four vertices from such graphs. For the random graphs (not pictured in Figure 1), the improvement from the two heuristics is mild, but the obtained solutions are already very close to the optimal solutions, that is the differences are less than 60 vertices when the solutions have more than 190000 vertices. We also find that the post processing heuristic will not affect the running time by much, while the kernelization heuristic can increase the running time at most by a factor of 5.

Figure 1: Results of our PTAS implementation. The Y axis represents the solution size normalized by the solutions of 2-approximation algorithm. Left: solutions of the three variants of our PTAS with and the best solutions of our PTAS with largest possible values of . Right: effect of parameter on the solution sizes where X axis represents the value of .

Recall that the largest size of the decomposed graphs is the only parameter in our PTAS. Now we analyze the effect of this parameter on the performance of our PTAS. Since the optimized variant works best for most of the test graphs, we focus on its performance affected by parameter . We start with and each time increase it by 5 until our implementation cannot compute a feasible solution, which is caused by the fact that the FPT implementation cannot solve some decomposed graphs of size in the given time. The result is shown in Figure 1. We can see in the figure that our implementation can solve the instance for relatively large value of , and the solution is improved when the parameter increases. This is because when is bigger, the total size of the separators, which is the error part of our PTAS, is smaller. Since we set a time limit for the FPT implementation, the effect of parameter on the running time is not significant, although we observed a mildly increasing tendency on the running time when increases.

Now we can compare our PTAS with the 2-approximation algorithm. Based on the above results, we know the largest value of may be different for different graphs. So to get the best result, we start with and each time increase it by 5 until we cannot find feasible solution. Since different variants work best for different graph classes, we choose the best variant for each graph class, that is, we apply the minimal variant for grid graphs, and the optimized variant for other graphs. The largest value we find varies from 80 to 125 for our test graphs. The final result is plotted in Figure 1 marked as best. We can see that although our PTAS implementation is competitive with the 2-approximation algorithm on all graphs, it cannot outperform the 2-approximation solution on most road network graphs. The reason is that the subgraphs for which we can solve the problem optimally are still not large enough, which results in a fact that the separator fraction in the solution is large. On the grid graphs, the 2-approximation algorithm outperforms our PTAS by about 2 percent. On four of the five triangu graphs, our PTAS is slightly better than the 2-approximation algorithm, where the difference for each graph is less than 1 percent. While on the random graphs the improvement is mild, the final solutions are very close to the optimal. We also find the running time of our PTAS is much longer than the 2-approximation algorithm. Specifically, the running time of the 2-approximation algorithm varies from a few seconds to a few minutes for our test graphs, while our PTAS needs a few hours to finish for the large graphs, where most time is spent on running the FPT algorithm.

3.3 Heuristic Approximation Scheme

We evaluate the performance of the following two algorithms and compare them with the 2-approximation algorithm (2approx).

  • The hybrid algorithm combines the kernelization reduction rules and the greedy step of the 2approx to find a solution, and then lifts it to a minimal feasible solution for the original graph.

  • HAS first computes a solution by the hybrid algorithm and then applies the local search heuristic with an FPT algorithm to improve the solution quality.

In our following experiments, the FPT algorithm used in the local search consists of two parts: Bonamy and Kowalik’s linear kernelization algorithm and Iwata and Imanishi’s implementation, which is run for at most 15 seconds.

Before showing the final comparison of these algorithms, we first need to optimize their parameters. For the hybrid algorithm, there is a potential parameter: how often should the kernelization reduction rules be applied? We evaluated different values from 1 to 100 for this frequency parameter to understand its effect on the solution size. We find that for the road network graphs the difference is at most 0.2 percent of the solution size and for the other test graphs the difference is less than 0.01 percent. So we only consider the road network graphs to optimize this parameter. Although we did not find an optimal value for this parameter that could always give smallest solution, we can avoid some values that always give larger solutions. For this goal, we choose the frequency as 41 in our later experiments, that means we apply the reduction rules after removing 41 vertices greedily.

Figure 2: Local search improvement affected by different values of . The X axis represents the number of local search iterations and the Y axis represents the number of vertices the initial solution is improved by. Left: results for graph triangu1. Right: results for graph COL.

For the local search heuristic in HAS, the only parameter we need to optimize is the size of the random set. We choose this parameter as a fraction of the solution size for an integer , so that we only need to optimize the value of . We evaluated four different values (3, 6, 12, 30) for and terminate the process when there is no improvement for twelve consecutive search rounds. Figure 2 shows the results for two graphs. We can see in the figures that the total improvement is not always monotone with in this range. For the synthetic graphs like triangu1, the total improvement for is the largest, while for most road network graphs, the largest total improvement is obtained for . The former phenomenon can be explained by our companion work [28], which shows local search is a PTAS for FVS in minor-free graphs so the solution will be better when the size of the random set replaced is larger. However, this will not hold when the FPT algorithm cannot solve the problem in a reasonable amount of time for large random set, which corresponds to the smaller , and then the improvement will be limited. This could explain the results for the road network graphs. Moreover, while local search with larger value of tends to give better improvements, the number of local search iterations is bigger for smaller value of , which implies the improvement is consecutive and stable. Based on these observations, we will iterate through the values of in an increasing order to maximize the improvement in our later experiments, that is, we will increase the value of by 3 when there are six consecutive search rounds that find no improvement. The range of is still from 3 to 30.

To better understand the local search heuristic, we illustrate the improvement fraction and running time fraction distributed on different values of in Figure 3, where the running time is represented by the number of local search iterations. We observe that for the synthetic graphs, represented by triangu5 in the figure, the total improvement comes from the search with , while for the road network graphs, the improvement distributes on different small values of . The distribution of the running time has the similar tendency as the improvement.

We notice that the local search heuristic in HAS can give us a “PTAS behavior”, that is we can obtain better solutions if we spend more time doing so. So one natural question to ask is how long can that improvement process last? To answer this, we tried looping the values of in the range [3, 30], and found that only one iteration over the range is enough, and that additional iterations only give minor improvement.

Figure 3: Local search improvement and number of iterations distributed on different values of . The X axis is the value of . Left: the Y axis represents the fraction of total improvement. Right: the Y axis represents the fraction of the total iterations.

Now we can set the parameters and compare these algorithms. For each graph, we run HAS five times, each of which is run with a different random seed, and compute the average of the five solutions. Figure 4 illustrates the results where each solution size is normalized by the 2approx solution. We can see in the figure that for most graphs, hybrid finds better solutions than 2approx, and HAS gives the best solutions. The improvement of HAS for all road network graphs is more than 5 percent, which could be over 30000 vertices for large graphs like W. For all triangu graphs the improvement of HAS is at least 3 percent. For random graphs the improvement is not very significant, this is because the final solutions are already very close to the optimal solutions. Since the 2approx works very well on the grid graphs as shown before, it is hard to outperform it on these graphs though our heuristics is able to find competitive solutions on these graphs. Although the improvement of HAS is significant, its running time is relatively long compared with the other two algorithms. For example, both of the 2approx and hybrid can terminate in a few minutes for graph W, but HAS needs more than 35 hours to terminate for this graph. For this, people may need to balance the running time and the solution quality by setting a proper number of local search iterations.

Figure 4: Results of hybrid and HAS. The Y axis represents the solution sizes normalized by the solutions of the 2-approximation algorithms. The solution of HAS is the average over the five runs with different random seeds.

4 Conclusions

We proposed an time PTAS and a heuristic algorithm for the minimum feedback vertex set problem in planar graphs. We also evaluated their performance and compare them with the 2-approximation algorithm. Our results show that our PTAS is competitive with the 2-approximation algorithm, and our heuristic algorithm can outperform the 2-approximation on both synthetic graphs and real-world graphs. We remark that we can also obtain an time PTAS for FVS in planar graphs by applying Baker’s technique [4] for the linear kernel, but then we need to compute a branch decomposition and handle the dynamic programming in the branch decomposition as done in previous PTAS engineering works [36, 6]. It will be interesting to see if this kind of PTAS can outperform the 2-approximation and our heuristic algorithm.

Although we focus on FVS in this work, we believe the ideas behind our heuristics can also work for other problems. For example, the idea of combining reduction rules and another approximation algorithm can also be applied to other problems like dominating set and vertex cover. Similarly, our local search heuristic can also be generalized to new problems if there are FPT algorithms for them and it will be interesting to see how do they work on different problems.

References

  • [1] Lyudmil Aleksandrov, Hristo Djidjev, Hua Guo, and Anil Maheshwari. Partitioning planar graphs with costs and weights. Journal of Experimental Algorithmics (JEA), 11:1–5, 2007.
  • [2] Noga Alon, Paul Seymour, and Robin Thomas. A separator theorem for nonplanar graphs. Journal of the American Mathematical Society, 3(4):801–808, 1990.
  • [3] Vineet Bafna, Piotr Berman, and Toshihiro Fujito. A 2-approximation algorithm for the undirected feedback vertex set problem. SIAM Journal on Discrete Mathematics, 12(3):289–297, 1999.
  • [4] Brenda S Baker. Approximation algorithms for NP-complete problems on planar graphs. Journal of the ACM (JACM), 41(1):153–180, 1994. doi:10.1145/174644.174650.
  • [5] Reuven Bar-Yehuda, Dan Geiger, Joseph Naor, and Ron M Roth. Approximation algorithms for the feedback vertex set problem with applications to constraint satisfaction and bayesian inference. SIAM journal on computing, 27(4):942–959, 1998.
  • [6] Amariah Becker, Eli Fox-Epstein, Philip N Klein, and David Meierfrankenfeld. Engineering an approximation scheme for traveling salesman in planar graphs. In LIPIcs-Leibniz International Proceedings in Informatics, volume 75, 2017.
  • [7] Ann Becker and Dan Geiger. Optimization of Pearl’s method of conditioning and greedy-like approximation algorithms for the vertex feedback set problem. Artificial Intelligence, 83(1):167–188, 1996.
  • [8] Hans L Bodlaender, Fedor V Fomin, Daniel Lokshtanov, Eelko Penninkx, Saket Saurabh, and Dimitrios M Thilikos. (meta) kernelization. Journal of the ACM (JACM), 63(5):44, 2016.
  • [9] Marthe Bonamy and Łukasz Kowalik. A 13k-kernel for planar feedback vertex set via region decomposition. Theoretical Computer Science, 645:25–40, 2016.
  • [10] John M Boyer and Wendy J Myrvold. On the cutting edge: Simplified O(n) planarity by edge addition. J. Graph Algorithms Appl., 8(2):241–273, 2004.
  • [11] Lorenzo Brunetta, Francesco Maffioli, and Marco Trubian. Solving the feedback vertex set problem on undirected graphs. Discrete Applied Mathematics, 101(1-3):37–51, 2000.
  • [12] Norishige Chiba, Takao Nishizeki, and Nobuji Saito. Applications of the Lipton and Tarjan’s planar separator theorem. Journal of information processing, 4(4):203–207, 1981.
  • [13] Norishige Chiba, Takao Nishizeki, and Nobuji Saito. An approximation algorithm for the maximum independent set problem on planar graphs. SIAM Journal on Computing, 11(4):663–675, 1982.
  • [14] Fabián A Chudak, Michel X Goemans, Dorit S Hochbaum, and David P Williamson. A primal–dual interpretation of two 2-approximation algorithms for the feedback vertex set problem in undirected graphs. Operations Research Letters, 22(4-5):111–118, 1998.
  • [15] Vincent Cohen-Addad, Éric Colin de Verdière, Philip N Klein, Claire Mathieu, and David Meierfrankenfeld. Approximating connectivity domination in weighted bounded-genus graphs. In Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing, pages 584–597. ACM, 2016.
  • [16] Erik D Demaine and MohammadTaghi Hajiaghayi. Bidimensionality: New connections between FPT algorithms and PTASs. In Proceedings of the Sixteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA’05, pages 590–601, 2005.
  • [17] Camil Demetrescu, Andrew V Goldberg, and David S Johnson. Implementation challenge for shortest paths. In Encyclopedia of Algorithms, pages 1–99. Springer, 2008.
  • [18] Fedor V Fomin, Daniel Lokshtanov, Saket Saurabh, and Dimitrios M Thilikos. Bidimensionality and kernels. In Proceedings of the twenty-first annual ACM-SIAM symposium on Discrete Algorithms, pages 503–510, 2010.
  • [19] Fedor V Fomin, Daniel Lokshtanov, Saket Saurabh, and Dimitrios M Thilikos. Linear kernels for (connected) dominating set on H-minor-free graphs. In Proceedings of the twenty-third annual ACM-SIAM symposium on Discrete Algorithms, pages 82–93, 2012.
  • [20] Eli Fox-Epstein, Shay Mozes, Phitchaya Mangpo Phothilimthana, and Christian Sommer. Short and simple cycle separators in planar graphs. Journal of Experimental Algorithmics (JEA), 21:2–2, 2016.
  • [21] Martin Grohe. Local tree-width, excluded minors, and approximation algorithms. Combinatorica, 23(4):613–632, 2003.
  • [22] Martin Holzer, Frank Schulz, Dorothea Wagner, Grigorios Prasinos, and Christos Zaroliagis. Engineering planar separator algorithms. Journal of Experimental Algorithmics (JEA), 14:5, 2009.
  • [23] Yoichi Iwata. Linear-time kernelization for feedback vertex set. CoRR, 2016.
  • [24] Yoichi Iwata, Magnus Wahlström, and Yuichi Yoshida. Half-integrality, LP-branching, and FPT algorithms. SIAM Journal on Computing, 45(4):1377–1411, 2016.
  • [25] Richard M Karp. Reducibility among combinatorial problems. In Complexity of computer computations, pages 85–103. Springer, 1972.
  • [26] Jon Kleinberg and Amit Kumar. Wavelength conversion in optical networks. Journal of Algorithms, 38:25–50, 2001.
  • [27] Dexter C Kozen. The design and analysis of algorithms. Springer Science & Business Media, 2012.
  • [28] Hung Le and Baigong Zheng. Local search is a PTAS for feedback vertex set in minor-free graphs. CoRR, abs/1804.06428, 2018.
  • [29] Richard J Lipton and Robert Endre Tarjan. A separator theorem for planar graphs. SIAM Journal on Applied Mathematics, 36(2):177–189, 1979.
  • [30] Richard J Lipton and Robert Endre Tarjan. Applications of a planar separator theorem. SIAM journal on computing, 9(3):615–627, 1980.
  • [31] Flaminia L Luccio. Almost exact minimum feedback vertex set in meshes and butterflies. Inf. Process. Lett., 66(2):59–64, 1998.
  • [32] Marjan Marzban, Qian-Ping Gu, and Xiaohua Jia. Computational study on planar dominating set problem. Theoretical Computer Science, 410(52):5455–5466, 2009.
  • [33] Kurt Mehlhorn, Stefan Näher, and Christian Uhrig. The LEDA platform for combinatorial and geometric computing. In International Colloquium on Automata, Languages, and Programming, pages 7–16. Springer, 1997.
  • [34] Panos M Pardalos, Tianbing Qian, and Mauricio GC Resende. A greedy randomized adaptive search procedure for the feedback vertex set problem.

    Journal of Combinatorial Optimization

    , 2(4):399–412, 1998.
  • [35] Shao-Meng Qin and Hai-Jun Zhou. Solving the undirected feedback vertex set problem by local search. The European Physical Journal B, 87(11):273, 2014.
  • [36] Siamak Tazari and Matthias Müller-Hannemann. Dealing with large hidden constants: Engineering a planar steiner tree PTAS. Journal of Experimental Algorithmics (JEA), 16(3–6), 2011.
  • [37] Mihalis Yannakakis. Node-and edge-deletion NP-complete problems. In Proceedings of the tenth annual ACM symposium on Theory of computing, pages 253–264, 1978.
  • [38] Zhiqiang Zhang, Ansheng Ye, Xiaoqing Zhou, and Zehui Shao. An efficient local search for the feedback vertex set problem. Algorithms, 6(4):726–746, 2013.

Appendix A Omitted Proofs

Proof of Obervation 2.2.
Figure 5: Reduction rule 8 replaces the left subgraph with the right subgraph. All dashed edges are optional, and all incident edges of black vertices are drawn as solid or dashed, while the white vertices may have other edges in the graph not drawn in the figure.

Rule 8 is illustrated in Figure 5, which will not modify the size of the optimal solution. We will show the new vertex can be replaced by the vertex in the resulting graph after applying this rule. Let and be the graph before and after applying Rule 8, and let be an FVS solution for . We only need to prove the following: if , then is an FVS solution for ; otherwise is an FVS solution for .

Assume . Then we claim that any FVS solution for is also an FVS solution for . This is because we can obtain from by applying Rule 3 (that is, if a vertex has degree two and its incident edges are not parallel edges, we remove this vertex and add an edge between its two neighbors) to vertex , which will not affect the size of the optimal solution. Then we know is a forest, which implies is an FVS for .

Now assume . Then we know since there are parallel edges between and . We claim that any FVS solution for that does not contain is also an FVS for . This is because after applying Rule 3 to in the resulting graph is the same as except that the label for the vertex is in . Since , we know is an FVS for , which implies is an FVS for . ∎

We need the following lemma to prove Theorem 2.3.2.

Given any FVS solution for a linear kernel obtained by Bonamy and Kowalik’s algorithm, we can obtain an FVS solution for the original graph such that .

Proof.

We can classify the reduction rules in Bonamy and Kowalik’s kernelization algorithm into three types according to their effects on the optimal solution.

  • Do not affect the optimal solution, such as removing vertices of degree one.

  • Remove some vertices from the graph that must be in the optimal solution , such as removing vertices with self-loops.

  • Add some new vertices into the graph without changing the size of the optimal solution, such as replacing a subgraph with another subgraph that has some new vertices.

When lifting the solution of to that of , we have their corresponding effects:

  • Do not change the current solution.

  • Add some new vertices to the current solution.

  • Replace some vertices in the current solution with other vertices without increasing its size.

The rules of the third type will maintain the size of optimal solution unchanged, so we know is equal to the total number of vertices added by the second type of rules. Since the rules of the third type cannot increase the size of the solution during the lifting step, we know the size difference after applying a reverse rule of the third type is non-positive. That is, when we apply any reverse rule of the third type to a solution and obtain a new solution , we have . Let be the sum of size differences over all third type rules applied during the lifting step. Then we know is also non-positive. Note that the rules of the second type will only add vertices that is not in the kernel, so it contributes the same vertices to as to any other solution . Therefore, we know , which implies the lemma. ∎

Now we are ready to prove Theorem 2.3.2. See 2.3.2

Proof.

We first give a bound for the size of the final solution. For an integer , let be a resulting graph after the decomposition step. Note that these graphs are vertex-disjoint. Let and be an optimal solution for and respectively. We know is a solution for FVS in since is a subgraph of and is an optimal solution for . So we have and then

(1)

Let be the union of all separators found in the second step and be the size of . Recall that parameter is the largest size of . Lipton and Tarjan [30] showed that the size of is at most for some constant . If we choose , then we have

(2)

Since is the union of and for all , by combining (1) and (2), we have

Since the kernelization algorithm can only decrease the size of the optimal solution, we have . By Lemma A, we have . Then we obtain the size bound for :

Bonamy and Kowalik [9] showed that a linear kernel for planar FVS can be constructed in deterministic time. Each balanced separator can be computed in linear time by Lipton and Tarjan’s algorithm [29], so we can finish the second step in time as done in [30]. The third step can be finished in time since each subgraph has size at most . And the last step can be done in time as we described in Section 2.2. So the total running time of this algorithm is where . ∎

Appendix B Detailed Experimental Results

graph vertices edges 2approx opt approx ratio
pace1 49 107 15 15 1.0
pace2 118 179 18 18 1.0
pace3 62 78 7 7 1.0
pace4 118 179 18 18 1.0
pace5 59 104 16 16 1.0
pace6 70 85 8 8 1.0
pace7 48 64 6 6 1.0
pace8 74 92 8 8 1.0
pace9 67 83 9 8 1.125
pace10 90 103 8 7 1.143
pace11 55 81 12 11 1.091
pace12 110 147 16 15 1.067
pace13 66 127 24 21 1.143
pace14 153 177 12 12 1.0
pace15 149 193 16 16 1.0
pace16 73 95 10 10 1.0
pace17 45 64 8 8 1.0
pace18 145 186 17 16 1.063
pace19 158 189 15 15 1.0
pace20 61 78 8 7 1.143
pace21 4960 9462 898 898 1.0
grid1 450000 1796400 149527 149401 1.001
grid2 600000 2396800 199552 199468 1.001
grid3 1000000 3996000 332669 332668 1.0
grid4 1680000 6714800 559252 559134 1.001
grid5 2100000 8394200 699285 699034 1.001
random1 699970 2000000 193601 192902 1.004
random2 1197582 3000000 285550 284195 1.005
random3 1399947 4000000 387216 385813 1.004
random4 1999760 5600000 540550 538524 1.004
random6 873280 1200000 87300 86796 1.006
random7 1061980 1500000 111973 111324 1.006
random8 1227072 1700000 125374 124635 1.006
random9 1520478 2200000 167709 166737 1.006
random10 2050946 3300000 270981 269315 1.006
Table 1: Compare the 2-approximation algorithm solutions and the optimal solutions. The italic numbers are lower bounds from [31].
graph vertices edges vanilla minimal optimized best 2approx
NY 264953 366250 52487 44178 43159 42790 41709
BAY 322694 400233 41264 35518 34877 34612 34211
COL 437294 524437 45831 40142 39445 39201 39205
NW 1214463 1423402 111149 97627 95951 95362 95735
FLA 1074167 1351411 147632 128941 126869 126361 125841
CAL 1898842 2331204 230712 198924 195303 194379 192465
LKS 2763392 3407840 342592 290065 284034 282972 277196
NE 1528387 1941840 222569 188936 185115 183916 181336
E 3608115 4372928 414132 354444 347418 345891 342371
W 6286759 7608797 705851 611351 600898 598667 594943
triangu1 600000 1799963 260475 238502 235796 232695 233958
triangu2 800000 2399961 348305 318058 314257 310034 311349
triangu3 1000000 2999955 434793 396644 392045 387690 387908
triangu4 1200000 3599966 521141 474683 468072 462865 463157
triangu5 1400000 4199957 606425 551194 544006 538496 537270
random1 699970 2000000 192970 192925 192925 192907 193601
random2 1197582 3000000 284195 284195 284195 284195 285550
random3 1399947 4000000 385928 385837 385866 385818 387216
random4 1999760 5600000 538620 538556 538573 538529 540550
random5 2199977 6400000 617940 617761 617768 617681 619710
random6 873280 1200000 86796 86796 86796 86796 87300
random7 1061980 1500000 111324 111324 111324 111324 111973
random8 1227072 1700000 124635 124635 124635 124635 125374
random9 1520478 2200000 166737 166737 166737 166737 167709
random10 2050946 3300000 269315 269315 269315 269315 270981
grid1 450000 1796400 165650 156071 161462 152515 149527
grid2 600000 2396800 219589 206563 215920 205189 199552
grid3 1000000 3996000 363242 344549 360783 340078 332669
grid4 1680000 6714800 621736 585211 604861 572608 559252
grid5 2100000 8394200 760797 723507 759568 719410 699285
Table 2: Summary of the solution sizes of different PTAS variants and the 2-approximation algorithm. The results for the three variants (“vanilla”, “minimal” and “optimized”) of the PTAS are computed for . The results for “best” are computed for different values of by different variants of PTAS depending on the graphs. For grid graphs, “minimal” variant is applied for “best” results, and for other graphs “optimized” variant is applied.
graph vertices edges vanilla minimal optimized 2approx
NY 264953 366250 5m 45s 5m 39s 13m 46s 9s
BAY 322694 400233 4m 25s 4m 17s 10m 9s
COL 437294 524437 5m 8s 4m 56s 10m 46s 13s
NW 1214463 1423402 13m 21s 12m 49s 26m 2s 37s
FLA 1074167 1351411 16m 38s 16m 37s 34m 18s 33s
CAL 1898842 2331204 35m 36s 33m 2s 1h 12m 20s 58s
LKS 2763392 3407840 1h 26s 1h 1m 46s 2h 48m 44s 1m 31s
NE 1528387 1941840 41m 13s 43m 32s 1h 53m 1s 48s
E 3608115 4372928 1h 39m 17s 1h 40m 7s 3h 34m 25s 1m 52s
W 6286759 7608797 3h 44m 38s 3h 43m 26s 7h 39m 21s 3m 15s
triangu1 600000 1799963 1h 6m 23s 55m 39s 1h 56m 32s 55s
triangu2 800000 2399961 2h 28m 7s 1h 57m 15s 4h 15m 24s 1m 7s
triangu3 1000000 2999955 4h 17m 57s 3h 41m 50s 6h 47m 30s 1m 22s
triangu4 1200000 3599966 6h 42m 30s 5h 48m 12s 9h 59m 24s 1m 39s
triangu5 1400000 4199957 9h 20m 14s 8h 14m 59s 14h 16m 45s 1m 58s
random1 699970 2000000 50m 40s 53m 18s 1h 22m 10s 1m 20s
random2 1197582 3000000 1h 19m 18s 1h 22m 27s 1h 37m 57s 1m 58s
random3 1399947 4000000 2h 42m 55s 2h 25m 9s 2h 5m 3s 2m 34s
random4 1999760 5600000 4h 1m 48s 4h 30m 10s 3h 32m 19s 3m 53s
random5 2199977 6400000 4h 57m 53s 5h 38m 16s 4h 39m 10s 4m 24s
random6 873280 1200000 14m 9s 16m 8s 13m 8s 58s
random7 1061980 1500000 19m 54s 22m 33s 18m 10s 1m 5s
random8 1227072 1700000 21m 44s 24m 29s 19m 41s 1m 14s
random9 1520478 2200000 30m 52s 35m 13s 28m 9s 1m 33s
random10 2050946 3300000 1h 1m 1h 10m 29s 55m 41s 2m 20s
grid1 450000 1796400 25m 41s 24m 28s 1h 13m 18s 24s
grid2 600000 2396800 35m 24s 34m 48s 1h 58m 24s 29s
grid3 1000000 3996000 1h 11m 9s 1h 6m 49s 4h 56m 29s 48s
grid4 1680000 6714800 2h 56m 47s 2h 18m 7s 10h 7m 46s 1m 25s
grid5 2100000 8394200 3h 48m 16s 3h 0m 23s 15h 1m 48s 1m 44s
Table 3: Summary of the running time of different variants of our PTAS. The parameter is set as 60 for all PTAS variants.
graph vertices edges 2approx hybrid HAS (avg) HAS (min) improv
NY 264953 366250 41709 40868 39582 39537 0.051
BAY 322694 400233 34211 33372 32492 32446 0.050
COL 437294 524437 39205 38141 37167 37141 0.052
NW 1214463 1423402 95735 93272 90844 90816 0.051
FLA 1074167 1351411 125841 122521 119211 119163 0.053
CAL 1898842 2331204 192465 187610 182282 182191 0.053
LKS 2763392 3407840 277196 270651 262041 261917 0.055
NE 1528387 1941840 181336 177101 171742 171619 0.053
E 3608115 4372928 342371 333997 324286 324056 0.053
W 6286759 7608797 594943 579822 562687 562606 0.054
triangu1 600000 1799963 233958 228711 225802 225791 0.035
triangu2 800000 2399961 311349 304288 300443 300430 0.035
triangu3 1000000 2999955 387908 379251 374485 374468 0.035
triangu4 1200000 3599966 463157 452692 447236 447206 0.034
triangu5 1400000 4199957 537270 525416 519361 519229 0.033
random1 699970 2000000 193601 193071 192908 192904 0.004
random2 1197582 3000000 285550 284340 284198 284195 0.005
random3 1399947 4000000 387216 386095 385818 385815 0.004
random4 1999760 5600000 540550 538958 538533 538526 0.004
random5 2199977 6400000 619710 618238 617674 617671 0.003
random6 873280 1200000 87300 86809 86802 86796 0.006
random7 1061980 1500000 111973 111343 111326 111324 0.006
random8 1227072 1700000 125374 124655 124641 124636 0.006
random9 1520478 2200000 167709 166762 166739 166739 0.006
random10 2050946 3300000 270981 269378 269319 269318 0.006
grid1 450000 1796400 149527 149511 149511 149511 0.001
grid2 600000 2396800 199552 199506 199506 199506 0.001
grid3 1000000 3996000 332669 332847 332847 332847 -0.001
grid4 1680000 6714800 559252 559298 559298 559298 -0.001
grid5 2100000 8394200 699285 699195 699195 699195 0.001
Table 4: Summary of the solution sizes of different heuristic algorithms. HAS (avg) is the solution size averaged over five runs of HAS with different random seeds. HAS (min) is the minimum size among the five values. The improv value is computed as 1-HAS(avg)/2approx.
graph vertices edges 2approx hybrid HAS (avg) HAS (min)
NY 264953 366250 9s 1m 28s 1h 6m 30s 1h 12m 33s
BAY 322694 400233 9s 1m 9s 54m 53s 1h 8m 2s
COL 437294 524437 13s 1m 19s 51m 22s 1h 10m 49s
NW 1214463 1423402 37s 3m 28s 2h 18m 40s 2h 24m 32s
FLA 1074167 1351411 33s 4m 12s 3h 57m 25s 4h 7m 32s
CAL 1898842 2331204 58s 7m 32s 6h 10m 28s 6h 12m 30s
LKS 2763392 3407840 1m 31s 11m 38s 13h 21m 22s 14h 35m 33s
NE 1528387 1941840 48s 7m 10s 5h 52m 16s 6h 49m 51s
E 3608115 4372928 1m 52s 14m 23s 16h 49m 22s 16h 27m 17s
W 6286759 7608797 3m 15s 23m 46s 35h 41m 39s 38h 10m 5s
triangu1 600000 1799963 55s 1m 46s 1h 32m 37s 1h 39m 7s
triangu2 800000 2399961 1m 7s 1m 58s 2h 11m 39s 2h 35m
triangu3 1000000 2999955 1m 22s 2m 20s 2h 33m 5s 2h 42m 50s
triangu4 1200000 3599966 1m 39s 2m 55s 3h 15m 9s 3h 54m 12s
triangu5 1400000 4199957 1m 58s 3m 30s 4h 38m 3h 23m 16s
random1 699970 2000000 1m 20s 1m 54s 6m 54s 7m 31s
random2 1197582 3000000 1m 58s 2m 26s 7m 47s 8m 57s
random3 1399947 4000000 2m 34s 3m 31s 15m 5s 15m 24s
random4 1999760 5600000 3m 53s 5m 12s 21m 2s 21m 53s
random5 2199977 6400000 4m 24s 5m 58s 30m 15s 32m 43s
random6 873280 1200000 58s 1m 17s 1m 45s 2m 12s
random7 1061980 1500000 1m 5s 1m 31s 2m 4s 1m 55s
random8 1227072 1700000 1m 14s 1m 42s 2m 25s 2m 13s
random9 1520478 2200000 1m 33s 2m 17s 3m 17s 3m 18s
random10 2050946 3300000 2m 20s 3m 29s 5m 10s 5m 56s
grid1 450000 1796400 24s 3m 49s 1h 1m 16s 1h 2m 26s
grid2 600000 2396800 29s 5m 19s 1h 18m 18s 1h 18m 54s
grid3 1000000 3996000 48s 8m 48s 1h 55m 10s 1h 56m 43s
grid4 1680000 6714800 1m 25s 14m 47s 3h 1m 44s 3h 4m 5s
grid5 2100000 8394200 1m 44s 17m 44s 3h 52m 47s 3h 42m 23s
Table 5: Summary of the running time of different heuristic algorithms. HAS (avg) is the running time averaged over five runs of HAS with different random seeds. HAS (min) is the running time for the HAS run with minimum solution size.