In this paper, we consider the problem of scheduling a setJ of n jobs onm identicalparallel machines (n>m�2) with respect to availability restrictions for both jobs andmachines. Each jobj (1�j�n) has a processing timepj , a release date (or head)rj onwhich the job becomes available for processing, and a delivery time (or tail)qj that must
64 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
elapse between its completion on the machine and its exit from the system. Each machineMi (1� i�m) has an availability timeai on which it becomes continuously ready forworking. All data are assumed to be positive integers and deterministic. Aschedule� isdefined by an assignment of the jobs to the machines and a vector(t1, t2, . . . , tn), wheretjdenotes the start time of jobj . A schedule is said to befeasibleif each job is processed,with no interruption, by exactly one machine and each machine processes at most one jobat one time. In addition, for 1�j�n and 1� i�m the following property must hold:
Jobj is assigned to machineMi �⇒ tj� max(ai, rj ).
Such a schedule induces a well defined makespanCmax(�) = max1� j�n (tj + pj + qj ).The problem is to find a feasible schedule of minimum makespan. In the standard three fieldscheduling notation of Graham et al.[8], this problem is denoted byP,NCinc|rj , qj |Cmax,whereNCinc indicates that the number of available machines is nondecreasing with time[23]. Although, many of its particular cases have been extensively studied, to the best ofour knowledge this problem has not previously been addressed in the scheduling literature.
It is easy to show thatP,NCinc|rj , qj |Cmax can be restated as an equivalentP,NCinc|rj |Lmax (i.e. minimizing the maximum lateness on identical parallel machines with non-simultaneous machine available times and release dates). This latter models the followingsituation. Jobs enter the system in batches on a periodic basis. Prior to processing, jobj(j = 1, . . . , n) requires a setup timerj and should be ideally completed before its due datedj . At the start of the planning period, some machines may not be available because theyare still processing the previous batch and we want to begin scheduling the new arrivingbatch before the completion of the previous one. The objective is to find a schedule thatminimizes the maximum latenessLmax=max1� j�n (Cj −dj )whereCj denotes the timeat which jobj is completed.
Our interest in theP,NCinc|rj , qj |Cmaxwas raised because it offers a unified frameworkfor modeling a large family of parallel machine problems including, among others, twoimportant special cases namelyP |rj , qj |Cmax andP,NCinc||Cmax. TheP |rj , qj |Cmax isan important (stronglyNP-hard) scheduling problem which arises as a strong relaxationof the Multiprocessor Flow Shop problem[10,21,25]. Moreover, it plays a central rolein some exact algorithms for the Resource Constrained Project Scheduling Problem[4].Despite its theoretical and practical interest, theP |rj , qj |Cmax received scant attentionin the scheduling literature. In particular, Carlier[3] proposed the first branch-and-boundalgorithm for this problem. Gharbi and Haouari[7] improved his algorithm by includingnew tools such as a preprocessing algorithm and Jackson’s Pseudo Preemptive Schedule[6]. On the other hand, Lee et al.[17] investigatedP,NCinc||Cmax and showed that theLongest Processing Time(LPT) rule yields a worst-case ratio of3
2 − 12m′ , wherem′ �m.
Also, Lee[16] showed that ifLPT is appropriately modified, then it yields a worst-case ratioof 4
3. Kellerer[12] developed a dual approximation heuristic which worst-case ratio is54. A
strong lower bound for theP,NCinc||Cmax has been proposed by Webster[26].In this paper, we present an exact branch-and-bound algorithm for solving theP,NCinc|rj , qj |Cmax. The proposed approach is based on four main features:
(i) a strong lower bound that is based on max-flow computations(ii) an effective heuristic that is based on heads and tails adjustments and feasibility tests
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 65
(iii) a representation of a schedule (on parallel machines) as a permutation of jobs(iv) dominance rules that aim at reducing the size of the search tree.
In order to provide evidence of the versatility and practical usefulness of the proposedapproach, we used it for solving the special casesP,NCinc||Cmax andP |rj , qj |Cmax, forwhich the approach was found to be very effective. For instance, whereas the best existingalgorithm for solving theP |rj , qj |Cmax experiences difficulties in solving hard instanceswith more than 300 jobs and 4 machines[7], the proposed algorithm makes it possible tosolve instances with up to 1000 jobs and 10 machines within moderate CPU time.
The paper is organized as follows. In Section 2, we introduce some results that will beused throughout the paper. Sections 3 and 4 are devoted to the description of new lower andupper bounds for theP,NCinc|rj , qj |Cmax. The details of our branch-and-bound algorithmare provided in Section 5. In Section 6, the performance of our algorithm is analyzed throughan extensive computational study.
2. Preliminary results
For the sake of simplicity, we assume that the machines are indexed in the nondecreasingorder of their availability times (i.e.a1�a2� · · · �am). The values̄rk(J ), p̄k(J ) andq̄k(J )denote thekth smallest release date, processing time, and delivery time inJ , respectively.Note that since a jobj cannot start processing before max(rj , a1), then we implicitly assumew.n.l.g. thatrj is adjusted to max(rj , a1) for all j ∈ J . Similarly, the availability time of amachineMi (i = 1, . . . , m) is adjusted to max(ai, r̄1(J )).
2.1. Bounds on the number of processing machines
It is worth noting that, due to non uniform availability times, some machines may notprocess any job in any optimal solution. The following observation provides simple boundson the number of processing machines in an optimal solution.
Proposition 1. Let UB denote an upper bound on the optimal makespan. Define:
• m=⌈ ∑
j∈J pjUB−a1−q̄1(J )
⌉• m̄ as the smallest k(k = 1, . . . , m− 1) satisfyingak+1 + minj∈J (pj + qj )>UB (if no
k satisfies this condition, thenm̄=m).Then, the number of machinesm∗ that are processing in an optimal schedule satisfies
m�m∗ �m̄.
Proof. A simple lower bound on the optimal makespan if exactlyk machines are active isLBk = a1 + (1/k)∑j∈J pj + q̄1(J ). Clearly, ifLBk >UB, thenm∗ �k + 1. Therefore, inan optimal schedule,m∗ � ∑j∈J pj /(UB − a1 − q̄1(J ))�.
Also, if ak+1 + minj∈J (pj + qj )>UB, then machineMk+1 cannot be used. Therefore,m∗ �k. �
66 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
It is worth noting that Lee et al.[17] proposed an upper bound on the number of processingmachines in an optimal schedule for theP,NCinc||Cmax. This bound is computed by takingthe smallest value ofk satisfyingak+1>(
∑kh=1 ah + ∑
j∈J pj )/k. It is easy to check thatthere is no dominance relation between the latter bound andm̄ for theP,NCinc||Cmax.
LetSi (i=1, . . . , m̄−1) denote the subset of jobs that have to be processed on machinesM1, . . . ,Mi in an optimal schedule. Since each jobj can be processed by machineM1, thenwe have
Let i0 denote the smallesti (i = 1, . . . , m̄ − 1) such thatSi �= ∅. Since each machineMh (h= i+1, . . . , k) has to process at least one job, then the following result immediatelyholds.
Lemma 1. If k machines are processing in an optimal solution then we have
k − i� |J\Si | ∀i = i0, . . . , k − 1.
Corollary 1. Let k0 (k0 = i0 + 1, . . . , m̄) denote the smallest k such that for a giveni(i = i0, . . . , k − 1) we havek − i > |J\Si |. Then, the number of machinesm∗ that areprocessing in an optimal solution satisfiesm∗ �k0 − 1.
An immediate consequence of the above corollary is that the value ofm̄ is adjusted tok0 − 1 (wheneverk0 exists).
2.2. Adjustments and feasibility tests
During the last few years, several authors implemented various adjustment procedures forscheduling problems[1,2,5,7,15,18,20]. In this section, we describe the so-calledFeasibilityandAdjustment Procedure(FAP) proposed by Gharbi and Haouari[7] for theP |rj , qj |Cmax.The objective of theFAP is twofold. It aims at adjusting the heads and tails, and checkingthe feasibility of a nonpreemptive schedule. TheFAP can be extended to deal with theP,NCinc|rj , qj |Cmax and was found very effective in the computation of both lower andupper bounds. In order to make the paper self-contained, we briefly describe theFAP. Fora more detailed description, the reader is referred to[7].
First, let LB andUB denote a lower and an upper bound on the optimal solution of aP,NCinc|rj , qj |Cmax instance. The problem is to check the feasibility of a nonpreemptiveschedule with makespan less than or equal to a valueC ∈ [LB,UB − 1]. For that purpose,a deadlinedj = C − qj is associated with each jobj ∈ J . Clearly, a schedule has amakespan less than or equal toC if and only if each job finishes processing no later than itscorresponding deadline.
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 67
TheFAP is based on the observation that if a jobj is such thatdj − rj <2pj , then in anynonpreemptive schedule, there is necessarily one machine which has to process jobj duringthe interval[dj − pj , rj + pj ]. Thus, a lower bound on the number of machines which arenecessarily loaded at any time can be easily computed (note that a machine which is not yetavailable is considered as loaded). The following feasibility condition immediately holds:
Condition 1. The instance is infeasible if there is a timet ∈ [a1,maxj∈J dj ] such that thenumber of machines loaded att is strictly greater thanm.
Moreover, each jobj ∈ S = {j ∈ J ; dj − rj <2pj }, has afixedprocessing part of2pj − (dj − rj ) units which has to be processed in[dj − pj , rj + pj ], and each jobj ∈ Jhas afreeprocessing part ofp′
j = min(pj , dj − rj − pj ) units which has to be processedin [rj , dj − pj ] ∪ [rj + pj , dj ]. Let e1, e2, . . . , eK be the different values ofrj (j ∈ J ),dj (j ∈ J ), dj − pj (j ∈ S), rj + pj (j ∈ S) andai (i = 1, . . . , m) ranked in increasingorder. For each time intervalIk = [ek, ek+1] (k = 1, . . . , K − 1), we denote byJk the setof jobs which free parts may be processed duringIk, by nk the number of jobs inJk, andby mk the number of machines which are idle duringIk. Since the amount of work inIk (k = 1, . . . , K − 1) cannot exceedAk = min
∑j∈Jk p
′j ; (ek+1 − ek) × min(nk,mk)},
then the following feasibility condition holds:
Condition 2. The instance is infeasible if∑K−1k=1 Ak <
∑j∈J p′
j .
Provided the number of loaded machines at any time, one can easily compute the timewindows in which there is at least one idle machine. These time windows are used inorder to adjust heads and tails of any jobj0 ∈ J . Indeed, a jobj0 can start processingat rj0 in a feasible nonpreemptive schedule if there exists a time window[a, b] such that[rj0, rj0 + pj0] ⊆ [a, b]. Otherwise, the earliest starting time ofj0 is at least equal to thelower bound of the first time window which fits[rj0, rj0 + pj0]. Similarly, the deadline ofjob j0 can be adjusted to the upper bound of the last time window which fits[dj0 −pj0, dj0].After performing these adjustments, the following feasibility condition immediately holds:
Condition 3. If there is a jobj0 ∈ J such thatrj0+pj0 >dj0, then the instance is infeasible.
The process is continued until there is no possible adjustment or an infeasibility is de-tected.
3. Lower bounds
In this section, we develop several new lower bounds for theP,NCinc|rj , qj |Cmax.
3.1. Simple lower bounds
A trivial lower bound which can be computed in O(n) is
LB0(J )= maxj∈J (rj + pj + qj ).
68 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
The following lemma provides a lower bound which takes into account the machine avail-ability times.
Lemma 2. A valid lower bound for theP,NCinc|rj , qj |Cmax is
LB1(J )= minm�k� m̄
LBk1(J )
where LBk1(J )=⌈
1k(∑ki=1 max(ai, r̄i (J ))+ ∑
j∈J pj + ∑ki=1 q̄i (J ))
⌉.
Proof. It suffices to prove thatLBk1 is a valid lower bound for thek-machine instance. Denoteby Pi andTi (i = 1, . . . , k) the total processing time and the total idle time (including theunavailability time) of machineMi in an optimal schedule, respectively. Since we have
Pi + Ti�C∗max for all i = 1, . . . , k
then
1
k
∑j∈J
pj +k∑i=1
Ti
�C∗
max. (1)
Note that each machineMi has to wait an amount of timeWi before starting the processingof the jobs. Moreover, there is necessarily a first machine that has to be idle from timeC∗
max − q1(J ) to C∗max, a second one from timeC∗
max − q2(J ) to C∗max . . . , and akth one
from timeC∗max − qk(J ) toC∗
max. Thus, we have
k∑i=1
Wi +k∑i=1
q̄i (J )�k∑i=1
Ti. (2)
Now, we prove that a valid lower bound on∑ki=1Wi is
∑ki=1 max(ai, r̄i (J )). Note that each
machineMi (i=1, . . . , k) cannot start processing before time max(ai, ri)whereri denotesthe release date of the first job to be processed onMi . Clearly, if the objective is to minimize∑ki=1Wi then there is an optimal schedule� such thatri ∈ {r̄1(J ), r̄2(J ), . . . , r̄k(J )} for
all i = 1, . . . , k. Assume that machineM1 starts at max(a1, r̄h(J )) in � (1<h�k). Thatis, there is a machineMl (1< l�k) that starts at max(al, r̄1(J )). Consider the schedule�′obtained by interchanging the set of jobs assigned to machinesM1 andMl in �. LetW ′
i
denote the machine waiting time of machineMi in �′. We have
∑ki=1Wi . Since� is optimal, then�′ is an optimal schedule where
machineM1 starts processing at max(a1, r̄1(J )). Similarly, it is possible to interchange jobsin �′ in order to obtain an optimal schedule where machinesM1 andM2 start processing atmax(a1, r̄1(J )) and max(a2, r̄2(J )), respectively, and so on. Therefore,
k∑i=1
max(ai, r̄i (J ))�k∑i=1
Wi. (3)
Combining (1)–(3) completes the proof.�
Note that, givenLBk1, the value ofLBk−11 can be computed in O(1). SinceLBm̄1 can be
computed in O(n logm), then the computation ofLB1 requires O(n logm+m) time.
3.2. A subset-sum based lower bound
Assume that exactlyk machines are active in an optimal schedule(m�k�m̄). LetJi,k (i = i0, . . . , k − 1) denote the subset of jobs that are processed on the machine subset{M1, . . . ,Mi}. We have
1
i
i∑h=1
max(ah, r̄h(Ji,k))+∑j∈Ji,k
pj +i∑h=1
q̄h(Ji,k)
�Cmax.
Thus, a valid lower bound is
L1i,k(Ji,k)=
1
i
i∑h=1
max(ah, r̄h(J ))+∑j∈Ji,k
pj +i∑h=1
q̄h(J )
.
Obviously, since the jobs ofJ\Ji,k are processed on the machine subset{Mi+1, . . . ,Mk},then we have
1
k − i
k∑h=i+1
max(ah, r̄h−i (J\Ji,k))+∑
j∈J\Ji,kpj +
k−i∑h=1
q̄h(J\Ji,k) �Cmax.
Note thatSi ⊆ Ji,k (whereSi is the set defined in Section 2.1). Then, a second valid lowerbound is
L2i,k(Ji,k)=
1
k − i
k∑h=i+1
max(ah, r̄h−i (J\Si))+∑
j∈J\Ji,kpj +
k−i∑h=1
q̄h(J\Si) .
Hence, for a given subsetJi,k ⊆ J , a valid lower bound is
Li,k(Ji,k)= max{L1i,k(Ji,k), L
2i,k(Ji,k)}.
70 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
Define:
LBi,k(J )= minJi,k⊆J
Li,k(Ji,k) ∀i0� i�k − 1; m�k�m̄,
LBk(J )= maxi0 � i�k−1
LBi,k(J ) ∀m�k�m̄.
Then, a valid lower bound is
LB2(J )= minm�k� m̄
LBk(J ).
Now, we show how to computeLBi,k(J ). For given values ofi andk, define the vectory∈ {0,1}n in the following way:
yj ={
1 if j ∈ Ji,k0 otherwise
for all j ∈ J.
Since,yj = 1 for all j ∈ Si , then we have
L1i,k(Ji,k)=
1
i
i∑h=1
max(ah, r̄h(J ))+∑j∈Si
pj +∑j∈J\Si
pjyj +i∑h=1
q̄h(J )
,
L2i,k(Ji,k)=
1
k − i
k∑h=i+1
max(ah, r̄h−i (J\Si))+∑j∈J\Si
pj
−∑j∈J\Si
pjyj +k−i∑h=1
q̄h(J\Si)
DefineAi , Bi,k andfi,k(J, y) by
Ai =i∑h=1
max(ah, r̄h(J ))+∑j∈Si
pj +i∑h=1
q̄h(J ),
Bi,k =k∑
h=i+1
max(ah, r̄h−i (J\Si))+∑j∈J\Si
pj +k−i∑h=1
q̄h(J\Si),
fi,k(J, y)= max
{Ai + ∑
j∈J\Si pjyji
,Bi,k − ∑
j∈J\Si pjyjk − i
}.
We haveLBi,k(J )= miny fi,k(J, y). Note thatfi,k(J, y)= (Ai + ∑j∈J\Si pjyj )/i if and
only if∑j∈J\Si pjyj�bik = (iBi,k − (k − i)Ai)/k. ThereforeLBi,k(J ) can be computed
by solving the pair of the followingSubset-Sumproblems:
z1 = MinAi + ∑
j∈J\Si pjyji
subject to: ∑j∈J\Si
pjyj�bikyj ∈ {0,1}j ∈ J\Si
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 71
and
z2 = MinBi,k − ∑
j∈J\Si pjyjk − i
subject to: ∑j∈J\Si
pjyj�bikyj ∈ {0,1}j ∈ J\Si.
We haveLBi,k(J )= min(z1, z2).Hence, the computation ofLBi,k(J ) requires theexactsolution of a Subset-Sum problem
(SSP). This problem is known to beNP -hard [19]. Nevertheless, during the last fewyears, several high performance exact and approximate algorithms have been proposed forthis problem[13,22,24]. However, since the problem isNP-hard, one would reasonablyexpect that for some instances it might take an excessive computation time to get a provenoptimal solution. Therefore, in the sequel, we show how a significantly simpler version ofLBi,k could be obtained. To that aim, we assume that the value ofx = ∑
j∈J\Si pjyj couldbe equal to any integer lying in[0,∑j∈J\Si pj ].
Note that it is implicitly assumed that there are at leastk − i jobs in J\Ji . There-fore, the total load of machinesMi+1, . . . ,Mk is at least equal to
Note that(Ai + x)/i is an increasing linear function and(Bi,k − x)/(k− i) is a decreasinglinear function. Letx0 denote the value ofx such that(Ai +x)/i= (Bi,k−x)/(k− i). Thatis, x0 = (iBi,k − (k − i)Ai)/k. Three cases have to be considered:
(i) if 0 <x0< p̄1(J\Si): thenLBi,k(J )= min{fi,k(J,0), fi,k(J, p̄1(J\Si))}.(ii) if p̄1(J\Si)�x0�∑|J\Si |
j=k−i+1 p̄j (J\Si): if x0 is integer thenLBi,k(J ) = fi,k(J, x0).Otherwise,LBi,k(J )= min{fi,k(J, �x0�), fi,k(J, x0�)}.
(iii) if x0>∑|J\Si |j=k−i+1 p̄j (J\Si): thenLBi,k(J )= fi,k(J,∑|J\Si |
j=k−i+1 p̄j (J\Si)).Note that it is assumed thati0<k in the computation ofLBi,k(J ). For values ofk such thatk� i0, the lower boundLBk(J ) can be replaced byLBk1(J ). Clearly, we have
LB2(J )�LB1(J ).
3.3. A max-flow-based lower bound
The lower bound introduced in this section consists in repeatedly checking the existenceof a relaxed schedule with makespan less than or equal to a trial valueC. For that purpose,a first step consists in applyingFAP to theP,NCinc|rj , qj , dj |Cmax defined by associatingwith each jobj ∈ J a deadlinedj =C − qj . Secondly, the feasibility of the trial valueC ischecked using a max-flow formulation as follows. Asemi-preemptiveschedule is definedas a schedule where the fixed parts of the jobs are constrained to start and to finish atfixed times with no preemption, whereas the free parts can be preempted. This concept of
72 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
semi-preemptive scheduling was recently introduced by Haouari and Gharbi[9] and used toderive a max-flow-based lower bound for theP |rj , qj |Cmax which dominates the classicalpreemptive lower bound[11]. In this section, we extend this work in a non trivial way and weshow how a tight semi-preemptive lower bound can be derived for theP,NCinc|rj , qj |Cmax.
For each jobj , let �j denote the largest machine index such thatai + pj�dj . Clearly,in any nonpreemptive schedule a jobj cannot be scheduled on any machineMi such thati >�j . Now, we show how to check the feasibility of a semi-preemptive schedule with thetwo additional conditions:
C1: Each machineMi (1� i�m) is constrained to start processing after its availabilitytimeai .
C2: Each jobj ∈ J can only be scheduled on a machineMi such that 1� i��j .
According to the notation of Section 2.2, we assume w.n.l.g. that themk machines whichare idle during the time intervalIk = [ek, ek+1] (1�k�K − 1) are indexed 1,2, . . . , mk,respectively. The feasibility problem can be solved using the following extension of Horn’sapproach[11]:
Consider the networkN = (V ,A) where the set of nodesV is the union of the followingsubsets:
Ehk (h= 1, . . . , mk) represents the time intervalIk = [ek, ek+1] but with only the subsetof machines{M1,M2, . . . ,Mh} being available.
• {s, t} wheres is the source node, andt is the sink node
The set of arcsA is constructed in the following way:
• For each job nodeJj (j=1, . . . , n) such thatp′j >0, there is an arc(s, Jj )with capacity
p′j representing the free part of jobj.
• For eachk=1, . . . , K−1 andh=1, . . . , mk−1, there is an arc(Ehk , Eh+1k )with capacity
h(ek+1 − ek).• For eachk = 1, . . . , K − 1, there is an arc(Emkk , t) with capacitymk(ek+1 − ek).• For eachj = 1, . . . , n, k = 1, . . . , K − 1, andh = 1, . . . , mk, there is an arc(Jj , Ehk )
with capacityek+1 − ek if and only if h = min(�j , mk) and one of the three followingconditions holds:
Obviously, an interval node which is not connected with any job node is dropped from thenetwork. We have the following theorem.
Theorem 1. A semi-preemptive schedule respecting time windows and conditions(C1) and(C2) exists if and only if the maximum flow between nodes s and t is equal to
∑j∈J p′
j .
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 73
Proof. Firstly, assume that a semi-preemptive schedule respecting conditions(C1) and(C2) exists. For eachk (k = 1, . . . , K − 1), define�ijk as the total processing time of jobj(j = 1, . . . , n) on machineMi (i= 1, . . . , m) in the time intervalIk. A corresponding flow(w, x, y, z) is obtained in the following way:
(i) A flow wj = p′j is assigned to each arc(s, Jj ) ∈ A.
(ii) A flow xhjk =∑hi=1 �ijk is assigned to each arc(Jj , Ehk ) ∈ A whereh= min(�j , mk).
The flow variablexhjk is equal to the total processing time of jobj on machinesM1, . . . ,Mh
in the time intervalIk. Then, it satisfiesxhjk�ek+1 − ek.(iii) A flow yhk =yh−1
k +∑nj=1 x
hjk (with y0
k =0) is assigned to each arc(Ehk , Eh+1k ) ∈ A.
The flow variableyhk is equal to the cumulative load of machinesM1, . . . ,Mh in the timeintervalIk. Then, it satisfiesyhk �h(ek+1 − ek).
(iv) A flow zk = ymk−1k + ∑n
j=1 xmkjk is assigned to each arc(Emkk , t) ∈ A. This flow can
also be expressed aszk = ∑mkh=1
∑nj=1 x
hjk. Therefore,zk is equal to the total load of all the
machines that are available during the time intervalIk. Consequently,zk�mk(ek+1 − ek).Moreover, since the schedule is feasible, then the total processing time of jobj is equal
to its free processing part. Hence,∑Kk=1
∑mkh=1 x
hjk = p′
j . Therefore, the flow(w, x, y, z)satisfies both the capacity and the flow conservation constraints. Hence, it is feasible. Thisflow is maximal because its value is
∑nj=1p
′j which is equal to the capacity of the cutset
({s} : V \{s}).Conversely, given a feasible flow(w, x, y, z) with value
∑nj=1p
′j , a feasible semi-
preemptive schedule could be constructed in the following way. Firstly, we assign the fixedparts by successively loading machinesMm,Mm−1, etc. Secondly, for each time intervalIk,we schedule jobs satisfying
∑mkh=1 x
hjk >0 onmk identical machines, while satisfying the
additional condition (C2). A schedule meeting this condition is constructed by schedulingthe jobs according to nondecreasing�j on the first available machine and splitting jobs intotwo parts whenever the upper boundek+1 is met. The remaining part of the job is scheduledon the next machine at timeek.
It is easy to check that the resulting schedule is necessarily feasible. Indeed, assume thatfor some time intervalIk we schedule jobsJ1, J2, . . . , Jp−1 but we fail to schedule jobJp(with �p = h∗) on any machineM1,M2, . . . ,Mh∗ . Therefore, we have
p∑j=1
h∗∑h=1
xhjk >h∗(ek+1 − ek). (4)
However, since the flow is feasible thenyh∗k �h∗(ek+1 − ek). The value of the flowyh
∗k is
equal toyh∗k = yh∗−1
k + ∑nj=1 x
h∗jk = ∑n
j=1∑h∗h=1 x
hjk. Therefore
p∑j=1
h∗∑h=1
xhjk�n∑j=1
h∗∑h=1
xhjk�h∗(ek+1 − ek), (5)
which contradicts (4). Hence, the resulting schedule is semi-preemptive, satisfies conditions(C1)–(C2), and time windows. �
74 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
Table 1Data of the 4 job—3 machine instance of Example 1
j 1 2 3 4
rj 3 3 4 4pj 5 4 6 1dj 12 12 15 12
s
E6
t
4
1
1
1
6
9
1
5
3
1
1
J1
J4
E1
E2
E4
E31
E32
E51
E52
E53
1
1
1
1
1 2
3
J2
J3
4
3
3
2
2 2
4
3
2
1
1
1
2
3
Fig. 1. The flow network corresponding to Example 1.
The computation of the maximum flow requires O(N3) time, whereN is the number ofnodes in the network. We have a maximum of 4nm+m2 −m+ n+ 2 nodes. Thus, afterapplyingFAP, checking the existence of a semi-preemptive schedule withCmax less thanor equal toC requires O(n3m3) time.
If LB andUB denote a lower and upper bound on the optimal makespan, respectively,then the optimal semi-preemptive schedule is computed using a bisection search on theinterval [LB,UB]. The obtained lower bound, denoted byLB3(J ), can be computed inO(n3m3(logn+ logm+ logpmax)) [14].
Example 1. Consider the feasibility problem defined on the 4 job—3 machine instancewhich data are depicted inTable 1.
Assume that the machine availabilities area1 = 3, a2 = 8 anda3 = 10. Then, we have
�1 = 1, �2 = 2, �3 = 2, �4 = 3.
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 75
The free parts of the jobs arep′1 = 4, p′
2 = 4, p′3 = 5 andp′
4 = 1. The time intervalscorresponding to this problem areE1 = [3,4], E2 = [4,7], E3 = [8,9], E4 = [9,10],E5 = [10,12] andE6 = [12,15]. Their respective number of available machines are 1,1, 2, 1, 3 and 3. The flow network corresponding to the semi-preemptive lower bound isillustrated inFig. 1.
4. Upper bounds
4.1. Jackson’s schedule
Jackson’s schedule provides a simple approximation of theP,NCinc|rj , qj |Cmaxoptimal solution. This algorithm is based on a dispatching rule which schedules theavailable job with the largest tail on the first available machine[3]. The makespan ofJackson’s schedule will be denoted byJS(J ). Its computation requiresO(n logn) time.
4.2. FAP-based upper bounds
Although Jackson’s schedule is a fairly good approximation schedule, its shortsightednessconstitutes its major flaw. In this section we describe how we can use theFAP in order toanticipate at best the impact of the current decision. Assume that we are interested inconstructing a nonpreemptive schedule with makespan less than or equal to a trial valueC ∈ [LB,UB − 1]. First, we setdj = C − qj for all j ∈ J and we adjust the heads andthe tails usingFAP. A job j ∈ J such thatdj = rj + pj is referred to as a fixed job and isconsidered as already scheduled. LetL denote the list of the free (unscheduled) jobs inJsorted according to the nondecreasing order of their heads, where ties are settled accordingto the nonincreasing order of tails. At each iteration, we useFAP to check whether the firstjob j0 ∈ L can be scheduled at its release date (note that after applyingFAP, all the releasedates are larger than the smallest machine availability). In this case, we setdj0 = rj0 +pj0.The listL is then updated by theFAP.
Now, assume that theFAP proves that schedulingj0 at the current position yields aninfeasibility. Therefore, we skip jobj0 and move to the next job in the list. Note thatthere may be no possible job to be scheduled at the current iteration. In this case, we up-date the trial value toC + 1 and so on. The algorithm stops when a feasible scheduleis constructed. In the sequel, the makespan of this approximate schedule will be denotedby FAP_UB(J ).
A second variant of theFAP-based upper bound amounts to a backward construction ofthe schedule (i.e. starting from the last scheduled job). Now, the listL contains the freejobs inJ sorted according to the nondecreasing order of their tails, where ties are settledaccording to the nonincreasing order of heads. Also, for a potential jobj0 to be scheduled,we setrj0 =dj0 −pj0. The obtained approximate makespan is denoted byFAP_UB−1(J ).We found in our experiments that taking the best of the two obtained schedules often yieldsan accurate approximate schedule.
76 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
5. Description of the B&B algorithm
5.1. Data representation
In our branch-and-bound algorithm, a schedule is represented by the chronological orderof the jobs. Formally, with a given schedule� = (t1, t2, . . . , tn) is associated a permutation�=(�(1),�(2), . . . ,�(n)) such thatt�(k)� t�(k+1) for all k=1, . . . , n−1. It is worth notingthat Carlier and Néron[5] used a similar representation for solving the Hybrid Flow Shopproblem. Starting at the root node with an empty permutation, at each level of the tree, ajob is assigned to the first available position of the permutation. With each nodeN of thesearch tree, we associate a partial permutation�N of scheduled jobs. It means that nodeNrepresents all the permutations beginning with�N . Let J̄ (N) denote the set of unscheduledjobs. We assume w.n.l.g. thata1(N)�a2(N)� · · · �am(N).
A lower boundLB(N), an upper boundUB(N) and deadlinesdj (N) are associatedwith nodeN . If UB denotes the current best upper bound, then the deadlines are set todj (N)= UB − qj (N)− 1 for 1�j�n. Moreover, a starting timetj (N) is defined for allj ∈ J .
5.2. Branching rule
The purpose of the branching rule is to indicate a candidate job to be fixed on the firstavailable position of the partial permutation�N associated with a given nodeN, and togenerate a descendant of the current node in the search tree. Given a nodeN0, if a jobj0 ∈ J (N0) is appended to�N0, then a descendant nodeN of N0 is created with thefollowing data:
Machine data
• ai(N)= ai(N0) for i = 1, . . . , m,• a1(N)= rj0(N0)+ pj0,• Updateai(N) for i = 1, . . . , m.
• J̄ (N)= J̄ (N0)\{j0},• rj (N)= max(rj (N0), tj0(N), a1(N)) for all j ∈ J̄ (N),• qj (N)= qj (N0) for all j ∈ J̄ (N),• dj (N)= dj (N0) for all j ∈ J̄ (N).
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 77
During the computations, each time a new improved upper boundUB is found, thedeadline and the tail of all the jobsj ∈ J̄ (N) are adjusted to
dj (N)= min{dj (N),UB − qj (N)− 1},qj (N)= max{qj (N),LB(N)− dj (N)}.
The depth-first search strategy has been adopted. It consists in branching the first candidatenode descendant of the current node in the tree. W.n.l.g., the jobs ofJ̄ (N) are rankedaccording to nondecreasing release dates, and in case of ties, nonincreasing delivery timesand nondecreasing processing times.
For the sake of clarity, we will denote the partial permutation�N by �, the setJ̄ (N) byJ̄ , and so on.
5.3. Dominance rules
In this section, we derive immediate selection rules which aims at removing dominatednodes from the set of candidate nodes to be branched.
Let C∗max(�) denote the minimum makespan of all those of the permutations beginning
with the partial permutation�. The three following results will be used to derive dominancerelations between jobs of̄J to be appended to�.
Observation 1. Let j andj ′ be two jobs ofJ̄ such that
rj = rj ′ , pj = pj ′ and qj = qj ′ .Then,
C∗max(�j)= C∗
max(�j′).
Proof. Obvious. �
Observation 2. Letj0 ∈ J̄ denote the job such thatrj0 + pj0 = minj∈J̄ (rj + pj ). Assume
that there exists a jobj ∈ J̄ such that
rj�rj0 + pj0.Then,
C∗max(�j0j)�C∗
max(�j).
Proof. Consider any permutation beginning with the partial permutation�j . Sequencingjob j0 between� and j will decrease the starting time ofj0 without delaying the startingtimes of the other jobs. �
Observation 3. Assume that there is a jobj0 such thatrj0 �a2. Let j denote a job suchthat rj�rj0. Then,
C∗max(�jj0)�C∗
max(�j0j).
78 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
M1
M2
j0
rj rj0
j
0
J1
J2
(a)
M1
M2 j0
j
rj rj00
J1
J2
(b)
Fig. 2.C∗max(�jj0)�C∗
max(�j0j): (a) a schedule beginning with�j0j , (b) a schedule beginning with�j0j .
Proof. LetM1 andM2 denote the first and second available machines. In any permutationbeginning with the partial permutation�j0j , the jobj0 is scheduled attj0 = rj0 onM1 andthe job j is scheduled attj0 = max(rj , tj0, a2) onM2 (seeFig. 2a). LetJ1 denote the setcontainingj0 and all jobs that are processed afterj0 onM1, andJ2 denote the set containingjob j and all jobs processed afterj onM2. Since all jobs inJ1 andJ2 start processing aftertj0 � max(a1, a2), then the schedule obtained by interchangingJ1 andJ2 has the samemakespan as the original one. This latter schedule is clearly dominated by the permutationbeginning with�jj0 and depicted inFig. 2b. �
The following dominance rules are immediate consequences of the above observations.The first two rules are derived from Observations 1 and 2, respectively, whereas the two lastones are derived from Observation 3. The jobsj1, j2, . . . , jK denote the jobs of̄J sortedaccording to the nondecreasing order of their release dates.
R1: If two jobsjk andjk+1 of J̄ have equal heads, processing times and tails, then jobjk+1is not candidate to be appended to�.
R2: All jobs k ∈ J̄ such thatrk�minj∈J̄ (rj + pj ) are not candidate to be appended to�.
R3: Assume that there is a jobjk ∈ J̄ such thatrjk �a2. Then, only jobsjh (h = k +1, . . . , K) are candidate to be appended to�jk.
R4: If rjK �a2, then jobjK is not candidate to be appended to�.
The following example shows how these selection rules are used in reducing the number ofnodes in the tree.
Example 2. Consider a given partial permutation� in a two-machine instance. Let̄J ={1,2,3,4,5} which data are provided byTable 2. Assume that the machine availabilitiesarea1 = 2 anda2 = 8.
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 79
Table 2Data of the unscheduled jobs of Example 2
j 1 2 3 4 5
rj 2 2 5 12 13pj 6 6 1 6 2qj 1 1 3 1 8
π1
π31 π32 π34 π35 π41 π42 π43 π45 π12 π13 π14 π15
π
π2 π3 π4 π5
Fig. 3. Application of dominance rules.
Fig. 3illustrates the significant impact of the proposed dominance rules on the size of thetree. Indeed, applying the dominance rules reduces the number of potentially valid nodes atthe second level from 20 nodes to only 3 nodes. The details are provided in the following.
Clearly, nodes�2 and�5 are removed according to R1 and R4, respectively. Also, nodes�41,�42 and�43 are removed according to R3.
Assume that job 1 is appended to�. Then, the release dates corresponding toJ̄ ={2,3,4,5} are{8,8,12,13}. Therefore, according to R2, the jobs with release dates largerthan or equal to minj∈J̄ (rj +pj )=9 are not candidate to be appended to�1. That is, nodes�14 and�15 are removed.
Similarly, assume that job 3 is appended to�. Then, the release dates corresponding toJ̄ = {1,2,4,5} are {6,6,12,13}. Therefore, node�32 is removed according to R1, andnodes�34 and�35 are removed according to R2.
Finally, in the case where job 4 is appended to�, the release dates corresponding toJ̄ ={1,2,3,5} are{12,12,12,13}. Sincer5=minj∈J̄ (rj +pj ), then node�45 is removedaccording to R2.
80 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
5.4. Synthesis of the branch-and-bound algorithm
We implemented our algorithm using, at each nodeN , the lower bound
LB(N)= max{LB0(J ),LB3(J )}.The upper bound computed at the root node is
UB(R)= min{JS(J ),FAP_UB(J )FAP_UB−1(J )}.It is worth noting that, since a node which yields an optimal makespan equal toUB is of nointerest, then the computation ofm,m andSi (i=1, . . . , m̄−1) have to be slightly modified.Indeed, at each node of the tree, we havem= �(∑j∈J pj )/(UB− a1 − q̄1(J ))� + 1 andm̄is the smallestk (k = 1, . . . , m− 1) satisfyingak+1 + minj∈J (pj + qj )�UB. Moreover,the subsetsSi (i = 1, . . . , m̄− 1) are computed by
Note thatm may be strictly larger than̄m. In this case, the node will be pruned.In the following pseudo-code description of our branch-and-bound algorithm, we adopted
the following notation:
• Np: the parent node ofN,• �(N): the set of candidate descendant nodes ofN,• N0: the current node to be branched.
Step 0: Initialization
0.1. Make a root node R containing the data set of the problem.0.2. Compute UB(R) and LB(R). Set UB= UB(R).0.3. If LB(R) = UB, then go to Step5. Else, compute�(R) using the selection rules and
setN0 = R.
Step 1: Node selectionIf �(N0) �= ∅, then select a nodeN ∈ �(N0) and go to Step2. Else, go to Step4Step 2: Branching
2.1. Create the data of node N as described in Section5.3.2.2. Compute LB(N). If LB(N)�UB then go to step3.Else setqj =max{qj ,LB(N)−dj }
for all j ∈ J̄ .2.3. Apply FAP to nodeN .2.4. Compute�(N) using the selection rules.2.5. SetN0 =N and go to Step1.
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 81
Step 3: PruningPrune N and go to Step1.Step 4: BacktrackingIf N0 = R then go to Step5. Else, setN =N0,N0 =Np and go to Step3.Step 5: Optimal makespanSetC∗
max = UB. Stop.
6. Computational experiments
In this section we present an empirical analysis of the performance of the proposedbranch-and-bound algorithm. The algorithm was coded in C and compiled with Visual C++5.0. The computational experiments were carried out on a Pentium IV 2.8 GHz PersonalComputer with 1 GB RAM.
6.1. Test generation
We carried out a series of experiments on test problems that were randomly generated inthe following way. The number of jobsn is taken equal to 50, 100, 150, 200, 300, 500, and700. The number of machinesm is taken equal to 2, 3, 5, 7, 10, and 20. The processing timesare drawn from the discrete uniform distribution on[1,10]. The heads and tails are drawnfrom the discrete uniform distribution on[1,K n
m], whereK is taken equal to 1, 3, 5 and
7. The availability times are drawn from the discrete uniform distribution on[rmin, rmax],wherermin andrmax are the smallest and largest release dates, respectively. We combinedthese problem characteristics to obtain 168 problem classes. For each class, 10 instanceswere generated. A CPU time limit of 300 s was set for each run.
6.2. Performance of the algorithm
We found that our algorithm solved 1674 out of 1680 instances within the CPU time limitof 300 s. Moreover, it requires an average computation time of only 4.70 s.Tables 3 a–dprovide the details of the performance of our algorithm according to the variation ofK, nandm. In these tables, we provide:
• Time: mean CPU time (in s).• NN: mean number of nodes.• US: number of instances for which optimality was not proved after reaching the time
limit. The values between parentheses denote the provided lower and upper bounds ofunsolved instances.
We observe that all of the instances (except one) withm�7 have been solved within thetime limit of 300 s. For larger values ofm, at least 9 out of 10 instances have been solved foreach problem class. In particular, forK�3, 18 out of 20 of the largest instances (700 jobsand 20 machines) have been solved, on average, in less than 1 min. Note that, for all of theunsolved instances, the absolute gap (UB− LB) is always equal to 1. The CPU time seemsto be more sensitive to the variation ofn thanm. Also, we observe that several instances
82 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
Table 3
m n Time NN US m n Time NN US
(a) Sensitivity to the variation ofn andm for K = 12 50 0.03 1.00 0 7 50 0.04 1.00 0
84 A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87
have been solved at the root node, which suggests the effectiveness of the proposed bounds.In particular, all of the instances withK = 7 have been solved at the root node.
At this point, it is worth noting that we performed similar computational experimentswith two additional variants of our branch-and-bound algorithm which are based onLB1andLB2, respectively. We found that these two variants have a very similar behavior for allproblem classes, and that they are largely outperformed by the branch-and-bound algorithmwhich is based onLB3. Indeed, they require about 5 times more CPU time, explore about 41times more nodes, and fail to solve 16 times more instances. The only significant exceptionbeing the set of instances withK = 1 where all of the three algorithms require comparableCPU time.
6.3. Performance on particular cases
In this section, we provide the analysis of additional experiments that have been carried outin order to assess the performance of our algorithm on the two special casesP,NCinc||CmaxandP |rj , qj |Cmax.
6.3.1. Performance on theP,NCinc||CmaxTo the best of our knowledge, no exact algorithm has been so far proposed in the literature
forP,NCinc||Cmax. In order to assess the performance of our algorithm on this special casewe generated a set of 1680 instances in the same way as described in Section 6.1, but withheads and tails equal to zero, and machine availabilities drawn from the discrete uniformdistribution on[1,K n
m] (K = 1,3,5,7).
Table 4shows that our algorithm performs remarkably well. Indeed, only one instanceout of 1680 has not been solved within the time limit of 300 s. Moreover, it requires, onaverage, less than 30 s to solve large-sized instances with 700 jobs and 20 machines.
6.3.2. Performance on theP |rj , qj |CmaxFirst, we compared our algorithm with the two time-window-based B&B algorithms
proposed in[7] for P |rj , qj |Cmax. In order to obtain meaningful results, we tested ouralgorithm on the same set of 720 problem tests generated by Gharbi and Haouari[7].Moreover, the runs were carried out on the same Pentium III 733 MHz Personal Computerused in[7]. The results are depicted inTable 5. In this table,TW1 andTW2 denote the twotime-window-based algorithms described in[7], andA denotes ourB&B algorithm.
Table 5provides strong evidence that our algorithm consistently outperformsTW1 andTW2. Indeed, we observe that it solved all of the 720 instances within the time limit of 300 s.It is worth noting that themaximalcomputing time of our algorithm is only 30.54 s. Themean CPU time being 1.25 s, this algorithm is 14.84 times faster thanTW1 and 21.82 timesfaster thanTW2. Moreover, the number of nodes explored is, on average, 128.55 times lessthan the number of nodes explored byTW1 and 57.35 times less than the number of nodesexplored byTW2. Table 6depicts the sensitivity of our algorithm to the variation ofK.As it can be seen from this table, the problems become easier asK increases. It is worthnoting that the two variants of our algorithm which are based onLB1 andLB2, respectively,exhibit a very poor performance on theseP |rj , qj |Cmax instances. Indeed, both algorithms
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 85
require about 15 times more CPU time and explore about 7000 times more nodes than thealgorithm which is based onLB3 does.
Moreover, we run our algorithm on larger test problems generated as follows. The numberof jobsn is taken equal to 400, 600, 800, and 1000. The number of machinesm is taken equalto 6, 7, 8, 9 and 10. The processing times are drawn from the discrete uniform distributionon[2,10]. The heads and tails are drawn from the discrete uniform distribution on[1, n/m].It is worth noting that, according to the analysis of Carlier[3] and Gharbi and Haouari[7],this set of instances belongs to the hardest class (K = 1 and large number of machines).For each combination ofn andm, 20 instances are generated. The CPU time limit was keptequal to 300 s.
Table 7shows that only three instances out of 400 have not been solved within the timelimit. It is worth noting that whileTW1 andTW2 experience difficulties in solving instancesof 300 jobs and 4 machines of this hard class (40% of unsolved instances byTW1 [7]),our algorithm makes it feasible to solve large-sized instances with up to 1000 jobs and 10machines in about 100 seconds, on average.
References
[1] P. Baptiste, S. Demassey, Tight LP bounds for resource constrained project scheduling, OR Spektrum 26(2004) 251–262.
A. Gharbi, M. Haouari / Discrete Applied Mathematics 148 (2005) 63–87 87
[2] P. Baptiste, C. Le Pape, W. Nuijten, Satisfiability tests and time bound adjustments for cumulative schedulingproblems, Ann. Oper. Res. 92 (1999) 305–333.
[3] J. Carlier, Scheduling jobs with release dates and tails on identical machines to minimize the makespan,European J. Oper. Res. 29 (1987) 298–306.
[4] J. Carlier, B. Latapie, Une méthode arborescente pour résoudre les problèmes cumulatifs, RAIRO 25 (1991)311–340.
[5] J. Carlier, E. Néron, An exact method for solving the multiprocessor flowshop, RAIRO-Oper. Res. 34 (2000)1–25.
[6] J. Carlier, E. Pinson, Jackson’s pseudo preemptive schedule for thePm/rj , qj /Cmax scheduling problem,Ann. Oper. Res. 83 (1998) 41–58.
[7] A. Gharbi, M. Haouari, Minimizing makespan on parallel machines subject to release dates and deliverytimes, J. Schedul. 5 (2002) 329–355.
[8] R.L. Graham, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Optimization and approximation indeterministic sequencing and scheduling: a survey, Ann. Discrete Math. 5 (1979) 287–326.
[9] M. Haouari, A. Gharbi, An improved max-flow based lower bound for minimizing maximum lateness onidentical parallel machines, Oper. Res. Lett. 31 (2003) 49–52.
[10] H. Hoogeveen, C. Hurkens, J.K. Lenstra, A. Vandevelde, Lower bounds for the multiprocessor flow shop,Second Workshop on Models and Algorithms for Planning and Scheduling, Wernigerode, 1995.
[11] W.A. Horn, Some simple scheduling algorithms, Naval Res. Logistics Quart. 21 (1974) 177–185.[12] H. Kellerer, Algorithms for multiprocessor scheduling with machine release times, IIE Trans. 30 (1998)
991–999.[13] H. Kellerer, R. Mansini, U. Pfersch, M.G. Speranza, An efficient fully polynomial approximation scheme for
the subset-sum problem, J. Comput. System Sci. 66 (2003) 349–370.[14] J. Labetoulle, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Preemptive scheduling of uniform machines
subject to release dates, Progress in Combinatorial Optimization,Academic Press, Florida, 1984, pp. 245–261.[15] A. Lahrichi, Ordonnancements: La Notion de “Parties Obligatoires” et son Application aux Problèmes
Cumulatifs, RAIRO-RO 16 (1982) 241–262.[16] C.-Y. Lee, Parallel machine scheduling with non simultaneous machine available time, Discrete Appl. Math.
30 (1991) 53–61.[17] C.-Y. Lee, Y. He, G. Tang, A note on parallel machine scheduling with non simultaneous machine available
time, Discrete Appl. Math. 100 (2000) 133–135.[18] P. Lopez, J. Erschler, P. Esquirol, Ordonnancement de Tâches sous Contraintes: une Approche Energétique,
RAIRO-APII 26 (1992) 453–481.[19] S. Martello, P. Toth, Knapsack Problems: Algorithms and Computer Implementations, Wiley, New York,
1990.[20] E. Néron, P. Baptiste, J.N.D. Gupta, Solving hybrid flow shop problem using energetic reasoning and global
operations, Omega 29 (2001) 501–511.[21] M. Perregaard, Branch-and-bound method for the multiprocessor jobshop and flowshop scheduling problem,
Master Thesis, Datalogisk institut K∅benhavns Universitet, 1995.[22] D. Pisinger, Dynamic programming on the word RAM, Algorithmica 35 (2003) 437–459.[23] G. Schmidt, Scheduling with limited machine availability, European J. Oper. Res. 121 (2000) 1–15.[24] N.Y. Soma, P. Toth, An exact algorithm for the subset sum problem, European J. Oper. Res. 136 (2002)
57–66.[25] A. Vandevelde, Minimizing the makespan in a multiprocessor flow shop, Master’s Thesis, Eindhoven
University of Technology, The Netherlands, 1994.[26] S.T. Webster, A general lower bound for the makespan problem, European J. Oper. Res. 89 (1996) 516–524.
