Optimal Distributed Covering Algorithms

We present a time-optimal deterministic distributed algorithm for approximating a minimum weight vertex cover in hypergraphs of rank $f$. This problem is equivalent to the Minimum Weight Set Cover problem in which the frequency of every element is bounded by $f$. The approximation factor of our algorithm is $(f+\epsilon)$. Our algorithm runs in the CONGEST model and requires $O(\log\Delta/ \log\log\Delta)$ rounds, for constants $\epsilon\in(0,1]$ and $f\in N^+$. This is the first distributed algorithm for this problem whose running time does not depend on the vertex weights nor the number of vertices. For constant values of $f$ and $\epsilon$, our algorithm improves over the $(f+\epsilon)$-approximation algorithm of KMW06 whose running time is $O(\log \Delta + \log W)$, where $W$ is the ratio between the largest and smallest vertex weights in the graph. Our algorithm also achieves an $f$-approximation for the problem in $O(f\log n)$ rounds, improving over the classical result of KVY94 that achieves a running time of $O(f\log^2 n)$. Finally, for weighted vertex cover ($f=2$) our algorithm achieves a \emph{deterministic} running time of $O(\log n)$, matching the \emph{randomized} previously best result of KY11. We also show that integer covering-programs can be reduced to the Minimum Weight Set Cover problem in the distributed setting. This allows us to achieve an $(f+\epsilon)$-approximate integral solution in $O(\frac{\log\Delta}{\log\log\Delta}+(f\cdot\log M)^{1.01}\log\epsilon^{-1}(\log\Delta)^{0.01})$ rounds, where $f$ bounds the number of variables in a constraint, $\Delta$ bounds the number of constraints a variable appears in, and $M=\max \{1, 1/a_{\min}\}$, where $a_{min}$ is the smallest normalized constraint coefficient. This improves over the results of KMW06 for the integral case, which runs in $O(\epsilon^{-4}\cdot f^4\cdot \log f\cdot\log(M\cdot\Delta))$ rounds.


Introduction
In the Minimum Weight Vertex Cover (mwvc) problem, we are given an undirected graph G = (V, E) with vertex weights w : V → {1, . . ., W }, for W = n O(1) .The goal is to find a minimum weight cover U ⊆ V such that ∀e ∈ E : e ∩ U = ∅.This problem is one of the classical NP-hard problems presented in [Kar72].
In this paper, we consider the Minimum Weight Hypergraph Vertex Cover (mwhvc) problem, a generalization of the mwvc problem to hypergraphs of rank f .In a hypergraph, G = (V, E), each edge is a nonempty subset of the vertices.A hypergraph is of rank f if the size of every hyperedge is bounded by f .The mwvc problem naturally extends to mwhvc using the above definition.Note that mwhvc is equivalent to the Minimum Weight Set Cover problem with element frequencies bounded by f .We consider the mwhvc problem in the distributed setting, where the communication network is a bipartite graph H(E ∪ V, {{e, v} | v ∈ e}).We refer to the network vertices as nodes and network edges as links.The nodes of the network are the hypergraph vertices on one side and hyperedges on the other side.There is a network link between vertex v ∈ V and hyperedge e ∈ E iff v ∈ e.The computation is performed in synchronous rounds, where messages are sent between neighbors in the communication network.As for message size, we consider the congest model where message sizes are bounded to O(log |V |).This is more restrictive than the local model where message sizes are unbounded.
Denoting by ∆ the maximum vertex degree in G, any distributed constant-factor approximation algorithm requires Ω(log ∆/ log log ∆) rounds to terminate, even for unweighted graphs and f = 2 [KMW16].Two results match the lower bound.For the (unweighted) Minimum Weight Vertex Cover Problem in graphs (f = 2), the lower bound was matched by [BCS17] with a (2 + ε)-approximation algorithm (BCS algorithm) with optimal round complexity for every ε = Ω(log log ∆/ log ∆). 1 The progress of the BCS algorithm is analyzed via a trade-off between reducing the degree of the vertices and reducing the weight of the vertices.We do not know how to generalize the BCS algorithm and its analysis to hypergraphs.For the Minimum Cardinality Vertex Cover in Hypergraphs Problem, the lower bound was recently matched by [EGM18] with an (f +ε)-approximation algorithm.The round complexity in [EGM18] is log log(f •∆) , which is optimal for constant f and ε.The algorithm in [EGM18] and its analysis is a deterministic version of the maximal independent set algorithm of [Gha16].We do not know how to generalize the algorithm in [EGM18] and its analysis to hypergraphs with vertex weights.
In this paper, we present a deterministic distributed (f + ε)-approximation algorithm for minimum weight vertex cover in f -rank hypergraphs, which completes in O(log ∆/ log log ∆) rounds in the congest model, for any constants ε ∈ (0, 1) and f ∈ N + .Our running time is optimal according to a lower bound by [KMW16].2This is the first distributed algorithm for this problem whose round complexity does not depend on the node weights nor the number of vertices   We note that [KY11] was the first to achieve this running time with no dependence on W , the maximum weight of the nodes.Comparison to previous works for vertex cover appears in Table 1 for hypergraphs in Table 2.We also show that general covering Integer Linear Programs (ILPs) can be reduced to the Minimum Weight Set Cover problem in the distributed setting.That is, LP constraints can be translated into hyperedges such that a cover for the hyperedges satisfies all covering constraints.This allows us to achieve an (f +ε)-approximate integral solution in 01 rounds, where f bounds the number of variables in a constraint, ∆ bounds the number of constraints a variable appears in, and M = max {1, ⌈1/a min ⌉}, where a min smallest normalized constraint coefficient.This significantly improves over the results of [KMW06] for the integral case, which combined with randomized rounding achieves the same guarantees in Note that the results of [KMW06] also include a (1 + ε)-approximation for the fractional case, while our result only allows for an integral solution.We also note that plugging ε = 1/nW M into our algorithm, achieves an f -approximation for ILPs in polylogarithmic time, a similar result cannot be achieved using [KMW06].

Tools and techniques
Our solution employs the Primal-Dual schema.The Primal-Dual approach introduces, for every hyperedge e ∈ E, a dual variable denoted by δ(e).The dual edge packing constraints are ∀v ∈ V, v∈e δ(e) ≤ w(v).If for some β ∈ [0, 1) it holds that v∈e δ(e) ≥ (1 − β) • w(v), we say the v is β-tight.Let β = ε/(f + ε).For every feasible dual solution, the weight of the set of β-tight vertices is at most (f + ε) times the weight of an optimal (fractional) solution.The algorithm terminates weighted approximation  when the set of β-tight edges constitutes a vertex cover.
The challenge in designing a distributed algorithm is in controlling the rate at which we increase the dual variables.On the one hand, we must grow them rapidly to reduce the number of communication rounds.On the other hand, we may not violate the edge packing constraints.The algorithm proceeds in iterations, each of which requires a constant number of communication rounds.We initialize the dual variables in a "safe" way so that feasibility is guaranteed.We refer to the additive increase of the dual variable δ(e) in iteration i by deal i (e).Similarly to [BEKS18], we use levels to measure the progress made by a vertex.Whenever the level of a vertex increases, it sends a message about it to all incident edges, which multiply (decrease) their deals by 0.5.Formally, we define the level of a vertex v as ℓ(v) = 1 + log . That is, the initial level of v is 1 (as e∈E(v) δ(e) = 0) and it is increased as the dual variables of the edges incident to v grow.Once the level of a vertex reaches z ⌈log β −1 ⌉, the vertex is β-tight and joins the cover.Loosely speaking, the algorithm increases the increments deal i (e) exponentially (multiplication by α) provided that no vertex v ∈ e is (0.5 ℓ(v) /α)-tight with respect to the deals of the previous iteration.Otherwise, the increment deal i (e) equals the previous increment deal i−1 (e).The analysis builds on two observations: (1) The number of times that the increment deal(e) is multiplied by α is bounded by log α ∆. (2) The number of iterations in which a vertex is (0.5 ℓ(v) /α)-tight with respect to the deals of the previous iteration is at most z • 2α.This is because for each vertex v and level ℓ(v) ∈ {1, 2, . . ., z}, v would level-up after α/0.5 iterations in which it was (0.5 ℓ(v) /α)-tight.Hence the total number of iterations is bounded by Next, we show distributed reductions that allow us to compute an (f +ε)-approximation for general covering integer linear programs (ILPs).To that end, we first show that any Zero-One covering program (where all variables are binary) can be translated into a set cover instance in which the vertex degree is bounded by 2 f times the bound on the number of constraints each ILP variable appears in.
We then generalize to arbitrary ILPs by replacing each variable with multiple vertices in the hypergraph, such that the value associated with the ILP variable will be the weighted sum of the vertices in the cover.

Problem Formulation
Let G = (V, E) denote a hypergraph.Vertices in V are equipped with positive weights w(v).For a subset U ⊆ V , let w(U ) v∈U w(v).Let E(U ) denote the set of hyperedges that are incident to some vertex in U (i.e., E(U The Minimum Weight Hypergraph Vertex Cover Problem (mwhvc) is defined as follows. Input: The mwhvc Problem is equivalent to the Weighted Set Cover Problem.Consider a set system (X, U), where X denotes a set of elements and U = {U 1 , . . ., U m } denotes a collection of subsets of X.The reduction from the set system (X, U) to a hypergraph G = (V, E) proceeds as follows.The set of vertices is V {u 1 , . . ., u m } (one vertex u i per subset U i ).The set of edges is E {e x } x∈X (one hyperedge e x per element x), where e x {u i : x ∈ U i }.The weight of vertex u i equals the weight of the subset U i .

Input
The input is a hypergraph G = (V, E) with non-negative vertex weights w : V → N + and an approximation ratio parameter ε ∈ (0, 1].We denote the rank of G by f (i.e., each hyperedge contains at most f vertices) and the maximum degree of G by ∆ (i.e., each vertex belongs to at most ∆ edges).
Assumptions.We assume that (i) Vertex weights are polynomial in n = |V | so that sending a vertex weight requires O(log n) bits.(ii) Vertex degrees are polynomial in n (i.e., |E(v)| = n O(1) ) so that sending a vertex degree requires O(log n) bits.Since |E(v)| ≤ n f , this assumption trivially holds for constant f .(iii) The maximum degree is at least 3 so that log log ∆ > 0.

Output
A vertex cover C ⊆ V .Namely, for every hyperedge e ∈ E, the intersection e ∩ C is not empty.The set C is maintained locally in the sense that every vertex v knows whether it belongs to C or not.

Communication Network
The communication network N (E ∪ V, {{e, v} | v ∈ e}) is a bipartite graph.There are two types of nodes in the network: servers and clients.The set of servers is V (the vertex set of G) and the set of clients is E (the hyperedges in G).There is a link (v, e) from server v ∈ V to a client e ∈ E if v ∈ e.We note that the degree of the clients is bounded by f and the degree of the servers is bounded by ∆.

Parameters and Variables
• The approximation factor parameter is ε ∈ (0, 1].The parameter β is defined by β ε/(f +ε), where f is the rank of the hypergraph.
• Each vertex v is assigned a level ℓ(v) which is a nonnegative integer.
• The parameter α > 1 determines the factor by which "deals" are multiplied .We determine its value in the analysis in the following section.
• We denote the dual variables at the end of iteration i by δ i (e) (see Appendix A for a description of the dual edge packing linear program).The amount by which δ i (e) is increased in iteration i is denoted by deal i (e).Namely, δ i (e) = j≤i deal j (e).

Notation
• We say that an edge e is covered by C if e ∩ C = ∅.
• Let E(v) {e ∈ E | v ∈ e} denote the set of hyperedges that contain v.
• For every vertex v, the algorithm maintains a subset

Algorithm MWHVC
1. Initialization.Set C ← ∅.For every vertex v, set level ℓ(v) ← 0 and uncovered edges (c) For every uncovered edge e, if e receives a message that it is covered, then it tells all its vertices that e is covered and terminates.
(d) For every vertex v / ∈ C, if it receives a message from e that e is covered, then then v terminates (without joining the cover).(e) Increment levels and scale deals.
For every active (that has not terminated) vertex: • w(v), then send the message "raise" to every e ∈ E ′ (v); otherwise, send the message "stuck" to every e ∈ E ′ (v).
(g) For every uncovered edge e, if all incoming messages are "raise" deal i (e) ← α • deal i (e).
Send deal i (e) to every v ∈ e, who updates δ i (e) ← δ i−1 (e) + deal i (e).
Termination Every vertex v terminates when either v ∈ C or every edge e ∈ E(v) is covered (i.e., E ′ (v) = ∅).Every edge e terminates when it is covered (i.e., e ∩ C = ∅).

Execution in CONGEST.
See Section B in the Appendix for a discussion of how Algorithm mwhvc is executed in the congest model.

Algorithm Analysis
The following invariants are satisfied throughout the execution of the algorithm.
Claim 4.1.After Line 3e, for every vertex v / ∈ C the following inequality holds: Proof.After iteration i = 0, the dual variables are positive, hence w(v) − e∈E(v) < w(v).Line 3e increases the levels until Eq. 1 holds.Further increases in the dual variables lead to incrementing the level until Eq. 1 hold again.
Let z log 1 β .Note that z = O (log(f /ε).Claim 4.2.The level of every vertex is less than z.
This implies that v is β-tight and joins the cover in Line 3b.

Approximation Ratio
In the following claim we bound the sum of the deals of edges incident to a vertex.
If an edge e is covered in iteration j, then e terminates and δ i (e) is not set for i ≥ j.In this case, we define δ i (e) = δ j−1 (e), namely, the last value assigned to a dual variable.Claim 4.4.For every i ≥ 0 the dual variables δ i (e) constitute a feasible edge packing.Namely, for every vertex v ∈ V , δ i (e) ≥ 0 for every edge e ∈ E.
Proof.Nonnegativity follows from the initialization and the positive increases by deals.The packing constraints are proved by induction on the number of iterations.The induction basis, for i = 0, holds because e∈E(v) δ 0 (e) = e∈E(v) deal 0 (e) ≤ 0.5•w(v).The induction step is proved as follows.By Step 3g, if e ∈ E ′ (v), then δ i (e) = δ i−1 (e) + deal i (e), otherwise δ i (e) = δ i−1 (e).By Claim 1, • w(v), and the claim follows.
Let opt denote the cost of an optimal (fractional) weighted vertex cover of G.
Proof.Throughout the algorithm, the set C consists of β-tight vertices.By Claim A.1, w(C) ≤ (f + ε) • opt.Upon termination, C constitutes a vertex cover, and the corollary follows.

Communication Rounds Analysis
In this section, we prove that the number of communication rounds of Algorithm mwhvc is bounded by (where γ > 0 is a constant, e.g., γ = 0.001) It suffices to bound the number of iterations because each iteration consists of a constant number of communication rounds.

Raise or Stuck Iterations
Definition 4.6.An iteration i ≥ 1 is an e-raise iteration if deal i (e) = α • deal i−1 (e).An iteration i is a v-stuck iteration if v sent the message "stuck" in iteration i.
Note that if iteration i is a v-stuck iteration and v ∈ e, then deal i (e) = deal i−1 (e) and i is not an e-raise iteration.
We bound the number of e-raise iterations as follows.
Proof.Let v * denote a vertex with minimum normalized weight in e.The first deal satisfies deal 0 (e) = 0.5 The deal is multiplied by α in each e-raise iteration and is halved at most f • z times.The bound on the number of halvings holds because the number of vertices in the edge is bounded by f , and each vertex halves the deal each time its level is incremented.The lemma follows.
We bound the number of v-stuck as follows.
Lemma 4.8.For every vertex v and level ℓ(v), the number of v-stuck iterations is bounded by 2 • α.
Proof.Fix a vertex v and a level ℓ(v).Assume, towards a contradiction, that the number of v-stuck iterations is greater than 2 • α.By Eq. 1, before the first v-stuck iteration, the slack in the edge packing constraint of vertex v is at most 0.5 ℓ(v) • w(v).Every v-stuck iteration, reduces the slack by at least 1 2•α • 0.5 ℓ(v) • w(v).Hence, after more than 2 • α such v-stuck iterations, the edge packing constraint for v is violated, contradicting feasibility (Claim 4.4).

Putting it Together
Theorem 4.9.For every α ≥ 2, the number of iterations of Algorithm mwhvc is Proof.Fix an edge e.We bound the number of iterations until e is covered as follows.Every iteration is either an e-raise iteration or a v-stuck iteration for some v ∈ e.Since e contains at most f vertices, we conclude that the number of iterations is bounded by the number of e-stuck iterations plus the sum over v ∈ e of the number of v-stuck iterations.The theorem follows from Lemmas 4.7 and 4.8.
In theorem 4.10 we assume that all the vertices know the maximum degree ∆ and that ∆ ≥ 3. The assumption that the maximal degree ∆ is known to all vertices is not required.Instead, each hyperedge e can compute a local maximum degree ∆(e), where ∆(e) max u∈e |E(u)|.The local maximum degree ∆(e) can be used instead of ∆ to define local value of the multiplier α = α(e).Let T (f, ∆, ε) denote the round complexity of Algorithm mwhvc.By setting α appropriately, we bound the running time as follows.
Theorem 4.10. 4Let γ > 0 denote a constant and Then, the round complexity of Algorithm mwhvc satisfies: Proof.First, consider the case where α . This means that the runtime is bounded by Second, assume that α = 2 and 2 . Then, the round complexity of Algorithm mwhvc is bounded by Therefore, since α = 2 in this case, the runtime is bounded by The bounds holds for all the cases, and the theorem follows.
Let W max v w(v)/ min v w(v).By setting ε = 1/(nW ), we conclude the following result for an f -approximation (recall that we assume that vertex degrees are polynomial in n): Corollary 4.11.Algorithm mwhvc computes an f -approximation of the problem in O(f log n) rounds.

Approximation of Covering ILPs
In this section we present a reduction from solving covering integer linear programs (ILPs) to mwhvc.This reduction implies that one can distributively compute approximate solutions to covering ILPs using a distributed algorithm for mwhvc.

Distributed Setting
We denote the number of rows of the matrix A by m and the number of columns by n.Let f (A) (resp., ∆(A)) denote the maximum number of nonzero entries in a row (resp., column) of A.
Given a covering ILP, ILP (A, b, w), the communication network N (ILP ) over which the ILP is solved is the bipartite graph N = (X × C, E), where: , and E = {(x j , c i ) | A i,j = 0}.We refer to the nodes in C as constraint nodes, and to nodes in X as variable nodes.Note that the maximum degree of a constraint node is f (A) and the maximum degree of a variable node is ∆(A).
We assume that the local input of every variable node x j consists of w j and the j'th column of A (i.e., A i,j , for i ∈ [m]).Every constraint vertex c i is given the value of b i as its local input.We assume that these inputs can be represented by O(log(nm)) bits.
In (f + 1) rounds, every variable node v j can learn all the components in the rows i of A such that A i,j = 0 as well as the component b i .

Zero-One Covering Programs
The special case in which a variable may be assigned only the values 0 or 1 is called a zero-one program.We denote the zero-one covering ILP induced by a matrix A and vectors b and w by ZO(A, b, z).Every instance of the mwhvc problem is a zero-one program in which the matrix A is the incidence matrix of the hypergraph.The following lemma deals with the converse reduction.ZO(A, b, w) can be reduced to an mwhvc instance with rank f ′ < f (A) and degree

Lemma 5.2. Every feasible zero-one covering program
Proof.Let A i denote the i'th row of the matrix A. For a subset S ⊆ [n], let I S denote the indicator vector of S. Let x ∈ {0, 1} n and let for every row i.Let S i denote the set of all subsets S ⊂ [n] such that the indicator vector I S does not satisfy the i'th constraint, i.e., A i • I S < b i The i'th constraint is not satisfied, i.e., A i • x < b i , if and if only there exists a set S ∈ S i such that x = I S .Hence, A i • x < b if and only if the truth value of the following DNF formula is false: ϕ i (x) S∈S i j∈σ i \S not(x j ).By De Morgan's law, we obtain that not(ϕ i (x)) is equivalent to a monotone CNF formula ψ i (x) such that ψ i (x) has less than 2 f (A) clauses, each of which has length less than f (A).
We now construct the hypergraph H for the mwhvc instance as follows.For every row i and every S ∈ S, add the hyperedge e i,S = σ i \ S. (Feasibility implies that e i,S is not empty.)Given a vertex cover C of the hypergraph, every hyperedge is stabbed by C, and hence I C satisfies all the formulae ψ i (x), where i ∈ [m].Hence, A i • I C ≥ b i , for every i.The converse direction holds as well, and the lemma follows.
How does the network N (ILP ) (a bipartite graph with m + n vertices) simulate the execution of mwhvc over the hypergraph H? Every constraint node c i simulates all the hyperedge nodes {e i,S } S∈S i .The algorithm has the property that, in each round, every vertex broadcasts the same message to all the hyperedges it is contained in.This means that the message c i receives from v is good for all the hyperedges it simulates.Consider now the messages send from hyperedges simulated by c i to a vertex v.In fact, v only needs to know the sum of the deals rather than the individual deals.Hence, c i can aggregate all these messages to a single message by simply sending the sum to v.
We summarize the running time of the distributed algorithm for solving a zero-one covering program in the following claim.
Claim 5.3.There exists a distributed congest algorithm for computing an (f +ε)-approximate solution for zero-one covering programs with running time of T (f (A), 2 f (A) •∆(A), ε), where T (f, ∆, ε) is the running time of Algorithm mwhvc.

Reduction of Covering ILPs to Zero-One Covering
Consider the covering ILP ILP (A, b, w).We present a reduction of the ILP to a zero-one covering program.Proof.Let B = ⌈log 2 M ⌉.Limiting each variable x j by M means that we can replace x j by B zeroone variables {x j,ℓ } B−1 ℓ=0 that correspond to the binary representation of x j , i.e., x j = B−1 ℓ=0 2 ℓ • x j,ℓ .This replacement means that the dimensions of the matrix A ′ are m × n ′ , where n ′ = n •B.The j'th column A (j) of A is replaced by B columns, indexed 0 to B −1, where the ℓ'th column equals 2 ℓ •A (j) .The vector w ′ is obtained by duplicating and scaling the entries of w in the same fashion.

Definition 5.4. Define
Combining Claims 5.3 and 5.6, we obtain the following result.

B Adaptation to the CONGEST model
To complete the discussion, we need to show that the message lengths in Algorithm mwhvc are O(log n). 2. In round i ≥ 1, every vertex sends messages.Messages of the sort: "e is covered", "raise", or "stuck" require only a constant number of bits.The increment of v's level needs to be sent to the edges in E(v).This increments require O(log z) = O(log n) bits.
3. Every edge sends the final deal to the vertices.This value can be encoded by a single bit indicating whether the deal was multiplied by α and by a power of 1/2 indicating the amount by which the vertices decreased the deal.This exponent is bounded by z, and hence can be sent using O(log z) = O(log n) bits.
4. Finally, if α = α(e) is set locally based on the local maximum degree max v∈e |E(v)|, then every vertex v sends its degree to all the edges e ∈ E(v).The local maximum degree for e is sent to every vertex v ∈ V , and this parameter is used to compute α(e) locally.
2. Iteration i = 0. Every edge e collects the weight w(v) and degree |E(v)| from every vertex v ∈ e, and sets: deal 0 (e) = 0.5 • min v∈e {w(v)/|E(v)|}.The value deal 0 (e) is sent to every v ∈ e.The dual variable is updated δ 0 (e) ← deal 0 (e).3.For i = 1 to ∞ do: (a) Copy deals.For every uncovered edge e, set deal i (e) ← deal i−1 (e).(b) Check β-tightness.For every v ∈ C, if e∈E(v) δ i−1 (e) ≥ (1 − β)w(v) then then v joins the cover C, sends a message to every e ∈ E ′ (v) that e is covered, and (v) terminates.

.
Let N denote the set of natural numbers {0, 1, 2 . ..}.Let A denote a real m×n matrix, b ∈ R n , and w ∈ R n .Let LP (A, b, w) denote the linear program min w T • x subject to A • x ≥ b and x ≥ 0. Let ILP (A, b, w) denote the integer linear program min w T • x subject to A • x ≥ b and x ∈ N. Definition 5.1.The linear program LP (A, b, w) and integer linear program ILP (A, b, w) are covering programs if all the components in A, b, w are non-negative.
We abbreviate and write M for M (A, b) when the context is clear.Proposition 5.5.Limiting x to the box [0, M ] n does not increase the optimal value of the ILP.Claim 5.6.Every covering ILP ILP (A, b, w) can be solved by a zero-one covering program ZO(A ′ , b, w ′ ), where f (A ′ ) ≤ f (A) • ⌈log 2 (M ) + 1⌉ and ∆(A ′ ) = ∆(A).

1.
In round 0, every vertex v sends its weight w(v) and degree |E(v)| to every hyperedge in e ∈ E(v).We assume that the weights and degrees are polynomial in n, hence the length of the binary representations of w(v) and |E(v)| is O(log n).Every hyperedge e sends back to every v ∈ e the pair (w(v e ), |E(v e )|), where v e has the smallest normalized weight, i.e., v e = argmin v∈e {w(v)/|E(v)|}.Every vertex v ∈ e locally computes deal 0 (e) = β • w(v e )/|E(v e )| and δ 0 (e) = deal 0 (e).
. For constant values of f ,

Table 1 :
In the table, n = |V | and ε ∈ (0, 1).The running times are stated for Weighted Vertex Cover (f = 2), except for [PS09, HKP01, ÅFP + 09] that do not support weights.For randomized algorithms the running times hold in expectation or with high probability.