Complexity of single machine scheduling problems under scenario-based uncertainty

Operations Research Letters 36 (2008) 338–342 www.elsevier.com/locate/orl

Complexity of single machine scheduling problems under scenario-based uncertainty Mohamed Ali Aloulou a,∗ , Federico Della Croce b a LAMSADE, Universit´e Paris Dauphine, France b D.A.I., Politecnico di Torino, Italy

Received 3 May 2006; accepted 8 November 2007 Available online 23 December 2007

Abstract We present algorithmic and computational complexity results for several single machine scheduling problems where some job characteristics are uncertain. This uncertainty is modeled through a finite set of well-defined scenarios. We use here the so-called absolute robustness criterion to select among feasible solutions. c 2007 Elsevier B.V. All rights reserved.

Keywords: Scheduling; Scenario-based uncertainty; Absolute robustness

1. Introduction This paper deals with single machine scheduling problems where uncertainty is structured by means of scenarios, each of which specifies a potential realization of job parameters. Two natural ways of describing the set S of all possible scenarios have been investigated in the literature. In the interval data case, each parameter may take any value between given lower and upper bounds, independent of the values of the other problem parameters. In the discrete scenario case, which we consider in this paper, the set S is described explicitly. When problem parameters are uncertain, it is appropriate to produce solutions with a reasonable objective function value under any likely input data scenario. For this purpose, several criteria can be applied to select a final solution. In [7], Kouvelis and Yu proposed three different robustness criteria: the absolute robustness or maximal cost, the maximal regret or robust deviation, and the relative robust deviation. In this paper, we focus on scheduling problems with the absolute robustness criterion, i.e., we search for solutions having the best worst case value over all scenarios. Consider a mono-objective scheduling problem, denoted by α|β|F according to Graham et al.’s notation [4], where F ∗ Corresponding address: LAMSADE, Universit´e Paris Dauphine, Place du Mar´echal de Lattre de Tassigny, 75775 Paris Cedex 16, France. E-mail address: [email protected] (M.A. Aloulou).

c 2007 Elsevier B.V. All rights reserved. 0167-6377/$ - see front matter doi:10.1016/j.orl.2007.11.005

denotes the objective function to minimize. Let Π be the set of all feasible schedules with respect to the problem constraints. This set is supposed to be scenario-independent. F(π, s) is the value of solution π ∈ Π under scenario s ∈ S. We denote by OPT(α|β|F, s) the problem of finding an optimal schedule πs∗ under scenario s ∈ S, satisfying F(πs∗ , s) = min F(π, s). π∈Π

To the best of our knowledge, the absolute robustness in single machine scheduling problems P has been considered only in [2,10] where, for the 1 k C j problem with uncertain processing times, two distinct proofs of the NP-hardness even for |S| = 2 were provided. The maximal regret criterion was instead much more studied (see [1,5,6,10]). Let θ be the set of uncertain problem parameters. We denote by MinMax(α|β|F, θ ) the problem of finding a schedule π A , called absolute robust schedule, minimizing the absolute robustness among all schedules π ∈ Π . It can be stated as min max F(π, s).

π∈Π s∈S

Notice that if problem α|β|F is NP-hard, then, in the presence of uncertainty, the corresponding problems MinMax(α|β|F, θ ) are also NP-hard. However, if problem α|β|F is polynomially solvable, then, the corresponding

339

M.A. Aloulou, F. Della Croce / Operations Research Letters 36 (2008) 338–342

problems MinMax(α|β|F, θ ) are not necessarily polynomially solvable. In this work we establish the complexity status for the absolute robustness versions of several well-known non-preemptive polynomial-time single machine P scheduling problems, namely problems 1|prec| f , 1 k w j C j and max P 1 k U j . The corresponding functions are: • the general maximum cost function f max = max j { f j (C j )} with f max ∈ {Cmax , L max , Tmax }: hence we deal with the maximum completion time (makespan) Cmax = max j {C j }, the maximum lateness L max = max j {L j } with L j = C j − d j and the maximum tardiness Tmax = max j {T j } with T j = max{0, L j }; P • the total weighted completion P time j w j C j ; • the number of late jobs j U j with U j = 0, if job j is on time (C j ≤ d j ) and U j = 1 if j is late (C j > d j ). Notice that all these problems present regular cost functions. In this context any schedule π ∈ Π is completely characterized by the corresponding job sequence. Given a schedule π ∈ Π , the completion time of job j ∈ N = {1, . . . , n} under scenario s, denoted by C j (π, s), s ∈ S, can easily be determined and the quality of the schedule π under scenario s is then evaluated using the regular cost function F(π, s). We denote by p sj , d sj and w sj , respectively, the processing time, the release date, the due date and the weight of job j under scenario s ∈ S. Using the set S of scenarios, we construct a scenario s w in which parameters k j take their worst-case value, denoted by k wj . In our case, we have p wj = maxs∈S p sj , s s w dw j = mins∈S d j and w j = maxs∈S w j . Notice that in the context of a discrete set of scenarios, the constructed scenario is not necessarily feasible, i.e., we can have s w 6∈ S: s w is called an artificial worst-case scenario. Remark 1. In the interval data case, s w is a feasible scenario. In this case, an absolute robust solution π A of problem MinMax(1|β|F, θ ) is a solution of min max F(π, s) = min F(π, s w ).

π∈Π s∈S

π∈Π

Hence π A is also optimal for the problem OPT(1|β|F, w s ). This means that the problem of finding an absolute robust sequence can be solved straightforwardly by the algorithm solving the problem without uncertainty applied to the artificial worst-case scenario.  In the discrete scenario case, we cannot apply the same reasoning because scenario s w is not necessarily feasible. Nevertheless, we show in this paper that problem MinMax(1|prec|L max , d j ) can be solved by Lawler’s algorithm applied to the artificial worst-case scenario. We also prove that an extension of Lawler’s algorithm, called here MinMax-Lawler, solves problem MinMax(1|prec| f max , p j , d j ) in Ppolynomial time. On the other hand, P problems MinMax(1 k w j C j , w j ) and MinMax(1 k U j , p j ) are proved to be NP-hard even when |S| = 2. However, problem MinMax(1 k P U j , d j ) remains open. Table 1 summarizes the above results presenting the complexity status for the absolute robustness versions of

the most well-known non-preemptive polynomial-time single machine scheduling problems, where an entry “–” indicates that P the considered case does not apply (for instance problem 1 k w j C j cannot have uncertainty on due dates as due dates are not present in the problem). 2. Problem MinMax(1|prec| fmax , θ) 2.1. Uncertainty about the due dates We consider the problem MinMax(1|prec| f max , d j ) with deterministic processing times and uncertain due dates (here f max ∈ {L max , Tmax } as for Cmax no uncertainty holds). In this case the artificial worst-case scenario s w is such that, for all s j ∈ N , dw j = mins∈S d j . Lawler’s algorithm [8] for solving 1|prec| f max constructs an P optimal schedule backwards, starting with point t = P = j∈N p j , and chooses among the unscheduled jobs having no successors a job with minimum cost to be completed at t. Notice that as processing times are deterministic, we have ∀π ∈ Π , ∀s ∈ S, ∀ j ∈ N ,

C j (π, s) = C j (π ).

The following theorem holds. Theorem 1. Problem MinMax(1|prec| f max , d j ) can be solved to optimality in O(n 2 + n|S|) time by means of Lawler’s algorithm applied to the artificial worst-case scenario s w . Proof. In the following, for the sake of clarity we consider that f max = L max but the same analysis holds for f max = Tmax . An absolute robust solution π A of problem MinMax(1|prec|L max , d j ) is such that max L max (π A , s) = min max L max (π, s) π∈Π s∈S

s∈S

= min max max(C j (π, s) − d sj ) π∈Π s∈S j∈N

= min max max(C j (π ) − d sj ) π∈Π s∈S j∈N

= min max max(C j (π ) − d sj ) π∈Π j∈N s∈S

w = min max(C j (π ) − d w j ) = min L max (π, s ). π∈Π j∈N

π∈Π

Hence, π A is also an optimal solution for problem OPT(1|prec|L max , s w ). For the complexity, the construction of the worst-case scenario requires O(n|S|) time and the application of Lawler’s algorithm requires O(n 2 ) time, hence the overall complexity is O(n 2 + n|S|).  We observe that the proof of Theorem 1 can be applied, as it is, to any scheduling problem α|β| f max . Hence, we have the following result. Corollary 1. Any algorithm solving to optimality problem α|β| f max provides an absolute robust solution for problem MinMax(α|β| f max , d j ), when applied to the artificial worstcase scenario s w .

340

M.A. Aloulou, F. Della Croce / Operations Research Letters 36 (2008) 338–342

We can reiterate the same reasoning and transform sequence π A into sequence (1, 2, . . . , n) without increasing the objective function value. 

Table 1 Summary of the obtained results Uncertain parameter

Corresponding deterministic problem 1k

P

wjCj

1|prec| f max

1k

P

Uj

dj

–

O(n 2 + n|S|) (Theorem 1)

Open

pj

NP-hard (Ref. [2,10])

O(n 2 |S|) (Corollary 2)

NP-hard (Theorem 4)

NP-hard (Theorem 3)

–

–

–

O(n 2 |S|)

wj p j and d j p j and w j

NP-hard (Ref. [2,10])

(Theorem 2)

NP-hard (Corollary 3)

–

–

2.2. Uncertainty about the processing times and the due dates We consider problem MinMax(1|prec| f max , p j , d j ) where we suppose now that both processing times and due dates are uncertain. We propose an algorithm, called MinMax-Lawler, which is an extension of Lawler’s algorithm. This algorithm constructs a sequence π in reverseP order. Let U be the set of unscheduled jobs. Define p s (U ) = j∈U p sj for all s ∈ S. The rule is the following: Schedule last the job j ∈ U , which has no successor in U and such that maxs∈S f js ( p s (U )) is minimal. The complexity of MinMax-Lawler is O(n 2 |S|). We have the following result. Theorem 2. Problem MinMax(1|prec| f max , p j , d j ) is solved to optimality by the algorithm MinMax-Lawler. Proof. The proof is very similar to the proof of Lawler’s algorithm optimality for the problem 1|prec| f max . Renumber the jobs in such a way that (1, 2, . . . , n) is the sequence constructed by the proposed algorithm. Let π A be an absolute robust sequence for the problem MinMax(1|prec| f max , p j , d j ) with π A (i) = i for i = n, n − 1, . . . , r and π A (r ) = j < r . Notice that it is possible to schedule r −1 immediately before r . Hence, we can construct a sequence π 0 in which we shift to the left the block between jobs r − 1 and r and process r − 1 immediately before r . Clearly, ∀i ∈ N − {r − 1}, ∀s ∈ S,

Ci (π 0 , s) ≤ Ci (π A , s).

Hence, max F(π 0 , s) s∈S

= max{max F(π A , s), max frs−1 (Cr −1 (π 0 , s))} s∈S

s∈S

= max{max F(π A , s), max frs−1 (C j (π A , s))} s∈S

s∈S

≤ max{max F(π , s), max f js (C j (π A , s))} A

s∈S

s∈S

≤ max F(π , s). A

s∈S

Consequently π 0 is also an absolute robust sequence.

Correspondingly, the following corollary also holds. Corollary 2. Problem MinMax(1|prec| f max , p j ) is solved to optimality by the algorithm MinMax-Lawler. 3. Problem MinMax(1 k

P

w jC j, w j)

P We consider problem MinMax(1 k w j C j , w j ) where processing times are deterministic and weights are uncertain. We prove that this problem is NP-hard even when |S| = 2 and p j = 1 ∀ j. To this extent we need to prove the following lemma. P P Lemma 1. Problems 1 k C j and 1| p j = 1| w j C j are equivalent. P Proof. Given any instance of the 1 k C j problem where each job j has processing time p 0j , generate an instance of P the 1| p j = 1| w j C j problem where each job j has weight w 00j = p 0j . We show that the cost function value Z 1 of a generic P sequence π = (1, 2, . . . , n − 1, n) for the 1 k C j problem is equal to the cost function value Z 2 of thePinverse sequence π i = (n, n − 1, . . . , 2, 1) for the 1| p j = 1| w j C j problem. P P Indeed, Z 1 = nj=1 (n − j + 1) p 0j and Z 2 = 1j=n (n − j + P n 0 1)w 00j = j=1 (n − j + 1) p j = Z 1 . Hence, sequence π is P optimal forPthe 1 k C j iff sequence π i is optimal for the 1| p j = 1| w j C j problem.  Theorem 3. Problem MinMax(1 k even when |S| = 2 and p j = 1 ∀ j.

P

w j C j , w j ) is NP-hard

Proof. Due toPLemma 1 and the NP-hardness of problem MinMax(1 k C j , p j ) from [2,10], the proof immediately follows.  4. Problem MinMax(1 k

P

U j , θ)

4.1. Uncertainty about the due dates P For problem MinMax(1 k U j , d j ) where processing times are deterministic and due dates are uncertain, we were not able to find any conclusive result. We can only show by a counterexample that it cannot be solved by the wellknown Moore’s algorithm [9] applied to the artificial worstcase scenario. Indeed, consider the following example: five jobs 1, . . . , 5 and two scenarios with p1 = 3, p2 = 3, p3 = 2, p4 = 2, p5 = 10, d11 = 4, d21 = 6, d31 = 1, d41 = 1, d51 = 10, d12 = 2, d22 = 2, d32 = 8, d42 = 10 and d52 = 10. The unique optimal sequence is (1, 2, 3, 4, 5) with maximum cost 3 while in the worst-case scenario, jobs 1, . . . 4 are late in any sequence. Hence, Moore’s algorithm applied to the worst-case scenario would sequence job 5 first and then jobs 1, . . . , 4 in any order, with maximum cost 4.

341

M.A. Aloulou, F. Della Croce / Operations Research Letters 36 (2008) 338–342

= a1 + a3 + · · · + a2i−3 + a2i−4

4.2. Uncertainty about the processing times P We prove that problem MinMax(1 k U j , p j ) is NP-hard even when |S| = 2 by constructing a reduction from the NPcomplete even–odd partition problem [3]. Even–odd partition problem: P Given 2n positive integers a1 < a2 < · · · < a2n where 2n j=1 a j = 2B, is there a partition of the integers into two subsets A1 and A2 such that X X aj = B aj = j∈A2

j∈A1

=

p22

=

a1 , p12

1 1 2 2 B = p2i + p2i−1 = p2i + p2i

= a2i + a2i−1 + 2 ∗ a2i−2 + · · · + 2 ∗ a4 + 2 ∗ a2 . The completion time of the last job is greater than or equal to A + B = a1 + a3 + · · · + a2i−3 + a2i + 2a2i−2 + . . . + ia2 = a1 + a3 + · · · + a2i−3 + d2i

and A1 and A2 each contains exactly one element of each pair (a2i−1 , a2i ), i = 1, . . . , n ? Given an instance of the even–odd partition problem, we P construct the following instance of the MinMax(1 k U j , p j ). P Instance of problem MinMax(1 k U j , p j ): We have 2n jobs and two scenarios 1 and 2. Job processing times and due dates are such that p11

+ · · · + (i − 2) ∗ a2 .

=

p21

= a2 , d1 = d2 = a2

∀i = 2, . . . , n  1 2 p2i−1 = p2i = a2i−1 + a2i−2 + · · · + a2    2 1   p2i−1 = p2i = a2i + a2i−2 + · · · + a2 d2i−1 = d2i = a2i + 2a2i−2 + · · · + ia2 ,    for i < n, and,   d2n = d2n−1 = B + d2n−2 . Jobs 2i − 1 and 2i are called a[i] - jobs. Notice that with this construction, the following lemmata hold. Lemma 2. Any sequence in which each position i, i = 1, . . . , n, is occupied by an a[i] - job admits at least n − 1 ontime jobs. Proof. We can prove straightforwardly that in such a sequence the first n − 1 jobs are on time.  Lemma 3. If two jobs 2i and 2i −1 are both on time, then there exists a j, 1 ≤ j < i, such that jobs 2 j and 2 j − 1 are both late. Proof. Suppose by contradiction that there exists a sequence in which for all j, 0 ≤ j < i, at least one job 2 j or 2 j −1, denoted a[ j] -job, is on time and that jobs 2i and 2i − 1 are both on time. Resequencing these on-time jobs in a non-decreasing order of their due dates does not increase the number of late jobs. In this new sequence, jobs 2i and 2i − 1 are sequenced last with respect to the considered on-time jobs. The completion time of the last job (2i or 2i − 1) is greater than or equal to 1. the sum of the minimal processing times of a[ j] -jobs scheduled before jobs 2i and 2i − 1, 0 ≤ j < i, denoted by A, plus, 2. the processing times of jobs 2i and 2i − 1, denoted by B. We have A = a1 + (a3 + a2 ) + (a5 + a4 + a2 ) + · · · + (a2i−3 + a2i−4 + · · · + a4 + a2 )

> d2i . Hence at least one job among jobs 2i and 2i − 1 is late. This contradicts the considered hypothesis.  Lemma 4. Every schedule admits at most n on-time jobs. Proof. Suppose by contradiction that there exists a sequence such that the number of on-time jobs is greater than or equal to n + 1. Resequencing the on-time jobs in a non-decreasing order of their due dates and sequencing late jobs last does not increase the number of late jobs. Let π be such a sequence. Since we have n + 1 on-time jobs, there exist at least an integer i such that jobs 2i and 2i − 1 are both on time. Let i ∗ be the smallest i such that 2i and 2i − 1 are both on time and πi ∗ be the subsequence of on-time jobs among jobs k, 1 ≤ k ≤ 2i ∗ . We have π = (πi ∗ , π R ). Notice that in subsequence πi ∗ there are at most i ∗ jobs, which are all on time. Due to Lemma 3, there exists an integer j, 1 ≤ j < i ∗ , such that neither job 2 j nor job 2 j − 1 is on time. We construct a new subsequence of sequence πi0∗ in which we exchange one job among 2i ∗ and 2i ∗ − 1 (which are on time in π) with job 2 j or 2 j − 1 (which are late in π). For example, we exchange jobs 2i ∗ and 2 j − 1. Then, we reorder the jobs of πi0∗ in a nondecreasing order of their due dates. Due to Lemma 2, all jobs s , then sequence of πi0∗ are on time. Since ∀s ∈ S, p2s j−1 < p2i ∗ 0 (πi ∗ , π R ) has at least the same number jobs on time as π. We can reiterate the same reasoning until we get a sequence in which we have at most n − 1 jobs on time among jobs 1, . . . , 2n − 2. Since we have at least n + 1 jobs on time, jobs 2n and 2n − 1 are both on time but this cannot occur due to Lemma 3.  The following theorem holds. Theorem 4. Problem MinMax(1 k if |S| = 2.

P

U j , p j ) is NP-hard even

Proof. We first prove that, if the even–odd partition problem has a solution, the constructed instance admits a solution with n on-time jobs. Let A1 be a solution of the even–odd partition problem. Consider a sequence π = (π1 , π2 ) such that • for all j ≤ 2n, if a j ∈ A1 then job j ∈ π1 ; • the jobs of π1 are ordered in non-decreasing order of their due dates.

342

M.A. Aloulou, F. Della Croce / Operations Research Letters 36 (2008) 338–342

Suppose that π = ([1], [2], . . . , [n], [n+1], [n+2], . . . [2n]) and π1 = ([1], [2], . . . , [n]) Due to Lemma 2, the first n − 1 jobs in π1 are on time. We prove that the last job in π1 is also on time. The completion time of the last job [n] in scenario s1 is

The completion time of job [n] in scenario s2 is 2 2 2 C[n] (π 0 , s2 ) = p[1] + p[2] + · · · p[n]

= a[n+1] + a[n+2] + · · · + a[2n] + a2n−2 + · · · + (n − 1) ∗ a2 = a[n+1] + a[n+2] + · · · + a[2n] + d2n−2 .

1 1 1 C[n] (π, s1 ) = p[1] + p[2] + · · · p[n]

= a[1] + (a[2] + a2 ) + · · · + (a[n] + a2n−2 + · · · + a4 + a2 ) = a[1] + a[2] + · · · + a[n] + a2n−2 + · · · + (n − 1) ∗ a2 = B + d2n−2 = d2n = d2n−1 = d[n] . The completion time of the last job [n] in scenario s2 is 2 2 2 C[n] (π, s2 ) = p[1] + p[2] + · · · + p[n]

= a[n+1] + (a[n+2] + a2 ) + · · · + (a[2n] + a2n−2 + · · · + a4 + a2 )

Since job [n] is on time then ∀s ∈ {s1 , s2 }, C[n] (π 0 , s) ≤ d[n] = d2n = d2n−1 = B + d2n−2 . Consequently, we have a[1] + a[2] + · · · + a[n] ≤ B, a[n+1] + a[n+2] + · · · + a[2n] ≤ B and a[1] + a[2] + · · · + a[2n] = B. This proves that a[1] +a[2] +· · ·+a[n] = a[n+1] +a[n+2] +· · ·+a[2n] = B, which means that the even–odd partition problem has a solution.  Correspondingly, the following corollary also holds. P Corollary 3. Problem MinMax(1 k U j , p j , d j ) is NP-hard even when |S| = 2.

= a[n+1] + a[n+2] + · · · + a[2n] + a2n−2 + · · · + (n − 1) ∗ a2 = B + d2n−2 = d2n = d2n−1 = d[n] . Consequently, job [n] is on time for the two scenarios and the number of on-time jobs in π is at least n and cannot be greater than n due to Lemma 4. We prove now that if the constructed instance admits a solution with n on-time jobs, then the even–odd partition problem admits a solution. Let π be a sequence in which the number of on-time jobs is equal to n. Suppose that in π, there exist two on-time jobs 2i and 2i − 1. Then, due to Lemma 3, there exists an index j, 1 ≤ j < i, such that jobs 2 j and 2 j − 1 are both late. Using the same technique as in Lemma 4, we transform sequence π in a new sequence in which job 2 j or 2 j − 1 is on time and job 2i or 2i − 1 is late. We reiterate the same reasoning until we get a sequence π 0 , in which for all k, 1 ≤ k ≤ n, only one job among jobs 2k and 2k − 1 is on time. Resequencing the on-time jobs in a non-decreasing order of their due dates and sequencing the late jobs last we do not increase the number of late jobs. We have π 0 = ([1], [2], . . . , [n], [n + 1], [n + 2], . . . [2n]) and jobs [i], 1 ≤ i ≤ n are on time. The completion time of job [n] in scenario s1 is 1 1 1 C[n] (π 0 , s1 ) = p[1] + p[2] + · · · p[n]

= a[1] + a[2] + · · · + a[n] + a2n−2 + · · · + (n − 1) ∗ a2 = a[1] + a[2] + · · · + a[n] + d2n−2 .

Acknowledgments The research was performed while the second author was visiting LAMSADE on a research position funded by the CNRS. The authors are very grateful to an anonymous referee for the suggestions to improve the presentation and the content of the paper and to Dr. Hassene Aissi who has pointed out an error in an earlier version of the paper. References [1] I. Averbakh, Minmax regret solutions for minimax optimization problems with uncertainty, Operations Research Letters 27 (2000) 57–65. [2] R.L. Daniels, P. Kouvelis, Robust scheduling to hedge against processing time uncertainty in single stage production, Management Science 41 (1995) 363–376. [3] M.R. Garey, D.S. Johnson, Computers and Intractability: A Guide to the Theory of NP-Completeness, W. H. Freeman, 1979. [4] R.L. Graham, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Optimization and approximation in deterministic machine scheduling: A survey, Annals of Discrete Mathematics 5 (1979) 287–326. [5] A. Kasperski, Minimizing maximal regret in the single machine sequencing problem with maximum lateness criterion, Operations Research Letters 33 (2005) 431–436. [6] P. Kouvelis, R.L. Daniels, G. Vairaktarakis, Robust scheduling of a twomachine flow shop with uncertain processing times, IIE Transactions 32 (2000) 421–432. [7] P. Kouvelis, G. Yu, Robust Discrete Optimisation and its Applications, Kluwer Academic Publisher, 1997. [8] E.L. Lawler, Optimal sequencing of a single machine subject to precedence constraints, Management Science 19 (1973) 544–546. [9] J.M. Moore, A n job, one machine sequencing algorithm for minimizing the number of late jobs, Management Science 15 (1968) 102–109. [10] J. Yang, G. Yu, On the robust single machine scheduling problem, Journal of Combinatorial Optimization 6 (2002) 17–33.