See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/335419240

Single machine scheduling with outsourcing under different fill rates or

quantity discount rates

Article  in  Asia Pacific Journal of Operational Research · February 2020

DOI: 10.1142/S0217595919500337

CITATIONS READS

0 50

4 authors, including:

Lingfa Lu Liqi Zhang

Zhengzhou University Henan Agriculture University
33 PUBLICATIONS   442 CITATIONS    22 PUBLICATIONS   328 CITATIONS   

SEE PROFILE SEE PROFILE

Some of the authors of this publication are also working on these related projects:

(NSFC11771406): Service scheduling for optimizing the satisfaction degree of customers View project

NSFC(11426094): On-line scheduling and trade-off scheduling with rejection View project

All content following this page was uploaded by Lingfa Lu on 27 August 2019.

The user has requested enhancement of the downloaded file.

 Single machine scheduling with outsourcing
under different fill rates or quantity
discount rates
Lingfa Lua,∗ Liqi Zhangb , Jie Zhanga , Lili Zuoa
a School of Mathematics and Statistics, Zhengzhou University,
Zhengzhou, Henan 450001, P.R. China
b College of Information and Management Science, Henan Agricultural University,
Zhengzhou, Henan 450003, P.R. China

Abstract. In this paper we consider two single machine scheduling problems with outsourcing
under different fill rates or quantity discount rates. From the manufacturer point of view, to
maintain a predefined high service level under limited production capacity, it is required that the
number of outsourced jobs must belong to a given interval [a, b]. We call this model “scheduling
with outsourcing under different fill rates”. Meanwhile, from the outsourcers point of view,
in order to encourage more outsourcing actions from the manufacturer, the outsourcers might
provide an attractive discount scheme. Here we assume that all discount rates depend only on
the quantity (number) of the outsourced jobs. That is, the actual outsourcing cost equals to
the original outsourcing cost multiplying by the corresponding discount rate. This model is
called “scheduling with outsourcing under different quantity discount rates”. The objective is
to minimize the sum of the makespan of the processed jobs and the (actual) outsourcing costs
of the outsourced jobs. For the above two problems, some optimal algorithms, approximation
algorithms and approximation schemes are proposed.

Keywords: Scheduling with outsourcing; Fill rates; Discount rates; Approximation algorithm;
FPTAS

1 Introduction
Outsourcing (rejection) is an important option for a manufacturer to face the changing
market. Usually, the manufacturer has a limited production capacity. When order quan-
tity is very high or deadlines are very tight sometimes, some orders might be rejected
or outsourced to the third-party machines for processing. Proper outsourcing (rejection)
∗
Corresponding author: Lingfa Lu. Email address: lulingfa@zzu.edu.cn

1
can shorten times, reduce costs, and make the manufacturer more competitive. The ben-
efit of outsourcing (rejection) has been studied extensively in different problems, such as
scheduling, bin packing, supply chain and service industry. Scheduling with outsourcing
(rejection) has received more and more attentions from many academic researchers over
the last decade. Generally speaking, if a job is outsourced (rejected), the manufacturer
need pay an outsourcing (rejection) cost. In this situation, to minimize a given objective
function, the manufacture needs to determine which jobs should be processed in-house
and which should be outsourced (rejected). Furthermore, the manufacturer needs to
determine a schedule for the jobs to be processed by the in-house machines.
Though scheduling with outsourcing is equivalent to scheduling with rejection in math-
ematics, they are studied independently by many researchers. Next, we will introduce
some results on scheduling problems with rejection or outsourcing , respectively.

1.1 Some results on scheduling with rejection

Scheduling with rejection was first studied by Bartal et al. (2000). They studied a
scheduling problem on m identical machines to minimize the sum of the makespan of
accepted jobs and the total rejection cost of rejected jobs. For the on-line problem,
√ they
5+1
presented an online algorithm with the best-possible competitive ratio of 2 ≈ 2.618.
For the off-line problem, they presented a (2 − m1 )-approximation algorithm, an FPTAS
when m is fixed and a PTAS when m is arbitrary. Zhang et al. (2009) considered the
single-machine scheduling with release dates and rejection. They showed that this problem
is NP-hard in the ordinary sense and then provided two pseudo-polynomial-time optimal
algorithms, a 2-approximation algorithm and an FPTAS for the problem, respectively.
Furthermore, Zhang et al. (2010) considered the single-machine scheduling under the job
rejection constraint in which the total rejection cost cannot exceed a given bound U . They
analyzed the computational complexities of the problems for distinct objective functions
and presented an FPTAS for the makespan problem with release dates.
For the off-line problem studied by Bartal et al. (2000), Ou et al. (2015) provided an
O(n log n + n )-time heuristic with a worst-case bound of 1.5 + , where  > 0 can be any
small given constant. Li et al. (2015) considered a similar scheduling problem in which
the total rejection cost cannot exceed a given bound U . They present a 2-approximation
algorithm, an FPTAS when m is fixed and a PTAS when m is arbitrary. Furthermore, Ou
and Zhong (2017a) considered another similar problem in which the number of rejected
jobs is limited to be no greater than a given value k. For the special case with a single-
machine (i.e., m = 1), they provided an optimal algorithm with a time complexity of
O(n log k). For the general case with m > 1 identical machines, they provided a simple
O(n log n)-time heuristic with a worst-case bound of 2 − m1 and a more sophisticated
heuristic with a worst-case bound of 1.5 +  and a time complexity of O(n log n + nm2 /).
Furthermore, Ou and Zhong (2017b) provided an improved heuristic with a worst-case
2
bound of 34 +  and a time complexity of O( kmn 2
). Moreover, the concept of “fill rate”
was presented in this article.
For the more results with other objective functions or other machine settings, we refer

2
the interested reader to a survey which was provided by Shabtay et al. (2013) on off-line
scheduling problems with rejection.

1.2 Some results on scheduling with outsourcing

To the best of our knowledge, Lee et al. (2002) first considered an advanced planning
and scheduling problem with outsourcing allowed. They proposed a genetic algorithm to
minimize the makespan. Qi (2008) considered a single-machine scheduling problem which
allows some jobs to be outsourced to a single outsourcing machine, with a transportation
delay and a transportation cost. Lee and Sung (2008a, 2008b) studied the single-machine
scheduling to minimize the weighted sum of the outsourcing cost and the associated
scheduling cost with an outsourcing budget constraint. They showed that the problem
is NP-hard in the ordinary sense and presented two heuristics and a branch-and-bound
algorithm. Choi and Chung (2011) considered a two-machine flow-shop scheduling in
which any operations can be outsourced. The objective is to minimize the sum of the
makespan and the total outsourcing cost. They showed that the problems are NP-hard
in the ordinary sense and presented an optimal algorithm for a special case. Choi and
Chung (2016) studied the min-max regret version of a single-machine scheduling problem
to determine which jobs are processed by outsourcing under processing time uncertainty.
They presented some computational complexities and some effective optimal algorithms.
For more results on scheduling problems, we refer the reader to a recent literature by Choi
and Chung (2016).
From the outsourcers point of view, in order to encourage more outsourcing action-
s from the manufacturer, the outsourcers might provide an attractive discount scheme.
Usually, the adopted discount scheme for the manufacturer depends on the quantity (num-
ber), or the total cost, or the season (high season or low season). There are two types of
discount schemes which are commonly used in practice. The first type is the dollar-based
discount scheme and the second type is rate-based discount scheme. To the best of our
knowledge, few articles consider distinct discount models in scheduling problems. Lu et
al. (2018) are the unique to introduce distinct discount models into a single-machine
scheduling problem with outsourcing. They proposed four discount models in which the
enjoyed discount depends only on the total original outsourcing cost. In addition, the
first two models belong to dollar-based discount scheme and the last two models belong
to rate-based discount scheme. In this paper, we consider a similar but different problem
under the rate-based discount scheme. Here we assume that all discount rates depend
only on the the quantity (number) of the outsourced jobs.

The rest of the article is organized as follows: In Section 2, we define two scheduling
problems, which are called “scheduling with outsourcing under different fill rates” and
“scheduling with outsourcing under different quantity discount rates”, respectively. In
Section 3, we discuss the connections among the above two problems and some related
problems which are studied in previous literature. In Section 4, we consider the single-
machine scheduling problem with outsourcing under different fill rates. We provide a

3
polynomial-time optimal algorithm for the special case with the identical release dates; two
dynamic programming algorithms, a 2-approximation algorithm and a fully polynomial-
time approximation scheme (FPTAS) for the general case with the non-identical release
dates, respectively. In Section 5, we consider the single-machine scheduling problem with
outsourcing under different quantity discount rates. We first show that the latter problem
can be decomposed into some subproblems and each subproblem can be transformed into
an instance of the former problem. Based on this idea, we adopt the above algorithms for
former problem as subroutines to solve the latter problem. Finally, some conclusions and
future research are given in Section 6.

2 Problem formulation
Single machine scheduling with outsourcing can be stated as follows. There are n jobs
J1 , · · · , Jn and a single machine. Each job Jj has a processing time pj , a release date
rj and an (original) outsourcing cost ej . We assume that all pj and ej are non-negative
integers. For each job Jj , the manufacturer can choose to process Jj directly by the in-
house machines or outsource it to an outsourcer for processing. Let O be the set of the
outsourced jobs. Let N = |O| and V = Jj ∈O ej be the number of the jobs in O and
P

the original total outsourcing cost of the jobs in O, respectively. Let O be the set of the
in-house processed jobs and Cmax (O) = max{Cj : Jj ∈ O} be the makespan of the jobs
in O.
In the first scheduling problem, there is a given interval [a, b], where we assume that
0 ≤ a ≤ b ≤ n. From the manufacturer’ point of view, to maintain a predefined high
service level under limited production capacity, we only consider the feasible schedule
under the constraint with N ∈ [a, b]. The corresponding scheduling problem can be
denoted by
1|rj , a ≤ N ≤ b|Cmax (O) + V. (1)
This model is also called “scheduling with outsourcing under different fill rates”. Clearly,
this problem is an interesting extension of the single-machine problems studied by Zhang
et al. (2009) and Ou and Zhong (2017a).
In the second scheduling problem, it is assumed that there are m disjoint intervals
[N1 , N2 − 1], · · · , [Nk−1 , Nk − 1], · · · , [Nm , Nm+1 − 1], where N1 = 0 and Nm+1 = n + 1.
From the outsourcer’ point of view, to encourage more outsourcing actions from the
manufacturer, the outsourcer might offer distinct discount rates depending on the quantity
(number) of outsourced jobs. Let g(N, V ) be the actual total outsourcing cost of the jobs
in O. When N ∈ [Nk , Nk+1 − 1], k = 1, · · · , m, a certain discount rate DRk is offered.
Without loss of generality, we also assume that 1 ≥ DR1 > DR2 > · · · > DRm > 0.
Then the actual outsourcing cost of the jobs in O is defined as

g(N, V ) = DRk · V, if N ∈ [Nk , Nk+1 − 1]. (2)

The above discount scheme is also called the all-units discount scheme in Li et al. (2012).

4
The corresponding scheduling problem can be denoted by

1|rj |Cmax (O) + g(N, V ). (3)

This model is also called “scheduling with outsourcing under different quantity discount
rates”.

3 The connections with related problems

In this section, we discuss the connections among the above two problems and some
related problems which are studied in previous literature. First, we consider the first
problem 1|rj , a ≤ N ≤ b|Cmax (O) + V . Clearly, when there is no constraint, i.e., a = 0
and b = n, the corresponding problem can be denoted by 1|rj |Cmax (O)+V . If we treat the
oursourcing cost ej of job Jj as its rejected penalty wj , then the problem 1|rj |Cmax (O)+V
is equivalent to the problem 1|rj |Cmax + Jj ∈R wj , where R is the set of rejected jobs.
P

Zhang et al. (2009) showed that problem 1|rj |Cmax + Jj ∈R wj is binary NP-hard and
P

further proposed two dynamic programming algorithms, a 2-approximation algorithm and

a fully polynomial-time approximation scheme.
Ou and Zhong (2017a) considered two order acceptance and scheduling problems with
consideration of service level. In their problems, to maintain a predefined high service
level, the number of rejected orders is limited to be no greater than a given value k. In
addition, they also assume that rj = 0 for each order Jj . The objective is to minimize the
makespan of accepted order plus the total rejection penalty of rejected orders. For the
single-machine problem, they presented an optimal algorithm with the time complexity
of O((n log k). For the parallel-machine scheduling problem, they proposed an O(n log n)-
2
time heuristic with a worst-case bound of 2 − m1 and an O(n log n + nm )-time heuristic
with a worst-case bound of 23 + , where m is the number of the machines and  > 0 can be
2 3
a small given constant. Furthermore, Ou and Zhong (2017b) proposed an O( m2n )-time
heuristic with an improved worst-case bound of 43 + . Notice that, in Ou and Zhong
(2017b), the constraint |R| ≤ k derives from “the consideration of fill rate”. Clearly, the
parallel-machine problems studied by Ou and Zhong (2017a, b) are the extension of the
problems studied by Bartal et al. (2000).
Because scheduling with outsourcing is equivalent to scheduling with rejection, as Ou
and Zhong (2017a, b) said, it is reasonable to assume that the number of outsourced
orders is no greater than a given upper b. Meanwhile, due to the limited capacity of
the in-house machines, it is also reasonable to assume that at least a orders should be
outsourced. Due to this reason, we consider the scheduling problem with outsourcing
under different fill rates. That is, the number of outsourced jobs must belong to a given
interval [a, b]. Thus, the first studied problem can be seen as an interesting extension of
the single-machine problems studied by Zhang et al. (2009) and Ou and Zhong (2017a).
Furthermore, in Section 5, we show that the latter problem 1|rj |Cmax (O) + g(N, V ) can
been seen as the extension of the former problem 1|rj , a ≤ N ≤ b|Cmax (O) + V .

5
4 Scheduling under different fill rates
In this section, we consider the problem 1|rj , a ≤ N ≤ b|Cmax (O)+V . In subsection 4.1, we
provide a polynomial-time algorithm for the special case with the identical release dates.
In subsection 4.2, we provide two dynamic programming algorithms, a 2-approximation
algorithms and a fully polynomial-time approximation scheme (FPTAS) for the general
case with the non-identical release dates.

4.1 Problem 1|a ≤ N ≤ b|Cmax (O) + V

In this subsection, we assume that rj = 0 for each job Jj , j = 1, · · · , n. The corresponding
problems can be denoted by 1|a ≤ N ≤ b|Cmax (O) + V . Set S1 = {Jj : pj < ej },
S2 = {Jj : pj = ej } and S3 = {Jj : pj > ej }. Note that, if the constraint a ≤ N ≤ b
does not exist, the corresponding problem can be denoted by 1||Cmax (O) + V . The latter
problem is trivial because the jobs in S1 must be processed on the machine, the jobs in
S3 must be outsourced and the jobs in S2 is arbitrary.
Let |S| be the number of the jobs in set S. Next, we consider the restricted problem
1|a ≤ N ≤ b|Cmax (O) + V in three cases.

Case 1. a ≤ |S3 | ≤ b.

In this case, there is an optimal schedule π ∗ for problem 1|a ≤ N ≤ b|Cmax (O) + V
∗
such that O∗ = S3 and O = S1 ∪ S2 .

Case 2. |S3 | < a.

In this case, we are first to show that S3 ⊆ O∗ in any optimal schedule π ∗ for problem
1|a ≤ N ≤ b|Cmax (O) + V . Otherwise, we assume that S3 \ O∗ 6= ∅. Note that |S3 | < a ≤
|O∗ |. Thus, we also have O∗ \ S3 6= ∅. It follows that, there are two jobs Ji and Jj such
that Ji ∈ S3 \ O∗ and Jj ∈ O∗ \ S3 . By the definitions of Ji and Jj , we have ei < pi and
ej ≥ pj . We can obtain a new feasible schedule π from π ∗ by exchanging Ji and Jj . That
∗
is, we have O = O∗ ∪ Ji \ Jj and O = O ∪ Jj \ Ji . Furthermore, we have

Cmax (π) + V = Cmax (π ∗ ) + V ∗ + (ei − pi ) + (pj − ej ) < Cmax (π ∗ ) + V ∗ .

This contradicts the fact that π ∗ is an optimal schedule for problem 1|a ≤ N ≤ b|Cmax (O)+
V.
By the above discussion, we have S3 ⊆ O∗ . Thus, we have

Cmax (π ∗ ) + V ∗ =
P P
∗ p +
j J ∈O∗ ej
PJnj ∈O P j
j=1 pj −
P
= Jj ∈O∗ pj + Jj ∈O∗ ej
Pn
∗ (ej − pj )
P
= j=1 pj +
Pn PJj ∈O
Jj ∈S3 (ej − pj ) + Jj ∈O∗ \S3 (ej − pj ).
P
= p
j=1 j +

6
 Note that nj=1 pj + Jj ∈S3 (ej − pj ) is a fixed constant. Thus, to satisfy the constraint
P P

the constraint a ≤ |O∗ | ≤ b, we must select k jobs with a − |S3 | ≤ k ≤ b − |S3 | from the
jobs in S1 ∪ S2 . Note further that ej − pj ≥ 0 holds for any job Jj ∈ O∗ \ S3 . Thus, to
minimize the Cmax (π ∗ ) + V ∗ value under the constraint the constraint a ≤ |O∗ | ≤ b, we
have to select a − |S3 | jobs with the minimum (ej − pj ) values from the jobs in S1 ∪ S2 .
That is, in this case, we need only to select a jobs with the minimum (ej − pj ) values from
all jobs as the outsourced jobs.

Case 3. |S3 | > b.

In this case, we are first to show that O∗ ⊆ S3 in any optimal schedule π ∗ for problem
1|a ≤ N ≤ b|Cmax (O) + V . Otherwise, we assume that O∗ \ S3 6= ∅. Note that |S3 | > b ≥
|O∗ |. Thus, we also have S3 \ O∗ 6= ∅. It follows that, there are two jobs Ji and Jj such
that Ji ∈ S3 \ O∗ and Jj ∈ O∗ \ S3 . By the definitions of Ji and Jj , we have ei − pi < 0
and pj − ej ≤ 0. Similar to the discussion in Case 2, we can obtain a contradiction.
By the above discussion, we have O∗ ⊆ S3 . Thus, we have

Cmax (π ∗ ) + V ∗ =
P P
Jj ∈O pj + J ∈O∗ ej
∗
Pn P j
pj − Jj ∈O∗ pj + Jj ∈O∗ ej
P
=
Pj=1
n
Jj ∈O∗ (ej − pj ).
P
= j=1 pj +

Note that O∗ ⊆ S3 and ej −pj < 0 for each job Jj ∈ O∗ . Thus, to satisfy the constraint
the constraint a ≤ |O∗ | ≤ b, we must select k jobs with a ≤ k ≤ b from the jobs in S3 .
Thus, to minimize the Cmax (π ∗ ) + V ∗ value under the constraint a ≤ |O∗ | ≤ b, we have
to select b jobs with the minimum (ej − pj ) values from the jobs in S3 as the outsourced
jobs.

Combine all cases, we can obtain the following optimal algorithm A1 for problem
1|a ≤ N ≤ b|Cmax (O) + V .

Optimal algorithm A1

Step 1: Set J = {Jj : j = 1, · · · , n}. For each job Jj , j = 1, · · · , n, we compute the

ej − pj value. Furthermore, we let S1 = {Jj : ej − pj > 0}, S2 = {Jj : ej − pj = 0} and
S3 = {Jj : ej − pj < 0}.
∗
Step 2: If a ≤ |S3 | ≤ b, we set O∗ = S3 and O = S1 ∪ S2 . If |S3 | < a, let O∗ be the a
∗
jobs with the minimum ej − pj values among all jobs and set O = J \ O∗ . If |S3 | > b, let
∗
O∗ be the b jobs with the minimum ej − pj values among all jobs and set O = J \ O∗ .
∗
Step 3: The jobs in O are processed in an arbitrary order on the machine.

Theorem 4.1. Optimal algorithm A1 yields an optimal schedule for the restricted
problem 1|a ≤ N ≤ b|Cmax (O) + V in O(n log b) time.

7
 Proof. The correctness of the algorithm is guaranteed by the above discussion. Clear-
ly, in Step 1, it takes an O(n) time to determine the jobs in Si , i = 1, 2, 3. In Step 2,
if a ≤ |S3 | ≤ b, the optimal schedule can be obtained in a constant time. If |S3 | < a or
|S3 | > b, then O∗ contains exactly k = a or k = b jobs with the minimum ej − pj values
among all jobs. By using a specific data structure named AVL tree, which is adopted in
Ou et al. (2017a), it follows that the time complexity of A1 is O(n log b). 2

4.2 Problem 1|rj , a ≤ N ≤ b|Cmax (O) + V

When there is no constraint, i.e., a = 0 and b = n, the corresponding problem can be
denoted by 1|rj |Cmax (O) + V . If we treat the oursourcing cost ej of job Jj as its rejected
penalty wj , then the problem 1|rj |Cmax (O) + V is equivalent to the problem 1|rj |Cmax +
P
Jj ∈R wj , where R is the set of rejected jobs. For the latter problem, Zhang et al. (2009)
showed that this problem is binary NP-hard and further proposed a 2-approximation
algorithm and a fully polynomial-time approximation scheme. As an extension of the
studied problem in Zhang et al. (2009), the problem 1|rj , a ≤ N ≤ b|Cmax (O) + V is also
NP-hard. By the modification of two dynamic programming algorithms for the problem
1|rj |Cmax + Jj ∈R wj in Zhang et al. (2009), we can present two dynamic programming
P

algorithms for the problems 1|rj , a ≤ N ≤ b|Cmax (O) + V . This implies that problem
1|rj , a ≤ N ≤ b|Cmax (O) + V is in fact binary NP-hard.

4.2.1 Dynamic Programming algorithms

Similar to Lemma 3.1 in Zhang et al. (2009), we can conclude that, for the problem
1|rj , a ≤ N ≤ b|Cmax (O) + V , there exists an optimal schedule such that the in-house
processed jobs are scheduled in the ERD rule. Thus, we first re-label the jobs such that
r1 ≤ · · · ≤ rn . Let fj (k, V ) be the optimal makespan of the processed jobs under the fol-
lowing conditions: (1) the jobs in consideration are J1 , · · · , Jj ; (2) there are k jobs which
are outsourced among the jobs J1 , · · · , Jj ; and (3) the total outsourcing cost is exactly
V . Now, we consider any optimal schedule for the jobs Jj , · · · , Jn . In any such schedule,
there are two possible cases: either Jj is outsourced or Jj is processed in house.

Case 1. Job Jj is outsourced.

In this case, among J1 , · · · , Jj−1 , there are exactly k − 1 jobs which are outsourced
and the corresponding total outsourcing cost is exactly V − ej . Furthermore, since Jj is
outsourced, the makespan does not change. Thus, we have fj (k, V ) = fj−1 (k − 1, V − ej ).

Case 2. Job Jj is processed.

In this case, among J1 , · · · , Jj−1 , there are still k jobs which are outsourced and the
corresponding total outsourcing cost is still V . Thus, the optimal makespan of the pro-

8
cessed jobs among J1 , · · · , Jj−1 is fj−1 (k, V ). Due to the ERD rule, Jj is scheduled after
the processed jobs among J1 , · · · , Jj−1 . Thus, we have fj (k, V ) = max{fj−1 (k, V ), rj }+pj .

Combining the above two cases, we have the following dynamic programming algo-
rithm DP1.

Dynamic programming algorithm DP1

The boundary conditions:



 r1 + p1 if k = 0 and V = 0;
f1 (k, V ) = 0 if k = 1 and V = e1 ;


+∞ otherwise.

The recursive function:

fj (k, V ) = min{max{fj−1 (k, V ), rj } + pj , fj−1 (k − 1, V − ej )}

Pn
The optimal value is given by min{fn (k, V ) + V : a ≤ k ≤ b, 0 ≤ V ≤ j=1 ej }.

Theorem 4.2. Algorithm DP1 solves problem 1|rj , a ≤ N ≤ b|Cmax (O) + V in

O(nb nj=1 ej ) time.
P

Proof. The correctness of the algorithm is guaranteed by the above discussion. Note
that 1 ≤ j ≤ n, k ≤ b and 0 ≤ V ≤ nj=1 ej . Thus, the recursive function fj (k, V ) has
P
Pn
at most O(nb j=1 ej ) states and each iteration takes a constant time. Hence, the overall
time complexity of DP1 is bounded by O(nb nj=1 ej ). 2
P

Remark: Similar to the dual algorithm DP2 in Zhang et al. (2009), we can also obtain
a dual dynamic programming algorithm DP2 with the time complexity of O(nbTERD ) for
problem 1|rj , a ≤ N ≤ b|Cmax (O) + V , where TERD ≤ rn + nj=1 pj is the makespan
P

obtained from the ERD rule.

4.2.2 Approximation algorithms

For problem 1|rj |Cmax + Jj ∈R wj , Zhang et al. (2009) proposed a 2-approximation al-
P

gorithm and a fully polynomial-time approximation scheme (FPTAS). In this subsection,

by the modification of their algorithms, we propose first a 2-approximation algorithm and
then an FPTAS for the problems 1|rj , a ≤ N ≤ b|Cmax (O) + V . For a set S of jobs, we
define |S|, p(S) = Jj ∈S pj and E(S) = Jj ∈S ej as the number, the total processing time
P P

and the original total outsourcing cost of the jobs in S .

Approximation algorithm A2

9
 Step 0: Let π(∅) be the schedule in which all jobs are outsourced. If a ≤ n ≤ b, then
Let Z(∅) = g(n, nj=1 ej ) be the corresponding value of the objective function. Otherwise,
P

we set Z(∅) = +∞.

Step 1: For each t ∈ {rj : j = 1, · · · , n}, we divide the jobs into two sets such that
S1 (t) = {Jj : rj ≤ t} and S2 (t) = {Jj : rj > t}. If |S2 (t)| > b, we set Z(t) = +∞. If
|S2 (t)| ≤ b, we set a0 = max{0, a − |S2 (t)|} and b0 = b − |S2 (t)|. Then we can construct an
instance I 0 (t) of problem 1|rj , a0 ≤ N ≤ b0 |Cmax (O) + V such that only the jobs in S1 (t)
are contained in instance I 0 (t). Furthermore, we can also obtain a new instance I 00 (t)
from instance I 0 (t) by setting rj0 = 0 for each job Jj ∈ S1 (t). That is, I 00 (t) is an instance
of problem 1|a0 ≤ N ≤ b0 |Cmax (O) + V .
Step 2: Apply algorithm A1 to obtain an optimal solution π 00 (t) of the instance I 00 (t).
Let O00 (t) and O00 (t) = S1 (t) \ O00 (t) be the outsourced jobs and the in-house processed
jobs, respectively. Process the jobs in O00 (t) in time interval [t, t + p(O00 (t))] and outsource
the jobs in O00 (t) ∪ S2 (t). We can obtain a feasible schedule π(t) for the original problem.
Let Z(t) = t + p(O00 (t)) + E(O00 (t)) + E(S2 (t)) be the value of the objective function in
π(t).
Step 3: Select the minimum value from {Z(∅), Z(r1 ), · · · , Z(rn )} and the correspond-
ing schedule with the minimum value.

Let π be the schedule obtained from the above approximation algorithm A2 . Let Z(I)
and Z ∗ (I) be the objective values of the schedule π and an optimal schedule π ∗ of instance
I, respectively.

Theorem 4.3. Z(I) ≤ 2Z ∗ (I) and the bound is tight. Furthermore, the time com-
plexity of A2 is O(n2 log b).

Proof. Let O∗ and O∗ be the sets of the outsourced jobs and in-house processed
jobs, respectively. If O∗ = ∅, i.e., all jobs are outsourced in π ∗ , then π(∅) = π ∗ . In this
situation, by Step 3, algorithm A2 outputs an optimal schedule.
Next, we assume that O∗ 6= ∅. In this situation, we let t∗ = max{rj : Jj ∈ O∗ }.
By the definition of t∗ , we have S2 (t∗ ) ⊆ O∗ and |S2 (t∗ )| ≤ b. Furthermore, we also
have Z ∗ (I) ≥ t∗ + E(S2 (t∗ )). We consider the instance I 00 (t∗ ) obtained by Step 2, which
is restricted to the jobs in S1 (t∗ ) and rj = 0 for each job Jj ∈ S1 (t∗ ). Let O00 (t∗ )
and O00 (t∗ ) = S1 (t∗ ) \ O00 (t∗ ) be the outsourced jobs and the in-house processed jobs,
respectively. Let Z 00 (I(t∗ )) be the optimal value of the objective function of the instance
I 00 (t∗ ). Note that instance I 00 (t∗ ) have fewer jobs and smaller release dates than instance
I. Thus, we have Z ∗ (I) ≥ Z ∗ (I 00 (t∗ )) = p(O00 (t∗ )) + E(O00 (t∗ )).
Combine the above two inequalities, we have
Z(I) ≤ Z(t∗ )
= t∗ + p(O00 (t∗ )) + E(O00 (t∗ )) + E(S2 (t∗ ))
≤ 2Z ∗ (I).

Note that, when a = 0 and b = n, the problem 1|rj , a ≤ N ≤ b|Cmax (O) + V is

10
equivalent to the problem 1|rj |Cmax + Jj ∈R wj studied by Zhang et al. (2009). In this
P

situation, approximation algorithm A2 is also equivalent to the 2-approximation algorithm

in Zhang et al. (2009). Note that Zhang et al. (2009) showed that this bound 2 is tight.
Thus, this bound 2 for our approximation algorithm A2 is also tight.
Note further that there are n choices for all t values in Step 1. Once t is determined,
S1 (t), S2 (t) and instance I 00 (t) can be obtained in O(n) time and algorithm A1 takes an
O(n log b) time to obtain an optimal schedule for instance I 00 (t). Finally, it also takes
an O(n) time to select the best schedule in Step 3. Thus, the time complexity of A2 is
O(n2 log b). 2

Remark. Algorithm A2 is in fact an extension of the 2-approximation algorithm in

Zhang et al. (2009). By using a better data structure, Ou et al. (2016) showed that the
time complexity of the 2-approximation algorithm in Zhang et al. (2009) can be improved
from O(n2 ) to O(n log n). By using the same data structure, the time complexity of algo-
rithm A2 can be reduced to O(n log n log b). However, our target is to obtain an FPTAS
for our problem by using the approximation ratio 2 of algorithm A2 . Thus, we omit the
detailed procedure on how to reduce the time complexity of algorithm A2 .

Similar to the FPTAS in Zhang et al. (2009), we can also present an FPTAS for
problem 1|rj , a ≤ N ≤ b|Cmax (O) + V . Let Z be the objective value of the above approx-
imation algorithm A2 . Let Z ∗ be the optimal objective value. By Theorem 4.3, we have
Z ∗ ≤ Z ≤ 2Z ∗ . For any job Jj with ej > Z, it is easy to see that Jj ∈ O∗ . Otherwise,
we have Z ∗ ≥ ej > Z ≥ Z ∗ , a contradiction. If we modify the outsourcing cost of Jj
such that ej = Z, this does not change the optimal objective value. Thus, without loss
of generation, we can assume that ej ≤ Z for j = 1, · · · , n. Now, we propose a fully
polynomial-time approximation scheme A for this problem.

Approximation scheme A

Step 1. For any  > 0, set M = Z 2n

. Given an instance I, we define a new instance
ej
I by rounding the outsourcing costs of the jobs in I such that e0j = b M
0
cM for j = 1, · · · , n.

Step 2. Apply the dynamic programming algorithm DP1 to the instance I 0 to obtain
an optimal solution π ∗ (I 0 ) for the instance I 0 .

Step 3. For each j = 1, · · · , n replace the modified outsourcing cost e0j by the original
outsourcing cost ej in π ∗ (I 0 ). We can obtain a feasible solution π for the instance I.

Let Z be the objective value of the schedule π obtained from A . We have the follow-
ing theorem.
3
Theorem 4.4. Z ≤ (1 + )Z ∗ and the running time of A is O( n b ).

11
 Proof. Let Z ∗ (I 0 ) be the optimal objective value of the schedule π ∗ (I 0 ). From step 1
of A , we have e0j ≤ ej < e0j + M . Thus, we have Z ∗ (I 0 ) ≤ Z ∗ . Replace rj0 and p0j by rj
and pj for each j = 1, · · · , n, we have
n
∗ 0 Z
(ej − e0j ) ≤ Z ∗ + nM ≤ Z ∗ + ≤ (1 + )Z ∗ .
X
Z ≤ Z (I ) +
j=1 2

Since ej ≤ Z for j = 1, · · · , n, we have e0j ≤ Z. Furthermore, we have V ≤ nj=1 e0j ≤

P

nZ. Note that, since all e0j s are the multiple of M , all V values in DP1 are also the
2
multiple of M . Thus, there are at most O( nZ M
) = O( n ) choices for all V values in DP1.
3
Therefore, the running time of DP2 (also A ) is O( n b ). Theorem 4.4 follows. 2

5 Scheduling with different quantity discount rates

In this section, we consider the problem 1|rj |Cmax (O) + g(N, V ). Let π ∗ be an optimal
schedule for problem 1|rj |Cmax (O) + g(N, V ). Let O∗ be the set of the outsourced jobs
in π ∗ . Furthermore, let N ∗ = |O∗ | and V ∗ = Jj ∈O∗ ej be the number of the jobs in
P

O∗ and the original total outsourcing cost of the jobs in O∗ , respectively. Note that, if
Nk ≤ N ∗ ≤ Nk+1 − 1 holds, we have g(N ∗ , V ∗ ) = DRk · Jj ∈O∗ ej = Jj ∈O∗ DRk · ej . Set
P P

e0j = DRk ·ej and V 0 = g(N, V ) = Jj ∈O e0j . Then the latter problem with the assumption
P

Nk ≤ N ∗ ≤ Nk+1 − 1 is equivalent to problem

1|rj , Nk ≤ N ≤ Nk+1 − 1|Cmax (O) + V 0 . (4)

Notice that, the latter problem is a special case of problem 1|rj , a ≤ N ≤ b|Cmax (O) +
V . Thus, the problem 1|rj |Cmax (O) + g(N, V ) can be decomposed into m subproblems
1|rj , Nk ≤ N ≤ Nk+1 − 1|Cmax (O) + V 0 , k = 1, · · · , m. Let A ∈ {A1 , A2 , A , DP 1, DP 2}
be an optimal or approximation algorithm for problem 1|rj , a ≤ N ≤ b|Cmax (O) + V such
that Z A (I) ≤ ρZ ∗ (I), where ρ = 1 if A is an optimal algorithm. By using algorithm A
as a subroutine to solve all m subproblems and selecting the best solution, we can obtain
the following algorithm A3 for problem 1|rj |Cmax (O) + g(N, V ).

Algorithm A3

Step 1: For a given instance of problem 1|rj |Cmax (O) + g(N, V ), we first decompose it
into m subproblems as follows: For each k = 1, · · · , m, set e0j = DRk · ej , we can construct
an instance of problem 1|rj , Nk ≤ N ≤ Nk+1 − 1|Cmax (O) + V 0 .
Step 2: Let A be a given algorithm for the problem 1|rj , a ≤ N ≤ b|Cmax (O) + V .
Solve all m subproblems by algorithm A, respectively. Let Zk be the objective function
value and πk be the corresponding optimal schedule for each subproblem 1|rj , Nk ≤ N ≤
Nk+1 − 1|Cmax (O) + V , k = 1, · · · , m.
Step 3: Set Zmin = min{Zk : k = 1, · · · , m} and select the schedule with the Zmin value.

12
 Let Z ∗ and Zk∗ be the optimal objective values for problems 1|rj |Cmax (O) + g(N, V )
and 1|rj , Nk ≤ N ≤ Nk+1 − 1|Cmax (O) + V 0 , respectively. Furthermore, let TA be the
maximum time complexity of algorithm A for solving m subproblems 1|rj , Nk ≤ N ≤
Nk+1 − 1|Cmax (O) + V 0 , where k = 1, · · · , m. Note that b ≤ Nm+1 − 1 = n. Thus,
5
we have TA1 = O(n log n), TA2 = O(n2 log n), TA = O( n ), TDP 1 = O(n2 ej ) and
P

TDP 2 = O(n2 TERD ).

Theorem 5.1. For problem 1|rj |Cmax (O) + g(N, V ), we have Zmin ≤ ρZ ∗ . Further-
more, the time complexity of algorithm A3 is O(mTA ) for each A ∈ {A1 , A2 , A , DP 1, DP 2}.

Proof. Let π ∗ be an optimal schedule for problem 1|rj |Cmax (O) + g(N, V ). Let O∗
be the set of the outsourced jobs in π ∗ . Furthermore, let N ∗ = |O∗ | be the number of
the jobs in O∗ . Note that, if Nk ≤ N ∗ ≤ Nk+1 − 1, then problem 1|rj |Cmax (O) + g(N, V )
is equivalent to problem 1|rj , Nk ≤ N ≤ Nk+1 − 1|Cmax (O) + V 0 . Thus, we have Zmin ≤
Zk ≤ ρZk∗ = ρZ ∗ .
Next, we consider the time complexity of algorithm A3 . Note that algorithm A is
used m times and the maximum time complexity is TA . Thus, it follows that the time
complexity of algorithm A3 is O(mTA ). 2

6 Conclusions and future research

In this paper we consider two single machine scheduling problems with outsourcing under
different fill rates or quantity discount rates. The objective is to minimize the sum of
the makespan of the processed jobs and the (actual) outsourcing costs of the outsourced
jobs. First, for the former problem, we provide a polynomial-time exact algorithm for
the special case with the identical release dates and a 2-approximation algorithm and
a fully polynomial-time approximation scheme (FPTAS) for the general case with the
non-identical release dates, respectively. Furthermore, we show the relation between the
latter problem and the former problem. That is, the latter problem can be decomposed
into some subproblems and each subproblem can be transformed into an instance of the
former problem. Thus, we can adopt the algorithm for the former problem as a subroutine
to solve the latter problem.
An interesting direction is to consider other objective functions or the other machine
environments such as parallel machines, etc.

Acknowledgments
This research was supported in part by NSFCs (11771406, 11901168, 11571321 and
11971443).

13
References
[1] Y. Bartal, S. Leonardi, A. M. Spaccamela, J. Sgall, L. Stougie, 2000. Multiprocessor
scheduling with rejection. SIAM Journal on Discrete Mathematics 13, 64-78.

[2] B.C. Choi, J.B. Chung, 2011. Two-machine flow shop scheduling problem with an
outsourcing option. European Journal of Operational Research 213, 66-72.

[3] B.C. Choi, K.H. Chung, 2016. Min-max regret version of a scheduling problem with
outsourcing decisions under processing time uncertainty. European Journal of Oper-
ational Research 252, 367-375.

[4] M.R. Garey, D.S. Johnson, 1979. Computers and Intractablity: A Guide to the
Theory of NP-Completeness. Freeman, San Francisco, CA.

[5] Y.H. Lee, C.S. Jeong, C. Moon, 2002. Advanced planning and scheduling with out-
sourcing in manufacturing supply chain. Computer and Industrial Engineering 43,
351-374.

[6] I.S Lee, C.S. Sung, 2008a. Minimizing due date related measures for a single machine
scheduling problem with outsourcing allowed. European Journal of Operational Re-
search 186, 931-952.

[7] I.S Lee, C.S. Sung, 2008b. Single machine scheduling with outsourcing allowed. In-
ternational Journal of Production Economics 101, 623-634.

[8] C.L. Li, J.W. Ou, V.N. Hsu, 2012. Dynamic lot sizing with all-units discount and
resales. Naval Research Logistics 59, 230-243.

[9] L.F. Lu, L.Q. Zhang, J.W. Ou, 2018. In-house production and outsourcing under dif-
ferent discount schemes on the total outsourcing cost. Annals of Operations Research,
in press.

[10] J.W. Ou, X.L. Zhong, 2017a. Order acceptance and scheduling with consideration
of service level. Annals of Operations Research 248, 429-447.

[11] J.W. Ou, X.L. Zhong, 2017b. Bicriteria order acceptance and scheduling with con-
sideration of fill rate. European Journal of Operational Research 262, 904-907.

[12] J.W. Ou, X.L. Zhong, C.L. Li, 2016. Faster algorithms for single machine scheduling
with release dates and rejection. Information Processing Letters 116, 503-507.

[13] X.T. Qi, 2008. Coordinated logistics scheduling for in-house production and out-
sourcing. IEEE Transactions on Automation Science and Engineering 5, 188-192.

[14] D. Shabtay, N. Gaspar, M. Kaspi, 2013. A survey on off-line scheduling with rejection.
Journal of Scheduling 16, 3-28.

14
 [15] L.Q. Zhang, L.F. Lu, J.J. Yuan, 2009. Single machine scheduling with release dates
and rejection. European Journal of Operational Research 198, 975-978.

Biography

Lingfa Lu is an Associate Professor in the School of Mathematics and Statistics,

Zhengzhou University, Zhengzhou, Henan, China. His principal research interests are in
combinatorial optimization and scheduling theory. His papers have been published in Eu-
ropean Journal of Operational Research, International Journal of Production Economics,
Journal of Scheduling, Operations Research Letters, Annals of Operational Research and
other journals.

Liqi Zhang is a Lecturer in the College of Information and Management Science,

Henan Agricultural University, Zhengzhou, Henan, China. Her principal research in-
terests are in combinatorial optimization and scheduling theory. Her papers have been
published in European Journal of Operational Research, Journal of the Operational Re-
search Society, Journal of Combinatorial Optimization and other journals.

Jie Zhang is a master research student in the School of Mathematics and Statistics,
Zhengzhou University, Zhengzhou, Henan, China. Her principal research interests are in
combinatorial optimization and scheduling theory.

Lili Zuo is a master research student in the School of Mathematics and Statistics,
Zhengzhou University, Zhengzhou, Henan, China. Her principal research interests are in
combinatorial optimization and scheduling theory.

15

View publication stats