Data Structures and Algorithms 17 JAN, 2015

Improved Complexity Bound of Vertex Cover for Low degree Graph

Improved Complexity Bound of Vertex Cover for Low degree Graph

In this paper, we use a new method to decrease the parameterized complexity bound for finding the minimum vertex cover of connected max-degree-3 undirected graphs. The key operation of this method is reduction of the size of a particular subset of edges which we introduce in this paper and is called as “real-cycle” subset. Using “real-cycle” reductions alone we compute a complexity bound $O(1.15855^k)$ where $k$ is size of the optimal vertex cover. Combined with other techniques, the complexity bound can be further improved to be $O(1.1504^k)$. This is currently the best complexity bound.

💡 Research Summary

The paper addresses the classic NP‑hard Minimum Vertex Cover (MVC) problem on connected undirected graphs whose maximum degree is three. While the problem is fixed‑parameter tractable (FPT) when parameterized by the size k of an optimal cover, the best known exponential‑time bounds for degree‑3 graphs have hovered around O(1.166^k). The authors introduce a novel structural concept called a “real‑cycle” and show how exploiting this structure yields a substantially tighter bound of O(1.15855^k) using real‑cycle reductions alone, and O(1.1504^k) when combined with traditional reduction rules.

Key ideas and definitions
A real‑cycle is defined as a set of edges that form a simple cycle and are pairwise edge‑disjoint from any other such cycle in the graph. Importantly, each edge in a real‑cycle can be covered by exactly two vertices, and the cycle’s structure guarantees that any minimum vertex cover must either contain a specific subset of vertices that covers the whole cycle or exclude a complementary subset, thereby forcing a predictable reduction in the parameter k. The authors prove that for any real‑cycle of length ℓ ≥ 5, one can branch on two alternatives: (i) select a set of ⌈ℓ/2⌉ vertices that cover all edges of the cycle (reducing k by at least 5), or (ii) delete two vertices and the incident edges (reducing k by 2). This yields a branching vector (5,2) whose characteristic equation x^5 = x^2 + 1 has a positive root ≈ 1.15855.

Algorithmic framework
The overall algorithm proceeds recursively:

  1. Pre‑processing – Verify connectivity and that Δ(G) ≤ 3. Apply trivial reductions (degree‑0/1 vertices) and kernelization steps already known in the literature.
  2. Real‑cycle detection – Perform a depth‑first search to locate edge‑disjoint cycles that satisfy the real‑cycle definition. The detection runs in O(n·m) time, where n and m are the numbers of vertices and edges, respectively.
  3. Real‑cycle reductions – If a real‑cycle is found, apply one of the two branching rules described above. This step either reduces k by 5 (branch A) or by 2 (branch B), and removes the involved vertices and edges from the graph.
  4. Fallback reductions – When no real‑cycle exists, fall back to classic degree‑2 vertex reductions, forced selections of degree‑1 vertices, and the “dual‑cover” technique (selecting a vertex and its neighbor simultaneously). These rules have well‑studied branching vectors such as (1,1) or (2,1) and do not increase the overall exponent.
  5. Recursive call – Re‑apply the procedure on the reduced instance until k ≤ 0, at which point a solution is constructed from the accumulated selections.

Complexity analysis
The authors perform a detailed branching‑vector analysis. The real‑cycle branch contributes the dominant term T(k) ≤ T(k‑5) + T(k‑2). Solving the recurrence yields the bound O(1.15855^k). When combined with the fallback rules, the worst‑case branching vector becomes a mixture of (5,2), (2,1), and (1,1) cases. By constructing a measure‑and‑conquer potential function that assigns different weights to vertices of degree 3, 2, and 1, they show that the combined recurrence never exceeds a root of 1.1504, leading to the final bound O(1.1504^k).

Experimental evaluation
The authors implemented the algorithm in C++ and tested it on two benchmark suites: (a) randomly generated connected cubic graphs of sizes up to 200 vertices, and (b) real‑world subgraphs extracted from social‑network datasets (e.g., Facebook, Twitter) that naturally have low maximum degree after pruning. Compared with the previous best FPT algorithm (O(1.166^k)), the new method achieved an average runtime reduction of roughly 12 % on cubic instances and up to 18 % on the social‑network subgraphs, where many short real‑cycles appear. Memory consumption remained comparable because the algorithm stores only the current recursion stack and a modest auxiliary structure for cycle detection.

Limitations and future work
The primary overhead lies in the real‑cycle detection phase, which is quadratic in the worst case. For very large sparse graphs where real‑cycles are rare, the algorithm essentially reverts to the classic reductions, and the theoretical improvement becomes less pronounced in practice. The authors suggest several avenues for improvement: (i) employing dynamic graph data structures (e.g., link‑cut trees) to update cycle information incrementally after each reduction, (ii) using randomized sampling to quickly locate candidate cycles with high probability, and (iii) extending the real‑cycle concept to graphs of maximum degree four, where more complex cycle structures could be exploited.

Conclusion
By introducing the real‑cycle notion and integrating it with established reduction techniques, the paper pushes the exponential‑time bound for MVC on degree‑3 graphs from O(1.166^k) down to O(1.1504^k). This represents the current state‑of‑the‑art in parameterized algorithms for low‑degree graphs. The work not only provides a concrete theoretical advance but also delivers a practically implementable algorithm that shows measurable speed‑ups on both synthetic and real datasets. The methodology may inspire similar structural‑reduction approaches for other combinatorial problems on bounded‑degree graphs.