*1.1. Scheduling with Non-Availability Intervals*

In most scheduling problems, it is assumed that the machines are available at all times. However, in some industrial settings, the assumption might not be true. Some machines or the operator might be unavailable in some time intervals. Recently, some researchers have studied some scheduling problems with the non-availability intervals. Two models of the non-availability interval were studied mainly: one is the machine non-availability (MNA) intervals due to the machine maintenances and the other is the operator non-availability (ONA) intervals because the operator is resting from work. The difference between MNA intervals and ONA intervals is that a crossover job can exist in the ONA interval. However, no job can be processed in the MNA interval.

To the best of our knowledge, the earliest scheduling problem with MNA intervals was studied by Schmidt [1]. He considered a parallel-machine scheduling problem in which each machine has different MNA intervals. The task is to find a feasible preemptive schedule if it exists. A polynomial-time algorithm is presented for the above problem. We first introduce some single-machine scheduling problems with an MNA interval (*a*, *b*). The corresponding problem can be denoted by 1|MNA(*a*, *b*)| *f* , where "MNA(*a*, *b*)" means that there is an MNA interval (*a*, *b*) and *f* is the objective function to be minimized. For problem 1|MNA(*a*, *b*)| ∑ *Cj*, Adiri et al. [2] proved that the problem is NP-hard and then presented a <sup>5</sup> <sup>4</sup> -approximation algorithm. For problem 1|MNA(*a*, *b*)|*C*max, Lee [3] showed that this problem is binary NP-hard and then provided a <sup>4</sup> <sup>3</sup> -approximation algorithm. For problem

<sup>1</sup>|MNA(*a*, *<sup>b</sup>*)|*L*max, Kacem [4] designed a <sup>3</sup> <sup>2</sup> -approximation algorithm and a fully polynomial-time approximation scheme (FPTAS). If there are *k* ≥ 2 MNA intervals (*a*1, *b*1),(*a*2, *b*2), ··· ,(*ak*, *bk*) on the machine, the corresponding problem 1|MNA(*ai*, *bi*)|*C*max is strongly NP-hard (see [3]) when *k* is arbitrary. Breit et al. [5] showed that, for any *ρ* ≥ 1 and *k* ≥ 2, there is no *ρ*-approximation algorithm for problem 1|MNA(*ai*, *bi*)|*C*max unless P = NP.

When there are *m* ≥ 2 parallel machines *M*1, ··· , *Mm* and each machine *Mi* has an MNA interval (*ai*, *bi*), the corresponding problem is denoted by *Pm*|MNA(*ai*, *bi*)| *f* . For problem *Pm*|MNA(0, *bi*)|*C*max, i.e., each machine *Mi* has a machine release time *bj*, Lee [6] provided a modified LPT (MLPT) algorithm with a tight approximation ratio <sup>4</sup> <sup>3</sup> . Kellerer [7] improved this bound <sup>4</sup> <sup>3</sup> to <sup>5</sup> <sup>4</sup> by a dual approximation algorithm using a bin packing approach. For problem *Pm*|MNA(0, *bi*)| ∑ *Cj*, Schmidt [8] showed that the SPT rule is optimal. Lee [6] also studied the problem *Pm*|MNA(*ai*, *bi*)|*C*max with the assumption that one machine is always available. He showed that the approximation ratios of LS (List Scheduling) and LPT are *m* and *<sup>m</sup>*+<sup>1</sup> <sup>2</sup> , respectively. Furthermore, Liao et al. [9] considered the same problem with *m* = 2 and developed exact algorithms based on the TMO algorithm for problem *P*2||*C*max. Aggoune [10] studied the flow-shop scheduling problem with several MNA intervals on each machine. A heuristic algorithm is provided to approximately solve this problem. Burdett and Kozan [11] also addressed some MNA intervals in railway scenarios. They introduced new fixed jobs for the MNA intervals. Some constructive heuristics and meta-heuristic algorithms were proposed in this paper. For more new models and results about this topic, the reader is referred to the survey by Ma et al. [12].

Brauner et al. [13] first studied the scheduling problems with an ONA interval. Similarly, this scheduling model can be denoted by 1|ONA(*a*, *b*)| *f* . For problem 1|ONA(*a*, *b*)|*C*max, Brauner et al. [13] proved that it is binary NP-hard and provided an FPTAS. For problem 1|ONA(*a*, *b*)|*L*max, Kacem et al. [14] proposed an FPTAS by borrowing the FPTAS for problem 1|MNA(*a*, *b*)|*L*max. Chen et al. [15] considered the problem 1|ONA(*a*, *b*)| ∑ *Cj* and presented a <sup>20</sup> <sup>17</sup> -approximation algorithm. Wan and Yuan [16] further considered the problem 1|ONA(*a*, *b*)| ∑ *wjCj*. They designed a pseudo-polynomial-time dynamic programming (DP) algorithm and then converted the DP algorithm into an FPTAS. Burdett et al. [17] considered the flexible job shop scheduling with operators (FJSOP) for coal export terminals. A hybrid meta-heuristic and a lot of numerical testings were designed for the above problem.

#### *1.2. Scheduling with Rejection*

In many practical cases, processing all jobs may occur high inventory or tardiness costs. However, rejecting some jobs can save time and reduce costs. When a job is rejected, a corresponding rejection cost is required. The decision maker needs to determine which jobs should be accepted (and a feasible schedule for accepted jobs), and which jobs should be rejected, such that the production cost and the total rejection cost are minimized. Thus, both from the practical and theoretical point of view, scheduling models with rejection are very interesting. In addition, an important application also occurs in scheduling with outsourcing. If the outsourcing cost is treated as the rejection cost, scheduling with rejection and scheduling with outsourcing are in fact equivalent.

Scheduling models with rejection were first introduced by Bartal et al. [18]. They considered several off-line and on-line scheduling problems on *m* parallel machines. The task is to minimize the sum of the makespan of accepted jobs and the total rejection cost of rejected jobs. For the on-line version, they designed an on-line algorithm with the best-possible competitive ratio of 2.618. For the off-line version, they provided an FPTAS when *m* is fixed, and a PTAS when *m* is arbitrary.

Next, we only introduce some results on the single-machine scheduling with rejection. The corresponding problem can be denoted by 1|rej| *f* + *e*(*R*), where *f* is the objective function on the set *A* of accepted jobs and *e*(*R*) is the total rejection cost on the set *R* of rejected jobs. For problem 1|*rj*,rej|*C*max + *e*(*R*), Cao and Zhang [19] proved that this problem is NP-hard and designed a PTAS. However, they also pointed out that it is open whether this problem is ordinary or

strongly NP-hard. Zhang et al. [20] showed that this problem is binary NP-hard by providing two different pseudo-polynomial-time algorithms. Finally, they also provided a 2-approximation algorithm and an FPTAS for the above problem. For problem 1|rej|*L*max + *e*(*R*), Sengupta [21] proved that this problem is binary NP-hard. He also proposed two dynamic programming algorithms and converted one of the two algorithms into an FPTAS. Engels et al. [22] studied the problem 1|rej| ∑ *wjCj* + *e*(*R*). They showed that this problem is binary NP-hard and then provided an FPTAS. They also showed that, when *wj* = 1, the problem 1|rej| ∑ *Cj* + *e*(*R*) is polynomial-time solvable. Recently, Shabtay et al. [23] presented a comprehensive survey for the off-line scheduling problems with rejection. For other models and results on scheduling with rejection, the reader is referred to the survey by Shabtay et al. [23].

#### *1.3. Scheduling with Rejection and Non-Availability Intervals*

There are only two articles which considered "scheduling with rejection" and "machine non-availability intervals" together. Zhong et al. [24], and Zhao and Tang [25] considered the problems 1|MNA(*a*, *b*),rej|*C*max + *e*(*R*) and 1|MNA(*a*, *b*),rej| ∑ *wjCj* + *e*(*R*), respectively. Both of them presented a pseudo-polynomial dynamic programming algorithm and an FPTAS for the corresponding problem. In addition, Li and Chen [26] investigated several scheduling problems with rejection and a deteriorating maintenance activity on a single machine. In their model, the starting time of the maintenance activity (non-availability intervals) is not fixed and the duration is a linear increasing function of its starting time. Some (pseudo-)polynomial-time algorithms are presented for some different objective functions. However, to the best of our knowledge, no article considered "scheduling with rejection" and "operator non-availability intervals" simultaneously. In this paper, we are the first to consider scheduling with rejection and an operator non-availability interval.

#### **2. Problem Formulation**

The single-machine scheduling with rejection and an operator non-availability interval can be stated formally as follows. There are *n* jobs *J*1, *J*2, ··· , *Jn* and a single machine. Each job *Jj* is available at time 0 and has a processing time *pj*, a weight *wj* and a rejection cost *ej*. Each job *Jj* is either rejected and the rejection cost *ej* has to be paid, or accepted and then processed non-preemptively on the machine. There is an operator non-availability interval (*a*, *b*) on the machine, where we assume that 0 < *a* < *b*. This implies that, in any feasible schedule *π*, no accepted job *Jj* can be started or be completed in the interval (*a*, *b*). However, a crossover job is allowed such that it can start before this interval and complete after this interval. Without loss of generality, we assume that all the parameters *a*, *b*, *pj*, *wj* and *ej* are non-negative integers. Let *A* and *R* be the sets of accepted jobs and rejected jobs, respectively. Denote by *<sup>C</sup>*max = max{*Cj* : *Jj* ∈ *<sup>A</sup>*}, <sup>∑</sup> *wjCj* = <sup>∑</sup>*Jj*∈*<sup>A</sup> wjCj* and *<sup>e</sup>*(*R*) = <sup>∑</sup>*Jj*∈*<sup>R</sup> ej* the makespan of accepted jobs, the total weighted completion time of accepted jobs and the total rejection cost of rejected jobs, respectively. Our task is to find a feasible schedule such that *C*max + *e*(*R*) or ∑ *wjCj* + *e*(*R*) is minimized. By using the notation for scheduling problems, the corresponding problems are denoted by 1|ONA(*a*, *b*), rej|*C*max + *e*(*R*) and 1|ONA(*a*, *b*), rej| ∑ *wjCj* + *e*(*R*), respectively.

Two similar problems related to the above problems are 1|MNA(*a*, *b*),rej|*C*max + *e*(*R*) and 1|MNA(*a*, *b*),rej| ∑ *wjCj* + *e*(*R*). Zhong et al. [24] and Zhao and Tang [25] presented a pseudo-polynomial dynamic programming algorithm and an FPTAS for the corresponding problem, respectively. In this paper, by borrowing the algorithms in [24,25], we also presented a pseudo-polynomial dynamic programming algorithm and an FPTAS for the problems 1|ONA(*a*, *b*), rej|*C*max + *e*(*R*) and 1|ONA(*a*, *b*), rej| ∑ *wjCj* + *e*(*R*), respectively.

#### **3. Pseudo-Polynomial-Time Algorithms**

Brauner et al. [13] and Chen et al. [15] showed that problems 1|ONA(*a*, *b*)|*C*max and 1|ONA(*a*, *b*)| ∑ *Cj* are NP-hard. Thus, two problems 1|ONA(*a*, *b*),rej|*C*max + *e*(*R*) and 1|ONA(*a*, *b*),rej| ∑ *wjCj* + *e*(*R*) are also NP-hard. In this section, we show that the above problems can be solved in pseudo-polynomial time. That is, both of the problems, 1|ONA(*a*, *b*),rej|*C*max + *e*(*R*) and 1|ONA(*a*, *b*), rej| ∑ *wjCj* + *e*(*R*), are binary NP-hard.

For problems 1|MNA(*a*, *b*),rej|*C*max + *e*(*R*) and 1|MNA(*a*, *b*),rej| ∑ *wjCj* + *e*(*R*), Zhong et al. [24] and Zhao and Tang [25] presented a pseudo-polynomial dynamic programming algorithm, respectively. By enumerating the crossover job and its starting time, we show that problem 1|ONA(*a*, *b*),rej| *f* + *e*(*R*) can be decomposed into many subproblems of 1|MNA(*a*, *b*),rej| *f* + *e*(*R*). Consequently, by borrowing the algorithms in [24,25], we also presented a pseudo-polynomial algorithm for problems 1|ONA(*a*, *b*),rej|*C*max + *e*(*R*) and 1|ONA(*a*, *b*), rej| ∑ *wjCj* + *e*(*R*), respectively.

**Lemma 1.** *If algorithm <sup>A</sup>*MNA *solves problem* <sup>1</sup>|*MNA*(*a*, *<sup>b</sup>*),*rej*<sup>|</sup> *<sup>f</sup>* <sup>+</sup> *<sup>e</sup>*(*R*) *in <sup>O</sup>*(*T*) *time, then Algorithm 1 yields an optimal schedule for problem* 1|*ONA*(*a*, *b*),*rej*| *f* + *e*(*R*) *in O*(*naT*) *time.*

**Algorithm 1** *A*ONA

Step 1: Let *<sup>A</sup>*MNA be a dynamic programming algorithm for problem 1|MNA(*a*, *<sup>b</sup>*),rej<sup>|</sup> *<sup>f</sup>* <sup>+</sup> *<sup>e</sup>*(*R*), where *f* ∈ {*C*max, ∑ *wjCj*}.

Step 2: Applying algorithm *<sup>A</sup>*MNA to the problem 1|MNA(*a*, *<sup>b</sup>*),rej<sup>|</sup> *<sup>f</sup>* <sup>+</sup> *<sup>e</sup>*(*R*), we can obtain a schedule *π*0.

Step 3: For each job *Jj* with *j* = 1, ··· , *n* and each integer *t* with 0 ≤ *t* ≤ *a* and *t* + *pj* ≥ *b*, we first schedule *Jj* in time interval [*t*, *t* + *pj*]. Set *a* = *t*, *b* = *t* + *pj* and instance *I* = {*J*1, ··· , *Jn*} \ *Jj*. Applying algorithm *<sup>A</sup>*MNA to the instance *<sup>I</sup>* of problem 1|MNA(*a* , *b* ),rej| *f* + *e*(*R*), we can obtain a schedule *π*(*j*, *t*).

Step 4: Choose the schedule among all schedules in {*π*0}∪{*π*(*j*, *t*) : 1 ≤ *j* ≤ *n*, 0 ≤ *t* ≤ *a* and *t* + *pj* ≥ *b*} with the smallest objective value.

**Proof.** Firstly, we show that Algorithm 1 yields an optimal schedule for problem 1|ONA(*a*, *b*),rej| *f* + *e*(*R*). Let *π*<sup>∗</sup> be an optimal schedule for problem 1|ONA(*a*, *b*), rej| *f* + *e*(*R*). We distinguish two cases into our discussion.

**Case 1:** No crossover job exist in *π*∗.

In this case, interval (*a*, *b*) is completely forbidden. That is, an ONA interval is equivalent to an MNA interval. Thus, in this case, *π*<sup>0</sup> is also an optimal schedule for problem 1|ONA(*a*, *b*),rej| *f* + *e*(*R*).

**Case 2:** There is a crossover job in *π*∗.

Let *Jj* be the crossover job in *π*<sup>∗</sup> and let *t* be the starting time of *Jj* in *π*∗. Clearly, we have 0 ≤ *t* ≤ *a* and *t* + *pj* ≥ *b*. In this case, no job in *I* = {*J*1, ··· , *Jn*} \ *Jj* can be processed in the interval (*t*, *t* + *pj*). Set *a* = *t* and *b* = *t* + *pj*. The remaining problem is equivalent to the instance *I* of the problem 1|MNA(*a* , *b* ),rej| *f* + *e*(*R*). Thus, in this case, *π*(*j*, *t*) is also an optimal schedule for problem 1|ONA(*a*, *b*), rej| *f* + *e*(*R*).

From the above discussions, Algorithm 1 always yields an optimal schedule for problem <sup>1</sup>|ONA(*a*, *<sup>b</sup>*),rej<sup>|</sup> *<sup>f</sup>* <sup>+</sup> *<sup>e</sup>*(*R*). Note that algorithm *<sup>A</sup>*MNA is called at most *<sup>O</sup>*(*na*) times. Thus, the time complexity of Algorithm 1 is exactly *O*(*naT*).

Note that Zhong et al. [24] presented an *O*(*n* ∑*<sup>n</sup> <sup>j</sup>*=<sup>1</sup> *pj*)-time dynamic programming algorithm for problem 1|MNA(*a*, *<sup>b</sup>*),rej|*C*max <sup>+</sup> *<sup>e</sup>*(*R*). Zhao and Tang [25] presented an *<sup>O</sup>*(*na* <sup>∑</sup>*<sup>n</sup> <sup>j</sup>*=<sup>1</sup> *pj*)-time algorithm for problem 1|MNA(*a*, *b*), rej| ∑ *wjCj* + *e*(*R*). Thus, we have the following corollaries.

**Corollary 1.** *Algorithm 1 solves problem* <sup>1</sup>|*ONA*(*a*, *<sup>b</sup>*),*rej*|*C*max <sup>+</sup> *<sup>e</sup>*(*R*) *in <sup>O</sup>*(*n*2*<sup>a</sup>* <sup>∑</sup>*<sup>n</sup> <sup>j</sup>*=<sup>1</sup> *pj*) *time and solves problem* <sup>1</sup>|*ONA*(*a*, *<sup>b</sup>*),*rej*<sup>|</sup> <sup>∑</sup> *wjCj* <sup>+</sup> *<sup>e</sup>*(*R*) *in O*(*n*2*a*<sup>2</sup> <sup>∑</sup>*<sup>n</sup> <sup>j</sup>*=<sup>1</sup> *pj*) *time.*

**Example 1.** *A simple example for problem* 1|*ONA*(*a*, *b*),*rej*|*C*max + *e*(*R*) *is constructed as follows: Given a positive number k* > 0*, we have three jobs J*1, *J*2, *J*<sup>3</sup> *with* (*p*1,*e*1)=(2*k*, *k*)*,* (*p*2,*e*2)=(4*k*, 2*k*) *and* (*p*3,*e*3)=(7*k*, +∞)*. We also assume that there is a single machine with an ONA interval* (*a*, *b*)*, where a* = 4*k and b* = 9*k. Note that p*<sup>1</sup> < *p*<sup>2</sup> < *bk* − *ak* = 5*k* < *p*3*. Thus, J*<sup>3</sup> *is the unique candidate for the crossover job. Note further that e*<sup>3</sup> = +∞*. Thus, J*<sup>3</sup> *must be accepted in any optimal schedule. We distinguish two cases in our discussion.*

**Case 1:** *J*<sup>3</sup> is not a crossover job.

In this case, since *p*<sup>3</sup> = 7*k* > *a* = 4*k*, *J*<sup>3</sup> must be processed at or after time *b* = 9*k*. Thus, the optimal schedule is to process *J*<sup>2</sup> and *J*<sup>3</sup> in [0, 4*k*] and [9*k*, 16*k*], respectively, and reject *J*1. That is, the *C*max + *e*(*R*) value is 16*k* + *k* = 17*k*.

**Case 2:** *J*<sup>3</sup> is the crossover job and *J*<sup>3</sup> starts its processing at time *t*.

Since *t* ∈ [0, 4*k*] and *t* + *p*<sup>3</sup> ≥ *b* = 9*k*, we have 2*k* ≤ *t* ≤ 4*k*. When *t* ∈ [2*k*, 4*k*), only *J*<sup>1</sup> can be processed before *J*3. Thus, the *C*max + *e*(*R*) value is at least *t* + 7*k* + 2*k* ≥ 11*k*. The minimum value *C*max + *e*(*R*) = 11*k* can be reached by processing *J*<sup>1</sup> and *J*<sup>3</sup> in [0, 9*k*] and reject *J*2. When *t* = 4*k*, only one job between *J*<sup>1</sup> and *J*<sup>2</sup> can be processed before *J*3. Thus, the *C*max + *e*(*R*) value is at least 4*k* + 7*k* + *k* ≥ 12*k*. The minimum value *C*max + *e*(*R*) = 12*k* can be reached by processing *J*<sup>2</sup> and *J*<sup>3</sup> in [0, 11*k*] and reject *J*1.

By combining all cases, the optimal *C*max + *e*(*R*) value is 11*k*, which can be reached by processing *J*<sup>1</sup> and *J*<sup>3</sup> in [0, 9*k*] and reject *J*2.

#### **4. Approximation Schemes**

In this section, by borrowing the FPTASs in [24,25], we also presented an FPTAS for problems <sup>1</sup>|ONA(*a*, *<sup>b</sup>*),rej|*C*max <sup>+</sup> *<sup>e</sup>*(*R*) and 1|ONA(*a*, *<sup>b</sup>*),rej<sup>|</sup> <sup>∑</sup> *wjCj* <sup>+</sup> *<sup>e</sup>*(*R*), respectively. Given an <sup>=</sup> <sup>1</sup> *<sup>E</sup>* for some positive integer *E*, we set *ti* = *ia* for each *i* = 1, 2, ··· , *E*. To propose an FPTAS, we delay the starting of the crossover job slightly such that the crossover job starts its processing at some time *ti*. Such a delay may increase the objective value by 1 + times, we say that it produces a (1 + )-loss.

**Lemma 2.** *If a crossover job exists in an optimal schedule, with a* (1 + )*-loss, we can assume that the crossover job starts its processing at some time ti.*

**Proof.** Let *π*<sup>∗</sup> be an an optimal schedule for problem 1|ONA(*a*, *b*),rej|*C*max + *e*(*R*) or problem 1|ONA(*a*, *b*),rej| ∑ *wjCj* + *e*(*R*). Let *A*<sup>∗</sup> and *R*<sup>∗</sup> be the set of accepted jobs and the set of rejected jobs in *π*∗, respectively. In addition, we also assume that *Jj* ∈ *A*<sup>∗</sup> is the *j*th processed job in *π*∗. Without loss of generality, we assume that *Jk* ∈ *A*<sup>∗</sup> is the crossover job in *π*∗. Furthermore, we assume that the starting time of *Jk* is *t* with 0 ≤ *t* ≤ *a* and *t* + *pk* ≥ *b*. If *t* = *ti* for each *i* = 1, 2, ··· , *E*, then there is some *i* with <sup>1</sup> ≤ *<sup>i</sup>* ≤ *<sup>E</sup>* such that *ti*−<sup>1</sup> < *<sup>t</sup>* < *ti*, where *<sup>t</sup>*<sup>0</sup> = 0. By delaying the processing of *Jk*, *Jk*+1, ··· , *<sup>J</sup>*|*A*∗| by a length of *ti* − *t*, we can obtain a schedule *π*. Note that *ti* ≤ *a* and *ti* + *pk* ≥ *t* + *pk* ≥ *b*. Thus, *π* is feasible for problems 1|ONA(*a*, *b*),rej|*C*max + *e*(*R*) and 1|ONA(*a*, *b*),rej| ∑ *wjCj* + *e*(*R*). Note further that *ti* − *<sup>t</sup>* < *ti* − *ti*−<sup>1</sup> = *<sup>a</sup>* and *Cj*(*π*∗) ≥ *<sup>b</sup>* > *<sup>a</sup>* for each *<sup>j</sup>* = *<sup>k</sup>*, ··· , |*A*∗|. Thus, we have *Cj*(*π*) = *Cj*(*π*∗) for each *j* = 1, ··· , *k* − 1 and *Cj*(*π*) = *Cj*(*π*∗)+(*ti* − *t*) ≤ *Cj*(*π*∗) + *a* ≤ *Cj*(*π*∗) + *Cj*(*π*∗) = (1 + )*Cj*(*π*∗) for each *j* = *k*, ··· , |*A*∗|. It follows that

$$\mathbb{C}\_{\text{max}}(\pi) \le (1+\epsilon)\mathbb{C}\_{\text{max}}(\pi^\*) \text{ and } \sum w\_j \mathbb{C}\_{\pi} \le (1+\epsilon)\sum w\_j \mathbb{C}\_j(\pi^\*).$$

Notice that both of the total rejection cost in *π* and *π*∗ are *e*(*R*∗). Thus, we can conclude that the objective value is increased by at most 1 + times. This completes the proof of Lemma 2.

Next, based on Lemma 2, we propose an FPTAS for problems 1|ONA(*a*, *b*),rej|*C*max + *e*(*R*) and 1|ONA(*a*, *b*), rej| ∑ *wjCj* + *e*(*R*).

**Lemma 3.** *If algorithm A*MNA *is an FPTAS for problem* 1|*MNA*(*a*, *b*),*rej*| *f* + *e*(*R*) *with the time complexity of O*(*T*)*, then Algorithm 2 is also an FPTAS for problem* 1|*ONA*(*a*, *b*),*rej*| *f* + *e*(*R*) *with the time complexity of O*( *nT* )*.*

**Algorithm 2** *A*ONA 

a schedule *π*0.

Step 1: Let *A*MNA be an FPTAS for problem 1|MNA(*a*, *b*), rej| *f* + *e*(*R*), where *f* ∈ {*C*max, ∑ *wjCj*}. Step 2: Applying algorithm *A*MNA to the problem 1|MNA(*a*, *b*),rej| *f* + *e*(*R*), we can obtain

Step 3: For each job *Jj* with *j* = 1, ··· , *n* and each integer *ti* with 0 ≤ *ti* ≤ *a* and *ti* + *pj* ≥ *b*, we first schedule *Jj* in time interval [*ti*, *ti* + *pj*]. Set *a* = *ti*, *b* = *ti* + *pj* and instance *I* = {*J*1, ··· , *Jn*} \ *Jj*. Applying algorithm *A*MNA to the instance *I* of problem 1|MNA(*a* , *b* ),rej| *f* + *e*(*R*), we can obtain a schedule *π*(*j*, *ti*).

Step 4: Choose the schedule among all schedules in {*π*0}∪{*π*(*j*, *ti*) : 1 ≤ *j* ≤ *n*, 0 ≤ *ti* ≤ *a* and *ti* + *pj* ≥ *b*} with the smallest objective value.

**Proof.** Firstly, we prove that Algorithm 2 is an FPTAS for 1|ONA(*a*, *b*),rej| *f* + *e*(*R*). Let *π*<sup>∗</sup> be an optimal schedule for problem 1|ONA(*a*, *b*),rej| *f* + *e*(*R*). Let *Z* and *Z*<sup>∗</sup> be the objective values obtained from Algorithm 2 and the optimal schedule *π*∗, respectively. We also distinguish two cases in our discussion.

**Case 1:** No crossover job exists in *π*∗.

In this case, interval (*a*, *b*) is completely forbidden. That is, an ONA interval is equivalent to an MNA interval. Thus, we have *Z* ≤ *Z*(*π*0) ≤ (1 + )*Z*(*π*∗)=(1 + )*Z*∗.

**Case 2:** There is a crossover job in *π*∗.

Let *Jj* be the crossover job in *π*<sup>∗</sup> and let *t* be the starting time of *Jj* in *π*∗. Clearly, we have 0 ≤ *t* ≤ *a* and *t* + *pj* ≥ *b*. In this case, no job in *I* = {*J*1, ··· , *Jn*} \ *Jj* can be processed in the interval (*t*, *t* + *pj*). Set *a* = *t* and *b* = *t* + *pj*. Thus, the remaining problem is equivalent to the instance *I* of the problem 1|MNA(*a* , *b* ),rej| *f* + *e*(*R*). Let *Z*∗(*j*, *t*) be the optimal objective value for problem 1|ONA(*a*, *b*),rej| *f* + *e*(*R*) under the constraint in which *Jj* is the crossover job and *Jj* starts its processing at time *t*. Note that algorithm *A*MNA is an FPTAS for problem 1|MNA(*a*, *b*),rej| *f* + *e*(*R*). Thus, we have *Z*(*π*(*j*, *ti*)) ≤ (1 + )*Z*∗(*j*, *ti*). Furthermore, by Lemma 2, we also have *Z*∗(*j*, *ti*) ≤ (1 + )*Z*∗(*j*, *t*) = (1 + )*Z*∗. It follows that

$$Z \le Z(\pi(j, t\_i)) \le (1 + \epsilon) Z^\*(j, t\_i) \le (1 + \epsilon)^2 Z^\*(j, t) = (1 + \epsilon)^2 Z^\* \dots$$

From the above discussions, Algorithm 2 is an FPTAS for 1|ONA(*a*, *b*),rej| *f* + *e*(*R*). Note that algorithm *A*MNA is called at most *O*( *<sup>n</sup>* ) times. Thus, the time complexity of Algorithm 2 is exactly *O*( *nT* ).

Note that Zhong et al. [24] presented an FPTAS with the time complexity of *O*( *<sup>n</sup>* ) for problem 1|MNA(*a*, *b*),rej|*C*max + *e*(*R*). Zhao and Tang [25] presented an FPTAS with the time complexity *O*( *<sup>n</sup>*4*L*<sup>5</sup> <sup>4</sup> ) for problem 1|MNA(*a*, *<sup>b</sup>*),rej<sup>|</sup> <sup>∑</sup> *wjCj* <sup>+</sup> *<sup>e</sup>*(*R*), where *<sup>L</sup>* <sup>=</sup> log(max{*n*, <sup>1</sup> , *b*, max *ej*,(max *wj*) · (max *pj*)}). Thus, we have the following corollaries.

**Corollary 2.** *Algorithm 1 is an FPTAS for problems* 1|*ONA*(*a*, *b*),*rej*|*C*max + *e*(*R*) *and* 1|*ONA*(*a*, *b*),*rej*| <sup>∑</sup> *wjCj* <sup>+</sup> *<sup>e</sup>*(*R*) *with the time complexities of O*( *<sup>n</sup>*<sup>2</sup> <sup>2</sup> ) *and O*( *<sup>n</sup>*5*L*<sup>5</sup> <sup>5</sup> )*, respectively.*

#### **5. Conclusions and Future Work**

In this paper, we are the first to consider scheduling with rejection and an operator non-availability interval simultaneously. The objective is to minimize the sum of the makespan (or the total weighted completion time) of the accepted jobs and the total rejection cost of the rejected jobs. Firstly, we build the relation between problem 1|MNA(*a*, *b*),rej| *f* + *e*(*R*) and problem 1|ONA(*a*, *b*),rej| *f* + *e*(*R*), where *f* ∈ {*C*max, ∑ *wjCj*}. That is, by enumerating the crossover job and its starting time, problem 1|ONA(*a*, *b*),rej| *f* + *e*(*R*) can be decomposed into many subproblems of 1|MNA(*a*, *b*),rej| *f* + *e*(*R*). Consequently, by borrowing the previous algorithms for problem 1|MNA(*a*, *b*),rej| *f* + *e*(*R*), we provide a pseudo-polynomial-time algorithm and an FPTAS for problem 1|ONA(*a*, *b*),rej| *f* + *e*(*R*), respectively.

When there are *k* ≥ 2 MNA or ONA intervals (*a*1, *b*1),(*a*2, *b*2), ··· ,(*ak*, *bk*) on the machine, the corresponding problem is strongly NP-hard (see [3]) when *k* is arbitrary. However, when *k* is a fixed constant, it is possible to propose a pseudo-polynomial-time algorithm with a larger time complexity. Breit et al. [5] showed that, for any *ρ* ≥ 1 and *k* ≥ 2, there is no *ρ*-approximation algorithm for problem 1|MNA(*ai*, *bi*)|*C*max unless P = NP. It is easy to verify that the inapproximability result still holds when there are *k* ≥ 2 MNA or ONA intervals on the machine and *bk* is sufficiently large.

Note that, for problem 1|ONA(*a*, *b*),rej| ∑ *wjCj* + *e*(*R*), the time complexity of the proposed FPTAS is *O*( *<sup>n</sup>*5*L*<sup>5</sup> <sup>5</sup> ). That is, the running time is very large and it is not strongly polynomial. Thus, an interesting problem is to design a faster (strongly polynomial) FPTAS for problem 1|ONA(*a*, *b*),rej| ∑ *wjCj* + *e*(*R*). Note further that, when there are *k* ≥ 2 MNA or ONA intervals and each MNA or ONA interval has a bounded length, it is possible to design an effective approximation algorithm. Thus, another interesting problem is to propose some approximation algorithms for the problems with multiple MNA or ONA intervals. Finally, it is also interesting to consider other objective functions such as *L*max + *e*(*R*) and other machine setting such as parallel machines or shop machines.

**Author Contributions:** Conceptualization, methodology and writing-original manuscript, L.Z. (Lili Zuo) and Z.S.; project management, supervision and writing-review, L.L.; investigation, formal analysis and editing, L.Z. (Liqi Zhang).

**Funding:** This research was funded by the National Natural Science Foundation of China under grant number 11771406 and 11571321.

**Acknowledgments:** We are grateful to the Associate Editor and three anonymous reviewers for their valuable comments, which helped us significantly improve the quality of our paper.

**Conflicts of Interest:** The authors declare no conflict of interest.

#### **References**


c 2019 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).
