Approximation in (Poly-) Logarithmic Space
AApproximation in (Poly-) Logarithmic Space
Arindam Biswas
The Institute of Mathematical Sciences, HBNI, Chennai, [email protected]
Venkatesh Raman
The Institute of Mathematical Sciences, HBNI, Chennai, [email protected]
Saket Saurabh
The Institute of Mathematical Sciences, HBNI, Chennai, India and University of Bergen, Bergen,[email protected]
Abstract
We develop new approximation algorithms for classical graph and set problems in the RAM modelunder space constraints. As one of our main results, we devise an algorithm for d − Hitting Set thatruns in time n O ( d +( d/(cid:15) ) ), uses O (cid:0) ( d + ( d/(cid:15) )) log n (cid:1) bits of space, and achieves an approximationratio of O(( d/(cid:15) ) n (cid:15) ) for any positive (cid:15) ≤ d ∈ N . In particular, this yields afactor-O( d log n ) approximation algorithm which uses O (cid:0) log n (cid:1) bits of space. As a corollary, weobtain similar bounds on space and approximation ratio for Vertex Cover and several graphdeletion problems. For graphs with maximum degree ∆, one can do better. We give a factor-2approximation algorithm for
Vertex Cover which runs in time n O(∆) and uses O(∆ log n ) bits ofspace.For Independent Set on graphs with average degree d , we give a factor-(2 d ) approximationalgorithm which runs in polynomial time and uses O(log n ) bits of space. We also devise a factor-O (cid:0) d (cid:1) approximation algorithm for Dominating Set on d -degenerate graphs which runs in time n O(log n ) and uses O (cid:0) log n (cid:1) bits of space. For d -regular graphs, we observe that a known randomizedalgorithm which achieves an approximation ratio of O(log d ) can be derandomized and implementedto run in polynomial time and use O(log n ) bits of space.Our results use a combination of ideas from the theory of kernelization, distributed algorithmsand randomized algorithms. Theory of computation → Approximation algorithms analysis;Theory of computation → Graph algorithms analysis; Theory of computation → Streaming, sublinearand near linear time algorithms
Keywords and phrases approximation, logspace, logarithmic, log, space, small, limited, memory,ROM, read-only
This paper examines the classical approximation problems
Vertex Cover , Hitting Set and
Dominating Set in the RAM model under additional polylogarithmic space constraints.We devise approximation algorithms for these problems which use polylogarithmic space ingeneral and O(log n ) bits of space on certain special input types.In the absence of space constraints, the greedy heuristic is a good starting point formany approximation algorithms. For Set Cover , it even yields optimal (under certaincomplexity-theoretic assumptions) approximation ratios [2, 18]. However, the heuristicinherently changes the input in some way. In a space-constrained setting however, this isasking for too much: the input is immutable, and the amount of auxiliary space available(polylogarithmic in our case) is not sufficient to register changes to the input.Linear programming is another tool that plays a central role in the design of approximation a r X i v : . [ c s . D S ] A ug Approximation in (Poly-) Logarithmic Space algorithms. While it yields competitive approximations in polynomial time when space isnot constrained, it is known that under logarithmic-space reductions, it is P -complete toapproximate the Linear Programming problem to any constant factor [40]. Such a resultcan be shown even for positive linear programming [43].
Machine Model
We use the standard RAM model with an additional polylogarithmic spaceconstraint. For inputs n bits in length, memory is organized as words of length O(log n ),which allows the entire input to be addressed using a single word of memory. Integerarithmetic operations on pairs of words and single-word memory access operations takeconstant time. The input (a graph or family of sets) is provided to the algorithm using somecanonical encoding, which can be read but not modified, i.e. the algorithm has read-onlyaccess to the input.The algorithm uses some auxiliary memory, to which it has read-write access, and in thesetting of this paper, the amount of such memory available is bounded by a polynomial inlog n . Output is written to a stream: once something is output, the algorithm cannot read itback at a later point as it executes. We count the amount of auxiliary memory used in unitsof 1 bit, and the objective is to use as little auxiliary memory as possible. Our Results d − Hitting Set and Vertex Deletion Problems
An instance of the d − Hitting Set problem consists of a universe and a family of size- d subsets of the universe, and the objectiveis to find a subset of the universe that has a non-empty intersection with each set in thefamily.We develop a factor-O(( d/(cid:15) ) n (cid:15) ) approximation algorithm for d − Hitting Set which runsin time n Ohd +( d/(cid:15) ) and uses O (cid:0) ( d + ( d/(cid:15) )) log n (cid:1) bits of space (Section 3), where (cid:15) ≤ d is a fixed positive integer. In particular, this yieldsa factor-O( d log n ) approximation algorithm for the problem which uses O (cid:0) log n (cid:1) bits ofspace. As an application, we show how the algorithm can be used to approximate various deletion problems with similar space bounds. From this, we derive a factor-O((1 /(cid:15) ) n (cid:15) )(for arbitrary positive (cid:15) ≤
1) approximation algorithm for
Vertex Cover that runs intime n O(1 /(cid:15) )) and uses O((1 /(cid:15) ) log n ) bits of space.We give a simple factor-2 approximation algorithm for Vertex Cover on graphswith maximum degree ∆ which runs in time n O(∆) and uses O(∆ log n ) bits of space(Section 3.1). Dominating Set
In the
Dominating Set problem, the objective is to find a vertex set ofminimum size in a graph such that all other vertices are adjacent to some vertex in the set.We give a factor-O( √ n ) approximation algorithm for graphs excluding C (a cycle on 4vertices) as a subgraph, which runs in polynomial time and uses O(log n ) bits of space(Section 4.1).Graphs of bounded degeneracy form a large class which includes planar graphs, graphs ofbounded genus, graphs excluding a fixed graph H as a (topological) minor and graphs ofbounded expansion. For graphs with degeneracy d , we give a factor-O (cid:0) d (cid:1) approximationalgorithm which uses O (cid:0) log n (cid:1) bits of space. (Section 4.2).Additionally, for graphs in which each vertex has degree d , i.e. d -regular graphs, weexhibit a factor-O(log d ) approximation algorithm for Dominating Set (Section 4.3)which is an adaptation of known results to the constrained-space setting. . Biswas, V. Raman and S. Saurabh 3
Independent Set
An instance of the
Independent Set problem consists of a graph, andthe objective is to find an independent set of maximum size i.e. a set of vertices withno edges between them. We show how a known factor-(2 d ) approximation algorithm for Independent Set on graphs with average degree d can be implemented to run in polynomialtime and use O(log n ) bits of space (Section 5). Related Work
Small-space models such as the streaming model and the in-place model have been the subjectof much research over the last two decades (see [28, 15, 13] and references therein). In thestreaming model, in addition to the space constraint, the algorithm is also required to readthe input in a specific (possibly adversarial) sequence in one or more passes. The in-placemodel, on the other hand, allows the memory used for storing the input to be modified.The read-only RAM model we use is distinct from both these models. Historically, theread-only model has been studied from the perspective of time–space tradeoff lower bounds,particularly for problems like
Sorting [8, 9, 5, 32, 31] and
Selection [30, 21, 29, 35].The earliest graph problems studied in this model were the undirected and directed graphreachability problems (resp.
USTCON and
STCON ) in connection with the complexityclasses L and NL . Savitch [39] showed that on input graphs with n vetices, STCON (andtherefore also
USTCON ) can be solved in O (cid:0) log n (cid:1) bits of space. This bound was graduallywhittled down over more than two decades, a process culminating in the result of Reingold [38]which shows that USTCON can be solved using O(log n ) bits of space.Reif [37] showed that the problems of recognizing bipartite, chordal, interval and splitgraphs are reducible to USTCON . Later on, Allender and Mahajan [1] showed that planaritytesting also reduces to
USTCON . Thus, Reingold’s result put all these problems in L . Morerecently, Elberfeld and Kawarabayashi [19] showed that the problems of recognizing andcanonizing bounded-genus graphs were in L . The model was also studied by Yamakami [45]in relation to the complexity of search problems solvable in polynomial time, and byTantau [41], who studied the approximation properties of search problems that can besolved in nondeterministic logarithmic space.The other direction in which small-space problems and even the approximation problemswe study have been investigated previously is in the context of fast parallel algorithms. By aknown reduction, algorithms for these problems have sequential implementations that usepolylogarithmic space. The PRAM algorithm of Luby [26] for finding maximal independentsets in a graph can be used to 2-approximate Vertex Cover (recall that a better than2-approximate algorithm is known to be unlikely [24]). Implemented in the sequential RAMmodel, it uses O (cid:0) log n (cid:1) bits of space. There have been attempts to generalize Luby’salgorithm to hypergraphs, and to the best of our knowledge, an efficient deterministic parallelalgorithm (an NC algorithm) to find maximal independent sets in hypergraphs is not known toexist (see [6] and references therein). Our scheme for d − Hitting Set trades approximationfactor against space used to obtain a family of algorithms that use O (cid:0) ( d + ( d/(cid:15) )) log n ) (cid:1) bitsof space to obtain O(( d/(cid:15) ) n (cid:15) )-approximate solutions for any positive (cid:15) ≤
1. As a corollary, weobtain an O( d log n )-approximation algorithm that uses O (cid:0) log n (cid:1) bits of space. On graphswith maximum degree ∆, our approximation algorithm for Vertex Cover uses O(∆ log n )bits of space to obtain 2-approximate solutions.Berger et al. [7] gave a PRAM algorithm for Set Cover which can be implemented in thesequential RAM model to O(log n )-approximate Dominating Set in O (cid:0) log n (cid:1) bits of space.See also [42, 27], which give parallel approximation algorithms for Linear Programming ,and see [25], which gives tight approximation ratios for CSP’s using semi-definite programming
Approximation in (Poly-) Logarithmic Space in the PRAM model. Our algorithms for
Dominating Set are simpler and more direct,and work for a large class of graphs while using O (cid:0) log n (cid:1) bits of space. Our Techniques
As noted earlier, the greedy heuristic causes changes to the input, which our modeldoes not permit. To get around this, we use a staggered greedy approach in which thesolution is constructed in a sequence of greedy steps to approximate
Vertex Cover ongraphs of bounded degree (Section 3.1). By combining this with data reduction rulesfrom kernelization algorithms, we also obtain approximations for
Vertex Cover andmore generally d − Hitting Set (Section 3), and restricted versions of
Dominating Set (Sections 4.1 and 4.2). In Sections 4 and 5, we use 2-universal hash families constructible inlogarithmic space to approximate
Independent Set on graphs of bounded average degree(Section 5) and
Dominating Set on regular graphs (Section 4.3) in logarithmic space.
Notation N denotes the set of natural numbers { , , . . . } and Z + denotes the set of positiveintegers { , , . . . } . For n ∈ Z + , [ n ] denotes the set { , , . . . , n } . Let G be a graph. Itsvertex set is denoted by V( G ), and its edge set by E( G ). The degree of a vertex v is denotedby deg( v ), and for a set S ⊆ V( G ) or a subraph H of G , deg S ( v ) denotes the degree of v in G [ S ] and deg H ( v ) denotes the degree of v in H . Known Results
To start with, consider the next result, which arises from a logarithmic-space implementation of the Buss kernelization rule [10] for
Vertex Cover combined withthe observation that the kernel produced is itself a vertex cover. (cid:73)
Proposition 1 (Cai et al. [11], Theorem 2.3) . There is an algorithm which takes as inputa graph G and k ∈ N , and either determines that G has no vertex cover of size at most k or produces a vertex cover of size at most k . The algorithm runs in time O (cid:0) n (cid:1) and uses O(log n ) bits of space. The
Vertex Cover can be generalized to the d − Hitting Set problem ( d ∈ N , aconstant), an instance of which comprises a family of size- d subsets of a ground set and k ∈ N . The objective is to determine whether there is a hitting set of size at most k , i.e. asubset of the ground set which has a nonempty intersection with each set in the family. Thenext proposition shows that a similar result as above also holds for this generalization. (cid:73) Proposition 2 (Fafianie and Kratsch [20], Theorem 1) . There is an algorithm which takesas input a family F of d -subsets ( d ∈ N , a constant) of a ground set U and k ∈ N , and eitherdetermines that F has no hitting set of size at most k or produces an equivalent subfamily ofthe original family which has size O (cid:16) ( k + 1) d (cid:17) . The algorithm runs in time n O ( d ) and uses O (cid:0) d log n (cid:1) bits of space. Our algorithms repeatedly “delete” vertices or sets of vertices, but as they only have read-onlyaccess to the graph (or family of sets), we require a way to implement these deletions using asmall amount of auxiliary space. Towards that, we prove the following theorem. . Biswas, V. Raman and S. Saurabh 5 (cid:73)
Theorem 3.
Let G = G = ( V, E ) be a graph with n vertices, and let G i ( i ∈ [ k ] ) beobtained from G i − by deleting a set S i ⊆ V( G i − ) consisting of all vertices v ∈ V( G i − ) which satisfy a property that can be checked (given access to G i − ) using O(log n ) bits ofspace.Given read-only access to G , one can, for each i ∈ [ k ] , enumerate and answer membershipqueries for S i , V i = V( G i ) and E i = E( G i ) in time n O( i ) using O( i log n ) bits of space. Proof.
For each i ∈ [ k ] let Check i ( G i − , v ) be the algorithmic check which, given (oracle)access to G i − , determines whether v ∈ V i − satisfies the condition for inclusion in S i . Notethat this condition may be something that depends on the graph G i − , i.e. G i − must beaccessible to Check i .To provide oracle access to G i , V i and E i , it suffices to compute, for v ∈ V and uw ∈ E ,the predicates [ v ∈ V i ] and [ uw ∈ E i ]. A vertex is in V i if and only if it is in V i − and it isnot in S i . Similarly, an edge is in E i if and only if it is in E i − and neither of its endpointsare in S i . Thus, we have the following relations.[ v ∈ V i ] ≡ [ v ∈ V i − ] ∧ ¬ Check i ( G i − , v ) (1)[ uw ∈ E i ] ≡ [ uw ∈ E i − ] ∧ ¬ ( Check i ( G i − , u ) ∨ Check i ( G i − , w )) (2)To compute each of these predicates for G i , we require oracle access to G i − , which inturn involves computing the predicates [ v ∈ V i − ] and [ uw ∈ E i − ]. Suppose the numberof operations needed to compute Check i ( G i − , v ) is r ( n ), where r is a polynomial (it usesO(log n ) bits of space, so it is polynomial-time). Let p i (resp. q i ) be the amount of spaceused to compute the predicate [ v ∈ V i ] (resp. [ uw ∈ E i ]), and let s i (resp. t i ) be the timeneeded to compute the predicate [ v ∈ V i ] (resp. [ uw ∈ E i ]). From Relations 1 and 2 and thefact that Check i accesses G i − at most r ( n ) times, we see that these quantities satisfy thefollowing relations. p i = p i − + O(log n ) , q i = q i − + O(log n ) (3) s i = s i − + O( r ( n )( s i − + t i − )) , t i = t i − + O( r ( n )( s i − + t i − )) (4)It is easy to see that these recurrences solve to p i , q i = O( i log n ) and s i , t i = n O( i ) , soboth predicates can be computed in time n O( i ) using O( i log n ) bits of space.With oracle access to G i − , the predicate [ v ∈ S i ] can be computed simply as Check i ( G i − , v ), from which enumerating V i (resp. E i and S i ) is straightforward: enu-merate V (resp. E and V ) and suppress vertices v (resp. edges uw and vertices z ) which failthe predicate [ v ∈ V i ] (resp. [ uw ∈ E i ] and [ z ∈ S i ]). As the most space-hungry operations arethe membership queries, the enumeration can also be performed using O( i log n ) bits of space.The enumeration needs time n O( i ) for each element of V and E , and since | V | , | E | = O (cid:0) n (cid:1) ,the total time needed is also n O( i ) . (cid:74) Algorithms appearing later on use the trick of randomized sampling to obtain a certainstructure with good probability and then derandomize this procedure by using a family of2- universal functions. A 2- universal hash family is a family F of functions from [ n ] to [ k ],for integers n, k with k ≤ n such that for any pair i and j of elements from [ n ], the numberof functions from F that map i and j to the same element in [ k ] is at most |F| /k . Thefollowing proposition, which is a combination of a result of Carter and Wegman [12] showingthe existence of such families, and the observation that these families can be computed inlogarithmic space [44]. Approximation in (Poly-) Logarithmic Space (cid:73)
Proposition 4 (Carter and Wegman [12], Proposition 7) . Let n, k ∈ N with n ≥ k . One canenumerate a -universal hash family for [[ n ] → [ k ]] in polynomial time using O(log n ) bits ofspace. Π -Deletion Problems The d − Hitting Set problem is a generalization of
Vertex Cover in which an instanceconsists of a family F of d -subsets of a ground set U , and the objective is to find a subset of U of minimum size which intersects all sets in F .Algorithms for the problem are useful as subroutines in solving various deletion problems,where the objective is to delete the minimum possible number of vertices from a graph sothat the resulting graph satisfies a certain property. The following result is a corollary toProposition 2. (cid:73) Corollary 5.
Let F be a family of d -subsets of a ground set U with n elements. Onecan compute an O (cid:0) dn − /d (cid:1) -approximate minimum hitting set for F in time n O ( d ) using O (cid:0) d log n (cid:1) bits of space. Proof.
Consider the following algorithm. Starting at k = 1, run the algorithm of Proposition 2and repeatedly increment the value of k until k = n /d or the algorithm returns a solutionof size O (cid:16) d ( k + 1) d (cid:17) (i.e. it does not return a NO answer) for the first time. If k isincremented until n /d , then simply return the entire universe as the solution. Clearly,the approximation ratio is n − /d , as OP T ≥ n /d (and so the size of the solution returnedis n = n − /d · n /d ≤ n − /d · OP T , where
OP T is the size of the minimum hitting set).If k < n /d , then the size of the solution produced is O (cid:16) d ( k + 1) d (cid:17) , and we knowthat OP T ≥ k , since the algorithm had returned NO answers until this point. Sothe size of the solution produced is O (cid:16) d ( k + 1) d (cid:17) = O (cid:0) d ( k + 1) d − · ( OP T + 1) (cid:1) =O (cid:0) dn − /d · ( OP T + 1) (cid:1) . Thus, we have an O (cid:0) dn − /d (cid:1) -approximation. The bounds onrunning time and space used follow from the fact that the algorithm of Proposition 2 runs intime n O ( d ) and uses O (cid:0) d log n (cid:1) bits of space. (cid:74) The next result is one of our main results en route to developing a space-efficientapproximation algorithm for d − Hitting Set . (cid:73) Lemma 6.
Let (cid:15) ≤ be a positive number. There is an algorithm which takes as inputa family F of d -subsets of a ground set U of n elements and k ∈ N , and either determines F has no hitting set of size at most k or produces a hitting set of size O (cid:0) ( d/(cid:15) ) k (cid:15) (cid:1) . Thealgorithm runs in time n O ( d +( d/(cid:15) ) ) and uses O (cid:0) ( d + ( d/(cid:15) )) log n (cid:1) bits of space. Proof.
Let i = d ( d − /(cid:15) e . The algorithm performs i rounds of computation, each usingO(log n ) bits of space to determine a set of elements (accessible by oracle) to be removed inthe next round, or determine that F has no hitting set of size at most k . Use the algorithm of Proposition 2 to obtain a subfamily F ⊆ F over the ground set U ⊆ U such that |F | ≤ c ( k + 1) d , | U | = cd ( k + 1) d , andthere exists a hitting set S ⊆ U of size at most k in F if and only if there exists ahitting set S ⊆ U and S is a hitting set for F . Set U = U and F = F . For j = { , , . . . , i − } , perform the following steps. . Biswas, V. Raman and S. Saurabh 7 Determine S j , the set of all elements in U j − which appear in at least c ( k + 1) d − − j(cid:15) sets in F j − .Let U j = U j − \ S j and F j = { A ∈ F j − | A ∩ S j = ∅} . If there are more than c ( k + 1) d − j(cid:15) sets in F j , then return NO . Determine S i , the set of all elements in U i − which are in some set in F i − . Output S = S ij =1 S j .We now prove the correctness of the algorithm. In Step 1, the algorithm obtains theground set U and the family F , using the algorithm of Proposition 2. Let l ∈ [ i −
1] suchthat the algorithm answers NO in Step 2 for j = l , and otherwise let l = i if it never returns a NO answer in Step 2. (cid:66) Claim 7.
For all j ∈ [ l ], F j has at most c ( k + 1) d − j(cid:15) sets.Consider the case when the algorithm does not return a NO answer. Observe that the claimholds for the base case j = 1: F has c ( k + 1) d sets, and since the algorithm does notreturn a NO answer, we have |F | ≤ c ( k + 1) d − j(cid:15) . For induction, observe that whenever |F j | ≤ c ( k + 1) d − j(cid:15) , the algorithm ensures that |F j +1 | ≤ c ( k + 1) d − ( j +1) (cid:15) ; otherwise, itreturns a NO answer.Suppose the algorithm returns a NO answer at some value of j in Step 2, then there aremore than c ( k + 1) d − j(cid:15) sets in F j , which have survived the repeated removal of sets from F up to this point, and they cannot be hit by any k of the elements in U j , since each elementcan hit at most c ( k + 1) d − − j(cid:15) sets in F j . Thus, the algorithm correctly infers that the inputdoes not have a hitting set of size at most k .Once the algorithm has reached Step 3, the number of sets in the residual family, F i − is at most ( k + 1) d − ( d ( d − /(cid:15) e− · (cid:15) < k d − (( d − /(cid:15) − · (cid:15) = k (cid:15) . The set S i of elements in U i − that appear in some set in F i − is trivially also a hitting set. Observe that the sets ofelements removed in earlier stages, i.e. S , . . . , S i − together hit all sets in F not appearingin F i − . Thus, the set S = S ij =0 S j output by the algorithm is a hitting set for F . (cid:66) Claim 8.
The set S output by the algorithm has at most (( d − /(cid:15) + d ) k (cid:15) elements.For each j ∈ [ i − |F j − | ≤ c ( k + 1) d − ( j − (cid:15) (otherwise, itreturns a NO answer). Thus, the number of elements which appear in at least c ( k + 1) d − − j(cid:15) sets is at most (cid:16) c ( k + 1) d − ( j − (cid:15) (cid:17) / (cid:16) c ( k + 1) d − − j(cid:15) (cid:17) = k (cid:15) , i.e. | S j | ≤ k (cid:15) .In Step 3, the algorithm ensures that |F i − | ≤ k d − ( i − (cid:15) ≤ k (cid:15) . Each set in F i − edgesand each of these edges can span at most d elements. Thus, the number of elements in U i − which appear in some set in F i − dk (cid:15) , i.e. | S i | ≤ dk (cid:15) . Therefore, the total number ofelements output by the algorithm in all three phases is | S | = P ij =1 | S j | ≤ ( i − k (cid:15) + dk (cid:15) ≤ ( d ( d − /(cid:15) e + d ) k (cid:15) . (cid:66) Claim 9.
The algorithm runs in time n O ( d +( d/(cid:15) ) ) and uses O (cid:0) ( d + ( d/(cid:15) )) log n (cid:1) bits ofspace.Observe that in Step 1, the family F is obtained using the algorithm of Proposition 2, whichruns in time n O ( d ) and uses O (cid:0) d log n (cid:1) bits of space (for any constant d ). The output ofthe algorithm can now be used as an oracle for G .In Step 2, each successive family F j ( j ∈ [ i − F j − by deleting setscontaining elements which appear in at least k − j(cid:15) sets (this test can be performed usingO(log n )) bits of space. Thus, given oracle access to F j − , an oracle for F j can be providedwhich runs in polynomial time and uses O(log n ) bits of space. Approximation in (Poly-) Logarithmic Space
Step 3 involves writing out all elements in U i − that appear in some set in F i − , whichcan also be done in O(log n ) bits of space given oracle access to G i − . Since the numberof oracles created in Step 2 is i −
1, the various oracles together run in time n O( i ) and useO( i log n ) = O(( d/(cid:15) ) log n ) bits of space (Theorem 3). Combined with the n O ( d ) time andO (cid:0) d log n (cid:1) bits of space used by the oracle of Step 1, this gives bounds of n O ( d +( d/(cid:15) ) ) onthe running time and O (cid:0) ( d + ( d/(cid:15) )) log n (cid:1) bits on the total space used by the algorithm. (cid:74) The next theorem follows from the above lemma. (cid:73)
Theorem 10.
Let (cid:15) ≤ be a positive number. For instances ( U, F ) of d - Hitting Set with | U | = n , one can compute an O(( d/(cid:15) ) n (cid:15) ) -approximate minimum hitting set in time n O ( d +( d/(cid:15) ) ) using O (cid:0) ( d + ( d/(cid:15) )) log n (cid:1) bits of space. Proof.
Apply the algorithm of Lemma 6 starting from k = 1 successively incrementing by 1until the algorithm returns a family of size O (cid:0) ( d/(cid:15) ) k (cid:15) (cid:1) or k = n − (cid:15) . When k = n − (cid:15) returnthe entire universe as the solution. As, in this case, OP T ≥ n − (cid:15) , the size of the solutionproduced, which is n ≤ n (cid:15) OP T , and so we have a factor- n (cid:15) approximation algorithm.When the algorithm returns a family of size O (cid:0) ( d/(cid:15) ) k (cid:15) (cid:1) for some k , note that OP T ≥ k (as the algorithm returned NO so far), and so the solution produced is of size O(( d/(cid:15) ) k (cid:15) k ),which is O(( d/(cid:15) ) n (cid:15) OP T ) resulting in a factor-O(( d/(cid:15) ) n (cid:15) ) approximation algorithm. As wemerely reuse the procedure of Lemma 6, the running time is O (cid:0) ( d + ( d/(cid:15) )) log n (cid:1) and theamount of space used is O (cid:0) ( d + ( d/(cid:15) )) log n (cid:1) bits. (cid:74) The above theorem allows us to devise space-efficient approximation algorithms for anumber of graph deletion problems. Let Π be a hereditary class of graphs, i.e. a class closedunder taking induced subgraphs. Let Φ be a set of forbidden graphs for Π such that a graph G is in Π if and only no induced subgraph of G is isomorphic to a graph in Φ. Considerthe problem Del–
Π (described below), defined for classes Π with finite sets Φ of forbiddengraphs.
Instance G , a graph Solution a set of vertices smallest size whose deletion yields a graph in ΠThe next result is a combination of the fact that
Del–
Π can be formulated as a certainhitting set problem and the procedure of Theorem 10. (cid:73)
Lemma 11.
Let (cid:15) ≤ be a positive number. On graphs with n vertices, one can compute O((1 /(cid:15) ) n (cid:15) ) -approximate solutions for Del– Π in time n O(1 /(cid:15) ) using O((1 /(cid:15) ) log n ) bits ofspace. Proof.
Let Π be a class of graphs characterized by a finite set Φ of forbidden inducedsubgraphs. Consider the problem of finding, given a graph, a deletion set of vertices ofminimum size whose removal from the graph produces a graph in Π.Given a graph G on n vertices, it is possible using O((1 /(cid:15) ) log n ) bits of space, toproduce an O( n (cid:15) /(cid:15) )-approximate minimum deletion set for G . Simply construct the family F G = { S ⊆ V( G ) | G [ S ] contains a graph from Φ } . This family of subsets is constructed “onthe fly” in a systematic way (as and when the hitting set algorithm needs it) by runningover all subsets of V ( G ) of size at most d where d is the maximum size of the vertex setin a graph in Φ. It can be seen that this can be constructed using O(log n ) bits of spacefor constant d and that an O( n (cid:15) /(cid:15) ) approximate minimum hitting set for F G is also anO( n (cid:15) /(cid:15) )-approximate solution for the deletion problem. . Biswas, V. Raman and S. Saurabh 9 Thus, a variant of the procedure described earlier can be used to produce O( n (cid:15) /(cid:15) )-approximate solutions for n -vertex instances of this problem using using O((1 /(cid:15) ) log n ) bitsof space. (cid:74) The following list defines problems for which we obtain polylogarithmic-space approxima-tion algorithms using the preceding lemma.
Triangle-Free Deletion
Instance: ( G, k ), where G is a graph and k ∈ N Question:
Is there a set S ⊆ V( G ) with | S | ≤ k such that G − S has no triangles? Tournament FVS
Instance: ( D, k ), where D is a a tournament and k ∈ N Question:
Is there a set S ⊆ V( D ) with | S | ≤ k such that G − S is acyclic? Cluster Deletion
Instance: ( G, k ), where G is a graph and k ∈ N Question:
Is there a set S ⊆ V( G ) with | S | ≤ k such that G − S is a disjoint union ofcliques, i.e. a cluster graph? Split Deletion
Instance: ( G, k ), where G is a graph and k ∈ N Question:
Is there a set S ⊆ V( G ) with | S | ≤ k such that G − S can be partitioned intoa clique and an independent set, i.e. such that ( G − S ) is a split graph? Threshold Deletion
Instance: ( G, k ), where G is a graph and k ∈ N Question:
Is there a set S ⊆ V( G ) with | S | ≤ k such that G − S is threshold graph? Athreshold graph is one which can be constructed from a single vertex by a sequence ofoperations that either add an isolated vertex, or add a vertex which dominates all theother vertices. Cograph Deletion
Instance: ( G, k ), where G is a graph and k ∈ N Question:
Is there a set S ⊆ V( G ) with | S | ≤ k such that G − S contains no inducedpaths of length 4, i.e. it is a cograph?For all the problems appearing above, the target graph classes are known to becharacterized by a finite set of forbidden induced subgraphs (see e.g. Cygan et al. [17])and so the problems can be formulated as Del–
Π. By setting (cid:15) to a small positive constantor (1 / log n ), we obtain the following corollary to Lemma 11. (cid:73) Corollary 12.
On graphs with n vertices, one can compute O( n (cid:15) ) -approximate solutions in time n O(1 /(cid:15) ) = n O(1) using
O((1 /(cid:15) ) log n ) = O(log n ) bitsof space for any positive constant (cid:15) ≤ , and O(log n ) -approximate solutions in time n O(log n ) using O (cid:0) log n (cid:1) bits of spacefor the problems Vertex Cover , Triangle-Free Deletion , Threshold Deletion , Cluster Deletion , Split Deletion , Cograph Deletion and
Tournament FVS . We begin this section with the observation that in a directed graph with maximum outdegree1, every connected component contains (as an induced subgraph or otherwise) at most one(undirected) cycle. For such a directed graph D , consider the graph G obtained by ignoringarc directions. Because every connected component in G also has at most one cycle, onecan find a minimum vertex cover for G in polynomial time and logarithmic space using a modified post-order traversal procedure on the connected components. The following lemmaformalizes this discussion. (cid:73) Lemma 13.
Let D be a directed graph on n vertices with maximum outdegree and let G be the undirected graph obtained by ignoring the arc directions in D . One can find aminimum vertex cover for G in polynomial time using O(log n ) bits of space. To prove the above lemma, we use the following algorithm, which computes minimumvertex covers in trees.
Algorithm 1,
TreeVtxCover: compute a minimum vertex cover
Input: T = ( V, E ), a tree
Output: a mininmum vertex cover for T let r be an arbitrary vertex of T ; foreach v ∈ V( T ) do if IsInVC ( v, r, T ) then output v ; Procedure
IsInVC( v, r, T ) // T a tree rooted at r , v a vertex in V( T ) generate a post-order traversal L for T with r as the root; seek L to the first leaf in the subtree of T rooted at v ; visited _ vertex ← NULL ; visited _ included ← NO ; foreach u ∈ L do if u is a leaf then visited _ vertex ← u ; visited _ included ← NO ; else // u is not a leaf; u is the parent of visited _ vertex visited _ vertex ← u ; if not visited _ included then if u = v then return YES ; visited _ included ← YES ; // include u else // last-visited vertex was included if u = v then return NO ; visited _ included ← NO ; // do not include u seek L to u ’s parent; // vertices in subtrees of u ’s unvisitedsiblings can be ignored The algorithm operates by rooting T at an arbitrary vertex r ∈ V( T ) and determines avertex cover S given by repeatedly applying the following rule. Rule VCT
Include the the parents of leaves on the bottom level of T in S , then deletefrom T the included vertices, their children, and all edges incident with them. The fact that S is a minimum vertex cover follows directly from the observation thatto cover the edges of T incident with the leaves at the bottom level, picking the parents ofthose leaves is at least as good as any other choice of covering vertices. . Biswas, V. Raman and S. Saurabh 11 Observe that at any intermediate stage in the repeated application of Rule VCT, a vertexis a leaf on the bottom level of T if a previous application of the rule deleted all of its children,i.e. all of them were included in S . Thus, any vertex v ∈ V( T ), is in S if and only if S doesnot contain all of its children.Instead of repeatedly deleting vertices from T , Procedure IsInVC in the algorithmdetermines membership in S by performing what is essentially a post-order traversal of T .In the post order traversal, to determine if a vertex v is in S , the only information necessaryis whether at least one of v ’s children is not in S , which the procedure stores in the variable visited _ included . If such a child vertex is encountered, the procedure determines that v isin S , and skips the rest of the subtree rooted at v .The post-order traversal used by the procedure can be generated from a BFS traversal of T , which can be computed using O(log n ) bits of space [16]. The constantly-many variablesappearing in the algorithm also use O(log n ) bits of space total. Therefore, the overallspace usage of the algorithm is O(log n ) bits. The following lemma formalizes the precedingdiscussion. (cid:73) Lemma 14.
For an input tree T on n vertices, the algorithm TreeVtxCover computes aminimum vertex cover using O(log n ) bits of space. By layering multiple such steps, one can find a vertex cover in a bounded degree graphwhich is a 2-approximation for the minimum vertex cover. Our approach is inspired bya local distributed algorithm of Polishchuk and Suomela [34] which computes a factor-3approximations. (cid:73)
Theorem 15.
There is an algorithm which takes as input a graph G on n vertices in whichevery vertex has degree at most ∆ , and computes a -approximate minimum vertex cover for G . The algorithm runs in time n O(∆) and uses
O(∆ log n ) bits of space. Proof.
Set G = G and V = V( G ). The algorithm works in stages 1 , . . . , ∆ as follows. InStage i , it enumerates the subgraph H i − of G i − in which each vertex of u of G i − onlyretains the edge to its i th neighbour v (if it exists) in G . Observe that directing every suchedge from u to v yields a directed graph R with maximum outdegree 1.Applying the procedure of Lemma 13 with D = R and G = H i − , the algorithm nowcomputes a minimum vertex cover S i for H i − in polynomial time using O(log n ) bits ofspace. It then produces the graph G i by removing the vertex set S i from G i − and outputsthe vertices in S i . At the end of Stage ∆, the algorithm terminates.We now prove the bounds in the claim. Observe that the vertex set of G i ( i ∈ [∆]) isprecisely V( G i − ) \ S i . In Stage i , the algorithm only considers the vertices in G i − , so thevertex cover generated by it has no neighbours in vertex covers generated in earlier stages,i.e. S i ∩ S j = ∅ for j < i .For each H i − , consider a maximal matching M i in H i − . From the way the varioussets S i are generated, it is easy to see that S = S ∆ i =1 S i forms a vertex cover for G andadditionally, M = S ∆ i =1 M i is a maximal matching in G . Observe that the each set S i alsocovers the matching M i in H i − . Since S i is a minimum vertex cover for H i − , and theendpoints of edges in M i form a vertex cover for H i − , we have | S i | ≤ | M i | .As M is a maximal matching in G , the endpoints of edges in M form a vertex cover for G , and we have | S | = P ∆ i =1 | S i | ≤ · P ∆ i =1 | M i | ≤ · P ∆ i =1 τ ( G ), where τ ( G ) is the vertexcover number of G . Thus, the set S output by the algorithm is a 2-approximate vertex cover.Now observe that for all i ∈ [∆], G i and S i satisfy the hypothesis of Theorem 3. Thus,one can compute each of the sets S i in time n O( i ) using O( i log n ) bits of space. Since the maximum value i takes on is ∆, the algorithm runs in time n O(∆) and uses a total ofO(∆ log n ) bits of space. (cid:74) In this section, we describe approximation algorithms for
Dominating Set restricted tocertain graph classes. A problem instance consists of a graph G = ( V, E ) and k ∈ N , and theobjective is to determine if there is a dominating set of size at most k , i.e. a set S ⊆ V of atmost k vertices such that S ∪ N( S ) = V .The first result of this section concerns graphs excluding C (a cycle on 4 vertices) as asubgraph. On such graphs, one can compute O( √ n )-approximations using O(log n ) bits ofspace using a known kernelization algorithm [36]. C -Free Graphs Any vertex v ∈ V( G ) of degree at least 2 k + 1 must be in any dominating set of size at most k , as any other vertex (including a neighbour of v ) can dominate at most 2 vertices in theneighbourhood (as there will be a C otherwise). Using this, we establish the following result. (cid:73) Lemma 16.
There is an algorithm which takes as input a C -free graph G on n verticesand k ∈ N , and either determines that G has no dominating set of size at most k , or outputsa dominating set of size O (cid:0) k (cid:1) . The algorithm runs in polynomial time and uses O(log n ) bits of space. Proof.
The crux of the algorithm is the fact that any vertex v ∈ V( G ) of degree at least2 k + 1 must be in any dominating set of size at most k , as any other vertex (including aneighbour of v ) can dominate at most 2 vertices in the neighbourhood (as there will be a C otherwise). The algorithm proceeds as follows. Let S be the set of vertices with degree more than 2 k . If | S | is more than k , return NO . Note that all vertices in N( S ) have already been dominated. If | V \ ( S ∪ N( S )) | > ( k − | S | ) · (2 k + 1) return NO , as each vertex in V \ S can dominate at most 2 k + 1 verticesincluding itself. If the algorithm has not returned NO , output S ∪ ( V \ ( S ∪ N( S )))Correctness is immediate from the the description of the algorithm. When it outputsvertices, it outputs S , which has at most k vertices from Step 1, and the number of remainingvertices in Step 2 is O (cid:0) k (cid:1) , so it outputs O (cid:0) k (cid:1) vertices overall. To see that the space used isO(log n ) bits, observe that membership in each of the sets output is determined by predicatesthat test degrees of vertices individually, and these predicates can by computed in logarithmicspace. Thus, by Theorem 3, the algorithm uses a total of O(log n ) bits of space. (cid:74) The proof of the following corollary uses arguments very similar to those in the proof ofTheorem 10, so we omit it. (cid:73)
Corollary 17.
There is an algorithm which takes as input a C -free graph G on n vertices,and computes an O( √ n ) -approximate minimum dominating set for G . The algorithm runsin polynomial time and uses O(log n ) bits of space. . Biswas, V. Raman and S. Saurabh 13 A graph is called d -degenerate if there is a vertex of degree at most d in every subgraph of G . A graph with maximum degree d is clearly d -degenerate. Planar graphs are 5-degenerate.Let G be a d -degenerate graph on n vertices. As every subgraph of G has a vertex withdegree at most d , the number of edges in G is at most dn . It follows that (cid:73) Observation 1.
In any subgraph of p vertices of a d degenerate graph, at least p/ d .There is a generalization of polynomial kernel of Dominating Set for C -free graphs to K i,j -free graphs for any fixed i, j ∈ N [33] (recall that K i,j is the complete bipartite graphwith i vertices in one part and j vertices in the other). The class of K i,j -free graphs includes C -free graphs, and ( i + 1)-degenerate graphs (where i ≤ j ). This kernelization, however,does not appear suited to approximation in logarithmic (or even polylogarithmic) space. Todesign a space-efficient approximation algorithm for d -degenerate graphs, we resort insteadto the O (cid:0) d (cid:1) -approximation algorithm of Jones et al. [23]. To achieve an O (cid:0) log n (cid:1) boundon the space used, several adaptations are necessary.The algorithm starts by picking the neighbours of all vertices of degree at most 2 d , andworks by repeatedly finding such vertices in smaller and smaller sugraphs of G and pickingall their neighbours in the solution. As the vertex or one of its neighbours must be in anydominating set, this will result in an O( d ) approximation if we manage to find a vertex thatdominates (at least one and) at most 2 d of the undominated vertices. This may not happenin the intermediate steps as more and more vertices are dominated by those vertices pickedearlier. So we do some careful partitioning of the vertices and find low degree vertices inappropriate subgraphs.Let Y be the set of vertices picked at any point, B be the set of vertices (other than thosein Y ) dominated by Y , and W be the set of vertices in V \ ( Y ∪ B ) (see Figure 1). The goalis to dominate vertices in W , and we try to do so by finding (the neighbours of) low degreevertices from B ∪ W . So we start finding low degree (at most 2 d ) vertices in B ∪ W to picktheir neighbours. First we look for such vertices in B , and so we further partition B into B h ,those vertices of B with at least 2 d + 1 neighbours in W and B l = B \ B h .First, we remove (for later consideration) vertices of W that have no neighbours in W ∪ B h ,let they be W l and focus on the induced subgraph G [ B h ∪ W h ] where W h = W \ W l . Here,we are bound to find low degree vertices from W h (as vertices in B h have high degree) as longas W h is non-empty, and so we repeat the above procedure of picking the neighbours of alllow degree vertices from W h . Finally, when W h is empty, if W l is non-empty, we simply pickall vertices of W l into the solution and return it. What follows is a pseudocode descriptionof the algorithm.If we treat a round as the step where we find all vertices in W h with at most 2 d neighboursin W h , then as at least a fraction of the vertices of W h are dominated in each round dueto Observation 1, the number of rounds is O(log n ). Each round just requires identifyingvertices based on their degrees in the resulting subgraph, the i -th round can be implementedin O( i log n ) bits using Theorem 3 resulting in an O (cid:0) log n (cid:1) bits implementation.The approximation ratio of O (cid:0) d (cid:1) can be proved formally using a charging argument(see Jones et al. [23], Theorem 4.9). We give an informal explanation here. First we arguethe approximation ratio of (2 d + 1) for the base case when W h is empty. Isolated verticesin W l are isolated vertices in G and hence they need to be picked in the solution. Thenumber of non-isolated vertices in W l is at most 2 d | B l | as their neighbours are only in B l (otherwise, by definition, those vertices will be in W h ). As vertices in B l have degree at most W h B h B l W l Y : partial solution B : verticesdominated by Y W : remainingvertices Y dominate at most2 d vertices in W dominate at least2 d + 1 vertices in W Figure 1
Partitioning of the vertices in the algorithm for
Dominating Set on d -degenerategraphs. d , | W l | ≤ d | B l | and as at least one vertex of B l ∪ W l must be picked to dominate a vertexin W l , we have the approximation ratio of (2 d + 1) for those vertices.In the intermediate step, if we did not ignore vertices in B l to dominate a vertex in W h ,a (2 d + 1)- approximation is clear. For, a vertex or one of its at most 2 d neighbours mustbe picked in the dominating set. However, a vertex in W h maybe dominated by a vertex in B l , but by ignoring B l , we maybe picking 2 d vertices to dominate it. As a vertex in B l candominate at most 2 d (such) vertices of W h , we get an approximation ratio of O (cid:0) d (cid:1) .The next theorem formalizes the above discussion. (cid:73) Theorem 18.
There is an algorithm which takes as input a d -degenerate graph G on n vertices and computes an O (cid:0) d (cid:1) -approximate minimum dominating for G . The algorithmuses O (cid:0) log n (cid:1) bits of space and runs in time n O(log n ) . On regular graphs, we can achieve a better approximation ratio in logarithmic space byderandomizing a result of Alon and Spencer [3] on the size of a dominating set on graphswith minimum degree d . (cid:73) Proposition 19 (Alon and Spencer [3], Theorem 1.2.2) . Any graph on n vertices withminimum degree d has a dominating set of size at most n (log ( d + 1) + 1) / ( d + 1) . On a d -regular graph, because the size of any dominating set is at least n/ ( d + 1), theapproximation ratio achieved is log ( d + 1) + 1.Now we outline the proof of the above proposition to show how it can be derandomized.Consider a d -regular graph G on n vertices. Picking each vertex of G with probability . Biswas, V. Raman and S. Saurabh 15 Algorithm 2,
DgnDomSet: find an approximate minimum dominating set
Input: G = ( V, E ), a d -degenerate graph Output: S , an O (cid:0) d (cid:1) -approximate minimum dominating set for G W, W h ← V ; W l , Y, B, B h , B l ← ∅ ; while W h = ∅ do // there are vertices in W h to be dominated W ∗ ← W ∪ B h ; S ← n v ∈ W h | deg G [ W ∗ ] ( v ) ≤ d o ; Y ← Y ∪ N G [ W ∗ ] ( S ) // Y is the partial solution ; B ← N( Y ); W ← V \ ( Y ∪ B ); B h ← n v ∈ B | deg G [ W ] ( v ) ≥ d + 1 o ; B l ← B \ B h ; W ∗ ← W ∪ B h ; W h ← { v ∈ W | v is not isolated in G [ W ∗ ] } ; W l ← W \ W h ; return Y ∪ W l p = log ( d + 1) / ( d + 1) yields a set S with expected size E [ | S | ] = np . By adding in thevertices not dominated by S , we obtain a dominating set W = S ∪ ( V \ ( S ∪ N( S ))). Theexpected size of this set is E [ | W | ] ≤ n ( p + (1 − p ) d +1 ), and it can be shown that this quantityis n (log ( d + 1) + 1) / ( d + 1).Note that the expectation bounds only need the sampling of the vertices to bepairwise independent. Consider a 2-universal hash family F for [[ n ] → [ d + 1]], and define S f = { v ∈ V( G ) | f ( v ) ≤ log ( d + 1) + 1 } and W f = S f ∪ ( V \ ( S f ∪ N( S f ))). Over functions f = F , the sampling probability P( v ∈ S f ) is b (log ( d + 1) + 1) / ( d + 1) c . Because F is a2-universal hash family, there is a function f ∈ F for which W f achieves the expectationbound for | W | above.The sampling procedure can now be derandomized as follows. Enumerate F in logarithmicspace using Proposition 4 and enumerate it. For each f ∈ F , determine | W f | , and output W f for the first function f for which | W f | ≥ n (log ( d + 1) + 1) / ( d + 1).We thus have the following result. (cid:73) Theorem 20.
There is an algorithm which takes as input a d -regular graph G on n vertices,and computes a (log ( d + 1) + 1) -approximate minimum dominating set for G . The algorithmruns in polynomial time and uses O(log n ) bits of space. In this section, we consider the
Independent Set problem restricted to graphs with boundedaverage degree. On general graphs, the problem is unlikely to have a non-trivial (factor-( n − (cid:15) )) approximation algorithm [22]. However, if the graph has average degree d , then anindependent set satisfying the bound of the next lemma is a (2 d )-approximate solution. Notethat graphs of bounded average degree encompass planar graphs and graphs of boundeddegeneracy. It is also known 2 d is the best approximation ratio possible up to polylogarithmicfactors in d [4, 14]. (cid:73) Proposition 21 (Alon and Spencer [3], Theorem 3.2.1) . If a graph on n vertices has averagedegree d , then it has an independent set of size at least n/ (2 d ) . In what follows, we develop a logarithmic-space procedure that achieves the above bound.Let G = ( V, E ) be a graph on n vertices with average degree d . Consider a set S ⊆ V obtained by picking each vertex in V independently with probability p = 1 /d . Let m S be thenumber of edges with both endpoints in S . The following bound appears as an intermediateclaim in the proof of Proposition 21 (see Alon and Spencer [3], Theorem 3.2.1). We use ithere without proof. (cid:73) Lemma 22. E [ | S | − m S ] = n d . Consider the set I obtained by arbitrarily eliminating an endpoint of each edge in G [ S ]. Observe that G [ I ] has no edges, i.e. I is an independent set whose expected size is E [ | S | − m S ] = n/ (2 d ).Derandomizing this sampling procedure is simple: simply run through the functions ofa 2-universal hash family F for [[ n ] → [ d ]] and for each f ∈ F , pick a vertex v ∈ V into S if and only if f ( v ) = 1. Because the range of the functions is [ d ], the sampling probabilityis P( v ∈ S ) = 1 /d . Recall that Lemma 22 only requires the sampling procedure to bepairwise independent, so the expectation bound remains the same: E [ | S | − m S ] = n/ (2 d ).While going through F , select the function f ∈ F which maximizes | S | − m S , where S = { v ∈ V | f ( v ) = 1 } and m S is the number of edges uv ∈ E with f ( u ) = f ( v ) = 1. Usingthe construction of Proposition 4, this step can be performed in polynomial time usingO(log n ) bits of space and f can be used as an oracle for S at the same space cost.The next step, in which vertices are deleted arbitrarily from each pair of adjacent verticesin the sample S , is tricky to carry out in small space. This is because for any edge uv in G [ S ],it is not possible to determine whether either of the endpoints survive the deletion procedurewithout additional information about the other edges incident with u and v . However, thereis a simple fix for this: retain only those vertices in S which are the smallest vertices intheir neighbourhoods in G [ S ]. Using this, we prove the following lemma and the subsequenttheorem, as a direct consequence. (cid:73) Lemma 23.
Let T be the set of vertices v ∈ S such that v is the smallest vertex (in theoriginal arbitrary labelling) in its neighbourhood in G [ S ] . The set T is independent in G ,has size | T | ≥ | S | − m S , and one can enumerate it in polynomial time using O(log n ) bits ofspace. Proof.
Determining if v ∈ S is the smallest vertex in its neighbourhood in G [ S ] involvesenumerating the neighbourhood of v in the induced subgraph G [ S ] which can be performedin polynomial time using O(log n ) bits of additional space. As we pick only one vertex fromeach neighbourhood, the set T picked is independent and it is trivial to see that the overallprocedure is polynomial-time and uses O(log n ) bits of space.Let C , . . . , C t be the connected components of G [ S ]. Consider the difference between thenumber of vertices and the number of edges in each component. Any component with l verticescontains at least l − i ∈ [ t ], denote by n i the number of vertices in C i and by m i ,the number of edges. We have P ti =1 ( n i − ≤ P ti =1 m i , i.e. P ti =1 n i − t ≤ P ti =1 m i = m S ,which implies that t ≥ n − m S .As we pick at least one vertex (the smallest vertex) from each component in T , we have | T | ≥ t ≥ n − m . Since (cid:74) . Biswas, V. Raman and S. Saurabh 17 (cid:73) Theorem 24.
There is a an algorithm which takes as input a graph G on n vertices withaverage degree d , and computes a (2 d ) -approximate maximum independent set in G . Thealgorithm runs in polynomial time and uses O(log n ) bits of space. We devised space efficient approximation algorithms for d − Hitting Set (and its restriction
Vertex Cover ), Independent Set and
Dominating Set in some special classes ofgraphs.We consider our contribution as simply drawing attention to a direction in the study ofapproximation algorithms, and believe that it should be possible to improve the approximationratios and the space used for the problems considered here. Obtaining a constant-factoror even factor-O(log n ) approximation algorithm for Vertex Cover and a factor-O(log n )approximation algorithm for Dominating Set on general graphs using O(log n ) bits ofspace are some specific open problems of interest. References Eric Allender and Meena Mahajan. The complexity of planarity testing.
Information andComputation , 189(1):117–134, February 2004. doi:10.1016/j.ic.2003.09.002 . Noga Alon, Dana Moshkovitz, and Shmuel Safra. Algorithmic construction of sets for k-restrictions.
ACM Transactions on Algorithms , 2(2):153–177, April 2006. doi:10.1145/1150334.1150336 . Noga Alon and Joel H. Spencer.
The Probabilistic Method . Wiley, Hoboken, NJ, USA, thirdedition, 2008. Per Austrin, Subhash Khot, and Muli Safra. Inapproximability of Vertex Cover andIndependent Set in Bounded Degree Graphs.
Theory of Computing , 7(1):27–43, March2011. doi:10.4086/toc.2011.v007a003 . Paul Beame. A general Sequential Time-Space Tradeoff for Finding Unique Elements.
SIAMJournal on Computing , 20(2):270–277, April 1991. doi:10.1137/0220017 . Ioana O. Bercea, Navin Goyal, David G. Harris, and Aravind Srinivasan. On ComputingMaximal Independent Sets of Hypergraphs in Parallel.
ACM Transactions on ParallelComputing , 3(1):1–13, January 2017. doi:10.1145/2938436 . Bonnie Berger, John Rompel, and Peter W. Shor. Efficient NC algorithms for set coverwith applications to learning and geometry.
Journal of Computer and System Sciences ,49(3):454–477, December 1994. doi:10.1016/S0022-0000(05)80068-6 . Allan Borodin and Stephen A. Cook. A Time-Space Tradeoff for Sorting on a GeneralSequential Model of Computation.
SIAM Journal on Computing , 11(2):287–297, May 1982. doi:10.1137/0211022 . Allan Borodin, Michael J. Fischer, David G. Kirkpatrick, Nancy A. Lynch, and Martin Tompa.A time-space tradeoff for sorting on non-oblivious machines.
Journal of Computer and SystemSciences , 22(3):351–364, June 1981. doi:10.1016/0022-0000(81)90037-4 . Jonathan F. Buss and Judy Goldsmith. Nondeterminism within P.
SIAM Journal onComputing , 22(3):560–572, June 1993. doi:10.1137/0222038 . Liming Cai, Jianer Chen, Rodney G. Downey, and Michael R. Fellows. Advice classes ofparameterized tractability.
Annals of Pure and Applied Logic , 84(1):119–138, March 1997. doi:10.1016/S0168-0072(95)00020-8 . J. Lawrence Carter and Mark N. Wegman. Universal classes of hash functions.
Journalof Computer and System Sciences , 18(2):143–154, April 1979. doi:10.1016/0022-0000(79)90044-8 . Sankardeep Chakraborty, Anish Mukherjee, Venkatesh Raman, and Srinivasa Rao Satti.A Framework for In-place Graph Algorithms. In , volume 112, pages 13:1 – 13:16, Helsinki, Finland, August 2018. Schloss Dagstuhl –Leibniz-Zentrum für Informatik. doi:10.4230/lipics.esa.2018.13 . Siu On Chan. Approximation Resistance from Pairwise-Independent Subgroups.
Journal ofthe ACM , 63(3):1–32, September 2016. doi:10.1145/2873054 . Timothy M. Chan, J. Ian Munro, and Venkatesh Raman. Selection and Sorting in the “Restore”Model. In
Proceedings of the 25th Annual Symposium on Discrete Algorithms , pages 995–1004,Portland, OR, USA, January 2014. SIAM. doi:10.1137/1.9781611973402.74 . Stephen A. Cook and Pierre McKenzie. Problems complete for deterministic logarithmic space.
Journal of Algorithms , 8(3):385–394, September 1987. doi:10.1016/0196-6774(87)90018-6 . Marek Cygan, Fedor V. Fomin, Łukasz Kowalik, Daniel Lokshtanov, Dániel Marx, MarcinPilipczuk, Michał Pilipczuk, and Saket Saurabh.
Parameterized Algorithms . Springer-Verlag,Cham, Switzerland, 2015. Irit Dinur and David Steurer. Analytical approach to parallel repetition. In
Proceedings ofthe 46th Annual ACM Symposium on Theory of Computing - STOC ’14 , pages 624–633, NewYork, New York, May 2014. ACM Press. doi:10.1145/2591796.2591884 . Michael Elberfeld and Ken-ichi Kawarabayashi. Embedding and canonizing graphs of boundedgenus in logspace. In
Proceedings of the 46th Annual Symposium on Theory of Computing ,pages 383–392, New York, NY, USA, May 2014. ACM Press. doi:10.1145/2591796.2591865 . Stefan Fafianie and Stefan Kratsch. A Shortcut to (Sun)Flowers: Kernels in LogarithmicSpace or Linear Time. In
Mathematical Foundations of Computer Science , volume 9235, pages299–310, Milan, Italy, August 2015. Springer-Verlag. doi:10.1007/978-3-662-48054-0_25 . Greg N. Frederickson. Upper bounds for time-space trade-offs in sorting and selection.
Journalof Computer and System Sciences , 34(1):19–26, February 1987. doi:10.1016/0022-0000(87)90002-X . Johan Håstad. Clique is hard to approximate within nˆ(1 - (cid:15) ). Acta Mathematica , 182(1):105–142,March 1999. doi:10.1007/BF02392825 . Mark Jones, Daniel Lokshtanov, M. S. Ramanujan, Saket Saurabh, and Ondřej Suchý.Parameterized Complexity of Directed Steiner Tree on Sparse Graphs.
SIAM Journal onDiscrete Mathematics , 31(2):1294–1327, January 2017. doi:10.1137/15M103618X . Subhash Khot and Oded Regev. Vertex cover might be hard to approximate to within 2 - (cid:15) . Journal of Computer and System Sciences , 74(3):335–349, May 2008. doi:10.1016/j.jcss.2007.06.019 . Jason Li and Ryan O’Donnell. Bounding Laconic Proof Systems by Solving CSPs in Parallel.In
Proceedings of the 29th Annual Symposium on Parallelism in Algorithms and Architectures ,pages 95–100, Washington, DC, USA, July 2017. ACM Press. doi:10.1145/3087556.3087557 . Michael Luby. A Simple Parallel Algorithm for the Maximal Independent Set Problem.
SIAMJournal on Computing , 15(4):1036–1053, November 1986. doi:10.1137/0215074 . Michael Luby and Noam Nisan. A parallel approximation algorithm for positive linearprogramming. In
Proceedings of the 25th Annual Smposium on Theory of Computing , pages448–457, San Diego, CA, USA, May 1993. ACM Press. doi:10.1145/167088.167211 . Andrew McGregor. Graph stream algorithms: A survey.
ACM SIGMOD Record , 43(1):9–20,May 2014. doi:10.1145/2627692.2627694 . J. Ian Munro and Venkatesh Raman. Selection from read-only memory and sorting withminimum data movement.
Theoretical Computer Science , 165(2):311–323, October 1996. doi:10.1016/0304-3975(95)00225-1 . J.I. Munro and M.S. Paterson. Selection and sorting with limited storage.
Theoretical ComputerScience , 12(3):315–323, November 1980. doi:10.1016/0304-3975(80)90061-4 . Rasmus Pagh and Jakob Pagter. Optimal time-space trade-offs for non-comparison-basedsorting. In
Proceedings of the 13th Annual Symposium on Discrete Algorithms , pages 9–18,Philadelphia, PA, USA, January 2002. SIAM. doi:10.5555/545381.545383 . . Biswas, V. Raman and S. Saurabh 19 J. Pagter and T. Rauhe. Optimal time-space trade-offs for sorting. In
Proceedings of the 39thAnnual Symposium on Foundations of Computer Science , pages 264–268, Palo Alto, CA, USA,November 1998. IEEE Comput. Soc. doi:10.1109/SFCS.1998.743455 . Geevarghese Philip, Venkatesh Raman, and Somnath Sikdar. Polynomial kernels for dominatingset in graphs of bounded degeneracy and beyond.
ACM Transactions on Algorithms , 9(1):1–23,December 2012. doi:10.1145/2390176.2390187 . Valentin Polishchuk and Jukka Suomela. A simple local 3-approximation algorithm for vertexcover.
Information Processing Letters , 109(12):642–645, May 2009. doi:10.1016/j.ipl.2009.02.017 . Venkatesh Raman and Sarnath Ramnath. Improved upper bounds for time-space tradeoffs forselection with limited storage. In
Algorithm Theory , volume 1432, pages 131–142, Stockholm,Sweden, July 1998. Springer-Verlag. doi:10.1007/BFb0054361 . Venkatesh Raman and Saket Saurabh. Short Cycles Make W-hard Problems Hard: FPTAlgorithms for W-hard Problems in Graphs with no Short Cycles.
Algorithmica , 52(2):203–225,October 2008. doi:10.1007/s00453-007-9148-9 . John H. Reif. Symmetric Complementation.
Journal of the ACM , 31(2):401–421, March 1984. doi:10.1145/62.322436 . Omer Reingold. Undirected connectivity in log-space.
Journal of the ACM , 55(4):1–24,September 2008. doi:10.1145/1391289.1391291 . Walter J. Savitch. Relationships between nondeterministic and deterministic tape com-plexities.
Journal of Computer and System Sciences , 4(2):177–192, April 1970. doi:10.1016/S0022-0000(70)80006-X . Maria Serna. Approximating linear programming is log-space complete for P.
InformationProcessing Letters , 37(4):233–236, February 1991. doi:10.1016/0020-0190(91)90194-M . Till Tantau. Logspace Optimization Problems and Their Approximability Properties.
Theoryof Computing Systems , 41(2):327–350, August 2007. doi:10.1007/s00224-007-2011-1 . Luca Trevisan. Parallel Approximation Algorithms by Positive Linear Programming.
Algorithmica , 21(1):72–88, May 1998. doi:10.1007/PL00009209 . Luca Trevisan and Fatos Xhafa. The Parallel Complexity of Positive Linear Programming.
Par-allel Processing Letters , 08(04):527–533, December 1998. doi:10.1142/S0129626498000511 . Heribert Vollmer.
Introduction to Circuit Complexity . Springer-Verlag, Berlin, Germany, 1999. Tomoyuki Yamakami. Uniform-Circuit and Logarithmic-Space Approximations of RefinedCombinatorial Optimization Problems. In
Combinatorial Optimization and Applications ,volume 8287, pages 318–329, Chengdu, China, December 2013. Springer-Verlag. doi:10.1007/978-3-319-03780-6_28doi:10.1007/978-3-319-03780-6_28