Scheduling Simple Linear Deteriorating Jobs with Rejection

Abstract

We consider the problems of scheduling deteriorating jobs with release dates on a single machine (parallel machines) and jobs can be rejected by paying penalties. The processing time of a job is a simple linear increasing function of its starting time. For a single machine model, the objective is to minimize the maximum lateness of the accepted jobs plus the total penalty of the rejected jobs. We show that the problem is NP-hard in the strong sense and presents a fully polynomial time approximation scheme to solve it when all jobs have agreeable release dates and due dates. For parallel-machine model, the objective is to minimize the maximum delivery completion time of the accepted jobs plus the total penalty of the rejected jobs. When the jobs have identical release dates, we first propose a fully polynomial time approximation scheme to solve it. Then, we present a heuristic algorithm for the case where all jobs have to be accepted and evaluate its efficiency by computational experiments.

1. Introduction

For most classical scheduling problems, the processing times of jobs are considered to be constant and independent of their starting time. However, this assumption is not appropriate for the modelling of many modern industrial processes; we often encounter situations in which processing time increases over time, when the machines gradually lose efficiency. Such problems are generally known as scheduling with deterioration effects. Scheduling with linear deterioration was first considered by Browne and Yechiali [1] who assumed that the processing times of jobs are nondecreasing and start time dependent linear functions. They derived optimal scheduling policies that minimize the expected makespan. Mosheiov [2] considered simple linear deterioration where jobs have a fixed job-dependent growth rate but no basic processing time. He showed that most commonly applied performance criteria, such as the makespan, the total flow time, the total lateness, the sum of weighted completion time, the maximum lateness, the maximum tardiness, and the number of tardy jobs, remain polynomially solvable. Since then, machine scheduling problems with deteriorating jobs have received increasing attention. An extensive survey of different models and problems was provided by Alidaee and Womer [3]. Cheng et al. [4] presented an updated survey of the results on scheduling problems with time-dependent processing times. Other new results of scheduling with deterioration effect can be found in [5–7].

At the same time, it is always assumed in traditional research that all the jobs have to be processed. In the real world, however, things may be more complicated. For example, due to limited resources or limited available capacity, the decider of a factory can choose only a subset of these tasks to be scheduled, while perhaps incurring some penalty for the rejected jobs. The machine scheduling problem with rejection was first introduced by Bartal et al. [8]. They studied both the offline and online versions of scheduling problem with rejection on identical parallel machines. The objective is to minimize the sum of the makespan of the accepted jobs and the total rejection penalty of the rejected jobs. After that, the machine scheduling problem with rejection received more and more attention. Hoogeveen et al. [9] considered the offline multiprocessor scheduling problem with rejection where preemption is allowed. Zhang et al. [10] studied the single machine scheduling with release dates and rejection to minimize the sum of the maximum completion times of the scheduled jobs and the total penalty of the rejected jobs. Sengupta [11] considered algorithms and approximation schemes for minimum lateness/tardiness scheduling with rejection. Shabtay et al. [12] recently presented an updated survey on offline scheduling with rejection. In addition, there has been some work on scheduling deteriorating jobs with rejection. For example, Cheng and Sun [13] considered the single machine scheduling problem with deterioration and rejection, in which the processing time of a job is a linear function of its starting time. Li and Yuan [14] studied several parallel-machine scheduling problems in which the processing time of a job is a linear increasing function of its starting time and jobs can be rejected by paying penalties. The objectives are to minimize the makespan and the total weighted completion time plus the total penalty of the rejected jobs. Hsua and Chang [15] considered the unrelated parallel-machine scheduling with deteriorating jobs and rejection. To the best of our knowledge, the problems of scheduling deteriorating jobs with release dates and rejection have not been discussed.

In this paper, we study the single machine (parallel-machine) scheduling of deteriorating jobs with release dates and rejection. The paper is organized as follows. In Section 2, we formulate the problems under consideration and introduce some notations. In Section 3, we first discuss single machine model and show that the problem is strongly NP-hard. Then we propose a fully polynomial time approximation scheme for the case where all jobs have agreeable release dates and due dates. In Section 4, we consider parallel-machine scheduling problem with deterioration and rejection. In Section 5, we conclude the paper and suggest some topics for future research.

2. Problem Description and Notation

The problems considered in this paper can be formally described as follows. There are an independent job set 𝒥={𝐽₁,…,𝐽_𝑛} and a single machine (𝑚≥2 identical parallel machines {𝑀₁,…,𝑀_𝑚}). Each job 𝐽_𝑗(𝑗=1,…,𝑛) has a release date 𝑟_𝑗, a due date 𝑑_𝑗 (a delivery time 𝑞_𝑗), a deteriorating rate 𝑏_𝑗>0, and a rejection penalty 𝑒_𝑗. Each job 𝐽_𝑗(𝑗=1,…,𝑛) is either rejected with a rejection penalty 𝑒_𝑗 having to be paid or accepted and processed on the single machine (one of parallel machines). The actual processing time of job 𝐽_𝑗 is given by 𝑝_𝑗=𝑏_𝑗𝑡, where 𝑡≥𝑟_𝑗 is the starting time of 𝐽_𝑗. Denote by 𝑅 and 𝑅=𝒥⧵𝑅 the set of rejected jobs and the set of accepted jobs, respectively. Denote by 𝐶_𝑗 the completion time of the accepted job 𝐽_𝑗. In the single machine model, assume min{𝑟_𝑗∣𝑗=1,…,𝑛}≥𝑡₀>0; the lateness of job 𝐽_𝑗 is defined as 𝐿_𝑗=𝐶_𝑗−𝑑_𝑗. The objective is to minimize the maximum lateness (i.e., 𝐿_max=max{𝐿_𝑗∶𝐽_𝑗∈𝑅}) plus the total penalty of the rejected jobs. In parallel-machine model, assume min{𝑟_𝑗∣𝑗=1,…,𝑛}=𝑡₀>0. We consider that each job 𝐽_𝑗 has a delivery time 𝑞_𝑗≥0 rather than a due date 𝑑_𝑗. The delivery of a job begins immediately after it completes processing, and job deliveries are allowed to overlap. We define the delivery completion time as 𝐷_𝑗=𝐶_𝑗+𝑞_𝑗; the objective is to minimize the maximum delivery completion time (i.e., 𝐷_max=max{𝐷_𝑗∶𝐽_𝑗∈𝑅}) plus the total penalty of the rejected jobs. Using the three-field notation of Graham et al. [16], the problems are denoted by 1∣𝑟_𝑗,𝑝_𝑗=𝑏_𝑗𝑡,rej∣𝐿_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗 and 𝑃𝑚∣𝑟_𝑗=𝑡₀,𝑝_𝑗=𝑏_𝑗𝑡,rej∣𝐷_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗.

3. The Single Machine Problem

3.1. NP-Hardness Proof

In this subsection, we first discuss the complexity of the problem 1∣𝑟_𝑗, 𝑝_𝑗=𝑏_𝑗𝑡∣𝐿_max where rejection is not considered.

Theorem 1. The problem 1∣𝑟_𝑗, 𝑝_𝑗=𝑏_𝑗𝑡∣𝐿_max is strongly NP-hard.

Proof. The decision version of the scheduling problem is clearly in NP. We use a reduction from the 4-product problem (4-P), which is strongly NP-hard (see [17]).
An instance of the 4-product problem is formulated as follows. Given 𝐷∈𝑄⁺, a finite set 𝑁={1,2,…,4𝑘} for some natural number 𝑘, a size 𝑦_𝑗∈𝑄⁺ and 𝐷^1/5<𝑦_𝑗<𝐷^1/3 for every 𝑗∈𝑁, ∏_𝑗∈𝑁𝑦_𝑗=𝐷^𝑘. Does there exist disjoint subsets 𝑁₁,…,𝑁_𝑘 such that ⋃^𝑘_𝑖=1𝑁_𝑖=𝑁 and the product of sizes of the elements in 𝑁_𝑖 satisfies ∏_{𝑗∈𝑁𝑖}𝑦_𝑗=𝐷 for 1≤𝑖≤𝑘 ?
Given an arbitrary instance I of 4-product problem, we construct an instance II of the scheduling problem as follows.(i)There are 𝑛=5𝑘−1 jobs.(ii)For 1≤𝑗≤4𝑘, 𝑟_𝑗=1, 𝑏_𝑗=𝑦_𝑗−1, and 𝑑_𝑗=2^𝑘−1𝐷^𝑘.(iii)For 4𝑘+1≤𝑗≤5𝑘−1, 𝑟_𝑗=2^{𝑗−4𝑘+1}𝐷^𝑗−4𝑘, 𝑏_𝑗=1, and 𝑑_𝑗=2^𝑗−4𝑘𝐷^𝑗−4𝑘.(iv)The threshold value is defined by 𝑌=0.
The decision version asks whether there is a schedule 𝜋 for problem 1∣𝑟_𝑗,𝑝_𝑗=𝑏_𝑗𝑡∣𝐿_max such that 𝐿_max≤𝑌.
It is clear that the reduction can be done in polynomial time. Now we prove that instance I has a solution if and only if instance II has a schedule 𝜋 with 𝐿_max≤𝑌.
Assume that 4-product problem has a solution; that is, there exist disjoint subsets 𝑁₁,…,𝑁_𝑘 such that ⋃^𝑘_𝑖=1𝑁_𝑖=𝑁 and the product of sizes of the elements in 𝑁_𝑖 satisfies ∏_{𝑗∈𝑁𝑖}𝑦_𝑗=𝐷 for 1≤𝑖≤𝑘. For convenience, we denote the set of jobs {𝐽_𝑗∶𝑗∈𝑁_𝑙}(1≤𝑙≤𝑘) by 𝐽_𝑁𝑙. The jobs are scheduled without idle times as follows. First, the set of jobs 𝐽_𝑁𝑙 are scheduled in the interval [2^𝑙−1𝐷^𝑙−1,2^𝑙−1𝐷^𝑙] for 𝑙=1,…,𝑘. Next, each job 𝐽_𝑗 is scheduled at time 𝑟_𝑗=2^{𝑗−4𝑘+1}𝐷^𝑗−4𝑘 for 𝑗=4𝑘+1,…,5𝑘−1. Therefore, the maximum lateness of this schedule is 𝐿_max=max{𝐶_𝑗−𝑑_𝑗∶1≤𝑗≤5𝑘−1}=0.
Conversely, assume that there is a schedule 𝜋 with 𝐿_max≤0. We are ready to prove that instance I has a solution.
First, each job 𝐽_𝑗(4𝑘+1≤𝑗≤5𝑘−1) must start exactly at its release date 𝑟_𝑗 and finish at its due date 𝑑_𝑗, since 𝐿_max≤𝑌=0. Second, the rest 4𝑘 jobs are scheduled as the 𝑘 intervals from time 𝑡=1 to time 𝑡=2^𝑘−1𝐷^𝑘. Without loss of generality, let 𝐽_𝑁𝑙(1≤𝑙≤𝑘) be the set of jobs scheduled in the interval [2^𝑙−1𝐷^𝑙−1,2^𝑙−1𝐷^𝑙].
Therefore, from the above discussion, we know that ∏_{𝑗∈𝑁𝑙}𝑦_𝑗≤𝐷 for 1≤𝑙≤𝑘. Note that ∏^𝑘_𝑙=1∏_{𝑗∈𝑁𝑙}𝑦_𝑗=∏^4𝑘_𝑗=1𝑦_𝑗=𝐷^𝑘. Thus, we have ∏_{𝑗∈𝑁𝑙}𝑦_𝑗=𝐷 for 1≤𝑙≤𝑘. That is, instance I has a solution. This completes the proof.

Corollary 2. The problem 1∣𝑟_𝑗,𝑝_𝑗=𝑏_𝑗𝑡,𝑟𝑒𝑗∣𝐿_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗 is strongly NP-hard, so it has no fully polynomial time approximation scheme unless 𝑃=𝑁𝑃.

3.2. An FPTAS for One Special Case

An algorithm 𝒜 is a 𝜌-approximation (𝜌≥1) algorithm for a minimization problem if it produces a solution that is at most 𝜌 times than the optimal one (𝜌 is also referred to as the worst-case ratio). A family of algorithms {𝒜_𝜖∶𝜖>0} is called a fully polynomial time approximation scheme (FPTAS), if for each 𝜖>0, the algorithm 𝒜_𝜖 is a (1+𝜖) approximation algorithm running in polynomial time in the input size and 1/𝜖.

In this subsection, we consider the special case where all jobs have agreeable release dates and due dates and assume that the jobs have been indexed such that 𝑟₁≤⋯≤𝑟_𝑛 and 𝑑₁≤⋯≤𝑑_𝑛. The problem can be denoted by 1∣𝑟_𝑗,𝑝_𝑗=𝑏_𝑗𝑡,rej,agreeable∣𝐿_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗.

We design an FPTAS for this problem by considering the modified deteriorating rates, the modified release dates, the modified due dates, and the inflated rejection penalty. The definition of the modified deteriorating rates and the modified release dates involves a geometric rounding technique developed by Afrati et al. [18]. The definition of the inflated rejection penalty is stated by Sengupta [11]. The rounding technique and the inflated rejection penalty are stated, respectively, as follows.

For any 𝜖^′>0 and 𝑥≥1, if (1+𝜖^′)^𝑘−1<𝑥<(1+𝜖^′)^𝑘, then we define ⌈𝑥⌉_𝜖′=(1+𝜖^′)^𝑘,⌊𝑥⌋_𝜖′=(1+𝜖^′)^𝑘−1. If 𝑥 is an exact power of (1+𝜖^′), then ⌈𝑥⌉_𝜖′=⌊𝑥⌋_𝜖′=𝑥. Note that ⌈𝑥⌉_𝜖′≤(1+𝜖^′)𝑥 for any 𝑥≥1.

For any 𝜖>0, we define the modified deteriorating rate of job 𝐽_𝑗 as 𝑏^′_𝑗=⌈1+𝑏_𝑗⌉_𝜖′−1, the modified release date of job 𝐽_𝑗 as 𝑟^′_𝑗=⌈𝑟_𝑗⌉_𝜖′ and the modified due date of job 𝐽_𝑗 as 𝑑^′_𝑗=(1+𝜖)𝑑_𝑗, where 𝜖^′=𝜖/2(𝑛+1). Let 𝐿_𝑗 denote the exponent of 1+𝑏^′_𝑗; that is, 1+𝑏^′_𝑗=⌈1+𝑏_𝑗⌉_𝜖′=(1+𝜖^′)^𝐿𝑗; then 𝐿_𝑗=log⌈1+𝑏_𝑗⌉_𝜖′/log(1+𝜖^′)=𝑂(𝑛log(1+𝑏_𝑗)/𝜖); let 𝑙_𝑗 denote the exponent of 𝑟^′_𝑗; that is, 𝑟^′_𝑗=⌈𝑟_𝑗⌉_𝜖′=(1+𝜖^′)^𝑙𝑗; then 𝑙_𝑗=log⌈𝑟_𝑗⌉_𝜖′/log(1+𝜖^′)=𝑂(𝑛log𝑟_𝑗/𝜖).

For any 𝜖>0, let 𝜖^′=𝜖/2(𝑛+1) and 𝑅={𝐽_𝑖1,𝐽_𝑖2,…,𝐽_𝑖𝑚} be the set of the rejected jobs, where 𝑖₁<𝑖₂<⋯<𝑖_𝑚. The inflated rejection penalty of the set 𝑅 is defined as 𝜙_𝜖′(𝑅)=𝑒_𝑖𝑚+𝜙_𝜖′𝑅−𝐽_{𝑖𝑚𝜖′},if𝑚≥1,0,if𝑅=Ø. (1)

Lemma 3 (see [11]). For any set 𝑅 of jobs and any 𝜖^′>0, 𝜙_𝜖′(𝑅)≤(1+𝜖^′)^|𝑅|∑_{𝐽𝑗∈𝑅}𝑒_𝑗.

Lemma 4 (see [19]). For any 0<𝑥≤1 and for any integer 𝑛≥1, (1+𝑥/𝑛)^𝑛≤1+2𝑥 holds.

Theorem 5. For any 0<𝜖≤2, the optimal objective function value for 1∣𝑟_𝑗,𝑝_𝑗=𝑏_𝑗𝑡,𝑟𝑒𝑗,𝑎𝑔𝑟𝑒𝑒𝑎𝑏𝑙𝑒∣𝐿_max(𝑅)+𝜙_𝜖′(𝑅) with the modified deteriorating rates, the modified release dates, and the modified due dates is at most (1+𝜖) times the optimal objective function value for 1∣𝑟_𝑗,𝑝_𝑗=𝑏_𝑗𝑡,𝑟𝑒𝑗,𝑎𝑔𝑟𝑒𝑒𝑎𝑏𝑙𝑒∣𝐿_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗.

Proof. Assume that jobs in the set 𝑅 are scheduled in the order of [1],…,[|𝑅|]. Let 𝐶^′_𝑗 denote the completion time of job 𝐽_𝑗 under the modified deteriorating rates and release dates; we have 𝐶^′_𝑗=max_{1≤𝑖≤𝑗}{𝑟^′_[𝑖]∏^𝑗_𝑘=𝑖(1+𝑏^′_[𝑘])}, then 𝐿^′_𝑗=𝐶^′_𝑗−𝑑^′_𝑗=max_{1≤𝑖≤𝑗}𝑟^′_[𝑖]^𝑗_𝑘=𝑖1+𝑏^′_[𝑘]−𝑑^′_[𝑗]≤1+𝜖^′𝑗+1max_{1≤𝑖≤𝑗}𝑟^𝑗_{[𝑖]𝑘=𝑖}1+𝑏_[𝑘]−(1+𝜖)𝑑_[𝑗]≤1+𝜖^′𝑛+1𝐶_𝑗−(1+𝜖)𝑑_𝑗≤(1+𝜖)𝐿_𝑗. (2) The objective function is 𝐿^′_max𝑅+𝜙_𝜖′(𝑅)≤max𝐿^′_𝑗+1+𝜖^′|𝑅|_{𝐽𝑗∈𝑅}𝑒_𝑗≤(1+𝜖)𝐿_max𝑅+_{𝐽𝑗∈𝑅}𝑒_𝑗. (3) Since the above inequality is valid for any 𝑅⊆𝒥, the results hold.
Assume that the jobs have been reindexed such that 𝑑₁≤⋯≤𝑑_𝑛 and define 𝜏_𝑘=1+𝜖^′𝑘,if𝑘≠−1,0,if𝑘=−1. (4)
Let 𝑓(𝑗,𝜆,𝑘) denote the minimum value of the maximum lateness satisfying the following conditions.(i)The jobs in consideration are 𝐽₁,…,𝐽_𝑗.(ii)The maximum completion time of the accepted jobs is (1+𝜖^′)^𝜆.(iii)The inflated rejection penalty of the rejected jobs is 𝜏_𝑘.
In any such schedule, there are two possible cases: either job 𝐽_𝑗 is rejected or 𝐽_𝑗 is accepted and processed on the machine.

Case 1 (Job 𝐽_𝑗 is rejected). Let (1+𝜖^′)^𝑘′ be the inflated rejection penalty of the rejected jobs among 𝐽₁,…,𝐽_𝑗−1. From the definition of inflated rejection penalty, the largest value of 𝑘^′ is given by (1+𝜖^′)^𝑘=⌊(1+𝜖^′)^𝑘−𝑒_𝑗⌋_𝜖′. Hence, the value of the maximum lateness for the optimal schedule is min_{−1≤𝑘′≤𝑘}𝑓(𝑗−1,𝜆,𝑘^′).

Case 2 (Job 𝐽_𝑗 is accepted). Consider the following.
Case 2.1  (𝜆>𝑙_𝑗+𝐿_𝑗). In this case, the maximum completion time of accepted jobs among 𝐽₁,…,𝐽_𝑗−1 is (1+𝜖^′)^𝜆/(1+𝜖^′)^𝐿𝑗. Therefore, 𝑓(𝑗,𝜆,𝑘)=max{𝑓(𝑗−1,𝜆−𝐿_𝑗,𝑘),(1+𝜖^′)^𝜆−𝑑^′_𝑗}.
Case 2.2  (𝜆=𝑙_𝑗+𝐿_𝑗). In this case, let (1+𝜖^′)^𝜆′ be the maximum completion time of accepted jobs among 𝐽₁,…,𝐽_𝑗−1. Since the starting time of job 𝐽_𝑗 is 𝑟^′_𝑗, we have 𝜆^′≤𝑙_𝑗. Hence, 𝑓(𝑗,𝜆,𝑘)=max{min_{0≤𝜆′≤𝑙𝑗}𝑓(𝑗−1,𝜆^′,𝑘),(1+𝜖^′)^𝜆−𝑑^′_𝑗}.

Combining the above two cases, the dynamic programming algorithm is stated as follows.

Algorithm DP1

Step 1 (initialization). 𝑓()=𝑟1,𝜆,𝑘^′11+𝑏_1𝜖′−𝑑^′𝜆=𝑙₁+𝐿₁,𝑘=−1,−∞𝜆=0,𝜏_𝑘=𝑒_1𝜖′,+∞otherwise. (5)

Step 2 (recursion). If 𝜆<𝑙_𝑗+𝐿_𝑗, 𝑓(𝑗,𝜆,𝑘)=min_{−1≤𝑘′≤𝑘}𝑓(𝑗−1,𝜆,𝑘^′),
If 𝜆>𝑙_𝑗+𝐿_𝑗, 𝑓𝑓𝑗,𝜆,𝑘=minmax𝑗−1,𝜆−𝐿_𝑗,𝑘,1+𝜖^′𝜆−𝑑^′_𝑗,min_{−1≤𝑘′≤𝑘}𝑓𝑗−1,𝜆,𝑘^′. (6)
If 𝜆=𝑙_𝑗+𝐿_𝑗, 𝑓𝑗,𝜆,𝑘=minmaxmin_{0≤𝜆′≤𝑙𝑗}𝑓𝑗−1,𝜆^′,𝑘,1+𝜖^′𝜆−𝑑^′_𝑗,min_{−1≤𝑘′≤𝑘}𝑓𝑗−1,𝜆,𝑘^′, (7) where 𝑘 is given by (1+𝜖^′)^𝑘=⌊(1+𝜖^′)^𝑘−𝑒_𝑗⌋_𝜖′.

Step 3 (output). The optimal value is determined by min{𝑓(𝑛,𝜆,𝑘)+𝜏_𝑘∶0≤𝜆≤max_{1≤𝑖≤𝑛}{𝑙_𝑖}+∑^𝑛_𝑗=1𝐿_𝑗,−1≤𝑘≤𝐾}, where 𝐾 is the smallest integer such that (1+𝜖^′)^𝐾≥(1+𝜖^′)^𝑛∑^𝑛_𝑗=1𝑒_𝑗.
Let 𝐿=logmax{𝑟_max,1+𝑏_max,∑^𝑛_𝑗=1𝑒_𝑗}, where 𝑟_max=max_{1≤𝑗≤𝑛}𝑟_𝑗, 𝑏_max=max_{1≤𝑗≤𝑛}𝑏_𝑗. We have the following theorem.

Theorem 6. There exists an FPTAS for problem 1∣𝑟_𝑗,𝑝_𝑗=𝑏_𝑗𝑡,𝑟𝑒𝑗,𝑎𝑔𝑟𝑒𝑒𝑎𝑏𝑙𝑒∣𝐿_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗 which runs in 𝑂(𝑛⁷𝐿⁴/𝜖⁴) time.

Proof. We need to compute exactly 𝑂(𝑛(max_{1≤𝑖≤𝑛}{𝑙_𝑖}+∑^𝑛_𝑗=1𝐿_𝑗+1)(𝐾+2)) values 𝑓(𝑗,𝜆,𝑘) and computation of each value takes at most 𝑂((max_{1≤𝑖≤𝑛}{𝑙_𝑖}+∑^𝑛_𝑗=1𝐿_𝑗)𝐾) time, where 𝐾=𝑂((𝑛/𝜖)log∑^𝑛_𝑗=1𝑒_𝑗). Hence, the running time of Algorithm DP1 is 𝑂𝑛max_{1≤𝑖≤𝑛}𝑙_𝑖+^𝑛_𝑗=1𝐿_𝑗²𝐾²=𝑂𝑛𝑛log𝑟_max𝜖+𝑛²log1+𝑏_max𝜖²×𝑛log∑^𝑛_𝑗=1𝑒_𝑗𝜖²𝑛=𝑂⁷𝐿⁴𝜖⁴. (8)

4. Parallel-Machine Problem

4.1. An FPTAS

In this subsection, we focus our attention on identical parallel machines problem with deterioration and rejection. For convenience of discussion, we consider a scheduling model in which each job 𝐽_𝑗 has a delivery time 𝑞_𝑗≥0 rather than a due date 𝑑_𝑗. When all jobs have identical release dates, the problem 𝑃𝑚∣𝑟_𝑗=𝑡₀,𝑝_𝑗=𝑏_𝑗𝑡,rej∣𝐷_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗 is at least ordinarily NP-hard according to Kononov [20]. We give a fully polynomial time approximation scheme to solve it by considering the modified deteriorating rates, the modified delivery times, and the inflated rejection penalty.

For any 𝜖>0, we define the modified deteriorating rate and delivery time of job 𝐽_𝑗 as 𝑏^′_𝑗=⌈1+𝑏_𝑗⌉_𝜖′−1, 𝑞_𝑗′=(1+𝜖^′)𝑞_𝑗, where 𝜖^′=𝜖/2𝑛. Let 𝐿_𝑗 denote the exponent of 1+𝑏^′_𝑗; that is, 1+𝑏^′_𝑗=⌈1+𝑏_𝑗⌉_𝜖′=(1+𝜖^′)^𝐿𝑗; then 𝐿_𝑗=log⌈1+𝑏_𝑗⌉_𝜖′/log(1+𝜖^′)=𝑂(𝑛log(1+𝑏_𝑗)/𝜖).

For any 𝜖>0, let 𝜖^′=𝜖/2𝑛 and 𝑅={𝐽_𝑖1,𝐽_𝑖2,…,𝐽_𝑖𝑚} be the set of the rejected jobs, where 𝑖₁<𝑖₂<⋯<𝑖_𝑚. The inflated rejection penalty of the set 𝑅 is defined as 𝜙_𝜖′(𝑅)=𝑒_𝑖𝑚+𝜙_𝜖′(𝑅−𝐽_𝑖𝑚)_𝜖′,if𝑚≥1,0,if𝑅=Ø. (9)

Lemma 7. For any 0<𝜖≤2, the optimal objective function value for 𝑃𝑚∣𝑟_𝑗=𝑡₀, 𝑝_𝑗=𝑏_𝑗𝑡, 𝑟𝑒𝑗∣𝐷_max(𝑅)+𝜙_𝜖′(𝑅) with the modified deteriorating rates and the modified delivery times is at most (1+𝜖) times the optimal objective function value for 𝑃𝑚∣𝑟_𝑗=𝑡₀,𝑝_𝑗=𝑏_𝑗𝑡,𝑟𝑒𝑗∣𝐷_max𝑅+_{𝐽𝑗∈𝑅}𝑒_𝑗. (10)

Lemma 8. There exists an optimal job sequence for 𝑃𝑚∣𝑟_𝑗=𝑡₀,𝑝_𝑗=𝑏_𝑗𝑡,𝑟𝑒𝑗∣𝐷_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗 such that on each machine the accepted jobs are sequenced in nonincreasing order of 𝑞_𝑗.

Based on Lemmas 7 and 8, we design a dynamic programming algorithm for 𝑃𝑚∣𝑟_𝑗=𝑡₀,𝑝_𝑗=𝑏_𝑗𝑡,rej∣𝐷_max(𝑅)+𝜙_𝜖′(𝑅) with the modified deteriorating rates and delivery times. Let us index the jobs such that 𝑞₁≥⋯≥𝑞_𝑛 and define 𝜏_𝑘=1+𝜖^′𝑘,if𝑘≠−1,0,if𝑘=−1. (11)

Let 𝐹(𝑗,𝜆₁,…,𝜆_𝑚,𝑘) denote the optimal value of the maximum delivery completion time satisfying the following conditions.(i)The jobs in consideration are 𝐽₁,…,𝐽_𝑗.(ii)The maximum completion time of the accepted jobs on machine 𝑀_𝑖 is 𝑡₀(1+𝜖^′)^𝜆𝑖 for 𝑖=1,…,𝑚.(iii)The inflated rejection penalty of the rejected jobs is 𝜏_𝑘.

The dynamic programming algorithm is stated as follows.

Algorithm DP2

Step 1 (initialization). 𝐹1,𝜆₁,…,𝜆_𝑚=𝑡,𝑘₀1+𝜖^′𝐿1+𝑞^′₁,𝜆₁,…,𝜆_𝑖,…,𝜆_𝑚=,𝑘0,…,𝐿₁,𝜆,…,0,−1−∞,₁,…,𝜆_𝑖,…,𝜆_𝑚=(),𝜏0,…,0,…,0_𝑘=𝑒_1𝜖′+∞,otherwise. (12)

Step 2 (recursion). If job 𝐽_𝑗 is rejected, 𝐹𝑗,𝜆₁,…,𝜆_𝑚,𝑘=min_{−1≤𝑘′≤𝑘}𝐹𝑗−1,𝜆₁,…,𝜆_𝑚,𝑘^′. (13) If job 𝐽_𝑗 is accepted, 𝐹𝑗,𝜆₁,…,𝜆_𝑚,𝑘=min_{1≤𝑖≤𝑚}max𝐹𝑗−1,𝜆₁,…,𝜆_𝑖−𝐿_𝑖,…,𝜆_𝑚,𝑡,𝑘₀1+𝜖^′𝜆𝑖+𝑞^′_𝑗. (14) Combining the two cases, we have 𝐹𝑗,𝜆₁,…,𝜆_𝑚,𝑘=minmin_{1≤𝑖≤𝑚}max𝐹𝑗−1,𝜆₁,…,𝜆_𝑖−𝐿_𝑖,…,𝜆_𝑚,𝑡,𝑘₀1+𝜖^′𝜆𝑖+𝑞^′_𝑗,min_{−1≤𝑘′≤𝑘}𝐹𝑗−1,𝜆₁,…,𝜆_𝑚,𝑘^′, (15) where 𝑘 is given by (1+𝜖^′)^𝑘=⌊(1+𝜖^′)^𝑘−𝑒_𝑗⌋_𝜖′.

Step 3 (output). The optimal value is determined by min𝐹𝑛,𝜆₁,…,𝜆_𝑚,𝑘+𝜏_𝑘∶0≤𝜆_𝑖≤^𝑛_𝑗=1𝐿_𝑗,1≤𝑖≤𝑚,−1≤𝑘≤𝐾, (16) where 𝐾 is the smallest integer such that (1+𝜖^′)^𝐾≥(1+𝜖^′)^𝑛∑^𝑛_𝑗=1𝑒_𝑗.

Theorem 9. There exists an FPTAS for problem 𝑃𝑚∣𝑟_𝑗=𝑡₀,𝑝_𝑗=𝑏_𝑗𝑡, 𝑟𝑒𝑗∣𝐷_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗 which runs in 𝑂((𝑛^𝑚+3/𝜖^𝑚+2)(∑^𝑛_𝑗=1log(1+𝑏_𝑗))^𝑚log²(∑^𝑛_𝑗=1𝑒_𝑗)) time.

Proof. We need to compute 𝑛(∑^𝑛_𝑗=1𝐿_𝑗+1)^𝑚(𝐾+2) values 𝐹(𝑗,𝜆₁,…,𝜆_𝑚,𝑘). Computation of each such value takes 𝑂(𝐾) time, where 𝐾=𝑂((𝑛/𝜖)log∑^𝑛_𝑗=1𝑒_𝑗). Therefore the overall time of the algorithm is 𝑂(𝑛(∑^𝑛_𝑗=1𝐿_𝑗)^𝑚𝐾²)=𝑂((𝑛^𝑚+3/𝜖^𝑚+2)(∑^𝑛_𝑗=1log(1+𝑏_𝑗))^𝑚log²(∑^𝑛_𝑗=1𝑒_𝑗)).

4.2. A Heuristic Algorithm for a Special Case

In this subsection, it is assumed that all jobs have to be processed; that is, rejection is not allowed. This problem can be denoted by 𝑃𝑚∣𝑟_𝑗=𝑡₀, 𝑝_𝑗=𝑏_𝑗𝑡∣𝐷_max. We present a heuristic algorithm and give its worst case analysis.

Heuristic 𝐷𝐿𝑆. Consider the following steps.

Step 1. Place all jobs in a list ordered by nonincreasing delivery times. Set 𝑆_𝑖=𝑡₀ for 1≤𝑖≤𝑚, and 𝑆_𝑖 denotes the total completion time of jobs assigned to machine 𝑀_𝑖.

Step 2. Select a machine 𝑀_𝑖 for which 𝑆_𝑖 is as small as possible. Choose the first unscheduled job 𝐽_𝑗 of the list and assign it to machine 𝑀_𝑖. Set 𝑆_𝑖=𝑆_𝑖(1+𝑏_𝑗).

Step 3. Repeat Step 2 until all jobs are scheduled.

Theorem 10. The worst case performance ratio of heuristic 𝐷𝐿𝑆 is (1+𝑏_max)^1−1/𝑚and this bound is tight.

Proof. Let 𝐷^DLS_max be the maximum delivery completion time according to heuristic DLS and let 𝐷^∗_max be the corresponding time in an optimal schedule. Assume that there exists a counterexample with 𝐷^DLS_max/𝐷^∗_max>(1+𝑏_max)^1−1/𝑚. Let 𝐽_𝑘 be the first job in the sorted list with 𝐶_𝑘+𝑞_𝑘>(1+𝑏_max)^1−1/𝑚𝐷^∗_max, remove all the following jobs from the list, and produce a minimum counterexample with 𝐷^DLS_max=𝐶_𝑘+𝑞_𝑘, where 𝐽_𝑘 is the job with smallest delivery time. Next, we transform the counterexample by subtracting 𝑞_𝑘 from all delivery times. Obviously, this decreases both 𝐷^DLS_max and 𝐷^∗_max by 𝑞_𝑘. Since 𝐷^DLS_max−𝑞_𝑘𝐷^∗_max−𝑞_𝑘≥𝐷^DLS_max𝐷^∗_max>1+𝑏_max^1−1/𝑚 (17) holds, the transformation yields another counterexample. Now the last job has delivery times zero and 𝐷^DLS_max=𝐶_𝑘. At the time before job 𝐽_𝑘 is assigned to its machine 𝑀_𝑖, 𝑆_𝑖≤∏^𝑘_𝑙=11+𝑏₁^1/𝑚1+𝑏_𝑘^1/𝑚≤𝐷^∗_max1+𝑏_𝑘^1/𝑚. (18) This implies 𝐷^DLS_max=𝐶_𝑘=𝑆_𝑖1+𝑏_𝑘≤1+𝑏_𝑘^1−1/𝑚𝐷^∗_max≤1+𝑏_max^1−1/𝑚𝐷^∗_max. (19)
To prove that the bound is tight, consider the following example with 𝑛=𝑚(𝑚−1)+1 jobs, all jobs have delivery time zero, the first 𝑚(𝑚−1) of them has deteriorating rates 𝑏_𝑗=1, 𝑗=1,2,…,𝑚(𝑚−1), and the last job’s deteriorating rate is 𝑏_𝑛=2^𝑚−1. Then 𝑏_max=𝑏_𝑛 and (1+𝑏_max)^1−1/𝑚=2^𝑚−1. By DLS, 𝐷^DLS_max=𝑡₀(1+𝑏_𝑗)^𝑚−1(1+𝑏_𝑛)=𝑡₀2^𝑚−12^𝑚=𝑡₀2^2𝑚−1. In an optimal schedule, 𝐽_𝑛 is assigned to one machine and all the previous 𝑚(𝑚−1) jobs are equally assigned to the other 𝑚−1 machines. This yields to 𝐷^∗_max=𝑡₀2^𝑚. Thus, 𝐷^DLS_max𝐷^∗_max=1+𝑏_max^1−1/𝑚=2^𝑚−1. (20) This completes the proof.

4.3. Numerical Experiment

This section conducts some numerical experiments to evaluate the performance of heuristic DLS. Without loss of generality, we set 𝑡₀=1. The delivery time 𝑞_𝑗,1≤𝑗≤𝑛 and the deteriorating rate 𝑏_𝑗,1≤𝑗≤𝑛 are generated from 𝑈[0,50] and 𝑈[1,10], respectively. The lower bound of optimal value is 𝐿(𝐷^∗_max)=(∏^𝑛_𝑙=1(1+𝑏_𝑙))^1/𝑚. The numerical results are summarized in Table 1. The program was coded in Matlab. The results of numerical experiments show that the algorithm has good performance. The proposed algorithm is acceptable for the NP-hard problem.

Table 1 

Summary of the computational results.

5. Conclusion

In this paper, we focus on several scheduling problems with deterioration, release date, and rejection. For the single machine model, we show that this problem is strongly NP-hard and provides a fully polynomial time approximation scheme when all jobs have agreeable release dates and due dates. For parallel machines model, we propose a fully polynomial time approximation scheme for 𝑃𝑚∣𝑟_𝑗=𝑡₀,𝑝_𝑗=𝑏_𝑗𝑡,rej∣𝐷_max(𝑅)+∑_{𝐽𝑗∈𝑅}𝑒_𝑗 and a heuristic algorithm for a special case. The computational results show that the heuristics is efficient in obtaining near-optimal solutions. For future research, it would be interesting to focus on scheduling deteriorating jobs and rejection with other objectives. Furthermore, investigation of the online version of this scheduling model is also an interesting research direction.

Conflict of Interests

The authors declare that there is no conflict of interests regarding the publication of this paper.

Acknowledgments

This paper is supported by the National Natural Science Foundation of China (11201259), the Doctoral Fund of the Ministry of Education (20123705120001 and 20123705110003), and Promotive Research Fund for Young and Middle-aged Scientists of Shandong Province (BS2013SF016).