Improved Analysis of Highest-Degree Branching for Feedback Vertex Set

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.


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 k; i.e., we can find a deletion set of size k in O * (f (k)) 1 time for some function f . 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 [3,4,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 O * (3.619 k ) time. When allowing randomization, the current fastest one is a cut-and-count dynamic programming algorithm [5] which runs in O * (3 k ) time. In this paper, we give a faster deterministic algorithm which runs in O * (3.460 k ) 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. * Supported by JSPS KAKENHI Grant Number JP17K12643 † Supported by JSPS KAKENHI Grant Numbers JP16K16010, 17K19960, and 18H05291 1 O * (·) hides factors polynomial in n. Note that for FVS, any O(f (k)n O(1) )-time FPT algorithms can be improved to O(f (k)k O(1) + k O(1) n) time by applying a linear-time kernel [10] as a preprocess. We can therefore focus only on the f (k) factor when comparing the running time.
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 highestdegree 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: 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 highestdegree branching slightly outperforms the others. Cao [2] showed that one can stop the highestdegree branching at depth 3k by using a degree-based argument, and therefore the running time is O(8 k ). On the other hand, the theoretically proved running time of other branching algorithms (without the degree-based pruning) are, O * (4 k ) for the LP-guided branching [11] and O * (3.619 k ) 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 k 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 O * (4 k )-time upper bound which significantly improves the O * (8 k )-time upper bound obtained by Cao [2]. We then apply the measure-and-conquer analysis [8] and improve the upper bound to O * (3.460 k ).

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 https://github.com/wata-orz/FVS_analysis.

Algorithm
An input to the algorithm is a tuple (G, F, k) of a multi-graph G = (V, E), a set of undeletable vertices F ⊆ V , and an integer k. Our task is to find a subset of vertices S ⊆ V \F such that |S| ≤ k and G[V \ S] contains no cycles. Note that a double edge is also considered as a cycle. We denote by N (u) the multiset of the adjacent vertices of u and define d(u) := |N (u)|. For convenience, we use D to denote max v∈V \F d(v).
Our algorithm uses the standard reduction rules listed below in the given order (i.e., rule i is applied only when none of the rules j with j < i 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 u of degree at most one, delete u.
Reduction Rule 2. If there exists a vertex u ∈ F such that G[F ∪ {u}] contains a cycle, delete u and decrease k by one.
Reduction Rule 3. If there exists a vertex u of degree two, delete u and add an edge connecting its two endpoints.
Reduction Rule 4. If there exists an edge e of multiplicity more than two, reduce its multiplicity to two.
Reduction Rule 5. If there exists a vertex u ∈ F incident to a double edge uw with d(w) ≤ 3, delete u and decrease k by one.
Reduction Rule 6. If D ≤ 3, solve the problem in polynomial time by a reduction to the matroid matching [3].
Branching Rule. Pick a vertex u ∈ V \ F of the highest degree D. Let U := N (u) ∩ F and let G ′ be the graph obtained by contracting U ∪ {u} into a single vertex u ′ . We branch into two cases: 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 uw, any feedback vertex set must contain at least one of u and w. Because w has at most one edge other than the double edge uw, every cycle containing w also contains u. Therefore, there always exists a minimum feedback vertex set containing u.
After applying the reductions, the following conditions hold.
1. G has the minimum degree at least three.

No double edges are incident to F .
3. For any vertex v ∈ F , G − v has the minimum degree at least two.

D ≥ 4.
The correctness of the pruning rule follows from the following lemma.

Lemma 2. If the minimum degree of G is at least two and kD
Proof. Suppose that there is a feedback vertex set S ⊆ V \ F of size at most k. We have Because G − S 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.
We now show that applying the reduction rules does not increase µ. We can easily see that D never increases by the reduction but may decrease; however, because such decrease leads to a smaller µ, we can analyze as if D 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 F , 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 µ.
Proof. By deleting an edge vw such that v ∈ F and w ∈ F , µ increases by at most In the series of the reductions, the number of such deletion is at most d(u) ≤ D. Because k decreases by one, the increase of µ is at most −1 + D × 1 D ≤ 0. Finally, we analyze the branching rule. Let f := |U | and d := {d 1 , . . . , d f } be the multiset of degrees of vertices in U . The degree of u ′ is d ′ : . In the former case of the branching, we have In the latter case, we have If c −∆ 1 (D,d) + c −∆ 2 (D,d) ≤ 1 holds for any (D, d) for some c > 1, the running time of the algorithm is bounded by O * (c k ). We now optimize the parameters to minimize c.

Simple Analysis
As a simple analysis whose correctness can be easily checked, we use α = log 4 8 3 ≈ 0.7075, β d = 1 2 log 4 3 2 ≈ 0.1462 for all d ≥ 3, and c = 4. Note that D ≥ 4 holds. For these parameters, we have We now show that c −∆ 1 (D,d) + c −∆ 2 (D,d) ≤ 1 holds by the following case analysis.

Measure-and-Conquer Analysis
We use the parameters α = 0.922863, β shown in Table 1, and c = 3.460.  (D, d). Therefore, we can focus on the case of d i ≤ 31 for all i. We now show that the inequality holds by induction on D. When D = 4, we can verify that c −∆ 1 (4,d) + c −∆ 2 (4,d) ≤ 1 (∀d) (1) holds by naively enumerating all the possible configurations of d. Assume that, for a fixed D, the inequality holds for any (D − 1, d). We show that the inequality also holds for any (D, d).
When f < D, we have and . We can verify that our parameters satisfy Therefore, we have ∆ 2 (D, d) ≥ ∆ 2 (D − 1, d). This shows that When f = D, let d ′ := {d 1 , . . . , d f −1 }. We have and Because we can verify that our parameters satisfy we have ∆ 2 (D, d) ≥ ∆ 2 (D − 1, d ′ ). This shows that