Exponential neighborhood search for a parallel machine scheduling problem

Transcription

1 xponential neighborhood search for a parallel machine scheduling problem Y.A. Rios Solis and F. Sourd LIP6 - Université Pierre et Marie Curie 4 Place Jussieu, Paris Cedex 05, France Abstract We consider the parallel machine scheduling problem where jobs have different earlinesstardiness penalties and a restrictive common due date. his problem is NP-hard in the strong sense. In this paper we define an exponential size neighborhood for this problem and prove that finding the local minimum in it is an NP-hard problem. he main contribution of this paper is to propose a pseudo-polynomial algorithm that finds the best solution of the exponential neighborhood. Additionally, we present some computational results. Keywords: Parallel machine scheduling; arliness-tardiness penalties; Large neighborhood search; Dynamic programming. Introduction During the last years, just-in-time production has received a special interest. his concept reflects the aim to produce as close to the due date as possible in order to avoid storage costs when the production is early and additional costs resulting from a tardy delivery. he scheduling problem we study in this article stems from this just-in-time philosophy. he problem we are interested in is about n jobs, J = {1, 2,..., n}, that are to be executed on m identical parallel machines. ach machine M j (j = 1,..., m) is available from time 0 and can only execute one job at the time. ach job i is also available from time 0 and has an execution time p i. he execution of a job is not preemptive: once the job starts it cannot be interrupted. We consider for this research the hypothesis of a common due date d = d i ( i J), at which ideally all the jobs must end. From a practical point of view, a common due date appears when a set of jobs must be produced simultaneously to be assembled in a later production level or when a client orders various goods that are to be delivered at the same moment. he aim is to find a schedule S that specifies the completion time C i of each job. A job is early when it completes before the common due date. Given S, the earliness of a job i is defined as i = max {0, (d C i )}. Similarly, when a job ends after the due date then its tardiness is i = max {0, (C i d)}. Jobs whose completion time is d are said on time. ach job i has an earliness penalty α i and a tardiness one β i. hen, the total cost of a schedule S is f(s) = i J (α i i + β i i ). Corresponding author. el.: +33(0) mail address: yasmin.rios@lip6.fr. Partial funding provided by CONACy, the Mexican National Council of Science and echnology. 1

2 he common due date is said to be large when i J p i d. his large due date (d l ) allows to ignore the constraint that makes the schedule to start at or after time 0 on every machine. In an intuitive way, if the optimal cost cannot decrease when the common due date increases, then the due date is unrestricted or large. Otherwise, the due date is called restrictive (d r ). In this case, the due date is early enough to act as a constraint on the scheduling decision. For a more explicit definition of a restrictive due date we refer the reader to the article of Lauff and Werner [20]. he scheduling problem we investigate in this article has a restrictive common due date. In the standard classification scheme of Graham et al. [12] the problem we study can be written as P d i = d r i (α i i + β i i ) (where P is for the identical parallel machine environment and d i = d r means that all the jobs have the same restrictive due date). Several common due date scheduling surveys can be pointed out: Baker and Scudder [2], Gordon et al. [11] and Lauff and Werner [21]. he parallel machine problem without earliness or tardiness penalties and a large common due date is investigated by Hall [13] and Sundaraghavan and Ahmed [27]. hey generalize Kanet s algorithm ([17]). mmons [8] proposes a O(nlogn) algorithm for Q d i = d l i ( i + i ) and Q d i = d l i (α i + β i ), where Q means the parallel machines are uniform (different dependent speeds). He models the problem with a transportation formulation. Kubiak et al. [19] present a O(n 3 ) algorithm for R d i = d l i ( i + i ), where R denotes an unrelated parallel machine environment (the machines have different independent speeds). Sun and Wang [26] consider the identical parallel machine problem with a large due date P d i = d l i w i (C i d) where the weight w i of each job is proportional to its processing time. hey show that even for m = 2 the problem is NP-hard in the ordinary sense. hey formulate a dynamic programming algorithm and consider two list scheduling heuristics. Chen and Powell [6] propose a column generation algorithm for the identical parallel machine problem with large common due date P d i = d l i (α i i + β i i ) and they optimally solve instances with up to 60 jobs with a branch and bound algorithm. For the single machine problem with a large common due date, 1 d i = d l i (α i i + β i i ), Lee and Kim [23] propose a parallel genetic algorithm and Van den Akker et al. [28] use a combination of column generation and Lagrangian relaxation to solve instances with up to 125 jobs. Some earliness-tardiness problems can be solved in an exact way by pseudo-polynomial algorithms. o the best of our knowledge, this kind of algorithm has not been presented for the single machine version of the problem we study, 1 d i = d r i (α i i + β i i ). In fact, some authors have conjectured that this problem is NP-hard in the strong sense [22, 9]. he parallel machine problem P d i = d r i (α i i + β i i ), inherits the characteristic of been NP-hard in the strong sense from the parallel machine problem P i w ic i (Brucker [4], p.152). he manner we choose to tackle the problem P d i = d r i (α i i + β i i ) is by a neighborhood search algorithm (also known as local search). From an initial solution, this kind of algorithms search for a better solution by exploring the neighborhood of the initial one. his solution becomes the current solution and the local search goes on by exploring its neighborhood. he algorithm stops when the current neighborhood does not furnish a better value and the current solution is called local optimum. In an intuitive way, the larger the neighborhood is, the better is the quality of the local optimum. But, the larger the neighborhood is, the longer is needed to explore it. For this reason, a larger neighborhood is in practice interesting only when it can be explored in an efficient way. he article of Ahuja et al. [1] present a survey of very large scale neighborhoods. It focuses on exponential neighborhoods (in the size of the initial instance) where the best neighbor can be found 2

3 in polynomial time. Unlike these algorithms, the exponential neighborhood search we present in this article has a pseudo-polynomial complexity. Congram et al. [7] have introduced the Dynasearch search algorithm for the one-machine problem where the objective function is to minimize the sum of the weighted tardiness. While neighbors are usually derived from the current solution by a single transformation, Dynasearch neighbors are obtained by several simultaneous independent job exchanges. Sourd [25] has studied the single machine problem with release dates and setup times, 1 r i,setup i (α i i + β i i ) with this neighborhood technique (r i is the release date of job i). He proves that the exploration of the Dynasearch neighborhood for this problem is NP-hard. Nevertheless, it can be explored in a pseudo-polynomial time. Since the problem we study in this article, P d i = d r i (α i i + β i i ), is NP-hard in the strong sense, our purpose is to define a neighborhood in order to propose a local search algorithm. his neighborhood is called exponential since the number of neighbor schedules of a given schedule S can be exponential. his exponential neighborhood is based on job exchanges: an early job is inserted late in the same machine or in another; a late job is inserted early in any machine; an early job is transferred early to another machine; and finally, a tardy job is transferred late to another machine. Similarly to Dynasearch, the definition of the neighbor will rely on several independent job exchanges. In this paper we usually say search or explore the neighborhood and we mean finding the minimum cost schedule in the neighborhood of a given schedule. Section 1 surveys the properties of the dominant schedules of the problem P d i = d r i (α i i + β i i ). he exponential neighborhood and the local search algorithm (based on dynamic programming) are presented in Section 2. In Section 3 we show that finding the best schedule in the exponential neighborhood is an NP-hard problem. Finally, some computational tests are presented in Section 4. 1 V-shaped schedule he class of dominant schedules of the identical parallel machine problem with restrictive common due date and job dependent earliness and tardiness penalties, P d i = d r i (α i i + β i i ), inherits some well known properties from the single machine problem with restrictive common due date. A schedule that verifies the following properties is a V-shaped schedule. Property 1 As for the single machine problem, an optimal schedule has no inserted idle time between the execution of the jobs (it can be proved by interchange argument). Property 2 An optimal schedule exists in which for each machine, either a job is completed exactly at the due date d r or the schedule starts at time 0. For the single machine problem and α i = β i (for all i), a proof of this property is presented by Hoogeveen and van de Velde [16]. It can be generalized for the problem we are interested in. his property implies that, on any machine, there could be a job that starts before and ends after the due date. In this article, such a job is referred to as straddling job. Property 3 In an optimal schedule, for each machine M j, the jobs completed before the due date are ordered according to the non-decreasing ratios α i /p i, and the jobs started after the due date are ordered according to non-increasing ratios β i /p i. 3

4 S M 1 s S M 2 S S 0 d r È p i i J Figure 1: V-shaped schedule for a two machines instance. his result follows from Smith s ratio rule [24]. Notice that this property does not impose any constraint on a straddling job. hen, such a job does not have necessarily the biggest α i /p i or β i /p i ratio. Let S j be the set of jobs executed on machine Mj that complete before or at the common due date plus the straddling job (if it exists). he set of the jobs started after the common due date on machine M j is denoted as S j. So, a V-shaped schedule is determined by these 2m job subsets. Notice this defines a partition of the job set, J = m j=1 Sj Sj. One of the particularities of the neighborhood we present in the following section is that it is only composed by V-shaped schedules. Figure 1 illustrates, for a two machines instance, a V-shaped schedule. On machine M 1, the early job set S 1 starts at time 0 and there is a straddling job s. On machine M 2, the set S 2 starts after time 0, then the end of the last early job coincides with the common due date and with the starting time of the first tardy job. 2 xponential neighborhood In this section we first define the exponential neighborhood for the one-machine problem with a restrictive common due date and general earliness and tardiness penalties, 1 d i = d r i (α i i + β i i ). hen, for a given initial schedule S, we propose an algorithm that finds the best schedule in this exponential neighborhood. Later, based on the one-machine neighborhood, we define the exponential neighborhood for the parallel machine problem and an algorithm to explore it. 2.1 Single machine problem Let V (S) be the neighborhood of a single machine initial schedule S. It contains the neighbors schedules of S which have a straddling job (neighborhood V 2 (S)) and which do not have a straddling one (neighborhood V 1 (S)). o simplify the notation, for now on d r = d and since we have placed ourselves in the single machine case, we do not use in this section the upper-index that specifies the machine (for example, S 1 = S ). We begin presenting the neighborhood V 1. he completion time of a job coincides with the common due date We introduce some supplementary notations (see Figure 2). Let n = S and n = S. he first n jobs are renamed n,, 2, 1 while the last n jobs are renamed 1, 2,, n. he earliness and tardiness penalties and the duration of i and i are respectively noted by (α i, β i, p i ), and (α i, β i, p i ). 4

5 ( 2 ) Σ(S) Σ(S) Σ(S ) α 3 p 3 < α 2 p 2 < α 1 p 1 = p 2 d d = p 2 β 1 p > β 2 1 p > β 2 2 p 2 Figure 2: ( 2 ) operation. We define now two Remove-Insert operators which take into account Properties 1, 2 and 3. Operation ( i ) removes the early job i from S and inserts it late. By Property 3, the position that job i must take among late jobs of S is pointed out. We suppose this position is unique: if some ratios are equal then we break the tie according to the initial index of the tasks. hus, we define R(i) = i if job i must be placed between the jobs i and i +1. Moreover, R(i) = 0 if job i must be placed before 1 and R(i) = n if it must be inserted in last position. he second operator inserts among the early jobs a late one. It is denoted as ( i ) if job i is the one to be put early. As we have defined R(i), we define L(i) as the rank of i among the early jobs. We also define = Σ(S ) Σ(S) as the total shift from the starting time Σ(S) of the initial schedule S to the new starting time Σ(S ) of the schedule S obtained after some / moves. When operation ( i ) is executed, is increased by p i. Inversely, when operation ( i) is done this parameter is decreased by p i. Figure 2 illustrates the operation ( 2 ): early job 2 is moved tardy. We assume that R(2) = 1, that is 2 must be placed between 1 and 2. his move implies a shift = p 2 from the initial schedule (the left one in the figure) to the schedule obtained after the ( 2 ) operation (the right one). Notice that in the obtained schedule, the completion time of the jobs 1 and 1 are unchanged while the completion time of job 3 is shifted to fulfill the space left by 2 and the completion time of job 2 is also shifted by to leave a place to 2. We can say that is the variation of the starting time and completion time between the initial schedule and the obtained one. he amplitude of operator ( i ) (resp. ( i )) corresponds to the pair (i, R(i)) (resp. (L(i), i)). wo operations are said independent if their amplitudes are nested, i.e., if i 1 i 2 and i 2 i 1 for the two amplitudes (i 1, i 1 ) and (i 2, i 2 ). We say S is a 1-neighbor of S (other types of neighbors are defined later) if there is a combination of independent / operations that transforms S into S and such that it starts at or after time 0. Neighborhood V 1 (S) is composed by all the 1-neighbor schedules of S. Notice all schedules in neighborhood V 1 (S) are V-shaped. Remark 1 he size of the neighborhood V 1 (S) may be Ω(2 n ). o verify this result, lets consider an instance where α i /p i α i /p i implies β i /p i β i /p i for all tasks and let S be a feasible schedule for this instance. hus, for every pair of jobs composed by an early job i (i = 1,..., n ) and a tardy job i (i = 1,...n ), independent operations / are possible. hen, schedule S has 2 n +n different neighbors. In order to find the schedule with minimum cost in the neighborhood V 1 (S), we propose a dynamic programming algorithm. Let δ(i, i, ) be the minimum value of the cost function after executing some combination of independent / moves between the jobs i,..., 1 and 1,..., i with a shift equal to. he last parameter can take the integer values in the interval Iv = [ i J p i, i J p i], which means that we consider in the recursion schedules that 5

6 start before time 0. he recursion of the function δ can be written as follows for 0 < i n, 0 < i n and Iv: δ(i, i 1, ) δ(i, i δ(i 1, i, ) = min, ) δ(i 1, R(i), p (1) i ) + C(i, ) if R(i) i δ(l(i ), i 1, + p i ) + C(i, ) if L(i ) i where C(i, ) (resp. C(i, )) is the cost resulting from removing the early job i (resp. the tardy job j ) and placing it in S (resp. S ). First line of the minimum of equation (1) corresponds to leaving job i late, taking into account that eventually some / moves have been done between the jobs i,..., 1 and 1,..., i 1. he second line corresponds to leaving job i early considering that some / moves could be done between the jobs i 1,..., 1 and 1,..., i. he third line is about moving job i tardy among the jobs in S. It corresponds to the cost of the scheduling when some operations have eventually been done between jobs i 1,..., 1 and 1,..., R(i) with a total shift of p i. Notice that moving i implies an additional shift of p i, this way the total shift is. he cost C(i, ) is composed by the benefice of removing job i from S, plus the cost of inserting it late in S at the position R(i) (given by Property 3), minus the p i shift of the early jobs that found themselves before i, plus the p i shift of the tardy jobs that are after R(i). In order to state the cost C(i, ), we note Ci the completion time of job i in the original scheduling S. So, the cost of operation ( i ) when the total shift is, corresponds to the following formula: C(i, ) = αi ( d (C i + p i ) ) ) + βi (C R(i) + d + p i. R(i)<h n β h n l>i he fourth line of equation 1 corresponds to inserting job i into S. Some operations have eventually been done between jobs L(i ),..., 1 and 1,..., i 1 with a shift of + p i. Plus the cost C(i, ) that results from the gain of removing job i from S, plus the cost of inserting it early, minus the p i shift of jobs that are placed after i, plus the p i shift of jobs n,..., L(i )+1. his cost is similar to C(i, ). he initialization of the recursion function δ(i, i, ) for all i = 1,..., n and i = 1,..., n is { δ(i, i f(s) for = 0, ) = 0. Notice that δ(i, i, 0) means that no movements are done between jobs i,..., 1 and 1,..., i. hen, this value corresponds to the cost of the initial schedule f(s). A value δ(n, n, ) corresponds to the cost of a V-shaped schedule obtained by applying some independent operations to S, such that one of its jobs is completed at the due date and such that the total shifting from the initial schedule S to the one obtained is. In order to have all the 1-neighbors of S we must look for the schedules S that begin at or after time 0, which means that Σ(S ) = Σ(S)+ 0, that is Σ(S). hen the cost of the 1-neighbor of V 1 (S) with minimum cost is min Σ(S) δ(n, n, ). α l 6

7 Already arranged ( i ) Already arranged i+1 i i i +1 0 t d t p t p ( i ) Figure 3: he recursive function γ(i, i, t). he schedule starts at time 0 We describe in this section the neighborhood V 2 (S) which contains the neighbor schedules of S that start at time 0 and end at time i J p i, i.e., schedules with a straddling job (Property 2). By using the same / operators as before, we say a V-shaped schedule S is a 2-neighbor of S if there is a set of independent / operations that applied to S gives S and such that it starts at time 0. Neighborhood V 2 (S) is composed by all the 2-neighbors of S. We obtain the values of all the schedules in V 2 (S) with another dynamic programming. Contrary to the precedent recursion (equation 1), we schedule the jobs from the edges. Formally, let γ(i, i, t) be the value of the objective function [ when only jobs h ( h i) and l ( l i ) have been arranged into the intervals [0, t] and t + i 1 h=1 p h + i 1 l=1 p l, ] h J p h. Figure 3 illustrates an iteration of γ(i, i, t) (in the figure t p = t + i 1 h=1 p h + i 1 l=1 p l and t p = h J p h). In order to present the dynamic programming for γ(i, i, t), we introduce two fictive jobs n +1 and n +1 such that (αn +1, β n +1, p n +1 ) = (α n +1, β n +1, p n +1 ) = (0, 0, 0) and α n +1 /p n +1 = βn +1 /p n +1 = α n +1 /p n +1 = β n +1 /p n +1 = 0. And let P(i, i ) = i h=1 p h + i l=1 p l. he recursive relation γ(i, i, t) can be written as follows for i = n + 1, n,...1, i = n +1, n,...1 and 0 t < d + max i J p i : γ(i, i, t) = min γ(i + 1, i, t p i ) + α i (d t) if t p i 0, t d γ(i + 1, i, t) + βi (t + P(i, i 1) d) if t + P(i, i 1) > d and t + P(i + 1, i 1) < d γ(i, i + 1, t) + βi (t + P(i 1, i ) d) if t + P(i 1, i ) > d γ(i, i + 1, t) + βi ( t + p i d ) if t < d and t + p i > d γ(i + 1, i, t) + βi (t + P(i, i ) d) p i β i if i = R(i) and t + P(i, i ) d γ(i, i + 1, t p i ) + α ( i d t + p i ) p i αi if L(i ) = i and d t + p i 0. (2) he first line of this minimum implies that job i is placed early if there is enough place, taking into account the possible operations that eventually [ have been done between jobs n,..., i+1 and i,..., n and such that intervals [0, t] and t + i 1 h=1 p h + i 1 l=1 p l, ] h J p h are filled up. he second line considers the case where job i is straddling. Analogous to the first line, the third member is about putting late job i. he fourth, is when i is the straddling job. he fifth is the cost of executing operation ( i ). he last line of this minimum corresponds to the execution of 7

8 the operation ( i ) with its respective costs. he limit cases of the function γ are: { 0 if t = 0 γ(n + 1, n + 1, t) = else. he 2-neighbor of S that has the smallest cost is min t γ(1, 1, t). he single machine exponential neighborhood he exponential neighborhood V (S) contains all the V-shaped schedules that can be obtained by applying a set of independent / operations to S and such that they start at or after time 0. Formally, V (S) = V 1 (S) V 2 (S). he cost of the best schedule of V (S) is then min { min Σ(S) δ(n, n, ), min t γ(1, 1, t) }. Given a feasible initial schedule S, the one-machine neighborhood search corresponds to first compute recursions (1) and (2) to obtain the neighborhoods V 1 (S) and V 2 (S). If the cost of the best schedule of V (S) is not better than the cost of S, then S is a local optimum. Otherwise, find an optimal schedule S V (S) by backtracking the corresponding dynamic programming. S becomes the current solution and we start a new iteration of this algorithm. he exponential neighborhood search for the single machine problem with restricted common due date and job dependent earliness and tardiness penalties has a pseudo-polynomial complexity of O(n n n i J p i) time. In Section 3, we will prove that finding the schedule with minimum cost in V (S) is an NP-hard problem (in the ordinary sense). 2.2 Parallel machine problem In this section we present an exponential neighborhood search for the parallel machine scheduling problem with restrictive common due date and job dependent earliness and tardiness penalties, P d i = d r i (α i i + β i i ). he neighborhood of a given parallel schedule S, noted as V (S), corresponds to the union of the neighborhoods we present in the following subsections. Neighborhood V jj (S) A schedule S is a jj -neighbor of S if the tardy jobs of machine M j and the tardy ones of machine M j are rearranged. All the jobs of S k (resp. S h ) remains the same as in Sk (resp. Sh ) for k = 1,...m, and h = 1,..., m (h j and h j ). Set V jj (S) contains all jj -neighbors of S. he optimal way to rearrange the jobs in S j Sj is similar to solve the problem with only two parallel machines and where the weighted completion time is to be minimized, P2 β i S j i C i, Sj with the additional constraint that jobs scheduled on M j (resp. M j ) start at max(d, i S j p i ) (resp. max(d, p i S j i )). his last problem is NP-hard but not in the strong sense: it can be solved with an immediate adaptation of the pseudo-polynomial algorithm of [5]. In this way, the best schedule of V jj (S) can ) be determined in O (n jj p i time where n jj = Sj Sj. Neighborhood V jj (S) i S j Sj Schedule S is a jj -neighbor of S if the early jobs of machine M j and the early ones of machine M j are rearranged. Additionally, in an jj -neighbor all jobs must start at or after time 0 and 8

9 there may be a straddling job in M j and in M j. Notice that all the jobs of S k (S h ) remain in the same order as in S k (resp. Sh ) for k, h = 1,..., m (resp. h j and h j ). he neighborhood that contains all the jj -neighbors of S is V jj (S). We can distinguish three different types of jj -neighbors. he first type is when there are no straddling jobs in machines M j and M j. Finding the values of this type of jj -neighbors almost corresponds to solve the problem P2 α i S j i S i, where S i is the starting time of job i. We Sj must take into account that the capacity of each machine is constrained by the common due date d and consider the following benefit which corresponds to the left shifting of the tardy schedules on machines M j and M j : max 0, p i d + max 0, p i d = D j B j + D j B j. i S j i S j β i i S j ) Computing the values of this type of schedules can be done in O (n jj p i S j i time where Sj n jj = Sj Sj. he second type of jj -neighbor has a straddling job in both machines. In order to obtain the value of this schedules we sort and rename the jobs in S j Sj such that α 1/p 1 α 2 /p 2... α n jj /p n jj. he idea is to look for the best pair of straddling jobs. For this, we select a pair of jobs (s l, s l ) of S j Sj. hen, by dynamic programming (3) we present forward, we rearrange the J jj rest of the jobs ( (l, l ) = S j Sj sl s l ) such that the schedules of machines M j and M j start at time 0. Finally, we sum the cost of putting straddling job s l in M j and s l in M j, and vice versa. Let P i = i k=1;k J (j,j ) p k and let ϕ(i, t) be the cost of the schedule where only jobs 1,..., i (excluding jobs s l and s l ) are placed and such that the interval [0, t] of machine M j is already assigned to the execution of some jobs. For each pair (s l, s l ), the following recursion arranges the jj jobs i J (l, l ) for t = 0,..., d 1: i S j β i ϕ(i, t) = min { ϕ(i 1, t pi ) + α i (d t) if t p i 0 ϕ(i 1, t) + α i (d P i + t) if P i t < d. (3) We initially set ϕ(0, 0) = 0 and ϕ(0, t) = for all t > 0. hen, the cost of the two early schedules rearranged with job s l in M j and job s l in M j is min t [d ps l,d) Cost t (s l, s l ) where ϕ(n jj 2, t) + β s l(t + p s l d) + β s l (P t + p Cost t (s l n jj s l d), s l ) = else. if t + p s l d and P n jj t + p s l Remark some extra cost can arise when the tardy jobs of machines M j and M j are shifted in order to place the pair of straddling jobs (s l, s l ). he third type of jj -neighbor is such that there is one straddling job or in machine M j or in M j. Dynamic programming (3) can be adapted to this case taking into account that in the machine that has not a straddling job there must be a job that ends exactly at d. he best value of the neighborhood V jj (S) (which contains the three types of schedules) can be computed in O(n jj nj nj i S j Sj p i ) time. 9

10 D j B j M j S j (1) D j M j M j S j d (2) 0 d D j B j d D j Figure 4: xample of the 1 jj and 2 jj -neighbors of S. Neighborhood V jj (S) Neighborhood V jj (S) is based on the one machine neighborhood V (S) described in Section 2.1. A schedule S V jj (S) is such that there is a set of independent / operations (between the early jobs of machine M j and tardy jobs of machine M j ) that applied to S gives S. Notice that in such a schedule the rest of the jobs remains in the same machine and in the same order than in schedule S. Contrary to neighborhoods V jj jj (S) and V (S) there is no pseudo-polynomial algorithm than can be adapted to the case in which the early jobs of a machine are rearranged with the tardy ones of another. It would correspond to have a pseudo-polynomial algorithm for the single machine problem with restrictive common due date, 1 d i = d r i α i i + β i i, which is conjectured NP-hard in the strong sense [22]. Determining the values of the schedules in V jj (S) can be similarly done than for V (S). he n j early jobs of machine Mj are renamed as n j,, 2, 1 while the n j tardy jobs of machine M j are renamed as 1, 2,, n j. First, we look for the schedules such that the completion time of a job in S j Sj coincides with the common due date d in machine Mj. For this, we use an adaptation of dynamic programming (1) of Section 2.1. Doing this generates schedules that we name as 1 jj -neighbors of S. hen, we look for the schedules that may have a straddling job in machine M j. hese schedules are determined by an adaptation of dynamic programming (2) of Section 2.1. hese schedules are named as 2 jj -neighbors of S. he adaptations of the dynamic programs (1) and (2) must consider the possible shifting caused by the straddling jobs on machines M j and M j. Specifying the equations and the details of the extra costs induced by the straddling jobs can be, in our point of view, very technical and without much interest. Instead, in order to explain these additional costs that must be taken into account while generating all the 1 jj and 2 jj -neighbors, an example is illustrated in Figure 4. In the left part of this figure are represented machines M j, M j and M j of some schedule S. Notice that only jobs in S j and Sj are to be subject to possible / operations. he rest of the jobs in S, the ones that are on the filled blocs corresponding to S j, Sj, Sj and Sj, remain in the same machine and in the same order than in S. he right top figure is obtained when the adaptation of dynamic programming (1) is applied to S j and Sj in order to find the 1jj -neighbors of S. After 10

11 computing this recursion, a benefit equal to D j B j must be taken into account on every value δ(n j, nj, ) for every Iv. his benefit corresponds to the Dj right shift of jobs in S j since there is no longer a straddling job after the dynamic programming. In machine M j there is a straddling job that finishes at time d + D j then, the tardy jobs of M j must start at this time. he schedule of Figure 4 which is on the right side at the bottom corresponds to a 2 jj -neighbor of S. It is obtained by applying an adaptation of dynamic programming (2) to the jobs in S j and S j. hus, the early jobs of machine Mj start at time 0 and there could be a straddling job in this machine. After ( dynamic programming, the tardy jobs of machine M j are shifted inducing a cost equal to max 0, ) i S j p i d B j. It is summed to the all the values γ(1, 1, t) ( t) after computing dynamic programming (2). Because late ( jobs of machine M j must start at time d+d j then the tardy costs must be penalized by max 0, ) i S j p i d B j as in the other case. he parallel machine exponential neighborhood he exponential neighborhood of a parallel machine schedule S is the union of the neighborhoods we have presented: V (S) = ) (V jj jj (S) V (S) (S) for j, j = 1,..., m. j<j j j V jj he parallel machine exponential neighborhood search starts by a feasible V-shaped schedule S, then neighborhood V (S) must be determined. he minimum value in V (S) corresponds to the neighbor of S with minimum cost. If it has a cost less that S then a new iteration is done. Otherwise, the current schedule is a local minimum. We call this search algorithm as N. 3 Complexity of the neighborhood search In Section 2.2 we have shown how to determine the best schedule in neighborhood V (S) in pseudopolynomial time. For the sake of completeness, we show now that this problem is NP-hard even if we only consider neighborhood V 1 (S) corresponding to the single machine case and α i = β i = 1 for all task i. Formally, we consider the following problem P. Given a set of n jobs that have a restrictive common due date d r, penalties α i = β i = 1 for all i = 1,...n, a V-shaped schedule S INI of the jobs specified by two sets S INI and S INI, and a positive integer K. Is there a scheduling S V 1 (S INI ) such that the cost of S is equal or less than K? We will use the proof that the single machine problem with restrictive common due date and α i = β i = 1 for all jobs i = 1,..., n is NP-hard [16, 14]. So, we first present the problem from which the reduction of 1 d i = d r i C i d r is made. ven-odd partition problem (Garey et al. [10]): given a set of 2n positive integers, B = {b 1, b 2,..., b 2n } such that b i > b i+1 for each i = 1,...,2n 1, is there a partition of B into two subsets B 1 and B 2 such that b i B 1 b i = b i B 2 b i = A (i.e., A = b i /2) and such that B 1 contains exactly one of the integers { b 2i 1, b 2i } for each i = 1,..., n? In their proof, Hoogeveen and van de Velde [16] build the following instance I of the problem 1 d i = d r i C i d r from the ven-odd partition instance. 11

12 Instance I: A set of 2n jobs J 1,..., J 2n with processing times p i = b i + na for each i = 1,...,2n, a job J 0 with p 0 = 3(n 2 + 1)A and a restrictive common due date d r = (n 2 + 1)A. Is there a scheduling of these jobs such that its cost is equal or less than y 0 = n i=1 [(i + 1)(p 2i 1 + p 2i )] + d r? Lemma 1 ([16]) he following statements are equivalent: 1. here exists a solution to the ven-odd partition problem. 2. here is a partition of the jobs J 1,..., J 2n defined in I into the sets B 1 = {J 11, J 21,..., J n1 } and B 2 = {J 12, J 22,..., J n2 } where {J i1, J i2 } = {J 2i 1, J 2i } for each i = 1,..., n. 3. here exists a scheduling with cost less or equal than y 0 for the instance I. In Lemma 1, the schedule with cost less or equal than y 0 has the following form. he jobs corresponding to the set B 1 are scheduled from time 0 to d r in the order of non-decreasing ratios α i /p i. hen are scheduled from time d r to 2d r the jobs corresponding to the set B 2 in the order of non-increasing β i /p i ratios. And finally, the starting time of job J 0 is 2d r. We name this schedule as S(B 1, B 2 ). We now prove the complexity of problem P. For an arbitrary instance of the ven-odd partition problem, we build the following instance of P. Instance I : Construct the set of jobs J 1,..., J 2n and job J 0 with the same processing times and the same common due date as in instance I. Let keep the same bound on the cost of the schedule, y 0, as in I. he initial scheduling S INI is defined as follows. Let J k be the job such that k 1 i=1 p i d r and k i=1 p i > d r. he V-shaped schedule S INI has as early jobs J 1,..., J k 1 and as tardy jobs J k,..., J 2n, J 0. Observe that in S INI the number of early and tardy jobs is usually different (that is k n), that the starting time of the first job is not necessarily time 0, and that there is no straddling job. Lemma 2 here exists a partition of the jobs J 1,..., J 2n into the sets B 1 = {J 11, J 21,..., J n1 } and B 2 = {J 12, J 22,..., J n2 } where {J i1, J i2 } = {J 2i 1, J 2i } for each i = 1,..., n, if and only if, there exist a scheduling in V 1 (S INI ) such that the sum of the processing times of its early jobs is equal to d r and its cost is less or equal than y 0. Proof We prove that the schedule S(B 1, B 2 ) belongs to the neighborhood V 1 (S INI ). We must verify that there exists a set of independent / moves that leads from S INI to S(B 1, B 2 ). Notice that for i > i (i 0) the ratios of the jobs are in the following order: 1/p 0 < 1/p 2i 1 < 1/p 2i < 1/p 2i 1 < 1/p 2i. Since there is a partition of the jobs J 1,..., J 2n into the sets B 1 and B 2, one of the jobs of the pair {J 2i 1, J 2i } is placed early and the other is placed tardy (i = 1,..., n). Let i be such that {J 2i 1, J 2i } are two early jobs in S INI. hen, the positions of these jobs among the tardy ones are after the pair of jobs {J 2n 1, J 2n } and before J 0. Inversely, for a pair of tardy jobs {J 2i 1, J 2i }, the positions of this jobs among the early ones are before all the early jobs in S INI. If k is even, then the job J 2k 1 is early and job J 2k is tardy in S INI. hese jobs can also be moved in an independent way since R(J 2k 1 ) = 2n (before the job J 0 ) and R(J 2k ) = 0 (before all early jobs). his implies independent moves. hen, S(B 1, B 2 ) V 1 (S INI ). Moreover, S(B 1, B 2 ) has a cost equal to y 0. he reciprocal prove is quite direct. 4 xperimental results he purpose of this section is to point out the quality and the efficiency of the solutions obtained by the exponential neighborhood search we presented in the previous sections. 12

13 4.1 Instances We consider two kinds of instances in this work: SP (for Short Processing imes) and LP (for Long Processing imes). Class SP: It contains the instances that Biskup and Feldmann [3] generated in order to apply some heuristic methods to the restricted problem 1 d i = d r i (α i i + β i i ). hese instances can be found in the OR-Library which is a collection of instances for operations research problems (J.. Beasley web page, mastjjb/jeb/orlib/schinfo.html). he processing times p i are uniformly drawn from [0, 20], the earliness penalties α i from [0, 10] and the tardiness penalties β i from [0, 15]. his class also contains randomly generated instances such that p i, α i and β i are drawn from the uniform distribution [1, 20]. We only take into account instances with 10, 20, 50, 100 and 200 jobs and a due date restrictive factor h equal to 0.2, 0.4 and 0.6. he number of machines is 1, 4 and 8. We tested 900 different instances of this class. Class LP: It has the instances randomly generated as van den Akker et al. propose in [28]. A third of the instances are such that p i, α i and β i are drawn from the uniform distribution [1, 100]. he second third of the instances are such that p i is drawn from the uniform distribution [10, 100], α i and β i from [p i 5, p i + 5]. his leads to highly correlated instances since the ratios α i /p i and β i /p i are close to one. he rest of the instances are such that p i, α i and β i are drawn from the uniform distribution [90, 100]. We generated instances with 10, 20, 50, 100, 125, 150 jobs. We also take into account three restrictive factors h for the common due date: 0.2, 0.4 and 0.6, and the number of machines is 1, 4 and 8. We generated 2000 different instances. he restrictive due date of each instance is computed as follows: d = h i J p i/m. Since we have proposed a pseudo-polynomial algorithm the instances of class LP are interesting in order to evaluate the performance of the algorithm N. 4.2 Algorithms he dynamic programming algorithm we present for the exploration of the exponential neighborhood was coded in C++, and the tests have been executed on a Pentium IV with a 2.6 GHz processor and 0.98 Go of RAM. In order to have a comparison point for our computational results, we use the linear relaxation of the resource constraints proposed by Kedad-Sidhoum et al. [18]. his lower bound, noted by LB, has the advantage that gives quite good results in little time. It was computed up to 100 jobs instances and its execution time was bounded at 600 seconds. We also compare our results with the solutions obtained by an effective heuristic [18] consisting on the following moves. Job-swap: two jobs are selected on the same or different machine and interchange their positions. xtract and reinsert: a job is chosen and inserted in any another position. And list-crossover: two machines are selected, say M j and M j and two positions i and i. he schedule on machine M j is modified by putting its first i jobs and followed by the jobs after position i of M j. he inverse is done for M j. We call H the upper bound resulting from a single descent of this heuristic. Let N be the solution found by our neighborhood search method. hen, the percentage difference between our upper bound N and the lower bound LB (resp. H) is 100 N LB /LB (resp. 100 N H /H). After testing some feasible initial schedules for N and H, we finally use a simple heuristic for the experimental results. It is based on the idea of positioning early the jobs with a high tardiness penalty with respect to their earliness penalty. Based on this criterion, at most half of the total 13

14 number of the jobs are set early and the others are set tardy while properties 1, 2 and 3 are verified. he assignment of the jobs to the machines is uniformly done. his heuristic has a complexity of O(nlogn). From this feasible initial schedule we start both the exponential neighborhood search N and the simple descent H. he search algorithm N is time consuming because its pseudo-polynomial complexity. xperimental tests have shown interval Iv of the pseudo-polynomial parameter can be reduced without modifying the obtained results but reducing the CPU times. In this paper we have reduced Iv by 40%. 4.3 Parallel machine instances able 1 (resp. able 2) summarizes the computational results of the exponential neighborhood search N for the class SP (resp. LP). At the top of ables 1 and 2 is indicated the common due date restrictive factor h. he first column corresponds to the number of jobs and the second is the number of machines. -N is the average CPU time in seconds of the exponential neighborhood search N, I is the average number of iterations made by N, %D is the percentage difference between N and H and -H is the average CPU time in seconds made by H. able 1: Results for the LP instances n m -N I %D -H -N I %D -H -N I %D -H Instances with h = 0.2 have the most restrictive common due date then, the number of early jobs is smaller than the number of tardy ones. hen the CPU time for this instances is smaller than the ones with restrictive factor h = 0.4 or h = 0.6. We remark, that the average number of iterations of the N algorithm is independent of the due date restrictive factor h. Another observation is that the CPU time is the longest when the number of machines is smaller. Algorithms N and H start from the same initial schedule, the neighborhoods they explore are different and so are the values they obtain. he quality of the values given by N (columns %D in able 1) is better than the ones given by H. Nevertheless, there are few instances where the value obtained by N does not beat the value of H. his occurs when the number of jobs is small and the number of machines is big. Since N can handle moves only between a pair of job sets (for 14

15 exemple, the ealy jobs of M j with the tardy jobs of M j ) some mouves around the common due date are not possible for N but are for H. When the number of jobs increases, this fenomenon disapears. able 2: Results for the SP instances n m -N I %D -H -N I %D -H -N I %D -H able 2 summarizes the computational results of the exponential neighborhood search N for the class SP. We can notice again that instances with few machines are the ones with bigger CPU times. Instances of the SP class are the easiest because their processing times are smaller. his implies that the pseudo-polynomial parameters of algorithm N are smaller and it takes less time to the algorithm to be executed. Notice the average number of iterations (columns I) decreases when the restrictive factor increases and it is lower in comparison to the class LP. here are some instances for which the value given by H beats the one of N by the same reasons that in the LP class. able 3: Average percentage gap between the value of the solution of N and the value of LB n m LP SP LP SP LP SP able 3 shows in the columns LP (resp. SP) the average percentage GAP between the lower bound LB and N for the different restrictive factors of the instances of the class LP (resp. SP). he first and second columns are respectively the number of jobs and the number of machines. For 15

16 some of the 100 jobs instances, the lower bound was not able to find a solution. Surprisingly, the gap is bigger for the instances of the class SP. And it is not larger than 1.14% for the instances of the hard class LP. 4.4 One-machine instances Biskup and Feldmann presented two papers: [9] and [3]. In the first one, they propose some benchmark instances and an upper bound to these instances based on a heuristic that place the jobs with higher penalty near the common due date. In the second paper, they propose some metaheuristics in order to obtain better bounds for the instances they had proposed before. Also, Hino et al. [15] present various heuristics for the single machine problem and they use these instances to test their algorithms. able 4: Average percentage gains of N n %N FB HR %N FB HR %N able 4 present in columns %N, the average percentages gain between N and the first bounds of Biskup and Feldmann with the restrictive due date factors h = 0.2, 0.4 and 0.6. he first column of the table corresponds to the number of jobs. Columns HR are the best gain of the heuristics of Hino et al. with respect to the first bounds of Biskup and Feldmann. Columns FB are the best gain of the improved heuristics of Feldmann and Biskup with respect to their first bounds. hey do not present experimental results for the instances with 10 jobs and none presented experimental results for h = 0.6. Remark that the average percenage gains FB and HR are very close. We notice our gains are always bigger, nevertheless, they can compute instances up to 1000 jobs in less than 100 seconds. N gives the best results when the restrictive factor of the due date is small and when the number of jobs increases. 4.5 Hybrid algorithm Let HN be the algorithm N which starts with a local optimum given by H. he hybrid algorithm HN allows to escape from a local optimum for H and the time required by N is reduced because it starts with a good initial schedule. able 5 and able 6 show the performance of algorithm HN for the instances of classes LP and SP respectively. he first column corresponds to the number of jobs, the second is the number of machines, the different restrictive factors h are at the top of the table. he average percentage gain from the local optimum given by H and the solution obtained by N using as initial schedule this local optimum is on columns %HN. he average number of iterations HN executes is on column I. he CPU column corresponds to the time needed by H to compute the local optimum plus the time neede by N to compute an improved local optimum. For the instances of class LP, N improves the local optimum obtained with H in 60.66% of the times and for classes SP in 53.5%. ables 5 and 6 show that the CPU times of HN are less than the ones for N (ables 1 and 2). Since the gap between the values of the lower 16

17 able 5: Average percentage gain %HN for the instances of the class LP n m CPU I %HN CPU I %HN CPU I %HN bound LB and the ones of N varies between 0.03% and 6.77% (able 3) then the improvement percentage presented on columns %HN of ables 5 and 6 cannot be greater than this gap. We can observe that %HN is greater for the instances of class LP than for the instances of class SP. he number of iterations of HN is also less than for N. 5 Conclusions We have studied a scheduling problem on identical parallel machines with earliness-tardiness penalties and a restricted common due date, P d i = d r i (α i i + β i i ). Since this problem is NP-hard in the strong sense we proposed a neighborhood search algorithm. he particularity of the neighborhood we defined is its exponential size. We proved that searching the schedule with less cost in the neighborhood of a given schedule is an NP-hard problem. Nevertheless, we proposed a pseudo polynomial dynamic programming algorithm to find this local optimum. he experimental results show out that this large neighborhood search is interesting since the quality of its solutions is satisfactory since the gap between the lower bound and our upper bound is reasonable. An interesting way of using this algorithm is by starting the exponential neighborhood search with the solution of a simpler but faster local search. We proposed an exponential neighborhood and an algorithm that are specific for the identical parallel machines. Nevertheless, the generalization for problems where the machines have different independent machine speeds is not difficult, since the neighborhood and the dynamic programming algorithm depend neither on the processing times nor on the machine the jobs are executed on. References [1] R.K. Ahuja, O. rgun, J.B. Orlin, and A.P. Punnen. A survey of very large-scale neighborhood search techniques. Discrete Applied Mathematics, 123(1-3):75 102,