Lawler-Moore Speedups via Additive Combinatorics

2026-04-15

AI Summary

This work addresses the computational bottleneck of the classic Lawler–Moore dynamic programming algorithm for parallel machine scheduling, whose runtime heavily depends on the total processing time $P$. By integrating additive combinatorics–inspired exchange arguments and a novel state-pruning mechanism, the authors reformulate the dynamic programming framework. The key insight is proving that, in any optimal schedule, the load difference across machines within any prefix is bounded by $4p_{\max}^2$, where $p_{\max}$ denotes the maximum job processing time. This bound enables a complexity shift from dependence on $P$ to dependence solely on $p_{\max}^2$. Consequently, the algorithm achieves runtimes of $O(p_{\max}^{2m-2}n)$ for objectives $\sum w_jC_j$ and $L_{\max}$, and $O(p_{\max}^{2m-2}Pn)$ for $\sum w_jU_j$. The approach significantly outperforms the original when $p_{\max}=o(\sqrt{P})$, and for the first time yields near-linear-time solutions when $p_{\max}=\text{polylog}(n)$.

Technology Category

• Planning, Routing, and Scheduling: Learning for Planning and Scheduling
• Search and Optimization: Combinatorial Optimization
• Machine Learning: Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Responsible Web: Human-perceived consequences of algorithmic deployment on the web
• Economics, Online Markets and Human Computation: Incentives in network design for Web infrastructures and ecosystems

Abstract

The Lawler-Moore dynamic programming framework is a classical tool in scheduling on parallel machines. It applies when the objective is regular, i.e. monotone in job completion times, and each machine follows a fixed priority order such as Smith's Rule or Jackson's Rule. For the basic objectives $Pm||\sum w_jC_j$, $Pm||L_{\max}$, and $Pm||\sum w_jU_j$, it gives running times $O(P^{m-1}n)$, $O(P^{m-1}n)$, and $O(P^mn)$, respectively, where $P$ is the total processing time. Recent SETH-based lower bounds indicate that the dependence on $P$ is essentially optimal, but they do not rule out improved dependence on the maximum processing time $p_{\max}$. We give the first major speedup of the Lawler-Moore recurrence. Our main ingredients are a new state-pruning method and a swapping argument based on an additive-combinatorial lemma. We prove that, whenever this swap does not increase the objective value, there exists an optimal schedule in which, for every prefix of jobs, the load difference between any two machines is at most $4p_{\max}^2$. This lets us prune redundant states throughout the dynamic program, replacing the dependence on $P$ by a dependence on $p_{\max}^2$. We show that the swap is non-increasing for all three objectives above. Hence $Pm||\sum w_jC_j$ and $Pm||L_{\max}$ admit algorithms with running time $O(p_{\max}^{2m-2}n)$, while $Pm||\sum w_jU_j$ can be solved in time $O(p_{\max}^{2m-2}Pn)\le O(p_{\max}^{2m-1}n^2)$. These bounds strictly improve the original Lawler-Moore runtimes whenever $p_{\max}=o(\sqrt{P})$. In particular, for $Pm||\sum w_jC_j$ and $Pm||L_{\max}$, we obtain the first near-linear-time algorithms when processing times are polylogarithmic in $n$.

Problem

• scheduling
• parallel machines
• dynamic programming
• Lawler-Moore
• additive combinatorics

Innovation

• Lawler-Moore speedup
• additive combinatorics
• state pruning
• scheduling on parallel machines
• parameterized complexity