A Two-Stage Assembly-Type Flowshop Scheduling Problem for Minimizing Total Tardiness

This research considers a two-stage assembly-type flowshop scheduling problemwith the objective ofminimizing the total tardiness. Thefirst stage consists of two independentmachines, and the second stage consists of a singlemachine. Two types of components are fabricated in the first stage, and then they are assembled in the second stage. Dominance properties and lower bounds are developed, and a branch and bound algorithm is presented that uses these properties and lower bounds as well as an upper bound obtained from a heuristic algorithm. The algorithm performance is evaluated using a series of computational experiments on randomly generated instances and the results are reported.


Introduction
This paper focuses on the problem of scheduling a given set of jobs with different due dates in a two-stage assembly-type flowshop in which the first stage consists of two independent machines and the second stage consists of a single machine.In the first (or subassembly) stage, two types of components are fabricated separately and independently on the two different machines; then, they are assembled into the final product in the second (or assembly) stage.In the system, the two components can be produced on the two machines in the first stage at the same time, while they are fed into the second stage only after both components are completed.In this paper, a branch and bound algorithm is presented for a two-stage assembly-type flowshop scheduling problem with the objective of minimizing the total tardiness.
This study considers a two-stage assembly-type flowshop scheduling problem to minimize total tardiness.This scheduling problem is denoted by 2 ‖ Σ  in the threefield notation of Graham et al. [1], where 2 refers to a twostage assembly-type flowshop with two machines in the first stage and   is the tardiness of job  defined as   = max{  −   , 0}, where   and   are the completion time and due date of job , respectively.Note that a typical two-machine flowshop is a special case of a two-stage assembly-type flowshop if the first stage has one machine instead of two independent machines.Thus, the problem considered in this study can be easily proven to be NP-hard in the strong sense because an ordinary two-machine flowshop scheduling problem with the objective of minimizing the total tardiness is NP-hard in the strong sense [2].
Two-stage assembly-type flowshops are found in various manufacturing systems.For example, Lee et al. [3] described a fire engine assembly system in which the body shell and chassis are produced independently on two machines and then brought into a final assembly stage.Furthermore, Sung and Kim [4] considered a table assembly system where the board and legs are made separately in the first stage and then they are assembled together in the second stage; and they also considered a cross-docking distribution problem where two products are gathered and then repacked.In addition, many practical problems can be modeled as two-stage assemblytype flowshops.
There have been many studies on two-stage assemblytype flowshop scheduling problems.For problems with the objective of minimizing makespan, Lee et al. [3] proved that the problem is strongly NP-complete, although there are only two machines in the first stage; they also discussed some polynomially solvable cases of the problem and proposed a branch and bound (B&B) algorithm.Furthermore, Potts et al. [5] showed that the search for an optimal solution may be restricted to permutation schedules.In addition, Hariri and Potts [6] and Haouari and Daouas [7] proposed B&B algorithms, while Sun et al. [8] develop heuristic algorithms.On the other hand, Koulamas and Kyparisis [9] generalized the problem into a three-stage assembly-type flowshop and proposed heuristic algorithms.Furthermore, Sung and Juhn [10] proposed a B&B algorithm for the problem in which one type of components is outsourced subject to the job-dependent lead-time in the first stage.
In addition, for problems with the objective of minimizing the total (weighted) completion time, Tozkapan et al. [11] developed two heuristic algorithms and a B&B algorithm, and Al-Anzi and Allahverdi [12] proposed several heuristic algorithms, while Allahverdi and Al-Anzi [13] proposed three heuristic algorithms for the problem considering separate setup times.On the other hand, Sung and Kim [4] developed a B&B algorithm and heuristic algorithm for the problem in which the second stage consists of two identical parallel machines.
Although there have been many studies on problems with the objective of minimizing the makespan or total flow time, there has not been significant progress in problems with respect to the performance measures related to due dates.Allahverdi and Al-Anzi [14] proposed a mathematical formulation and heuristic algorithms for a problem with the objective of minimizing the maximum tardiness, and Al-Anzi and Allahverdi [15] addressed the same problem while considering separate setup times.In addition, Allahverdi and Aydilek [16] proposed heuristic algorithms in order to minimize the total tardiness.
In this study, a branch and bound (B&B) algorithm is presented for the two-stage assembly-type flowshop scheduling problem with the objective of minimizing the total tardiness.Dominance properties and lower bounds are developed, and these can be used in the B&B algorithm.Also, a heuristic algorithm is proposed that can be used to find an (initial) upper bound in the B&B algorithm as well as to find a good solution quickly.Note that this study is the first attempt to develop an optimal solution algorithm for the problem considered in this paper, that is, 2 ‖ Σ  .
The remainder of this paper is organized as follows.In the next section, we describe the problem considered in this study in more detail and give a mixed integer programming formulation for the problem.Then, the dominance properties associated with the problem are given in Section 3, and the lower bounds and a B&B algorithm are given in Section 4. For the evaluation of the performance of the B&B algorithm, a series of computational experiments are performed and the results are reported in Section 5. Finally, Section 6 concludes the paper with a short summary.

Problem Description
In this paper, a two-stage assembly-type flowshop scheduling problem is considered.There are two machines in the first stage, while there is a single machine in the second stage.There are  jobs ( 1 ,  2 , . . .,   ) to be processed in the flowshop and each job (say job ) consists of three operations (  ,   , and   ).The first two operations (  and   ) are performed separately and independently on different machines (  and   , resp.) in the first stage and the last operation (  ) is performed on a single machine (  ) in the second stage.Here, it is assumed that   can be started only after both   and   are completed in the first stage.Other assumptions include the following: (1) All jobs are available at time zero.
(2) Preemption of the jobs is not allowed.
(3) There is no precedence relationship between the jobs.
(4) There is no setup time required before a job is processed.
(5) Machine idle time in the first stage is not allowed.
In this problem, there are (!) 3 alternatives for ordering jobs on the machines.However, there is an optimal solution among ! permutation schedules in which the operating sequences of the jobs are the same on the machines.This is because Tozkapan et al. [11] proved that permutation schedules are dominant for the two-stage assembly scheduling problem with the objective of minimizing the total completion time and their proof is sufficient to show that permutation schedules are dominant for any regular performance measure, including total tardiness.Therefore, only permutation schedules are considered in order to find an optimal solution.That is, the sequence of jobs on the three machines (two in the first stage and one in the second stage) is the same.
A mathematical formulation of the problem considered in this study is provided below.The notation that is used in the formulation and throughout this paper is provided in Notation.Now, a mixed integer program is given: Mathematical Problems in Engineering 3 The objective function, which is to be minimized, represents the total tardiness.Constraints (2) and (3) are used to compute the tardiness and completion time of each job.Constraint sets (4)-( 6) specify the starting time of each job on the machine in the second stage.Also, constraint sets ( 7)- (10) specify the starting times of each job on the machines in the first stage.Constraints (11) and (12) ensure that each job is placed at only one position in the sequence and only one job can be placed at each position, respectively.Constraints ( 13) and ( 14) define the domain of the decision variables.

Dominance Properties
In this section, the dominance properties of the problem considered in this study are developed, which are used in the branch and bound (B&B) algorithm proposed in this paper.These properties are used to delete nodes (in the B&B tree) associated with partial schedules that are dominated by others in the B&B algorithm.A partial schedule () is said to be dominated by another partial schedule (  ) when it results in a complete schedule better than the best possible complete schedule resulting from .Thus, when a node (corresponding to a partial schedule) is generated in the B&B algorithm, it can be deleted if its corresponding partial schedule is dominated by another partial schedule.The notation that is used in the statements and proofs of the properties and for the description of the algorithms presented in this paper is provided in Notation.
The following propositions provide the dominance properties that are used to identify the partial schedules that are dominated by others.First, Propositions 1 and 2 are obtained through modifying the dominance conditions given in Schaller [17].
Proposition 1.For any partial schedule () in which job  is scheduled last and job  immediately precedes job  and another partial schedule (  ) which is identical to  except that jobs  and  are interchanged, if ()   (  ) ≤   and (1) Proof.Because there is no machine idle time in the first stage, the completion times of the last jobs on the machines are the same in both partial schedules  and   .If () is satisfied, job  is not tardy in  and   ; that is,   () =   (  ) = 0. Also, because job  is completed earlier in   than in , the tardiness of job  may be decreased or unchanged; that is,   () ≥   (  ).On the other hand, if (1) is satisfied, the interchange does not delay the starting time of the next job to be scheduled after   .If (2) is satisfied, the starting time of the next job to be scheduled after   does not depend on the completion time of job  in   because Δ(  ) = max{ 1 (  ) + min ∉(  ) { 1 },  2 (  ) + min ∉(  ) { 2 }} is the lower bound on the completion time of the next job in the first stage after   .Consequently, the interchange can decrease the tardiness of jobs  and , and it does not delay the starting time of the next job to be scheduled after   .Therefore,  is dominated by   .

Proposition 2. For any partial schedule (𝜎) in which job 𝑖 is scheduled last and job 𝑗 is completed earlier than job 𝑖 and another partial schedule (𝜎
Proof.If () is satisfied, because   is obtained by interchanging job  and job  only, the tardiness of   is no greater than the tardiness of .However, the starting time of each job to be scheduled after job  in a complete schedule resulting from   can be increased by at most   (  )−max{  (), Δ(  )}.Then, the increase of the total tardiness caused by this interchange is less than or equal to The following two propositions show the dominance properties related to two adjacent jobs scheduled in a partial schedule.Proposition 3.For any partial schedule () in which job  is scheduled last and job  immediately precedes job  and another partial schedule (  ) which is identical to  except that jobs  and  are interchanged, if ()   (  ) ≤   () and   (  ) ≤   () and ()   ≤   ,  is dominated by   .
Proof.Because   (  ) ≤   (), the interchange does not delay the starting time of the next job to be scheduled after   .Thus, in order to prove the proposition, it must be proved that the tardiness may be decreased or unchanged by interchanging job  and job  in the partial schedule .Let Δ  and Δ  be the changes in the tardiness of job  and job  due to the interchange, respectively.Then, for any three real numbers  1 ,  2 , and  3 .The following cases are considered in order to determine the relationship between Δ  + Δ  and 0.
Therefore, the sum of tardiness is decreased or unchanged through the interchange of the two jobs.This completes the proof.Because   (  ) ≤   (), the interchange does not delay the starting time of the next job to be scheduled after   .Thus, in order to prove the proposition, it is only needed to be shown that   (  ) +   (  ) ≤   () +   ().Then,
The following proposition is extended from a dominance rule that is used for a single-machine weighted tardiness problem, suggested by Potts and Van-Wassenhove [18].Proposition 5. Consider two partial schedules, that is, a partial schedule () and another partial schedule (  ), which consist of the same set of jobs included in ; that is, () = (  ) and the sequences are different.If () Γ  (  ) ≤ Γ  () and () ∑ ∈(  )   (  ) ≤ ∑ ∈()   (),  is dominated by   .
Proof.Because the two partial schedules ( and   ) consist of the same set of jobs and only the sequences are different, Γ  () = Γ  (  ) and Γ  () = Γ  (  ).If (a) is satisfied, the starting time of the next job to be scheduled after   is no greater than the starting time of the next job to be scheduled after .Furthermore, the tardiness of the jobs under   is no greater than that under .Therefore, if Γ  (  ) ≤ Γ  () and ∑ ∈(  )   (  ) ≤ ∑ ∈()   (),  is dominated by   .

Branch and Bound Algorithm
This section presents the proposed branch and bound (B&B) algorithm for the problem considered in this study.In the following, the methods to construct a B&B tree in the algorithm, to obtain an initial feasible solution (or upper bound), and to compute lower bounds associated with nodes generated in the B&B tree are described.

Branching.
In this algorithm, the B&B tree is constructed as follows.Each node in the B&B tree corresponds to a partial schedule, and a node at the th level in the tree corresponds to a partial schedule in which the first  jobs are scheduled in front of the complete schedules that results from the partial schedule.Thus, when a node branches, or when child nodes are generated from a parent node or when a job is newly included in the partial schedule associated with the node, the new job to be included is appended at the end of the partial schedule.Because the sequences of  jobs must be considered in this scheduling problem, a complete schedule is at the th level in the B&B tree.
In the B&B algorithm, an initial upper bound, or initial feasible solution, is obtained at the root node of the B&B tree using a heuristic algorithm to be presented in the next section.For branching, that is, for selecting a node to generate branches from, the depth-first rule is employed in the algorithm.That is, a node with the most jobs included in the partial schedule that it is associated with is selected for branching.In case of ties, a node with the minimum lower bound is selected.When child nodes are generated from a selected parent node, it is verified whether the schedules associated with the child nodes are dominated by others using the dominance properties given in the previous section.For each child node that is not dominated, a lower bound is computed.Nodes with lower bounds greater than or equal to the current upper bound are deleted from further consideration.The upper bound is updated whenever a complete schedule better than the current upper bound is found.The algorithm is terminated if there are no more dangling nodes in the B&B tree, which can be selected for branching.

Upper Bound.
In order to obtain an initial upper bound at the root node of the B&B tree, a simple heuristic algorithm that consists of two phases (one for obtaining an initial solution and one for improving it) is used.The initial solution is obtained using the heuristic algorithm that is modified from a constructive algorithm developed by Nawaz et al. [19], called NEH, and, then, the solution is improved using pairwise interchanges of jobs.The NEH is known to work well in flowshop scheduling problems and it has been modified by many other researchers for various scheduling problems.The following summarizes the procedure of the two-phase heuristic, called mNEH-PI.

Procedure 1 (mNEH-PI).
Step 0. Obtain a seed sequence by sorting jobs in nondecreasing order of due dates.Let  be this sequence and set  * = ⌀, where  * is the (partial) schedule constructed so far in the heuristic.Set  = 1.Go to Step 1.
Step 1. Select the th job in .Go to Step 2.
Step 2. For  = 1 to | * | + 1, do the following: insert the selected job into the th position of  * and then compute the total tardiness of the schedule that is composed of the schedule of these | * | + 1 jobs followed by the sequence of jobs that are placed at the ( + 1)th position through the th position in .Go to Step 3.
Step 3. Select a partial schedule that results in the minimum total tardiness in Step 2. Let  * be the selected (partial) schedule.Go to Step 4.
Step 6. Generate a new sequence by interchanging two jobs in the th and th positions in  * .If the total tardiness of the new sequence is less than that of  * , then replace  * with the new sequence and go to Step 5; otherwise, go to Step 7.
Step 7. Let  ←  + 1.If  ≤ , go to Step 6; otherwise, let  ←  + 1 and  ←  + 1.If  < , go to Step 6; otherwise, terminate.( * is the final solution of this heuristic.)4.3.Lower Bound.In the B&B algorithm, a lower bound on the total tardiness (of the complete schedules resulting from the partial schedule associated with a node) is computed for each node that is not eliminated by the dominance rules given in the previous section.In the algorithm, two lower bounds are used and computed for jobs that are not included in the partial schedule associated with the current node.These bounds are based on Theorem 6, which was proposed by Chu [20] and independently by Kondakci et al. [21] and Kim [22].Here,  [] denotes the due date of a job with the th earliest due date among jobs in a partial schedule.Theorem 6.For nonnegative real numbers   and   corresponding to job , if  1 ≤  2 ≤ ⋅ ⋅ ⋅ ≤   , then the following inequality holds: Based on Theorem 6, if lower bounds on the completion times of the jobs can be computed, a lower bound on the total tardiness of the jobs can be calculated.
The first lower bound (LB 1 ) is developed based on the following proposition, which gives a lower bound on the completion time of the job that is completed th in a complete schedule.The proposition is obtained by modifying the result of Kim [22], which is used in two-machine flowshop total tardiness problem.

Proposition 7. In a two-stage flowshop, the completion time of the 𝑗th job in an arbitrary schedule is no less than
,  and   is the sum of  shortest processing times on machine  among all jobs; that is, Proof.  and   are lower bounds on the time needed to process  jobs on machines  and , respectively.Thus, max{  ,   } is a lower bound on the time required to process  jobs in the first stage.Thus, the completion time of the th job is no less than the sum of max{  ,   } and the minimum processing time among all jobs in the second stage,  [1] .Similarly, it is no less than max{ [1] ,  [1] } +   .
From Proposition 7, a lower bound on the total tardiness of jobs that are not included in a partial schedule,  (or to be scheduled after ), can be computed.Then, the lower bound is computed as The lower bound can be improved by considering the completion times of the last jobs on the machines in , that is, Γ  (), Γ  (), and Γ  ().Meanwhile, if machine  in the second stage is working when the processing in the first stage of the next job after  is completed, the last operation of the job can be started only after machine  becomes available.Then, Γ  () +   can also be used to compute a lower bound.Thus, the improved lower bound is used in the B&B algorithm and it is computed as follows: The second bound (LB 2 ) is obtained by relaxing the problem considered in this study into a two-machine flowshop tardiness problem in which the two machines in the first stage are considered as a single machine.Here, let  1 be the minimum value of the completion times of the two machines in the first stage and  2 the completion time of the machine in the second stage.The following procedure is used to obtain LB 2 .
The maximum value between the two lower bounds, max{LB 1 , LB 2 }, can be used as the lower bound for jobs not in the partial schedule in the proposed B&B algorithm.Then, a lower bound for the partial schedule corresponding to each node in the B&B tree can be obtained by adding this lower bound to the total tardiness of the jobs included in the partial schedule.

Computational Experiments
In order to evaluate the performance of the branch and bound (B&B) algorithm proposed in this paper, a series of computational tests were performed on randomly generated problem instances.In the instances, five levels (8, 12, 16, 20, and 24) for the number of jobs were considered.Processing times and due dates were generated according to the method used in Kim [23].The processing time of an operation was generated from (1, 100), where (, ) denotes the discrete uniform distribution with a range [, ].Then, the due dates of the jobs were generated from ( * (1 −  − /2),  * (1 −  + /2)), where  * is the time at which all jobs are completed, and  and  are the tardiness factor and relative range of due dates parameters, respectively.Here,  * is estimated using the lower bound on the makespan; that is,  * = max{max{∑  =1   , ∑  =1   } + min ∈ {  }, ∑  =1   }, and three levels for each of  and  were used for generation; that is,  = (0.1, 0.3, and 0.5) and  = (0.8, 1.3, and 1.8).If the resulting due dates were less than 0, they were reset to 0. For the experiments, 450 instances were generated, 10 instances for each combination of the number of jobs, , and .The algorithm was coded in Java, and the experiments were performed on a personal computer with a quad-core processor operating at 3.2 GHz and 4 GB RAM.In order to avoid excessive computation times for the experiments, a limit of 3600 seconds was set for the CPU time for each instance.
First, the performance of the B&B algorithm proposed in this study was tested through comparisons with that of the mixed integer program (MIP) given in Section 2 in terms of computation times and the numbers of instances that were solved within the time limit.Note that a commercial integer programming solver (CPLEX 12.5) was used to solve the MIP.The results of the test are given in Table 1.As seen in the table, the CPU times required to solve instances with up to 12 jobs did not differ significantly.However, for instances with 16 to 24 jobs, the B&B algorithm required a significantly shorter time than CPLEX.In addition, the B&B algorithm found optimal solutions for instances with up to 20 jobs, whereas CPLEX did not find optimal solutions for 10 instances with 20 jobs.For instances with 24 jobs, the B&B algorithm found more optimal solutions than CPLEX.Generally, the outperformance of the B&B algorithm over CPLEX became more significant as the problem size increased.Note that the test results of the proposed B&B algorithm are used in the next tests.
As seen from Table 1, the performance of the B&B algorithm was affected by the tightness of due dates or the tardiness factor () and relative range of due dates ().In order to see the effect, an analysis of variance (ANOVA) was performed for the instances with up to 20 jobs because several instances with 24 jobs were not solved within the time limit.From the results given in Table 2, the performance of the B&B algorithm was significantly affected by the values of  and , but not by their interaction ( × ).As seen in Table 1, the instances with a small  were solved within shorter computation times.Note that when  is smaller, the due dates are looser in general and, in this case, the total tardiness of jobs in an optimal solution was small (or 0 in several instances).In cases with looser due dates, the heuristic algorithm used in the root node of the B&B tree may find a tighter initial upper bound; hence, many partial schedules could be fathomed in the earlier stages of the B&B algorithm.Furthermore, the algorithm worked better when  was large, possibly because the due dates of jobs were widely dispersed, which resulted in the dominance properties used in the B&B algorithm being applied more often.In contrast, when  was large and  was small, the performance of the algorithm was not good.
In order to verify the effectiveness of the lower bounds used in the B&B algorithm, two B&B algorithms were compared; the BB LB+ with the lower bounds and the BB LB− without the lower bounds.All dominance properties given in Section 3 were implemented in both algorithms.In order to avoid excessive computation times, instances with up to 20 jobs were used.The results are summarized in Table 3.As seen from the table, instances with up to 12 jobs were solved within 1 second on average, even though the lower bounds were not used.However, as the number of jobs increased, BB LB+ outperformed BB LB− , and the outperformance became clearer as the number of jobs increased.In addition, BB LB+ solved all instances, whereas BB LB− did not solve 36 instances with 20 jobs within 3600 seconds.This indicates that using  the lower bounds significantly reduced the computation time of the B&B algorithm and fathomed a larger number of nodes generated in the B&B procedure.Furthermore, the effectiveness of the lower bounds became more significant as the problem size increased.
Next, in order to verify the effectiveness of the dominance properties, seven B&B algorithms were tested: BB, which is the B&B algorithm with all dominance properties; BB D , where  = 1, 2, . . ., 5, which denotes the B&B algorithm with all dominance properties except for that given in Proposition ; and BB D− , which is the B&B algorithm with no dominance property.In these algorithms, the lower bounds were used.Table 4 presents the results of these tests.As seen from the table, using the dominance properties, the computation time and the number of generated nodes were reduced considerably.In particular, when  = 20, BB D− did not solve 19 instances within 3600 seconds.This shows that a large portion of the nodes in the B&B tree could be fathomed; hence, the use of dominance properties assisted in enhancing the performance of the B&B algorithm, even though checking those in each node required the computation times.On the other hand, BB D5 required longer computation time than the other BB D algorithms.This indicates that the dominance property given in Proposition 5 can be applied more often.
Finally, the heuristic algorithm (mNEH-PI) used in the B&B algorithm was tested in order to examine its effectiveness and performance.As in the above tests, a B&B algorithm with the heuristic was compared with a B&B algorithm without the heuristic.All lower bounds and dominance properties were used in both algorithms.The results of this test are summarized in Table 5.In the table, BB H+ and BB H− denote the B&B algorithms with and without mNEH-PI, respectively.As shown in Table 5, the performance of BB H+ was better than that of BB H− .That is, when the heuristic was embedded in the B&B algorithm, the computation time and the number of nodes were reduced significantly.On the other hand, the percentage gap of the solutions of mNEH-PI from the optimal solutions was 2.09% on average.Note that the computation time required for mNEH-PI to solve an instance was less than 0.01 seconds regardless of the instance size and parameter values.

Concluding Remarks
This paper considered a two-stage assembly-type flowshop scheduling problem with the objective of minimizing the total tardiness, in which the first stage consists of two independent machines and the second stage consists of a single machine.It is assumed that the processing in the second stage can start only after the processing in the first stage is completed.The dominance properties and lower bounds on the tardiness of jobs associated with a partial schedule were developed, and a branch and bound (B&B) algorithm using these was presented.The results for randomly generated instances showed that the proposed B&B algorithm could find optimal solutions for instances with up to 24 jobs within a reasonable amount of computation time, except for a few cases, and the proposed algorithm worked better than CPLEX.
This research can be extended in several ways.In this study, a simple assembly-type flowshop case was considered, but problems with various characteristics could have been considered.For example, there is a case in which machines in the first stage can produce several types of components; that is, two components of a job can be fabricated on the same machine.Also, a case might include time constraints between the two stages; that is, the (assembly) operation of each job in the second stage should be started within a certain time period after the operations of the job in the first stage are completed.On the other hand, as mentioned earlier, this study has been the first attempt to develop an exact algorithm for the problem considered in this paper.Thus, better dominance properties and tighter bounds might need to be developed, or other exact algorithms to solve larger problems in which there are two stages and more than two machines in each stage might need to be developed.

Notation
The Notation Used in the Formulation Index for the th job in a sequence   : A binary variable that is equal to 1 if job  is scheduled in the th position in a sequence, and 0 otherwise

Table 1 :
Results of the test on the B&B algorithm and CPLEX.
‡ Median CPU time.# Number of instances (out of 10 instances) that were solved within 3600 seconds.

Table 2 :
ANOVA for the effect of due date tightness on CPU time of the B&B algorithm.

Table 3 :
Effectiveness of the lower bounds.Average number of nodes generated in the branch and bound procedure.# Number of instances (out of 90 instances) that were solved within 3600 seconds. ‡