A survey of scheduling with deterministic machine availability constraints

Computers & Industrial Engineering 58 (2010) 199–211

Contents lists available at ScienceDirect

Computers & Industrial Engineering journal homepage: www.elsevier.com/locate/caie

A survey of scheduling with deterministic machine availability constraints Ying Ma a,*, Chengbin Chu a,b, Chunrong Zuo a a b

School of Management, Hefei University of Technology, 193 Tunxi Road, Hefei 230009, Anhui, China Université de Technologie de Troyes, ICD, LOSI FRE CNRS 2848, 12 rue Marie Curie, BP 2060, 10010 Troyes Cedex, Troyes, France

a r t i c l e

i n f o

Article history: Available online 3 May 2009 Keywords: Scheduling problems Availability constraints Algorithms

a b s t r a c t Various deterministic scheduling problems with availability constraints motivated by preventive maintenance attract more and more researchers. Many results involving this constraint have been published in recent years. But there is no recent paper to summarize them. To be convenient for interested researchers, we make this survey. In this paper, complexity results, exact algorithms and approximation algorithms in single machine, parallel machine, flow shop, open shop, job shop scheduling environment with different criteria are surveyed briefly. Ó 2009 Elsevier Ltd. All rights reserved.

1. Introduction The vast majority of research in scheduling assumes that machines are continuously available for processing throughout the scheduling period. However, this assumption may not be true in real industrial settings, since a machine may become unavailable during certain periods of time. So recently more and more researchers began to study problems with this constraint on machines. In this paper, we provide a survey of these studies. Previous reviews in this area are provided by Lee, Lei, and Pinedo (1997), Sanlaville and Schmidt (1998) and Schmidt (2000). Machine may become unavailable due to a machine breakdown or preventive maintenance during the scheduling period. When unavailability constraints are due to preventive maintenance, two cases are possible. One is the case where maintenance periods are fixed in advance, it is called deterministic case. The other is that maintenance periods are also decision variables, i.e., scheduling processing of jobs and maintenance of a machine simultaneously. When unavailabilities are due to machine breakdowns, it is a stochastic case, i.e., the breakdowns and repair processes are random. It is also possible that a machine is unavailable at the beginning of the scheduling period because it continues to process uncompleted jobs scheduled during the previous scheduling period. This case can be classified into the deterministic one. Sometimes, we refer to an unavailability interval as a hole. In this paper, we only deal with the deterministic case. The problem can be described as follows. We are given a set of jobs J = {Ji|i = 1, . . . , n} and machines M = {Mj|j = 1, . . . , m} which does not operate continuously, machine Mj is unavailable for processing within Sj given time intervals [Bsj ; F sj ], s = 1, . . . , Sj and * Corresponding author. Tel./fax: +86 0551 2904860. E-mail addresses: [email protected], [email protected] (Y. Ma). 0360-8352/$ - see front matter Ó 2009 Elsevier Ltd. All rights reserved. doi:10.1016/j.cie.2009.04.014

 F sj for all s = 1, . . . , Sj1. Bsj denotes the start time and F sj the Bsþ1 j finish time of sth interval of unavailability of machine Mj. Sometimes the notation may be simplified. For example, since there is only one machine in single machine problems, the subscript j can be dropped. And if there is only one hole, then s can be dropped. At any time, each machine can process at most one job and each job can be processed on at most one machine. For the machine environment, the simplest model is single machine. And there are multi-machine models. Machines may be either parallel, i.e., performing the same functions, or dedicated, i.e., being specialized for the execution of certain operations. For parallel machines, there are three models: identical machines, uniform machines and unrelated machines. If all machines from M have equal operation processing speeds, then we call them identical. Machines with proportional performance are called uniform machines. And if there is no relation between the performances of the machines, then we call them unrelated machines. For dedicated machines there are three models: flow shop, open shop and job shop. In flow shop, each job has m operations, the first of which requires processing on machine M1, the second requires processing on machine M2, and so on. In job shop, each job has a given sequence of operations on the machines, so that different jobs pass through the machines in a different order. In open shop, each job has an operation on each of the m machines, but the processing order of these operations can be chosen. Each job Ji may be divided into many operations and operation Oi,j (the jth operation of Ji) will be performed on Mk with pi,j,k time units processing. In some cases, there are no alternative machines for operations, and then we simply write pij as the processing time. If furthermore, there is only one operation per job (in single machine and identical machine problems), the subscript j in pij is dropped.

200

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

There are some notions for characterizing each job. Let ri qi ~ d i

di wi Ci,j Ci Li Ti Ui ¼ Ei Cmax Cmin Lmax Tmax



1; 0;

if job i is late; i:e:; C j > dj otherwise

a release time a latency duration or tail a due date a deadline a weight (priority) the completion time of operation Oi,j completion time of job i lateness of job i, Li = Ci  di tardiness of job i, Ti=max(Ci  di, 0) earliness of job i makespan minimum completion time maximum lateness maximum tardiness

A schedule is called preemptive if the processing of each operation on a machine can be interrupted at any time and resumed later at any time and restarted at no cost; between the interruption and the resumption of the processing, the operation may be processed on any other machine. There are two cases in preemptive schedule: one is the case where operations may be preempted, but each operation must be processed by only one machine, i.e., if an operation is preempted, it must stay on that machine, until it can be continued later, this is known as operation preemption, the other is the case where operations may be arbitrarily preempted, i.e., operations may be preempted and can be shifted to another machine or to be continued later, this is known as arbitrary preemption. If preemption of operations is not allowed, i.e., once an operation is started it must be completed without interruption, we call the schedule nonpreemptive. If there is only one machine dedicated to each operation then operation preemptions and arbitrary preemptions become equivalent. For single machine and flow shop problems this difference has not to be considered (Schmidt, 2000). From another perspective, according to the effect of unavailability constraints to the disrupted job’s processing, researchers discuss three cases, namely resumable, nonresumable, and semiresumable. Resumable and nonresumable cases are defined by Lee (1996). In the resumable case preemption is allowed. If an operation cannot be finished before the unavailable period of a machine, then it can continue after the machine is available again. Nonresumable case defines the case where preemption is not allowed. The disrupted operation has to totally restart rather than continue. Semiresumable case is defined by Lee (1999). Under the semiresumable assumption, the disrupted operation will have to partially restart after the machine becomes available again. In all these three cases, operations not affected by holes (As defined above, these ‘‘holes” are unavailability intervals which happen on machines) are nonpreemptive. Obviously, if each job only has one operation, we can call them resumable, nonresumable and semiresumable jobs, respectively. According to the degree of the information on the job data in advance, we distinguish two kinds of problems. If we have full information on the job data before constructing a schedule, this problem is called offline. And a scheduling problem is called online if it requires scheduling jobs irrevocably on the machines as soon as they are given, without any knowledge about jobs that follow later on (Tan & He, 2002). To be able to refer to the problem in a concise way, in the following we will use the standard three fields a|b|c notation similar

to that introduced by Schmidt (2000). We modify the entry denoting machine availability and omit entries which are not relevant to investigated problems. The first field a = a1a2a3 describes the machine environment. Parameter a1e{U, P, Q, R, F, J, O} characterizes the classical machines in single machine, identical, uniform and unrelated parallel machines, flow shop, job shop and open shop environment. Parameter a2e{U, m} indicates that the number of machines (for parallel machine systems) or the number of stages (for dedicated machine systems) is assumed to be variable and equal to m (m is a positive integer), respectively. Parameter a3e{U, hjk} describes the holes, where a3 = U means that there are no holes. In this notation, hjk specifies the number of the hole(s) and the machine(s) on which they appear, and a3 = hjk represents the problem with an arbitrary number of holes on each machine. If j is replaced by a positive integer, it means that holes are only on this machine. Otherwise, holes will be allowed to be on all machines. If k is replaced by a positive integer, it denotes the number of holes on the corresponding machine. Otherwise this number is arbitrary. For example, a3 = h1k represents the problem with an arbitrary number of holes on M1 but no holes on other machines; a3 = hk1 represents the problem with one hole on each machine; and a3 = hl1 represents the problem with one hole on machine M1 only. In particular, in single machine environment, the subscript j can be dropped, so a3 = hk indicates that k holes can occur on the machine. The second field b = b1, . . . , b5 describes operation (job) and resource characteristics. Parameter b1 e {U, t  pmtn, pmtn} indicates the possibility of preemption, where b1 = U, b1 = t  pmtn and b1 = pmtn denotes, respectively, nonpreemption, operations preemptions and arbitrary preemptions. There are many studies use b1 = r  a, b1 = nr  a and b1 = sr  a to denote resumable, nonresumable and semiresumable availability constraints, respectively. Parameter b2 e {U, ri} describes ready times, where b2 = U indicates all ready times are zero, and b4 = ri denotes ready times differ per ~ } describes deadlines or, operation (job). Parameter b3 e {U, d i where b3 = U indicates no deadlines are assumed (however, due dates may be defined if a due date involving criterion is used to ~ indicates deadlines are imposed evaluate schedules), and b3 = d i on the performance of a job set (Schmidt, 2000). Parameter b4 e {U, qi} describes tails, where b4 = U indicates that jobs have no tail, and b4 = qi indicates that jobs have tail. Parameter b5 e {U, online} reflects whether the problem is offline or online. The third field c represents the performance measure to be optimized. Such criterion considered in the previous literature are minimization of completion time and due date related measures, for P P P P example, Cmax, Cmin, Lmax, Tmax, Ci, wiCi, Ui, wiUi and so on. The time complexity of an algorithm is measured by the number of elementary arithmetical operations (addition, subtractions, comparisons,. . .) required to run the algorithm in function of the problem size g expressed in terms of number of input data k, we note it O(g(k)). For offline settings, the relative worst-case error of a polynomial algorithm H is defined as

RH ¼ maxfC H ðIÞ=C opt ðIÞ  1 : for all Ig where CH(I) is the performance of algorithm H applied to some problem instance I and Copt(I) is the value of an optimal solution. And the absolute error AH is defined as

AH ¼ maxfC H ðIÞ  C OPT ðIÞ : for all Ig From another perspective, a polynomial algorithm that creates a schedule with the criteria that is at most q P 1 times the optimal value is called a q-approximation algorithm, the value of q is called a worst-case ratio bound. If a problem admits a q-approximation algorithm it is said to be approximable within a factor q. It is obvious that the relation between q and RH is

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

q ¼ RH þ 1 And for online settings, we use competitive analysis. Competitive analysis is a type of worst-case analysis where the performance of an online algorithm is compared to that of the optimal offline algorithm. For an online algorithm H, let CH denote the performance of a schedule produced by H and COPT denote the corresponding performance of some optimal schedule. Then the competitive ratio of H is defined as the smallest number c such that CH 6 cCOPT for all instances. An algorithm with a competitive ratio c is called a c-competitive algorithm. An online problem has a lower bound q if no online algorithm can be q0 -competitive with q0 < q. An online algorithm is called optimal if its competitive ratio matches the lower bound of the problem (Tan & He, 2002). Because simple priority rules are easy to implement and their computational complexity is low, so many of the problems are solved with priority rules. The following rules are the most prominent.  Shortest Processing Time (SPT) rule. Sequencing (jobs) operations in the nondecreasing order of pi.  Weighted Shortest Processing Time (WSPT) rule (also defined as Smith rule). Sequencing (jobs) operations in the nondecreasing order of the ratio pi/wi.  Longest Processing Time (LPT) rule. Sequencing (jobs) operations in the nonincreasing order of pi.  Earliest Due Date (EDD) rule. Sequencing (jobs) operations in the nondecreasing order of di.  Johnson’s rule (JR) for two-machine flowshop problem: Ji precedes Jj if min(pi1, pj2) < min(pi2, pj1).  Johnson’s algorithm (JA) for two-machine flowshop problem: divide the n-job set into two disjoint subsets, S1 and S2, where S1 = {Ji: pi1 6 pi2} and S2 = {Ji: pi1 > pi2}. Order the jobs in S1 in the nondecreasing order of pi1 and those jobs in S2 in the nonincreasing order of pi2. Sequence jobs in S1 first, followed by S2. The remainder of this paper is organized as follows. Surveys of single machine, parallel machine, flow shop, open shop, job shop scheduling problems with availability constraints will be given in Sections 2–6, respectively. In every section, we distinguish three cases: resumable, nonresumable and semiresumable cases. And in every subsection, we survey problems according to different criteria. The final section gives conclusions and future research trends. In this section, we draw three tables to summarize most of the results reviewed in this paper. In parallel machine and open shop environment, without loss of generality, for m = 2, if hole happens on only one of the two machines, we assume that the hole happens on machine M2; otherwise, the machines can be appropriately renamed. 2. Single machine problems Single machine problems are of fundamental character. They can be interpreted as building blocks for more complex problems. So we begin with this shop type.

201

modified to 2/7 by Lee and Liman (1992). They also provide a simpler proof of the NP-hardness. Later, an approximation algorithm MSPT with a tight error bound of RMSPT 6 3/17 is proposed by Sadfi, _ Penz, Rapine, Błazewicz, and Formanowicz (2005), and a parametric O(nlog n)-algorithm with which better worst-case error bounds can be obtained is presented by Breit (2007). Also for this problem, He, Zhong, and Gu (2006) present a polynomial time approximation scheme (PTAS). P The problem 1, h1|nr  a| wiCi is obviously NP-hard. Lee (1996) shows that the error bound of applying WSPT algorithm to this problem can be arbitrary large even if wi = pi. But recently, Kacem and Chu (2008a) show that both WSPT and MWSPT (Modified Weighted Shortest Processing Time) rules have a tight error bound of 2 under some conditions. Later, Kacem (2008) propose a 2approximation algorithm with O(n2) time complexity and show that this bound is tight. They also propose three exact methods to solve this problem: a branch-and-bound procedure based on new properties and lower bounds, a mixed-integer linear programming model and a dynamic programming method (Kacem & Chu, 2008b; Kacem, Chu, & Souissi, 2008). They show that the branchand-bound algorithm can handle very large-sized instances. For 1, h1|nr  a|Cmax, Lee (1996) shows easily that this problem is NP-hard. He also shows that if we order the jobs in the LPT order, assigning to the machine as many jobs as possible before B, and then assigning the remaining jobs after F in an arbitrary order, then this rule can leads to a tight error bound of RSPT 6 1/3. When every job has a positive tail (1, h1|nr  a, qi|Cmax), Kacem (2009) propose a tight 3/2-approximation heuristic for this problem. He also presents a dynamic programming algorithm and show that the problem has a fully polynomial time approximation scheme (FPTAS) by exploiting the well-known approach of Ibarra and Kim (1975). And if multiple holes are allowed (1, hk|nr  a|Cmax), the problem becomes NP-hard in the strong sense (See Lee, 1996). Breit, Schmidt, and Strusevich (2003) show that for a fixed q P 1, the existence of a q-approximation algorithm for problem 1, h2||Cmax implies that P = NP. P The problems 1, h1|nr  a| Ui and 1, h1|nr  a|Lmax are also NPhard. And Moore and Hodgson’s algorithm (see Moore, 1968) leads to an absolute error of AMH = 1 to solve the problem 1, P h1|nr  a| Ui while EDD rule leads to an absolute error of AEDD = pmax for the problem 1, h1|nr  a|Lmax (shown by Lee, 1996). In case of multiple holes on machine and ready time and due date constraints on jobs (1, hk|ri|Lmax), Leon and Wu (1992) propose an efficient branch-and-bound algorithm to solve it. Later, Asano and Ohta (1999) extend this branch-and-bound algorithm to include sequence-dependent set-up times. The proposed optimization algorithm based on the branch-and-bound method improves the practicality because it includes their algorithm in the special case of sequence independent setup times, and furthermore it improves the computational efficiency for solving the problems with multiple holes. Liao and Chen (2003) study the problem with periodic maintenance periods where maintenance is required after a fixed time interval (1, hk|nr  a|Tmax). A branch-and-bound algorithm that utilizes several inherent theorems and a heuristic is developed for small-to-medium-sized and large-sized instances, respectively.

2.1. Nonresumable cases P The classical 1|| Ci problem where no hole is imposed on machine can be solved applying the SPT rule. It is obvious that if the machine has release time, i.e., B = 0 and F > B, the SPT rule is also P optimal for this problem (1, h1|| Ci). Adiri, Bruno, Frostig, and Rinnooy Kan (1989) study the problem P with only one single interval of unavailability (1, h1|nr  a| Ci). They show that the problem is NP-hard and the SPT sequence has a relative error bound of RSPT 6 1/4. But this error bound is

2.2. Preemptive and resumable cases In case of a single hole, Lee (1996) states that the problems 1, P h1|r  a|Cmax and 1, h1|r  a| Ci and 1, h1|r  a|Lmax can be solved optimally by an arbitrary sequence, the SPT rule, and the EDD rule, P respectively. And the problem 1, h1|r  a| Ui can be solved optimally by applying Moore–Hodgson’s algorithm while adding unavailable time period (F  B) to the completion times of those jobs finished after B.

202

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

P When wiCi is concerned, Lee (1996) shows that the problem 1, P h1|r  a| wiCi is NP-hard even if wi = pi while the model without availability constraints can be solved by the WSPT rule. He shows that WSPT algorithm is optimal if there exists a job Ji with Ci = B in the WSPT schedule. And the WSPT rule and another combine-algorithm proposed in his paper all have an arbitrarily large worst-case error bound. A dynamic programming model is also developed to solve this problem optimally with the complexity of O(npmaxB). And for the proportional weight case (wi = pi), Lee (1996) shows that the combine-algorithm which combines the WSPT and the Largest Weight order has a tight relative worst-case error bound of RH 6 1. Later, a heuristic with a tight relative worst-case error bound of RH < 1 is proposed by Wang, Sun, and Chu (2005) for P the preemptive case (1, h1|pmtn| wiCi). P For multiple holes (1, hk|pmtn| wiCi), Wang et al. (2005) show that the problem is NP-hard in the strong sense and this problem P can be transformed into a 1|pmtn, ri| wiCi problem. And when wi = pi, they show that the LPT rule is a 2-approximation algorithm and the bound is tight.

Wu and Lee (2007) consider scheduling problem with learning effect and an availability constraint. The ‘‘learning effect” is the phenomenon that unit costs decline as firms produce more of a product and gain knowledge or experience. They assume that the actual processing time for job i is Pi = pi ja if it is scheduled in position j in a sequence, where pi denote the processing time for job i as in the classical scheduling problem and a<0 is the learning effect. It is shown that the SPT rule provides the optimal schedules for the makespan and the total completion time problems when jobs are resumable. When jobs are nonresumable, they use mixed integer programming techniques to solve the problems.

3. Parallel machine problems In this section, we review parallel machine problems with availability constraints. Most of the studies focus on offline algorithm, only very few studies involve online algorithms. 3.1. Problems with machine release times

2.3. Other cases with new settings As we show above, in the literature, two main cases are mainly considered: resumable and nonresumable cases. But the context that considered by Mauguière, Billaut, and Bouquard (2005) is more general. They consider three models with different assumptions concerning the operations: all operations are resumable; all operations are nonresumable; some operations are resumable and the others nonresumable (resumable/nonresumable). Furthermore, they assume that interrupting an operation may depend on the unavailability period. More precisely, an unavailability period that allows an operation to be interrupted and resumed after the period is called ‘‘crossable” while an unavailability period that prevents the interruption of any operation, even if the operation is resumable, is called ‘‘noncrossable”. They distinguish three cases: all unavailability periods are crossable; all unavailability periods are noncrossable; some unavailability periods are crossable and the others noncrossable. Depending on the types of operations and the type of unavailability periods, five problems are identified. They also assume each job i has a head (ri) and tail (qi). The aim is to minimize max(Ci + qi). They state that all these problems are strongly NP-hard and develop branch-and-bound procedures to solve the problem with the most general case: resumable/nonresumable operations and crossable/noncrossable unavailability periods (1, hk, cr/ncr|ri, rs/nrs, qi|max(Ci + qi), this notation is different from ours, the interested reader can refer to this paper. In above literature about single machine scheduling with availability constraint, job processing times are assumed to be constant for all jobs. But in some cases, things are different. Wu and Lee (2003) study a problem with deteriorating jobs (By a deteriorating job it means that the processing time of the job is a function of its starting time.) where Cmax is the objective (1, h1|r  a|Cmax), derive a way to solve this problem using the 0–1 integer programming technique. As nonresumable case is considered (1, hk|nr  a|Cmax), Gawiejnowicz (2007) show that the problem becomes NP-hard in the ordinary or in the strong sense depending on the number of holes. For nonresumable case and only one hole on the machine, Ji, He, and Cheng (2006) study two problems: minimizing makespan and total completion time problems. They show that both problems are NP-hard and present pseudo-polynomial time optimal algorithms to solve them. Furthermore, for the makespan problem, they present an optimal approximation algorithm for the on-line case, and a FPTAS for the off-line case. For the total completion time problem, they provide a heuristic and show that it is efficient in obtaining near-optimal solutions.

A special case of these problems is identical machine scheduling with machine release times. When Cmax is the objective, Lee (1991) shows that the classical LPT algorithm has a tight relative error RLPT 6 1/2  1/(2m), and provides a modified LPT (MLPT) algorithm with tight error RMLPT 6 1/3. In some cases, it is possible to have machines that will not process any jobs assigned in the current planning horizon. For example, if Bj is a very large number, then machine j may not process any job and hence is inactive in the current horizon. So, Lee (2000) points out that if there are some machines that do not process any job and hence is inactive in the planning horizon then the lower bound of makespan provided by Lee (1991) may not be a valid one. Furthermore, the error bound of LPT algorithm can be tightened if the number of active machines is smaller than the total number of machines. Chang and Hwang (1999) show that Lee’s 1/3 bound for the MLPT is tight by constructing a worst-case example, and show the MULTIFIT algorithm (based on the bin-packing heuristic algorithm called first-fit decreasing) has a relative worst-case error less than 2/7 + 2k, where k is the number of the major iterations in the algorithm. But the tightness of the bound for MULTIFIT is still an open question. Lin, He, Yao, and Lu (1997) show that the tight error bound of MLPT proposed by Lee (1991) is RMLPT 6 1/3, RMLPT 6 1/4 and RMLPT = 0 when m P 3, m = 2 and m = 1, respectively. In the same paper, they propose two other modified LPT algorithms called MLPT1 and MLPT2 to solve this problem. And they show that the tight error bound of MLPT1 is RMLPT1 6 1/2, RMLPT1 6 1/4 and RMLPT1 = 0 when m P 3, m = 2 and m = 1, respectively, and the tight error bound of MLPT2 is RMLPT2 6 1/2  1/(2m). In a study of Kellerer (1998), Lee’s bound of 1/3 is improved to 1/4 reached by a dual approximation algorithm using a bin packing approach. In the same paper, he also considers another criterion Cmin, he states that this problem is NP-hard, and presents a 2/3-algorithm. For the problems P2, h21|nr  a|Cmax and P2, h21|r  a|Cmax where B2 = 0, there are also exact algorithms. Liao, Shyur, and Lin (2005) treat the unavailability time as a dummy job with processing time F2 and then apply the TMO algorithm proposed for P2||Cmax directly. And Lin and Liao (2007) state that the problem P2, hj1|nr  a|Cmax with B1 = B2 = 0 is equivalent to the case where one machine starts at zero and the other starts at |F2  F1|, respectively. The latter case is actually the problem studied by Liao et al. (2005). When machine release times, job release dates, and delivery times are considered on identical parallel machines (n > m P 2) and Cmax is the objective, Gharbi and Haouari (2005) present an exact branch-and-bound algorithm for solving this problem. They show that embedding a semi-preemptive lower bound based on

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

max-flow computations in a branch-and-bound algorithm yields very promising performance. When unrelated machine problem are considered, Suresh and Chaudhuri (1996) consider the problem where each machine has several holes to minimize the makespan (Rm, hjk|nr  a|Cmax). They treat the unavailability period of a machine as a job to be done only on the machine and transfer this problem as an n + m jobs m machines problem, then formulate this problem into a linear program problem solved by the GAP-algorithm. P Without unavailability periods, the classical Pm|| Ci problem can be solved applying the SPT rule. Also the SPT rule is an optimal policy for multiple machines with machine release times (Pm, P hj1|| Ci, i may be one or some of the machines, Bj = 0 and Fj > Bj), as stated in (Schmidt, 2000). 3.2. Nonresumable cases For Cmax criterion, Lee (1996) considers the identical machine problem with the assumption that at least one machine is always available (i.e. there exists at least one j such that Bj = Fj = 0 and every other machine has one unavailable period). He states that this problem is NP-hard and shows that the relative worst-case errors of LS (List Scheduling) and LPT are m  1 and (m + 1)/2  1, respectively. Here LS assigns the first unprocessed job in the list to the machine such that the job can be completed the earliest, and LPT assigns jobs in the same way as LS except that the jobs are sorted in nonincreasing order of processing times before assignment. Hwang and Chang (1998), Hwang, Lee, and Chang (2005) analyze the worst-case performance of the LPT algorithm for the problem where each machine may have an unavailable interval with respect to Cmax criterion. They show that the actual factor which governs the worst-case behavior of LPT is not how many machines are allowed to be shutdown but how many machines are allowed to be shutdown simultaneously. Hwang and Chang (1998) show that the tight worst-case performance of LPT is RLPT 6 1 if the maximum number of machines that are simultaneously unavailable is bounded by m/2. Hwang et al. (2005) generalize this result. They suppose that arbitrary number k (1 6 k 6 m  1) machines are unavailable simultaneously and show that the makespan of LPT is never more than the tight worst-case bound of 1 + ½dm=ðm  kÞe times the optimum makespan, where dm=ðm  kÞe denotes the smallest integer that is not less than m/(m  k). When m = 2, Liao et al. (2005) provide an exact algorithm for the problem P2, h21|nr  a|Cmax by partitioning this problem into four sub-problems, each of which is solved optimally by an algorithm based on the TMO algorithm. Lin and Liao (2007) generalize these results by imposing the availability constraint on both machines (P2, hj1|nr  a|Cmax). They assume the two unavailable periods have the same length. According to the period in which the lower bound on makespan value occurs, they divide it into different cases and develop an algorithm based on lexicographic search to find an optimal solution for each of them. To the best of our knowledge, there is only one paper related to unrelated machines. A multi-pass heuristic is proposed by Suresh and Chaudhuri (1996) to solve the nonresumable problem where each machine has several holes to minimize the makespan (Rm, hjk|nr  a|Cmax). P P For Ci cretion, Lee and Liman (1993) consider the P2, h21|| Ci problem where one machine is available from time zero up to a fixed point in time after which it can no longer process any job (B2 > 0 and F2 = 1). They show that this problem is NP-hard and provide a pseudo-polynomial dynamic programming algorithm. They also propose a SPT-based heuristic with a tight relative error bound of 1/2. For fixed m, Mosheiov (1994) studies the similar problem under the condition that Mj is available in the time win-

203

dow [xj, yj], where 0 < xj < yj. He shows that the SPT rule is asymptotically optimal for the m-machine problem as the number of jobs P increases. When each job has a weight (P2, h21|nr  a| wiCi), Lee (1996) states that this problem is NP-hard and proposes a dynamic programming to solve it optimally. 3.3. Preemptive and resumable cases When all machines are only available in a same time interval, McNaughton (1959) proposes an O(n)-algorithm which generates at most m  1 preemptions to construct a feasible schedule so as to minimize the makespan (stated by Schmidt, 2000). If each machine has different availability intervals, Schmidt (1984) presents an O(nlog m)-algorithm to find a feasible preemptive schedule whenever one exists. Later Schmidt (1988) provides an O(nmlog m)-algorithm to solve a generalized problem where jobs may have different deadlines (stated by Lee et al., 1997; Schmidt, 2000). Lee (1996) shows that for the problem Pm, hj1|r  a|Cmax, if Bj > 0 for all j, then the relative error of the LPT algorithm can be arbitrary large even for m = 2. In this paper, Lee mainly considers the identical machine problem with the assumption that at least one machine is always available and every other machine has one unavailable period. He shows that the relative error of the LPT1 algorithm (the traditional LPT algorithm, i.e., assigning job to the minimum loaded machine) can be arbitrary large even for m = 2 and that LPT2 (assigning a job on the top of the list to a machine such that the finishing time of that job is minimized) has a tight worst-case error of 1/2(1  1/m). When one of the two machines is not available during a time period (P2, h21|r  a|Cmax), Liao et al. (2005) solve this problem by partitioning it into four sub-problems, each of which is solved optimally by an algorithm. P For wiCi criterion, Lee (1996) shows easily that the problem P P2, h21|r  a| wiCi is NP-hard and proposes a dynamic programming algorithm to solve it. _ Błazewicz, Drozdowski, Formanowicz, Kubiak, and Schmidt (2000) consider the problems of preemptive scheduling operations on parallel machines available in certain intervals only with makespan and maximum lateness objective functions. They sort availability patterns in a same way with Sanlaville and Schmidt (1998). In this paper, it is shown that the problem with a staircase pattern of availability is NP-hard in the strong sense for intrees. In the case of identical machines with a staircase pattern of availability, the problem can be solved in low-order polynomial time for Cmax criterion, and a linear programming approach is required for Lmax criterion. On the other hand, unrelated machines result in strong NP-hardness of the problem, even with two machines. Network flow and linear programming approaches are proposed for independent operations scheduled on, respectively, uniform and unrelated machines with arbitrary patterns of availability for makespan and maximum lateness criteria. When the problem is online, Tan and He (2002) consider two identical machines with machine availability constraints for minimizing makespan (P2, hj1|nr  a, online|Cmax). They show that the lower bound of the problem is q = 5/2 and LS is a 3-competitive algorithm. They further give an algorithm CLS with a competitive ratio of 5/2, which implies that it is an optimal online algorithm.

4. Flow shop problems There are a lot of studies on flow shop scheduling with availability constraints. And two-machine problems receive much attention, but multi-machine problems do not.

204

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

4.1. Two-machine problems To the best of our knowledge, all two-machine problems are studied with respect to makespan criterion. 4.1.1. Two-machine flow shop without storage constraints This is the traditional flow shop, i.e., there is unlimited storage between the machines so that, if a job is complete on M1, at the same time, M2 is processing another job, then this job will be stored until M2 completes another job. Then M2 begins to process it. 4.1.1.1. Preemptive and resumable cases. The two-machine flow shop scheduling problem with availability constraint is first studied by Lee (1997). He shows that the problem becomes NP-hard for two machines if there is a single hole on one machine only, while the classic flow shop problem F2||Cmax can be solved in polynomial time by JA. As far as the problem with only one availability constraint on M1 is concerned (F2, h11|r  a|Cmax), Lee (1997) proves that this problems is NP-hard in the ordinary sense and provides a dynamic programming algorithm to solve the problem optimally. Also, he shows that JA leads to a relative error bound of RJA 6 1. Later, Allaoui, Artiba, Elmaghraby, and Riane (2006) establish the conditions under which the JR yields the optimum, and demonstrate that in other cases its performance is bounded by RJR 6 1. For the same problem, Lee (1997) proposes an O(nlog n) time heuristic with a relative worst-case error bound of RH 6 1/2. But the problem of whether the bound is tight remains open. Later, Cheng and Wang (2000) show that this bound is tight, and develop an improved heuristic with a worst-case error bound of RH 6 1/3. Although they are not able to show that the bound is tight, they propose an instance to show that the bound cannot be better than 1/4. Then the bound is improved to 1/4 by Breit (2004). Ng and Kovalyov (2004) study the same problem, too. They first propose basic properties of an optimal schedule, then show that the problem is equivalent to similar partition type problem and derive a generic FPTAS with O(n5/q4) time complexity for the latter problem. When setup times are added into this problem, Wang and Cheng (2007a) and Wang and Cheng (2007b) develop a PTAS and a heuristic with the worst-case error bound of RJA 6 2/3, respectively to solve it. As far as the problem with an availability constraint on M2 only (F2, h21|r  a|Cmax) is concerned, Lee (1997) proves that the problem is NP-hard in the ordinary sense. He shows that JA leads to a relative error bound of RJA 6 1/2 and proposes an O(nlog n) time heuristic with a error bound of RH 6 1/3. Ng and Kovalyov (2004) consider the problem F2, h21|r  a|Cmax, too. Similar to the F2, h11|r  a|Cmax problem, they first propose basic properties of an optimal schedule and correct a minor flaw made in the paper by Lee (1997). Lee (1997) shows that there exists an optimal permutation for problem F2, h21|r  a|Cmax such that the set of jobs finished after F2 follows JR, and the remaining job set also follows JR, but Ng and Kovalyov (2004) show that there exists an optimal schedule that jobs started on M2 at or after F2 follows JR and the remaining jobs also follows JR. Then they show that the problem is equivalent to similar partition type problem and derive a generic FPTAS with O(n5/q4) time complexity for the latter problem. When setup times are added into this problem, Wang and Cheng (2007b) present a heuristic with the worst-case error bound of RJA 6 2/3 to solve it. Lee (1997) notes that the problem F2, h11|r  a|Cmax and the problem F2, h21|r  a|Cmax is not reversible, in the sense that interchanging job processing times on M1 and M2 will not yield an equivalent problem which is different from the standard flow shop problem. The preemptive variant of this problem (F2, h11|t  pmtn|Cmax) is concerned by Breit (2006). He presents a PTAS and extends this approach to the case with a hole on the second machine (F2, h21|t  pmtn|Cmax).

If each of machine has a hole, Lee (1997) shows that JA is optimal for the problem with machine release times (F2, hj1|r  a|Cmax with B1 = B2 = 0). When each machine may have an arbitrary number of holes (F2, _ Breit, Formanowicz, Kubiak, and Schmidt hjk|r  a|Cmax), Błazewicz, (2001) present two constructive heuristics (JR and a look-ahead heuristic which is based on local optimization) and one local search heuristic (simulated annealing algorithm) to solve it. The algorithms are tested on easy and difficult test problems with up to 100 jobs and 10 intervals of unavailability. The worst relative deviation from the optimum for easy and difficult instances was 2.6% and 44.4%, respectively. For many problems an optimal solu_ tion is found. Kubiak, Błazewicz, Formanowicz, Breit, and Schmidt (2002) consider the problem with several machine availability constraints on M1 only (F2, h1k|r  a|Cmax), M2 only (F2, h2k|r  a|Cmax), or on both machines (F2, hjk|r  a|Cmax). They show that the problem is NP-hard in the strong sense even if an arbitrary number of holes occur on one machine only. Moreover, they prove that if at least one hole is on the second machine, then there is no polynomial time heuristics with a constant relative error, unless P = NP. On the other hand, if all holes occur on M1, a simple heuristic based on Johnson order of jobs guarantees a relative error of R 6 1. They also prove two properties of optimal schedules and propose a branch-and-bound algorithm that uses them to prune the search tree. Computational experiment shows that the performance of the branch-and-bound algorithm is influenced by the number of holes in an instance. Kubzin, Potts, and Strusevich (2009) improve the R 6 1 error bound to R 6 1/2 by a fast heuristic for the problem when several holes occur on M1. Braun, Lai, Schmidt, and Sotskov (2002) study the question of whether Johnson’s permutation remains optimal if there are w P 1 unavailability intervals on M1 and M2 in the two-machine flow shop problem (F2, hjw|r  a|Cmax, note that, in this place w is a fixed positive integer, so this notation F2, hjw|r  a|Cmax here is different from F2, hjk|r  a|Cmax). It is well known that JA is optimal when all machines are continuously available (w = 0). In this paper, they derive sufficient conditions for the stability of this optimal permutation. 4.1.1.2. Semiresumable cases and nonresumable cases. As far as we know, only three papers consider the semiresumable case. Lee (1999) studies the problem with an availability constraint imposing on one machine (F2, h11|sr  a|Cmax and F2, h21|sr  a|Cmax) and both machines (F2, hj1|sr  a|Cmax), respectively. In this paper, he uses a parameter a to denote the fraction of an operation that need to be reprocessed after the machine is available, 0 6 a 6 1. He states that the semiresumable case contains two special cases: resumable (a = 0) and nonresumable case (a=1), and shows that JA is optimal for F2, hj1|sr  a|Cmax if B1 = B2 = 0. In this paper, he states that it can be shown that it is sufficient to consider the permutation solution if the availability constraint is imposed only on one machine, however, if availability constraints are imposed on both machines, it is possible that there does not exist any permutation solution to be optimal. But for the resumable case (F2, hj1|r  a|Cmax, a = 0), it is still sufficient to consider the permutation solution. For F2, h11|sr  a|Cmax, he provides dynamic programming algorithm to solve it and shows that JA leads to a tight relative error RJA 6 1.Then he develops a heuristic combining three simple greedy rules with JA and shows that this algorithm has a tight error bound of 1, i.e., he still could not improve the error bound for the nonresumable case. For F2, h21|sr  a|Cmax, he shows that JA leads to a tight relative error RJA 6 max{1/2, a} (it is shown that the tight error bound of JA to F2, h11|sr  a|Cmax is independent of the parameter a while it does depend on a if JA is applied to F2, h21|sr  a|Cmax). Similarly, he develops a JA-based heuristic which is independent of the value of a and has a worst-case error bound

205

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

of 1/2 to solve this problem. Furthermore, he shows that the general problem F2, hj1|sr  a|Cmax with a > 0 is NP-hard even if B1 = B2 and F1 = F2. And applying JA to the problem F2, hj1|sr  a|Cmax with B1 = B2 and F1 = F2 leads to the tight relative error of RJA 6 a. Then they deduce that JA is optimal for F2, hj1|r  a|Cmax if B1 = B2 and F1 = F2. For the F2, hj1|r  a|Cmax problem, he shows that if B1 – B2 this problem is NP-hard even if F1  B1 = F2  B2 and RJA can be arbitrarily large. Also for the problem F2, h21|sr  a|Cmax, Kubzin et al. (2009) give a PTAS to solve it. Cheng and Wang (1999) consider a special case of the problem F2, hj1|sr  a|Cmax: the two availability constraints are consecutive. Hence there are two cases: B2 = F1 and F2 = B1. They show that it is sufficient to consider permutation schedules for these two problems and establish some basic properties of an optimal schedule and then provide a heuristic with a tight worst-case error bound of RH 6 2/3 for the nonresumable case. When the nonresumable case is concerned, Allaoui et al. (2006) consider the problem with an availability constraint on M1 only (F2, h11|nr  a|Cmax). They propose an improved dynamic programming model over that proposed by Lee (1997), which is independent of the processing times of the jobs. This reduces the computational burden of the search for optimality drastically. They also specify the conditions under which JR gives the optimum and demonstrate that the worst-case error bound of JR is RJR 6 1. 4.1.2. Two-machine flow shop with storage constraints—no-wait flow shop There is a special environment in flow shop — the no-wait flow shop. In no-wait flow shop there is no possible storage between the

machines so that, the starting time of a job on the second machine has to be equal to the completion time of the same job on the first one, i.e., all jobs have to be processed continuously without waiting between consecutive machines. In the following, we consider the two-machine no-wait flow shop with availability constraints. And to simplify the notations, we add ‘‘no-wait’ in the second field to denote this special environment. Although the classical two-machine no-wait flow shop problem is polynomially solvable (see Gilmore & Gomory, 1964; Hall & Sriskandarajah, 1996), the problem with availability constraints is NP-hard even if only one hole occurs on one machine, and NPhard in the strong sense even if holes occur on only one machine, as shown in (Espinouse, Formanowlcz, & Penz, 1999, 2001). In these two papers, they provide an O(nlogn) heuristic based on Gilmore and Gomory’s algorithm (see Gilmore & Gomory, 1964) with a relative error of R 6 1 for the problem with one hole on M1 only for both resumable and nonresumable cases. Espinouse et al. (1999) show that Gilmore and Gomory’s algorithm (GGA) gives a solution to the problem F2, h21|no-wait, nr  a|Cmax with a relative error of RGGA 6 1. Later, they provide another heuristic algorithm for the problem with one hole on M2 for both resumable and nonresumable cases (Espinouse et al., 2001). The error of this algorithm is R 6 1 and this bound is asymptotically tight. Wang and Cheng (2001) proposed two improved algorithms for the two nonresumable models studied by Espinouse et al. (1999), and show that each algorithm has a worst-case error bound of 2/ 3. But the tightness of the bounds remains open. Cheng and Liu (2003a) present a PTAS for the nonresumable case when an unavailable interval is imposed on only one machine,

Table 1 Summary of complexity. Problem P 1, h1|| Ci with B = 0 P 1, h1|nr  a| Ci 1, h1|nr  a|Cmax 1, hk|nr  a|Cmax 1, hk|nr  a|Cmax with proportionally deteriorating jobs 1, h1|nr  a|Cmax with proportionally deteriorating jobs P 1, h1|nr  a| Ci with proportionally deteriorating jobs 1, h1|r  a|Cmax 1, h1|r  a|Lmax P 1, h1|r  a|| Ci P 1, h1|r  a|| Ui P 1, h1|r  a| wiCi P 1, hk|pmtn| wiCi 1, h1|r  a|Cmax with learning effect P 1, h1|r  a| Ci with learning effect P Pm, hj1|| Ci, j may be one or some of the machines, Bj = 0 and Fj > Bj P P2, h21|| Ci with B2 > 0 and F2 = 1 P Pm, hj1|| Ci when Mj is available in [xj, yj] F2, h11|r  a|Cmax F2, h21|r  a|Cmax F2, hj1|r  a|Cmax with B1 = B2 = 0 F2, hj1|r  a|Cmax with B1 – B2 F2, hj1|sr  a|Cmax with B1 = B2 = 0 F2, hj1|sr  a|Cmax with a > 0 F2, h1k|r  a|Cmax F2, h2k|r  a|Cmax F2, h11|nr  a, no-wait |Cmax F2, h11|r  a, no-wait|Cmax F2, h21|nr  a, no-wait|Cmax F2, h21|r  a, no-wait|Cmax F2, hjk|nr  a, no-wait|Cmax F2, hjk|r  a, no-wait|Cmax F2, h11|sr  a, no-wait|Cmax F2, h21|sr  a, no-wait|Cmax F2(P), hik,1|(m1 = 1, m2 = m), nr  a|Cmax, k may be one or some of the machines O2, h21|t  pmtn|Cmax with B = 0 O2, h21|t  pmtn|Cmax

Complexity

References

P, (SPT) NP-hard NP-hard NP-hard NP-hard NP-hard NP-hard P (any sequence) P (EDD) P (SPT) P (Moore–Hodgson’s algorithm) NP-hard even if wi = pi strongly NP-hard P (SPT) P (SPT) P (SPT) NP-hard P (SPT) Weakly NP-hard Weakly NP-hard P, (JA) NP-hard P, (JA) NP-hard Strongly NP-hard Strongly NP-hard NP-hard NP-hard NP-hard NP-hard Strongly NP-hard Strongly NP-hard NP-hard NP-hard Strongly NP-hard P, (O(n) time) NP-hard

Lee (1996) Adiri et al. (1989), Lee and Liman (1992) Lee (1996) Lee (1996) Gawiejnowicz (2007) Ji et al. (2006) Ji et al. (2006) Lee (1996) Lee (1996) Lee (1996) Lee (1996) Lee (1996) Wang et al. (2005) Wu and Lee (2007) Wu and Lee (2007) Schmidt (2000) Lee and Liman (1993) Mosheiov (1994) Lee (1997) Lee (1997) Lee (1997) Lee (1999) Lee (1999) Lee (1999) Kubiak et al. (2002) Kubiak et al. (2002) Espinouse et al. (1999, 2001) Espinouse et al. (1999, 2001) Espinouse et al. (1999, 2001) Espinouse et al. (1999, 2001) Espinouse et al. (1999, 2001) Espinouse et al. (1999, 2001) Kubzin and Strusevich (2004) Kubzin and Strusevich (2004) Allaoui and Artiba (2006) Allaoui and Artiba (2006) Breit et al. (2001)

206

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

Table 2 Summary of approximation algorithms. Problem 1, h1|nr  a|

P Ci

1, h1|nr  a|

P wiCi

1, 1, 1, 1,

h1|nr  a|Cmax h1|nr  a|Cmax with linear deteriorating jobs P h1|nr  a| Ci with linear deteriorating jobs h1|nr  a, qi|Cmax

P 1, h1|nr  a| Ui 1, h1|nr  a|Lmax 1, hk|nr  a|Tmax with periodic holes P 1, h1|r  a| wiCi P 1, h1|r  a| wiCi with wi = pi P 1, h1|pmtn| wiCi P 1, hk|pmtn| wiCi with wi = pi Pm, hj1||Cmax, j may be one or some of the machines, Bj = 0 and Fj > Bj

Approximation algorithm

Algorithm performance

References

SPT MSPT Parametric algorithm PTAS

R 6 2/7 R 6 3/17 R = 0.31%, Rmax = 3.18% O(n2k + 1), where k is a local search procedure parameter R = +1 even if wi = pi R 6 2 under some conditions R61 R 6 1/3 O(n2/e) Near-optimal R 6 1/2 O(n3/e2), where e > 0 A=1 A = pmax P O(n2 pi), near-optimal R = +1 R61 R<1 R61 R 6 1/2  1/(2 m)

Lee and Liman (1992) Sadfi et al. (2005) Breit (2007) He et al. (2006)

WSPT WSPT and MWSPT Heuristic LPT FPTAS Heuristic Heuristic FPTAS Moore and Hodgson’s algorithm EDD Heuristic based on bin-packing WSPT and another combine-algorithm Combine-algorithm Heuristic LPT LPT MLPT

MLPT2 Dual approximation Dual approximation

R 6 1/3 R 6 1/3, R 6 1/4 and R = 0 when m P 3, m = 2 and m = 1, respectively R 6 2/7 + 2k R 6 1/2, R 6 1/4 and R = 0 when m P 3, m = 2 and m = 1, respectively R 6 1/2  1/(2 m) R 6 1/4 R 6 2/3

LS

R6m1

Lee (1996)

LPT LPT

R 6 [(m + 1)/2]  1 R 6 1 under some conditions

Lee (1996) Hwang and Chang (1998)

LPT Multi-pass heuristic SPT-based algorithm LPT LPT

R 6 1/2dm=ðm  kÞe 40 jobs and 10 machines R 6 1/2 R = +1 even if m = 2 R = +1 even if m = 2

Hwang et al. (2005) Suresh and Chaudhuri (1996) Lee and Liman (1993) Lee (1996) Lee (1996)

LPT2 JA Heuristic Heuristic Heuristic FPTAS PTAS Heuristic PTAS JA Heuristic FPTAS Heuristic JR, look-ahead heuristic and simulated annealing Heuristic Heuristic JA heuristic combining three greedy rules with JA JA JA-based heuristic PTAS

R 6 1/2(1  1/m) R61 R 6 1/2 R 6 1/3 R 6 1/4 O(n5/q4) O(n log n) R 6 2/3 O(n log n) R 6 1/2 R 6 1/3 O(n5/q4) R 6 2/3 Reasy 6 2.6%, Rdifficult 6 44.4%

Lee (1996) Lee (1997), Allaoui et al. (2006) Lee (1997) Cheng and Wang (2000) Breit (2004) Ng and Kovalyov (2004) Wang and Cheng (2007a) Wang and Cheng (2007b) Breit (2006) Lee (1997) Lee (1997) Ng and Kovalyov (2004) Wang and Cheng (2007b) _ Błazewicz et al. (2001)

R61 R 6 1/2 R61 R61 R 6 max{1/2, a} R 6 1/2 A polynomial of ns and nb, where ns and nb denote the number of small and big jobs, respectively R6a R 6 2/3 R61 R61 R 6 2/3

Kubiak et al. (2002) Kubzin et al. (2009) Lee (1999) Lee (1999) Lee (1999) Lee (1999) Kubzin et al. (2009)

MULTIFIT MLPT1

Pm, hj1||Cmin, j may be one or some of the machines, Bj = 0 and Fj > Bj Pm, hj1|nr  a|Cmax, j may be one or some of the machines, and at least one machine is always available Pm, hj1|nr  a|Cmax, j may be one or some of the machines Rm, hjk|nr  a|Cmax P P2, h21|| Ci with B2 > 0 and F2 = 1 Pm, hj1|r  a|Cmax Pm, hj1|r  a|Cmax, j may be one or some of the machines, and at least one machine is always available F2, h11|r  a|Cmax

F2, h11|r  a|Cmax with setup times F2, h11|t  pmtn|Cmax and F2, h21|t  pmtn|Cmax F2, h21|r  a|Cmax

F2, h21|r  a|Cmax with setup times F2, hjk|r  a|Cmax F2, h1k|r  a|Cmax F2, h11|sr  a|Cmax F2, h21|sr  a|Cmax

F2, F2, F2, F2,

hj1|sr  a|Cmax with B1 = B2 and F1 = F2 hj1|sr  a|Cmax with two consecutive holes h11|nr  a|Cmax h21|nr  a, no-wait|Cmax

Lee (1996) Kacem and Chu (2008a) Kacem (2008) Lee (1996) Ji et al. (2006) Ji et al. (2006) Kacem (2009) Kacem (2009) Lee (1996) Lee (1996) Liao and Chen (2003) Lee (1996) Lee (1996) Wang et al. (2005) Wang et al. (2005) Lee (1991)

JA heuristic JR GGA GGA-based heuristic

Lee (1991) Lin et al. (1997) Chang and Hwang (1999) Lin et al. (1997) Lin et al. (1997) Kellerer (1998) Kellerer (1998)

Lee (1999) Cheng and Wang (1999) Allaoui et al. (2006) Espinouse et al. (1999) Wang and Cheng (2001)

207

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211 Table 2 (continued) Problem

F2, h11|nr  a, no-wait|Cmax

F2, h11|r  a, no-wait|Cmax F2, h21|r  a, no-wait|Cmax F2, h11|nr  a, no-wait|Cmax F2, h21|nr  a, no-wait|Cmax F2, hj1|nr  a, no-wait|Cmax with B1 < F2 and B2 6 F1 or with B1 = F2 F2, hj1|nr  a, no-wait|Cmax with B1 < F2 and B2 6 F1 F2, h21|nr  a, no-wait|Cmax F2, h21|r  a, no-wait|Cmax F2, h21|sr  a, no-wait|Cmax F2, h21|r  a, no-wait|Cmax Fm, hjk|nr  a|Cmax

Approximation algorithm

Algorithm performance

References

GGA-based heuristic GGA-based GGA-based heuristic GGA-based GGA-based

R61 R 6 1/2 R61 R 6 2/3 R 6 1/2 R61 R61

Espinouse et al. (2001) Cheng and Liu (2003b) Espinouse et al. (1999, 2001) Wang and Cheng (2001) Cheng and Liu (2003b) Espinouse et al. (2001) Espinouse et al. (2001)

O(2|L|n2log n), where |L| is the number of large jobs R 6 1/2

Cheng and Liu (2003a)

Kubzin and Strusevich (2004) Kubzin and Strusevich (2004) Aggoune (2004)

List scheduling

R 6 1/2 R 6 1/3 20 jobs and 10 machines, nearoptimal outperforms the one proposed in Aggoune (2004) R61+m

LPT Heuristic List scheduling LPT Heuristic

R 6 1 + m/2 R 6 3  1/m R 6 3  1/m R 6 5/2  1/m R62

Allaoui and Artiba (2006) Allaoui and Artiba (2006) Xie and Wang (2005) Xie and Wang (2005) Xie and Wang (2005)

Heuristic PTAS PTAS Heuristic Heuristic Heuristic Heuristic

R 6 1/3 O(n) O(n) R61 R 6 1/3 Effective Effective

Breit et al. (2001) Kubzin et al. (2005) Kubzin et al. (2005) Breit et al. (2003) Breit et al. (2003) Zribi (2005) Zribi et al. (2008)

heuristic heuristic heuristic heuristic heuristic

PTAS Heuristic

Heuristic Heuristic Heuristic Heuristic

F2(P), hik,1|(m1 = 1, m2 = m), nr  a|Cmax, k may be one or some of the machines

F2(P), h11,1|(m1 = 1, m2 = mP2), r  a|Cmax F2(P), h1k,1|(m1 = mP2, m2 = 1), r  a|Cmax where at any time the number of unavailable machines does not exceed one half of the number of the machines at the first stage O2, h21|t  pmtn|Cmax O2, h2k|t  pmtn|Cmax O2, hj1|t  pmtn|Cmax O2, hi1|nr  a|Cmax O2, h21|nr  a|Cmax Jm(F), hjk||Cmax Jm(MPM), hjk|ri|Cmax

or the unavailable intervals on the two machines overlap. And they show that the problem with the unavailable intervals [B1, F1] and [B2, F2] has a PTAS if B1 < F2 and B2 6 F1, or B1 = +1, or B2 = +1. If B1 = F2, this problem has a PTAS, too. But the approximation scheme is interesting only in theory since its complexity contains a huge coefficient whose value depends on the accuracy desired. So later they propose 3/2-approximation algorithms which are more efficient in practice for these three same problems (Cheng & Liu, 2003b). The complexity of all three algorithm is O(n2log n). But if B2 6 B1 < F2, the complexity of the algorithm for the problem where unavailable intervals on the two machines overlap reduces to O(nlog n). Kubzin and Strusevich (2004) consider the problem with a single hole. They consider three cases: resumable, nonresumable or semiresumable. They show that the problem with a hole on M1 is NP-hard irrespective the case and this conclusion can easily be modified for the case of the hole on M2. For the problem with a hole on M2, they present an approximation algorithm for all these cases with a worst-case error of 1/2. And they offer a 4/3-approximation algorithm for F2, h21|r  a, no-wait|Cmax. 4.2. Multi-machine problems Aggoune (2004) considers a problem with several unavailability periods on each machine (Fm, hjk|nr  a|Cmax). Since the problem is NP-hard in the strong sense, a heuristic approach based on a genetic algorithm and a tabu search is proposed to approximately solve the problem. Later, Aggoune and Portmann (2006) present a temporized geometric approach to solve the problem with two jobs.

Cheng and Liu (2003b)

Aggoune and Portmann (2006) Allaoui and Artiba (2006)

Based on this polynomial algorithm, they propose a heuristic to approximately solve the problem with more than two jobs. Some papers are related to hybrid flow shop problem. Hybrid flow shop is a mixture of the serial shop organization and the parallel shop organization. It consists of a set of u stages with each stage i (1 6 i 6 u) having mi parallel machines with the property that all jobs have to be processed through all the stages on the same order. The jth machine at the stage i is denoted by Mij. The notation of problem is modified accordingly in this section, since it is easy to know its meaning, we do not detail this modification here and refer the interested reader to Lee and Vairaktarakis (1994). The nonresumable case of a two-stage problem with only one machine on the first stage and m machines on the second stage to minimize the makespan (F2(P), hik,1|(m1 = 1, m2 = m), nr  a|Cmax, k may be one or some of the machines) is investigated by Allaoui and Artiba (2006). They assume that each machine is subject to at most one unavailability period. They show that this problem is NP-hard in the strong sense and no PTAS exists unless P = NP even if there is no machine on the second stage which is always available. To solve optimally the small size problems they propose a branch-and-bound algorithm. For large size problems, the performance of three heuristics are given: List scheduling, LPT (sort the set of jobs according to the processing times on the first stage in nonincreasing order, and then use the list scheduling) and H heuristic proposed by Lee and Vairaktarakis (1994) for the hybrid flow shop without availability constraints. It is shown that RLS 6 1 + m and RLPT 6 1 + m/2, while RH 6 3  1/m. But they show that the tightness of heuristic performances is still open. They also prove

208

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

Table 3 Summary of exact algorithms. Problem 1, h1|nr  a|

P wiCi

1, h1|nr  a, qi|Cmax 1, h1|nr  a|Cmax with linear deteriorating jobs 1, h1|nr  a, on-line|Cmax with linear deteriorating jobs P 1, h1|nr  a| Ci with linear deteriorating jobs 1, hk|ri|Lmax 1, hk|ri|Lmax with dependent setup times 1, hk|nr  a|Tmax with periodic holes P 1, h1|r  a| wiCi 1, hk, cr/ncr|ri, rs/nrs, qi |max(Ci+qi) Pm, hj1|ri|Cmax (j may be one or some of the machines, Bj = 0 and Fj > Bj) involving delivery times P2, h21|nr  a|Cmax P2, P2, P2, P2,

hj1|nr  a|Cmax P h21|| Ci where B2 > 0 and F2 = 1 P h21|nr  a| wiCi h11|r  a|Cmax

P P2, h21|r  a| wiCi P2, hj1|nr  a, online|Cmax F2, h11|r  a|Cmax F2, h11|sr  a|Cmax F2, hjk|r  a|Cmax F2, h11|nr  a|Cmax F2(P), hik,1|(m1 = 1, m2 = k), nr  a|Cmax, k may be one or some of the machines Jm, hjk|ri, qi |max(Ci + qi) Jm, hjk|r  a|Cmax

Exact algorithm

Solvable problem size

References

Branch-and-bound

1000 jobs

Mixed-integer linear programming Dynamic programming Dynamic programming Pseudo-polynomial algorithm based on dynamic programming LS Pseudo-polynomial algorithm based on dynamic programming Branch-and-bound Branch-and-bound Branch-and-bound Dynamic programming Branch-and-bound Branch-and-bound

60 jobs O(nB2),3000 jobs O(nB) O(n(B  t0)), where t0 is the machine release time c = B/t0 O(n(B  t0)Y), where Y is the sum of parameters 50 jobs 50 jobs 30 jobs O(n pmaxB) 1000 jobs 700 jobs and 20 machines

Kacem and Chu (2008b), Kacem et al. (2008) Kacem et al. (2008) Kacem et al. (2008) Kacem (2009) Ji et al. (2006)

Decomposition with sub-problems solved optimally by a TMO-based algorithm TMO-based algorithm Dynamic programming Dynamic programming Decomposition with sub-problems solved optimally by a TMO-based algorithm Dynamic programming CLS Dynamic programming Dynamic programming Branch-and-bound Dynamic programming Branch-and-bound

100 jobs

Liao et al. (2005)

1000 jobs O(nB2) P O(nB2 pi) 100 jobs

Lin and Liao (2007) Lee and Liman (1993) Lee (1996) Liao et al. (2005)

P O(nB2 pmax pi) c = q = 2/5 O(nMSMSB1pmax,1)a O(nMSMSB1pmax,1) 100 jobs and 10 holes Oð2n1 n log nÞb Small size problem

Lee (1996) Tan and He (2002) Lee (1997) Lee (1999) Kubiak et al. (2002) Allaoui et al. (2006) Allaoui and Artiba (2006)

Branch-and-bound Branch-and-bound

Effective Effective

Jm, hjk|rs/nrs|Cmax

Branch-and-bound

Effective

Jm, hjk, cr/ncr|rs/nrs|Cmax

Branch-and-bound

Effective

a b

Ji et al. (2006) Ji et al. (2006) Leon and Wu (1992) Asano and Ohta (1999) Liao and Chen (2003) Lee (1996) Mauguière et al. (2005) Gharbi and Haouari (2005)

Aggoune (2002) Mauguière, Bouquard, and Billaut (2003) Mauguière, Billaut, and Bouquard (2003) Mauguie˙re et al. (2005)

P Where MS = (pi1 + pi2) P JA, JA denote the makespan obtained by JA, pmax,1 = max{pi1}. Where n1 is the sequence number of a particular job.

that in the worst-case H heuristic performance is better than LPT heuristic performance if and only if m P 4. Xie and Wang (2005) consider the resumable case of the problem where there is only one hole on the only machine at the first stage and no holes on the second m2 machines (F2(P), h11,1|(m1 = 1, m2 = m P 2), r  a|Cmax). They show that the worstcase error bound of the List Scheduling and LPT algorithm is RLS 6 3  1/m, RLPT 6 5/2  1/m, respectively, and these bounds are tight. When there are m machines at the first stage and one hole may be on each of them, and only one machine at the second stage and no holes on it (F2(P), h1k,1|(m1 = m P 2, m2 = 1), r  a|Cmax), they provide an algorithm with an error bound of RH 6 2 for the special case where at any time the number of unavailable machines does not exceed one half of the number of the machines (at the first stage). A u-stage hybrid flow shop with each stage i (1 6 i 6 u) having mi parallel machines with availability constraints is considered by Allaoui and Artiba (2004) under the criteria based on flow time and due date (maximum completion time, mean completion time, mean waiting time, mean tardiness, maximum tardiness, mean flow time and the number of tardy jobs). Setup, cleaning and transportation times are also considered. They illustrate an approach integrating the simulation and the optimization. Three dispatching rules LPT, SPT and EDD, the simulated annealing (SA) heuristic and a flexible simulation model are used to construct this approach. First, the experimental study of the three heuristics SA (LPT), SA (SPT) and SA (EDD) reveals that, in resumable case the perfor-

mance of such heuristics can be affected by the percentage of the repair time only when due date based criteria are considered. However, in nonresumable case both flow time and due date based criteria depend on this factor. Secondly, it reveals that in both resumable and nonresumable cases, this approach can perform better than NEH heuristic (see Nawaz, Enscore, & Ham, 1983) under certain conditions.

5. Open shop problems As the same with flow shop, the majority of literature on this subject is focused on two-machine case and the objective of makespan optimization. For problems with continuously available machines O2|pmtn|Cmax and O2|t  pmtn|Cmax, a schedule found by the Gonzalez–Sahni algorithm (see Gonzalez & Sahni, 1976) is optimal. And in case of a single hole and machine release time, the O2, h21|t  pmtn|Cmax with B = 0 problem is shown to be solvable in O(n) time by Lu and Posner (1993). For the O2, h21|t  pmtn|Cmax problem, Breit, Schmidt, and Strusevich (2001) show that this problem is NP-hard and demonstrate that a straightforward application of the Gonzalez–Sahni algorithm to this problem may lead to an arbitrarily bad schedule. Based on these, they present their approximation algorithm with a tight relative error of RH 6 1/3. For multiple holes, Breit et al. (2001) show that the two-machine problem with arbitrary number of holes on one machine

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

(O2, h2k|t  pmtn|Cmax) admits a linear-time algorithm that provides a relative worst-case error of 1. And a PTAS for this problem is proposed by Kubzin, Strusevich, Breit, and Schmidt (2005). Problems with a more general structure of the non-availability intervals are not approximable in polynomial time within a constant factor, unless P = NP. For example, as mentioned in (Breit et al., 2001), the problem with one hole on one machine and two holes on the other machine cannot be approximated in polynomial time within a constant factor. And this result can easily be extended to the problem with a fixed number of the machines and arbitrarily many holes on one of them. The problem with one unavailability interval on each machine (O2, hj1|t  pmtn|Cmax) is considered by Kubzin et al. (2005). They present a PTAS to solve it. When m = 3, problem O3|t  pmtn|Cmax is NP-hard, as stated in (Cho & Sahni, 1981). And Kubzin et al. (2005) state that it is not difficult to prove that the O3, hj1|t  pmtn|Cmax is not approximable in polynomial time unless P = NP. For arbitrary preemptive case, the Om|pmtn|Cmax problem is polynomially solvable, as shown in (Gonzalez & Sahni, 1976; Lawler & Labetoulle, 1978; Vairaktarakis & Sahni, 1995). And Vairaktarakis and Sahni (1995) show that an extension of problem Om|pmtn|Cmax remains polynomially solvable provided that each machine has an arbitrary number of unavailability intervals. If preemption is not allowed, the O2||Cmax problem is solvable in O(n) time, while the O3||Cmax is NP-hard in the ordinary sense, as shown in (Gonzalez & Sahni, 1976). And for problems with availability constraints, Breit et al. (2003) show that each of the problems O2, h12|nr  a|Cmax and O2, h22|nr  a|Cmax cannot be approximated in polynomial time within a constant factor unless P = NP, while the problem O2, hi1|nr  a|Cmax admits a 2-approximation algorithm. An approximation algorithm with a tight error bound of RH 6 1/3 is presented for the problem O2, h21|nr  a|Cmax. And it remains unknown whether the problem admits a FPTAS or a PTAS in the case of a single hole or two holes, one on each machine.

6. Job shop problems In job shop environment, scheduling problems with deterministic availability constraints become extremely complex. So there are only several papers studying it. Aggoune (2002) proposes a branchand-bound algorithm with lower bound based on two-job decomposition for the problem with heads, and tails (Jm, hjk|ri, qi |max(Ci + qi)). Zribi (2005) propose an integrated approach based on the exact resolution of the two job and using an extension of the geometric approach to solve the classical flexible job shop problems (Jm(F), hjk||Cmax). A generalization problem – the multipurpose machine problem with availability constraints (Jm(MPM), hjk|ri|Cmax) is considered by Zribi, Kamel, and Borne (2008). They propose a two-phase heuristic method to solve this problem. In the first phase, a heuristic based on priority rules to solve the assignment problem is developed. A local search algorithm is then introduced to improve this solution. In the second phase, a genetic algorithm is proposed to solve the sequencing problem. A branch-and-bound algorithm is proposed in (Mauguière, Bouquard, & Billaut, 2003) to solve the resumable case of the job shop problem (Jm, hjk|r  a|Cmax) and in (Mauguière, Billaut, Bouquard, 2003) they also propose a branch-and-bound algorithm to solve the case where some jobs are resumable, and others are nonresumable (Jm, hjk|rs/nrs|Cmax). Later, Mauguie˙re, Billaut, and Bouquard (2005) propose a generalization algorithm to solve the general problem where only some unavailability periods are crossable and some jobs are resumable, other periods are non-crossable and other jobs are nonresumable (Jm, hjk, cr/ncr|rs/nrs|Cmax).

209

7. Conclusions In this paper, we survey briefly machine scheduling with deterministic availability constraints. We sort problems according to their machine environment and distinguish between nonpreemptive and preemptive scheduling (resumable, nonresumable and semiresumable case). We try to summarize most of the results reviewed in this paper in Table 1, Tables 2 and 3. Table 1 lists problem complexity. As far as we know, a complex problem is obviously NP-hard if its simpler counterpart is already NP-hard. So in this paper, what we need is to summarize the complexity of simplest model. And if a problem is polynomially solvable (P), we give its algorithm in brackets. Approximation algorithms are summarized in Table 2. For off-line problems, we summarize their algorithm performances by listing their worst-case errors. If an algorithm’s worst-case error has not been analyzed by the authors, we draw its time complexity for substitute. For on-line problems, competitive ratio is given. Table 3 summarizes exact algorithms. The problem size these algorithms can solve or time complexity is summarized in this table. Form previous survey, we can see that almost all results are concentrated on the offline version of problems, little is known about the online version of the corresponding problems. However, in real industry, online version often happens. So it is worthwhile to develop algorithms to solve the online problems in the future. Because of their fundamental character and simplicity, single machine and parallel machine scheduling problems under different criteria have been extensively studied. And many of them can be solved optimally. But for flow shop problems, only makespan criterion has been studied widely. So future research might focus on other criteria such as the total flow time, the total lateness, the sum of the weighted completion times, the maximum lateness, the maximum tardiness and the number of tardy jobs, as they are practical in the industry. For flow shop problems, most papers only deals with two machines, extending the existing models to more machines and more complicated job shop and open shop problems is also an interesting research direction. Although semiresumable case is important as it happens often in industry, there are only a few papers in the scheduling area that deal with this case. So a next step in research could be to design algorithms for this case. Acknowledgement The authors thank the partial support by the NSFC under Grant 70631003 and 90718037, and the Doctoral Fund of Ministry of Education of China under Grant 200803590007. And the authors would like to thank the editors and reviewers for their constructive comments and recommendations. References Adiri, I., Bruno, J., Frostig, E., & Rinnooy Kan, A. H. G. (1989). Single machine flowtime scheduling with a single breakdown. Acta Informatica, 26, 679–696. Aggoune, R. (2002). Ordonnancement d’Ateliers sous Contraintes de Disponibilite0 des Machines. Ph.D. Thesis, Universite0 de Metz, France. Aggoune, R. (2004). Minimizing the makespan for the flow shop scheduling problem with availability constraints. European Journal of Operational Research, 153, 534–543. Aggoune, R., & Portmann, M.-C. (2006). Flow shop scheduling problem with limited machine availability: A heuristic approach. International Journal of Production Economics, 99, 4–15. Allaoui, A., & Artiba, A. (2004). Integrating simulation and optimization to schedule a hybrid flow shop with maintenance constraints. Computers & Industrial Engineering, 47, 431–450. Allaoui, A., & Artiba, A. (2006). Scheduling two-stage hybrid flow shop with availability constraints. Computers & Operations Research, 33, 1399–1419.

210

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211

Allaoui, A., Artiba, A., Elmaghraby, S. E., & Riane, F. (2006). Scheduling of a twomachine flowshop with availability constraints on the first machine. International Journal of Production Economics, 99, 16–27. Asano, M., & Ohta, H. (1999). Scheduling with shutdowns and sequence dependent set-up times. International Journal of Production Research, 37, 1661–1676. _ Błazewicz, J., Breit, J., Formanowicz, P., Kubiak, W., & Schmidt, G. (2001). Heuristic algorithms for the two-machine flowshop with limited machine availability. Omega, 29, 599–608. _ Błazewicz, J., Drozdowski, M., Formanowicz, P., Kubiak, W., & Schmidt, G. (2000). Scheduling preemptable tasks on parallel processors with limited availability. Parallel Computing, 26, 1195–1211. Braun, O., Lai, T.-C., Schmidt, G., & Sotskov, Y. N. (2002). Stability of Johnson’s schedule with respect to limited machine availability. International Journal of Production Research, 40, 4381–4400. Breit, J. (2004). An improved approximation algorithm for two-machine flow shop scheduling with an availability constraint. Information Processing Letters, 90, 273–278. Breit, J. (2006). A polynomial-time approximation scheme for the two-machine flow shop scheduling problem with an availability constraint. Computers & Operations Research, 33, 2143–2153. Breit, J. (2007). Improved approximation for non-preemptive single machine flowtime scheduling with an availability constraint. European Journal of Operational Research, 183, 516–524. Breit, J., Schmidt, G., & Strusevich, V. A. (2001). Two-machine open shop scheduling with an availability constraint. Operations Research Letters, 29, 65–77. Breit, J., Schmidt, G., & Strusevich, V. A. (2003). Non-preemptive two-machine open shop scheduling with non-availability constraints. Mathematical Methods of Operations Research, 57, 217–234. Chang, S. Y., & Hwang, H.-C. (1999). The worst-case analysis of the MULTIFIT algorithm for scheduling non-simultaneous parallel machines. Discrete Applied Mathematics, 92, 135–147. Cheng, T. C. E., & Liu, Z. (2003a). Approximability of two-machine no-wait flowshop scheduling with availability constraints. Operations Research Letters, 31, 319–322. Cheng, T. C. E., & Liu, Z. (2003b). 3/2-approximation for two-machine no-wait flowshop scheduling with availability constraints. Information Processing Letters, 88, 161–165. Cheng, T. C. E., & Wang, G. (1999). Two-machine flowshop scheduling with consecutive availability constraints. Information Processing Letters, 71, 49–54. Cheng, T. C. E., & Wang, G. (2000). An improved heuristic for two-machine flowshop scheduling with an availability constraint. Operations Research Letters, 26, 223–229. Cho, Y., & Sahni, S. (1981). Preemptive scheduling of independent jobs with release and due dates times on open, flow and job shop. Operations Research, 29, 511–522. Espinouse, M. L., Formanowlcz, P., & Penz, B. (1999). Minimizing the makespan in the two-machine no-wait flow-shop with limited machine availability. Computers & Industrial Engineering, 37, 497–500. Espinouse, M. L., Formanowlcz, P., & Penz, B. (2001). Complexity results and approximation algorithms for the two-machine no-wait flow-shop with limited machine availability. Journal of the Operational Research Society, 52, 116–121. Gharbi, A., & Haouari, M. (2005). Optimal parallel machines scheduling with availability constraints. Discrete Applied Mathematics, 148, 63–87. Gilmore, P. C., & Gomory, R. E. (1964). Sequencing a one-state-variable machine: A solvable case of the travelling salesman problem. Operations Research, 12, 655–679. Gonzalez, T., & Sahni, S. (1976). Open shop scheduling to minimize finish time. Journal of the Association for Computing Machinery, 23, 665–679. Hall, N. G., & Sriskandarajah, C. (1996). A survey of machine scheduling problems with blocking and no-wait in process. Operations Research, 44, 510–525. He, Y., Zhong, W., & Gu, H. (2006). Improved algorithms for two single machine scheduling problems. Theoretical Computer Science, 363, 257–265. Hwang, H.-C., & Chang, S. Y. (1998). Parallel machines scheduling with machine shutdowns. Computers and Mathematics with Applications, 36, 21–31. Hwang, H.-C., Lee, K., & Chang, S. Y. (2005). The effect of machine availability on the worst-case performance of LPT. Discrete Applied Mathematics, 148, 49–61. Ibarra, O., & Kim, C. E. (1975). Fast approximation algorithms for the knapsack and sum of subset problems. Journal of the Association for Computing Machinery, 22, 463–468. Ji, M., He, Y., & Cheng, T. C. E. (2006). Scheduling linear deteriorating jobs with an availability constraint on a single machine. Theoretical Computer Science, 362, 115–126. Kacem, I. (2008). Approximation algorithm for the weighted flow-time minimization on a single machine with a fixed non-availability interval. Computers & Industrial Engineering, 54, 401–410. Kacem, I. (2009). Approximation algorithms for the makespan minimization with positive tails on a single machine with a fixed nonavailability interval. Journal of Combinatorial Optimization, 17, 117–133. Kacem, I., & Chu, C. (2008a). Worst-case analysis of the WSPT and MWSPT rules for single machine scheduling with one planned setup period. European Journal of Operational Research, 187, 1080–1089. Kacem, I., & Chu, C. (2008b). Efficient branch-and-bound algorithm for minimizing the weighted sum of completion times on a single machine with one availability constraint. International Journal of Production Economics, 112, 138–150. Kacem, I., Chu, C., & Souissi, A. (2008). Single-machine scheduling with an availability constraint to minimize the weighted sum of the completion times. Computers & Operations Research, 35(3), 827–844.

Kellerer, H. (1998). Algorithms for multiprocessor scheduling with machine release times. IIE Transactions, 30, 991–999. _ Kubiak, W., Błazewicz, J., Formanowicz, P., Breit, J., & Schmidt, G. (2002). Twomachine flow shops with limited machine availability. European Journal of Operational Research, 136, 528–540. Kubzin, M. A., Potts, C. N., & Strusevich, V. A. (2009). Approximation results for flow shop scheduling problems with machine availability constraints. Computers & Operations Research, 36, 379–390. Kubzin, M. A., & Strusevich, V. A. (2004). Two-machine flow shop no-wait scheduling with a nonavailability interval. Naval Research Logistics, 51, 613–631. Kubzin, M. A., Strusevich, V. A., Breit, J., & Schmidt, G. (2005). Polynomial-time approximation schemes for two-machine open shop scheduling with nonavailability constraints. Naval Research Logistics, 53, 1–8. Lawler, E. L., & Labetoulle, J. (1978). On preemptive scheduling of unrelated parallel processors by linear programming. Journal of the Operational Research Society, 25, 612–619. Lee, C. Y. (1991). Parallel machine scheduling with non-simultaneous machine available time. Discrete Applied Mathematics, 30, 53–61. Lee, C. Y. (1996). Machine scheduling with an availability constraints. Journal of Global Optimization, 9, 363–382. Lee, C. Y. (1997). Minimizing the makespan in the two-machine flowshop scheduling problem with an availability constraint. Operations Research Letters, 20, 129–139. Lee, C. Y. (1999). Two-machine flowshop scheduling with availability constraints. European Journal of Operational Research, 114, 420–429. Lee, C. Y. (2000). A note on ‘‘parallel machine scheduling with non-simultaneous machine available time”. Discrete Applied Mathematics, 100, 133–135. Lee, C. Y., Lei, L., & Pinedo, M. (1997). Current trends in deterministic scheduling. Annals of Operations Research, 70, 1–41. Lee, C. Y., & Liman, S. D. (1992). Single machine flow-time scheduling with scheduled maintenance. Acta Informatica, 29, 375–382. Lee, C. Y., & Liman, S. D. (1993). Capacitated two-parallel machines scheduling to minimize sum of job completion times. Discrete Applied Mathematics, 41, 211–222. Lee, C. Y., & Vairaktarakis, G. L. (1994). Minimizing makespan in hybrid flowshops. Operations Research Letters, 16, 149–158. Leon, V. J., & Wu, S. D. (1992). On scheduling with ready-times, due-dates and vacations. Naval Research Logistics, 39, 53–65. Liao, C. J., & Chen, W. J. (2003). Single-machine scheduling with periodic maintenance and nonresumable jobs. Computers & Operations Research, 30, 1335–1347. Liao, C.-J., Shyur, D.-L., & Lin, C.-H. (2005). Makespan minimization for two parallel machines with an availability constraint. European Journal of Operational Research, 160, 445–456. Lin, G., He, Y., Yao, Y., & Lu, H. (1997). Exact bounds of the modified LPT algorithm applying to parallel machines scheduling with nonsimultaneous machine available times. Applied Mathematics: A Journal of Chinese Universities, 12, 109–116. Lin, C.-H., & Liao, C.-J. (2007). Makespan minimization for two parallel machines with an unavailable period on each machine. The International Journal of Advanced Manufacturing Technology, 33, 1024–1030. Lu, L., & Posner, M. E. (1993). An NP-hard open shop scheduling problem with polynomial average time complexity. Mathematical Methods of Operations Research, 18, 12–38. Mauguie˙re, P. H., Billaut, J.-C., & Bouquard, J.-L. (2005). New single machine and jobshop scheduling problems with availability constraints. Journal of Scheduling, 8, 211–231. Mauguière, P. H., Billaut, J. -C., & Bouquard, J. -L. (2003). Scheduling resumable and non-resumable operations. In Proceedings of the joint international meeting EURO/INFORMS, Istanbul, Turkey (pp. 166–167). Mauguière, P. H., Bouquard, J. -L., & Billaut, J. -C. (2003). A branch and bound algorithm for a job shop scheduling problem with availability constraints. In Proceedings of the sixth workshop on models and algorithms for planning and scheduling problems, MAPSP’2003, Aussois, France (pp. 147–148). McNaughton, R. (1959). Scheduling with deadlines and loss functions. Management Science, 15, 1–12. Moore, J. M. (1968). An n job one machine sequencing algorithm for minimizing the number of late jobs. Management Science, 15, 102–109. Mosheiov, G. (1994). Minimizing the sum of job completion times on capacitated parallel machines. Mathematical and Computer Modelling, 20, 91–99. Nawaz, J., Enscore, E. E., & Ham, I. (1983). A heuristic algorithm for three-machine, n-job sequencing problem. Omega, 11, 91–95. Ng, C. T., & Kovalyov, M. Y. (2004). An FPTAS for scheduling a two-machine flowshop with one unavailability interval. Naval Research Logistics, 51, 307–315. _ Sadfi, C., Penz, B., Rapine, C., Błazewicz, J., & Formanowicz, P. (2005). An improved approximation algorithm for the single machine total completion time scheduling problem with availability constraints. European Journal of Operational Research, 161, 3–10. Sanlaville, E., & Schmidt, G. (1998). Machine scheduling with availability constraints. Acta Informatica, 35, 795–811. Schmidt, G. (1984). Scheduling on semi-identical processors. Zeitschrift fur Operation Research, 28, 153–162. Schmidt, G. (1988). Scheduling independent tasks with deadlines on semi-identical processors. Journal of the Operational Research Society, 39, 271–277. Schmidt, G. (2000). Scheduling with limited machine availability. European Journal of Operational Research, 121, 1–15.

Y. Ma et al. / Computers & Industrial Engineering 58 (2010) 199–211 Gawiejnowicz, S. (2007). Scheduling deteriorating jobs subject to job or machine availability constraints. European Journal of Operational Research, 180, 472–478. Suresh, V., & Chaudhuri, D. (1996). Scheduling of unrelated parallel machines when machine availability is specified. Production Planning & Control, 7, 393–400. Tan, Z., & He, Y. (2002). Optimal online algorithm for scheduling on two identical machines with machine availability constraints. Information Processing Letters, 83, 323–329. Vairaktarakis, G., & Sahni, S. (1995). Dual criteria preemptive open-shop problems with minimum makespan. Naval Research Logistics Quarterly, 42, 103–121. Wang, G., & Cheng, T. C. E. (2001). Heuristics for two-machine no-wait flowshop scheduling with an availability constraint. Information Processing Letters, 80, 305–309. Wang, G., & Cheng, T. C. E. (2007a). An approximation scheme for two-machine flowshop scheduling with setup times and an availability constraint. Computers & Operations Research, 34, 2894–2901. Wang, G., & Cheng, T. C. E. (2007b). Heuristics for two-machine flowshop scheduling with setup times and an availability constraint. Computers & Operations Research, 34, 152–162.

211

Wang, G., Sun, H., & Chu, C. (2005). Preemptive scheduling with availability constraints to minimize total weighted completion times. Annals of Operations Research, 133, 183–192. Wu, C.-C., & Lee, W.-C. (2003). Scheduling linear deteriorating jobs to minimize makespan with an availability constraint on a single machine. Information Processing Letters, 87, 89–93. Wu, C.-C., & Lee, W.-C. (2007). A note on single-machine scheduling with learning effect and an availability constraint. The International Journal of Advanced Manufacturing Technology, 33, 540–544. Xie, J., & Wang, X. (2005). Complexity and algorithms for two-stage flexible flowshop scheduling with availability constraints. Computers and Mathematics with Applications, 50, 1629–1638. Zribi, N. (2005). Ordonnancement des job-shop flexibles sous contraintes de disponibilite0 des machines. Ph.D. Thesis, Ecole Centrale de Lille, France. Zribi, N., Kamel, A. El., & Borne, P. (2008). Minimizing the makespan for the MPM job-shop with availability constraints. International Journal of Production Economics, 112, 151–160.