[Paper Review] Linear-Time FPT Algorithms via Network Flow

Yoichi Iwata, Keigo Oka+1 more|arXiv (Cornell University)|Jul 18, 2013

Advanced Graph Theory Research4 citations

TL;DR

This paper presents the first linear-time FPT algorithms for fundamental problems like Odd Cycle Transversal and Almost 2-SAT, achieving a runtime of $O(4^k n)$ by reducing BIP2 integer programs to Vertex Cover Above LP and using network flow to maintain optimal LP solutions during exhaustive search. The key innovation is a linear-time update of optimal dual solutions via residual graph decomposition, enabling efficient branching with minimal overhead.

ABSTRACT

In the area of parameterized complexity, to cope with NP-Hard problems, we introduce a parameter k besides the input size n, and we aim to design algorithms (called FPT algorithms) that run in O(f(k)n^d) time for some function f(k) and constant d. Though FPT algorithms have been successfully designed for many problems, typically they are not sufficiently fast because of huge f(k) and d. In this paper, we give FPT algorithms with small f(k) and d for many important problems including Odd Cycle Transversal and Almost 2-SAT. More specifically, we can choose f(k) as a single exponential (4^k) and d as one, that is, linear in the input size. To the best of our knowledge, our algorithms achieve linear time complexity for the first time for these problems. To obtain our algorithms for these problems, we consider a large class of integer programs, called BIP2. Then we show that, in linear time, we can reduce BIP2 to Vertex Cover Above LP preserving the parameter k, and we can compute an optimal LP solution for Vertex Cover Above LP using network flow. Then, we perform an exhaustive search by fixing half-integral values in the optimal LP solution for Vertex Cover Above LP. A bottleneck here is that we need to recompute an LP optimal solution after branching. To address this issue, we exploit network flow to update the optimal LP solution in linear time.

Motivation & Objective

• To design fixed-parameter tractable (FPT) algorithms with both small function $f(k)$ and linear polynomial degree $d$ for NP-hard problems.
• To overcome the bottleneck in FPT algorithms where recomputing optimal LP solutions after branching incurs high overhead.
• To generalize the Vertex Cover Above LP framework to a broad class of integer programs, specifically BIP2, enabling efficient parameterized solutions.
• To achieve linear-time complexity $O(4^k n)$ for key problems, improving upon prior algorithms with higher-degree polynomials or larger exponential factors.

Proposed method

• Introduce BIP2, a class of binary integer programs with constraints involving variables $x_i, x_j$ and single-use slack variables $z_{ij}$, to model problems like Vertex Cover and Almost 2-SAT.
• Reduce any BIP2 instance to Vertex Cover Above LP while preserving the parameter $k$, enabling use of known LP-based FPT techniques.
• Use network flow to compute and maintain an optimal LP solution for Vertex Cover Above LP in linear time, even after branching.
• Identify and remove tail strongly connected components in the residual graph that correspond to independent sets with equal weight to neighbors, allowing safe assignment of 0/1 values to variables.
• Update the optimal dual solution after each branching step by removing nodes and augmenting flow in the residual graph, leveraging half-integrality to bound update cost.
• Perform exhaustive search over variable assignments, using the fact that each augmentation step decreases $k$ by $\Delta/2$, ensuring the total number of recursive calls is bounded by $4^k$.

Experimental results

Research questions

• RQ1 Can we design FPT algorithms with both linear polynomial dependence on input size and single-exponential dependence on the parameter $k$ for fundamental NP-hard problems?
• RQ2 How can we efficiently maintain optimal LP solutions during exhaustive search in FPT algorithms without recomputing them from scratch at each step?
• RQ3 Is there a general framework for integer programs that allows linear-time reduction to Vertex Cover Above LP and efficient branching?
• RQ4 Can network flow techniques be used to update optimal dual solutions in linear time after variable fixing in parameterized integer programs?
• RQ5 What structural properties of the residual graph allow for efficient identification of safe variable assignments in the context of half-integral optimal solutions?

Key findings

• The paper achieves the first linear-time FPT algorithms for Odd Cycle Transversal and Almost 2-SAT, with runtime $O(4^k n)$, significantly improving upon prior $O(3^k knm)$ and $O(15^k km^3)$ bounds.
• The reduction from BIP2 to Vertex Cover Above LP preserves the parameter $k$, enabling the use of LP-based FPT techniques on a broad class of problems.
• The optimal LP solution for Vertex Cover Above LP can be maintained in linear time using network flow and residual graph decomposition, avoiding costly recomputation.
• The algorithm identifies and removes tail strongly connected components in the residual graph that correspond to safe 0/1 assignments, reducing the search space efficiently.
• The total cost of flow augmentation across all recursive calls is bounded by $O(4^k (|V| + |E|))$, ensuring the overall runtime remains linear in the input size.
• The method achieves a $4^k$ dependency on the parameter $k$, which is optimal for the current framework and improves upon prior $9^k$ and $15^k$ bounds for related problems.