An Improved Exact Algorithm for Undirected Feedback Vertex Set

Transcription

1 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 n n O(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 2 n. Later, Fomin et al. (Algorithmica 2008) improved the result to n n O(1). In this paper, we further improve the result to n n O(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 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 , China Tel.: Fax: myxiao@gmail.com H. Nagamochi Department of Applied Mathematics and Physics, Graduate School of Informatics, Kyoto University, Yoshida Honmachi, Sakyo, Kyoto , Japan nag@amp.i.kyoto-u.ac.jp

2 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.83 k kn 2 ) 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 2 n n O(1) time for both UFVS and DFVS were developed recently. Based on a good choice of the measure to problem instances, a n n O(1) -time algorithm for UFVS was designed by Razgon [16], and later the running time was improved to n n O(1) by Fomin et al. [10]. Razgon [17] also broke the barrier 2 n for DFVS by giving a n n O(1) -time algorithm. In this paper, we will design a n n O(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.

3 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 {T 1, T 2,..., T k } denotes the set of connected components of G[F ], let G be the graph obtained from G by contracting each connected component T i of G[F ] into a single vertex z i, and let F = {z 1,..., z k } 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 2 n n O(1). However, in the first branch we observe more information: the vertices in N(v) \ N(t) will become neighbors

4 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( w ) by choosing α = That is how Razgon [16] obtained the first exact algorithm that breaks the barrier of 2 n 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( w ) with α = 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} = {v 1, v 2,..., v d } 1. v S; 2. (D(v) {v}) S = {v 1, v 2 }; and 3. {v, v i, v i+1,..., v d } S = {v i } for some i {3,..., d}, where D(v) 3.

5 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 v 1 and v 2 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 v 1 and v 2 to F and deleting v, or by including v 3 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) = {v 1, v 2,..., v d } (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 = {v 1, v 2 }; and 3. {v, v i, v i+1,..., v d } S = {v i } 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 v i S, where i 2. If i = 2, then we have the second condition. Otherwise for i 3 we have the third condition.

6 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) = {u 1, u 2 }. 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 {u 1, v, u 2 }. We first claim that such a cycle C is unique. If G[S {v}] contains two such cycles C 1 and C 2, then C 1 {v} and C 2 {v} are paths between u 1 and u 2, and the union of C 1 {v} and C 2 {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

7 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 F 1 = F (V (H) {v}), G 1 = G[V (H) {v}], F 2 = F \V (H), G 2 = G \V (H), and Fi = F i {v}, i = 1, 2. (i) Assume that v F. Then an F -MIF of (G, F ) is obtained by the union of any F 1 -MIF of I 1 = (G 1, F 1 ) and F 2 -MIF of I 2 = (G 2, F 2 ). (ii) Assume that v F and S 1 > S 1 for an F 1 -MIF S 1 of I 1 = (G 1, F 1 ) and an F 1-MIF S 1 of I H = (H, F 1 = F V (H)). Then an F -MIF of (G, F ) is obtained by the union of S 1 \{v} and S 2 for any F 1 -MIF S 1 of I 1 = (G 1, F 1 ) and F 2 -MIF S 2 of I 2 = (G 2, F 2 ).

8 8 Mingyu Xiao, Hiroshi Nagamochi (iii) Assume that v F and S 1 S 1 for an F 1 -MIF S 1 of I 1 = (G 1, F 1 ) and an F 1-MIF S 1 of I H = (H, F 1 = F V (H)). Then an F -MIF of (G, F ) is obtained by the union any F 1 -MIF of I H = (H, F 1 ) and F 2-MIF of I H = (G \(V (H) {v}), F 2 = F \(V (H) {v})). Proof. (i) Let S 1 be an F 1 -MIF of (G 1, F 1 ) and S 2 be an F 2 -MIF of (G 2, F 2 ). We show that the union S = S 1 S 2 is a feasible solution to (G, F ). Since F 1 F 2 F, S contains F. Since v is contained in both S 1 and S 2 and G has no cycle passing through v, no new cycle will appear in the union G[S] of G[S 1 ] and G[S 2 ]. 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 F 1 -MIF in (G 1, F 1 ) (resp., F 2 -MIF in (G 2, F 2 )) and S (V (H) {v}) S 1 (resp., S \V (H) S 2 ) holds by the optimality of S 1 (resp., S 2 ). This implies that S = S (V (H) {v}) + S \V (H) 1 S 1 + S 2 1 = S, as required. (ii) Note that S 1 > S 1 implies S 1 1 = S 1, since S 1 \{v} is a feasible solution to forced MIF in (H, F 1 ). Let S 1 be an F 1 -MIF of (G 1, F 1 ) and S 2 be an F 2 -MIF of (G 2, F 2 ). We show that the union S = (S 1 \{v}) S 2 is a feasible solution to (G, F ). Since F 1 F 2 F, the union S contains F. Note that G[{v} (S 1 \{v})] = G[S 1] is acyclic even if v S 2. 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 F 1-MIF in (H, F 1) (resp., F 2 -MIF in (G 2, F 2 )) and S V (H) S 1 (resp., S \V (H) S 2 ) holds by the optimality of S 1 (resp., S 2 ). This implies that S = S V (H) + S \V (H) S 1 + S 2 = S 1 \{v} + S 2 = S, as required. (iii) Let S 1 be an F 1-MIF of (H, F 1) and S 2 be an F 2-MIF of (G \(V (H) {v}), F 2 = F \(V (H) {v})). We show that the union S = S 1 S 2 is a feasible solution to (G, F ). Since F 1 F 2 F, S contains F. Since v V (H) V (G \ (V (H) {v})), G[S] is a disjoint union of acyclic graphs G[S 1 ] and G[S 2 ]. 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 F 1-MIF in (H, F 1) (resp., F 2-MIF in (G \(V (H) {v}), F 2)) and S V (H) S 1 (resp., S \(V (H) {v}) S 2 ) holds by the optimality of S 1 (resp., S 2 ), indicating that S = S V (H) + S \(V (H) {v}) S 1 + S 2 = S. Now consider the case of v S. Then S (V (H) {v}) (resp., S \(V (H) {v})) is a feasible solution to F 1 -MIF in (G 1, F 1 ) (resp., F 2-MIF in (G\(V (H) {v}), F 2)) and S (V (H) {v}) S 1 (resp., S \(V (H) {v}) S 2 ) holds by the optimality of S 1 (resp., S 2 ), where we have S S 1 + S 2 S 1 + S 2 = S by the assumption S 1 S 1.

9 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 I 1 and I 2 in (i) of the lemma. If v is not in F, we first compute I1 and I H in (ii) or (iii) of the lemma and then compute either I 2 or I H in (ii) or (iii) of the lemma according to the solutions to I1 and I H. 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 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) = {v 1, v 2 }, and return a maximum one from { mif(g, F {v}), mif(g \{v}, F {v 1, v 2 }) }. 8. Elseif select an optimal vertex v V \ F. (a) If {gd(v) = 3 but v is not a trigger vertex}, let GD(v) = {v 1, v 2, v 3 } so that v 3 N(t) (if possible) and d(v 3 ) is maximized (otherwise), and return a maximum one from {mif(g, F {v}), mif(g \ {v, v 3 }, F {v 1, v 2 }), mif(g \{v}, F {v 3 }) }. (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 {v 1, v 2 } 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

11 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 F v 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 F v, 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 α = , 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 n n O(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 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 n n O(1) to n n O(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, a i, b i, i = 1, 2,..., l (l 1), the maximum of C(w ( k i a i +c)) + C(w ( k i b i +d)) i=1,2,...,l i=1,2,...,l over all k 1, k 2,..., k l 0 subject to k 1 + k k l = p is equal to the maximum of C(w (pa i +c)) + C(w (pb i +d)) over all i = 1, 2,..., l. 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

13 An Improved Exact Algorithm for Undirected Feedback Vertex Set 13 operation B is always applied to the subinstance G 1 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 a 1 ) + C(w a 2 ) + + C(w a k ) as [a 1 ; a 2 ;... ; a k ], 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 i if v U and d(v) = i for i {2, 3, 4} 1 if v U and d(v) 5, where w i is the weight of a vertex v U of degree i 0 such that w 0 = w 1 = 0 and w j = 1 for all j 5. We will determine the best value of β, α, w 3 and w 4 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 < β w 2 w 3 w 4 1 and max{β, 0.5} α min{(3/5)w 3, (2w 3 β)/3}. (4) Let i (i 1) denote w i w i 1, where i 0 holds for each i 1. Recall that we denote F v = N(v) (F \{t}) for each vertex v V \F.

14 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 w d(v) to α + β, and the weight of each neighbor u N(v) \F of v decreases from w(u) = w d(u) to α. In total, the measure w decreases by at least w = w d(v) (α + β) + (w d(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 F v. 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) = w d(u) to α. We see that the weight of some vertices in F also decreases. After including v to F, all vertices in {t, v} F v will be contracted into a new active vertex. This decreases the weight of each vertex in F v by β. In total, the decrease of the measure w is at least w = α + GD(v) N(t) α + (w d(u) α) + F v β. (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) = w d(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.

15 An Improved Exact Algorithm for Undirected Feedback Vertex Set 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 w d(u). However, the measure decreases by at least α + β (w d(u) α) 2α 1 + β ( β by (4)). Step 4 moves a vertex v V (G ) \ F to F, which decreases the measure by w d(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 F v + gd(v) F v + N(v)\F = d(v) 1 for any vertex v N(t). Since F v +gd(v) d(v) 1 in G, it holds F v d(v) 1 gd(v) 1 by gd(v) d(v) 2. In a reduced instance, each vertex a F v has a neighbor u a N(a) \ (F {v}). If two distinct vertices a, b F v share a common neighbor u a = u b V (G) \ {v}, then vav b for v = u a = u b forms a short-cycle. Assume that no two vertices in F v share a common neighbor. Then there is some vertex a F v such that N(v) contains its neighbor u a V (G)\{v}, since otherwise gd(v) N(v)\F v + F v d(v) would hold. In this case, triangle vav for v = u a is a short-cycle 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 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) (w 3 β) + w 3 and the second of deleting v from G decreases the measure by at least w(v) w 3. Hence we have recurrence [(w 3 β) + w 3 ; w 3 ]. (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 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 three instances I1, I H and I 2 (or I H ). For a subgraph H of G, let w(h ) 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(g 1 ) 0.5 V and w(g 2 ) 0.5 V β V by (4), where G 1 and G 2 are graphs defined in Lemma 4. Since w(g) = w(g 1 ) + w(g 2 ) > w(g 1 ) V > w(g 1 ) w(G 1 ), then it holds w(g 1 ) < 1/1.01w(G) < 0.991w(G). Also, since w(g) = w(g 1 )+w(g 2 ) < 0.5 V +w(g 2 ) < 100w(G 2 )+ w(g 2 ) = 101w(G 2 ), we have w(g 2 ) > 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.7 w satisfies the above recurrence for any constant σ 0. After Step 3, the graph G in an instance (G, F ) consists of only biconnected components 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) = w d(u) w 3 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 [w 3 (α + β) + z(w 3 α) + (3 z)(w 4 α); w 3 + z(w 3 w 2 )] for z = 0, 1, 2, 3. (9)

17 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 w 3 α. Hence in this step the measure decreases directly by at least 2(w 3 α) α = 2w 3 3α ( β by (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 By (6) and (7), we can get recurrence r = gd(v) 5 and x = GD(v) N(t). [α + xα + u GD(v)\N(t) (w d(u) α) + β F v ; α + 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 F v 3, and σ from those with F v 4. We distinguish two cases. Case 1. F v = : 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)(w i α) σ 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. F v : (i) F v = 1: In this case, y = N(v) \ F = d(v) 1 F v = 4. When x 4, we obtain recurrences [α + xα + (r x)(w 3 α) + β σ 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)(w 3 α) + (4 x)(w i α) + β σ 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) F v = 2: Now y 3. Analogously with (i), we get recurrences [α + xα + (r x)(w 3 α) + 2β σ x ; α σ x ] for 3 x 5 and r = 5, (13)

18 18 Mingyu Xiao, Hiroshi Nagamochi and [(x+1)α + (r 3)(w 3 α) + (3 x)(w i α) + 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) F v = 3: Now y 2. Analogously with (i), we get recurrences [α + xα + (r x)(w 3 α) + 3β σ x ; α σ x ] for r = 5 and 2 x r; (15) and [(x+1)α + (r 2)(w 3 α) + (2 x)(w i α) + 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) F v 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(w 3 α) + 4β σ ; α σ ]. (17) 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) = {v 1, v 2 } 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, v 1 GD(v) N(t) and v 2 GD(v) \N(t)

19 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)(w 3 α). 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)(w 3 β). Then we get recurrences [α + xα + (2 x)(w 3 α); α + xα + (2 x)(w 3 β)] for x = 0, 1, 2. (18) Branch in Step 8(a). Let v be the optimal vertex of gd(v) = 3 selected in Step 8(a), and let GD(v) = {v 1, v 2, v 3 }. Step 8(a) will generate three instances (G, F ) {(G, F {v}), (G \ {v, v 3 }, F {v 1, v 2 }), (G \ {v}, F {v 3 })}. 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), {v 1, v 2, v 3 } N(t) = and F v = 1. We distinguish subcases. (I) GD(v) contains a non-neighbor v of t: By the choice of indices of v i GD(v) in Step 7(a), it holds v 3 N(t), where w(v 3 ) = w d(v3) w 3. We here distinguish three cases. Case 1. Both v 1 and v 2 are not in N(t), where w(v i ) = w d(vi) w 3, i = 1, 2: (i) F v 1: Let s F v. 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 2 [α+ (w d(vi ) α)+β; α+w d(v3 )+ (w d(vi ) β)+δβ; α+(w d(v3 ) β)+(1 δ)β], i=1 i=1

20 20 Mingyu Xiao, Hiroshi Nagamochi where d(v 1 ), d(v 2 ), d(v 3 ) 3 and δ {0, 1}. Since w(v i ) w 3 for i = 1, 2, 3, we only need to consider the recurrences with w(v 1 ) = w(v 2 ) = w(v 3 ) = w 3 : [3w 3 2α + β; α + 3w 3 2β + δβ; α + w 3 β + (1 δ)β] (δ {0, 1}).(19) (ii) F v = 0: Then {v 1, v 2, v 3 } N(v) and thereby the third branch of removing v will decrease the degree of v i (i = 1, 2) by 1. Then we get recurrences [α + 3 (w d(vi ) α); α + w d(v3 ) + i=1 2 (w d(vi ) β); α + (w d(v3 ) β) + i=1 2 d(vi )], where d(v 3 ) max{d(v 1 ), d(v 2 )} by the choice of indices of v i GD(v). By Lemma 5 and d(v 3 ) 3, we only need to consider the recurrences with d(v 1 ) = d(v 2 ) = d(v 3 ) {3, 4, 5, 6}: where i = 3, 4, 5, 6. [3w i 2α; α + 3w i 2β; α + (w i β) + 2 i ], (20) Case 2. Exactly one of v 1 and v 2, say v 1, is in N(t), where w(v 1 ) = α and w(v 2 ) = w d(v2) w 3 : Vertex v 1 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 (w d(vi) α); α + w d(v3) + α + (w d(v2) β); α + (w d(v3) β)] i=2 for 3 d(v 2 ), d(v 3 ) 6. We show that some more weight decrease can be obtained in one of the three branches. (i) v and v 3 have a common vertex s F \ {t}: In the first and third branches, vertex s will be merged with t or v 3, and we get recurrences [w d(v2 ) + w d(v3 ) + β; 2α + w d(v3 ) + w d(v2 ) β; α + w d(v3 )], (21) where 3 d(v 2 ), d(v 3 ) 5. (ii) v and v i 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 v i, and we get recurrences [w d(v2 ) + w d(v3 ) + β; 2α + w d(v3 ) + w d(v2 ); α + w d(v3 ) β], (22) where 3 d(v 2 ), d(v 3 ) 5. (iii) v 3 and v i for some i = 1, 2 have a common vertex s F \ {t}: In the second and third branches, vertex s will be merged with v i or v 3, and we get recurrences [w d(v2 ) + w d(v3 ); 2α + w d(v3 ) + w d(v2 ); α + w d(v3 )], (23) where 3 d(v 2 ), d(v 3 ) 5. i=1

21 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), {v 1, v 2, v 3 } N(t) = {v 1 } and GD(v 1 ) \ {v, v 2, v 3 } =. (iv) GD(v 1 ) \ {v, v 2, v 3 } = (resp., GD(v 1 ) = {v, v 2, v 3 } and GD(v 2 ) \ {v, v 1, v 3 } ): Figure 5 illustrates the case of GD(v 1 ) \ {v, v 2, v 3 } =. In this case, the second branch of including vertices v 1, v 2 N(t) to F actually contracts them into t, and then any vertex u GD(v 1 ) \ {v, v 2, v 3 } (resp., u GD(v 2 ) \ {v, v 1, v 3 }) 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{w d(u) α, α} w 3 α. Hence we get recurrences [w d(v2) + w d(v3); 2α + w d(v3) + w d(v2) β + (w 3 α); α + w d(v3) β], (24) where 3 d(v 2 ), d(v 3 ) 5. (v) No two vertices in {v, v 1, v 2, v 3 } except v 1 and v 2 have any common vertex in F \ {t}, v 1 and v 2 have a common vertex s F \ {t}, and it holds that GD(v 1 ) = {v, v 2, v 3 } and GD(v 2 ) = {v, v 1, v 3 }: 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, v 1, v 2, v 3 } have any common vertex in F \ {t}, and it holds that GD(v 1 ) = {v, v 2, v 3 } and GD(v 2 ) = {v, v 1, v 3 }: Hence N(v) = {t, v 1, v 2, v 3 }, N(v 1 ) = {t, v, v 2, v 3 } and N(v 2 ) = {v, v 1, v 3 } (d(v 2 ) = 3). In the third branch of deleting v, vertex v 2 becomes a vertex of degree 2 and then will be added to F in Rd, where the weight of v 2 changes from w 3 to β. Hence we have recurrences [w 3 + w d(v3 ); 2α + w d(v3 ) + w 3 β; α + w d(v3 ) β + (w 3 β)], (25) where 3 d(v 3 ) 5. Case 3. Both of v 1 and v 2 are in N(t), where w(v 1 ) = w(v 2 ) = α: We only consider the case where v 2 GD(v 1 ), since otherwise the second branch will be ignored, leading to a much better recurrence. Hence by gd(v 1 ) 3,