This research considers a two-stage assembly-type flowshop scheduling problem with the objective of minimizing the total tardiness. The first stage consists of two independent machines, and the second stage consists of a single machine. 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.
1. 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 AF2∥ΣTi in the three-field notation of Graham et al. [1], where AF2 refers to a two-stage assembly-type flowshop with two machines in the first stage and Ti is the tardiness of job i defined as Ti = maxCi-di,0, where Ci and di are the completion time and due date of job i, 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 assembly-type flowshops.
There have been many studies on two-stage assembly-type 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, AF2∥ΣTi.
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.
2. 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 n jobs (J1,J2,…,Jn) to be processed in the flowshop and each job (say job i) consists of three operations (Oia, Oib, and Oil). The first two operations (Oia and Oib) are performed separately and independently on different machines (Ma and Mb, resp.) in the first stage and the last operation (Oil) is performed on a single machine (Ml) in the second stage. Here, it is assumed that Oil can be started only after both Oia and Oib are completed in the first stage. Other assumptions include the following:
All jobs are available at time zero.
Preemption of the jobs is not allowed.
There is no precedence relationship between the jobs.
There is no setup time required before a job is processed.
Machine idle time in the first stage is not allowed.
In this problem, there are n!3 alternatives for ordering jobs on the machines. However, there is an optimal solution among n! 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:(1)P Minimize∑r=1nTr(2)subject toTr≥Cr-∑i=1ndixirr=1,…,n(3)Cr=srl+∑i=1npilxir∀r(4)srl≥sra+∑i=1npiaxir∀r(5)srl≥srb+∑i=1npibxir∀r(6)sr+1l≥Crr=1,…,n-1(7)sr+1a≥sra+∑i=1npiaxirr=1,…,n-1(8)sr+1b≥srb+∑i=1npibxirr=1,…,n-1(9)s1a=0(10)s1b=0(11)∑r=1nxir=1i=1,…,n(12)∑i=1nxir=1∀r(13)Tr,Cr,sra,srb,srl≥0∀r(14)xir∈0,1∀i,r.
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.
3. 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 i is scheduled last and job j immediately precedes job i and another partial schedule (σ′) which is identical to σ except that jobs i and j are interchanged, if (a) Cj(σ′)≤dj and (b1) Cj(σ′)≤Ci(σ) or (b2) Cj(σ′)≤Δ(σ′), σ is dominated by σ′, where Δ(σ′)=maxcj1σ′+minq∉Sσ′pq1,cj2σ′+minq∉Sσ′pq2.
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 (a) is satisfied, job j is not tardy in σ and σ′; that is, Tj(σ)=Tj(σ′)=0. Also, because job i is completed earlier in σ′ than in σ, the tardiness of job i may be decreased or unchanged; that is, Ti(σ)≥Ti(σ′). On the other hand, if (b1) is satisfied, the interchange does not delay the starting time of the next job to be scheduled after σ′. If (b2) is satisfied, the starting time of the next job to be scheduled after σ′ does not depend on the completion time of job j in σ′ because Δ(σ′)=maxcj1σ′+minq∉Sσ′pq1,cj2σ′+minq∉Sσ′pq2 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 i and j, 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 i is scheduled last and job j is completed earlier than job i and another partial schedule (σ′) which is identical to σ except that jobs i and j are interchanged, if (a) ∑q∈SjiσTq(σ)≥∑q∈Sijσ′Tq(σ′) and (b) ∑q∈SjiσTqσ-∑q∈Sijσ′Tq(σ′)≥nuσ·[Cjσ′-maxCiσ,Δσ′], σ is dominated by σ′, where Δ(σ′)=maxcj1σ′+minq∉Sσ′pq1,cj2σ′+minq∉Sσ′pq2.
Proof.
If (a) is satisfied, because σ′ is obtained by interchanging job i and job j only, the tardiness of σ′ is no greater than the tardiness of σ. However, the starting time of each job to be scheduled after job j in a complete schedule resulting from σ′ can be increased by at most Cjσ′-maxCiσ,Δσ′. Then, the increase of the total tardiness caused by this interchange is less than or equal to nuσ·Cjσ′-maxCiσ,Δσ′-∑q∈SjiσTq(σ)+∑q∈Sijσ′Tq(σ′), which is less than or equal to 0. Therefore, σ is dominated by σ′.
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 i is scheduled last and job j immediately precedes job i and another partial schedule (σ′) which is identical to σ except that jobs i and j are interchanged, if (a) Cj(σ′)≤Ci(σ) and Ci(σ′)≤Cj(σ) and (b) di≤dj, σ is dominated by σ′.
Proof.
Because Cj(σ′)≤Ci(σ), 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 i and job j in the partial schedule σ. Let ΔTi and ΔTj be the changes in the tardiness of job i and job j due to the interchange, respectively. Then,(15)ΔTi=maxCiσ′-di,0-maxCiσ-di,0=maxCiσ′,di-maxCiσ,di,ΔTj=maxCjσ′-dj,0-maxCjσ-dj,0=maxCjσ′,dj-maxCjσ,dj,because maxx1-x2,0-maxx3-x2,0=maxx1,x2-maxx3,x2 for any three real numbers x1, x2, and x3. The following cases are considered in order to determine the relationship between ΔTi+ΔTj and 0.
Case 1. If dj>Cj(σ′), then dj>Cj(σ′)>Cj(σ); hence, ΔTj=0. Then, ΔTi+ΔTj≤0.
Case 2. If Cj(σ′)>dj>Cj(σ), then Ci(σ)≥Cj(σ′)>dj>di and dj>Cj(σ)≥Ci(σ′). Then,(16)ΔTi+ΔTj=maxCiσ′,di-Ciσ+Cjσ′-dj=maxCiσ′,di-dj+Cjσ′-Ciσ≤0.
Case 3. If Cj(σ)>dj, then Ci(σ)≥Cj(σ′)>Cj(σ)>dj>di and Cj(σ)≥maxCiσ′,di. Then,(17)ΔTi+ΔTj=maxCiσ′,di-Ciσ+Cjσ′-Cjσ=maxCiσ′,di-Cjσ+Cjσ′-Ciσ≤0.
Therefore, the sum of tardiness is decreased or unchanged through the interchange of the two jobs. This completes the proof.
Proposition 4.
For any partial schedule (σ) in which job i is scheduled last and job j immediately precedes job i and another partial schedule (σ′) which is identical to σ except that jobs i and j are interchanged, if di≤dj, pil-di≤pjl-dj, maxpia,pib≤pil, and sil(σ′)≤sjl(σ), σ is dominated by σ′.
Proof.
First, it is shown that Cj(σ′)≤Ci(σ). Let sa and sb denote the start time of job j on machine a and machine b, respectively, in schedule σ. Then,(18)Ciσ=maxsa+pja+pia,sb+pjb+pib,sjlσ+pjl+pilCjσ′=maxsa+pia+pja,sb+pib+pjb,silσ′+pil+pjl.
Because maxsa+pja,sb+pjb≤sjl(σ) and maxpia,pib≤pil≤pjl, maxsa+pja+pia,sb+pjb+pib,sjlσ+pjl=sjl(σ)+pjl, and, hence, Ci(σ)=sjl(σ)+pjl+pil. The following are considered in order to determine the relationship between Cj(σ′)-Ci(σ) and 0.
Case 1. If maxsa+pia+pja,sb+pib+pjb,silσ′+pil=sa+pia+pja, then Cj(σ′)=sa+pia+pja+pjl. Then, because sa+pja≤sjl(σ) and pia≤pil, Cj(σ′)-Ci(σ)=sa+pja-sjlσ+(pia-pil)≤0.
Case 2. If maxsa+pia+pja,sb+pib+pjb,silσ′+pil=sb+pib+pjb, then Cj(σ′)=sb+pib+pjb+pjl. Then, because sb+pjb≤sjl(σ) and pib≤pil, Ci(σ)-Cj(σ′)=sb+pjb-sjlσ+(pib-pil)≤0.
Case 3. If maxsa+pia+pja,sb+pib+pjb,silσ′+pil=sil(σ′)+pil, then Cj(σ′)=sil(σ′)+pil+pjl. Then, because sil(σ′)≤sjl(σ), Cjσ′-Ciσ=silσ′-sjl(σ)≤0.
Because Cj(σ′)≤Ci(σ), 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 Ti(σ′)+Tj(σ′)≤Tj(σ)+Ti(σ). Then, (19)Tjσ=max0,sjlσ+pjl-djTiσ=max0,sjlσ+pjl+pil-diTiσ′=max0,silσ′+pil-diTjσ′=max0,maxsa+pia+pja,sb+pib+pjb,silσ′+pil+pjl-dj.
Because pil-di≤pjl-dj and sil(σ′)≤sjl(σ), Ti(σ′)≤Tj(σ). Also, because Cj(σ′)≤Ci(σ) and di≤dj, Tj(σ′)≤Ti(σ). Therefore, the sum of tardiness is decreased or unchanged by the interchange of the two jobs. This completes the proof.
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, S(σ)=S(σ′) and the sequences are different. If (a) Γl(σ′)≤Γl(σ) and (b) ∑i∈S(σ′)Ti(σ′)≤∑i∈S(σ)Ti(σ), σ is dominated by σ′.
Proof.
Because the two partial schedules (σ and σ′) consist of the same set of jobs and only the sequences are different, Γa(σ)=Γa(σ′) and Γb(σ)=Γb(σ′). 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 Γl(σ′)≤Γl(σ) and ∑i∈S(σ′)Ti(σ′)≤∑i∈S(σ)Ti(σ), σ is dominated by σ′.
4. 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.
4.1. 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 jth level in the tree corresponds to a partial schedule in which the first j 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 n jobs must be considered in this scheduling problem, a complete schedule is at the nth 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.
4.2. 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 r=1. Go to Step 1.
Step 1. Select the rth job in σ. Go to Step 2.
Step 2. For i=1 to σ∗+1, do the following: insert the selected job into the ith 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 (r+1)th position through the nth 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 4. Let r←r+1. If r≤n, go to Step 1; otherwise, go to Step 5. (σ∗ is the initial solution of the first phase.)
Step 5. Set i=1 and j=2. Go to Step 6.
Step 6. Generate a new sequence by interchanging two jobs in the ith and jth 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 j←j+1. If j≤n, go to Step 6; otherwise, let i←i+1 and j←i+1. If i<n, 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, d[j] denotes the due date of a job with the jth earliest due date among jobs in a partial schedule.
Theorem 6.
For nonnegative real numbers cj and dj corresponding to job j, if C1≤C2≤⋯≤Cn, then the following inequality holds:(20)∑j=1nmaxCj-dj,0≤∑j=1nmaxCj-dj,0.
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 jth 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 jth job in an arbitrary schedule is no less than maxmaxPja,Pjb+p1l,maxp1a,p1b+Pjl, where p[1]k=minipik for k=a,b,l and Pjk is the sum of j shortest processing times on machine k among all jobs; that is, p[1]k≤p2k≤⋯≤p[n]k and Pjk=∑i=1jp[i]k.
Proof.
Pja and Pjb are lower bounds on the time needed to process j jobs on machines a and b, respectively. Thus, maxPja,Pjb is a lower bound on the time required to process j jobs in the first stage. Thus, the completion time of the jth job is no less than the sum of maxPja,Pjb and the minimum processing time among all jobs in the second stage, p[1]l. Similarly, it is no less than max{p[1]a,p[1]b}+Pjl.
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 ∑j=1nu(σ)max0,maxmaxPja,Pjb+p1l,maxp1a,p1b+Pjl-dj.
The lower bound can be improved by considering the completion times of the last jobs on the machines in σ, that is, Γa(σ), Γb(σ), and Γl(σ). Meanwhile, if machine l 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 l becomes available. Then, Γl(σ)+Pjl 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:(21)LB1=∑j=1nuσmax0,maxmaxΓaσ+Pja,Γbσ+Pjb+p1l,maxmaxΓaσ+p1a,Γbσ+p1b,Γlσ+Pjl-dj.
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 G1 be the minimum value of the completion times of the two machines in the first stage and G2 the completion time of the machine in the second stage. The following procedure is used to obtain LB_{2}.
Procedure 2 (computation of LB<sub>2</sub>).
Step 0. Set j=1, G1 = minΓaσ,Γbσ, G2=Γl(σ), and LB2=0.
Step 1. Let LB2←LB2+max0,maxG1+maxpja,pjb,G2+pjl-dj, G2←maxG1+maxpja,pjb,G2+p[j]l, and G1←G1+minpja,pjb.
Step 2. Let j←j+1. If j>nu(σ), terminate; otherwise, go to Step 1.
The maximum value between the two lower bounds, maxLB1,LB2, 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.
5. 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 DU(1,100), where DU(a,b) denotes the discrete uniform distribution with a range [a,b]. Then, the due dates of the jobs were generated from DU(P∗(1-T-R/2),P∗(1-T+R/2)), where P∗ is the time at which all jobs are completed, and T and R are the tardiness factor and relative range of due dates parameters, respectively. Here, P∗ is estimated using the lower bound on the makespan; that is, P∗=maxmax∑i=1npia,∑i=1npib+mini∈Jpil,∑i=1npil, and three levels for each of T and R were used for generation; that is, T = (0.1, 0.3, and 0.5) and R = (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, T, and R. 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.
Results of the test on the B&B algorithm and CPLEX.
n
(T, R)
B&B
CPLEX
ACPUT^{†}
MCPUT^{‡}
NI^{#}
ACPUT
MCPUT
NI
8
(0.1, 0.8)
<0.01
<0.01
10
0.04
0.03
10
(0.1, 1.3)
<0.01
<0.01
10
0.05
0.05
10
(0.1, 1.8)
<0.01
<0.01
10
0.06
0.06
10
(0.3, 0.8)
<0.01
<0.01
10
0.05
0.03
10
(0.3, 1.3)
<0.01
<0.01
10
0.04
0.04
10
(0.3, 1.8)
<0.01
<0.01
10
0.07
0.06
10
(0.5, 0.8)
<0.01
<0.01
10
0.05
0.05
10
(0.5, 1.3)
<0.01
<0.01
10
0.05
0.05
10
(0.5, 1.8)
<0.01
<0.01
10
0.07
0.06
10
12
(0.1, 0.8)
0.04
0.00
10
0.13
0.06
10
(0.1, 1.3)
0.00
0.00
10
0.11
0.05
10
(0.1, 1.8)
0.02
0.00
10
0.55
0.42
10
(0.3, 0.8)
0.03
0.02
10
0.24
0.09
10
(0.3, 1.3)
0.03
0.02
10
0.71
0.40
10
(0.3, 1.8)
0.02
0.02
10
1.14
0.72
10
(0.5, 0.8)
0.05
0.04
10
0.26
0.17
10
(0.5, 1.3)
0.05
0.02
10
0.97
0.35
10
(0.5, 1.8)
0.06
0.02
10
0.66
0.65
10
16
(0.1, 0.8)
0.00
0.00
10
0.07
0.06
10
(0.1, 1.3)
0.06
0.00
10
0.25
0.08
10
(0.1, 1.8)
0.12
0.09
10
4.57
1.15
10
(0.3, 0.8)
1.21
0.91
10
0.62
0.65
10
(0.3, 1.3)
0.10
0.06
10
4.05
1.53
10
(0.3, 1.8)
0.85
0.17
10
77.79
10.82
10
(0.5, 0.8)
2.10
1.20
10
4.10
3.74
10
(0.5, 1.3)
1.26
1.07
10
8.80
4.79
10
(0.5, 1.8)
1.09
0.87
10
208.34
80.99
10
20
(0.1, 0.8)
0.00
0.00
10
0.12
0.11
10
(0.1, 1.3)
0.44
0.00
10
8.82
0.11
10
(0.1, 1.8)
0.85
0.13
10
32.97
2.66
10
(0.3, 0.8)
34.42
24.09
10
18.43
1.88
10
(0.3, 1.3)
7.68
0.66
10
758.16
10.90
8
(0.3, 1.8)
14.57
6.41
10
1804.62
1817.27
5
(0.5, 0.8)
151.51
71.92
10
239.56
40.82
10
(0.5, 1.3)
61.48
11.08
10
386.61
180.46
10
(0.5, 1.8)
32.53
7.96
10
1230.12
275.37
7
24
(0.1, 0.8)
0.00
0.00
10
0.20
0.19
10
(0.1, 1.3)
7.15
0.00
10
18.10
0.40
10
(0.1, 1.8)
5.71
1.02
10
514.38
96.66
9
(0.3, 0.8)
292.95
81.57
10
3.34
2.23
10
(0.3, 1.3)
692.23
9.70
9
1248.93
255.20
7
(0.3, 1.8)
304.40
34.13
10
2905.16
3600.00
2
(0.5, 0.8)
1210.80
431.44
8
1209.62
135.64
7
(0.5, 1.3)
946.30
166.13
8
2129.49
3055.50
5
(0.5, 1.8)
669.19
161.96
9
2634.28
3600.00
3
†Average CPU time (3600 seconds was used as the CPU time for the instances that were not solved to optimality in 3600 seconds).
^{‡}Median CPU time.
^{#}Number of instances (out of 10 instances) that were solved within 3600 seconds.
As seen from Table 1, the performance of the B&B algorithm was affected by the tightness of due dates or the tardiness factor (T) and relative range of due dates (R). 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 T and R, but not by their interaction (T×R). As seen in Table 1, the instances with a small T were solved within shorter computation times. Note that when T 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 R 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 T was large and R was small, the performance of the algorithm was not good.
ANOVA for the effect of due date tightness on CPU time of the B&B algorithm.
Sources
SS
DF
MS
F
p value
T
28237.9
2
14119.0
9.3
0.000
R
9393.6
2
4696.8
3.1
0.047
Interaction (T×R)
11227.5
4
2806.9
1.8
0.119
Error
533384.4
351
1519.6
Total
582243.4
359
Significance level = 0.05.
In order to verify the effectiveness of the lower bounds used in the B&B algorithm, two B&B algorithms were compared; the BBLB+ with the lower bounds and the BBLB- 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, BBLB+ outperformed BBLB-, and the outperformance became clearer as the number of jobs increased. In addition, BBLB+ solved all instances, whereas BBLB- 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.
Effectiveness of the lower bounds.
n
ACPUT^{†}
ANNG^{‡}
NI^{#}
BBLB+
BBLB-
BBLB+
BBLB-
BBLB+
BBLB-
8
<0.01
0.01
68
542
90
90
12
0.03
0.58
1008
26498
90
90
16
0.75
111.93
13855
3326995
90
90
20
33.72
1967.48
423917
39077867
90
54
†Average CPU time.
^{‡}Average number of nodes generated in the branch and bound procedure.
^{#}Number of instances (out of 90 instances) that were solved within 3600 seconds.
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; BBDx, where x=1,2,…,5, which denotes the B&B algorithm with all dominance properties except for that given in Proposition x; and BBD-, 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 n=20, BBD- 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, BBD5 required longer computation time than the other BBDx algorithms. This indicates that the dominance property given in Proposition 5 can be applied more often.
Effectiveness of the dominance properties.
n
n=8
n=12
n=16
n=20
ACPUT^{†}
ANNG^{‡}
ACPUT
ANNG
ACPUT
ANNG
ACPUT
ANNG
BB
<0.01
68
0.03
1008
0.75
13855
33.72
423917
BBD1
<0.01
91
0.07
2141
1.96
36077
95.20
1239968
BBD2
<0.01
78
0.05
1506
1.35
25266
69.23
852062
BBD3
<0.01
73
0.05
1561
1.65
31665
84.22
1085409
BBD4
<0.01
71
0.04
1309
1.13
21147
53.62
684952
BBD5
<0.01
75
0.10
3222
4.64
104141
252.84
3666210
BBD-
<0.01
192
0.51
34250
82.38
4176444
976.07
26509066
†,‡See footnotes in Table 3.
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, BBH+ and BBH- denote the B&B algorithms with and without mNEH-PI, respectively. As shown in Table 5, the performance of BBH+ was better than that of BBH-. 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.
Effectiveness and performance of the heuristic algorithm.
n
BBH+
BBH-
mNEH-PI
ACPUT^{†}
ANNG^{‡}
ACPUT
ANNG
APG¶
8
<0.01
68
<0.01
106
1.44
12
0.03
1008
0.05
1565
2.67
16
0.75
13855
1.71
35412
1.98
20
33.72
423917
64.04
879744
2.25
†,‡See footnotes in Table 3.
¶Average percentage gap between heuristic solutions and optimal solutions.
6. 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.
NotationThe Notation Used in the FormulationJ:
Set of jobs, J=1,…,n
i,j:
Job indices
a,b,l:
Machine indices
Oia(Oib):
Operation of job i to be processed on machine a (b) in the first stage
Oil:
Operation of job i to be processed on machine l in the second stage
pik:
Processing time of operation Oik, k=a,b,l
di:
Due date of job i
[r]:
Index for the rth job in a sequence
xir:
A binary variable that is equal to 1 if job i is scheduled in the rth position in a sequence, and 0 otherwise
s[r]k:
Starting time of the rth job on machine k, k=a,b,l
C[r]:
Completion time of the rth job in a sequence
T[r]:
Tardiness of the rth job in a sequence, T[r]=maxC[r]-∑i=1ndi·xir.
The Notation Used in the Statements and Proofs of the Properties and for the Description of the Algorithmsσ:
A (partial) schedule
sik(σ):
Start time of operation Oik in σ, k=a,b,l
cik(σ):
Completion time of operation Oik in σ, k=a,b,l
Ci(σ):
Completion time of job i in σ; that is, Ci(σ)=cil(σ)
Ti(σ):
Tardiness of job i in σ; that is, Ti(σ)=maxCiσ-di,0
Γk(σ):
Completion time of the last job on machine k in σ, k=a,b,l
S(σ):
Set of jobs scheduled (or included) in σ
ns(σ):
Number of jobs scheduled in σ, that is, Sσ
nu(σ):
Number of jobs that are not included in σ, that is, n-Sσ
Sij(σ):
Set of jobs scheduled from job i to j in σ.
Competing Interests
The authors declare that there is no conflict of interests regarding the publication of this paper.
GrahamR. L.LawlerE. L.LenstraJ. K.Rinnooy KanA. H.Optimization and approximation in deterministic sequencing and scheduling: a surveyKoulamasC.The total tardiness problem: review and extensionsLeeC.-Y.ChengT. C. E.LinB. M. T.Minimizing the makespan in the 3-machine assembly-type flowshop scheduling problemSungC. S.KimH. A.A two-stage multiple-machine assembly scheduling problem for minimizing sum of completion timesPottsC. N.Sevast’janovS. V.StrusevichV. A.Van WassenhoveL. N.ZwaneveldC. M.The two-stage assembly scheduling problem: complexity and approximationHaririA. M. A.PottsC. N.A branch and bound algorithm for the two-stage assembly scheduling problemHaouariM.DaouasT.Optimal scheduling of the 3-machine assembly-type flow shopSunX.MorizawaK.NagasawaH.Powerful heuristics to minimize makespan in fixed, 3-machine, assembly-type flowshop schedulingKoulamasC.KyparisisG. J.The three-stage assembly flowshop scheduling problemSungC.-S.JuhnJ.-H.Makespan minimization for a 2-stage assembly scheduling problem subject to component available time constraintTozkapanA.KircaO.ChungC.-S.A branch and bound algorithm to minimize the total weighted flowtime for the two-stage assembly scheduling problemAl-AnziF. S.AllahverdiA.A hybrid tabu search heuristic for the two-stage assembly scheduling problemAllahverdiA.Al-AnziF. S.The two-stage assembly scheduling problem to minimize total completion time with setup timesAllahverdiA.Al-AnziF. S.A PSO and a Tabu search heuristics for the assembly scheduling problem of the two-stage distributed database applicationAl-AnziF. S.AllahverdiA.A self-adaptive differential evolution heuristic for two-stage assembly scheduling problem to minimize maximum lateness with setup timesAllahverdiA.AydilekH.The two stage assembly flowshop scheduling problem to minimize total tardinessSchallerJ.Note on minimizing total tardiness in a two-machine flowshopPottsC. N.Van-WassenhoveL. N.Branch and bound algorithm for the total weighted tardiness problemNawazM.EnscoreE. E.Jr.HamI.A heuristic algorithm for the m-machine, n-job flow-shop sequencing problemChuC.A branch-and-bound algorithm to minimize total tardiness with different release datesKondakciS.KircaÖ.AzizoğluM.An efficient algorithm for the single machine tardiness problemKimY.-D.A new branch and bound algorithm for minimizing mean tardiness in two-machine flowshopsKimY.-D.Minimizing total tardiness in permutation flowshops