Improved Analysis of Highest-Degree Branching for Feedback Vertex Set

05/29/2019 ∙ by Yoichi Iwata, et al. ∙ Kyoto University 0

Recent empirical evaluations of exact algorithms for Feedback Vertex Set have demonstrated the efficiency of a highest-degree branching algorithm with a degree-based pruning heuristic. In this paper, we prove that this empirically fast algorithm runs in O(3.460^k n) time, where k is the solution size. This improves the previous best O(3.619^k n)-time deterministic algorithm obtained by Kociumaka and Pilipczuk.



There are no comments yet.


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

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 [10] 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 [7], highest-degree branching [2], iterative-compression branching [4, 3, 14], LP-guided branching [11, 12], cut-and-count dynamic programming [5], and random sampling [1].

The current fastest deterministic FPT algorithm for FVS is a branching algorithm combined with the iterative compression technique [14] which runs in time. When allowing randomization, the current fastest one is a cut-and-count dynamic programming algorithm [5] 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 [13]. 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 [6]. 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 [9] used the following degree-based pruning heuristic:

Lemma 1 ([9]).

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 [13] 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 [11], the highest-degree branching [2], and the iterative-compression branching [14], are all significantly improved, and among them, the highest-degree branching slightly outperforms the others. Cao [2] 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 [11] and for the iterative-compression branching [14]. 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 [2] 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 [2]. We then apply the measure-and-conquer analysis [8] and improve the upper bound to .

1.1 Organization

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

2 Algorithm

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 [13]. 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 [3].

Pruning Rule.

If or , return NO.

Branching Rule.

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.

  1. has the minimum degree at least three.

  2. No double edges are incident to .

  3. For any vertex , has the minimum degree at least two.

  4. .

The correctness of the pruning rule follows from the following lemma.

Lemma 2.

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 [9] and the empirical evaluation [13]; 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.

Lemma 3.

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

3 Analysis

For parameters and satisfying , we define

Initially, we have .

Lemma 4.

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.

Lemma 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 .

1 0.000000
2 0.000000
3 0.114038
4 0.186479
5 0.238143
6 0.277239
7 0.308030
8 0.332974
9 0.353536
10 0.370540
11 0.384771
12 0.396884
13 0.408715
14 0.418855
15 0.427643
16 0.435333
17 0.442118
18 0.448149
19 0.453544
20 0.458401
21 0.462794
22 0.466788
23 0.470435
24 0.473778
25 0.476853
26 0.479691
27 0.482320
28 0.484760
29 0.487032
Table 1: The values of .
Lemma 6.

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.


  • [1] Ann Becker, Reuven Bar-Yehuda, and Dan Geiger. Randomized algorithms for the loop cutset problem. J. Artif. Intell. Res., 12:219–234, 2000.
  • [2] Yixin Cao. A naive algorithm for feedback vertex set. In SOSA 2018, pages 1:1–1:9, 2018.
  • [3] Yixin Cao, Jianer Chen, and Yang Liu. On feedback vertex set: New measure and new structures. Algorithmica, 73(1):63–86, 2015.
  • [4] 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.
  • [5] 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.
  • [6] 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.
  • [7] Rodney G. Downey and Michael R. Fellows. Fixed parameter tractability and completeness. In Complexity Theory: Current Research, pages 191–225, 1992.
  • [8] 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.
  • [9] Kensuke Imanishi and Yoichi Iwata. Feedback vertex set solver, 2016. Entry to PACE challenge 2016. URL:
  • [10] 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.
  • [11] Yoichi Iwata, Magnus Wahlström, and Yuichi Yoshida. Half-integrality, LP-branching and FPT algorithms. SIAM J. Comput., 45(4):1377–1411, 2016.
  • [12] 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.
  • [13] Krzysztof Kiljan and Marcin Pilipczuk. Experimental evaluation of parameterized algorithms for feedback vertex set. In SEA 2018, pages 12:1–12:12, 2018.
  • [14] Tomasz Kociumaka and Marcin Pilipczuk. Faster deterministic feedback vertex set. Inf. Process. Lett., 114(10):556–560, 2014.

Appendix A Program to check Lemma 6

We attach a source code of a python3 program to evaluate the inequalities (1)–(3) appeared in the proof of Lemma 6. The same source code is also available at

#!/usr/bin/env python3
a = 0.922863
b = [0.0, 0.0, 0.0, 0.114038, 0.186479, 0.238143, 0.277239, 0.308030, 0.332974,
  0.353536, 0.370540, 0.384771, 0.396884, 0.408715, 0.418855, 0.427643, 0.435333,
  0.442118, 0.448149, 0.453544, 0.458401, 0.462794, 0.466788, 0.470435, 0.473778,
  0.476853, 0.479691, 0.482320, 0.484760, 0.487032, 0.489153, 0.489153]
c = 3.460
eps = 1e-7 # for avoiding rounding errors
# enumerate all d
def all_d(d, i, d_min):
    yield d
    if i < 4:
        for di in range(d_min, 32):
            yield from all_d(d + [di], i + 1, di)
# inequality (1)
for d in all_d([], 0, 3):
    f = len(d)
    d_prime = 4 + sum(d) - 2 * f
    delta1 = 1 - f * a / 4 + sum(map(lambda di: b[di] - b[di-1], d))
    delta2 = a - 2 * a / 4 + sum(map(lambda di: b[di], d)) - b[min(30, d_prime)]
    assert(c**(-delta1) + c**(-delta2) <= 1 - eps)
# inequality (2)
for D in range(5, 32):
    for d_prime in range(D, 32):
        assert(-2 * a / D - b[d_prime] + 2 * a / (D - 1) + b[d_prime - 1] >= eps)
# inequality (3)
for d_f in range(3, 32):
    for d_prime in range(d_f+1, 32):
        assert(b[d_f] - b[d_prime] + b[d_prime - d_f + 2] >= eps)
print(”all the inequalities are satisfied”)