- Email: [email protected]
Lagrangian domain reductions for the single machine earliness–tardiness problem with release dates
European Journal of Operational Research 201 (2010) 45–54
Contents lists available at ScienceDirect
European Journal of Operational Research journal homepage: www.elsevier.com/locate/ejor
Discrete Optimization
Lagrangian domain reductions for the single machine earliness–tardiness problem with release dates Boris Detienne a,*, Éric Pinson b, David Rivreau b a b
École Nationale Supérieure des Mines de Saint-Étienne, Centre Microélectronique de Provence Georges Charpak, 880 route de Mimet, 13541 Gardanne, France Institut de Mathématiques Appliquées, 3 place André-Leroy 49008 Angers, France
a r t i c l e
i n f o
Article history: Received 12 March 2008 Accepted 4 February 2009 Available online 14 February 2009 Keywords: Scheduling Just-in-time Elimination rules Lagrangian relaxation Exact method
a b s t r a c t This paper presents new elimination rules for the single machine problem with general earliness and tardiness penalties subject to release dates. These rules, based on a Lagrangian decomposition, allow to drastically reduce the execution windows of the jobs. We measure the efficiency of these properties by integrating them in a branch-and-bound. Tests show that instances with up to 70 jobs without release dates, and up to 40 jobs with release dates, can be optimally solved within 1000 seconds. Ó 2009 Elsevier B.V. All rights reserved.
1. Introduction P In the 1jrj j j aj Ej þ bj T j scheduling problem, a set J of n jobs has to be scheduled without preemption on a single processor, which is able to handle only one job at a time. Each job j 2 J is given an integer processing time pj , a release date r j , a due date dj , and two positive penalties aj and bj . The earliness (resp. tardiness) of job j is defined as Ej ¼ maxðdj C j ; 0Þ (resp. T j ¼ maxðC j dj ; 0Þ), where C j denotes the completion time of j, and a cost aj Ej þ bj T j is incurred if the completion time of j is different from its due date. P Reviews about this problem and variants can be found in Baker and Scudder (1990) or Kanet et al. (2000). Since its special case 1jj j wj T j is NP-hard in the strong sense (Lenstra et al., 1977), this problem is clearly NP-hard. A few polynomial special cases exist, most of them involving a common due date. Hassin and Shani (2005) gather algorithms for solving some of these problems. Kedad-Sidhoum et al. (2008) present a computational study of lower bounds for the general case, in which one can notice the excellent quality of time-indexed based bounds. An interesting property of the problem has been exploited in many exact as well as heuristic approaches: solving the problem with respect to a fixed sequence of jobs (timing problem) can be done polynomially (see, e.g. Hendel and Sourd, 2007). Thus, an important part of the computational effort can be focused on searching for a good or optimal sequence. P Solving exactly 1jrj j j aj Ej þ bj T j appears to be difficult, even for small instances, and much work has been devoted to special cases or heuristic methods (Fry et al., 1987; Lee and Choi, 1995; Bülbül et al., 2007). Exact approaches able to solve instances without release dates and with up to 30 jobs were proposed by Tanaka et al. (2003) and Sourd and Kedad-Sidhoum (2003). More recently, Sourd and Kedad-Sidhoum (2008) present a branch-and-bound algorithm based on a Lagrangian relaxation of resource constraints in the time-indexed formulation (Sousa, 1989) with new dominance rules that can solve most instances with 50 jobs. Yau et al. (2006) develop an hybrid Dynamic Programming – branch-and-bound method, relying on an assignment-based lower bound, allowing to solve instances with up to 50 jobs. Two very recent papers deal successfully with the presence of release dates: Sourd (in press) uses a Lagrangian relaxation of the number of occurrences in the time-indexed formulation and reinforcing valid inequalities to deal successfully with instances with up to 60 jobs. Tanaka and Fujikama (2008) develop a Successive Sublimation Dynamic Programming scheme to handle general single machine problems that can solve optimally all of the instances of the literature of P 1jr j j j aj Ej þ bj T j with up to 200 jobs. * Corresponding author. Tel.: +33 (0)4 42 61 66 76. E-mail address: [email protected] (B. Detienne). 0377-2217/$ - see front matter Ó 2009 Elsevier B.V. All rights reserved. doi:10.1016/j.ejor.2009.02.005
46
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
This paper aims to present new and original elimination rules for this problem. It is organized as follows. In Section 2 we state a 0–1 time-indexed formulation of the problem, and we present a lower bound based on a Lagrangian decomposition. Next, we describe new elimination rules exploiting this decomposition (Section 3). Section 4 is devoted to a branch-and-bound exploiting these results and two Lagrangian upper bounds. Computational experiments are reported in the last section, followed by a conclusion. 2. Lower bound 2.1. Time-indexed formulation Our elimination rules rely on the computation of a lower bound based on a Lagrangian decomposition over the following 0–1 time-indexed formulation. Let us introduce the notations used in the sequel: P T ¼ f0; . . . ; sg: scheduling horizon. We can set s ¼ maxj maxðrj ; dj Þ þ j pj . P P ¼ j2J pj : sum of the processing times. 8j 2 J; ectj (resp. lctj ): earliest (resp. latest) possible completion time possible for job j. 8j 2 J; Dj ¼ fectj ; . . . ; lctj g: completion time window for job j. 8j 2 J; 8t 2 Dj ; cjt ¼ maxðaj ðdj tÞ; bj ðt dj ÞÞ: cost incurred if job j completes at time t. 1 if h 2 ft pj ; . . . ; t 1g : indicates if job j is in processing at time h if it completes at time t. 8j 2 J; 8t 2 Dj ; 8h 2 T; ajth ¼ 0 otherwise
Our problem can be formulated as a time-indexed integer program, where a decision variable xjt is equal to 1 if job j completes at time instant t, 0 otherwise; yh is equal to 1 if a task is processed at time instant h
½ETTISD
XX
min
X
s:t:
cjt xjt
t2Dj
j2J
xjt ¼ 1 8j 2 J;
ð1Þ
t2Dj
XX
ajth xjt 6 yh
8h 2 T;
ð2Þ
t2Dj
j2J
X
yh ¼ P;
ð3Þ
h2T
xjt 2 f0; 1g 8j 2 J; 8t 2 Dj ;
ð4Þ
yh 2 f0; 1g 8h 2 T:
ð5Þ
Constraint (1) ensures that at most one occurrence of each job is processed in any feasible schedule, while constraints (2) and (3) prevent from processing more than one job simultaneously. The use of the surrogate (3) allows the design of the elimination rule described in Proposition 5. 2.2. Lagrangian decomposition Let v ¼ ðv 0 ; . . . ; v s Þ P 0 denote Lagrangian multipliers associated with the Lagrangian dual function: D
L ðv Þ ¼ min
XX j2J
s:t:
0 @cjt þ
t2Dj
t1 X
1
v h A xjt
h¼tpj
X
s þ 1 coupling constraints, we price out (2) to form the
v h yh
h2T
ð1Þ ^ ð3Þ ^ ð4Þ ^ ð5Þ:
It follows that the dual problem ½DP consists in finding a vector of Lagrangian multipliers
v maximizing LD ðv Þ:
½DP ¼ max LD ðv Þ: þs v 2R
The resulting value provides us with a lower bound. 2.3. Solving the dual problem Clearly, computing LD ðv Þ for any vector of Lagrangian multipliers D
L ðv Þ ¼
X
D SPx j ð
vÞ
SPDy ð
v leads to n þ 1 independent subproblems. Indeed, one can write
v Þ:
j2J
~cjt ¼ cjt þ
Pt1
h¼tpj
v h noting the reduced cost of variable xjt , the subproblem associated with each job j can be described by
SPDj x ð
v Þ ¼ min
X
~cjt xjt
t2Dj
s:t:
X
xjt ¼ 1;
t2Dj
xjt 2 f0; 1g 8t 2 Dj :
47
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
This subproblem can be easily solved to optimality using the following OðsÞ strategy: process job j at the time instant minimizing the reduced cost ~cjt . The last subproblem can be written as
X
SPDy ðv Þ ¼ max
v h yh
h2T
X
s:t:
yh ¼ P;
h2T
yh 2 f0; 1g 8h 2 T: Solving this problem merely consists of selecting the P time instants with the highest multipliers, and can be achieved by a simple Oðs log sÞtime sort procedure. In order to optimize the dual problem ½DP, we use a classical sub-gradient algorithm (see, e.g. Held et al. (1974)).
3. Lagrangian domain reductions The elimination rules presented in this section can be seen as a special case of shaving (Carlier and Pinson, 1994; Martin and Schmoys, 1996; Carlier et al., 2004). They consist in testing the feasibility of the problem under certain hypothesis by means of the implicit compuP tation of a lower bound. This idea has already been used in Peridy et al. (2003) for 1jr j j j wj U j , for checking conditions relating to the lateness of a job. This approach also presents similarities with Constraint Programming Based Lagrangian Relaxations (Sellmann and Fahle, 2001; Sellmann, 2004), which, like the method developed by Péridy et al., apply to a single variable at a time. The work described here differs from previous work by the test of more complex assumptions. In this section, we assume that the following values are known: An upper bound UB of the optimal value of the problem at hand. of the Lagrangian multipliers. A vector v Þ. In particular, define An optimal solution to the corresponding Lagrangian subproblem, and its value LD ðv
lj ¼ SPDj x ðv Þ 8j 2 J.
Furthermore, let us introduce the notations:
r max ¼ maxj2J rj . dmax ¼ maxj2J dj . fmax ¼ maxðr max ; dmax Þ. dmin ¼ minj2J dj .
Besides, let SD be the set of feasible solutions of ½ETTISD whose cost is less than or equal to UB, and redefine Dj , for any job j, as the set of time instants where j completes in at least one solution of SD . Three elimination rules are proposed below. The first one checks if a job can complete at a given time instant. Proposition 1. Let j 2 J and h 2 T. Þ lj þ ~cjh > UB, then h R Dj . If LD ðv 0
Proof. Let us consider the set of solutions whose cost is less than or equal to UB, and such that j ends at time h, i.e. SD , with 0 0 8i 2 J fjg; D0i ¼ Di and D0j ¼ fhg. Thus, if LD ðv Þ > UB, then SD ¼ ;. We have 0
LD ðv Þ ¼
X
0
0
SPxD i ðv Þ þ SPDy ðv Þ ¼
i2J
X
0
0
D Dj Dj Dj D D ~ SPDi x ðv Þ þ SP y ðv Þ þ SP x ðv Þ ¼ L ðv Þ SP x ðv Þ þ SP x ðv Þ ¼ L ðv Þ lj þ c jh
i2Jfjg 0
Þ lj þ ~cjh > UB, then SD ¼ ;. Thus, h R Dj . So, if L ðv D
h
The following proposition investigates the selection of a given disjunction. Proposition 2. Let i 2 J, j 2 J fig, and let us denote:
li ¼ minðlct i ; lct j pj Þ. 8t 2 fecti ; . . . ; li g; ej ðtÞ ¼ maxðt þ pj ; ectj Þ. fi!j ¼ minf~cit þ ~cjt0 jt 2 fecti ; . . . ; li g ^ t0 2 fej ðtÞ; . . . ; lct j gg. Þ ¼ LD ðv Þ li lj þ fi!j > UB. LDi!j ðv
Þ > UB, then j is processed before i in any solution of SD . If LDi!j ðv Proof. Let us consider the set of solutions whose cost is less than or equal to UB, such that i completes before or at time instant h and i is h processed before j, i.e. SD , with: 8h 2 fecti ; . . . ; li g; 8k 2 J fi; jg; Dhk ¼ Dk . 8h 2 fecti ; . . . ; li g; Dhi ¼ fect i ; . . . ; hg. 8h 2 fecti ; . . . ; li g; Dhj ¼ fej ðhÞ; . . . ; lct j g. h
h
Þ > UB, then [h2fecti ;...;li g SD ¼ ;. We have Thus, if minh2fecti ;...;li g LD ðv
48
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54 h
LD ðv Þ ¼
X
h
k2J
h
SPDx k ðv Þ þ SPDy ðv Þ ¼
¼ LD ðv Þ li lj þ
min
t2fecti ;...;hg
X
h
k2Jfi;jg
~cit þ
h
h
h
D D i D j Di Dj D i D j D SPDk x ðv Þ þ SP y ðv Þ þ SP x ðv Þ þ SP x ðv Þ ¼ L ðv Þ SP x ðv Þ SP x ðv Þ þ SP x ðv Þ þ SP x ðv Þ
min
t 0 2fej ðhÞ;...;lctj g
~cjt :
Then, h
min
LD ðv Þ ¼ LD ðv Þ li lj þ minf~cit þ ~cjt0 jt 2 fecti ; . . . ; li g ^ t0 2 fej ðtÞ; . . . ; lctj gg;
min
LD ðv Þ ¼ LD ðv Þ li lj þ fi!j :
h2fecti ;...;li g
h2fecti ;...;li g
h
h
Þ li lj þ fi!j > UB, then [h2fecti ;...;li g SD ¼ ;. It follows that i cannot be processed before j in any solution of SD . So, if LD ðv
h
For any pair of jobs ði; jÞ, this property can be checked by a straightforward Dynamic Programming procedure running in OðjDi j þ jDj j pi pj Þ steps. The three following propositions allow to check if an optimal schedule can start at a given time instant. Proposition 3. There is at least one optimal solution without idle time inserted between two jobs in fr max ; . . . ; dmin g and ffmax ; . . . ; sg. Proof. One can easily verify that delaying the job that immediately precedes an idle time in fr max ; . . . ; dmin g leads to a solution whose cost is less than or equal to the cost of the current solution. The symmetrical argument can be independently applied in ffmax ; . . . ; sg. h Proposition 4. Let t 2 T, and denote: ft; . . . ; dmin g if t 6 dmin ; Y ðtÞ ¼ otherwise: ; ffmax ; . . . ; t þ P 1g if t þ P 1 P fmax ; þ Y ðtÞ ¼ ; otherwise: If there exists an optimal solution whose first job starts at t, then there exists an optimal solution such that the processor is busy during all time instants in Y ðtÞ [ Y þ ðtÞ. Proof. Straightforward according to Proposition 3 by considering that any feasible schedule starting at t cannot complete before t þ P 1. h Proposition 5. Let t 2 f0; . . . ; s P þ 1g, and consider the following additional notations:
Y 0 ðtÞ ¼ T ðY ðtÞ [ Y þ ðtÞ [ f0; . . . ; t 1gÞ. 8z 2 R; ðzÞþ ¼ maxð0; zÞ. rðtÞ ¼ P ðdmin tÞþ ðt þ P fmax Þþ : smallest possible total processing time in the interval frmax ; . . . ; dmin 1g [ ffmax þ 1; . . . ; sg. r: permutation of T corresponding to the non-increasing order of the Lagrangian multipliers. Y ðtÞ ¼ frs j s 6 rðtÞg: rðtÞ instants with the highest Lagrangian multipliers, in Y 0 ðtÞ. P ; tÞ ¼ h2Y ðtÞ[Y þ ðtÞ[Y ðtÞ v h. SP 0y ðv
Þ SP 0y ðv ; tÞ > UB, then no optimal schedule starts at time instant t. If SP Dx ðv Proof. Let us assume the existence of an optimal solution starting at time instant t. Then, according to Proposition 4, there exists an optimal solution such that the processor is busy during all instants in Y ðtÞ [ Y þ ðtÞ. This configuration can be modeled by means of the following integer linear program:
½ETTISD 0
min
XX j2J
s:t:
cjt xjt
t2Dj
X
xjt ¼ 1 8j 2 J;
t2Dj
XX j2J
X
ajth xjt 6 yh
8h 2 T;
t2Dj
ð6Þ
yh ¼ P;
h2T
yh ¼ 1 8h 2 Y ðtÞ [ Y þ ðtÞ; xjt 2 f0; 1g 8j 2 J; 8t 2 T; yh 2 f0; 1g 8h 2 T: By dualizing constraints (6), it is clear that SPDx ðv Þ SP 0y ðv ; tÞ is a lower bound of the optimum of ½ETTISD 0 , for any vector of the Lagrangian multipliers v. Since the optimal solution of ½ETTISD 0 is also optimal for ½ETTISD , SPDx ðv Þ SP 0y ðv ; tÞ > UB leads to a contradiction. h Algorithm 1 aims to compute a lower bound associated with the first time instant where an optimal schedule can start. It takes as input a non-increasing order r of the Lagrangian multipliers (an output from the computation of SP Dy ðv Þ). The main loop performs in OðsÞ iterations. Moreover, since the value z never decreases, the global number of iterations required by the two inner loops cannot exceed s. Consequently, the overall complexity of this algorithm is OðsÞ. Similar arguments hold to check if an optimal schedule may end at a given time instant.
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
49
Algorithm 1. Computation of the first time instant where an optimal schedule can start according to Proposition 5 {Compute the initial contribution of Y ðtÞ [ Y þ ðtÞ} true; end tþP1 t ðdmin PÞþ ; ok P P sF h2ft;...;dmin g v h þ h2ffmax ;...;endg v h r P maxð0; dmint Þ þ maxð0; end fmax þ 1Þ {Compute the initial contribution of ðY ðtÞÞ} false s 0; z 0; sV 0; 8t 2 T; sel½t while ðs < rÞ do if rz > dmin then if ððend > fmax Þ ^ ðrz < fmax _ rz > endÞÞ _ ðend < fmax Þ then true; sV sV þ v rz ; s sþ1 sel½rz end if end if z zþ1 end while {Main loop: seek for the first valid instant} while ðLDx ðv Þ þ sF þ sV > UBÞ ^ ðt < dmin Þ do t t þ 1; end end þ 1 {Remove the previous instant from Y ðtÞ} sF sF v t1 if end < fmax then {If there is no new instant in Y þ ðtÞ, update the contribution of Y ðtÞ} while rz < dmin _ sel½rz do z zþ1 end while True sV sV þ v rz ; sel½rz else {Otherwise, update the contribution of Y ðtÞ [ Y þ ðtÞ} sF sF þ v end {If instant end was part of Y ðtÞ, update Y ðtÞ} if sel½end then sV sV v end ; sel½end False while rz < dmin _ ðrz P dmax ^ rz 6 endÞ do z zþ1 end while True sV sV þ v rz ; sel½rz z zþ1 end if end if end while return t
4. Branch-and-bound method The previous elimination rules, jointly with other classical elimination and dominance rules, have been embedded in a branch-andbound method, performing a Depth First Search strategy. 4.1. Integrating Lagrangian domain reduction The rules presented in the previous section have been exploited inside a sub-gradient routine, dealing with the optimization of the dual function. This procedure, providing of course a lower bound, checks the different rules with numerous vectors of Lagrangian multipliers generated during the sub-gradient process. , by seeking for the smallest (resp. greatest) The first rule (Proposition 1) is applied for each job j and the current vector of multipliers v time instant for which Proposition 1 is not active. The corresponding bounds of Dj , coded as a simple interval, are then adjusted to these is not optimal and may not even be near-optimal under the assumption Dj ¼ fhg, the large number of lower bounds values. Although v estimates yields efficient reductions. We use the second rule (Proposition 2) in the same way, for each non-selected disjunction. Algorithm 1 and its symmetrical version are then run in order to apply the third rule (from Proposition 5), possibly reducing the active scheduling horizon. Our strategy, inspired by experimental considerations, consists in performing the reductions every 20 iterations of the sub-gradient procedure, which is in turn used at each node of the search tree to compute a lower bound. After each run of the Lagrangian reductions, the other dominance and elimination rules (detailed below) are launched. This process is iterated until a stabilization of the execution windows occurs. Upper bounds are also derived during this process; their computation is detailed in Section 4.5.
50
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
4.2. Other dominance and elimination rules Each node of the search tree is characterized by a set of selected disjunctions, and one time window for each job. On the one hand, a consistent complete selection corresponds to a sequence of jobs, from which we can derive an optimal schedule. On the other hand, each selection leads to an adjustment of the time windows of the corresponding jobs. For the sake of simplicity in formulating the following propositions, let i ! j; 8i 2 J; 8j 2 J fig stand for job i processed before job j. A number of rules allowing selections and adjustments can be found in the literature. These rules prove to be very powerful as soon as time windows are tight enough, and Lagrangian reductions enable their efficient use. Now, let us state a few of these properties, embedded in our method. Proposition 6. There is at least one optimal solution such that: a
i ! j, for any pair of jobs ði; jÞ such that i is fully processed in fr max ; . . . ; dmin g and apii < pjj . k ! l, for any pair of jobs ðk; lÞ such that l is fully processed in ffmax ; . . . ; sg and bpl > bpk . l
k
Proposition 7 (Immediate selection on a disjunction (Carlier, 1975)). Let i and j be two distinct jobs of J. If ect i þ pj > lct j , then j ! i in any solution. Proposition 8 (Adjustment on a disjunction). Let i and j be two distinct jobs of J. If i ! j, then ect j P ect i þ pj and lct i 6 lct j pj . Carlier and Pinson (1994) propose an Oðn log nÞ algorithm computing all immediate selections and the corresponding adjustments. Proposition 9 (Immediate selections on an ascendant/descendant set (Carlier and Pinson, 1989; Carlier and Pinson, 1990)). Let j 2 J and I # J fjg. P If mini2I[fjg fecti pi g þ pj þ i2I pi > maxi2I lct i , then 8i 2 I; i ! j in any solution. P If mini2I fecti pi g þ pj þ i2I pi > maxi2I[fjg lct i , then 8i 2 I; j ! i in any solution. Proposition 10 (Adjustment on an ascendant/descendant set (Carlier and Pinson, 1989)). Let j 2 J and I # J fig. P P If mini2I[fjg fecti pi g þ pj þ i2I pi > maxi2I lct i , then ectj P maxI0 # I mini2I0 r i þ i2I0 pi þ pj . P P If mini2I fecti pi g þ pj þ i2I pi > maxi2I[fjg lct i , then lct j 6 minI0 # I maxi2I0 di i2I0 pi . An Oðn log nÞ algorithm for optimally adjusting the execution windows using this proposition is described in Carlier and Pinson (1994). 4.3. Branching scheme In our implementation, we restrict the search to the set of potential sequences, since, as pointed out before, we can easily compute an optimal solution relative to a given sequence. Our branch-and-bound relies on an extension of the Edge-Finding branching scheme (see, for instance, Carlier, 1978). Each node of the search tree is characterized by: A sub-sequence I (resp. O) of jobs scheduled first (resp. last) in all derived global sequences. A set U of unscheduled jobs (to be processed between I and O). A set PI # U (resp. PO # U) of jobs that are candidates for extending the sub-sequence I (resp. O), i.e. which can be consistently processed immediately after jobs in I (resp. before jobs in O). One completion time window per job. Depending on the context, we either explicitly add a job to the current sequence, or split a time window. The branching procedure can be summarized as follows: (1) Check sets PI and PO: If U ¼ ; (and thus PI ¼ PO ¼ ;), then the current node is a leaf, and no decision has to be taken. If U – ; and (PI ¼ ; or PO ¼ ;), then the current node is clearly infeasible and a backtrack occurs. If PI ¼ fjg (resp. PO ¼ fjg), then we append the corresponding job in queue of the current sub-sequence I (resp. in head of the current sub-sequence O). Otherwise, we take one of the following decisions: (2) Try to split a relevant time window: As pointed out previously, job domains are coded as simple intervals. Nevertheless, Proposition 1 sometimes detects infeasible completion times in the middle of the current range for a given job, without invalidating completion times associated with the bounds of the corresponding interval. When such a case occurs, and for a large job domain (the threshold is arbitrarily fixed to 10n time instants), we exploit this information by splitting the window in two parts, leading to two child nodes in the search tree. If no such job is identified, we investigate the second decision type. Þ be a lower bound of the total cost of any schedule such that job i pre(3) Or explicitly extend one of the sub-sequences I or O: Let LDi!K ðv cedes all the jobs in K, and defined by:
LDi!K ðv Þ ¼ max LDi!k ðv Þ: k2K
Also, define
LDK!i ðv Þ ¼ max LDk!i ðv Þ: k2K
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
51
Þ 6 minj2O LDOfjg!j ðv Þ. Then we select the job i satisfying Let us now assume that jPIj < jPOj, or that jPIj ¼ jPOj and minj2I LDj!Ifjg ðv i ¼ argminj2I LDj!Ifjg ðv Þ, and create two child nodes in the search tree. In the first one, we append job i to sub-sequence I, while in the second one we remove job i from set PI. Of course, the symmetrical decision applies when set PO appears to be more favorable. At each node of the search tree, the lower bound presented in Section 2 is updated by taking into account the new execution windows resulting from the branching decision and running a few iterations of the modified sub-gradient procedure. 4.4. Initialization The initialization step aims at reducing the search tree by computing the lower bound at the root node and a heuristic upper bound, and pruning jobs time windows. To this end, the modified sub-gradient procedure (see Section 4.1) is run twice. The first pass provides an upper bound and preliminary domain reductions. The second pass takes benefits from the tight upper bound leading to stronger reductions. Preliminary numerical results showed that starting the second pass with null Lagrangian multipliers is beneficial. This fact can be explained as follows: the efficiency of the reductions relies not only on the near-optimality of the multipliers, but also on the diversity of the vectors used (see Sellmann (2004) for a theoretical development). 4.5. Upper bounds The efficiency of branch-and-bound methods is, generally, considerably improved by the computation of tight upper bounds. In our case, this is even more important, because it drastically affects the performance of our elimination rules. We develop two Lagrangian heuristics, both deriving a permutation from the current set of Lagrangian multipliers. The corresponding sequence is then optimally scheduled using the algorithm described in Jòzefowska and Bauman (2006). At the root node, this heuristic sequence is also used for initializing a simple steepest descent meta-heuristic, whose neighborhood relies on permutation and extraction/reinsertion of jobs. In our method, no development effort has been devoted to this step. However, notice that an efficient implementation is possible (Hendel and Sourd, 2006). Below, we explain in detail the two ways of getting a sequence of jobs at each node of the branch-and-bound tree. 4.5.1. Heuristic sequence based on the Lagrangian subproblem One can derive a good sequence from the optimal solution of the Lagrangian subproblems by taking the tasks in the increasing order of completion times in the corresponding current solutions. Already selected disjunctions are taken into account by delaying jobs whose predecessors are not all scheduled yet. 4.5.2. Best pairwise chaining Assuming that there is only a little number of idle times in an optimal solution, we based our second heuristic on the following proposition. Proposition 11. Let i 2 J and j 2 J fig. Let us consider the set Sij of the solutions such that i and j are processed consecutively and with no idle time. Besides, let a ¼ maxðecti ; ect j pj Þ and b ¼ minðlct j ; lct i þ pj Þ, and assume a 6 b (otherwise we have Sij ¼ ;). D D ~ ~ Denoting by zðsÞ the cost of the solution s, 8j 2 J; lj ¼ SP Dj x ðv Þ and 8i 2 J; 8j 2 J fig; Lij ðv Þ ¼ L ðv Þ li lj þ mint2fa;...;bg fc i;tpj þ c j;t g, we ij D s Þ. 2 R ; zðsÞ P Lij ðv have 8s 2 S ; 8v Proof. Clearly, the consecutive processing with no idle time of i and j can be modeled by replacing them by a unique job k, whose duration is pi þ pj , with a cost of ci;tpj þ cj;t and fa; . . . ; bg as completion time window. Obviously, the optimal solutions to the Lagrangian subproblems associated with the other jobs do not change, and the optimal value for the new subproblem is equal to mint2fa;...;bg f~ci;tpj þ ~cj;t g. Þ. h The claimed result is simply obtained by replacing the non-common part in the expression of LD ðv Þ. The remaining jobs are then seIn order to build the solution, we initialize the sequence by selecting the job i minimizing LDi!Jfig ðv quenced in a greedy way by choosing, at each step, the best chaining job as depicted in Algorithm 2. Algorithm 2. Greedy heuristic based on Proposition 11 Þ; s j argminj2J LDj!Jfjg ðv ðjÞ; U J fjg Let V bet the set of jobs whose predecessors are all sequenced while U – ; do Þ; s i argmini2V LDji ðv s [ i; U U fig Update V; j i end while return s
5. Computational results All the tests have been performed on a Personal Computer equipped with 3 gigabyte RAM and a 2.66 gigahertz Intel Core 2 microprocessor, running on MS Windows XP. The code has been compiled with MS Visual.Net 2002.
52
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
5.1. Test bed The tests are mostly performed on problems of the literature. For the case without release dates, we used the instances proposed in Sourd and Kedad-Sidhoum (2008). As described in their paper, the release dates are all null, and the instance generator takes three parameters into account: the number of jobs n, the range factor R and the tardiness factor T. The processing time of each job is first drawn from a discrete uniform distribution f10; . . . ; 99g. The due dates are then generated from a discrete uniform distribution fdmin ; . . . ; dmin þ R Pg, where P dmin ¼ maxð0; PðT R=2ÞÞ and P ¼ j pj . Earliness and tardiness penalties are drawn from f1; . . . ; 5g. 26 instances have been generated for each combination of the following parameters: n 2 f30; 50g, T 2 f0:2; 0:3; 0:4; 0:5; 0:6; 0:7; 0:8g and R 2 f0:2; 0:3; 0:4; 0:5; 0:6; 0:7; 0:8g. For n ¼ 60, five instances are proposed for each combination of T 2 f0:2; 0:5; 0:8g and R 2 f0:2; 0:5; 0:8g. We generated an additional category, similar to this one, for n ¼ 70. The total number of instances without release dates is 2638. In order to test our approach when release dates are present, we used the test bed proposed in Bülbül et al. (2007). The whole set consists of 300 instances for each number of job n 2 f20; 40; 60; 80; 100; 130; 170; 200g. 5.2. Domain reductions This section presents the results obtained by the initialization procedure described in Section 4.4. For the sake of readability, these tests were performed on instances without release dates. Results on instances with release dates are presented for our branch-and-bound in Section 5.3. All elimination and dominance rules presented in this paper were applied. We detail the impact of the different rules at the end of this section. We first report the required computation time, depending on the number of jobs, in Table 1, as well as the part of variables (relating to the formulation presented in Section 2.1) that are discarded by the procedure, and the part of selected disjunctions. One can observe that the relative reductions are approximately constant with respect to the number of jobs. Besides, the heuristic solution provided in output of the procedure is optimal (although not necessarily proved to be optimal) for more than one half of the 50-job instances, and more than 30% of the 70-job instances. Table 2 details the performance of the bounds obtained by the procedure, according to different critical values of the range factor R, for the 50-job instances. We give below an explanation of the degradation of the quality that can be noticed when R rises. These results clearly show that our elimination rules, coupled with classical ones, form an efficient and useful pre-process for P 1jrj j aj Ej þ bj T j . Indeed, they provide good lower and upper bounds, and allow to considerably reduce the number of variables of the problem, in a reasonable computation time. 5.3. Branch-and-bound This section presents the results obtained by our exact method, within a time limit of 1000 seconds, as used by most recent papers studying this problem. 5.3.1. Instances with no release date Table 3 gives the part of instances solved to optimality within the prespecified time limit, the corresponding average computation times and number of nodes explored in the search tree. Notice that this latter only takes instances solved to optimality into account, that is why
Table 1 Mean computation time, part of selected disjunctions and deleted variables after initial domain reduction. # jobs
# deleted variables (%)
# selected disjunctions (%)
Av. time (seconds)
# instances for which heuristic solution is optimal
50 60 70
91 91 91
77 76 75
10.0 18.7 32.8
699/1274 21/45 17/45
Table 2 Mean deviation between upper and lower bound after initial domain reduction for 50-job instances. R
(Upper bound lower bound)/lower bound (%)
0.2 0.5 0.8
0.28 1.00 3.29
Mean for all values of R
1.25
Table 3 Part of instances without release dates solved to optimality within 1000 seconds. # of jobs
% solved to optimality (%)
Average time (seconds)
# of nodes
50 60 70
89 73 51
115.2 218.4 298.1
3145.8 5393.8 4967.4
53
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54 Table 4 Part of 50-job instances without release dates solved to optimality with respect to some generation parameters. T
R 0.2
0.5
0.8
0.2 0.5 0.8 Average
100% 100% 100% 99%a
100% 92% 77% 90%a
100% 73% 58% 74%a
a b c
Average
99%b 90%b 77%b 89%c
Average values are computed from the whole set of the tardiness factor values, i.e. T 2 f0:2; 0:3; 0:4; 0:5; 0:6; 0:7; 0:8g. Average values are computed from the whole set of the range factor values, i.e. R 2 f0:2; 0:3; 0:4; 0:5; 0:6; 0:7; 0:8g. Overall average is computed from the whole set of 50-job instances.
the number of nodes explored for the 70-job instances appears smaller than the one reported for 60-job instances. A more correct idea can be given by considering the results obtained within a time limit of 1 hour: 84% of the 60-job (resp. 64% of the 70-job) instances are then solved with an average number of nodes equal to 8085 (resp. 14532) and an average computing time of 688 seconds (resp. 848 seconds). Table 4 gives an indication of the tolerance of our method with respect to the parameters R and T. We can see clearly that our Branchand-Bound performs well when due dates are grouped ðR ¼ 0:2Þ. It can be easily explained by the fact that dominance rules at the extremities of the schedule (Proposition 6) are more often used, because their inactive range is determined by fdmin ; . . . ; dmax g. The same argument applies to the worse results obtained when R ¼ 0:8. The good performance obtained with small values of the tardiness factor can be attributed to the important part of the total processing time that has to be scheduled after dmax . In this case, both Propositions 6 and 5 can be used to select disjunctions and efficiently reduce the execution windows. In order to measure the contribution of our new rules to the performance of the exact method, Table 5 reports the results obtained when applying different combinations of them. To get relevant results for all methods, these tests were performed on 30-job instances, under a time limit of 30 seconds. Using Proposition 1 (denoted by R1 in the Table 5) is clearly beneficial compared to the only use of edge finding techniques (EF) and the dominance rules (D: Proposition 6). The application of Proposition 2 (R2) speeds up the process by an improved pruning of the search tree. Proposition 5 (R5) allows to reduce even more the number of expanded nodes in the search tree, and correlatively the total CPU time. 5.3.2. Instances with release dates As mentioned above, our experiments are based on the test bed proposed in Bülbül et al. (2007). The generation of these instances depends on more parameters than the process already described, determining minimum and maximum processing times and penalties. Besides, release dates are drawn from a uniform distribution in f0; . . . ; Pg (thus, we can have r max > dmax ). The combination of these parameters leads to 300 instances per number of jobs. For more details, we refer to Bülbül et al. (2007). In the presence of release dates, our branch-and-bound fails at solving instances with 60 jobs and more. Table 6 gives the results for the sets with 20 and 40 tasks. Once again, the poor performance of our method can be explained by the restricted range where Proposition 6 is valid, preventing deductions on selections at the beginning of the schedule. 5.3.3. Comparison with the performance of other recent approaches It can be noticed that the bound exploited in this paper is theoretically equivalent to the classical one applied to the same problem by Sourd and Kedad-Sidhoum (2008). Indeed, we can first observe that there exists at least one integer optimal solution associated with each subproblem occurring in the computation of this bound. Thus, the dual problem ½DP has the same optimal value than the continuous relaxation ½CETTISD of ½ETTISD (integrality property). In addition, one can verify that this latter is equivalent to the linear relaxation ½CETTID of the classical time-indexed formulation (for a description of this model, see, e.g. Kedad-Sidhoum et al., 2008), since it is possible to build a feasible solution of ½CETTISD from any feasible solution of ½CETTID with the same cost, and conversely. Moreover, the bound obtained by Lagrangian relaxation of the resource constraints in the classical time-indexed formulation is equivalent to ½CETTID . So, the bounds used in both papers are theoretically equivalent. The use of the surrogate allows the design of one of the
Table 5 Impact of the different rules on the branch-and-bound performance. Rules enabled
EF + D
EF + R1
EF + D + R1
EF + D + R1 + R2
EF + D + R1 + R2 + R5
% optimal Av. time (seconds) # nodes
49% 8.5 251.0
93% 4.6 160.8
93% 4.5 143.2
96% 4.3 135.5
96% 3.8 115.9a
a
22% of the 30-job instances are solved at the root node when all rules are applied.
Table 6 Part of instances with release dates solved to optimality within 1000 seconds. # of jobs
% solved to optimality
Average time (seconds)
# of nodes
20 40
100% 93%
1.3 106.4
73.2a 2897.9
a
39% of the 20-job instances are solved at the root node.
54
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
new elimination rules, that proves to be efficient in practice and makes the originality of this paper. Indeed, we benchmarked our results against the branch-and-bound described in Sourd and Kedad-Sidhoum (2008), whose code, as well as the test bed used, are provided by the authors on their home page. This code was compiled and run in the same conditions as our methods. In the case without release dates, the performances of both methods are similar for 50-job instances. However, the algorithm of Sourd and Kedad-Sidhoum can solve only 47% of the 60-job instances and 16% of the 70-job instances. Besides, this approach leaves some 20-job instances with release dates open. Notice that since the first submission of this paper, two new approaches have been proposed, in Sourd (in press) and Tanaka and Fujikama (2008). According to the authors, they both outperform the branch-and-bound based on the Lagrangian reductions, since they solve all instances of the test bed proposed by Bülbül et al. (2007) with up to 60 and 200 jobs, respectively. 6. Conclusion This paper presents new elimination rules for the single machine problem with general earliness and tardiness penalties subject to release dates. These rules prove to be a powerful tool for reducing job time windows. Several extensions to this work can be considered, like exploiting new consistency tests: one can, for example, easily test the presence of idle times in an optimal schedule by a slight modification of Proposition 5. Besides, it would be interesting to test different branching P schemes for this problem, and to apply similar methods to other combinatorial optimization problems, like Pmjrj j j aj Ej þ bj T j . References Baker, K.R., Scudder, G.D., 1990. Sequencing with earliness and tardiness penalties: A review. Operations Research, 0030-364X 38 (1), 22–36. Bülbül, K., Kaminsky, P., Yano, C., 2007. Preemption in single machine earliness/tardiness scheduling. Journal of Scheduling 10 (4–5), 271–292. Carlier, J., 1975. Thèse de troisième cycle. Carlier, J., 1978. Ordonnancements à contraintes disjonctives. RAIRO 12, 333–351. Carlier, J., Pinson, E., 1989. An algorithm for solving the job-shop problem. Management Science, 0025-1909 35 (2), 164–176. Carlier, J., Pinson, E., 1990. A practical use of jackson’s preemptive schedule for solving the job shop problem. Annals of Operations Research, 0254-5330 26 (1–4), 269–287. Carlier, J., Pinson, E., 1994. Adjustments of heads and tails for the job-shop problem. European Journal of Operational Research 78, 146–161. Carlier, J., Péridy, L., Pinson, E., Rivreau, D., 2004. Chapter IV: Elimination Rules for Job-Shop Scheduling Problem – Overview and Extensions. Handbook of Scheduling: Algorithms, Models, and Performance Analysis. CRC Press. pp. 1–19. Fry, T.D., Armstrong, R.D., Blackstone, J.H., 1987. Minimizing weighted absolute deviation in single machine scheduling. IIE Transactions 19, 445–450. Hassin, R., Shani, M., 2005. Machine scheduling with earliness tardiness and non-execution penalties. Computers and Operations Research, 0305-0548 32 (3), 683–705. Held, M., Wolfe, P., Crowder, H.P., 1974. Validation of sub-gradient optimization. Mathematical Programming 6, 62–88. Hendel, Y., Sourd, F., 2006. Efficient neighborhood search for the one-machine earliness–tardiness scheduling problem. European Journal of Operational Research 173 (1), 108–119. Hendel, Y., Sourd, F., 2007. An improved earliness–tardiness timing algorithm. Computers and Operations Research 34 (10), 2931–2938. Jòzefowska, J., Bauman, J., 2006. Minimizing the earliness–tardiness costs on a single machine. Computers and Operations Research 33 (11), 3219–3230. Kanet, J.J., Sridharan, V., 2000. Scheduling with inserted idle time: Problem taxonomy and literature review. Operations Research, 0030-364X 48 (1), 99–110. Kedad-Sidhoum, S., Rios Solis, Y.A., Sourd, F., 2008. Lower bounds for the earliness–tardiness scheduling problem on parallel machines with distinct due dates. European Journal of Operational Research 189 (3), 1305–1316. Lee, C.Y., Choi, J.Y., 1995. A genetic algorithm for job sequencing problems with distinct due dates and general early-tardy penalty weights. Computers and Operations Research, 0305-0548 22 (8), 857–869. Lenstra, J., Rinnoy Kan, A., Brucker, P., 1977. Complexity of machine scheduling problems. Annals of Discrete Mathematics 1, 343–362. Martin, P., Schmoys, D.B., 1996. A new approach to computing optimal schedules for the job-shop scheduling problem. In: Proceedings of the 5th International IPCO Conference, pp. 389–403. Peridy, L., Pinson, E., Rivreau, D., 2003. Using short-term memory to minimize the weighted number of late jobs on a single machine. European Journal of Operational Research 148 (0), 591–603. Sellmann, M., 2004. Theoretical foundations of CP-based Lagrangian relaxation. In: Principles and Practice of Constraint Programming (CP). LNCS, vol. 3258. Springer, pp. 634– 647. Sellmann, M., Fahle, T., 2001. CP-based Lagrangian relaxation for a multimedia application.. Sourd, F., Kedad-Sidhoum, S., 2003. The one machine scheduling with earliness and tardiness penalties. Journal of Scheduling 6 (6), 533–549. Sourd, F., Kedad-Sidhoum, S., 2008. A faster branch-and-bound algorithm for the earliness–tardiness scheduling problem. Journal of Scheduling 11 (1), 49–58. Sourd, F., in press. New exact algorithms for one-machine earliness–tardiness scheduling. INFORMS Journal of Computing. doi:10.1287/ijoc.1080.0287. Sousa, J.P., 1989. Time-indexed Formulation of Non-preemptive Single Machine Scheduling Problems. Ph.D. Thesis, Université Catholique de Louvain. Tanaka, S., Fujikama, S., 2008. An efficient exact algorithm for general single-machine scheduling with machine idle time. In: IEEE International Conference on Automation Science and Engineering, pp. 371–376. Tanaka, S., Sasaki, T., Araki, M., 2003. A branch-and-bound algorithm for the single-machine weighted earliness–tardiness scheduling problem with job-independent weights. In: IEEE International Conference on Systems, Man and Cybernetics, pp. 1571–1577. Yau, H., Pan, Y., Shi, L., 2006. New solution approaches to the general single machine earliness–tardiness problem. In: IEEE Transactions on Automation Science and Engineering.
Contents lists available at ScienceDirect
European Journal of Operational Research journal homepage: www.elsevier.com/locate/ejor
Discrete Optimization
Lagrangian domain reductions for the single machine earliness–tardiness problem with release dates Boris Detienne a,*, Éric Pinson b, David Rivreau b a b
École Nationale Supérieure des Mines de Saint-Étienne, Centre Microélectronique de Provence Georges Charpak, 880 route de Mimet, 13541 Gardanne, France Institut de Mathématiques Appliquées, 3 place André-Leroy 49008 Angers, France
a r t i c l e
i n f o
Article history: Received 12 March 2008 Accepted 4 February 2009 Available online 14 February 2009 Keywords: Scheduling Just-in-time Elimination rules Lagrangian relaxation Exact method
a b s t r a c t This paper presents new elimination rules for the single machine problem with general earliness and tardiness penalties subject to release dates. These rules, based on a Lagrangian decomposition, allow to drastically reduce the execution windows of the jobs. We measure the efficiency of these properties by integrating them in a branch-and-bound. Tests show that instances with up to 70 jobs without release dates, and up to 40 jobs with release dates, can be optimally solved within 1000 seconds. Ó 2009 Elsevier B.V. All rights reserved.
1. Introduction P In the 1jrj j j aj Ej þ bj T j scheduling problem, a set J of n jobs has to be scheduled without preemption on a single processor, which is able to handle only one job at a time. Each job j 2 J is given an integer processing time pj , a release date r j , a due date dj , and two positive penalties aj and bj . The earliness (resp. tardiness) of job j is defined as Ej ¼ maxðdj C j ; 0Þ (resp. T j ¼ maxðC j dj ; 0Þ), where C j denotes the completion time of j, and a cost aj Ej þ bj T j is incurred if the completion time of j is different from its due date. P Reviews about this problem and variants can be found in Baker and Scudder (1990) or Kanet et al. (2000). Since its special case 1jj j wj T j is NP-hard in the strong sense (Lenstra et al., 1977), this problem is clearly NP-hard. A few polynomial special cases exist, most of them involving a common due date. Hassin and Shani (2005) gather algorithms for solving some of these problems. Kedad-Sidhoum et al. (2008) present a computational study of lower bounds for the general case, in which one can notice the excellent quality of time-indexed based bounds. An interesting property of the problem has been exploited in many exact as well as heuristic approaches: solving the problem with respect to a fixed sequence of jobs (timing problem) can be done polynomially (see, e.g. Hendel and Sourd, 2007). Thus, an important part of the computational effort can be focused on searching for a good or optimal sequence. P Solving exactly 1jrj j j aj Ej þ bj T j appears to be difficult, even for small instances, and much work has been devoted to special cases or heuristic methods (Fry et al., 1987; Lee and Choi, 1995; Bülbül et al., 2007). Exact approaches able to solve instances without release dates and with up to 30 jobs were proposed by Tanaka et al. (2003) and Sourd and Kedad-Sidhoum (2003). More recently, Sourd and Kedad-Sidhoum (2008) present a branch-and-bound algorithm based on a Lagrangian relaxation of resource constraints in the time-indexed formulation (Sousa, 1989) with new dominance rules that can solve most instances with 50 jobs. Yau et al. (2006) develop an hybrid Dynamic Programming – branch-and-bound method, relying on an assignment-based lower bound, allowing to solve instances with up to 50 jobs. Two very recent papers deal successfully with the presence of release dates: Sourd (in press) uses a Lagrangian relaxation of the number of occurrences in the time-indexed formulation and reinforcing valid inequalities to deal successfully with instances with up to 60 jobs. Tanaka and Fujikama (2008) develop a Successive Sublimation Dynamic Programming scheme to handle general single machine problems that can solve optimally all of the instances of the literature of P 1jr j j j aj Ej þ bj T j with up to 200 jobs. * Corresponding author. Tel.: +33 (0)4 42 61 66 76. E-mail address: [email protected] (B. Detienne). 0377-2217/$ - see front matter Ó 2009 Elsevier B.V. All rights reserved. doi:10.1016/j.ejor.2009.02.005
46
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
This paper aims to present new and original elimination rules for this problem. It is organized as follows. In Section 2 we state a 0–1 time-indexed formulation of the problem, and we present a lower bound based on a Lagrangian decomposition. Next, we describe new elimination rules exploiting this decomposition (Section 3). Section 4 is devoted to a branch-and-bound exploiting these results and two Lagrangian upper bounds. Computational experiments are reported in the last section, followed by a conclusion. 2. Lower bound 2.1. Time-indexed formulation Our elimination rules rely on the computation of a lower bound based on a Lagrangian decomposition over the following 0–1 time-indexed formulation. Let us introduce the notations used in the sequel: P T ¼ f0; . . . ; sg: scheduling horizon. We can set s ¼ maxj maxðrj ; dj Þ þ j pj . P P ¼ j2J pj : sum of the processing times. 8j 2 J; ectj (resp. lctj ): earliest (resp. latest) possible completion time possible for job j. 8j 2 J; Dj ¼ fectj ; . . . ; lctj g: completion time window for job j. 8j 2 J; 8t 2 Dj ; cjt ¼ maxðaj ðdj tÞ; bj ðt dj ÞÞ: cost incurred if job j completes at time t. 1 if h 2 ft pj ; . . . ; t 1g : indicates if job j is in processing at time h if it completes at time t. 8j 2 J; 8t 2 Dj ; 8h 2 T; ajth ¼ 0 otherwise
Our problem can be formulated as a time-indexed integer program, where a decision variable xjt is equal to 1 if job j completes at time instant t, 0 otherwise; yh is equal to 1 if a task is processed at time instant h
½ETTISD
XX
min
X
s:t:
cjt xjt
t2Dj
j2J
xjt ¼ 1 8j 2 J;
ð1Þ
t2Dj
XX
ajth xjt 6 yh
8h 2 T;
ð2Þ
t2Dj
j2J
X
yh ¼ P;
ð3Þ
h2T
xjt 2 f0; 1g 8j 2 J; 8t 2 Dj ;
ð4Þ
yh 2 f0; 1g 8h 2 T:
ð5Þ
Constraint (1) ensures that at most one occurrence of each job is processed in any feasible schedule, while constraints (2) and (3) prevent from processing more than one job simultaneously. The use of the surrogate (3) allows the design of the elimination rule described in Proposition 5. 2.2. Lagrangian decomposition Let v ¼ ðv 0 ; . . . ; v s Þ P 0 denote Lagrangian multipliers associated with the Lagrangian dual function: D
L ðv Þ ¼ min
XX j2J
s:t:
0 @cjt þ
t2Dj
t1 X
1
v h A xjt
h¼tpj
X
s þ 1 coupling constraints, we price out (2) to form the
v h yh
h2T
ð1Þ ^ ð3Þ ^ ð4Þ ^ ð5Þ:
It follows that the dual problem ½DP consists in finding a vector of Lagrangian multipliers
v maximizing LD ðv Þ:
½DP ¼ max LD ðv Þ: þs v 2R
The resulting value provides us with a lower bound. 2.3. Solving the dual problem Clearly, computing LD ðv Þ for any vector of Lagrangian multipliers D
L ðv Þ ¼
X
D SPx j ð
vÞ
SPDy ð
v leads to n þ 1 independent subproblems. Indeed, one can write
v Þ:
j2J
~cjt ¼ cjt þ
Pt1
h¼tpj
v h noting the reduced cost of variable xjt , the subproblem associated with each job j can be described by
SPDj x ð
v Þ ¼ min
X
~cjt xjt
t2Dj
s:t:
X
xjt ¼ 1;
t2Dj
xjt 2 f0; 1g 8t 2 Dj :
47
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
This subproblem can be easily solved to optimality using the following OðsÞ strategy: process job j at the time instant minimizing the reduced cost ~cjt . The last subproblem can be written as
X
SPDy ðv Þ ¼ max
v h yh
h2T
X
s:t:
yh ¼ P;
h2T
yh 2 f0; 1g 8h 2 T: Solving this problem merely consists of selecting the P time instants with the highest multipliers, and can be achieved by a simple Oðs log sÞtime sort procedure. In order to optimize the dual problem ½DP, we use a classical sub-gradient algorithm (see, e.g. Held et al. (1974)).
3. Lagrangian domain reductions The elimination rules presented in this section can be seen as a special case of shaving (Carlier and Pinson, 1994; Martin and Schmoys, 1996; Carlier et al., 2004). They consist in testing the feasibility of the problem under certain hypothesis by means of the implicit compuP tation of a lower bound. This idea has already been used in Peridy et al. (2003) for 1jr j j j wj U j , for checking conditions relating to the lateness of a job. This approach also presents similarities with Constraint Programming Based Lagrangian Relaxations (Sellmann and Fahle, 2001; Sellmann, 2004), which, like the method developed by Péridy et al., apply to a single variable at a time. The work described here differs from previous work by the test of more complex assumptions. In this section, we assume that the following values are known: An upper bound UB of the optimal value of the problem at hand. of the Lagrangian multipliers. A vector v Þ. In particular, define An optimal solution to the corresponding Lagrangian subproblem, and its value LD ðv
lj ¼ SPDj x ðv Þ 8j 2 J.
Furthermore, let us introduce the notations:
r max ¼ maxj2J rj . dmax ¼ maxj2J dj . fmax ¼ maxðr max ; dmax Þ. dmin ¼ minj2J dj .
Besides, let SD be the set of feasible solutions of ½ETTISD whose cost is less than or equal to UB, and redefine Dj , for any job j, as the set of time instants where j completes in at least one solution of SD . Three elimination rules are proposed below. The first one checks if a job can complete at a given time instant. Proposition 1. Let j 2 J and h 2 T. Þ lj þ ~cjh > UB, then h R Dj . If LD ðv 0
Proof. Let us consider the set of solutions whose cost is less than or equal to UB, and such that j ends at time h, i.e. SD , with 0 0 8i 2 J fjg; D0i ¼ Di and D0j ¼ fhg. Thus, if LD ðv Þ > UB, then SD ¼ ;. We have 0
LD ðv Þ ¼
X
0
0
SPxD i ðv Þ þ SPDy ðv Þ ¼
i2J
X
0
0
D Dj Dj Dj D D ~ SPDi x ðv Þ þ SP y ðv Þ þ SP x ðv Þ ¼ L ðv Þ SP x ðv Þ þ SP x ðv Þ ¼ L ðv Þ lj þ c jh
i2Jfjg 0
Þ lj þ ~cjh > UB, then SD ¼ ;. Thus, h R Dj . So, if L ðv D
h
The following proposition investigates the selection of a given disjunction. Proposition 2. Let i 2 J, j 2 J fig, and let us denote:
li ¼ minðlct i ; lct j pj Þ. 8t 2 fecti ; . . . ; li g; ej ðtÞ ¼ maxðt þ pj ; ectj Þ. fi!j ¼ minf~cit þ ~cjt0 jt 2 fecti ; . . . ; li g ^ t0 2 fej ðtÞ; . . . ; lct j gg. Þ ¼ LD ðv Þ li lj þ fi!j > UB. LDi!j ðv
Þ > UB, then j is processed before i in any solution of SD . If LDi!j ðv Proof. Let us consider the set of solutions whose cost is less than or equal to UB, such that i completes before or at time instant h and i is h processed before j, i.e. SD , with: 8h 2 fecti ; . . . ; li g; 8k 2 J fi; jg; Dhk ¼ Dk . 8h 2 fecti ; . . . ; li g; Dhi ¼ fect i ; . . . ; hg. 8h 2 fecti ; . . . ; li g; Dhj ¼ fej ðhÞ; . . . ; lct j g. h
h
Þ > UB, then [h2fecti ;...;li g SD ¼ ;. We have Thus, if minh2fecti ;...;li g LD ðv
48
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54 h
LD ðv Þ ¼
X
h
k2J
h
SPDx k ðv Þ þ SPDy ðv Þ ¼
¼ LD ðv Þ li lj þ
min
t2fecti ;...;hg
X
h
k2Jfi;jg
~cit þ
h
h
h
D D i D j Di Dj D i D j D SPDk x ðv Þ þ SP y ðv Þ þ SP x ðv Þ þ SP x ðv Þ ¼ L ðv Þ SP x ðv Þ SP x ðv Þ þ SP x ðv Þ þ SP x ðv Þ
min
t 0 2fej ðhÞ;...;lctj g
~cjt :
Then, h
min
LD ðv Þ ¼ LD ðv Þ li lj þ minf~cit þ ~cjt0 jt 2 fecti ; . . . ; li g ^ t0 2 fej ðtÞ; . . . ; lctj gg;
min
LD ðv Þ ¼ LD ðv Þ li lj þ fi!j :
h2fecti ;...;li g
h2fecti ;...;li g
h
h
Þ li lj þ fi!j > UB, then [h2fecti ;...;li g SD ¼ ;. It follows that i cannot be processed before j in any solution of SD . So, if LD ðv
h
For any pair of jobs ði; jÞ, this property can be checked by a straightforward Dynamic Programming procedure running in OðjDi j þ jDj j pi pj Þ steps. The three following propositions allow to check if an optimal schedule can start at a given time instant. Proposition 3. There is at least one optimal solution without idle time inserted between two jobs in fr max ; . . . ; dmin g and ffmax ; . . . ; sg. Proof. One can easily verify that delaying the job that immediately precedes an idle time in fr max ; . . . ; dmin g leads to a solution whose cost is less than or equal to the cost of the current solution. The symmetrical argument can be independently applied in ffmax ; . . . ; sg. h Proposition 4. Let t 2 T, and denote: ft; . . . ; dmin g if t 6 dmin ; Y ðtÞ ¼ otherwise: ; ffmax ; . . . ; t þ P 1g if t þ P 1 P fmax ; þ Y ðtÞ ¼ ; otherwise: If there exists an optimal solution whose first job starts at t, then there exists an optimal solution such that the processor is busy during all time instants in Y ðtÞ [ Y þ ðtÞ. Proof. Straightforward according to Proposition 3 by considering that any feasible schedule starting at t cannot complete before t þ P 1. h Proposition 5. Let t 2 f0; . . . ; s P þ 1g, and consider the following additional notations:
Y 0 ðtÞ ¼ T ðY ðtÞ [ Y þ ðtÞ [ f0; . . . ; t 1gÞ. 8z 2 R; ðzÞþ ¼ maxð0; zÞ. rðtÞ ¼ P ðdmin tÞþ ðt þ P fmax Þþ : smallest possible total processing time in the interval frmax ; . . . ; dmin 1g [ ffmax þ 1; . . . ; sg. r: permutation of T corresponding to the non-increasing order of the Lagrangian multipliers. Y ðtÞ ¼ frs j s 6 rðtÞg: rðtÞ instants with the highest Lagrangian multipliers, in Y 0 ðtÞ. P ; tÞ ¼ h2Y ðtÞ[Y þ ðtÞ[Y ðtÞ v h. SP 0y ðv
Þ SP 0y ðv ; tÞ > UB, then no optimal schedule starts at time instant t. If SP Dx ðv Proof. Let us assume the existence of an optimal solution starting at time instant t. Then, according to Proposition 4, there exists an optimal solution such that the processor is busy during all instants in Y ðtÞ [ Y þ ðtÞ. This configuration can be modeled by means of the following integer linear program:
½ETTISD 0
min
XX j2J
s:t:
cjt xjt
t2Dj
X
xjt ¼ 1 8j 2 J;
t2Dj
XX j2J
X
ajth xjt 6 yh
8h 2 T;
t2Dj
ð6Þ
yh ¼ P;
h2T
yh ¼ 1 8h 2 Y ðtÞ [ Y þ ðtÞ; xjt 2 f0; 1g 8j 2 J; 8t 2 T; yh 2 f0; 1g 8h 2 T: By dualizing constraints (6), it is clear that SPDx ðv Þ SP 0y ðv ; tÞ is a lower bound of the optimum of ½ETTISD 0 , for any vector of the Lagrangian multipliers v. Since the optimal solution of ½ETTISD 0 is also optimal for ½ETTISD , SPDx ðv Þ SP 0y ðv ; tÞ > UB leads to a contradiction. h Algorithm 1 aims to compute a lower bound associated with the first time instant where an optimal schedule can start. It takes as input a non-increasing order r of the Lagrangian multipliers (an output from the computation of SP Dy ðv Þ). The main loop performs in OðsÞ iterations. Moreover, since the value z never decreases, the global number of iterations required by the two inner loops cannot exceed s. Consequently, the overall complexity of this algorithm is OðsÞ. Similar arguments hold to check if an optimal schedule may end at a given time instant.
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
49
Algorithm 1. Computation of the first time instant where an optimal schedule can start according to Proposition 5 {Compute the initial contribution of Y ðtÞ [ Y þ ðtÞ} true; end tþP1 t ðdmin PÞþ ; ok P P sF h2ft;...;dmin g v h þ h2ffmax ;...;endg v h r P maxð0; dmint Þ þ maxð0; end fmax þ 1Þ {Compute the initial contribution of ðY ðtÞÞ} false s 0; z 0; sV 0; 8t 2 T; sel½t while ðs < rÞ do if rz > dmin then if ððend > fmax Þ ^ ðrz < fmax _ rz > endÞÞ _ ðend < fmax Þ then true; sV sV þ v rz ; s sþ1 sel½rz end if end if z zþ1 end while {Main loop: seek for the first valid instant} while ðLDx ðv Þ þ sF þ sV > UBÞ ^ ðt < dmin Þ do t t þ 1; end end þ 1 {Remove the previous instant from Y ðtÞ} sF sF v t1 if end < fmax then {If there is no new instant in Y þ ðtÞ, update the contribution of Y ðtÞ} while rz < dmin _ sel½rz do z zþ1 end while True sV sV þ v rz ; sel½rz else {Otherwise, update the contribution of Y ðtÞ [ Y þ ðtÞ} sF sF þ v end {If instant end was part of Y ðtÞ, update Y ðtÞ} if sel½end then sV sV v end ; sel½end False while rz < dmin _ ðrz P dmax ^ rz 6 endÞ do z zþ1 end while True sV sV þ v rz ; sel½rz z zþ1 end if end if end while return t
4. Branch-and-bound method The previous elimination rules, jointly with other classical elimination and dominance rules, have been embedded in a branch-andbound method, performing a Depth First Search strategy. 4.1. Integrating Lagrangian domain reduction The rules presented in the previous section have been exploited inside a sub-gradient routine, dealing with the optimization of the dual function. This procedure, providing of course a lower bound, checks the different rules with numerous vectors of Lagrangian multipliers generated during the sub-gradient process. , by seeking for the smallest (resp. greatest) The first rule (Proposition 1) is applied for each job j and the current vector of multipliers v time instant for which Proposition 1 is not active. The corresponding bounds of Dj , coded as a simple interval, are then adjusted to these is not optimal and may not even be near-optimal under the assumption Dj ¼ fhg, the large number of lower bounds values. Although v estimates yields efficient reductions. We use the second rule (Proposition 2) in the same way, for each non-selected disjunction. Algorithm 1 and its symmetrical version are then run in order to apply the third rule (from Proposition 5), possibly reducing the active scheduling horizon. Our strategy, inspired by experimental considerations, consists in performing the reductions every 20 iterations of the sub-gradient procedure, which is in turn used at each node of the search tree to compute a lower bound. After each run of the Lagrangian reductions, the other dominance and elimination rules (detailed below) are launched. This process is iterated until a stabilization of the execution windows occurs. Upper bounds are also derived during this process; their computation is detailed in Section 4.5.
50
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
4.2. Other dominance and elimination rules Each node of the search tree is characterized by a set of selected disjunctions, and one time window for each job. On the one hand, a consistent complete selection corresponds to a sequence of jobs, from which we can derive an optimal schedule. On the other hand, each selection leads to an adjustment of the time windows of the corresponding jobs. For the sake of simplicity in formulating the following propositions, let i ! j; 8i 2 J; 8j 2 J fig stand for job i processed before job j. A number of rules allowing selections and adjustments can be found in the literature. These rules prove to be very powerful as soon as time windows are tight enough, and Lagrangian reductions enable their efficient use. Now, let us state a few of these properties, embedded in our method. Proposition 6. There is at least one optimal solution such that: a
i ! j, for any pair of jobs ði; jÞ such that i is fully processed in fr max ; . . . ; dmin g and apii < pjj . k ! l, for any pair of jobs ðk; lÞ such that l is fully processed in ffmax ; . . . ; sg and bpl > bpk . l
k
Proposition 7 (Immediate selection on a disjunction (Carlier, 1975)). Let i and j be two distinct jobs of J. If ect i þ pj > lct j , then j ! i in any solution. Proposition 8 (Adjustment on a disjunction). Let i and j be two distinct jobs of J. If i ! j, then ect j P ect i þ pj and lct i 6 lct j pj . Carlier and Pinson (1994) propose an Oðn log nÞ algorithm computing all immediate selections and the corresponding adjustments. Proposition 9 (Immediate selections on an ascendant/descendant set (Carlier and Pinson, 1989; Carlier and Pinson, 1990)). Let j 2 J and I # J fjg. P If mini2I[fjg fecti pi g þ pj þ i2I pi > maxi2I lct i , then 8i 2 I; i ! j in any solution. P If mini2I fecti pi g þ pj þ i2I pi > maxi2I[fjg lct i , then 8i 2 I; j ! i in any solution. Proposition 10 (Adjustment on an ascendant/descendant set (Carlier and Pinson, 1989)). Let j 2 J and I # J fig. P P If mini2I[fjg fecti pi g þ pj þ i2I pi > maxi2I lct i , then ectj P maxI0 # I mini2I0 r i þ i2I0 pi þ pj . P P If mini2I fecti pi g þ pj þ i2I pi > maxi2I[fjg lct i , then lct j 6 minI0 # I maxi2I0 di i2I0 pi . An Oðn log nÞ algorithm for optimally adjusting the execution windows using this proposition is described in Carlier and Pinson (1994). 4.3. Branching scheme In our implementation, we restrict the search to the set of potential sequences, since, as pointed out before, we can easily compute an optimal solution relative to a given sequence. Our branch-and-bound relies on an extension of the Edge-Finding branching scheme (see, for instance, Carlier, 1978). Each node of the search tree is characterized by: A sub-sequence I (resp. O) of jobs scheduled first (resp. last) in all derived global sequences. A set U of unscheduled jobs (to be processed between I and O). A set PI # U (resp. PO # U) of jobs that are candidates for extending the sub-sequence I (resp. O), i.e. which can be consistently processed immediately after jobs in I (resp. before jobs in O). One completion time window per job. Depending on the context, we either explicitly add a job to the current sequence, or split a time window. The branching procedure can be summarized as follows: (1) Check sets PI and PO: If U ¼ ; (and thus PI ¼ PO ¼ ;), then the current node is a leaf, and no decision has to be taken. If U – ; and (PI ¼ ; or PO ¼ ;), then the current node is clearly infeasible and a backtrack occurs. If PI ¼ fjg (resp. PO ¼ fjg), then we append the corresponding job in queue of the current sub-sequence I (resp. in head of the current sub-sequence O). Otherwise, we take one of the following decisions: (2) Try to split a relevant time window: As pointed out previously, job domains are coded as simple intervals. Nevertheless, Proposition 1 sometimes detects infeasible completion times in the middle of the current range for a given job, without invalidating completion times associated with the bounds of the corresponding interval. When such a case occurs, and for a large job domain (the threshold is arbitrarily fixed to 10n time instants), we exploit this information by splitting the window in two parts, leading to two child nodes in the search tree. If no such job is identified, we investigate the second decision type. Þ be a lower bound of the total cost of any schedule such that job i pre(3) Or explicitly extend one of the sub-sequences I or O: Let LDi!K ðv cedes all the jobs in K, and defined by:
LDi!K ðv Þ ¼ max LDi!k ðv Þ: k2K
Also, define
LDK!i ðv Þ ¼ max LDk!i ðv Þ: k2K
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
51
Þ 6 minj2O LDOfjg!j ðv Þ. Then we select the job i satisfying Let us now assume that jPIj < jPOj, or that jPIj ¼ jPOj and minj2I LDj!Ifjg ðv i ¼ argminj2I LDj!Ifjg ðv Þ, and create two child nodes in the search tree. In the first one, we append job i to sub-sequence I, while in the second one we remove job i from set PI. Of course, the symmetrical decision applies when set PO appears to be more favorable. At each node of the search tree, the lower bound presented in Section 2 is updated by taking into account the new execution windows resulting from the branching decision and running a few iterations of the modified sub-gradient procedure. 4.4. Initialization The initialization step aims at reducing the search tree by computing the lower bound at the root node and a heuristic upper bound, and pruning jobs time windows. To this end, the modified sub-gradient procedure (see Section 4.1) is run twice. The first pass provides an upper bound and preliminary domain reductions. The second pass takes benefits from the tight upper bound leading to stronger reductions. Preliminary numerical results showed that starting the second pass with null Lagrangian multipliers is beneficial. This fact can be explained as follows: the efficiency of the reductions relies not only on the near-optimality of the multipliers, but also on the diversity of the vectors used (see Sellmann (2004) for a theoretical development). 4.5. Upper bounds The efficiency of branch-and-bound methods is, generally, considerably improved by the computation of tight upper bounds. In our case, this is even more important, because it drastically affects the performance of our elimination rules. We develop two Lagrangian heuristics, both deriving a permutation from the current set of Lagrangian multipliers. The corresponding sequence is then optimally scheduled using the algorithm described in Jòzefowska and Bauman (2006). At the root node, this heuristic sequence is also used for initializing a simple steepest descent meta-heuristic, whose neighborhood relies on permutation and extraction/reinsertion of jobs. In our method, no development effort has been devoted to this step. However, notice that an efficient implementation is possible (Hendel and Sourd, 2006). Below, we explain in detail the two ways of getting a sequence of jobs at each node of the branch-and-bound tree. 4.5.1. Heuristic sequence based on the Lagrangian subproblem One can derive a good sequence from the optimal solution of the Lagrangian subproblems by taking the tasks in the increasing order of completion times in the corresponding current solutions. Already selected disjunctions are taken into account by delaying jobs whose predecessors are not all scheduled yet. 4.5.2. Best pairwise chaining Assuming that there is only a little number of idle times in an optimal solution, we based our second heuristic on the following proposition. Proposition 11. Let i 2 J and j 2 J fig. Let us consider the set Sij of the solutions such that i and j are processed consecutively and with no idle time. Besides, let a ¼ maxðecti ; ect j pj Þ and b ¼ minðlct j ; lct i þ pj Þ, and assume a 6 b (otherwise we have Sij ¼ ;). D D ~ ~ Denoting by zðsÞ the cost of the solution s, 8j 2 J; lj ¼ SP Dj x ðv Þ and 8i 2 J; 8j 2 J fig; Lij ðv Þ ¼ L ðv Þ li lj þ mint2fa;...;bg fc i;tpj þ c j;t g, we ij D s Þ. 2 R ; zðsÞ P Lij ðv have 8s 2 S ; 8v Proof. Clearly, the consecutive processing with no idle time of i and j can be modeled by replacing them by a unique job k, whose duration is pi þ pj , with a cost of ci;tpj þ cj;t and fa; . . . ; bg as completion time window. Obviously, the optimal solutions to the Lagrangian subproblems associated with the other jobs do not change, and the optimal value for the new subproblem is equal to mint2fa;...;bg f~ci;tpj þ ~cj;t g. Þ. h The claimed result is simply obtained by replacing the non-common part in the expression of LD ðv Þ. The remaining jobs are then seIn order to build the solution, we initialize the sequence by selecting the job i minimizing LDi!Jfig ðv quenced in a greedy way by choosing, at each step, the best chaining job as depicted in Algorithm 2. Algorithm 2. Greedy heuristic based on Proposition 11 Þ; s j argminj2J LDj!Jfjg ðv ðjÞ; U J fjg Let V bet the set of jobs whose predecessors are all sequenced while U – ; do Þ; s i argmini2V LDji ðv s [ i; U U fig Update V; j i end while return s
5. Computational results All the tests have been performed on a Personal Computer equipped with 3 gigabyte RAM and a 2.66 gigahertz Intel Core 2 microprocessor, running on MS Windows XP. The code has been compiled with MS Visual.Net 2002.
52
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
5.1. Test bed The tests are mostly performed on problems of the literature. For the case without release dates, we used the instances proposed in Sourd and Kedad-Sidhoum (2008). As described in their paper, the release dates are all null, and the instance generator takes three parameters into account: the number of jobs n, the range factor R and the tardiness factor T. The processing time of each job is first drawn from a discrete uniform distribution f10; . . . ; 99g. The due dates are then generated from a discrete uniform distribution fdmin ; . . . ; dmin þ R Pg, where P dmin ¼ maxð0; PðT R=2ÞÞ and P ¼ j pj . Earliness and tardiness penalties are drawn from f1; . . . ; 5g. 26 instances have been generated for each combination of the following parameters: n 2 f30; 50g, T 2 f0:2; 0:3; 0:4; 0:5; 0:6; 0:7; 0:8g and R 2 f0:2; 0:3; 0:4; 0:5; 0:6; 0:7; 0:8g. For n ¼ 60, five instances are proposed for each combination of T 2 f0:2; 0:5; 0:8g and R 2 f0:2; 0:5; 0:8g. We generated an additional category, similar to this one, for n ¼ 70. The total number of instances without release dates is 2638. In order to test our approach when release dates are present, we used the test bed proposed in Bülbül et al. (2007). The whole set consists of 300 instances for each number of job n 2 f20; 40; 60; 80; 100; 130; 170; 200g. 5.2. Domain reductions This section presents the results obtained by the initialization procedure described in Section 4.4. For the sake of readability, these tests were performed on instances without release dates. Results on instances with release dates are presented for our branch-and-bound in Section 5.3. All elimination and dominance rules presented in this paper were applied. We detail the impact of the different rules at the end of this section. We first report the required computation time, depending on the number of jobs, in Table 1, as well as the part of variables (relating to the formulation presented in Section 2.1) that are discarded by the procedure, and the part of selected disjunctions. One can observe that the relative reductions are approximately constant with respect to the number of jobs. Besides, the heuristic solution provided in output of the procedure is optimal (although not necessarily proved to be optimal) for more than one half of the 50-job instances, and more than 30% of the 70-job instances. Table 2 details the performance of the bounds obtained by the procedure, according to different critical values of the range factor R, for the 50-job instances. We give below an explanation of the degradation of the quality that can be noticed when R rises. These results clearly show that our elimination rules, coupled with classical ones, form an efficient and useful pre-process for P 1jrj j aj Ej þ bj T j . Indeed, they provide good lower and upper bounds, and allow to considerably reduce the number of variables of the problem, in a reasonable computation time. 5.3. Branch-and-bound This section presents the results obtained by our exact method, within a time limit of 1000 seconds, as used by most recent papers studying this problem. 5.3.1. Instances with no release date Table 3 gives the part of instances solved to optimality within the prespecified time limit, the corresponding average computation times and number of nodes explored in the search tree. Notice that this latter only takes instances solved to optimality into account, that is why
Table 1 Mean computation time, part of selected disjunctions and deleted variables after initial domain reduction. # jobs
# deleted variables (%)
# selected disjunctions (%)
Av. time (seconds)
# instances for which heuristic solution is optimal
50 60 70
91 91 91
77 76 75
10.0 18.7 32.8
699/1274 21/45 17/45
Table 2 Mean deviation between upper and lower bound after initial domain reduction for 50-job instances. R
(Upper bound lower bound)/lower bound (%)
0.2 0.5 0.8
0.28 1.00 3.29
Mean for all values of R
1.25
Table 3 Part of instances without release dates solved to optimality within 1000 seconds. # of jobs
% solved to optimality (%)
Average time (seconds)
# of nodes
50 60 70
89 73 51
115.2 218.4 298.1
3145.8 5393.8 4967.4
53
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54 Table 4 Part of 50-job instances without release dates solved to optimality with respect to some generation parameters. T
R 0.2
0.5
0.8
0.2 0.5 0.8 Average
100% 100% 100% 99%a
100% 92% 77% 90%a
100% 73% 58% 74%a
a b c
Average
99%b 90%b 77%b 89%c
Average values are computed from the whole set of the tardiness factor values, i.e. T 2 f0:2; 0:3; 0:4; 0:5; 0:6; 0:7; 0:8g. Average values are computed from the whole set of the range factor values, i.e. R 2 f0:2; 0:3; 0:4; 0:5; 0:6; 0:7; 0:8g. Overall average is computed from the whole set of 50-job instances.
the number of nodes explored for the 70-job instances appears smaller than the one reported for 60-job instances. A more correct idea can be given by considering the results obtained within a time limit of 1 hour: 84% of the 60-job (resp. 64% of the 70-job) instances are then solved with an average number of nodes equal to 8085 (resp. 14532) and an average computing time of 688 seconds (resp. 848 seconds). Table 4 gives an indication of the tolerance of our method with respect to the parameters R and T. We can see clearly that our Branchand-Bound performs well when due dates are grouped ðR ¼ 0:2Þ. It can be easily explained by the fact that dominance rules at the extremities of the schedule (Proposition 6) are more often used, because their inactive range is determined by fdmin ; . . . ; dmax g. The same argument applies to the worse results obtained when R ¼ 0:8. The good performance obtained with small values of the tardiness factor can be attributed to the important part of the total processing time that has to be scheduled after dmax . In this case, both Propositions 6 and 5 can be used to select disjunctions and efficiently reduce the execution windows. In order to measure the contribution of our new rules to the performance of the exact method, Table 5 reports the results obtained when applying different combinations of them. To get relevant results for all methods, these tests were performed on 30-job instances, under a time limit of 30 seconds. Using Proposition 1 (denoted by R1 in the Table 5) is clearly beneficial compared to the only use of edge finding techniques (EF) and the dominance rules (D: Proposition 6). The application of Proposition 2 (R2) speeds up the process by an improved pruning of the search tree. Proposition 5 (R5) allows to reduce even more the number of expanded nodes in the search tree, and correlatively the total CPU time. 5.3.2. Instances with release dates As mentioned above, our experiments are based on the test bed proposed in Bülbül et al. (2007). The generation of these instances depends on more parameters than the process already described, determining minimum and maximum processing times and penalties. Besides, release dates are drawn from a uniform distribution in f0; . . . ; Pg (thus, we can have r max > dmax ). The combination of these parameters leads to 300 instances per number of jobs. For more details, we refer to Bülbül et al. (2007). In the presence of release dates, our branch-and-bound fails at solving instances with 60 jobs and more. Table 6 gives the results for the sets with 20 and 40 tasks. Once again, the poor performance of our method can be explained by the restricted range where Proposition 6 is valid, preventing deductions on selections at the beginning of the schedule. 5.3.3. Comparison with the performance of other recent approaches It can be noticed that the bound exploited in this paper is theoretically equivalent to the classical one applied to the same problem by Sourd and Kedad-Sidhoum (2008). Indeed, we can first observe that there exists at least one integer optimal solution associated with each subproblem occurring in the computation of this bound. Thus, the dual problem ½DP has the same optimal value than the continuous relaxation ½CETTISD of ½ETTISD (integrality property). In addition, one can verify that this latter is equivalent to the linear relaxation ½CETTID of the classical time-indexed formulation (for a description of this model, see, e.g. Kedad-Sidhoum et al., 2008), since it is possible to build a feasible solution of ½CETTISD from any feasible solution of ½CETTID with the same cost, and conversely. Moreover, the bound obtained by Lagrangian relaxation of the resource constraints in the classical time-indexed formulation is equivalent to ½CETTID . So, the bounds used in both papers are theoretically equivalent. The use of the surrogate allows the design of one of the
Table 5 Impact of the different rules on the branch-and-bound performance. Rules enabled
EF + D
EF + R1
EF + D + R1
EF + D + R1 + R2
EF + D + R1 + R2 + R5
% optimal Av. time (seconds) # nodes
49% 8.5 251.0
93% 4.6 160.8
93% 4.5 143.2
96% 4.3 135.5
96% 3.8 115.9a
a
22% of the 30-job instances are solved at the root node when all rules are applied.
Table 6 Part of instances with release dates solved to optimality within 1000 seconds. # of jobs
% solved to optimality
Average time (seconds)
# of nodes
20 40
100% 93%
1.3 106.4
73.2a 2897.9
a
39% of the 20-job instances are solved at the root node.
54
B. Detienne et al. / European Journal of Operational Research 201 (2010) 45–54
new elimination rules, that proves to be efficient in practice and makes the originality of this paper. Indeed, we benchmarked our results against the branch-and-bound described in Sourd and Kedad-Sidhoum (2008), whose code, as well as the test bed used, are provided by the authors on their home page. This code was compiled and run in the same conditions as our methods. In the case without release dates, the performances of both methods are similar for 50-job instances. However, the algorithm of Sourd and Kedad-Sidhoum can solve only 47% of the 60-job instances and 16% of the 70-job instances. Besides, this approach leaves some 20-job instances with release dates open. Notice that since the first submission of this paper, two new approaches have been proposed, in Sourd (in press) and Tanaka and Fujikama (2008). According to the authors, they both outperform the branch-and-bound based on the Lagrangian reductions, since they solve all instances of the test bed proposed by Bülbül et al. (2007) with up to 60 and 200 jobs, respectively. 6. Conclusion This paper presents new elimination rules for the single machine problem with general earliness and tardiness penalties subject to release dates. These rules prove to be a powerful tool for reducing job time windows. Several extensions to this work can be considered, like exploiting new consistency tests: one can, for example, easily test the presence of idle times in an optimal schedule by a slight modification of Proposition 5. Besides, it would be interesting to test different branching P schemes for this problem, and to apply similar methods to other combinatorial optimization problems, like Pmjrj j j aj Ej þ bj T j . References Baker, K.R., Scudder, G.D., 1990. Sequencing with earliness and tardiness penalties: A review. Operations Research, 0030-364X 38 (1), 22–36. Bülbül, K., Kaminsky, P., Yano, C., 2007. Preemption in single machine earliness/tardiness scheduling. Journal of Scheduling 10 (4–5), 271–292. Carlier, J., 1975. Thèse de troisième cycle. Carlier, J., 1978. Ordonnancements à contraintes disjonctives. RAIRO 12, 333–351. Carlier, J., Pinson, E., 1989. An algorithm for solving the job-shop problem. Management Science, 0025-1909 35 (2), 164–176. Carlier, J., Pinson, E., 1990. A practical use of jackson’s preemptive schedule for solving the job shop problem. Annals of Operations Research, 0254-5330 26 (1–4), 269–287. Carlier, J., Pinson, E., 1994. Adjustments of heads and tails for the job-shop problem. European Journal of Operational Research 78, 146–161. Carlier, J., Péridy, L., Pinson, E., Rivreau, D., 2004. Chapter IV: Elimination Rules for Job-Shop Scheduling Problem – Overview and Extensions. Handbook of Scheduling: Algorithms, Models, and Performance Analysis. CRC Press. pp. 1–19. Fry, T.D., Armstrong, R.D., Blackstone, J.H., 1987. Minimizing weighted absolute deviation in single machine scheduling. IIE Transactions 19, 445–450. Hassin, R., Shani, M., 2005. Machine scheduling with earliness tardiness and non-execution penalties. Computers and Operations Research, 0305-0548 32 (3), 683–705. Held, M., Wolfe, P., Crowder, H.P., 1974. Validation of sub-gradient optimization. Mathematical Programming 6, 62–88. Hendel, Y., Sourd, F., 2006. Efficient neighborhood search for the one-machine earliness–tardiness scheduling problem. European Journal of Operational Research 173 (1), 108–119. Hendel, Y., Sourd, F., 2007. An improved earliness–tardiness timing algorithm. Computers and Operations Research 34 (10), 2931–2938. Jòzefowska, J., Bauman, J., 2006. Minimizing the earliness–tardiness costs on a single machine. Computers and Operations Research 33 (11), 3219–3230. Kanet, J.J., Sridharan, V., 2000. Scheduling with inserted idle time: Problem taxonomy and literature review. Operations Research, 0030-364X 48 (1), 99–110. Kedad-Sidhoum, S., Rios Solis, Y.A., Sourd, F., 2008. Lower bounds for the earliness–tardiness scheduling problem on parallel machines with distinct due dates. European Journal of Operational Research 189 (3), 1305–1316. Lee, C.Y., Choi, J.Y., 1995. A genetic algorithm for job sequencing problems with distinct due dates and general early-tardy penalty weights. Computers and Operations Research, 0305-0548 22 (8), 857–869. Lenstra, J., Rinnoy Kan, A., Brucker, P., 1977. Complexity of machine scheduling problems. Annals of Discrete Mathematics 1, 343–362. Martin, P., Schmoys, D.B., 1996. A new approach to computing optimal schedules for the job-shop scheduling problem. In: Proceedings of the 5th International IPCO Conference, pp. 389–403. Peridy, L., Pinson, E., Rivreau, D., 2003. Using short-term memory to minimize the weighted number of late jobs on a single machine. European Journal of Operational Research 148 (0), 591–603. Sellmann, M., 2004. Theoretical foundations of CP-based Lagrangian relaxation. In: Principles and Practice of Constraint Programming (CP). LNCS, vol. 3258. Springer, pp. 634– 647. Sellmann, M., Fahle, T., 2001. CP-based Lagrangian relaxation for a multimedia application.