26
MATHEMATICAL PERGAMON Mathematical and Computer Modelling 29 (1999) 101-126 COMPUTER MODELLING A Comparison of Heuristic Algorithms for Flow Shop Scheduling Problems with Setup Times and Limited Batch Size D. DANNEBERG, T. TAUTENHAHN AND F. WERNER Otto-von-Guericke-Universitat Magdeburg, PSF 4120 39016 Magdeburg, Germany (Received and accepted September 1998) Abstract-In this paper, we propose different heuristic algorithms for flow shop scheduling prob- lems, where the jobs are partitioned into groups or families. Jobs of the same group can be processed together in a batch but the maximal number of jobs in a batch is limited. A setup is necessary before starting the processing of a batch, where the setup time depends on the group of the jobs. In this paper, we consider the case when the processing time of a batch is given by the maximum of the processing times of the operations contained in the batch. As objective function we consider the makespan as well as the weighted sum of completion times of the jobs. For these problems, we pro- pose and compare various constructive and iterative algorithms. We derive suitable neighbourhood structures for such problems with batch setup times and describe iterative algorithms that are based on different types of local search algorithms. Except for standard metaheuristics, we also apply mul- tilevel procedures which use different neighbourhoods within the search. The algorithms developed have been tested in detail on a large collection of problems with up to 120 jobs. @ 1999 Elsevier Science Ltd. All rights reserved. Keywords-Flow shop scheduling, Setup times, Insertion algorithms,Local search, Multilevel heuristics. 1. INTRODUCTION In scheduling theory, the flow shop problem has been intensely studied: n jobs 1,. . . , n have to be processed on m machines Ml,. . . , Mm successively in this order. The processing of a job i on machine Mj is called an operation and the processing times of all operations are given in advance. Each machine can handle only one job at a time. Pre-emption of an operation is not allowed. In the case of a permutation flow shop problem, all jobs are assumed to be processed on each machine in the same order, i.e., a schedule is determined by a permutation p of all jobs. In most papers, the objective is to minimize the makespan Cm,,, i.e., the completion time Ci of job i completed last. This problem is usually denoted as F//Cmax [l] or, to indicate that the permutation flow shop problem is considered, as PF//C,,,. For the case of two machines (m = 2), th e ro p bl em can be solved by the O(nlogn) algorithm given by Johnson [2]. However, slight generalizations of this problem already lead to NP-hard problems [3]. Therefore, several Supported by Deutsche Forschungsgemeinschaft (Project ScheMA) and by the International Association for the Promotion of Cooperation with Scientists from the Independent States of the Former Soviet Union (Project INTAS-93-257). 0895-7177/99/g - see front matter. @ 1999 Elsevier Science Ltd. All rights reserved. PII: SO895-7177(99)00085-O Typeset by .A&x-TFX

A comparison of heuristic algorithms for flow shop scheduling problems with setup times and limited batch size

Embed Size (px)

Citation preview

MATHEMATICAL

PERGAMON Mathematical and Computer Modelling 29 (1999) 101-126

COMPUTER MODELLING

A Comparison of Heuristic Algorithms for Flow Shop Scheduling Problems with Setup

Times and Limited Batch Size

D. DANNEBERG, T. TAUTENHAHN AND F. WERNER Otto-von-Guericke-Universitat Magdeburg, PSF 4120

39016 Magdeburg, Germany

(Received and accepted September 1998)

Abstract-In this paper, we propose different heuristic algorithms for flow shop scheduling prob- lems, where the jobs are partitioned into groups or families. Jobs of the same group can be processed together in a batch but the maximal number of jobs in a batch is limited. A setup is necessary before starting the processing of a batch, where the setup time depends on the group of the jobs. In this paper, we consider the case when the processing time of a batch is given by the maximum of the processing times of the operations contained in the batch. As objective function we consider the makespan as well as the weighted sum of completion times of the jobs. For these problems, we pro- pose and compare various constructive and iterative algorithms. We derive suitable neighbourhood structures for such problems with batch setup times and describe iterative algorithms that are based on different types of local search algorithms. Except for standard metaheuristics, we also apply mul- tilevel procedures which use different neighbourhoods within the search. The algorithms developed have been tested in detail on a large collection of problems with up to 120 jobs. @ 1999 Elsevier Science Ltd. All rights reserved.

Keywords-Flow shop scheduling, Setup times, Insertion algorithms, Local search, Multilevel

heuristics.

1. INTRODUCTION

In scheduling theory, the flow shop problem has been intensely studied: n jobs 1,. . . , n have to

be processed on m machines Ml,. . . , Mm successively in this order. The processing of a job i

on machine Mj is called an operation and the processing times of all operations are given in

advance. Each machine can handle only one job at a time. Pre-emption of an operation is not

allowed. In the case of a permutation flow shop problem, all jobs are assumed to be processed

on each machine in the same order, i.e., a schedule is determined by a permutation p of all jobs.

In most papers, the objective is to minimize the makespan Cm,,, i.e., the completion time Ci

of job i completed last. This problem is usually denoted as F//Cmax [l] or, to indicate that

the permutation flow shop problem is considered, as PF//C,,,. For the case of two machines

(m = 2), th e ro p bl em can be solved by the O(nlogn) algorithm given by Johnson [2]. However,

slight generalizations of this problem already lead to NP-hard problems [3]. Therefore, several

Supported by Deutsche Forschungsgemeinschaft (Project ScheMA) and by the International Association for the Promotion of Cooperation with Scientists from the Independent States of the Former Soviet Union (Project INTAS-93-257).

0895-7177/99/g - see front matter. @ 1999 Elsevier Science Ltd. All rights reserved.

PII: SO895-7177(99)00085-O Typeset by .A&x-TFX

102 D. DANNEBERG et al.

branch and bound algorithms and heuristics have been developed for problem PF//Cmax (ef.

for instance [4-161). In the case when the sum of completion times has to be minimized, only

a few results are available. Here the two-machine problem is already NP-hard [17]. A branch

and bound algorithm for problem F2// C Ci is given in [18]. A review of flow shop sequencing

research has been given in [ 191.

In connection with flexible manufacturing cells, usual setup times or change-over costs between

the processing of certain jobs on the machines have to be considered. Jobs are classified into

different groups or families and jobs of the same group can be processed together in a batch. A

setup time is required before a batch starts with its processing. Up to now, mostly one-machine

or parallel machine batch problems have been considered in the literature (cf. for instance [20] for

an overview or [21-251). In [26], the permutation flow shop problem with setup times has been

studied, where the processing time of a batch is equal to the sum of the processing times of the

operations in this batch (sum-time batch problem). For such problems, constructive and iterative

algorithms have been proposed and compared. Some recent trends in scheduling research to make

it more relevant and applicable in operations management and manufacturing systems have been

given in [27].

In this paper, we deal with permutation flow shop problems with setup times, where the groups

to be processed are known in advance, i.e., we have a static flow-line (cf. [28]). We consider batch

processing problems, where the processing time of a batch is equal to the maximum of the

processing times of the operations contained in the batch. Additionally, the maximal number

of jobs contained in the batch is limited. Such type of problems may arise in connection with

different technologies (e.g., when coloring several products together in a batch). In contrast to

the sum-time batch problems mentioned above, we denote the latter problems as maz-time batch

problems. The remainder of the paper is organized as follows. In Section 2, we describe the problems con-

sidered in detail. In Section 3, we derive some constructive heuristics. In Section 4, we describe

iterative algorithms based on neighbourhood search techniques. Mainly, we consider the question

of determining suitable neighbourhoods for such problems but we also include various metaheuris-

tics and multilevel search. Finally, in Section 5, detailed and comparative computational results

are given.

2. THE PROBLEM

In this paper, we consider the following permutation flow shop scheduling problem with batch

processing: n jobs are partitioned into g groups Gi, . . . , G,. Each job has to be processed on m

machines in the same order, namely according to the numbering of the machines. Times tij > 0

for processing job i on machine IVlj are given. Jobs are processed within batches. A batch consists

of one or more jobs of the same group which are processed together on all machines. However,

the maximal number of jobs contained in a batch is limited by a given parameter mbsize. In

addition to identical batches on all machines, we assume that the same batch sequence is chosen

on each machine.

Moreover, there are given setup times srj _ > 0 on machine Mj which occur before a batch with

jobs of group G, is started. The setup times are assumed to be sequence independent, i.e., they

do not depend on the group of the preceding batch.

The problem setting described above assumes batch availability (ba) of the jobs, i.e., the pro-

cessing time of a batch on a machine can start when

l the processing of the preceding batch on this machine has been finished and a setup has

been done, and

l the processing of this batch on the preceding machine has been completed.

The processing time (or length) of a batch on a machine is given by the longest processing time

of an operation contained in this batch. The completion time of a batch, i.e., the completion

Heuristic Algorithms 103

time of all operations contained in the batch, is equal to the starting time of the batch plus the processing time of this batch. Thus, if the batches have been formed, the problem reduces to a permutation flow shop problem with jobs (representing the batches) and setup times.

In this paper, we always assume anticipatory setup times, where the setup can start before the processing of the batch on the preceding machine is finished, i.e., the setup can be done ‘in anticipation’ of the job. Note that nonanticipatory setup times when the setup cannot start until the processing of this batch on the preceding machine is finished, are not of interest for the problem considered in this paper, since one could include the setup time into the processing time

of each operation.

Similarly as in [26], we consider objective functions which are based on the completion times Ci of the jobs. In particular, we minimize the makespan C,,, or the weighted sum of completion times C WiCi.

For the problem under consideration, a feasible solution is described by a batch sequence

7r = (7ri,7r2,..., Q), where 7ri,7r2,. . . , TTk are pairwise disjoint batches such that each batch contains no more than mbsize jobs, and the union of all job sets of the batches is equal to the set of all n jobs. Such a batch sequence can be graphically illustrated in a similar way as for

the classical permutation flow shop problem. A convenient representation of a batch sequence x

is the directed graph G(r), where the vertex set is the set of batches (ri,j) (representing the processing of batch ~i on machine &‘j) including a set of m fictitious batches (0,j) (representing an artificial initial operation on each machine belonging to batch 0) (1 5 j 5 m). There are arcs

between two successive batches on the same machine including an arc from the fictitious batch 0 to the first batch on each machine as well as arcs between the vertices belonging to the same batch and immediately succeeding machines. The arcs belonging to the same machine have arc

weights equal to the setup time of the group of the batch of the end vertex of the arc on the corresponding machine. Arcs belonging to the same batch have the arc weight 0. To each batch (ni, j), its processing time is assigned to the corresponding vertex and fictitious batches have the vertex weight 0. The makespan value C,,, is given by the length of a longest (i.e., critical) path

in G(r).

3. CONSTRUCTIVE ALGORITHMS

For the permutation flow shop problem without consideration of setup times, often priority rules have been used. Another approach is to transform the original problem into one or several artificial two-machine problems (see for instance [4]), which can be solved using the algorithm by Johnson [2]. However, the probably best known constructive algorithm is the insertion algorithm given by Nawaz et al. [8]. Werner and Winkler [29] and Braise1 et al. [30] refined this procedure for other shop scheduling problems and in both papers the beam search idea [31] is also used.

For the problem under consideration, we apply a two-stage insertion algorithm for the con- structive solution. In a first stage, we determine suitable batches of jobs of the individual groups by successively inserting jobs into the current batch. Then, in a second stage, we determine the sequence of the batches by applying an insertion algorithm to the batches that have been formed.

In the first stage, batches of maximal cardinality are formed, except possibly one batch of each group which could contain less than mbsize jobs. First, we deal with the C,,, criterion. We consider each group consecutively and we apply the following variants.

(a) Starting with the job having the smallest sum of processing times, we include further jobs into this batch such that the increase in the sum of the lengths of the batches for the m machines is as small as possible in each case. After having formed the first batch of a group, we look among the remaining jobs for one having the smallest sum of processing times and continue this procedure until all batches have been formed. In this variant, all batches except possibly the last one of each group contain mbsize jobs.

104

(b)

Cc)

D. DANNEBERG et al.

We apply the same procedure as in (a) but all batches except possibly the first one contain mbsize jobs. In this variant, it has to be first determined how many jobs have to be included into the first batch.

Let

be the slack time of batch Xk on machine Mj. Starting with the job having the greatest sum of processing times, we include further jobs into this batch such that the increase in the sum of the slack times of this batch on the m machines is as small as possible in each step. Again, after having filled the first batch of a group, we look among the remaining jobs for one having the greatest sum of processing times and continue this procedure until all batches have been formed. All batches except possibly the last one of each group

contain mbsize jobs.

Next, we consider objective function CwiCi+ As it turned out for other problems with this criterion [26], the consideration of the weights in fixing an insertion order turned out to be

preferable. Recall that for the one-machine problem with this objective function, it is optimal to sequence the jobs according to nonincreasing ratios wilti of the jobs. This suggests the following

procedure for forming the batches of the groups. We start with the job with the largest ratio

wilLi, where Li is the sum of the lengths of the current batch containing this job over all machines, i.e., at the beginning it is equal to the sum of the processing times of this job. Then we include that job of the same group into the batch for which the ratio of the average weight of the jobs in the resulting batch and the actualized value of Li is as large as possible. This is continued until the first batch contains mbsize jobs. Among the remaining jobs of the same group, we look again for the job with the largest ratio WilLi and we proceed until all batches are filled. This procedure can be used again in such a way that at most either the first or the last

batch contains less than mbsize jobs (see above Variants (a) and (b) for Cmax). In the second stage, we apply a standard insertion procedure to calculate the sequence of

batches. As insertion order, we tested the following variants for criterion Cmax:

(01) (02)

(03)

(04)

insert the batches according to nonincreasing sums of their lengths; insert the batches according to order 01 but groupwise, i.e., consider first the batch with the largest sum of its lengths and then from the same group the batch with the second largest sum and only if all batches of the same group are inserted, we start with the next batch of another group having the largest sum of its lengths; insert the batches according to nondecreasing sums of the lengths of the batches; insert the batches according to order 03 but groupwise.

Insertion order 01 is a generalization of that proposed by Nawaz et al. [8] for the classical permutation flow shop problem. The groupwise insertion orders are considered since for other

problem types this had led partially to better results due to the same setup times of all batches

of a group (see [26,32]). For criterion C WiCi, we considered additionally the following insertion orders:

(05) insert the batches according to nonincreasing weights; (06) insert the batches according to order 05 but groupwise; (07) insert the batches according to nonincreasing ratios Wi/Liy where Wi is the sum of the

weights of the jobs contained in this batch; (08) insert the batches according to order 07 but groupwise.

For comparison purposes, we also implemented an insertion order 09 which is randomly gen- erated.

The complexity of forming the batches is O(n2m) for all variants and the determination of the batch sequence by the insertion procedure can be done in 0(n2a) time, where a = [n/mbsize] + k is the maximum number of batches formed in the first step.

Heuristic Algorithms 105

Insertion order 07 can be considered as a generalization of Smith’s rule [33] to the problem under consideration. Applying this ratio, it seems to be very unlikely that batches with a small

ratio should be put at the first positions at the batch sequence. Therefore, it seems reasonable to apply for this criterion a restricted insertion algorithm, where the currently inserted batch is only considered as a candidate for the last u positions in the actual partial batch sequence.

Thus, for a constant value of U, instead of 0(n2) partial sequences one has only to evaluate O(n) partial sequences. We denote this variant as algorithm Ins (Ok, u), where Ok represents the

chosen insertion order (if parameter u is omitted, all positions are considered for insertion). For illustration, consider the following example. Assume that n = 10 jobs are given belonging

to two groups Gi = { 1,2,3,4,5,6} and Gz = { 7,8,9, lo} which have to be processed on m = 3 machines. Let mbsize = 3. The given setup times s,.j are as follows: sir = 10, ~12 = 4, s13 = 5,

~21 = 10, ~22 = 7, and ~23 = 8. Moreover, let the matrix T = [tij] of processing times be as

follows:

T=

7 10 4

6 9 1 1 6 7 1 4 1 5 7 6

10 9 6 1 7 5 8 10 8 3 1 8 4 7 8,

Let us consider criterion C,,,,, and apply Variant (b) in the first stage. Since Gi consists of six

jobs, we have two full batches of jobs of G 1. We start with job 4 having LI = Cj t4j = 6. Next, we insert job 3 into this batch since this leads to the smallest increase of L1, namely we get

L1 = 14. Continuing in this way, we now insert job 5 into the first batch which leads to L1 = 19,

i.e., the first batch is ~1 = {3,4,5}. Since we have only three remaining jobs of group Gi, we get 7rs = {1,2,6} with L2 = 26. Since group Gz consists of four jobs, we first form the batch rrs = (9) with Ls = 12 and then ~4 = {7,8,10} with L4 = 26.

When applying insertion order 01 in the second stage, we start with batch 7rs (or with ~4). First, we insert batch ~4. For the batch sequence 7r1 = (~4,7rs), we obtain Cmax(7r1) = 54 and for the batch sequence 7r2 = (7r2,7r4), we get C,,, (7r2) = 56. Thus, the first sequence is chosen for the further insertion process. Inserting now batch ~1, we get for sequence x3 = (7ri,7r4,7r2) the objective function value C,,,,, (x3) = 69, for sequence 7r4 = (~4, ~1, YT~), we get C,,,(n4) = 69

and for sequence r5 = (7r4, ~2, ~1)) we get C,,,(.rr5) = 67. Thus, sequence 7r5 is chosen. In the final step, we insert batch 7rs. Among all four possible batch sequences, we choose either 7r6 = (7rs, 7r4,7r2, ~1) or 7r7 = (~4,7rs, 7r2, ~1) with Cm,,(#) = C,,,(7r7) = 80 as heuristic solution.

For comparison purposes, we also implemented two other constructive algorithms that are modifications of the corresponding algorithms for the classical problem when the makespan has to be minimized. In both algorithms, batches are formed in the same way as above, and only the batch sequences are determined in a different way.

The first algorithm ECT is an adaptation of the earliest completion time rule, which has been applied to many scheduling problems (see for instance [34,35]). Assume that a partial batch sequence consisting of 1 batches already exists. Then each of the n - 1 unscheduled batches is appended at the last position and the completion time of the new batch on machine Mm is computed for all n - 1 resulting partial batch sequences. The partial sequence with the earliest completion time of the last batch on machine Mm is selected for further considerations. We continue until all batches have been scheduled.

The second comparative algorithm CDS is an adaptation of the algorithm by Campbell et al. [4] developed for the permutation flow shop problem. This algorithm solves m - 1 artificial two-

106 D. DANNEBERG et&.

machine problems by Johnson’s algorithm, computes the objective function values for these se- quences with respect to the original problem and selects the best solution as heuristic solution.

For the classical permutation flow shop problem, the processing times for the kth artificial problem are chosen as follows:

tti = -&t+ $2 = 2 tij, lli<n, j=l k+l

i.e., the processing times on the first k machines and of the last m - k machines of each job are combined to a new processing time. For the problem under consideration, we determine the processing times of the kth problem as follows. Let ck(nlT,) be the completion time of batch ri on

machine Mk when the setup on machine MI starts at time zero. Then we define

t:i = Ck('h), & = cm(ni) -ck(ni), l<klm

for all batches xi that have been formed. When minimizing c WiCi, the variant Ins (07,l) corresponds to a generalized WSPT priority

rule (we use in the following the notation Append since batches are appended only at the end of

the current partial batch sequence).

4. ITERATIVE ALGORITHMS

In this section, we describe some iterative algorithms for the problems considered which are based on different types of neighbourhood or local search. One main aim of our investigations consists in designing suitable neighbourhoods for the problems considered but we also apply and

compare different local search strategies. First, we derive the neighbourhood structures that have been used and then we explain the search algorithms applied in detail.

4.1. Neighbourhoods

In [26], there have been given neighbourhoods for the type of problems under consideration, where the processing time of a batch is equal to the sum of the processing times of the operations and the batch size is unlimited. In the latter paper, the generation of a neighbour is controlled

by probability parameters. Here we use a similar procedure for generating different types of neighbours. First, we give a formal definition of the neighbourhood.

DEFINITION 1. The batch sequence r* is called shift-shift neighbour of the batch sequence rr =

(7h,7r2,... , ?‘rk) if either

(4

(b)

(cl

a batch ni is shifted to another position within the batch sequence, i.e., we get

or

a batch xi with p(ni) = (pi,. . . ,phi) is split into two batches 7rl and 7ry and one of them may be shifted to another position in the batch sequence (if not, we have simply a splitting of a batch), or a job i, of a batch ni is chosen and inserted into a batch nj of jobs of the same group if this does not exceed the maximum batch size, otherwise job i, is interchanged with a job j, of batch rj.

In Cases (a) or (b), we perform a batch change and in Case (c) a job change. According to Condition (c), a shift operation of a job is always preferred as long as it does not violate the maximum batch size (only then a job exchange is performed). The notation shift-shift neighbour

Heuristic Algorithms 107

means that both the batch change and the job change (if possible) are done by shift operations.

If we replace in Conditions (a) and (b) the shift operation of a batch by an exchange of this batch

with another batch, we generate an exchange-shift neighbour. Analogously, when considering in

Condition (c) only job exchanges, then we generate a shift-exchange or an exchange-exchange

neighbour. A special case of the above shift-shift neighbourhood is the API-AS1 neighbourhood,

where in Cases (a) and (b) only a pairwise interchange of two adjacent batches (API) is allowed

and in Case (c) a job of a batch 7ri is put into or exchanged with a job of the closest batch of

jobs of the same group before or after ri (ASI-‘adjacent’ shift or interchange).

Contrary to the strategy proposed in [26] for the sum-time batch problem with batch availability

on some machines, we do not consider explicit combination of adjacent batches of the same group

since, due to the bounded maximum batch size, often such a combination is not possible. However,

the consideration of job changes as shifts is used as a adequate procedure to combine a batch (of

small size) in a few steps with a batch of jobs of the same group.

When generating a neighbour according to Definition 1, one can observe that the cardinality

of the set of neighbours quickly increases with the problem size. Therefore, it is not advisable

to investigate the neighbourhood of a solution completely. On the other hand, most neighbours

of a feasible solution could be generated by Conditions (b) and (c). However, it is clear that

splitting of a batch should not be applied so often for generating a neighbour whereas neighbours

according to Condition (a) or (c) should be sufficiently often generated. Therefore, in [26] the

generation of neighbours has been suitably controlled by probability parameters and here we

apply a similar procedure.

We use two parameters probl and prob2 as follows. First, it is decided by parameter probl

whether a job or batch change is done. The parameter probl is the probability that a job change

according to Condition (c) is performed. If a batch change will be done, it is decided by means of

parameter prob2 whether a batch is split or not. The parameter prob2 is the probability that a

neighbour is generated by Condition (a) (no splitting occurs). We notice that each generation of

a neighbour according to Condition (b) increases the number of batches whereas the number of

batches is reduced if a job change is done as a shift from a single job batch. It is easy to see that

the graphs representing the neighbourhoods derived in this section are strongly connected, i.e.,

from an arbitrary starting batch sequence there exists a path in the corresponding neighbourhood

graph to any batch sequence. Moreover, it can be shown that the graph representing the shift-shift

neighbourhood has the diameter n - 1 (note that this diameter is even obtained when generating

neighbours only by Conditions (b) and (c)) and thus it is the same as for the shift or exchange

neighbourhood for the classical permutation flow shop problem without setup times (see [36]).

4.2. Metaheuristics

A basic variant of local search is iterative improvement. Starting with an initial sequence X,

a neighbour r’ in a specific neighbourhood is generated. If sequence 7r’ has a better objective

function value than X, the move from r to & is accepted and K’ is chosen as new initial sequence.

Then the search is continued until no neighbour leads to an objective function value improvement.

In our tests, we include a multistart descent algorithm which is an adaptation, where the above

iterative improvement algorithm is applied repeatedly, using a different randomly generated initial

solution for each restart.

In our experiments, we also include basic variants of simulated annealing and tabu search.

Simulated annealing (see for instance 1377) h as its origin in statistical physics, where the process of cooling solids slowly until they reach a low energy state is called annealing. Contrary to iterative

improvement a new sequence is, in certain cases, accepted even though its objective function

value exceeds that of the old sequence. More precisely, starting with an initial sequence n, a neighbour 7r’ is generated in the chosen neighbourhood and the difference

A = F(?r’) - F(r)

108 D. DANNEBERG et al.

is calculated, where F denotes the objective function. When A < 0, sequence XI is accepted as the current sequence. In the other case, sequence X’ is accepted as the current sequence

with probability exp( - A/T), w h ere T is a parameter known as the temperature. Typically, the

temperature is high in the initial stages so that often increases in the objective function value

are accepted. Then the temperature decreases slowly until it is close to zero in the final stages.

For example, the algorithm may stop if the temperature has reached a chosen final value. In

initial tests, we used a geometric cooling scheme TneW = X . Told with 0 < X < 1 and the final

temperature is chosen to be close to zero (T = 0.01). Based on our tests, as in [26], the initial

temperature To was chosen to be equal to the objective function value of the starting sequence

divided by 5. We note that a lower initial temperature T ” = To/3 yielded results of comparable

quality, whereas a higher initial temperature T “O = 3T” worked slightly worse. As in [26], a data

dependent initial temperature was taken since the range of the objective function values differs

very much in dependence on the objective criterion applied. So, it appears to be advisable to

accept a sequence with an objective function value that has been increased by a fixed percentage

with the same probability at the beginning.

Tabu search is an iterative method that moves in each iteration from the current sequence to

the ‘best allowed’ neighbour. Notice here that ‘best allowed’ must not necessarily lead to an

improvement of the objective function value. The key feature of tabu search is to avoid as much

as possible moves that would bring the search back to one of the recently visited solutions in order

to limit the risk of cycling. For doing this, the last accepted moves are collected in a tabu list.

However, a move remains forbidden only for a certain number of iterations, which is controlled

by the length L of the tabu list. The tabu list can be represented by a queue, i.e., as soon as L

moves have been included into the list, at each further iteration the oldest stored move will be

deleted and the last accepted move will be added to the queue. For more details of this approach

the reader is referred to the papers by Glover (see [38,39]). S ome refinements such as the reverse

elimination method are reviewed for instance in [40].

Due to the cardinality of the neighbourhood, we do not investigate the whole set of neighbours,

but generate randomly only s neighbours in one iteration. Having these s neighbours generated,

we accept the move to the best nontabu neighbour 7r’ which becomes the starting solution of the

next iteration. Only if no nontabu neighbour has been generated within one iteration, we accept

the move to the best tabu neighbour. We also apply an aspiration criterion which is satisfied

if the objective function value of a generated neighbour ii is less than the value of any solution

previously obtained (independently whether it is tabu or not). In this case, we immediately

accept the move to i! and start with the next iteration from the latter sequence.

We now give some more details of the tabu list applied. We store some attribute for the last L accepted moves in the list. In our tests, we considered an order attribute in the following way. If

a job or batch has been shifted to the left, we introduce the order attribute (i,j), where i is the

shifted job in the case of a performed job change or an arbitrary job of the shifted batch in the

case of a batch change and j is an arbitrary job of the succeeding batch of xi after the performed

batch change. Analogously, in the case of a job or batch right shift, we introduce (j,i) into the

tabu list, where job j is an arbitrary job of the batch preceding the job or batch that has been

shifted. Now a neighbour is tabu if any of the ordered job pairs on the tabu list are sequenced in

the reversed order, i.e., where job j is sequenced before job i for the pair (i,j) in the tabu list. In

most algorithms, there has been applied either a constant length of the tabu list [38] or a length

linearly depending on the number of jobs (see for instance [41]). Based on initial experiments,

we used L = 7 and s = 20. Additionally, we also consider so-called multilevel heuristics, where different neighbourhood

structures are used within the search. Typically, one has a neighbourhood with ‘large’ changes

(high-level) and another neighbourhood with ‘small’ changes (low-level). Starting with an initial

solution, such algorithms first perform a step in the high-level neighbourhood and then a local

optimization within the low-level neighbourhood is performed. After having determined a local

Heuristic Algorithms 109

optimum in the low-level neighbourhood, the objective function value of this local optimum is compared with this of the initial solution. To decide which solution is chosen as starting solution

for the next iteration, one can apply iterative improvement or the known metaheuristics such as simulated annealing. Such types of local search has been applied to the traveling salesman problem by Martin et al. [42], where the high-level neighbourhood is the 4-opt neighbourhood and the low-level neighbourhood, within which local optimization is performed, is the 3-opt neighbourhood (note that in the k-opt neighbourhood, a neighbour of a tour is obtained by replacing Ic direct links between cities so that a feasible tour results). A related approach to

job shop scheduling (without setup times) has been given by Lorenco [43]. In the latter paper, the neighbourhood is based on the performance of certain adjacent pairwise interchanges of

operations and large steps can be done by performing several consecutive pairwise interchanges or by reoptimizing the sequence of operations on several machines. In [44,45] a similar approach has been applied to several scheduling problems. For problems on a set of permutations, the high-level neighbourhood was often a special type of shift neighbourhood and the low-level neighbourhood was the adjacent pairwise interchange neighbourhood. In our tests, we included the following types of such an approach.

MULTILEVEL 1. Both the high- and low-level neighbourhoods are based on the complex neigh- bourhood with batch and job changes. The high-level neighbourhood is the shift-shift neighbour- hood and the low-level neighbourhood is the API-AS1 neighbourhood. As mentioned before, in

the case of a job change in the low-level neighbourhood, a chosen job is shifted to the closest batch of the same group before or after the batch of the chosen job or (see Condition (c)), an exchange

of a job with such a batch is performed when the maximum batch size would be exceeded.

MULTILEVEL 2a. The high-level neighbourhood is the shift neighbourhood with batch changes (i.e., a neighbour is generated according to Condition (a) or (b) of Definition 1) and in the low- level neighbourhood only job changes between two batches of the same group are allowed. Again, a job can be put into another batch of the same group if it is not full or an exchange of a job with a job of a batch having the maximum batch size can be performed.

MULTILEVEL 2b. This variant is similar to Variant 2a except the changes in the low-level neigh- bourhood. Here a neighbour can be generated by selecting a job of the batch xi, which has been shifted in the high-level neighbourhood, and inserting this job into another batch of jobs of the

same group (if possible, otherwise an exchange of a job with one of the other chosen batch of the group is performed). Additionally, we allow a ‘dummy’ shift in the high-level neighbourhood such that in this case, only low-level neighbours are generated from the initial batch sequence.

The first variant considers in both levels the complex neighbourhood with possible batch and job changes, whereas the latter two variants consider batch changes in the high-level neighbour- hood and special job changes in the low-level neighbourhood. Contrary to variant Multilevel 2a, where the cardinality of the low-level neighborhood is rather large, this neighbourhood contains in variant Multilevel 2b substantially less neighbours.

To illustrate, the different low-level neighbourhoods in the multilevel heuristics proposed above, we consider the following example. Let n = 14; Gi = {1,2,. . . , lo}, Gs = {11,12,13,14}, mbsize = 3 and let 7r = (~1, ~2, . . . ,YTTT~) be the current solution with 7rr = {1,2,3}, 7rz =

{4,5), 7r3 = {Il,I2,I31, 7r4 = {6,7}, 7rs = {14}, and rs = {8,9,10}. Thus, we have 52 = 25 high-level neighbours (in variant Multilevel 2b there is one additional neighbour for keeping the current batch sequence). Assume now that in the high-level neighbourhood the batch 7r1 has been shifted after batch 7r5, i.e., we have obtained X* = (~2, IQ, 7r4, x5, 7r1, 7rs).

If we apply procedure Multilevel 2b, then one could put one of the jobs 1, 2, or 3 of 7r1 into batch 7r4 or exchange one of these jobs with a job from batch ?rs (since rs contains mbsize jobs, a job exchange has to be done). Consequently, we have 3 + 9 = 12 neighbours in the low- level neighbourhood (note that, if a neighbour is accepted, the number of possible neighbours

110 D.DANNEBERG etal.

for generating the second neighbour could be smaller since the number of jobs in batch ~1 may

reduce).

If we apply procedure Multilevel 2a, we could additionally generate a neighbour in the low-level

neighbourhood by putting one of the jobs of 7rs into batch 7r4 (two neighbours) and opposite (two

neighbours) by exchanging one of the jobs of 7r2 with one of the jobs of ~1 (six neighbours) or

shifting one of the jobs of ~1 into batch 7r2 (three neighbours), by exchanging one of the jobs

of 7rs with one of the jobs of batch ns (six neighbours) or putting one of the jobs of rs in to

batch ~1 (three neighbours), by putting one of the jobs of 7rs with the only job of batch 7r5 (three

neighbours) or exchanging the only job of 7rs with one of the jobs of batch 7r3 (three neighbours),

by exchanging one of the jobs of 7r4 with one of the jobs of batch ~1 (six neighbours), by exchanging

one of the jobs of ~4 with one of the jobs of batch rs (six neighbours) or by putting one of the jobs

of ?‘rs into batch 7r4 (three neighbours). Together with the 12 possible low-level neighbours when

applying procedure Multilevel 2b, we get 55 possible neighbours in this case. Among these 55

neighbours, there are 28 neighbours with job changes in the low-level neighbourhood of Variant 1

since we must drop all job changes between batches ~2 and 711, ~2 and ?rs, and 7r4 and ?rITg (i.e.,

27 neighbours).

If we apply procedure Multilevel 1, we have in addition to the 28 possible neighbours in the

low-level neighbourhood of n* when applying procedure Multilevel 2a five further neighbours

which are obtained by interchanging two adjacent batches in K* as well as several neighbours

which are obtained by splitting a batch (in different ways) and possibly interchanging one of the

new batches with its neighbour.

In our scheme, we direct the multilevel procedure by three parameters A, h, and 1. The first

parameter A (threshold) gives the value how many percent the objective function value of a

generated high-level neighbour ~~ can be worse than that of the initial solution r to be accepted

for starting with the local optimization in the low-level neighbourhood. If a generated high-level

neighbour does not satisfy the above condition, we generate another high-level neighbour. The

parameter h gives the maximal number of high-level neighbours to be generated in one iteration.

If none of the h generated neighbours has an objective function value no more than A% worse

than that of the initial solution, we take the best high-level neighbour among these h neighbours

and continue with the local optimization in the low-level neighbourhood.

Since iteration in the low-level neighbourhood may be time-consuming, we restrict the number

of low-level neighbours generated within one iteration by a depth parameter 1. So, within an

iteration the search does not necessarily stop with a local optimum within the low-level neigh-

bourhood. Note that, as usual, within the low-level neighbourhood only neighbours with an

improvement of the objective function value are accepted. After generating 1 neighbours in the

low-level neighbourhood, we compare the solution r* obtained with the initial solution 7r of the

current iteration by applying the simulation annealing acceptance test (with the same cooling

scheme). However, the use of parameter A in our implementation prevents that, at the beginning

or in the middle of the search, solutions with a ‘much worse’ objective function value will be ac-

cepted. The multilevel approach is summarized in the following algorithm. Based on the number

nsol of iterations in the chosen simulated annealing algorithm, we approximately generate the

same number of solutions in the multilevel procedure.

ALGORITHM. MULTILEVEL (A, h,Z).

1. by means of parameter nsol and the initial temperature T determine X such that

Xnso’T is equal to the final temperature;

2. determine a starting solution 7r” and calculate F(r’); 7r := 7r”; ns := 0;

Repeat

3. u := 0;

Repeat

4. generate a high-level neighbour 7r’ of YT and compute F(r’);

Heuristic Algorithms 111

21:=u+l;

If h = 1 or F(x’) < A Then ++ := 7r;

Until u = h or (F(r’) - F(r))/F(r) 5 A;

For T = 1 To 1 Do

Begin

7. generate a low-level neighbour 7r’ of n* and compute F(n’);

8. If F(r’) < F(r*) Then 7r* := 7r;

End;

9. determine a (pseudo)random number x E [0, 11;

10. If z 2 exp(-(F(r*) - F(r))/T) Then n := 7r*;

11. If F(r) < F(7r”) Then x0 := r;

12. T := X”T;

13. ns=ns+u+1;

Until ns 2 nsol {TO is the heuristic solution}.

4.3. Structural Properties

In [44,45], structural properties of special scheduling problems have been taken into consider-

ation so that the local optimization within the low-level neighbourhood can be performed in a

constructive way even in polynomial time. This procedure has led to excellent results. Although

for various problems, even the determination of a local optimum turns out to be PLS-complete

(see [46]), nevertheless the inclusion of structural properties to direct the search within the low-

level neighbourhood seems to be promising. In the following, we describe such an approach for

minimizing the makespan C,,, by using the structure of a critical path. In particular, we con-

sider only such neighbours in the low-level neighbourhood which satisfy a necessary condition

for an objective function value improvement. Of course, one can include such considerations into

other metaheuristics too when applying this type of neighbourhood in the search.

In the case, when an adjacent batch interchange of two batches is considered (only possible

if procedure Multilevel 1 is applied), the situation is quite similar to the classical permutation

flow shop problem without consideration of setup times. The critical path consists of blocks of

batches, where a block is a maximal set of (at least two) contiguous batches, which are processed

on the same machine. The notation of a block is illustrated in Figure 1, where S indicates a

required setup time. For this example, we have three blocks of at least two batches. Note that

the critical path must not necessarily be uniquely determined. Figure 2 illustrates the case when,

beginning from the last batch, a critical path is selected which changes to the preceding machine

if the corresponding batch on the current machine has no waiting time after the completion of

this batch on the preceding machine.

It is known (see [15]) that an API neighbour may only have a better objective function value

if the first or last two batches of a block will be interchanged. Additionally, if the critical path

begins with a block, only the last two batches of this block must be considered as a candidate

for generating an API neighbour. Analogously, if the critical path ends with a block, then only

Figure 1. The formation of blocks of the critical path.

112 D. DANNEBERG et al.

critical path

. . .

Figure 2. The critical path passes through ri and hi on the same machine.

the first two batches of this block must be considered for generating a neighbour in the API neighbourhood satisfying the necessary condition for an objective function value improvement.

It is obvious that all other pairwise interchanges of two adjacent batches lead to a solution that has an objective function value at least as large as the length of the critical path of the initial solution. Thus, in the example illustrated in Figure 1, only four adjacent batch interchange neighbours are a candidate in the low-level neighbourhood, namely the interchanges of 7r2 and 7rs,, 77s and ~4, 7r5 and 7’rs, as well as ?re and 7r7. Quite similar considerations can be done for the case of batch splits possibly combined with an adjacent interchange of one of the new batches with its neighbour.

Next, we describe how the generation of a low-level neighbour can be restricted when a job change will be performed. Assume that we have chosen batch 7ri for performing a job change and that a job from 7ri will be put into a batch 7rj. Assume that 17rjl < mbsize, i.e., a job from pi

is shifted into the nonfull batch rj. We have to consider two cases in dependence whether the critical path passes on the same machine through both batches 7~i and ~j or not.

The first situation is illustrated in Figure 2, where we assume without loss of generality that batch nj is sequenced before batch 7ri. We denote by Ai,, Old the length of batch xi in the initial

solution and by AF,iw the length of batch ni on machine MI, after performing the corresponding

Old job change. In order to shorten Ai,k, the job with the longest processing time in ri on machine IL& is removed from this batch and inserted into the nonfull batch 7rj which gives a new solution r*.

If A?” + A?” < A?ld + A?ld

z,k I,k t,k j>k

holds, a necessary condition for an objective function value improvement is satisfied. In this case, we calculate the objective function value of sequence 7r* and, if it is better than that of

the initial solution, we accept I? as a generated neighbour in the low-level neighbourhood and repeat the above procedure. If (1) does not hold, we reject K* and consider a new job change. The generation of low-level neighbours within one iteration stops if 1 objective function value calculations have been performed.

Consider now the case that the critical path passes on different machines through both batches ri and rj. Assume that the critical path passes on machine Mk through ~j and on machine Ml through xi (if the critical path passes on more than one machine through a batch, then one of these machines is arbitrarily chosen). Then we proceed analogously as described above, however, we replace inequality (1) by

A?ew + A?ew < A?rd + A?ld %l g,k z,r 3,k’

Now consider the case that batch nj is already full, i.e., we have to consider an interchange of a job of ni with a job of nj. Again, we can consider both above cases with respect to the critical path. Now we try in both cases to interchange the longest job in ri on machine Mk with a job in rj on the corresponding machine, where the critical path passes through, such that conditions (1) and (2), respectively, are fulfilled. Note that, if more than one job in rj satisfies

Heuristic Algorithms 113

condition (1) and (2), respectively, we choose an arbitrary one which satisfies the corresponding

condition.

The above considerations can be generalized to the following proposition.

PROPOSITION 1. If there exists a batch sequence X’ with C max(7r’) < Cmax(7r), then there must

hold one of the following conditions:

(1) a job of a batch 7ri must be put into a batch rrj with j # i (if ]rj’j[ < mbsize), or exchanged

with a job of batch nj (if jri’j( = m size such that inequality (1) holds if the critical path b )

of G(r) passes on machine Mk through both batches 7ri and rj;

(2) jb f bth a ‘o o a a c ni must be put into a batch rjrj; j # i (if ]~jjl < mbsize), or exchanged

with a job of batch rj (if /n-j] = m size such that inequality (2) holds if the critical path b )

of G(n) passes on different machines Mk and Ml through both batches; or

(3) an inner batch 7ri of a block k (i.e., ni is neither the first nor the last batch of a block)

must be shifted after the last batch of this block (if this block belongs to machine MU with

u < m) or an inner batch nj of a block 1 (if this block belongs to machine M, with u > I),

where an inner batch of a block is a batch not sequenced on the first or last position of

this block; or

(4) an inner batch of a block is split into two batches 7r’ and I? and one of them is shifted

as in Condition (3) or a noninner batch of a block is split which belongs at least on two

machines to the critical path.

It can be easily proved that for all batch sequences not satisfying any of the conditions of

Proposition 1, there exists a path with a weight at least as large as the weight of the critical path

of the current solution p. In particular, for the API-AS1 neighbourhood the neighbours satisfying

a necessary condition for an objective function value improvement can be immediately derived

from the above considerations.

5. COMPUTATIONAL RESULTS

First, we describe the generation of the test problems which has been done in a similar way

as proposed by Taillard [47]. A problem is entirely defined by the initial value of a seed 20 of a

random generator. The (pseudo) random number generator is based on the recursive formula

~i+i := (16807~) mod (231 - 1) .

This formula provides a uniformly distributed sequence of numbers in the closed interval

[l, 231 - 11, which are transformed to integers zi from the closed interval [a, b] according to

&=a+ i

(b - a + l)Zi 231 _ 1 1 ’

The flow shop problems with setup times considered are characterized by the processing

times ti, of job i on machine Mj, by the setup times .s,~ when starting with a batch of group G, on

machine Mj , by setting the maximum batch size mbsize and by assigning a weight wi to each job.

By using the algorithm proposed by Taillard [47], first the matrix T of the processing times and

then the matrix S of setup times are rowwise generated, where the processing times are uniformly

distributed integers in [l, b ] 1 and the setup times are uniformly distributed integers in [0, bz]. We

consider the case of dominant processing times (DPT; bi = 200, b2 = 50), dominant setup times

(DST; bl = 50, bz = 200) and of similar processing and setup times (SIT; bl = ba = 100).

In our tests, we considered ten problem classes, namely

(a) n = 40, m = 10, g = 7, mbsize = 3;

(b) n = 40, m = 10, g = 5, mbsize = 4; (c) n = 60, m = 5, g = 5, mbsize = 3;

114 D. DANNEBERG et al.

(d) n = 80, m = 5, g = 5, mbsize = 3;

(e) n = 80, m = 5, g = 3, mbsize = 5;

(f) n = 60, m = 5, g = 3, mbsize = 4;

(g) n = 60, m = 10, g = 3, mbsize = 3;

(h) n = 100, m = 5, g = 5, mbsize = 4;

(i) n = 100, m = 5, g = 3, mbsize = 3; and

(j) n = 120, m = 5, g = 4, mbsize = 3.

First, we tested and compared the constructive algorithms from Section 3. We generated for

each problem class 20 instances with DST, 20 instances with SIT, and 20 instances with DPT,

thus obtaining 600 instances. We performed initial tests with the three variants of forming the

batches and found that Variant (b) worked best followed by Variant (c). For this reason, we

apply in the following always Variant (b) to form the batches.

Next, we compared the different insertion orders. The random insertion of the jobs (algorithm

Ins (09)) is taken as reference algorithm and the percentage improvements of the average objective

function value in comparison with variant Ins (09) is presented. The results are given in Table 1

for criterion C,,,, where also algorithms ECT and CDS are included, and in Table 2 for criterion

C WiCi. Moreover, the analogous results for the restricted insertion algorithm Ins (07,~) for

C w&‘i are given in Table 3.

Concerning criterion C,,, , we observe that only Ins (01) outperforms Ins (09). The superiority

of order 01 is in correspondence with the results for the makespan minimization problem without

setup times (see [S]) h w ereas for sum-time batch problems with makespan minimization and item

availability a groupwise insertion (see [26], here order 04 was the best) turned out to be preferable.

For our type of problem, a groupwise job insertion cannot be recommended. However, even the

application of a ‘nonsuitable’ insertion order yields clearly better results than the constructive

heuristics ECT and CDS (analogously to sum-time batch problems, see [26]).

For criterion C WiCi, it can be observed that, in contrast to C,,,, most insertion orders work

better than a random insertion. Here the best order for C max yields even the worst results for

CwiCi. As expected, the insertion orders based on weights (orders 05-08) are preferable in

this case (note that orders 05 and 07 work in particular well for DST problems). Contrary

to other shop scheduling problems, the recommendation for a suitable insertion order does not

(substantially) depend on the type of problems considered (In [26,32], it has been observed that

for certain flow shop and job shop problems with setup times sometimes a groupwise insertion is

preferable and sometimes it’should be avoided!)

Concerning the restricted insertion algorithm, it can be seen that variant Ins (07,5) already

outperforms algorithm Ins (09), but only 5n - 10n partial sequences have to be considered in

comparison with (n2 + n)/2 partial sequences when applying an unrestricted insertion algorithm.

It can be seen that the differences in the objective function values between algorithms Append

and Ins (07,9) are larger for DST problems.

Before comparing the different iterative algorithms, we performed some initial tests for finding

some suitable parameters. In this stage of the experiments, we did not use a specific constructive

algorithm described in Section 3 for determining a starting solution. In these initial tests, we

always started with an arbitrary solution with completely filled batches (except possibly the

last one of each group). Due to the larger computational times for the iterative algorithms, we

reduced the number of problem classes considered and sometimes also the number of instances

per problem class.

First, we tested the shift-shift neighbourhood against the shift-exchange, exchange-shift, and exchange-exchange neighbourhoods using simulated annealing. For each of the five problem

classes (a)-(e) and each problem type (DST, SIT, and DPT), we generated 20 instances, yielding

altogether 300 instances. We observed that, considering only exchanges as job changes works

generally bad (in this case the cardinality of batches cannot change and thus the resulting neigh-

115 Heuristic Algorithms

Table 1. Comparison of different insertion orders for C,,,

Type Ins (01) Ins (02) Ins (04)

DPT 0.35 0.13

SIT 0.27 0.03

DST 0.01 -0.61

Ins (03)

-0.16

-0.03

-0.26

-0.04

-0.21

-0.80

ECT

-11.89

-10.40

-10.15

CDS

-3.21

-2.99

-3.96

a

b

DPT 0.25

SIT -0.27

DST 0.22

- 10.00

-9.77

-11.13

-13.06

-10.40

-10.51

-12.91

-9.26

-8.53

-10.95

-9.06

-8.07

-14.13

-10.51

-8.04

-2.40

-3.39

-4.13

-2.75

-2.30

-1.44

-2.28

-1.59

-1.44

-4.30

-2.87

-1.80

-4.22

-2.67

-3.15

-3.92

-3.24

-2.51

-3.58

-2.13

-1.82

0.10 -0.13 -0.09

-0.00 -0.59 -0.14

0.04 -0.36 -0.74

0.46 0.04 -0.04

-0.07 -0.15 -0.57

-0.51 -0.17 -0.79

DPT 0.77

SIT 0.50

DST -0.08

DPT 1.07

SIT 0.25

DST 0.48

c

-0.06 -0.46

-0.14 -0.38

0.09 -0.09

-0.47

-1.20

-0.60

-0.36

-1.18

-0.22

-0.76

-0.98

-0.66

d

0.23 -0.06 -0.45

0.01 -0.28 -0.36

0.15 -0.34 -0.21

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

all

all

all

all

all

all

all

all

all

all

DPT

SIT

DST

all

e

0.05 -0.26 -0.13

0.08 -0.40 -0.71

0.12 -0.21 -0.08

f

0.40 0.28 -0.44 0.15

0.20 0.03 -0.40 -0.56

0.07 -0.44 0.04 -0.49

0.49 -0.25 -0.62 0.14

0.14 -0.19 -0.34 -0.71

0.00 -0.61 -0.02 -0.63

-11.84

-10.46

-8.73

-10.75

-8.58

-8.17

-12.91

-7.19

-6.05

g

h

-0.26 -0.16

-0.10 -0.25

0.03 -0.13

-2.24

-1.33

-0.73

-2.37

-0.71

-0.95

0.61 0.40

0.10 -0.27

0.01 -0.58

0.45 -0.00

0.20 -0.51

0.05 -1.01

i

-0.33 -0.12 -13.32

-0.09 -0.37 -8.78

-0.21 -0.49 -8.61

j

0.21 -0.15 -0.15

0.06 0.05 -0.36

0.39 -0.04 -0.09

0.60 -0.04 -0.31

0.13 -0.23 -0.34

0.08 -0.29 -0.31

0.22 -0.05 -0.27

0.21 -0.35 -0.32

0.24 -0.15 -0.11

0.24 -0.51 -0.21

0.47 0.07 -0.29

0.15 -0.18 -0.31

0.10 -0.42 -0.13

-0.35 -10.81 -3.39

-0.33 -10.30 -3.31

-0.47 -11.32 -2.16

-0.76 -10.23 -1.77

-0.58 -9.36 -2.99

-0.80 -10.89 -3.35

-0.30 -10.35 -3.22

-0.40 -9.17 -2.51

-0.18 -8.71 -1.43

-0.33 -10.24 -1.34

-0.17 -12.18 -3.13

-0.62 -9.44 -2.32

-0.56 -8.80 -2.19

-0.45 -10.14 -2.55

a

b

c

d

e

f

g

h

i

j

all

all

all

all 0.24 -0.18 -0.25

bourhood graph is not connected). For the objective function Cw$i, the objective function

values are even, on average, 33% worse than considering preferably shifts as job changes. Con-

cerning batch changes, the consideration of shifts is slightly better than the consideration of

116 D. DANNEBERG et al.

Table 2. Comparison of different insertion orders for C wiCi

Class

a

b

c

d

e

f

h

i

j

a

b

c

d

e

f

g

h

i

j

all

all

all

all

5w Ins (01) Ins (02)

DPT 0.10 0.21

SIT -0.31 0.36

DST -0.38 -0.28

DPT -0.05 -0.01

SIT -0.78 0.11

DST 0.16 0.90

DPT -0.06 0.25

SIT -0.41 -0.19

DST -0.41 -0.79

DPT -0.93 0.36

SIT -0.64 0.02

DST -0.13 -0.58

DPT 0.28 0.96

SIT -0.71 -0.13

DST -0.48 0.43

DPT

SIT

DST

0.53

0.43

0.04

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

all

all

all

all

all

all

all

all

all

all

DPT

SIT

DST

all

0.14

-0.02

-0.03

-0.54

-0.58

-0.58

-0.02

-0.24

0.25

-0.40

-0.00

0.01

-1.34

-0.77

-0.79

-0.20

-0.22

-0.29

-0.57

-0.30

0.03

-0.57

-0.00

-0.13

-0.97

-0.28

-0.45

-0.24

-0.32

-0.01

0.22

-0.23

-0.14

-0.14

0.60

0.23

0.02

-0.03

-0.35

-0.04

-0.94

0.10

0.33

-0.24

-0.06

0.42

0.33

-0.01

0.11

0.07

-0.44

0.20

0.07

-0.09

0.06

Ins (07) Ins (03)

-0.19

-0.11

-0.61

Ins (04)

-0.01

0.03

-0.26

Ins (05) Ins (06)

0.31 0.25

0.51 0.33

0.08 0.25

0.36

0.36

1.18

0.73

0.89

1.62

0.55

0.97

0.98

1.12

1.07

1.46

0.49

0.27

0.92

0.48

0.67

0.94

0.30

0.41

0.62

0.94 0.83 1.11

1.08 0.90 1.05

1.59 1.59 1.63

0.74

0.70

0.87

0.80

0.92

1.13

0.70

0.82

1.74

0.83

1.13

1.26

0.64

0.92

1.15

0.30

0.63

1.08

0.83

1.22

0.77

0.95

1.08

1.08

0.90

0.68

0.83

1.15

0.88

0.70 0.60 0.67

0.71 0.59 0.61

0.89 0.92 0.83

0.64

0.70

1.46

0.62

0.72

1.41

0.92

0.95

1.12

0.18

0.48

0.10

0.28

0.56

0.69

0.44

1.20

0.77

0.93

0.92

1.00

0.25

0.55

0.63

0.93

0.71

0.18

0.52

0.13

Ins(08)

0.33

0.31

0.25

0.31 0.35

0.39 0.33

0.96 0.93

0.38 0.40

0.87 0.46

1.49 1.07

0.03 0.34

0.83 0.23

1.03 0.54

0.50

0.79

0.91

0.13

0.73

1.65

0.62

0.92

1.33

-0.05

0.89

1.12

0.28

0.55

0.92

0.63

1.10

0.71

0.73

0.84

0.96

0.66

0.35

0.74

1.11

0.74

0.84

0.96

1.29

0.65

0.82

1.41

0.90

0.99

1.06

0.32

0.54

0.64

0.30

0.54

0.65

0.37

1.26

0.71

1.03

0.96

0.98

0.50

0.59

0.63

0.97

0.73

-0.06

-0.18

0.69

-0.35

0.32

0.64

0.65

0.71

1.06

0.30

0.20

0.80

-0.19

0.46

0.62

0.20

0.32

-0.07

1.17

0.85

0.81

0.68

0.59

0.96

0.62

0.50

0.54

0.32

0.41

0.99

0.42

0.82

1.33

0.57

0.98

0.96

0.42

0.35

0.50

0.64

0.56

0.27

0.23 0.04

0.72 0.44

0.59 0.28

-0.30 -0.08

0.15 0.20

0.81 0.43

0.30 0.15

1.09 0.94

0.74 0.55

0.57 0.72

0.86 0.42

0.84 0.49

0.51 0.25

0.35 0.36

0.52 0.41

0.79 0.46

0.56 0.41

exchanges of batches. In particular, among the 300 instances, the better objective function value by applying job exchanges was obtained only for 133 instances when minimizing C,,, and for

Heuristic Algorithms

Table 3. Restricted insertion algorithm for C wiCi.

117

Class Append Ins (07,5) Ins (07,7) Ins (07,9) Ins (07)

-2.47

-3.26

-6.27

Ins (07,3)

-0.56

-0.16

-1.53

-0.21 -0.01 0.03 0.18

0.28 0.43 0.52 0.52

-0.23 0.06 0.13 0.13

-2.24 -0.09 0.30 0.31 0.31 0.31

-3.67 -0.06 0.39 0.39 0.39 0.39

-3.86 0.18 0.96 0.96 0.96 0.96

-3.22 -0.71

-3.36 -0.24

-5.57 -0.53

-4.86 -1.32

-4.54 -0.90

-5.68 -1.74

0.11

0.60

0.93

-0.50

0.22

-0.09

0.75

0.40

1.46

0.24

0.73

1.29

-0.30

0.53

0.67

0.37 0.38

0.87 0.87

1.50 1.49

-0.11 0.03

0.75 0.83

0.93 1.03

-2.91

-4.15

-3.93

-1.63

-2.96

-4.00

-2.70

-2.48

-2.97

-3.49

-3.28

-4.72

0.56

0.57

0.65

0.21

0.57

0.82

0.83

0.90

1.59

0.60

0.59

0.91

0.39

0.65

0.88

0.83 0.83

0.90 0.90

1.59 1.59

0.60 0.60

0.59 0.59

0.92 0.92

-0.35 -0.33

0.09 0.48

0.36 1.26

0.50 0.50

0.79 0.79

0.88 0.91

0.13 0.13

0.70 0.73

1.49 1.65

-4.35

-4.03

-5.14

-5.73

-4.02

-5.19

-4.00

-3.26

-4.05

-5.02

-3.66

-2.86

-2.72

-3.83

-4.50

-4.98

-3.36

-3.57

-4.73

-3.89

-0.11

-0.61

0.40

0.42

0.43

-0.10

-0.07

0.22

0.12

-0.96

-0.84

-1.13

-0.95

-0.79

-1.76

-2.66

-1.22

-1.77

-0.75

0.01

-0.49

-1.32

-0.11

0.25

0.09

-0.98

-1.17

-1.89

-0.70

-0.42

-0.79

-0.63

0.30 0.41 0.57 0.62

0.28 0.62 0.82 0.92

-0.24 0.49 1.01 1.33

-0.77 -0.46 -0.24 -0.05

0.01 0.43 0.60 0.89

-0.37 0.55 0.88 1.12

-0.05 0.16

0.55 0.55

0.55 0.75

-0.12 0.30

0.87 1.10

0.59 0.70

0.54 0.64

0.03 0.47

0.11 0.51

-0.38 0.17

0.04 0.17

0.34 0.58

0.43 0.87

0.27 0.54

0.23 0.28

0.55 0.55

0.91 0.92

0.53 0.63

1.10 1.10

0.71 0.71

0.72 0.73

0.77 0.84

0.80 0.96

0.41 0.66

0.30 0.35

0.69 0.74

1.03 1.11

0.67 0.74

Type

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

a

b

c

DPT

SIT

DST

DPT

SIT

DST

i

j

a all

b all

c all

d all

e all

f all

g all

h all

i all

j all

all DPT

all SIT

all DST

all all

137 instances in the case of minimizing C wiCi. Among the six types considered (three problem

types and both objective functions), the exchange-shift neighbourhood was slightly better than

118 D. DANNEBERG etal.

the shift-shift neighbourhood only for one type (DST problems, objective function C,,,). For the above reason, we consider from now on the shift-shift neighbourhood.

Next, we determined suitable values for the probability parameters probl and prob2. To this end, we applied simulated annealing (in the shift-shift neighbourhood). First, we have found that small or large values of parameter probl work bad and additionally that, as expected, splitting of batches should not too often be considered. Therefore, we tested 18 combinations (probl,prob2)

more in detail, namely probl E {0.4,0.5,0.6,0.7} and prob2 E {0.75,0.8,0.85,0.9,0.95,1.0}.

For each problem class (a)-(e), we generated eight instances with DST, eight instances with DPT, and eight instances with SIT. Each instance was run for both objective functions with a short run (nsol = 25n) and a longer run (nsol = loon). Summarized over all problem classes, we decided to use combination (prob 1, pro 2) = (0.6, 0.95) for both objective functions due to the following reasons:

l for both objective functions, this variant has obtained among all combinations most often

the best objective function value; l comparing the results for short and long runs for both objective functions (each time sum-

marized over all problem types), in all four cases the average objective function value was always less than 0.2% over the average objective function value of the best combination.

The results do not differ very much if we distinguish between short and long runs, different problem types or problem classes. For problems with a smaller average number of batches (problem classes (a) and (b)), ft o en variants with a smaller value of probl (i.e., probl 5 0.5) work good, whereas for the larger problems, slightly more often job changes should be considered, i.e., variants with probl E {0.6,0.7} are preferable (problem classes (d) and (e)). Also the problem type (DST, SIT, or DPT) does not significantly influence the results. Of course, in the case of

DPT problems, splitting of batches should slightly more often be considered. A similar conclusion can be drawn for the longer runs. In both situations, the number of best objective function values for combinations with prob2 < 0.9 are larger than on average. Summarizing, job changes should be considered slightly more often than batch changes and the chosen combination (0.6,0.95) turns

out to be a good compromise for the different problems.

Next, we compared the different multilevel variants relative to each other and looked for suitable values of the parameters A, h, and 1. To this end, we generated 25 instances from the problem classes (a)-(e), and tested all 75 combinations with h, 1 E {1,3,5,7,9}, and A E {1,2,3} for both objective functions and the fixed value nsol = 100n. Although it is difficult or even impossible to determine the ‘optimal’ combination of the three parameters, we can draw the following conclusions from these tests. First, we have found that for the fixed value of nsol the variant A = 1% obtained the best results. Concerning parameter h, we have found that larger values (7 2 h 5 9) are preferable. This ensures that the accepted high-level neighbour does usually

not have an objective function value which is much worse, if no neighbour has been found with an objective function value no more than 1% over that of the starting solution. The choice of a suitable value of parameter 1 depends on the search variant and the objective criterion.

For C WiCi, we observed that for Multilevels 2a and 2b, the value of 1 should be greater (1 1 7) and for Multilevel 1, this value should be small (1 < 3). For our final tests, we have chosen the best variants h = 1 = 7 for Multilevels 2a and 2b as well as h = 9,Z = 1 for variant Multilevel 1. More detailed results of the latter tests are given in [48].

Next, we tested the different local search variants for both objective functions against the other variants mentioned in Section 4.1. In particular, we considered the following variants.

VARIANT MS(S-S). Multistart descent algorithm with four starts using the shift-shift neigh- bourhood and nsollfour solutions generated per run.

VARIANT SA(S-S); SA(API-ASI). S imulated annealing in the shift-shift neighbourhood and the API-AS1 neighbourhood, respectively, with nsol solutions generated.

Class

a

g

j

DPT

SIT

DST

DPT

SIT

DST

2.19 6.11

1.20 5.03

0.58 2.01

a all 0.89 3.51

b all 1.63 2.38

c all 1.14 3.23

d all 1.15 3.96

e all 1.59 3.56

f all 1.38 2.91

g all 1.38 4.72

h all 1.14 4.04

i all 1.81 4.91

j all 1.32 4.39

all DPT 2.04 5.70

all SIT 1.49 4.01

all DST 0.50 1.57

all all 1.34 3.76

Type

DPT

SIT

DST

SA(S-S)

1.34

1 .oo

0.34

MS(S-S)

2.68

2.16

1.26

ML1 ML2a

0.98

0.20

0.33

DPT 1.10

SIT 2.81

DST 0.96

SA(API-ASI)

4.56

4.22

1.75

4.53

2.21

0.39

1.83

2.40

0.84

DPT 2.22 6.48 3.60

SIT 0.89 2.42 2.42

DST 0.29 0.80 0.32

0.79

0.72

0.35

1.04

0.46

0.12

1.11

0.42

0.42

1.25

1.36

0.60

0.75

0.15

0.11

DPT 2.08

SIT 1.28

DST 0.09

DPT 3.42

SIT 0.98

DST 0.37

6.45 4.16 0.49 0.24

4.43 2.33 0.17 0.24

0.99 0.74 0.15 0.11

5.69 5.46 0.35 0.59

3.98 2.89 0.39 0.58

1.02 0.94 0.23 0.14

DPT 1.89 3.77 4.32 0.50 0.49

SIT 2.01 4.23 2.62 0.67 0.77

DST 0.25 0.74 0.94 0.18 0.63

DPT

SIT

DST

DPT

SIT

DST

2.18 6.32 3.34 0.47 0.61

1.33 4.40 3.36 0.78 0.23

0.64 3.43 1.38 0.37 0.00

1.40 5.74 4.62 0.78

1.02 3.98 2.66 0.57

1.02 2.40 1.53 0.28

2.58 7.34

2.39 5.25

0.47 2.15

5.39 0.82

4.00 1.22

0.99 0.33

4.99 1.46

2.88 0.70

0.99 0.23

0.29

0.29

0.46

0.74

0.00

0.14

0.80

0.09

0.05

2.03 0.50

1.69 0.62

2.11 0.54

2.41 0.27

3.10 0.32

2.63 0.45

2.69 0.54

2.94 0.55

3.46 0.79

2.96 0.80

4.04 0.77

2.77 0.59

0.99 0.26

2.60 0.54

0.65

1.07

0.34

0.19

0.44

0.63

0.28

0.35

0.29

0.31

0.69

0.41

0.27

0.45

Heuristic Algorithms

Table 4. Comparison of iterative algorithms for C,,.

ML2b

1.57

0.96

0.80

1.18

0.45

1.22

1.04

1.37

0.25

1.00

0.67

0.17

1.21

0.59

0.17

0.43

1.26

0.48

1.32

0.57

0.77

1.62

0.41

0.24

0.12

0.53

0.39

0.62

0.51

0.21

1.11

0.95

0.89

0.62

0.65

0.72

0.89

0.76

0.35

0.44

1.01

0.73

0.47

0.74

TS(S-S) TS(API-ASI)

2.88 4.70

2.32 4.43

0.74 3.07

1.76 4.08

1.59 3.71

1.73 3.19

2.68 4.75

1.19 3.39

0.13 0.98

2.96

1.29

0.39

3.69

2.03

0.55

6.83

4.81

1.34

4.98

2.61

1.10

2.38 3.55

2.29 3.68

0.48 0.80

2.00 4.92

1.87 4.98

0.81 2.42

3.05

1.81

0.72

2.83

2.04

0.48

1.97

1.62

0.24

1.98

1.70

1.33

1.55

2.09

1.71

1.56

1.86

1.78

1.27

2.62

1.81

0.63

1.68

5.78

4.46

1.88

5.69

5.16

1.54

5.11

4.24

1.72

4.07

3.66

3.04

4.32

2.90

2.68

4.11

4.04

4.13

3.69

5.04

4.15

1.80

3.66

120 D. DANNEBERG et al.

Class

a

b

C

d

g

h

a

b

c

d

e

f

g

h

i

j

all

all

all

all

Type

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

DPT

SIT

DST

all

all

all

all

all

all

all

all

all

all

DPT

SIT

DST

SA(S-S)

2.32

0.71

0.43

1.68

0.31

0.45

SA(API-ASI)

3.29

2.10

2.61

2.14

2.84

1.23

1.06

0.63

0.08

1.82

0.64

0.57

2.13

0.79

0.57

1.18

1.01

0.63

0.75

0.60

0.78

2.36

0.39

0.32

0.88

0.25

0.16

1.41

0.74

0.21

1.15

0.81

0.59

1.01

1.16

0.94

0.71

1.02

0.43

0.79

1.56

0.61

0.42

6.53

4.29

2.62

11.29

5.65

4.77

4.62

9.27

2.85

5.02

3.81

0.82

10.23

5.97

2.84

10.29

7.71

1.83

18.19

18.18

8.03

21.05

16.89

5.83

2.67

2.07

4.48

7.24

5.58

3.22

6.35

6.61

14.80

14.59

9.27

7.67

3.34

MS( S-S) ML1

1.34 0.50

0.64 0.44

0.48 0.34

0.48 0.59

0.61 0.00

0.09 0.25

2.90 0.80

1.47 0.78

0.49 0.27

3.48 0.30

1.45 1.29

1.17 0.14

1.82 0.96

2.10 1.07

1.92 0.26

1.72 0.15

1.33 0.47

1.35 0.06

1.92 1.46

1.56 0.71

1.06 0.70

1.89 0.46

1.80 0.89

1.14 0.41

3.51 1.63

2.96 0.82

1.20 0.26

3.83 0.68

1.73 0.46

1.30 0.26

0.82 0.43

0.39 0.28

1.62 0.62

2.04 0.58

1.95 0.76

1.47 0.22

1.51 0.96

1.61 0.59

2.56 0.91

2.29 0.47

2.29 0.75

1.57 0.69

1.02 0.30

all 0.86 6.76 1.63 0.58

Table 5. Comparison of iterative algorithms for C wiCi

ML2a

0.18

0.00

0.46

0.37

0.33

0.60

2.04

0.36

0.78

0.71

1.20

0.41

2.43

2.05

1.21

1.15

2.14

1.26

2.33

1.38

0.22

0.89

0.96

0.31

1.86

1.32

1.22

0.68

0.86

1.19

0.21

0.43

1.06

0.77

1.90

1.52

1.31

0.72

1.47

0.91

1.26

1.06

0.77

1.03

ML2b

0.83

0.69

0.32

0.42

0.34

0.10

0.94

0.66

0.50

1.19

0.82

0.36

1.56

0.65

1.82

0.49

1.40

0.86

1.52

0.45

1.29

1.50

0.60

0.93

1.25

1.17

1.17

0.68

1.49

1.20

0.61

0.29

0.70

0.79

1.34

0.92

1.09

1.01

1.20

1.12

1.04

0.83

0.85

0.91

TS(S-S) TS(API-ASI)

1.63 4.79

0.95 2.43

1.22 1.80

0.50 1.48

0.77 0.81

0.49 0.90

2.62 8.76

2.05 3.01

0.75 3.46

3.07 9.59

1.21 5.52

1.63 2.59

3.00 8.27

2.66 6.50

1.95 1.34

1.68 9.56

2.20 5.14

1.62 0.64

2.42 7.29

1.96 7.09

1.83 2.64

1.75 8.20

0.91 5.60

1.30 2.62

1.85 13.93

2.40 8.30

1.52 3.68

1.21 14.73

2.01 9.87

1.14 4.40

1.27 3.01

0.58 1.07

1.80 5.08

1.97 5.90

2.54 5.37

1.83 5.11

2.07 5.68

1.32 5.47

1.92 8.63

1.46 9.66

1.97 8.66

1.71 5.43

1.35 2.41

1.68 5.50

121 Heuristic Algorithms

Table 6. Numbers of best solutions obtained with each strategy.

r 1 c ax

ML1 ML2a ML2b

4 6 1

5 2 4

5 7 4

7 8 3

9 6 4

4 6 4

4 10 1

6 4 5

4 8 5

1 8 4

16 19 13

16 25 11

17 21 11

49 65 35

(APT-k) (g;, 1

0

4

1

1

1

1

0

0

2

Class Type

a all

b all

c all

d all

e all

f all

g all

h all

i all

j all

all DPT

all SIT

all DST

all all

Class Type

a all

b all

c all

d all

e all

f all

g all

h all

i all

j all

all DPT

all SIT

all DST

all all

C WiCi

ML1 ML2a ML2b

4 8 1

8 4 5

5 0 3

4 4 3

4 0 4

9 0 1

1 5 2

4 4 0

4 1 1

7 1 2

18 9 9

15 11 7

17 7 6

50 27 22

3

2

1

1

1

2

0

0

0

1

0

0

1

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

n

2

2

7

11

c:-:As,

2

5

6

3

5

1

7

5

8

3

0

1

10

11

(z:,

0

2

0

1

0

1

0

2

1

2

0

I (AP::SI) ( APT-SaSI)

0

0

0

0

1

1

0

0

0

0

1

4

0

0

1

0

0

0

0

0

0

2

1

0

0

2

0

0

0

n

7 0

20 0 XL 18 2

45 2 _I-

6 1

2 1

1 3

9 5 6 L L

VARIANT MLl; ML2a; ML2b. Multilevel Variants 1, 2a, and 2b, respectively, with parameter

nsol (since the stopping criterion is only checked after generating 1 low-level neighbours, the

number of solution generated could be slightly larger than nsol).

VARIANT TS(S-S); TS(API-ASI). Tabu search in the shift-shift and the API-AS1 neighbour-

hood, respectively, with nsol solutions generated in each case.

Note that the API-AS1 neighbourhood has only been included to test whether the meta-

heuristics are able to ‘compensate’ the application of a considerably ‘weaker’ neighbourhood in

comparison with the shift-shift neighbourhood. We generated, for each problem class and prob-

lem type, five instances, thus obtaining 150 instances. Since the computation of the objective function value is the most time consuming part, every algorithm with equal value of nsol uses

roughly the same amount of time (for nsol = lOOn, the average running time per instance is less

than 20 seconds on a Pentium PC (133 MHz)). The average percentage deviations from the best

solution value obtained in these tests with nsol = 1OOn are presented in Table 4 for C,,, and in

122 D. D~NNEBERG et al.

Table 7. Influence of the starting solution.

Class

a

b

c

d

e

f

g

h

i

all

all

all

all

Class

a

b

c

d

e

f

g

h

i

j

all

all

all

all

Type SA( S-S), Random SA(S-S), Ins MS(S-S), Ins

all 0.32 0.89 0.72

all 1.16 0.61 0.59

all 0.73 0.60 0.65

all 0.55 0.19 0.63

all 0.65 0.37 1.15

all 0.90 0.63 0.31

all 0.84 0.51 0.46

all 0.51 0.59 0.73

all 0.55 0.28 0.46

all 0.43 0.46 0.48

DPT 1.04 0.71 0.78

SIT 0.73 0.57 0.72

DST 0.22 0.26 0.35

all 0.67 0.51 0.62

c wici Type SA(S-S), Random SA(S-S), Ins

all 0.95 0.44

all 0.79 0.34

all 0.52 0.94

all 1.23 0.64

all 1.29 1.09

all 0.94 1.10

all 0.61 1.02

all 1.36 0.55

all 0.73 0.76

all 1.71 1.10

MS(S-S), Ins

0.29

0.26

0.12

0.34

0.48

0.26

0.67

0.75

0.70

0.27

0.51

0.39

0.34

0.41

Ins(O1)

5.38

6.26

5.67

4.28

6.28

4.56

4.36

3.85

5.19

3.23

5.35

5.77

3.60

4.90

Ins (05)

2.41

1.84

2.57

3.33

4.06

3.84

4.19

3.73

4.18

3.25

3.74

3.38

2.89

3.34 -1

Table 5 for C wiC,. Moreover, in Table 6 we give for each local search variant the number how often this variant has obtained the best solution value.

It can be observed that for the C,,, criterion multilevel procedures perform clearly best. Only

these procedures have an average deviation from the best value obtained than lower 1%. In

particular, procedure Multilevel 2a, which has clearly obtained most often the best value, and

also Multilevel 1 outperform the remaining variants. It can also be observed that the deviations

from the best value are smaller for the DST problems. Moreover, it can be seen that the choice

of a suitable neighbourhood is of fundamental importance. The application of the API-AS1

neighbourhood yields clearly worse results than using the shift-shift neighbourhood.

Similar results have been obtained for objective function C WiCi. However, here only procedure Multilevel 1 outperforms simulated annealing. The other multilevel procedures perform slightly

worse than simulated annealing (it is probably due to that fact, that no structural properties

can be used for guiding the local optimization in the low-level neighbourhood). The application

of the smaller API-AS1 neighbourhood leads to bad results (it confirms that the use of a weak

neighbourhood cannot be compensated by suitable control parameters of the metaheuristics).

Heuristic Algorithms 123

-4 -

-3 -

I -2 - m P & : m : -1 -

t 9 i n % O-

l-

2-

SA(SS)\,

L 25n

I I

10078 250n

Number of solutions nsd

I 5oon

Figure 3. Influence of parameter nsol for C,,,.

Next, we considered problem classes (i) and (j) and compared the local search algorithms SA, TS, and ML relative to each other for runs with nsol ranging from 25n to 500n. The

percentage improvements over the reference algorithm simulated annealing with nsol = 1OOn for

the C,,, criterion are given in Figure 3. It once more documents the superiority of the multilevel

procedure which has produced already with a small number of solutions (nsol = 25n) results of

similar quality as simulated annealing with nsol = 100n. This is in contrast to C wiCi, where

these short runs do not outperform the longer simulated annealing variants due to the fact that

no structural properties can be used for the local optimization phase. Also, for longer runs,

tabu search works worse than both multilevel and simulated annealing. For C wiCi, it is worth

mentioning that for long runs, both Multilevel 1 and Multilevel 2b have obtained the best values

followed by simulated annealing. The slight superiority of variant Multilevel 2b over Multilevel 2a

for C wiCi can be explained by the fact that the latter low-level neighbourhood probably has too

many neighbours if, contrary to C,,,, no structural properties are used in the local optimization

phase. Finally, we investigated the influence of the choice of a suitable starting solution. We compared

multistart and simulated annealing. The results are given in Table 7. Random means that an

arbitrary starting solution has been used and Ins means that we used as constructive initial solution the insertion variant recommended earlier for simulated annealing as well as several

124 D. DANNEBERG et al.

insertion variants for multi&art. It can be observed that a good starting solution only very slightly improves the results obtained with an arbitrary starting solution for C,,,. The situation is a bit different for criterion c wiCi. Here, the multistart procedure works very well, which is due to the smaller percentage deviations of the insertion algorithm of the insertion algorithm

from the best solution value obtained.

6. CONCLUDING REMARKS

In this paper, we considered different constructive and local search algorithms for the permu- tation flow shop problems with batch processing, where the processing time of a batch is given by the maximum processing time of an operation contained in the batch and the maximum batch size is limited. From our experiments, the following conclusions can be drawn.

1. Among constructive algorithms, insertion procedures work best. The insertion order has a substantial influence on the quality of the results. For C,,,, an insertion according to nonincreasing sums of the processing times of the batches is advisable whereas for

C WiCi, an insertion according to nonincreasing weights is preferable. Contrary to other problems, the choice of a suitable insertion order does not depend on the type of problems

considered (i.e., dominant setup or processing times). In particular, for minimizing C WiCi the average percentage deviation from the best solution value obtained is less than 3.5%.

2. Concerning the neighbourhoods, it appears to be advisable to apply shift neighbourhoods for both job and batch changes. The use of a neighbourhood based on ‘adjacent’ shift or interchanges of jobs or batches works badly (in particular for DPT problems) and this cannot be compensated by the inclusion of metaheuristics. The control of the generation of neighbours by means of two probability parameters (for controlling the generation of

batch or job changes as well as for the application of batch splitting) works well and it preserves the connectivity of the underlying neighbourhood graph.

3. For criterion C,,,, among iterative algorithms multilevel procedures work clearly best.

This is due to the inclusion of critical path considerations into the local optimization phase which allows us to guide the search to candidate solutions for an improvement of the objective function value.

4. For problems with minimizing c WiCi, procedure Multilevel 1 works well even without us- ing a specific constructive initial solution, but also procedure multistart is advisable when using ‘good’ constructive solutions. It has been observed that the percentage deviation of the insertion algorithms from the best solution value obtained is much smaller than for

c max and so multistart is competitive or even superior when good starting solutions have been used. The latter also confirms that the neighbourhood derived in this paper works

well.

In connection with multilevel procedures, we settled the parameters from a point of an equal number of solutions generated also with other metaheuristics. If the quality of the results is mainly of interest and long runs are possible, it might be that the local optimization phase should be extended (larger values of parameter 1). Alternative high-level neighbourhoods could also be a topic of further research. For instance, one can perform a certain number of low-level steps as generation of a high-level neighbour. This gives the possibility to enforce a certain distance of the high-level neighbour from the starting solution, whereas for the neighbourhood suggested in this paper, a move in the high-level neighbourhood could indeed be only a move in the low-level

neighbourhood. Further research can, for instance, investigate the influence of dropping the permutation flow

shop assumption that on all machines the same batches are formed. Of course, also problems with a mixture of batch and item availability can be considered (as it has been done for sum-time batch problems in [26]). It can be expected that, in this case, the probability parameter prob2 must be smaller in dependence on the degree of batch availability.

Heuristic Algorithms 125

REFERENCES

1. R.L. Graham, E.L. Lawler, J.K. Lenstra and A.H.G. Rinnooy Kan, Optimization and approximation in deterministic sequencing and scheduling: A survey, Ann. Discrete Math. 5, 287-326, (1979).

2. S.M. Johnson, Optimal two- and three-stage production scheduling with setup times included, Naval Res. Logist. Quart. 1, 61-68, (1954).

3. J.K. Lenstra, A.H.G. Rinnooy Kan and P. Brucker, Complexity of machine scheduling problems, Ann. Dis- crete Math. 1, 343-362, (1977).

4. H.G. Campbell, R.A. Dudek and M.L. Smith, A heuristic algorithm for the n-job, m-machine sequencing problem, Management Sci. 16, 630-637, (1970).

5. G.A. Cleveland and S.F. Smith, Using genetic algorithms to schedule flow shop releases, In Proceedings of the Third International Conference on Genetic Algorithms, (Edited by J.D. Schaeffer), pp. 16&169, Morgan Kaufmann, San Mateo, CA, (1989).

6. D.G. Dannenbring, An evaluation of flow shop sequencing heuristics, Management Sci. 23, 1273-1283, (1977). 7. E. Ignall and L. Schrage, Application of the branch and bound technique to some flow-shop scheduling

problems, Operations Res. 13, 400-412, (1965). 8. M. Nawaz, E.E. Enscore and I. Ham, A heuristic algorithm for the m-machine, n-job flow shop sequencing

problem, OMEGA 11, 91-95, (1983). 9. I.H. Osman and C.N. Potts, Simulated annealing for permutation flow-shop scheduling, OMEGA 17, 551-557,

(1989). 10. C.R. Reeves, Improving the efficiency of tabu search for machine sequencing problems, Journal Oper. Res.

Sot. 44, 375-382, (1993). 11. J.G. Shanthikumar and Y.B. Wu, Decomposition approaches in permutation scheduling problems with ap-

plications to the m-machine flow shop scheduling problem, European J. Oper. Res. 19, 125-141, (1985). 12. S. StGppler and C. Bierwirth, The application of a parallel genetic algorithm to the n/m/P/C,,, flowshop

problem, In New Directions for Operations Research in Manufacturing, (Edited by G. Fandel et al.), pp. 14% 160, Springer, Berlin, (1992).

13. E. Taillard, Some efficient heuristic methods for the flow shop sequencing problem, European J. Oper. Res. 47, 65-74, (1990).

14. F. Werner, Ein adaptives stochastisches Suchverfahren fiir spezielle Reihenfolgeprobleme, Ekonomicko-Ma&

ematicky Obror 24, 50-67, (1988). 15. F. Werner, On the heuristic solution of the permutation Row shop problem by path algorithms, Comp. Oper.

Res. 20, 707-722, (1993). 16. M. Widmer and A. Hertz, A new heuristic method for the flow shop sequencing problem, European J. Oper.

Res. 41, 186-193, (1989). 17. M.R. Garey, D.S. Johnson and R. Sethi, The complexity of flowshop and jobshop scheduling, Math. Oper.

Res. 1, 117-129, (1976). 18. S.L. van de Velde, Minimizing the sum of the job completion times in the two-machine flow shop by La-

grangean relaxation, Ann. Oper. Res. 26, 257-268, (1990). 19. R.A. Dudek, S.S. Panwalkar and M.L. Smith, The lessons of flowshop scheduling research, Operations Res.

40, 7-13, (1992). 20. S. Webster and K.R. Baker, Scheduling groups of jobs on a single machine, Operations Res. 43, 692-703,

(1995). 21. S. Albers and P. Brucker, The complexity of one-machine batching problems, Discrete Appl. Math. 47,

87-107, (1993). 22. C.L. Monma and C.N. Potts, On the complexity of scheduling with batch setup times, Operations Res. 37,

788-803, (1989). 23. D. Naddef and C. Santos, One-pass batching algorithms for the one-machine problem, Discrete Appl. Math.

21, 133-145, (1988). 24. C. Santos and M. Magazine, Batching in single operation manufacturing systems, Oper. Res. Letters 4,

99-103, (1985). 25. L. van Wsssenhove and C.N. Potts, Integrating scheduling with batching and lot sizing: A review of algorithms

and complexity, Journal Oper. Res. Sot. 43, 395-406, (1992). 26. Y.N. Sotskov, T. Tautenhahn and F. Werner, Heuristics for permutation flow shop scheduling with batch

setup times, OR Spektrmm 18, 67-80, (1996). 27. B.L. MacCarthy and J. Liu, Addressing the gap in scheduling research: A review of optimization and heuristic

methods in production research, Intern. J. Prod. Res. 31, 59-79, (1993). 28. A.J. Vakharia and Y.-L. Chang, A simulated annealing approach to scheduling a manufacturing cell, Naval

Res. Logist. 37, 559-577, (1990). 29. F. Werner and A. Winkler, Insertion techniques for the heuristic solution of the job shop problem, Discrete

Appl. Math. 58, 191-211, (1995). 30. H. BrLel, T. Tautenhahn and F. Werner, Constructive heuristic algorithms for the open shop problem,

Computing 51, 95-110, (1993). 31. P.S. Ow and T.E. Morton, The single machine early/tardy problem, Management Sci. 35, 177-191, (1989). 32. Y.N. Sotskov, T. Tautenhahn and F. Werner, On the application of insertion techniques for job shop problems

with setup times, RAIRO Rech. Oper. (to appear).

126 D. DANNEBERG et al.

33. W.E. Smith, Various optimizers for single-stage production, Naval Rex Logist. Quart. 3, 59-66, (1956). 34. R. Haupt, A survey of priority rule-based scheduling, OR Spektrzlm 11, 3-16, (1989). 35. S.S. Panwalkar and W. Iskander, A survey of scheduling rules, Operations Res. 25, 2561, (1977). 36. F. Werner, Some relations between neighbourhood graphs for a permutation problem, Optimization 22,

297-306, (1991). 37. P.J.M. van Laarhoven and E.H.L. Aarts, Simulated Annealing; Theory and Applications, Reidel, Dordrecht,

(1987). 38. F. Glover, Tabu search-part I, ORSA J. CompzLt. 1, 190-206, (1989). 39. F. Glover, Tabu search-part II, ORSA J. Comput. 2, 4-32, (1990).

40. E. Pesch and S. Voss, Strategies with memories: Local search in an application oriented environment, OR Spektrum 17, 55-66, (1995).

41. C.A. Glass and C.N. Potts, A comparison of local search methods for flow shop scheduling, Annals Oper. Res. 63, 489-509, (1996).

42. 0. Martin, S.W. Otto and E.W. Felten, Large step Markov chains for the traveling salesman problem, Complex

Systems 5, 299-326, (1989). 43. H.R. Loreqo, Job-shop scheduling: Computational study of large-step optimization methods, European J.

Oper. Res. 83, 347-364, (1995). 44. P. Brucker, J. Hurink and F. Werner, Improving local search heuristics for some scheduling problems. Part I,

Discrete Appl. Math. 65, 97-122, (1996). 45. P. Brucker, J. Hurink and F. Werner, Improving local search heuristics for some scheduling problems. Part II,

Discrete Appl. Math. 72, 47-69, (1997). 46. D.S. Johnson, C.H. Papadimitriou and M. Yannakakis, How easy is local search?, Journal of Computer and

System Science 37, 79-100, (1988). 47. E. Taillard, Benchmarks for basic scheduling problems, European J. Oper. Res. 64, 278-285, (1993). 48. D. Danneberg, Heuristic algorithms for permutation flow shop batch scheduling problems, (in German),

Diploma Thesis, Otto-von-Guericke-Universitgt Magdeburg, (1997). 49. U. Kleinau, Two-machine shop scheduling problems with batch processing, Mathl. Comput. Modelling 17

(6), 55-66, (1993).