Polynomially solvable cases for scheduling deteriorating jobs with rejection Ming Liu
Chengbin Chu
School of Economics and Management Tongji University Shanghai, 200092, P.R. China Email:
[email protected]
Laboratoire G´enie Industriel Ecole Centrale Paris Grande Voie des Vignes 92295 Chˆatenay-Malabry Cedex, France Email:
[email protected]
Abstract—This paper considers the problem of scheduling proportionally deteriorating jobs with rejection on a single machine. Deteriorating job means that its actual processing time is a increasing function on its execution starting time. In this setting, jobs can be rejected by paying penalties. The objective is to minimize the makespan plus the total penalty incurred by rejecting jobs. It is known that this problem is NP-hard [13]. We show some polynomial-time solvable cases and propose the corresponding algorithm. Then we explore an modified criterion which can be solved polynomially.
I. I NTRODUCTION In the classical scheduling theory, job processing times are considered to be constant, or to say, independent of their starting times [2]. In reality, however, we often encounter the situations in which processing time is time-dependent. Examples can be found in steel production, machine maintenance and fire fighting, where any delay in dealing with a task may increase its completion time [3]. Paper [4], as well as [5], first introduced job’s deterioration. They assume the actual processing time of a job j is aj + bj t (bj > 0), where aj is the basic processing time, bj the deteriorating rate, and t the starting time. They also showed that sequencing jobs in non-decreasing order of aj /bj minimizes the makespan. Paper [6] studied the problem to minimize total flow time (or total completion time) with the actual processing time of job j equal to a + bj t, where a is a common basic processing time. He showed that an optimal schedule is V -shaped with respect to bj . He further introduced the simple linear deteriorating jobs, where all jobs have a 0 basic processing time [15]. He proposed several algorithms polynomially solving the problems to minimize makespan, flow time, total weighted flow time, maximum lateness, maximum tardiness and the number of tardy jobs. Paper [8] considered the step-deteriorating variant and gave a pseudo-polynomial algorithm for the makespan minimization problem. Other results of scheduling models considering job deterioration can be found in [9], [10], [11]. In the literature, it is always assumed that all jobs have to be processed. In practice, however, some jobs may be rejected. In order to reduce processing costs, the decision-maker of a
978-1-4673-5200-0/13/$31.00 ©2013 IEEE
factory may choose some tasks with long processing times to be fabricated by other factories while paying some fees. Therefore, a complicated situation is that we must decide in two aspects: whether to reject a job and if we accept it then how to schedule the job. Paper [12] first considered the scheduling problem with rejection. It’s assumed that jobs must be processed in any schedule, in traditional scheduling problem. In practice, some jobs may be rejected to guarantee some criteria. In the online settings where jobs arrive over list, this problem of Multiprocessor Scheduling with Rejection (MSR) was introduced by [16]. The main goal of an algorithm designed for online MSR problem is to choose the proper balance between the penalties yielded by rejecting jobs and the increase in the makespan for the accepted jobs. At the beginning it might have to reject some jobs if the penalty for their rejections is small compared to their processing times. However, at a certain point, it would be better to schedule some of the previously rejected jobs since the increase in the makespan due to scheduling those jobs in parallel is less than the total penalty incurred. They showed an 1 + φ ≈ 2.618-competitive algorithm, where φ is the golden ratio. Their algorithm used two simple rules. The algorithms of [16] consist of two parts, a rejection scheme, which decides which jobs are rejected, and a scheduling algorithm, which assigns accepted jobs to a machine. The rejection schemes are combined with Graham’s LIST algorithm. If preemption is √ allowed, [17] gave an 4+3 10 ≈ 2.38743-competitive algorithm and showed a lower bound of 2.12457. The algorithms they proposed also consist of two parts, a rejection scheme and a scheduling algorithm. In fact, the rejection schemes given in [16] can be combined with any scheduling algorithm. The general idea in [17] is that by combining the rejection schemes with algorithms for different scheduling models, Seiden got new algorithms for scheduling with rejection. To our best knowledge, paper [13] is the first to study an single machine scheduling problem with deteriorating jobs and rejection, denoted by 1|rej, rj = t0 , pj = bj t|Cmax (S) + P S ej . They considered the deterioration effect and rejection at the same time. They showed that the problem is NP-hard and proposed a dynamic programming algorithm, and further
318
an FPTAS. In this paper, we show some polynomially solvable cases for the same problem and present the algorithm to solve them. After that, we study an variant of the problem with a modified criterion. For such problem, we design an polynomial time algorithm. The remainder of the paper is organized as follows. In Section 2, we give problems definitions and some notations. Then Section 3 shows some preliminaries. In Section 4, we study some polynomially solvable cases. At last, we cope with the modified problem. II. P ROBLEM DEFINITIONS AND NOTATIONS Given a set of jobs I = {1, 2, ..., n} to schedule on a single machine, the jobs are available at time t0 > 0 and the machine can process at most one job at a time. Job j’s (j ∈ I) actual processing time is an increasing function of its starting time t, i.e., pj = bj t(bj > 0), and it can be rejected by paying a fixed penalty ej ≥ 0. The objective is to minimize the makespan plus the total penalties incurred by rejected jobs. This P problem is denoted by 1|rej, rj = t0 , pj = bj t|Cmax (S) + S ej , where S and S denote the sets of scheduled jobs and rejected jobs respectively.
H 0 − HOP T
j∈S ∗
S
(1 + bj ) + {i0 }
X
ei − (A + B)
i∈S ∗ /{i0 }
= A(1 + bi0 ) + B − ei0 − A − B = Abi0 − ei0 By H 0 − HOP T ≥ 0, we have ej 0 (1+b0j ) bj 0
ei 0 bi0 0
≤ A for i0 ∈ S ∗ .
Lemma 3.4: ≥ A for j ∈ S ∗ . Proof: Similar to the proof of above lemma, let j 0 be any job of set S ∗ . We construct a new schedule S 0 by deleting j 0 from S ∗ and adding it to S ∗ . We use H 0 to denote the objective value of this new formed schedule S 0 . From the optimality of S , we have H 0 − HOP T ≥ 0. By the constructive way of S 0 and HOP T = A + B, it is followed that H 0 − HOP T
= t0
Y
(1 + bj ) +
j∈S ∗ /{j 0 }
X i∈S ∗
ei − (A + B)
S 0 {j }
= A/(1 + bj 0 ) + B + ej 0 − A − B bj = − A + ej 0 1 + bj 0
III. P RELIMINARIES P For problem 1|rej, rj = t0 , pj = bj t|Cmax (S) + S ej , there are some results in the literature. Paper [15] studied a simpler problem without rejection, i.e., 1|rj = t0 , pj = bj t|Cmax . He showed that the makespan is independent of the permutation of the jobs in any schedule, assumed that there is no idle time. Lemma 3.1: ([15]) QThe maximum completion time of the set S is Cmax (S) = t0 S (1 + bj ). Recently, considering rejection, paper [13] showed the NPhardness of the problem 1|rej, rj = t0 , pj = bj t|Cmax (S) + P e . j S PTheorem 3.2: ([13]) 1|rej, rj = t0 , pj = bj t|Cmax (S) + S ej is NP-hard. P Since 1|rej, rj = t0 , pj = bj t|Cmax (S)+ S ej is NP-hard, it is interesting to find some polynomially solvable cases. We first give the following lemmas, with the purpose to establish a rule to identify polynomially solvable cases. For a given job instance, let S ∗ denote the set of scheduled jobs in an optimal schedule S . Thus, S ∗ means the set of rejected jobs in this optimal schedule. We use HQ OP T denote the value of this optimal schedule, i.e., H = t (1+bj )+ OP T 0 j∈S ∗P P Q e . For simplicity, let A = t and B = ∗ ∗ i 0 j∈S i∈S i∈S ∗ ei . Then, we have HOP T = A + B. Suppose that S ∗ and S ∗ are not empty, since otherwise, these trivial cases are polynomially solvable. Lemma 3.3: ebi00 ≤ A for i0 ∈ S ∗ . i Proof: Let i0 be any job of set S ∗ . We construct a new schedule S 0 by deleting i0 from S ∗ and adding it to S ∗ . We use H 0 to denote the objective value of this new formed schedule S 0 . From the optimality of S , we have H 0 − HOP T ≥ 0. By the constructive way of S 0 and HOP T = A + B, it is followed that
Y
= t0
e 0 (1+b0 )
By H 0 − HOP T ≥ 0, we have j b 0 j ≥ A for j 0 ∈ S ∗ . j From these two lemmas, we obtain the following result immediately. Lemma 3.5: P In any optimal solution for 1|rej, rj = t0 , pj = bj t|Cmax (S) + S ej , it is satisfied that (1 + bj )ej /bj ≥ ei /bi , where j ∈ S ∗ and i ∈ S ∗ . IV. P OLYNOMIALLY SOLVABLE CASES In this section, we introduce a method to identify a variety P of solvable cases for 1|rej, rj = t0 , pj = bj t|Cmax (S) + S ej . First, we give a definition of binary relation ≺ of two jobs. Definition For a pair of jobs i, j in an instance I, if ei /bi > ej (1 + bj )/bj then i ≺ j, i.e., i precedes j. Property 4.1: ≺ is transitive. Proof: For three jobs h, i, j of an instance I, suppose that h ≺ i and i ≺ j. By the definition of ≺, we know eh /bh > ei (1+bi )/bi > ei /bi > ej (1+bj )/bj . This completes the proof. From the definition of ≺, we can divide I into a group of chains in the following way. Reindex the job set in nonincreasing order of ei /bi , ties broken arbitrarily. Set the first job the head of a chain. Put the next job, say i, at the end of the chain if the last job in the chain, say j, precedes i, i.e., ej /bj > ej+1 (1 + bj+1 )/bj+1 . Repeat this operation until all jobs are checked. For the remaining jobs, repeat the procedure to construct other chains until there is no job left. Let m ≥ 1 be a fixed integer. Now we consider the situation where m chains are established. We call this case the mchain case. We denote these chains respectively by chain-i (i ∈ {1, ..., m}). Let Ki (i ∈ {1, ..., m}) be the number of jobs
319
in chain-i, respectively. We define a m-tuple (k1 , k2 , ..., km ), where ki ∈ {0, 1, ..., Ki } for i ∈ {1, ..., m}. For the m-chain case, we establish the following algorithm.
From the expression of the objective function, we have X Y Y log ej = log t0 ej log Cmax (S) + (1 + bj ) + log j∈S
S
Algorithm A1. Step 1: Construct m chains. Step 2: For different (k1 , k2 , ..., km ) such that ki ∈ {0, 1, ..., Ki } for i ∈ {1, ..., m}, schedule the first ki jobs in the chain-i (and reject the others). Compute the objective value of each solution. Step 3: Choose among these solutions the one with minimum objective value.
=
log t0
Y
j∈S
(1 + bj )
j∈S
Lemma 4.2: Algorithm A2 optimally solve the single-chain case. Proof: If either of S ∗ and S ∗ is empty, the theorem holds since these cases are calculated by the algorithm. Thus, we only need to consider the cases where neither of S ∗ and S ∗ is empty. Reindex the jobs of chain-i (i ∈ {1, ..., m}), i.e., 1, 2, ..., Ki . By contradiction. Suppose that there exists one optimal solution such that in one chain, denoted by chain-c, the first k jobs are scheduled, as well as one job l of this chain such that l > k + 1, i.e., l is not the direct successor of the last of the first k jobs in chain-c. Let X be the set of jobs lying between jobs k and l in chain-c. We know X is not empty since l > k + 1. For each job j ∈ X, by Property 4.1 of ≺, we have j ≺ l. By the assumption, we also know that j ∈ S ∗ and l ∈ S ∗ , i.e., j is rejected and l is scheduled. It implies ej /bj > (1 + bl )el /bl which contradicts to Lemma 3.5. Therefore, it is obtained that such job l does not exist. By the same way, we can rule out all the possibilities except those where the first ki jobs of chain-i are scheduled. That is to say, the optimal schedule must be one of the possibilities such that only the first ki jobs of chain-i are scheduled. This completes the proof.
V. L OGARITHMIC VERSION OF THE PROBLEM A logarithmic scale is a scale of measurement that uses the logarithm of a objective value instead of the objective value itself. In this section, we will cope with a polynomially solvable problem, i.e., 1|rej, rj = t0 , pj = bj t| log Cmax (S) + P S log ej , a logarithmic version of the original problem.
ej .
j∈S
For this problem setting, we first give an polynomial-time algorithm LOG. LOG algorithm works as follows: For each job j, if 1 + bj ≤ ej , accept and process it on the machine; otherwise, reject this job. Theorem 5.1: LOG P algorithm solves 1|rej, rj = t0 , pj = bj t| log Cmax (S) + S log ej in O(n) time. Proof: For an instance I of n jobs, it is obvious that LOG algorithm takes O(n) time. In the following, We will prove LOG P algorithm solves 1|rej, rj = t0 , pj = bj t| log Cmax (S)+ S log ej . By contradiction. Suppose there exists an optimal schedule S in which at least one job k satisfies 1 + bk > ek , i.e, j ∈ S ∗ . Our purpose is to prove this optimal schedule does not exist. According to LOG algorithm, we reject job k and obtain a new schedule S 0 . We use HOP T and H 0 to denote the objective value of optimal schedule S and this new formed schedule S 0 , respectively. From the above equation, we know that Y Y HOP T = log t0 (1 + bj ) ej j∈S ∗
=
j∈S ∗
Y
log(1 + bk ) + log t0
(1 + bj )
j∈S ∗ /{k}
Y
ej .
j∈S ∗
On the other hand, we obtain H0
=
log t0
Y
=
log ek + log t0
Y
(1 + bj )
j∈S ∗ /{k}
Theorem 4.3: P The m-chain case of 1|rej, rj = t0 , pj = bj t|Cmax (S) + S ej is polynomially solvable. Proof: It suffices to prove the time complexity of algorithm A1 is polynomial. Given an instance of n jobs, Step 1 of algorithm A1 takes O(mn) = O(n) time. Step 2 takes O(nm+1 ) time since there are nm possibilities and each possibility takes O(n) for computation. Step 3 takes O(nm log nm ) = O(nm log n) time. Therefore, the time complexity of algorithm A1 is O(nm+1 log n). This complete the proof.
Y
j∈S ∗
Y
F
ej {k}
(1 + bj )
j∈S ∗ /{k}
Y
ej .
j∈S ∗
Since 1 + bk > ek , we have HOP T > H 0 , a contradiction. Therefore, the theorem holds. ACKNOWLEDGEMENTS The first author is supported by the Fundamental Research Funds for the Central Universities (2010KJ035). This research was supported by the National Science Foundation of China under Grants 71101106, 71172189, 71171149, 70832005 and 71090404/71090400. R EFERENCES [1] J.A. Hoogeveen, J.K. Lenstra and B. Veltman, Preemptive scheduling in a two stage multiprocessor flow shop is NP-hard, European Journal of Operational research 89 (1996) 172-175. [2] M. Pinedo, Scheduling: Theory, Algorithms, and Systems (Second Editon), Prentice-Hall, Englewood Cliffs, NJ, 2000.
320
[3] T. Cheng, Q. Ding, B. Lin, A concise survey of scheduling with timedependent processing times, European Journal of Operational Research 152 (2004) 1-13. [4] J. Gupta, S. Gupta, Single facility scheduling with nonlinear processing times, Computer Industrial Engineering 14 (1988) 387-393. [5] S. Browne, U. Yechiali, Scheduling deteriorating jobs on a single processor, Operations Research 38 (1990) 495-498. [6] G. Mosheiov, V -shaped policies for scheduling deteriorating jobs, Operations Research 39 (1991) 979-991. [7] G. Mosheiov, Scheduling jobs under simple linear deterioration, Computer and Operations Research 21 (1994) 653-659. [8] T. Cheng, Q. Ding, Single machine scheduling with step-deteriorating processing times, European Journal of Operational Research 134 (2001) 623-630. [9] B. Alidaee, N. Womer, Scheduling with time dependent processing times: Review and extentions, Journal of the Operational Research Society 50 (1999) 711-720. [10] T. Cheng, L. Kang, C. Ng, Due-date assignment and single machine scheduling with deteriorating jobs, Journal of Operational Research Society 55 (2004) 198-203. [11] E. Lodree, C. Gerger, A note on the optimal sequence position for a ratemodifying activity under simple linear deterioration, European Journal of Operational Research 201 (2010) 644-648. [12] Y. Bartal, S. Leonardi, A. Marchetti-Spaccamela, J. Sgall, L. Stougie, Multiporcessor scheduling with rejection, in: Seventh ACM-SIAM Symposium on Discrete Algorithms, 1996, 95-103. [13] Y. Cheng, S. Sun, Scheduling linear deterorating jobs with rejection on a single machine, European Journal of Operational Research 194 (2009) 18-27. [14] S. Gawiejnowicz, A. Kononov, Complexity and approximability of scheduling resumable proportionally deteriorating jobs, European Journal of Operational Research 200 (2010) 305-308. [15] G. Mosheiov, Scheduling jobs under simple linear deterioration, Computers and Operations Research 21 (1994) 653-659. [16] Y. Bartal, S. Leonardi, A. Spaccamela, J. Sgall, L. Stougie, Multiprocessor scheduling with rejection, SIAM Journal on Discrete Mathematics 13 (2000) 64-78. [17] S. Seiden, Preemptive multiprocessor scheduling with rejection, Theoretical Computer Science, 262 (2001) 437-458.
321
