On the Robust Single Machine Scheduling Problem

Transcription

1 Journal of Combinatorial Optimization, 6, 17 33, 00 c 00 Kluwer Academic Publishers. Manufactured in The Netherlands. On the Robust Single Machine Scheduling Problem JIAN YANG yang@adm.nit.edu Department of Industrial and Manufacturing Engineering, New Jersey Institute of Technology, Newark, NJ 0710 GANG YU Department of Management Science and Information Systems, and Center for Management of Operations and Logistics, The University of Texas at Austin, Austin, TX , USA Received March, 1998; Revised July 8, 1999; Accepted August 3, 1999 Abstract. The single machine scheduling problem with sum of completion times criterion (SS) can be solved easily by the Shortest Processing Time (SPT) rule. In the case of significant uncertainty of the processing times, a robustness approach is appropriate. In this paper, we show that the robust version of the (SS) problem is NPcomplete even for very restricted cases. We present an algorithm for finding optimal solutions for the robust (SS) problem using dynamic programming. We also provide two polynomial time heuristics and demonstrate their effectiveness. Keywords: robust optimization, machine scheduling, NP-completeness, heuristic 1. Introduction We have a set of n obs to be processed on a single machine with the processing time of ob i being p i, i = 1,...,n. All obs are released at time 0 with no due dates. The single machine scheduling problem with sum of completion times criterion (SS) is defined as to find an optimal processing sequence of the obs which minimizes the sum of completion times of all obs. In standard machine scheduling terms, the problem is denoted by 1// C. We define x i = 1 if ob i is assigned to the th position of the processing sequence and 0 otherwise. The integer programming formulation of (SS) is: n n (SS) z = min (n + 1)p i x i subect to n x i = 1 n x i = 1 =1 x i {0, 1} =1 = 1,...,n, i = 1,...,n, i, = 1,...,n. The (SS) problem is one of the simplest and thoroughly-studied problems in the context of scheduling. It is well known that the Shortest Processing Time (SPT) rule

2 18 YANG AND YU provides an optimal sequence for (SS). According to the SPT rule, an optimal schedule is obtained by sequencing the obs according to nondecreasing processing times. Based on this observation, an O(n log n) algorithm can be easily devised. However, in a real world production environment, schedulers often confront significant uncertainties due to machine breakdowns, working environment changes, worker performance instabilities, tool quality variations and unavailability, as well as a variety of other external complex factors. In dealing with these uncertainties, researchers have considered the cases in which ob processing times and other ob-related properties (for instance, due dates) are random, or the machine(s) is(are) subect to random breakdowns, or both. Glazebrook (1979), Weiss and Pinedo (1980), Agrawala et al. (1984), Kampke (1989), and Emmons and Pinedo (1990) all consider the scheduling problem where one or more aspects of obs are random. When machine breakdown is considered, the problem is more complicated. Pinedo and Ross (1980) consider scheduling obs with random processing times on a machine experiencing external shocks occurring according to a nonhomogeneous Poisson process. Birge et al. (1990) assume that processing times are deterministic and the machine has intermittent up and down times that are independent random variables. In Birge and Glazebrook (1988), both ob processing times and machine up and down times are modeled as random variables. Other work considering random machine breakdowns include Glazebrook (1987, 1991), Du and Pinedo (1995), and Allahverdi and Mittenthal (1994a,b, 1995). All the above approaches assume certain probabilistic distributions for the uncertain factors and try to achieve optimality in the average sense. In reality, processing times are often estimated based on statistical data. The variance of these data can be large and the the underlying distributions drawn from the data can be inaccurate. Also, quite often the worst-case performance of a system is more important than the average-case performance. When either of the situations is true, a robustness approach to hedge against the worst case contingency (see Kouvelis and Yu, 1997) is more appropriate. In Kouvelis and Yu (1997), the uncertainties for general robust optimization problems are described by the scenario set S. Each scenario s S may be realized with a positive, but perhaps unknown, probability. The cost of making decision x under scenario s S is f s (x). The feasible region for scenario s S is X s. We define X = s S X s. Three robustness measures can be defined as follows (Kouvelis and Yu, 1997): (1) z a = min x X max s S f s (x), () z d = min x X max s S ( f s (x) z s ), (3) z r = min x X max s S ( f s (x) z s z s ), where z s = min x X f s (x) is the optimal obective value under a single scenario s S. Referring to the above three measures, (1) minimizes the maximum absolute cost over all scenarios (indexed by symbol a for absolute), () minimizes the maximum deviation from optimality (indexed by symbol d for deviation), and (3) minimizes the maximum relative (or percentage) deviation from optimality (indexed by r for relative deviation). All three

3 ON THE ROBUST SINGLE MACHINE SCHEDULING PROBLEM 19 definitions hedge against the worst contingency. We define: f s (x) R = a, FR s (x) = f s (x) z s R = d, f s (x) z s R = r. z s Most properties can be derived with respect to F without specifying the measure. In the robust single machine scheduling problem, the processing time vector for scenario s S is p s = (p1 s, ps,...,ps n ). Now the constraint sets for all scenarios are the same, X s = X, s S with X containing the assignment constraints and integer requirements on all the variables. The obective function for scenario s is f s (x) = n n =1 (n + 1)ps i x i. Note that no restrictions are placed on the scenario set S. In the case where processing times are given by intervals, i.e., interval [l i, u i ] to specify the range of processing times of ob i, wehaveaninfinite number of scenarios. In this paper, we study situations with a finite number of scenarios. Although exact and heuristic solutions were provided by Daniels and Kouvelis (1995) on the robust (SS) with interval processing times, we are aware of no published work on the robust (SS) dealing with a finite number of scenarios. The discrete scenario robust (SS) is important and stands on its own due to the fact that correlations among processing times of different obs cannot be sufficiently addressed through intervals; however, it can be fully captured through finite scenarios. According to our definition, the Robust Single Machine Scheduling (RSS) R problem can be written as: (RSS) R z R = min y subect to y s R n n (n + 1)pi s x i s S =1 n x i = 1 n x i = 1 =1 x i {0, 1} = 1,...,n, i = 1,...,n, i, = 1,...,n. where y R = a, yr s = y + z s R = d, z s (1 + y) R = r, and z s is the optimal obective value of (SS) with processing time vector p s.

4 0 YANG AND YU In this paper, we prove that the (RSS) R problem is NP-complete for all three measures, and even in the case of two scenarios. We show that the (RSS) R problem under all three robustness measures can be transformed and solved by an exact algorithm using dynamic programming. We also present two efficient heuristics, with one having a bound, and the other outperforming the first empirically.. NP-completeness of the (RSS) R In this section, we demonstrate that the robust version of the single machine scheduling problem loses its simplicity. For all three measures of robustness, the (RSS) R problem is NP-complete even in the case of only two scenarios. The proof also sheds some light on the structure of the problem, which will lead to further analysis. Theorem 1. The (RSS) R problem is NP-complete for all three measures of robustness even in the case of two scenarios. Proof: We reduce the two-partition problem to the (RSS) R problem. The two-partition problem is a well-known NP-complete problem (see Garey and Johnson, 1979) as defined below. The two-partition problem: Instance: Finite set I and a size s i Z + for i I. Question: Is there a subset I I such that i I s i = i I \I s i? We assume that the numbers are in nondecreasing order: s 1 s s I. For any instance of the two-partition problem, we define the following robust single machine scheduling problem with I obs and two scenarios; i.e., n = I, S =. Let the processing time vector for the two scenarios be: { pi 1 si 1 i I = 0 1+ I i I p i = { 0 1 i I s i I 1 + I i I. With the above definition, we prove the following assertion: a two-partition I I exists if and only if (RSS) R has the following optimal values: ( i I n i + 3 ) si R = a, ( z R = i I I i + 1 ) si R = d, R = r. i I ( I i+ 1 )s i i I ( I i+1)s i First, we demonstrate the case where R = a.

5 ON THE ROBUST SINGLE MACHINE SCHEDULING PROBLEM 1 To prove the only if part, we consider the following solution: x i,i = 1 i I x i,i 1 = 1 i I \I x i+ I,i 1 = 1 i I x i+ I,i = 1 i I \I. The proposed solution above is feasible with f 1 (x ) = (n i + 1)s i + (n i + )s i, i I i I \I f (x ) = (n i + )s i + (n i + 1)s i. i I i I \I Using the definition of two-partition i I s i = i I \I s i, we obtain f 1 (x ) = f (x ) = f 1 (x )+ f (x ) = i I (n i + 3 )s i. Thus, we get an upper bound z for z a. z a z = i I (n i + 3 )s i. To show the optimality of the proposed solution, we use surrogate relaxation: z = min x X (λ 1 f 1 (x) + λ f (x)) where λ 1 + λ = 1,λ 1 0,λ 0. The surrogate relaxation will provide a lower bound z z a (see Nemhauser and Wolsey, 1988). We choose λ 1 = λ = 1. This reduces to a single machine scheduling problem for n obs with processing time of ob i as: p i = p1 i + p i { si / 1 i I = s i I / i = 1 + I i I Since p 1 = p 1+ I p = p + I p I = p I, the proposed solution is optimal for this surrogate relaxation. Thus z = n (n i + 1) p i I = 1 (n i + 1)s i + 1 ( n i + 3 ) s i = i I I (n i + )s i We conclude that z = z a = z. To prove the if part, we note that when z a = i I (n i + 3 )s i, the optimal solution x is also optimal for the surrogate relaxation, because we have z a z and z = i I (n i + 3 )s i. According to the SPT rule for the single scenario surrogate relaxation, there must

6 YANG AND YU exist a subset I of I such that: x i,i = 1 i I x i,i 1 = 1 i I \I x i+ I,i 1 = 1 i I x i+ I,i = 1 i I \I. Therefore, we have: f 1 (x ) = (n i + 1)s i + (n i + )s i, i I i I \I f (x ) = (n i + )s i + (n i + 1)s i. i I i I \I From z a = z, weget f 1 (x ) = f (x ).Sowefind a subset I of I, such that i I s i = i I \I s i. To prove the cases where R = d and R = r, we note that the optimal value for the single scenario case z 1 = z = i I ( I i + 1)s i. Thus, the z s term in the obective functions of the robust deviation and relative robust measures can be treated as a constant. A proof similar to the above leads to the desired result. Under an unbounded number of scenarios, the problems are shown to be strongly NPhard. The proof can be found in the appendix. 3. An exact dynamic programming algorithm for (RSS) R Before we proceed to the details of the solution procedure, we first show that the problems under the three different robustness measures can be solved by a single method. Note that z d = min max( f s (x) z s ) = min max f s (x), x X s S x X s S where f s (x) = n n =1 (n + 1)ps i x i, while f s (x) = n n =1 (n + 1) (pi s zs n(n+1) )x i. That is, we can uniformly distribute z s s contribution to each ob by a term zs. No matter where each ob resides in the sequence of obs to be executed, there n(n+1) will always be exactly one ob placed in the first position, exactly one ob in the second, etc. The total change in the completion time will be n z s (n + 1) n(n + 1) =1 = n(n + 1) z s n(n + 1) = zs. We thus can transform the problem of finding z d, the (RSS) R problem with the deviation measure with the parameters pi s s, to the problem of finding z a, the (RSS) R problem with the absolute measure with parameters (pi s zs n(n+1) ) s. In our solution for z a, pi s s nonnegativity does not matter. Therefore, the sign of pi s will not affect the solution procedure. zs n(n+1)

7 ON THE ROBUST SINGLE MACHINE SCHEDULING PROBLEM 3 For z r,wehave ( f s z r = min max (x) z s x X s S z s ) = min max f s (x), x X s S where f s (x) = n n =1 (n + 1)( ps i z s n(n+1) )x i. Thus, the problem of finding z R, the (RSS) R problem with the relative deviation measure, can also be transformed to the one of finding z a, the (RSS) R problem with the absolute measure, with a different set of parameters. In later sections of this paper, all the solution techniques are for the (RSS) R problem with the absolute robustness measure, the (RSS) a problem. Problems with the other two measures can use the same technique after proper transformations. In our dynamic programming solution procedure, the state variables are the 0 1 vector u = (u 1,...,u n ) which indicates whether or not each ob i has been put in the processing sequence, and vector α = (α 1,...,α S ), which is the contribution of the obs already in the sequence to the total completion times under all the scenarios. For a vector u, wedefine two index sets associated with it. They are: I (u) ={i u i = 1, i {1,...,n}}, and O(u) = {i u i = 0, i {1,...,n}}. Apparently, I (u) O(u) ={1,...,n} and I (u) O(u) =.For i O(u), we also define a new vector u (+i) which satisfies I (u (+i) ) = I (u) {i}. Nowwe define: f (u; α) = the max s S f s (x) value of the sequence with the minimum of this value among all the sequences whose first I (u) obs are the ob i s in the set I (u), and that these obs contribution to the total completion time in scenario s is α s, s S. The initial condition is: f (1 n ; α) = max s S αs. The recursive relation between f s of different states is: f (u; α) = min f ( u (+i) ; α 1 + O(u) pi 1 i O(u),...,α S + O(u) p S ) i. The optimal value z a = f (0 n ; 0 S ). To get the optimal ob sequence σ a = (σ a (1),...,σ a (n)) such that σ a ( ) = n ix i, {1,...,n}, where x is the optimal solution, we let u 0 = 0 n, α 0 = 0 S, and k = 0. At stage k, according to the recursive relation, we will find at least one i O(u k ), that satisfies f (u k ; α k ) = f ( u k(+i) ; αk 1 + (n k)p1 i,...,α S k + (n k)p S ) i. We then let u k+1 = u k(+i), αk+1 s = αs k + (n k)ps i, s S, let k = k + 1, σ a(k) = i, and go to the next stage k, until k = n. Written in pseudo code, the procedure is as follows: Algorithm RobustScheduling for s = 1 to S do sort (p s 1,...,ps n ) to get index sets (l 1,...,l n ) and (m 1,...,m n ) so that p s l 1 p s l n, and p s m 1 p s m n ;

8 4 YANG AND YU if p s l 1 0, then let k = 0; else, find k {1,...,n} such that p s l k < 0butp s l k+1 0; L s = k =1 (n + 1)ps l ; M s = n =1 (n + 1)ps m ; for α 1 = L 1 to M 1 do for α S = L S to M S do f (1,...,1; α 1,...,α S ) = max s S α s ; for t = 1 to n do for u be any 0 1 vector with O(u) =t do for α 1 = L 1 to M 1 do for α S = L S to M S do f (u; α 1,...,α S ) = min i O(u) f (u (+i) ; α 1 + tp 1 i,...,α S + tp S i ); end for. If the number of scenarios is assumed to be bounded, the main iterations will exhaust all subsets of set {1,...,n}. So the procedure s complexity is O( n ). It is notably better than O(n!) by pure enumeration, but it is still prohibitive to large n. The hurdle that prevents us from easily obtaining an exact pseudo-polynomial algorithm by using dynamic programming is that not only do the contributions of those obs already in the sequence in current state matter, but also what obs they are, since each ob can only be in the sequence once. In later sections, we introduce two polynomial time heuristics. Now we present a numerical example to show how the algorithm works. Our example has two obs and two scenarios. Its parameters are: p1 1 = 1, p1 = ; p1 = 3, p = 0. When σ = (1, ), wehave f 1 (σ ) = = 4, f (σ ) = = 6, so f (σ ) = 6. When σ = (, 1),wehave f 1 (σ ) = = 5, f (σ ) = = 3, so f (σ ) = 5. Thus, we have z a = 5 and σ a = (, 1). Going through the algorithm above, we will get the following results: L 1 = 0, L = 0, M 1 = 5, M = 6,..., f (1, 1; 4, 6) = 6,..., f (1, 1; 5, 3) = 5,......, f (0, 1; 4, 0) = f (1, 1; , ) = f (1, 1; 5, 3) = 5,......, f (1, 0;, 6) = f (1, 1; + 1, ) = f (1, 1; 4, 6) = 6,...

9 ON THE ROBUST SINGLE MACHINE SCHEDULING PROBLEM 5 f (0, 0; 0, 0) = min{ f (1, 0; 0 + 1, 0 + 3), f (0, 1; 0 +, 0 + 0)} = min{ f (1, 0;, 6), f (0, 1; 4, 0)} =min{6, 5} =5,... Thus we have z a = 5. Also, because f (0, 0; 0, 0) = f (0, 1; 4, 0) = f (1, 1; 5, 3), we have σ a = (, 1). These agree with our enumeration results. 4. The surrogate heuristic for the robust (SS) For a feasible ob sequence σ, z a (σ ) = max s S f s (σ ) = max s S ( n =1 (n + 1)ps ) is the obective function of the (RSS) a problem. We now introduce z SU (σ ) = 1 S s S f s (σ ), the average total completion time over all the scenarios, as a new obective function. The minimization problem with the new obective function and the same set of constraints as those in (RSS) a is called surrogate relaxation of (RSS) a.ifσ a and σ SU are the optimal solutions of (RSS) a and its surrogate relaxation, respectively, we have the following interesting properties: z SU (σ SU ) z SU (σ a ), because σ SU is the optimal solution of the minimization problem of surrogate relaxation; z SU (σ a ) z a (σ a ), because z SU (σ ) z a (σ ), σ being a feasible ob sequence; and z a (σ a ) z a (σ SU ), because σ a is the optimal solution of the (RSS) a problem. Therefore, for the optimal value z a (σ a ) of the (RSS) a problem, we get one lower bound z SU (σ SU ), and an upper-bound z a (σ SU ) which is associated with a feasible solution. While the (RSS) a problem is hard to solve, the surrogate relaxation is ust the single scenario single machine scheduling problem (SS). We can apply the SPT rule to the surrogate relaxation, get its optimal solution σ SU, and take it as an approximate optimal solution for the original problem. We call this procedure the SurrogateHeuristic. The procedure has polynomial time complexity. To be exact, SurrogateHeuristic runs in O(n log n + S n) time where O(n log n) is for sorting and O( S n) is for surrogate. A good property of the approximate optimal value z a (σ SU ) is that it is bounded from above. We have z a (σ SU ) z a (σ a ) θ S θ + S 1, where θ = max s S f s (σ SU ) min s S f s (σ SU. The proof is provided by Yu and Yang (1998) in a paper on the ) robust shortest path problem. We can show the tightness of the bound by presenting some instances where the bound is achieved. The following is an instance with two obs: p 1 1 = p, p1 = β S β S +1 β S +β + S p,

10 6 YANG AND YU p s 1 = p s = 3 S / β S +β + S p, 3 S /4 β S +β + S p, s S\{1}, where S =3, 4, 5, β = S = 7 4,, 9 respectively is a parameter, and p > 0 is another 4 scaling parameter. Because we choose < S < 6, we have S < S. Thus, the S denominator ( β S +β + S ) is always positive. Later comparisons only need to be done on the numerators. In order to apply the SPT rule to the surrogate relaxation, we need to calculate p i = 1 S s S ps i for i = 1, : p 1 = β S +β + 3 S / + S / p, S ( β S + β + S ) p = β S β + 3 S /4 7 S /4 + 1 p. S ( β S + β + S ) We get p 1 p because β = S S + 1 and the common denominator is positive. 4 Therefore, we can choose σ SU = (, 1). On the other hand, p1 1 < p1 S, because β = 4 +1 > 1 and the common denominator is positive; p1 1 + p1 ps 1 + ps, s S\{1}, because β = S S and the common denominator is positive; and p1 1 + p1 > ps 1 + ps, s S\{1} because β>1and the common denominator is positive. Therefore, z a ((, 1)) = p p1 > p1 1 + p1 = z a((1, )), and we have to set σ a = (1, ). Now, we have θ = max s S f s (σ SU ) min s S f s (σ SU ) = p1 1 + p1 p1 + p 3β S p/( β S +β + S ) = 3 S p/( β S +β + S ) = β, z a (σ a ) = p 1 + p 1 = 3(β + S 1) β S +β + S p, and z a (σ SU ) = p p1 = 3β S β S +β + S p. Thus, the bound is reached: z a (σ SU ) z a (σ a ) = β S β + S 1 = θ S θ + S 1.

11 ON THE ROBUST SINGLE MACHINE SCHEDULING PROBLEM 7 5. An empirically more effective greedy heuristic for (RSS) R Here we present a polynomial time heuristic algorithm that empirically outperforms the surrogate heuristic by some margin. The algorithm runs through n stages. At stage t, for every ob i, a partial sequence of obs σi t = (σi t(1),...,σt t i (t 1), σi (t)) is found, such that σi t t (t) = i; (σi (1),...,σt t 1 i (t 1)) is the partial sequence σ where = σi t t (t 1); and σi is the partial sequence among all the partial sequences satisfying the previous two conditions that has the smallest f t (σ ) value, where f t (σ ) = max s S ( t=1 (n + 1)ps σ() ). After stage n, we examine the sequences obtained at stage n for all the obs and pick the one σi n with the minimum f n (σi n) as the solution σ GP. The intuition behind the procedure is the SPT rule. We place more weight on earlier obs. When there is only one scenario, the procedure will produce the optimal schedule. The pseudo code version of the algorithm is: Algorithm GreedyHeuristic (Preliminary) for i = 1 to n do σ 1 i = (i); for t = to n do for i = 1 to n do i PRE = argmin =1,...,n,i / σ t 1 σ t i = (σ t 1 i PRE, i); i 0 = argmin,...,n f n (σi n); σ GP = σi n 0 ; f t ((σ t 1, i)); The algorithm takes O(n 4 S ) time to execute. It is possible that σi t does not exist for some t and i due to the nonexistence of a σ t 1 which does not contain i. However, a feasible solution is always guaranteed. For σi t not to exist for some i at some t > 1, i must be in the partial sequence σ t 1 s for every {1,...,n}. So, for σi n not to exist for all the i {1,...,n}, σ n 1 has to have all the obs 1,...,n, {1,...,n}. Since every σ n 1 only contains n 1 obs, this is impossible. In the above algorithm, we let i PRE = 0 when there is no non-null partial sequence σ t 1 to which i does not belong, σ0 t = NULL, and (NULL, i) = NULL. An improvement of the GreedyHeuristic can be achieved when, at each stage t and for each ob i, we not only store the best partial ob sequence whose tth position is taken by i, but also the second best, the third best, etc., until some gth best where g is a prespecified parameter. When obtaining the sequences at each new stage, we study all the possibilities of growing the sequences from the previous stage s sequences for all obs at all g levels. The smaller the g number is, the more myopic we are. By increasing g, we expect to improve the solution. Note that the computation time is proportional to g, because at each stage there are g times more partial ob sequences and for each partial ob sequence, g times more extra effort is needed to grow new sequences.

12 8 YANG AND YU Table 1. Comparison of the heuristics. n S g z SU z GP 100 zsu zgp z SU % m(z GP SU) Here is the pseudo code of the improved algorithm: Algorithm GreedyHeuristic (Final) for i = 1 to n do for g = 1 to g do σ 1 ig = (i); for t = to n do for i = 1 to n do for g = 1 to g do (i PRE, g PRE ) = argmin(g ) =1,...,n,g =1,...,g,i / σ t 1 f t ((σ t 1 g g, i)); σ t ig = (σ t 1 i PRE,g i); PRE, i 0 = argmin,...,n f n (σ n σ GP = σ n i 0 1 ; i1 );

13 ON THE ROBUST SINGLE MACHINE SCHEDULING PROBLEM 9 In the above presentation, argmin(g ) refers to the g th minimum argument. To compare the effectiveness of GreedyHeuristic and SurrogateHeuristic, we conducted computational tests. Our code was written in C. All the obs processing times under all the scenarios are independent, identical, and uniformly distributed integers from {0, 1,...,99}. For each problem instance, we ran both algorithms 100 times and compared their average values. Table 1 presents our results. The first column shows the numbers of obs, the second the number of scenarios, the third the g parameter we used in the procedure, the fourth the average results from the SurrogateHeuristic, the fifth the average results from the GreedyHeuristic, the sixth the percentage improvements of GreedyHeuristic over SurrogateHeuristic, and the seventh the numbers of times the GreedyHeuristic outperformed SurrogateHeuristic in the 100 runs. The first row of the table verifies that the GreedyHeuristic and the SurrogateHeuristic do produce optimal solutions when there is only one scenario. The solution quality improvement from increasing g is slow, but clearly recognizable. The advantage of the GreedyHeuristic over the SurrogateHeuristic becomes more and more obvious as the number of scenarios increases. In our experiment, whenever S reaches 10, the greedy procedure outperforms the surrogate heuristic 100% of the time. The improvement in solution quality may exceed ten percent. 6. Conclusions In this paper, we have shown that the robust single machine scheduling problem (RSS) R is much harder than its corresponding conventional single machine scheduling problem (SS). To solve the (RSS) R problems using three different robust measures, we found that only a common solution procedure is needed. Even with two scenarios, the problem is NPcomplete. We devised an exact dynamic programming algorithm to solve (RSS) R with complexity O( n ). Polynomial time heuristics with interesting properties were also presented. As this point, no pseudo-polynomial time exact solution procedure has been discovered. Based on our analysis and intuition, we doubt that there is one. More efficient and effective heuristics need to be developed. We also noted that both the exact and heuristic algorithms became much more complex as the number of scenarios increased. An important research topic would be, on one hand, to study the improving rate of the robust solutions as a function of the number of scenarios, and on the other hand, to study the increasing rate of cost as a function of the number of scenarios, with the cost including both of the scenario generation and of the solution technique. Appendix: The (RSS) R problem is strongly NP-hard with an unbounded number of scenarios In this Appendix, we prove that the robust single machine scheduling problem is strongly NP-hard when the number of scenarios becomes unbounded. The (RSS) R problem is strongly NP-hard for an unbounded number of sce- Theorem. narios.

14 30 YANG AND YU Proof: We reduce the three-partition problem to the (RSS) R problem. The three-partition problem is strongly NP-hard (see Garey and Johnson, 1979), as defined below. The three-partition problem: Instance: A finite set I of 3m elements, a bound B Z +, and a size s k Z+ for k I, such that each s k satisfies B/4 < s k < B/ and such that k I s k = mb. Question: Can I be partitioned into m disoint sets I 1, I,...,I m such that, for 1 i m, k I i s k = B? We assume that all the sizes are in increasing order: s 1 < s < < s 3m. For any instance of the three-partition problem, we define the following robust single machine scheduling problem with 3m obs and m scenarios; i.e., n = 3m, S =m. Let the processing time vector under the various scenarios be: p i 3m(i 1)+k = s k 1 i m, 1 k 3m, p i 3m(i 1)+k = 0 1 i, i m, i =i, 1 k 3m. That is, if we put the obs into m groups (1,...,3m),...,(3m 3m + 1,...,3m ), then under scenario i, only obs in the ith group have positive processing times, and the processing time of the kth ob in the group equals the size of the k th element in set I. With the above definition, we prove the following assertion: a three-partition I 1,...,I m exists if and only if the (RSS) R problem has the following optimal values: (3m + m+1 ) 3m s k m 3m ks k R = a, z R = (3m 5m+1 ) 3m s k (m 1) 3m ks k R = d, (3m 5m+1 ) 3m s k (m 1) 3m ks k R = r. (3m+1) 3m s k 3m ks k First, we demonstrate the case where R = a. To prove the only if part, we consider the following solution: x3m(i 1)+k,m(k 1)+( +i 1 mod m) = 1 1 i, m, 1 k 3m, k I, x uv = 0 otherwise, 1 u,v 3m. Because I 1,...,I m are disoint sets that exactly cover set I ={1,...,3m}, x is actually a feasible solution that permutes the 3m obs to 3m different positions. Under this solution x,wehave: f 1 (x ) = m k I i {3m [(k 1)m + i] + 1}s k = (3m + m + 1) m k I i s k m m k I i ks k m i s k k I i

15 ON THE ROBUST SINGLE MACHINE SCHEDULING PROBLEM 31 = (3m + m + 1) ) ( = 3m + m + 1 f (x ) f 1 (x ) = (m 1) s k k I m s k m s k m ks k ks k, s k = 0,..., i m 1 k I i f m (x ) f m 1 (x ) = (m 1) s k s k = 0. k I i k I i m(m + 1) 1 m s k Therefore, we have z(x ) = ax{ f 1 (x ),..., f m (x )}=(3m + m+1 ) 3m s k m 3m ks k, and z a z(x ) = (3m + m+1 ) 3m s k m 3m ks k. On the other hand, we can design a surrogate relaxation of the original problem with the following processing times: p 3m(i 1)+k = m =1 p 3m(i 1)+k m = s k m. According to the SPT rule for (SS) problem, x is an optimal solution for the surrogate relaxation, with optimal value z = = = { } m [3m (k 1)m i + 1] s k m [ 3m (k 1)m m + 1 ] + 1 s k ( 3m + m + 1 ) s k m ks k = z(x ). We also know that z a z (see Nemhauser and Wolsey, 1988). Thus, we get z a z(x ). So, finally we get z a = z(x ) = ( 3m + m + 1 ) s k m To prove the if part, note that when z a = (3m + m+1 ) 3m s k m 3m ks k, the optimal solution x is also optimal for the surrogate relaxation, because we have z a z and z = (3m + m+1 ) 3m s k m 3m ks k. Following the SPT rule for the single scenario problem of surrogate relaxation, ob 3m(i 1) + k must correspond to position m(k 1) +, for 1 i, m, 1 k 3m. For 1 i, m, we define: I i ={k x 3m(i 1)+k,m(k 1)+ = 1, 1 k 3m}. ks k.

16 3 YANG AND YU The properties of I i s are: I i I i = for =, I i I i = for i =i, m I i = I ={1,...,3m} 1 i m, =1 m i =1 I i = I ={1,...,3m} 1 m. For z a = ax{ f 1 (x),..., f m (x)}, wehave: f i (x) = m {3m [(k 1)m + ] + 1}s k =1 k I i = (3m + m + 1) s k m za ks k m k I i =1 1 i m. s k So for every i {1,...,m},wehave m =1 k I i s k m + 1 In summing the above inequalities from i = 1toi = m, weget m =1 m s k k I i s k. m(m + 1) But from the properties of I i s, we have s k. m m s k = =1 k I i m =1 s k = m(m + 1) s k. Therefore, m =1 k I s i k = m+1 3m s k, i {1,...,m}. This is only possible when we have disoint sets I 1,...,I m covering set I ={1,...,3m}, such that = 1 3m m k I i s k s k = B, and {I1 i,...,i m i } for every i is ust a distinct permutation of {I 1,...,I m }. The I 1,...,I m thus found are the three-partition sets. To prove the cases where R = d and R = r, note that the optimal value for the single scenario cases:

17 ON THE ROBUST SINGLE MACHINE SCHEDULING PROBLEM 33 z 1 = = z m = (3m + 1) 3m s k 3m ks k. Therefore, the z s term in the obective functions of the robust deviation and relative robust measures can be treated as a constant. A proof similar to the above leads to the desired result. References A.K. Agrawala, E.G. Coffman, Jr., M.R. Garey, and S.K. Tripathi, A static optimization algorithm minimizing expected flowtime on uniform processors, IEEE Transactions on Computing, vol. 33, pp , A. Allahverdi and J. Mittenthal, Two-machine ordered flowshop scheduling under random breakdowns, Mathematical and Computer Modeling, vol. 0, pp. 9 17, 1994a. A. Allahverdi and J. Mittenthal, Scheduling on M parallel machines subect to random breakdowns to minimize expected mean flow time, Naval Research Logistics, vol. 41, pp , 1994b. A. Allahverdi and J. Mittenthal, Scheduling on a two-machine flowshop subect to random breakdowns with a makespan obective function, European Journal of Operational Research, vol. 81, pp , J. Birge, J.B.G. Frenk, J. Mittenthal, and A.H.G. Rinnooy Kan, Single machine scheduling subect to stochastic breakdowns, Naval Research Logistics, vol. 37, pp , J.R. Birge and K. Glazebrook, Assessing the effects of machine breakdown in stochastic scheduling, Operations Research Letters, vol. 7, pp , R.L. Daniels and P. Kouvelis, Robust scheduling to hedge against processing time uncertainty in single-stage production, Management Science, vol. 41,, pp , C. Du and M. Pinedo, A note on minimizing the expected makespan in flowshops subect to breakdowns, Naval Research Logistics, vol. 4, pp , H. Emmons and M. Pinedo, Scheduling stochastic obs with due dates on parallel machines, European Journal of Operational Research, vol. 47, pp , M.R. Garey and D.S. Johnson, Computers and Intractability, W.H. Freeman: San Francisco, K.D. Glazebrook, Scheduling tasks with exponential service times on parallel processors, Journal of Applied Probability, vol. 16, pp , K. Glazebrook, Evaluating the effects of machine breakdowns in stochastic scheduling problems, Naval Research Logistics, vol. 34, pp , K. Glazebrook, On non-preemptive policies for stochastic single machine scheduling with breakdown, Probability in the Engineering and Informational Science, vol. 5, pp , T. Kampke, Optimal scheduling of obs with exponential service times on identical parallel machines, Operations Research, vol. 37, pp , P. Kouvelis and G. Yu, Robust Discrete Optimization and Its Applications, Kluwer Academic Publishers: Boston, G.L. Nemhauser and L.A. Wolsey, Integer and Combinatorial Optimization, John Wiley & Sons: New York, M.L. Pinedo and S.H. Ross, Scheduling obs subect to nonhomogeneous Poisson shocks, Management Science, vol. 6, pp , G. Weiss and M. Pinedo, Scheduling tasks with exponential service times on nonidentical processors to minimize various cost functions, Journal of Applied Probability, vol. 17, pp , G. Yu and J. Yang, On the robust shortest path problem, Computers & Operations Research, vol. 5, no. 6, pp , 1998.