Feedback Vertex Set (FVS) is a classical NP-hard graph optimization problem of finding the minimum-size vertex deletion set to make the input graph a forest. It is known that this problem is fixed-parameter tractable (FPT) parameterized by the solution size ; i.e., we can find a deletion set of size in 111 hides factors polynomial in . Note that for FVS, any -time FPT algorithms can be improved to time by applying a linear-time kernel  as a preprocess. We can therefore focus only on the factor when comparing the running time. time for some function . FVS is one of the most comprehensively studied problems in the field of parameterized algorithms, and various FPT algorithms using different approaches have been developed, including short-cycle branching , highest-degree branching , iterative-compression branching [4, 3, 14], LP-guided branching [11, 12], cut-and-count dynamic programming , and random sampling .
The current fastest deterministic FPT algorithm for FVS is a branching algorithm combined with the iterative compression technique  which runs in time. When allowing randomization, the current fastest one is a cut-and-count dynamic programming algorithm  which runs in time. In this paper, we give a faster deterministic algorithm which runs in time. As explained below, this study is strongly motivated by Parameterized Algorithms and Computational Experiments (PACE) challenge and its follow-up empirical evaluation by Kiljan and Pilipczuk . Instead of designing a new theoretically fast algorithm, we analyze the theoretical worst-case running time of the empirically fast algorithm that has been developed through the PACE challenge and the empirical evaluation, and we show that this algorithm is not only empirically fast but also theoretically fast.
PACE challenge is an annual programming challenge started in 2016. Due to its importance in the field, FVS was selected as the subject of track B in the first PACE challenge . Although in theoretical studies, the current fastest algorithm is the randomized cut-and-count dynamic programming, the result of the challenge suggests that branching is the best choice in practice. This is not so surprising; because the theoretical analysis of branching algorithms is difficult, the proved upper bound of the running time is rather pessimistic.
Among seven submissions to the PACE challenge, top six submissions used branching algorithms; the first used the LP-guided branching; the second and third used branching on highest-degree vertices; the fourth and sixth used branching combined with iterative compression; and the fifth used branching on short cycles. In addition to the pruning by the LP lower bound, the first-place solver by Imanishi and Iwata  used the following degree-based pruning heuristic:
Lemma 1 ().
Given a set of undeletable vertices , let be the vertices of in the non-decreasing order of the degrees in . If holds, there is no feedback vertex set of size .
The follow-up empirical evaluation  shows that the use of the degree-based pruning is much more important than the choice of branching rules. By combining with the degree-based pruning, the performances of the LP-guided branching , the highest-degree branching , and the iterative-compression branching , are all significantly improved, and among them, the highest-degree branching slightly outperforms the others. Cao  showed that one can stop the highest-degree branching at depth by using a degree-based argument, and therefore the running time is . On the other hand, the theoretically proved running time of other branching algorithms (without the degree-based pruning) are, for the LP-guided branching  and for the iterative-compression branching . These affairs motivated us to refine the analysis of the highest-degree branching with the degree-based pruning.
In our analysis, instead of bounding the depth of the search tree as Cao  did, we design a new measure to bound the size of the search tree. The measure is initially at most and we show that the measure drops by some amount for each branching. In contrast to the standard analysis of branching algorithms, our measure has a negative term and thus can have negative values; however, we show that we can immediately apply the degree-based pruning for all such cases. A simple analysis already leads to an -time upper bound which significantly improves the -time upper bound obtained by Cao . We then apply the measure-and-conquer analysis  and improve the upper bound to .
Section 2 describes the highest-degree branching algorithm with the degree-based pruning. In Section 3, we analyze the running time of the algorithm. We first give a simple analysis in Section 3.1 and then give a measure-and-conquer analysis in Section 3.2. While the correctness of the simple analysis can be easily checked, we need to evaluate thousands of inequalities to check the correctness of the measure-and-conquer analysis. For convenience, we attach a source code of the program to evaluate the inequalities in Appendix A. The same source code is also available at https://github.com/wata-orz/FVS_analysis.
An input to the algorithm is a tuple of a multi-graph , a set of undeletable vertices , and an integer . Our task is to find a subset of vertices such that and contains no cycles. Note that a double edge is also considered as a cycle. We denote by the multiset of the adjacent vertices of and define . For convenience, we use to denote .
Our algorithm uses the standard reduction rules listed below in the given order (i.e., rule is applied only when none of the rules with are applicable). All of these reductions are also used in the empirical evaluation by Kiljan and Pilipczuk . If none of the reductions are applicable, we apply a pruning rule, and if it cannot be pruned, we apply a branching rule.
Reduction Rule 1.
If there exists a vertex of degree at most one, delete .
Reduction Rule 2.
If there exists a vertex such that contains a cycle, delete and decrease by one.
Reduction Rule 3.
If there exists a vertex of degree two, delete and add an edge connecting its two endpoints.
Reduction Rule 4.
If there exists an edge of multiplicity more than two, reduce its multiplicity to two.
Reduction Rule 5.
If there exists a vertex incident to a double edge with , delete and decrease by one.
Reduction Rule 6.
If , solve the problem in polynomial time by a reduction to the matroid matching .
If or , return NO.
Pick a vertex of the highest degree . Let and let be the graph obtained by contracting into a single vertex . We branch into two cases: and .
The correctness of the first four reduction rules is trivial. We can prove the correctness of the reduction rule 5 as follows. Because there is a double edge , any feedback vertex set must contain at least one of and . Because has at most one edge other than the double edge , every cycle containing also contains . Therefore, there always exists a minimum feedback vertex set containing .
After applying the reductions, the following conditions hold.
has the minimum degree at least three.
No double edges are incident to .
For any vertex , has the minimum degree at least two.
The correctness of the pruning rule follows from the following lemma.
If the minimum degree of is at least two and holds, there is no feedback vertex set of size at most .
Suppose that there is a feedback vertex set of size at most . We have
Because is a forest, this must be non-negative. ∎
Note that this pruning is different from the degree-based pruning (Lemma 1) used in the Imanishi-Iwata solver  and the empirical evaluation ; however, as the following lemma shows, if this pruning is applied, then the original degree-based pruning is also applied. Therefore, we can use the same analysis against the original degree-based pruning. We use this weaker version because it is sufficient for our analysis. We leave whether the stronger version helps further improve the analysis as future work.
For a subset , let be the vertices of in the non-increasing order of the degrees in . If the minimum degree of is at least two, implies .
Let and assume that . Then, we have
For parameters and satisfying , we define
Initially, we have .
After the pruning, we have .
We now show that applying the reduction rules does not increase . We can easily see that never increases by the reduction but may decrease; however, because such decrease leads to a smaller , we can analyze as if does not change by the reduction. Because the reduction rule 3 deletes a vertex of degree two and does not change the degrees of other vertices, it does not change . Because the reduction rule 4 is applied only when the reduction rule 2 cannot be applied, it does not change the degrees of vertices in , and therefore it does not change . Because the graph immediately after branching has the minimum degree at least two, we apply the reduction rule 1 only after applying the reduction rules 2 or 5.
The reduction rule 2 or 5, together with the subsequent applications of the reduction rule 1, does not increase .
By deleting an edge such that and , increases by at most
In the series of the reductions, the number of such deletion is at most . Because decreases by one, the increase of is at most . ∎
Finally, we analyze the branching rule. Let and be the multiset of degrees of vertices in . The degree of is . In the former case of the branching, we have
In the latter case, we have
If holds for any for some , the running time of the algorithm is bounded by . We now optimize the parameters to minimize .
3.1 Simple Analysis
As a simple analysis whose correctness can be easily checked, we use , for all , and . Note that holds. For these parameters, we have
We now show that holds by the following case analysis.
3.2 Measure-and-Conquer Analysis
We use the parameters , shown in Table 1, and .
holds for any with .
Suppose that holds for some . Because for all and because holds, decreasing by one does not change nor . Therefore, we can focus on the case of for all . We now show that the inequality holds by induction on . When , we can verify that
holds by naively enumerating all the possible configurations of . Assume that, for a fixed , the inequality holds for any . We show that the inequality also holds for any .
When , we have
where . We can verify that our parameters satisfy
Therefore, we have . This shows that
When , let . We have
Because we can verify that our parameters satisfy
we have . This shows that
We would like to thank Yixin Cao for valuable discussions and thank organizers of PACE challenge 2016 for motivating us to study FVS.
-  Ann Becker, Reuven Bar-Yehuda, and Dan Geiger. Randomized algorithms for the loop cutset problem. J. Artif. Intell. Res., 12:219–234, 2000.
-  Yixin Cao. A naive algorithm for feedback vertex set. In SOSA 2018, pages 1:1–1:9, 2018.
-  Yixin Cao, Jianer Chen, and Yang Liu. On feedback vertex set: New measure and new structures. Algorithmica, 73(1):63–86, 2015.
-  Jianer Chen, Fedor V. Fomin, Yang Liu, Songjian Lu, and Yngve Villanger. Improved algorithms for feedback vertex set problems. J. Comput. Syst. Sci., 74(7):1188–1198, 2008.
-  Marek Cygan, Jesper Nederlof, Marcin Pilipczuk, Michal Pilipczuk, Johan M. M. van Rooij, and Jakub Onufry Wojtaszczyk. Solving connectivity problems parameterized by treewidth in single exponential time. In FOCS 2011, pages 150–159, 2011.
-  Holger Dell, Thore Husfeldt, Bart M. P. Jansen, Petteri Kaski, Christian Komusiewicz, and Frances A. Rosamond. The first parameterized algorithms and computational experiments challenge. In IPEC 2016, pages 30:1–30:9, 2016.
-  Rodney G. Downey and Michael R. Fellows. Fixed parameter tractability and completeness. In Complexity Theory: Current Research, pages 191–225, 1992.
-  Fedor V. Fomin, Fabrizio Grandoni, and Dieter Kratsch. A measure & conquer approach for the analysis of exact algorithms. J. ACM, 56(5):25:1–25:32, 2009.
-  Kensuke Imanishi and Yoichi Iwata. Feedback vertex set solver, 2016. Entry to PACE challenge 2016. URL: http://github.com/wata-orz/fvs.
-  Yoichi Iwata. Linear-time kernelization for feedback vertex set. In 44th International Colloquium on Automata, Languages, and Programming, ICALP 2017, July 10-14, 2017, Warsaw, Poland, pages 68:1–68:14, 2017.
-  Yoichi Iwata, Magnus Wahlström, and Yuichi Yoshida. Half-integrality, LP-branching and FPT algorithms. SIAM J. Comput., 45(4):1377–1411, 2016.
-  Yoichi Iwata, Yutaro Yamaguchi, and Yuichi Yoshida. 0/1/all CSPs, half-integral A-path packing, and linear-time FPT algorithms. In FOCS 2018, pages 462–473, 2018.
-  Krzysztof Kiljan and Marcin Pilipczuk. Experimental evaluation of parameterized algorithms for feedback vertex set. In SEA 2018, pages 12:1–12:12, 2018.
-  Tomasz Kociumaka and Marcin Pilipczuk. Faster deterministic feedback vertex set. Inf. Process. Lett., 114(10):556–560, 2014.