CC BY
0Hindawi Publishing Corporation Journal of Applied Mathematics Volume 2014, Article ID 273567, 14 pages http://dx.doi.org/10.1155/2014/273567
Research Article
The Nonpermutation Flowshop Scheduling Problem: Adjustment and Bounding Procedures
Anis Gharbi, Mohamed Labidi, and Mohamed Aly Louly
Department of Industrial Engineering, College of Engineering, KingSaud University, P.O. Box 800, Riyadh 11421, Saudi Arabia Correspondence should be addressed to Anis Gharbi; a.gharbi@ksu.edu.sa
Received 13 April 2014; Revised 8 October 2014; Accepted 14 October 2014; Published 26 November 2014 Academic Editor: Yuri N. Sotskov
Copyright © 2014 Anis Gharbi et al. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.
We consider the makespan minimization in a flowshop environment where the job sequence does not have to be the same for all the machines. Contrarily to the classical permutation flowshop scheduling problem, this strongly NP-hard problem received very scant attention in the literature. In this paper, some improved single-machine-based adjustment procedures are proposed, and a new two-machine-based one is introduced. Based on these adjustments, new lower and upper bounding schemes are derived. Our experimental analysis shows that the proposed procedures provide promising results.
1. Introduction
In this paper, we focus on the following scheduling problem: a set of n jobs (1,..., n) has to be processed on a set of m machines M1,M2,..., Mm in that order. That is, each job has to be processed first on machine M1, then on machine M2, and so on until performing its last operation on machine Mm. Each operation O^ (i = 1 ,...,m and j = 1 ,...,n) requires an integer and deterministic processing time ptj. The objective is to find a feasible schedule which minimizes the makespan. We also make the following common assumptions.
(i) Each job can be processed at most on one machine at the same time.
(ii) Each machine can process only one job at a time.
(iii) No preemption is allowed; that is, the processing of an operation cannot be interrupted.
(iv) All jobs are independent and are available for processing at time zero.
(v) The machines are continuously available.
In studying flowshop scheduling problems, it is usually assumed that the sequence in which each machine processes the jobs is identical on all machines. A sequence of this type is called a permutation sequence. Almost all of the research has been focused on the development of procedures to obtain permutation schedules. The main reason is probably that, in
the general case involving m machines and n jobs, the total number of feasible schedules tends to (n\)m, whereas with the assumption of no job passing, the number of feasible solutions is reduced to n\. However, identifying the best permutation schedule itself becomes very difficult, as the problem size grows bigger. Obviously, finding an optimal solution when sequence changes are permitted is more complex. Figures 1 and 2 depict the optimal solutions of the permutation and the nonpermutation flowshop instance with 3 jobs and 4 machines whose data are provided in Table 1.
Several authors emphasized the worth of considering nonpermutation schedules in real life flowshop environments [1,2]. In particular, Potts et al. [3] exhibit a family of instances for which the value of the optimal permutation schedule is worse than that of the optimal nonpermutation schedule by a factor ofmorethan (1/2)[ /rn + 1/2]. This is a nonnegligible gap since it can reach 50% for a 4-machine flowshop instance. Also, Sviridenko [4] proposed a new approximation algorithm which delivers a permutation schedule with makespan at most 0(\jmlogm) times of the optimal nonpermutation schedule. In this paper, we consider the nonpermutation case where the job sequence is not necessarily identical on all the machines. Using the notation of Graham et al. [5], this problem is denoted by F||Cmax.
Although the F||Cmax is solvable to optimality in polynomial time when m = 2 [6], it is known to be NP-hard in the strong sense when m > 3 [7]. The F||Cmax
1 2 3
1 * 2 3
1 * 2 3
Figure 1: Optimal permutation schedule.
1 2 3
1 3 2
1 3 2
Figure 2: Optimal nonpermutation schedule.
Table 1: Data of a 3-job-4-machine flowshop instance.
M, M2 M3 M4
1 1 1 3 2
2 1 4 3 3
3 4 1 1 3
has several interesting practical applications since in several manufacturing environments (such as in glass industry, textile, and microelectronic chip), jobs have unidirectional flow with identical flow pattern.
The paper is organized as follows. In Section 2, we provide a literature survey of the nonpermutation flowshop as well as two closely related problems: the permutation flowshop and the jobshop scheduling problems. In Section 3, we recall several adjustment procedures from the literature and we investigate new ones. The main purpose of adjustments is to reduce the time windows of operations, mainly to achieve a better efficiency for enumerative approaches. New bounding strategies based on these adjustments are introduced in Section 4. Our experimental results are presented in Section 5. Finally, we conclude our paper by providing a synthesis of our research and indicating some directions for future research.
2. Literature Survey on Shop Scheduling Problems
In this section, we provide a brief overview of the existing research on the nonpermutation flowshop scheduling problem together with two closely related and much more studied problems: the permutation flowshop and the jobshop scheduling problems. Furthermore, we emphasize the most important relationships between the permutation and the nonpermutation flowshop scheduling problems.
2.1. The Flowshop Scheduling Problem. Since the nonper-mutation flowshop scheduling problem received very scant attention in the literature, we devote this section to the case where we have identical job sequence on each machine. This problem is commonly referred to as Fm|prmu|Cmax.
Johnson [6] demonstrated that the two-machine problem can be solved in 0(n log n) time by the following sequencing rule. First schedule the jobs with p1j < p2j in order of nondecreasing p1j; then schedule the remainingjobs in order of nonincreasing p2j. Unfortunately, the problem is no longer polynomial for larger values of m. Indeed, Garey et al. [7] showed that F3|prmu|Cmax is strongly NP-hard.
The F|prmu|Cmax has received an impressive interest by scheduling researchers. Indeed, the first proposed branch-and-bound algorithms have been developed by Ignall and Schrage [8] and Lomnicki [9]. In addition, several exact approaches have been devised by Grabowski [10], Carlier and Rebai [11], and Cheng et al. [12]. All these algorithms, except the latter, can solve only instances of very limited size. Also, an effective branch-and-bound algorithm is proposed by Haouari and Ladhari [13].
Many algorithms have been designed to find near optimal schedule in reasonable time. These algorithms can be classified as either constructive or based on local search. There are several constructive heuristics available (for a comprehensive review, see [14]). Nawaz et al.'s algorithm [15] (NEH) is currently considered as the most efficient constructive heuristic among others for the permutation flowshop problem. In addition, a new local search paradigm based on a truncated branch-and-bound strategy, and called branch-and-bound-based local search, has been implemented for the F|prmu|Cmax by Haouari and Ladhari [16] and shown to yield approximate solutions of excellent quality.
The permutation flowshop problem has been tackled by several metaheuristics like simulated annealing (SA) (see [17]) and tabu search (see [18,19]).
2.2. The Jobshop Scheduling Problem. In jobshop environment, each job has its own routing on machines. The jobshop problem, denoted by /||Cmax, is not only NP-hard, but even among the members of this class, it belongs to the worst in practice. A notorious problem with 10 jobs and 10 machines given by Fisher and Thompson [20] remained unsolved for more than 25 years. Interested readers can find various jobshop-related complexity results in Brucker et al. [21-23].
Several exact approaches have been proposed for the jobshop problem. In particular, an interesting branch-and-bound algorithm was proposed by Carlier and Pinson [24]. It was the first algorithm to solve optimally the notorious 10-job-10-machine jobshop problem of Fisher and Thompson [20]. This algorithm has been followed by Brucker et al. [25] and Brinkkotter and Brucker [26]. The efficiency of these algorithms relies on the concept of immediate selections leading to effective adjustments.
Among the heuristics, one of the most successful approaches is the shifting bottleneck proposed by Adams et al. [27]. Numerous enhancements of this method have been proposed by Dauzere-Peres and Lasserre [28], Balas et al. [29], and Wenqi and Aihua [30].
C * = 15
^max 1 -
Cmax - 14
Several tabu search approaches have been designed for the jobshop problem such as Nowicki and Smutnicki [19] and Armentano and Scrich [31]. Nowicki and Smutnicki [32] presented a new algorithm for the jobshop problem using tabu search. The computational experiments showed that the algorithm not only finds shorter makespan than the best approximation approaches, but also runs in shorter time.
2.3. Permutation versus Nonpermutation Flowshop Scheduling Problems. In this section, we recall the main relationships and differences between permutation and nonpermutation flowshops. First, it is worth noting that both problems are symmetric. That is, the value of the optimal makespan of the original problem (denoted by the forward problem) is equal to that of its symmetric problem (denoted by the backward problem) that is obtained by reversing the routing of the jobs; that is, the jobs are first processed on Mm, then on Mm-1, and so on. Now, we state the following propertywhich is proposed by Conway et al. [33].
Property 1. For F||Cmax, there exists an optimal solution having the same processing permutation on the first two machines.
To see Property 1, consider any solution where different orders exist on the first two machines. Then, there must be a pair of adjacent jobs, say a and fc, on the first machine permutation that appear in reverse order in the permutation on the second. But these two jobs can be reversed on the first machine without increasing the start time (and thus the completion time) of any job on the second machine. Inductively, we can repeat this pairwise switching process until the permutation on the first machine is made to agree with the (original) order on the second. An immediate consequence of Property 1 is that the F2||Cmax and the F2|perm|Cmax are equivalent. That is, in the case of two-machine flowshop, there exists an optimal schedule which is a permutation. Consequently, the F2||Cmax is solvable in polynomial time using Johnson's algorithm [6]. Moreover, due to the symmetry of the F||Cmax, the following property holds.
Property 2. For F||Cmax, there exists an optimal solution having the same processing permutation on the last two machines.
According to the two above properties, one can deduce that there is an optimal solution which has the same permutation on the machines for the problem F3||Cmax. In other terms, the F3||Cmax and F3|perm|Cmax are equivalent.
Garey et al. [7] showed that the problems of nonpermutation and permutation flowshop become NP-hard in the strong sense when the number of machines is larger than 3. However, there are several polynomially solvable special cases of Fm||Cmax that result from imposing certain inequalities on the processing times. For instance, Johnson [6] observed that if maxjp2j < max|min;p1;-, min;p3;j holds in an F3||Cmax instance, then the second machine is nonbottleneck, and the optimal algorithm for problem F2||Cmax can be suitably
adapted. Monma and Rinnooy Kan [34] provide a survey of these types of results.
Now, consider the two-machine flowshop and assume that a time delay (or time lag) is incurred by the transfer of the jobs from the first machine to the second one. The obtained problem, denoted by F2|/;|Cmax, is proven to be solvable in 0(nlogn) time in the permutation case [35], whereas it turns to be NP-hard in the general case [36]. Dell'Amico
[37] proved that the nonpermutation case remains NP-hard even if preemption is allowed. It is worth noting that Rebaine
[38] evaluated the worst-case performance ratio between the optimal permutation and nonpermutation schedule. He observed that, even in the restricted case of two machines and unit execution time operations, the two models may generate different optimal values for the makespan. More specifically, he showed that, in the two-machine case, the performance ratio between the two optimal solutions is bounded by 2. When the operations of the n jobs are restricted to be unit execution time, this ratio is reduced to 2 - (3/(n + 2)) for the two-machine case and is m for the m-machine case.
If we consider the case where n = 2, the optimal permutation schedule is trivially computed by taking the best permutation among the two possible ones. The problem turns to be slightly more complicated but is still polynomially solvable, if a nonpermutation optimal schedule is to be determined. Indeed, Benson and Dror [39] proved that the two-job nonpermutation flowshop is solved in O(n) time.
3. Adjustment Procedures
The nonpermutation flowshop problem may be represented using a disjunctive graph: two operations i and j, executed by the same machine, cannot be simultaneously processed. Therefore with each pair («, j) of operations, we associate a pair of disjunctive arcs [«, j] = {(«, j), (j,«)}. The problem is then modelled by a disjunctive graph G = (C, D),where C = (X, U") is a conjunctive graph (two operations belonging to the same job are represented by a conjunctive arc) and D is a set of disjunctions.
Figure 3 depicts a disjunctive graph of a 3-job-3-machine instance. The pair (a, fc) denotes the processing of job a on machine fc. Two dummy operations 0 and * are included which represent the source and the sink node, respectively. The minimum starting time denoted by rj of an operation j is equal to the longest weighted path from 0 to j in the disjunctive graph G. Similarly for each operation j the tail qj is the length of the longest weighted path from j to * in G.
In the sequel, we assume that the makespan is fixed to a trial value C. The problem amounts to checking whether a feasible schedule with makespan less than or equal to C exists. For that purpose, a deadline dj = C - qj is associated with each operation j.
The main purpose of adjustments is to reduce the time windows [rj,dj]. This kind of elimination rule has been widely studied over the last two decades, especially for solving jobshop scheduling problems. The importance of the adjustment rules is twofold. They are used in the branch-and-bound algorithm for discarding infeasible nodes, and they permit the adjustment of the release dates and deadlines, so that the lower bounds are tightened. The major breakthrough of adjustment procedures has been achieved by Carlier and Pinson [24] who solved the famous Muth and Thompson 10 x 10 jobshop instance for the first time.
A nonpermutation flowshop can be viewed as a particular case of the jobshop scheduling problem. Therefore, we can apply the same adjustment procedures of this last problem to the nonpermutation flowshop. Interestingly, if an adjustment of an operation is performed, then the sets of its predecessors (Pred) and successors (Succ) according to the conjunctive graph can be adjusted using the following global adjustment algorithm (Algorithm 1; rj and dj denote the adjusted values of rj and dj, resp.).
3.1. Adjustments from the Literature. In this section, we describe the most relevant adjustment procedures proposed in the literature.
3.1.1. Disjunction-Based Adjustment. Clearly, if two operations i and j are such that rj + pj + pi > di then i cannot be scheduled after j. In this case, a disjunctive arc (i, j) can be fixed, which means that i is processed before j in any feasible schedule [24]. Therefore, the release date of job j can be adjusted to rj = max(rj, ri + pi). Similarly, the deadline of
job i can be adjusted to di = min(di, dj - pj). More generally, after determining all the disjunctive arcs using the above rule, the release date and the deadline of each job j can be adjusted
to rj = maxi£pred(j)(rj,ri+pi) and"di = minj£succ(i)(di,dj-pJ),
where pred(j) and succ(f') denote the sets of predecessors of j and the sets of successors of i, respectively. Obviously, the instance is infeasible if fj + pj > dj or the obtained graph contains a cycle. Carlier and Pinson [40] proposed an algorithm allowing the determination of all immediate selections in a disjunctive graph in 0(n log n) steps.
Example 1. Consider the 5-job instance defined by Table 2. We have d3 - p3 = 29 < r1 + p1 = 30. Therefore, a disjunctive arc (3,1) should be added to the graph. Similarly, since d5 -p5 = 11 < r1 + p1, then job 5 should be processed before job 1 in any feasible schedule. By applying the same rule to each job pair, we obtain the graph depicted in Figure 4. Accordingly, the release dates can be adjusted as follows:
~i = max {ri,~3 +p3,~5 + p5) = 20,
~2 = max ir2Jl +Pi Jl +p3,~5 + p5) = 35,
Table 2: Data of the 5-job instance of Example 1.
Jobs 1 2 3 4 5
ri 15 33 0 26 0
Pi 15 1 2 8 20
46 44 31 48 31
=r3 = 0,
~A = max {r4'~1 +Pl,ri +Pl,~5 +P5) = 35 ~5 =r5 =0-
The deadlines can be adjusted (decreased) in a similar way. The corresponding procedures are symmetric to those derived for the release dates. The procedure is reiterated until no adjustment can be performed.
Brucker et al. [41] proposed an extension of the procedure developed by Carlier and Pinson [24] in order to fix additional disjunctive arcs. This procedure referred to as "3-set condition" may be described as follows. Assume that all the arcs derived from Carlier and Pinson procedure are fixed. Suppose that j ^ i. Let k be an operation such that rj + pj +
Pi + Pk > rj + Pj + Pk + Pi > di,andrk + pk +pj + pt > d(; then k can be scheduled neither before j, nor between j and i, nor after i. Consequently, j cannot be processed before i in any feasible schedule, and a disjunctive arc (i, j) can therefore be fixed.
3.1.2. Preemption-Based Adjustment. Carlier and Pinson [42] presented an algorithm for adjusting release dates and deadlines in the jobshop problem. This algorithm is based on Jackson's preemptive schedule (JPS) for the one-machine problem. JPS provides the optimal solution for the 1\rj,qj, pmtn|Cmax in 0(nlogn) time. It is constructed as follows. At the first moment t where the machine and at least one operation are available, the operation with the maximal tail is scheduled. This operation is processed either up to its completion or until a more urgent job (i.e., with larger tail) becomes available. Then, t is updated and the procedure is iterated until all operations are scheduled [43].
In the following, we describe the procedure of Carlier and Pinson [42] for adjusting the release date rc of a given operation c. Let UB denote an upper bound of the optimal makespan and assume that Jackson's preemptive schedule has
(1) For each operation (i)
2) Compute rt and dt.
3) If (?i > rj) then
4) Let Succ(i) = {Sj, S2,..., SJ the set of successors of operation i.
5) For (h=1,...,k-1)
6) If (7J„ + Ps„ > ) then = r^ + pSh.
7) If (rSh + pSh > dSh) then the instance is infeasible.
8) end (For)
9) end (If)
10) If (dt < dt) then
11) Let Pred(i) = {Rj ,R2,..., Rk} the set of predecessors of operation i
12) For (h = k,..., 2)
13) If (dRh - pRh < ) then dRh l = dRh - pRh.
14) If (rRh + pRh > dRh) then the instance is infeasible.
15) end (For)
16) end (If)
(17) end (For)
(18) If for all operations we have ri = rt and dt = dt then STOP. Otherwise, set rt = r¡; dt = dt and go to line (1).
Algorithm 1: GlobaLAdjustment_Algorithm.
been built until time t = rc. Let p+ denote the remaining processing times in the preemptive schedule. Then, rc can be adjusted as follows.
(i) Compute Kc = [j e J | qj > qc} and K+ = [j e Kc | p+ > 0}.
(ii) Take the operations of k+ in increasing order of qj and find the first jj such that rc +pc+lUik+\qjzqh} Pji+qji > UB (if any exists).
(iii) Define K = [j e k+ | qj > qh}.
(iv) Set Tc = maXjgK. Cj (Cj is the completion time of job j).
Carlier and Pinson [42] presented an 0(n2) algorithm for adjusting all release dates. Brucker et al. [25] improved this complexity by proposing an 0(max[n log n, f}) algorithm, where f is the number of new disjunctive arcs. The idea relies on the dual version of JPS which, starting from d = maxj^jdj, calculates a schedule from right to left by applying the following dual rule. At each time t which is given by a deadline or a release date of an operation, schedule backwards an incompletely scheduled operation j with dj > t and rj = maxi6j[ri | dt > t}. Such a schedule is referred to as backwards Jackson preemptive schedule (BJPS). The release date of a given operation c canbe adjusted using the following procedure.
Earliest-Possible Completion Algorithm Step 1. Calculate JPS up to rc.
Step 2. Calculate BJPS without c in [rc, d] using the remaining processing times.
Step 3. Schedule operation c from left to right within the idle periods of [rc, d]. Let sc be the completion time of operation c and set ~c = sc - pc.
Similarly, the deadline of a given operation c can be adjusted by applying the dual version of the above algorithm.
Latest_PossiMe_Completion Algorithm
Step 1. Calculate BJPS up to dc.
Step 2. Calculate JPS without c in [minjejrj,dc] using the remaining processing times.
Step 3. Schedule operation c from right to left within the idle periods of [minj£jrj,dc]. Let s'c be the starting time of
operation c and set dc = s'c + pc.
Example 1 (continued).Figures 5 and 6 depict the preemption-based adj'ustment of the release date and the deadline of job 1, respectively. We have rj = ^ - p1 = 37 - 15 = 22 and dj = s[ + px = 24+ 15 = 39.
3.2. New Adjustment Procedures. In this section, we introduce new adjustment procedures and show that they outperform those described in the previous section.
3.2.1. Improved Disjunction-Based Procedure. Recall that the disjunction-based adjustment rule consists in setting fj =
maxiepred(j)(rj,ri + Pi) and ¿j = miniesucc(j)(dj,di - pt) for all j e J. Interestingly, this adjustment rule can be improved in the following way.
(i) A job i is defined as an immediate predecessor of j if there exists an arc (i, j) in the disjunctive graph.
(ii) A job i is defined as a predecessor of j if there exists a path (i,..., j) in the disjunctive graph.
Let Pj denote the set of all the predecessors of j. Clearly, job j has to wait until all the jobs of Pj have been processed.
Step 1: application of JPS up to ri = 15
24 31 39
Step 2: application of BJPS in [15,48]
31 37 39
Step 3: scheduling of job 1 within [15,48] Figure 5: Preemption-based adjustment of rl (Example 1).
Step 1: application of BJPS up to d = 46
□ I 4 I a
0 2 22 26 32 33 34 46 48
Step 2: application of JPS in [0,46]
1 4 12 1
22 24 26 32 33 34
Table 3: Data of the 5-job instance of Example 2.
Jobs 1 2 3 4 5
5 2 4 14 1
Pi 11 2 11 6 14
50 49 41 46 27
First, by remarking that the latest starting time of any job j e J is dj - pj, and its earliest finishing time is tj + pj, we can state the following observation.
Step 3: backward scheduling of job 1 within [0,46] Figure 6: Preemption-based adjustment of dt (Example 1).
Let Cmax(Pj) denote the minimum completion time of all jobs of Pj. Therefore, the minimum starting time of j is at least equal to max(r;-, Cmax(Pj)). It is worth noting that Cmax(Pj) corresponds to the optimal makespan of the
Mrj\Cm!ix
is solvable
problem defined on Pj. The 1\r j\C in 0(n log n) time by ranking jobs in nondecreasing order of their release dates. Clearly, since Cmax(P j) > maxieP, (rt + pt), then this adjustment rule dominates the classical one proposed by Carlier and Pinson [24].
Similarly, the deadline of job j can be adjusted by setting dj = min(dj, maxigS.d, - Cmax(Sj)), where Sj denotes the set of all the successors of j, and Cmax(Sj) is the optimal makespan of 1\rj\Cmax problem defined on Sj by setting tj =
maxieSjdi - dj.
3.2.2. Semipreemption-Based Procedure. In this section, we develop a new adjustment rule which dominates the preemptive version while having the same complexity. The proposed procedure is similar, in spirit, to JPS in the sense that we apply the same algorithm with a small distinction. The idea of semipreemption has been introduced in Haouari and Gharbi [44].
Observation 1. Assume that there exists a job j such that tj + pj > dj - pj. Then, in any nonpreemptive schedule, there is a part of job j which must be processed during the interval
[dj -Pj,rj + Pj\.
According to the above observation, each job j satisfying rj + Pj > dj - pj is composed of a fixed and a free part. Its fixed part is the amount of time 2pj - (dj - rj) which must be processed in [dj - pj, rj + pj\, and its free part is the amount of time p'j = dj - (rj + pj) which has to be processed in [rj,dj - pj\ U [rj + pj,dj\. The other jobs are composed only of a free processing part p'j = pj which has to be processed in [rj,dj\. Let Jackson's semipreemptive schedule (JSPS) denote Jackson's preemptive schedule applied on the modified instance where each job is replaced by two jobs which designate its free part and fixed part, respectively. Clearly, the preemption-based adjustment is improved if JPS is replaced by JSPS.
Example 2. Consider the 5-job instance defined by Table 3.
We remark that r5 + p5 > d5 - p5. Then, job 5 has a fixed part (5') in [13,15\ with processing time equal to 2 and a free part in [1,27\ with processing time equal to 12. The modified instance is depicted in Table 4.
Figure 7 displays the semipreemption-based adjustment of the release date of job 1.Wehaver: = Sj-px = 18-11 = 7.
13 15 18 19
46 47 49
Figure 1: Semipreemption-based adjustment of rl (Example 2).
Table 4: Modified instance of Example 2.
Jobs 1 2 3 4 5 5'
n 5 ; 1 4 14 1 13
pJ 11 2 11 6 12 2
dj 50 49 41 46 21 15
Table 5: Semipreemptive-based adjusted data of Example 2.
Jobs 1 2 3 4 5
fj 15 2 15 15 1
Pj 11 2 11 6 14
dj 50 49 41 46 22
The procedure is reiterated until no adjustment can be performed. The obtained adjusted release dates and deadlines are depicted in Table 5.
It is worth noting that no adjustment can be made on this instance using the classical preemptive-based procedure.
3.2.3. Two-Machine-Based Adjustment Procedure. First, we observe that there exists an optimal F||Cmax schedule such that there is no idle time on the first machine. That is, no job finishes processing on M1 later than £p1j. Therefore,
the deadlines on M1 can be adjusted by setting d1j = min(d1j-, £ p1j) for all j e J. In a similar way, using the symmetry of the F||Cmax the release dates on the last machine can be adjusted by setting rmj = max(rmj, C pmj).
Now, we introduce a new approach for adjusting the deadlines on the second machine. Recall that there exists an optimal schedule such that the sequences on M1 and M2 are the same. Consider a particular job j* and let a* denote the sequence (or permutation) of J \ {j*} which maximizes the makespan on M2. Let Cj, denote the completion time of j* on M2 and let Cmax(a*) denote an upper bound on the completion time of a* on M2. Clearly, we have Cj, < max{£p1j,Cmax(a*)} + p2j,. Consequently, the deadline of j* on machine M2 can be adjusted to d2j, = min^/, max{£ p1j, C
In what follows, we show how to compute Cmax(a*). Let aj denote a permutation such that j0 is the job that starts processing on M2 after its last idle period (see Figure 8). Denote by t^ and Cj the starting time and the completion time of job j on machine Mt, respectively. Clearly, we have
C1jo = t2j0.
Cmax(ffj0)
Figure 8: Illustration of the permutation a, .
Let S and S' denote the set of jobs that are scheduled before and after j0 in Oj , respectively. Denote by Xj the variable that equals 1 if j e S and 0 otherwise. We have
Cmax )= I P1j*j + P1k +P2k + I p2j {l-*j) jtJ\{jo } j£J\{j° }
= 1 (P1j -P2j)xj + P1j0 +P2j0 + T P2j-jV\{h } jV\{h }
Clearly Cmax(djo) is maximized by setting Xj = 1 for all j satisfying p1j > p2j and Xj = 0 otherwise. Let Cmax(a**) denote the corresponding makespan and j' = {j e J : p1j > P2j}. We have Cmax^j* ) = Ijel'\[k}(p1j - p2j) + p1j0 + p2j0 +
ljej\[j0} P2j.
Two cases have to be considered.
(i) If j0 e J' then
Cmax (% ) = Tp1j - P1ja - ( Tp2j - P2ja ) jzj' \jzj' )
+ Plk +P2k +1P2J -P2k №
= IPiJ + lp2j -lp2j + P2jo
w W jej'
* 1 (PU - P2j) + IP2J + JJX {P2k } •
jej' jej
(ii) If j0 t J' then Cmax )=1Plj -1 p2J + Plj0 + P2k + 1P2J - P2J,
jej' jej' JeJ
* 1 (P1J -P2J) + 1P2J + jjX {Plj0
jej' jej
Table 6: Data of 5-job-4-machine instance of Example 3.
1 2 3 4 5
M, 6 20 2 9 20
M2 9 13 5 11 10
M3 15 1 8 6 4
M4 2 4 4 8 3
Table 7: Initial values of release dates of Example 3.
Jobs 1 2 3 4 5
M, 0 0 0 0 0
M2 6 20 2 9 20
M3 15 33 7 20 30
M4 30 34 15 26 34
Table 8: Initial values of deadlines of Example 3.
Jobs 1 2 3 4 5
M, 59 67 68 60 62
M2 68 80 73 71 78
M3 83 81 81 77 82
M4 85 85 85 85 85
Consequently, an obtained by upper bound Cmax(% ) on Cmax(^J0 ) is
Cmax (o-;o ) = I (Pli je/' - P2;) + Zp2i je/ (5)
+ max max {^1io }, meax {^2;o}
Finally, Cmax(<r*) = maxjo6/ Cmax(a*) is an upper bound on the completion time of all possible permutations on M2. Using appropriate data structure, all the deadlines on M2 can be adjusted in O(n) time.
Thanks to the symmetry of the problem, the release dates on Mm-1 can be adjusted by setting rm-1- = max(rm-1>;-; C -Cmax(a*)), where Cmax(<r*) is computed on the two-machine flowshop problem defined on Mm and Mm-1.
Example 3. Consider the 5-job-4-machine instance depicted in Table 6 and let C = 85. The values of the releases dates and the deadlines before performing any adjustment are depicted in Tables 7 and 8, respectively
First, we have
¿1} = min (^X^i) = 57,
r4j = max (r4j, C - X p4;-) = 64 (6)
V; e /.
Now, we have /' = {2, 5} and Cmax(<r*) = 55. Therefore, the deadline of job 2 on M2 can be adj'usted to
d22 = min {d22,max Cmax (CT*)} + p22}
= min {80, max {57, 55} + 13} = 70.
Similarly, the deadline of job 5 on M2 is adjusted to d25 = 68 (instead of 78). The adjusted release dates on M3 obtained by the two-machine-based procedure are the following:
r,, = 40; r„ = 43; r„ = 40;
^34 = 44,
4. Bounding Procedures
In this section, we introduce lower and upper bounding procedures for the nonpermutation flowshop problem. These procedures are derived from the adjustments described in Section 3.
4.1. Lower Bounds. A simple and efficient way of deriving a good lower bound for the F||Cmax consists in relaxing the capacities of all the machines but one denoted by Mfc. The obtained problem is a one machine problem with release dates and delivery times denoted by 1|r;-, ^j|Cmax, where =
Ii<k Pij and 3,- = L>fc Pij.
Although the latter problem is strongly NP-hard, it is efficiently solved using the branch-and-bound algorithm developed by Carlier [45]. Let Cmax(Mfc) denote the optimal makespan of the 1|r;-, ^-|Cmax problem defined on Mfc. Avalid lower bound for the F||Cmax is
Lfio = max Cmax
(Mfc).
It is worth noting that LB0 is considered as a good lower bound in the context of jobshop scheduling problem. Moreover, it constitutes a fundamental component in several effective heuristics, such as the well-known shifting bottleneck procedure [27]. In the sequel, we introduce an interesting way of deriving a stronger lower bound using the developed adjustment procedures.
Let US denote an upper bound on the optimal makespan andlet C e [LB0, U£-1] denote a trial value of the makespan. With each operation O^ is associated a release date r^, a delivery time qtj, and a deadline dtj = C - q^. Clearly, if after performing the adjustment procedure the instance is identified to be infeasible, then C + 1 is a valid lower bound on the optimal makespan. Consequently, a bisection search on [LB0,U£ - 1] combined with the proposed adjustment procedure provides a lower bound denoted by LB1 which dominates LB0. The computation of LB1 can be described as follows.
Compute LB1
Step 1. Set C- = LB0, C+ = US - 1. Step 2. Let C = L(C- + C+)/2j. Step 3. Set dj = C - q^ for all j e /.
Step 4. Apply an adjustment procedure to the instance obtained in step 3. If the instance is infeasible, then set C- = C + 1. Otherwise, set C+ = C - 1.
Step 5. If C- = C+, then stop and set LB1 = C. Else, go to step 2.
3 4 2 1
3 1 4 2
3 1 4 2
0 38 49 515254 130 140 176 202 234 257 287
Figure 9: Schedule of Example 4 according to LPT rule.
In the computation of LB we implemented the new proposed adjustment procedures. The value of UB is equal to the makespan of the schedule obtained by applying the longest processing time (LPT) dispatching rule. It consists in scheduling in the first available machine, the available operation with longest processing time.
4.2. Heuristics. In this sectionwe describe howwe can use the adjustment procedures in order to construct an upper bound for the nonpermutation flowshop scheduling problem.
4.2.1. Heuristic H1. We are interested in building a nonpre-emptive schedule with makespan less than or equal to a trial value C e [LB, UB - 1]. First, we set d^ = C - qtj and we adjust the release dates and the deadlines using an adjustment procedure. An operation such that d^ = rtj + ptj is referred to as a fixed operation and is considered as already scheduled. Let L denote the list of the free (nonfixed) first operations of each job, sorted according to the nondecreasing order of their release dates. The ties are settled according to the nonde-creasing order of deadlines, then by the nondecreasing order of processing times. At each iteration, we use an adjustment procedure to check whether the first operation Oijo can be scheduled at its release date. In this case, we set dif = r;i + pi; . The list L is then updated by the adjustment procedure.
Now, assume that the adjustment procedure yields an infeasibility. That is, scheduling j0 at this position is not the right decision. Therefore, we have to skip operation Oijo and move to the next operation in the list. Note that in this case the minimum starting time of Oijo is r^ + 1. Obviously, there may be no possible operation to be scheduled at the current iteration. In this case, finding a schedule with makespan less than or equal to the trial value C is assumed as impossible. So we have to move on to C + 1 and so on. The algorithm stops when a feasible schedule is constructed.
Example 4. Consider the 4-job-3-machine instance whose data are depicted in Table 9.
Assume that LB = 252 and UB = 287 (UB is a makespan obtained by LPT dispatching rule and it is depicted in Figure 9).
Table 9: Data of 4-job-3-machine instance of Example 4.
M, M2 M3
1 1 86 36
2 2 55 30
3 38 16 76
4 11 62 32
Assume that we are interested in constructing a schedule with makespan equal to 254. The list L contains only the first free operations in each machine. Thus, L = {011,012,014,013}. At the first iteration, operation 011 is scheduled at time r11 = 0. That is, the deadline is set to d11 = 1. The current data is updated by applying the adjustment procedures. Thus, we have L = {012,014,013,021}. In the second iteration, the operation 012 is scheduled to finish at d12 = 3. Next, we apply the adjustment procedures. Thus, we have L = {021,014,013,022}. Assume that operation 021 is scheduled at r21 = 1 at the third iteration. That is, its deadline is set to d21 = 87.
Applying the adjustment procedures to the obtained instance yields an infeasibility. That is, the minimum starting time of 021 is equal to 2, and scheduling operation 021 at the third iteration is not the right choice. Consequently, we move to the next operation, and we have L = {014,013,021} and so on. The obtained schedule is depicted in Figure 10. Its makespan is equal to 254.
4.2.2. Heuristic H2. Using the symmetry of the problem, a second heuristic can be obtained by applying H1 to the symmetric F||Cmax instance (backward).
Example 4 (continued). Assume that LB = 252 and UB = 254. We are interested in constructing a schedule with makespan equal to 253. The list of the free jobs is L = {011,012,014,013}. At the first iteration, operation 011 is scheduled at time r11 = 0. That is, the deadline is set to d11 = 36. Applying the adjustment procedures to the obtained instance yields an infeasibility. That is, the minimum starting time of 011 is equal to 1. Consequently, scheduling
1 2 4 3
2 3 1 4
2 3 1 4
0 1 3 14 52 58 74 80 110 180 186 222 254
Figure 10: Schedue provided by H1 for Example 4.
4 1 2 3
4 13 2
1 4 3 2
0 32 68 94 98 174 180 196 201202 213 251 253
Figure 11: Schedule provided by H2 for Example 4.
operation On at the first iteration is not the right choice and we move to the next operation, and so on. The obtained schedule is depicted in Figure 11. Its makespan is equal to 253.
4.2.3. Heuristic H3. For each value of C, we first consider the forward instance and try to construct a feasible schedule. In case of failure, the backward instance is considered. We move on to C +1 only if a failure has been obtained for both forward and backward instance. Note that the obtained value of the makespan is equal to the minimum between those obtained by H1 and H2. However, our experimental results show that the required computational effort is substantially reduced.
4.2.4. Heuristic H4. In order to reduce the computational effort, a bisection search on the trial value C is embedded within H3. The value of C lies in the interval [LB1,UB] where UB denotes the makespan obtained by LPT dispatching rule. It is worth noting that if a failure is obtained for a given value C then all the values less than C will not be considered. However, it may be possible to obtain a feasible schedule if a smaller value of C is considered. Therefore, it is possible that H4 yields a solution which is worse than that obtained by H3. Our experimental results show that H4 often exhibits a good
trade-off between the decrease of the computation time and the decrease of the solution's quality.
4.2.5. Heuristic H5. A randomization component is included in H4 by selecting the operation that has to be scheduled randomlybetween the two first operations in the list L. In case of failure for a given value of C, the randomized procedure is performed until a feasible schedule is obtained or the maximum number of iterations is reached. In our experiments, we fixed the maximum number of iterations to 40. Also, a CPU time limit of 600 seconds has been fixed for H5.
5. Computational Results
In this section, we present an empirical analysis of the performance of the proposed lower and upper bounds that are derived from our adjustment procedures. The algorithms were coded in C and compiled with Visual C++ 6.0. All the computational experiments were carried out on a Pentium IV 3.2 GHz Personal Computer with 1GB RAM.
5.1. Test Generation. We carried out a series of experiments on 240 test problems that were randomly generated in the following way. The processing times are drawn from the
Table 10: Performance of the lower bounds for m = 4.
n Opto Imp Redavg Redmax Opt; Time
10 30 85.71 76.32 100 50 0.04
20 50 40 71.15 92.31 0 0.06
30 50 60 73.22 100 66.67 0.17
40 70 66.67 100 100 100 0.28
50 50 40 100 100 100 0.59
60 50 60 100 100 100 1.05
70 40 50 69.89 100 66.67 1.09
80 60 50 72.5 100 50 1.49
Table 12: Performance of the lower bounds for m = 6.
n Opto Imp Redavg Redmax Opt, Time
10 10 77.78 21.51 46.42 0 0.04
20 0 70 34.49 78.12 0 0.19
30 10 88.89 8.40 14.28 0 0.43
40 10 44.45 11.52 25.32 0 0.95
50 0 80 27.92 85.71 0 1.35
60 20 50 36.87 85 0 2.09
70 30 57.14 23.79 85.71 0 2.88
80 30 85.71 20.19 100 16.68 3.44
Table 11: Performance of the lower bounds for m = 5.
n Opto Imp Redavg Redmax Opt, Time
10 20 100 48.92 100 28.57 0.02
20 20 100 36.24 100 12.5 0.08
30 10 88.89 21.91 100 12.5 0.20
40 10 77.78 47.77 100 14.27 0.53
50 10 100 46.56 100 22.22 0.67
60 30 71.43 26.02 100 20 1.46
70 30 71.43 40.59 77.78 0 2.03
80 50 80 61.17 100 25 2.79
discrete uniform distribution on [1,100]. The number of jobs n is taken equal to 10,20, 30,40, 50, 60, 70, and 80. The number of machines m is taken equal to 4, 5, and 6. We combined these problem characteristics to obtain 24 classes of instances. For each class, 10 instances are generated.
5.2. Performance of the Lower Bounds. In order to assess the impact of the proposed adjustment procedures in the computation of a lower bound, we performed a thorough comparison between the one-machine-based lower bound LB0 and the adjustment-based lower bound LB1. The objective of this analysis is to determine how many times LB1 improved LB0 and how important is this improvement. For that purpose, we first computed, for each class of instances, the percentage of times (Opt0) where LB0 provides the optimal makespan, that is, LB0 = UB, where UB denotes the best value of the makespan provided by our five heuristics. Clearly, LB1 is not computed for these instances since there is no room for improving LB0. Then, we computed for the remaining instances the percentage of times (Imp) where LB1 outperformed LB0. The importance of this improvement is emphasized in the following way. For the instances where an improvement of LB0 occurred, we compared the reduced gap UB-LB1 with respect to the initial gap UB-LB0 by computing the relative gap reduction defined as 100((LB1 - LB0)/(UB -LB0)). We reported the average gap reduction (Redavg), the maximum gap reduction (Redmax), and the percentage of times (Opt1) where the reduced gap reached 100%; that is, the optimal makespan is provided by LB1. Finally, the average CPU time (in seconds) required by LB1 is computed. At this point, it is worth noting that the CPU time of LB0 is always less than 0.001 sec and has not been reported.
The results of our analysis are reported in Tables 10,11, and 12. These tables provide strong evidence of the dominance
of our adjustment-based lower bound. Indeed, we observe that, in all problem classes, LB1 was able to improve LB0. Moreover, this improvement often occurred in more than 70% of the cases (14 out of 24 classes) and reached 100% in some few cases. In addition, the average gap reduction is in most cases larger than 30% and the maximal gap reduction exceeds 70% in 87.5% of the problem classes (21 out of 24). We observe that this gap reduction is more important for smaller values of m. Indeed, for m = 4, the average gap reduction is always more than about 70% and the maximal gap reduction is equal to 100% in all problem classes except one. Furthermore, except for m = 6, the bound LB1 was often able to provide the optimal makespan. Finally, we observe that the adjustment-based lower bound is very fast, since the average CPU time never exceeds 3.5 sec.
5.3. Performance of the Heuristics. The results of a comparison of our five heuristics are depicted in Tables 13,14, and 15. For each heuristic, we provide the following.
(i) Gap: the average gap with respect to the lower bound LB1, where the gap of the heuristic Ht (i = 1,..., 5) with makespan UB; is defined as 100((UBj -LB^/LB^.
(ii) Time: the average CPU time
(iii) Opt: the percentage of times where the provided solution is proven optimal (i.e., the provided makespan is equal to LB1)
We observe that H1 and H2 exhibit a similar performance but are outperformed by H3. We note that the obtained value of the makespan provided by H3 is equal to the minimum between those obtained by H1 and H2. However, our experimental results show that the required computational effort is substantially reduced.
The comparison of H3 with H4 shows that the bisection search performed by H4 allows a substantial decrease of the CPU time while it slightly deteriorates the quality of the obtained solution. H4 often exhibits a good trade-offbetween the decrease of the computation time and the decrease of the solution's quality. In addition, H5 outperforms all the other heuristics for small value of n (n < 50) by providing a small average gap. However it requires much more CPU time.
For all the heuristics, we observe that the average gap increases when the number of machines increases (especially for m = 6) and decreases when the number of jobs increases.
Table 13: Performance of the heuristics for m = 4.
H1 Gap Time Opt H2 Gap Time Opt H3 Gap Time Opt H4 Gap Time Opt H5 Gap Time Opt
3.57 0.76 50
3.88 0.71 40
2.69 0.92 60
3.50 0.33 50
1.62 2.72 60
2.15 6.65 10
9.03 20
2.04 10.56
2.99 3.25 30
0.95 26.90 50
1.29 24.78 30
1.00 15.80 50
0.84 29.25 60
2.03 13.91 20
0.66 159.39 60
0.50 39.09 60
0.49 23.74 50
0.22 34.45 70
0.52 35.38 60
0.25 149.75 90
0.72 119.40 40
0.80 236.01 40
0.51 256.20 60
0.97 95.81 60
0.46 290.63 60
115.96 60
0.77 218.44 50
140.97
0.47 185.55 70
0.29 314.27
0.31 208.47 40
0.80 379.63 40
0.20 271.56 50
0.55 360.32 50
0.48 482.18 50
0.09 229.45 50
0.56 507.28 50
0.07 260.30 70
0.44 628.47 50
0.22 599.55 30
Table 14: Performance of the heuristics for m = 5.
H1 Gap Time Opt H2 Gap Time Opt H3 Gap Time Opt H4 Gap Time Opt H5 Gap Time Opt
5.79 1.66 20
4.94 1.62 20
3.86 2.10 30
5.15 0.53 20
2.90 9.58 40
7.18 31.35 10
5.29 25.63 10
4.43 35.78 20
6.21 6.38 20
3.17 108.53 30
5.73 134.53 10
6.35 170.30 10
4.93 233.55 10
5.35 24.17 10
3.99 376.25 20
3.08 222.54 0
3.44 213.26 0
2.36 285.89 0
3.34 59.67 0
2.40 529.69 20
1.77 300.07 10
1.27 319.76 10
0.73 291.89 20
1.38 152.74 10
0.96 560 20
1.68 681.81 40
1.36 606.98 20
0.91 851.41 40
1.26 281.72 40
1.32 498.20 40
1.34 1391.61 20
1.82 1228.84 10
1.23 1882.48 20
1.59 537.82 10
1.40 590.75 20
0.84 881.23 30
0.94 1652.91 50
0.55 1485.87 60
0.90 907.04 40
Furthermore, for the case where m = 4, we remark that the average gap is in most cases less than 1%. The maximum number of occurrences where the average gap is less than 1% is reached for H5 which is often able to provide the optimal solution.
6. Conclusion
In this paper, we present new adjustment and bounding procedures for the nonpermutation flowshop scheduling problem. We improve the main proposed adjustment procedures
of the literature and develop new ones. The resulting adjustments have been efficiently used to derive lower and upper bounds for the problem. Our experimental results show that the developed bounds provide good results especially for small values of the number of machines. In particular, a heuristic based on randomization and bisection search seems to exhibit promising performance.
This research can be extended by incorporating all the new adjustment procedures and the developed lower and upper bounds in a branch-and-bound algorithm. Another avenue of future investigation is to apply the adjustment
Table 15: Performance of the heuristics for m = 6.
HI Gap Time Opt H2 Gap Time Opt H3 Gap Time Opt H4 Gap Time Opt H5 Gap Time Opt
9.47 3.78 0
9.61 4.28 0
7.99 5.85 0
9.75 0.87 0
6.39 16.85 10
7.67 53.16 0
7.43 49.41 0
6.49 83.94 0
8.29 10.34 0
4.84 223.17 0
6.91 253.38 0
7.31 242.64 0
6.23 412.25 0
6.90 40.37 0
5.61 554.18 10
5.14 728.58 0
5.12 628.18 10
4.48 1180.35 10
5.45 106.24 10
5.05 553.06 10
3.80 1063.13 0
4.57 1192.89 0
3.33 1563.44 0
4.72 217.00 0
5.01 594.42 0
1.62 1228.46 20
2.04 1173.98 0
1.27 1476.98 20
2.55 453.18 10
3.43 576.12 10
2.76 3719.93 20
2.56 2274.25 20
2.32 4525.30 30
2.81 922.69 20
3.31 600 0
2.68 6279.36 20
2.72 5679.16 40
2.18 7984.64 40
2.78 1491.32 20
5.04 600 0
procedures to the permutation flowshop and the jobshop scheduling problems.
Conflict of Interests
The authors declare that there is no conflict of interests regarding the publication of this paper.
Acknowledgment
The authors would like to extend their sincere appreciation to the Deanship of Scientific Research at King Saud University for its funding of this research through the Research Group Project no. RGP-VPP-296.
References
[1] S. Pugazhendhi, S. Thiagarajan, C. Rajendran, and N. Anantharaman, "Performance enhancement by using non-permutation schedules in flowline-based manufacturing systems," Computers & Industrial Engineering, vol. 44, no. 1, pp. 133-157, 2003.
[2] R. Swaminathan, M. E. Pfund, J. W. Fowler, S. J. Mason, and A. Keha, "Impact of permutation enforcement when minimizing total weighted tardiness in dynamic flowshops with uncertain processing times," Computers & Operations Research,vol. 34, no. 10, pp. 3055-3068, 2007.
[3] C. N. Potts, D. B. Shmoys, and D. P. Williamson, "Permutation vs. non-permutation flow shop schedules," Operations Research Letters, vol. 10, no. 5, pp. 281-284,1991.
[4] M. I. Sviridenko, "A note on permutation flow shop problem," Annals of Operations Research, vol. 129, pp. 247-252, 2004.
[5] R. L. Graham, E. L. Lawler, J. K. Lenstra, and A. H. Rinnooy Kan, "Optimization and approximation in deterministic sequencing and scheduling: a survey," Annals of Discrete Mathematics, vol. 5, pp. 287-326, 1979.
[6] S. M. Johnson, "Optimal two- and three-stage production schedules with setup times included," Naval Research Logistics Quarterly, vol. 1, no. 1, pp. 61-68,1954.
[7] M. R. Garey, D. S. Johnson, and R. Sethi, "The complexity of flowshop and jobshop scheduling," Mathematics of Operations Research, vol. 1, no. 2, pp. 117-129,1976.
[8] E. Ignall and L. Schrage, "Application of the branch and bound technique to some flow-shop scheduling problems," Operations Research, vol. 13, no. 3, pp. 400-412,1965.
[9] L. Lomnicki, "A branch and bound algorithm for the exact solution ofthe three-machine scheduling problem," Operational Research Quarterly, vol. 16, no. 1, pp. 89-100,1965.
[10] J. Grabowski, "On two-machine scheduling with release dates to minimize maximum lateness," Operations Research, vol. 17, pp. 133-154, 1980.
[11] J. Carlier and I. Rebal, "Two branch and bound algorithms for the permutation flow shop problem," European Journal of Operational Research, vol. 90, no. 2, pp. 238-251,1996.
[12] J. Cheng, H. Kise, and H. Matsumoto, "A branch-and-bound algorithm with fuzzy inference for a permutation flowshop scheduling problem," European Journal of Operational Research, vol. 96, no. 3, pp. 578-590,1997.
[13] M. Haouari and T. Ladhari, "A computational study of the permutation flow shop problem based on a tight lower bound," Computers and Operations Research, vol. 32, no. 7, pp. 1831-1847, 2005.
[14] R. Ruiz and C. Maroto, "A comprehensive review and evaluation of permutation flowshop heuristics," European Journal of Operational Research, vol. 165, no. 2, pp. 479-494, 2005.
[15] M. Nawaz, E. E. Enscore Jr., and I. Ham, "A heuristic algorithm for the m-machine, n-job flow-shop sequencing problem," Omega, vol. 11, no. 1, pp. 91-95,1983.
[16] M. Haouari and T. Ladhari, "A branch-and-bound-based local search method for the flow shop problem," Journal of the Operational Research Society, vol. 54, no. 10, pp. 1076-1084, 2003.
[17] I. H. Osman and C. N. Potts, "Simulated annealing for permutation flow-shop scheduling," Omega, vol. 17, no. 6, pp. 551-557, 1989.
[18] C. R. Reeves, "Improving the efficiency of tabu search for machine sequencing problems," Journal of the Operational Research Society, vol. 44, no. 4, pp. 375-382,1993.
[19] E. Nowicki and C. Smutnicki, "A fast taboo search algorithm for the job shop problem," Management Science, vol. 42, no. 6, pp. 797-813, 1996.
[20] H. Fisher and G. L. Thompson, "Probabilistic learning combinations of local job-shop scheduling rules," in Industrial Scheduling, J. F. Muth and G. L. Thompson, Eds., pp. 225-251, Prentice Hall, Englewood Cliffs, NJ, USA, 1963.
[21] P. Brucker, S. A. Kravchenko, and Y. N. Sotskov, "On the complexity of two machine job-shop scheduling with regular objective functions," Operations-Research-Spektrum, vol. 19, no. 1, pp. 5-10,1997.
[22] P. Brucker, S. A. Kravchenko, and Y. N. Sotskov, "Preemptive job-shop scheduling problems with a fixed number of jobs," Mathematical Methods of Operations Research, vol. 49, no. 1, pp. 41-76, 1999.
[23] P. Brucker, Y. N. Sotskov, and F. Werner, "Complexity of shop-scheduling problems with fixed number of jobs: a survey," Mathematical Methods of Operations Research, vol. 65, no. 3, pp. 461-481, 2007.
[24] J. Carlier and E. Pinson, "An algorithm for solving the job-shop problem," Management Science, vol. 35, no. 2, pp. 164-176,1989.
[25] P. Brucker, B. Jurisch, and B. Sievers, "A branch and bound algorithm for the job-shop scheduling problem," Discrete Applied Mathematics, vol. 49, no. 1-3, pp. 107-127,1994.
[26] W. Brinkkotter and P. Brucker, "Solving open benchmark instances for the job-shop problem by parallel head-tail adjustments," Journal of Scheduling, vol. 4, no. 1, pp. 53-64, 2001.
[27] J. Adams, E. Balas, and D. Zawack, "The shifting bottleneck procedure for job shop scheduling," Management Science, vol. 34, no. 3, pp. 391-401, 1988.
[28] S. Dauzere-Peres and J.-B. Lasserre, "A modified shifting bottleneck procedure for job-shop scheduling," International Journal of Production Research, vol. 31, no. 4, pp. 923-932,1993.
[29] E. Balas, J. K. Lenstra, and A. Vazacopoulos, "The one-machine problem with delayed precedence constraints and its use in job shop scheduling," Management Science, vol. 41, no. 1, pp. 94-109, 1995.
[30] H. Wenqi and Y. Aihua, "An improved shifting bottleneck procedure for the job shop scheduling problem," Computers & Operations Research, vol. 31, no. 12, pp. 2093-2110, 2004.
[31] V. A. Armentano and C. R. Scrich, "Tabu search for minimizing total tardiness in a job shop," International Journal of Production Economics, vol. 63, no. 2, pp. 131-140, 2000.
[32] E. Nowicki and C. Smutnicki, "New algorithm for the jobshop problem," Tech. Rep., Institute of Engineering Cybernetics, Wroclaw University of Technology, Wroclaw, Poland, 2003.
[33] R. W. Conway, W. L. Maxwell, and L. W. Miller, Theory of Scheduling, Addison-Wesley, Reading, Mass, USA, 1967.
[34] C. L. Monma and A. H. G. Rinnooy Kan, "A concise survey of efficiently solvable special cases of the permutation flow-shop problem," RAIRO Recherche Opérationnelle, vol. 17, no. 2, pp. 105-119,1983.
[35] A. H. G. R. Kan, Machine Scheduling Problems: Classification, Complexity and Computations, Nijhoff, The Hague, The Netherlands, 1976.
[36] J. K. Lenstra, Sequencing by Enumerative Methods, vol. 69 of Mathematical Center Tracts, Mathematisch Centrum, Amsterdam, The Netherlands, 1977.
[37] M. Dell'Amico, "Shop problems with two machines and time Lags," Operations Research, vol. 44, no. 5, pp. 777-787,1996.
[38] D. Rebaine, "Flow shop vs. permutation shop with time delays," Computers and Industrial Engineering, vol. 48, no. 2, pp. 357362, 2005.
[39] B. Benson and M. Dror, "Linear time procedure for the two job flowshop," Foundations of Computing and Decision Sciences, vol. 23, no. 3, pp. 179-186,1998.
[40] J. Carlier and E. Pinson, "Adjustment of heads and tails for the job-shop problem," European Journal of Operational Research, vol. 78, no. 2, pp. 146-161,1994.
[41] P. Brucker, B. Jurisch, and A. Kramer, "The job-shop problem and immediate selection," Annals of Operations Research, vol. 50, pp. 73-114, 1994.
[42] J. Carlier and E. Pinson, "A practical use of Jackson's Preemptive Schedule for solving job-shop problem," Annals of Operations Research, vol. 26, no. 1-4, pp. 269-287,1990.
[43] J. R. Jackson, "Scheduling a production line to minimize maximum tardiness," Management Science Research Project, University of California, Los Angeles, Calif, USA, 1955.
[44] M. Haouari and A. Gharbi, "An improved max-flow-based lower bound for minimizing maximum lateness on identical parallel machines," Operations Research Letters, vol. 31, no. 1, pp. 49-52, 2003.
[45] J. Carlier, "The one-machine sequencing problem," European Journal of Operational Research, vol. 11, no. 1, pp. 42-47,1982.
Copyright of Journal of Applied Mathematics is the property of Hindawi Publishing Corporation and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use.
