1
Sequencing Problems
Consider the problem of sequencing a set of
n
jobs on a single machine with all of the
jobs initially available for processing.
The objective is to sequence the jobs on the
machine so as to minimize an additive function of the completion times of the jobs.
We
assume that each job
i
has a due date
d
i
, a starting time
s
i
that is a function of the
sequence, a processing time
t
i
, and a penalty weight of being late of
w
i
.
The job
completion time
c
i
is
s
i
+
t
i
.
The function g measures the penalty of the schedule with
respect the job
i
, where
g
(
s
i
,
i
)
=
w
i
(
s
i
+
t
i
−
d
i
),
if
s
i
+
t
i
≥
d
i
,
0
otherwise.
⎧
⎨
⎩
The problem at hand then is to select the permutation of the jobs {1,
"
,
n
} which
minimizes the sum of the penalties.
Let
P
be the collection of all permutations of the job
set, let
p
be a particular permutation and define
p
(
j
) as the
j
th
job in the permutation
p
.
The
j
th job in the sequence (permutation) we denote
s
p
(
j
)
as the starting time,
t
p
(
j
)
as the
processing time, and
d
p
(
j
)
as the job's due date.
Then the value of the objective for
permutation
p
∈
P
is
g
(
s
p
(
j
)
,
p
(
j
))
j
=
1
n
∑
,
and the objective is to find the permutation
p
∈
P
which minimizes this function.
There are
n
! permutations in the permutation set
P
and for small problems it is
relatively easy to compute all of these and select the best one with respect to the objective
function measure.
For example, the four job problem (sequence the job set {1,2,3,4}) we
have only 24 sequences to consider.
For a ten-job problem, however, the number of
sequences to be explicitly considered is 3,628,800.
So exhaustive enumeration quickly
becomes infeasible.
In his book on sequencing and scheduling, French [1982] gives a
comparison between the computational efforts of dynamic programming and exhaustive
enumeration for the
n
-job sequencing problem (see Table 1).
To put these numbers in
perspective, if it takes one micro-second (10
-6
seconds) to perform one operation
(addition, subtraction, or comparison) then to exhaustively solve the 20-job sequencing
problem, it would take ten million years.
To solve the 20-job sequencing problem by
dynamic programming would only take about one minute, but, the 40-job problem would

This
** preview**
has intentionally

**sections.**

*blurred***to view the full version.**

*Sign up*