Abstract
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 jobs has to be processed on a set of machines in that order. That is, each job has to be processed first on machine , then on machine , and so on until performing its last operation on machine . Each operation and requires an integer and deterministic processing time . 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 machines and jobs, the total number of feasible schedules tends to , whereas with the assumption of no job passing, the number of feasible solutions is reduced to . 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 of more than . 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 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 .
Although the is solvable to optimality in polynomial time when [6], it is known to be -hard in the strong sense when [7]. The 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 nonpermutation 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 .
Johnson [6] demonstrated that the two-machine problem can be solved in time by the following sequencing rule. First schedule the jobs with in order of nondecreasing ; then schedule the remaining jobs in order of nonincreasing . Unfortunately, the problem is no longer polynomial for larger values of . Indeed, Garey et al. [7] showed that is strongly -hard.
The 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 Rebaï [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 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 , is not only -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 Brinkkötter 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].
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 , then on , and so on. Now, we state the following property which is proposed by Conway et al. [33].
Property 1. For , 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 and , 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 and the are equivalent. That is, in the case of two-machine flowshop, there exists an optimal schedule which is a permutation. Consequently, the is solvable in polynomial time using Johnson’s algorithm [6]. Moreover, due to the symmetry of the , the following property holds.
Property 2. For , 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 . In other terms, the and are equivalent.
Garey et al. [7] showed that the problems of nonpermutation and permutation flowshop become -hard in the strong sense when the number of machines is larger than 3. However, there are several polynomially solvable special cases of that result from imposing certain inequalities on the processing times. For instance, Johnson [6] observed that if holds in an instance, then the second machine is nonbottleneck, and the optimal algorithm for problem 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 , is proven to be solvable in time in the permutation case [35], whereas it turns to be -hard in the general case [36]. Dell’Amico [37] proved that the nonpermutation case remains -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 jobs are restricted to be unit execution time, this ratio is reduced to for the two-machine case and is for the -machine case.
If we consider the case where , 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 time.
3. Adjustment Procedures
The nonpermutation flowshop problem may be represented using a disjunctive graph: two operations and , executed by the same machine, cannot be simultaneously processed. Therefore with each pair of operations, we associate a pair of disjunctive arcs . The problem is then modelled by a disjunctive graph , where is a conjunctive graph (two operations belonging to the same job are represented by a conjunctive arc) and is a set of disjunctions.
Figure 3 depicts a disjunctive graph of a 3-job-3-machine instance. The pair () denotes the processing of job on machine . Two dummy operations 0 and * are included which represent the source and the sink node, respectively. The minimum starting time denoted by of an operation is equal to the longest weighted path from to in the disjunctive graph . Similarly for each operation the tail is the length of the longest weighted path from to in .
In the sequel, we assume that the makespan is fixed to a trial value . The problem amounts to checking whether a feasible schedule with makespan less than or equal to exists. For that purpose, a deadline is associated with each operation .
The main purpose of adjustments is to reduce the time windows . 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 × 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 and successors according to the conjunctive graph can be adjusted using the following global adjustment algorithm (Algorithm 1; and denote the adjusted values of and , 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 and are such that then cannot be scheduled after . In this case, a disjunctive arc can be fixed, which means that is processed before in any feasible schedule [24]. Therefore, the release date of job can be adjusted to . Similarly, the deadline of job can be adjusted to . More generally, after determining all the disjunctive arcs using the above rule, the release date and the deadline of each job can be adjusted to and , where and denote the sets of predecessors of and the sets of successors of , respectively. Obviously, the instance is infeasible if 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 steps.
Example 1. Consider the 5-job instance defined by Table 2. We have . Therefore, a disjunctive arc should be added to the graph. Similarly, since , 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:
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 . Let be an operation such that , , and ; then can be scheduled neither before , nor between and , nor after . Consequently, cannot be processed before in any feasible schedule, and a disjunctive arc 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 in time. It is constructed as follows. At the first moment 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, 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 of a given operation . Let denote an upper bound of the optimal makespan and assume that Jackson’s preemptive schedule has been built until time . Let denote the remaining processing times in the preemptive schedule. Then, can be adjusted as follows.(i)Compute and .(ii)Take the operations of in increasing order of and find the first such that (if any exists).(iii)Define .(iv)Set ( is the completion time of job ).
Carlier and Pinson [42] presented an algorithm for adjusting all release dates. Brucker et al. [25] improved this complexity by proposing an algorithm, where is the number of new disjunctive arcs. The idea relies on the dual version of JPS which, starting from , calculates a schedule from right to left by applying the following dual rule. At each time which is given by a deadline or a release date of an operation, schedule backwards an incompletely scheduled operation with and . Such a schedule is referred to as backwards Jackson preemptive schedule (BJPS). The release date of a given operation can be adjusted using the following procedure.
Earliest_Possible_Completion_Algorithm
Step 1. Calculate JPS up to .
Step 2. Calculate BJPS without in using the remaining processing times.
Step 3. Schedule operation from left to right within the idle periods of . Let be the completion time of operation and set .
Similarly, the deadline of a given operation can be adjusted by applying the dual version of the above algorithm.
Latest_Possible_Completion_Algorithm
Step 1. Calculate BJPS up to .
Step 2. Calculate JPS without in using the remaining processing times.
Step 3. Schedule operation from right to left within the idle periods of . Let be the starting time of operation and set .
Example 1 (continued). Figures 5 and 6 depict the preemption-based adjustment of the release date and the deadline of job 1, respectively. We have and .
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 and for all . Interestingly, this adjustment rule can be improved in the following way.(i)A job is defined as an immediate predecessor of if there exists an arc in the disjunctive graph.(ii)A job is defined as a predecessor of if there exists a path in the disjunctive graph.
Let denote the set of all the predecessors of . Clearly, job has to wait until all the jobs of have been processed. Let denote the minimum completion time of all jobs of . Therefore, the minimum starting time of is at least equal to . It is worth noting that corresponds to the optimal makespan of the problem defined on . The is solvable in time by ranking jobs in nondecreasing order of their release dates. Clearly, since , then this adjustment rule dominates the classical one proposed by Carlier and Pinson [24].
Similarly, the deadline of job can be adjusted by setting , where denotes the set of all the successors of , and is the optimal makespan of problem defined on by setting .
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].
First, by remarking that the latest starting time of any job is , and its earliest finishing time is , we can state the following observation.
Observation 1. Assume that there exists a job such that . Then, in any nonpreemptive schedule, there is a part of job which must be processed during the interval .
According to the above observation, each job satisfying is composed of a fixed and a free part. Its fixed part is the amount of time which must be processed in , and its free part is the amount of time which has to be processed in . The other jobs are composed only of a free processing part which has to be processed in . 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 . Then, job has a fixed part in with processing time equal to and a free part in with processing time equal to . The modified instance is depicted in Table 4.
Figure 7 displays the semipreemption-based adjustment of the release date of job . We have .
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 schedule such that there is no idle time on the first machine. That is, no job finishes processing on later than . Therefore, the deadlines on can be adjusted by setting for all . In a similar way, using the symmetry of the the release dates on the last machine can be adjusted by setting .
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 and are the same. Consider a particular job and let denote the sequence (or permutation) of which maximizes the makespan on . Let denote the completion time of on and let denote an upper bound on the completion time of on . Clearly, we have . Consequently, the deadline of on machine can be adjusted to .
In what follows, we show how to compute . Let denote a permutation such that is the job that starts processing on after its last idle period (see Figure 8). Denote by and the starting time and the completion time of job on machine , respectively. Clearly, we have .
Let and denote the set of jobs that are scheduled before and after in , respectively. Denote by the variable that equals 1 if and 0 otherwise. We have
Clearly is maximized by setting for all satisfying and otherwise. Let denote the corresponding makespan and . We have .
Two cases have to be considered.(i)If then (ii)If then Consequently, an upper bound on is obtained by
Finally, is an upper bound on the completion time of all possible permutations on . Using appropriate data structure, all the deadlines on can be adjusted in time.
Thanks to the symmetry of the problem, the release dates on can be adjusted by setting , where is computed on the two-machine flowshop problem defined on and .
Example 3. Consider the 5-job-4-machine instance depicted in Table 6 and let . The values of the releases dates and the deadlines before performing any adjustment are depicted in Tables 7 and 8, respectively.
First, we have Now, we have and . Therefore, the deadline of job 2 on can be adjusted to Similarly, the deadline of job 5 on is adjusted to (instead of ). The adjusted release dates on obtained by the two-machine-based procedure are the following:
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 consists in relaxing the capacities of all the machines but one denoted by . The obtained problem is a one machine problem with release dates and delivery times denoted by , where and .
Although the latter problem is strongly -hard, it is efficiently solved using the branch-and-bound algorithm developed by Carlier [45]. Let denote the optimal makespan of the problem defined on . A valid lower bound for the is
It is worth noting that 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 denote an upper bound on the optimal makespan and let denote a trial value of the makespan. With each operation is associated a release date , a delivery time , and a deadline . Clearly, if after performing the adjustment procedure the instance is identified to be infeasible, then is a valid lower bound on the optimal makespan. Consequently, a bisection search on combined with the proposed adjustment procedure provides a lower bound denoted by which dominates . The computation of can be described as follows.
Compute
Step 1. Set , .
Step 2. Let .
Step 3. Set for all .
Step 4. Apply an adjustment procedure to the instance obtained in step 3. If the instance is infeasible, then set . Otherwise, set .
Step 5. If , then stop and set . Else, go to step 2.
In the computation of , we implemented the new proposed adjustment procedures. The value of 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 section we describe how we can use the adjustment procedures in order to construct an upper bound for the nonpermutation flowshop scheduling problem.
4.2.1. Heuristic
We are interested in building a nonpreemptive schedule with makespan less than or equal to a trial value . First, we set and we adjust the release dates and the deadlines using an adjustment procedure. An operation such that is referred to as a fixed operation and is considered as already scheduled. Let 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 nondecreasing 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 can be scheduled at its release date. In this case, we set . The list is then updated by the adjustment procedure.
Now, assume that the adjustment procedure yields an infeasibility. That is, scheduling at this position is not the right decision. Therefore, we have to skip operation and move to the next operation in the list. Note that in this case the minimum starting time of is . 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 is assumed as impossible. So we have to move on to 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 and ( is a makespan obtained by LPT dispatching rule and it is depicted in Figure 9).
Assume that we are interested in constructing a schedule with makespan equal to 254. The list contains only the first free operations in each machine. Thus, . At the first iteration, operation is scheduled at time . That is, the deadline is set to . The current data is updated by applying the adjustment procedures. Thus, we have . In the second iteration, the operation is scheduled to finish at . Next, we apply the adjustment procedures. Thus, we have . Assume that operation is scheduled at at the third iteration. That is, its deadline is set to .
Applying the adjustment procedures to the obtained instance yields an infeasibility. That is, the minimum starting time of is equal to , and scheduling operation at the third iteration is not the right choice. Consequently, we move to the next operation, and we have and so on. The obtained schedule is depicted in Figure 10. Its makespan is equal to 254.
4.2.2. Heuristic
Using the symmetry of the problem, a second heuristic can be obtained by applying to the symmetric instance (backward).
Example 4 (continued). Assume that and . We are interested in constructing a schedule with makespan equal to 253. The list of the free jobs is . At the first iteration, operation is scheduled at time . That is, the deadline is set to . Applying the adjustment procedures to the obtained instance yields an infeasibility. That is, the minimum starting time of is equal to . Consequently, scheduling operation 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
For each value of , 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 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 and . However, our experimental results show that the required computational effort is substantially reduced.
4.2.4. Heuristic
In order to reduce the computational effort, a bisection search on the trial value is embedded within . The value of lies in the interval where denotes the makespan obtained by LPT dispatching rule. It is worth noting that if a failure is obtained for a given value then all the values less than will not be considered. However, it may be possible to obtain a feasible schedule if a smaller value of is considered. Therefore, it is possible that yields a solution which is worse than that obtained by . Our experimental results show that 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
A randomization component is included in by selecting the operation that has to be scheduled randomly between the two first operations in the list . In case of failure for a given value of , 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 .
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 1 GB 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 discrete uniform distribution on . The number of jobs is taken equal to , and . The number of machines 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 and the adjustment-based lower bound . The objective of this analysis is to determine how many times improved and how important is this improvement. For that purpose, we first computed, for each class of instances, the percentage of times where provides the optimal makespan, that is, , where denotes the best value of the makespan provided by our five heuristics. Clearly, is not computed for these instances since there is no room for improving . Then, we computed for the remaining instances the percentage of times where outperformed . The importance of this improvement is emphasized in the following way. For the instances where an improvement of occurred, we compared the reduced gap with respect to the initial gap by computing the relative gap reduction defined as . We reported the average gap reduction , the maximum gap reduction , and the percentage of times where the reduced gap reached 100%; that is, the optimal makespan is provided by . Finally, the average CPU time (in seconds) required by is computed. At this point, it is worth noting that the CPU time of 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, was able to improve . 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 . Indeed, for , 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 , the bound 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 , where the gap of the heuristic with makespan is defined as .(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 )
We observe that and exhibit a similar performance but are outperformed by . We note that the obtained value of the makespan provided by is equal to the minimum between those obtained by and . However, our experimental results show that the required computational effort is substantially reduced.
The comparison of with shows that the bisection search performed by allows a substantial decrease of the CPU time while it slightly deteriorates the quality of the obtained solution. often exhibits a good trade-off between the decrease of the computation time and the decrease of the solution’s quality. In addition, outperforms all the other heuristics for small value of 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 ) and decreases when the number of jobs increases. Furthermore, for the case where , 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 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 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.