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

https://doi.org/10.1016/j.ejor.2006.05.052Get rights and content

Abstract

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%.

Introduction

The 20-year old emphasis on the Just-in-Time policy in industry has motivated the study of theoretical scheduling models able of capturing the main features of this philosophy. Among these models, a lot of research effort was devoted to earliness–tardiness problems – where both early completion (which results in the need for storage) and tardy completion are penalized. However, as shown by the recent surveys of T’kindt and Billaut [30] and Hoogeveen [14], most of this effort was dedicated to the one-machine problem. In this paper, we consider the earliness–tardiness problem in a parallel machine environment.

The jobs of a set J={1,,n} are to be scheduled on a set of m identical machines. The single-machine case (m = 1) will be considered in the computational tests but no specific result is presented for this case. Let pj and rj, respectively denote the processing time and the release date for job j. Each job j has also a distinct due date djrj. In any feasible schedule, Cj is the completion time of job j. If Cj>dj, the job is said to be tardy and the tardiness is penalized by the cost βjTj where Tj=max{0,Cj-dj} and βj>0 is the tardiness penalty per time unit. Similarly, if Cj<dj, the job is early and it is penalized by the cost αjEj where Ej=max{0,dj-Cj} and αj>0 is the earliness penalty per time unit.

We also assume that all the release dates, due dates and processing times are integer, which ensures that there exists an optimal solution with integer start times. However, there are two common ways to deal with noninteger values. The first possibility consists in scaling the problem by multiplying all these values by a well-chosen integer (the earliness and tardiness penalties must be divided by the same value) but, as we are going to propose pseudopolynomial algorithms, this approach remains valid in practice only if the dates and durations remain relatively small. The second approach consists in rounding the noninteger values in such a way that the constraints are relaxed and the costs are lower bounded. More precisely, it means that we can redefine rj as rj, pj as pj, Ej as max{0,dj-Cj} and Tj as max{0,Cj-dj}. Both approaches can also be mixed.

In the standard three-field notation scheme [11], this problem is denoted by P|rj|jαjEj+βjTj. The problem is known to be strongly NP-complete because the sub-problem 1|rj|Tj is strongly NP-complete [18].

Chen and Powell [6] study the special case where the jobs have an unrestrictively large common due date djpj. This problem is formulated as an integer linear programming. By using column generation, a strong lower bound is derived and a branch-and-bound algorithm is proposed to solve the problem to optimality.

More recently, Ventura and Kim [32] study a related problem with unit execution time jobs and additional resource constraints. From the Lagrangean relaxation of a zero-one linear programming formulation of the problem, both lower bound and heuristics are derived. The authors use the property that the special case P|rj;pj=1|jαjEj+βjTj is solved as an assignment problem.

In this paper, we study computational issues related to the use of standard mathematical formulations for machine scheduling problems in order to derive new lower bounds for the problem P|rj|jαjEj+βjTj. This computational analysis was particularly motivated by the use of time-indexed formulations [7] for which the bounds provided by the solution of LP-relaxation or Lagrangean relaxations are very strong [31]. We will focus on two of these formulations – namely the xjt-formulation and the yjt-formulation according to the terminology of Savelsbergh et al. [25]. In these formulations, xjt=1 means that job j starts at time t while yjt=1 means that it is in process at time t. These formulations have been useful in the design of strong lower bounds for problem with different regular criteria. The reader can refer to the works of Luh et al. [19], De Sousa and Wolsey [29], van den Akker et al. [31] for single machine scheduling problems. In a more theoretical approach, Queyranne and Schulz [24] study the polyhedral properties of such formulations.

The main contribution of this paper is to study these formulations for earliness–tardiness scheduling problems which are renowned for being hard to solve due to the difficulty of devising good lower bounds. The lower bounds tested in this paper are not all new – references are given in each section – but, to the best of our knowledge, they have not been tested and compared for earliness–tardiness problems. Some of the lower bounds as well as the heuristic algorithm can be considered as new since they are generalizations of lower bounds and algorithms, previously developed for the one-machine problem, to the parallel machine case. Finally, experimental comparison of these algorithms is of importance because it helps choose the best algorithm in function of the problem parameters.

The paper is organized as follows. Section 2 provides lower bounds based on the linear and Lagrangean relaxations of time-indexed problem formulation. In Section 3, a new lower bound based on the single-machine bound of Sourd and Kedad-Sidhoum [28] is presented. The generalization of the bound of Sourd [26] is also introduced. Section 4 is devoted to a simple heuristic based on local search, while in Section 5 we give some computational results which illustrate the effectiveness of the lower bounds. Some conclusions and extensions are finally discussed in Section 6.

Section snippets

Time-indexed formulation

We present an integer program (IP) for the problem P|rj|jαjEj+βjTj with integer start times – we recall that all the release dates, due dates and processing times are integer so that there exists an optimal schedule with integer start times. We use the time-indexed formulation (or xjt-formulation) [7]. It is based on time-discretization where time is divided into periods (or time slots), where period t starts at time t and ends at time t + 1. Let T denote the scheduling horizon, thus we consider

Assignment-based IP formulation

We now consider the assignment-based formulation or yjt-formulation. This formulation assumes the same time-discretization as for the xjt-formulation in Section 2.1. Here, yjt is a binary variable equal to 1 if job j is processed in period t and 0 otherwise. However, we will see in Section 3.3 how the discretization can be avoided.

The rationale for this formulation is to regard the scheduling problem as the assignment of unit job segments to unit time slots. The idea originates in the article

Feasible solutions

Typically, good feasible solutions can be derived from good relaxations of a problem. For the one-machine case (m = 1), Sourd and Kedad-Sidhoum [28] and Bülbül et al. [3] present different heuristic algorithms grounded on the assignment-based lower bound. These heuristics could be directly adapted for the general case (m>1) and very similar heuristics could be derived from the other time-indexed lower bounds (see e.g. [25]). It can however be observed that computing these lower bounds is somewhat

Algorithms and implementation

All of our algorithms are implemented in C++. Here is the list of implementations with some notes including the libraries used by each algorithm.

  • LinCG

    It implements the linear relaxation with column generation presented in Section 2.2. This algorithm calls ILOG CPLEX 9.1 to solve the linear problems.

  • LagOcc

    It implements the Lagrangean relaxation of the number of job occurences presented in Section 2.3. The network flow problem is solved with the library GOBLIN 2.7 [8].

  • LagRes

    It implements the Lagrangean relaxation

Conclusion

This paper has addressed the earliness–tardiness scheduling problem on parallel machines with a focus on lower bounds. Several lower bounds recently proposed for the one-machine problem have been extended to the parallel machine case. A simple but efficient local search heuristic has also been provided.

Experimental tests show that the best lower bound is the Lagrangean relaxation of the resource constraints in the time-indexed formulation and the gap between this lower bound and the heuristic

Acknowledgements

The authors are grateful to David Rivreau and anonymous referees for their comments that help improve the paper.

References (32)

  • J.D. Boissonnat et al.

    Algorithmic geometry

    (2001)
  • K. Bülbül, P. Kaminsky, and C. Yano, Preemption in single machine earliness/tardiness scheduling, Working paper,...
  • H. Chen et al.

    An improvement of the Lagrangean relaxation approach for job shop scheduling: A dynamic programming method

    IEEE Transactions on Robotics and Automation

    (1998)
  • C. Fremuth-Paeger, Goblin: A library for graph matching and network programming problems – Reference manual,...
  • M.R. Garey et al.

    Computers and intractability; a guide to the theory of NP-completeness

    (1979)
  • L. Gelders et al.

    Coordinating aggregate and detailed scheduling decisions in the one-machine job shop. I. Theory

    Operations Research

    (1974)
  • Cited by (56)

    • Dynamic scheduling of patients in emergency departments

      2023, European Journal of Operational Research
    • Just-in-time single-batch-processing machine scheduling

      2022, Computers and Operations Research
    View all citing articles on Scopus
    View full text