#### Abstract

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 time algorithm for the case where jobs have identical release dates.

#### 1. 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.

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 job-dependent 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: : to minimize the total integrated cost ; : to minimize subject to ; : to minimize subject to ; : to identify a Pareto-optimal solution for each Pareto-optimal point,where is the original scheduling objective function and 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 NP-hard 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.

#### 2. Problem Description and Notation

The problem considered in this paper can be formally described as follows. There are an independent job set 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 has a release date , a deteriorating rate , and a rejection penalty . Each job is either rejected with a rejection penalty having to be paid or accepted and processed on the parallel batch machine. Denote by and 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 . For a given batch , we denote its deteriorating rate and release date by and , respectively. Then, and . 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., ) and the total penalty of the rejected jobs. Using the three-field notation of Graham et al. [23], we denote the problem by .

#### 3. Main Results

##### 3.1. NP-Hardness Proof

We first give a lemma, which will be used in what follows.

Lemma 1 (see [10]). *For the problem , the maximum completion time of the jobs is equal to and it does not depend on the processing order of the jobs.*

Theorem 2. *The problem is binary NP-hard.*

*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 and positive integers for each such that 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.(i)There are jobs.(ii)For , there exist job with and job with .(iii)For each , there exist job with = and job with = .(iv)For , there exists only a job with .(v)The threshold value is given by .

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 for . 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 and as a batch . If , we assign the job as a batch . We assign the job as the last batch . The jobs are processed on the batch machine in the order of . All other jobs are rejected. It is easy to verify that

Conversely, suppose that there is a schedule with . We need to show that there is a subset for the Equal Products Problem with . We have the following claims.

*Claim 1. *All jobs for each are accepted and .

*Proof. *If there exists some job being rejected, then we have = . It is a contradiction. Since job is accepted, we have .

From Claim 1, we can obtain that only the jobs can be rejected.

*Claim 2. *Only job is processed in the last batch.

*Proof. *If there exists a job () with processed in the same batch , then we have

Then, we denote by the last batch containing only job .

*Claim 3. *Each batch contains either a single job or two jobs for .

*Proof. *For job , if there exists a job () with which are processed in the same batch , then we have .

Thus, we denote by the new batch containing job .

For job , if there exists a job () with which are processed in the same batch , then we have the completion time of the batch as
The completion time of batch is

Therefore, batch can only contain either job or jobs . Repeat this deduction, we have the correctness of Claim 3. Let be the batch containing job for .

By Claims 2 and 3, we have batch if is accepted and batch if is rejected. Let is rejected for . Next, we are ready to show that is a solution of the Equal Products Problem.

Since and , we have = . If , we have

It is a contradiction. Hence, we have and is a solution of the Equal Products Problem. This completes the proof.

##### 3.2. Dynamic Programming Algorithms

Lemma 3. *For problem , there exists an optimal schedule such that the accepted jobs are processed in a nonincreasing order of deteriorating rates.*

*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 .

Let denote the optimal objective function value of the following scheduling problem:(i)the jobs in consideration are ;(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 1. *Job is rejected. Since is rejected, in the corresponding optimal schedule for , is still the job with the minimum index in the last batch and the total rejection penalty among is . Therefore, we have .

*Case 2. *Job is accepted. In this case, we consider this problem in the following two cases.*Case **2**.1*. If , then job starts a new batch. The starting time of job is . Therefore, we have .*Case **2.2*. If , then job can be assigned to the last batch containing job . Therefore, .

Combining the above two cases, we design the following dynamic programming algorithm.*Algorithm DP1*. Consider the following steps.*Step **1 (initialization)*. Consider and for .

Consider and for .*Step **2 (recursion)*. If ,

If ,
*Step **3 (optimal solution)*. The optimal value is given by .

Theorem 4. *Algorithm DP1 solves the problem in time.*

*Proof. *The correctness of Algorithm DP1 is guaranteed by the above discussion. The recursive function has at most states; each iteration takes a constant time to execute. Hence, the running time of Algorithm is .

Next, we give another dynamic programming Algorithm . Let denote the minimum value of the maximum completion time satisfying the following conditions.(i)The jobs in consideration are .(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.

*Case 1. *If job is rejected, we have .

*Case 2. *Job is accepted.*Case **2.1*. If , then job starts a new batch; the starting time of job is . Therefore, we have .*Case **2.2*. If , then job can be assigned to the last batch containing job . Therefore, .

Combining the above two cases, we design the dynamic programming algorithm as follows.

*Algorithm DP2*. Consider the following steps.

*Step **1 (initialization)*. Consider and for any .

Consider and for any .

*Step **2 (recursion)*. If ,

If ,

*Step **3 (optimal solution)*. The optimal value is determined by .

Theorem 5. *Algorithm DP2 solves the problem in time.*

##### 3.3. An FPTAS

Algorithm is a -approximation 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 is called a fully polynomial-time approximation scheme (FPTAS), if, for each , the algorithm is a -approximation algorithm running in polynomial time in the input size and . In the sequel, we assume .

For any and , if , then we define . If is an exact power of , then . Note that for any .

For any , let and let be the set of the rejected jobs, where . The inflated rejection penalty of the set with respect to any is defined as

Lemma 6 (see [25]). *For any set of jobs and any , .*

Lemma 7 (see [19]). *For any and for any integer , holds.*

Based on Lemmas 6 and 7, we have the following theorem.

Theorem 8. *For any , the optimal objective function value for is at most times the optimal objective function value for .*

Assume that the jobs have been indexed such that and define

Let denote the minimum value of the maximum completion time satisfying the following conditions.(i)The jobs in consideration are .(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 *. Consider the following steps.

*Step **1 (initialization)*. Consider

*Step **2 (recursion)*. If , then

If , then where is given by .

*Step **3 (output)*. The optimal value is determined by , where is the smallest integer such that .

Theorem 9. *There exists an FPTAS for problem which runs in time.*

*Proof. *The correctness of Algorithm is guaranteed by the above discussion. We need to compute exactly values and computation of each value takes time, where . Hence, the running time of Algorithm is .

##### 3.4. An Optimal Algorithm of One Special Case

The special case where all jobs have the same release dates is considered in this subsection, that is, the problem .

We first reindex the jobs in nonincreasing order of their deteriorating rates such that .

Lemma 10. *For problem , in any optimal schedule, if job is accepted, then the jobs set is accepted too.*

*Proof. *If job is accepted, since , there is no limit on the number of jobs in a batch; the jobs can be accepted and assigned to the current last batch. Obviously, this does not increase the value of the objective function. This completes the proof.

Theorem 11. *For problem , the optimal function value is ; the optimal solution can be found in time.*

#### 4. Conclusion

In this paper, we focus on the unbounded parallel batch scheduling of deteriorating jobs with release date and rejection. The objective is to minimize the makespan of the accepted jobs plus the total penalty of rejected jobs. We show that it is binary NP-hard; we provide two pseudopolynomial time algorithms and also propose a fully polynomial-time approximation scheme for the problem . Furthermore, we show that this problem can be solvable in time when jobs have identical release dates. For future research, it would be interesting to focus on scheduling deteriorating jobs with other objectives. Analysis of the other models of scheduling with rejection 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 research was supported by the National Natural Science Foundation of China (11201259), the Special Funds of the National Natural Science Foundation of China (61340045), and the Doctoral Fund of the Ministry of Education (20123705120001, 20123705110003).