An Improved Exact Algorithm for Undirected Feedback Vertex Set

Noname manuscript No. (will be inserted by the editor)

An Improved Exact Algorithm for Undirected Feedback Vertex Set Mingyu Xiao · Hiroshi Nagamochi

Received: date / Accepted: date

Abstract A feedback vertex set in an undirected graph is a subset of vertices removal of which leaves a graph with no cycles. Razgon (SWAT 2006) gave a 1.8899n nO(1) -time algorithm for finding a minimum feedback vertex set in an n-vertex undirected graph, which is the first exact algorithm for the problem that breaks the trivial barrier of 2n . Later, Fomin et al. (Algorithmica 2008) improved the result to 1.7548n nO(1) . In this paper, we further improve the result to 1.7266n nO(1) . Our algorithm is analyzed by the measure-and-conquer method. We get the improvement by designing new reductions based on biconnectivity of instances and introducing a new measure scheme on the structure of reduced graphs. Keywords Exact Exponential Algorithms · Feedback Vertex Set · Measure and Conquer · Branch and Bound

1 Introduction There are many practical problems that require us to find a minimum number of vertices or edges in a graph that intersect all cycles in the graph. An example Supported by NFSC of China under the Grant 61370071 and Fundamental Research Funds for the Central Universities under the Grant ZYGX2012J069. M. Xiao School of Computer Science and Engineering, University of Electronic Science and Technology of China, Chengdu 611731, China Tel.: +86-15397626165 Fax: +86-28-61831656 E-mail: [email protected] H. Nagamochi Department of Applied Mathematics and Physics, Graduate School of Informatics, Kyoto University, Yoshida Honmachi, Sakyo, Kyoto 606-8501, Japan E-mail: [email protected]

2

Mingyu Xiao, Hiroshi Nagamochi

is the deadlock recovery problem in concurrent programs [15], which has applications in operating system, computer architecture communities, database system and so on. In this problem, the system is represented by a resource allocation graph (RAG) with vertices being processed and a deadlock in the system is represented by a cycle in RAG. We need to abort a set of processes in the system to recover it from deadlocks. The set of processes corresponds to a minimum set of vertices in RAG intersecting all cycles. Another well-known application is the rank aggregation problem [7, 14], in which we are asked to find out a ranking that minimizes the number of pairs that occur in a different order in the outcome ranking, i.e., to delete a minimum number of arcs in a directed graph so that all cycles in the graph are broken. Some other applications are also mentioned in the literature [5,9, 10]. The above kinds of problems of destroying cycles in graphs are known as feedback set problems. They have been systematically studied in both practice and theory due to their importance. According to the graph being directed or undirected, and the elements to be deleted being vertices or edges, we can define four different versions of the problem: Directed Feedback Vertex Set (DFVS), Undirected Feedback Vertex Set (UFVS), Directed Feedback Arc Set (DFAS) and Undirected Feedback Edge Set (UFES). Among these, UFES is polynomial-time solvable since it is equivalent to finding a maximum spanning tree in a graph, while the other three problems become NP-hard, where UFVS and DFAS are also included in the list of Karp’s 21 NP-complete problems [13]. UFVS admits a polynomial-time approximation algorithm with ratio 2 [1], whereas no constant-ratio approximation algorithm has been found for the problems in directed graphs [8]. These problems have also been extensively studied in parameterized and exact algorithms. For parameterized problems with parameter k being the size of the solution, there is a long list of contributions to k-UFVS [3, 4,6, 12], and it can be solved in O(3.83k kn2 ) time now [3]. Whether k-DFVS admits fixed-parameterized tractable algorithms or not had been an open problem for a long time and finally it was solved affirmatively by Chen et al. [5]. Exact algorithms faster than the trivial 2n nO(1) time for both UFVS and DFVS were developed recently. Based on a good choice of the measure to problem instances, a 1.8899n nO(1) -time algorithm for UFVS was designed by Razgon [16], and later the running time was improved to 1.7548n nO(1) by Fomin et al. [10]. Razgon [17] also broke the barrier 2n for DFVS by giving a 1.9977n nO(1) -time algorithm. In this paper, we will design a 1.7266n nO(1) -time exact algorithm for UFVS, which improves the previous results. Our algorithm also uses some good branching rules for UFVS introduced in [16] and [10]. But our algorithm adopts a different measure scheme from the previous algorithms. Under this measure scheme, we can get the improvement by showing that the worst case of the algorithm in [10] will not always happen. To effectively use the measure scheme, we also design new reductions based on biconnectivity of instances.

An Improved Exact Algorithm for Undirected Feedback Vertex Set

3

2 Preliminaries In this paper, a graph stands for an undirected graph with possible multiple edges and self-loops. A simple graph is a graph without any parallel edges and self-loops. For a graph H, let V (H) and E(H) denote the sets of vertices and edges in H, respectively. Let G = (V, E) be a graph and X ⊆ V be a subset of vertices. The subgraph induced by X is denoted by G[X], and G[V \X] is also written as G \X. Contracting X into a single vertex v ∗ means to remove X from G after changing the end-vertex u ∈ X of each edge uv ∈ E to the new vertex v ∗ , where we keep any parallel edges between v ∗ and v ∈ V \X while we remove all resulting loops incident to v ∗ . A vertex v in a graph is called a cut-vertex, if removing it increases the number of connected components of the graph. For a vertex v ∈ V , the set of the neighbors of v is denoted by N (v), and the degree d(v) of v is defined to be the number of edges incident to v, where d(v) ≥ |N (v)|. In a simple graph, d(v) = |N (v)|. After some preprocessing, our algorithm will keep the graph as a simple graph. A subset X ⊆ V of vertices is called an feedback vertex set of a graph G if G \ X is a forest (a graph with no cycles). Note that X is a feedback vertex set of G if and only if V \X induces a forest. The problem of finding a minimum feedback vertex set (FVS) is equivalent to the problem of finding a maximum induced forest (MIF). For the purpose of description, we will design an algorithm in terms of MIF. Given a subset F ⊆ V of vertices which induces a forest G[F ], a maximum induced forest containing F is called an F -MIF. The problem of finding an F -MIF is called forced MIF. We will use (G, F ) to denote an instance of forced MIF. The next lemma allows us to maintain a set F as an independent set in G. Proposition 1 [17] Given an instance (G, F ), where {T1 , T2 , . . . , Tk } denotes the set of connected components of G[F ], let G′ be the graph obtained from G by contracting each connected component Ti of G[F ] into a single vertex zi , and let F ′ = {z1 , . . . , zk } ⊆ V (G′ ). Then for a subset X ⊆ V \F , a set F ∪ X is an F -MIF in (G, F ) if and only if F ′ ∪ X is an F ′ -MIF in (G′ , F ′ ). 3 Branching Operations A simple idea to design algorithms for forced MIF is that: we pick up a vertex t ∈ F and select a neighbor v (∈ V \ F ) of it, and then branch on v by either including it to F or deleting it from the graph. Deleting v in the second branch decreases the number of vertices only by one. We look at the first branch. When v is included to F , we delete all vertices in N (v) ∩ N (t) from the graph and contract v and t into a new vertex, say t. We select a vertex t ∈ F as a designated vertex in our algorithm, and always choose a neighbor v ∈ V \ F of t to branch on when t is designated. When N (v) ∩ N (t) = ∅, the number of vertices decreases again only by one in the first branch. It leads to the trivial running time bound of 2n nO(1) . However, in the first branch we observe more information: the vertices in N (v) \N (t) will become neighbors

4

Mingyu Xiao, Hiroshi Nagamochi

of t in the new graph. We set a weight to each vertex in a graph to distinguish their contribution to the computational complexity of the algorithm. Define the weight of each vertex in F to be 0, that of each vertex in V \(F ∪ N (t)) to be 1, and that of each vertex in N (t) to be a value α ∈ [0.5, 1.0], where the best value of α will be determined according to the analysis of our algorithm described later. We use the sum w of all the vertex weights in (G, F ) as the measure of the instance, where w ≤ n holds, and let a function C(w) = τ w (τ > 1) represent the worst size of the search tree generated from an instance with measure w by our algorithm. Suppose that we choose a neighbor v of t for branching, and let d be the number of neighbors of v except t (i.e., d = |N (v)| − 1). In the worst case where N (v) ∩ N (t) = ∅, we get the following recurrence for the above branching operation C(w) ≤ C(w − (α + d(1−α))) + C(w−α),

(1)

which will be the worst recurrence in the algorithm. To get a smaller upper bound on the size of the search tree of the algorithm, we hope that d(1−α) is as large as possible. When d = 1, we can simply include v to F without branching, because every F -MIF S not containing v always includes the other neighbor v ′ (̸= t) of v by the maximality and can be modified into another F -MIF S ′ = (S\{v ′ })∪{v}. Razgon [16] gave a way of dealing with the case of d = 2 effectively so that the worst recurrence becomes C(w) ≤ C(w − (α + 3(1−α))) + C(w−α). We can verify that C(w) = O(1.8899w ) by choosing α = 0.6370. That is how Razgon [16] obtained the first exact algorithm that breaks the barrier of 2n for MIF. Fomin et al. [10] further analyzed the problem and found a way to deal with the case of d = 3, and then improved the worst case recurrence to C(w) ≤ C(w − (α + 4(1−α))) + C(w−α),

(2)

which solves to C(w) = O(1.7548w ) with α = 0.5116. This leads to the current best time bound on exact algorithms for FVS (MIF). Previous techniques to deal with the cases of d = 2 and d = 3 come from the following lemma. Lemma 1 [10] Let (G, F ) be an instance such that F is an independent set. For a vertex t ∈ F , let v ∈ V \ F be a neighbor of t such that |N (v)| ≥ 3 and no parallel edges are incident to v. If N (v) ∩ F = {t}, then there is an F -MIF S satisfying one of the following properties: For D(v) = N (v) \{t} = {v1 , v2 , . . . , vd } 1. v ∈ S; 2. (D(v)∪{v}) ∩ S = {v1 , v2 }; and 3. {v, vi , vi+1 , . . . , vd } ∩ S = {vi } for some i ∈ {3, . . . , d}, where |D(v)| ≥ 3.

An Improved Exact Algorithm for Undirected Feedback Vertex Set

5

Based on the lemma, we obtain the following branching rule. When d = 2 (|N (v)| = 3), we can branch into two instances at v either by including v to F or by including v1 and v2 to F and deleting v. When d = 3 (|N (v)| = 4), we can branch into three instances at v by including v to F , by including v1 and v2 to F and deleting v, or by including v3 to F and deleting v. These two branching rules are more effective than simply branching on v by including it to F or not. Therefore we get effective ways to deal with the cases of d = 2 and d = 3. However, Lemma 1 only handles the case where N (v) ∩ F = {t}. When v is also adjacent to other vertices in F , the analysis will become complicated. To extend Lemma 1, Razgon [16] and Fomin et al. [10] introduced two concepts “active vertex” and “generalized neighbor.” In their algorithms, at most one vertex t ∈ F is designated as an active vertex. When we contract a set of vertices in F into a single vertex according to Proposition 1, the new vertex is called an active vertex and denoted by t if the set includes the active vertex t. Their algorithms always choose a “neighbor” of the active vertex t to branch on based on the “generalized degree.” For a vertex v ∈ V \F , a vertex u ∈ V \F is called a generalized neighbor of v if u is a neighbor of v or u and v share a common neighbor s in F \{t}. Note that in [16] and [10], “generalized neighbor” is only defined for the vertices in V \ F that are the neighbors of the active vertex t. In this paper, we extend the definition to all vertices in V \F . Denote by GD(v) the set of generalized neighbors of v, and define gd(v) = |GD(v)| to be the generalized degree of v. Hence GD(v) = (N (v) \ F ) ∪ {u ∈ N (s) \ F | s ∈ N (v) ∩ (F \ {t})}. For generalized neighbors, the next property holds, which nearly corresponds to Lemma 1. Lemma 2 Let (G, F ) be an instance such that F is an independent set, and let t ∈ F be a designated vertex in F . For a vertex v ∈ V \ F such that no parallel edges are incident to v, denote GD(v) = {v1 , v2 , . . . , vd } (d = gd(v)). If gd(v) ≤ 1, then there is an F -MIF containing v. Otherwise (gd(v) ≥ 2) there is an F -MIF S satisfying one of the following properties: 1. v ∈ S; 2. (GD(v)∪{v}) ∩ S = {v1 , v2 }; and 3. {v, vi , vi+1 , . . . , vd } ∩ S = {vi } for some i ∈ {3, . . . , d}, where gd(v) ≥ 3. Proof. Let S be an F -MIF of (G, F ), where we assume that v ̸∈ S (otherwise we are done). By the maximality of S, we see that G[S ∪ {v}] contains a cycle C passing through v, and V (C) \ {t} contains at least one vertex u in GD(v) = (N (v) \F ) ∪ {u ∈ N (s) \F | s ∈ N (v) ∩ (F \{t})} since G has no parallel edges between v and t. If S contains no other vertex from GD(v)\{u}, then S ′ = (S \{u}) ∪ {v} is an F -MIF containing v (which means that there is an F -MIF S ′ containing v when gd(v) ≤ 1). Assume that S contains at least two vertices from GD(v). Hence gd(v) ≥ 2. Let i be the largest index such that vi ∈ S, where i ≥ 2. If i = 2, then we have the second condition. Otherwise for i ≥ 3 we have the third condition. ⊔ ⊓

6

Mingyu Xiao, Hiroshi Nagamochi

In this paper, we use the following lemma to deal with degree-2 vertices in the instance. Lemma 3 Let (G, F ) be an instance such that F is an independent set, and let v ∈ V \F be a vertex of degree 2 such that no parallel edges are incident to v. Then there is an F -MIF containing v. Proof. Since G has no parallel edges incident to v, the two neighbors of v are different. Let N (v) = {u1 , u2 }. Assume that there is an F -MIF S of (G, F ) that does not contain v (otherwise we are done). Let S be an F -MIF of (G, F ). Since S is maximal subject to acyclicity of induced graph G[S], S ∪{v} induces a graph G[S ∪ {v}] with a cycle C passing through {u1 , v, u2 }. We first claim that such a cycle C is unique. If G[S ∪ {v}] contains two such cycles C1 and C2 , then C1 − {v} and C2 − {v} are paths between u1 and u2 , and the union of C1 − {v} and C2 − {v} contains a cycle, contradicting that G[S] is acyclic. This proves the claim; i.e., G[S ∪ {v}] contains exactly one such cycle C. Since F is an independent set, C contains at least one vertex v ′ ∈ V (C) \(F ∪ {v}), for which S ′ = (S \ {v ′ }) ∪ {v} still induces an acyclic graph, and hence S ′ is another F -MIF of (G, F ), contradicting the assumption. This proves the lemma. ⊔ ⊓ 4 Reducing Instances In this section, we give a procedure that consists of several reduction steps. Let (G, F ) be an instance where G may contain parallel edges and G[F ] may contain edges. Our procedure Rd(G, F ) for reduction operations is described in Figure 2. An instance to which none of the conditions in the steps is applicable is called a reduced instance. Given an instance (G, F ) of forced MIF such that V (G) ̸= ∅, Rd(G, F ) finds a cycle in the induced subgraph G[F ] or returns a reduced instance (G′ , F ′ ) and a subset S ⊆ V such that for any F ′ -MIF X of (G′ , F ′ ), the union S ∪ X is an F -MIF to the input instance (G, F ), where possibly V (G′ ) or S is empty. We will observe the correctness of each step in Rd. Clearly if G[F ] contains a cycle, then the given instance (G, F ) has no F -MIF. Let (G′ , F ′ ) be the current instance after initializing it as (G, F ). Step 1 is based on Proposition 1. It contracts each connected component H of G′ [F ′ ] into a single vertex v. By Proposition 1, for any solution X to the resulting instance, a solution to the given instance is obtained by X ∪ V (H). Hence Step 1 preserves the optimality of the instance. Step 2 removes any vertex v ∈ V (G′ ) \ F ′ contained in a cycle Q with V (Q) \ F ′ = {v} from the graph. We easily see that such a vertex cannot be contained in any solution to the instance. After Step 1, such a cycle Q is a pair of parallel edges between v and a vertex u ∈ F . As for Step 3, we easily see that if there is a vertex v of degree 1 (either v ∈ V (G′ ) \ F or v ∈ F ′ ), then we can delete the edge incident to v from the graph without changing the optimality of the instance and v will be part of any

An Improved Exact Algorithm for Undirected Feedback Vertex Set

7

Input: A graph (G, F ) and a subset of vertices F ⊆ V . Output: A message for the infeasibility of (G, F ); or a reduced instance (G′ , F ′ ) and a subset S ⊆ V such that for any F ′ -MIF X of (G′ , F ′ ), the union X ∪ S is an F ′ -MIF of the input instance (G, F ). If G[F ] contains a cycle, then halt after returning message “infeasible”; Initialize S := ∅ and (G′ , F ′ ) := (G, F ). While one of the conditions in Steps 1 to 4 holds do 1. If G′ [F ′ ] has a connected component with more than one vertex then choose such a connected component H of G′ [F ′ ] and a vertex v ∈ V (H) (where we let v = t if V (H) contains an active vertex t), and let S := S ∪ (V (H) \ {v}), F ′ := F ′ \ (V (H) \ {v}) and G′ be the graph obtained from G′ by contracting the vertices in V (H) into v. 2. Elseif there is a cycle Q such that |V (Q) \ F ′ | = 1 then choose such a cycle Q with V (Q) \ F ′ = {v} (Q is a pair of parallel edges between v and a vertex u ∈ F ′ ), and let G′ := G′ \ {v}. 3. Elseif there is a degree-1 vertex v ∈ V (G′ ) then choose a degree-1 vertex v ∈ V (G′ ), and let S := S ∪ {v} and G′ := G′ \ {v}. 4. Elseif there is a vertex v ∈ V (G′ ) \F ′ with d(v) = 2 or gd(v) ≤ 1 then choose such a vertex v ∈ V (G′ ) \F ′ , and let F ′ := F ′ ∪ {v}. Return (G′ , F ′ ) and S. Fig. 1 Procedure Rd(G, F )

solution to the instance. Thus we can execute G′ := G′ \ {v} and S := S ∪ {v}, as in Step 3. Step 4 includes to F ′ a degree-2 vertex v ∈ V (G′ ) \F ′ or a vertex v ∈ N (t) with gd(v) ≤ 1. The correctness of these operations are verified by Lemma 3 and Lemma 2, respectively. Note that during an execution of Rd(G, F ), no new parallel edges between two vertices in V \ F will be created, since no two vertices in V \ F are contracted into a new vertex in V \ F . 5 Divide-and-Conquer Procedure Based on Cut-Vertices We also use the following new lemma, which leads to a divide-and-conquer method to eliminate cut-vertices in any instances. Lemma 4 Let (G, F ) be a reduced instance of forced MIF with a cut-vertex v, and let H be a new connected component in G\{v}. Let F1 = F ∩(V (H)∪{v}), G1 = G[V (H) ∪ {v}], F2 = F \V (H), G2 = G \V (H), and Fi∗ = Fi ∪ {v}, i = 1, 2. (i) Assume that v ∈ F . Then an F -MIF of (G, F ) is obtained by the union of any F1 -MIF of I1 = (G1 , F1 ) and F2 -MIF of I2 = (G2 , F2 ). (ii) Assume that v ̸∈ F and |S1∗ | > |S1 | for an F1∗ -MIF S1∗ of I1∗ = (G1 , F1∗ ) and an F1′ -MIF S1 of IH = (H, F1′ = F ∩ V (H)). Then an F -MIF of (G, F ) is obtained by the union of S1∗ \{v} and S2 for any F1∗ -MIF S1∗ of I1∗ = (G1 , F1∗ ) and F2 -MIF S2 of I2 = (G2 , F2 ).

8

Mingyu Xiao, Hiroshi Nagamochi

(iii) Assume that v ̸∈ F and |S1∗ | ≤ |S1 | for an F1∗ -MIF S1∗ of I1∗ = (G1 , F1∗ ) and an F1′ -MIF S1 of IH = (H, F1′ = F ∩ V (H)). Then an F -MIF of (G, F ) is obtained by the union any F1 -MIF of IH = (H, F1 ) and F2′ -MIF ′ = (G \(V (H)∪{v}), F2′ = F \(V (H)∪{v})). of IH Proof. (i) Let S1 be an F1 -MIF of (G1 , F1 ) and S2 be an F2 -MIF of (G2 , F2 ). We show that the union S = S1 ∪ S2 is a feasible solution to (G, F ). Since F1 ∪ F2 ⊆ F , S contains F . Since v is contained in both S1 and S2 and G has no cycle passing through v, no new cycle will appear in the union G[S] of G[S1 ] and G[S2 ]. To prove the optimality of S, we show that, for any F -MIF S ′ in (G, F ), it holds |S ′ | ≤ |S|. We see that S ′ ∩ (V (H) ∪ {v}) (resp., S ′ − V (H)) is a feasible solution to F1 -MIF in (G1 , F1 ) (resp., F2 -MIF in (G2 , F2 )) and |S ′ ∩ (V (H) ∪ {v})| ≤ |S1 | (resp., |S ′ \V (H)| ≤ |S2 |) holds by the optimality of S1 (resp., S2 ). This implies that |S ′ | = |S ′ ∩ (V (H) ∪ {v})| + |S ′ \V (H)| − 1 ≤ |S1 | + |S2 | − 1 = |S|, as required. (ii) Note that |S1∗ | > |S1 | implies |S1∗ | − 1 = |S1 |, since S1∗ \{v} is a feasible solution to forced MIF in (H, F1 ). Let S1∗ be an F1∗ -MIF of (G1 , F1∗ ) and S2 be an F2 -MIF of (G2 , F2 ). We show that the union S = (S1∗ \{v}) ∪ S2 is a feasible solution to (G, F ). Since F1∗ ∪ F2 ⊆ F , the union S contains F . Note that G[{v} ∪ (S1∗ \{v})] = G[S1∗ ] is acyclic even if v ∈ S2 . Then G[S] is acyclic, since G has no cycle passing through v. Hence S is a feasible solution to the forced MIF instance (G, F ). To prove the optimality of S, we show that, for any F -MIF S ′ in (G, F ), it holds |S ′ | ≤ |S|. Note that S ′ ∩ V (H) (resp., S ′ \V (H)) is a feasible solution to F1′ -MIF in (H, F1′ ) (resp., F2 -MIF in (G2 , F2 )) and |S ′ ∩ V (H)| ≤ |S1 | (resp., |S ′ \V (H)| ≤ |S2 |) holds by the optimality of S1 (resp., S2 ). This implies that |S ′ | = |S ′ ∩ V (H)| + |S ′ \ V (H)| ≤ |S1 | + |S2 | = |S1∗ \ {v}| + |S2 | = |S|, as required. (iii) Let S1 be an F1′ -MIF of (H, F1′ ) and S2 be an F2′ -MIF of (G \(V (H)∪ {v}), F2′ = F \(V (H)∪{v})). We show that the union S = S1 ∪ S2 is a feasible solution to (G, F ). Since F1′ ∪ F2′ ⊆ F , S contains F . Since v ̸∈ V (H) ∪ V (G \ (V (H)∪{v})), G[S] is a disjoint union of acyclic graphs G[S1 ] and G[S2 ]. Hence S is a feasible solution to the forced MIF instance (G, F ). To prove the optimality of S, we show that, for any F -MIF S ′ in (G, F ), it holds |S ′ | ≤ |S|. If v ̸∈ S ′ , then S ′ ∩ V (H) (resp., S ′ \ (V (H)∪{v})) is a feasible solution to F1′ -MIF in (H, F1′ ) (resp., F2′ -MIF in (G \(V (H)∪{v}), F2′ )) and |S ′ ∩ V (H)| ≤ |S1 | (resp., |S ′ \(V (H)∪{v})| ≤ |S2 |) holds by the optimality of S1 (resp., S2 ), indicating that |S ′ | = |S ′ ∩ V (H)| + |S ′ \ (V (H) ∪ {v})| ≤ |S1 | + |S2 | = |S|. Now consider the case of v ∈ S ′ . Then S ′ ∩(V (H)∪{v}) (resp., S ′ \(V (H)∪ {v})) is a feasible solution to F1 -MIF in (G1 , F1 ) (resp., F2′ -MIF in (G\(V (H)∪ {v}), F2′ )) and |S ′ ∩ (V (H) ∪ {v})| ≤ |S1∗ | (resp., |S ′ \(V (H) ∪ {v})| ≤ |S2 |) holds by the optimality of S1∗ (resp., S2 ), where we have |S ′ | ≤ |S1∗ | + |S2 | ≤ |S1 | + |S2 | = |S| by the assumption |S1∗ | ≤ |S1 |. ⊔ ⊓

An Improved Exact Algorithm for Undirected Feedback Vertex Set

9

Lemma 4 enables us to design the following divide-and-conquer method to eliminate any cut-vertex v in an instance (G, F ). If v is in F , then we compute I1 and I2 in (i) of the lemma. If v is not in F , we first compute I1∗ and IH in ′ in (ii) or (iii) of (ii) or (iii) of the lemma and then compute either I2 or IH ∗ the lemma according to the solutions to I1 and IH .

6 The Algorithm To describe our algorithm, we first introduce some notions on local structures of instances (G, F ). A cycle C that contains exactly two vertices in V (G) \ F is called a shortcycle, where C may contain some vertices from F . When F is an independent set, every short-cycle contains at most two vertices from F . In particular, a short-cycle is a pair of parallel edges when it contains no vertex from F . We see that at most one of the two vertices in V (G) \ F in a short-cycle can be contained in any F -MIF. We call the two vertices u, v ∈ V (G) \ F in a short cycle a short-pair if no active vertex is designated or none of them is adjacent to the active vertex t. A neighbor v ∈ N (t) of the active vertex t is called a demand-vertex if gd(v) = 4, GD(v) ∩ N (t) = ∅, and GD(v) = N (v) contains at least one vertex of degree ≥ 6. Recurrences for branching on demand-vertices will lead to some bottlenecks in our algorithm. To achieve the improvement, we include in the recurrence a shift saved from recurrences for branching on special vertices, called “supply-vertices.” We also introduce “trigger-vertices” (non-neighbors of t), which admit a different branching operation with a better recurrence than the standard branching on neighbors of t. A neighbor v ∈ N (t) of the active vertex t is called a supply-vertex if gd(v) ≥ d(v) − 1 ≥ 5 holds. For a vertex u ∈ N (t) \ F such that |GD(u) \ N (t)| ≥ 3, a neighbor v ∈ GD(u) is called a trigger-vertex if N (u) is given as one of the following: N (u) = {t, v, s}; N (u) = {t, v ′ , s}; or N (u) = {t, v, v ′ , s}, where s ∈ F \ N (v), v ′ ∈ F ∩ N (v) and d(v ′ ) = 2. We describe our algorithm for forced MIF in Figure 2. Step 1 calls Rd(G, F ) to reduce the instance (G, F ). Recall that no new parallel edges between two vertices in V \ F have been created during an execution of Rd(G, F ). In Step 2, the algorithm deals with short-pairs u, v ∈ V \F of degree ≥ 3. We branch by either including v to F or deleting it from the graph. In the first branch we can also remove vertex u directly since at least one of vertices u and v should be deleted to destroy all cycles containing them. Note that during the first application of Step 2 to the initial instance, no active vertex has been selected and all parallel edges will be eliminated. We see that no step in the algorithm contracts two vertices in V \F into a new vertex in V \F , and thereby no new parallel edges between two vertices in V \F will be created. Hence after the first application of Steps 1 and 2 to the initial instance, the

10

Mingyu Xiao, Hiroshi Nagamochi

Input: A graph G = (V, E) and a subset of vertices F ⊆ V . Initially F = ∅. Output: An F -MIF of G; or a message for the infeasibility of (G, F ). 1. If {(G, F ) is not a reduced instance}, halt after returning message “infeasible” if Rd(G, F ) =“infeasible;” otherwise let [S, (G′ , F ′ )] := Rd(G, F ), and return S ∪ mif(G′ , F ′ ), where we return only S if V (G′ ) = ∅. 2. Elseif {There is a short-pair u, v ∈ V \F }, return a maximum one from { mif(G \ {u}, F ∪ {v}), mif(G \{v}, F ) }. 3. Elseif {G has cut-vertices}, choose a cut-vertex v and decompose (G, F ) into subinstances by applying Lemma 4 to a new component H of minimum number of vertices in G \{v}. 4. Elseif {F = ∅}, select a vertex v of maximum degree, and return a maximum one from { mif(G, {t := v}), mif(G \{v}, ∅) }, where v is designated as the active vertex t in (G, {v}). 5. Elseif {F ′ ̸= ∅ and no active vertex is selected}, designate any vertex in F ′ as an active vertex t. 6. Elseif {There is a supply-vertex}, select a supply-vertex v and return a maximum one from { mif(G, F ∪ {v}), mif(G \{v}, F ) }. 7. Elseif {There is a vertex v ∈ N (t) with gd(v) = 2}, select such a vertex v, where GD(v) = {v1 , v2 }, and return a maximum one from { mif(G, F ∪ {v}), mif(G \{v}, F ∪ {v1 , v2 }) }. 8. Elseif select an optimal vertex v ∈ V \ F . (a) If {gd(v) = 3 but v is not a trigger vertex}, let GD(v) = {v1 , v2 , v3 } so that v3 ̸∈ N (t) (if possible) and d(v3 ) is maximized (otherwise), and return a maximum one from {mif(G, F ∪ {v}), mif(G \ {v, v3 }, F ∪ {v1 , v2 }), mif(G \{v}, F ∪ {v3 }) }. (b) Else /* v is a trigger-vertex or gd(v) ≥ 4 */ return a maximum one from {mif(G, F ∪ {v}), mif(G \{v}, F ) }. Note. In Steps 7 and 8(a), if the subgraph induced by F ∪ {v1 , v2 } contains a cycle, we ignore the second branch. Fig. 2 Algorithm mif(G, F )

graphs of any instances remain simple in the subsequent execution. Step 3 is executed to eliminate cut-vertices in G, where new cut-vertices may be created in the subsequent execution. After Step 3, the instance satisfies the following properties: the instance is a reduced one; the graph G has no parallel edges or cut-vertices (where G may be disconnected); and all vertices in V \F are of degree d ≥ 3 and generalized degree gd ≥ 2. Based on these properties, we will design the major branching rules in our algorithm based on Lemma 2. We branch on supply-vertices in Step 6, vertices with gd(v) = 2 in Step 7 and the rest vertices (including demand-vertices) in

An Improved Exact Algorithm for Undirected Feedback Vertex Set

11

Step 8. In Step 8, where gd(z) ≥ 3 for all neighbors z ∈ N (t), we use a careful rule of selecting a vertex v ∈ N (t), called “optimal” to branch on, which is important to get the improvement. We use Fv to denote the set N (v)∩(F \{t}) for any vertex v ∈ V \F . A vertex v ∈ N (t) \ F with gd(v) ≥ 3 is called an optimal vertex if (i) v is a trigger-vertex or v is a vertex gd(v) = 3 with maximum |GD(v)\N (t)| among such neighbors of t; or (ii) when N (t) \ F contains no vertex of Case (i), v maximizes |Fv |, |GD(v) ∩ N (t)| and gd(v) in this order. Since our branching rules for branching on a vertex v ∈ N (t) with gd(v) = 3 and gd(v) ≥ 4 are different, in Step 8 we consider two subcases (a) and (b) to deal with these vertices separately. From Lemma 2, we obtain the branching operations in Steps 6, 7 and 8 in Figure 2.

7 Running Time Analysis We exploit the measure-and-conquer method [11] to analyze the algorithm. In this method, we set a non-negative weight to each vertex in the graph of an instance and use the sum w of the total vertex weight as the measure to scale the size of the instance. In fact, we will set the vertex weight of each vertex at most 1 so that w is at most the number n of vertices. Then a running time bound O∗ (τ w ) with respect to w will imply a running time bound O∗ (τ n ) with respect to n. Fomin et al. used the measure-and-conquer method in the analysis of their algorithm [10]. In their analysis, they only considered three kinds of different vertex weight: setting the weight of each vertex in F as 0, that of each vertex in N (t)∩(V \F ) as α = 0.5116, and that of each remaining vertex in V \(F ∪N (t)) as 1, where t is the active vertex in the graph. By listing out all recurrences generated by the algorithm as (1), Fomin et al. proved that the algorithm runs in 1.7548n nO(1) time and the worst case recurrence is (2). One way to further decrease the time bound of Fomin et al.’s algorithm would be to improve the worst case of (2) by using the branching rule from Lemma 2 with d = 4. However, this new branching rule will create four instances and it will generate a recurrence even worse than (2). In this paper, we try to improve the result of MIF in a different way. We will use a different measure scheme to improve the worst case analysis. In most measure-and-conquer algorithms for graph problems, such as the algorithms in [2,11,18], we set different vertex weights for vertices of different degree. One reason for this would be that vertices of higher degree may have a larger contribution to the structural complexity of the graph. However, MIF seems different from the previous measure-and-conquer algorithms in the sense that the current fastest algorithm is obtained by using weights with no difference between vertices of different degree. We wonder whether the algorithm for MIF can be improved by distinguishing vertices of different degree, without significantly modifying the algorithm.

12

Mingyu Xiao, Hiroshi Nagamochi

Note that in some branching operations in the algorithm, we will delete some vertices from the graph and the degree of their neighbors will decrease. When the maximum degree of the graph is at most 2, the forced MIF can be solved in polynomial time. These properties imply that vertices of different degree have different contribution to the hardness of the problem. After carefully analyzing the algorithm based on the above observation, we improve the running time bound for this problem from 1.7548n nO(1) to 1.7266n nO(1) by our sophisticated measure scheme. Our improvement is obtained from the following intuitive observation. The worst case of Fomin et al.’s algorithm is to branch on a vertex v of gd(v) = 4 (as Step 7(b) in mif(G, F )) with recurrence (2). However, we observe that this case may not always happen. If there is a vertex in GD(v) of a high degree (say ≥ 6), in the branch of including v to F (where such a vertex becomes adjacent to the new active vertex), then we can branch on a vertex u ∈ GD(v) of degree at least 6 in the next step, which may lead to a good performance. If there is a vertex u ∈ GD(v) of a low degree (say ≤ 5), in the other branch of deleting v from the graph, the degree of u will decrease by one and u will become a ‘beneficial’ vertex in the subsequent computation. Then it is possible to decrease some measure from u by setting different vertex weight to vertices of different degree. Both cases imply that we can get a recurrence better then (2). This is the main idea on how our algorithm runs in the claimed time bound. Next we show the details about the weight setting and the recurrences generated by the algorithm after reviewing two techniques for time bound analysis in the next subsection.

7.1 Analyzing techniques To analyze each step of the algorithm mif(G, F ), we also introduce the following proposition proved in [19], which can be used to eliminate redundant recurrences among a set of systematically generated recurrences. Lemma 5 [19] Let C(x) = τ x for a positive τ > 1. For any nonnegative p, w, ai , bi , i = 1, 2, . . . , ℓ (ℓ ≥ 1), the maximum of ∑ ∑ C(w − ( ki ai +c)) + C(w − ( ki bi +d)) i=1,2,...,ℓ

i=1,2,...,ℓ

over all k1 , k2 , . . . , kℓ ≥ 0 subject to k1 + k2 + · · · + kℓ = p is equal to the maximum of C(w−(pai +c)) + C(w − (pbi +d)) over all i = 1, 2, . . . , ℓ. To ease amortization on our analysis, we introduce “shift” σ for some recurrences which are not bottlenecks in our algorithm. Suppose that there are two branching operations A and B with recurrences C(w) ≤ C(w − t(A1) ) + C(w − t(A2) ) and C(w) ≤ C(w − t(B1) ) + C(w − t(B2) ), and that branching

An Improved Exact Algorithm for Undirected Feedback Vertex Set

13

operation B is always applied to the subinstance G1 generated by the first branch of A in the algorithm. The branching operation B may lead to a better recurrence (with a smaller branching factor) than A does. To improve the recurrence for operation A, we will save some decreasing of the measure in operation B to A. Instead, we save σB ≥ 0 from B by evaluating the branch rule B with a worse recurrence C(w) ≤ C(w − (t(B1) −σB )) + C(w − (t(B2) −σB )). The saved weight σB will be included to the recurrence for operation A to obtain C(w) ≤ C(w − (t(A1) +σB )) + C(w − t(A2) ). The amount of saving is also called shift. In our algorithm, we save shifts σ ∗ and σi (i ≥ 0) from recurrences for the divide-and-conquer in Step 3 and branching on supply-vertices v in Step 6, and include these shifts to some recurrences for branching of demand-vertices in Step 8(b). For convenience, we assume σ0 ≤ σ ∗ ≤ β; σi ≤ σi+1 ≤ β for i ≥ 0.

(3)

To simplify the presentation, we may simply write a recurrence C(w) ≤ C(w − a1 ) + C(w − a2 ) + · · · + C(w − ak ) as [a1 ; a2 ; . . . ; ak ], which is also called the branching vector of the recurrence.

7.2 Weight setting and basic analysis Let t be the active vertex in a graph (if any) and U = V \(F ∪ N (t)). For each vertex v ∈ V , we set its vertex-weight w(v) to be  α + β if v = t (v is the active vertex)     0 if v ∈ V \ {t} and d(v) ∈ {0, 1}    β if v ∈ F \{t} and d(v) ≥ 2 w(v) = α if v ∈ N (t) ∩ (V \F ) and d(v) ≥ 2     w if v ∈ U and d(v) = i for i ∈ {2, 3, 4}  i   1 if v ∈ U and d(v) ≥ 5, where wi is the weight of a vertex v ∈ U of degree i ≥ 0 such that w0 = w1 = 0 and wj = 1 for all j ≥ 5. We will determine the best value of β, α, w3 and w4 so that the worst recurrence in the algorithm is as good as possible. To simplify some arguments, we assume that vertex weights satisfy the following constraints 0.01 < β ≤ w2 ≤ w3 ≤ w4 ≤ 1 and max{β, 0.5} ≤ α ≤ min{(3/5)w3 , (2w3 −β)/3}. (4) Let ∆i (i ≥ 1) denote wi − wi−1 , where ∆i ≥ 0 holds for each i ≥ 1. Recall that we denote Fv = N (v) ∩ (F \{t}) for each vertex v ∈ V \F .

14

Mingyu Xiao, Hiroshi Nagamochi

Recall that we use C(w) to denote the worst size of the search tree with respect to the measure w generated by the algorithm. We will list out all possible recurrences created by the algorithm. To do so, we analyze the decrease of the measure in each of the generated instances in every recurrence. In the algorithm, we have two basic operations in branching on a vertex v ∈ V \F in a reduced instance (G, F ): one is to include vertex v to F and the other is to delete vertex v from the graph. We here consider the following three basic cases (1), (2) and (3). (1) The vertex v is in U , and it is included to F and also selected as the active vertex t: In this case, the weight of v changes from wd(v) to α + β, and the weight of each neighbor u ∈ N (v) \F of v decreases from w(u) = wd(u) to α. In total, the measure w decreases by at least ∑ ∆w = wd(v) − (α + β) + (wd(u) −α). (5) u∈N (v)\F

(2) The vertex v ∈ V \ F is a neighbor of the active vertex t, and it is included to F , and Rd(G, F ) is executed in the next step, where t and v (possibly with some other vertices in F adjacent to v) will be contracted into a new active vertex: We analyze the decrease of the measure w in these two operations together. In fact, the decrease of the measure comes from three kinds of vertices, which are v itself, the vertices in GD(v), and the vertices in Fv . The weight of v decreases from w(v) = α to 0. For vertices u ∈ GD(v), we distinguish two cases. If u is also in N (t), then after including v to F , vertex u will be removed from the graph by executing Rd(G, F ). Then the weight of each vertex u ∈ GD(v) ∩ N (t) decreases from w(u) = α to 0, whereas the weight of each vertex u ∈ GD(v) \N (t) decreases from w(u) = wd(u) to α. We see that the weight of some vertices in F also decreases. After including v to F , all vertices in {t, v} ∪ Fv will be contracted into a new active vertex. This decreases the weight of each vertex in Fv by β. In total, the decrease of the measure w is at least ∑ ∆w = α + |GD(v) ∩ N (t)|α + (wd(u) −α) + |Fv |β. (6) u∈GD(v)\N (t)

(3) The vertex v is deleted from the graph: In this case the measure decreases by the deletion of v and the weight decrease of some of its neighbors since their degrees decrease by 1. Then the weight of each vertex u ∈ N (v) \(F ∪ N (t)) decreases by ∆d(u) . Then deleting v decreases the measure w by at least ∑ ∆w = w(v) + ∆d(u) , (7) u∈N (v)\(F ∪N (t))

where w(v) = wd(v) when v ∈ U and w(v) = α otherwise (v ∈ N (t)). We will frequently use (5), (6) and (7) in the next subsection to derive our recurrences generated by the algorithm.

An Improved Exact Algorithm for Undirected Feedback Vertex Set

15

7.3 Measure in Reductions In this subsection we show that each step of Rd(G, F ) does not increase the measure of instances. In fact, we obtain the next. Lemma 6 Each step in Rd decreases the measure by at least β. Proof. In Step 1, when a connected component H with more than one vertex in G′ [F ′ ] is contracted, the measure decreases by at least (|V (H)| − 1)β ≥ β. Step 2 removes one vertex v ∈ V (G′ ) \ F ′ , which decreases the measure by at least α (≥ β). Step 3 eliminates degree-1 vertices. We see that the measure decreases by at least β when the procedure is applied until no degree-1 vertices are left, except for the case where the active vertex t is of degree 1. Consider the case where t is of degree 1, where its weight is α. The unique neighbor v of t becomes a vertex in U = V (G′ ) \ (F ′ ∪ N (t)) and its weight increases from α to wd(u) . However, the measure decreases by at least α + β − (wd(u) − α) ≥ 2α − 1 + β (≥ β by (4)). Step 4 moves a vertex v ∈ V (G′ ) \ F ′ to F ′ , which decreases the measure by wd(u) − α (≥ β). ⊔ ⊓ 7.4 List of recurrences In this subsection we derive recurrences from each of the branching steps in mif(G, F ). We first observe a relationship between generalized degree and short-cycles. Lemma 7 Let v be a neighbor in N (t) of the active vertex t in a reduced instance (G, F ) obtained after Step 1 of mif. If gd(v) ≤ d(v) − 2 holds, then there is a short-cycle that contains v but avoids t. Proof. Note that G has no parallel edges and it holds |Fv | + gd(v) ≥ |Fv | + |N (v)\F | = d(v)−1 for any vertex v ∈ N (t). Since |Fv |+gd(v) ≥ d(v)−1 in G, it holds |Fv | ≥ d(v) − 1 − gd(v) ≥ 1 by gd(v) ≤ d(v) − 2. In a reduced instance, each vertex a ∈ Fv ̸= ∅ has a neighbor ua ∈ N (a) \ (F ∪ {v}). If two distinct vertices a, b ∈ Fv share a common neighbor ua = ub ∈ V (G) \ {v}, then vav ′ b for v ′ = ua = ub forms a short-cycle. Assume that no two vertices in Fv share a common neighbor. Then there is some vertex a ∈ Fv such that N (v) contains its neighbor ua ∈ V (G) \ {v}, since otherwise gd(v) ≥ |N (v) \ Fv | + |Fv | ≥ d(v) would hold. In this case, triangle vav ′ for v ′ = ua is a short-cycle. ⊔ ⊓ 7.4.1 Branch in Step 2. In Step 2, the algorithm deals with short-pairs u, v ∈ V \F of degree ≥ 3. Note that in the first branch, we do not designate v as an active vertex t in Step 2.

16

Mingyu Xiao, Hiroshi Nagamochi

Hence every short-pair remains a short-pair in each of resulting instances after the branching operation. We derive a recurrence for the branching in Step 2 when both u and v are of degree at least 3. Recall that u, v ̸∈ N (t) by the definition of short-pairs. The first branch of including v to F deletes u from G and decreases the measure by at least (w(v) − β) + w(u) ≥ (w3 − β) + w3 and the second of deleting v from G decreases the measure by at least w(v) ≥ w3 . Hence we have recurrence [(w3 − β) + w3 ; w3 ].

(8)

Each step of the algorithm never contracts vertices in V \F and thereby creates no new parallel edges between two vertices in V \ F . Hence parallel edges between vertices V \ F will be eliminated after Step 2 in the initial graph before an active vertex t is chosen. 7.4.2 Branch in Step 3. This step is a divide-and-conquer procedure based on Lemma 4. We show that the operation in this step will not exponentially increase the size of the search tree in our algorithm as long as the subgraph H to be eliminate is chosen as a component of minimum number of vertices in G − {v} for a cut-vertex v. We analyze the worst case in this step; i.e., v ̸∈ F and the algorithm computes ′ ). For a subgraph H ′ of G, let w(H ′ ) three instances I1∗ , IH and I2 (or IH ∑ denote x∈V (H ′ ) w(x). Note that after Step 1 there is no vertex of degree ≤ 1 and each vertex has a weight at least β > 0. By the choice of H, we have w(H) ≤ w(G1 ) ≤ 0.5|V | and w(G2 ) ≥ 0.5|V |β ≥ 0.005|V | by (4), where G1 and G2 are graphs defined in Lemma 4. Since w(G) = w(G1 ) + w(G2 ) > w(G1 ) + 0.005|V | > w(G1 ) + 0.01w(G1 ), then it holds w(G1 ) < 1/1.01w(G) < 0.991w(G). Also, since w(G) = w(G1 )+w(G2 ) < 0.5|V |+w(G2 ) < 100w(G2 )+ w(G2 ) = 101w(G2 ), we have w(G2 ) > 1/101w(G) > 0.009w(G). Hence we get recurrence [0.991w−σ ∗ ; 0.991w−σ ∗ ; 0.009w−σ ∗ ], where we save a shift σ ∗ ≥ 0 which will be included to some other recurrences in Step 8(b). It is easy to versify that C(w) = 1.7w satisfies the above recurrence for any constant σ ∗ ≥ 0. After Step 3, the graph G in an instance (G, F ) consists of only biconnected components. 7.4.3 Branch in Steps 4 and 5. In Step 4, it holds that F = ∅, the selected vertex v is of maximum degree d (≥ 3) in the graph G, and two instances (G′ , F ′ ) ∈ {(G, {v}), (G \{v}, ∅)} will be generated, where v will be the active vertex in (G, {v}). Since F = ∅, it holds w(u) = wd(u) ≥ w3 for all vertices u ∈ V . Let z be the number of degree-3 neighbors in V \F of v. Then by (5) and (7) we can get recurrences [w3 − (α + β) + z(w3 −α) + (3 − z)(w4 −α); w3 + z(w3 − w2 )] for z = 0, 1, 2, 3. (9)

An Improved Exact Algorithm for Undirected Feedback Vertex Set

17

Step 5 will not create a recurrence. In this step, when a vertex v ∈ F newly becomes an active vertex t, its weight increases from β to α + β. After Step 1, v is adjacent to at least two neighbors in V \ (F ∪ N (t)), and the weight of each of these neighbors decreases by at least w3 − α. Hence in this step the measure decreases directly by at least 2(w3 − α) − α = 2w3 − 3α (≥ β by (4)). 7.4.4 Branch in Step 6. Let v be the supply-vertex selected in Step 6, where gd(v) ≥ d(v) − 1 ≥ 5 since v is a supply-vertex. Let r = gd(v) ≥ 5 and x = |GD(v) ∩ N (t)|. By (6) and (7), we can get recurrence ∑ ∑ [α + xα + (wd(u) −α) + β|Fv |; α + u∈GD(v)\N (t)

u∈N (v)\(F ∪N (t))

∆d(u) ].

We will derive recurrences for branching on a supply-vertex v so that we save a shift σx from the recurrences with x = |GD(v) ∩ N (t)| and |Fv | ≤ 3, and σ ∗ from those with |Fv | ≥ 4. We distinguish two cases. Case 1. Fv = ∅: By Lemma 5, we can assume that all vertices in GD(v) are of the same degree i to get recurrences. Then we get recurrence [α + xα + (r−x)(wi −α)−σx ; α + (5−x)∆i −σx ]

(10)

for r = 5, 0 ≤ x ≤ 5 and i = 3, 4, 5, 6, where the case of i > 6 is included in the case of i = 6. We only consider the case of r = 5, which covers the other case of r ≥ 6. Case 2. Fv ̸= ∅: (i) |Fv | = 1: In this case, y = |N (v) \ F | = d(v) − 1 − |Fv | ≥ 6 − 1 − 1 = 4. When x ≥ 4, we obtain recurrences [α + xα + (r−x)(w3 −α) + β −σx ; α−σx ] for 4 ≤ x ≤ 5 and r = 5. (11) The cases of r ≥ 6 are covered by the case of r = 5. Assume that x ≤ 3. Then the second branch of deleting v from the graph decreases the degree of at least (y −x) ≥ (4−x) vertices in N (v) \ N (t), and we obtain recurrences [(x+1)α + (r − 4)(w3 −α) + (4−x)(wi −α) + β −σx ; α + (4−x)∆i −σx ] (12) for x = 0, 1, 2, 3, r = 5 and i = 3, 4, 5, 6. The cases of r ≥ 6 are covered by the case of r = 5. (ii) |Fv | = 2: Now y ≥ 3. Analogously with (i), we get recurrences [α + xα + (r−x)(w3 −α) + 2β −σx ; α−σx ] for 3 ≤ x ≤ 5 and r = 5, (13)

18

Mingyu Xiao, Hiroshi Nagamochi

and [(x+1)α + (r − 3)(w3 −α) + (3−x)(wi −α) + 2β −σx ; α + (3−x)∆i −σx ] (14) for x = 0, 1, 2, r = 5 and i = 3, 4, 5, 6. The cases of r ≥ 6 are covered by the case of r = 5. (iii) |Fv | = 3: Now y ≥ 2. Analogously with (i), we get recurrences [α + xα + (r−x)(w3 −α) + 3β −σx ; α−σx ] for r = 5 and 2 ≤ x ≤ r; (15) and [(x+1)α + (r − 2)(w3 −α) + (2−x)(wi −α) + 3β −σx ; α + (2−x)∆i −σx ] (16) for x = 0, 1, r = 5 and i = 3, 4, 5, 6. The cases of r ≥ 6 are covered by the case of r = 5. (iv) |Fv | ≥ 4: We consider the case of r = 5 and x = 0 which covers the other case of r ≥ 6 or x ≥ 1, and obtain recurrence [α + 5(w3 −α) + 4β −σ ∗ ; α−σ ∗ ].

(17)

7.4.5 Branch in Step 7. In Step 7, the selected vertex v is of gd(v) = 2 among the neighbors of t, and two instances (G′ , F ′ ) ∈ {(G, F ∪ {v}), (G \{v}, F ∪ GD(v))} will be generated. Let GD(v) = {v1 , v2 } and x = |GD(v) ∩ N (t)|. See Figure 3 for an illustration.

Fig. 3 Two instances generated by the branching in Step 7, where x = 1, v1 ∈ GD(v)∩N (t) and v2 ∈ GD(v) \N (t)

An Improved Exact Algorithm for Undirected Feedback Vertex Set

19

In the first branch of including v to F , all vertices in GD(v) ∩ N (t) will be removed decreasing the measure by xα, while all vertices in GD(v) \N (t) will become vertices adjacent to the active vertex decreasing the measure by at least (2−x)(w3−α). In the second branch of deleting v and including GD(v) to F , all vertices in GD(v) ∩ N (t) will also be removed by contraction decreasing the measure by xα and all vertices in GD(v) \N (t) will become vertices in F decreasing the measure by at least (2−x)(w3 − β). Then we get recurrences [α + xα + (2−x)(w3 −α); α + xα + (2−x)(w3 − β)] for x = 0, 1, 2.

(18)

7.4.6 Branch in Step 8(a). Let v be the optimal vertex of gd(v) = 3 selected in Step 8(a), and let GD(v) = {v1 , v2 , v3 }. Step 8(a) will generate three instances (G′ , F ′ ) ∈ {(G, F ∪ {v}), (G \ {v, v3 }, F ∪ {v1 , v2 }), (G \ {v}, F ∪ {v3 })}. See Figure 4 for an illustration.

Fig. 4 Three instances generated by the branching in Step 8(a), where v is an optimal vertex of Case (i), {v1 , v2 , v3 } ∩ N (t) = ∅ and |Fv | = 1.

We distinguish subcases. (I) GD(v) contains a non-neighbor v ′ of t: By the choice of indices of vi ∈ GD(v) in Step 7(a), it holds v3 ̸∈ N (t), where w(v3 ) = wd(v3 ) ≥ w3 . We here distinguish three cases. Case 1. Both v1 and v2 are not in N (t), where w(vi ) = wd(vi ) ≥ w3 , i = 1, 2: (i) |Fv | ≥ 1: Let s ∈ Fv . Note that vertex s will be eliminated in the first branch and at least one of the second and third branches. Then we get recurrences [α+

3 ∑ i=1

(wd(vi )−α)+β; α+wd(v3 ) +

2 ∑ i=1

(wd(vi ) −β)+δβ; α+(wd(v3 ) −β)+(1−δ)β],

20

Mingyu Xiao, Hiroshi Nagamochi

where d(v1 ), d(v2 ), d(v3 ) ≥ 3 and δ ∈ {0, 1}. Since w(vi ) ≥ w3 for i = 1, 2, 3, we only need to consider the recurrences with w(v1 ) = w(v2 ) = w(v3 ) = w3 : [3w3 − 2α + β; α + 3w3 − 2β + δβ; α + w3 − β + (1 − δ)β] (δ ∈ {0, 1}).(19) (ii) |Fv | = 0: Then {v1 , v2 , v3 } ⊆ N (v) and thereby the third branch of removing v will decrease the degree of vi (i = 1, 2) by 1. Then we get recurrences [α +

3 ∑

(wd(vi )−α); α + wd(v3 ) +

i=1

2 ∑

(wd(vi ) − β); α + (wd(v3 ) − β) +

i=1

2 ∑

∆d(vi ) ],

i=1

where d(v3 ) ≥ max{d(v1 ), d(v2 )} by the choice of indices of vi ∈ GD(v). By Lemma 5 and d(v3 ) ≥ 3, we only need to consider the recurrences with d(v1 ) = d(v2 ) = d(v3 ) ∈ {3, 4, 5, 6}: [3wi − 2α; α + 3wi − 2β; α + (wi − β) + 2∆i ],

(20)

where i = 3, 4, 5, 6. Case 2. Exactly one of v1 and v2 , say v1 , is in N (t), where w(v1 ) = α and w(v2 ) = wd(v2 ) ≥ w3 : Vertex v1 will be eliminated from the graph in the first and second branches. By considering weight decreases of vertices in {v}∪N (t), we get recurrences [2α +

3 ∑

(wd(vi ) −α); α + wd(v3 ) + α + (wd(v2 ) − β); α + (wd(v3 ) − β)]

i=2

for 3 ≤ d(v2 ), d(v3 ) ≤ 6. We show that some more weight decrease can be obtained in one of the three branches. (i) v and v3 have a common vertex s ∈ F \ {t}: In the first and third branches, vertex s will be merged with t or v3 , and we get recurrences [wd(v2 ) + wd(v3 ) + β; 2α + wd(v3 ) + wd(v2 ) − β; α + wd(v3 ) ],

(21)

where 3 ≤ d(v2 ), d(v3 ) ≤ 5. (ii) v and vi for some i = 1, 2 have a common vertex s ∈ F \{t}: In the first and second branches, vertex s will be merged with t or vi , and we get recurrences [wd(v2 ) + wd(v3 ) + β; 2α + wd(v3 ) + wd(v2 ) ; α + wd(v3 ) − β],

(22)

where 3 ≤ d(v2 ), d(v3 ) ≤ 5. (iii) v3 and vi for some i = 1, 2 have a common vertex s ∈ F \ {t}: In the second and third branches, vertex s will be merged with vi or v3 , and we get recurrences [wd(v2 ) + wd(v3 ) ; 2α + wd(v3 ) + wd(v2 ) ; α + wd(v3 ) ], where 3 ≤ d(v2 ), d(v3 ) ≤ 5.

(23)

An Improved Exact Algorithm for Undirected Feedback Vertex Set

21

Fig. 5 Three instances generated by the branching in Step 8(a), where v is an optimal vertex of Case (i) , {v1 , v2 , v3 } ∩ N (t) = {v1 } and GD(v1 ) \ {v, v2 , v3 } ̸= ∅.

(iv) GD(v1 ) \ {v, v2 , v3 } ̸= ∅ (resp., GD(v1 ) = {v, v2 , v3 } and GD(v2 ) \ {v, v1 , v3 } = ̸ ∅): Figure 5 illustrates the case of GD(v1 ) \ {v, v2 , v3 } ̸= ∅. In this case, the second branch of including vertices v1 , v2 ∈ N (t) to F actually contracts them into t, and then any vertex u ∈ GD(v1 ) \ {v, v2 , v3 } (resp., u ∈ GD(v2 ) \ {v, v1 , v3 }) will be newly adjacent to t (when u ∈ U ) or be deleted from G (when u ∈ N (t)), decreasing the weight of u by at least min{wd(u) −α, α} ≥ w3 −α. Hence we get recurrences [wd(v2 ) + wd(v3 ) ; 2α + wd(v3 ) + wd(v2 ) − β + (w3 −α); α + wd(v3 ) − β], (24) where 3 ≤ d(v2 ), d(v3 ) ≤ 5. (v) No two vertices in {v, v1 , v2 , v3 } except v1 and v2 have any common vertex in F \ {t}, v1 and v2 have a common vertex s ∈ F \ {t}, and it holds that GD(v1 ) = {v, v2 , v3 } and GD(v2 ) = {v, v1 , v3 }: Note that d(s) = 2. Hence in the first and second branches, vertex s will be eliminated, and we get the same recurrence (22). (vi) No two vertices in {v, v1 , v2 , v3 } have any common vertex in F \ {t}, and it holds that GD(v1 ) = {v, v2 , v3 } and GD(v2 ) = {v, v1 , v3 }: Hence N (v) = {t, v1 , v2 , v3 }, N (v1 ) = {t, v, v2 , v3 } and N (v2 ) = {v, v1 , v3 } (d(v2 ) = 3). In the third branch of deleting v, vertex v2 becomes a vertex of degree 2 and then will be added to F in Rd, where the weight of v2 changes from w3 to β. Hence we have recurrences [w3 + wd(v3 ) ; 2α + wd(v3 ) + w3 − β; α + wd(v3 ) − β + (w3 − β)],

(25)

where 3 ≤ d(v3 ) ≤ 5. Case 3. Both of v1 and v2 are in N (t), where w(v1 ) = w(v2 ) = α: We only consider the case where v2 ̸∈ GD(v1 ), since otherwise the second branch will be ignored, leading to a much better recurrence. Hence by gd(v1 ) ≥ 3,

22

Mingyu Xiao, Hiroshi Nagamochi

there is a vertex u1 ∈ GD(v1 ) \ {v, v2 , v3 }. Analogously there is a vertex u2 ∈ GD(v2 ) \ {v, v1 , v3 }. In the first branch of including v to F , vertices v1 , v2 ∈ N (t) will be removed from the graph, decreasing the measure by at least 3α + (wd(v3 ) −α). In the second branch of deleting v and v3 from the graph and including vertices v1 , v2 ∈ N (t) to F , v1 and v2 will be contracted into t, and the weight decrease of vertices in {v, v1 , v2 , v3 } is at least α + wd(v3 ) + 2α = 3α + wd(v3 ) . Also each vertex ui (i = 1, 2) will be newly adjacent to t (when ui ∈ U ) or be deleted from G (when ui ∈ N (t)), decreasing the weight of ui by at least wd(ui ) − α (≥ w3 − α) or α. When ui ∈ N (t) for some i = 1, 2 or u1 ̸= u2 , the weight decrease from u1 and u2 is at least min{α, 2(w3 −α)}. When u1 = u2 ̸∈ N (t), vertex u1 = u2 will be removed since the subgraph induced by F ∪ {v1 , v2 , u1 = u2 } contains a cycle, and the weight decrease from u1 = u2 is at least w3 . Note that min{α, 2(w3 −α), w3 } = α by (4). In the third branch of deleting v and including v3 to F , the weight decrease of vertices in {v, v3 } is at least α + (wd(v3 ) − β). Hence we get a recurrence [2α + wd(v3 ) ; 3α + wd(v3 ) + α; α + wd(v3 ) − β], to which some more weight decrease will be included in the following. If there are at least two vertices in GD(v1 ) \ {v, v2 , v3 } (or in GD(v2 ) \ {v, v1 , v3 }), then the weight decrease from the vertices in GD(v1 ) ∪ GD(v2 ) \ {v, v1 , v2 , v3 } in the second branch is at least 2(w3 −α), and we get recurrences [2α + wd(v3 ) ; 3α + wd(v3 ) + 2(w3 − α); α + wd(v3 ) − β],

(26)

where 3 ≤ d(v3 ) ≤ 5. When v3 has a neighbor s ∈ F \ {t}, the measure further decreases by w(s) = β in the third branch, and we obtain recurrences [2α + wd(v3 ) ; 3α + wd(v3 ) + α; α + wd(v3 ) ],

(27)

where 3 ≤ d(v3 ) ≤ 5. Now assume that |GD(v1 ) \ {v, v2 , v3 }| = |GD(v2 ) \ {v, v1 , v3 }| = 1 and N (v3 ) ∩ F = ∅. Then v3 is adjacent to v1 and v2 . In the first branch, vertex v3 with d(v3 ) = 3 (resp., d(v3 ) = 4) will be deleted or (resp., included to F in Rd), and we get recurrences [3α + (wi − δ); 3α + wi + α; α + wi − β] for i = 3, 4, 5,

(28)

where δ = 0 for i = 3, δ = β for i = 4 and δ = α for i = 5. (II) v satisfies GD(v) = {v1 , v2 , v3 } ⊆ N (v): By the definition of optimal vertices, now GD(z) ⊆ N (z) for all neighbors z ∈ N (t) with gd(z) = 3. In the first branch, after including v to F , all vertices in GD(v) ∪ {v} will be deleted in (G′ , F ′ ) = (G, F ∪ {v}). In total, the measure will decrease by at least 4α. For the second branch of generating (G\{v, v3 }, F ∪{v1 , v2 }), we can assume that v1 ̸∈ GD(v2 ) and v2 ̸∈ GD(v1 ), since otherwise the subgraph induced by

An Improved Exact Algorithm for Undirected Feedback Vertex Set

23

F ∪ {v1 , v2 } contains a cycle and this branch will be ignored leading to a much better recurrence. In the second branch, we first consider the case where max{gd(v1 ), gd(v2 )} ≥ 4, say gd(v1 ) ≥ 4. Let x ≥ 1 be the number of vertices in GD(v1 ) ∩ N (t), where v ∈ GD(v1 ) ∩ N (t). When v1 is included to F , the measure will decrease by 2α from {v1 , v2 } and by at least xα +(4−x)(w3−α) ≥ α + 3(w3 −α) from GD(v1 ), where GD(v1 ) ∩ {v1 , v2 } = ∅), In total, the second branch decreases the measure by at least 2α + α + 3(w3 −α) = 3w3 . We now consider the case of max{gd(v1 ), gd(v2 )} = 3. In this case, v1 , v2 ̸∈ GD(v1 ) and GD(v1 ) ⊆ N (t) by the assumption and all vertices in GD(v1 ) will be deleted in this branch. Then the second branch decreases the measure by at least 5α (2α from {v1 , v2 } and 3α from GD(v1 )). Note that min{3w3 , 5α} = 5α by (4). For the third branch of generating (G \{v}, F ∪ {v3 }), we first consider the case of gd(v3 ) ≥ 4. Let x = |GD(v3 ) ∩ N (t)| (≥ 1), where v ∈ GD(v3 ) ∩ N (t). Analogously with the second branch, the third branch decreases the weight of vertices in {v3 } ∪ GD(v3 ) by at least α + xα + (4−x)(w3−α) ≥ 2α + 3(w3−α) = 3w3−α. We now consider the case of gd(v3 ) = 3. In this case, the third branch decreases the measure by at least 4α. Note that min{3w3−α, 4α} = 4α by (4). Hence we can get recurrences [4α; 5α; 4α].

(29)

7.4.7 Branch in Step 8(b). Let v be the optimal vertex selected in Step 8(b). Step 8(b) generates two instances (G, F ∪ {v}) and (G \{v}, F ). See Figure 6 for an illustration.

Fig. 6 Two instances generated by the branching in Step 8(b), where v is a demand-vertex, |Fv | = GD(v) ∩ N (t) = 0 and d(u) ≥ 6 for some neighbor u ∈ GD(v) = N (v) \ {t}.

(I) We first consider the case where v is a trigger-vertex. Let v ′ and s be the associated vertices for the trigger-vertex v. In the first branch of including v to F , the measure decreases by at least wd(v) − β ≥ w3 − β. In the second branch of deleting v from the graph, u will be of degree 2 after the vertex v ′ becomes of degree 1 and is deleted, and vertices u and s are contracted into t, which decreases the weight of vertices in N (s) \ N (t) by at least 2(w3 −α)

24

Mingyu Xiao, Hiroshi Nagamochi

(note that |N (s) \ N (t)| ≥ 2 by |GD(u) \ N (t)| ≥ 3). In total, the measure decreases by at least wd(v) + α + β + 2(w3 −α). Hence we have recurrence [w3 − β; w3 + α + β + 2(w3 −α)].

(30)

(II) Now v is not a trigger-vertex and v is a vertex with gd(v) = 4 or gd(v) ≤ d(v) − 2. Hence if gd(v) ≥ 5, then gd(v) ≤ d(v) − 2 holds and Fv ̸= ∅ since there is a short-cycle which passes through v by Lemma 7. Let r = gd(v) ≥ 4 and x = |GD(v) ∩ N (t)|. We distinguish several cases according to the combinations of |Fv |, gd(v) and x = |GD(v) \N (t)|. Case 1. We first analyze the case of Fv = ∅ (i.e., N (v) ∩ F = {t}). By (6) and (7), we can get recurrence ∑ ∑ [α + xα + (wd(u) −α); α + ∆d(u) ]. u∈GD(v)\N (t)

u∈GD(v)\N (t)

We distinguish four subcases. (i) v is a demand-vertex; i.e., gd(v) = 4, Fv = GD(v)∩N (t) = ∅, and GD(v) = N (v) contains at least one vertex of degree ≥ 6: Let h be the number of vertices of degree ≥ 6 in GD(v), where h ∈ {1, 2, 3, 4}. After the first branch of including v to F , we show in the next subsection that all the h neighbors of degree ≥ 6 become supply-vertices in the resulting instance (G′ , F ′ ). Hence the algorithm then branches on them in Step 6 until it leaves no supply-vertices or executes Step 1 or Step 3. We also prove in the next subsection that a shift λh = min{ min {⌊h/(k + 1)⌋σk }, σ ∗ } 0≤k≤h−1

can be saved from the measure decrease in an execution of Step 1 or Step 3 or an iteration of Step 6 of branching on the h supply-vertices from vertex v. By including the shift λh to the measure decrease in the first branch, we get recurrences [α+h(1−α)+(4−h)(wi −α)+λh ; α+(4−h)∆i ]

(31)

for h = 1, 2, 3, 4 and i = 3, 4, 5, where all vertices of degree ≤ 5 in GD(v) are assumed to be the same degree i by Lemma 5. (ii) gd(z) = r ≥ 5 and Fv = GD(v) ∩ N (t) = ∅, and GD(v) = N (v) contains at least one vertex of degree ≥ 6: Let h be the number of vertices of degree ≥ 6 in GD(v), where 1 ≤ h ≤ r. Analogously with (i), we obtain recurrence [α+h(1−α)+(5−h)(wi −α);+(5−h)∆i ]

(32)

for 1 ≤ h ≤ 5 and i = 3, 4, 5, where we only consider the case of r = 5, which covers the other case of r ≥ 6. (iii) gd(z) = r ≥ 4, Fv = GD(v) ∩ N (t) = ∅, and GD(v) = N (v) consists of r vertices of degree 3, 4 or 5: By Lemma 5, we only need to consider the

An Improved Exact Algorithm for Undirected Feedback Vertex Set

25

cases where the vertices in GD(v) \N (t) are of the same degree i. Then we get recurrence [α + 4(wi −α); α + 4∆i ] for i = 3, 4, 5,

(33)

where we only consider the case of r = 4, which covers the other case of r ≥ 5. (iv) gd(v) = r ≥ 4, Fv = ∅, and |GD(v) ∩ N (t)| ≥ 1: By Lemma 5, we only need to consider the cases where the vertices in GD(v) \N (t) are of the same degree i. Then we get recurrence [α + xα + (4−x)(wi −α); α + (4−x)∆i ],

(34)

for 1 ≤ x ≤ 4, i = 3, 4, 5, 6, where the case of i > 6 is included in the case of i = 6 and we only consider the case of r = 4 which covers the other case of r ≥ 5. Case 2. Fv ̸= ∅: By (6) and (7), we can get recurrences [α + xα + (r−x)(w3 −α) + |Fv |β; α]

for r ≥ 4.

We distinguish two subcases. (i) |Fv | ≥ 2: Since α ≥ w3 −α by α ≥ 0.5 in (4), we consider the case of x = 0 only. From the above, we obtain recurrence [α + 4(w3 −α) + 2β; α],

(35)

where we only consider the case of r = 4 which covers the other case of r ≥ 5. (ii) |Fv | = 1: Let y = |N (v) \ F | = d(v) − 1 − |Fv | (≥ 3 − 1 − 1 = 1), where y ≥ 2 (hence d(v) ≥ 4) holds, since otherwise the vertex in N (v) \ F would be an trigger-vertex which must have been chosen as an optima vertex instead of the current vertex v. For x = 1, we get the next instead of (35): [α + α + (4 − 1)(w3 −α) + β; α],

(36)

where we only consider the case of r = 4 and x = 1, which covers the other cases. Assume that x = 0; i.e., no vertex in GD(v) is adjacent to t. The second branch of deleting v decreases the measure further by at least ∆d(u) , u ∈ N (v) \ F , and we get the following recurrences instead of (35): [α + (4 − y)(w3 −α) + y(wi −α) + β; α + y∆i ]

(37)

for i = 3, 4, 5, 6 and 2 ≤ y ≤ 4, where we only consider the case of r = 4, which covers the other case of r ≥ 5.

26

Mingyu Xiao, Hiroshi Nagamochi

7.4.8 Analysis on Shifts In this subsection, we prove the next lemma. Lemma 8 (i) In Step 8(b), after the first branch of including a demand-vertex v to F , all the h neighbors of degree ≥ 6 of vertex v become supply-vertices in the resulting instance (G′ , F ′ ). (ii) Shift λh can be saved from the measure decrease in an execution of Step 1 or Step 3 or an iteration of Step 6 of branching on the h supply-vertices from vertex v. Assume that a demand-vertex v is selected in Step 8 as an optimal vertex in (G, F ). Let Nv denote the set of the neighbors N (v) \ {t} = GD(v) of v in G, and Nv∗ denote the set of vertices u ∈ Nv of degree ≥ 6. Let (G′ , F ′ ) be the instance obtained by the first branch of including v to F (after contracting v and t into t), where F ′ \ {t} = F \ {t, v}. Note that each vertex u ∈ Nv is a neighbor of the active vertex t in G′ , and has the same degree in G′ . Lemma 9 Each vertex u ∈ Nv satisfies gd(u) ≥ d(u) − 1 in G′ . Proof. Let u ∈ Nv , where u has the same degree both in G and G′ . Assume that gd(u) ≤ d(u)−2 in G′ , and derive a contradiction. Since gd(u) ≤ d(u)−2 in G′ , there is a short-cycle Q which passes through u and some vertex u′ ∈ V (G′ )\F in G′ by Lemma 7. Recall that u ̸∈ N (t) in G since GD(v) ∩ N (t) = ∅ in G. If u′ ̸∈ N (t) in G′ (hence u′ ̸∈ N (t) in G), then u and u′ would be a short-pair when v was selected in Step 8(b) in G, contradicting that any short-pair must have been eliminated in Step 2. Now consider the case where u′ ∈ N (t) in G′ (hence u′ ∈ N (t) in G). By our choice of optimal vertices in Step 8, when a demand-vertex v is selected in Step 8(b), it holds that Fz = ∅ for all neighbors z ∈ N (t) of t. In particular Fu′ = ∅ in G, which contradicts that u′ is adjacent to a vertex in F \ {t} in the short-cycle Q. ⊔ ⊓ Lemma 9 implies Lemma 8(i); i.e., all the h neighbors of degree ≥ 6 of v becomes supply-vertices in the instance (G′ , F ′ ). In what follows, we prove Lemma 8(ii). By Lemma 6, each step in Rd decreases the measure by at least β (≥ σ ∗ ). Also, as already analyzed, when Step 3 in mif(G′ , F ′ ) is applied, we can save shift σ ∗ of any constant from the recurrence. Hence if Step 1 or 3 in mif(G′ , F ′ ) is executed, then we can include at least σ ∗ (≥ λh ) as the shift for the recurrences (31). Now assume that none of Steps 1 and 3 will be executed before Step 5 is executed at least h times. Obviously Step 4 is not applicable as long as there exits at least one supplyvertex in an instance. We show that the condition of Step 2 will not be satisfied before Step 6 is executed at least h times. Recall that no short-pair exits in the instance (G, F ) when the demand-vertex v is selected in Step 8. A new short-pair {u′ , v ′ } is created only when a neighbor s ∈ V ′ \ (F ′ ∪ N (t)) of u′ or v ′ is included to F ′ , which can happen in Step 1 among Steps 1 to 5. Since Step 1 is not applicable before Step 6 is executed at least h times, we see that Step 2 will not be executed either by then.

An Improved Exact Algorithm for Undirected Feedback Vertex Set

27

Assuming that none of Steps 1 to 5 is applied to (G′ , F ′ ) before Step 6 is executed at least h times, our algorithm will branch on one of the supplyvertices in (G′ , F ′ ). Recall that we have saved shift σx from the recurrences for branching on supply-vertex v with x = |GD(v) ∩ N (t)| and |Fv | ≤ 1, and σ ∗ from those for branching on supply-vertex v with |Fv | ≥ 4. Hence we can include the shift min{minx≥0 {σx }, σ ∗ } = σ0 (by (3)) to the recurrences (31). Note that a branching operation of including or excluding a supply-vertex u in Step 6 may change some other supply-vertices u′ into non-supply-vertices. This can occur only when u′ ∈ GD(u) ∩ N (t) holds. Therefore, an operation of including or excluding a supply-vertex u with k = |GD(u) ∩ N (t)| can destroy at most k other supply-vertices in the instance. Thus at most (k + 1) supply-vertices will disappear after branching on such a supply-vertex. Since we have saved shift σk from the recurrences for branching on a supply-vertex u with k = |GD(u) ∩ N (t)|, we can include σk to the recurrences (31) per (k + 1) supply-vertices. Hence when the branch of including a supply-vertex v to F generates h new supply-vertices, the minimum of the total amount of shifts that can be included to the recurrences (31) for the vertex v is at least min0≤k≤h−1 {⌊h/(k + 1)⌋σk }. This proves Lemma 8(ii).

7.5 Final result We build up a quasiconvex program according to the list of recurrences. By solving the program, we obtain the best values w2 = 0.1695, w3 = 0.9760, w4 = 0.9898, α = 0.5176, β = 0.1668, σ ∗ = 0.1189, σ0 = 0.0297, σ1 = 0.0882, and σi = 0.1189 (i ≥ 2) to proved the running time bound of 1.7266n nO(1) . The recurrences that determine the best values are (20) with i = 4, (33) with i = 4, 5, (34) with x = 4, and (37) with y = 2 and i = 6. Theorem 1 The minimum feedback vertex set in an n-vertex undirected graph can be solved in 1.7266n nO(1) time.

8 Concluding Remarks With new reductions based on biconnectivity and a finer analysis using a measure scheme wherein vertices of different degree are distinguished, we improved the running time bound for the maximum induced forest problem (the feedback vertex set problem) from 1.7548n nO(1) to 1.7266n nO(1) . In the previous measure-and-conquer algorithms for MIF, such weight setting has not been used. Furthermore, we introduced several new structural properties for the problem, and our algorithm does not need to invoke any exact algorithm for solving the maximum independent set problem while the previous best algorithm needs to rely on this as a subroutine.

28

Mingyu Xiao, Hiroshi Nagamochi

References 1. Bafna, V., Berman, P., and Fujito, T.: A 2-approximation algorithm for the undirected feedback vertex set problem. SIAM Journal on Discrete Mathematics 12(3) 289–297 (1999) 2. Bourgeois, N., Escoffier, B., Paschos, V. T., and van Rooij, J. M. M.: Fast algorithms for max independent set. Algorithmica 62(1-2) 382–415 (2012) 3. Cao, Y., Chen, J., and Liu, Y.: On feedback vertex set new measure and new structures. In Kaplan, H. (Ed.): Algorithm Theory - SWAT 2010 LNCS 6139 93-104 (2010) 4. Chen, J., Fomin, F., Liu, Y., Lu, S., and Villanger, Y.: Improved algorithms for feedback vertex set problems. J. Comput. Syst. Sci. 74 1188–1198 (2008) 5. Chen, J., Liu, Y., Lu, S., O’Sullivan, B., and Razgon, I.: A fixed-parameter algorithm for the directed feedback vertex set problem. J. ACM 55 1–19 (2008) 6. Dehne, F., Fellows, M., Langston, M., Rosamond, F., and Stevens, K.: An O(2O(k) n3 ) FPT algorithm for the undirected feedback vertex set problem. In: COCOON 2005. LNCS 3595 859–869 (2005) 7. Dwork, C., Kumar, R., Naor, M., and Sivakumar, D.: Rank aggregation revisited. Manuscript (2001). 8. Even, G., Naor, J., Schieber, B., and Sudan, M.: Approximating minimum feedback sets and multicuts in directed graphs. Algorithmica 20 151–174 (1998) 9. Festa, P., Pardalos, P. M., and Resende, M. G. C.: Feedback set problems. In Handbook of Combinatorial Optimization, Vol. A, Kluwer Acad. Publ., Dordrecht, 209–258 (1999) 10. Fomin, F. V., Gaspers, S., Pyatkin, A. V., and Razgon, I.: On the minimum feedback vertex set problem: exact and enumeration algorithms. Algorithmica 52(2) 293–307 (2008) 11. Fomin, F. V., Grandoni, F., and Kratsch, D.: A measure & conquer approach for the analysis of exact algorithms. J. ACM 56(5) 1–32 (2009) 12. Guo, J., Gramm, J., Huffner, F., Niedermeier, R., and Wernicke, S.: Compression-based fixed-parameter algorithms for feedback vertex set and edge bipartization. J. Comput. Syst. Sci. 72 1386–1396 (2006) 13. Karp, R. M.: Reducibility Among Combinatorial Problems. In Miller, R.M. and Thatcher, J.W. (editors): Complexity of Computer Computations. Plenum Press. Nwe York 85–103 (1972) 14. Kemeny, J. and Snell, J.: Mathematical models in the social sciences. Blaisdell (1962) 15. Silberschatz, A. and Galvin, P.: Operating System Concepts, 4-th ed., Addison-Wesley, 1994. 16. Razgon, I.: Exact computation of maximum induced forest. In: Proceedings of the 10th Scandinavian Workshop on Algorithm Theory (SWAT 2006). LNCS 4059 160–171 (2006) 17. Razgon, I.: Computing minimum directed feedback vertex set in O(1.9977n ). In: Theoretical Computer Science, 10th Italian Conference. ICTCS 2007. Rome, Italy 70-81 (2007) 18. Xiao, M. and Nagamochi, H.: A refined exact algorithm for edge dominating set. In: TAMC 2012. LNCS 7287 360–372 (2012) 19. Xiao, M. and Nagamochi, H.: Exact algorithms for maximum independent set. In: ISAAC 2013. LNCS 8283 328–338 (2013)