A simple local 3-approximation algorithm for vertex cover

We present a local algorithm (constant-time distributed algorithm) for finding a 3-approximate vertex cover in bounded-degree graphs. The algorithm is deterministic, and no auxiliary information besides port numbering is required.

💡 Research Summary

The paper tackles the classic NP‑hard Vertex Cover problem in the stringent setting of deterministic local (constant‑time distributed) algorithms. In this model each node can only use information available within a constant‑radius neighbourhood and communication proceeds in synchronous rounds; the only structural information assumed is a port‑numbering of incident edges, i.e., each node knows an arbitrary ordering of its incident edges but has no unique identifier, no randomness, and no geometric coordinates.

Prior work has shown that without additional assumptions many fundamental graph problems (maximal matching, maximal independent set, 3‑coloring, etc.) cannot be solved locally, even with randomisation or unique IDs. Moreover, Kuhn, Moscibroda and Wattenhofer proved that for general (unbounded‑degree) graphs no constant‑factor approximation for Minimum Vertex Cover can be achieved by any local algorithm. The only positive local results known before this work rely on randomness, LP‑based rounding, or extra information such as node coordinates in unit‑disk graphs.

The authors present a simple deterministic algorithm that, for graphs of maximum degree Δ, computes a vertex cover whose size is at most three times optimal in exactly 2Δ + 1 communication rounds. The algorithm does not use linear programming, randomisation, or any global coordination; it can be implemented with only local message passing and constant memory per node.

Key idea – bipartite transformation.
Given the input graph G = (V,E), each vertex v is replaced by two copies: a “black” copy vᵇ and a “white” copy vʷ. For every original edge {u,v} we add two edges in a new graph H: (uᵇ, vʷ) and (uʷ, vᵇ). H is bipartite (black vs. white) and therefore 2‑coloured: every node knows which side it belongs to (its copy colour). In this setting a known local subroutine, LowDegreeMatch, can compute a maximal matching in bounded‑degree bipartite graphs in constant time.

Algorithm description.
Each node v maintains two port numbers a(v) and b(v) (initially ⊥) and a Boolean flag c(v) (initially false). The execution proceeds in alternating odd and even rounds:

Odd round (proposal phase) – If a(v) is still ⊥, the node scans its ports sequentially. For the current port i(v) it receives any incoming message; if the message is “accept” it records a(v) ← i(v) and sets c(v) ← true. Otherwise it increments i(v) and, if still within its degree, sends a “propose” message on that port.

Even round (response phase) – Each node receives all messages sent in the previous odd round. For every incoming “propose” on port j (processed in increasing order) it behaves as follows: if b(v) is still ⊥ it replies “accept”, records b(v) ← j and sets c(v) ← true; otherwise it replies “reject”.

Because each node tries at most Δ ports and each successful exchange consumes two rounds, after at most 2Δ + 1 rounds no further messages are sent and the algorithm terminates. The set C = {v | c(v)=true} is the output vertex cover.

Correctness.
For any edge {u,v} in the original graph, if a(u) ≠ ⊥ then u∈C. If a(u)=⊥, then u must have sent a “propose” to v, and v must have replied “reject”, which implies b(v) ≠ ⊥ and therefore v∈C. Hence every edge is incident to at least one vertex of C, i.e., C is a vertex cover.

Approximation analysis.
Consider the set P of edges in G that correspond to successful matches in H (i.e., edges {u,v} where u’s black copy matched v’s white copy or vice‑versa). In the subgraph G₁ = (V,P) each vertex has degree at most 2: at most one incident edge is selected via a(v) and at most one via b(v). The non‑isolated vertices of G₁ are exactly the vertices placed in C. Removing isolated vertices yields G₂ = (C,P), whose connected components are paths or cycles (no isolated vertices).

Take any component that is a path of length m (i.e., m edges, m + 1 vertices). Since each edge of the component belongs to the original graph, the optimal vertex cover C* must contain at least ⌈m/2⌉ vertices of this path (otherwise an edge would be uncovered). The worst case occurs for m = 2, where the component has three vertices but only one of them is guaranteed to be in C*. Consequently, for every component the number of vertices contributed to C is at most three times the number contributed to C*. Summing over all components yields |C| ≤ 3 |C*|, establishing a 3‑approximation.

Discussion and open problems.
The algorithm demonstrates that, contrary to many negative results, a deterministic constant‑factor approximation for Minimum Vertex Cover is achievable in the pure local model when the degree is bounded. The running time O(Δ) is linear in the degree bound, whereas known lower bounds for any local approximation of Vertex Cover in unbounded‑degree graphs are Ω(log Δ / log log Δ). Closing this gap—either by reducing the round complexity or by extending the technique to larger degree classes—remains an open challenge. Moreover, the transformation to a bipartite graph and the simple proposal/accept protocol may inspire similar approaches for other covering or packing problems in the local setting.

In summary, the paper contributes a clean, easily implementable deterministic local algorithm that attains a factor‑3 approximation for Minimum Vertex Cover in bounded‑degree graphs, using only port numbering and constant‑size local memory, and it opens avenues for further refinement of locality‑aware approximation techniques.