Scheduling a variable maintenance and linear deteriorating jobs on a single machine.pdf

7/21/2019 Scheduling a variable maintenance and linear deteriorating jobs on a single machine.pdf

http://slidepdf.com/reader/full/scheduling-a-variable-maintenance-and-linear-deteriorating-jobs-on-a-single 1/7

Information Processing Letters 115 (2015) 33–39

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 Chinab School of Computer Science and Information Engineering, Contemporary Business and Trade Research Center, Zhejiang Gongshang

University, Hangzhou 310018, PR China

a

r

t

i

c

l

e

i

n

f

o a

b

s

t

r

a

c

t

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

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 jis defined 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 nonde-

creasing). Without loss of generality, we also assume that

all the data (the basic processing times, the deteriorating

* Corresponding author.

E-mail addresses: [email protected] (W. Luo), [email protected]

(M. Ji).

rates, the deadline and the duration of maintenance) are

integers and the function f (s) can be computed in polyno-

mial time. Furthermore, we assume that jobs cannot fit all

together before sd (i.e., αn +n

i=1(αi

n 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 deterio-

rating 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 comple-

tion time (makespan). Following the three-field 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 respec-

tively, where “VM” stands for a variable maintenance on

the machine.

The above problem is referred to as scheduling dete-

riorating jobs with machine unavailable constraints and

this kind of problem has received considerable attention

since 2003 (see, e.g., [14,3,5,9,7,10–12]). 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

http://dx.doi.org/10.1016/j.ipl.2014.08.011

0020-0190/© 2014

Elsevier

B.V.

All rights reserved.


http://www.sciencedirect.com/

http://www.elsevier.com/locate/ipl

mailto:[email protected]




http://crossmark.crossref.org/dialog/?doi=10.1016/j.ipl.2014.08.011&domain=pdf




http://www.elsevier.com/locate/ipl

http://www.sciencedirect.com/




34 W. Luo, M. Ji / Information Processing Letters 115 (2015) 33–39

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 prefixed, which differ from our model.

Related works Browne and Yechiali [1] first 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-

creasing order of α j

β j(i.e. α1

β1≤ α2

β2· · · ≤ αn

βn).

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 un-

available intervals or not, there are two versions: resum-

able version and non-resumable version.

For the resumable version, Wu and Lee [14] first stud-

ied

the

problem

of

scheduling

simple

linear

deteriorat-ing jobs with an unavailable constraint to minimize the

makespan. They showed the model can be solved by using

the 0–1 integer programming technique. In some special

case, the 0–1 integer programming can be solved in poly-

nomial time. For the general case, the complexity of the

problem is open. Gawiejnowicz and Kononov [7] consid-

ered 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. Fur-

thermore, for the problem with two or more unavailable

intervals, they showed that there does not exist a polyno-

mial time approximation algorithm with a constant worst-

case ratio,

unless

P

= NP.

Ji

and

Cheng

[10] considered a single machine scheduling problem in which the pro-

cessing 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 0–1 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 schedul-

ing 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

sin-gle unavailable interval is NP-hard and showed that there

exists a fully polynomial time approximation scheme. Fur-

thermore, they showed that there does not exist a polyno-

mial time approximation algorithm with a constant worst-

case 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 al-gorithm 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 al-

gorithm with computational experiments to evaluate its

efficiency.

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 Prob-

lem 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 finite 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 satisfies j∈S 1

x j = B ?

Clearly, we can assume x j ≥ 2 for all j.

Theorem 1. The 1, VM| p j = α j + β j s j |C max problem is NP-

hard.

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 defined 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 so-

lution

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) 33–39 35

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

β j, then start the maintenance “VM”

and process the remaining jobs according to nonde-


β j.

For convenience, we denote the schedule π as π =

( S 1, VM, S 2), where S 2 (= S \S 1) denotes the remaining

jobs. With simple calculations, we have

C S 1

(π ) =

j∈ S 1

(1 + α j ) − 1 =

j∈S 1

x j − 1 = B − 1,

where C S 1

(π ) denotes the completion time of the final job

in

S 1.

Similarly

define

C S 2(π ) as

the

completion

time

of

the final job in S 2 . Then we have

C S 2

(π ) = 2B

j∈S 2

(1 + α j ) − 1 = 2B

j∈S 2

x j − 1.

Since

j∈S 2

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

(π ) = 2 X − 1,

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

that C max(π ) = C S 2

(π ) ≤ G .

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

β j.

Assume that the starting time of maintenance “VM” is

B

− 1

− ∆, ∆

≥ 0. Then with simple calculations we obtain

C S 1

(π ) =

j∈S 1

(1 + α j ) − 1 = B − 1 − ∆

and

C S 2

(π ) = (2B − ∆)

j∈S 2

(1 + α j ) − 1

= (2B − ∆) X

B − ∆− 1.

If ∆ > 0, then we have

C max(π ) = C S 2

(π ) = (2B − ∆) X

B − ∆− 1

> (2B − 2∆) X

B − ∆− 1 = 2 X − 1,

which achieves a contradiction. Thus we obtain ∆ = 0,

which implies

j∈S 1(1

+ α j ) =

j∈S 1 x j = B . Then we ob-

tain a solution of instance I .

In order to solve the 1, VM| p j = α j + β j s j |C max prob-

lem,

we

first

consider

a

close

variant,

in

which

the

starting time of maintenance is fixed (i.e., equal to s). We denote

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

in the first field denotes a non-resumable availability con-

straint. 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 fixed 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 opti-

mally solved by performing the following dynamic pro-

gramming algorithm.

First, we order the jobs as 1, 2, 3, · · · , n according to

the nondecreasing order of α j

β j, i.e., α1

β1≤ α2

β2≤ · · · ≤ αn

βn.

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 sched-

ule for the first j jobs. The variable j denotes the first

j jobs that we have scheduled, t denotes the comple-

tion time of the last job scheduled before s and C is

the makespan of the associated partial schedule. This al-

gorithm

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 + β jt , C ] in E j If t + α j + β jt ≤ 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.

Obviously, the set of E 1 consists of two partial sched-

ules, in the first of which job J 1 is processed before s, and

in the second schedule job J 1 is placed after the main-

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

der of α j

β j, the first possible position is the last position

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 + β jt ≤ s.

It

can

be

easily

verified

that

the

above

dynamic

pro-gramming algorithm runs in O (ns(αn +

ni=1(1 + βi )(s +

d) +n−1

j=1

ni= j+1(1 + βi )α j )) time.

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 gen-

erated by the dynamic programming to reduce the size

of the state space down to polynomial size, which is at-

tributed to Woeginger [13].

Algorithm H 0:

Step 1. Let ∆ = 1 + ε/(2n). Partition

• the

interval

[0,

s] into

r 1 = log∆ s subintervals [0, ∆], · · · , [∆t 1 , ∆t 1+1], · · · , [∆r 1−1, s] and






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 func-

tion,

and

can

be

computed

in

polynomial

time,

then

Algo-rithm 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)

=

C max

S i1

+ f

C max

S i1 n

k=|S i1|+1

(1 + β[k])

+ α[n] +

n−1k=|S i1|+1

α[k]

n

j=k+1

(1 + β[ j])

,

where

|S i1| denote the number of jobs in S i1 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 du-

ration

of

maintenance

is

f (si),

we

construct

a

schedule

π∗

corresponding to schedule π ∗ and a schedule π (i) cor-

responding 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( π ∗). Further-

more, we have

C max

π ∗

=

s∗ + f

s∗

n

k=|S ∗1|+1

(1 + β[k])

+ α[n] +

n−1k=|S ∗1|+1

α[k]

n

j=k+1

(1 + β[ j])

,

and

C max

π ∗

=

si + f (si ) n

k=|S ∗1|+1

(1 + β[k])

+ α[n] +

n−1k=|S ∗1|+1

a[k]

n

j=k+1

(1 + β[ j])

.

Since

f (s) is

continuous

and

nondecreasing,

according to the choice of si , we have si ≤ (1

+ ε )s∗ and f (si ) ≤

(1

+ ε) f (s∗). Then we have C max( π ∗) ≤ (1

+ ε)C max(π ∗).

Then we obtain

C max

π (i)

≤ C max

π (i)

≤

1 + ε

C max

π ∗

≤

1 + ε

2

C max

π ∗

.

Let

ε = ε2 + 2ε ,

we

achieve

C max(π )

≤ C max(π (i))

≤ (1

+ε)C max(π ∗). Computing each si , i = 0, 1, 2 · · · , l needs at

most logsd

2 time by using binary search because the func-

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

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

j C j problem

In this section, we consider the 1, VM| p j = α j +

β j s 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 .

3.1. Proof of NP-hardness

Again the NP-hardness proof is constructed by per-

forming a reduction from the NP-complete Subset Product

Problem.

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

j C j problem is NP-

hard.

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 defined as G = X 3 − 1 + 2(m +

1)( X 6 − 1/2)

+ 2 X 10 − 1.

It can be verified that the above construction can be

completed in polynomial time. We show that the in-

stance I has a solution if and only if there exists a fea-

sible 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 aux-

iliary 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) 33–39

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

ule π . If the schedule π for the 1, VM| p j = α j + β j s j |

j C j problem satisfies 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.

Proof. The proof is straight. We omit it.

Next we prove Theorem 6.

Suppose that there exists a subset S 1 ⊆ S satisfying j∈S 1

x j = B (i.e.,

j∈S 2 x j = A, where S 2 = S \S 1) for in-

stance I . We construct a schedule π for instance I in the

following way:

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


β jstarting at time 0, then we pro-

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

β j, and finally we process jobs J m+2 and

J m+3.

For convenience, we denote the schedule π as π =

(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

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

C m+2 = j∈S 1

(1 + α j )(1 + αm+1) + X 3×

j∈S 2

(1 + α j )(1 + αm+2) − 1

= 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 (π ) ≤

m j=1

C j +

3k=1

C m+k

< X 3 − 1 + 2(m + 1) X 6 − 1/2

+ 2 X 10 − 1 = G.

Now suppose that there is a feasible schedule π such

that Z (π ) ≤ G . According to Lemma 8, we only need to

consider two cases.

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

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

Consider Case 1. Let S 2 ⊆ {1, 2, · · · , n} denote the in-

dices 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

mainte-nance is

C Bmax =

j∈ S 1

(1 + α j )(1 + αm+1) − 1

= X 2

A

j∈S 1

(1 + α j )

− 1,

and the maximum completion time of the jobs processed

after

the

maintenance

is

C Amax =

X 2

A

j∈S 1

(1 + α j )

+ X 3

×

j∈S 2

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

= X 10 + X 9

B

j∈S 2

(1 + α j )

− 1.

Hence, we have

Z (π ) > C

B

max + C

A

max

= X 2

A

j∈S 1

(1 + α j )

− 1 + X 10

+ X 9

B

j∈S 2

(1 + α j )

− 1

= X 10 + X 9

A

j∈ S 1

(1 + α j ) + B

j∈ S 2

(1 + α j )

− X 9 − X 2 A j∈

ˆS 1

(1 + α j )− 2.

Clearly C Bmax ≤ sd , i.e., X 2( A

j∈S 1

(1 + α j)) ≤ X 3 − 1.

We have A

j∈S 1

(1 + α j ) ≤ X , which implies

j∈S 1(1 +

α j ) ≤ B . Suppose there is no solution for instance I , then j∈S 1

(1 + α j ) < B . By Lemma 7, we have B

j∈S 2

x j +

A

j∈S 1

x j > 2 X , and thus B

j∈S 2

x j + A

j∈S 1

x j ≥

2 X + 1. With simple calculations we have

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

− X 9 − X 2

A

j∈S 1

(1 + α j )

− 2

> X 10 + 2 X 10 + X 9 − X 9 − X 2

X − 2

> 2 X 10 + X 9 + X 3 − 2

> G,

which achieves a contradiction. Thus

j∈S 1(1

+ α j ) = j∈S 1

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

it.

For the 1, VM| p j = α j + β j s j |

j C j problem with the

special case α j = β j , it is easily verified that there exist

an optimal solution such that the jobs before the main-

tenance

are

sequenced

according

to

the

nondecreasing

α j

order, and so are the jobs scheduled after the maintenance.




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 com-

pletion 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 comple-

tion time minimization problem, in general case whether

it admits an FPTAS is open.

Acknowledgements

We thank three anonymous referees for their help-

ful

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 Uni-

versity (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.

References

[1] S. Browne, U. Yechiali, Scheduling deteriorating jobs on a single pro-

cessor, Oper. Res. 38 (3) (1990) 495–498.

[2] Z.-L. Chen, Parallel machine scheduling with time dependent pro-

cessing times, Discrete Appl. Math. 70 (1) (1996) 81–93.

[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 (4–5)

(2011)

275–280.[4] R.L.

Graham,

E.L.

Lawler,

J.K.

Lenstra,

A.H.G.

Rinnooy

Kan,

Optimiza-

tion and approximation in deterministic sequencing and scheduling:

a survey, Ann. Discrete Math. 5 (1979) 287–326.

[5] S. Gawiejnowicz, Scheduling deteriorating jobs subject to job or ma-

chine availability constraints, Eur. J. Oper. Res. 180 (2007) 472–478.

[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) 305–308.

[8] D.S. Johnson, The NP-completeness column: an ongoing guide, J. Al-

gorithms 2 (1983) 393–405.

[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) 115–126.

[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) 794–798.

[11] W. Luo, L. Chen, Approximation scheme for scheduling resumable

proportionally deteriorating jobs, in: Frontiers in Algorithmics and

Algorithmic Aspects in Information and Management, AAIM’10, 2011,

pp. 36–45.

[12] W. Luo, L. Chen, Approximation schemes for scheduling a main-

tenance and linear deteriorating jobs, J. Ind. Manag. Optim. 8 (2)

(2012) 271–283.

[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) 57–74.

[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) 89–93.

http://refhub.elsevier.com/S0020-0190(14)00173-2/bib623930s1























































































































































































































































http://refhub.elsevier.com/S0020-0190(14)00173-2/bib6A3833s1


























































































































http://refhub.elsevier.com/S0020-0190(14)00173-2/bib6C633131s1





























































































































































































































Documents

Scheduling a variable maintenance and linear deteriorating jobs on a single machine.pdf