Mathematical Problems in Engineering

Volume 2016 (2016), Article ID 6124734, 12 pages

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

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

^{1}Department of Industrial Engineering and Management, National Yunlin University of Science and Technology, 123 University Road, Douliou, Yunlin 64002, Taiwan^{2}Department of Industrial Engineering and Management, National Chiao Tung University, 1001 University Road, Hsinchu 30010, Taiwan

Received 23 March 2016; Accepted 6 June 2016

Academic Editor: Miguel A. Salido

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

#### Abstract

This paper addresses the problem of scheduling 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.

#### 1. 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 earliness-tardiness 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 job-machine 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–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 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 two-parallel-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 two-phase 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 branch-and-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. Kaplanoğlu [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 time-dependent 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.

#### 2. Problem Presentation and Optimality Properties

##### 2.1. 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 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 and 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 are minimized. Extending the standard three-field notation in Graham et al. [42], this problem can be referred to as , where indicates that there is only one unavailability interval on the machine.

##### 2.2. Problem Analysis

In absence of machine availability constraints, the problem under consideration is reduced to the problem , which has been proven to be NP-hard by Hall et al. [9] based on the even-odd 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 : and , : and ,

where is an upper bound on the makespan. Let be the index of the job for which . Define as the set of jobs that finish on or before the due date, and define as the set of jobs that start on or after the due date. In addition, we denote by the set of jobs that are processed in available time windows , such that , , and . 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 V-shaped 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 .

*Property 3. *In an optimal schedule, there is no idle interval between the last job in and time when , and there is no idle interval between the first job in 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 .

*Property 5. *An optimal schedule must satisfy if or if .

#### 3. Mixed Integer Linear Programming Methods

This section presents four distinct ways of formulating the problem using mixed integer linear programming. Following is the notation for various indices and parameters used in the models.

*Indices* : 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, , : an appropriately large positive number.

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

*MILP1.* Consider

Constraint (2) enforces that all processing occurs only within set . Constraints (3) and (4) indicate that each job is processed during periods and . 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 constraints, binary variables, and standard variables.

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

*MILP2*. Consider

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 constraints, binary variables, and standard variables.

##### 3.3. Sequence-Position Decisions

In this formulation, the key binary variables are if job is assigned to the th () 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.

*MILP3*. Consider

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., ), 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 constraints (i.e., at most), binary variables (i.e., at most), and standard variables (i.e., at most).

##### 3.4. 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 . Hence, the problem can be modelled as follows.

*MILP4*. Consider

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., ), then job is scheduled either before or after job in ; that is, . Otherwise, there is no need to consider the precedence relationship between jobs and in (i.e., ). 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 constraints, binary variables, and 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.

#### 4. Dynamic Programming Based Method

In this section, a dynamic programming model for the problem 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 is , and the earliest job in starts at time . For and , 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 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 byIf then all jobs in are tardy, so job has to be scheduled as the last one in . As a result, in this situation the first term in recursion can be omitted.