Deletion to Induced Matching
DDeletion to Induced Matching
Akash Kumar Aalto University, Finland [email protected]
Mithilesh Kumar Simula@UiB, Norway [email protected]
Abstract
In the
Deletion to induced matching problem, we are given a graph G on n vertices, m edgesand a non-negative integer k and asks whether there exists a set of vertices S ⊆ V ( G ) such that | S | ≤ k and the size of any connected component in G − S is exactly
2. In this paper, we providea fixed-parameter tractable (FPT) algorithm of running time O ∗ (1 . k ) for the Deletion toinduced matching problem using branch -and- reduce strategy and path decomposition. We alsoextend our work to the exact-exponential version of the problem.
Theory of computation → Fixed parameter tractability
Keywords and phrases
Fixed Parameter Tractable, Parameterized Algorithms, Complexity Theory
In the classic
Vertex Cover problem, the input is a graph G and integer k , and the taskis to determine whether there exists a vertex set S of size at most k such that every edgein G has at least one endpoint in S . Such a set is called a vertex cover of the input graph G . An equivalent definition of a vertex cover is that every connected component of G − S has at most 1 vertex. This view of the Vertex Cover problem gives rise to a naturalgeneralization: can we delete at most k vertices from G such that every connected componentin the resulting graph has at most ‘ vertices? Kumar et al [13] studied this generalizationas ‘ - COC ( ‘ -Component Order Connectivity ). In this work, we would study a special case ofthis generalization where ‘ is exactly
2. Formally, we consider the following problem, called
Deletion to Induced Matching ( IND ). Deletion to Induced Matching ( IND ) Input:
A graph G on n vertices and m edges, and a positive integer k . Task: determine whether there exists a set S ⊆ V ( G ) such that | S | ≤ k and the maximumsize of a component in G − S is exactly 2.From the work of Stockmeyer and Vazirani [17], it is evident that IND is NP-complete.This motivates the study of
IND within paradigms for coping with NP-hardness, suchas approximation algorithms [20], exact exponential time algorithms [10], parameterizedalgorithms [4, 7] and kernelization [12, 14]. In this work we focus on
IND from the perspectiveof parameterized complexity and exact exponential algorithms. As our main result, weprovide an algorithm that given an instance (
G, k ) of
IND such that degree of any vertexis at most 3, runs in polynomial time to output a path decomposition such that the pathwidth is bounded by O ( k ). We provide an application of branching technique to convert anarbitrary instance ( G, k ) of
IND to ( G , k ) such that degree of any vertex in G is at most 3. author did most of this work while a bachelor’s student at CMI author did most of this work while a PhD student at UiB a r X i v : . [ c s . D S ] A ug Deletion to Induced Matching
Related Work.
If the component size is 1, then the problem converts to finding a
VERTEX COVER , which is extremely well studied from the perspective of approximation al-gorithms [20, 6], exact exponential time algorithms [9, 16, 22], parameterized algorithms [4, 3]and kernelization [2, 15]. The relaxed version of
IND where component sizes are bounded by 2(also 2-
COC [13]) is also well studied, and has been considered under several different names.The problem, or rather the dual problem of finding a largest possible set S that inducesa subgraph in which every connected component has order at most 2, was first defined byYannakakis [23] under the name Dissociation Set. The problem has attracted attention inexact exponential time algorithms [11, 21], the fastest currently known algorithm [21] hasrunning time O (1 . n ). 2- COC has also been studied from the perspective of paramet-erized algorithms [1, 18] (under the name
Vertex Cover P ) as well as approximationalgorithms [19]. The fastest known parameterized algorithm, due to Chang et al. [1] hasrunning time 1 . k n O (1) , while the best approximation algorithm, due to Tu and Zhou [19]has factor 2.To the best of our knowledge, IND has not been studied in the parameterized setting.We achieve the runtime of 1 . k n O (1) in the polynomial space. We also provide a 1 . n runtime algorithm for the exact exponential version of the problem, called EXTEND . Our Method.
The key to our solution is reducing an
IND instance (
G, k ) to ( G , k ) usingbranch-and-reduce strategy such that the maximum degree of any vertex u ∈ G is 3. Weachieve this by analysing certain properties of a solution set S ⊆ V ( G ). Thus, we only applythe branch-and-reduce strategy on vertices with degree more than 4. Consider a search tree T ∗ and the subtree rooted at some node with IND instance ( G , k ). Now, for any u ∈ V ( G ),either u ∈ S or u / ∈ S . In the former case, the algorithm creates a child with instance( G [( V ( G ) \ u )] , k − e ∈ E ( G ) such that e := uv forsome v ∈ N ( u ) (neighbours of u in G ). Our branching rules cover all the possible cases of { u, v } 6⊂ S where v ∈ N ( u ).Now, the motivation behind reducing the IND instances to maximum degree 3 instances,call ( G , k ), is because we can efficiently solve those instances using ideas from path decom-position. We are able to show that there exists a path decomposition of G with pathwidthhaving constant dependency on k . Not only that we provide an algorithm that runs inpolynomial time to construct one.We note that Fomin and Hłie [8] proved a tight bound on a path decomposition of a graph G with maximum degree at most three. They show that for any (cid:15) > pw ( G ) ≤ ( + (cid:15) ) | V ( G ) | (pathwidth of the graph, cf §2). We first show that in the case of the special degree 3 graphs,we can bound the number of vertices of degree exactly 3 if ( G, k ) is a
YES -instance, and viceversa. Now the key is to show a path decomposition of the instance of width bounded by O ( k ). The main insight is in using the decomposition given by Fomin and Hłie [8], call it P , and then applying color coding of edges and vertices to appropriately group the bags ofthe decomposition P (cf §2) to construct the desired path decomposition P .Now, the only question left to be answered is how to construct an efficient solution forthe instance ( G, k )? We provide a dynamic programming algorithm to solve an
IND instance(
G, k ) if a path decomposition of G if given. We define a coloring map of any bag X t ∈ P i.e. the path decomposition P of G in the following manner: f : X t → { , , } assigningthree different colors to vertices of the bag. For the path decomposition P representedas ( P , { X t } t ∈ V ( P ) ). The idea is to dynamically find partial solution S t ⊆ G [ V t ] where V t := S i = ti =1 X i for any t ∈ V ( P ). Thus, the coloring set { , , } induces a canonical meaningwith the color 0 is when the vextex is in the partial solution, the color 1 is assigned whenthe vertex is not in the partial solution but to be paired later in the DP, and the color 2 is . Kumar and M. Kumar 3 assigned when the vextex doesn’t belong to the partial solution but has degree one in G t − S t .Since, we have to ensure the minimum property of S t we further define a cost function c [ t, f ]the minimum size of a set S t ⊆ V t such that the following two properties hold: S t ∩ X t = f − (0), i.e. the set of vertices of X t that belong to the partial solution. Degree of every vertex in G t − S t is at most 1.We show the function c [ · , · ] could be dynamically constructed. Since, the maximum possiblecolorings f of a bag X t is bounded by 3 | X t | thus the main claim could be shown.The exact-exponential algorithm of the problem which involves finding the minimum set S ⊆ V ( G ) such that G [ V − S ] contains only components of size exactly 2, follows similarbranching and reducing strategy as devised for the parameterized problem IND . We usethe key results proven for the parameterized to analyse this case and provide a worst-casesolution.
Overview of the paper.
In §2 we recall basic definitions and set up notations. We providea self-contained section for the FPT algorithm and the corresponding necessary results in §3.In §4, we state the exact-exponential problem and provide the exact-exponential algorithm.
Let N denote the set of positive integers { , , , . . . } . For any non-zero t ∈ N , [ t ] := { , , . . . , t } . For a set { v } containing a single element, we simply write v . A vertex u ∈ V ( G )is said to be incident on an edge e ∈ E ( G ) if u is one of the endpoints of e . A pair of edges e, e ∈ E ( G ) are said to be adjacent if there is a vertex u ∈ V ( G ) such that u is incident onboth e and e . For any vertex u ∈ V ( G ), by N ( u ) we denote the set of neighbors of u i.e. N ( u ) := { v ∈ V ( G ) | uv ∈ E ( G ) } . We use the notation N [ u ] to denote the union u ∪ N ( u ),where d ( u ) denotes the degree of the vextex u . For any subgraph X ⊆ G , by N ( X ) wedenote the set of neighbors of vertices in X outside X , i.e. N ( X ) := (cid:0)S u ∈ X N ( u ) (cid:1) \ X . Aninduced subgraph on X ⊆ V ( G ) is denoted by G [ X ].A path P is a graph, denoted by a sequence of vertices v v . . . v t such that for any i, j ∈ [ t ], v i v j ∈ E ( P ) if and only if | i − j | = 1. A cycle C is a graph, denoted either by asequence of vertices v v . . . v t or by a sequence of edges e e . . . e t , such that for any i, j ∈ [ t ] u i u j ∈ E ( C ) if and only if | i − j | = 1 mod t or in terms of edges, for any i, j ∈ [ t ], e i isadjacent to e j if and only if | i − j | = 1 mod t . The length of a path(cycle) is the number ofedges in the path(cycle). Path Decomposition. [5] A path decomposition of a graph G is a sequence P = ( X , X , · · · , X r )of bags where X i ⊆ V ( G ) for each i ∈ { , , · · · , r } , such that the following conditions hold: • S ri =1 X i = V ( G ). In other words, every vertex of V ( G ) is in at the least one of the bag. • For every uv ∈ E ( G ), there is an ‘ ∈ { , , · · · , r } such that the bag X ‘ contains both u and v . • For every u ∈ V ( G ), if u ∈ X i ∩ X k for some i ≤ k , then u ∈ X j also for each j suchthat i ≤ j ≤ k . In other words, the indices of the bags containing u form an interval in { , , · · · , r } .The width of a path decomposition ( X , X , · · · , X r ) is max ≤ i ≤ r | X i | −
1. The pathwidthof a graph G , denoted by pw ( G ), is the minimum possible width of a path decomposition of G . The reason for subtracting 1 in the definition of the width of the path decomposition isto ensure that the path width of a path with at least one edge is 1, not 2. Deletion to Induced Matching
Fixed Parameter Tractability. A parameterized problem Π is a subset of Σ ∗ × N . Aparameterized problem Π is said to be fixed parameter tractable ( FPT ) if there exists analgorithm that takes as input an instance (
I, k ) and decides whether (
I, k ) ∈ Π in time f ( k ) · n c , where n is the length of the string I , f ( k ) is a computable function depending onlyon k and c is a constant independent of n and k .A data reduction rule , or simply, reduction rule, for a parameterized problem Q is afunction φ : Σ ∗ × N → Σ ∗ × N that maps an instance ( I, k ) of Q to an equivalent instance( I , k ) of Q such that φ is computable in time polynomial in | I | and k . We say that twoinstances of Q are equivalent if ( I, k ) ∈ Q if and only if ( I , k ) ∈ Q ; this property of thereduction rule φ , that it translates an instance to an equivalent one, is referred as the safeness of the reduction rule.A fixed-parameter algorithm based on branch-and-reduce strategy consists of a collectionof reduction rules and branching rules. The branching rules are used to recursively solve thesmaller instances of the problem with smaller parameter. We analyze each branching rule anduse the worst-case time complexity over all branching rules as an upper bound of the runningtime. We represent the execution of a branching algorithm via search tree. The root of asearch tree represents the input of the problem, every child of the root represents a smallerinstance reached by applying a branching rule associated with the instance of the root. Onecan recursively assign a child to a node in the search tree when applying a branching rule.Notice that we do not assign a child to a node when applying a reduction rule. The runningtime of a branching algorithm is usually measured by the maximum number of leaves in itscorresponding search tree. Let b be any branching rule. When rule b is applied, the currentinstance ( G, k ) is branched into s ≥ G i , k i ) where | G i | ≤ | G | and k i = k − t i .Notice that fixed-parameter algorithms return “No” when the parameter k ≤
0. We call b = ( t , t , · · · , t s ) the branching vector of branching rule b . This can be formulated in alinear recurrence: T ( k ) ≤ T ( k − t ) + T ( k − t ) + · · · + T ( k − t s ), where T ( k ) is the numberof leaves in the search tree depending on the parameter k . The running time of the branchingalgorithm using only branching rule b is O ( poly ( n ) · T ( k )) = O ∗ ( c k ) where c is the uniquepositive real root of x k − x k − t − x k − t − · · · − x k − t s = 0 [10]. The number c is called thebranching number of the branching vector ( t , t , · · · , t s ). In this section, we would provide the fixed parameter tractable algorithm for
DELETION TOINDUCED MATCHING . First, we construct a set of branching rules for problem instanceswith at the least one vertex with degree ≥
4. The branching rules are based on a novelobservation. Using these rules, we get a problem instance ( G , k ) from ( G, k ) such that anyvertex u ∈ V ( G ) has degree bounded by 3. We provide an efficient solution for the instance( G , k ) using ideas from path decomposition.We denote by S a potential solution of size at most k . Now we proceed to write thereduction rules and branching rules. Note that while stating a reduction rule or a branchrule we assume that previous rules are not applicable. Furthermore, each rule changes theinstance from ( G, k ) to ( G , k ) where | V ( G ) | < | V ( G ) | and k ≤ k , but we use the samesymbols ( G, k ) to represent the modified instance. We note the following key observation: (cid:73)
Observation 1. If ∃ u, v ∈ V ( G ) such that N [ v ] \ u ⊆ N ( u ) , then there exists a solution S such that either u ∈ S or { u, v } 6∈ S . . Kumar and M. Kumar 5 Indeed if S is a solution such that u / ∈ S and v ∈ S such that ∃ w ∈ N ( u ) ∩ N ( v ) and w / ∈ S ,then S := ( S \ v ) ∪ u is also a solution where v S . If ∃ x N ( v ) such that x S , then notethat all the neighbours of x outside that of u has to be deleted. Thus, S := ( S \ v ) ∪ x where x ∈ S and v S . Hence, even for u / ∈ S , we get a solution such that either u ∈ S or { u, v } 6⊆ S .Observation 1 suggests the following branching rule where we assume that the degreeof u is at the least 4 i.e. d ( u ) ≥
4, where the branching subtree is rooted at u : (cid:73) Branching Rule 1. If ∃ v ∈ V ( G ) such that N [ v ] ⊆ N [ u ] . Then, make nodes in the branchtree for the following cases: u ∈ S or u / ∈ S . In the second case, we pair the vertex u with v anddelete at least d ( u ) − many vertices. The recurrence relation is T ( k ) ≤ T ( k − T ( k − d +1) whose solution is bounded by T ( k ) ≤ . k . From now on we assume that for every vertex u of degree at least 4, we have that for everyvertex v ∈ N ( u ), | N ( v ) ∩ N [ u ] | ≥
1. If u / ∈ S , then one neighbor v ∈ N ( u ) does not belongto S . In that case, N ( v ) ∩ N [ u ] ⊆ S . This is the basis for the following branching rule: (cid:73) Branching Rule 2.
Let u be a vertex of degree d ≥ such that ∀ v ∈ N ( u ) | N ( v ) ∩ N [ u ] | ≥ .Create d +1 branch nodes: one for the case when u ∈ S and one for each vertex v ∈ N ( u ) suchthat ( N ( u ) ∪ N ( v )) \ { u, v } ⊆ S where at least d vertices are deleted. Then, the recurrencerelation is T ( k ) ≤ T ( k −
1) + d · T ( k − d ) whose solution is bounded by T ( k ) ≤ . k . Using the above branching rules 1-2, we can reduce any
IND instance (
G, k ) to ( G , k ) suchthat G has maximum degree 3 for any vertex u ∈ V ( G ). Now, we would provide theconstruction of a path decomposition for ( G , k ). First, we state the following result byFomin and Hłie [8]: (cid:73) Theorem 1 (Fomin and H ł ie) . For any (cid:15) > , there exists an integer n (cid:15) such thatfor every graph G with maximum vertex degree at most three and with | V ( G ) | > n (cid:15) , pw ( G ) ≤ ( + (cid:15) ) | V ( G ) | . Furthermore, such a decomposition can be obtained in polynomialtime. Now, we would prove a lemma which ascertains a key property on the number of verticeswith degree 3 for an
IND problem instance (
G, k ) to be a
YES -instance. (cid:73)
Lemma 2.
Let G be a graph of maximum degree 3. Then ( G, k ) is a yes -instance if andonly if there are at most . k vertices of degree 3 in G . Proof.
Let (
G, k ) be a yes -instance of IND and S be a solution of size at most k . Since thedegree of any vertex is at most 3, the number of edges between S and V \ S is at most 3 k .Now, the degree of any vertex in G − S is 1. Hence, for every vertex of degree 3 in V \ S ,the number of edges to S is 2. Hence, the maximum number of degree 3 vertices is boundedby k + k = 2 . k .If number of degree 3 vertices is more than 2 . k , then for any set S of size k , G − S contains a vertex of degree greater than 1 and hence ( G, k ) is a no -instance. (cid:74) Using Theorem 1 and Lemma 2, we can bound the path width of the path decomposition ofan
IND instane (
G, k ) as follows: (cid:73)
Lemma 3.
There exists a polynomial time algorithm that given an IND instance ( G, k ) obtains a path decomposition of G of width at most . k + 2 . Deletion to Induced Matching
Proof.
By Lemma 2, the maximum number of vertices of degree 3 in G is at most 2 . k . Weobtain a graph G by first recursively contracting all edges incident on two degree-2 verticesand then recursively contracting edges incident on one vertex of degree at most 2. If thedegree of a contracted vertex is 3, we color the edge representing the contracted path red. Ifa vertex of degree 1 gets merged to a vertex of degree 3, we color the vertex red. Clearly, themaximum degree of any vertex in G is at most 3 and | V ( G ) | ≤ . k . By Theorem 1, wecan obtain a path decomposition P of width at most p = . k in polynomial time.Now we show how to obtain a path decomposition P of width at most p + 1 of G usingthe decomposition P in polynomial time. Suppose there is a red edge in bag X t . Let x, y be the endpoints of this edge. Without loss of generality, assume that y is introduced after x has been introduced and X t be the bag just before y is introduced. Clearly, x ∈ X t .Let P = xu u . . . u a y be the path in G corresponding to the contracted edge is G . Weintroduce the following bags in order in P after X t : X u , X u , X u , X u , X u . . . where X u denotes an introduce bag for u and X u denotes a forget node for u . Here X u = X t ∪ { u } .Note that the size of any bag is at most p + 2. This split of a bag containing a red edge isapplied exhaustively. Note that there can be at most one red edge between two vertices thatalso share an edge in the original graph. If there is a red edge between two vertices whichare not adjacent in the original graph, then in the above sequence when we introduce extrabags, the size of the bags does not exceed the original size. Now we consider the case whenthere are two xy -paths in G that get contracted. If xy ∈ E ( G ), then pathwidth of G is atmost 3 and hence the decomposition satisfies the requirements of the lemma. Otherwise, wefollow above procedure of introducing extra bags for the second path before y is introduced.For red vertices, the procedure is similar. Let v be a red vertex in some bag X t and let au u . . . v be the path that got contracted to v . Let X be the bag just before v is introduced.We insert the following bags in the decomposition after X : X a , X u , X u , X u . . . . We applythis operation exhaustively for each red vertex. The width of the decomposition is at most p + 2. It is easily seen that P is a valid path decomposition of G . (cid:74) Before, we show our algorithm for solving an
IND instance with every vertex u ∈ G havingmaximum degree 3, we would give an algorithm to solve an IND instance in O ∗ (3 p ) timewhere p is the pathwidth of a path decomposition for G : (cid:73) Theorem 4.
There exists an algorithm that given a path decomposition of G solves IND in O ∗ (3 p ) time where p is the width of the decomposition. Proof.
We would assume that we are given a nice path decomposition ( P , { X t } t ∈ V ( P ) ) ofwidth p of G . We define V t := S i = ti =1 X i and G t := G [ V t ] for any t ∈ V ( P ). We define acoloring of a bag X t as a mapping f : X t → { , , } assigning three different colors tovertices of the bag, which is described extensively as follows: • If f ( v ) = 0, then v must be contained in the partial solution in G t . • If f ( v ) = 1, then v does not belong to the partial solution, but it is isolated in G t − S t where S t is the partial solution in G t . These are the vertices which are to be paired laterin the DP (dynamic programming of the algorithm). • If f ( v ) = 2, then v does not belong to the partial solution, but it has degree one in G t − S t . Note that d ( v ) ≤ G [ X t − f − (0)].For a subset X ⊆ V ( G ), consider a coloring f : X → { , , } . For a vertex v ∈ V ( G ) and acolor α ∈ { , , } we define a new coloring f v → α : X ∪ { v } → { , , } as follows: f v → α ( x ) = ( f ( x ) when x = v,α when x = v. . Kumar and M. Kumar 7 Similarly, we define another coloring f v ← α : X → { , , } as follows: f v ← α ( x ) = ( f ( x ) when x = v,α when x = v. For a coloring f of X and Y ⊆ X , we use f | Y to denote the restriction of f to Y . Fora coloring f of X t , we denote by c [ t, f ] the minimum size of a set S t ⊆ V t such that thefollowing two properties hold: S t ∩ X t = f − (0), i.e. the set of vertices of X t that belong to the partial solution. Degree of every vertex in G t − S t is at most 1.Since the decomposition is nice , we specify the values of the recursive function c [ · , · ] tovarious node types as shown below: Leaf node : For a leaf node t we have that X t = ∅ . Hence there is only one, empty coloring,and we have c [ t, ∅ ] = 0. Introduce node : Let t be an introduce node with a child t such that X t = X t ∪ { v } forsome v / ∈ X t . We write the recursive formulae for various cases. Note that we put infinityas a value for c [ t, f ] whenever a feasible solution is not possible. c [ t, f ] = c [ t , f | X t ] if f ( v ) = 0 c [ t , f | X t ] if f ( v ) = 1 and (cid:64) u ∈ X t s.t. uv ∈ E ( G ) and f ( u ) = 0 c [ t , f w ← | X t \ w ] if f ( v ) = 2 , ∃ w s.t. f ( w ) = 1 and wv ∈ E ( G )and (cid:64) u s.t. f ( u ) = 2 and uv ∈ E ( G ) ∞ otherwise . Note that when vw ∈ E ( G ) and f ( w ) = 1 in X t , then at the introduce node X t , we have f ( w ) = 2. Forget node : Let t be a forget node with a child t such that X t = X t \ { v } for some v ∈ X t . Since multiple colorings of X t can lead to the same coloring of X t , it suffices tokeep the one that leads to minimum size solution. c [ t, f ] = min { c [ t , f v → ] , c [ t , f v → ] , c [ t , f v → ] } If an introduced vertex is colored 2 then, the coloring is valid unless there is a vertex w ∈ X t such that the restriction f | X t satisfies f | X t ( w ) = 1.Since there are at most 3 | X t | number of colorings f for any bag X t , the time to processany node is at most 3 p +1 . Hence, IND can be solved in O ∗ (3 p ) time. (cid:74)(cid:73) Lemma 5.
IND on graphs of maximum degree 3 can be solved in O ∗ (1 . k ) time. Proof.
Run the algorithm of Lemma 3 to get a nice path decomposition of width at most . k + 2 and then use the algorithm of Theorem 4. Hence, the runtime of the algorithm isbounded by O ∗ (3 . k +2 ) = O ∗ (1 . k ). (cid:74) We have provided a faster
FPT solution for problem instances with maximum degree 3. Usingthe branching rules 1-2 and Lemma 5, we would state and proof the main claim of the sectionin which we show a fixed-parameter tractable algorithm of runtime O ∗ (1 . k ) for any IND instance (
G, k ). In the following, we state the claim below and then we complete the proof.
Deletion to Induced Matching (cid:73)
Theorem 6 (Main Theorem) . IND can be solved in O ∗ (1 . k ) time. Proof.
Algorithm solves
IND in two phases. In phase one, it applies some reduction rules toeliminate degree four vertices. In phase two, it solves
IND on graphs of maximum degree 3.After exhaustively applying branching rules 1 and 2 on an
IND instance (
G, k ), we canassume that for the reduced instance ( G , k ) the maximum degree of a vertex in the reducedgraph G is 3. At this point we run the algorithm of Lemma 5 to solve IND optimally. Hence,if (
G, k ) is a
YES -instance of
IND , then in at least one branch, we get a solution of size atmost k .Now we proceed to the runtime analysis of the algorithm. First, we write the recurrencerelations for each of the branch rules we have used so far.Branch rule 1 T ( k ) ≤ T ( k −
1) + T ( k − d + 1) T ( k ) ≤ . k Branch rule 2 T ( k ) ≤ T ( k −
1) + d · T ( k − d ) T ( k ) ≤ . k Consider the branch tree at the end of the branch phase. Let s be the parameter with whichthe algorithm of Lemma 5 is called. Clearly, 0 < s ≤ k . It is easily shown by induction on k that the number of leaves with parameter s is bounded by the worst case branching inthe branch tree which is 1 . k − s : indeed the base case k = 1 is trivial. Consider that thestatement is true for any value less than k . Let T represent the branch tree. Then considerall the nodes with parameter s in T . If there is a path on which there is no such node then,delete the subtree rooted at the node that has an edge to the path that leads to a node withparameter s . Now delete all subtrees rooted at nodes with parameter s except the root. Inthis truncated tree defined as T ∗ , leaves have parameter s . Now, change k to k = k − s .Due to this parameter change, all leaves are with parameter 1. Since, k < k , by induction,the number of nodes with parameter value 1 is bounded by 1 . k = 1 . k − s . Hence, thetotal runtime of the algorithm is bounded as follows s = k X s =0 . k − s × . s × n O (1) ≤ s = k X s =0 . s × . k − s × n O (1) ≤ O ∗ (1 . k ) (cid:74) In this section, we would discuss an exact-exponential version of the
Deletion to InducedMatching problem. We provide an exact-exponential algorithm of runtime O ∗ (1 . n ) whichuses the key ideas from the parameterized version of IND . We state the the exact-exponentialversion of the problem, also called
EXTEND , as follows:
Deletion to Induced Matching (EXTEND)
Input:
A graph G on n vertices and m edges. Task: determine the minimum cardinality subset S ⊆ V ( G ) such that the maximum size ofany component in G − S is exactly 2.Notice that since we get a fixed parameter tractable algorithm of running time of O ∗ (1 . k ) for IND thus the running time of the exact-exponential problem is bounded by O (1 . n ) where we solve for n instead of k . We would use the stated Observation 1 (cf §3)to find the minimum possible set S such that the task is fulfilled. Note that the observationhas a particular property that it doesn’t involve increase in the cardinality of a solution set . Kumar and M. Kumar 9 S if a solution S exists.We approach the problem in the similar manner where the main idea is to exhaust allthe vertices v such that d ( v ) ≥
4. We state the following observation (cid:73)
Observation 2. If ∃ u, v / ∈ S such that uv ∈ E ( G ) then we can delete { u, v } where G → G such that n → n − . Observations 1 and 2 suggest the following branching rule 1, 2 and 3 such that d ( u ) ≥ (cid:73) Branching Rule 3. If ∃ v ∈ V ( G ) such that N [ v ] ⊆ N [ u ] . Then, make nodes in the branchtree for the following cases: u ∈ S or u, v / ∈ S using Observation
1. In the second casewe delete at least 3 vertices as d(u) ≥ uv edge using Observation
2. Therecurrence relation is T ( n ) ≤ T ( n −
1) + T ( n − which solves to . n . From now on we assume that for every vertex u of degree at least 4, we have that forevery vertex v ∈ N ( u ), | N ( v ) ∩ N [ u ] | ≥
1. If u / ∈ S , then one neighbor v ∈ N ( u ) does notbelong to S . In that case, N ( v ) ∩ N [ u ] ⊆ S . This is the basis for the following branchingrule: (cid:73) Branching Rule 4.
Let u be a vertex of degree d ≥ such that ∀ v ∈ N ( u ) | N ( v ) ∩ N [ u ] | ≥ .Create d + 1 branch node: one for the case when u ∈ S and one for each vertex v ∈ N ( u ) such that N ( u ) ∪ N ( v ) \ { u, v } ⊆ S where at least d vertices are deleted along with { u, v } using Observation
2. Then, the recurrence relation is T ( n ) ≤ T ( n −
1) + d · T ( n − d − whose solution is bounded by T ( n ) ≤ . n . Using the above branching rules 3-4, we can reduce any
EXTEND instance ( G ) to ( G ) suchthat G has maximum degree 3 for any vertex u ∈ V ( G ). Now, we would prove a theoremwhich ascertains an algorithm on an EXTEND instance where every vextex of G has boundeddegree 3. (cid:73) Theorem 7.
There exists an algorithm that given an instance G of max degree 3 solves
EXTEND in O ∗ (3 n ) time. Proof.
Note that in
Lemma
3, we find a path decomposition of the
IND instance (
G, k )with width p such that p is bounded by . k + 2. But note that using Lemma G canhave at max 2 . k many vertices of degree 3 which is indeed bounded by n . Now, if we runthe algorithm in Theorem
IND instance (
G, k ) ∀ k ∈ [ n ] where the pathdecomposition of G has pathwidth p bounded by (cid:0) n + 2 (cid:1) . Note, using this procedure theruntime is bounded by n ∗ ( n +2) ∗ n c where c is a constant from Theorem
4. Thus, overallthe running time for
EXTEND is bounded by O (3 n ) (i.e. O (1 . n )) . (cid:74)(cid:73) Theorem 8 (Main Theorem) . EXTEND can be solved in O ∗ (1 . n ) runtime. Proof.
Algorithm solves
EXTEND in two phases. In phase one, it applies some reductionrules to eliminate degree four vertices. In phase two, it solves
EXTEND on graphs of maximumdegree 3.After exhaustively applying Branching rules 3 and 4, we can assume that the maximumdegree of a vertex in the remaining graph is 3. Hence, this instance can be seen as an instanceof
EXTEND ( G , n − n ) with maximum degree three. At this point we run the algorithmof Theorem 7 to solve EXTEND optimally. Now we proceed to the runtime analysis of the algorithm. First, we write the recurrence relations for each of the branch rules we have usedso far.Branch rule 3 T ( n ) ≤ T ( n −
1) + T ( n − T ( n ) ≤ . n Branch rule 4 T ( n ) ≤ T ( n −
1) + d · T ( n − d − T ( n ) ≤ . n Consider the branch tree at the end of the branch phase. Let G be the instance with whichthe algorithm of Theorem 7 is called. Let | V ( G ) | = n . It is easily shown by induction on n that the number of leaves with | V ( G ) | = n is bounded by the worst case branching in thebranch tree which is 1 . n − n : indeed in the base case n = 1 is trivial. Consider that thestatement is true for any value less than n . Let T represent the branch tree. Then considerall the nodes with | V ( G ) | = n in T . If there is a path on which there is no such node then,delete the subtree rooted at the node that has an edge to the path that leads to a node with | V ( G ) | = n . Now delete all subtrees rooted at nodes with | V ( G ) | = n except the root. Inthis truncated tree T ∗ , leaves have G where | V ( G ) | = n . Now, change n to n = n − n .Due to this change, all leaves are with | V ( G ) | = n . Since, n < n , by induction, the numberof nodes with | V ( G ) | = 1 is bounded by 1 . n = 1 . n − n . Hence, the total runtime ofthe algorithm is bounded by n X s =0 . n − s × . n − s ≤ n X s =0 . s × . n − s ≤ O (1 . n ) (cid:74) In this work, we provide a fixed parameter tractable algorithm to the deletion to inducedmatching problem. We provide a novel way to combine ideas from branching and pathdecompostion, which gives an efficient solution to this problem. We note that using similarideas one could provide similar results for various exact version of ‘ - COC (2-
COC in our case).We believe that there could be further improvement to the runtime for
IND if the branchingrule-2 is improved to a better bound. The bottleneck could be analysing a matching caseinvolving an induced bipartite subgraph. We leave the improvement for future work.
References Maw-Shang Chang, Li-Hsuan Chen, Ling-Ju Hung, Peter Rossmanith, and Ping-Chen Su.Fixed-parameter algorithms for vertex cover p3.
Discrete Optimization , 19:12–22, 2016. Jianer Chen, Iyad A. Kanj, and Weijia Jia. Vertex cover: Further observations and furtherimprovements.
J. Algorithms , 41(2):280–301, 2001. Jianer Chen, Iyad A. Kanj, and Ge Xia. Improved upper bounds for vertex cover.
Theor.Comput. Sci. , 411(40-42):3736–3756, 2010. Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Dániel Marx, MarcinPilipczuk, Michal Pilipczuk, and Saket Saurabh.
Parameterized Algorithms . Springer, 2015. Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Daniel Marx, MarcinPilipczuk, Michal Pilipczuk, and Saket Saurabh.
Parameterized Algorithms . Springer PublishingCompany, Incorporated, 1st edition, 2015. Irit Dinur and Samuel Safra. On the hardness of approximating minimum vertex cover.
Annalsof mathematics , pages 439–485, 2005. Rodney G. Downey and Michael R. Fellows.
Fundamentals of Parameterized Complexity .Texts in Computer Science. Springer, 2013. . Kumar and M. Kumar 11 Fedor Fomin and Kjartan Høie. Pathwidth of cubic graphs and exact algorithms.
InformationProcessing Letters , 97:191–196, 03 2006. Fedor V. Fomin, Fabrizio Grandoni, and Dieter Kratsch. A measure & conquer approach forthe analysis of exact algorithms.
J. ACM , 56(5), 2009. Fedor V. Fomin and Dieter Kratsch.
Exact Exponential Algorithms . Texts in TheoreticalComputer Science. An EATCS Series. Springer, 2010. Frantisek Kardos, Ján Katrenic, and Ingo Schiermeyer. On computing the minimum 3-pathvertex cover and dissociation number of graphs.
Theor. Comput. Sci. , 412(50):7009–7017,2011. Stefan Kratsch. Recent developments in kernelization: A survey.
Bulletin of the EATCS , 113,2014. Mithilesh Kumar and Daniel Lokshtanov. A 2lk Kernel for l-Component Order Connectivity. InJiong Guo and Danny Hermelin, editors, , volume 63 of
Leibniz International Proceedings in Informatics(LIPIcs) , pages 20:1–20:14, Dagstuhl, Germany, 2017. Schloss Dagstuhl–Leibniz-Zentrum fuerInformatik. Daniel Lokshtanov, Neeldhara Misra, and Saket Saurabh. Kernelization–preprocessing with aguarantee. In
The Multivariate Algorithmic Revolution and Beyond , pages 129–161. Springer,2012. George L. Nemhauser and Leslie E. Trotter Jr. Properties of vertex packing and independencesystem polyhedra.
Math. Program. , 6(1):48–61, 1974. J. M. Robson. Algorithms for maximum independent sets.
J. Algorithms , 7(3):425–440, 1986. Larry J. Stockmeyer and Vijay V. Vazirani. Np-completeness of some generalizations of themaximum matching problem.
Inf. Process. Lett. , 15:14–19, 1982. Jianhua Tu. A fixed-parameter algorithm for the vertex cover p3 problem.
Inf. Process. Lett. ,115(2):96–99, 2015. Jianhua Tu and Wenli Zhou. A factor 2 approximation algorithm for the vertex cover p3problem.
Inf. Process. Lett. , 111(14):683–686, July 2011. David P. Williamson and David B. Shmoys.
The Design of Approximation Algorithms .Cambridge University Press, 2011. Mingyu Xiao and Shaowei Kou. Faster computation of the maximum dissociation set andminimum 3-path vertex cover in graphs. volume 9130, 07 2015. Mingyu Xiao and Hiroshi Nagamochi. Exact algorithms for maximum independent set. In
Algorithms and Computation - 24th International Symposium, ISAAC 2013, Hong Kong,China, December 16-18, 2013, Proceedings , pages 328–338, 2013. Mihalis Yannakakis. Node-deletion problems on bipartite graphs.