Lagrangian Domain Reductions for the Single Machine Earliness-Tardiness Problem with Release Dates

Transcription

1 Lagrangian Domain Reductions for the Single Machine Earliness-Tardiness Problem with Release Dates Boris Detienne a, Éric Pinsonb and David Rivreau b a École Nationale Supérieure des Mines de Saint-Étienne, Centre de Microélectronique de Provence Georges Charpak, 880 route de Mimet, Gardanne, France b Institut de Mathématiques Appliquées, 3 place André-Leroy Angers, France Abstract 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. Key words: Scheduling, Just-in-time, Elimination rules, Lagrangian relaxation, Exact method 1 Introduction In a 1 r j j α j E j + β j 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 J is given an integer processing time p j, a release date r j, a due date d j, and two positive penalties α j and β j. The earliness (resp. tardiness) of job j is defined as E j = max(d j C j, 0) (resp. T j = max(c j d j, 0)), where C j denotes the completion time of j, and a cost α j E j + β j T j is incurred if the completion time of j is different than its due date. Corresponding author. address: boris.detienne@emse.fr (Boris Detienne). Preprint submitted to Elsevier 28 October 2008

2 Reviews about this problem and variants can be found in Baker and Scudder (1990) or Kanet and Sridharan (2000). Since its special case 1 j w j T j is NP-hard in the strong sense (Lenstra et al., 1977), this problem is clearly NPhard. 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. (2004) present a computational study of lower bounds for the general case, in which one can notice the excellent quality of timeindexed 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. Solving exactly 1 r j j α j E j + β j 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 (To appear) uses the Lagrangian relaxation of the number of occurrences of the time-indexed formulation and reinforcing valid inequalities to solve instances with up to 60 jobs, and Tanaka et al. (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 1 r j j α j E j + β j T j with up to 200 jobs. 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

3 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: T = {0,..., τ}: scheduling horizon. We can set τ = max j max(r j, d j )+ j p j P = j J p j : sum of the processing times j J, ect j (resp. lct j ): earliest (resp. latest) possible completion time possible for job j j J, D j = {ect j,..., lct j }: completion time window for job j j J, t D j, c jt = max (α j (d j t), β j (t d j )): cost incurred if job j completes at time t j J, t D j, θ T, a jt θ = 1 if θ {t p j,..., t 1} : indicates if job 0 otherwise j is in processing at time θ if it completes at time t Our problem can be formulated as a time-indexed integer program, where a decision variable x jt is equal to 1 if job j completes at time instant t, 0 otherwise; y θ is equal to 1 if a task is processed at time instant θ. [ET T IS D ] Minimize subject to j J c jt x jt t D j x jt = 1 j J (1) t D j a jt θ x jt y θ θ T (2) j J t D j y θ = P (3) θ T x jt {0, 1} j J, t D j (4) y θ {0, 1} θ T (5) Constraints (1) ensure 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. 3

4 2.2 Lagrangian decomposition Letting v = (v 0,..., v τ ) 0 denote Lagrangian multipliers associated with the τ + 1 coupling constraints, we price out (2) to form the Lagrangian dual function: L D (v) = min t 1 c jt + v θ x jt v θ y θ j J t D j θ=t p j θ T s.t. (1) (3) (4) (5) It follows that the dual problem [DP ] consists in finding a vector of Lagrangian multipliers v maximizing L D (v): [DP ] = max v R +τ LD (v) The resulting value provides us with a lower bound. 2.3 Solving the dual problem Clearly, computing L D (v) for any vector of Lagrangian multipliers v leads to n + 1 independent subproblems. Indeed, one can write: L D (v) = SP D j x (v) SPy D (v) j J c jt = c jt + t 1 θ=t p j v θ noting the reduced cost of variable x jt, the subproblem associated with each job j can be described by: SPx Dj (v) = min c jt x jt t D j s.t. t D j x jt = 1 x jt {0, 1} t D j This subproblem can be easily solved to optimality using the following O(τ) strategy: process job j at the time instant minimizing the reduced cost c jt. The last subproblem can be written as: 4

5 SPy D (v) = max v θ y θ θ T s.t. y θ = P θ T y θ {0, 1} θ T Solving this problem merely consists of selecting the P time instants with the highest multipliers, and can be achieved by a simple O(τlogτ)-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 computation of a lower bound. This idea has already been used in Peridy et al. (2003) for 1 r j j w j 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 a vector v of the Lagrangian multipliers an optimal solution to the corresponding Lagrangian subproblem, and its value L D ( v). In particular, define µ j = SPx Dj ( v), j J Furthermore, let us introduce the notations: r max = max j J r j d max = max j J d j ζ max = max(r max, d max ) d min = min j J d j Besides, let S D be the set of feasible solutions of [ET T IS D ] whose cost is less than or equal to UB, and redefine D j, for any job j, as the set of time instants where j completes in at least one solution of S D. 5

6 Three elimination rules are proposed below. The first one checks if a job can complete at a given time instant. Proposition 1 Let j J and θ T. If L D ( v) µ j + c jθ > UB, then θ / D j. PROOF. Let us consider the set of solutions whose cost is less than or equal to UB, and such that j ends at time θ, i.e. S D, with i J {j}, D i = D i and D j = {θ}. Thus, if L D ( v) > UB, then S D =. We have: L D ( v) = SP D i x ( v) + SPy D ( v) i J = ( v) + SPy D ( v) + SP D j ( v) i J {j} SP Di x = L D ( v) SPx Dj ( v) + SP D j x ( v) = L D ( v) µ j + c jθ x So, if L D ( v) µ j + c jθ > UB, then S D =. Thus, θ / D j. The following proposition investigates the selection of a given disjunction. Proposition 2 Let i J, j J {i}, and let us denote: l i = min(lct i, lct j p j ) t {ect i,..., l i }, e j (t) = max(t + p j, ect j ) f i j = min{ c it + c jt t {ect i,..., l i } t {e j (t),..., lct j }} L D i j( v) = L D ( v) µ i µ j + f i j > UB If L D i j( v) > UB, then j is processed before i in any solution of S D. 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 θ and i is processed before j, i.e. S Dθ, with: θ {ect i,..., l i }, k J {i, j}, D θ k = D k θ {ect i,..., l i }, D θ i = {ect i,..., θ} θ {ect i,..., l i }, D θ j = {e j (θ),..., lct j } Thus, if min θ {ecti,...,l i } L Dθ ( v) > UB, then θ {ecti,...,l i }S Dθ =. We have: 6

7 Then, L Dθ ( v) = k J = SP Dθ k x k J {i,j} ( v) + SPy Dθ ( v) SP Dk x = L D ( v) SP Di x ( v) + SP D y ( v) + SP Dθ i x ( v) SP Dj x ( v) + SP Dθ i x = L D ( v) µ i µ j + min t {ect i,...,θ} c it + ( v) + SP Dθ j ( v) x ( v) + SP Dθ j ( v) x min t {e j (θ),...,lct j } c jt min θ {ect i,...,l i } LDθ ( v) = L D ( v) µ i µ j + min{ c it + c jt t {ect i,..., l i } t {e j (t),..., lct j }} min θ {ect i,...,l i } LDθ ( v) = L D ( v) µ i µ j + f i j So, if L D ( v) µ i µ j + f i j > UB, then θ {ecti,...,l i }S Dθ i cannot be processed before j in any solution of S D. =. It follows that For any pair of jobs (i, j), this property can be checked by a straightforward Dynamic Programming procedure running in O( D i + D j p i p j ) 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 {r max,..., d min } and {ζ max,..., τ}. PROOF. One can easily verify that delaying the job that immediately precedes an idle time in {r max,..., d min } 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 {ζ max,..., τ}. Proposition 4 Let t T, and denote: {t,..., d Y min } if t d min (t) = otherwise {ζ Y + max,..., t + P 1} if t + P 1 ζ max (t) =. otherwise 7

8 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. Proposition 5 Let t {0,..., τ P + 1}, and consider the following additional notations: Y 0 (t) = T (Y (t) Y + (t) {0,..., t 1}) z R, (z) + = max(0, z) r(t) = P (d min t) + (t + P ζ max ) + : smallest possible total processing time in the interval {r max,..., d min 1} {ζ max + 1,..., τ} σ: permutation of T corresponding to the non-increasing order of the Lagrangian multipliers Y (t) = {σ s s r(t)}: r(t) instants with the highest Lagrangian multipliers, in Y 0 (t) SP y( v, t) = v θ θ Y (t) Y + (t) Y (t) If SP D x ( v) SP y( v, t) > UB, then no optimal schedule starts at time instant t. 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: [ET T IS D ] minimize subject to j J c jt x jt t D j x jt = 1 j J t D j a jt θ x jt y θ θ T (6) j J t D j y θ = P θ T y θ = 1 x jt {0, 1} y θ {0, 1} θ Y (t) Y + (t) j J, t T θ T By dualizing constraints (6), it is clear that SP D x (v) SP y(v, t) is a lower bound of the optimum of [ET T IS D ], for any vector of the Lagrangian multipliers 8

9 v. Since the optimal solution of [ET T IS D ] is also optimal for [ET T IS D ], SPx D (v) SP y(v, t) > UB leads to a contradiction. 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 σ of the Lagrangian multipliers (an output from the computation of SP D y (v)). The main loop performs in O(τ) iterations. Moreover, since the value z never decreases, the global number of iterations required by the two inner loops cannot exceed τ. Consequently, the overall complexity of this algorithm is O(τ). Similar arguments hold to check if an optimal schedule may end at a given time instant. 4 Branch-And-Bound method The previous elimination rules, jointly with other classical elimination and dominance rules, have been embedded in a branch-and-bound 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 subgradient 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. The first rule (Proposition 1) is applied for each job j and the current vector of multipliers v, by seeking for the smallest (resp. greatest) time instant for which Proposition 1 is not active. The corresponding bounds of D j, coded as a simple interval, are then adjusted to these values. Although v is not optimal and may not even be near-optimal under the assumption D j = {θ}, the large number of lower bounds 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 9

10 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)} t (d min P ) + ; ok true ; end t + P 1 sf θ {t,...,d min } v θ + θ {ζ max,...,end} v θ r P max(0, d min t ) + max(0, end ζ max + 1) {Compute the initial contribution of (Y (t))} s 0 ; z 0 ; sv 0 ; t T, sel[t] false while (s < r) do if σ z > d min then if ((end > ζ max ) (σ z < ζ max σ z > end)) (end < ζ max ) then sel[σ z ] true ; sv sv + v σz ; s s + 1 end if end if z z + 1 end while {Main loop: seek for the first valid instant} while (L D x (v) + sf + sv > UB) (t < d min ) do t t + 1 ; end end + 1 {Remove the previous instant from Y (t)} sf sf v t 1 if end < ζ max then {If there is no new instant in Y + (t), update the contribution of Y (t)} while σ z < d min sel[σ z ] do z z + 1 end while sv sv + v σz ; sel[σ z ] T rue 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] F alse while σ z < d min (σ z d max σ z end) do z z + 1 end while sv sv + v σz z z + 1 end if end if end while return t ; sel[σ z ] T rue 10

11 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 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, i J, j J {i} 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: i j, for any pair of jobs (i, j) such that i is fully processed in {r max,..., d min } and α i p i < α j p j k l, for any pair of jobs (k, l) such that l is fully processed in {ζ max,..., τ} and β l p l > β k p k Proposition 7 Immediate selection on a disjunction (Carlier, 1975) Let i and j be two distinct jobs of J. If ect i + p j > 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 ect i + p j and lct i lct j p j Carlier and Pinson propose, in Carlier and Pinson (1994), 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, 1990) Let j J and I J {j}. If min i I {j} {ect i p i } + p j + i I p i > max lct i, then i I, i j in any solution. i I 11

12 If min {ect i p i } + p j + p i > max lct i, then i I, j i in any solution. i I i I {j} i I Proposition 10 Adjustment on an ascendant/descendant set (Carlier and Pinson, 1989) Let j J and I J {i}. { } If min i I {j} {ect i p i }+p j + i I p i > max lct i, then ect j max i I I I If min {ect i p i } + p j + p i > max lct i, then lct j min i I i I {j} I I i I min r i I i + p i +p j { i I } max d i p i i I i I An O(n log n) algorithm for optimally adjusting the execution windows using this proposition is described in Carlier and Pinson (1994) 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 P I U (resp. P O 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 P I and P O: If U = (and thus P I = P O = ), then the current node is a leaf, and no decision has to be taken. If U and (P I = or P O = ), then the current node is clearly infeasible and a backtrack occurs. If P I = {j} (resp. P O = {j}), 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 some- 12

13 times 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. (3) Or explicitly extend one of the sub-sequences I or O: Let L D i K( v) be a lower bound of the total cost of any schedule such that job i precedes all jobs in K, and defined by: Also, define: L D i K( v) = max k K LD i k( v) L D K i( v) = max k K LD k i( v) Let us now assume that P I < P O, or that P I = P O and min j I L D j I {j} ( v) min j O L D O {j} j ( v). Then we select the job i satisfying i = argmin j I L D j I {j} ( 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 P I. Of course, the symmetrical decision applies when set P O 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). 13

14 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/re-insertion 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 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 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 J and j J {i}. Let us consider the set S i j of the solutions such that i and j are processed consecutively and with no idle time. Besides, let a = max(ect i, ect j p j ) and b = min(lct j, lct i + p j ), and assume a b (otherwise we have S i j = ). Denoting by z(s) the cost of the solution s, j J, µ j = SPx Dj i J, j J {i}, L D i j( v) = L D ( v) µ i µ j + have: s S i j, v R τ, z(s) L D i j( v). ( v) and min { c i,t p j + c j,t }, we t {a,...,b} 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 p i +p j, with 14

15 a cost of c i,t pj + c j,t and {a,..., b} 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 min t {a,...,b} { c i,t pj + c j,t }. The claimed result is simply obtained by replacing the non-common part in the expression of L D ( v). In order to build the solution, we initialize the sequence by selecting the job i minimizing L D i J {i} ( v). The remaining jobs are then sequenced 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 j argmin j J L D j J {j} ( v) ; s (j) ; U J {j} Let V bet the set of jobs whose predecessors are all sequenced while U do i argmin i V L D j i( v) ; s s i ; U U {i} Update V ; j i end while return s 5 Computational results All tests have been performed on a Personal Computer equipped with 3 GB RAM and a 2.66 GHz Intel Core 2 microprocessor, running on MS Windows XP. The code has been compiled with MS Visual.Net 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 {10,..., 99}. The due dates are then generated from a discrete uniform distribution {d min,..., d min + R P }, where d min = max(0, P (T R/2)) and P = j p j. Earliness and tardiness penalties are drawn in {1,..., 5}. 26 instances have been generated for each combination of the following parameters: n {30, 50}, T {0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8} and R {0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8}. For n = 60, 5 instances are proposed for each combination of T {0.2, 0.5, 0.8} and 15

16 R {0.2, 0.5, 0.8}. We generated an additional category, similar to this one, for n = 70. The total number of instances without release dates is 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 {20, 40, 60, 80, 100, 130, 170, 200}. 5.2 Domain reductions This section presents the results obtained by the initialization procedure described in section 4.4. For a 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. # jobs # deleted # selected Av. Time (s.) # instances for which variables disjunctions heuristic solution is optimal 50 91% 77% / % 76% / % 75% /45 Table 1 Mean computation time, part of selected disjunctions and deleted variables after initial domain reduction 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 1 r j α j E j + β j 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. 16

17 R (Upper bound-lower bound) / Lower bound % % % Mean for all values of R 1.25% Table 2 Mean deviation between upper and lower bound after initial domain reduction for 50-job instances 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 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 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 ) and an average computing time of 688 seconds (resp. 848 seconds). # of jobs % solved to optimality Average time (s.) # of nodes 50 89% % % Table 3 Part of instances without release dates solved to optimality within 1000 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 Branch-and-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 {d min,..., d max }. 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 17

18 R T Average a % 100% 100% 99% % 92% 73% 90% % 77% 58% 77% Average a 99% 90% 74% 89% Table 4 Part of 50-job instances without release dates solved to optimality with respect to some generation parameters. a Average values are reported for T {0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8} and R {0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8} time that has to be scheduled after d max. In this case, both Propositions 6 and 5 can be used to select disjunctions and efficiently reduce the execution windows. Rules enabled EF+D EF+R1 EF+D EF+D EF+D +R1 +R1+R2 +R1+R2+R5 % optimal 49% 93% 93% 96% 96% Av. Time (s.) # nodes a Table 5 Impact of the different rules on the Branch-and-Bound performance. a 22% of the 30-job instances are solved at the root node when all rules are applied. 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 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 {0,..., P } (thus, we can have r max > d max ). 18

19 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). # of jobs % solved to optimality Average time (s.) # of nodes % a 40 93% Table 6 Part of instances with release dates solved to optimality within 1000 seconds. a 39% of the 20-job instances are solved at the root node. 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 Comparison with the performance of other recent approaches 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 (To appear) and Tanaka et al. (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 in 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 jobs 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 19

20 would be interesting to test different branching schemes for this problem, and to apply similar methods to other combinatorial optimization problems, like P m r j j α j E j + β j T j. References K. R. Baker and G. D. Scudder. Sequencing with earliness and tardiness penalties: a review. Operations Research, 38(1):22 36, ISSN X. K. Bülbül, P. Kaminsky, and C. Yano. Preemption in single machine earliness/tardiness scheduling. Journal of scheduling, 10(4-5): , J. Carlier. Thèse de troisième cycle, J. Carlier. Ordonnancements à contraintes disjonctives. RAIRO, 12: , J. Carlier and E. Pinson. An algorithm for solving the job-shop problem. Management Science, 35(2): , ISSN J. Carlier and E. Pinson. Adjustments of heads and tails for the job-shop problem. European Journal of Operational Research, 78: , J. Carlier and E. Pinson. A practical use of jackson s preemptive schedule for solving the job shop problem. Annals of Operations Research, 26(1-4): , ISSN J. Carlier, L. Péridy, E. Pinson, and D. Rivreau. Handbook of scheduling: Algorithms, Models, and Performance Analysis, chapter Chapter IV: Elimination rules for job-shop scheduling problem: overview and extensions, pages CRC Press, T. D. Fry, R. D. Armstrong, and J. H. Blackstone. Minimizing weighted absolute deviation in single machine scheduling. IIE Transactions, 19: , R. Hassin and M. Shani. Machine scheduling with earliness, tardiness and non-execution penalties. Computers and Operations Research, 32(3): , ISSN M. Held, P. Wolfe, and H.P. Crowder. Validation of sub-gradient optimization. Mathematical Programming, 6:62 88, Y. Hendel and F. Sourd. Efficient neighborhood search for the one-machine earliness-tardiness scheduling problem. European Journal of Operational Research, 173(1): , Y. Hendel and F. Sourd. An improved earliness-tardiness timing algorithm. Computers & Operations Research, 34(10): , J. Jòzefowska and J. Bauman. Minimizing the earliness-tardiness costs on a single machine. Computers & Operations Research, 33(11): , J. J. Kanet and V. Sridharan. Scheduling with inserted idle time: Problem taxonomy and literature review. Operations Research, 48(1):99 110, ISSN X. 20

21 S. Kedad-Sidhoum, Y. A. Rios Solis, and F. Sourd. Lower bounds for the earliness-tardiness scheduling problem on parallel machines. In A. Oulamara and M.C. Portmann, editors, Proceedings of the 9th International Conference on Project Management and Scheduling, pages , April C. Y. Lee and J. Y. Choi. A genetic algorithm for job sequencing problems with distinct due dates and general early-tardy penalty weights. Comput. Oper. Res., 22(8): , ISSN J. Lenstra, A. Rinnoy Kan, and P. Brucker. Complexity of machine scheduling problems. Annals of Discrete Mathematics, 1: , P. Martin and D. B. Schmoys. A new approach to computing optimal schedules for the job-shop scheduling problem. In Proceedings of the 5th International IPCO Conference, pages , L. Peridy, E. Pinson, and D. Rivreau. Using short-term memory to minimize the weighted number of late jobs on a single machine. European Journal of Operational Research, 148(0): , M. Sellmann and T. Fahle. Cp-based Lagrangian relaxation for a multimedia application, URL citeseer.ist.psu.edu/sellmann01cpbased.html. M. Sellmann. Theoretical foundations of CP-based Lagrangian relaxation. In Principles and Practice of Constraint Programming (CP) LNCS 3258, pages , Springer, F. Sourd and S. Kedad-Sidhoum. A faster branch-and-bound algorithm for the earliness-tardiness scheduling problem. Journal of Scheduling, 11(1): 49 58, F. Sourd and S. Kedad-Sidhoum. The one machine scheduling with earliness and tardiness penalties. Journal of Scheduling, 6(6): , F. Sourd. New Exact Algorithms for One-Machine Earliness-Tardiness Scheduling. INFORMS Journal of Computing, To appear. J.P. Sousa. Time-indexed Formulation of Non-preemptive Single Machine Scheduling Problems. PhD thesis, Université Catholique de Louvain, S. Tanaka, T. Sasaki, and M. Araki. A branch-and-bound algorithm for the single-machine weighted earliness-tardiness scheduling problem with jobindependent weights. In IEEE International Conference on Systems, Man and Cybernetics, pages , S. Tanaka, and S. Fujikama An efficient exact algorithm for general singlemachine scheduling with machine idle time. In IEEE International Conference on Automation Science and Engineering, pages , H. Yau, Y. Pan, and L. Shi. New solution approaches to the general single machine earliness-tardiness problem. In IEEE Transactions on Automation Science and Engineering,