A Deterministic Distributed 2-Approximation for Weighted Vertex Cover in O( n/ ^2) Rounds

by   Ran Ben Basat, et al.

We present a deterministic distributed 2-approximation algorithm for the Minimum Weight Vertex Cover problem in the CONGEST model whose round complexity is O( n Δ / ^2 Δ). This improves over the currently best known deterministic 2-approximation implied by [KVY94]. Our solution generalizes the (2+ϵ)-approximation algorithm of [BCS17], improving the dependency on ϵ^-1 from linear to logarithmic. In addition, for every ϵ=(Δ)^-c, where c≥ 1 is a constant, our algorithm computes a (2+ϵ)-approximation in O(Δ / Δ) rounds (which is asymptotically optimal).


page 1

page 2

page 3

page 4


Optimal Distributed Weighted Set Cover Approximation

We present a time-optimal deterministic distributed algorithm for approx...

Deterministic, Near-Linear ε-Approximation Algorithm for Geometric Bipartite Matching

Given point sets A and B in ℝ^d where A and B have equal size n for some...

Distributed Spanner Approximation

We address the fundamental network design problem of constructing approx...

Local approximation of the Maximum Cut in regular graphs

This paper is devoted to the distributed complexity of finding an approx...

Fast and Simple Deterministic Algorithms for Highly-Dynamic Networks

This paper provides a surprisingly simple method for obtaining fast (con...

Optimal Distributed Covering Algorithms

We present a time-optimal deterministic distributed algorithm for approx...

Locally Private k-Means in One Round

We provide an approximation algorithm for k-means clustering in the one-...

1 Introduction

The Minimum Weight Vertex Cover Problem (MWVC) is defined as follows. The input is a graph with nonnegative vertex weights . A subset is a vertex cover if, for every edge , the intersection is not empty. The weight of a subset of vertices is . The goal is to find a minimum weight vertex cover. This problem is one of the classical NP-hard problems [Kar72].

In this paper we deal with distributed deterministic approximation algorithms for MWVC. We focus on the CONGEST model of distributed computation in which the communication network is the graph itself.111In the CONGEST model vertices have distinct IDs (that are polynomial in ), however, as in [BCS17], our algorithm works also in the case of anonymous vertices. Computation proceeds in synchronous rounds. Each round consists of three parts: each vertex receives messages from its neighbors, performs a local computation, and sends messages to its neighbors. The sent messages arrive at their destination in the beginning of the next round. In the CONGEST model, message lengths are bounded by . In order to send vertex weights, we assume that all the vertex weights are positive integers bounded by polynomial in . See  [BCS17, ÅS10] for detailed overviews of distributed algorithms for MWVC.

Let denote the maximum vertex degree in . Two of the most relevant results in this setting to our paper are the lower bound of [KMW16] and the upper bound of [BCS17]. The lower bound of Kuhn et al. [KMW16] states that every constant approximation algorithm for MWVC requires at least rounds of communication. The upper bound of Bar-Yehuda et al. [BCS17] presents a deterministic distributed -approximation algorithm (BCS Algorithm) that requires rounds for . For , the running time is , with no dependence on , and is optimal according to [KMW16].

In this paper, we present a generalization of the BCS Algorithm with improved guarantees on the running time for certain ranges of . We focus on decreasing the dependency of the number of rounds on . Since the round complexity of the BCS Algorithm is optimal for constant values of (and even ), we consider values of that depend on .

Our main result222All logarithms are base unless the basis is written explicitly. is a deterministic distributed -approximation algorithm in which the number of rounds is bounded by

This result assumes that all the vertices know

or an estimate that is a polynomial in

. This result leads to the following consequences:

  1. If , for a constant , then the number of rounds asymptotically matches the lower bound, and is thus optimal. In [BCS17] the same asymptotic running time is guaranteed only for .

  2. If , then the dependency of the round complexity on is reduced from linear to logarithmic. In addition, the round complexity is decreased by an additional factor of .

  3. Every -approximation is a -approximation if , where . Since we assume that , where , we obtain a -approximate deterministic distributed algorithm for MWVC with round complexity . This improves over the 2-approximation in rounds implied by [KVY94]333The actual result is stated as a -approximation in rounds, from which we infer a 2-approximation by setting . (which has the lowest round complexity for deterministic -approximation to the best of our knowledge).

Our round complexity increases for the case that the maximum degree is unknown to the vertices of the graphs. We propose two alternatives for the case that is unknown. The first alternative holds for every , and achieves a -approximate solution with a round complexity of . The second alternative holds for , where is a constant. In the second alternative, a -approximation is achieved with an optimal asymptotic round complexity of .

Our algorithm builds on the BCS Algorithm [BCS17]. This algorithm adapts the local ratio framework [BE85] to the distributed setting, with several improvements that provide the desired speedup. The BCS Algorithm can be also interpreted as the following “primal-dual” algorithm. Essentially the algorithm aims to increase the edge variables (i.e., dual) such that the following holds:

  1. The sum of edge variables incident to every node does not exceed its weight (feasibility of edge variables).

  2. The set of vertices whose edge variable sum is at least -fraction of the vertex weight constitute a vertex cover.

The above conditions yield a -approximation for MWVC.

The challenge in the above framework is to maintain feasibility of the edge variables while converging as fast as possible to a vertex cover. To increase the edge variables, vertices send offers to their neighbors. The neighbors respond to these offers in a way that guarantees feasibility of the edge variables. This requires a coordination mechanism in the distributed setting, as a vertex both sends and receives offers simultaneously. To this end, the weight of every vertex is divided into two parts: vault and bank. Offers are allocated from the vault, while responses are allocated from the bank, respectively. Hence the agreed upon increases to the edge variables do not violate the feasibility of the edge variables. The BCS algorithm sets the vault to be an -fraction of the vertex weight (and the bank to be the remainder). This leads to a running time of and if .

Our algorithm introduces three modifications to the BCS Algorithm, which allows us to improve the round complexity. First, we attach levels to the vertices that measure by how much the remaining weight of a vertex has decreased. Second, the size of the vault decreases as the level of the vertex increases. Third, offers are not sent to all the neighbors. Instead, offers are sent only to the neighbors whose level is the smallest level among the remaining neighbors.

Related Work

An excellent overview of the related work is presented in [BCS17, ÅS10] which we summarize hereinafter. Minimum vertex cover is one of Karp’s 21 NP-hard problems [Kar72]. A simple 2-approximation for the unweighted version can be achieved by a reduction from maximal matching (see, e.g., [CLRS09, GJ79]). For the weighted case, [BE81] achieves the first linear-time -approximation algorithm using the primal-dual schema, while [BE85] achieves the same result using the local-ratio technique. Prior to that, the first polynomial-time -approximation algorithm was due to [NJ75] and observed by [Hoc82]. For any constant , if the Unique Games conjecture holds, no polynomial-time algorithm can compute a approximation of the minimum vertex cover [KR08].

Let us now turn our attention to the distributed setting. Let us start from the unweighted case. A -approximation can be found in rounds [HKP01] and in rounds [PR01]. Completely local algorithms with no dependence on are presented in [ÅFP09] which gives an -round -approximation algorithm, and in [PS09] which gives an -round -approximation algorithm. Using the maximal matching algorithm of [BEPS12] gives a -approximation algorithm for vertex cover in rounds. This can be made into a -approximation algorithm within rounds [Pet16].

For the weighted case, [GKP08] presents a randomized -approximation algorithm in rounds (where is a bound on the vertex weights). In [KY11] the first (randomized) -approximation algorithm running in rounds is presented (note that the running time is logarithmic in and independent of the weights). A deterministic -approximation algorithm in rounds is given within [PR01]. In [KVY94], a deterministic -approximation algorithm is given within rounds. As for deterministic algorithms independent of [KMW06] presents a -approximation algorithm in rounds and [ÅFP09] presents a -approximation algorithm in rounds for , while [ÅS10] presents a -approximation algorithm in rounds (where ). Finally in [BCS17] a deterministic -approximation which runs in rounds is given. In [Sol18] a -approximation in rounds for graphs of arboricity bounded by .

As the result of [Sol18] uses the algorithm of [BCS17] as a black box, plugging , our results can also be used. This means all of results stated in this paper also hold for bounded arboricity graphs setting . We list the previous results and the results of this paper in Table 1 (Adapted from [ÅS10]).

deterministic weighted approximation time algorithm
no yes 2 [GKP08]
no yes 2 [KY09]
yes no 3 [PS09]
yes no 2 [HKP01]
yes no 2 [ÅFP09]
yes yes [KVY94]
yes yes [KVY94]
yes yes [Hoc82, KMW06]
yes yes 2 [PR01]
yes yes 2 [ÅS10]
yes yes 2 for [ÅFP09]
yes yes [BCS17]
yes yes [BCS17]
yes yes This work
yes yes This work,
yes yes 2 This work
Table 1: In the table (adapted from [ÅS10]), and

. The running times are stated for the case of unit weight vertices. For randomized algorithms the running times hold in expectation or with high probability.

2 The MWVC local ratio template

In this section we overview [BCS17]’s local ratio paradigm for approximating MWVC. We note that the template does not assume anything about the model of computation and that our algorithms will fit into this framework. This template can also be viewed via the primal-dual schema.

Let denote a graph with a vertex-weight function . An edge-weight function is -valid if for every vertex the incident edges weight sum does not exceed ; that is, is -valid if . (In fact, a -valid function is a feasible solution to the dual edge packing LP.)

Next, for a -valid function , define the vertex-weight function by . Let be the set of vertices for which and differ by at most , for . We refer to vertices in as -tight vertices. The essence of the template consists of two parts: (1) The sum of the weights of the vertices in is at most times the weight of an optimal solution to MWVC. (2) When the algorithm terminates, is a vertex cover.

Theorem 1.

([BCS17]) Fix and let be a -valid function. Let be the sum of weights of vertices in a minimum weight vertex cover of . Then . In particular, if is a vertex cover, then it is a -approximation for MWVC for .

3 A fast distributed implementation

In this section, we present a modification of the distributed algorithm for MWVC of Bar-Yehuda et al. [BCS17]. The pseudo-code for our algorithm is given in Algorithm 1. In this section we assume that the maximal degree is known to all vertices. 444A polynomial upper bound of would yield the same asymptotic bound on the number of rounds. In Section 4 we provide an algorithm with a slightly higher running time in which this assumption is lifted.

For clarity of presentation, we first describe an implementation for the LOCAL model. This algorithm can be easily adapted to the CONGEST model using the techniques of [BCS17].

Overview of Algorithm 1

The algorithm uses the following parameters: (i) , (ii) , (iii) . The parameter is used for defining tightness of the dual packing constraint. The parameter is used for defining levels. Loosely speaking, in every iteration the weight of a vertex is reduced, and the level of a vertex is proportional to . The parameter is used to bound the number of levels till a vertex becomes -tight, meaning that .

Our algorithm, listed as Algorithm 1, is a variation of the Algorithm of Bar-Yehuda et al. [BCS17] with a few modifications. We begin with a description of the common features. In the course of the algorithm, the weight of each vertex is reduced. Once a vertex becomes -tight (i.e., the reduced weight is an -fraction of its original weight) it decides to join the vertex cover and terminates after sending the message to its remaining neighbors. The message causes the neighbors of to erase from their list of remaining neighbors. If a vertex loses all its neighbors (i.e., becomes isolated), it decides that is not in the vertex cover, and terminates. Upon termination, the -tight vertices constitute a vertex cover.

The handling of offers is as in [BCS17]. Vertex sends an irrevocable offer to every . The offers are allocated from the vault. The responses to the offers are allocated greedily from the bank, namely ’s responses satisfy: and . The updating of the weights can be interpreted as follows. For every edge the dual edge packing variable is increased by . The remaining weight satisfies . Note that each iteration of the while-loop requires a constant number of communication rounds.

The first modification is that we attach a level to each vertex as follows. Let denote the weight of in the beginning of iteration of the while-loop. The level of in iteration satisfies . Note that the initial level is one, and that if the level of is greater than , then is -tight (see Claim 1).

The second modification is how we partition between the vault and the bank. Instead of using a fixed fraction of the initial weight for the vault, our vault decreases as the level of the vertex increases. Formally, . The bank is the rest of the weight, namely, .

The third modification is that in each iteration, every vertex only sends offers to its remaining neighbors with the smallest level. Let denote the set of remaining neighbors of in the beginning of the th iteration. The smallest level of the neighbors of is defined by . The set of neighbors of lowest level is defined by . Let . The size of each offer sent is .

Note that if , then Algorithm 1 reduces to the BCS Algorithm because there is just one level, and the vault size is fixed and equals to . On the other hand, if , then there are levels. Per level , the algorithm can be viewed as a version of the BCS algorithm with . This also explains why our algorithm may be adapted to the CONGEST model of distributed computation using the techniques of [BCS17]. In essence they give an adaptation for a single level of our algorithm, which can easily be extended to multiple levels.

1 parameter in the interval .
7 //Let be the set of neighbors of lowest level in iteration and
9 while  do
12       and
13       foreach  do
15             Send to
16             Let be the response from
19      Let be an arbitrary order of neighbors that sent requests in this iteration
20       foreach  do
21             Let be received from
23             Send to
25       if  and  then
28      if  or  then
29             Send to all neighbors
30             Return InCover
32      foreach  received from  do
35      if  then
36             Return NotInCover
Algorithm 1 A distributed -approximation algorithm for MWVC, code for vertex . (Listing taken from [BCS17] and edited to include our modifications.)

We now state the main theorem of this work.

Theorem 2.

Algorithm 1 (with if and otherwise) is a deterministic distributed -approximation algorithm for MWVC. The number of rounds required for the algorithm to terminate is if and otherwise.

3.1 Proof of Theorem 2


In the analysis we use to denote the value of these variables at the beginning of the th iteration.

The following claim states an invariant that Algorithm 1 satisfies.

Claim 1.

The following invariant holds in every iteration of the while-loop:


Hence, (i)  and (ii) if , then .

This invariant of Claim 1 implies, among other things, that every vertex that decides to join the vertex cover is -tight. This property, together with the fact that the set of vertices that join the vertex cover constitute a vertex cover leads to the proof that Algorithm 1 is a -approximation algorithm. An analogous lemma and its proof also appears in [BCS17]. We remark that termination of the algorithm is implied by the upper bound on the number of iterations of the while-loop proved in the sequel.

Lemma 1 ([Bcs17, Lemma 3.2]).

For every , upon termination Algorithm 1 computes a -approximate solution to MWVC.

In the following lemma we show that, for every vertex and every iteration of the while-loop, either many of ’s neighbors of the smallest level have increased their level or ’s weight has decreased significantly.

Lemma 2.

Let . Let be an iteration of the while-loop in the execution of Algorithm 1 by vertex in which does not join the cover. At least one of following conditions must hold:

  1. At least of the neighbors of of the lowest level have increased their level. Formally, If , then .

  2. .


Assume that and . Note that if the level of a vertex remains unchanged (i.e., ), then either or . If , then joins the cover, a contradiction. If , then the bank was not exhausted and . To conclude, at least vertices responded with . This implies that

Lemma 3.

For every and , the number of iterations of the while-loop for every vertex is bounded by:


The number of levels is bounded by . Hence it suffices to prove that the number of rounds per level is at most . Indeed, the number of rounds that satisfy Condition 1 per level is bounded by because is divided by at least in each such iteration.

We now bound the number of iterations that satisfies Condition 2 per level. By Claim 1, . Hence, the number of iterations that satisfies Condition 2 is bounded by , as required, and the lemma follows. ∎

We now prove Theorem 2.


First, consider the case where . We set (hence, ) and . Lemma 3 immediately shows that the termination time is . Next, assume that (thus hereafter: , , , and ). We set and . Now we can express the running time as:

Let us analyze the running time according to the values of . First, consider the case where . Since , it follows that . We get that . Thus, the total running time for this case is . Next we consider the complementary case, where . This means that . Therefore, , and the running time for the second case is given by . Thus, we may express the running time of our algorithm asymptotically as:

The number of rounds is bounded as required, and the theorem follows. ∎

4 An algorithm without knowing

The bound on the round complexity in Theorem 2 assumes that every vertex knows the maximum degree (or a polynomial upper bound on ). This is required in order to determine the value of . In this section we consider the setting in which is unknown to the vertices.

Note that the analysis in Lemma 3 is per a vertex. Hence, in the analysis of the round complexity, we may use a different per a vertex. Let denote the value of that is used in the analysis for bounding the round complexity of .

We propose two alternatives for the setting of unknown maximum degree, as follows:

  1. In the first setting, we simply set in the algorithm. For the analysis, we consider , where denotes the degree of . Plugging in these parameters in Lemma 3 gives a round complexity of .

  2. For any , we can set (hence, ). An analysis with shows that terminates in the optimal rounds for any . This is because

    That allows us to express the running time as


  • [ÅFP09] Matti Åstrand, Patrik Floréen, Valentin Polishchuk, Joel Rybicki, Jukka Suomela, and Jara Uitto. A local 2-approximation algorithm for the vertex cover problem. In Distributed Computing, 23rd International Symposium, DISC 2009, Elche, Spain, September 23-25, 2009. Proceedings, pages 191–205, 2009.
  • [ÅS10] Matti Åstrand and Jukka Suomela. Fast distributed approximation algorithms for vertex cover and set cover in anonymous networks. In SPAA 2010: Proceedings of the 22nd Annual ACM Symposium on Parallelism in Algorithms and Architectures, Thira, Santorini, Greece, June 13-15, 2010, pages 294–302, 2010.
  • [BCS17] Reuven Bar-Yehuda, Keren Censor-Hillel, and Gregory Schwartzman. A distributed (2 + )-approximation for vertex cover in o(log / log log ) rounds. J. ACM, 64(3):23:1–23:11, 2017.
  • [BE81] Reuven Bar-Yehuda and Shimon Even. A linear-time approximation algorithm for the weighted vertex cover problem. J. Algorithms, 2(2):198–203, 1981.
  • [BE85] Reuven Bar-Yehuda and Shimon Even. A local-ratio theorem for approximating the weighted vertex cover problem. North-Holland Mathematics Studies, 109:27–45, 1985.
  • [BEPS12] Leonid Barenboim, Michael Elkin, Seth Pettie, and Johannes Schneider. The locality of distributed symmetry breaking. In 53rd Annual IEEE Symposium on Foundations of Computer Science, FOCS 2012, New Brunswick, NJ, USA, October 20-23, 2012, pages 321–330, 2012.
  • [CLRS09] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to Algorithms, Third Edition. The MIT Press, 3rd edition, 2009.
  • [GJ79] M. R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman, 1979.
  • [GKP08] Fabrizio Grandoni, Jochen Könemann, and Alessandro Panconesi. Distributed weighted vertex cover via maximal matchings. ACM Transactions on Algorithms, 5(1), 2008.
  • [HKP01] Michal Hanckowiak, Michal Karonski, and Alessandro Panconesi. On the distributed complexity of computing maximal matchings. SIAM J. Discrete Math., 15(1):41–57, 2001.
  • [Hoc82] Dorit S. Hochbaum. Approximation algorithms for the set covering and vertex cover problems. SIAM J. Comput., 11(3):555–556, 1982.
  • [Kar72] Richard M. Karp. Reducibility among combinatorial problems. In Proceedings of a symposium on the Complexity of Computer Computations, held March 20-22, 1972, at the IBM Thomas J. Watson Research Center, Yorktown Heights, New York., pages 85–103, 1972.
  • [KMW06] Fabian Kuhn, Thomas Moscibroda, and Roger Wattenhofer. The price of being near-sighted. In Proceedings of the Seventeenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2006, Miami, Florida, USA, January 22-26, 2006, pages 980–989, 2006.
  • [KMW16] Fabian Kuhn, Thomas Moscibroda, and Roger Wattenhofer. Local computation: Lower and upper bounds. J. ACM, 63(2):17:1–17:44, 2016.
  • [KR08] Subhash Khot and Oded Regev. Vertex cover might be hard to approximate to within 2-epsilon. J. Comput. Syst. Sci., 74(3):335–349, 2008.
  • [KVY94] Samir Khuller, Uzi Vishkin, and Neal E. Young. A primal-dual parallel approximation technique applied to weighted set and vertex covers. J. Algorithms, 17(2):280–289, 1994.
  • [KY09] Christos Koufogiannakis and Neal E. Young. Distributed and parallel algorithms for weighted vertex cover and other covering problems. In Proceedings of the 28th ACM Symposium on Principles of Distributed Computing, PODC ’09, pages 171–179, New York, NY, USA, 2009. ACM.
  • [KY11] Christos Koufogiannakis and Neal E. Young. Distributed algorithms for covering, packing and maximum weighted matching. Distributed Computing, 24(1):45–63, 2011.
  • [NJ75] George L. Nemhauser and Leslie E. Trotter Jr. Vertex packings: Structural properties and algorithms. Math. Program., 8(1):232–248, 1975.
  • [Pet16] Seth Pettie. Personal communication. 2016.
  • [PR01] Alessandro Panconesi and Romeo Rizzi. Some simple distributed algorithms for sparse networks. Distributed Computing, 14(2):97–100, 2001.
  • [PS09] Valentin Polishchuk and Jukka Suomela. A simple local 3-approximation algorithm for vertex cover. Inf. Process. Lett., 109(12):642–645, 2009.
  • [Sol18] Shay Solomon. Local algorithms for bounded degree sparsifiers in sparse graphs. In ITCS, volume 94 of LIPIcs, pages 52:1–52:19. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 2018.