W. Li et al. / Theoretical Computer Science 607 (2015) 181–192 183
2. A strongly polynomial time approximation algorithm for the problem P |
J
j
∈R
e
j
≤ B|C
max
As mentioned in the last section, we can derive a 2-approximation algorithm from Shmoys and Tardos [21] for
P |
J
j
∈R
e
j
≤ B|C
max
. However, this kind of approximation algorithm may not be strongly polynomial as it requires the
solution of a linear programming formulation and this is well-known that there is no strongly polynomial algorithm for
solving linear programming so far. So it would be desirable to have strongly polynomial 2-approximation algorithms for the
problem P |
J
j
∈R
e
j
≤ B|C
max
. In this section, we shall provide such one algorithm (Algorithm 2).
Let
us introduce some notations and terminology before proceeding. An instance I = (M, J , p, e, B) of the problem
P |
J
j
∈R
e
j
≤ B|C
max
consists of a number of machines M with |M| = m, a set of jobs J with |J | = n, a nonnegative
pair (p
j
, e
j
) for each job J
j
∈ J where p
j
is the processing time (or size) of J
j
and e
j
is the penalty of J
j
, and a given
bound B. For a set of jobs X ⊆ J , p(X) =
J
j
∈X
p
j
is the total processing time of jobs in X, and e(X) =
J
j
∈X
e
j
is the
total penalty of jobs in X . We call (S
1
, S
2
, ..., S
m
; R), where S
i
and R are all subsets of J , a schedule for I if the followings
hold:
(i)
∪
m
i
=1
S
i
∪ R = J ; and
(ii) S
i
∩ S
j
=∅, for distinct i, j ∈{1, 2, ..., m} and S
k
∩ R =∅ for each k ∈{1, 2 ..., m}
We further call a schedule (S
1
, S
2
, ..., S
m
; R) feasible if e(R) ≤ B. Obviously, for i ∈{1, ..., m}, S
i
stands for the set of jobs
that have to be processed on machine M
i
, and R stands for the set of rejected jobs in a feasible schedule (S
1
, S
2
, ..., S
m
; R).
For 1 ≤ i ≤ m, the completion time C
i
of machine M
i
in some fixed schedule equals the total processing time of the jobs that
are assigned to M
i
, and the makespan of the schedule equals max
1≤i≤m
{C
i
}. We call schedule (S
1
, S
2
, ..., S
m
; R) optimal
if
the schedule is feasible and the makespan of the schedule attains the minimum. As usual, when we say OPT is the
optimal value for instance I, we mean that there is an optimal schedule for instance I and OPT equals the makespan of
this schedule. Note that we allow OPT =+∞ in the case that there is no feasible schedule for instance I.
Now
let’s consider an optimal schedule (S
∗
1
, S
∗
2
, ..., S
∗
m
; R
∗
) and assume that we know the maximum size p
max
of the
accepted jobs in the schedule, where p
max
= max{p
j
| J
j
∈∪
m
i
=1
S
∗
i
}. To motivate the construction of a 2-approximation
algorithm for the problem, we may have a simple idea that is to reject all jobs with size bigger than p
max
and other some
jobs, if any, as long as the total penalty of the rejected jobs is no more than the given bound B, and then greedily allocate
the remaining jobs as LS algorithm does. Fortunately, this simple idea can indeed lead to a 2-approximation algorithm for
the problem. Motivated by this, we actually do not need the prior knowledge about the maximum size p
max
of the accepted
jobs in an optimal schedule, as we can try at most n possibilities to meet our purpose of designing a 2-approximation
algorithm.
Let
us be more precise. Given an instance I = (M, J , p, e, B) for P |
J
j
∈R
e
j
≤ B|C
max
, reindex, if there is a need, the
jobs in J such that p
1
/e
1
≤ p
2
/e
2
≤···≤ p
n
/e
n
. Note that we assume that e
j
> 0for all jobs J
j
∈ J throughout the paper,
as for otherwise, the jobs with penalty of 0 can be all rejected without reducing the given bound. Also we assume that
n
j
=1
e
j
> B, as for otherwise, all jobs should be rejected and OPT = 0, where OPT denotes the optimal value for instance I.
It is worth pointing out that any subset ⊆ J enjoys a nice property under our sorting, i.e.,
p
i
e
i
≤
p
j
e
j
if i ≤ j (1)
for all jobs J
i
, J
j
in . This property shall be used in the proof for the following Lemma 1.
For
each index k ∈{1, 2, ..., n}, consider the following restricted instance I
k
= (M, J
k
, p, e, B
k
) of I :
• The number of machines remains the same as in instance I.
• The job set J
k
consists of jobs in J with processing time no more than p
k
, i.e., J
k
={J
j
∈ J | p
j
≤ p
k
}.
• The processing time (or size) p
j
and penalty e
j
of job J
j
in J
k
remain the same as in instance I.
• The bound B
k
of instance I
k
is reduced by
J
j
∈J \J
k
e
j
, i.e., B
k
= B −
J
j
∈J \J
k
e
j
.
Let
OPT
k
be the optimal value for instance I
k
. If B
k
< 0, set OPT
k
=+∞, reflecting the fact that there is no feasible
schedule for instance I
k
. Otherwise, use the following Algorithm 1 to obtain a feasible schedule for I
k
.
Algorithm
1.
Step
1. Find the maximum index τ
k
satisfying
j≥τ
k
; J
j
∈J
k
e
j
> B
k
, which implies that
j>τ
k
; J
j
∈J
k
e
j
≤ B
k
, and reject
the jobs in J
k
with index bigger than τ
k
. Let R
k
={J
j
| j > τ
k
, J
j
∈ J
k
} denote the set of all rejected jobs;
Step
2. As in LS algorithm, we repeatedly assign the next job in J
k
\ R
k
to a machine with currently smallest load. Let
F
k
denote the feasible schedule produced and OUT
k
the makespan of F
k
.
Lemma
1. The value of OUT
k
produced by Algorithm 1 is no more than 2OPT
k
.