The Maximum Cardinality Cut Problem is Polynomial in Proper Interval Graphs

It is known that the maximum cardinality cut problem is NP-hard even in chordal graphs. In this paper, we consider the time complexity of the problem in proper interval graphs, a subclass of chordal graphs, and propose a dynamic programming algorithm which runs in polynomial-time.

💡 Research Summary

The paper addresses the computational status of the Maximum Cardinality Cut (Max‑Cut) problem on proper interval graphs, a well‑studied subclass of chordal graphs. While Max‑Cut is known to be NP‑hard on chordal graphs and many other graph families, polynomial‑time algorithms exist for planar graphs, line graphs, and graphs that can be reduced to bounded‑treewidth structures. Proper interval graphs, however, are neither planar nor line graphs, and they are not guaranteed to be factorable into bounded‑treewidth components; consequently, the complexity of Max‑Cut on this class remained open.

The authors resolve this open question by exploiting the “bubble model” representation of proper interval graphs introduced by Heggernes et al. (2009). In this representation, vertices are organized into a two‑dimensional array of bubbles B_{i,j}, where i indexes rows and j indexes columns. Two vertices are adjacent if they belong to the same column or to consecutive columns with the row index of the left vertex smaller than that of the right vertex. This model is equivalent to proper interval graphs, can be constructed in O(n²) time, and contains O(n²) bubbles.

The key insight is that consecutive columns of the bubble model induce co‑bipartite chain graphs, so the whole graph can be viewed as a chain of such graphs. The authors define a subgraph G_{i,j} consisting of the first i rows of column j together with all vertices in columns j+1,…,k+1 (where k is the total number of columns). For any cut S of G_{i,j}, they track two parameters: x = |S ∩ C_j| and x′ = |S ∩ C_{j+1}|, where C_j is the union of all bubbles in column j. They then define a dynamic‑programming table F_{i,j}(x, x′) as the maximum cut size achievable in G_{i,j} under these constraints.

A recurrence is derived:

1. Base case: F_{0,k+1}(0,0)=0 because the rightmost auxiliary column is empty.
2. For a column j, the optimal value F_{0,j}(0,0) is obtained by enumerating all possible (s_j, s_{j+1}) assignments for the next column and taking the maximum of F_{r_j+1,j+1}(s_j, s_{j+1}).
3. For a bubble B_{i,j}, the cut contribution is split into four parts: edges inside the previous subgraph, edges inside the bubble (a complete graph), edges between the bubble and the preceding column j, and edges between the bubble and column j+1. Because every vertex of B_{i,j} is adjacent to all vertices of the two neighboring columns, the sizes of these edge sets can be expressed as simple linear functions of s_{i,j}, s_{i,j+1}, x, x′, and the bubble sizes b_{i,j}, b_{i,j+1}.
4. The recurrence for F_{i,j}(x, x′) therefore maximizes over all feasible s_{i,j} and s_{i,j+1} (subject to natural bounds) the expression: F_{i‑1,j}(x−s_{i,j}, x′−s_{i,j+1}) + (terms derived from the four edge sets).

The feasible ranges for s_{i,j} and s_{i,j+1} are bounded by the bubble size and the remaining quota of vertices that must be placed in the current column, leading to a double loop over at most b_{i,j}·b_{i,j+1} possibilities for each (i,j) pair.

Algorithmically, the authors scan columns from right to left and rows within each column from top to bottom, filling the DP table according to the recurrence. The auxiliary functions SummarizeColumn and CalculateOpt implement steps (2) and (3) respectively. The total number of DP states is O(∑j c_j²), where c_j = |C_j|, and each state is processed in O(b{i,j}·b_{i,j+1}) time. Since both the number of bubbles and the column sizes are bounded by O(n), the overall running time is bounded by O(n⁴). The authors prove correctness by showing that F_{0,0}(0,0) equals the maximum cut size of the original graph, and they verify that the recurrence captures all possible cuts without omission.

The paper’s contributions are threefold:

• It provides the first polynomial‑time algorithm for Max‑Cut on proper interval graphs, establishing that the problem is tractable on this important subclass of chordal graphs.
• It extends the dynamic‑programming technique previously applied only to co‑bipartite chain graphs (the authors’ own earlier work) to the more general bubble‑model structure, thereby handling a richer class of graphs.
• It demonstrates that the bubble model, despite having O(n²) bubbles, can be leveraged efficiently: the preprocessing to obtain the model is O(n²), and the DP runs in O(n⁴), which is feasible for moderate‑size instances.

The authors discuss potential extensions, such as exploiting more compact representations of the bubble model to improve the O(n⁴) bound, or adapting the framework to related NP‑hard problems like Max‑Bisection or Minimum Cut on proper interval graphs. They also suggest that the structural decomposition into co‑bipartite chain components might be useful for designing approximation algorithms or for parameterized complexity analyses.

In summary, the paper resolves a longstanding open question by showing that Max‑Cut on proper interval graphs can be solved exactly in polynomial time using a bubble‑model‑based dynamic programming approach with O(n⁴) runtime. This result enriches the landscape of graph classes where Max‑Cut is tractable and opens avenues for further algorithmic developments on interval‑type graphs.