1. Introduction
In this section, we introduce some models on scheduling with (machine or operator) non-availability intervals, scheduling with rejection, and scheduling with rejection and non-availability intervals, respectively.
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
. The corresponding problem can be denoted by
, where “MNA
” means that there is an MNA interval
and
f is the objective function to be minimized. For problem
, Adiri et al. [
2] proved that the problem is NP-hard and then presented a
-approximation algorithm. For problem
, Lee [
3] showed that this problem is binary NP-hard and then provided a
-approximation algorithm. For problem
, Kacem [
4] designed a
-approximation algorithm and a fully polynomial-time approximation scheme (FPTAS). If there are
MNA intervals
on the machine, the corresponding problem
is strongly NP-hard (see [
3]) when
k is arbitrary. Breit et al. [
5] showed that, for any
and
, there is no
-approximation algorithm for problem
unless P = NP.
When there are
parallel machines
and each machine
has an MNA interval
, the corresponding problem is denoted by
. For problem
, i.e., each machine
has a machine release time
, Lee [
6] provided a modified LPT (MLPT) algorithm with a tight approximation ratio
. Kellerer [
7] improved this bound
to
by a dual approximation algorithm using a bin packing approach. For problem
, Schmidt [
8] showed that the SPT rule is optimal. Lee [
6] also studied the problem
with the assumption that one machine is always available. He showed that the approximation ratios of LS (List Scheduling) and LPT are
m and
, respectively. Furthermore, Liao et al. [
9] considered the same problem with
and developed exact algorithms based on the TMO algorithm for problem
. 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
. For problem
, Brauner et al. [
13] proved that it is binary NP-hard and provided an FPTAS. For problem
, Kacem et al. [
14] proposed an FPTAS by borrowing the FPTAS for problem
. Chen et al. [
15] considered the problem
and presented a
-approximation algorithm. Wan and Yuan [
16] further considered the problem
. 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
, where
f is the objective function on the set
A of accepted jobs and
is the total rejection cost on the set
R of rejected jobs. For problem
, 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
, 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
. They showed that this problem is binary NP-hard and then provided an FPTAS. They also showed that, when
, the problem
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
and
, 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 and a single machine. Each job is available at time 0 and has a processing time , a weight and a rejection cost . Each job is either rejected and the rejection cost has to be paid, or accepted and then processed non-preemptively on the machine. There is an operator non-availability interval on the machine, where we assume that . This implies that, in any feasible schedule , no accepted job can be started or be completed in the interval . 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, , and are non-negative integers. Let A and R be the sets of accepted jobs and rejected jobs, respectively. Denote by , and 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 or is minimized. By using the notation for scheduling problems, the corresponding problems are denoted by and , respectively.
Two similar problems related to the above problems are
and
. 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
and
, respectively.
3. Pseudo-Polynomial-Time Algorithms
Brauner et al. [
13] and Chen et al. [
15] showed that problems
and
are NP-hard. Thus, two problems
and
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,
and
, are binary NP-hard.
For problems
and
, 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
can be decomposed into many subproblems of
. Consequently, by borrowing the algorithms in [
24,
25], we also presented a pseudo-polynomial algorithm for problems
and
, respectively.
Lemma 1. If algorithm solves problem in time, then Algorithm 1 yields an optimal schedule for problem in time.Algorithm 1 |
Step 1: Let be a dynamic programming algorithm for problem , where |
Step 2: Applying algorithm to the problem , we can obtain a schedule |
Step 3: For each job with and each integer t with and , we first schedule in time interval . Set , and instance . Applying algorithm to the instance of problem , we can obtain a schedule |
Step 4: Choose the schedule among all schedules in with the smallest objective value. |
Proof. Firstly, we show that Algorithm 1 yields an optimal schedule for problem . Let be an optimal schedule for problem . We distinguish two cases into our discussion.
Case 1: No crossover job exist in .
In this case, interval is completely forbidden. That is, an ONA interval is equivalent to an MNA interval. Thus, in this case, is also an optimal schedule for problem .
Case 2: There is a crossover job in .
Let be the crossover job in and let t be the starting time of in . Clearly, we have and . In this case, no job in can be processed in the interval . Set and . The remaining problem is equivalent to the instance of the problem . Thus, in this case, is also an optimal schedule for problem .
From the above discussions, Algorithm 1 always yields an optimal schedule for problem . Note that algorithm is called at most times. Thus, the time complexity of Algorithm 1 is exactly . □
Note that Zhong et al. [
24] presented an
-time dynamic programming algorithm for problem
. Zhao and Tang [
25] presented an
-time algorithm for problem
. Thus, we have the following corollaries.
Corollary 1. Algorithm 1 solves problem in time and solves problem in time.
Example 1. A simple example for problem is constructed as follows: Given a positive number , we have three jobs with , and . We also assume that there is a single machine with an ONA interval , where and . Note that . Thus, is the unique candidate for the crossover job. Note further that . Thus, must be accepted in any optimal schedule. We distinguish two cases in our discussion.
Case 1: is not a crossover job.
In this case, since , must be processed at or after time . Thus, the optimal schedule is to process and in and , respectively, and reject . That is, the value is .
Case 2: is the crossover job and starts its processing at time t.
Since and , we have . When , only can be processed before . Thus, the value is at least . The minimum value can be reached by processing and in and reject . When , only one job between and can be processed before . Thus, the value is at least . The minimum value can be reached by processing and in and reject .
By combining all cases, the optimal value is , which can be reached by processing and in and reject .
4. Approximation Schemes
In this section, by borrowing the FPTASs in [
24,
25], we also presented an FPTAS for problems
and
, respectively. Given an
for some positive integer
E, we set
for each
. To propose an FPTAS, we delay the starting of the crossover job slightly such that the crossover job starts its processing at some time
. Such a delay may increase the objective value by
times, we say that it produces a
-loss.
Lemma 2. If a crossover job exists in an optimal schedule, with a -loss, we can assume that the crossover job starts its processing at some time .
Proof. Let
be an an optimal schedule for problem
or problem
. Let
and
be the set of accepted jobs and the set of rejected jobs in
, respectively. In addition, we also assume that
is the
jth processed job in
. Without loss of generality, we assume that
is the crossover job in
. Furthermore, we assume that the starting time of
is
t with
and
. If
for each
, then there is some
i with
such that
, where
. By delaying the processing of
by a length of
, we can obtain a schedule
. Note that
and
. Thus,
is feasible for problems
and
. Note further that
and
for each
. Thus, we have
for each
and
for each
. It follows that
Notice that both of the total rejection cost in and are . Thus, we can conclude that the objective value is increased by at most times. This completes the proof of Lemma 2. □
Next, based on Lemma 2, we propose an FPTAS for problems and .
Lemma 3. If algorithm is an FPTAS for problem with the time complexity of , then Algorithm 2 is also an FPTAS for problem with the time complexity of .Algorithm 2 |
Step 1: Let be an FPTAS for problem , where . |
Step 2: Applying algorithm to the problem , we can obtain a schedule . |
Step 3: For each job with and each integer with and , we first schedule in time interval . Set , and instance . Applying algorithm to the instance of problem , we can obtain a schedule . |
Step 4: Choose the schedule among all schedules in with the smallest objective value. |
Proof. Firstly, we prove that Algorithm 2 is an FPTAS for . Let be an optimal schedule for problem . Let Z and 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 is completely forbidden. That is, an ONA interval is equivalent to an MNA interval. Thus, we have .
Case 2: There is a crossover job in .
Let
be the crossover job in
and let
t be the starting time of
in
. Clearly, we have
and
. In this case, no job in
can be processed in the interval
. Set
and
. Thus, the remaining problem is equivalent to the instance
of the problem
. Let
be the optimal objective value for problem
under the constraint in which
is the crossover job and
starts its processing at time
t. Note that algorithm
is an FPTAS for problem
. Thus, we have
. Furthermore, by Lemma 2, we also have
. It follows that
From the above discussions, Algorithm 2 is an FPTAS for . Note that algorithm is called at most times. Thus, the time complexity of Algorithm 2 is exactly . □
Note that Zhong et al. [
24] presented an FPTAS with the time complexity of
for problem
. Zhao and Tang [
25] presented an FPTAS with the time complexity
for problem
, where
. Thus, we have the following corollaries.
Corollary 2. Algorithm 1 is an FPTAS for problems and with the time complexities of and , 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 and problem , where . That is, by enumerating the crossover job and its starting time, problem can be decomposed into many subproblems of . Consequently, by borrowing the previous algorithms for problem , we provide a pseudo-polynomial-time algorithm and an FPTAS for problem , respectively.
When there are
MNA or ONA intervals
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
and
, there is no
-approximation algorithm for problem
unless P = NP. It is easy to verify that the inapproximability result still holds when there are
MNA or ONA intervals on the machine and
is sufficiently large.
Note that, for problem , the time complexity of the proposed FPTAS is . 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 . Note further that, when there are 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 and other machine setting such as parallel machines or shop machines.