Francis Sourd

The One-Machine Problem with Earliness and Tardiness Penalties

We address the one-machine problem in which the jobs have distinct due dates, earliness costs, and tardiness costs. In order to determine the minimal cost of such a problem, a new lower bound is proposed. It is based on the decomposition of each job in unary operations that are then assigned to the time slots, which gives a preemptive schedule. Assignment costs are defined so that the minimum assignment cost is a valid lower bound. A branch-and-bound algorithm based on this lower bound and on some new dominance rules is experimentally tested.

A Multiobjective Branch-and-Bound Framework: Application to the Biobjective Spanning Tree Problem

This paper focuses on a multiobjective derivation of branch-and-bound procedures. Such a procedure aims to provide the set of Pareto-optimal solutions of a multiobjective combinatorial optimization problem. Unlike previous works on this issue, the bounding is performed here via a set of points rather than a single ideal point. The main idea is that a node in the search tree can be discarded if one can define a separating hypersurface in the objective space between the set of feasible solutions in the subtree and the set of points corresponding to potential Pareto-optimal solutions. Numerical experiments on the biobjective spanning tree problem are provided that show the efficiency of the approach in a biobjective setting.

Lower bounds for the earliness–tardiness scheduling problem on parallel machines with distinct due dates

This paper addresses the parallel machine scheduling problem in which the jobs have distinct due dates with earliness and tardiness costs. New lower bounds are proposed for the problem, they can be classed into two families. First, two assignment-based lower bounds for the one-machine problem are generalized for the parallel machine case. Second, a time-indexed formulation of the problem is investigated in order to derive efficient lower bounds throught column generation or Lagrangean relaxation. A simple local search algorithm is also presented in order to derive an upper bound. Computational experiments compare these bounds for both the one machine and parallel machine problems and show that the gap between upper and lower bounds is about 1.5%.

Efficient neighborhood search for the one-machine earliness-tardiness scheduling problem

Abstract This paper addresses the one-machine scheduling problem where the objective is to minimize a sum of costs such as earliness–tardiness costs. Since the sequencing problem is NP-hard, local search is very useful for finding good solutions. Unlike scheduling problems with regular cost functions, the scheduling (or timing) problem is not trivial when the sequence is fixed. Therefore, the local search approaches must deal with both job interchanges in the sequence and the timing of the sequenced jobs. We present a new approach that efficiently searches in a large neighborhood and always returns a solution for which the timing is optimal.

Earliness-tardiness scheduling with setup considerations

The one-machine scheduling problem with sequence-dependent setup times and costs and earliness-tardiness penalties is addressed. A time-indexed formulation of the problem is presented as well as different relaxations that give lower bounds of the problem. Then, a branch-and-bound procedure based on one of these lower bounds is presented. The efficiency of this algorithm also relies on new dominance rules and on a heuristic to derive good feasible schedules. Computational tests are finally presented.

PERT scheduling with convex cost functions

This paper deals with the problem of finding a minimum cost schedule for a set of dependent activities when a convex cost function is attached to the starting time of each activity. A first optimality necessary and sufficient condition bearing on the head and tail blocks of a schedule is first established. A second such condition that uses the spanning active equality trees of a schedule leads to design a generic algorithm for the general case. When the cost function is the usual earliness-tardiness linear function with assymetric and independent penalty coefficients, the problem is shown to be solved in O(n max{n,m}). Finally, the special cases when the precedence graph is an intree or a family of chains are then also shown to be solved by efficient polynomial algorithms.

An improved earliness-tardiness timing algorithm

Earliness-tardiness criteria with distinct due dates usually induce NP-complete problems. Researchers have focused on particular cases like the timing problem, which is to look for the optimal schedule when the jobs sequence is already known. These timing algorithms are very useful since they can be used in more complex procedures. In the first part of this paper we provide the most efficient and fairly general algorithm to solve the one-machine timing problem. It is then adapted to a permutation flow shop problem.

Optimal timing of a sequence of tasks with general completion costs

Scheduling a sequence of tasks––in the acceptation of finding the execution times––is not a trivial problem when the optimization criterion is irregular as for instance in earliness–tardiness problems. This paper presents an efficient dynamic programming algorithm to solve the problem with general cost functions depending on the end time of the tasks, idle time costs and variable durations also depending on the execution time of the tasks. The algorithm is also valid when the precedence graph is a tree and it can be adapted to determine the possible execution windows for each task not exceeding a maximum fixed cost.

Dynasearch for the earliness-tardiness scheduling problem with release dates and setup constraints

A large dynasearch neighborhood is introduced for the one-machine scheduling problem with sequence-dependent setup times and costs and earliness-tardiness penalties. Finding the best schedule in this neighborhood is NP-complete in the ordinary sense but can be done in pseudo-polynomial time. We also present experimental results.

The complexity of mean flow time scheduling problems with release times

We study the problem of preemptive scheduling of n} jobs with given release times on m identical parallel machines. The objective is to minimize the average flow time. In this paper, show that when all jobs have equal processing times then the problem can be solved in polynomial time using linear programming. Our algorithm can also be applied to the open-shop problem with release times and unit processing times. For the general case (when processing times are arbitrary), we show that the problem is unary NP-hard.