Han Hoogeveen

Scheduling a batching machine

textabstractWe study the problem of scheduling a chain-reentrant shop, in which each job goes for its processing first to a machine called the primary machine, then to a number of other machines in a fixed sequence, and finally back to the primary machine for its last operation. The problem is to schedule the jobs so as to minimize the makespan. This problem is unary NP-hard for a general number of machines. We focus in particular on the two-machine case that is also at least binary NP-hard. We prove some properties that identify a specific class of optimal schedules, and then use these properties in designing an approximation algorithm and a branch-and-bound type optimization algorithm. The approximation algorithm, of which we present three versions, has a worst-case performance guarantee of f32 along with an excellent empirical performance. The optimization algorithm solves large instances quickly. Finally, we identify a few well solvable special cases and present a pseudo-polynomial algorithm for the case in which the first and the last operations of any job (on the primary machine) are identical.

Optimal On-Line Algorithms for Single-Machine Scheduling

We consider single-machine on-line scheduling problems where jobs arrive over time. A set of independent jobs has to be scheduled on the machine, where preemption is not allowed and the number of jobs is unknown in advance. Each job becomes available at its release date, which is not known in advance, and its characteristics, e.g., processing requirement, become known at its arrival. We deal with two problems: minimizing total completion time and minimizing the maximum time by which all jobs have been delivered. For both problems we propose and analyze an on-line algorithm based on the following idea: As soon as the machine becomes available for processing, choose an available job with highest priority, and schedule it if its processing requirement is not too large. Otherwise, postpone the start of this job for a while. We prove that our algorithms have performance bound 2 and (√5 + 1)/2, respectively, and we show that for both problems there cannot exist an on-line algorithm with a better performance guarantee.

Non-Approximability Results for Scheduling Problems with Minsum Criteria

We provide several non-approximability results for deterministic scheduling problems whose objective is to minimize the total job completion time. Unless , none of the problems under consideration can be approximated in polynomial time within arbitrarily good precision. Most of our results are derived by APX-hardness proofs.We show that, whereas scheduling on unrelated machines with unit weights is polynomially solvable, the problem becomes APX-hard if release dates or weights are added. We further show APX-hardness for scheduling in flow shops, job shops, and open shops. We also investigate the problems of scheduling on parallel machines with precedence constraints and unit processing times, and two variants of the latter problem with unit communication delays; for these problems we provide lower bounds on the worst-case behavior of any polynomial-time approximation algorithm through the gap-reduction technique.

Preemptive scheduling with rejection

Abstract. We consider the problem of preemptively scheduling a set of n jobs on m (identical, uniformly related, or unrelated) parallel machines. The scheduler may reject a subset of the jobs and thereby incur job-dependent penalties for each rejected job, and he must construct a schedule for the remaining jobs so as to optimize the preemptive makespan on the m machines plus the sum of the penalties of the jobs rejected. We provide a complete classification of these scheduling problems with respect to complexity and approximability. Our main results are on the variant with an arbitrary number of unrelated machines. This variant is APX-hard, and we design a 1.58-approximation algorithm for it. All other considered variants are weakly -hard, and we provide fully polynomial time approximation schemes for them. Finally, we argue that our results for unrelated machines can be carried over to the corresponding preemptive open shop scheduling problem with rejection.

Minimizing Makespan in a Two-Machine Flow Shop with Delays and Unit-Time Operations is NP-Hard

One of the first problems to be studied in scheduling theory was the problem of minimizing the makespan in a two-machine flow shop. Johnson showed that this problem can be solved in O(n log n) time. A crucial assumption here is that the time needed to move a job from the first to the second machine is negligible. If this is not the case and if this ‘delay’ is not equal for all jobs, then the problem becomes NP-hard in the strong sense. We show that this is even the case if all processing times are equal to one. As a consequence, we show strong NP-hardness of a number of similar problems, including a severely restricted version of the Numerical 3-Dimensional Matching problem.

On-line scheduling on a single machine: maximizing the number of early jobs

This note deals with the scheduling problem of maximizing the number of early jobs on a single machine. We investigate the on-line version of this problem in the Preemption-Restart model. This means that jobs may be preempted, but preempting results in all the work done on this job so far being lost. Thus, if the job is restarted, then it has to be done from scratch. We prove that the shortest remaining processing time (SRPT) rule yields an on-line algorithm with competitive ratio 12. Moreover, we show that there does not exist an on-line algorithm with a better performance guarantee.

Preemptive Scheduling with Rejection

We consider the problem of preemptively scheduling a set of n jobs on m (identical, uniformly related, or unrelated) parallel machines. The scheduler may reject a subset of the jobs and thereby incur job-dependent penalties for each rejected job, and he must construct a schedule for the remaining jobs so as to optimize the preemptive makespan on the m machines plus the sum of the penalties of the jobs rejected. We provide a complete classification of these scheduling problems with respect to complexity and approximability. Our main results are on the variant with an arbitrary number of unrelated machines. This variant is APX-hard, and we design a 1.58-approximation algorithm for it. All other considered variants are weakly NP-hard, and we provide fully polynomial time approximation schemes for them.

Non-approximability Results for Scheduling Problems with Minsum Criteria

We provide several non-approximability results for deterministic scheduling problems whose objective is to minimize the total job completion time. Unless P = NP, none of the problems under consideration can be approximated in polynomial time within arbitrarily good precision. Most of our results are derived by Max SNP hardness proofs. Among the investigated problems are: scheduling unrelated machines with some additional features like job release dates, deadlines and weights, scheduling flow shops, and scheduling open shops.

Some comments on sequencing with controllable processing times

We discuss sequencing problems on a single machine with controllable job processing times. For the maximum job cost criterion, we present several polynomial time results. For the total weighted job completion time criterion, we present an NP-hardness result. Our results settle several open questions in this area.

Combining Column Generation and Lagrangean Relaxation to Solve a Single-Machine Common Due Date Problem

Column generation has proved to be an effective technique for solving the linear programming relaxation ofhuge set covering or set partitioning problems, and column generation approaches have led to state-of-the-art so-called branch-and-price algorithms for various archetypical combinatorial optimization problems. We use a combination of column generation and Lagrangean relaxation to tackle a single-machine common due date problem, where Lagrangean relaxation is exploited for early termination of the column generation algorithm and for speeding up the pricing algorithm. We show that the Lagrangean lower bound dominates the lower bound that can be derived from the column generation algorithm when applied to the standard linear programming formulation, but we also show how the linear programming formulation can be adapted such that the corresponding lower bound is equal to the Lagrangean lower bound.Our comprehensive computational study shows that the combined algorithm is by far superior to two existing purely column generation algorithms: it solves instances with up to 125 jobs to optimality, while a purely column generation algorithm can solve instances with up to only 60 jobs.