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

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.


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.
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 Vshape 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 twomachine 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.

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  = 0.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 as Associated with each job there is an earliness penalty   > 0 and a tardiness penalty   > 0 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 CDD ≥ ∑  =1   , 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 ≥ Δ, where For 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, where where   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  = 0 the tighter (i.e., more restricted) the schedule.This fact can be used to define whether the CDD is restricted or not.Let  1 = set with jobs to be finished on machine 1,  2 = set with jobs to be finished on machine 2, number of jobs to be finished on machine 2. Also, let where Finally, let where and the number of tardy jobs in sets   1 and   2 are equal to zero.
where  1 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  1 is the completion time of the jobs with their last operation on machine 1 and to be completed after CDD and Δ 1 is the summation of processing times of the jobs in  1 .The optimal schedule for the machine 1 can be obtained by applying Kanet's SCHED algorithm to the jobs in sets  1 and  1 .The starting times of the jobs in sets  1 and  1 provide the due dates for their first operations to be processed on machine 2 (i.e., jobs in set    2 ).The jobs whose first operation must be performed on machine 1, jobs in   1 , are processed before the jobs in  1 without interfering with the optimal schedule since CDD ≥  1 + Δ 1 .
In order to find out if the number of tardy jobs in   1 is equal to zero, the earliest due date (EDD) rule needs to be applied to jobs in   1 .If an EDD sequence yields either zero or one tardy job, then it minimizes the number of tardy jobs [38]. Let , where  2 is the completion time of the jobs with their last operation on machine 2 to be completed before or on the CDD and Δ 2 is the summation of processing times of the jobs in  2 .Since  2 + Δ 2 ≤  1 + Δ 1 , jobs to be finished on machine 2 can be optimally scheduled by applying Kanet's SCHED algorithm to the jobs in sets  2 and  2 , where  2 is defined similarly to  1 .In the same way, the starting times of the jobs in sets  2 and  2 provide the due dates for their first operations to be processed on machine 1 (i.e., jobs in set   1 ).The jobs whose first operation must be performed on machine 2, jobs in   2 , are performed before the jobs in  2 without interfering with the optimal schedule.Also, it is possible to find whether the number of tardy jobs in   2 is equal to zero by applying the EDD rule to jobs in   2 .The same reasoning can be applied if max 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 max { 1 + Δ 1 ,  2 + Δ 2 } = max {8 + 13, 20 + 10} =  2 + Δ 2 = 30.Note that if the CDD > 30, the problem is still unrestricted.
1 and  2 are as in Definition 1.Hence, Δ 1 and Δ 2 are the summation of processing times of the jobs in  1 and  2 , respectively.Given CDD ≥  1 + Δ 1 , in an optimal schedule jobs in   1 are performed before the jobs in  1 without interference with the jobs in  1 .The optimal schedule for machine 1 can be obtained by applying Kanet's SCHED algorithm to the jobs in  1 and  1 .The starting times of the jobs in sets  1 and  1 provide the due dates for their first operations to be processed on machine 2 (i.e., jobs in the set    2 ), which are processed before the jobs in  2 .But given that CDD <  2 + Δ 2 , jobs in  2 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  2 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    1 ).The jobs whose first operation must be performed on machine 1, jobs in    1 , are processed before the jobs in  1 without interfering with the optimal schedule since CDD ≥  1 + Δ 1 .Similar to the unrestricted case, jobs in   1 and   2 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 min 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.
where  1 is the completion time of the jobs with their last operation on machine 1.Hence, Δ 1 is the summation of processing times of the jobs in  1 .Since CDD <  1 +Δ 1 , there is no way to optimally schedule jobs in  1 without modifying the starting times of the jobs in   1 (the first operations of jobs in  2 ).Hence, a tradeoff between jobs in   1 and jobs in  1 must be made.The jobs in   1 (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   1 is delayed, this delay interferes with the optimal schedule on machine 2. The same reasoning can be applied if min { 1 + Δ 1 ,  2 + Δ 2 } =  2 + Δ 2 .Following the same numeric example, Figure 3 illustrates the case when the CDD = 15 which is less than min 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.

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.

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 4. Let  1 and  2 represent an ordered set of jobs pertaining, respectively, to  1 and  2 to be scheduled without inserted idle time such that the first job in both  1 and  2 starts at time  = CDD.In an optimal schedule, jobs in both  1 and  2 are sequenced by shortest processing time (SPT) first.
Property 6.There is a one-to-one mapping of the jobs in both  1 and  2 onto the jobs in  1 and  2 such that  1 ∈  1 and  2 ∈  2 and  1 ∈  1 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.

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 min { 1 + Δ 1 ,  2 + Δ 2 }.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  * 1 or  * 2 denote the starting times in an optimal schedule of the first job processed on either  1 or  2 , respectively, corresponding to the machine where max Property 1.There exists at least one of the following: An optimal schedule with either  * 1 =  1 or  * 2 =  2 .An optimal schedule with  1(2) = CDD, where  is a job with its last operation on machine 1(2) starting before CDD and completing at CDD or later.Property 2. In an optimal schedule, the jobs in   1(2) are in LPT order, and the jobs in  1(2) 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 1(2) a schedule is early V-Shaped (EVS) if  1(2) ≤  1(2)min .Definition 5. On machine 1(2) a schedule is tardy V-Shaped (TVS) if  1(2) ≤  1(2)min , where min = min { 1(2) ∈   1(2) }, and min = min { 1(2) ∈  1(2) }.

Mathematical Problems in Engineering
, where job  is the first job scheduled on machine 1(2).
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  * 1(2) =  1(2) by using  and  procedures described by Hall et al. [6].
, then it is possible to assume that  1(2) = CDD 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.

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  1 = the set of jobs to be finished on machine 1 and to be scheduled around the restricted CDD. 2 = the set of jobs to be finished on machine 2 and to be scheduled around the restricted CDD.
Property 1. Jobs in  1 and  2 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,  ∈  1 ( 2 ), and the predecessors of a and b are already scheduled at machine 2(1).If job a is early ( 1(2) < CDD), then the total penalty cost can be reduced by shifting job a (and any jobs that precedes it) later by an amount Δ, where Δ ≤ min (, CDD −  1(2) ) without affecting the feasibility of .Denoting the values after the shift with primes, it follows that   1(2) =  1(2) and   1(2) ≤  1(2) strictly for at least one job.Similarly, if job b is tardy ( 1(2) > CDD), then the total penalty cost can be reduced by shifting job b (and any jobs that follows it) earlier by an amount Δt, where Δ ≤ min (,  1(2) − CDD) without affecting the feasibility of S. Hence, it follows that   1(2) =  1(2) and   1(2) ≤  1(2) 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  1 and  2 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  1(2) 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 1(2) without affecting the feasibility of S. Similarly, if S is an optimal schedule containing an adjacent pair of jobs that starts late in  1 (2) 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 1(2).In either case, S cannot be an optimal schedule.
Once the jobs to be included in  1 and  2 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  = CDD?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 1 and 2 is proposed.By iteratively eliminating the job with the longest processing time in either machine 1 or machine 2, sets  1 and  2 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.

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  * 1 =  1 or  * 2 =  2 and those with either  * 1 >  1 or  * 2 >  2 .In the first case, jobs either in where  1 = ∑ ∈ 1  1 and  2 = ∑ ∈ 2  2 .Based on Property 3, any optimal schedule is either EVS or TVS, and so EVS (TVS) procedure discussed next will find optimal Mathematical Problems in Engineering 7 EVS (TVS) schedules which is completed at either  1 +  1 or  2 +  2 .In the second case, suppose that either  * 1 >  1 or  * 2 >  2 and based on Property 1, it is possible to assume that either  1 = CDD or  2 = CDD 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 2 and 3 (V-shaped structure).
Procedures EVS and TVS consider jobs in nonincreasing order.From Property 3, job  1 (to be finished on machine 1) either starts at  1 or ends at  1 +  1 , and job  2 (to be finished on machine 2) either starts at  2 or ends  2 +  2 .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.

Procedure EVS.
Let   ( 1 ) = the minimum cost to schedule jobs  1 ,  1 − 1, . . .,  1 −  + 1 (similarly  2 ,  2 − 1, . . .,  2 −  + 1) provided that the latest job scheduled which finished at or before CDD finishes at time CDD −  1 ,  1 ≥ 0 (similarly CDD −  2 ,  2 ≥ 0), and the earliest job scheduled which finishes after CDD starts at time ∑ Recurrence relation is as follows: Boundary condition is as follows: Minimum cost schedule is defined by Recurrence relation is as follows: Boundary condition is as follows: Minimum cost schedule is defined by 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.

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 min { 1 + Δ 1 ,  2 + Δ 2 }), 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.

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 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 min ( 1 + Δ Finally, for the restricted case, the CDD is given by CDD = ⌊ℎ * min ( where ℎ is the tightness factor, ℎ ∈ [0, 1), and it takes four possible values, ℎ = 0.7, 0.8, 0.9, 0.95.⌊⌋ 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 9 * 30 * 6 = 1620 problem instances were solved.

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

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.

2 Figure 3 :
Figure 3: Example final scheduled for the restricted version.

Property 1 . 2 . 2 .Property 3 .
There is no idle time between jobs in sets  1 and  Property The jobs in both  1 and  2 are sequenced by longest processing time first (LPT).The last jobs in  1 and  2 are completed at time  = CDD.
) 4.3.Procedure Nosplit.Let ℎ  ( 1 ) = the minimum cost to schedule jobs 1, 2, . . .,  for either  1 or  2 without the CDD splitting any job, given that the total processing time of jobs scheduled early (or on time) is either  1 or  2 .

Table 3 :
Computational times for the unrestricted and semirestricted cases.