Fixed-Parameter Linear-Time MaxCut

• Fixed-Parameter Linear-Time MaxCut is an algorithm that parameterizes above the Poljak-Turzík bound, offering a tighter guarantee for multigraphs and weighted graphs.
• It employs eight systematic reduction rules to transform the input into a uniform-clique–forest, enabling efficient dynamic programming on vertex weights.
• The approach improves upon earlier methods by achieving 2^{O(k)} · O(n + m) running time, making it highly applicable to network science, circuit design, and related fields.

MaxCut is a classical combinatorial optimization problem in which the goal is to partition the vertex set of an undirected graph (potentially a multigraph or a weighted graph) into two sets so as to maximize the sum of the weights of edges crossing the partition. Lower bounds on the achievable cut size play a crucial role in the parameterized analysis of MaxCut. The recently developed fixed-parameter tractable (FPT) algorithm for MaxCut parameterized above the Poljak-Turzík bound offers linear-time performance for multigraphs and positive integer-weighted graphs, significantly broadening the scope and improving upon prior results parameterized above the traditional Edwards-Erdős bound (Lill et al., 2024).

1. The Poljak-Turzík Bound and Its Role in Parameterization

The Poljak-Turzík bound asserts that any weighted graph $G$ admits a cut of size at least

$w(G)/2 + w_\text{MSF}(G)/4,$

where $w(G)$ is the total edge weight and $w_\text{MSF}(G)$ is the weight of a minimum spanning forest in $G$. While, in connected simple graphs, the Poljak-Turzík bound coincides with the Edwards-Erdős bound ($m/2 + (n-1)/4$ for $n$ vertices and $m$ edges), the Poljak-Turzík bound can be strictly superior for multigraphs or weighted graphs. This is due to the possibility that multiedges or weighted edges inflate $w(G)$ without proportionally increasing the MSF weight. Consequently, the parameter $k$ defined as the “excess” above the Poljak-Turzík bound ($k = s - \bigl(w(G)/2 + w_\text{MSF}(G)/4\bigr)$, where $s$ is the target cut size) is potentially smaller than the corresponding parameterization above the Edwards-Erdős bound, tightening the parameterized analysis.

2. Algorithmic Framework and Reduction Strategies

The FPT algorithm operates by systematically applying a set of eight reduction rules to the input weighted multigraph. These reduction rules serve two primary objectives: either (a) to certify that a cut meeting or exceeding the required size exists, or (b) to reduce the instance size by restricting attention to a small set $S$ of "marked" vertices with $|S| = O(k)$ such that the graph $G - S$ forms a uniform-clique–forest. This latter structure is a graph in which every biconnected block is a clique with all edges sharing the same weight. The refinement of the reduction rules is necessitated by the use of the Poljak-Turzík bound, since the impact on the minimum spanning forest weight is more delicate to track than in the simple Edwards-Erdős case. The reduction process is accomplished in $O(k \cdot m)$ time, where $m$ is the number of edges.

3. Solving the Reduced Instance: Dynamic Programming on Uniform-Clique–Forests

Once the reduction phase terminates and $G - S$ is a uniform–clique–forest, the problem is further reduced to the so-called MaxCut–With–Vertex–Weights instance. In this setting, each vertex is endowed with two weights, reflecting the cumulative influence from $S$ and the structure of the forest. The solution proceeds by exhaustively branching over all $2^{O(k)}$ possible assignments of the marked set $S$ to the two cut sides. For each such assignment, the residual MaxCut–With–Vertex–Weights problem on the uniform–clique–forest is solved via a dynamic programming algorithm that exploits the clique and forest structure; this is achievable in $O(n + m)$ time per assignment. The combination yields a total running time of $f(k) \cdot O(n + m)$ with $f(k) = 2^{O(k)}$.

4. Comparison to Previous Methods and Parameterizations

Earlier fixed-parameter algorithms for MaxCut parameterized above guarantee originated with Crowston, Jones, and Mnich (FPT above the Edwards-Erdős bound for simple graphs, $2^{O(k)} n^4$ time), and were refined by Etscheid and Mnich to achieve parameterized linear time for simple graphs ($2^{O(k)} m$) [Algorithmica, 2017]. The principal advancements in the present approach (Lill et al., 2024) are:

• Extension to multigraphs and positive integer-weighted graphs, rather than just simple graphs.
• Parameterization above the Poljak-Turzík bound, which is potentially tighter than the Edwards-Erdős bound for non-simple graphs.
• The necessity of more intricate reduction rules to maintain control over $w_\text{MSF}(G)$ during reductions, as opposed to the vertex-counting arguments sufficing under the Edwards-Erdős paradigm.

This results in broader applicability and, for certain instances, a provably smaller parameter $k$.

5. Theoretical Complexity and Guarantee

The main complexity result is that MaxCut in multigraphs (or weighted graphs) can be decided in

$2^{O(k)} \cdot O(n + m)$

time, given a target of $w(G)/2 + w_\text{MSF}(G)/4 + k$ for the cut size. The reduction phase strictly divides into steps that reduce $k$ and steps that only restructure the instance, but overall only $O(k)$ parameter-reducing steps are performed. Once the uniform–clique–forest structure is reached, branching over $2^{O(k)}$ assignments dominates the parameter-dependent part, with each assignment solved in linear time.

6. Applications and Consequences

The enhanced parameterization and tractable running time directly benefit instances arising in disciplines such as circuit design, network science, and statistical physics, all of which routinely produce multigraphs or weighted networks. The reliance on the Poljak-Turzík bound as the baseline cut guarantee enables the algorithm to handle a larger class of instances efficiently, especially when the parameter above guarantee $k$ is small. The reduction framework—culminating in a uniform–clique–forest and exploiting efficient dynamic programming—may be adaptable for other “parameterized above guarantee” scenarios within cut problems and related optimization domains.

7. Future Directions and Open Questions

Several generalizations and theoretical questions remain open:

• Extending the algorithmic schema to other $\lambda$-extendible properties parameterized above corresponding Poljak-Turzík-type bounds.
• Obtaining polynomial or linear kernels for multigraphs or positive-integer-weighted graphs remains unresolved, in contrast to kernelization results for the simple graph case.
• Incorporating even stronger lower bounds (such as those based on maximum matchings or alternative spanning tree structures) as the parameterization baseline could further reduce $k$ and possibly yield more efficient algorithms; the challenge remains due to the computational difficulty of exactly evaluating such bounds.
• Generalization to graphs with real-valued positive weights introduces further hurdles, particularly for defining a discrete decrement in the parameter $k$ during reductions and branching.

These avenues underscore the ongoing evolution of FPT and parameterized linear-time techniques in combinatorial optimization.

---

Summary Table: Comparison of MaxCut FPT Algorithms Above Guarantee

Reference	Graph Type	Guarantee Bound	Parameter $k$	Running Time
Crowston-Jones-Mnich	Simple graphs	Edwards-Erdős	Above $m/2 + (n-1)/4$	$2^{O(k)} n^4$
Etscheid-Mnich	Simple graphs	Edwards-Erdős	Above $m/2 + (n-1)/4$	$2^{O(k)} (m+n)$
(Lill et al., 2024)	Multigraphs, integer weights	Poljak-Turzík ($w/2+w_{MSF}/4$)	Above $w/2 + w_{MSF}/4$	$2^{O(k)} (m+n)$

Note: $w_{MSF}(G)$ is the weight of a minimum spanning forest in $G$. For multigraphs and weighted graphs, the Poljak-Turzík bound can be strictly larger, yielding tighter parameterizations.