Theoretical Computer Science 535 (2014) 25–30

Contents lists available at ScienceDirect

Theoretical Computer Science

www.elsevier.com/locate/tcs

An improved parameterized algorithm for the independentfeedback vertex set problem

Yinglei Song 1

School of Computer Science and Engineering, Jiangsu University of Science and Technology, Zhenjiang, Jiangsu 212003, China

a r t i c l e i n f o a b s t r a c t

Article history:Received 2 August 2013Received in revised form 14 March 2014Accepted 27 March 2014Communicated by V.Th. Paschos

Keywords:Independent feedback vertex setParameterized algorithmDynamic programming

In this paper, we develop a new parameterized algorithm for the Independent Feedback

Vertex Set problem. Given a graph G = (V , E), the goal of the problem is to determinewhether there exists a vertex subset F ⊆ V such that V − F induces a forest in G andF is an independent set. We show that there exists a parameterized algorithm that candetermine whether a graph contains an IFVS of size k or not in time O (4kn2). To ourbest knowledge, this result improves the known upper bound for this problem, which isO (5knO (1)).

© 2014 Elsevier B.V. All rights reserved.

1. Introduction

A feedback vertex set (FVS) in a graph G = (V , E) is a vertex subset F ⊆ V such that vertices in V − F induce a forestin G . Feedback vertex sets have important applications in deadlock recovery in the development of operating systems [23]and database management systems [17]. Moreover, F is an independent feedback vertex set (IFVS) if it induces an independentset in G . In contrast to the fact that a graph always has an FVS, a graph (such as a clique) may not always have an IFVS.

In the past two decades, the FVS problem has been intensively studied. The goal of the problem is to determine whethera graph contains an FVS of size k or not. In [14], it is shown that the problem is NP-complete. So far, a few exact algorithmshave been developed to compute a minimum FVS in a graph. For example, in [21], an algorithm that needs O (1.9053n)

time was developed to find a minimum FVS in a graph, this algorithm is also the first one that breaks the trivial O (2nn)

bound. In [9], an elegant algorithm that can enumerate all induced forests in a graph is used to find the minimum FVS. Thisalgorithm needs O (1.7548n) computation time. Recently, the upper bound of this problem is improved to O (1.7347n) [10].

In practice, efficient solutions exist for some NP-hard problems when some or all of the parameters in these problemsare small integers. A well known example is the Vertex Cover problem [7,18]. Given a parameter k and a graph G = (V , E),a simple parameterized algorithm can decide whether G contains a vertex cover of size at most k in time O (2k|V |) [7,18].This algorithm is efficient and can be used in practice when the parameter k is a fixed small integer.

An NP-hard problem is fixed parameter tractable if it can be solved in time O (g(p1, p2, . . . , ps)nc), where n is the sizeof the problem, p1, p2, . . . , ps are the parameters in the problem, g is a function of p1, p2, . . . , ps and c is a constant thatdoes not depend on any of the parameters. In the past decades, a large number of NP-hard problems have been shownto be fixed parameter tractable [7,18]. However, not all NP-hard problems are known to be fixed parameter tractable, the

E-mail address: yingleisong@gmail.com.1 The majority of this work is done when the author was working in the Department of Mathematics and Computer Science at University of Maryland

Eastern Shore, USA. This work is supported in part by the University Research Fund of Jiangsu University of Science and Technology, under the GrantNumber 635301202.

http://dx.doi.org/10.1016/j.tcs.2014.03.0310304-3975/© 2014 Elsevier B.V. All rights reserved.

26 Y. Song / Theoretical Computer Science 535 (2014) 25–30

Independent Set problem is one of them [8]. Many of these problems are believed to be parameterized intractable and anumber of complexity classes have been identified to describe their parameterized complexity [8].

The parameterized FVS problem uses the size of an FVS as the parameter k. In [1,5–8,11–13,19,20], it is shown that theproblem is fixed parameter tractable and a few algorithms that can solve the problem in time O (2O (k)nO (1)) are developed.In [3], it is shown that the problem can be solved in time O (5kkn2). In [2], the upper bound of this problem is furtherimproved to O (3.83kkn2). Recently, a faster algorithm that needs O ∗(3.592kn2) time is developed in [15]. This algorithm iscurrently the best algorithm known for the FVS problem. In [4], a new technique is developed for connectivity problemsparameterized by tree width and it is shown that the FVS problem can be solved by a randomized algorithm in timeO ∗(3kn2).

Although the FVS problem has attracted a lot of attention from researchers in computer science, little effort has beenmade toward the IFVS problem. Recently, it is shown that the FVS problem can be reduced to the IFVS problem in poly-nomial time while preserving the parameter k [16]. The reduction is simply subdividing each graph edge once. The IFVSproblem is thus more general than the FVS problem.

In [16], an algorithm that needs O (5knO (1)) time is developed for the IFVS problem. The algorithm starts by applyingtwo reduction rules to remove all vertices of degree at most one from the graph and then uses the algorithm developed in[2] to obtain an FVS of size k. The algorithm returns “no” if no such FVS exists. Based on such an FVS, a branching approachis used to analyze the graph and determine whether it contains an IFVS of size k or not. It is also shown in [16] that theIFVS problem has a kernel of size O (k3).

In this paper, we develop a new parameterized algorithm that can determine whether a graph contains an IFVS of size kor not in time O (4kn2). Our algorithm follows the iterative compression approach developed in [22]. This technique has beenused to develop parameterized algorithms for many problems [5,6,12]. Specifically, given a graph G = (V , E), where V ={v1, v2, v3, . . . , vn}, the approach starts with an empty graph and adds vertices one by one in the order of v1, v2, v3, . . . , vn

to reconstruct G . When vi (1 � i � n) is added, edges are also added to join vi with its neighbors in {v1, v2, . . . , vi−1}. Wedenote the graph induced on vertices v1, v2, . . . , vi in G by Gi . In other words, Gi = G[{v1, v2, . . . , vi}]. It is clear that aseries of graph G0, G1, . . . , Gn can be constructed as the vertices are added to the graph, where G0 is an empty graph andGn = G . The approach starts with Gk since Gk trivially contains an IFVS of size k, each Gi (k + 1 � i � n) is processed todetermine whether it contains an IFVS of size k or not. If the answer is “yes”, the approach finds such a set Fi in Gi andcontinues to process Gi+1, otherwise the approach outputs “no” since G does not contain an IFVS of size k if one of itssubgraph does not contain such an IFVS. The approach outputs “yes” if eventually G is found to contain an IFVS of size k.A detailed description of the approach can be found in [22] and some other related work such as [5,6,12].

It is not difficult to see that, the key part of the above approach is to develop an algorithm that can determine whetherGi+1 contains an IFVS of size k or not, given an FVS Li+1 of size k + 1 in Gi+1, where Li+1 = Fi ∪ {vi+1}. The majorcontribution of this paper is the development of such an algorithm. We need to emphasize here that Li+1 may not be anIFVS of Gi+1. However, we show later that our algorithm only needs the fact that it is an FVS of Gi+1. Other than usinga branching approach, the algorithm uses a dynamic programming based approach to accomplish the task in time O (4kn).Since G contains n vertices in total, the total amount of computation time needed by the approach is thus at most O (4kn2).Based on the simple parameter preserving polynomial time reduction that reduces the FVS problem to IFVS problem, wealso immediately obtain a parameterized algorithm that solves the FVS problem in time O (4kn2).

2. Notations and preliminaries

The graphs in this paper are undirected graphs without loops. For a given graph G = (V , E) and a vertex subset V ′ ⊆ V ,G[V ′] is the subgraph induced on the vertices in V ′ . A vertex u is a neighbor of V ′ if it is joined to one of the vertices inV ′ by an edge in G ′ . We use NG [V ′] to denote the set of neighbors of V ′ in G . We may omit the subscript G when theunderlying graph is clear in the context. Given two graphs G1 = (V 1, E1) and G2 = (V 2, E2), we use G1 ∪ G2 to denote thegraph (V 1 ∪ V 2, E1 ∪ E2). Furthermore, to simplify the notation, we use G − V ′ to denote subgraph G[V − V ′]. A vertexsubset V ′ is a feedback vertex set in G if G − V ′ is a forest. The objective of our algorithm is to find a feedback vertex setthat contains the minimum number of vertices and also induces an independent set.

3. The algorithm

Our algorithm is based on the following lemma.

Lemma 3.1. Given a graph G = (V , E) and an FVS F in G, a minimum IFVS in G can be computed in time O (4|F ||V |).

Proof. Since F is an FVS, G[V − F ] is a forest. As the first step of the algorithm, we arbitrarily choose a vertex in each treein G[V − F ] as the root of the tree. We color each vertex in V − F with black. We then check the number of children ofeach vertex in the tree and find those that have more than two children. For each such vertex u, we remove the edges thatjoin it with its children c1, c2, . . . , cd , where d is the number of children in the tree. We then create a path of white verticesw1, w2, . . . , wd−1. wd−1 is joined to u with an edge. To construct a binary tree, w1 is joined to c1 and c2 with two edges

Y. Song / Theoretical Computer Science 535 (2014) 25–30 27

Fig. 1. The description of how the algorithm converts a tree in G[V − F ] into a binary tree. (a) An internal node u that has d children c1, c2, . . . , cd ;(b) A path of d − 1 white vertices w1, w2, . . . , wd−1 are added to convert the tree into a binary tree.

and each white vertex wt (2 � t � d − 1) in the path is joined to ct+1 with an edge. Each white vertex wt is said to beequivalent to u. We use H to denote the resulting forest. The number of white vertices in H is at most

|V |−|F |∑i=1

(di − 1)�(|V | − |F |) (1)

where di ’s are the degrees of all vertices in G[V − F ]. The number of vertices in H is thus at most 2(|V | − |F |). Fig. 1illustrates the approach the algorithm uses to convert a tree in G[V − F ] into a binary tree.

In order to find a minimum IFVS F ′ , we consider the vertices in F ′ ∩ F first. We enumerate all subsets in F . For eachsuch subset S , we check whether S is an independent set and G[F − S] is acyclic, if it is not the case, S cannot be F ′ ∩ Fand we can continue to the next subset. Otherwise, we need to find a minimum subset S ′ ⊆ G − F such that S ′ ∪ S form anIFVS in G .

Without loss of generality, we assume G[F − S] contains l connected components C1, C2, . . . , Cl and let C ={C1, C2, . . . , Cl}. Since H is a forest, for each tree Ti ∈ H , we use a dynamic programming algorithm to find a minimumsubset S ′

i in Ti such that (Ti − S ′i) ∪ (F − F ′) is acyclic. We then obtain S ′ by taking the union of S ′

i ’s for all Ti ’s in G − F .We use ri to denote the root of Ti . The algorithm starts with the leaves of the Ti and follows a bottom–up order to scan

through all vertices in Ti . For a tree node u in Ti and a set Su ⊆ C , we consider the following two cases.

1. u is not in the IFVS, there exists a path that connects u to each component in Su in the subtree rooted at u in Ti .Moreover, none of the vertices in the path are in the IFVS,

2. u is in the IFVS.

The algorithm maintains dynamic programming table M[u, Su] for case 1 and table P [u] for case 2. The two tables storethe minimum number of vertices that can be included in the IFVS in the subtree rooted at u.

For a leaf node v of Ti and a subset S v of connected components in G[V − F ], the values of M[v, S v ] are initialized tobe 0 if S v is the set of components that are directly connected to v with an edge. Otherwise, M[v, S v ] is set to be |V | + 1.If v ∈ NG(S), v is not in the IFVS, we thus set P [v] to be |V | + 1, otherwise P [v] is set to be 1.

For an internal node u in Ti , since Ti is a binary tree, we use c1, c2 to denote its children in Ti . In the case whereu ∈ NG(S), u cannot be in the IFVS and we thus set P [u] to be |V | + 1. Otherwise, both M[u, P [u]] and P [u] need to bedetermined with the recursion relations of the dynamic programming.

Next, we determine the recursion relations of the dynamic programming. For a black vertex u, we use W u to denote theset of connected components in G[F − S] that are directly connected to u with an edge. If W u contains a component thatis not in Su , M[u, Su] is set to be |V | + 1, since u is connected to any component in W u regardless of its child nodes in Ti .For a white vertex u, Wu = Wb , where b is the black vertex that is equivalent to u in Ti . The algorithm thus only needs tocompute the values of M[u, Su] for those Su ’s that are supersets of W u .

We now assume Wu ⊂ Su and u has two children. Based on the color of u, we use the following recursion relations tocompute M[u, W u] and M[u, Su], if u is a black vertex, the recursion relation to compute M[u, Su] are as follows.

M[u, Wu] = min

⎧⎪⎪⎨⎪⎪⎩

M[c1, ε] + M[c2, ε]M[c1, ε] + P [c2]P [c1] + M[c2, ε]P [c1] + P [c2]

(2)

M[u, Su] = min

⎧⎨⎩

minSc1 ,Sc2{M[c1, Sc1 ] + M[c2, Sc2 ]}

M[c1, Su − Wu] + P [c2] (3)

P [c1] + M[c2, Su − Wu]

28 Y. Song / Theoretical Computer Science 535 (2014) 25–30

where Sc1 and Sc2 are disjoint subsets of Su and Su − Wu = Sc1 ∪ Sc2 . The algorithm exhaustively enumerates all suchsubsets and computes the minimum value of M[c1, Sc1 ] + M[c2, Sc2 ] over all possible subsets Sc1 and Sc2 .

If u is a white vertex and both c1 and c2 are black vertices, the recursion relation to compute M[u, Su] is the same asabove. If u is white and one of c1, c2 is white, without loss of generality, we assume c1 is white. Since u and c1 representthe same vertex in G , if u is not in the IFVS, c1 cannot be in the IFVS. The recursion relation is thus as follows.

M[u, Wu] = min

{M[c1, Wu] + M[c2, ε]M[c1, Wu] + P [c2] (4)

M[u, Su] = min

{minSc1 ,Sc2

{M[c1, Sc1 ∪ Wu] + M[c2, Sc2 ]}M[c1, Su] + P [c2] (5)

where Sc1 and Sc2 are disjoint subsets of Su and Sc1 ∪ Sc2 = Su − Wu .If u is black and u /∈ NG(S), since none of c1 and c2 are included in the IFVS, the recursion relation to compute P [u] is

as follows.

P [u] = minSu

{M[c1, Su]} + min

Su

{M[c2, Su]} + 1 (6)

where the minimum is taken over all possible subsets Su of C .If u is white, u /∈ NG(S), and both c1 and c2 are black, the recursion for computing P [u] is the same as above. If u is

white and one of c1, c2 is white, without loss of generality, we assume c1 is white. Since u and c1 represents the samevertex and c2 is not included in the IFVS, the recursion relation is as follows.

P [u] = P [c1] + minSu

{M[c2, Su]} (7)

where the minimum is taken over all possible subsets Su of C .If u has only one child, u must be black and we use c to denote its child. If c is black, we use the following recursion

relations to compute M[u, W u], M[u, Su], and P [u].

M[u, Wu] = min{

M[c, ε], P [c]} (8)

M[u, Su] = M[c, Su − Wu] (9)

P [u] = minSu

{M[c, Su]} + 1 (10)

where the minimum is taken over all possible subsets Su of C .If c is white, c is equivalent to u, we use the following recursion relations to compute M[u, Su] and P [u].

M[u, Su] = M[c, Su] (11)

P [u] = P [c] (12)

After the dynamic programming tables are filled by the algorithm, for each Ti (1 � k � l), we can find the minimum ofP [ri], M[ri, Sri ] for all subsets Sri ’s of C . We then follow a top–down trace back procedure to find S ′

i . Note that the aboverecursions split Su into two disjoint subsets Sc1 and Sc2 , which can guarantee that no cycles are formed if u is not includedin the IFVS. The correctness of this algorithm can thus be easily proved with the principle of induction and its recursionrelations.

Before the dynamic programming starts, the algorithm needs to construct H from the trees in G[V − F ], it needs at mostO (|V |) time. In addition, the algorithm also needs to compute W u for each internal node in the trees in H and NG(S).However, since S contains at most |F | vertices, this needs at most O (|F ||V |) time.

During the dynamic programming process, for a given node u and Su , the algorithm needs to consider all possibledisjoint pairs of subsets Sc1 and Sc2 , such that Sc1 ∪ Sc2 = Su − Wu . We denote t = |Su|, the number of such pairs is atmost 2t . The total amount of computation time needed by the dynamic programming on one single vertex in Ti is thus atmost

O

(l∑

t=0

2t(

l

t

))= O

(3l) (13)

where the right hand side of the equation can be directly obtained with the binomial theorem.Since H contains at most 2(|V | − |F |) vertices, the dynamic programming algorithm can find S ′ in time O (3l|V |). For

each S ⊆ F such that G[F − S] is acyclic, we can find an IFVS S ∪ S ′ . The one that contains the minimum number of verticesis a minimum IFVS. The total amount of the computation time needed by the algorithm is thus at most

Y. Song / Theoretical Computer Science 535 (2014) 25–30 29

O

( |F |∑l=1

3l(|F |

l

)|V |

)= O

(4|F ||V |) (14)

The right hand side of the equation again is the direct result of applying the binomial theorem to the left hand side. Thetheorem has been proved. �

Based on the algorithm we have developed in Lemma 3.1, we can use the iterative compression technique developed in[22] to develop a parameterized algorithm that can determine whether a graph contains an IFVS of size k in time O (4kn2).We thus have the following theorem.

Theorem 3.1. Given a graph G = (V , E) and a positive integer parameter k, there exists a parameterized algorithm that can determinewhether G contains an IFVS of size k or not in time O (4k|V |2).

Proof. We use the iterative compression technique to develop the algorithm. Let n = |V | and V = {v1, v2, . . . , vn}, alsoV i = {v1, v2, . . . , vi}, where 1 � i � n and Gi = G[V i], the algorithm can be sketched as follows.

1. Starting with graph Gk , add vertices one by one to reconstruct graph G . Based on the above notation, when a vertex ui+1is added to Gi (k � i < n), edges are added to Gi to join ui+1 with its neighbors in Gi to construct Gi+1. Gk, Gk+1, . . . , Gncan thus be obtained, where Gn = G;

2. Include all vertices in Gk into set Fk;3. For each i = k to n −1, given Fi ∪{ui+1}, use the algorithm presented in the proof of Lemma 3.1 to compute a minimum

IFVS Fi+1 in Gi+1, if Fi+1 contains more than k vertices, return “no”;4. Return “yes”.

For computation time, step 1 can be accomplished in time O (n2). From Lemma 3.1, the computation time needed bystep 3 is at most

n∑i=k+1

O(4ki

) = O(4kn2) (15)

The theorem has been proved. �In [16], it is shown that the FVS problem can be reduced to the IFVS problem through a simple polynomial time reduction

that also preserves the parameter k. Theorem 3.1 thus implies there exists a dynamic programming based algorithm thatsolves the FVS problem in time O (4kn2). In fact, it is not difficult to see that the algorithm presented in the proof ofLemma 3.1 can be slightly changed to solve the FVS problem.

4. Conclusions

In this paper, we develop a new parameterized algorithm that can determine whether a graph contains an IFVS ofsize k or not in time O (4kn2). To our best knowledge, this result improves the previously known upper bound for thisproblem, which is O (5knO (1)). Our technique combines a dynamic programming approach with the recently developediterative compression technique, which has been proved to be useful for developing parameterized algorithms for manyNP-complete problems.

Our algorithm does not employ the method of branching, which is an often used approach for developing exact andparameterized algorithms. Indeed, the IFVS is a subset with certain global structural properties. In general, a branchingalgorithm employs the local structure of a graph and can hardly be used to further improve the upper bound of theproblem. However, we are still looking for the possibility to combine our method and the branching approach to furtherimprove the upper bound of this problem. In fact, recent work [10] has shown that this combination can lead to improvedupper bound results for many NP-hard graph optimization problems.

References

[1] H. Bodlaender, On disjoint cycles, Internat. J. Found. Comput. Sci. 5 (1) (1994) 59–68.[2] Y. Cao, J. Chen, Y. Liu, On feedback vertex set new measure and new structures, in: SWAT 2010, 2010, pp. 93–104.[3] J. Chen, F.V. Fomin, Y. Liu, S. Lu, Y. Villanger, Improved algorithms for feedback vertex set problems, J. Comput. System Sci. 74 (7) (2008) 1188–1198.[4] M. Cygan, J. Nederlof, M. Pilipczuk, M. Pilipczuk, J.M.M. van Rooij, J.O. Wojtaszczyk, Solving connectivity problems parameterized by treewidth in single

exponential time, in: Proceedings of the 52nd Annual Symposium on Foundations of Computer Science, FOCS 2011, 2011, pp. 150–159.[5] F.K.H. Dehne, M.R. Fellows, M.A. Langston, F.A. Rosamond, K. Stevens, An O (2O (k)n3) algorithm for the undirected feedback vertex set problem, in:

Proceedings of the 11th Annual International Conference on Computing and Combinatorics, COCOON 2005, 2005, pp. 859–869.[6] M. Dom, J. Guo, F. Hüffner, R. Niedermeier, A. Trub, Fixed-parameter tractability results for feedback set problems in tournaments, J. Discrete Algorithms

8 (1) (2010) 76–86.

30 Y. Song / Theoretical Computer Science 535 (2014) 25–30

[7] R. Downey, M. Fellows, Fixed parameter tractability and completeness, in: Complexity Theory: Current Research, Cambridge University Press, 1992,pp. 191–225.

[8] R. Downey, M. Fellows, Parameterized Complexity, Springer-Verlag, New York, 1999.[9] F.V. Fomin, S. Gaspers, A.V. Pyatkin, I. Razgon, On the minimum feedback vertex set problem: exact and enumeration algorithms, Algorithmica 52 (2)

(2008) 293–307.[10] F.V. Fomin, S. Gaspers, S. Saurabh, A.A. Stepanov, On two techniques of combining branching and treewidth, Algorithmica 54 (2) (2009) 181–207.[11] J. Guo, R. Niedermeier, S. Wernicke, Parameterized complexity of vertex cover variants, Theory Comput. Syst. 41 (3) (2007) 501–520.[12] J. Guo, J. Gramm, F. Hüffner, R. Niedermeier, S. Wernicke, Compression-based fixed-parameter algorithms for feedback vertex set and edge bipartization,

J. Comput. System Sci. 72 (8) (2006) 1386–1396.[13] I. Kanj, M. Pelsmajer, M. Schaefer, Parameterized algorithms for feedback vertex set, in: Proceedings of 2004 International Workshop on Parameterized

and Exact Computation, IWPEC 2004, 2004, pp. 234–247.[14] R.M. Karp, Reducibility among combinatorial problems, in: Complexity of Computer Computations, Plenum Press, New York, 1972, pp. 85–103.[15] T. Kociumaka, M. Pilipczuk, Faster deterministic feedback vertex set, arXiv:1306.3566 [cs.DS].[16] N. Misra, G. Philip, V. Raman, S. Saurabh, On parameterized independent feedback vertex set, Theoret. Comput. Sci. 461 (23) (2012) 65–75.[17] H.G. Molina, J.D. Ullman, J. Widom, Database Systems: The Complete Book, 2nd edition, Pearson Prentice Hall, 2009.[18] R. Niedermeier, Invitation to Fixed-Parameter Algorithms, Oxford University Press, London, 2006.[19] V. Raman, S. Saurabh, C.R. Subramanian, Faster fixed parameter tractable algorithms for undirected feedback vertex set, ACM Trans. Algorithms 2 (3)

(2006) 403–415.[20] V. Raman, S. Saurabh, C.R. Subramanian, Faster fixed parameter tractable algorithms for finding feedback vertex set, in: Proceedings of the 13th

International Symposium on Algorithms and Computation, ISAAC 2002, 2002, pp. 241–248.[21] I. Razgon, Exact computation of maximum induced forest, in: Proceedings of the 10th Scandinavian Workshop on Algorithm Theory, SWAT 2006, 2006,

pp. 160–171.[22] B. Reed, K. Smith, A. Vetta, Finding odd cycle transversals, Oper. Res. Lett. 32 (4) (2004) 299–301.[23] A. Silberschatz, P.B. Galvin, G. Gagne, Operating System Concepts, 9th edition, John Wiley and Sons Inc., 2012.