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

*Definition 2. *A CDD is semirestricted if CDD ≥ , and CDD < , and the number of tardy jobs in the sets and are equal to zero.

*Discussion*. If , = , then , = . and are as in Definition 1. Hence, and are the summation of processing times of the jobs in and , respectively. Given , in an optimal schedule jobs in are performed before the jobs in without interference with the jobs in . The optimal schedule for machine 1 can be obtained by applying Kanet’s SCHED algorithm to the jobs in 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 the set ), which are processed before the jobs in . But given that , jobs in cannot be optimally scheduled by using the SCHED algorithm; instead this problem needs to be treated as a single machine problem with a restricted CDD, which can be optimally solved by using the dynamic programming (DP) procedures proposed by Hall et al. [6]. The starting times of the jobs in given by the optimal solution provide the due dates for their first operations to be processed on machine 1 (i.e., jobs in the 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 . Similar to the unrestricted case, jobs in and need to be sequenced by using the EDD rule to check if the number of tardy jobs is equal to zero. If both sequences yield zero tardy jobs then the problem is semirestricted. Following the same numeric example, Figure 2 describes the case when the CDD is equal to 23 which is greater than and is less than , = = 30.

In this sense, a CDD is semirestricted when the optimal schedule of either one of the machines can be obtained by using Kanet’s SCHED algorithm. The optimal schedule for the other machine has different features, and so the SCHED algorithm will not be able to find it. Instead, the DP procedures developed by Hall et al. [6] need to be used to find the optimal schedule. This procedure is extended to the problem studied here in the next section.

*Definition 3. *A CDD is restricted if neither Definition 1’s conditions nor Definition 2’s conditions hold.

*Discussion*. If , let , , and , where is the completion time of the jobs with their last operation on machine 1. Hence, is the summation of processing times of the jobs in . Since , there is no way to optimally schedule jobs in without modifying the starting times of the jobs in (the first operations of jobs in ). Hence, a tradeoff between jobs in and jobs in must be made. The jobs in (those with their first operation to be performed on machine 1) interfere with the optimal schedule on this machine. On the other hand, if at least one of the jobs in is delayed, this delay interferes with the optimal schedule on machine 2. The same reasoning can be applied if , = . Following the same numeric example, Figure 3 illustrates the case when the CDD = 15 which is less than , .

Additionally, if there is at least one tardy job in the cases given in Definitions 1 or 2, then the CDD is also considered restricted since precedence constraints for at least one job (i.e., the tardy job) do not hold.

Next, optimality conditions for the unrestricted and semirestricted case are presented. Also, two properties of the optimal solution for the restricted case are proved and used to construct approximate solutions.

#### 3. Optimality Conditions

Optimal solutions for the two-machine JSSP with restricted CDD are difficult to characterize. In this paper, optimal solutions will be defined when the CDD is unrestricted and semirestricted. Approximate solutions, obtained by a heuristic procedure, will be defined when the CDD is restricted.

##### 3.1. Unrestricted CDD

If the CDD is unrestricted as described in Definition 1, the optimal solution can be found by using Kanet’s SCHED procedure on each machine. The properties of the optimal schedule as defined in Kanet [1] will be extended for our use.

*Property 1. *There is no idle time between jobs in sets and .

*Property 2. *The jobs in both and are sequenced by longest processing time first (LPT).

*Property 3. *The last jobs in and are completed at time .

*Property 4. *Let and represent an ordered set of jobs pertaining, respectively, to and to be scheduled without inserted idle time such that the first job in both and starts at time . In an optimal schedule, jobs in both and are sequenced by shortest processing time (SPT) first.

*Property 5. *If is even then . If is odd then . If is even then . If is odd then .

*Property 6. *There is a one-to-one mapping of the jobs in both and onto the jobs in and such that and and and and .

The proofs of these properties and the proof that SCHED yields optimal solutions can be easily extended from Kanet [1] and Definition 1. It is important to note that SCHED runs in polynomial time as discussed by Kanet [1]. Figure 1 shows the optimal schedule of the same numerical example when the CDD is unrestricted.

##### 3.2. Semirestricted CDD

If the CDD is semirestricted as described in Definition 2, the optimal solution can be found by using Kanet’s SCHED procedure on the machine with . The optimal solution in this machine preserves the properties given for the unrestricted case. For the other machine, some properties must be defined in order to characterize the optimal solution. The properties of the optimal schedule as defined by Hall et al. [6] will be extended for our use.

Let or denote the starting times in an optimal schedule of the first job processed on either or , respectively, corresponding to the machine where holds.

Also, define , , , and .

*Property 1. *There exists at least one of the following: An optimal schedule with either or . An optimal schedule with , where is a job with its last operation on machine starting before CDD and completing at CDD or later.

*Property 2. *In an optimal schedule, the jobs in are in LPT order, and the jobs in are in SPT order.

*Property 3. *Each optimal schedule is weakly V-shaped. A weakly V-shaped schedule means a job does not necessarily end at the CDD.

*Definition 4. *On machine a schedule is early V-Shaped (EVS) if .

*Definition 5. *On machine a schedule is tardy V-Shaped (TVS) if , where , and .

*Property 4. *If , then or if , then .

*Property 5. *Consider .

*Property 6. *If , then , where job is the first job scheduled on machine .

The proofs of these properties can be extended from Hall et al. [6] and Definition 2.

Based on these properties, the DP procedure can be introduced to find the optimal solution examining all EVS and TVS schedules if by using and procedures described by Hall et al. [6]. If , then it is possible to assume that and the procedure described by Hall and Posner [5] can be extended to find an optimal schedule in which a job is completed at CDD. By jointly using these procedures, an optimal solution can be found for the two-machine JSSP with a semirestricted CDD. More detail on these procedures will be presented in the next section. It is important to note that, in the general case, the dynamic programming approach proposed by Hall et al. [6] for the single machine restricted case runs in pseudopolynomial time. Figure 2 shows the optimal schedule of the same previous numerical example when the CDD is semirestricted.

##### 3.3. Restricted CDD

To characterize the optimal solution when the CDD is restricted is difficult. Hence, two properties are defined in order to develop a heuristic algorithm to obtain approximate solutions for the two-machine JSSP.

Define = the set of jobs to be finished on machine 1 and to be scheduled around the restricted CDD. = the set of jobs to be finished on machine 2 and to be scheduled around the restricted CDD.

Clearly, and .

*Property 1. *Jobs in and are scheduled without idle time.

*Proof. *By contradiction and similar to the approach by Baker [38], assume that there exists an optimal schedule* S* with an idle interval of length* t* between consecutive jobs* a* and* b*, with* b* following* a*;* a*, (), and the predecessors of* a* and* b* are already scheduled at machine . If job* a* is early (), then the total penalty cost can be reduced by shifting job* a* (and any jobs that precedes it) later by an amount , where ) without affecting the feasibility of . Denoting the values after the shift with primes, it follows that and strictly for at least one job. Similarly, if job* b* is tardy (), then the total penalty cost can be reduced by shifting job* b* (and any jobs that follows it) earlier by an amount* Δt*, where without affecting the feasibility of* S*. Hence, it follows that and strictly for at least one job. Since any schedule must have either job* a* early or job* b* tardy, then schedule* S* can be improved, and therefore, it cannot be optimal.

*Property 2. *The optimal schedule for the jobs in and is weakly V-shaped, where a schedule* S* is weakly V-shaped if all jobs completed before the CDD are ordered according to LPT and all jobs that begin their processing after the CDD ordered according to SPT.

*Proof. *By contradiction and similar to the approach in Baker [38], assume* S* denotes an optimal schedule in which some adjacent pair of early jobs in is not in LPT order. Then a pairwise interchange of these two jobs will reduce the total earliness penalty and leave the tardiness penalty unchanged on machine without affecting the feasibility of* S*. Similarly, if* S* is an optimal schedule containing an adjacent pair of jobs that starts late in and that violates the SPT order, then an adjacent pairwise interchange will reduce the total tardiness penalty and leave the total earliness penalty unchanged on machine . In either case,* S* cannot be an optimal schedule.

Once the jobs to be included in and have been defined, there are still two questions to be answered. First, in an optimal schedule, is there some job that must be completed exactly at ? It was shown by Hall et al. [6] for the single machine case with a restricted CDD that this is not necessarily true. Second, in an optimal schedule, which jobs are early and which ones are tardy? Figure 3 shows an approximate schedule of the numerical example when the CDD is restricted.

In order to find an approximate solution for the restricted version of the problem addressed in this paper,* Restricted Heuristic*, a heuristic procedure based on Properties and is proposed. By iteratively eliminating the job with the longest processing time in either machine 1 or machine 2, sets and are defined. This procedure tries to reduce a restricted problem to the semirestricted version in order to apply the SCHED, EVS, TVS, and Nosplit procedures. Given the jobs removed are going to be tardy anyway, the SPT rule is applied in order to minimize their tardiness. Each time a remaining tardy job is scheduled, an improvement procedure tries to look for early slots of time in the current schedule in order to decrease the tardiness cost.* Restricted Heuristic* reduces the problem to a semirestricted one in order to apply the dynamic programming approach proposed by Hall et al. [6] for the single machine restricted case; hence, it runs in pseudopolynomial time. It is important to note that* Restricted Heuristic* does not guarantee an optimal solution.

#### 4. Dynamic Programming Algorithm for the Two-Machine JSSP

The algorithm JSSPET presented here uses a DP algorithm to find optimal solutions for the two-machine JSSP when the CDD is semirestricted. This algorithm partitions the solution space into schedules with either or and those with either or . In the first case, jobs either in or are scheduled in the interval [] or [], where and . Based on Property , any optimal schedule is either EVS or TVS, and so* EVS* (*TVS*) procedure discussed next will find optimal EVS (TVS) schedules which is completed at either or . In the second case, suppose that either or and based on Property , it is possible to assume that either or so that* Nosplit* procedure discussed later will find an optimal schedule in which a job is completed at CDD. Finally, the lower cost offered by the three procedures is an optimal schedule. All three procedures make use of Properties and (V-shaped structure).

Procedures EVS and TVS consider jobs in nonincreasing order. From Property , job (to be finished on machine 1) either starts at or ends at , and job (to be finished on machine 2) either starts at or ends . The total processing time of previously scheduled jobs which finish before CDD in* EVS* and after CDD in* TVS* procedures is stored.* Nosplit* procedure considers jobs in nondecreasing order.

##### 4.1. Procedure EVS

Let = the minimum cost to schedule jobs (similarly , ) provided that the latest job scheduled which finished at or before CDD finishes at time , (similarly , ), and the earliest job scheduled which finishes after CDD starts at time (similarly ). That is, the latest job finishes at (similarly ).

Recurrence relation is as follows:

Boundary condition is as follows:

Minimum cost schedule is defined by

##### 4.2. Procedure TVS

Let = the minimum cost to schedule jobs (similarly ) provided that the earliest job scheduled which starts at or after CDD starts at time , (similarly , ), and the latest job scheduled which starts before CDD finishes at time (similarly ). That is, the earliest such a job starts is at (similarly ).

Recurrence relation is as follows:

Boundary condition is as follows:

Minimum cost schedule is defined by

##### 4.3. Procedure Nosplit

Let = the minimum cost to schedule jobs for either or without the CDD splitting any job, given that the total processing time of jobs scheduled early (or on time) is either or .

Recurrence relation is as follows:

Boundary condition is as follows:

Minimum cost schedule is defined by

In all of the three procedures, the first alternative in the recurrence relation represents the cost of scheduling the next job as early as possible and the second one, similarly, as late as possible. Since in the procedure an early job may finish after the CDD, there is a need for the absolute value in the first equation on its recurrence relation.

##### 4.4. JSSPET Algorithm

In order to solve the two-machine JSSP over a CDD, the three cases of the due date must be considered. The JSSPET algorithm decides the type of CDD (restricted, semirestricted, or restricted) and then applies the appropriate procedure. When the CDD is unrestricted, the JSSPET uses the SCHED procedure [1] to find the optimal solution for both machines. When the CDD is semirestricted, JSSPET jointly uses the SCHED procedure to find the optimal solution for one of the machines (the one with ), and the , , and procedures to find the optimal for the other machine. Finally, when the CDD is restricted, JSSPET uses* Restricted Heuristic* (explained earlier) to find approximate solutions. This heuristic procedure reduces a restricted problem to the semirestricted version by iteratively removing one job at the time. Once the problem is reduced to its semirestricted version, the SCHED, , , and procedures are applied. Since the jobs removed are going to be tardy anyway, the SPT rule is applied in order to minimize their tardiness. Each time a removed job is scheduled, an improvement procedure runs in search for early time slots in the current schedule to decrease the tardiness cost. The pseudocode for JSSPET is given next.

*Algorithm JSSPET* Calculate , , , Apply SCHED procedure to Apply SCHED procedure to Calculate = Number of tardy jobs in Calculate = Number of tardy jobs in If and and then Optimal schedule is given by SCHED procedure on both machines Schedule first operations on machine 1 and machine 2 by using EDD rule. Stop. Else Apply SCHED to machine where holds Apply EVS to the other machine Apply TVS to the other machine Apply Nosplit to the other machine Solution for the other machine is Calculate = Number of tardy jobs on Calculate = Number of tardy jobs on If and and and then Optimal schedule is given by SCHED and Schedule first operations on machine 1 and machine 2 by using EDD rule. Stop. Else Apply Restricted Heuristic End If End If End Algorithm

#### 5. Computational Experiments

Sets of problems with 2 machines, 5, 6, 7, 8, 10, 20, 50, 100, and 500 jobs, with 30 problem instances per problem size, were generated. The processing times were generated from a discrete uniform distribution (1, 100) and the jobs routes were obtained from another discrete uniform distribution (1,* m*) where* m* is the number of machines (two in our case). Similar to most random numbers generators in use today, the processing times and jobs routes were generated by using random numbers coming from a linear congruential generator [39].

The CDD for the unrestricted case is given by For the semirestricted case, the CDD is chosen to be in the middle of the interval between and as given by Finally, for the restricted case, the CDD is given by where is the tightness factor, , and it takes four possible values, . is the largest integer less than or equal to .

Considering the four cases of the restricted version, the single case of both the unrestricted and the semirestricted version, a total of problem instances were solved.

#### 6. Results

The results in Table 3 show the average, standard deviation, and maximum computational solution times for each set of instances. The times are in seconds and exclude input and output time. Computational solution times increase approximately linearly with for the unrestricted case and in proportion to for the semirestricted case. These results confirm that* JSSPET* algorithm finds optimal solutions for both the unrestricted and the semirestricted cases for large random instances of the problem within no more than 20 minutes. Such result is made possible by the new optimality conditions extended from the single machine problem provided in this paper and which enable us to prove the optimality of the dynamic programming procedure.

For restricted problems with 5, 6, 7, and 8 jobs, finding an optimal solution is not guaranteed, but when compared with optimal solutions obtained through a MILP formulation, it turned out the JSSPET algorithm found optimal solutions for about 30% to 40% of all the instances by applying the* Restricted Heuristic*.

For restricted problems with 10 or more jobs, the* JSSPET* algorithm is evaluated based on how far its solutions are from a lower bound (LB). The LB used in this case is the optimal solution for the same instances but with a semirestricted CDD. Recall that a problem instance’s solution with a restricted CDD will always be larger than the same instance with unrestricted or semirestricted CDD. The closer the tightness factor* h* to one, the smaller the deviation from the LB (the semirestricted version). Also, as the number of jobs increases, the deviation from the LB decreases. Since the behavior of the optimal objective function value for the restricted version of the problem is unknown, using the solution of the semirestricted version as a LB for the restricted case tends to underestimate the performance of the* JSSPET* algorithm. Therefore, this LB needs to be used carefully and a better one needs to be found.

#### 7. Conclusions

The earliness and tardiness problem is an important problem in machine scheduling involving nonregular measures of performance. In this work, a dynamic programming (DP) algorithm to deal with the two-machine job shop scheduling problem (JSSP) and a common due date (CDD) were presented. The CDD can be classified as unrestricted, restricted, or semirestricted depending on how large it is. Lauff and Werner [30] conjectured that the definition of the restrictedness of the CDD for a multimachine early/tardy job shop scheduling problem is a NP-hard problem. In this research, a pseudopolynomial procedure to define the class of restrictedness was presented for the two-machine JSSP.

Additionally, some properties for this problem as well as optimality conditions for the unrestricted and semirestricted case were extended from the single machine problem. Optimal solutions for the unrestricted and semirestricted case were obtained for problems with up to 500 jobs by using the SCHED algorithm and a dynamic programming algorithm, respectively. Two properties for the restricted case were proved and used to come up with a heuristic algorithm for the two machines problem with restricted CDD.

Finally, through experiments, it was shown that the* JSSPET* algorithm could find optimal solutions for the unrestricted and semirestricted versions of the problem. Also, the proposed algorithm works well as a heuristic for the restricted case with large problems. However, there is room to improve the performance of the* JSSPET* algorithm through the development of optimality conditions for the restricted case and by introducing better lower bounds to better evaluate the performance of the heuristic.

Future research involves extending this work to job shop scheduling problems with more than two machines.

#### Competing Interests

The authors declare that they have no competing interests.