Parallel Batch Scheduling of Deteriorating Jobs with Release Dates and Rejection

We consider the unbounded parallel batch scheduling with deterioration, release dates, and rejection. Each job is either accepted and processed on a single batching machine, or rejected by paying penalties. The processing time of a job is a simple linear increasing function of its starting time. The objective is to minimize the sum of the makespan of the accepted jobs and the total penalty of the rejected jobs. First, we show that the problem is NP-hard in the ordinary sense. Then, we present two pseudopolynomial time algorithms and a fully polynomial-time approximation scheme to solve this problem. Furthermore, we provide an optimal O(nlog⁡n) time algorithm for the case where jobs have identical release dates.


Introduction
The parallel batch scheduling problem has been extensively studied in the literature over the last decade. The fundamental model of the parallel batch scheduling problem was first introduced by Lee et al. [1] with the restriction that the number of jobs in each batch is bounded by a number . This bounded model is motivated by the burn-in operations in semiconductor manufacturing. Brucker et al. [2] provided an extensive discussion of the unbounded version of the parallel batch scheduling problem. This unbounded model can be applied, for example, to situations where the batch contents are heated in a sufficiently large kiln. Cheng et al. [3], Deng et al. [4,5], and Liu et al. [6,7] presented new complexity results and approximation algorithms for the parallel batch scheduling problem subject to release dates. In addition, more recent developments of this topic can be found in [8].
In classical scheduling problems, it is assumed that the processing times of jobs are fixed parameters. In practice, however, we often encounter situations in which processing time increases over time. Examples can be found in financial management, steel production, firefighting, and so forth, where any delay in processing a job may increase its completion time. Such problems are generally known as scheduling with deterioration effects. Browne and Yechiali [9] first considered scheduling problem with linear deterioration. They provided the optimal solution for the single machine when the objective is to minimize makespan. In addition, they solved a special case when the objective function is to minimize the total weighted completion time. Mosheiov [10] considered single machine scheduling problems with simple linear deteriorating jobs. He showed that most commonly scheduling objectives, such as the makespan, the total flow time, the sum of weighted completion times, the maximum lateness, the total lateness, the maximum tardiness, and the number of tardy jobs, remain solvable in polynomial time. Alidaee and Womer [11] presented an extensive survey of different deteriorating models and scheduling problems. Cheng et al. [12] provided an updated survey of scheduling problems with time-dependent processing times. Li et al. [13] considered the problem of scheduling of deteriorating jobs with release dates on a single batching machine. Miao et al. [14] studied the scheduling problems with deteriorating jobs and release dates on a single (batching) machine to minimize the maximum lateness. Zou et al. [15] considered several uniform parallel machine scheduling problems with linear deteriorating jobs.

The Scientific World Journal
On the other hand, it is always assumed in traditional scheduling research that all the jobs have to be processed on some machines. In real applications, however, things may be more complicated. For example, due to limited resources, the scheduler may reject some jobs and thereby incur jobdependent penalties for each rejected job. Bartal et al. [16] first introduced the notion of rejection. They considered both the offline and online versions of scheduling problem and studied the multiprocessor scheduling problem to minimize the sum of the makespan of the accepted jobs and the total rejection penalty of the rejected jobs. Subsequently, the machine scheduling problem with rejection has received increasing research attention. Hoogeveen et al. [17] considered the offline multiprocessor scheduling problem with rejection where preemption is allowed. They provided a pseudopolynomial time algorithm for each problem. Lu et al. [18] considered the unbounded parallel batch machine scheduling problem with release dates and rejection. Engels et al. [19] studied the single machine scheduling with rejection to minimize the sum of the weighted completion times of the scheduled jobs and the total penalty of the rejected jobs. Shabtay et al. [20] 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 [21] considered the single machine scheduling problems with linear deteriorating jobs and rejection. Li and Yuan [22] 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. To the best of our knowledge, no work has been done on the problem of scheduling deteriorating jobs with rejection on a single batching machine. Literature [20] on scheduling with rejection focuses on the following four models: 1: to minimize the total integrated cost 1 + 2 ; 2: to minimize 1 subject to 2 ≤ ; 3: to minimize 2 subject to 1 ≤ ; 4: to identify a Pareto-optimal solution for each Pareto-optimal point, where 1 is the original scheduling objective function and 2 is total rejection cost. We discuss the first model with deterioration and release dates.
In this paper, we study parallel batch scheduling of deteriorating jobs with release dates and rejection. The paper is organized as follows. In Section 2, we formulate the problem under consideration and introduce some notations. In Section 3, we first show that the problem is binary NPhard and provide two pseudopolynomial time algorithms. We also propose a fully polynomial-time approximation scheme for the problem and discuss one special case. In Section 4, we conclude the paper and suggest some topics for future research.

Problem Description and Notation
The problem considered in this paper can be formally described as follows. There are an independent job set J = { 1 , . . . , } and a single batching machine. The machine can process up to job simultaneously as a batch, where ≥ . The jobs processed in the same batch have the same starting time and completion time. The processing time of a batch is equal to the largest processing time of the jobs in the batch. Each job ( = 1, . . . , ) has a release date , 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 parallel batch machine. Denote by and = J \ the set of rejected jobs and the set of accepted jobs, respectively. The actual processing time of job is given by = , where ≥ is the starting time of . We assume min{ | = 1, . . . , } ≥ 0 > 0. For a given batch , we denote its deteriorating rate and release date by ( ) and ( ), respectively. Then, ( ) = max{ : ∈ } and ( ) = max{ : ∈ }. Denote by the completion time of the accepted job . We study the problem of minimizing the sum of the makespan of the accepted jobs (i.e., max ( ) = max{ : ∈ }) and the total penalty of the rejected jobs. Using the threefield notation of Graham et al. [23], we denote the problem by 1| -batch, , = , , ≥ | max ( ) + ∑ ∈ .

NP-Hardness Proof.
We first give a lemma, which will be used in what follows.
Lemma 1 (see [10]). For the problem 1| = 0 , = | max , the maximum completion time of the jobs is equal to max = 0 ∏ ∈J (1 + ) and it does not depend on the processing order of the jobs.
Proof. The decision version of the scheduling problem is clearly in NP. We use a reduction from the Equal Products Problem, which is NP-hard (see [24]). An instance I of the Equal Products Problem is formulated as follows. Given a set = {1, 2, . . . , } and positive integers for each ∈ such that ∏ ∈ = 2 for a certain positive integer , does there exist a subset ⊂ such that ∏ ∈ = ?
For any given instance I of the Equal Products Problem, we construct a corresponding instance II of our problem as follows.
The decision asks whether there is a schedule such that It is clear that the reduction can be done in polynomial time, and it is easy to verify that > 0 for = 1, . . . , + 1. Assume first that the Equal Products Problem has a solution such that ∏ ∈ = . Then, we construct a schedule in the following way. If ∈ , we assign the jobs 2 −1 and 2 as a batch . If ∉ , we assign the job 2 −1 as a batch . We assign the job 2 +1 as the last batch +1 . The jobs are processed on the batch machine in the order of 1 , . . . , +1 . All other jobs are rejected. It is easy to verify that Conversely, suppose that there is a schedule with max ( )+∑ ∈ ≤ . We need to show that there is a subset for the Equal Products Problem with ∏ ∈ = . We have the following claims. Proof. If there exists some job 2 −1 (1 ≤ ≤ + 1) being rejected, then we have max ( )+∑ ∈ ≥ 2 −1 = 2 2 + +1 + > . It is a contradiction. Since job 2 +1 is accepted, we have max ( ) ≥ 2 +1 (1 + 2 +1 ) ≥ 2 2 + +1 .
From Claim 1, we can obtain that only the jobs { 2 : 1 ≤ ≤ } can be rejected.

Claim 2.
Only job 2 +1 is processed in the last batch.
The completion time of batch is Therefore, batch −1 can only contain either job 2 −3 or jobs { 2 −3 , 2 −4 }. Repeat this deduction, we have the correctness of Claim 3. Let be the batch containing job 2 −1 for 1 ≤ ≤ .
By Claims 2 and 3, we have batch = { 2 −1 , 2 } if 2 is accepted and batch = { 2 −1 } if 2 is rejected. Let = { : 2 is rejected for 1 ≤ ≤ }. Next, we are ready to show that is a solution of the Equal Products Problem.

Dynamic Programming Algorithms
Lemma 3. For problem 1| -ℎ, , = , , ≥ | max ( ) + ∑ ∈ , there exists an optimal schedule such that the accepted jobs are processed in a nonincreasing order of deteriorating rates.

The Scientific World Journal
Proof. Otherwise, there exist two accepted jobs and such that is processed later than , but < . Since ≥ , there is no limit on the number of jobs in a batch and we can put job into the batch containing job . This does not delay the completion time of any batch. A finite number of repetitions of this procedure yields an optimal schedule of the required form.
Based on Lemma 3, we only consider the schedules in which the accepted jobs are processed in a nonincreasing order of deterioration rates. Assume that jobs are indexed such that 1 ≥ ⋅ ⋅ ⋅ ≥ .
Let ( , , ) denote the optimal objective function value of the following scheduling problem: (i) the jobs in consideration are 1 , . . . , ; (ii) is the job with the minimum index in the last batch; (iii) the total penalty of rejected jobs is .
In any such schedule, there are two possible cases: either is rejected or is accepted and processed on the batching machine. We distinguish two cases in the following discussion.

Case 2.
Job is accepted. In this case, we consider this problem in the following two cases. Combining the above two cases, we design the following dynamic programming algorithm.
Algorithm DP1. Consider the following steps.
Proof. The correctness of Algorithm DP1 is guaranteed by the above discussion. The recursive function has at most ( 2 ∑ =1 ) states; each iteration takes a constant time to execute. Hence, the running time of Algorithm DP1 is Next, we give another dynamic programming Algorithm DP2. Let ( , , ) denote the minimum value of the maximum completion time satisfying the following conditions.
(ii) is the job with the minimum index in the last batch.
(iii) The total penalty of rejected jobs is .
In any such schedule, there are two possible cases: either is rejected or is accepted and processed on the batching machine. Combining the above two cases, we design the dynamic programming algorithm as follows.
Algorithm DP2. Consider the following steps.

An FPTAS. Algorithm
A 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 {A : > 0} is called a fully polynomial-time approximation scheme (FPTAS), if, for each > 0, the algorithm A is a (1 + )-approximation algorithm running in polynomial time in the input size and 1/ . In the sequel, we assume 0 < ≤ 1.
Based on Lemmas 6 and 7, we have the following theorem.
Assume that the jobs have been indexed such that 1 ≥ ⋅ ⋅ ⋅ ≥ and define Let ( , , ) denote the minimum value of the maximum completion time satisfying the following conditions.
(ii) In the last batch, is the job with the minimum index.
(iii) The inflated rejection penalty of the rejected jobs is .
We design a dynamic programming algorithm as follows.
Algorithm A . Consider the following steps.