Optimal Cuts and Bisections on the Real Line in Polynomial Time

The exact complexity of geometric cuts and bisections is the longstanding open problem including even the dimension one. In this paper, we resolve this problem for dimension one (the real line) by designing an exact polynomial time algorithm. Our results depend on a new technique of dealing with metric equalities and their connection to dynamic programming. The method of our solution could be also of independent interest.

💡 Research Summary

The paper tackles a long‑standing open question in geometric graph partitioning: the exact computational complexity of MAX‑CUT, MAX‑BISECTION, MIN‑PARTITION and MIN‑BISECTION when the underlying metric is the one‑dimensional Euclidean space (the real line). While polynomial‑time approximation schemes (PTAS) are known for these problems on general metric spaces, their exact status even in one dimension had remained unresolved. The authors present the first exact polynomial‑time algorithms for all four problems on the line, achieving an O(n⁴) running time, where n is the total number of points (counting multiplicities).

Problem formulation.
The input is a finite multiset P of real numbers. A cut is defined by partitioning P into two multisets P₁ and P₂; the value of the cut equals the sum of Euclidean distances between every pair (a,b) with a∈P₁ and b∈P₂. MAX‑CUT asks for a partition maximizing this sum; MAX‑BISECTION adds the constraint |P₁|=|P₂|=n/2. MIN‑PARTITION and MIN‑BISECTION are the analogous minimization versions, possibly with a prescribed cardinality split (k, n−k).

Key insight – metric equalities.
On the line the distance between two points is simply the absolute difference, and the triangle equality holds with equality: for any three ordered points x_{i‑1} ≤ x_i ≤ x_{i+1}, we have x_{i+1}‑x_{i‑1} = (x_{i+1}‑x_i) + (x_i‑x_{i‑1}). This property allows the contribution of a pair of points to be expressed as a linear combination of the distances between consecutive distinct values. By grouping identical coordinates into “copies”, the authors can treat the multiset as a sequence of distinct values x₁ < x₂ < … < x_l, each with a certain multiplicity.

Dynamic programming framework.
The algorithm defines a family of subproblems S_i(p,q,r,t) for the maximization case. Here:

• i ∈ {1,…,l} indicates that we are currently processing the i‑th distinct value x_i.
• p and q are the numbers of copies of the first i‑1 values that have already been placed in the first and second partitions, respectively (so p+q = |P_{i‑1}|).
• r and t are the numbers of copies of x_i that will be placed in the first and second partitions (so r+t = n‑|P_{i‑1}|).

The goal of S_i(p,q,r,t) is to maximize the cut value under these constraints. Lemma 1 gives the exact recurrence:

MAXCUT(S_i(p,q,r,t)) =
    (x_i – x_{i‑1})·(p·t + q·r) +
    max_{0≤r₀≤p, 0≤t₀≤q, r₀+t₀ = |P_{i‑1}| – |P_{i‑2}|}
        MAXCUT(S_{i‑1}(p‑r₀, q‑t₀, r₀+r, t₀+t)).

The term (x_i – x_{i‑1})(p·t + q·r) captures precisely the additional contribution created when the r copies of x_i are placed opposite the q copies of earlier points, and the t copies of x_i are placed opposite the p earlier points. The maximization over (r₀,t₀) enumerates all possible ways the copies of the previous distinct value x_{i‑1} could have been split between the two sides.

Because p, q, r, t each range from 0 to n, there are O(n³) distinct states (i contributes a factor ≤ n). For each state the inner maximization iterates over at most O(n) possibilities for (r₀,t₀), leading to O(n⁴) total time. The DP is filled bottom‑up: S₁ is trivial (no earlier values), and each subsequent layer uses the already computed values of S_{i‑1}.

The maximization framework directly yields MAX‑BISECTION by restricting to states where p+r = n/2 (the size of the first partition). Similarly, the authors define a minimization counterpart U_i(p,q,r,t) with an analogous recurrence (Lemma 2) where the outer max is replaced by a min. This solves MIN‑PARTITION and MIN‑BISECTION in the same O(n⁴) time bound.

Correctness and reconstruction.
The authors prove both directions of the recurrence: any optimal solution for S_i can be transformed into a feasible solution for S_{i‑1} with the stated loss/gain of (x_i – x_{i‑1})(p·t + q·r), and conversely any optimal solution for S_{i‑1} can be extended to a feasible solution for S_i achieving the same bound. Hence the DP computes the exact optimum. After the DP table is filled, a standard back‑tracking step recovers the actual partition.

Complexity analysis.

• Number of distinct values l ≤ n.
• For each i, the number of (p,q) pairs is O(n) (since p+q = |P_{i‑1}|) and similarly for (r,t). Hence O(n³) total states.
• Transition cost per state is O(n) (enumerating r₀,t₀).
• Overall time O(n⁴), space O(n³) (or O(n²) with careful compression).

Discussion and open problems.
The technique crucially relies on the linear order of points and the exact triangle equality on the line. Extending the method to higher dimensions would require handling more complex distance relationships, and the authors leave this as an open challenge. They also note that the exact status of many other geometric optimization problems remains unknown, suggesting that the “metric‑equality‑driven DP” could inspire further breakthroughs.

In summary, the paper resolves the exact complexity of several fundamental partition problems on the real line, presenting a clear O(n⁴) dynamic programming algorithm based on a novel exploitation of metric equalities. This result closes a long‑standing gap between approximation and exact computation in one‑dimensional geometric optimization.