On the Robust Single Machine Scheduling Problem - Semantic Scholar
On the Robust Single Machine Scheduling Problem Jian Yang Department of Industrial and Manufacturing Engineering New Jersey Institute of Technology Newark, NJ 07102 Gang Yu Department of Management Science and Information Systems University of Texas at Austin Austin, TX 78712 July 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 NP-complete 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
1
Introduction
We have a set of n jobs to be processed on a single machine with the processing time of job i being pi , i = 1, ..., n. All jobs 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 jobs which minimizes the sum of completion times of all jobs. In standard machine scheduling terms, the problem is P denoted by 1// Cj . We define xij = 1 if job i is assigned to the jth position of the processing sequence and 0 otherwise. The integer programming formulation of (SS) is: n n (SS)
z = min
XX
(n − j + 1)pi xij
i=1 j=1
subject to
n X
xij = 1
j = 1, ..., n,
n X
xij = 1
i = 1, ..., n,
i=1
j=1
xij ∈ {0, 1}
i, j = 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 provides an optimal sequence for (SS). According to the SPT rule, an optimal schedule is obtained by sequencing the jobs 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 job processing times and other job-related properties (for instance, due dates) are random, or the machine(s) is(are) subject to random breakdowns, or both. Glazebrook [11], Weiss and Pinedo [18], Agrawala, Coffman, Garey, and Tripathi [1], Kampke [14], and Emmons and Pinedo [9] all consider the scheduling problem where one or more aspects of jobs are random. When machine breakdown is considered, the problem is more complicated. Pinedo and Ross [17] consider scheduling jobs with random processing times on a machine experiencing external shocks occurring according to a nonhomogeneous Poisson process. Birge, Frenk, Mittenthal, and Rinnooy Kan [5] assume that processing times are deterministic and the machine has intermittent up 2
and down times that are independent random variables. In Birge and Glazebrook [6], both job processing times and machine up and down times are modeled as random variables. Other work considering random machine breakdowns include Glazebrook [12][13], Du and Pinedo [8], and Allahverdi and Mittenthal [2][3] [4]. 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 [15]) is more appropriate. In Kouvelis and Yu book, 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 Xs . We define X = ∩s∈S Xs . Three robustness measures can be defined as in Kouvelis and Yu: (1) za = minx∈X maxs∈S f s (x), (2) zd = minx∈X maxs∈S (f s (x) − z s ), (3) zr = minx∈X maxs∈S ( f
s (x)−z s
zs
),
where z s = minx∈X f s (x) is the optimal objective 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), (2) 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 symbol “r” for relative deviation). All three definitions hedge against the worst possible contingency. We define:
FRs (x)
s f (x)
= f s (x) − z s
f s (x)−z s zs
R = a, R = d, R = r.
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 ps = (ps1 , ps2 , ..., psn ). Now the constraint sets for all scenarios are 3
the same, Xs = X, s ∈ S with X containing the assignment constraints and integer requirements on all the variables. The objective function for scenario s is f s (x) = Pn Pn s i=1 j=1 (n − j + 1)pi xij . Note that no restrictions are placed on the scenario set S. In the case where processing times are given by intervals, i.e., interval [li , ui ] to specify the range of processing times of job i, we have an infinite 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 [7] 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 jobs 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 zR = min y subject to yRs
≥
n n X X
(n − j + 1)psi xij
s∈S
i=1 j=1 n X
xij = 1
j = 1, ..., n,
n X
xij = 1
i = 1, ..., n,
i=1
j=1
xij ∈ {0, 1}
i, j = 1, ..., n.
where yRs
y R = a, s = y+z R = d, s z (1 + y) R = r,
and z s is the optimal objective value of (SS) with processing time vector ps . 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.
4
2
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 twopartition problem is a well-known NP-complete problem (see Garey and Johnson [10]) as defined below. The two-partition problem: Instance: Finite set I and a size si ∈ Z+ for i ∈ I. Question: Is there a subset I 0 ⊆ I such that
P
i∈I 0
si =
P
i∈I\I 0
si ?
We assume that the numbers are in nondecreasing order: s1 ≤ s2 ≤ ... ≤ s|I| . For any instance of the two-partition problem, we define the following robust single machine scheduling problem with 2|I| jobs and two scenarios; i.e. n = 2|I|, |S| = 2. Let the processing time vector for the two scenarios be: s i p1i = 0
p2i =
1 ≤ i ≤ |I| 1 + |I| ≤ i ≤ 2|I|
0
s i−|I|
1 ≤ i ≤ |I| . 1 + |I| ≤ i ≤ 2|I|
With the above definition, we prove the following assertion: a two-partition I 0 ∈ I exists if and only if (RSS)R has the following optimal values:
zR
P 3 i∈I (n − 2i + 2 )si P (|I| − i + 12 )si i∈I = P (|I|−i+ 12 )si Pi∈I i∈I
(|I|−i+1)si
First, we demonstrate the case where R = a.
5
R = a, R = d, R = r.
To prove the only if part, we consider the following solution: x∗i,2i
=
1
i ∈ I0
x∗i,2i−1
=
1
i ∈ I \ I0 i ∈ I0
x∗i+|I|,2i−1 = 1 x∗i+|I|,2i
=
i ∈ I \ I 0.
1
The proposed solution above is feasible with f 1 (x∗ ) =
X
(n − 2i + 1)si +
X
(n − 2i + 2)si +
i∈I 0
f 2 (x∗ ) =
X
(n − 2i + 2)si ,
X
(n − 2i + 1)si .
i∈I\I 0
i∈I 0
i∈I\I 0
Using the definition of two-partition i∈I 0 si = i∈I\I 0 si , we obtain f 1 (x∗ ) = 1 ∗ 2 (x∗ ) P f 2 (x∗ ) = f (x )+f = i∈I (n − 2i + 32 )si . Thus, we get an upper bound z¯ for za . 2 P za ≤ z¯ = i∈I (n − 2i + 32 )si . To show the optimality of the proposed solution, we use surrogate relaxation: P
P
z = min(λ1 f 1 (x) + λ2 f 2 (x)) x∈X
where λ1 + λ2 = 1, λ1 ≥ 0, λ2 ≥ 0. The surrogate relaxation will provide a lower bound z ≤ za (see Nemhauser and Wolsey [16]). We choose λ1 = λ2 = 12 . This reduces to a single machine scheduling problem for n jobs with processing time of job i as: s /2 1 ≤ i ≤ |I| p1i + p2i i p¯i = = 2 si−|I| /2 i = 1 + |I| ≤ i ≤ 2|I|
Since p¯1 = p¯1+|I| ≤ p¯2 = p¯2+|I| ≤ ... ≤ p¯|I| = p¯2|I| , the proposed solution is optimal for this surrogate relaxation. Thus z =
n X
(n − i + 1)¯ pi
i=1 |I|
|I| 1X 1X (n − 2i + 1)si + (n − 2i + 2)si 2 i=1 2 i=1 X 3 = (n − 2i + )si 2 i∈I
=
We conclude that z = za = z¯. P To prove the if part, we note that when za = i∈I (n − 2i + 32 )si , the optimal solution x∗ is also optimal for the surrogate relaxation, because we have za ≥ z and 6
z = i∈I (n − 2i + 32 )si . According to the SPT rule for the single scenario surrogate relaxation, there must exist a subset I 0 of I such that: P
i ∈ I0
x∗i,2i = 1
i ∈ I \ I0
x∗i,2i−1 = 1
i ∈ I0
x∗i+|I|,2i−1 = 1
i ∈ I \ I 0.
x∗i+|I|,2i = 1 Therefore, we have: f 1 (x∗ ) =
X i∈I
f 2 (x∗ ) =
0
X i∈I
X
(n − 2i + 1)si +
(n − 2i + 2)si ,
i∈I \I 0
X
(n − 2i + 2)si +
0
i∈I \I
(n − 2i + 1)si . 0
From za = z, we get f 1 (x∗ ) = f 2 (x∗ ). So we find a subset I 0 of I, such that i∈I 0 si = P i∈I \I 0 si . To prove the cases where R = d and R = r, we note that the optimal value for the P single scenario case z 1 = z 2 = i∈I (|I| − i + 1)si . Thus, the z s term in the objective 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. P
Under an unbounded number of scenarios, the problems are shown to be strongly NP-hard. 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 zd = min max(f s (x) − z s ) = min max f s0 (x), x∈X s∈S
x∈X s∈S
where f s (x) = ni=1 nj=1 (n − j + 1)psi xij , while f s0 (x) = ni=1 nj=1 (n − j + 1)(psi − 2z s )xij . That is, we can uniformly distribute −z s ’s contribution to each job by n(n+1) 2z s a term − n(n+1) . No matter where each job resides in the sequence of jobs to be P
P
P
7
P
executed, there will always be exactly one job placed in the first position, exactly one job in the second, etc. The total change in the completion time will be −
n X
(n − j + 1)
j=1
2z s n(n + 1) 2z s =− = −z s . n(n + 1) 2 n(n + 1)
We thus can transform the problem of finding zd , the (RSS)R problem with the deviation measure with the parameters psi ’s, to the problem of finding za , the (RSS)R 2z s problem with the absolute measure with parameters (psi − n(n+1) )’s. In our solution 2z s s for za , pi ’s nonnegativity does not matter. Therefore, the sign of psi − n(n+1) will not affect the solution procedure. For zr , we have zr = min max( x∈X s∈S
f s (x) − z s ) = min max f s00 (x), x∈X s∈S zs ps
2 where f s00 (x) = ni=1 nj=1 (n − j + 1)( zis − n(n+1) )xij . Thus, the problem of finding zr , the (RSS)R problem with the relative deviation measure, can also be transformed to the one of finding za , 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 = (u1 , ..., un ) which indicates whether or not each job i has been put in the processing sequence, and vector α = (α1 , ..., α|S| ), which is the contribution of the jobs already in the sequence to the total completion times under all the scenarios. For a vector u, we define two index sets associated with it. They are: I(u) = {i | ui = 1, i ∈ {1, ..., n}}, and O(u) = {i | ui = 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}. Now we define:
P
P
f (u; α) = the maxs∈S f s (x) value of the sequence with the minimum of this value among all the sequences whose first | I(u) | jobs are the job i’s in the set I(u), and that these jobs’ contribution to the total completion time in scenario s is αs , ∀s ∈ S. The initial condition is: f (1n ; α) = max αs . s∈S
8
The recursive relation between f ’s of different states is: |S|
f (u; α) = min f (u(+i) ; α1 + | O(u) | p1i , ..., α|S| + | O(u) | pi ). i∈O(u)
The optimal value za = f (0n ; 0|S| ). P To get the optimal job sequence σa = (σa (1), ..., σa (n)) such that σa (j) = ni=1 ixij , ∀j ∈ {1, ..., n}, where x is the optimal solution, we let u0 = 0n , α0 = 0|S| , and k = 0. At stage k, according to the recursive relation, we will find at least one i ∈ O(uk ), that satisfies |S| |S| f (uk ; αk ) = f (uk(+i) ; αk1 + (n − k)p1i , ..., αk + (n − k)pi ). s We then let uk+1 = uk(+i) , αk+1 = αks + (n − k)psi , ∀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 (ps1 , ..., psn ) to get index sets (l1 , ..., ln ) and (m1 , ..., mn ) so that psl1 ≤ ... ≤ psln , and psm1 ≥ ... ≥ psmn ; if psl1 ≥ 0, then let k = 0; else, find k ∈ {1, ..., n} such that pslk < 0 but pslk+1 ≥ 0; Ls =
Pk
Ms = end for;
s j=1 (n − j + 1)plj ; Pn s j=1 (n − j + 1)pmj ;
for α1 = L1 to M 1 do ··· for α|S| = L|S| to M |S| do f (1, ..., 1; α1 , ..., α|S| ) = maxs∈S αs ; end for; ··· end for; for t = 1 to n do for u be any 0 − 1 vector with | O(u) |= t do for α1 = L1 to M 1 do ··· for α|S| = L|S| to M |S| do |S|
f (u; α1 , ..., α|S| ) = mini∈O(u) f (u(+i) ; α1 + tp1i , ..., α|S| + tpi );
9
end for; ··· end for; end for; 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(2n ). 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 jobs already in the sequence in current state matter, but also what jobs they are, since each job 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 jobs and two scenarios. Its parameters are: p11 = 1, p12 = 2; p21 = 3, p22 = 0. When σ = (1, 2), we have f 1 (σ) = 2 × 1 + 1 × 2 = 4, f 2 (σ) = 2 × 3 + 1 × 0 = 6, so f (σ) = 6. When σ = (2, 1), we have f 1 (σ) = 1×1+2×2 = 5, f 2 (σ) = 1×3+2×0 = 3, so f (σ) = 5. Thus, we have za = 5 and σa = (2, 1). Going through the algorithm above, we will get the following results: L1 = 0, L2 = 0, M 1 = 5, M 2 = 6, · · · , f (1, 1; 4, 6) = 6, · · · , f (1, 1; 5, 3) = 5, · · · · · · , f (0, 1; 4, 0) = f (1, 1; 4 + 1 × 1, 0 + 1 × 3) = f (1, 1; 5, 3) = 5, · · · · · · , f (1, 0; 2, 6) = f (1, 1; 2 + 1 × 2, 6 + 1 × 0) = f (1, 1; 4, 6) = 6, · · · f (0, 0; 0, 0) = min{f (1, 0; 0 + 2 × 1, 0 + 2 × 3), f (0, 1; 0 + 2 × 2, 0 + 2 × 0)} = min{f (1, 0; 2, 6), f (0, 1; 4, 0)} = min{6, 5} = 5, · · · . Thus we have za = 5. Also, because f (0, 0; 0, 0) = f (0, 1; 4, 0) = f (1, 1; 5, 3), we have σa = (2, 1). These agree with our enumeration results. 10
4
The Surrogate Heuristic for the Robust (SS)
For a feasible job sequence σ, za (σ) = maxs∈S f s (σ) = maxs∈S ( nj=1 (n−j+1)psj ) is the 1 P s objective function of the (RSS)a problem. We now introduce zSU (σ) = |S| s∈S f (σ), the average total completion time over all the scenarios, as a new objective function. The minimization problem with the new objective 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: P
• zSU (σSU ) ≤ zSU (σa ), because σSU is the optimal solution of the minimization problem of surrogate relaxation; • zSU (σa ) ≤ za (σa ), because zSU (σ) ≤ za (σ), ∀σ being a feasible job sequence; and • za (σa ) ≤ za (σSU ), because σa is the optimal solution of the (RSS)a problem. Therefore, for the optimal value za (σa ) of the (RSS)a problem, we get one lower bound zSU (σSU ), and an upper-bound za (σSU ) which is associated with a feasible solution. While the (RSS)a problem is hard to solve, the surrogate relaxation is just 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 surrogation. A good property of the approximate optimal value za (σSU ) is that it is bounded from above. We have za (σSU ) θ|S| ≤ , za (σa ) θ+ | S | −1 s
s∈S f (σSU ) where θ = max . The proof is provided by Yu and Yang [19] in a paper on mins∈S f s (σSU ) 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 jobs:
p11 = p, p12 = ps1 =
2β | S | −β− | S | +1 p, −β | S | +2β + 2 | S | −2
3 | S | /2 3 | S | /4 p, ps2 = p, ∀s ∈ S \ {1}, −β | S | +2β + 2 | S | −2 −β | S | +2β + 2 | S | −2 11
where | S |= 3, 4, 5, β = |S| + 1 = 74 , 2, 94 respectively is a parameter, and p > 0 is 4 another scaling parameter. Because we choose 2 1 and the common denominator is positive; 2p11 + p12 ≥ 2ps1 + ps2 , ∀s ∈ 4 S \ {1}, because β = |S| + 1 ≥ |S| + 1 and the common denominator is positive; and 4 4 1 1 s s p1 + 2p2 > p1 + 2p2 , ∀s ∈ S \ {1} because β > 1 and the common denominator is positive. Therefore, za ((2, 1)) = p11 + 2p12 > 2p11 + p12 = za ((1, 2)), and we have to set σa = (1, 2). Now, we have maxs∈S f s (σSU ) p11 + 2p12 = mins∈S f s (σSU ) p21 + 2p22 3β | S | p/(−β | S | +2β + 2 | S | −2) = = β, 3 | S | p/(−β | S | +2β + 2 | S | −2) 3(β+ | S | −1) p, za (σa ) = 2p1 + p12 = −β | S | +2β + 2 | S | −2 θ=
and za (σSU ) = p11 + 2p12 =
3β | S | p. −β | S | +2β + 2 | S | −2
Thus, the bound is reached: β|S| θ|S| za (σSU ) = = . za (σa ) β+ | S | −1 θ+ | S | −1
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 12
stage t, for every job i, a partial sequence of jobs σit = (σit (1), ..., σit (t − 1), σit (t)) is found, such that σit (t) = i; (σit (1), ..., σit (t − 1)) is the partial sequence σjt−1 where j = σit (t − 1); and σit is the partial sequence among all the partial sequences satisfying the previous two conditions that has the smallest ft (σ) value, where ft (σ) = P maxs∈S ( tj=1 (n − j + 1)psσ(j) ). After stage n, we examine the sequences obtained at stage n for all the jobs and pick the one σin with the minimum fn (σin ) as the solution σGP . The intuition behind the procedure is the SPT rule. We place more weight on earlier jobs. 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 σi1 = (i); end for; for t = 2 to n do for i = 1 to n do t−1 iP RE = argminj=1,...,n,i∈σ / t−1 ft ((σj , i)); j
, i); σit = (σit−1 P RE end for; end for; i0 = argmini=1,...,n fn (σin ); σGP = σin0 ;
The algorithm takes O(n4 | S |) time to execute. It is possible that σit does not exist for some t and i due to the nonexistence of a σjt−1 which does not contain i. However, a feasible solution is always guaranteed. For σit not to exist for some i at some t > 1, i must be in the partial sequence σjt−1 ’s for every j ∈ {1, ..., n}. So, for σin not to exist for all the i ∈ {1, ..., n}, σjn−1 has to have all the jobs 1, ..., n, ∀j ∈ {1, ..., n}. Since every σjn−1 only contains n − 1 jobs, this is impossible. In the above algorithm, we let iP RE = 0 when there is no non-NULL partial sequence σjt−1 to which i does not belong, σ0t = NULL, and (NULL, i) = NULL. An improvement of the GreedyHeuristic can be achieved when, at each stage t and for each job i, we not only store the best partial job 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 13
all the possibilities of growing the sequences from the previous stage’s sequences for all jobs 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 2 , because at each stage there are g times more partial job sequences and for each partial job sequence, g times more extra effort is needed to grow new sequences. Here is the pseudo code of the improved algorithm: Algorithm GreedyHeuristic (Final) for i = 1 to n do for g 0 = 1 to g do 1 = (i); σig 0
end for; end for; for t = 2 to n do for i = 1 to n do for g 0 = 1 to g do t−1 (iP RE , gP0 RE ) = argmin(g 0 )j=1,...,n,g00 =1,...,g,i∈σ / t−1 ft ((σjg 00 , i)); jg 00
t σig 0
=
, i); (σit−1 0 P RE ,gP RE
end for; end for; end for; n ); i0 = argmini=1,...,n fn (σi1
σGP = σin0 1 ;
In the above presentation, argmin(g 0 ) refers to the g 0 th minimum argument. To compare the effectiveness of GreedyHeuristic and SurrogateHeuristic, we conducted computational tests. Our code was written in C. All the jobs’ 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 jobs, 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 that GreedyHeuristic is as good as SurrogateHeuristic in the 100 runs. 14
Table 1: Comparison of the Heuristics n
|S|
g
z¯SU
z¯GP
10 10 10 10 10 10 10 10 10 10 10 10 10 20 20 20 20 20 20 20 20 20
1 2 2 2 2 5 5 5 5 10 10 10 10 2 2 2 5 5 5 10 10 10
1 1 2 5 10 1 2 5 10 1 2 5 10 1 5 10 1 5 10 1 5 10
2031.2 2559.0 2559.0 2559.0 2559.0 3082.7 3082.7 3082.7 3082.7 3418.4 3418.4 3418.4 3418.4 8978.4 8978.4 8978.4 10920.2 10920.2 10920.2 11861.9 11861.9 11861.9
2031.2 2433.5 2427.4 2421.2 2414.0 2856.7 2841.3 2826.5 2814.6 3126.9 3113.1 3092.1 3076.9 8614.8 8598.3 8592.8 10092.1 10050.9 10037.2 10869.5 10808.6 10788.5
100 ×
z¯SU −¯ zGP z¯SU
0.0 4.9 5.1 5.4 5.7 7.3 7.8 8.3 8.7 8.5 8.9 9.5 10.0 4.1 4.2 4.3 7.6 8.0 8.1 8.4 8.9 9.0
15
% m(zGP ≤ zSU ) 100 85 89 88 93 96 97 99 99 100 100 100 100 83 85 86 99 100 100 100 100 100
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 is as good as 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 NP-complete. We devised an exact dynamic programming algorithm to solve (RSS)R with complexity O(2n ). Polynomial time heuristics with interesting properties were also presented. At 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.
A
Appendix: The (RSS)R Problem is Strongly NPHard 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. Theorem 2 The (RSS)R problem is strongly NP-hard for an unbounded number of scenarios.
16
Proof: We reduce the three-partition problem to the (RSS)R problem. The threepartition problem is strongly NP-hard (see Garey and Johnson[10]), as defined below. The three-partition problem: Instance: A finite set I of 3m elements, a bound B ∈ Z+ , and a size sk ∈ Z+ for k ∈ I, such that each sk satisfies B/4 < sk < B/2 and such P that k∈I sk = mB. Question: Can I be partitioned into m disjoint sets I1 , I2 , ..., Im such that, P for 1 ≤ i ≤ m, k∈Ii sk = B? We assume that all the sizes are in increasing order: s1 < s2 < ... < s3m . For any instance of the three-partition problem, we define the following robust single machine scheduling problem with 3m2 jobs and m scenarios; i.e., n = 3m2 , |S| = m. Let the processing time vector under the various scenarios be: pi3m(i−1)+k = sk
1 ≤ i ≤ m, 1 ≤ k ≤ 3m, 1 ≤ i, i0 ≤ m, i 6= i0 , 1 ≤ k ≤ 3m.
pi3m(i0 −1)+k = 0
That is, if we put the jobs into m groups (1, ..., 3m), ..., (3m2 − 3m + 1, ..., 3m2 ), then under scenario i, only jobs in the ith group have positive processing times, and the processing time of the kth job 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 I1 , ..., Im exists if and only if the (RSS)R problem has the following optimal values:
zR =
3m (3m2 + m+1 ) 3m R = a, k=1 sk − m k=1 ksk 2 P P 3m (3m2 − 5m+1 ) 3m k=1 sk − (m − 1) k=1 ksk R = d, 2
P
(3m2 − 5m+1 ) 2
P
P3m P3m sk −(m−1) k=1 ksk k=1 P3m P3m
(3m+1)
s − k=1 k
k=1
ksk
R = r.
First, we demonstrate the case where R = a. To prove the only if part, we consider the following solution: x∗3m(i−1)+k,m(k−1)+(j+i−1 mod m) = 1 xuv = 0
1 ≤ i, j ≤ m, 1 ≤ k ≤ 3m, k ∈ Ij ,
otherwise, 1 ≤ u, v ≤ 3m2 .
Because I1 , ..., Im are disjoint sets that exactly cover set I = {1, ..., 3m}, x∗ is actually a feasible solution that permutes the 3m2 jobs to 3m2 different positions.
17
Under this solution x∗ , we have: 1
∗
f (x ) =
m X X
{3m2 − [(k − 1)m + i] + 1}sk
i=1 k∈Ii
2
= (3m + m + 1)
m X X
sk − m
i=1 k∈Ii
= (3m2 + m + 1)
3m X
sk − m
k=1
m X X
ksk −
i=1 k∈Ii
3m X
ksk −
k=1
= (3m2 + f 2 (x∗ ) − f 1 (x∗ ) = (m − 1)
m X X
i
i=1
sk
k∈Ii
3m m(m + 1) 1 X × sk 2 m k=1
3m 3m X m+1 X ) sk − m ksk , 2 k=1 k=1
X
sk −
k∈Im
X
X
sk = 0,
i6=m−1 k∈Ii
···, f m (x∗ ) − f m−1 (x∗ ) = (m − 1)
X
sk −
k∈I2
XX
sk = 0.
i6=2 k∈Ii
3m Therefore, we have z(x∗ ) = max{f 1 (x∗ ), ..., f m (x∗ )} = (3m2 + m+1 ) 3m k=1 sk −m k=1 ksk , 2 P P 3m and za ≤ z(x∗ ) = (3m2 + m+1 ) 3m k=1 sk − m k=1 ksk . 2 On the other hand, we can design a surrogate relaxation of the original problem with the following processing times:
P
p¯3m(i−1)+k =
Pm
j=1
pj3m(i−1)+k m
=
P
sk . m
According to the SPT rule for (SS) problem, x∗ is an optimal solution for the surrogate relaxation, with optimal value 3m X m X
3m X sk m+1 z= { [3m − (k − 1)m − i + 1] } = [3m2 − (k − 1)m − + 1]sk m 2 k=1 i=1 k=1 2
= (3m2 +
3m 3m X m+1 X ) sk − m ksk = z(x∗ ). 2 k=1 k=1
We also know that za ≥ z (see Nemhauser and Wolsey[16]). Thus, we get za ≥ z(x∗ ). So, finally we get za = z(x∗ ) = (3m2 +
3m 3m X m+1 X ) sk − m ksk . 2 k=1 k=1
3m To prove the if part, note that when za = (3m2 + m+1 ) 3m k=1 sk − m k=1 ksk , 2 the optimal solution x is also optimal for the surrogate relaxation, because we have P P3m za ≥ z and z = (3m2 + m+1 ) 3m k=1 sk − m k=1 ksk . Following the SPT rule for the 2
P
18
P
single scenario problem of surrogate relaxation, job 3m(i − 1) + k must correspond to position m(k − 1) + j, for 1 ≤ i, j ≤ m, 1 ≤ k ≤ 3m. For 1 ≤ i, j ≤ m, we define: Iji = {k|x3m(i−1)+k,m(k−1)+j = 1, 1 ≤ k ≤ 3m}. The properties of Iji ’s are: f orj 6= j 0 ,
Iji ∩ Iji0 = ∅ 0
f ori 6= i0 ,
Iji ∩ Iji = ∅ m [
Iji0 = I = {1, ..., 3m}
m [
Iji = I = {1, ..., 3m}
1 ≤ i ≤ m,
j 0 =1 0
1 ≤ j ≤ m.
i0 =1
For za = max{f 1 (x), ..., f m (x)}, we have: m X X
f i (x) =
{3m2 − [(k − 1)m + j] + 1}sk
j=1 k∈I i j
2
= (3m + m + 1)
3m X
sk − m
3m X
k=1
k=1
≤ za
ksk −
m X
j
j=1
X
sk
k∈Iji
1 ≤ i ≤ m.
So for every i ∈ {1, ..., m}, we have m X
j=1
j
X
sk ≥
k∈Iji
3m m+1 X sk . 2 k=1
In summing the above inequalities from i = 1 to i = m, we get m m X X X
3m m(m + 1) X sk ≥ sk . j 2 j=1 i=1 k∈I i k=1 j
But from the properties of Iji ’s, we have m m X X X
j
j=1
sk =
i=1 k∈I i
m X
j=1
j
j
3m X
sk =
k=1
3m m(m + 1) X sk . 2 k=1
3m m+1 Therefore, m k∈Iji sk = 2 k=1 sk , ∀i ∈ {1, ..., m}. This is only possible when j=1 j P we have disjoint sets I1 , ..., Im covering set I = {1, ..., 3m}, such that k∈Ii sk =
P
P
P
19
1 m
P3m
i sk = B, and {I1i , ..., Im } for every i is just a distinct permutation of {I1 , ..., Im }. The I1 , ..., Im 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: P P3m s z 1 = · · · = z m = (3m + 1) 3m k=1 sk − k=1 ksk . Therefore, the z term in the objective 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. k=1
References [1] Agrawala, A.K., E.G. Coffman, Jr., M.R. Garey, and S.K. Tripathi (1984), “A Static Optimization Algorithm Minimizing Expected Flowtime on Uniform Processors,” IEEE Transactions on Computing, 33, pp. 351-357. [2] Allahverdi, A. and J. Mittenthal (1994), “Two-Machine Ordered Flowshop Scheduling Under Random Breakdowns,” Mathematical and Computer Modeling, 20, pp. 9-17. [3] Allahverdi, A. and J. Mittenthal (1994), “Scheduling on M Parallel Machines Subject to Random Breakdowns to Minimize Expected Mean Flow Time,” Naval Research Logistics, 41, pp. 677-682. [4] Allahverdi, A. and J. Mittenthal (1995), “Scheduling on a Two-Machine Flowshop Subject to Random Breakdowns with a Makespan Objective Function,” European Journal of Operational Research, 81, pp. 376-387. [5] Birge, J., J.B.G. Frenk, J. Mittenthal, and A.H.G. Rinnooy Kan (1990), “Single Machine Scheduling Subject to Stochastic Breakdowns,” Naval Research Logistics, 37, pp. 661-677. [6] Birge, J.R. and K. Glazebrook (1988), “Assessing the Effects of Machine Breakdown in Stochastic Scheduling,” Operations Research Letters, 7, pp. 267-271. [7] Daniels, R.L and P. Kouvelis (1995), “Robust Scheduling to Hedge Against Processing Time Uncertainty in Single-Stage Production,” Management Science 41, 2, pp. 363-376. [8] Du, C. and M. Pinedo (1995), “A Note on Minimizing the Expected Makespan in Flowshops Subject to Breakdowns,” Naval Research Logistics, 42, pp. 1251-1262. 20
[9] Emmons, H. and M. Pinedo (1990), “Scheduling Stochastic Jobs with Due Dates on Parallel Machines,” European Journal of Operational Research, 47, pp. 49-55. [10] Garey, M.R. and D.S. Johnson (1979), Computers and Intractability, W.H. Freeman, San Francisco. [11] Glazebrook, K.D. (1979), “Scheduling Tasks with Exponential Service Times on Parallel Processors,” Journal of Applied Probability, 16, pp. 685-689. [12] Glazebrook, K. (1987), “Evaluating the Effects of Machine Breakdowns in Stochastic Scheduling Problems,” Naval Research Logistics, 34, pp. 319-335. [13] Glazebrook, K. (1991), “On Non-preemptive Policies for Stochastic Single Machine Scheduling with Breakdown,” Probability in the Engineering and Informational Science, 5, pp. 77-87. [14] Kampke, T. (1989), “Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Machines,” Operations Research, 37, pp. 126-133. [15] Kouvelis, P. and G. Yu (1997), Robust Discrete Optimization and Its Applications, Kluwer Academic Publishers, Boston. [16] Nemhauser, G.L. and L.A. Wolsey (1988), Integer and Combinatorial Optimization, John Wiley & Sons, New York. [17] Pinedo, M.L. and S.H. Ross (1980), “Scheduling Jobs Subject to Nonhomogeneous Poisson Shocks,” Management Science, 26, pp. 1250-1257. [18] Weiss, G. and M. Pinedo (1980), “Scheduling Tasks with Exponential Service Times on Nonidentical Processors to Minimize Various Cost Functions,” Journal of Applied Probability, 17, pp. 187-202. [19] Yu, G. and J. Yang (1998), “On the Robust Shortest Path Problem,” Computers & Operations Research, 25:6, pp. 457-468.
21
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 NP-complete 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
1
Introduction
We have a set of n jobs to be processed on a single machine with the processing time of job i being pi , i = 1, ..., n. All jobs 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 jobs which minimizes the sum of completion times of all jobs. In standard machine scheduling terms, the problem is P denoted by 1// Cj . We define xij = 1 if job i is assigned to the jth position of the processing sequence and 0 otherwise. The integer programming formulation of (SS) is: n n (SS)
z = min
XX
(n − j + 1)pi xij
i=1 j=1
subject to
n X
xij = 1
j = 1, ..., n,
n X
xij = 1
i = 1, ..., n,
i=1
j=1
xij ∈ {0, 1}
i, j = 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 provides an optimal sequence for (SS). According to the SPT rule, an optimal schedule is obtained by sequencing the jobs 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 job processing times and other job-related properties (for instance, due dates) are random, or the machine(s) is(are) subject to random breakdowns, or both. Glazebrook [11], Weiss and Pinedo [18], Agrawala, Coffman, Garey, and Tripathi [1], Kampke [14], and Emmons and Pinedo [9] all consider the scheduling problem where one or more aspects of jobs are random. When machine breakdown is considered, the problem is more complicated. Pinedo and Ross [17] consider scheduling jobs with random processing times on a machine experiencing external shocks occurring according to a nonhomogeneous Poisson process. Birge, Frenk, Mittenthal, and Rinnooy Kan [5] assume that processing times are deterministic and the machine has intermittent up 2
and down times that are independent random variables. In Birge and Glazebrook [6], both job processing times and machine up and down times are modeled as random variables. Other work considering random machine breakdowns include Glazebrook [12][13], Du and Pinedo [8], and Allahverdi and Mittenthal [2][3] [4]. 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 [15]) is more appropriate. In Kouvelis and Yu book, 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 Xs . We define X = ∩s∈S Xs . Three robustness measures can be defined as in Kouvelis and Yu: (1) za = minx∈X maxs∈S f s (x), (2) zd = minx∈X maxs∈S (f s (x) − z s ), (3) zr = minx∈X maxs∈S ( f
s (x)−z s
zs
),
where z s = minx∈X f s (x) is the optimal objective 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), (2) 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 symbol “r” for relative deviation). All three definitions hedge against the worst possible contingency. We define:
FRs (x)
s f (x)
= f s (x) − z s
f s (x)−z s zs
R = a, R = d, R = r.
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 ps = (ps1 , ps2 , ..., psn ). Now the constraint sets for all scenarios are 3
the same, Xs = X, s ∈ S with X containing the assignment constraints and integer requirements on all the variables. The objective function for scenario s is f s (x) = Pn Pn s i=1 j=1 (n − j + 1)pi xij . Note that no restrictions are placed on the scenario set S. In the case where processing times are given by intervals, i.e., interval [li , ui ] to specify the range of processing times of job i, we have an infinite 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 [7] 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 jobs 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 zR = min y subject to yRs
≥
n n X X
(n − j + 1)psi xij
s∈S
i=1 j=1 n X
xij = 1
j = 1, ..., n,
n X
xij = 1
i = 1, ..., n,
i=1
j=1
xij ∈ {0, 1}
i, j = 1, ..., n.
where yRs
y R = a, s = y+z R = d, s z (1 + y) R = r,
and z s is the optimal objective value of (SS) with processing time vector ps . 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.
4
2
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 twopartition problem is a well-known NP-complete problem (see Garey and Johnson [10]) as defined below. The two-partition problem: Instance: Finite set I and a size si ∈ Z+ for i ∈ I. Question: Is there a subset I 0 ⊆ I such that
P
i∈I 0
si =
P
i∈I\I 0
si ?
We assume that the numbers are in nondecreasing order: s1 ≤ s2 ≤ ... ≤ s|I| . For any instance of the two-partition problem, we define the following robust single machine scheduling problem with 2|I| jobs and two scenarios; i.e. n = 2|I|, |S| = 2. Let the processing time vector for the two scenarios be: s i p1i = 0
p2i =
1 ≤ i ≤ |I| 1 + |I| ≤ i ≤ 2|I|
0
s i−|I|
1 ≤ i ≤ |I| . 1 + |I| ≤ i ≤ 2|I|
With the above definition, we prove the following assertion: a two-partition I 0 ∈ I exists if and only if (RSS)R has the following optimal values:
zR
P 3 i∈I (n − 2i + 2 )si P (|I| − i + 12 )si i∈I = P (|I|−i+ 12 )si Pi∈I i∈I
(|I|−i+1)si
First, we demonstrate the case where R = a.
5
R = a, R = d, R = r.
To prove the only if part, we consider the following solution: x∗i,2i
=
1
i ∈ I0
x∗i,2i−1
=
1
i ∈ I \ I0 i ∈ I0
x∗i+|I|,2i−1 = 1 x∗i+|I|,2i
=
i ∈ I \ I 0.
1
The proposed solution above is feasible with f 1 (x∗ ) =
X
(n − 2i + 1)si +
X
(n − 2i + 2)si +
i∈I 0
f 2 (x∗ ) =
X
(n − 2i + 2)si ,
X
(n − 2i + 1)si .
i∈I\I 0
i∈I 0
i∈I\I 0
Using the definition of two-partition i∈I 0 si = i∈I\I 0 si , we obtain f 1 (x∗ ) = 1 ∗ 2 (x∗ ) P f 2 (x∗ ) = f (x )+f = i∈I (n − 2i + 32 )si . Thus, we get an upper bound z¯ for za . 2 P za ≤ z¯ = i∈I (n − 2i + 32 )si . To show the optimality of the proposed solution, we use surrogate relaxation: P
P
z = min(λ1 f 1 (x) + λ2 f 2 (x)) x∈X
where λ1 + λ2 = 1, λ1 ≥ 0, λ2 ≥ 0. The surrogate relaxation will provide a lower bound z ≤ za (see Nemhauser and Wolsey [16]). We choose λ1 = λ2 = 12 . This reduces to a single machine scheduling problem for n jobs with processing time of job i as: s /2 1 ≤ i ≤ |I| p1i + p2i i p¯i = = 2 si−|I| /2 i = 1 + |I| ≤ i ≤ 2|I|
Since p¯1 = p¯1+|I| ≤ p¯2 = p¯2+|I| ≤ ... ≤ p¯|I| = p¯2|I| , the proposed solution is optimal for this surrogate relaxation. Thus z =
n X
(n − i + 1)¯ pi
i=1 |I|
|I| 1X 1X (n − 2i + 1)si + (n − 2i + 2)si 2 i=1 2 i=1 X 3 = (n − 2i + )si 2 i∈I
=
We conclude that z = za = z¯. P To prove the if part, we note that when za = i∈I (n − 2i + 32 )si , the optimal solution x∗ is also optimal for the surrogate relaxation, because we have za ≥ z and 6
z = i∈I (n − 2i + 32 )si . According to the SPT rule for the single scenario surrogate relaxation, there must exist a subset I 0 of I such that: P
i ∈ I0
x∗i,2i = 1
i ∈ I \ I0
x∗i,2i−1 = 1
i ∈ I0
x∗i+|I|,2i−1 = 1
i ∈ I \ I 0.
x∗i+|I|,2i = 1 Therefore, we have: f 1 (x∗ ) =
X i∈I
f 2 (x∗ ) =
0
X i∈I
X
(n − 2i + 1)si +
(n − 2i + 2)si ,
i∈I \I 0
X
(n − 2i + 2)si +
0
i∈I \I
(n − 2i + 1)si . 0
From za = z, we get f 1 (x∗ ) = f 2 (x∗ ). So we find a subset I 0 of I, such that i∈I 0 si = P i∈I \I 0 si . To prove the cases where R = d and R = r, we note that the optimal value for the P single scenario case z 1 = z 2 = i∈I (|I| − i + 1)si . Thus, the z s term in the objective 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. P
Under an unbounded number of scenarios, the problems are shown to be strongly NP-hard. 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 zd = min max(f s (x) − z s ) = min max f s0 (x), x∈X s∈S
x∈X s∈S
where f s (x) = ni=1 nj=1 (n − j + 1)psi xij , while f s0 (x) = ni=1 nj=1 (n − j + 1)(psi − 2z s )xij . That is, we can uniformly distribute −z s ’s contribution to each job by n(n+1) 2z s a term − n(n+1) . No matter where each job resides in the sequence of jobs to be P
P
P
7
P
executed, there will always be exactly one job placed in the first position, exactly one job in the second, etc. The total change in the completion time will be −
n X
(n − j + 1)
j=1
2z s n(n + 1) 2z s =− = −z s . n(n + 1) 2 n(n + 1)
We thus can transform the problem of finding zd , the (RSS)R problem with the deviation measure with the parameters psi ’s, to the problem of finding za , the (RSS)R 2z s problem with the absolute measure with parameters (psi − n(n+1) )’s. In our solution 2z s s for za , pi ’s nonnegativity does not matter. Therefore, the sign of psi − n(n+1) will not affect the solution procedure. For zr , we have zr = min max( x∈X s∈S
f s (x) − z s ) = min max f s00 (x), x∈X s∈S zs ps
2 where f s00 (x) = ni=1 nj=1 (n − j + 1)( zis − n(n+1) )xij . Thus, the problem of finding zr , the (RSS)R problem with the relative deviation measure, can also be transformed to the one of finding za , 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 = (u1 , ..., un ) which indicates whether or not each job i has been put in the processing sequence, and vector α = (α1 , ..., α|S| ), which is the contribution of the jobs already in the sequence to the total completion times under all the scenarios. For a vector u, we define two index sets associated with it. They are: I(u) = {i | ui = 1, i ∈ {1, ..., n}}, and O(u) = {i | ui = 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}. Now we define:
P
P
f (u; α) = the maxs∈S f s (x) value of the sequence with the minimum of this value among all the sequences whose first | I(u) | jobs are the job i’s in the set I(u), and that these jobs’ contribution to the total completion time in scenario s is αs , ∀s ∈ S. The initial condition is: f (1n ; α) = max αs . s∈S
8
The recursive relation between f ’s of different states is: |S|
f (u; α) = min f (u(+i) ; α1 + | O(u) | p1i , ..., α|S| + | O(u) | pi ). i∈O(u)
The optimal value za = f (0n ; 0|S| ). P To get the optimal job sequence σa = (σa (1), ..., σa (n)) such that σa (j) = ni=1 ixij , ∀j ∈ {1, ..., n}, where x is the optimal solution, we let u0 = 0n , α0 = 0|S| , and k = 0. At stage k, according to the recursive relation, we will find at least one i ∈ O(uk ), that satisfies |S| |S| f (uk ; αk ) = f (uk(+i) ; αk1 + (n − k)p1i , ..., αk + (n − k)pi ). s We then let uk+1 = uk(+i) , αk+1 = αks + (n − k)psi , ∀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 (ps1 , ..., psn ) to get index sets (l1 , ..., ln ) and (m1 , ..., mn ) so that psl1 ≤ ... ≤ psln , and psm1 ≥ ... ≥ psmn ; if psl1 ≥ 0, then let k = 0; else, find k ∈ {1, ..., n} such that pslk < 0 but pslk+1 ≥ 0; Ls =
Pk
Ms = end for;
s j=1 (n − j + 1)plj ; Pn s j=1 (n − j + 1)pmj ;
for α1 = L1 to M 1 do ··· for α|S| = L|S| to M |S| do f (1, ..., 1; α1 , ..., α|S| ) = maxs∈S αs ; end for; ··· end for; for t = 1 to n do for u be any 0 − 1 vector with | O(u) |= t do for α1 = L1 to M 1 do ··· for α|S| = L|S| to M |S| do |S|
f (u; α1 , ..., α|S| ) = mini∈O(u) f (u(+i) ; α1 + tp1i , ..., α|S| + tpi );
9
end for; ··· end for; end for; 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(2n ). 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 jobs already in the sequence in current state matter, but also what jobs they are, since each job 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 jobs and two scenarios. Its parameters are: p11 = 1, p12 = 2; p21 = 3, p22 = 0. When σ = (1, 2), we have f 1 (σ) = 2 × 1 + 1 × 2 = 4, f 2 (σ) = 2 × 3 + 1 × 0 = 6, so f (σ) = 6. When σ = (2, 1), we have f 1 (σ) = 1×1+2×2 = 5, f 2 (σ) = 1×3+2×0 = 3, so f (σ) = 5. Thus, we have za = 5 and σa = (2, 1). Going through the algorithm above, we will get the following results: L1 = 0, L2 = 0, M 1 = 5, M 2 = 6, · · · , f (1, 1; 4, 6) = 6, · · · , f (1, 1; 5, 3) = 5, · · · · · · , f (0, 1; 4, 0) = f (1, 1; 4 + 1 × 1, 0 + 1 × 3) = f (1, 1; 5, 3) = 5, · · · · · · , f (1, 0; 2, 6) = f (1, 1; 2 + 1 × 2, 6 + 1 × 0) = f (1, 1; 4, 6) = 6, · · · f (0, 0; 0, 0) = min{f (1, 0; 0 + 2 × 1, 0 + 2 × 3), f (0, 1; 0 + 2 × 2, 0 + 2 × 0)} = min{f (1, 0; 2, 6), f (0, 1; 4, 0)} = min{6, 5} = 5, · · · . Thus we have za = 5. Also, because f (0, 0; 0, 0) = f (0, 1; 4, 0) = f (1, 1; 5, 3), we have σa = (2, 1). These agree with our enumeration results. 10
4
The Surrogate Heuristic for the Robust (SS)
For a feasible job sequence σ, za (σ) = maxs∈S f s (σ) = maxs∈S ( nj=1 (n−j+1)psj ) is the 1 P s objective function of the (RSS)a problem. We now introduce zSU (σ) = |S| s∈S f (σ), the average total completion time over all the scenarios, as a new objective function. The minimization problem with the new objective 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: P
• zSU (σSU ) ≤ zSU (σa ), because σSU is the optimal solution of the minimization problem of surrogate relaxation; • zSU (σa ) ≤ za (σa ), because zSU (σ) ≤ za (σ), ∀σ being a feasible job sequence; and • za (σa ) ≤ za (σSU ), because σa is the optimal solution of the (RSS)a problem. Therefore, for the optimal value za (σa ) of the (RSS)a problem, we get one lower bound zSU (σSU ), and an upper-bound za (σSU ) which is associated with a feasible solution. While the (RSS)a problem is hard to solve, the surrogate relaxation is just 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 surrogation. A good property of the approximate optimal value za (σSU ) is that it is bounded from above. We have za (σSU ) θ|S| ≤ , za (σa ) θ+ | S | −1 s
s∈S f (σSU ) where θ = max . The proof is provided by Yu and Yang [19] in a paper on mins∈S f s (σSU ) 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 jobs:
p11 = p, p12 = ps1 =
2β | S | −β− | S | +1 p, −β | S | +2β + 2 | S | −2
3 | S | /2 3 | S | /4 p, ps2 = p, ∀s ∈ S \ {1}, −β | S | +2β + 2 | S | −2 −β | S | +2β + 2 | S | −2 11
where | S |= 3, 4, 5, β = |S| + 1 = 74 , 2, 94 respectively is a parameter, and p > 0 is 4 another scaling parameter. Because we choose 2 1 and the common denominator is positive; 2p11 + p12 ≥ 2ps1 + ps2 , ∀s ∈ 4 S \ {1}, because β = |S| + 1 ≥ |S| + 1 and the common denominator is positive; and 4 4 1 1 s s p1 + 2p2 > p1 + 2p2 , ∀s ∈ S \ {1} because β > 1 and the common denominator is positive. Therefore, za ((2, 1)) = p11 + 2p12 > 2p11 + p12 = za ((1, 2)), and we have to set σa = (1, 2). Now, we have maxs∈S f s (σSU ) p11 + 2p12 = mins∈S f s (σSU ) p21 + 2p22 3β | S | p/(−β | S | +2β + 2 | S | −2) = = β, 3 | S | p/(−β | S | +2β + 2 | S | −2) 3(β+ | S | −1) p, za (σa ) = 2p1 + p12 = −β | S | +2β + 2 | S | −2 θ=
and za (σSU ) = p11 + 2p12 =
3β | S | p. −β | S | +2β + 2 | S | −2
Thus, the bound is reached: β|S| θ|S| za (σSU ) = = . za (σa ) β+ | S | −1 θ+ | S | −1
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 12
stage t, for every job i, a partial sequence of jobs σit = (σit (1), ..., σit (t − 1), σit (t)) is found, such that σit (t) = i; (σit (1), ..., σit (t − 1)) is the partial sequence σjt−1 where j = σit (t − 1); and σit is the partial sequence among all the partial sequences satisfying the previous two conditions that has the smallest ft (σ) value, where ft (σ) = P maxs∈S ( tj=1 (n − j + 1)psσ(j) ). After stage n, we examine the sequences obtained at stage n for all the jobs and pick the one σin with the minimum fn (σin ) as the solution σGP . The intuition behind the procedure is the SPT rule. We place more weight on earlier jobs. 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 σi1 = (i); end for; for t = 2 to n do for i = 1 to n do t−1 iP RE = argminj=1,...,n,i∈σ / t−1 ft ((σj , i)); j
, i); σit = (σit−1 P RE end for; end for; i0 = argmini=1,...,n fn (σin ); σGP = σin0 ;
The algorithm takes O(n4 | S |) time to execute. It is possible that σit does not exist for some t and i due to the nonexistence of a σjt−1 which does not contain i. However, a feasible solution is always guaranteed. For σit not to exist for some i at some t > 1, i must be in the partial sequence σjt−1 ’s for every j ∈ {1, ..., n}. So, for σin not to exist for all the i ∈ {1, ..., n}, σjn−1 has to have all the jobs 1, ..., n, ∀j ∈ {1, ..., n}. Since every σjn−1 only contains n − 1 jobs, this is impossible. In the above algorithm, we let iP RE = 0 when there is no non-NULL partial sequence σjt−1 to which i does not belong, σ0t = NULL, and (NULL, i) = NULL. An improvement of the GreedyHeuristic can be achieved when, at each stage t and for each job i, we not only store the best partial job 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 13
all the possibilities of growing the sequences from the previous stage’s sequences for all jobs 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 2 , because at each stage there are g times more partial job sequences and for each partial job sequence, g times more extra effort is needed to grow new sequences. Here is the pseudo code of the improved algorithm: Algorithm GreedyHeuristic (Final) for i = 1 to n do for g 0 = 1 to g do 1 = (i); σig 0
end for; end for; for t = 2 to n do for i = 1 to n do for g 0 = 1 to g do t−1 (iP RE , gP0 RE ) = argmin(g 0 )j=1,...,n,g00 =1,...,g,i∈σ / t−1 ft ((σjg 00 , i)); jg 00
t σig 0
=
, i); (σit−1 0 P RE ,gP RE
end for; end for; end for; n ); i0 = argmini=1,...,n fn (σi1
σGP = σin0 1 ;
In the above presentation, argmin(g 0 ) refers to the g 0 th minimum argument. To compare the effectiveness of GreedyHeuristic and SurrogateHeuristic, we conducted computational tests. Our code was written in C. All the jobs’ 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 jobs, 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 that GreedyHeuristic is as good as SurrogateHeuristic in the 100 runs. 14
Table 1: Comparison of the Heuristics n
|S|
g
z¯SU
z¯GP
10 10 10 10 10 10 10 10 10 10 10 10 10 20 20 20 20 20 20 20 20 20
1 2 2 2 2 5 5 5 5 10 10 10 10 2 2 2 5 5 5 10 10 10
1 1 2 5 10 1 2 5 10 1 2 5 10 1 5 10 1 5 10 1 5 10
2031.2 2559.0 2559.0 2559.0 2559.0 3082.7 3082.7 3082.7 3082.7 3418.4 3418.4 3418.4 3418.4 8978.4 8978.4 8978.4 10920.2 10920.2 10920.2 11861.9 11861.9 11861.9
2031.2 2433.5 2427.4 2421.2 2414.0 2856.7 2841.3 2826.5 2814.6 3126.9 3113.1 3092.1 3076.9 8614.8 8598.3 8592.8 10092.1 10050.9 10037.2 10869.5 10808.6 10788.5
100 ×
z¯SU −¯ zGP z¯SU
0.0 4.9 5.1 5.4 5.7 7.3 7.8 8.3 8.7 8.5 8.9 9.5 10.0 4.1 4.2 4.3 7.6 8.0 8.1 8.4 8.9 9.0
15
% m(zGP ≤ zSU ) 100 85 89 88 93 96 97 99 99 100 100 100 100 83 85 86 99 100 100 100 100 100
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 is as good as 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 NP-complete. We devised an exact dynamic programming algorithm to solve (RSS)R with complexity O(2n ). Polynomial time heuristics with interesting properties were also presented. At 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.
A
Appendix: The (RSS)R Problem is Strongly NPHard 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. Theorem 2 The (RSS)R problem is strongly NP-hard for an unbounded number of scenarios.
16
Proof: We reduce the three-partition problem to the (RSS)R problem. The threepartition problem is strongly NP-hard (see Garey and Johnson[10]), as defined below. The three-partition problem: Instance: A finite set I of 3m elements, a bound B ∈ Z+ , and a size sk ∈ Z+ for k ∈ I, such that each sk satisfies B/4 < sk < B/2 and such P that k∈I sk = mB. Question: Can I be partitioned into m disjoint sets I1 , I2 , ..., Im such that, P for 1 ≤ i ≤ m, k∈Ii sk = B? We assume that all the sizes are in increasing order: s1 < s2 < ... < s3m . For any instance of the three-partition problem, we define the following robust single machine scheduling problem with 3m2 jobs and m scenarios; i.e., n = 3m2 , |S| = m. Let the processing time vector under the various scenarios be: pi3m(i−1)+k = sk
1 ≤ i ≤ m, 1 ≤ k ≤ 3m, 1 ≤ i, i0 ≤ m, i 6= i0 , 1 ≤ k ≤ 3m.
pi3m(i0 −1)+k = 0
That is, if we put the jobs into m groups (1, ..., 3m), ..., (3m2 − 3m + 1, ..., 3m2 ), then under scenario i, only jobs in the ith group have positive processing times, and the processing time of the kth job 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 I1 , ..., Im exists if and only if the (RSS)R problem has the following optimal values:
zR =
3m (3m2 + m+1 ) 3m R = a, k=1 sk − m k=1 ksk 2 P P 3m (3m2 − 5m+1 ) 3m k=1 sk − (m − 1) k=1 ksk R = d, 2
P
(3m2 − 5m+1 ) 2
P
P3m P3m sk −(m−1) k=1 ksk k=1 P3m P3m
(3m+1)
s − k=1 k
k=1
ksk
R = r.
First, we demonstrate the case where R = a. To prove the only if part, we consider the following solution: x∗3m(i−1)+k,m(k−1)+(j+i−1 mod m) = 1 xuv = 0
1 ≤ i, j ≤ m, 1 ≤ k ≤ 3m, k ∈ Ij ,
otherwise, 1 ≤ u, v ≤ 3m2 .
Because I1 , ..., Im are disjoint sets that exactly cover set I = {1, ..., 3m}, x∗ is actually a feasible solution that permutes the 3m2 jobs to 3m2 different positions.
17
Under this solution x∗ , we have: 1
∗
f (x ) =
m X X
{3m2 − [(k − 1)m + i] + 1}sk
i=1 k∈Ii
2
= (3m + m + 1)
m X X
sk − m
i=1 k∈Ii
= (3m2 + m + 1)
3m X
sk − m
k=1
m X X
ksk −
i=1 k∈Ii
3m X
ksk −
k=1
= (3m2 + f 2 (x∗ ) − f 1 (x∗ ) = (m − 1)
m X X
i
i=1
sk
k∈Ii
3m m(m + 1) 1 X × sk 2 m k=1
3m 3m X m+1 X ) sk − m ksk , 2 k=1 k=1
X
sk −
k∈Im
X
X
sk = 0,
i6=m−1 k∈Ii
···, f m (x∗ ) − f m−1 (x∗ ) = (m − 1)
X
sk −
k∈I2
XX
sk = 0.
i6=2 k∈Ii
3m Therefore, we have z(x∗ ) = max{f 1 (x∗ ), ..., f m (x∗ )} = (3m2 + m+1 ) 3m k=1 sk −m k=1 ksk , 2 P P 3m and za ≤ z(x∗ ) = (3m2 + m+1 ) 3m k=1 sk − m k=1 ksk . 2 On the other hand, we can design a surrogate relaxation of the original problem with the following processing times:
P
p¯3m(i−1)+k =
Pm
j=1
pj3m(i−1)+k m
=
P
sk . m
According to the SPT rule for (SS) problem, x∗ is an optimal solution for the surrogate relaxation, with optimal value 3m X m X
3m X sk m+1 z= { [3m − (k − 1)m − i + 1] } = [3m2 − (k − 1)m − + 1]sk m 2 k=1 i=1 k=1 2
= (3m2 +
3m 3m X m+1 X ) sk − m ksk = z(x∗ ). 2 k=1 k=1
We also know that za ≥ z (see Nemhauser and Wolsey[16]). Thus, we get za ≥ z(x∗ ). So, finally we get za = z(x∗ ) = (3m2 +
3m 3m X m+1 X ) sk − m ksk . 2 k=1 k=1
3m To prove the if part, note that when za = (3m2 + m+1 ) 3m k=1 sk − m k=1 ksk , 2 the optimal solution x is also optimal for the surrogate relaxation, because we have P P3m za ≥ z and z = (3m2 + m+1 ) 3m k=1 sk − m k=1 ksk . Following the SPT rule for the 2
P
18
P
single scenario problem of surrogate relaxation, job 3m(i − 1) + k must correspond to position m(k − 1) + j, for 1 ≤ i, j ≤ m, 1 ≤ k ≤ 3m. For 1 ≤ i, j ≤ m, we define: Iji = {k|x3m(i−1)+k,m(k−1)+j = 1, 1 ≤ k ≤ 3m}. The properties of Iji ’s are: f orj 6= j 0 ,
Iji ∩ Iji0 = ∅ 0
f ori 6= i0 ,
Iji ∩ Iji = ∅ m [
Iji0 = I = {1, ..., 3m}
m [
Iji = I = {1, ..., 3m}
1 ≤ i ≤ m,
j 0 =1 0
1 ≤ j ≤ m.
i0 =1
For za = max{f 1 (x), ..., f m (x)}, we have: m X X
f i (x) =
{3m2 − [(k − 1)m + j] + 1}sk
j=1 k∈I i j
2
= (3m + m + 1)
3m X
sk − m
3m X
k=1
k=1
≤ za
ksk −
m X
j
j=1
X
sk
k∈Iji
1 ≤ i ≤ m.
So for every i ∈ {1, ..., m}, we have m X
j=1
j
X
sk ≥
k∈Iji
3m m+1 X sk . 2 k=1
In summing the above inequalities from i = 1 to i = m, we get m m X X X
3m m(m + 1) X sk ≥ sk . j 2 j=1 i=1 k∈I i k=1 j
But from the properties of Iji ’s, we have m m X X X
j
j=1
sk =
i=1 k∈I i
m X
j=1
j
j
3m X
sk =
k=1
3m m(m + 1) X sk . 2 k=1
3m m+1 Therefore, m k∈Iji sk = 2 k=1 sk , ∀i ∈ {1, ..., m}. This is only possible when j=1 j P we have disjoint sets I1 , ..., Im covering set I = {1, ..., 3m}, such that k∈Ii sk =
P
P
P
19
1 m
P3m
i sk = B, and {I1i , ..., Im } for every i is just a distinct permutation of {I1 , ..., Im }. The I1 , ..., Im 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: P P3m s z 1 = · · · = z m = (3m + 1) 3m k=1 sk − k=1 ksk . Therefore, the z term in the objective 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. k=1
References [1] Agrawala, A.K., E.G. Coffman, Jr., M.R. Garey, and S.K. Tripathi (1984), “A Static Optimization Algorithm Minimizing Expected Flowtime on Uniform Processors,” IEEE Transactions on Computing, 33, pp. 351-357. [2] Allahverdi, A. and J. Mittenthal (1994), “Two-Machine Ordered Flowshop Scheduling Under Random Breakdowns,” Mathematical and Computer Modeling, 20, pp. 9-17. [3] Allahverdi, A. and J. Mittenthal (1994), “Scheduling on M Parallel Machines Subject to Random Breakdowns to Minimize Expected Mean Flow Time,” Naval Research Logistics, 41, pp. 677-682. [4] Allahverdi, A. and J. Mittenthal (1995), “Scheduling on a Two-Machine Flowshop Subject to Random Breakdowns with a Makespan Objective Function,” European Journal of Operational Research, 81, pp. 376-387. [5] Birge, J., J.B.G. Frenk, J. Mittenthal, and A.H.G. Rinnooy Kan (1990), “Single Machine Scheduling Subject to Stochastic Breakdowns,” Naval Research Logistics, 37, pp. 661-677. [6] Birge, J.R. and K. Glazebrook (1988), “Assessing the Effects of Machine Breakdown in Stochastic Scheduling,” Operations Research Letters, 7, pp. 267-271. [7] Daniels, R.L and P. Kouvelis (1995), “Robust Scheduling to Hedge Against Processing Time Uncertainty in Single-Stage Production,” Management Science 41, 2, pp. 363-376. [8] Du, C. and M. Pinedo (1995), “A Note on Minimizing the Expected Makespan in Flowshops Subject to Breakdowns,” Naval Research Logistics, 42, pp. 1251-1262. 20
[9] Emmons, H. and M. Pinedo (1990), “Scheduling Stochastic Jobs with Due Dates on Parallel Machines,” European Journal of Operational Research, 47, pp. 49-55. [10] Garey, M.R. and D.S. Johnson (1979), Computers and Intractability, W.H. Freeman, San Francisco. [11] Glazebrook, K.D. (1979), “Scheduling Tasks with Exponential Service Times on Parallel Processors,” Journal of Applied Probability, 16, pp. 685-689. [12] Glazebrook, K. (1987), “Evaluating the Effects of Machine Breakdowns in Stochastic Scheduling Problems,” Naval Research Logistics, 34, pp. 319-335. [13] Glazebrook, K. (1991), “On Non-preemptive Policies for Stochastic Single Machine Scheduling with Breakdown,” Probability in the Engineering and Informational Science, 5, pp. 77-87. [14] Kampke, T. (1989), “Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Machines,” Operations Research, 37, pp. 126-133. [15] Kouvelis, P. and G. Yu (1997), Robust Discrete Optimization and Its Applications, Kluwer Academic Publishers, Boston. [16] Nemhauser, G.L. and L.A. Wolsey (1988), Integer and Combinatorial Optimization, John Wiley & Sons, New York. [17] Pinedo, M.L. and S.H. Ross (1980), “Scheduling Jobs Subject to Nonhomogeneous Poisson Shocks,” Management Science, 26, pp. 1250-1257. [18] Weiss, G. and M. Pinedo (1980), “Scheduling Tasks with Exponential Service Times on Nonidentical Processors to Minimize Various Cost Functions,” Journal of Applied Probability, 17, pp. 187-202. [19] Yu, G. and J. Yang (1998), “On the Robust Shortest Path Problem,” Computers & Operations Research, 25:6, pp. 457-468.
21
