Approximation in (Poly-) Logarithmic Space

08/10/2020
by   Arindam Biswas, et al.
0

We develop new approximation algorithms for classical graph and set problems in the RAM model under space constraints. As one of our main results, we devise an algorithm for d-Hitting Set that runs in time n^O(d^2 + (d / ϵ)), uses O(d^2 + (d / ϵ) log n) bits of space, and achieves an approximation ratio of O((d / ϵ) n^ϵ) for any positive ϵ≤1 and any constant d ∈N. In particular, this yields a factor-O(d log n) approximation algorithm which uses O(log^2 n) bits of space. As a corollary, we obtain similar bounds on space and approximation ratio for Vertex Cover and several graph deletion problems. For graphs with maximum degree Δ, one can do better. We give a factor-2 approximation algorithm for Vertex Cover which runs in time n^O(Δ) and uses O(Δlog n) bits of space. For Independent Set on graphs with average degree d, we give a factor-(2d) approximation algorithm which runs in polynomial time and uses O(log n) bits of space. We also devise a factor-O(d^2) approximation algorithm for Dominating Set on d-degenerate graphs which runs in time n^O(log n) and uses O(log^2 n) bits of space. For d-regular graphs, we observe that a known randomized algorithm which achieves an approximation ratio of O(log d) can be derandomized and implemented to 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 algorithms and randomized algorithms.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

02/04/2022

Lossy Planarization: A Constant-Factor Approximate Kernelization for Planar Vertex Deletion

In the F-minor-free deletion problem we want to find a minimum vertex se...
07/22/2020

FPT-space Graph Kernelizations

Let n be the size of a parametrized problem and k the parameter. We pres...
09/24/2013

Partition-Merge: Distributed Inference and Modularity Optimization

This paper presents a novel meta algorithm, Partition-Merge (PM), which ...
02/14/2022

A Subpolynomial Approximation Algorithm for Graph Crossing Number in Low-Degree Graphs

We consider the classical Minimum Crossing Number problem: given an n-ve...
12/17/2019

Approximating MIS over equilateral B_1-VPG graphs

We present an approximation algorithm for the maximum independent set (M...
11/11/2021

Approximating Sparsest Cut in Low-Treewidth Graphs via Combinatorial Diameter

The fundamental sparsest cut problem takes as input a graph G together w...
07/04/2021

Sublinear-Space Approximation Algorithms for Max r-SAT

In the Max r-SAT problem, the input is a CNF formula with n variables wh...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction and Motivation

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 in general and bits of space on certain special input types.

In the absence of space constraints, the greedy heuristic is a good starting point for many approximation algorithms. For

Set Cover, it even yields optimal (under certain complexity-theoretic assumptions) approximation ratios [AMS2006TALG, DS2014STOC]. However, the heuristic inherently changes the input in some way. In a space-constrained setting however, this is asking 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 algorithms. While it yields competitive approximations in polynomial time when space is not constrained, it is known that under logarithmic-space reductions, it is P-complete to approximate the Linear Programming problem to any constant factor [Ser1991IPL]. Such a result can be shown even for positive linear programming [TX1998ParallelProcessLett].

Machine Model

We use the standard RAM model with an additional polylogarithmic space constraint. For inputs bits in length, memory is organized as words of length , which allows the entire input to be addressed using a single word of memory. Integer arithmetic operations on pairs of words and single-word memory access operations take constant time. The input (a graph or family of sets) is provided to the algorithm using some canonical encoding, which can be read but not modified, i.e. the algorithm has read-only access to the input.

The algorithm uses some auxiliary memory, to which it has read-write access, and in the setting of this paper, the amount of such memory available is bounded by a polynomial in . Output is written to a stream: once something is output, the algorithm cannot read it back at a later point as it executes. We count the amount of auxiliary memory used in units of bit, and the objective is to use as little auxiliary memory as possible.

Our Results

and Vertex Deletion Problems

An instance of the problem consists of a universe and a family of size- subsets of the universe, and the objective is to find a subset of the universe that has a non-empty intersection with each set in the family.

  • We develop a factor- approximation algorithm for which runs in time and uses bits of space (Section 3), where is an arbitrary positive number and is a fixed positive integer. In particular, this yields a factor- approximation algorithm for the problem which uses bits of space. 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- (for arbitrary positive ) approximation algorithm for Vertex Cover that runs in time and uses bits of space.

  • We give a simple factor- approximation algorithm for Vertex Cover on graphs with maximum degree which runs in time and uses bits of space (Section 3.1).

Dominating Set

In the Dominating Set problem, the objective is to find a vertex set of minimum size in a graph such that all other vertices are adjacent to some vertex in the set.

  • We give a factor- approximation algorithm for graphs excluding (a cycle on vertices) as a subgraph, which runs in polynomial time and uses bits of space (Section 4.1).

  • Graphs of bounded degeneracy form a large class which includes planar graphs, graphs of bounded genus, graphs excluding a fixed graph as a (topological) minor and graphs of bounded expansion. For graphs with degeneracy , we give a factor- approximation algorithm which uses bits of space. (Section 4.2).

  • Additionally, for graphs in which each vertex has degree , i.e. -regular graphs, we exhibit a factor- approximation algorithm for Dominating Set (Section 4.3) which is an adaptation of known results to the constrained-space setting.

Independent Set

An instance of the Independent Set problem consists of a graph, and the objective is to find an independent set of maximum size i.e. a set of vertices with no edges between them. We show how a known factor- approximation algorithm for Independent Set on graphs with average degree can be implemented to run in polynomial time and use bits of space (Section 5).

Related Work

Small-space models such as the streaming model and the in-place model have been the subject of much research over the last two decades (see [McG2014SIGMODRec, CMR2014SODA, CMRS2018ESA] and references therein). In the streaming model, in addition to the space constraint, the algorithm is also required to read the input in a specific (possibly adversarial) sequence in one or more passes. The in-place model, 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, the read-only model has been studied from the perspective of time–space tradeoff lower bounds, particularly for problems like Sorting [BC1982SICOMP, BFK+1981JCSS, Bea1991SICOMP, PR1998FOCS, PP2002SODA] and Selection [MP1980TCS, Fre1987JCSS, MR1996TCS, RR1998SWAT].

The earliest graph problems studied in this model were the undirected and directed graph reachability problems (resp. USTCON and STCON) in connection with the complexity classes L and NL. Savitch [Sav1970JCSS] showed that on input graphs with vetices, STCON (and therefore also USTCON) can be solved in bits of space. This bound was gradually whittled down over more than two decades, a process culminating in the result of Reingold [Rei2008JACM] which shows that USTCON can be solved using bits of space.

Reif [Rei1984JACM] showed that the problems of recognizing bipartite, chordal, interval and split graphs are reducible to USTCON. Later on, Allender and Mahajan [AM2004InfComput] showed that planarity testing also reduces to USTCON. Thus, Reingold’s result put all these problems in L. More recently, Elberfeld and Kawarabayashi [EK2014STOC] showed that the problems of recognizing and canonizing bounded-genus graphs were in L. The model was also studied by Yamakami [Yam2013COCOA] in relation to the complexity of search problems solvable in polynomial time, and by Tantau [Tan2007TheoryComputSyst], who studied the approximation properties of search problems that can be solved in nondeterministic logarithmic space.

The other direction in which small-space problems and even the approximation problems we study have been investigated previously is in the context of fast parallel algorithms. By a known reduction, algorithms for these problems have sequential implementations that use polylogarithmic space. The PRAM algorithm of Luby [Lub1986SICOMP] for finding maximal independent sets in a graph can be used to -approximate Vertex Cover (recall that a better than -approximate algorithm is known to be unlikely [KR2008JCSS]). Implemented in the sequential RAM model, it uses bits of space. There have been attempts to generalize Luby’s algorithm to hypergraphs, and to the best of our knowledge, an efficient deterministic parallel algorithm (an NC algorithm) to find maximal independent sets in hypergraphs is not known to exist (see [BGHS2017TOPC] and references therein). Our scheme for trades approximation factor against space used to obtain a family of algorithms that use bits of space to obtain -approximate solutions for any positive . As a corollary, we obtain an -approximation algorithm that uses bits of space. On graphs with maximum degree , our approximation algorithm for Vertex Cover uses bits of space to obtain -approximate solutions.

Berger et al. [BRS1994JCSS] gave a PRAM algorithm for Set Cover which can be implemented in the sequential RAM model to -approximate Dominating Set in bits of space. See also [Tre1998Algorithmica, LN1993STOC], which give parallel approximation algorithms for Linear Programming, and see [LO2017SPAA], which gives tight approximation ratios for CSP’s using semi-definite programming in the PRAM model. Our algorithms for Dominating Set are simpler and more direct, and work for a large class of graphs while using bits of space.

Our Techniques

As noted earlier, the greedy heuristic causes changes to the input, which our model does not permit. To get around this, we use a staggered greedy approach in which the solution is constructed in a sequence of greedy steps to approximate Vertex Cover on graphs of bounded degree (Section 3.1). By combining this with data reduction rules from kernelization algorithms, we also obtain approximations for Vertex Cover and more generally (Section 3), and restricted versions of Dominating Set (Sections 4.1 and 4.2). In Sections 4 and 5, we use -universal hash families constructible in logarithmic 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.

2 Preliminaries

Notation

denotes the set of natural numbers and denotes the set of positive integers . For , denotes the set . Let be a graph. Its vertex set is denoted by , and its edge set by . The degree of a vertex is denoted by , and for a set or a subraph of , denotes the degree of in and denotes the degree of in .

Known Results

To start with, consider the next result, which arises from a logarithmic-space implementation of the Buss kernelization rule [BG1993SICOMP] for Vertex Cover combined with the observation that the kernel produced is itself a vertex cover.

[Cai et al. [CCDF1997AnnPureApplLogic], Theorem 2.3] There is an algorithm which takes as input a graph and , and either determines that has no vertex cover of size at most or produces a vertex cover of size at most . The algorithm runs in time and uses bits of space.

The Vertex Cover can be generalized to the problem (, a constant), an instance of which comprises a family of size- subsets of a ground set and . The objective is to determine whether there is a hitting set of size at most , i.e. a subset of the ground set which has a nonempty intersection with each set in the family. The next proposition shows that a similar result as above also holds for this generalization. [Fafianie and Kratsch [FK2015MFCS], Theorem 1] There is an algorithm which takes as input a family of -subsets (, a constant) of a ground set and , and either determines that has no hitting set of size at most or produces an equivalent subfamily of the original family which has size . The algorithm runs in time and uses bits of space.

2.1 Presenting modified graphs using oracles

Our algorithms repeatedly “delete” vertices or sets of vertices, but as they only have read-only access to the graph (or family of sets), we require a way to implement these deletions using a small amount of auxiliary space. Towards that, we prove the following theorem.

Let be a graph with vertices, and let () be obtained from by deleting a set consisting of all vertices which satisfy a property that can be checked (given access to ) using bits of space.

Given read-only access to , one can, for each , enumerate and answer membership queries for , and in time using bits of space.

Proof.

For each let be the algorithmic check which, given (oracle) access to , determines whether satisfies the condition for inclusion in . Note that this condition may be something that depends on the graph , i.e.  must be accessible to .

To provide oracle access to and , it suffices to compute, for and , the predicates and . A vertex is in if and only if it is in and it is not in . Similarly, an edge is in if and only if it is in and neither of its endpoints are in . Thus, we have the following relations.

(1)
(2)

To compute each of these predicates for , we require oracle access to , which in turn involves computing the predicates and . Suppose the number of operations needed to compute is , where is a polynomial (it uses bits of space, so it is polynomial-time). Let (resp. ) be the amount of space used to compute the predicate (resp. ), and let (resp. ) be the time needed to compute the predicate (resp. ). From Relations 1 and 2 and the fact that accesses at most times, we see that these quantities satisfy the following relations.

(3)
(4)

It is easy to see that these recurrences solve to and , so both predicates can be computed in time using bits of space.

With oracle access to , the predicate can be computed simply as , from which enumerating (resp. and ) is straightforward: enumerate (resp. and ) and suppress vertices (resp. edges and vertices ) which fail the predicate (resp. and ). As the most space-hungry operations are the membership queries, the enumeration can also be performed using bits of space. The enumeration needs time for each element of and , and since , the total time needed is also . ∎

2.2 Universal Hash Families

Algorithms appearing later on use the trick of randomized sampling to obtain a certain structure with good probability and then derandomize this procedure by using a family of

-universal functions. A -universal hash family is a family of functions from to , for integers with such that for any pair and of elements from , the number of functions from that map and to the same element in is at most . The following proposition, which is a combination of a result of Carter and Wegman [CW1979JCSS] showing the existence of such families, and the observation that these families can be computed in logarithmic space [Vol1999book].

[Carter and Wegman [CW1979JCSS], Proposition 7] Let with . One can enumerate a -universal hash family for in polynomial time using bits of space.

3 Hitting Sets and -Deletion Problems

The problem is a generalization of Vertex Cover in which an instance consists of a family of -subsets of a ground set , and the objective is to find a subset of of minimum size which intersects all sets in .

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 so that the resulting graph satisfies a certain property. The following result is a corollary to Proposition 2.

Let be a family of -subsets of a ground set with elements. One can compute an -approximate minimum hitting set for in time using bits of space.

Proof.

Consider the following algorithm. Starting at , run the algorithm of Proposition 2 and repeatedly increment the value of until or the algorithm returns a solution of size (i.e. it does not return a NO answer) for the first time. If is incremented until , then simply return the entire universe as the solution. Clearly, the approximation ratio is , as (and so the size of the solution returned is , where is the size of the minimum hitting set).

If , then the size of the solution produced is , and we know that , since the algorithm had returned NO answers until this point. So the size of the solution produced is . Thus, we have an -approximation. The bounds on running time and space used follow from the fact that the algorithm of Proposition 2 runs in time and uses bits of space. ∎

The next result is one of our main results en route to developing a space-efficient approximation algorithm for .

Let be a positive number. There is an algorithm which takes as input a family of -subsets of a ground set of elements and , and either determines has no hitting set of size at most or produces a hitting set of size . The algorithm runs in time and uses bits of space.

Proof.

Let . The algorithm performs rounds of computation, each using bits of space to determine a set of elements (accessible by oracle) to be removed in the next round, or determine that has no hitting set of size at most .

  1. Use the algorithm of Proposition 2 to obtain a subfamily over the ground set such that

    • , and

    • there exists a hitting set of size at most in if and only if there exists a hitting set and is a hitting set for .

  2. Set and . For , perform the following steps.

    • Determine , the set of all elements in which appear in at least sets in .

    • Let and . If there are more than sets in , then return NO.

  3. Determine , the set of all elements in which are in some set in . Output .

We now prove the correctness of the algorithm. In Step 1, the algorithm obtains the ground set and the family, using the algorithm of Proposition 2. Let such that the algorithm answers NO in Step 2 for , and otherwise let if it never returns a NO answer in Step 2. For all , has at most sets. Consider the case when the algorithm does not return a NO answer. Observe that the claim holds for the base case : has sets, and since the algorithm does not return a NO answer, we have . For induction, observe that whenever , the algorithm ensures that ; otherwise, it returns a NO answer.

Suppose the algorithm returns a NO answer at some value of in Step 2, then there are more than sets in , which have survived the repeated removal of sets from up to this point, and they cannot be hit by any of the elements in , since each element can hit at most sets in . Thus, the algorithm correctly infers that the input does not have a hitting set of size at most .

Once the algorithm has reached Step 3, the number of sets in the residual family, is at most . The set of elements in that appear in some set in is trivially also a hitting set. Observe that the sets of elements removed in earlier stages, i.e. together hit all sets in not appearing in . Thus, the set output by the algorithm is a hitting set for .

The set output by the algorithm has at most elements. For each , the algorithm ensures that (otherwise, it returns a NO answer). Thus, the number of elements which appear in at least sets is at most , i.e. .

In Step 3, the algorithm ensures that . Each set in edges and each of these edges can span at most elements. Thus, the number of elements in which appear in some set in , i.e. . Therefore, the total number of elements output by the algorithm in all three phases is .

The algorithm runs in time and uses bits of space. Observe that in Step 1, the family is obtained using the algorithm of Proposition 2, which runs in time and uses bits of space (for any constant ). The output of the algorithm can now be used as an oracle for .

In Step 2, each successive family () is obtained from by deleting sets containing elements which appear in at least sets (this test can be performed using ) bits of space. Thus, given oracle access to , an oracle for can be provided which runs in polynomial time and uses bits of space.

Step 3 involves writing out all elements in that appear in some set in , which can also be done in bits of space given oracle access to . Since the number of oracles created in Step 2 is , the various oracles together run in time and use bits of space (Theorem 2.1). Combined with the time and bits of space used by the oracle of Step 1, this gives bounds of on the running time and bits on the total space used by the algorithm. ∎

The next theorem follows from the above lemma. Let be a positive number. For instances of d-Hitting Set with , one can compute an -approximate minimum hitting set in time using bits of space.

Proof.

Apply the algorithm of Lemma 3 starting from successively incrementing by until the algorithm returns a family of size or . When return the entire universe as the solution. As, in this case, , the size of the solution produced, which is , and so we have a factor- approximation algorithm.

When the algorithm returns a family of size for some , note that (as the algorithm returned NO so far), and so the solution produced is of size , which is resulting in a factor- approximation algorithm. As we merely reuse the procedure of Lemma  3, the running time is and the amount of space used is bits. ∎

The above theorem allows us to devise space-efficient approximation algorithms for a number of graph deletion problems. Let be a hereditary class of graphs, i.e. a class closed under taking induced subgraphs. Let be a set of forbidden graphs for such that a graph is in if and only no induced subgraph of is isomorphic to a graph in . Consider the problem (described below), defined for classes with finite sets of forbidden graphs.

Instance

, 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 can be formulated as a certain hitting set problem and the procedure of Theorem 3. Let be a positive number. On graphs with vertices, one can compute -approximate solutions for in time using bits of space.

Proof.

Let be a class of graphs characterized by a finite set of forbidden induced subgraphs. Consider the problem of finding, given a graph, a deletion set of vertices of minimum size whose removal from the graph produces a graph in .

Given a graph on vertices, it is possible using bits of space, to produce an -approximate minimum deletion set for . Simply construct the family . This family of subsets is constructed “on the fly” in a systematic way (as and when the hitting set algorithm needs it) by running over all subsets of of size at most where is the maximum size of the vertex set in a graph in . It can be seen that this can be constructed using bits of space for constant and that an approximate minimum hitting set for is also an -approximate solution for the deletion problem.

Thus, a variant of the procedure described earlier can be used to produce -approximate solutions for -vertex instances of this problem using using bits of space. ∎

The following list defines problems for which we obtain polylogarithmic-space approximation algorithms using the preceding lemma.

Triangle-Free Deletion

Instance: , where is a graph and
Question: Is there a set with such that has no triangles?

Tournament FVS

Instance: , where is a a tournament and
Question: Is there a set with such that is acyclic?

Cluster Deletion

Instance: , where is a graph and
Question: Is there a set with such that is a disjoint union of cliques, i.e. a cluster graph?

Split Deletion

Instance: , where is a graph and
Question: Is there a set with such that can be partitioned into a clique and an independent set, i.e. such that is a split graph?

Threshold Deletion

Instance: , where is a graph and
Question: Is there a set with such that is threshold graph? A threshold graph is one which can be constructed from a single vertex by a sequence of operations that either add an isolated vertex, or add a vertex which dominates all the other vertices.

Cograph Deletion

Instance: , where is a graph and
Question: Is there a set with such that contains no induced paths of length , i.e. it is a cograph?

For all the problems appearing above, the target graph classes are known to be characterized by a finite set of forbidden induced subgraphs (see e.g. Cygan et al. [CFK+2015book]) and so the problems can be formulated as . By setting to a small positive constant or , we obtain the following corollary to Lemma 3. On graphs with vertices, one can compute

  • -approximate solutions in time using bits of space for any positive constant , and

  • -approximate solutions in time using bits of space

for the problems Vertex Cover, Triangle-Free Deletion, Threshold Deletion, Cluster Deletion, Split Deletion, Cograph Deletion and Tournament FVS.

3.1 Vertex Cover on Graphs of Bounded Degree

We begin this section with the observation that in a directed graph with maximum outdegree , every connected component contains (as an induced subgraph or otherwise) at most one (undirected) cycle. For such a directed graph , consider the graph obtained by ignoring arc directions. Because every connected component in also has at most one cycle, one can find a minimum vertex cover for in polynomial time and logarithmic space using a modified post-order traversal procedure on the connected components. The following lemma formalizes this discussion.

Let be a directed graph on vertices with maximum outdegree and let be the undirected graph obtained by ignoring the arc directions in . One can find a minimum vertex cover for in polynomial time using bits of space.

To prove the above lemma, we use the following algorithm, which computes minimum vertex covers in trees.

Input: , a tree
Output: a mininmum vertex cover for
1 let be an arbitrary vertex of ;
2 foreach  do
3       if IsInVC() then
4             output ;
5            
6      
7 Procedure IsInVC() // a tree rooted at , a vertex in
8       generate a post-order traversal for with as the root;
9       seek to the first leaf in the subtree of rooted at ;
10       ;
11       ;
12       foreach  do
13             if  is a leaf then
14                   ;
15                   ;
16                  
17            else // is not a leaf; is the parent of
18                   ;
19                   if not  then
20                         if  then
21                               return YES;
22                              
                        ;
                          // include
23                        
24                  else // last-visited vertex was included
25                         if  then
26                               return NO;
27                              
                        ;
                          // do not include
                         seek to ’s parent;
                          // vertices in subtrees of ’s unvisited siblings can be ignored
28                        
29                  
30            
31      
Algorithm 1 TreeVtxCover: compute a minimum vertex cover

The algorithm operates by rooting at an arbitrary vertex and determines a vertex cover given by repeatedly applying the following rule.

Rule VCT Include the the parents of leaves on the bottom level of in , then delete from the included vertices, their children, and all edges incident with them.

The fact that is a minimum vertex cover follows directly from the observation that to cover the edges of incident with the leaves at the bottom level, picking the parents of those leaves is at least as good as any other choice of covering vertices.

Observe that at any intermediate stage in the repeated application of Rule VCT, a vertex is a leaf on the bottom level of if a previous application of the rule deleted all of its children, i.e. all of them were included in . Thus, any vertex , is in if and only if does not contain all of its children.

Instead of repeatedly deleting vertices from , Procedure IsInVC in the algorithm determines membership in by performing what is essentially a post-order traversal of . In the post order traversal, to determine if a vertex is in , the only information necessary is whether at least one of ’s children is not in , which the procedure stores in the variable . If such a child vertex is encountered, the procedure determines that is in , and skips the rest of the subtree rooted at .

The post-order traversal used by the procedure can be generated from a BFS traversal of , which can be computed using bits of space [CM1987JAlgorithms]. The constantly-many variables appearing in the algorithm also use bits of space total. Therefore, the overall space usage of the algorithm is bits. The following lemma formalizes the preceding discussion.

For an input tree on vertices, the algorithm TreeVtxCover computes a minimum vertex cover using bits of space.

By layering multiple such steps, one can find a vertex cover in a bounded degree graph which is a -approximation for the minimum vertex cover. Our approach is inspired by a local distributed algorithm of Polishchuk and Suomela [PS2009IPL] which computes a factor- approximations.

There is an algorithm which takes as input a graph on vertices in which every vertex has degree at most , and computes a -approximate minimum vertex cover for . The algorithm runs in time and uses bits of space.

Proof.

Set and . The algorithm works in stages as follows. In Stage , it enumerates the subgraph of in which each vertex of of only retains the edge to its th neighbour (if it exists) in . Observe that directing every such edge from to yields a directed graph with maximum outdegree .

Applying the procedure of Lemma 3.1 with and , the algorithm now computes a minimum vertex cover for in polynomial time using bits of space. It then produces the graph by removing the vertex set from and outputs the vertices in . At the end of Stage , the algorithm terminates.

We now prove the bounds in the claim. Observe that the vertex set of () is precisely . In Stage , the algorithm only considers the vertices in , so the vertex cover generated by it has no neighbours in vertex covers generated in earlier stages, i.e.  for .

For each , consider a maximal matching in . From the way the various sets are generated, it is easy to see that forms a vertex cover for and additionally, is a maximal matching in . Observe that the each set also covers the matching in . Since is a minimum vertex cover for , and the endpoints of edges in form a vertex cover for , we have .

As is a maximal matching in , the endpoints of edges in form a vertex cover for , and we have , where is the vertex cover number of . Thus, the set output by the algorithm is a -approximate vertex cover.

Now observe that for all , and satisfy the hypothesis of Theorem 2.1. Thus, one can compute each of the sets in time using bits of space. Since the maximum value takes on is , the algorithm runs in time and uses a total of bits of space. ∎

4 Dominating Sets

In this section, we describe approximation algorithms for Dominating Set restricted to certain graph classes. A problem instance consists of a graph and , and the objective is to determine if there is a dominating set of size at most , i.e. a set of at most vertices such that .

The first result of this section concerns graphs excluding (a cycle on vertices) as a subgraph. On such graphs, one can compute -approximations using bits of space using a known kernelization algorithm [RS2008Algorithmica].

4.1 -Free Graphs

Any vertex of degree at least must be in any dominating set of size at most , as any other vertex (including a neighbour of ) can dominate at most vertices in the neighbourhood (as there will be a otherwise). Using this, we establish the following result.

There is an algorithm which takes as input a -free graph on vertices and , and either determines that has no dominating set of size at most , or outputs a dominating set of size . The algorithm runs in polynomial time and uses bits of space.

Proof.

The crux of the algorithm is the fact that any vertex of degree at least must be in any dominating set of size at most , as any other vertex (including a neighbour of ) can dominate at most vertices in the neighbourhood (as there will be a otherwise). The algorithm proceeds as follows.

  1. Let be the set of vertices with degree more than . If is more than , return NO.

  2. Note that all vertices in have already been dominated. If return NO, as each vertex in can dominate at most vertices including itself.

  3. If the algorithm has not returned NO, output

Correctness is immediate from the the description of the algorithm. When it outputs vertices, it outputs , which has at most vertices from Step 1, and the number of remaining vertices in Step 2 is , so it outputs vertices overall. To see that the space used is bits, observe that membership in each of the sets output is determined by predicates that test degrees of vertices individually, and these predicates can by computed in logarithmic space. Thus, by Theorem 2.1, the algorithm uses a total of bits of space. ∎

The proof of the following corollary uses arguments very similar to those in the proof of Theorem 3, so we omit it. There is an algorithm which takes as input a -free graph on vertices, and computes an -approximate minimum dominating set for . The algorithm runs in polynomial time and uses bits of space.

4.2 Graphs of Bounded Degeneracy

A graph is called -degenerate if there is a vertex of degree at most in every subgraph of . A graph with maximum degree is clearly -degenerate. Planar graphs are -degenerate. Let be a -degenerate graph on vertices. As every subgraph of has a vertex with degree at most , the number of edges in is at most . It follows that

Observation 1.

In any subgraph of vertices of a degenerate graph, at least vertices are of degree at most .

There is a generalization of polynomial kernel of Dominating Set for -free graphs to -free graphs for any fixed  [PRS2012TALG] (recall that is the complete bipartite graph with vertices in one part and vertices in the other). The class of -free graphs includes -free graphs, and -degenerate graphs (where ). This kernelization, however, does not appear suited to approximation in logarithmic (or even polylogarithmic) space. To design a space-efficient approximation algorithm for -degenerate graphs, we resort instead to the -approximation algorithm of Jones et al. [JLR+2017SIDMA]. To achieve an bound on the space used, several adaptations are necessary.

The algorithm starts by picking the neighbours of all vertices of degree at most , and works by repeatedly finding such vertices in smaller and smaller sugraphs of and picking all their neighbours in the solution. As the vertex or one of its neighbours must be in any dominating set, this will result in an approximation if we manage to find a vertex that dominates (at least one and) at most of the undominated vertices. This may not happen in the intermediate steps as more and more vertices are dominated by those vertices picked earlier. So we do some careful partitioning of the vertices and find low degree vertices in appropriate subgraphs.

Let be the set of vertices picked at any point, be the set of vertices (other than those in ) dominated by , and be the set of vertices in (see Figure 1). The goal is to dominate vertices in , and we try to do so by finding (the neighbours of) low degree vertices from . So we start finding low degree (at most ) vertices in to pick their neighbours. First we look for such vertices in , and so we further partition into , those vertices of with at least neighbours in and .

Figure 1: Partitioning of the vertices in the algorithm for Dominating Set on -degenerate graphs.

First, we remove (for later consideration) vertices of that have no neighbours in , let they be and focus on the induced subgraph where . Here, we are bound to find low degree vertices from (as vertices in have high degree) as long as is non-empty, and so we repeat the above procedure of picking the neighbours of all low degree vertices from . Finally, when is empty, if is non-empty, we simply pick all vertices of into the solution and return it. What follows is a pseudocode description of the algorithm.

Input: , a -degenerate graph
Output: , an -approximate minimum dominating set for
1 ;
2 ;
3 while  do // there are vertices in to be dominated
4       ;
5       ;
6       // is the partial solution;
7       ;
8       ;
9       ;
10       ;
11       ;
12       ;
13       ;
14      
return
Algorithm 2 DgnDomSet: find an approximate minimum dominating set

If we treat a round as the step where we find all vertices in with at most neighbours in , then as at least a fraction of the vertices of are dominated in each round due to Observation  1, the number of rounds is . Each round just requires identifying vertices based on their degrees in the resulting subgraph, the -th round can be implemented in bits using Theorem 2.1 resulting in an bits implementation.

The approximation ratio of can be proved formally using a charging argument (see Jones et al. [JLR+2017SIDMA], Theorem 4.9). We give an informal explanation here. First we argue the approximation ratio of for the base case when is empty. Isolated vertices in are isolated vertices in and hence they need to be picked in the solution. The number of non-isolated vertices in is at most as their neighbours are only in (otherwise, by definition, those vertices will be in ). As vertices in have degree at most , and as at least one vertex of must be picked to dominate a vertex in , we have the approximation ratio of for those vertices.

In the intermediate step, if we did not ignore vertices in to dominate a vertex in , a - approximation is clear. For, a vertex or one of its at most neighbours must be picked in the dominating set. However, a vertex in maybe dominated by a vertex in , but by ignoring , we maybe picking vertices to dominate it. As a vertex in can dominate at most (such) vertices of , we get an approximation ratio of .

The next theorem formalizes the above discussion. There is an algorithm which takes as input a -degenerate graph on vertices and computes an -approximate minimum dominating for . The algorithm uses bits of space and runs in time .

4.3 Regular Graphs

On regular graphs, we can achieve a better approximation ratio in logarithmic space by derandomizing a result of Alon and Spencer [AS2008book] on the size of a dominating set on graphs with minimum degree .

[Alon and Spencer [AS2008book], Theorem 1.2.2] Any graph on vertices with minimum degree has a dominating set of size at most .

On a -regular graph, because the size of any dominating set is at least , the approximation ratio achieved is .

Now we outline the proof of the above proposition to show how it can be derandomized. Consider a -regular graph on vertices. Picking each vertex of with probability yields a set with expected size . By adding in the vertices not dominated by , we obtain a dominating set . The expected size of this set is , and it can be shown that this quantity is .

Note that the expectation bounds only need the sampling of the vertices to be pairwise independent. Consider a -universal hash family for , and define