J.A. Hoogeveen

Short Shop Schedules

We consider the open shop, job shop, and flow shop scheduling problems with integral processing times. We give polynomial-time algorithms to determine if an instance has a schedule of length at most 3, and show that deciding if there is a schedule of length at most 4 is 𝒩𝒫-complete. The latter result implies that, unless 𝒫 = 𝒩𝒫, there does not exist a polynomial-time approximation algorithm for any of these problems that constructs a schedule with length guaranteed to be strictly less than 5/4 times the optimal length. This work constitutes the first nontrivial theoretical evidence that shop scheduling problems are hard to solve even approximately.

Preemptive scheduling in a two-stage multiprocessor flow shop is NP-hard

In 1954, Johnson gave an efficient algorithm for minimizing makespan in a two-machine flow shop; there is no advantage to preemption in this case. McNaughtons wrap-around rule of 1959 finds a shortest preemptive schedule on identical parallel machines in linear time. A similarly efficient algorithm is unlikely to exist for the simplest common generalization of these problems. We show that preemptive scheduling in a two-stage flow shop with at least two identical parallel machines in one of the stages so as to minimize makespan is NP-hard in the strong sense.

Scheduling multipurpose batch process industries with no-wait restrictions by simulated annealing

Scheduling problems in multipurpose batch process industries are very hard to solve because of the job shop like processing structure in combination with rigid technical constraints, such as no-wait restrictions. This paper shows that scheduling problems in this type of industry may be characterized as multiprocessor no-wait job shop problems with overlapping operations. A simulated annealing algorithm is proposed that obtains near-optimal solutions with respect to makespan. This paper shows that the no-wait restrictions require several adaptations of the neighborhood structure used by simulated annealing. The performance of the algorithm is evaluated by scheduling industrial instances from a multipurpose batch plant in the pharmaceutical industry. Our results indicate that simulated annealing consistently gives better results for a number of realistic instances than simple heuristics within acceptable computation time.

Complexity of scheduling multiprocessor tasks with prespecified processor allocations

We investigate the computational complexity of scheduling multiprocessor tasks with prespecified processor allocations. We consider two criteria: minimizing schedule length and minimizing the sum of the task completion times. In addition, we investigate the complexity of problems when precedence constraints or release dates are involved.

Parallel Machine Scheduling by Column Generation

Parallel machine scheduling problems concern the scheduling of n jobs on m machines to minimize some function of the job completion times. If preemption is not allowed, then most problems are not only NP-hard, but also very hard from a practical point of view. In this paper, we show that strong and fast linear programming lower bounds can be computed for an important class of machine scheduling problems with additive objective functions. Characteristic of these problems is that on each machine the order of the jobs in the relevant part of the schedule is obtained through some priority rule. To that end, we formulate these parallel machine scheduling problems as a set covering problem with an exponential number of binary variables, n covering constraints, and a single side constraint. We show that the linear programming relaxation can be solved efficiently by column generation because the pricing problem is solvable in pseudo-polynomial time. We display this approach on the problem of minimizing total weighted completion time on m identical machines. Our computational results show that the lower bound is singularly strong and that the outcome of the linear program is often integral. Moreover, they show that our branch-and-bound algorithm that uses the linear programming lower bound outperforms the previously best algorithm.

Scheduling around a small common due date

A set of n jobs has to be scheduled on a single machine which can handle only one job at a time. Each job requires a given positive uninterrupted processing time and has a positive weight. The problem is to find a schedule that minimizes the sum of weighted deviations of the job completion times from a given common due date d, which is smaller than the sum of the processing times. We prove that this problem is NP-hard even if all job weights are equal. In addition, we present a pseudopolynomial algorithm that requires O(n2d) time and O(nd) space.

Minimizing total completion time and maximum cost simultaneously is solvable in polynomial time

We prove that the bicriteria single-machine scheduling problem of minimizing total completion time and maximum cost simultaneously is solvable in polynomial time. Our result settles a long-standing open problem.

Minimizing Total Completion Time in a Two-Machine

We consider the problem of minimizing total completion time in a two-machine owshop. We present a heuristic with worst-case bound 2β/(α + β), where α and β denote the minimum and maximum processing time of all operations. Furthermore, we analyze four special cases: equal processing times on the first machine, equal processing times on the second machine, processing a job on the first machine takes time no less than its processing on the second machine, and processing a job on the first machine takes time no more than its processing on the second machine. We prove that the rst special case is NP-hard in the strong sense and present an O(n log n) approximation algorithm for it with worst-case bound 4/3. We repeat the easy polynomial algorithms for the cases two and three, and show that problem four is solvable in polynomial time as well.

A branch-and-bound algorithm for single-machine earliness-tardiness scheduling with idle time

We address the NP-hard single-machine problem of scheduling n independent jobs so as to minimize the sum of α times total completion time and β times total earliness with β > α, which can be rewritten as an earliness–tardiness problem. Postponing jobs by leaving the machine idle may then be advantageous. The allowance of machine idle time between the execution of jobs singles out our problem from most concurrent research on problems with earliness penalties. Solving the problem to optimality poses a computational challenge, since the possibility of leaving the machine idle has a major effect on designing a branch-and-bound algorithm in general, and on computing lower bounds in particular. We present a branch-and-bound algorithm which is based upon many dominance rules and various lower bound approaches, including relaxation of the machine capacity, data manipulation, and Lagrangian relaxation. The algorithm is shown to solve small instances with up to 20 jobs.

Stronger Lagrangian bounds by use of slack variables: applications to machine scheduling problems

Lagrangian relaxation is a powerful bounding technique that has been applied successfully to manyNP-hard combinatorial optimization problems. The basic idea is to see anNP-hard problem as an “easy-to-solve” problem complicated by a number of “nasty” side constraints. We show that reformulating nasty inequality constraints as equalities by using slack variables leads to stronger lower bounds. The trick is widely applicable, but we focus on a broad class of machine scheduling problems for which it is particularly useful. We provide promising computational results for three problems belonging to this class for which Lagrangian bounds have appeared in the literature: the single-machine problem of minimizing total weighted completion time subject to precedence constraints, the two-machine flow-shop problem of minimizing total completion time, and the single-machine problem of minimizing total weighted tardiness.