Académique Documents
Professionnel Documents
Culture Documents
=(''') and
=(''') be two
permutations of n jobs that differ only in the order of the
subsequences and . For a function F() that depends on a
permutation, suppose that there exists a function () such
that for any two permutations
and
the inequality
()>() implies that F(
) F(
)= F(
i
||
=j+1
(1+a
(i)
))
The problem of minimizing the weighted sum of completion times is NP-
hard (Bachman, Janiak, Kovalyov, Inform.Proc.Lett. 2002)
We show that even for unit processing times a 1-priority function
does not exist for this problem
simple linear time: p
j
(t)
= p
j
(1+a t )
For the single machine problem to minimize the weighted sum of
completion times, the objective function is priority-generating (Wang, Ng,
Cheng, Comp.Oper.Res. 2008)
15
Time deterioration
constant rate linear time: p
j
(t)
= a t + p
j
( processing time of
a job depends linearly on its start time in some schedule)
Theorem 6. For the single machine problem to minimize the
sum of completion times, the objective function is priority-
generating. Its priority function is
() = (
k
||
=1
(1+a)
k
) / (
k
||
=1
p
(k)
(1+a)
|| - k
)
For independent jobs, the problem admits SPT optimal index policy (Ng,
Cheng, Bachman, Janiak, Inform.Proc.Lett. 2002).
This is follows as a Corollary: If the priority function is
calculated for a single job, (j) = 1 / p
j
is a 1-priority function.
16
17
Problem Complexity
-----------------------------------------------------------------------
Positional deterioration
polinomial
1 | p
j
[r]
= p
j
r
A
, SP | C
max
O(nlogn) for A=1
cumulative
1 | p
j
[r]
= p
j
(1+
k
r
=
-
1
1
p
[k]
)
A
, prec | C
max
O(n) for A=1
1 | p
j
[r]
= p
j
(1+
k
r
=
-
1
1
p
[k]
)
A
, SP | C
max
O(nlogn) for A=2
1 | p
j
[r]
= p
j
(1+
k
r
=
-
1
1
p
[k]
)
A
| C
j
O(nlogn) for A>1
exponential
1 | p
j
[r]
= p
j
r-1
, SP | C
max
O(nlogn)
1 | p
j
[r]
= p
j
r-1
| C
j
O(nlogn) for 2
18
Problem Complexity
-------------------------------------------------------------------
Time deterioration
linear time
1 | p
j
(t)
= a
j
t + p
j
, SP | C
max
O(nlogn)
simple linear time
1 | p
j
(t)
= a
j
t , prec | C
max
O(n)
1 | p
j
(t)
= a
j
t , SP | w
j
C
j
O(nlogn)
1 | p
j
(t)
= p
j
(1+at) , SP | w
j
C
j
O(nlogn)
constant rate linear time
1 | p
j
(t)
= a
t , SP |
C
j
O(nlogn)
19
2. Single Machine Scheduling
and Due Date Assignment
under Positional Deterioration
Valery Gordon
United Institute of Information Problems,
Minsk, Belarus
Vitaly Strusevich
University of Greenwich, London, U.K.
This Part
Single Machine Scheduling
Jobs with Positional Deterioration Effect
Due Date Assignment (DDA)
Admission Control
Cost:
Total Cost of Discarded Jobs
Cost for DDA
Possibly Total Earliness of Scheduled Jobs
Motivation
The supply chain: a manufacturer and a customer.
The manufacturer: wishes that all accepted orders are
completed in full and in time to satisfy the customer's
demand.
The due dates are the subject of negotiation with the
customer
For the mutually agreed due dates, the manufacturer can
discard some of the orders if they cannot be completed
in time; in this case a penalty for each discarded order is
paid
The manufactures uses sensitive equipment, with its
production capability changing over time
Notation
N = {1,, n} set of jobs to be processed on a single machine
p
j
normal processing time of job j
If the jobs are processed in accordance with a certain
permutation =((1), (2),, (n)), then the
processing time of job j = (r), i.e., the job
sequenced in the r-th position is given by
p
j
[r]
=p
j
g(r),
g(r) is a function that specifies a positional deterioration effect
We assume that g(1)=1 and g(r) g(r+1) for each r, 1 r n-1.
Notation: Deterioration
Polynomial Deterioration:
The actual processing time of a job j that is sequenced in position
r is given by
p
j
[r]
=p
j
r
A
,
where A > 0 is a given constant, common for all jobs.
Biskup (1999), Mosheiov (2001, 2005) , Gordon et al. (2008)
Exponential Deterioration:
The actual processing time of a job j that is sequenced in position
r is given by
p
j
[r]
=p
j
r-1
,
where > 1 is a given constant representing a rate of
deterioration, common for all jobs
Wang (2005), Wang and Xia (2005) , Gordon et al. (2008)
Notation
Due Date Assignment (DDA): survey by Gordon et al. (2004)
Each job j N has to be assigned a due date d
j
Given a schedule, let C
j
denote the completion time of job j and, provided that C
j
d
j
, define its
earliness as E
j
= d
j
- C
j
In all problems under consideration: the jobs of set N have to be split into two subsets denoted by
N
E
and N
T
The jobs of subset N
T
are essentially discarded, and a penalty
j
is paid for a discarded job j N
T
.
Only the jobs of set N
E
are sequenced, and each of these jobs is completed no later than its
assigned due date.
The purpose is to select the due dates for the jobs and the sequence of the early jobs in such a
way that a certain penalty function is minimized.
Notation: Objective Functions
e
+ =
T
N j
j
F o t ) ( ) , (
1
d d
e e
+ + =
T E
N j
j
N j
j
E F o t ) ( ) , (
2
d d
Vector of
due dates
Cost for DDA,
Depends on the chosen
model
Total cost of
discarded
jobs
Total
earliness
Sequence of
jobs
Objective Functions
Due Date Assignment (DDA)
Admission Control
Scheduling of Deteriorating Accepted Jobs
e
+ =
T
N j
j
F o t ) ( ) , (
1
d d
e e
+ + =
T E
N j
j
N j
j
E F o t ) ( ) , (
2
d d
Auxiliary Problem PdE
, ) ( ) (
1
) (
=
+ =
n
k
k
E d f
t
t | t
Find a permutation that minimizes the function
where is a given positive constant,
d() is the completion time of the last job (n) and is
treated as a due date common to all jobs
Auxiliary Problem PdE
Lemma
1
Auxiliary Problem PdE
By pairwise interchange argument: Let be an optimal
permutation for Problem PdE. Choose an arbitrary
position u, where 1 u n-1, and introduce a
permutation that differs from by swapping the jobs
(u) and (u+1). It follows that
=f()-f() =(p
(u)
- p
(u+1)
)(g(u)(+u-1)-g(u+1)(+u))
Lemma
1
Auxiliary Problem PdE
For Problem PdE with positional deterioration an optimal
permutation can be found by LPT rule:
g(u+1)/g(u) 1 > (+u-1)/(+u)
Lemma
1
Auxiliary Problem Pd
) ( ) ( t t d f =
Find a permutation that minimizes the function
where d() is the completion time of the last job (n)
For Problem Pd with positional deterioration an optimal
permutation can be found by LPT rule
CON: Common Due Date
Assignment
For the CON model, all due dates are equal, and we select
d as the cost function (d), where is a positive
constant. Thus we minimize the objective functions
e
+ =
T
N j
j
F o t ) ( ) , (
1
d d
e e
+ + =
T E
N j
j
N j
j
E F o t ) ( ) , (
2
d d
e
+ =
T
N j
j
d F o | t) , (
1
d
e e
+ + =
T E
N j
j
N j
j
d E F o | t) , (
2
d
CON: Common Due Date
Assignment
To minimize the weighted number of discarded jobs with
fixed times with respect to a given common due date is
NP-hard in the ordinary sense [Karp 1972]
CON DDA problems with fixed times admit polynomial
time algorithms [De et al. 1991, Kahlbacher and Cheng
1993]
CON DDA problems with resource-dependent
processing times admit polynomial time algorithms
[Shabtay and Steiner (2007)]
e
+ =
T
N j
j
d F o | t) , (
1
d
e e
+ + =
T E
N j
j
N j
j
d E F o | t) , (
2
d
CON: Common Due Date
Assignment
Idea:
Fill the sequence from left to right so that the last scheduled
job completes exactly at time d
Scan the jobs in LPT order
Try either to discard the job (move to set N
T
) or schedule it
(to put it last among the scheduled jobs, compute its
processing time by the deterioration formula, recompute the
due date etc.). Accept the best option.
Dynamic programming
e
+ =
T
N j
j
d F o | t) , (
1
d
e e
+ + =
T E
N j
j
N j
j
d E F o | t) , (
2
d
Function for
Problem Pd
Function for
Problem
PdE
CON: Illustartion
Idea:
Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
Scan the jobs in LPT order
Try either to discard the job (move to set N
T
) or schedule
it (to put it last among the scheduled jobs, compute its
processing time by the deterioration formula, recompute
the due date etc.)
e
+ =
T
N j
j
d F o | t) , (
1
d
CON: Illustartion
Idea:
Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
Scan the jobs in SPT order
Try either to discard the job (move to set N
T
) or schedule
it (to put it last among the scheduled jobs, compute its
processing time by the deterioration formula, recompute
the due date etc.)
e
+ =
T
N j
j
d F o | t) , (
1
d
CON: Illustartion
Idea:
Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
Scan the jobs in LPT order
Try either to discard the job (move to set N
T
) or schedule
it (to put it last among the scheduled jobs, compute its
processing time deterioration formula, recompute the
due date etc.)
e
+ =
T
N j
j
d F o | t) , (
1
d
CON: Illustartion
Idea:
Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
Scan the jobs in LPT order
Try either to discard the job (move to set N
T
) or schedule
it (to put it last among the scheduled jobs, compute its
processing time deterioration formula, recompute the
due date etc.)
e
+ =
T
N j
j
d F o | t) , (
1
d
CON: Illustartion
Idea:
Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
Scan the jobs in LPT order
Try either to discard the job (move to set N
T
) or schedule
it (to put it last among the scheduled jobs, compute its
processing time deterioration formula, recompute the
due date etc.)
e
+ =
T
N j
j
d F o | t) , (
1
d
CON: Dynamic Programming
The DP algorithm uses the states of the form (k, r), where
k - the number of jobs that have been considered
r, 0 r k, - how many of these jobs have been sequenced
early
A state (k, r) is associated with f(k, r), the smallest value of the
objective function in the class of partial schedules for
processing k jobs, provided that r of these jobs have been
sequenced early, where f(0, 0) = 0
For each k from 1 to n
e
+ =
T
N j
j
d F o | t) , (
1
d
Answer: Optimal F
1
= min{f(n, r}|0rn}
= O(n
2
)
CON: Dynamic Programming
The DP algorithm uses the states of the form (k, r), where
k - the number of jobs that have been considered
r, 0 r k, - how many of these jobs have been sequenced
early
A state (k, r) is associated with f(k, r), the smallest value of the
objective function in the class of partial schedules for
processing k jobs, provided that r of these jobs have been
sequenced early, where f(0, 0) = 0
For each k from 1 to n
Answer: Optimal F
2
= min{f(n, r}|0rn}
e e
+ + =
T E
N j
j
N j
j
d E F o | t) , (
2
d
1 r k-1
= O(n
2
)
SLK Due Date Assignment
For the SLK model, for each job its due date is computed
by increasing its actual processing time by a slack q,
common to all jobs.
We select q as the cost function (d), where is a
positive constant. Thus we minimize the objective
functions
e
+ =
T
N j
j
F o t ) ( ) , (
1
d d
e e
+ + =
T E
N j
j
N j
j
E F o t ) ( ) , (
2
d d
e
+ =
T
N j
j
q F o t | t ) ( ) , (
1
d
e e
+ + =
T E
N j
j
N j
j
q E F o t | t ) ( ) , (
2
d
SLK Due Date Assignment
e
+ =
T
N j
j
q F o t | t ) ( ) , (
1
d
e e
+ + =
T E
N j
j
N j
j
q E F o t | t ) ( ) , (
2
d
SLK Due Date Assignment
e
+ =
T
N j
j
q F o t | t ) ( ) , (
1
d
e e
+ + =
T E
N j
j
N j
j
q E F o t | t ) ( ) , (
2
d
Idea:
Try each job one by one as the on-time job
Scan the remaining jobs in LPT order
Try either to discard the job (move to set N
T
) or schedule it
(to put it right before the on-time job, compute its
processing time by the deterioration formula, recompute the
due date, the slack etc.). Accept the best option.
Dynamic programming
SLK: Dynamic Programming
The DP algorithm uses the states of the form (h, k, r), where
h the fixed on-time job
k - the number of jobs that have been considered
r, 0 r k, - how many of these jobs have been sequenced
early
A state (h, k, r) is associated with f(h, k, r), the smallest value of
the objective function in this class, where f(0, 0, 0) = 0
For each h, each k from 1 to n (without h)
e
+ =
T
N j
j
q F o t | t ) ( ) , (
1
d
1 r k-1
Answer: Optimal F
1
= min{min{f(h, n, r)},
j
}
= O(n
3
)
SLK: Dynamic Programming
The DP algorithm uses the states of the form (h, k, r), where
h the fixed on-time job
k - the number of jobs that have been considered
r, 0 r k, - how many of these jobs have been sequenced
early
A state (h, k, r) is associated with f(h, k, r), the smallest value of
the objective function in this class, where f(0, 0, 0) = 0
For each h, each k from 1 to n (without h)
Answer: Optimal F
2
= min{min{f(h, n, r)},
j
}
e e
+ + =
T E
N j
j
N j
j
q E F o t | t ) ( ) , (
2
d
= O(n
3
)
Conclusion
Polynomialtime dynamic programming algorithms are
developed for single machine scheduling problems with
deteriorating jobs, admission control and two popular
policies of due date assignment (CON and SLK)
The scheduled jobs follow the LPT order
The results hold for any model of positional deterioration
Can be extended to models with a positional learning effect,
but in this case extra conditions of the parameters are
required