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 
and has applications in different areas, such as deadlock recovery in operating systems and reducing computation in Bayesian inference. The current best approximation ratio for FVS in general graphs is 2 due to Becker and Geiger  and Bafna, Berman and Fujito , both of which could also work for the vertex-weighted version of FVS. Chudak et al.  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 , 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  gave the first PTAS for FVS in planar graphs. Demaine and Hajiaghayi  gave a different PTAS for FVS in single-crossing-minor-free graphs through their bidimensionality theory. Cohen-Addad et al.  gave a PTAS for the vertex-weighted version of this problem in bounded-genus graphs. In our companion work , 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.  developed a greedy randomized adaptive search procedure for FVS, Brunetta et al.  proposed a system based on local search and a branch-and-cut algorithm, Zhang et al.  presented a variable depth-based local search algorithm with a randomized scheme, and Qin and Zhou  introduced a simulated annealing local search algorithm for FVS. However, all of these works focus on general graphs. Brunetta et al.  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 , the Steiner tree problem  and the traveling salesman problem (TSP)  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  as our baseline, which is simpler than the algorithm of Bafna, Berman and Fujito . 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  and the minimum vertex cover problem  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 . 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 , 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 , Bonamy and Kowalik’s linear kernel  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  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  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 . 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  for full details of the reduction rules.
We remark that in the original paper , 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  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:
if there is any BFS level satisfying the requirements, then it is returned as a result;
if there is no such level, then the algorithm tries to find two BFS levels that can form a balanced separator together;
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  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  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:
Compute a linear kernel for the original graph , that is, is at most for some constant .
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.
Solve the problem optimally for all the resulting graphs.
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.
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:
Compute a temporary solution by repeating the following two steps until the graph is empty.
Apply reduction rules from the kernelization algorithm in order until there are no applicable rules.
Remove a vertex of highest degree from the graph and add it into the temporary solution.
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 , 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.
Select a subset of size from randomly.
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 .
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 . 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  and a branch-and-bound based FPT algorithm  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) ;
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 . 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 , 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  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 , 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.
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.
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 , 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.
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.
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  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.
-  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.
-  Noga Alon, Paul Seymour, and Robin Thomas. A separator theorem for nonplanar graphs. Journal of the American Mathematical Society, 3(4):801–808, 1990.
-  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.
-  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.
-  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.
-  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.
-  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.
-  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.
-  Marthe Bonamy and Łukasz Kowalik. A 13k-kernel for planar feedback vertex set via region decomposition. Theoretical Computer Science, 645:25–40, 2016.
-  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.
-  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.
-  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.
-  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.
-  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.
-  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.
-  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.
-  Camil Demetrescu, Andrew V Goldberg, and David S Johnson. Implementation challenge for shortest paths. In Encyclopedia of Algorithms, pages 1–99. Springer, 2008.
-  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.
-  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.
-  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.
-  Martin Grohe. Local tree-width, excluded minors, and approximation algorithms. Combinatorica, 23(4):613–632, 2003.
-  Martin Holzer, Frank Schulz, Dorothea Wagner, Grigorios Prasinos, and Christos Zaroliagis. Engineering planar separator algorithms. Journal of Experimental Algorithmics (JEA), 14:5, 2009.
-  Yoichi Iwata. Linear-time kernelization for feedback vertex set. CoRR, 2016.
-  Yoichi Iwata, Magnus Wahlström, and Yuichi Yoshida. Half-integrality, LP-branching, and FPT algorithms. SIAM Journal on Computing, 45(4):1377–1411, 2016.
-  Richard M Karp. Reducibility among combinatorial problems. In Complexity of computer computations, pages 85–103. Springer, 1972.
-  Jon Kleinberg and Amit Kumar. Wavelength conversion in optical networks. Journal of Algorithms, 38:25–50, 2001.
-  Dexter C Kozen. The design and analysis of algorithms. Springer Science & Business Media, 2012.
-  Hung Le and Baigong Zheng. Local search is a PTAS for feedback vertex set in minor-free graphs. CoRR, abs/1804.06428, 2018.
-  Richard J Lipton and Robert Endre Tarjan. A separator theorem for planar graphs. SIAM Journal on Applied Mathematics, 36(2):177–189, 1979.
-  Richard J Lipton and Robert Endre Tarjan. Applications of a planar separator theorem. SIAM journal on computing, 9(3):615–627, 1980.
-  Flaminia L Luccio. Almost exact minimum feedback vertex set in meshes and butterflies. Inf. Process. Lett., 66(2):59–64, 1998.
-  Marjan Marzban, Qian-Ping Gu, and Xiaohua Jia. Computational study on planar dominating set problem. Theoretical Computer Science, 410(52):5455–5466, 2009.
-  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.
Panos M Pardalos, Tianbing Qian, and Mauricio GC Resende.
A greedy randomized adaptive search procedure for the feedback vertex
Journal of Combinatorial Optimization, 2(4):399–412, 1998.
-  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.
-  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.
-  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.
-  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.
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 .
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. ∎
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
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  showed that the size of is at most for some constant . If we choose , then 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  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 , so we can finish the second step in time as done in . 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
|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|
|graph||vertices||edges||2approx||hybrid||HAS (avg)||HAS (min)||improv|
|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|