A branch and bound algorithm to minimize the total flow time for m-machine permutation flowshop problems

Int. J. Production Economics 79 (2002) 185–196

A branch and bound algorithm to minimize the total flow timefor m-machine permutation flowshop problems

Chia-Shin Chunga, James Flynna,*, Omer Kircab

aDepartment of Operations Management and Business Statistics, Cleveland State University, Cleveland, OH 44115, USAbDepartment of Industrial Engineering, Middle East Technical University, Ankara 06531, Turkey

Received 12 January 2001; accepted 12 March 2002

Abstract

The m-machine permutation flowshop problem with the total flow-time objective is a common scheduling problem,

which is known to be NP-hard for mX2: In this article, we develop a branch and bound algorithm to solve both the

weighted and unweighted version of this problem. Our algorithm incorporates a new machine-based lower bound and a

dominance test for pruning nodes. Computational experiments suggest that the algorithm can handle test problems

with np15: It also seems capable of dealing with larger problems for the unweighted objective, especially when the

processing times are correlated. r 2002 Elsevier Science B.V. All rights reserved.

Keywords: Scheduling theory; Permutation flowshop; Flow time; Machine-based lower bounds; Branch and bound

1. Introduction

In the permutation flowshop problem, each of n

jobs has to be processed on machines 1;y;m inthat order. The processing times of each job oneach machine are known. At any time, eachmachine can process at most one job and eachjob can be processed on at most one machine.Once the processing of a job on a machine hasstarted, it must be completed without interruption.Furthermore, each job must be processed in thesame order at every machine. The usual objectivesare the minimization of the make-span, flow time,tardiness, lateness, and the number of jobs late.For a review of the general flowshop problem, see

[1,2], and more recently [3]. In this article, theobjective is to minimize the total flow time. Flowtime measures the time a job stays in the system.Minimizing it amounts to maximizing the utiliza-tion of resources.

Schedules where each job must be processed inthe same order at every machine are calledpermutation schedules. When mp2; the restrictionto permutation schedules is harmless; however,when m > 3; there may exist a schedule whose totalflow is strictly less than the total flow of anypermutation schedule (see [1, Chapter 6]). Findingsuch a schedule is often computationally imprac-tical; so, most approaches to the m-machineflowshop problem restrict attention to permuta-tion schedules.

The single-machine case has been studiedextensively and it is well known that the SPT rule

*Corresponding author. Tel.: +216-621-6349.

E-mail address: [email protected] (J. Flynn).

0925-5273/02/$ - see front matter r 2002 Elsevier Science B.V. All rights reserved.

PII: S 0 9 2 5 - 5 2 7 3 ( 0 2 ) 0 0 2 3 4 - 7

minimizes the total flow time and the WSPT ruleminimizes the weighted total flow time. Most ofthe research in this area deals with specialvariations of the basic problem. For example,Sidney [4] and Potts [5] developed branch andbound algorithms to solve a problem withprecedence constraints. Bansal [6] and Potts andvan Wassenhove [7] considered weighted flow-timeproblems with constraints that require jobs tomeet their deadlines. Mason and Anderson [8]included job classes and setup times in their model.There is also considerable interest in problemswhich allow unequal release time for all jobs (see[9–11]).

Ignall and Schrage [12] developed a branch andbound algorithm for the two-machine case, whichwas extended to the m-machine case by Bansal[13]. Ahmadi and Bagchi [14] derived a newmachine-based lower bound for the m-machinecase and conducted computational experimentswhere their bound was strictly better than Bansal’sin 75–95% of the time. These experiments did notshow that the new bound improved the branchand bound algorithm’s performance. Note that allthese papers assume unweighted flow time.

Recently, other lower bounds have been devel-oped for the two-machine case. Van de Velde [15]proposed a bound based on the Lagrangeanrelaxation method. Hoogeveen and van de Velde[16] improved this bound by introducing slackvariables. Della Croce et al. [17] conductedexperiments that compare five lower boundingmethods with one of their own. They concludedthat, by combining van de Verde’s lower boundwith theirs, one can solve problems with up to 30jobs effectively.

There are only a few known solvable cases forthe m-machine total flow-time problem. Most ofthe research attempts to find conditions underwhich well-known rules such as SPT and WSPTare optimal. Panwalkar and Khan [18] show thatfor the m-machine case, the optimality of the SPTrule can be extended to an ordered flowshop wherethe order of the processing times on differentmachines is the same for each job. Szwarc [19]develops sufficient conditions for policies to beoptimal. (His conditions are automatically satis-fied by ordered flowshops.) Aderi and Amit [20]

show that the SPT rule is optimal for problemsthat satisfy a machine dominance condition. Notethat almost all solvable cases are for the un-weighted objective.

The general m-machine flow-time problemwith the total flow-time objective is known to beNP-hard for mX2 [21]. (For a thoroughcoverage of the complexity issues of machinescheduling problems, see [22,23].) Because of thedifficulty of finding optimal solutions to large-sizeproblems, there is considerable interest in devel-oping efficient heuristics. For recent developments,see [24,25].

Here, we first develop a branch and boundalgorithm to solve the unweighted m-machinepermutation flowshop problem. (The basic struc-ture of the algorithm is similar to the onedeveloped by Potts [26] for the make-span objec-tive.) Then we extend our algorithm to theweighted case. The possibility of assigningweights to jobs makes the model more practical.Jobs can be assigned weights based on theircost and priorities. For example, more expensivejobs should be given larger weights, since thelonger they stay in the system, the higher isthe cost.

In Section 2, we briefly describe the problem andderive a new machine-based lower bound for theunweighted case, which dominates Bansal’s lowerbound. Our bound employs estimates of theearliest start time for jobs assigned to eachposition in the job sequence. Section 3 presents adominance test, which helps to prune nodes.Section 4 extends the lower bound and thedominance test to weighted problems. An outlineof the algorithm appears in Section 5. Section 6reports on computational experiments, whichevaluate our algorithm and compare our lowerbound with the one using the lower bound ofAhmadi and Bagchi [14]. Finally, Section 7 statesour conclusions.

2. The problem description and a lower bound

Branch and bound algorithms are commonlyapplied to the permutation flowshop problem,which is known to be NP-hard for mX2: The

C.-S. Chung et al. / Int. J. Production Economics 79 (2002) 185–196186

effectiveness of a branch and bound algorithm isheavily influenced by its lower bounds. Suchbounds are more useful when they are tighterand easier to compute. In this section, we developa useful machine-based lower bound.

To derive our bound, we assume that onemachine has unit capacity and the others haveinfinite capacity. (A machine’s capacity equals thenumber of jobs that it can handle simultaneously.)Jobs need not wait at infinite-capacity machines.Hence, one can obtain a lower bound on the totalflow time by solving a single-machine schedulingproblem. The computations are easy, since theSPT rule is optimal.

Consider the search tree for our algorithm (see[27]). The root node + represents the nullschedule. Every other node represents a partial

schedule s ¼ ðsð1Þ;y; sðsÞÞ; indicating that jobsðjÞ occupies the jth position on each machine,for 1pjps; where 1pspn: Any permutation %s ofthe set of unscheduled jobs defines a completeschedule s %s ¼ ðsð1Þ;y;sðsÞ; %sð1Þ;y; %sðn � sÞÞ: Byplacing any unscheduled job i in position (s þ 1),we produce a descendant node si ¼ðsð1Þ;y;sðsÞ; iÞ: This paper employs the followingadditional notation:

N ¼ 1;y; n The set of all jobspjk Processing time of job j on ma-

chine k

wj Weight of job j

GðsÞ Total flow time for jobs in thepartial schedule s

GW ðsÞ Total weighted flow time for jobsin the partial schedule s

s The number of jobs in the partialschedule s

U The set of jobs that are notincluded in the partial schedule s

LkðsÞ Completion time of the last job ins on machine k

qjuv ¼

Pvr¼u pjr; for 1pjpn and 1pupvpm;

0; otherwise:

(

Next, consider our lower bound on the totalflow time at node s: Temporarily assumethat machine k has unit capacity and the others

have infinite capacity. Our lower bound isbased on estimates of the earliest possible starttime for any job in U assigned to position t;where s þ 1ptpn: The idea behind theseestimates is that a job can be processed at amachine only when both the job and the machineare ready. For 1prpk � 1; let q½sþ1�;r;k�1 denotethe smallest qj; r; k�1 for jAU : Also, let p½sþ1�k;p½sþ2�k;y; p½n�k denote a permutation of the pro-cessing times of the jobs in U on machine k; whichsatisfies p½sþ1�kpp½sþ2�kp ?pp½n�k: The procedurefor finding our lower bound is described asfollows.

Step 1: Set Esþ1;1 ¼ L1ðsÞ and Rs;1 ¼ L1ðsÞ;

Rt1 ¼ Rt�1;1 þ p½t�1 � Rs;1 þXt

r¼sþ1

p½r�1;

t ¼ s þ 1;y; n;

Et1 ¼ Rt�1;1; t ¼ s þ 2;y; n:

Step 2: For k ¼ 2;y;m;

Esþ1;k ¼ maxfLkðsÞ;

max1prpk�1fEsþ1;r þ q½sþ1�;r;k�1gg;ð1Þ

Rsk ¼ Esþ1;k; ð2Þ

Rtk ¼ Rt�1;k þ p½t�k � Rs;k þXt

r¼sþ1

p½r�k;

t ¼ s þ 1;y; n; ð3Þ

Etk ¼ maxfRt�1;k;Rt;k�1g; t ¼ s þ 2;y; n: ð4Þ

For tXs þ 1; Etk is an underestimateof the earliest start time of the tth job on machinek and Rtk is an underestimate of the earliestcompletion time of the tth job on machine k:Recursive equation (1) estimates the earliesttime to start the first unscheduled job, which isthe earliest time that both machine k andthe ðs þ 1Þth job are ready. Note that wedo not specify what the ðs þ 1Þth job is.Eqs. (2) and (3) estimate the earliest completiontimes of all unscheduled jobs at machine k:Eq. (4) provides a lower bound for the start timeof any job assigned to the tth position onmachine k:

C.-S. Chung et al. / Int. J. Production Economics 79 (2002) 185–196 187

A lower bound LB on the total flow time atnode s is computed as follows:

LBk ¼Xn

t¼sþ1

Etk þXjAU

qjkm; ð5aÞ

LB ¼ GðsÞ þmax1pkpm LBk; k ¼ 2;y;m:

ð5bÞ

Remark 2.1. One can reduce the computationaleffort by performing certain preliminary calcula-tions before starting the branch and boundalgorithm. For k ¼ 1; 2;y;m; let að1; kÞ; að2; kÞ;y; aðn; kÞ denote a permutation of the integers1; 2;y; n such that pað1;kÞ;kppað2;kÞ;kp?ppaðn;kÞ;k:Similarly, for 1pupvpm; let bð1; u; vÞ; bð2; u; vÞ;y; bðn; u; vÞ; denote a permutation of 1; 2;y; nsuch that qbð1;u;vÞ;uvpqbð2;u;vÞ;uvp?pqbðn;u;vÞ;uv: Theaðj; kÞ’s and bðj; u; vÞ’s can be calculated at thebeginning and saved for future access, thus savingunnecessary sorting. Given these objects, thecalculations of p½sþ1�k through p½n�k for fixed k

and the calculations of q½sþ1�;r;k�1 for fixed r and k

require OðnÞ calculations. Hence, one can evaluateLB for a given node s using Oðm2nÞ calculations.(Doing m iterations of (1) requires Oðm2nÞcalculations. The remaining work requires OðmnÞcalculations.)

Bansal [13] developed a lower bound for the m-machine problem with unweighted total flow-timeobjective. There are three basic steps in developinghis machine-based bound. First, he uses thefollowing formula to estimate the earliest starttime at machine k for every unscheduled job:

ESTðs; kÞ ¼maxfLkðsÞ;max1prpk�1fLrðsÞ

þ q½sþ1�;r;k�1gg: ð6Þ

Second, he assumes infinite capacities at everymachine except at machine k: Third, he applies theSPT rule to schedule jobs at machine k: Using thisprocedure, he develops the lower bound LS below,

LSk ¼Xn

t¼sþ1

ðESTðs; kÞ þXt

r¼sþ1

p½r�kÞ þXjAU

qj;kþ1;m;

ð7aÞ

LS ¼ GðsÞ þmax1pkpm LSk: ð7bÞ

The main difference between LSk and LBk isthat the estimated start time for all unscheduledjobs is the same in LSk; while the estimated starttime of a job depends on the position of the job inLBk: One can easily show that Etk > ESTðs; kÞ þPt�1

r¼sþ1 p½r�k for all k: Furthermore, qj;kþ1;m � pjk þqj;kþ1;m and (5a) imply that LBk ¼

Pnt¼sþ1ðEtk þ

p½t�kÞ þP

jAU qj;kþ1;m: These results imply thatLBkXLSk for all k; which implies the followingtheorem.

Theorem 2.1. LB dominates LS; the lower bound of

Bansal.

Our computational experiments in Section 6find that dominance is often strict. Ahmadi andBagchi [14] developed a lower bound, which alsodominates Bansal’s bound. (There is no dom-inance relationship between Ahmadi and Bagchi’s(A&B’s) bound and our bound.) The calculationsfor A&B’s bound entail minimizing the total flowtime for each of m single-machine problems withpreemption and release times. For such problems,the shortest remaining processing time rule(SRPT) is optimal and requires Oðn logðnÞÞ com-putation time [1], which implies that the timerequirement for A&B’s bound is Oðmn logðnÞÞ [14].Since our bound has time requirement Oðm2nÞ andsince n is much larger than m in most practicalsituations, this suggests that our bound is typicallyeasier to compute. In the computational experi-ments of Section 6, our bound tends to prune morenodes and require less time. Note that a majoradvantage of our bound over A&B’s bound is thatonly our bound naturally extends to a usefulbound for weighted problems. (A&B’s bound doesnot extend, since the SRPT rule is not optimal forthe weighted flow-time problem.)

3. Dominance criteria

Here, we define a dominance relation betweenpartial schedules, which can help us to prunenodes.


Definition 3.1. Let s1 and s2 be two partialschedules for the same set of jobs S: We say thats1 dominates s2; if Gðs1sÞpGðs2sÞ for everypermutation s of the jobs in N � S: If the previousinequality is strict, we say that s1 strictlydominates s2:

The following theorem develops conditions forone partial schedule to dominate another.

Theorem 3.1 (Node dominance). Let s1 and s2 be

two partial schedules for the same set of jobs S, and

let s ¼ jSj: If

Gðs2Þ � Gðs2Þ

Xðn � sÞmax1pkpmfLkðs1Þ � Lkðs2Þg ð8Þ

then s1 dominates s2: Moreover, dominance is strict

if inequality (8) is strict.

Proof. Let p ¼ j1j2?jn�s denote any permutationof the jobs in N � S; and let pi ¼ j1j2?ji; for1pipn � s: First, we prove that for i ¼1; 2;y; n � s;

Luðs1piÞ � Luðs2piÞpmax1pkpmfLkðs1Þ � Lkðs2Þg

for all 1pupm: ð9Þ

(Recall that Luðs1piÞ and Luðs2piÞ; respectively, arethe completion times of the last job in s1pi ands2pi at machine u:) It is well known that for1pupm;

Luðs1piÞ ¼ max1pvpufLvðs1pi�1Þ þ qjivug

� Lv1 ðs1pi�1Þ þ qjiv1u;

Luðs2piÞ ¼ max1pvpufLvðs2pi�1Þ þ qjivug

� Lv2 ðs2pi�1Þ þ qjiv2u;

where p0 denotes the null sequence and lpv1;v2pu: These results imply that

Luðs1piÞ � Luðs2piÞ

¼ ðLv1 ðs1pi�1Þ þ qjiv1uÞÞ � ðLv2ðs2pi�1Þ þ qjiv2uÞÞ

pðLv1 ðs1pi�1Þ þ qjiv1uÞÞ � ðLv1 ðs2pi�1Þ þ qjiv1uÞÞ

¼ Lv1 ðs1pi�1Þ � Lv1ðs2pi�1Þ

pmax1pkpmfLkðs1pi�1Þ � Lkðs2pi�1Þg:

UseLuðs1piÞ � Luðs2piÞpmax1pkpmfLkðs1pi�1Þ

� Lkðs2pi�1Þg

and an induction argument to get (9). Finally,GðsjpÞ ¼ GðsjÞ þ

Pn�si¼1 LmðsjpiÞ; for j ¼ 1; 2:

Hence,Gðs2pÞ � Gðs1pÞ

¼ Gðs2ÞGðs1Þ �Pn�s

i¼1 ðLmðs1piÞ � Lmðs2piÞÞ

XGðs2Þ � Gðs1Þðn � sÞmax1pkpmfLkðs1Þ

�Lkðs2Þg;

which is non-negative by (8), as required. &

Due to excessive memory requirements, it isimpractical to apply the above theorem directly.The following corollary applies to the special caseof consecutive jobs.

Corollary 3.1 (Job dominance). Let s be a partial

schedule for the set of jobs S; let s ¼ jSj; and let i

and j be distinct jobs in N � S. If

GðsijÞ � GðsjiÞ

Xðn � s � 2Þmax1pkpmfLkðsjiÞ � LkðsijÞg; ð10Þ

then sji dominates sij: Moreover, dominance is

strict if inequality (10) is strict.

4. Extension to the weighted objective

Our lower bound and elimination criteria can beextended to the weighted case, where each job isassigned a weight indicating its importance. Thepossibility of assigning weights to jobs makes themodel more practical; however, it also makes itharder to find an optimal solution.

A lower bound on the total flow time at node sfor the weighted case can be obtained by solvingthe following assignment problem:

MinPjAU

Pnt¼sþ1

wjEtkXjt þPjAU

wjqjkm

s:t:PjAU

xjt ¼ 1; for t ¼ s þ 1;y; n;ð11Þ

Xn

t¼sþ1

xjt ¼ 1; for jAU ;

xjtA1 ¼ f0; 1g for jAU and t ¼ s þ 1;y; n:


Here xjt equals 1 if job j is assigned to position t;and xjt ¼ 0 otherwise. The above objective functionunderestimates the total weighted flow time of alljobs in U : Therefore, GW ðsÞ plus the optimalobjective function for the above assignment problembecomes a lower bound on the weighted total flowtime at node s:Note that the second term in (11) is aconstant, which can be ignored when solving theassignment problem. The following theorem showsthat an optimal solution can be obtained by usingthe largest weight rule (LWR), which arranges thejobs in descending order of their weight.

Theorem 4.1. The LWR rule minimizes the objec-

tive in (11).

Proof. Consider any assignment that does notsatisfy LWR rule. There exists a tAfs þ 1;y; n �1g such that wrðtþ1Þ > wrðtÞ; where rðtÞ and rðt þ 1Þ;respectively, denote the jobs in positions t and t þ1: By interchanging jobs rðtÞ and rðt þ 1Þ; theobjective is decreased by

ðwrðtÞEtk þ wrðtþ1ÞEtþ1;kÞ � ðwrðtþ1ÞEtk þ wrðtÞEtþ1;kÞ

¼ ðwrðtþ1Þ � wrðtÞÞðEtþ1;k � Et;kÞ;

which is positive. &

Next, let w½sþ1�;w½sþ2�;y;w½n� denote a permuta-tion of the weights of the jobs in U which satisfiesw½sþ1�Xw½sþ2�X?Xw½n�: Theorem 4.1 implies thatWLB below is a lower bound on the weighted flowtime at node s:

WLBk ¼Xn

t¼sþ1

w½t�Etk þXjAU

wjqjkm;

k ¼ 1;y;m; ð12aÞ

WLB ¼ GW ðsÞ þmax1pkpmWLBk: ð12bÞ

The dominance results described in Section 3can be easily extended to the weighted case.Condition (10) of Corollary 3.1 becomes

GW ðsijÞ � GW ðsjiÞXX

rAU�fi;jg

wr

!

�max1pkpmfLkðsjiÞ � LkðsijÞg: ð13Þ

The proof is similar to that for the unweightedcase and will not be presented here. Note that if

wj ¼ 1 for 1pjpn; then WLBk ¼ LBk; WLB ¼LB; and (13) is equivalent to (10).

5. The algorithm

Branch and bound is commonly applied toscheduling problems. The algorithm of this paperemploys an adaptive depth-first plus backtracking

search strategy, which differs from the breadth-first

strategy of Bansal [13]. The advantages of a depth-first strategy are: (1) the number of active nodes isalways pn; (2) the bottom of the tree is reachedfaster so a feasible solution can be found earlier,(3) a stack can be used to reduce computations.

Our search strategy incorporates a dominance

and a best bound rule. Given the current node sr ¼ðsrð1Þ;y;srðrÞÞ; let Ur denote the set of all jobs notin the set fsrð1Þ;y;srðrÞg; and for each jAUr; letZrðjÞ denote the lower bound for node srj: Also, lets ¼ ðsrð1Þ;y;srðr � 1ÞÞ and i ¼ srðrÞ: (Note thatsi � sr:) For each jAUr; our algorithm dictates thefollowing. If node sij has not been previouslyfathomed, use the dominance test of (10) or (13) todetermine whether sji strictly dominates sij: If so,then fathom sij and assign to it the lower boundN;otherwise, compute a lower bound for sij: Finally,branch on the job j with the smallest lower bound.Calculating all these lower bounds costs additionaltime. However, our computational experience sug-gests that the benefits outweigh the costs.

To obtain an initial incumbent node, we use asimple m-machine heuristic. For each u and v with1pupvpm; consider a schedule which is gener-ated as follows. Compute qjuv for j ¼ 1; 2;y; n andthen schedule jobs in ascending order of qjuv;breaking ties arbitrarily. For each of these mðm þ1Þ=2 schedules, compute the objective function.Then select the minimum Z as the initial upperbound and a schedule s achieving the minimumas the initial incumbent. The rationale for this isthat if one treats machine u through machine v as asingle consolidated machine with unit capacity andassumes that the other machines have infinitecapacity, then one has a single-machine problemwhere the SPT rule is optimal. In the computa-tional experiments of Section 6, this heuristicproduces tight upper bounds. Our algorithm isoutlined below.


Step 1: Initialization. Set r :¼ 0; sr :¼ +; Ur :¼N , and ZrðjÞ :¼ 0 for all jAUr: Compute an upperbound Z from an initial feasible solution s : Goto Step 3.

Step 2: Dominance test. Set ZrðjÞ :¼ 0 for jAUr:Set s :¼ ðsrð1Þ;y;srðr � 1ÞÞ and i :¼ srðrÞ: Foreach jAUr; apply the dominance test to i; j; and s:Whenever sji strictly dominates sij; set ZrðjÞ :¼ N:

Step 3: Lower bound computation.

(a) For each jAUr such that ZrðjÞoN; compute alower bound ZrðjÞ for srj:

(b) If minjAUrZrðjÞ X Z then go to Step 5 else

continue to Step 4.

Step 4: Branch/Update upper bound.

(a) If rXn � 1 then let j0 be the unique element inUr;s :¼ srj0;Z :¼ Zrðj0Þ; and go to Step 5.

(b) Set j0 :¼ argðminjAUrZrðjÞÞ; r :¼ r þ 1;sr :¼

sr�1j0;Ur :¼ Ur�1 � fj0g; and Zr�1ðj0Þ :¼ N:Go to Step 2.

Step 5: Fathom.

(a) r :¼ r � 1; if ro0 then stop with the optimalsolution s and Z :

(b) If minjAUrZrðjÞXZ then repeat Step 5, else go

to Step 4.

6. Computational experiments

This section reports on computational experi-ments that evaluate the effectiveness of the optimalbranch and bound algorithm, compare the perfor-mance of our lower bound with A&B’s, and assessthe contribution of our dominance test. Ourresults suggest that our lower bound outperformsA&B’s and that our algorithm can handle testproblems with np15 for both the unweighted andweighted objectives. It also seems capable ofdealing with even larger problems for the un-weighted objective, especially when the processingtimes are correlated.

The algorithm was coded in C and run underBorland C++ version 5.0 on a 1700MHzPentium 4 processor under Windows 2000. Ourimplementation of the branch and bound algo-

rithm uses data structures to minimize redundantcomputations and employs integer variables wherepractical. All random numbers are generated by theran1 procedure from [28, Chapter 7]. A simpleheuristic described in Section 5 produces the initialincumbent node. Our branch and bound algorithmstops if the node count reaches the upper limit

of 4� 106 without finding an optimal node. Tomeasure performance, we record the computa-tion time and node count. To evaluate our heuristicfor an initial incumbent, we compute UB�1�(finalobjective function)/(initial objective function).(Note that if our algorithm stops before findingan optimal node, the final objective function issuboptimal, so UB is artificially small.)

Our problem generation procedure outlinedbelow yields test problems encompassing a widevariety of situations. For all problems, the proces-sing times are generated using a scheme like that ofLageweg et al. [27]. Specifically, for i ¼ 1;y; n andk ¼ 1;y;m; pik follows a discrete uniform dis-tribution on ½aik; bik�; where aik and bik aredependent on a trend and a correlation factor. Apositive trend in the processing time for job i

indicates that pik increases as k increases, while anegative trend indicates that pik decreases as k

increases. Similarly, a correlation between theprocessing times of job i exists if pi1; pi2;y; pin

are consistently relatively large or relatively small.For problems with correlation, additional integersri; i ¼ 1;y; n; are randomly drawn from{0, 1, 2, 3, 4}. Depending on the existence of atrend and/or a correlation, we consider the six p-types summarized below.

(I) Neither correlation nor trend: aik ¼ 1 andbik ¼ 100:

(II) Correlation only: aik ¼ 20ri and bik ¼ 20ri þ20:

(III) Positive trend only: aik ¼ 1212ðk � 1Þ þ 1; and

bik ¼ 1212ðk � 1Þ þ 100:(IV) Correlation and positive trend: aik ¼ 21

2ðk � 1Þ

þ20ri þ 1; and bik ¼ 212ðk � 1Þ þ 20ri þ 20:

(V) Negative trend only: aik ¼ 1212ðm � kÞ þ 1;

and bik ¼ 1212ðm � kÞ þ 100:

(VI) Correlation and negative trend: aik ¼ 212

ðm � kÞþ20ri þ 1; and bik ¼ 212ðm � kÞ þ20ri þ 20:


To study the unweighted objective, we useeleven combinations of m and n values:ðm; nÞ=(2,10), (4,10), (6,10), (8,10), (10,10),(2,15), (4,15), (6,15), (8,15), (2,20), and (4,20).For each ðm; nÞ and p-type (i.e., I–VI above), weproduce 50 random problems. This entails gen-erating random pik’s and ri’s that meet thespecifications described in the previous para-graphs. We use the resulting test bed of 3300problems for Tables 1–5, which summarize ourfindings for the unweighted objective. (For someðm; nÞ and p-types, we also ran experiments basedon 500 random problems; however, the resultswere similar to those reported here.)

Table 1 reports on how the mean and standarddeviation of the node count, computation time,and UB (in percent) vary with the p-type when

n ¼ 15 and m ¼ 4: The situation is typical of othern and m values. Problems with neither trend norcorrelation tend to be harder while those withcorrelation tend to be dramatically easier. Simi-larly, the UB values tend to be higher for problemswith neither trend nor correlation and tend to beclose to zero for problems with correlation (e.g.,see Table 3). The reason correlation makes jobseasier and UB values smaller is that given itspresence, some jobs tend to be more dominantthan other jobs, which increases the effectivenessof both our bounds and our heuristic for generat-ing initial solutions.

Table 2 reports on how the percentage ofproblems terminated early by our stopping rulend the mean and standard deviation of the nodecount, computation time, and UB (in percent) vary

Table 1

Unweighted case: mean and standard deviation of node count, computation time, and % UB as a function of p-type when n ¼ 15 and

m ¼ 4

p-type Node count Time (s) % UB

Mean s.d. Mean s.d. Mean s.d.

Neither correlation nor trend 30671.7 43,687.9 1.020 1.448 8.1 3.1

Correlation only 334.3 305.8 0.012 0.013 0.2 0.2

Positive trend only 2947.7 4656.3 0.093 0.146 7.0 2.5

Correlation and positive trend 804.9 1091.2 0.029 0.040 0.3 0.4

Negative trend only 10,253.8 35,010.6 0.351 1.129 2.5 1.4

Correlation and negative trend 153.8 181.7 0.005 0.007 0.2 0.1

Average 7527.7 14,155.6 0.252 0.464 3.1 1.3

Table 2

Unweighted case: mean and standard deviation of node count, computation time, and % UB, and % stopped as a function of n and m

n=m Node count Time (s) % UB % stopped


10/2 39.8 48.3 0.001 0.002 2.4 1.9 None

10/6 175.3 211.2 0.006 0.008 1.5 0.8 None

10/10 286.4 360.8 0.018 0.022 1.0 0.5 None

15/2 1353.6 2735.9 0.024 0.048 3.0 1.8 None

15/4 2415.8 14,155.0 0.252 0.464 3.1 1.3 None

15/6 16,387.4 21,228.6 0.875 1.104 2.3 0.9 None

15/8 29,957.8 51,014.1 2.271 3.586 2.0 0.6 None

20/2 184,417.1 458,847.0 4.468 10.744 3.3 1.9 2.67

20/4 441,022.1 636,623.0 23.178 32.600 3.7 1.3 6.67


Table 3

Unweighted case: mean and standard deviation of node count, computation time, and % UB, and % stopped for test problems with

correlation as a function of n and m



10/2 10.6 7.8 0.000 0.001 0.1 0.3 None

10/6 36.1 36.9 0.001 0.003 0.1 0.1 None

10/10 70.8 177.8 0.004 0.010 0.0 0.0 None

15/2 95.4 210.1 0.002 0.005 0.2 0.2 None

15/4 431.0 526.2 0.015 0.020 0.2 0.2 None

15/6 890.3 1585.6 0.048 0.083 0.2 0.2 None

15/8 2832.8 8723.5 0.186 0.502 0.1 0.1 None

20/2 1302.9 3393.0 0.033 0.101 0.3 0.4 None

20/4 13,210.8 42,630.4 0.704 2.391 0.3 0.2 None

Table 4

Unweighted case: mean and standard deviation of node count and computation time, and % stopped for Ahmadi and Bagchi as a

function of n and m

n=m Number of nodes Time (s) % stopped

Mean s.d. Mean s.d.

10/2 60.8 109.1 0.001 0.003 None

10/6 235.4 250.8 0.011 0.013 None

10/10 342.4 382.2 0.031 0.033 None

15/2 3296.8 7287.7 0.142 0.282 None

15/4 15,156.3 27,143.6 0.937 1.667 None

15/6 27,273.7 35,573.4 2.769 3.511 None

15/8 41,484.8 69,393.6 5.808 8.580 None

20/2 288,208.1 536,202.9 10.977 18.910 3.67

20/4 615,182.1 724,178.2 62.505 69.747 10.30

Table 5

Unweighted case: mean and standard deviation of node count and computation time, and % stopped when dominance test is

suspended as a function of n and m

n=m Number of nodes Time (s) % stopped

Mean s.d. Mean s.d.

10/2 57.9 77.4 0.001 0.002 None

10/6 193.0 240.0 0.006 0.008 None

10/10 301.3 397.1 0.018 0.024 None

15/2 4236.8 10,183.2 0.067 0.154 None

15/4 11,298.5 21,906.5 0.360 0.688 None

15/6 19,380.6 25,250.8 0.968 1.217 None

15/8 34,333.6 19,205.9 2.437 4.099 None

20/2 430,852.1 726,224.2 11.764 16.343 8.33

20/4 577,627.6 785,400.6 29.144 38.767 9.00


with n and m when averaged over all p-type values,while Table 3 does the same for test problems withcorrelation (i.e., p-type II, IV or VI). As expected,the means of the node count and computationtimes tend to increase with n and m: Our branchand bound algorithm performs adequately for alltest problems with correlation and for most testproblems with n ¼ 10 or 15: None of theseproblems are terminated early by our stoppingrule. Some of the others are hard to solve. Amongproblems without correlation, 5.33% with ðm; nÞ ¼ð2; 20Þ and 13.33% with ðm; nÞ ¼ ð4; 20Þ arestopped early. One noticeable feature of the resultsin Tables 1–3 is the high value of the variances ofthe node counts and computation times. This isdue to the presence of some hard problems.

Table 4 reports on the performance of thebranch and bound algorithm when the lowerbound of A&B’s replaces ours. (Everything elseis the same, including the dominance test.) The testproblems for Table 4 are identical to those forTable 2. For such problems, using A&B’s boundincreases the number of problems stopped earlyand multiplies the average values of the nodecount and computation time, respectively, by 1.47and 2.67. (When coding A&B’s bound, we employa heap to ensure that its computation time achievesits ideal level of Oðmn logðnÞÞ:) As mentioned inSection 2, there is no dominance relationshipbetween A&B’s bound and our bound. Hence,the maximum of these bounds provides a new andtighter lower bound. Extensive computational

experiments find that replacing our bound withthis new bound is not worthwhile, since it leads toan increase in the mean computation time.

For the experiments of previous paragraph, thedominance test was activated. In order to gaugethe effect of the dominance test, we conductedexperiments with the dominance test suspended,using the test problems for Table 2. For theseproblems, suspending the dominance test increasesthe number of problems stopped early and multi-plies the average values of the node count andcomputation time, respectively, by around 1.59and 1.44 (see Table 5). This suggests that thedominance test is very useful.

To study the weighted objective, we generate3300 test problems using the approach describedabove for unweighted problems. (For eachweighted test problem, we also generate weightswj ; 1pjpn; that follow a discrete uniformdistribution on [1,10].) In contrast to the un-weighted case, the values of the node count,computation time, and UB are not sensitive tothe p-type. In particular, our results for problemswith correlation are similar to those for problemswithout correlation. Table 6 reports on how thequantities of interest vary with n and m whenaveraged over all p-type values. As before, themeans of the node count and computation timestend to increase with n and m: Furthermore,weighted problems are harder to solve and havehigher UB values than unweighted ones. Thedifferences are greater for larger n: For n ¼ 20;

Table 6

Weighted problems: mean and standard deviation of node count, computation time, and % UB, and % stopped as a function of n and

m



10/2 230.9 306.4 0.002 0.005 12.2 5.5 None

10/6 325.0 355.6 0.010 0.012 5.8 3.1 None

10/10 344.9 444.9 0.022 0.025 3.8 2.0 None

15/2 31,995.9 89,140.9 0.471 1.133 15.3 5.5 None

15/4 56,871.7 138,923.4 1.984 4.685 11.4 3.9 None

15/6 58,601.9 13,007.3 2.976 6.227 9.1 3.1 None

15/8 63,134.0 143,223.0 4.684 9.989 7.3 2.7 None

20/2 1,789,465.4 1,560,441.7 41.153 35.445 15.5 5.9 27.33

20/4 2,123,175.0 1,459,539.9 113.150 75.914 13.4 4.1 36.33


we get the following results: The mean computa-tion time equals 77.152 seconds for weightedproblems and 13.383 seconds for unweightedproblems; furthermore, 31.83% of the weightedproblems and 4.67% of the unweighted problemsare stopped early. (No problems with no20 arestopped early.)

The main purpose of the paper is to present alower bound generation scheme and a dominancecriterion, which are used to improve a branch andbound algorithm. A limited computational experi-ment is conducted to test their effectiveness. It isdesigned to shed some light on the usefulness ofthe two features. A more general experiment willbe needed if one is interested in a full-scale study tofind the most efficient algorithm utilizing one or acombination of the existing bounds in the litera-ture.

7. Conclusions

The m-machine permutation flowshop problemwith the total flow-time objective is a commonscheduling problem, which is known to be NP-hard for mX2: Here, we develop a branch andbound algorithm to solve both the weighted andunweighted version of this problem. Our algorithmincorporates a new machine-based lower boundand a dominance test for pruning nodes. Compu-tational experiments suggest that the algorithmcan handle test problems with np15: It also seemscapable of dealing with larger problems for theunweighted objective, especially when the proces-sing times are correlated. Note that our algor-ithm’s ability to handle the weighted flow-timeobjective makes it more practical. Jobs can beassigned weights based on their cost and priorities.For example, more expensive jobs should be givenlarger weights, since the longer they stay in thesystem, the higher the cost.

For future research, we believe that the follow-ing topics are potentially useful: (i) the applicationof other solution techniques to the problem, e.g.,Lagrangean relaxation and slack variable decom-position; (ii) extending our branch and boundalgorithm to other objectives, e.g., the minimiza-tion of total tardiness or total weighted tardiness;

(iii) the development of efficient heuristics. Sincethe problem is NP-hard, it is unlikely that aneffective algorithm for solving large problemsexists, so (iii) is especially important. Our optimalbranch and bound algorithm can play a useful rolein evaluating the performance of any heuristic.

References

[1] K.R. Baker, Introduction to Sequencing and Scheduling,

Wiley, New York, 1974.

[2] R.W. Conway, W.L. Maxwell, L.W. Miller, Theory of

Scheduling, Addison-Wesley, Reading, MA, 1967.

[3] Lawler, E.L., J.K. Lenstra, A.H.G. Rinnooy Kan, D.

Shmoys, Sequencing and scheduling: algorithms and

complexity, in: S. Graves, A.H.G. Rinnooy Kan, P. Zipkin

(Eds.), Handbooks in Operations Research and Manage-

ment Science, Logistics of Production and Inventory,

Vol. 4, North-Holland, Amsterdam, 1993, pp. 445–522.

[4] J.B. Sidney, Decomposition algorithms for single-machine

sequencing with precedence relations and referral costs,

Operations Research 23 (1975) 283–298.

[5] C.N. Potts, A Lagrangean based branch and bound

algorithm for single-machine sequencing with precedence

constraints to minimize total weighted completion-time,

Management Science 31 (1985) 1300–1311.

[6] S.P. Bansal, Single-machine scheduling to minimize

weighted sum of completion times with secondary criter-

ion – a branch and bound approach, European Journal of

Operational Research 5 (1980) 177–181.

[7] C.N. Potts, L.N. van Wassenhove, An algorithm for

single-machine sequencing with deadlines to minimize total

weighted, completion time, European Journal of Opera-

tional Research 12 (1983) 379–387.

[8] A.J. Mason, E.J. Anderson, Minimizing flow time on a

single machine with job classes and setup time, Naval

Research Logistics 38 (1991) 333–350.

[9] L. Bianco, S. Ricciardelli, Scheduling of a single machine

to minimize total weighted completion time subject to

release dates, Naval Research Logistics Quarterly 29

(1982) 151–162.

[10] C. Chu, A branch and bound algorithm to minimize total

flow time with unequal release dates, Naval Research

Logistics 39 (1992) 859–875.

[11] S. Chand, R. Traub, R. Uzsoy, Single machine scheduling

with dynamic arrivals: Decomposition results and an

improved algorithm, Naval Research Logistics 43 (1996)

705–719.

[12] E. Ignall, L. Schrage, Application of the branch and bound

technique to some flow-shop scheduling problems, Opera-

tions Research 13 (1965) 400–412.

[13] S.P. Bansal, Minimizing the sum of completion times of n

jobs over m machines in a flowshop– a branch, bound

approach, AIIE Transactions 9 (1977) 306–311.


[14] R.H. Ahmadi, U. Bagchi, Improved lower bounds for

minimizing the sum of completion times of n jobs over m

machines in a flow shop, European Journal of Operational

Research 44 (1990) 331–336.

[15] S.L. van de Velde, Minimizing the sum of the job

completion times in the two-machine flow shop by

Lagrangian relaxation, Annals of Operations Research

26 (1990) 257–268.

[16] J.A. Hoogeveen, S.L. van de Velde, Stronger Lagrangian

bounds by use of slack variables: Applications to machine

scheduling problems, Mathematical Programming 70

(1994) 173–190.

[17] F.C. Della Croce, V. Narayan, R. Tadei, The two-machine

total completion time flow shop problem, European

Journal of Operational Research 90 (1996) 227–237.

[18] S.S. Panwalkar, A.W. Khan, An ordered flowshop

sequencing problem with mean completion time criterion,

International Journal of Production Research 14 (1976)

631–635.

[19] W. Szwarc, Solvable cases of the flowshop problem

without interruptions in job processing, Naval Research

Logistics 30 (1983) 179–183.

[20] I. Adiri, N. Amit, Openshop and flowshop scheduling to

minimize the sum of completion times, Computers and

Operations Research 11 (1984) 275–284.

[21] T. Gonzales, S. Sahni, Flow-shop and job-shop schedules:

Complexity and approximation, Operations Research 26

(1978) 36–52.

[22] A.H.G. Rinnooy Kan, Machine scheduling problems:

Classification, complexity and computations, Nijhoff,

The Hague, 1976.

[23] J.K. Lenstra, A.H.G. Rinnooy Kan, P. Brucker, Complex-

ity of machine scheduling problems, Annals of Discrete

Mathematics 1 (1977) 343–362.

[24] J. Ho, Y. Chang, A new heuristic for the n job, m machine

flow-shop problem, European Journal of Operational

Research 52 (1991) 194–202.

[25] C. Rajendran, Heuristic algorithm for scheduling in a

flowshop to minimize total flowtime, International Journal

of Production Economics 29 (1993) 65–73.

[26] C.N. Potts, An adaptive branching rule for the permuta-

tion flow-shop problem, European Journal of Operational

Research 5 (1980) 19–25.

[27] B.J. Lageweg, J.K. Lenstra, A.H.G. Rinnooy Kan, A

general bounding scheme for the permutation flow-shop

problem, Operations Research 26 (1978) 53–67.

[28] W. Press, S. Teukolsky, W. Vetterling, B. Flannery,

Numerical Recipes in C: The Art of Scientific Computing,

2nd Edition, Cambridge University Press, Cambridge,

1992.


Documents

A branch and bound algorithm to minimize the total flow time for m-machine permutation flowshop problems