Information Processing Letters 115 (2015) 3339

Contents lists available at ScienceDirect

Information Processing Letters

www.elsevier.com/locate/ipl

Scheduling a variable maintenance and linear deteriorating

jobs on a single machine
Wenchang Luo a , Min Ji b,
a

Faculty of Science, Ningbo University, Ningbo 315211, PR China

School of Computer Science and Information Engineering, Contemporary Business and Trade Research Center, Zhejiang Gongshang
University, Hangzhou 310018, PR China
b

a r t i c l e

i n f o

Article history:
Received 16 October 2013
Received in revised form 19 August 2014
Accepted 19 August 2014
Available online 26 August 2014
Communicated by B. Doerr
Keywords:
Scheduling
Computational complexity
Deteriorating jobs
Maintenance

a b s t r a c t
We investigate a single machine scheduling problem in which the processing time of a
job is a linear function of its starting time and a variable maintenance on the machine
must be performed prior to a given deadline. The goals are to minimize the makespan
and the total completion time. We prove that both problems are NP-hard. Furthermore, we
show that there exists a fully polynomial time approximation scheme for the makespan
minimization problem. For the total completion time minimization problem we point out
that there exists a fully polynomial time approximation scheme for a special case.
2014 Elsevier B.V. All rights reserved.

1. Introduction
We consider the following scheduling problem: there is
a set of n linear deteriorating jobs J = { J 1 , J 2 , , J n } to
be non-preemptively processed on a single machine, all of
which are available at time 0. For each job J j , we use p j
and C j to denote the processing time and the completion
time, respectively. The actual processing time p j of job J j
is dened by p j = j + j s j , where j denotes the basic
processing time, j denotes the deteriorating rate and s j
denotes the starting time of job J j , respectively, i.e., p j is
a (general) linear function of s j . Moreover, a mandatory
maintenance must be started before a given deadline sd
on the machine and the duration of the maintenance d is
a nonnegative and nondecreasing function of its starting
time s (i.e., d = f (s) and f (s) is nonnegative and nondecreasing). Without loss of generality, we also assume that
all the data (the basic processing times, the deteriorating

Corresponding author.
E-mail addresses: luowenchang@163.com (W. Luo), jimkeen@163.com
(M. Ji).
http://dx.doi.org/10.1016/j.ipl.2014.08.011
0020-0190/ 2014 Elsevier B.V. All rights reserved.

rates, the deadline and the duration of maintenance) are

integers and the function f (s) can be computed in polynomial time. Furthermore, we assume that jobs cannot t all
n
n
together before sd (i.e., n + i =1 (i j =i +1 (1 + j )) > s)
and that every job J j can be inserted before sd (i.e.,
j sd ). The objective is to schedule all the linear deteriorating jobs and determine the starting time of maintenance
such that the makespan or the total completion time is
minimized.
Let C max (= max j C j ) denote the maximum completion time (makespan). Following the three-eld notation
introduced by Graham et al. [4] and the monograph by
Gawiejnowicz [6], we denote our problems by 1, VM| p j =

j + j s j |C max and 1, VM| p j = j + j s j | j C j respectively, where VM stands for a variable maintenance on
the machine.
The above problem is referred to as scheduling deteriorating jobs with machine unavailable constraints and
this kind of problem has received considerable attention
since 2003 (see, e.g., [14,3,5,9,7,1012]). For the related
monograph, we refer the readers to Gawiejnowicz [6].
All of the models proposed in [14,5,9,7,3,11,12] have the

34

W. Luo, M. Ji / Information Processing Letters 115 (2015) 3339

assumptions that the machine starts at time t 0 (> 0) (to

avoid the trivial case), the processing time of a job is a
simple linear function of its starting time (i.e., p j = j s j ),
and the machine unavailable intervals or the duration of
maintenance is prexed, which differ from our model.
Related works Browne and Yechiali [1] rst considered the
problem of scheduling (general) linear deteriorating jobs
(without maintenance) to minimize the makespan. Using
the standard interchange principle, they showed that there
achieves the optimal makespan according to the nonde
2
n
1
creasing order of j (i.e.
).
j

Since 2003, researchers have begun to consider the

problems of scheduling simple linear deteriorating jobs
with machine unavailable constraints. They assumed that
the jobs are available at time t 0 (= 1). Depending on
whether the job processing can be interrupted by the unavailable intervals or not, there are two versions: resumable version and non-resumable version.
For the resumable version, Wu and Lee [14] rst studied the problem of scheduling simple linear deteriorating jobs with an unavailable constraint to minimize the
makespan. They showed the model can be solved by using
the 01 integer programming technique. In some special
case, the 01 integer programming can be solved in polynomial time. For the general case, the complexity of the
problem is open. Gawiejnowicz and Kononov [7] considered the proposed model by Wu and Lee [14]. They proved
that the problem is weakly NP-hard and showed that there
exists a fully polynomial time approximation scheme. Furthermore, for the problem with two or more unavailable
intervals, they showed that there does not exist a polynomial time approximation algorithm with a constant worstcase ratio, unless P = NP. Ji and Cheng [10] considered
a single machine scheduling problem in which the processing time of each job is a simple linear deteriorating
function of its waiting time with the machine subject to
an unavailable constraint. The problem was similar to the
proposed problem by Gawiejnowicz and Kononov [7]. For
the makespan objective, they showed that the problem can
be modeled by 01 integer programming and then proved
that the problem is weakly NP-hard. Finally they showed
that there exists a fully polynomial time approximation
scheme. Fan et al. [3] considered the problem of scheduling resumable deteriorating jobs on a single machine with
unavailable constraints. The goal is to minimize the total
completion time. They proved that the problem with a single unavailable interval is NP-hard and showed that there
exists a fully polynomial time approximation scheme. Furthermore, they showed that there does not exist a polynomial time approximation algorithm with a constant worstcase ratio with two or more unavailable intervals, unless
P = NP.
For the non-resumable version, Ji et al. [9] considered
the single machine scheduling problem in which the jobs
are simple linear deteriorating and the machine is subject
to an unavailable constraint. The goal is to minimize the
makespan or the total completion time. They showed that
both problems are weakly NP-hard. Furthermore, for the
makespan objective, they proposed an optimal on-line algorithm for the on-line case, and a fully polynomial time

approximation scheme for the off-line case. For the total

completion time objective, they provided a heuristic algorithm with computational experiments to evaluate its
eciency.
Our results In this paper, we show both problems
1, VM| p j
= j + j s j |C max and 1, VM| p j = j + j s j | j C j are
NP-hard. Furthermore, for the 1, VM| p j = j + j s j |C max
problem, we show that there exists a fully polynomial
time approximation
scheme (FPTAS). For the 1, VM| p j =

j + j s j | j C j problem, we point out that there also
exists an FPTAS when j = j . But for the general case
j = j whether it has an FPTAS is open.
The remainder of this paper is organized as follows:
In Section 2, we prove that the 1, VM| p j = j + j s j |C max
problem is weakly NP-hard and show that there exists
an FPTAS. 
In Section 3, we prove that the 1, VM| p j =
j + j s j | j C j problem is also NP-hard and point out
that there exists an FPTAS for the special case j = j . The
concluding remarks are given in Section 4.
2. The 1, VM| p j = j + j s j |C max problem
In this section, we consider the 1, VM| p j = j +
j s j |C max problem. By reducing the Subset Product Problem to the considered problem, we show that the problem
is NP-hard and then show it admits an FPTAS.
2.1. Proof of NP-hardness
The NP-hardness proof of the problem is demonstrated
by performing a reduction from the NP-complete Subset
Product Problem [8].
Subset Product Problem. Given a nite set S = {1, 2,
, m}, a positive integer x j Z + for each j S, and
a positive integer B, does there exist a subset S 1 S
such that the product of the elements in S 1 satises

j S 1 x j = B?
Clearly, we can assume x j 2 for all j.
Theorem 1. The 1, VM| p j =
hard.

j + j s j |C max problem is NP-

Proof. Given an arbitrary instance I of the Subset Product

Problem, we construct an corresponding instance I of the
1, VM| p j = j + j s j |C max problem as follows:

There are n = m linear deteriorating jobs such that

j = j = x j 1 for j = 1, 2, , n.
The starting time of the maintenance s is prior to B 1
(i.e., s sd = B 1) and the duration is B (i.e., d =
f (s) = B).
The threshold
value G is dened as G = 2 X 1, where

X = j S x j .
Obviously the above construction can be completed in
polynomial time. Next, we show that instance I has a solution if and only if there exists a feasible schedule for
instance I such that C max ( ) G.

W. Luo, M. Ji / Information Processing Letters 115 (2015) 3339

To avoid the confusion, we write S 1 ( S 2 , S ) for instance

I to denote the job set with their indices corresponding to
S 1 ( S 2 , S ) of instance I .
 Given a solution S 1 S to instance I such that

j S 1 x j = B, we construct a schedule for instance I

in the following way:

First we process the jobs in S 1 according to the nonde

creasing order of j , then start the maintenance VM

j
and process the remaining jobs according to nondej
creasing order of .
j

For convenience, we denote the schedule as =

( S1 , VM, S 2 ), where S 2 (= S \ S 1 ) denotes the remaining
jobs. With simple calculations, we have

C S ( ) =
1

(1 + j ) 1 =

x j 1 = B 1,

j S 1

j S1

where C S ( ) denotes the completion time of the nal job

1
in S 1 . Similarly dene C S ( ) as the completion time of
2

the nal job in S 2 . Then we have

C S ( ) = 2B
2

Since

(1 + j ) 1 = 2B

x j 1.

j S 2

j S 2
j S 2

x j = X / B, we achieve that C S ( ) = 2 X 1,
2

i.e., there exists a feasible schedule for instance I such

that C max ( ) = C S ( ) G.
2
Conversely, assume that there is a feasible schedule
for instance I such that C max ( ) G. Again we use
( S 1 , VM, S 2 ) to denote the schedule , where the jobs in
S 1 and S 2 can be processed according to nondecreasing

order of j .

35

the variant by 1, nr-a| p j = j + j s j |C max , where nr-a

in the rst eld denotes a non-resumable availability constraint. The problem can be described as follows:
Given n linear deteriorating jobs J 1 , J 2 , , J n to be
non-preemptively processed on a single machine, all of
which are available at time 0. The machine is not available
during a xed interval [s, s + d]. The task is to schedule all
the jobs such that the makespan is minimized.
The 1, nr-a| p j = j + j s j |C max problem can be optimally solved by performing the following dynamic programming algorithm.
First, we order the jobs as 1, 2, 3, , n according to

2
n
1
the nondecreasing order of j , i.e.,
.
j

The algorithm contains n phases. In each phase j ( j =

1, 2, , n), a state space E j is generated. Each state
[ j , t , C ] in E j can be associated to a feasible partial schedule for the rst j jobs. The variable j denotes the rst
j jobs that we have scheduled, t denotes the completion time of the last job scheduled before s and C is
the makespan of the associated partial schedule. This algorithm can be described as follows:
Dynamic programming algorithm:
Initialize E 1 := {[1, 1 , 1 ], [1, 0, s + d + 1 + 1 (s + d)]}
For j {2, 3, , n}
E j = {}.
For every state [ j 1, t , C ] E j 1 do:
1. Put [ j , t , C + j + j C ] in E j ;
2. Put [ j , t + j + j t , C ] in E j If t + j + j t s.
Endfor
Remove E j 1
Endfor
Output OPT = min[n,t ,C ] E n {C } and the corresponding
optimal schedule, which can be found by backtracking.

Assume that the starting time of maintenance VM is

B 1 , 0. Then with simple calculations we obtain

C S ( ) =
1

(1 + j ) 1 = B 1

j S 1

Obviously, the set of E 1 consists of two partial schedules, in the rst of which job J 1 is processed before s, and
in the second schedule job J 1 is placed after the maintenance. For each state [ j 1, t , C ] in E j 1 , job J j has
two possible choices in E j . Due to the nondecreasing or

and

C S ( ) = (2B )
2

der of j , the rst possible position is the last position

j
in the partial schedule, and job J j completes in this case
at time C + j + j C . The second possible position is the
one just before the maintenance: J j starts at time t if
t + j + j t s.
It can be easily veried that the above
n dynamic programming algorithm runs in O (ns(n + i =1 (1 + i )(s +

(1 + j ) 1

j S 2

= (2B )

X
B

1.

n1 n

If > 0, then we have

C max ( ) = C S ( ) = (2B )
2

> (2B 2)

X
B

X
B

1 = 2 X 1,

which achievesa contradiction.Thus we obtain = 0,

which implies
(1 + j ) = j S 1 x j = B. Then we obj S 1
tain a solution of instance I . 2
In order to solve the 1, VM| p j = j + j s j |C max problem, we rst consider a close variant, in which the starting
time of maintenance is xed (i.e., equal to s). We denote

d) +
i = j +1 (1 + i ) j )) time.
j =1
Next we transform the above dynamic programming
into an FPTAS for problem 1, nr-a| p j = j + j s j |C max . The
main idea is that we iteratively remove some states generated by the dynamic programming to reduce the size
of the state space down to polynomial size, which is attributed to Woeginger [13].
Algorithm H 0 :
Step 1. Let = 1 + /(2n). Partition
the interval [0, s] into r1 = log s subintervals
[0, ], , [t1 , t1 +1 ], , [r1 1 , s] and

36

W. Luo, M. Ji / Information Processing Letters 115 (2015) 3339


the interval [(s + d), (n + ni=1 (1 + i )(s + d) +
n1 n
i = j +1 (1 + i ) j )] into r 2 = log (n +
 1 n
nj=1
(
1
+
i )(s + d) + nj=
i =1
i = j +1 (1 + i ) j )
1
log (s + d) subintervals [(s + d), (s + d)], ,
t2
t 2 +1
, [(s + d)r2 1 , (n +
[(
sn + d) , (s + d) n],
1 n
(
1
+

)(
s
+
d
)
+
i
i =1
i = j +1 (1 + i ) j )].
j =1

Then Construct a two-dimensional grid with the boxes

B t1 t2 , 1 t 1 r1 , 1 t 2 r2 .


Step 2. Let GS1 = GS1 = {[1, 1 , 1 ], [1, 0, s + d + 1 +

1 (s + d)].
Step 3. For j {2, 3, , n}, for every state [ j 1, t , C ]

in GS j 1 :
Step 3.1. If t + j + j t s, put [ j , t + j + j t , C ]
into GS j .
Step 3.2. Put [ j , t , C + j + j C ] into GS j .
It can be easily veried that each state in GS j lies
in some box B t1 t2 . If there are multiple states in the
same box, we choose the state with minimum t and
remove all the other states, i.e., reduce the state space

GS j into GS j .
Step 4. Output the vector [n, t , C ] that minimizes the
value C .
Next we show that Algorithm H 0 is an FPTAS for problem 1, nr-a| p j = j + j s j |C max . First we derive the following lemmas.
Lemma 2. Every state [ j , t, C ] in the (un-reduced) state space
GS j satises t t t j and C / j C C j , where the state


[ j , t , C ] lies in the reduced state space GS j .

Lemma 3. The size of every reduced state space GS j is bounded

2

n(log L )

by O (
, n}.

), where L = max{s, d, (1 + j ), j , j = 1, 2,

Proof. When execute Algorithm H 0 , every box in the

two-dimensional grid contains at most one state [ j , t , C ].
There are at most r1 r2 boxes, i.e., every state space


GS j contains at most r1 r2 states. Then the size of GS j
is bounded from above by (log s)(log (n +

n

i =1 (1 +
i )(s + d) + j=1 i = j +1 (1 + i ) j )), which is at most
O (n3 (log L )2 / 2 ). 2

n1 n

Lemma 4. Algorithm H 0 is an FPTAS for problem 1, nr-a| p j =

j + j s j |C max with the time complexity of O (n4 (log L )2 /2 ).
Proof. Let [n, t opt , C opt ] be the state that yields the optimal objective value. With Lemma 2, the reduced state

space GSn contains a state [n, t , C ] with C /n C opt . Thus
opt n
C C , i.e., C C opt (1 + /(2n))n (1 + )C opt , in
which the inequality (1 + x/m)m 1 + 2x for real numbers x with 0 x 1 and for integers m 1 is applied.
Clearly Algorithm H 0 runs in O (n4 (log L )2 / 2 ) time. 2
2.2. A fully polynomial time approximation scheme
In this section, by splitting the value of function f (s)
( f (s) is the duration of maintenance, which is a nondecreasing function of the starting time of maintenance)
and the interval [0, sd ], then calling the FPTAS for the
1, nr-a| p j = j + j s j |C max problem, we show that the
1, VM| p j = j + j s j |C max problem admits a fully polynomial time approximation scheme.

Proof. For j = 1, because of VS j = VS j , the conclusion is

trivial.
Suppose that the conclusion is correct up to j 1.
Consider an arbitrary state [ j , t, C ] in GS j . The dynamic
programming algorithm generates the state [ j , t, C ] in GS j
from some feasible state of GS j 1 . Let [ j 1, t , C ] be the

feasible state in GS j 1 that yields the state [ j , t, C ]. Consider two cases according to the assignment of job J j :
either [ j , t, C ] = [ j , t + j + j t , C ] or [ j , t, C ] = [ j , t ,
C + j + j C ].

Case 1. [ j , t, C ] = [ j , t + j + j t , C ].
Since [ j 1, t , C ] GS j 1 , there exists [ j 1, t  , C  ]

GS j 1 such that t  t t  j 1 and C  / j 1 C



C  j 1 . Clearly, the state [ j , t  + j + j t  , C  ] in GS j can

be generated. However, it may be removed when the state

space is reduced. Let [ j , t , C ] be the state chosen in GS j

such that it is in the same box with [ j , t  + j + j t  , C  ],

i.e., t t  + j + j t  t and C / C  C . With some
simple calculations we get t t + j + j t t j and
C / j C C j .
Case 2. [ j , t, C ] = [ j , t , C + j + j C ].
The proof is similar to Case 1. We omit it.

Algorithm H 1
Step 1. Let
be a given positive constant and t 1 =
mini {1,2,,n} i . Compute a series of t i such that
f (t i ) = f (t 1 )(1 +
)i , i = 2, , q with q = log1+d

f (s )

f (t )

log1+1
 and split time interval [t 1 , sd ] into subinter-

vals [t 1 , t 1 (1 +
)], [t 1 (1 +
), t 1 (1 +
)2 ], , [t 1 (1 +

)r , sd ], where r = log1+
(sd /t 1 ). Let t j = t 1 (1 +

) j , j = 1, 2, , r and t 0 = 0. Then we rename the

obtained time points t 0 , t i , i = 1, 2, , q; t j , j =

1, 2, , r; sd according to nondecreasing order as
s0 , s1 , , sl , where sl = sd .
Step 2. For each si , i = 0, 1, 2, , l, employ the FPTAS for
the 1, nr-a| p j = j + j s j |C max problem in which the
starting time of maintenance is si and the duration
of maintenance is f (si ) to determine the subset of
jobs scheduled before the maintenance S 1i and the
subset of jobs scheduled after the maintenance S 2i .
Let (i ) = ( S 1i , VM, S 2i ) denote the obtained schedule,
which means that we rst process the jobs in S 1i ac

cording to nondecreasing order of j , then following

j
the nal job in S 1i start the maintenance, nally process the jobs in S 2i according to nondecreasing order

of j after the maintenance.

j

W. Luo, M. Ji / Information Processing Letters 115 (2015) 3339

Step 3. Output the schedule = arg min (i ),i =0,1,,l

{C max ( (i ))} as the solution.
Note that in each time interval [si , si +1 ] we have si +1
(1 +
)si and f (si +1 ) (1 +
) f (si ).
Theorem 5. If f (s) is a continuous and nondecreasing function, and can be computed in polynomial time, then Algorithm H 1 is a fully polynomial time approximation scheme for
the 1, VM| p j = j + j s j |C max problem.
Proof. Let s denote the starting time of maintenance in
an optimal schedule . Let S 1 denote the set of jobs
scheduled before s in and S 2 (= J \ S 1 ) denote the set
of jobs scheduled after the maintenance in . Clearly we
have s = s0 , s1 or s (si 1 , si ], i = 2, , l. If s = s0 or
s1 , it is easy to obtain the optimal schedule. Thus we only
need to consider the cases that s (si 1 , si ], i = 2, 3, , l.
For schedule (i ), with simple calculations we have

C max

(i )

n


 

 

= C max S 1i + f C max S 1i

+ [n] +

n 1


(1 + [k] )

k=| S 1i |+1
n


[k]

n


 

= s + f s

k=| S 1 |+1
n 1


+ [n] +

k=| S 1 |+1

(1 + [k] )


[k]

n


(1 + [ j ] ) ,

j =k+1

and

C max = si + f (si )

n


(1 + [k] )

k=| S 1 |+1

+ [n] +

n 1

k=| S 1 |+1

a[k]

n


Then we obtain

C max

(i ) C max (i ) 1 +
C max

2
 

1 +
C max .

Let =
+ 2
, we achieve C max ( ) C max ( (i )) (1 +
)C max ( ). Computing each si , i = 0, 1, 2 , l needs at
s
most log2d time by using binary search because the function f (s) is continuous and nondecreasing. Thus, with the
assumption that f (s) can be computed in polynomial time,
Algorithm H 1 runs in polynomial time. 2
2

3. The 1, VM| p j = j + j s j |


j

C j problem

Inthis section, we consider the 1, VM| p j = j +

j C j problem. Again we use the Subset Product
Problem for the reduction to show that the problem is
NP-hard. Then, we point out that there exists an FPTAS for
the special case j = j .

js j|

Again the NP-hardness proof is constructed by performing a reduction from the NP-complete Subset Product
Problem.

(1 + [ j ] ) ,

where | S 1i | denote the number of jobs in S 1i and [k] denote

the job location in schedule (i ).
Now consider the 1, nr-a| p j = j + j s j |C max problem,
where the starting time of maintenance is si and the duration of maintenance is f (si ), we construct a schedule
corresponding to schedule and a schedule (i ) corresponding to schedule (i ). The subset of jobs before
the maintenance and after the maintenance are the same
in and . The only difference in and is the
different starting time and the duration of maintenance.
The same relations on schedules and also apply to
schedules (i ) and (i ).
Clearly we have C max ( (i )) (1 +
)C max ( ). Furthermore, we have

C max

(1 +
) f (s ). Then we have C max ( ) (1 +
)C max ( ).

3.1. Proof of NP-hardness

j =k+1

k=| S 1i |+1

37

(1 + [ j ] ) .

j =k+1

Since f (s) is continuous and nondecreasing, according

to the choice of si , we have si (1 +
)s and f (si )

Theorem 6. The 1, VM| p j = j + j s j |

hard.


j

C j problem is NP-

Proof. For a given instance I of the Subset Product Prob

lem, we construct an
 corresponding instance I of the
1, VM| p j = j + j s j | j C j problem as follows:

Let A = X / B, where X = j S x j .

There are totally n = m + 3 linear deteriorating jobs

such that j = j = x j 1 for j = 1, 2, , m and
3 large jobs m+1 = m+1 = X 2 A 1, m+2 = m+2 =
X 2 B 1, m+3 = m+3 = X 4 1.
The starting time of maintenance s is prior to X 3 1
(i.e., s sd = X 3 1) and the duration of maintenance
d is X 3 (i.e., d = f (s) = X 3 ).
The threshold value G is dened as G = X 3 1 + 2(m +
1)( X 6 1/2) + 2 X 10 1.
It can be veried that the above construction can be
completed in polynomial time. We show that the instance I has a solution if and only if there exists a feasible schedule for the scheduling instance I such that
Z ( ) G, where Z ( ) denote the total completion time
of schedule .
Before we present our main result, we state some auxiliary lemmas.
Lemma
7. (See 
[2,9].) For any subset S 1 S, we have

B j S \ S 1 x j + A j S 1 x j 2 X , and the equality holds if and


only if j S 1 x j = B and j S \ S 1 x j = A.

38

W. Luo, M. Ji / Information Processing Letters 115 (2015) 3339

Lemma 8. Let Z ( ) denote the total completion time of 

schedule . If the schedule for the 1, VM| p j = j + j s j | j C j
problem satises Z ( ) G, then the following two claims hold.
(1) One of the jobs J m+1 and J m+2 is scheduled before the
maintenance, and the other after the maintenance;
(2) the job J m+3 is scheduled after the maintenance.

(1 + j )(1 + m+1 ) 1

j S 1



= X2 A
(1 + j ) 1,
j S 1

and the maximum completion time of the jobs processed

after the maintenance is
A
C max
=

Next we prove Theorem 6.

 Suppose that there
 exists a subset S 1 S satisfying
x
=
B
(i.e.,
j
j S 1
j S 2 x j = A, where S 2 = S \ S 1 ) for instance I . We construct a schedule
following way:

Proof. The proof is straight. We omit it.

B
C max
=

X2 A



(1 + j ) + X 3


j S 1

(1 + j )(1 + m+2 )(1 + m+3 ) 1

j S 2

for instance I in the



= X 10 + X 9 B
(1 + j ) 1.

First we process the jobs in S 1 according to the nondej

creasing order of starting at time 0, then we proj

cess J m+1 , and start the maintenance right after the
completion time of job J m+1 , after the maintenance
we process the jobs in S 2 according to nondecreas
ing order of j , and nally we process jobs J m+2 and

j S 2

Hence, we have
B
A
Z ( ) > C max
+ C max

=X

For convenience, we denote the schedule

( S 1 , J m+1 , VM, S 2 , J m+2 , J m+3 ).
With simple calculations we have

C m +1 =

j S 1

C m +2 =

j S 2

= 2 X 6 1,
C m+3 = (1 + C m+2 )(1 + m+3 ) 1 = 2 X 10 1.
Because C j < C m+2 for j = 1, 2, , m, we achieve

Z ( )

j =1

j S 2

=X

Cj +

3


10

+X

(1 + j ) + B

j S 1

X9 X


2

B
Clearly C max
sd , i.e., X 2 ( A

(1 + j )) X 3 1.

(1 + j ) X , which implies
(1 +
j S 1
j S 1
j S 1

We have A

j ) B. Suppose there is no solution for instance

 I , then
(1 + j ) < B. By Lemma 7, we have B j S 2 x j +
j S

A j S 1 x j > 2 X , and thus B j S 2 x j + A

2 X + 1. With simple calculations we have

Z ( ) > X 10 + 2 X 10 + X 9

X X

C m+k

k =1

j S 1

xj


(1 + j ) 2

j S 1



< X 3 1 + 2(m + 1) X 6 1/2 + 2 X 10 1 = G .

>X

10

+ 2X

10



+ X X9 X2 X 2
9

> 2 X 10 + X 9 + X 3 2

Now suppose that there is a feasible schedule such

that Z ( ) G. According to Lemma 8, we only need to
consider two cases.

> G,
which achieves a contradiction. Thus

Case 1. Job J m+1 is scheduled before the maintenance.


(1 + j )


(1 + j ) 2.

j S 1


j S2

(1 + j )(1 + m+1 ) + X 3
(1 + j )(1 + m+2 ) 1


(1 + j ) 1

m


+ X9 B

as =

j S 1

(1 + j )(1 + m+1 ) 1 = X 3 1,


(1 + j ) 1 + X 10

j S 1

J m+3 .

j S 1

(1 + j ) =

x j = B, i.e., there exists a solution for instance I .

For Case 2, the proof is similar to Case 1, and we omit

j S 1

Case 2. Job J m+2 is scheduled before the maintenance.

it.

Consider Case 1. Let S 2 {1, 2, , n} denote the indices of jobs scheduled after the maintenance except the 3
large jobs and S 1 = {1, 2, , n}\{ S 2 }. Then the maximum
completion time of the jobs scheduled before the maintenance is

For the 1, VM| p j = j + j s j | j C j problem with the

special case j = j , it is easily veried that there exist
an optimal solution such that the jobs before the maintenance are sequenced according to the nondecreasing j
order, and so are the jobs scheduled after the maintenance.

W. Luo, M. Ji / Information Processing Letters 115 (2015) 3339

Using the similar idea for the 1, VM| p j = j + j s j |C max

problem, we can also derive an FPTAS. But for the general
case j = j , whether it admits an FPTAS is open.
4. Concluding remarks
In this paper, we study the problem of scheduling
a variable maintenance and (general) linear deteriorating
jobs on a single machine. For the makespan and total completion time minimization objectives, we show that both
problems are NP-hard and there exists an FPTAS for the
makespan minimization problem. But for the total completion time minimization problem, in general case whether
it admits an FPTAS is open.
Acknowledgements
We thank three anonymous referees for their helpful comments on an earlier version of our paper. Luo
was supported by Ningbo Natural Science Foundation
(2013A610099), Hu Lan outstanding doctoral foundation
of Ningbo University, Science Foundation of Ningbo University (xkl1320) and the K.C. Wong Magna Foundation of
Ningbo University. Ji was supported in part by the National
Social Science Foundation of China (Grant No. 14CGL071),
the Humanities and Social Sciences Planning Foundation of
the Ministry of Education (Grant No. 13YJA630034), and
the Contemporary Business and Trade Research Center of
Zhejiang Gongshang University, which is the key Research
Institute of Social Sciences and Humanities of the Ministry
of Education.

39

References
[1] S. Browne, U. Yechiali, Scheduling deteriorating jobs on a single processor, Oper. Res. 38 (3) (1990) 495498.
[2] Z.-L. Chen, Parallel machine scheduling with time dependent processing times, Discrete Appl. Math. 70 (1) (1996) 8193.
[3] B. Fan, S. Li, L. Zhou, L. Zhang, Scheduling resumable deteriorating
jobs on a single machine with non-availability constraints, Theor.
Comput. Sci. 412 (45) (2011) 275280.
[4] R.L. Graham, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Optimization and approximation in deterministic sequencing and scheduling:
a survey, Ann. Discrete Math. 5 (1979) 287326.
[5] S. Gawiejnowicz, Scheduling deteriorating jobs subject to job or machine availability constraints, Eur. J. Oper. Res. 180 (2007) 472478.
[6] S. Gawiejnowicz, Time-Dependent Scheduling, Springer-Verlag,
Berlin, 2008.
[7] S. Gawiejnowicz, A. Kononov, Complexity and approximability of
scheduling resumable proportionally deteriorating jobs, Eur. J. Oper.
Res. 200 (2010) 305308.
[8] D.S. Johnson, The NP-completeness column: an ongoing guide, J. Algorithms 2 (1983) 393405.
[9] M. Ji, Y. He, T.C.E. Cheng, Scheduling linear deteriorating jobs with
an availability constraint on a single machine, Theor. Comput. Sci.
362 (2006) 115126.
[10] M. Ji, T.C.E. Cheng, Scheduling resumable simple linear deteriorating
jobs on a single machine with an availability constraint to minimize
makespan, Comput. Ind. Eng. 59 (4) (2010) 794798.
[11] W. Luo, L. Chen, Approximation scheme for scheduling resumable
proportionally deteriorating jobs, in: Frontiers in Algorithmics and
Algorithmic Aspects in Information and Management, AAIM10, 2011,
pp. 3645.
[12] W. Luo, L. Chen, Approximation schemes for scheduling a maintenance and linear deteriorating jobs, J. Ind. Manag. Optim. 8 (2)
(2012) 271283.
[13] G.J. Woeginger, When does a dynamic programming formulation
guarantee the existence of a fully polynomial time approximation
scheme (FPTAS)?, INFORMS J. Comput. 12 (1) (2000) 5774.
[14] C.C. Wu, W.C. Lee, Scheduling linear deteriorating jobs to minimize
makespan with an availability constraint on a single machine, Inf.
Process. Lett. 87 (2003) 8993.