Mathematical Problems in Engineering

Volume 2016 (2016), Article ID 6591632, 11 pages

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

## Heuristic and Exact Algorithms for the Two-Machine Just in Time Job Shop Scheduling Problem

^{1}Qatar University, Doha, Qatar^{2}Colorado State University-Pueblo, Pueblo, CO, USA^{3}Old Dominion University, Norfolk, VA, USA

Received 23 April 2016; Revised 26 September 2016; Accepted 18 October 2016

Academic Editor: Thomas Hanne

Copyright © 2016 Mohammed Al-Salem et al. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

#### Abstract

The problem addressed in this paper is the two-machine job shop scheduling problem when the objective is to minimize the total earliness and tardiness from a common due date (CDD) for a set of jobs when their weights equal 1 (unweighted problem). This objective became very significant after the introduction of the Just in Time manufacturing approach. A procedure to determine whether the CDD is restricted or unrestricted is developed and a semirestricted CDD is defined. Algorithms are introduced to find the optimal solution when the CDD is unrestricted and semirestricted. When the CDD is restricted, which is a much harder problem, a heuristic algorithm is proposed to find approximate solutions. Through computational experiments, the heuristic algorithms’ performance is evaluated with problems up to 500 jobs.

#### 1. Introduction and Literature Review

Many objectives in scheduling are linked to due dates, which focus on meeting costumers’ delivery dates. When a CDD is considered, a set of components must be assembled into a finished product, for example, or several jobs must be shipped together to a certain customer. In Just in Time (JIT) manufacturing and production systems, it is intended to reduce both earliness and tardiness by constructing a job schedule in which the jobs are finished as close as possible to their due date. Minimizing tardiness reduces the cost of missing due dates and increases customers’ satisfaction, while minimizing earliness reduces the holding and inventory cost.

Most of the published literature on minimizing earliness/tardiness () addressed the single machine problem (e.g., Kanet [1], Sundararaghavan and Ahmed [2], Szwarc [3], Bagchi et al. [4], Hall and Posner [5], Hall et al. [6], Hariri and Potts [7], Rabadi et al. [8], Mason et al. [9], Rabadi et al. [10], Atan and Selim Akturk [11], Hepdogan et al. [12], Baptiste et al. [13], and Cheng et al. [14]). Baker and Scudder [15] published a comprehensive state-of-the-art review for different variants of the problem including the problem with a CDD. Also, many papers addressed the same objective in multimachine scheduling environment such as parallel machines (e.g., Emmons [16], Cheng and Chen [17], Alvarez-Valdes et al. [18], Kayvanfar et al. [19], Li et al. [20], Kubiak et al. [21]) and flow shops (e.g., Sarper [22], Sung and Min [23], Mosheiov [24], Gupta et al. [25], Lauff and Werner [26], Chandra et al. [27], Behnamian et al. [28], and M’Hallah [29]). Much less has been published on scheduling problems for job shops (e.g., Lauff and Werner [30], Baptiste et al. [31], Yang et al. [32], and Wang and Li [33]). Gordon et al. [34] have reviewed more recent literature of the problem with CDD. Lauff and Werner [30, 35] reviewed multistage systems involving earliness and tardiness problems with CDD as well.

Kanet [1] developed an algorithm to find an optimal solution for the single machine problem with an unrestricted CDD. In his work, some properties of optimal solutions were proved and used to construct a polynomial algorithm. Sundararaghavan and Ahmed [2] developed a heuristic algorithm for the same problem but with a restricted CDD (i.e., when the CDD is small enough to constrain the schedule) where they used some of the properties defined for the unrestricted case by Kanet. Bagchi et al. [4] extended Kanet’s work and developed an exact algorithm to generate alternate optimal solutions. They also developed an implicit enumeration procedure for the restricted case in a single machine environment. Raghavachari [36] extended the V-shape property of optimal schedules established by Kanet [1] to any CDD.

Hoogeveen and van de Velde [37] developed a dynamic programming (DP) algorithm to solve the single machine scheduling problem with a small CDD and a positive weight for each job. They found out that the problem with equal processing times for all jobs and the problem with equal weight to processing time rates are polynomially solvable. Also, Hall and Posner [5] developed a DP algorithm for the single machine problem considering an unrestricted CDD and different weights for the jobs. Hall et al. [6] constructed an exact algorithm based on DP to find optimal solutions for the unweighted version of the single machine problem with restricted CDD. Rabadi et al. [8] developed a branch-and-bound procedure to find optimal solutions for single machine problems with an unrestricted CDD and considering sequence-dependent setup times.

In multimachine environments, Emmons [16] developed an algorithm that is able to solve the identical parallel machine scheduling problem when all jobs have a CDD and earliness and tardiness have different cost rates. Cheng and Chen [17] studied the problem of assigning a common due date and sequencing a set of simultaneously available jobs on several identical parallel machines.

Sarper [22] developed a mixed integer linear programming formulation for the two-machine Flow Shop Scheduling Problems (FSSP) with unweighted earliness and tardiness cost over a CDD. Sung and Min [23] studied the two-machine FSSP with batch processing machines and a CDD. Mosheiov [24] studied the unit processing time on an* m*-machine flow shop problem over nonrestricted and restricted CDD. Gupta et al. [25] defined some properties of optimal schedules for the two-machine FSSP, developed lower and upper bounds, derived dominance criteria, and proposed an enumerative algorithm for finding an optimal schedule. Finally, based on some structural properties of the problem, Lauff and Werner [26] developed heuristic algorithms, both constructive and enumerative, to solve the two-machine FSSP with a given CDD considering asymmetric linear and quadratic penalty functions. Wang and Li [33] presented hybrid heuristic that combines variable neighborhood search with mathematical programming to minimize the sum of earliness and tardiness for the job shop scheduling problem with multiple due dates. Baptiste et al. [31] defined an integer programming model for the JITJSSP problem and proposed methods based on two Lagrangian relaxations of the model to derive lower and upper bounds. Yang et al. [32] introduced an enhanced genetic algorithm to solve the job shop scheduling problem of minimizing the weighted tardiness and earliness of jobs in the presence of due dates and deadlines. So far, there is no reported research on the job shop scheduling problem (JSSP) considering over a CDD, and therefore, the two-machine JSSP is addressed in this paper.

In the next section, a formulation of the problem with its three different cases is given. In section three, optimality conditions are introduced for two out of the three cases. Section 4 presents a dynamic programming algorithm to optimally solve the semirestricted case and a heuristic algorithm to solve the restricted case. Then, in Section 5, computational experiments for the three cases are analyzed. Finally, Section 6 discusses the results and Section 7 presents the conclusions and further research.

#### 2. Formulation of the Two-Machine Job Shop Scheduling Problem with a Common Due Date

This article addresses a nonpreemptive, no recirculation (jobs do not revisit the same machine) JSSP with two machines,* n* jobs, and an integer CDD when all jobs are available at time . Although JIT entails more detail and concepts, the problem seems to mathematically capture the scheduling essence of it.

Let , , and represent the completion time, earliness, and tardiness of job* j*, respectively; and can be defined asAssociated with each job there is an earliness penalty and a tardiness penalty per time unit, which in this research are all equal to 1 (unweighted problem). The basic earliness and tardiness () objective function for a schedule* S* can be written as as follows:The CDD is restricted when it is small enough to restrict the scheduling decision and hence impacts the optimal sequence. The restricted version of the problem is much harder than the unrestricted version [30]. For the single machine problem over a CDD, it would be desirable to construct a schedule in which half of the jobs are before the CDD [37]. If the CDD were too tight, then not enough jobs would be scheduled before the CDD, because they cannot start before time zero. For the single machine problem, the unrestricted case can be solved by using a polynomial algorithm [1]. In the JSSP, if the CDD is large enough, the problem can be solved in polynomial time by solving* m* (*m* = 2 in this paper) single machine problems [30].

Formally, there is a quantitative procedure to decide if a CDD is restricted or unrestricted for the single machine problem. In this paper, such procedure will be extended to the JSSP over a CDD with two machines.

Initially, for the single machine problem, Kanet [1] assumed that , where is the processing time for job* j* so that the problem can be solved optimally by using his algorithm SCHED. Later, Bagchi et al. [4] showed that Kanet’s algorithm is able to reach optimal solutions under the weaker assumption that the CDD ≥ , whereFor a CDD in a two-machine JSSP to be unrestricted, two conditions must hold. First, the remaining time to process the last operations on each machine must be enough to apply the SCHED algorithm [1] as if each machine is an unrestricted single machine problem. Second, the completion time of each job’s first operation on its corresponding machine has to be less than or equal to the starting time of its subsequent last operation. This starting time is given by the SCHED algorithm. The second condition is equivalent to finding a schedule for each single machine problem where no jobs are tardy.

In order to minimize the deviation over the CDD for all the jobs, the first operations of each job should have priority on each machine in order to allow the subsequent operations to be processed. The set of first operations and the set containing the last operations to be scheduled on each machine before the CDD compete for the time available within the interval from* t =* 0 to* t =* CDD. If the CDD is loose enough, say if CDD ≥ PT, wherewhere is the processing time for the operation of job* j* to be performed on machine* i* with* i* = 1, 2, then, the SCHED algorithm can be applied to the two machines and an optimal solution will be obtained. The closer the CDD to the tighter (i.e., more restricted) the schedule. This fact can be used to define whether the CDD is restricted or not. Let

= set with jobs to be finished on machine 1,

= set with jobs to be finished on machine 2,

= = number of jobs to be finished on machine 1,

= = number of jobs to be finished on machine 2.

Also, letwhereFinally, letwhere is the complement of and is the complement of .

*Definition 1. *A CDD is unrestricted if CDD ≥ and the number of tardy jobs in sets and are equal to zero.

*Discussion*. If = + , let , where is the completion time of the jobs with their last operation on machine 1 and to be completed before or on CDD. Similarly, let , where is the completion time of the jobs with their last operation on machine 1 and to be completed after CDD and is the summation of processing times of the jobs in . The optimal schedule for the machine 1 can be obtained by applying Kanet’s SCHED algorithm to the jobs in sets and . The starting times of the jobs in sets and provide the due dates for their first operations to be processed on machine 2 (i.e., jobs in set ). The jobs whose first operation must be performed on machine 1, jobs in , are processed before the jobs in without interfering with the optimal schedule since .

In order to find out if the number of tardy jobs in is equal to zero, the earliest due date (EDD) rule needs to be applied to jobs in . If an EDD sequence yields either zero or one tardy job, then it minimizes the number of tardy jobs [38].

Let , where is the completion time of the jobs with their last operation on machine 2 to be completed before or on the CDD and is the summation of processing times of the jobs in . Since , jobs to be finished on machine 2 can be optimally scheduled by applying Kanet’s SCHED algorithm to the jobs in sets and , where is defined similarly to . In the same way, the starting times of the jobs in sets and provide the due dates for their first operations to be processed on machine 1 (i.e., jobs in set ). The jobs whose first operation must be performed on machine 2, jobs in , are performed before the jobs in without interfering with the optimal schedule. Also, it is possible to find whether the number of tardy jobs in is equal to zero by applying the EDD rule to jobs in .

The same reasoning can be applied if , = . Tables 1 and 2 show the processing times and the operation-machine assignment for a seven-job example. Figure 1 illustrates the optimal solution for this example when the CDD is unrestricted and equal to 30. In this case , = = 30. Note that if the CDD > 30, the problem is still unrestricted.