Mathematical Problems in Engineering

Volume 2016 (2016), Article ID 6409321, 10 pages

http://dx.doi.org/10.1155/2016/6409321

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

^{1}System Engineering Team, Device Solution Business, Samsung Electronics Co., Ltd., Yongin-si, Gyeonggi-do 17113, Republic of Korea^{2}Department of Industrial Management Engineering, Sungkyul University, Anyang-si, Gyeonggi-do 14097, Republic of Korea

Received 11 March 2016; Accepted 20 June 2016

Academic Editor: Fons J. Verbeek

Copyright © 2016 Ju-Yong Lee and June-Young Bang. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

#### Abstract

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 in the three-field notation of Graham et al. [1], where refers to a two-stage assembly-type flowshop with two machines in the first stage and is the tardiness of job defined as = , 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 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, .

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 jobs () 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 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:

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 is scheduled last and job immediately precedes job and another partial schedule () which is identical to except that jobs and are interchanged, if () and () or () , is dominated by , where .*

*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, . 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 () is satisfied, the interchange does not delay the starting time of the next job to be scheduled after . If () is satisfied, the starting time of the next job to be scheduled after does not depend on the completion time of job in because 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 () which is identical to except that jobs and are interchanged, if () and () , is dominated by , where .*

*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 . Then, the increase of the total tardiness caused by this interchange is less than or equal to , 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 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,because for any three real numbers , , and . The following cases are considered in order to determine the relationship between and 0.*Case 1*. If , then ; hence, . Then, .*Case 2*. If , then and . Then,*Case 3*. If , then and . Then,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 is scheduled last and job immediately precedes job and another partial schedule () which is identical to except that jobs and are interchanged, if , , , and , is dominated by .*

*Proof. *First, it is shown that . Let and denote the start time of job on machine and machine , respectively, in schedule . Then,Because and , , and, hence, . The following are considered in order to determine the relationship between and 0.*Case 1*. If , then . Then, because and , .*Case 2*. If , then . Then, because and , .*Case 3*. If , then . Then, because , .

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, Because and , . Also, because and , . 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, 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 .

#### 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 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.

##### 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 . Go to Step 1.*Step 1*. Select the th job in . Go to Step 2.*Step 2*. For to , 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 jobs followed by the sequence of jobs that are placed at the 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 4*. Let . If , go to Step 1; otherwise, go to Step 5. ( is the initial solution of the first phase.)*Step 5*. Set and . Go to Step 6.*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 . If , go to Step 6; otherwise, let and . 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 , 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 , where for and is the sum of shortest processing times on machine among all jobs; that is, and .*

*Proof. * and are lower bounds on the time needed to process jobs on machines and , respectively. Thus, 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 and the minimum processing time among all jobs in the second stage, . Similarly, it is no less than .

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 be the minimum value of the completion times of the two machines in the first stage and the completion time of the machine in the second stage. The following procedure is used to obtain LB_{2}.

*Procedure 2 (computation of LB _{2}). *

*Step 0*. Set , = , , and .

*Step 1*. Let , , and .

*Step 2*. Let . If , terminate; otherwise, go to Step 1.

The maximum value between the two lower bounds, , 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 , where denotes the discrete uniform distribution with a range . Then, the due dates of the jobs were generated from , 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, , 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.