Journal of Heuristics, 5, 5–28 (1999)

°
c 1999 Kluwer Academic Publishers, Boston. Manufactured in The Netherlands.

A 3/2 Algorithm for Two-Machine Open Shop

with Route-Dependent Processing Times
V. A. STRUSEVICH V.Strusevich@greenwich.ac.uk
University of Greenwich, London, U.K.

A. J. A. VAN DE WAART
Erasmus University, Rotterdam, The Netherlands

R. DEKKER
Erasmus University, Rotterdam, The Netherlands

Abstract. This paper considers the problem of minimizing the schedule length of a two-machine shop in which not
only can a job be assigned any of the two possible routes, but also the processing times depend on the chosen route.
This problem is known to be NP-hard. We describe a simple approximation algorithm that guarantees a worst-case
performance ratio of 2. We also present some modifications to this algorithm that improve its performance and
guarantee a worst-case performance ratio of 3/2.

Keywords: approximation, open shop scheduling, heuristics, worst-case analysis

1. Introduction

Many practical situations can be described using multi-stage (or shop) scheduling models.
In these models each job has to be processed on a number of sequential machines. For
an overview of the results in this area see (Lawler et al., 1993) and (Tanaev et al., 1994).
However, in classical scheduling theory, even if a choice of the route for a job is allowed,
it is normally assumed that the processing times of all operations remain unchanged. This
may not be the case in practice. For instance, the authors have observed an example at
engineering works where cylinders for marine diesel engines are manufactured on special
turning lathes and the processing times depend upon the order in which the lathes are used.
Despite their practical relevance, shop scheduling models with route-dependent process-
ing times have not received much attention. To obtain more insight, this paper analyzes the
simplest problem of this type called the two-machine open shop scheduling problem with
route-dependent processing times to minimize the makespan. This problem is known to be
NP-hard (see (Adiri and Amit, 1983)), this is why we concentrate on heuristic algorithms
and worst-case analysis of their performance.
This paper is organized as follows. Section 2 contains the definition of the problem and
some notation. Section 3 considers a simple heuristic algorithm that guarantees a worst-case
ratio bound of 2. A schedule found by that heuristic is to be transformed by two algorithms
presented in Section 4. These algorithms require O(n 2 ) time each and they eventually
generate a schedule which is at most 3/2 times worse than an optimal one. Analysis of
these algorithms is given in Sections 5 through 7. Final remarks are contained in Section 8.
6 STRUSEVICH, VAN DE WAART AND DEKKER

2. Problem Definition

The problem under consideration can be formulated as follows. We are given two machines,
A and B, and a set N = {1, 2, . . . , n} of jobs. The jobs are available simultaneously, and
are to be processed on both machines A and B. Each job has to be assigned one of the
processing routes either (A, B) or (B, A), different jobs being allowed to be given different
routes. If a job j ∈ N is given the route (A, B), it is first processed on machine A and this
takes a j time units, and then it is processed on machine B and this takes b j time units. In the
case a job j ∈ N is given the other processing route (B, A), it is first processed on B and
this takes β j time units, then it is processed on A and this takes α j units. In processing each
job on each machine no preemption is allowed. Standard scheduling requirements say that
a job can be processed on at most one machine at a time, and a machine can process at most
one job at a time. The objective is to minimize the makespan, i.e., we look for a schedule in
which all jobs are completed as early as possible. This schedule is further called optimal.
This problem is a generalization of the classical two-machine open shop model (see
(Gonzalez and Sahni, 1976)). In the latter model, the processing times do not depend on
the processing route, i.e. a j = α j and b j = β j for each j ∈ N . For the classical model,
finding a schedule minimizing the makespan can be done in O(n) time.
If in the two-machine open shop problem with route-dependent processing times we have
that b j = α j = 0 for all jobs j ∈ N , then we obtain the scheduling problem for two unrelated
parallel processors. In that model, each job has to be assigned either to machine A or to
machine B so as to minimize the makespan. In the first case, the processing time of a job
j ∈ N equals to a j , in the second case the processing takes β j time.
Recall that the problem with two unrelated parallel machines is NP-hard even if the
machines are identical, i.e., if a j = β j for all jobs; the corresponding decision problem is
known as PARTITION, see (Karp, 1972). Therefore, the two-machine open shop problem
with route-dependent processing times is NP-hard. A direct proof of this fact can also
be found in (Adiri and Amit, 1983). This implies that finding an optimal schedule in
polynomial time is unlikely, and therefore, it is an interesting research goal to design a fast
approximation algorithm generating a solution reasonably close to the optimum.
Some other classical two-machine scheduling models are quite relevant to the one under
consideration. The difference between our model and the two-machine two-stage job shop
is that, in the latter model, the set N of jobs is known in advance to be divided into two
subsets N 0 and N 00 such that all jobs of set N 0 have the processing route (A, B), while all
jobs of the other set have the route (B, A). For this model, an optimal schedule can be
found in O(n log n) time due to (Jackson, 1956).
Note that, if one of the sets N 0 or N 00 is empty, the two-machine job shop becomes the
two-machine flow shop, for which finding an optimal schedule also takes O(n log n) time
(see (Johnson, 1954)).
Throughout this paper the following notation is used. For a schedule S, let Cmax (S) denote
the value of the makespan, or the length of this schedule. An optimal schedule is denoted
by S ∗ . P
Given a set Q ⊆ N , denote a(Q) = j∈Q a j if Q 6= ∅; otherwise let a(Q) = 0. The
values b(Q), α(Q) and β(Q) are defined analogously.
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 7

Given a schedule S, the set of jobs that are given the route (A, B) is denoted by P(S),
and the set of jobs that are given the route (B, A) is denoted by P̄(S) = N \P(S). The total
workload on machine A in schedule S is defined as
X X
T A (S) = aj + α j = a(P(S)) + α( P̄(S)).
j∈P(S) j∈ P̄(S)

Similarly, the total workload on machine B in schedule S is defined as

TB (S) = b(P(S)) + β( P̄(S)).

In the subsequent analysis we need lower bounds on the length of an optimal schedule.
Some apparent bounds are given below:
( )
X X
∗
Cmax (S ) ≥ max min{a j , α j }, min{b j , β j } ; (1)
j∈N j∈N

© ª
Cmax (S ∗ ) ≥ max min{a j + b j , α j + β j } | j ∈ N . (2)

Let S H be a schedule created by some algorithm H . The algorithm is said to pro-

vide a ratio performance guarantee ρ if for any instance of the problem the inequality
Cmax (S H )/Cmax (S ∗ ) ≤ ρ holds. A worst-case bound is called tight if for some instance of
the problem the corresponding inequality holds as the equality.
Recently, certain progress in developing fast approximation algorithms for shop schedul-
ing problems has been achieved. As far as open shop problems to minimize the makespan
Cmax is concerned, there are algorithms that guarantee ρ < 2 for any number of machines,
see, e.g., (Shmoys et al., 1993). In the case of three machines a linear time algorithm with
ρ = 3/2 is given in (Chen and Strusevich, 1993). Moreover, a polynomial-time approxima-
tion scheme for the open shop problem with a fixed number of machines has recently been
given in (Sevastianov & Woeginger, 1996). On the other hand, as shown in (Williamson
et al., 1997), a polynomial-time algorithm with ρ < 5/4 for the open shop problem with a
variable number of machines does not exist unless P = N P.
Our primary goal is to design a heuristic algorithm for the two-machine open shop problem
with route-dependent processing times that guarantees a tight worst-case ratio bound of
3/2. Notice this bound is the same as obtained by Potts for a less general problem of
scheduling on two unrelated machines (see (Potts, 1985)). We, however, do not use the
linear programming argument by Potts, and our algorithm requires more running time than
that from (Potts, 1985).

3. Priority Scheduling

In this section, we study a special class of heuristic algorithms for the two-machine open
shop route-dependent scheduling problem. A lower bound on the worst-case performance
ratio of any algorithm of this class is shown to be 2. We also present the best algorithm in
this class for which 2 is a tight upper bound on the worst-case ratio.
8 STRUSEVICH, VAN DE WAART AND DEKKER

For the problem under consideration, suppose that P is a subset of set N of jobs. This
subset defines the partition of N into two subsets: P and P̄ = N \P. Given a subset P,
we may find a schedule S such that P(S) = P (and, therefore, P̄(S) = P̄). The problem
of finding the best among all such schedules essentially becomes the two-stage job shop
problem. The latter problem is solvable by Jackson’s algorithm, which in the case under
consideration can be presented as follows.

Algorithm 1

INPUT: A subset P ⊆ N

OUTPUT: The best schedule S with P(S) = P

1. Find the sequence ϕ(P) of the jobs of set P which starts with the jobs such that a j ≤ b j
sorted in non-decreasing order of a j followed by the rest of the jobs in this set sorted in
non-increasing order of b j .
2. Find the sequence ψ( P̄) of the jobs of set P̄ = N \P which starts with the jobs such
that β j ≤ α j sorted in non-decreasing order of β j followed by the rest of the jobs in this
set sorted in non-increasing order of α j .
3. Find a schedule in which machine A processes the jobs according to the sequence
(ϕ(P), ψ( P̄)), and machine B processes the jobs according to the sequence (ψ( P̄),
ϕ(P)), provided that the processing of each operation starts as soon as possible. Stop.
The running time of Algorithm 1 is O(n log n).
We now present a class of algorithms that partition the set of jobs into two subsets by
comparing certain priority functions with a given threshold value. A general scheme of
such an algorithm is as follows. For each job j ∈ N , a priority f j = f (a j , b j , α j , β j ) is
computed, where f is a given function. Given a threshold value F, we may define the subset
P = { j ∈ N | f j ≤ F}. Once P is obtained, the corresponding schedule can be found by
running Algorithm 1. We call algorithms of this type Priority Scheduling Algorithms.
Priority Scheduling Algorithms are naturally defined and simple to use heuristics. They,
however, have a common disadvantage that affects their worst-case performance. The
function f that defines the priority is the same for all jobs. It follows that identical jobs
(i.e., the jobs with the same processing time parameters) are to be included into the same
subset.
Consider the problem of optimal scheduling two jobs, 1 and 2, assuming that

a1 = a2 = 1, b1 = b2 = 0, α1 = α2 = 0, β1 = β2 = 1.

Whatever Priority Scheduling Algorithm is applied, we have either P = {1, 2}, P̄ = ∅ or

P = ∅, P̄ = {1, 2} so that for the resulting heuristic schedule H we obtain Cmax (H ) = 2.
On the other hand, by directing job 1 to go from A to B and job 2 to go from B to A, we
obtain an optimal schedule S ∗ of unit length.
Therefore, none of Priority Scheduling Algorithms guarantees a worst-case performance
ratio better than 2. To find the best algorithm in this class, it seems reasonable to split the
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 9

jobs in such a way that each job is assigned the processing route with the smallest total
processing time for that job. This can be done by defining F = 0 and

f j = (a j + b j ) − (α j + β j ), j ∈ N.

The schedule produced by the resulting Priority Scheduling Algorithm is denoted by S0 .

Notice that P(S0 ) = NAB and P̄(S0 ) = NBA , where
© ª © ª
NAB = j ∈ N | a j + b j ≤ α j + β j , NBA = j ∈ N | a j + b j > α j + β j .

We show that the algorithm that finds schedule S0 is the best among Priority Scheduling
Algorithms.
THEOREM 1 The upper bound

Cmax (S0 ) ≤ 2Cmax (S ∗ ) (3)

holds, and this bound is tight.

Proof: We only need to prove the inequality (3); the tightness of this bound follows from
the example given above.
Take an arbitrary schedule S. It is clear that
X
T A (S) + TB (S) ≥ min{a j + b j , α j + β j }.
j∈N

In turn,
X X X
min{a j + b j , α j + β j } = (a j + b j ) + (α j + β j ) = T A (S0 ) + TB (S0 ).
j∈N j∈NAB n∈NBA

Thus, the inequality

T A (S) + TB (S) ≥ T A (S0 ) + TB (S0 ) (4)

holds for any schedule S.

Consider an arbitrary optimal schedule S ∗ . It follows that
1
Cmax (S ∗ ) ≥ max{T A (S ∗ ), TB (S ∗ )} ≥ (T A (S ∗ ) + TB (S ∗ )).
2
Due to (4) applied to S = S ∗ , we obtain the lower bound
1 1
Cmax (S ∗ ) ≥ (T A (S0 ) + TB (S0 )) = (a(NAB ) + b(NBA ) + α(NBA ) + β(NBA )). (5)
2 2
On the other hand, it is obvious that

Cmax (S0 ) ≤ T A (S0 ) + TB (S0 ),

so that the desired bound (3) holds.

10 STRUSEVICH, VAN DE WAART AND DEKKER

4. Transformation Algorithms

The bound of 2 established in Theorem 1 cannot be viewed as a good ratio bound for a two-
machine scheduling problem, since the guaranteed length of the resulting schedule may be
found unacceptable. In the subsequent section, we describe two algorithms that eventually
transform schedule S0 into a schedule whose length is at most 3/2 times the optimal value.
The required transformations are arranged as two algorithms to be run one after another.
Each of these algorithms involves gradual improvements of heuristic schedules. The im-
provements are done by determining a subset of jobs for which changing their routes could
decrease the schedule length, followed by an attempt of that change.
We first describe a procedure that transforms S0 into another heuristic schedule S H having
specific properties. In general, it may fail to find a schedule with the length that is at most
3/2 times the optimum, in which case the second algorithm makes further improvements.
Without loss of generality, assume that

T A (S0 ) ≥ TB (S0 ), (6)

otherwise the machines can be renamed.

Our current purpose is to design a procedure that converts schedule S0 into such a schedule
S H that either
3
Cmax (S H ) ≤ Cmax (S ∗ ), (7)
2
holds, or the following inequalities
T A (S H ) ≥ TB (S H ), (8)
T A (S H ) ≤ 3TB (S H ), (9)
1
Cmax (S ∗ ) ≥ (T A (S H ) + TB (S H )) (10)
2
hold simultaneously.
Schedule S H is then either accepted as the final schedule (if (7) can be proved), or is
subject to further transformations to be done by our second algorithm. In the latter case,
the relations (8)–(10) provide more information on the structural properties of an optimal
schedule, in particular (10) serves as a useful lower bound on the optimal makespan.
In what follows, it is assumed that

T A (S0 ) > 3TB (S0 ); (11)

otherwise S0 can be accepted as the desired schedule S H (it satisfies (8)–(10) due to (6) and
(5)).
In addition to (11) it is also assumed that

L = { j ∈ P(S0 ) | a j > α j } ∪ { j ∈ P̄(S0 ) | α j > a j } 6= ∅, (12)

as implied by the following statement.

A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 11

LEMMA 1 For a schedule S, suppose that a j ≤ α j for any job j ∈ P(S) and α j ≤ a j for
any job j ∈ P̄(S). If S satisfies the inequality

T A (S) ≥ 3TB (S),

then
4
Cmax (S) ≤ Cmax (S ∗ ).
3

Proof: The conditions of the lemma and (1) imply that

4 4X 4
Cmax (S) ≤ T A (S) + TB (S) < T A (S) = min{a j , α j } ≤ Cmax (S ∗ ).
3 3 j∈N 3

This proves the lemma.

In order to obtain a desired schedule S H satisfying either (7) or (8)–(10), schedule S0 is

subject to some transformations aimed at reducing the total workload on machine A. This
can be done by changing the route for some jobs in L.
For each job j ∈ N define
½
a − αj , if j ∈ P(S0 ) = NAB
U j := j
αj − aj , if j ∈ P̄(S0 ) = NBA

and
½
(α j + β j ) − (a j + b j ), if j ∈ P(S0 ) = NAB
Vj :=
(a j + b j ) − (α j + β j ), if j ∈ P̄(S0 ) = NBA

Notice that the values U j and Vj are non-negative for all j ∈ L. For a schedule S 0 in
which a job j ∈ L has the route as in schedule S0 , let the schedule S 00 be obtained from S 0
by changing the route of job j. This transformation reduces the workload on machine A
by U j and increases the total workload on both machines by Vj , i.e.,

T A (S 00 ) = T A (S 0 ) − U j , T A (S 00 ) + TB (S 00 ) = T A (S 0 ) + TB (S 0 ) + Vj .

The procedure for obtaining the desired schedule S H is arranged as an iterative process.
In each iteration, a job of set L is selected and an attempt of changing its route is made.
Intuitively, each time we would give the preference to the job which provides a substantial
reduction in the workload on machine A accompanied by a relatively small increment in
the total workload on both machines. This helps to achieve the relations similar to (8)–(10).
To simplify the selection process, the jobs of set L are scanned according to a certain list,
which is organized as follows. It starts with the jobs of set L for which Vj = 0 taken in
non-increasing order of U j . These jobs are followed by the remaining jobs of L taken in
non-increasing order of the ratios R j = U j /Vj . We denote the obtained list by L. It is
obvious that, given the schedule S0 or the set L, the list L can be found in no more than
O(n log n) time.
12 STRUSEVICH, VAN DE WAART AND DEKKER

Formally, an algorithm for transforming schedule S0 into schedule S H can be described

as follows. In the description of the algorithm and in the remainder of this paper we use
the following notation. For two schedules S 0 and S 00 , let S 0 ∨ S 00 denote the shorter of these
two schedules, i.e., the one with the smaller makespan.

Algorithm 2 (Initial Transformations)

INPUT: Schedule S0 defined by the subset P(S0 ) = NAB ; list L of jobs of set L

OUTPUT: Schedule S H satisfying either (7) or (8)–(10)

1. Define k := 0 and S H := S0 .
2. While list L is not empty do:
(a) Set k := k + 1. Let q be the first job in list L. Remove this job from L. Change
the route of job q, i.e., if q ∈ P(Sk−1 ), define P(Sk ) := P(Sk−1 )\{q}; otherwise,
if q ∈ P̄(Sk−1 ), define P(Sk ) := P(Sk−1 ) ∪ {q}. Find schedule Sk by running
Algorithm 1 with P = P(Sk ).
(b) If the inequality

T A (Sk ) > 3TB (Sk ) (13)

holds go to Step 2(a), otherwise go to Step 2(c).

(c) If the inequality

T A (Sk ) < TB (Sk ) (14)

holds, then go to Step 2(d), otherwise go to Step 3.

q
(d) In schedule S0 change the route of job q alone, i.e., if q ∈ P(S0 ), define P(S0 ) :=
q
P(S0 )\{q}; otherwise, if q ∈ P̄(S0 ), define P(S0 ) := P(S0 ) ∪ {q}. Find sched-
q q q
ule S0 by running Algorithm 1 with P = P(S0 ). Define S H := S H ∨ S0 ∨ Sk .
Modify schedule Sk by resuming the original route for job q, i.e., define P(Sk ) :=
P(Sk−1 ). Find schedule Sk by running Algorithm 1 with P = P(Sk ).
3. Define S H := S H ∨ Sk . Stop.
The running time of Algorithm 2 does not exceed O(n 2 ). For job q that is subject to
transformation in iteration k there can be two outcomes:
(i) for job q the new route is kept in schedule Sk (Step 2(a));
(ii) for job q the old route is resumed in schedule Sk (Step 2(d)).
In some iteration, the jobs of set N for which an attempt for changing the route has not yet
been made are called unchanged. Note that all jobs of the set N \L are always unchanged.
The jobs for which option (i) has occurred are called changed. The jobs for which option (ii)
has occurred are called fixed.
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 13

Algorithm 2 has the following features:

(1) If the algorithm leaves the main loop (see Step 2) because the list L is empty, then
schedule S H satisfies the conditions of Lemma 1 and is at most 4/3 times worse than
an optimal schedule.
(2) If the algorithm leaves the main loop because both conditions (13) and (14) do not hold
for the current schedule Sk , then that schedule satisfies (8) and (9). Moreover, for that
schedule (10) also holds, as the following theorem claims.

THEOREM 2 Let Sk , k < |L|, be a schedule found at some iteration of Algorithm 2. Then
the following lower bound
1
Cmax (S ∗ ) ≥ (T A (Sk ) + TB (Sk )) (15)
2
holds.
We prove Theorem 2 in Section 5.
(3) The following theorem holds.

THEOREM 3 Let for some k ≤ |L|, schedule Sk be obtained from schedule Sk−1 by
changing the route of some job q. If this schedule satisfies (14) and if there exists
an optimal schedule S ∗ in which job q has the same route as in schedule Sk , then for
schedule S H defined in Step 2(d) of Algorithm 2 the bound (7) holds.

For schedule Sk that satisfies (14), Theorem 3 claims that S H is the desired schedule,
provided that there is an optimal schedule in which job q has the same route as in Sk . Since
an optimal schedule is unknown and the problem is NP-hard, the conditions of Theorem 3
cannot be checked in polynomial time unless P = N P. Thus, in the worst case, it can
be assumed that the conditions of this theorem are never met, so that the route of job q in
schedule Sk is the opposite to the route of this job in any optimal schedule. This explains
why in Step 2(d) we create a new schedule Sk by changing back the route of job q, so that
the job becomes fixed. Note that any fixed job is assigned the same route as in any optimal
schedule.
We prove Theorem 3 in Section 6.
Suppose now that inequality (7) cannot be proved for schedule S H found by Algorithm 2.
We present another algorithm that converts schedule S H into a new schedule SG such that
the best of schedules S H and SG , i.e., the schedule S F = S H ∨ SG , satisfies
3
Cmax (S F ) ≤ Cmax (S ∗ ). (16)
2
Our second algorithm analyses a possible shape of schedule S H and involves transforma-
tions of that schedule if its length is equal to the makespan of an optimal flow shop schedule
of either the jobs in set P(S H ) or the jobs in set P̄(S H ).
Recall that schedule S H is found by running Algorithm 1 with P = P(S H ). Assume
that the length of S H is equal to the length of an optimal flow shop schedule of the jobs
14 STRUSEVICH, VAN DE WAART AND DEKKER

in set P(S H ). All jobs in P(S H ) are given the processing route (A, B). Without loss of
generality, we assume that these jobs are numbered in such a way that there are processed
on each machine according to the sequence (1, 2, . . . , r ), where r = |P(S H )|. The jobs
are sorted by Algorithm 1 in such a way that there exists a job v ∈ P(S H ) such that

a1 ≤ b1 , a2 ≤ b2 , . . . , av ≤ bv ; av+1 > bv+1 , av+2 > bv+2 , . . . , ar > br .

We call job v the changeover job. Besides, we define a critical job, which is a job
u ∈ P(S H ) that satisfies

X
u X
r
Cmax (S H ) = aj + bj . (17)
j=1 j=u

For the changeover job v it follows from Algorithm 1 that

a1 ≤ a2 ≤ · · · ≤ av , bv+1 ≥ bv+2 ≥ · · · ≥ br .

Also notice that the critical job cannot be started later without increasing the overall
makespan.
Suppose now that the length of S H is equal to the length of an optimal flow shop schedule of
the jobs in set P̄(S H ), and these jobs are processed according to the sequence (1, 2, . . . , ρ),
where ρ = | P̄(S H )|. Similarly as above, we may define the changeover job λ ∈ P̄(S H )
that satisfies

β1 ≤ α1 , β2 ≤ α2 , . . . , βλ ≤ αλ ; βλ+1 > αλ+1 , βλ+2 > αλ+2 , . . . , βρ > αρ ,

and

β1 ≤ β2 ≤ · · · ≤ βλ , αλ+1 ≥ αλ+2 ≥ · · · ≥ αρ ,

and define the critical job µ ∈ P̄(S H ) satisfying

X
µ X
ρ
Cmax (S H ) = βj + αj .
j=1 j=µ

Comparing the positions of the changeover job and the critical job is an important issue
for our final algorithm given below. The algorithm starts with schedule S H and creates
better schedules by changing either the route of the changeover job alone or the route of
each job between the changeover job and the critical job.
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 15

Algorithm 3 (Final Transformations)

INPUT: Schedule S H found by Algorithm 2

OUTPUT: Schedule S F satisfying (16)

1. If the length of schedule S H is equal to the total workload on machine A, then define
SG := S H and go to Step 5, otherwise go to Step 2.

2. If the length of schedule S H is equal to the length of an optimal flow shop schedule of
the jobs in set P(S H ), then go to Step 3, otherwise, go to Step 4.

3. If necessary, renumber the jobs of set P(S H ) in such a way that in schedule S H these
jobs are processed in the sequence (1, 2, . . . , r ), where r = |P(S H )|. In set P(S H ),
find the changeover job v and the critical job u.

(a) If u < v, then define SG := S H and go to Step 5, otherwise go to Step 3(b).

(b) If u = v, then change the route of job u, define P(SG ) := P(S H )\{u}. Find
schedule SG by running Algorithm 1 with P = P(SG ) and go to Step 5. Otherwise,
i.e., if u > v, go to Step 3(c).
(c) Define SG := S H . For each w from v + 1 to u do:
Change the route of job w, i.e., define P(S Hw ) := P(S H )\{w}. Find schedule S Hw
by running Algorithm 1 with P = P(S Hw ) and define SG := SG ∨ S Hw .
Go to Step 5.

4. If necessary, renumber the jobs of set P̄(S H ) in such a way that in schedule S H these
jobs are processed according to the sequence (1, 2, . . . , ρ), where ρ = | P̄(S H )|. In
set P̄(S H ), find the changeover job λ and the critical job µ.

(a) If µ > λ + 1, then define SG := S H and go to Step 5, otherwise go to Step 4(b).

(b) If µ = λ + 1, then change the route of job µ, define P(SG ) := P(S H ) ∪ {µ}. Find
schedule SG by running Algorithm 1 with P = P(SG ) and go to Step 5. Otherwise,
i.e., if µ ≤ λ, go to Step 4(c).
(c) Define SG := S H . For each w from µ to λ do:
Change the route of job w, i.e., define P(S Hw ) := P(S H ) ∪ {w}. Find schedule S Hw
by running Algorithm 1 with P = P(S Hw ) and define SG := SG ∨ S Hw .
Go to Step 5.

5. Define S F := S H ∨ SG . Stop.

Algorithm 3 requires no more than O(n 2 ) time. In Section 7 we prove that for schedule S F
found by Algorithm 3 the bound (16) holds.
16 STRUSEVICH, VAN DE WAART AND DEKKER

5. Analysis of Initial Transformations: A New Lower Bound

This section contains the proof of Theorem 2. We start with studying simple special cases
and proving some auxiliary statements. A general case is analyzed in Lemma 3.
In this section we use the following additional notation. Let S be one of the schedules Sk
found while running Algorithm 2. For a set Q ∈ {NAB , NBA } of jobs, let the subsets of all
changed, unchanged, and fixed jobs in S be denoted by Q c , Q d , and Q f , respectively. For
f
example, for some schedule S, NAB denotes the set of all fixed jobs of set NAB (in schedule S
these jobs are fixed at the same route (A, B) they have in schedule S0 ), while NBA c
denotes
the set of changed jobs of set NBA (these jobs in S have the route (A, B), other than the
route they have in S0 ).
It is straightforward to modify Algorithm 2 so that it will update the sets of changed,
unchanged and fixed jobs in each iteration. This, however, would make the algorithm
description unnecessarily complicated, especially given that all these sets are needed only
for the analysis of the algorithm. Fortunately, it is not difficult to recover all the required
sets based on the data available after each iteration.
For schedule Sk obtained after running k iterations of Algorithm 2 we know the set P(Sk )
and the set L k of jobs that have been removed from the list L. Then we can use the following
relations:
³ ´
f f
d
NAB = NAB \L k ; NAB = NAB ∩ P(Sk ) ∩ L k ; NAB c
= NAB \ NAB d
∪ NAB .

The sets of changed, unchanged and fixed jobs associated with the set NBA can be found
analogously.
Consider a schedule Sk found after k < |L| iterations of Algorithm 2. We want to prove
that this schedule provides a lower bound (15) on the length of an optimal schedule. Notice
c d f c d f
that for schedule Sk we know the sets NAB , NAB , NAB , NBA , NBA , and NBA . Denote
f f
N c = NAB
c
∪ NBA
c
, N d = NAB
d
∪ NBA
d
, N f = NAB ∪ NBA .

Recall that Algorithm 2 scans the jobs of set L according to the list L. We start with
considering some special cases for which the bound (15) can be derived easily.
First, we rule out the case when either set N d is empty or R j ≤ 0 for all j ∈ N d . In fact,
this would mean that the list L is empty, i.e., k = |L|.
Suppose that for schedule Sk we have N c = ∅. This implies that all jobs, for which an
attempt of changing the route has been made, are fixed. Then in schedule Sk all jobs have
the same route as in schedule S0 , i.e., P(Sk ) = P(S0 ) and P̄(Sk ) = P̄(S0 ). The desired
bound (15) follows from (5).
Consider now the case N c 6= ∅, assuming that Vj = 0 for all j ∈ N c . In this case, we
have that a(N c ) + b(N c ) = α(N c ) + β(N c ). Since in Sk the rest of the jobs have the same
route as in S0 , we obtain

T A (Sk ) + TB (Sk ) = T A (S0 ) + TB (S0 ),

and (15) follows from (5).

A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 17

Thus, we need to study the general case: N c 6= ∅ and Vj > 0 for at least one j ∈ N c ;
Nd 6= ∅ and R j > 0 for at least one j ∈ N d . P
For a non-empty set Q ⊆ N of jobs, denote R(Q) = j∈Q R j . The values U (Q) and
V (Q) are defined analogously. For Q = ∅, assume R(∅) = U (∅) = V (∅) = 0.
LEMMA 2 For schedule Sk , let Q c ⊆ N c and Q d ⊆ N d be some non-empty subsets of jobs
such that Vj > 0 for at least one j ∈ Q c and R j > 0 for at least one j ∈ Q d . Then
U (Q c ) U (Q d )
≥ . (18)
V (Q c ) V (Q d )

Proof: First, recall that Vj ≥ 0 for all jobs and R j > 0 for all j ∈ Q c . Thus, for a job
j ∈ Q d such that R j > 0 we have U j > 0. For a set Q of jobs, define

Q̃ = { j ∈ Q | R j > 0, Vj > 0}.

The lemma conditions say that both sets Q̃ c and Q̃ d are non-empty. Since the jobs in the
list L are sorted in non-increasing order of R j , it follows that
n o n o
min R j = U j /Vj | j ∈ Q̃ c ≥ max R j = U j /Vj | j ∈ Q̃ d .

It is well-known that for any four positive numbers a, b, c and d the inequality
a c
≥
b d
implies
a a+c c
≥ ≥ .
b b+d d
Therefore,
U ( Q̃ c ) U ( Q̃ d )
≥ min{R j = U j /Vj | j ∈ Q̃ c } ≥ max{R j = U j /Vj | j ∈ Q̃ d } ≥ .
V ( Q̃ c ) V ( Q̃ d )
Since either the set Q c \ Q̃ c is empty or U j > 0, Vj = 0 for all j ∈ Q c \ Q̃ c , we have

U (Q c ) U ( Q̃ c )
≥ .
V (Q )
c
V ( Q̃ c )
Moreover, since either the set Q d \ Q̃ d is empty, or U j ≤ 0, Vj ≥ 0 for all j ∈ Q d \ Q̃ d ,
we have
U ( Q̃ d ) U (Q d )
≥ ,
V ( Q̃ d ) V (Q d )
and (18) follows. This proves the lemma.

Now we are able to prove the desired statement.

18 STRUSEVICH, VAN DE WAART AND DEKKER

LEMMA 3 Let Sk be a schedule found after k < |L| iterations of Algorithm 2 such that
N c 6= ∅ and Vj > 0 for at least one j ∈ N c ; N d 6= ∅ and R j > 0 for at least one j ∈ N d .
Then the bound (15) holds.
Proof: Suppose that (15) does not hold. Then there exists an optimal schedule S ∗ such
that
1
T A (S ∗ ) ≤ Cmax (S ∗ ) < (T A (Sk ) + TB (Sk )),
2
∗ ∗ 1
TB (S ) ≤ Cmax (S ) < (T A (Sk ) + TB (Sk )), (19)
2
Summing this inequalities yields
T A (S ∗ ) + TB (S ∗ ) < T A (Sk ) + TB (Sk ). (20)
Observe that
f f
T A (Sk ) = a(NAB ) + a(NBA
c
) + a(NAB
d
) + α(NBA ) + α(NAB
c
) + α(NBA
d
). (21)
Similarly,
f f
TB (Sk ) = b(NAB ) + b(NBA
c
) + b(NAB
d
) + β(NBA ) + β(NAB
c
) + β(NBA
d
).
For a set of jobs Q ⊆ N c ∪ N d , let Q + define the subset of jobs of set Q such that their
route in Sk is the same as in S ∗ . Similarly, Q − denotes the subset of jobs of set Q which
have the route in Sk different from that in S ∗ . For example, all jobs of set NAB c
have the
route (B, A) in schedule Sk , and NAB consists of the jobs of set NAB which have the same
c+ c

route in schedule S ∗ . On the other hand, for example, all jobs of set NBA d
have the route
(B, A) in schedule Sk , and NBA consists of the jobs of set NBA which have the route (A, B)
d− d

in schedule S ∗ .
Recall that in schedule Sk the fixed jobs, i.e., the jobs of set N f , have the same route as
in schedule S ∗ .
In schedule S ∗ , the total workload on machine A can be written as
³ ´
T A (S ∗ ) = a NAB ∪ NBA
f c+
∪ NABd+
∪ NAB
c−
∪ NBAd−

³ ´
f
+ α NBA ∪ NBA c−
∪ NABd−
∪ NABc+
∪ NBAd+
.
Similarly, the total workload on machine B can be written as
³ ´
TB (S ∗ ) = b NAB ∪ NBA
f c+
∪ NAB
d+
∪ NAB
c−
∪ NBA
d−

³ ´
f
+ β NBA ∪ NBA c−
∪ NAB
d−
∪ NAB
c+
∪ NBAd+
.
Notice that
c+
a(NBA ) + α(NBA
c−
) = c
a(NBA ) + [α(NBA
c−
) − a(NBA
c−
)],
a(NAB ) + α(NAB )
d+ d−
= a(NAB ) + [α(NAB ) − a(NAB )],
d d− d−

c−
a(NAB ) + α(NAB
c+
) = α(NAB
c
) + [a(NAB
c−
) − α(NAB
c−
)],
a(NBA ) + α(NBA )
d− d+
= α(NBA ) + [a(NBA ) − α(NBA )].
d d− d−
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 19

Then we obtain
T A (S ∗ ) = a(NBA
c
) + [α(NBA
c−
) − a(NBA
c−
)] + a(NAB
d
) + [α(NAB
d−
) − a(NAB
d−
)]
+ α(NAB ) + [a(NAB ) − α(NAB )] + α(NBA ) + [a(NBA ) − α(NBA
c c− c− d d− d−
)]
f f
+ a(NAB ) + α(NBA ).

Due to (21), this implies that

£ ¤ £ ¤
T A (S ∗ ) = T A (Sk ) + α(NBA c−
) − a(NBA
c−
) + α(NABd−
) − a(NABd−
)
£ ¤ £ ¤
+ a(NAB c−
) − α(NAB c−
) + a(NBA
d−
) − α(NBAd−
) ,
which is equivalent to
£ ¤ £ ¤
T A (S ∗ ) = T A (Sk ) + U (NBA
c−
) + U (NAB
c−
) − U (NAB
d−
) + U (NBA
d−
) . (22)

Similarly, it can be shown that

£ ¤ £ ¤
TB (S ∗ ) = TB (Sk ) + β(NBA c−
) − b(NBA
c−
) + β(NAB d−
) − b(NABd−
)
£ ¤ £ ¤
+ b(NABc−
) − β(NAB c−
) + b(NBA
d−
) − β(NBA d−
) .

Thus, (20) reduces to

£ ¤
α(NBA
c−
) − a(NBA
c−
) + [α(NAB
d−
) − a(NAB
d−
)] + [a(NAB
c−
) − α(NAB
c−
)]
+ [a(NBA
d−
) − α(NBA
d−
)] + [β(NBA
c−
) − b(NBA
c−
)] + [β(NAB
d−
) − b(NAB
d−
)]
+ [b(NAB ) − β(NAB )] + [b(NBA ) − β(NBA )] < 0,
c− c− d− d−

which is equivalent to

V (NAB
d−
) + V (NBA
d−
) < V (NBA
c−
) + V (NAB
c−
). (23)

Note that, for schedule Sk , the inequality

T A (Sk ) ≥ TB (Sk )

holds. Substituting this into (19) yields

T A (S ∗ ) < T A (Sk ). (24)

Thus, (22) and (24) imply

U (NBA
c−
) + U (NAB
c−
) < U (NAB
d−
) + U (NBA
d−
). (25)

Since V (NAB
d−
) + V (NBA
d−
) ≥ 0 by definition, it follows from (23) that the set NBA
c−
∪ NAB
c−

is not empty and Vj > 0 for at least one j ∈ NBA ∪ NAB . On the other hand, since
c− c−

U (NBA
c−
) + U (NABc−
) > 0 by definition, it follows from (25) that the set NAB d−
∪ NBA
d−
is
not empty and U j > 0 for at least one j ∈ NAB ∪ NBA . Moreover, if Vj = 0 for a job
d− d−
20 STRUSEVICH, VAN DE WAART AND DEKKER

j ∈ NAB
d−
∪ NBAd−
such that U j > 0, then Vj = 0 for all j ∈ NBA
c−
∪ NAB
c−
, which is impossible.
Thus, there exists a job j ∈ NAB ∪ NBA with R j > 0. Therefore, Lemma 2 can be applied
d− d−

to the sets Q c = NBA

c−
∪ NAB
c−
and Q d = NABd−
∪ NBA
d−
, which gives

U (NBA
c−
) + U (NAB
c−
) U (NAB
d−
) + U (NBA
d−
)
c− ≥ . (26)
V (NBA ) + V (NAB )
c−
V (NAB ) + V (NBA )
d− d−

Observe that numerators and denominators of both fractions in (26) are strictly positive.
Comparing (26) with (23) we come to the inequality

U (NBA
c−
) + U (NAB
c−
) ≥ U (NAB
d−
) + U (NBA
d−
),

which contradicts (25). The lemma is proved.

Arguments presented in this section prove Theorem 2.

6. Analysis of Initial Transformations: Fixing the Routes of the Jobs

In this section we prove Theorem 3. Recall that the conditions of Theorem 3 cannot be
checked in polynomial time unless P = N P, so that in the worst case we assume that
they are never met. Therefore we use this theorem to justify the fact that in Step 2(d) of
Algorithm 2 the route of job q is changed back and that job becomes fixed.
We start with some auxiliary statements. The general case is analyzed in Lemma 6.
q
LEMMA 4 For some q ∈ N , let S0 be a schedule obtained from schedule S0 by changing the
q
route of job q. Then for any schedule S in which job q has the same route as in schedule S0
the inequality

1 q q
Cmax (S) ≥ (T A (S0 ) + TB (S0 )) (27)
2

holds.
q
Proof: Without loss of generality, assume that in schedule S0 job q has the route (B, A),
i.e., q ∈ P(S0 ) = NAB and the route of job q has been changed from (A, B) to (B, A);
otherwise the proof is symmetric.
q
Schedule S0 is obtained in such a way that
q q
T A (S0 ) + TB (S0 ) = a(NAB ) − aq + b(NAB ) − bq + α(NBA ) + αq + β(NAB ) + βq .

Since q ∈ NAB , it is easy to observe that

X
a(NAB ) − aq + b(NAB ) − bq + α(NBA ) + β(NAB ) = min{a j + b j , α j + β j },
j∈N \{q}
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 21

so that
q q
X
T A (S0 ) + TB (S0 ) = αq + βq + min{a j + b j , α j + β j }.
j∈N \{q}

Take any schedule S in which job q has the route (B, A). We have that
à !
1 1 X
Cmax (S) ≥ (T A (S) + TB (S)) ≥ αq + βq + min{a j + b j , α j + β j } ,
2 2 j∈N \{q}

and the desired bound (27) holds.

LEMMA 5 Let S be a schedule such that

T A (S) < 3TB (S)

and
1
Cmax (S ∗ ) ≥ (T A (S) + TB (S)).
2
Then
1
TB (S) ≤ Cmax (S ∗ ).
2

Proof: It is obvious that 4TB (S) < T A (S) + TB (S) ≤ 2Cmax (S ∗ ).

LEMMA 6 For some iteration k ≤ |L| of Algorithm 2, let Sk be the schedule obtained from
Sk−1 by changing the route of a job q. If Sk satisfies (14), and there exists an optimal
schedule S ∗ in which job q has the same route as in schedule Sk , then the inequality
q
Cmax (Sk ∨ S0 ) 3
∗
≤ (28)
Cmax (S ) 2
holds.
Proof: Without loss of generality, assume that schedule Sk is obtained from schedule Sk−1
by changing the route of job q ∈ P̄(Sk ), i.e., the route of job q has been changed from
(A, B) to (B, A); otherwise the proof is symmetric. Observe that Algorithm 2 guarantees
that

T A (Sk−1 ) > 3TB (Sk−1 ), (29)

and due to Theorem 2, the inequality

1
Cmax (S ∗ ) ≥ (T A (Sk−1 ) + TB (Sk−1 )) (30)
2
holds.
22 STRUSEVICH, VAN DE WAART AND DEKKER

Examine a possible shape of schedule Sk . Recall that aq > αq , and bq < βq . If the length
of Sk is equal to the total workload on some machine, then this must be machine B due to
(14), so that

Cmax (Sk ) = TB (Sk−1 ) + βq − bq .

By Lemma 5, it follows from (30) and (29) that

1
TB (Sk−1 ) ≤ Cmax (S ∗ ). (31)
2
By the conditions of this lemma, in schedule S ∗ job q has the route (B, A), therefore

αq + βq ≤ Cmax (S ∗ ). (32)

Summing up (31) and (32) we obtain

3
Cmax (Sk ) = TB (Sk−1 ) + βq − bq ≤ Cmax (S ∗ ),
2
which corresponds to (28).
Let C1 and C2 denote the length of an optimal (flow shop) schedule of the jobs in set P(Sk )
and of those in set P̄(Sk ), respectively. Consider the situation Cmax (Sk ) = max{C1 , C2 }.
Case 1. Suppose that

TB (Sk ) ≤ Cmax (S ∗ ). (33)

It follows from (14) and (33) and

T A (Sk ) < Cmax (S ∗ ),

implying

a(P(Sk )) < Cmax (S ∗ ) (34)

and

α( P̄(Sk )) = α( P̄(Sk−1 )) + αq < Cmax (S ∗ ). (35)

Case 1.1. Cmax (Sk ) = C1 . Due to (31) and (34), we have

Cmax (Sk ) ≤ a(P(Sk )) + b(P(Sk )) = a(P(Sk )) + b(P(Sk−1 )) − bq
≤ a(P(Sk )) + TB (Sk−1 ) ≤ 32 Cmax (S ∗ ).
Case 1.2. Cmax (Sk ) = C2 .
Recall (see Algorithm 1) that in schedule Sk machine A processes the jobs according
to the sequence (ϕ(P(Sk )), ψ( P̄(Sk ))), while machine B processes the jobs according
to the sequence (ψ( P̄(Sk )), ϕ(P(Sk ))). Introduce a new schedule Sk0 in which the jobs
are processed on machine A according to the sequence (ϕ(P(Sk )), π( P̄(Sk−1 )), q) and
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 23

on machine B according to the sequence (π( P̄(Sk−1 )), q, ϕ(P(Sk ))), where π( P̄(Sk−1 ))
denotes an arbitrary permutation of the jobs of set P̄(Sk−1 ). Observe that the length of
schedule Sk0 is still equal to the length of an optimal flow shop schedule of the jobs in
set P̄(Sk ), and Cmax (Sk0 ) ≥ Cmax (Sk ). It is easy to verify that

Cmax (Sk0 ) ≤ β( P̄(Sk−1 )) + max{α( P̄(Sk−1 )), βq } + αq .

Due to (31), (32) and (35) we conclude that

Cmax (Sk ) Cmax (Sk0 ) 3
∗
≤ ≤ .
Cmax (S ) Cmax (S ∗ ) 2
Case 2. Suppose now that

TB (Sk ) > Cmax (S ∗ ).

Since TB (Sk ) = TB (Sk−1 ) + βq − bq , it follows from (31) that

1
βq > Cmax (S ∗ ). (36)
2
q
We show that for schedule S0 the bound
q
Cmax (S0 ) 3
∗
≤ (37)
Cmax (S ) 2
holds.
q
Again, examine four possible shapes of schedule S0 . Recall that Lemma 4 implies that
2Cmax (S ∗ ) ≥ T A (S0 ) + TB (S0 ) = a(NAB ) − aq + b(NAB ) − bq
q q

+ α(NBA ) + αq + β(NBA ) + βq . (38)

q q
IfCmax (S0 ) = T A (S0 )
= a(NAB ) − aq + α(NBA ) + αq then (37) directly follows from
(36) and (38).
q q
Suppose that Cmax (S0 ) = TB (S0 ) = b(NAB )−bq +β(NBA )+βq . By Lemma 5, it follows
from (5) and (11) that
1
TB (S0 ) = b(NAB ) + β(NBA ) ≤ Cmax (S ∗ ). (39)
2
This together with (32) implies (37).
q
Suppose that the length of S0 is equal to the length of an optimal flow shop schedule of
q q
the jobs in set P(S0 ) = NAB \{q}. In this case, Cmax (S0 ) ≤ a(NAB ) − aq + b(NAB ) − bq .
The desired bound (37) directly follows from (38) and (36).
q
At last, suppose that the length of S0 is equal to the length of an optimal flow shop
q
schedule of the jobs in set P̄(S0 ) = NBA ∪ {q}. Consideration similar to the one applied to
q q
Case 1.2 of this proof shows that either Cmax (S0 ) ≤ β(NBA ) + αq + α(NBA ) or Cmax (S0 ) ≤
β(NBA ) + αq + βq . In the former case, (37) directly follows from (36) and (38). In the
latter case, (37) follows from (32) and (39). This proves the lemma.
24 STRUSEVICH, VAN DE WAART AND DEKKER

7. Analysis of Final Transformations

In this section we study the worst-case performance of Algorithm 3.

THEOREM 4 For schedule S F found by Algorithm 3, the bound (16) holds, and this bound
is tight.
Proof: Throughout the proof, it is assumed that
3
Cmax (S H ) > Cmax (S ∗ ). (40)
2
Then schedule S H satisfies (8)–(10). Examine a possible shape of this schedule.
If the length of S H is equal to the total workload on some machine, then this machine
must be machine A due to (8). Thus, Cmax (S H ) = T A (S H ) (see Step 1 of Algorithm 3).
Then it follows from (10) and (40) that
3
T A (S H ) > (T A (S H ) + TB (S H )).
4
This inequality implies T A (S H ) > 3TB (S H ), which contradicts (9). Therefore, (16) holds
with S F = S H .
Consider now the situation that the length of S H is equal to the length of an optimal flow
shop schedule of either the jobs in set P(S H ) or the jobs in set P̄(S H ). We concentrate on
the first case. The other case can be treated in a symmetric way.
Since a(P(S H )) + b(P(S H )) ≤ T A (S H ) + TB (S H ), it follows from (10) that

a(P(S H )) + b(P(S H )) ≤ 2Cmax (S ∗ ). (41)

Moreover, (8) and (41) imply that

b(P(S H )) ≤ Cmax (S ∗ ), (42)

while (9) and (41) imply that

3
a(P(S H )) ≤ Cmax (S ∗ ). (43)
2
Let r , u and v be the jobs defined in Step 3 of Algorithm 3.
Case 1. u ≤ v.
Since a j ≤ b j , j = 1, 2, . . . , u − 1, it follows that

X
u X
r X
u−1 X
r
Cmax (S H ) = aj + b j ≤ au + bj + b j = au + b(P(S H )). (44)
j=1 j=u j=1 j=u

If u < v (see Step 3(a)), then due to (41) we have that

au + bu + av + bv ≤ 2Cmax (S ∗ ).
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 25

Since au ≤ min{bu , av , bv }, we derive that au ≤ 12 Cmax (S ∗ ). Due to (42) and (44), it

follows that (16) holds for S F = S H .
If u = v (see Step 3(b)), then it follows from (40), (42) and (44) that au > 12 Cmax (S ∗ ).
Since bu ≥ au , we have that

au + bu > Cmax (S ∗ ). (45)

Therefore, due to (2), in any optimal schedule job u has the route (B, A), so that

αu + βu ≤ Cmax (S ∗ ). (46)

Moreover, (40) implies that

X
r X
u−1
1
aj + b j + α( P̄(S H )) + β( P̄(S H )) < Cmax (S ∗ ). (47)
j=u+1 j=1
2

Transform schedule S H into a new schedule SG as described in Step 3(b). Examine a

possible shape of SG .
If the length of schedule SG is equal to the length of an optimal flow shop schedule of the
jobs in set P(SG ), then

Cmax (SG ) ≤ a(P(SG )) + b(P(SG )) = a(P(S H )) + b(P(S H )) − (au + bu ).

The length of this schedule is less than the optimal value due to (41) and (45). Thus, this
case is not possible.
In the other cases, we have

Cmax (SG ) ≤ max{T A (SG ), TB (SG ), α( P̄(SG )) + β( P̄(SG ))}.

This is equivalent to
(
Xu−1 X
r
Cmax (SG ) ≤ max aj + a j + α( P̄(S H )) + αu ,
j=1 j=u+1

X
u−1 X
r
bj + b j + β( P̄(S H )) + βu ,
j=1 j=u+1
¾
α( P̄(S H )) + β( P̄(S H )) + (αu + βu ) .
26 STRUSEVICH, VAN DE WAART AND DEKKER

Since a j ≤ b j , j = 1, 2, . . . , u − 1, and a j > b j , j = u + 1, u + 2, . . . , r , we derive that

(
Xu−1 Xr X
u−1 X r
Cmax (SG ) ≤ max bj + a j + α( P̄(S H )) + αu , bj + aj
j=1 j=u+1 j=1 j=u+1
¾
+ β( P̄(S H )) + βu , α( P̄(S H )) + β( P̄(S H )) + (αu + βu ) ,

and (16) follows from (46) and (47).

Case 2. u > v.
The definition of job v implies that

X
v X
v X
u−1 X
r X
r
aj ≤ bj ≤ bj , bj ≤ aj .
j=1 j=1 j=1 j=u+1 j=u+1

Since we assume that (40) holds, it follows that (47) also holds, and we derive from the
above inequalities that
X
v X
r
1
aj + bj ≤ Cmax (S ∗ ).
j=1 j=u+1
2

Due to (17) and (40), this implies that

X
u
a j + bu > Cmax (S ∗ ).
j=v+1

Thus, we conclude that there exists a job w ∈ {v + 1, v + 2, . . . , u} such that in some

optimal schedule this job has the route (B, A).
Let w be such a job, eventually found while running the loop in Step 3(c). Consider a
schedule S Hw obtained from S H by changing the route of job w. Observe that

αw + βw ≤ Cmax (S ∗ ). (48)

Examine the four possible shapes of schedule S H .

First, suppose that the length of schedule S Hw is equal to the total workload on machine A,
so that

Cmax (S Hw ) ≤ T A (S H ) − aw + αw .

Two subcases are possible:

Case 2.1. aw ≥ αw ;
Case 2.2. For each job j ∈ {v + 1, v + 2, . . . , u} either aw < αw or job j in any optimal
schedule has the route (A, B), which implies
X
u
a j + αw − aw ≤ Cmax (S ∗ ). (49)
j=v+1
A 3/2 ALGORITHM FOR TWO-MACHINE OPEN SHOP 27

For Case 2.1, we have Cmax (S Hw ) ≤ T A (S H ), i.e., due to (43), we conclude that (16) holds
with S F = S Hw .
For Case 2.2, due to a j ≤ b j , j = 1, 2, . . . , v, we have that
X
v X
r
Cmax (S Hw ) ≤ bj + a j − aw + α( P̄(S H )) + αw
j=1 j=v+1

X
u−1 X
u X
r
≤ bj + aj + a j − aw + α( P̄(S H )) + αw .
j=1 j=v+1 j=u+1

Combining (47) and (49), we conclude that (16) holds with S F = S Hw .

Suppose now that the length of schedule S Hw is equal either to the total workload on
machine B or to the length of an optimal flow shop schedule of the jobs in set P̄(S Hw ). We
have that

Cmax (S Hw ) ≤ max{TB (S H ) − bw + βw , α( P̄(S H )) + β( P̄(S H )) + (αw + βw )}.

Since bw ≥ bu and a j > b j , j = u + 1, u + 2, . . . , r , it follows that

X
u−1 X
r
TB (S H ) − bw ≤ TB (S H ) − bu = bj + b j + β( P̄(S H ))
j=1 j=u+1

X
u−1 X
r
≤ bj + a j + β( P̄(S H )).
j=1 j=u+1

Thus,
(
Xu−1 X
r
Cmax (S Hw ) ≤ max bj + a j + β( P̄(S H )) + βw ,
j=1 j=u+1
¾
α( P̄(S H )) + β( P̄(S H )) + αw + βw ,

and, due to (47) and (48), we conclude that (16) holds with S F = S Hw .
Finally, suppose that the length of schedule S Hw is equal to the length of an optimal flow
shop schedule of the jobs in set P(S Hw ). Since schedule S H is of the same shape, we derive
Cmax (S Hw ) ≤ Cmax (S H ) − min{aw , bw } = Cmax (S H ) − bw
Xu Xr
≤ Cmax (S H ) − bu = aj + b j ≤ a(P(S H )).
j=1 j=u+1

Thus, due to (43), we conclude that (16) holds with S F = S Hw .

To prove the tightness of the established ratio bound, consider the following instance of
the problem. There are four identical jobs such that for each job j the processing times are
a j = 1, b j = 0, α j = 0, β j = 1. It is clear that NAB = {1, 2, 3, 4}, and Algorithm 1 finds
schedule S0 of length 4. In our case, L = {1, 2, 3, 4} and Algorithm 2 changes the route for
one job only, e.g., job 1. The resulting schedule has the length 3. Since the total workload
28 STRUSEVICH, VAN DE WAART AND DEKKER

on machine A determines the length of this schedule, no further changes are to be made by
Algorithm 3. On the other hand, there exists an optimal schedule with the length 2.
This proves the theorem.

8. Final Remarks

This paper considers the two-machine open shop scheduling problem with route-dependent
processing times, which generalizes the two-stage job shop as well as the scheduling model
with two unrelated parallel machines. The main result of this paper is a heuristic algorithm
which runs in at most O(n 2 ) time and creates a schedule with the length that is no more than
3/2 times the optimum value. This ratio bound compares favorably with approximation
results for the relevant scheduling models. We believe that this paper may initiate further
study of scheduling problems with route-dependent processing times.

Acknowledgments

The authors are grateful to the anonymous referees whose comments have contributed into
improving the presentation.
Research of the first author was partly supported by the International Association for the
Promotion of Cooperation with Scientists from the Independent States of the Former Soviet
Union, INTAS-93-257.

References

Adiri, I., and N. Amit. (1983). “Route-Depended Open-Shop Scheduling,” IIE Transactions 15, 231–234.
Chen, B., and V. A. Strusevich. (1993). “Approximation Algorithms for Three Machine Open Shop Scheduling,”
ORSA Journal on Computing 5, 321–326.
Gonzalez, T., and S. Sahni. (1976). “Open Shop Scheduling to Minimize Finish Time,” Journal of the Association
for Computing Machinery 23, 665–679.
Jackson, J. R. (1956). “An Extension of Johnson’s Results on Job Lot Scheduling,” Naval Research Logistics
Quarterly 3, 201–203.
Johnson, S. M. (1954). “Optimal Two- and Three-Stage Production Schedules with Set-Up Times Included,”
Naval Research Logistics Quarterly 1, 61–68.
Karp, R. M. (1972). “Reducibility Among the Combinatorial Problems.” In R. E. Miller and J. W. Thatcher (eds.),
Complexity of Computer Computation, pp. 85–103. New York: Plenum Press.
Lawler, E. L., J. K. Lenstra, A. H. G. Rinnooy Kan, and D. B. Shmoys. (1993). “Sequencing and Scheduling:
Algorithms and Complexity.” In S. C. Graves, A. H. G. Rinnooy Kan, and P. Zipkin (eds.), Handbooks in
Operations Research and Management Science, Vol. 4: Logistics of Production and Inventory, pp. 445–522.
Amsterdam: North-Holland.
Potts, C. N. (1985). “Analysis of a Linear Programming Heuristic for Scheduling Unrelated Parallel Machines.”
Discrete Applied Mathematics 10, 155–164.
Sevast’janov, S. V., and G. J. Woeginger. (1998). “Makespan Minimization in Open Shops: A Polynomial
Time Approximation Scheme.” Report SFB68, TU Graz, Austria, to appear in Mathematical Programming 82,
191–198.
Shmoys, D. B., C. Stein, and J. Wein. (1994). “Improved Approximation Algorithms for Shop Scheduling
Problems.” SIAM Journal on Computing 23, 617–632.
Tanaev, V. S., Y. N. Sotskov, and V. A. Strusevich. (1994). Scheduling Theory: Multi-Stage Systems. Dordrecht:
Kluwer Academic Publishers.
Williamson, D. P., L. A. Hall, J. A. Hoogeveen, C. A. J. Hurkens, J. K. Lenstra, S. V. Sevast’janov, and D. B. Shmoys.
(1997). “Short Shop Schedules.” Operations Research 45, 288–294.