Scalable Neighborhood Local Search for Single-Machine Scheduling with Family Setup Times

2024-09-01

arXiv.org

AI Summary

This paper addresses the single-machine scheduling problem with family setup times, aiming to minimize the makespan. The problem is NP-hard and highly relevant in industrial applications. We propose a scalable parameterized neighborhood local search heuristic. Specifically, we systematically characterize the computational complexity of k-neighborhood improvement under four natural distance metrics: we prove that two metrics admit fixed-parameter tractable (FPT) exact improvement algorithms, while the other two exhibit inherent computational lower bounds. Innovatively, our method integrates k-pair swaps and k-consecutive rearrangements as complementary neighborhood structures within a hill-climbing framework. Both theoretical analysis and extensive experiments on large-scale instances demonstrate that the algorithm achieves a superior balance between solution quality and computational efficiency.

Technology Category

• Search and Optimization: Mixed Discrete/Continuous Search
• Planning, Routing, and Scheduling: Learning for Planning and Scheduling
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Security and Privacy: Large-scale security measurements
• Search and Retrieval-Augmented AI: Efficiency and scalability of Web search engines

Abstract

In this work, we study the task of scheduling jobs on a single machine with sequence dependent family setup times under the goal of minimizing the makespan, that is, the completion time of the last job in the schedule. This notoriously NP-hard problem is highly relevant in practical productions and requires heuristics that provide good solutions quickly in order to deal with large instances. In this paper, we present a heuristic based on the approach of parameterized local search. That is, we aim to replace a given solution by a better solution having distance at most $k$ in a pre-defined distance measure. This is done multiple times in a hill-climbing manner, until a locally optimal solution is reached. We analyze the trade-off between the allowed distance $k$ and the algorithm's running time for four natural distance measures. Example of allowed operations for our considered distance measures are: swapping $k$ pairs of jobs in the sequence, or rearranging $k$ consecutive jobs. For two distance measures, we show that finding an improvement for given $k$ can be done in $f(k) cdot n^{mathcal{O}(1)}$ time, while such a running time for the other two distance measures is unlikely. We provide a preliminary experimental evaluation of our local search approaches.

Problem

• Minimize makespan in single-machine scheduling with family setup times
• Develop scalable heuristics for NP-hard scheduling problem
• Analyze trade-off between solution quality and running time

Innovation

• Parameterized local search heuristic
• Distance measures for solution improvement
• Efficient algorithms for large instances