Minimizing Total Earliness and Tardiness for Common Due Date Single-Machine Scheduling with an Unavailability Interval

This paper addresses the problem of scheduling n independent jobs on a single machine with a fixed unavailability interval, where the aim is to minimize the total earliness and tardiness (TET) about a common due date. Two exact methods are proposed for solving the problem: mixed integer linear programming formulations and a dynamic programming based method.These methods are coded and tested intensively on a large data set and the results are analytically compared. Computational experiments show that the dynamic programming method is efficient in obtaining the optimal solutions and no problems due to memory requirement.


Introduction
This paper considers the minimization of total earliness and tardiness (TET) for common due date single-machine scheduling with an unavailability interval.The TET performance measure is consistent with the just-in-time (JIT) manufacturing philosophy in which an ideal schedule consists of all jobs finish exactly on the due date.
These days, the emphasis on the JIT approach has led to a growing interest in earliness-tardiness scheduling models.In a JIT scheduling environment, job earliness may cause bounded capital and inventory holding costs, whereas job tardiness may disrupt a customer's operations.Therefore, both earliness and tardiness should be taken into account in order to determine the optimal machine scheduling policy.
The common due date scenarios are relevant in many realistic situations; for example, several items constitute a customer order, or they are delivered to an assembly line where the components are all required to be ready at the same time.Numerous studies have been published on the earlinesstardiness scheduling problems with common due date, such as those discussed in the surveys of Baker and Scudder [1], Biskup and Feldmann [2], Gordon et al. [3], and Lauff and Werner [4].In what follows, some references related to the common due date TET minimization are recalled.
Kanet [5] proposed a polynomially bounded matching algorithm for the single-machine problem that the due date was assumed to be greater than the total processing time of the jobs.Bagchi et al. [6] extended Kanet's result and provided an implicit enumeration procedure to find all the optimal schedules.Sundararaghavan and Ahmed [7] developed a polynomial-time algorithm to determine the optimal jobmachine assignment for identical parallel machines.Emmons [8] investigated the uniform parallel-machine scheduling problem when the makespan and machine occupancy were considered as the secondary objective.Baker and Scudder [1] specified the minimum value of a common due date that gives rise to the unrestricted version of the TET problem.Dynamic programming algorithms and branch-and-bound methods for single-machine scheduling with a restricted due date were presented in [6,[9][10][11][12][13].Sarper [14] modelled the two-machine flow shop scheduling problem as a mixed integer linear programming formulation and suggested three constructive heuristics.Sakuraba et al. [15] introduced a job timing algorithm for generating the optimal schedule when the sequence of jobs processed in the two-machine flow shop 2 Mathematical Problems in Engineering was given.Sung and Min [16] addressed the problem of scheduling two-machine flow shop with at least one batch processor incorporated.Some optimality properties were characterized for three different system configurations to derive their corresponding solution methods.Yeung et al. [17] proposed a branch-and-bound method and a heuristic to solve the two-machine flow shop scheduling problem with TET criterion in relation to a given common due window.Lauff and Werner [18] investigated the computational complexity of multistage scheduling problems with intermediate storage costs.
It can be observed that the majority of previous studies assumed that the machines are available at all times.However, in a real production system, machines may not be always available because of unforeseen breakdowns, tool changes, or preventive maintenance requirements for improving the production efficiency.It is also possible that machines have been committed to deal with the promised orders and hence become unavailable for processing in certain periods of the current planning horizon.Under such circumstances, the optimal production strategies can be quite different from those attained by classical models.
Due to the practical experience in production systems, there has been a great deal of efforts concentrated on scheduling problems with limited machine availability (see Lee et al. [19]; Schmidt [20]; Ma et al. [21]).More recently, Low et al. [22] presented heuristic approaches to minimize the makespan on a single machine that was periodically unavailable.Mosheiov and Sidney [23] developed polynomial-time algorithms for scheduling a deteriorating maintenance activity on a single machine with different objective functions.Zhao and Tang [24] analyzed the single-machine scheduling problem with simultaneous considerations of maintenance activities and job-dependent aging effect while minimizing the makespan.
Ángel-Bello et al. [25] proposed a mixed integer programming formulation and an efficient heuristic approach for the single-machine makespan problem with availability constraints and sequence-dependent setup costs.Huo and Zhao [26] presented polynomial-time algorithms to optimize both makespan and total completion time under a twoparallel-machine environment with availability constraints.Yang et al. [27] provided a dynamic programming algorithm and a branch-and-bound method for minimizing the total completion time on a single machine in which job processing and maintenance activity had to be scheduled simultaneously.Lee and Kim [28] studied the single-machine scheduling problem with periodic maintenance and adopted a twophase heuristic to minimize the number of tardy jobs.Yin et al. [29] examined the problem of scheduling jobs and common due date assignment on a single machine with a rate-modifying activity.They proposed some optimality conditions and developed polynomial-time algorithms for special cases.
Dong [30] presented a column generation based branchand-bound method to schedule identical parallel machines in which the job sequence and the timing of shutdown operation were jointly optimized.Hsu et al. [31] considered the scheduling problem of minimizing the total completion time and the total machine load on the unrelated parallel machines with three basic types of aging effect models and deteriorating maintenance activities.They showed that all the addressed models are polynomial-time solvable.Shen et al. [32] proposed polynomial-time algorithms to schedule identical parallel machines with nonsimultaneous machine available time.Vahedi-Nouri et al. [33] developed a new binary integer programming formulation and a branch-and-bound method for minimizing the total completion time in single-machine scheduling with learning effect and multiple availability constraints.Xu and Yang [34] considered the two-parallel-machine scheduling problem with a periodic availability constraint.They presented a mathematical programming model to minimize the makespan.
Hashemian et al. [35] addressed the makespan minimization for parallel-machine scheduling with multiple planned unavailability intervals.A mixed integer linear programming model and an implicit enumeration algorithm were designed to tackle the problem.Kaplanoglu [36] adopted a multiagent based approach for scheduling single machine with sequence-dependent setup times and machine maintenance, where both of the regular and irregular maintenance activities were considered.Rustogi and Strusevich [37] studied the single-machine scheduling problem incorporating positional and time-dependent effects, in which the machine was subject to rate-modifying activities that split the jobs into groups.The aims were to minimize the makespan and the total completion time.Yin et al. [38] explored the single-machine batch scheduling problem with an unavailability interval.A dynamic programming algorithm was proposed for minimizing the sum of total flow time and batch delivery cost.Yin et al. [39] investigated the problem of scheduling jobs with assignable due dates on a single machine, in which the job processing times were subject to positional deterioration and the execution of preventive maintenance.They analyzed the structural properties of the problems under consideration and presented polynomial-time algorithms for deriving the optimal solution.Rustogi and Strusevich [40] considered the single-machine scheduling problem with linear timedependent deterioration effects and maintenance activities.A range of polynomial-time algorithms were designed to minimize the makespan.
Most of the aforementioned scheduling models focused on regular performance measures such as makespan, total completion time, and number of tardy jobs.With current emphasis on the JIT production strategy, these classical measures may no longer be applicable.So far, only Low et al. [41] addressed the problem of minimizing common due date TET in the presence of availability constraints.They developed an ant colony optimization algorithm for the single-machine model in which one maintenance task had to be performed and analyzed some special cases that are polynomial-time solvable.Nevertheless, such heuristic approaches offer no guarantees to the optimality of the obtained solutions and do not define how close the obtained solutions are to the optimal ones.Furthermore, it should be noted that the matching algorithm suggested by Low et al. [41] only can be used to deal with the cases when the due date falls within the unavailability interval and certain conditions are satisfied.In practical scheduling environments, the production schedulers always expect to come up with an optimal schedule in reasonable time.It might be undesirable to use heuristic approaches to tackle problems while efficient exact algorithms are available.Thus, more powerful optimization techniques must be brought to bear on the problem.
This paper contributes two exact methods: mixed integer linear programming formulations and a dynamic programming method.The mixed integer linear programming formulations are characterized by the type of binary variable that captures the scheduling decision, and the dynamic programming method is derived based on the optimality properties.Experimental results show that the proposed methods are able to give satisfactory solutions.Moreover, it is computationally demonstrated that the dynamic programming method is efficient in obtaining the optimal schedules for large-scale problems.
In the next section, a formal statement of the problem is established and some optimality properties are given.Section 3 provides four mixed integer linear programming formulations based on different definitions of decision variables, while Section 4 describes the dynamic programming algorithms.In Section 5, computational results are reported to evaluate the proposed methods.Finally the conclusions are drawn in Section 6.

Description of the Problem.
A set of  independent jobs has to be processed on a single machine which is unavailable in a given time interval [  ,   ].Each job  ( = 1, 2, . . ., ) becomes available for processing at time zero, has a processing time   , and should ideally be completed at a common due date .The machine can handle at most one job at a time and preemption of jobs is prohibited.Without loss of generality, it is assumed that all data are integral.A schedule defines for each job  a completion time   .Let   = max{0,  −   } and   = max{0,   − } represent the earliness and tardiness, respectively, of job .The objective is to determine a feasible schedule so that the TET about the common due date ∑  =1 |  − | = ∑  =1 (  +   ) are minimized.Extending the standard three-field notation in Graham et al. [42], this problem can be referred to as , where ℎ 1 indicates that there is only one unavailability interval on the machine.

Problem Analysis.
In absence of machine availability constraints, the problem under consideration is reduced to the problem 1 |   =  | ∑  =1 (  +   ), which has been proven to be NP-hard by Hall et al. [9] based on the evenodd partition problem, and hence the addressed problem is also NP-hard.To begin with, some important optimality properties are established.They are essential for the design of the dynamic programming.
Since the machine cannot process any jobs in an unavailability interval [  ,   ], there are two available time windows   = [  ,   ], where  = 1:   = 0 and   =   ,  = 2:   =   and   =  * , where  * is an upper bound on the makespan.Let  be the index of the job for which   −   <  ≤   .Define   = {1 ≤  ≤  |   ≤ } as the set of jobs that finish on or before the due date, and define   = {1 ≤  ≤  |   −   ≥ } as the set of jobs that start on or after the due date.In addition, we denote by and  1 ∩  2 = 0. Properties 1 and 4 generalize the results given by Cheng and Kahlbacher [43] and Bagchi et al. [6], respectively.Properties 2 and 3 are straightforward to prove by contradiction.Property 5 is an extension of the weakly Vshaped schedule optimality shown in Hall et al. [9].It is easily verified that such a result can be generalized to the case with an unavailability interval.
Property 1.In an optimal schedule there are no idle times within the processing of consecutive jobs in each available time window.
Property 2. The earliest job in an optimal schedule must start at or before time  = max{,   }.Property 3. In an optimal schedule, there is no idle interval between the last job in  1 and time   when   ≤ , and there is no idle interval between the first job in  2 and time   when   ≥ .Property 4. In an optimal schedule, the jobs in set   ∩   are sorted according to nonincreasing order of processing times (LPT), and the jobs in set   ∩   are sorted according to nondecreasing order of processing times (SPT), for all  = 1, 2. Property 5.An optimal schedule must satisfy

Mixed Integer Linear Programming Methods
This section presents four distinct ways of formulating the problem 1, ℎ 1 |   =  | ∑  =1 (  +   ) using mixed integer linear programming.Following is the notation for various indices and parameters used in the models.3.1.Time-Indexed Decisions on Processing Periods.First, the time-indexed variables on processing periods are considered.The rationale for this approach is to decompose the scheduling horizon into individual periods, where period  starts at time  and ends at time  + 1 ( ∈ [0,  * − 1]).Then, the scheduling problem can be regarded as the assignment of unit job segments to unit periods.Let the binary variables   equal 1 if job  is processed during period  ∈ Ψ and 0 otherwise, where Ψ = ⋃  (  \ {  }) represents the set of time units in which the machine is available.The following formulation is originally proposed in Low et al. [41].A major drawback of this formulation is its size.The preliminary tests show that only instances with about 20 jobs can be solved by ILOG CPLEX 12.4.Therefore, a more sophisticated formulation must be considered.
Constraint (2) enforces that all processing occurs only within set Ψ. Constraints (3) and ( 4) indicate that each job  is processed during periods   −   and   − 1. Constraint (5) guarantees that at any given period at most one job can be handled.Constraint (6) determines the job earliness and tardiness.This model includes 2 + (2 + 1)|Ψ| constraints, |Ψ| binary variables, and 3 standard variables.

Time-Indexed Decisions on Start
Times.An alternative approach relies on time-indexed variables on start times.This formulation assumes the same time-discretization as for MILP1.Define   = { |   ≤  ≤   −   } as the set of time units in which job  is allowed to start its processing in available time window   , and define   () = { |  ∈ Ψ, max{0, −  +1} ≤  ≤ } as the set of start times for which job  would be in process in period .Let the binary variables   equal 1 if job  starts at period  ∈ Ψ and 0 otherwise.The formulation is described as follows.
Constraint (10) ensures that each job is processed once, where ⋃    represents the set of time units in which job  is allowed to start its processing in the scheduling horizon.Constraint (11) states that at most one job can be handled at any time.Constraint (12) calculates the values of earliness and tardiness of jobs.This model contains 2 + |Ψ| constraints, |Ψ| binary variables, and 2 standard variables.

Sequence-Position Decisions.
In this formulation, the key binary variables are   = 1 if job  is assigned to the th ( = 1, . . .,   ) position in available time window   and 0 otherwise, where   is the maximum number of jobs that can be scheduled in   .It is obtained easily by inserting the shortest jobs.Define   ,   , and   as the completion time, earliness, and tardiness of the job scheduled th in available time window   , respectively.From Property 1, it is sufficient to consider only schedules in which jobs are contiguous in each available time window.Nevertheless, an optimal schedule may not start processing the jobs immediately at the beginning of each available time window.Thus, the variables   are introduced to represent the start time of the first job processed in available time window   .With the above notation the problem can be modelled as follows.
Constraint (16) indicates that each job is assigned to exactly one position in one available time window.Constraint (17) guarantees the assignment of at most one job to each position in each available time window.Constraint (18) gives the completion time of the job that is assigned to the th position in   .Constraints ( 19)-( 21) measure the deviation of each job's completion time from the common due date.If there exists a job that is scheduled in the th position in   (i.e., ∑  =1   = 1), then its earliness and tardiness can be determined by equation   −  =   −   , which follows directly from Constraints (19) and (20).Otherwise, Constraint (21) enforces   and   equal to zero.Constraints (22) and ( 23) concern the machine unavailability.This model includes  + 6 ∑ 2 =1   + 2 constraints (i.e., 13 + 2 at most),  ∑ 2 =1   binary variables (i.e., 2 2 at most), and 3 ∑ 2 =1   + 2 standard variables (i.e., 6 + 2 at most).

Precedence Decisions.
This formulation is based on the precedence variables.Let     be the binary variables equal to 1 if job   precedes job  in available time window   , and let   be the binary variables equal to 1 if job  is scheduled in available time window   .Note that job   is not necessarily positioned immediately before job  in   when     = 1.Hence, the problem can be modelled as follows.
Constraint (28) states that each job is assigned to exactly one available time window.Constraints ( 29) and (30) establish the relation between precedence and assignment variables.If jobs   and  are both processed within   (i.e.,   =    = 1), then job   is scheduled either before or after job  in   ; that is,     +    = 1.Otherwise, there is no need to consider the precedence relationship between jobs   and  in   (i.e.,     =    = 0).Constraint (31) computes for every job  ̸ =   the completion time when job   precedes job  in the same available time window.Otherwise, the constraint is redundant.Constraints (32) and (33) describe the limits of the machine availabilities.Constraint (34) defines the earliness and tardiness of jobs.This model contains 3 2 + constraints, 2 2 binary variables, and 3 standard variables.
Unlike the other formulations, it can be seen that the sizes of the time-indexed formulations (MILP1 and MILP2) depend on the length of the scheduling horizon.This can lead to models with quite a large number of binary variables; however, the time-indexed formulations may be efficient in other respects.More specifically, tightening the linear relaxation of the formulation plays a key role in convergence of the solution procedure, and it strictly relies on the choice of decision variables used and the relevant constraint structures.To that end, the performance of these above formulations will be evaluated in computational study.

Dynamic Programming Based Method
In this section, a dynamic programming model for the problem 1, ℎ 1 |   =  | ∑  =1 (  +   ) is presented.This method is an extension of Ventura and Weng's dynamic programming [13].Here, we show that it can be applied with slight modification to the case with an unavailability interval.
Since the machine is unavailable for processing during the time interval [  ,   ], there are three cases to consider: (1)   < , (2)   > , and (3)   ≤  ≤   .The algorithms are developed below separately for each case.Assume for convenience that the jobs are renumbered in the order defined for SPT.
Algorithm for Case 1 (  < ).Let (, , ) denote the minimum cost for the -jobs partial problem, given that the total processing time of the jobs in  1 is , and the earliest job in  2 starts at time .For  = 1, . . ., ,  = 0, . . ., min{  , ∑  ℎ=1  ℎ } and  =   , . . ., +  − 1, the recursive three-term equation is defined as (41), in which the first two terms represent the value of (, , ) if job  is scheduled after   and the last term represents the value of (, , ) if job  is scheduled before   .From Properties 4 and 5, if  <  then at the stage of scheduling job  in  2 two decisions should be considered: job  can be scheduled as the first job, starting at time , or as the last one, then starting at time  + ∑ The first decision leads to the partial schedule presented in Figure 1.The cost of this partial schedule can be calculated according to The second decision results in the partial schedule shown in Figure 2, and its cost is given by   If  ≥  then all jobs in  2 are tardy, so job  has to be scheduled as the last one in  2 .As a result, in this situation the first term in recursion can be omitted.( − 1,  −   , ) +  −   +  −   is the value of (, , ) if job  is scheduled in  1 .By Properties 3 and 4, the partial schedule in  1 is constructed in a backward manner such that the last job in  1 finishes exactly at time   (see Figure 3).

Initial Condition. The initial condition is
The Recursion.The recursion is where The optimal objective value is equal to min 0≤≤min{  ,∑  =1   },   ≤≤ (, , ).For each state (, , ), there are at most three operations.It follows from Property 5 that if job 1 starts after  in an optimal schedule, it must start on or before  +   − 1, which implies that  ≤  +   − 1.In addition, the value of the state variable  is bounded by   .Therefore, the time complexity of the algorithm is O(  ( +   −   )).Algorithm for Case 2 (  > ).Following the same reasoning discussed in Case 1, let (, , ) denote the minimum cost for the -jobs partial problem, given that the earliest job in  1 starts at time , and the total processing time of the jobs in  2 is .For  = 1, . . ., ,  = 0, . . ., min{  ,  +   − 1} and  = 0, . . ., ∑  ℎ=1  ℎ , the recursive equation takes the following form.

Initial Condition. The initial condition is
The Recursion.The recursion is where Clearly if  ≥ , it is sufficient from Property 4 to consider that job  is scheduled either as the last one in  1 , starting at time +∑ −1 ℎ=1  ℎ −, or as the last one in  2 , then starting at time   +  −   (see Figure 4).Therefore, in this situation the first term in recursion can be eliminated.The optimal objective value is found for min 0≤≤min{  ,+  −1}, 0≤≤∑  =1   (, , ).Each state (, , ) requires at most three operations, and the state variables  and  take   and ∑  =1   as their maximum possible values, respectively.Hence, the overall time complexity of the algorithm is bounded by O(  (∑  =1   )).
Algorithm for Case 3 (  ≤  ≤   ).In this case, the problem is reduced to determining the optimal assignment of the jobs to the available time windows.Once the membership in the two available time windows is specified, the optimal schedules in each available time window can be found by Properties 1, 3, and 4. Let (, ) be the minimum cost for the -jobs partial problem, where the total processing time of the jobs in  1 is .
For  = 1, . . .,  and  = 0, . . ., min{  , ∑  ℎ=1  ℎ }, the recursive two-term equation is defined as (45), in which the first term represents the value of (, ) if job  is scheduled in  1 and the second term represents the value of (, ) if job  is scheduled in  2 .

Initial Condition. The initial condition is
The Recursion.The recursion is where The optimal objective value is equal to min 0≤≤min{  ,∑  =1   } (, ).As described above, it can be established that the algorithm finds an optimal schedule in O(  ) time.

Experimental Results
In this section, the numerical results are provided to assess the performance of the different methods presented above.The dynamic programming algorithms were written in C++ language and the mixed integer linear programs were solved by ILOG CPLEX 12.4.The experiments were conducted on a PC with a 3.4 GHz processor and 4 GB RAM.

Comparison between the Proposed Methods.
Here, the computation times (in CPU seconds) and the optimality gaps of the proposed methods are compared.The problem instances were generated as follows: (1) The number of jobs was chosen from 5 to 200.
Case  of which the due date factor was chosen from  ∈ {0.3, 0.5, 0.7}.
For each case, 10 instances were randomly generated for each problem size.The results of this experiment are summarized in Table 1.The symbol "-" denotes the cases that no feasible solution found within a time limit 5000 seconds or the program is interrupted due to lack of memory.The symbol " * " denotes that the optimality gap is calculated as [((IB) − optimum)/optimum] × 100%, where (IB) is the incumbent solution obtained before the program is terminated.
According to these results, it is clear that MILP2 and the dynamic programming method are much more effective than the other mixed integer linear programming formulations.MILP2 was able to handle the problems with close to 150 jobs, while it was difficult to use the latter approaches to solve instances with more than 20 jobs.However, the obtained results corroborate the findings in Kacem et al. [44] that the dynamic programming method could be superior to other methods.As compared to MILP2, the dynamic programming method was more efficient in attaining the optimal schedules and no problems due to memory requirement.In addition, the superiority of the dynamic programming method became more significant as the problem size increased.The dynamic programming method is complex.So, we add particularly further experiments with  max = 50, 100, and 200 to evaluate the impact of the length of the scheduling horizon on the method.Table 2 presents computation times required to obtain the optimal solutions for each case.As the results show, the dynamic programming method became relatively expensive, in terms of CPU time, when the value of ∑  =1   increased.Moreover, as compared to the results of the mixed integer linear programming methods for the problems with  max = 10, the dynamic programming method was still capable of quickly solving problems with hundreds of jobs.Given the above observations, we can conclude that the dynamic programming method may be more promising for the addressed problem.

Dynamic Programming Method
Experiments.In this section, the influence of the proportionality coefficient  and the due date factor  on the performance of the dynamic programming method is analyzed.The number of jobs varied in  ∈ {100, 300, 500, 700, 1000}, and the job processing times followed a discrete uniform distribution defined by the interval [1,20].The due date, start time, and the duration of the unavailability interval were set as those described in the previous experiment.For each treble (, , ), 10 instances were randomly generated.Hence, this experiment contains a total of 450 instances for each case.For Cases 1 and 2, it can be observed from Table 3 that for the same problem sizes the average of CPU times became higher when the value of  increased.The results also indicate that as compared to Case 1 when  was small (≤ 0.5) the problems of Case 2 were relatively easy to solve.Nevertheless, it is noticed that the variation of  did not have a significant influence on the problem hardness.With respect to Case 3, the results indicate that for the same problem sizes the larger the value of  was the harder the problems became.It seems that the value of  had no effect on the performance of this method.Indeed, in this case the algorithm is implemented in O(  ) time and therefore, its complexity is independent of the due date setting.

Conclusions
This paper addresses the single-machine scheduling problem to minimize the TET in relation to a common due date, where the machine is subject to a given unavailability interval during which the production is not allowed.To the best of our knowledge, no exact algorithms have previously been published for this problem.Therefore, this study proposes solution methodologies and properties of an optimal schedule for the purpose of exposing insights that may ultimately be useful in research on more complicated models.First, four mixed integer linear programming formulations with different types of binary variables that seize the scheduling decisions are introduced.Observing that these formulations are time-consuming to derive an optimal solution with the increase of the number of jobs, a dynamic programming method based on the solution properties is then proposed to deal with large-scale problems.Numerical results for problems with up to 1000 jobs demonstrate that the dynamic programming method is well suited to finding optimal schedules in comparison with the mixed integer linear programming methods and its advantage gets bigger as the problems size increases.In summary, when the complexity of the dynamic programming method remains correct, it is very promising for practical problems.
: index of available time windows, : index of jobs, : index of sequence positions, : index of time periods.Parameters : total number of jobs, : common due date,   : processing time of job ,   : start time of available time window   ,   : finish time of available time window   ,  * : an upper bound on the makespan,  * = max{,   } + ∑  =1   , : an appropriately large positive number.

Figure 3 :
Figure 3: A partial schedule in  1 with job  starting at time   − .

Figure 4 :
Figure 4: A partial schedule in  2 with job  starting at time   +−  .
Figure 1: A partial schedule in  2 with job  starting at time .

Table 1 :
Comparison between the exact methods.

Table 2 :
Dynamic programming method performance.