New Algorithm for Combinatorial $n$-folds and Applications

TL;DR

The paper addresses combinatorial $n$-fold ILPs in which the lower blocks are row vectors of ones, introducing a divide-and-conquer DP that progressively reduces the right-hand side and bounds the set of candidate RHS values. By solving small, structured subproblems and intelligently recombining their solutions, the authors obtain a feasibility and optimization algorithm with running time $ (n r Δ)^{O(r)} \log(b_{ ext{def}})$, where $Δ$ is the maximum coefficient and $b_{ ext{def}}$ is a problem-definable bound. The method includes a linear-time reduction to the non-negative case to handle general instances and extends naturally to maximize linear objectives via max-plus convolution. The approach yields strong results across applications like scheduling on uniform machines (matching ETH lower bounds in certain settings), Closest String (efficient when the number of column-types is bounded), and Imbalance (improved parameter dependence on vertex cover), illustrating practical impact for structured ILPs. Overall, the work provides a novel, scalable framework for solving combinatorial $n$-fold ILPs with bounded RHS and demonstrates competitive performance in key combinatorial optimization problems.

Abstract

Block-structured integer linear programs (ILPs) play an important role in various application fields. We address $n$-fold ILPs where the matrix $\mathcal{A}$ has a specific structure, i.e., where the blocks in the lower part of $\mathcal{A}$ consist only of the row vectors $(1,\dots,1)$. In this paper, we propose an approach tailored to exactly these combinatorial $n$-folds. We utilize a divide and conquer approach to separate the original problem such that the right-hand side iteratively decreases in size. We show that this decrease in size can be calculated such that we only need to consider a bounded amount of possible right-hand sides. This, in turn, lets us efficiently combine solutions of the smaller right-hand sides to solve the original problem. We can decide the feasibility of, and also optimally solve, such problems in time $(n r Δ)^{O(r)} \log(\|b\|_\infty),$ where $n$ is the number of blocks, $r$ the number of rows in the upper blocks and $Δ=\|A\|_\infty$. We complement the algorithm by discussing applications of the $n$-fold ILPs with the specific structure we require. We consider the problems of (i) scheduling on uniform machines, (ii) closest string and (iii) (graph) imbalance. Regarding (i), our algorithm results in running times of $p_{\max}^{O(d)}|I|^{O(1)},$ matching a lower bound derived via ETH. For (ii) we achieve running times matching the current state-of-the-art in the general case. In contrast to the state-of-the-art, our result can leverage a bounded number of column-types to yield an improved running time. For (iii), we improve the parameter dependency on the size of the vertex cover.

Figures (2)

• Figure 1: Example of the procedure with four iterations. The continuous (blue) arrows indicate a feasible upper RHS of the sub-problem in the current iteration. The dashed (red) arrows double the intermediate solution of the previous iteration.
• Figure 2: Zoom in on a single iteration $i$ including an illustration of the designation of the upper RHS $b^{\uparrow (i-1)}, \hat{b}^{\uparrow (i)}, \tilde{b}^{\uparrow (i)}$ and $b^{\uparrow (i)}$ and the upper bound $D$ of the box sizes and $\|\tilde{b}^{\uparrow (i)}\|_\infty$.

Theorems & Definitions (28)

• Theorem 1
• Theorem 2
• Corollary 2
• Corollary 2
• Lemma 3
• Lemma 3
• Lemma 3
• Lemma 3
• Lemma 3
• Lemma 3