Applying Column Generation to Machine Scheduling

8/3/2019 Applying Column Generation to Machine Scheduling

1/28

Chapter 11A P P L Y I N G C O L U M N G E N E R A T I O N T OM A C H I N E S C H E D U L I N GMarjan van den AkkerHan HoogeveenSteef van de VeldeA b s t r a c t The goal of a scheduling problem is to find out w hen each task mu stbe performed and by which machine such that an optimal solution isobtained. Especially when the main problem is to divide the jobs overthe machines, column generation turns out to be very successful. Ne xt

to a num be r of these 'par t i t ioning' problems, we shall discuss a num ber of other problems that have successfully been tackled by a columngeneration approach.

! IntroductionIn this chapter we discuss the apphcation of the technique of columngeneration to scheduhng problems. Scheduling problems appear in forinstance production facilities, where the goal is to find an optimal allocation of scarce resources to activities over time (Lawler, Lenstra, Rin-nooy Kan and Shmoys, 1993). The scarce resources are usually calledmachines, and the activities are called tasks or jobs; the basic schedulingproblem is then to find for each of the tasks an execution interval on oneof the machines that are able to execute it, such that all side-constraintsare met. Obviously, this should be done in such a way that the resultingsolution, which is called a schedule, is best possible, that is, it minimizesthe given objective function.Although the technique of column generation has been around sincethe early sixties, its first applicatio n to a machine scheduling problemis of a much later date. As far as we know, it was first used by Marjanvan den Akker. She wanted to solve single-machine scheduling problemswith an additive objective function by using polyhedral combinatorics.


2/28

304 COL UMN GENERA TIONTo this end, she formulated such a problem as an integer linear programming problem using a time-indexed formulation, which is based onbinary variables Xjt that indicate whether a job j {j = 1 , . . . , n ) s t a r t sat t ime t ( t = 0, . . . , T) . The solution to the LP-relaxation turned outto give a very strong lower bound for the small-sized problem instances,but at that time (1994), it was not possible to solve the LP-relaxation fora larger sized problem using the conventional techniques. To alleviatethis problem, she reformulated the problem by Dantzig-Wolfe decomposition and solved it by column gen eration . She prese nted these res ultsat a conference in Giens (France) and compared the performance of column generation to solving the time-indexed formulation with CPLEX,Robert Bixby, the man behind CPLEX, was in the audience, and heobviously was not happy hearing that CPLEX was not able to solve allthe instances. Therefore, he offered to try to solve some of the instancesusing CPLEX. The outcome was as follows: Bixby could solve the LPinstances using the CPLEX barrier method on a very fast computerbut still this required more computation time than column generation.Bixby sportingly admitted defeat and wrote to Marjan that she did noteven need to buy a better computer to solve these instances.After this initial success of column generation, attention shifted towards parallel machine scheduling problems with an additive objectivefunction, A parallel machine scheduling problem consists of two par ts:Determine for each job which machine should execute it, and given thisdecision, find an o ptim al schedule for each of th e resultin g single-machineproblems. If the difficulty of the problem lies in dividing the jobs overthe machines, that is, if it is easy to find an optimum solution giventhe set of jobs to be executed by each machine, then the problem canbe modelled as an integer linear programming problem in the followingway. First, enumerate all relevant subsets of jobs that can be assigned toa single machine and then formulate it as a set covering problem, whereeach jo b should be contained in exactly one subset of job s. Obviously,column generation seems to be an attractive technique to solve the LP-relaxation, as explicitly enumerating all relevant subsets is not a feasibleappro ach. Th is was discovered by three groups independently. Afterthese initial results, many follow-up papers have been written, dealingwith extensions.Finally, we discuss a number of problems that have been tackled byusing a combination of constraint satisfaction and column generation.Here we solve a linear programming problem using column generationto find out whether there can exist a feasible schedule. The problemsdiscussed here have an objective function of th e min m ax ty pe , w hereasthe problems discussed in the other sections are of the sum type.


3/28

11 Applying column generation to machine scheduling 305Since we are dealing with a large variety of proble m s, we intro du ce th enecessary not atio n in th e section in which the problem is described. Herewe use the three-field notation scheme introduced by Graham, Lawler,Lenstra and Rinnooy Kan (1979), to denote scheduling problems. Therem aind er of this chap ter is organized as follows. Since th e parallelmachine scheduling problem leads to a more HraditionaF column generation model than the single machine scheduling problem, in Section 2we discuss the parallel machine scheduling problem with the objectiveof m inimizing tot al weighted completion tim e. We describe here howto formulate it as an integer linear program and how to solve the LP-relaxation using column generation. We also show how to use this in a

branch-and-bound algorithm. We discuss and compare the implementations by Van den Akker, Hoogeveen and Van de Velde (1999); Chenand Powell (1999a). In Section 3 we briefly discuss a number of similar problems that can be solved in a similar way. In Section 4 we lookat the time-indexed formulation for single-machine scheduling problemsand show how the LP-relaxation of this formulation can be solved usingcolumn generation. Moreover, we stud y a column generation formulationfor a flow shop scheduHng problem, which can also be obtained from thetime-in dexe d form ulation. Finally, in Section 5 we discuss how columngeneration can be combined with constraint satisfaction.2. C o l u m n g e n e r a t i o n f o r P\\ YlwjCj

We start with describing the archetypal result in the area of parallelmachine scheduling that is solved using column generation. In Section 3we will see that similar results can be derived for many more problems.2 ,1 P r o b l e m d e s c r i p t i o n

The problem P | | "^WjCj is described as follows. There are m identical ma ch ines . M i , . . . , Mm^ available for processing n independent jobs,J i , . . . , Jn. Job Jj (j = 1,... , n) has a processing requirement of lengthPj and a weight Wj. Each machine is available from time zero onwardsand can handle no more than one job at a time. Preemption of jobs isnot allowed, that is, once started, the execution of the job must continueon the same machine until it has been completed. Hence, a schedule canbe specified by just specifying the completion times, which we denoteby Ci , . . . , Cni i t i s feasible if no job starts before time zero and if thereare at most m jobs being executed at the same time. Given these completion times, we can then find a feasible machine allocation, such thatno machine processes more than one job at a time and no job startsprocessing before tim e zero. Th e objective is to find a schedule with


4/28

306 COL UMN GENERA TIONminimum total weighted completion time Yllî^j^j- "^ê problem isA^P-hard in the strong sense when the number of machines is part ofthe problem instance. Smith (1956), has shown that the single-machineprob lem is solvable in 0 ( n log n) tim e. Th is algorithm is based on th eobservation that there exists an optimal schedule with the following twoproperties:

(i) The jobs are processed contiguously from time zero onwards,(ii) The jobs are sequenced in order of non-increasing ratios Wj/pj.

Since in the parallel machine case the machines are independent of eachother as soon as the jobs have been pa rtitioned , we know tha t there existsan optimal schedule in which each machine executes the jobs that havebeen assigned to it in order of non-increasing order of Wj/pj withoutany unnece ssary idle tim e. Th is implies th at the difficulty of solvingthis problem comes from finding an optimal division of the jobs over themachines. One way to achieve this is by applying dynam ic p rogram ming ;this can be implemented to run in 0{n{Yl^^^pj)'^~^^ time and space.Especially the space requirement becomes unmanageable when m orYl^=iPj increase.

To overcome this problem, we present a branch-and-bound procedure,where the lower bound comes from solving the LP-relaxation of a suitableinteger linear program m ing problem through column generation. Th isapproach has been applied by two groups of researchers: Van den Akker,Hoogeveen and Van de Velde (1999); Chen and Poweh (1999a). The onlydifference is in the branch-and-bound procedure; we will discuss bothprocedures in Section 2.5.Anticipating the branch-and-bound procedure by Van den Akker etal., we derive an execution interval for each job. The execution intervalof a job Jj is (j = 1,..., n) is specified by a release date rj, before whichit cannot be started, and a deadline dj, at which it has to be finished.We can derive initial release dates and deadlines from the following twocharacteristics that an optimal schedule is known to possess:

(iii) No machine becomes idle before the latest start time of a job.Therefore, the last job on any machine is completed between timeHmin = YJj=lVj/^^ - {m- l ) p m a x / m a n d i ^ m a x = E j ^ l ^ j / ^ +(m - l)pm ax/m , where pmax = ma xi< j Wk and pj < pk-, where at least one of the inequalitiesis strict, then there exists an optimal schedule in which job Jj isstar ted no later than job Jk-Property (iii) yields for each job an initial deadline dj Yll^îVkl'^ +(m l )p j/ m . We use Pro pe rty (iv) to derive tighter release dates and


5/28

11 Applying column generation to machine scheduling 307deadlines in the root node, and more effectively, in the nodes of thebra nc h-a nd -bo un d tree (see Subsection 2.5.1). Since Pr op ert y (ii) decrees that each machine executes the jobs in order of non-increasingWj/pj ratios, we reindex the jobs such that

!f > !f > . . . > !f .Pi ~ P2 ~ ~ Pn'to avoid trivialities, we assume that n> m. We define Vj as

Vj = {Jk\k < j , Wk > Wj.pk < Pj}

and Sj as Sj = {J'k \k> j,Wk< Wj.pk > Pj}.Accordingly, there is an optimal schedule in which all jobs in the set Vjstart no later than job Jj, Hence, if \Vj\ > m, then we may concludethat at least \Vj\ m + l jobs belonging to Vj are completed at or beforethe star ting time of Jj^ from which we can derive an earliest startingt ime. In a similar spirit, we can tighten the deadline of Jj.

2.2 IL P form ulat ionAs we have argued above, we have solved the P\\ X]j=i ^j^j pi*oblemwhen we have found the optimal assignment of the jobs to the machines.We define a machine schedule as a string of jobs that can be assignedtogether to any single machine. Let ajs be a constant that is equal to 1if jo b Jj is included in machine schedule s and 0 otherwise. Accordingly,the colum n ( a i s , . . , ,aris)"^ represents th e jobs in machine schedule s.Let Cj{s) be the completion time of job Jj in s; Cj{s) is defined only ifajs = 1. Because of Property (ii) above and the reindexing of the jobs,they appear in s in order of their indices without any idle time betweentheir execution. Hence, we have that Cj{s) = X1A)=I ^ksPk- So the costCg of machine schedule s is readily computed as

3 = 1 j=lX ^ o^ksPk

.k=l

We call a machine schedule s feasible if TJ + pj < Cj{s) < dj for eachjob Jj included in s. Let S be the set containing all feasible machineschedules. We introduce variables Xg {s =^ 1^.,, ^\S\) that assume value1 if machine schedule s is selected and 0 otherw ise. T he problem isthen to select m machine schedules, one for each machine, such thattogether they contain each job exactly once and minimize total cost.


6/28

308 COL UMN G ENERA TIONM athema t i ca l l y , w e have t o de t e rmine va lue s XQ t ha t so lve t he p rob lem

m in 2_. Cs^ssessub jec t to

E s = m^ (11.1)seSV ^ a j g X s ^ l , for e a ch j = 1 , . . . , n , (1 1-2)ses

Xs G { 0 , 1 } , for eac h 5 G 5 . (11.3)W e ob ta in t he l i nea r p rog ramming r e l axa t ion by r ep l ac ing cond i t i ons(11 .3) by the condi t ions Xg > 0 for all s E S; we do not need to enforceth e up pe r b ou nd of 1 for Xg, s ince thi s follows im m ed iate ly f rom th econd i t i ons (11 .2 ) . W e so lve t he LP- r e l axa t ion u s ing co lumn gene ra t i on .The in i t i a l se t S of co lumns can be genera ted heur i s t ica l ly , a f te r whichwe add co lumns wi th nega t ive reduced cos t , i f these ex is t .2,3 T he pr ic ing a lgo r i thmWe describe next the approach by Van den Akker, Hoogeveen andVan de Velde (1999). Th is is identical to th e approac h by Chen andPowell (1999a), except that Van den Akker et al. take the additionallygenerated release dates and deadlines into account.In our problem, the reduced cost c^ of any machine schedule s is givenby n

Cg Cs XQ 2_^ ^j^jsiwhere Ao is the given value of the dual variable corresponding to condition (11.1) and A l , . . . . An are the given values of the dual variablescorresponding to conditions (11.2). To test whether the current solutionis optimal, we determine if there exists a machine schedule s E S withnegative reduced cost. To that end, we solve the pricing problem of finding the machine schedule in S with minimum reduced cost. Since AQ is aconstant that is included in the reduced cost of each machine schedule,we essentially have to minimize

Cs - 2^Xjajs - 2_^ ^js


7/28

11 Applying column generation to machine scheduling 309subject to the release dates and the deadhnes of the jobs and Properties (i) and (ii).Ou r pricing algorithm is based on dynam ic programm ing. It uses aforward recursion, where we add th e jobs in order of increasing index. LetFj (t) denote the minimum reduced cost for all feasible machine schedulesth at consist of jobs from th e set { J i , . . . , Jj } in which the last job iscompleted at time t. Furthermore, let P{j) = Yli^iPk- Fo ^ ^he machineschedule that reahzes -Fj(t), there are two possibihties: Either Jj is notpart of it, or the machine schedule contains Jj, As to the first possibility,we must select the best machine schedule with respect to the first j Ijobs that finishes at time t; the value of this solution is Fj-i{t), T hesecond possibility is feasible only if Vj+pj < t < dj. If this is the case,then we add Jj to the best machine schedule for the first j 1 jobs tha tfinishes at time t pj] the value of this solution is Fj-i{t pj) + Wjt Xj.The initialization is then

^ ^ f -A o , if j = 0 and t = 0,I oo, otherw ise.Th e recursion is then for j = 1 , . . . ,n , t = 0 , . . . ,m in { P (j ) , maxi


8/28

310 COLUMN GENERATIONjobs Jj {j = 1, . . . ,n) the comple t ion t ime Cj{s) is equal to Cj in each5 6 5*. This special case plays a crucial role in the branch-and-boundalgorithm of Van den Akker et al.T H E O R E M 11.1 If Cj{s) =^ Cj for each job Jj {j = l , . . . , n ) and foreach s with x^ > 0, then the schedule obtained by processing Jj in thetime interval [Cj pj^ Cj] {j = 1 , . . . , n ) is feasible and has minimumcost.

If X* is fractional and does not satisfy th e con ditions of Th eore m 11 .1,then we need a branch-and-bound algorithm to find an optimal solution.We present two such algorithms in the next section.2.5 T w o b r a n c h - a n d - b o u n d a l g o r it h m s

It is well known that applying branch-and-bound in combination withcolumn generation makes sense only if it is possible to prevent a columnfrom being generated by the pricing algorithm when this column doesnot satisfy th e co nstr ain ts issued by the branch ing strategy. Van denAkker, Hoogeveen and Van de Velde (1999); Chen and Powell (1999a),present two alternative branching strategies in which the solution spaceis partitioned by imposing constraints on the columns that can easilybe incorp orate d in to th e pricing algorithm . We will first discuss theiralgorithms and then compare these.2 . 5 .1 B r a nc h ing on the e xe c ut io n in te r va l . We start withthe branch-and-bound algorithm by Van den Akker et al. If we have afractional optimal solution that does not satisfy the conditions of Theorem 11.1, then there is at least one job Jj for which

J2 Cj{s)x: > mm {Cj{s) \ x*, > 0} = C f " ;ses*

we call such a job Jj a fractional job. Our branching strategy is basedon partitioning the execution interval (see Carlier, 1987). In each nodeof the branch-and-bound tree, we first identify the fractional job withsmallest index, and, if any, then create two descendant nodes: One forthe condition that Cj < CJ^^^ and one for the condition that Cj >^min _|_ 2 rpj^^ ^g^ condi tio n essen tia lly specifies a new de ad lin e for Jjby which it must be completed, which is smaller than its current deadlinedj. For the problem corresponding to this descendant node, we thereforeset dj


9/28

11 Applying column generation to machine scheduling 311deadline dk. Hence, we let dk ^ min{d/c,dj pj +Pk} for each Jk G Vj.Since we have Vk C Vj for each job J^ G P j , up dating the deadline ofjob Jk will not lead to any further updates.The second condition specifies a release date C^^^ + 1 -- pj beforewhich Jj cannot be started, which is larger than its current release dateTj, For the problem corresponding to this descendant node, we thereforeset Tj = C^^^ + 1 Pj, Since the jobs in Sj start no earlier than Jj, wecan possibly increase th e release dat es of these jobs as welL For eachJk G


10/28

312 COL UMN GENERA TIONmachine; we introduce two dummy jobs Jo and Jn+i to model the casethat a job is the first or last one on a machine. The number of machinesthat is used is then equal to the number of immediate successors ofdummy job JQ.Given a solution of the linear program, we can compute for each pairof jobs Ji and Jj^ with i < j the value yij as

Vij / J ^s)

where Sij denotes the subset of the columns in which job Ji is an immediate predecessor of job Jj, We have the following theorem.T H E O R E M 11.2 / / the solution o f the linear programm ing formulationin a node leads to an integral set of yij values, then the correspondingsolution is optimal for this node.

If we encounter fractional values yij^ then we branch on the one thatis closest to 0.5; we impose the constraint of yij = 0 in the first branch,and we require yij = 1 in th e second branch . In bo th n odes, we removethe columns that do not satisfy the constraint. If the remaining set ofcolumns does not constitute a feasible solution, then we can apply someheuristic to find a schedule that satisfies all branching conditions, afterwhich we can add the corresponding machine schedules to the columnset. Unfortunately, we need to adjust the pricing algorithm to find thecolumns with minimum reduced cost that satisfy the branching conditions. We change the dynamic programming algorithm by recording theidentity of the job that completes at time t.Let Fj{t) denote the minimum reduced cost for ah feasible machineschedules in which Jj is the last job, which is completed at time t. Furthermore, let B{j) ( j =: 1 , . . . , n , n+1) denote the index set that containsthe indices of the jobs that are allowed as immediate predecessors of jobJj\ here B{n + 1) refers to the jobs that can finish last. To find the valueFj(t)^ we have to find the minimum of Fi{t pj) over all i G -(j), towhich we add the cost of completing job Jj at time t. After we havefound Fn{t) for all relevant values of t, we can compute the optimalsolution value as

F * = min FAt),Hnnn


11/28

11 Applying column generation to machine scheduling 313which Fj{t) < 0, where j is to restr icted to th e indices in the set B{n+1)]these can be found by backtracking.Note that the adjustment of the dynamic programming algorithm hasincreased its running time by a factor 0{n),2 .6 C om par ing t h e two a lgor i t hm s

In this subsection, we com pare the two algorithms w ith respect to theirrunn ing tim es and with respect to imp lem entation issues. Unfortunately,no study has been undertaken so far to compare the running times ofbo th algorithms; therefore, we provide only general rem arks w ith respectto this point.An obvious adva ntag e of th e algorith m by Van den Akker et al. isthat the running time of the pricing algorithm is not affected by thebranching scheme, whereas it now requires 0{ii?Yll=i'Pj) time in thealgorithm by Chen and Powell. A further advantage of the branchingscheme used by Van den Akker et al. is that release dates and deadlinesof other jobs can be strengthe ned using the sets Vj and 5j, which impliesthat a node not only can get pruned because of the lower bound, butalso because of its infeasibility with respect to the release dates anddead lines. Un fortunately , th is yields th e clear disad van tage th at , if itis unclear whether a node corresponds to a feasible schedule, then itis required to work with infeasible machine schedules that are madeunattractive by adding a penalty term to their cost.An advantage of the algorithm by Chen and Powell is that it is easierto implement, since in each node of the branch-and-bound tree it ispossible to find a set of columns that constitute a feasible solution.Overall, we expec t tha t on average th e algo rithm by Van den A kker et al.will be faster than the algorithm by Chen and Powell, but that it canbe m ore sensitive with respect to 'b ad ' instance s. We should keep inmind though, as reported by Van den Akker et al., that solving the LP-relaxation the first time is the bulk of the work. Hence, there is more tobe gained by solving the initial LP-relaxation, than by speeding up thebranch-and-bound algorithm.3. Rela t ed re su l t s

A similar approach as used for the P\\Y1 ^j^j problem can be appliedto a number of related parallel machine scheduling problems. Van denAkker, Hoogeveen and Van de Velde (1999); Chen and Poweh (1999a),extend the result of the previous section in two directions, which are prob lem s w ith add itive objective functions th at have all job s inthe relevant part of the schedule sequenced according to some pri-


12/28

314 COL UMN GENERA TIONority rule. Pro blem s th at fall in this category are th e problemof minimizing the weighted number of late jobs, which is denotedby P\\ ^WjUj^ and total weighted late work, which is denoted by

parallel machine problems with non-identical machines.We discuss these extensions in the next two subsections. After that, wedescribe some other related results that have appeared in the literaturesince the n. We only indic ate the majo r differences w ith the ap proa chused to solve the P\\ Y^WjCj problem.3 . 1 P r o b l e m s P\\ J2 ^jUj a n d P\\ ^ WjVjTh ese problem s are defined as follows. Again, th ere are m paralleliden tica l machines M i , . . . , Mm to process n jobs Ji, .. , Jn? where jobJj ( j = 1, . . . , n) has processing time pj and weight Wj, Moreover, eachjob Jj has a due date dj (j = 1,... , n) by which it ideally should be completed . In bo th cases jobs are not penalized as long as the y are com pletedat or before their due dates. If a job is completed after its due date, thatis , Cj > dj^ then it is called late, C/j (j = 1,..., n) is an indicator function that gets the value 1 if Jj is late, and 0, otherwise. The late workof Jj is defined as the portion of work of Jj that is performed after itsdue date dj. Accordingly, we have that Vj = minjp j , max{0 , Cj dj}].For either problem, there is an optimal schedule in which each machinefirst performs the on-time jobs in order of non-decreasing due dates andthen the late jobs in any sequence (Lawler and Moore, 1969; Potts andVan Wassenhove, 1992). The late jobs appear thus in the irrelevant partof the schedule, and in fact it does not matter if, when, and by what machine the late jobs are executed. These problems are therefore equivalentto maximizing Xl?=i ^ji^ ~ ^j)^ ^^e weighted number of on-time jobs,and jyj=i^j{Pj ~ ^')? ^^^ tota l weighted on-time work. These problems lend themselves much better for the column generation approach,since the pricing algorithm needs to focus then only on the on-time jobs.These complementary problems then boil down to determining values Xss e S that solve m ax y . c-s^ssessubject to

'^jsJl^j < 1, for each j = 1 , . . . ,n , (11-5)sesand con ditio ns (11.1) and (11.3). T he only difference, excep t for thecomputation of the cost Cg, is that only the (partially) on-time jobs will


13/28

11 Applying column generation to machine scheduling 315be present in one of the selected machine schedules. Relaxing the integrality constraints we are left with a linear programming problem thatcan be solved using column generation. Th e pricing algorithm maxim izesthe reduced cost, which can be achieved by applying dynamic programming, where the jobs are added in order of non-decreasing due date. Inthe dynamic programming algorithm, a job will only be included if it is(partially) on-time; we can incorporate release dates and deadlines.To find an optimal integral solution, we can again use one of the twobranch-and-bound algorithms described in Section 2.5. We refer to Chenand Powell (1999a); Van den Akker and Hoogeveen (2004), for details.3.2 N o n - i d e n t i c a l m a c h i n e sIf the machines are not identical, then the processing time of Jj depends on the machine Mi th at executes it. Th ere are two variants:Uniform and unrelated m achines. In th e first case, each m achine hasa given speed Si (i = 1,. . . , m), and the t ime needed to process job Jjon machine Mi is equal to pij Pj/si (i = 1 , . . . , m; j = 1 , . . . , n ) . Inth e lat ter case th e processing times can take any value. Th is implies,however, that in the latter case the priority rule is not equal for all machines for the objective of minimizing total weighted completion time.This can be easily overcome, though, by working with a different set ofmachine schedules for each machine. Let S{i) denote the set of feasiblemachine schedules for machine Mi {i l , . . . , n ) . W e need to a djustthe formulation given in Section 2.2 only slightly in case of non-identicalmachines. The problem then becomes

mm i n ^ X ] ^^ ^subject to 1=1 ses{i)

y ^ Xg 1, for each i == 1 , . . . ,m , (11.6)ses{i)

2_] / J cijsXs 1, for each j = 1,... , n,i=l seS{i)

Xs E {0,1}, for each s S{i)^ i = 1 , . . . , m .For the pricing algorithm, we need to perform the recursion m t imes,one time for each machine separately. Accordingly, the pricing algorithmruns in 0[nY^^i Y^l=iPij) time. Obviously, it is worth-while to reducethe set of eligible machines for each job by preprocessing.


14/28

316 COL UMN GENERA TIONTo find an integral solution, we must ap ply branch -and-b oun d. Th ebranch-and-bound algorithm of Chen and Powell can still be applied.The branch-and-bound algorithm by Van den Akker et al. cannot beapplied anymore, but this can now be replaced by a forward branchingstrategy where jobs are assigned to machines; this branching strategycan easily be combined with column generation.

3 .3 C o m m o n d u e d a t e p r o b l e m sIn case of a common due date problem jobs are penalized when theyare not completed exactly at their due date, which is common to alljobs. This objective function is motivated by the ' just-in-time' philosophy. Van den Akker, Hoogeveen and Van de Velde (2002), considerthe single-machine problem with the objective of minimizing the totalweighted deviation of the completion times from the common due date,which is denoted by d. The cost of completing job Jj {j == 1 , . . . , n) att ime Cj is then equal to aj{d Cj) if Cj < d\ it amounts to j{Cj d)if Cj > d, where aj and j are given. It is well-known that in case of alarge common due date there exists an optimal schedule in which somejob is completed exactly at time d; the common due date is considered

to be large, if ignoring the unavailability of the machine before timezero does not afi'ect the optimum solution. Under these circumstances,a schedule consists of an early and a tardy part, which comprises alljobs that are executed before and after the due date, respectively. It iseasily proven that, given the jobs that are in the early part, it is optimal to execute these in order of non-decreasing c^j/pj ratio, such thatthe last one is completed at time d. Similarly, the jobs in the tardypart must be executed in order of non-increasing j/pj ratio, where thefirst job starts at time d. Van den Akker, Hoogeveen and Van de Velde(2002), report that a straightforward appUcation of column generation,in which both pricing problems are solved independently through a dynamic programming algorithm like the one used to solve P\\ Y^'WjCj isable to solve problems with up to 60 jobs. But this performance can beimproved to solve problems w ith up to 125 job s by com bining co lumngeneration w ith Lagrangean relaxation. Th e main key to this successis not to solve both pricing problems independently, but to retain theconstraint that the total processing time of the jobs in the early andtardy part must sum up to Yll^riPj' Without this constraint we canonly conclude that the LP-relaxation has been solved to optimality ifthere is neither a miachine schedule for the early part nor for the tardypart with negative reduced cost. If we retain it, however, then we canstop column generation if there are no two machine schedules, one for


15/28

11 Applying column generation to machine scheduling 317the early and one for the tardy part, with total processing time equalto X)j=iPj wi^h total reduced cost smaller than zero. Since the totalprocessing of the machine schedule is kept in the state-variable used inthe dynamic programming algorithm, the constraint that the total processing time must be equal to Yll=iPj ^^ easily verified and provides nocomputational burden. Van den Akker et al. show how to derive an intermediate lower bound during the column generation process of solvingthe L P-relaxatio n. Th is can be used in a num ber of ways to speed upthe process of solving the LP-relaxation; for details we refer to Van denAkker et ah Quite unexpectedly, the solution to the LP-relaxation wasalways integral in all of their computational experiments; they show byexample that this is no structural result.Chen and Powell (1999b), generalize the above problem to the casewith m > 2 parallel identical machines. They solve the LP-relaxationthrough a standard implementation and apply branch-and-bound to f indan optimal solution, where they branch on the immediate successor. Intheir computational experiments they report that instances with up to60 jobs are solvable, where the hardest instances are the ones with 2machines.3.4 C o m m o n d u e w i n d o w p r o b l e m s

Chen and Lee (2002), generalize the common due date problem toa common due window prob lem . In this case, th e completion of a jobis penalized only if it falls outside this window, which we denote by[(ii,(i2]- There are m parallel identical machines to execute the jobs.The objective is to minimize total cost, where the cost of completingjob Jj is equal to aj{di Cj) if Cj < di and {Cj d^) if Cj > ^2,where aj and j are given. In contrast to the previous subsection, we donot assume that di is large. Therefore, we cannot guarantee that thereexists an optimal schedule in which a job is completed at time di or (i2,but in that case the first job must start at time zero. We partition eachmachine schedule into three parts: an early pa rtia l schedule, in which the last job com pletes at orbefore tim e d i. T he job s in this par t m ust be scheduled in non-decreasing order of aj/pj ratio; a fully ta rd y par tial schedule, in which th e first jobs sta rt at or aftertime ti2- The jobs in this part must be scheduled in non-increasingorder of /pj ratio; a middle parti al schedule.


16/28

318 COLUMN GENERATIONHere an early or fully ta rd y part ial schedule can be em pty. T he IL Pformulation is such that we search for at most m partial schedules ofeach type, such that for each early partial schedule that ends at time tithere exists a middle partial schedule that starts at time ti, and suchthat for each middle partial schedule that ends at time ^2 there existsone fully ta rd y p art ial schedule tha t s ta rt s at tim e ^2-We find a lower bound by solving the LP-relaxation through columngeneration. Here we need to find the early (fully tardy, middle) partialschedule with minimum reduced cost, which can be solved through adynam ic programm ing appro ach. Note tha t we do not have to solve aseparate pricing problem for each possible value of ti and ^2. This lowerbound is then used in a branch-and-bound algorithm where we branchon the immediate predecessor.3,5 Schedu l ing w i th se t -u p t im es

Chen and Powell (2003), have investigated an extension of the problems P\\ Y^WjCj and P\\ Yl^j^j involving set-up times. The jobs aredivided into several families, which roughly have the same characteristics. Before the start of a new job a set-up time is required, unless theconsecutive job s belong to th e sam e family. Th e set-u p times can beeither sequence dependent or sequence independent.We only work out the problem of minimizing total weighted completion time subject to sequence dependent set-up times; the other problems can be attacked in a similar fashion. Again, we work with machineschedules, which correspond to a given subset of the jobs and the order in which they are to be executed by a machine; we explicitly needthe ordering, since finding an optimal order for a given set of jobs is ahard problem. Our ILP formulation refiects that we look for m machineschedules containing each job exactly once with minimum total cost.If we solve the L P-relaxation using column gen eration in the sta nd ardway, then we need to generate machine schedules in which each job iscontained at most once, and the constraint that 'each job is containedat most once' makes the problem intractable. Therefore, we disregardthis constraint and generate machine schedules in which a job can becontained more than once; after all, these columns will not appear inan integral solution. We can find such a column through dynamic program m ing, where we use state-variables fj{t) that indicate the minimumreduced cost of completing job j at time t. In our branch-and-bound algorithm we branch on the imm ediate successor. A similar app roachoccurs in Subsection 4.1.


17/28

11 Applying column generation to machine scheduling 3193.6 Schedu l ing job s and m ain ten an ce ac t iv i t ies

Lee and Chen (2000), have studied another extension of the problemPW^'^jCj in which m ainte nan ce is required. Each mach ine needs tobe maintained once in the period [0 , r ] , which requires t t ime units.Lee and Chen (2000), study two variants of this problem, dependingon the capacity of the repair facility, which is either assumed to be oneor infinite. No te th at T is an upper bound on the completion of themaintenance; jobs can be completed after time T,If the capacity of the repair facility is infinite, then the machine schedules are independent except for the jobs that they contain. Any machineschedule then consists of two subsets of jobs with a maintenance activity in between, where the jobs within one subset are in order of non-increasing Wj/pj rati o. Ju st like in th e previous subsection , we allowany job to be part of both subsets of the same machine schedule; we canthen solve the LP-relaxation using column generation. We use this as alower bound in our branch-and-bound algorithm, in which we branch onthe immediate successor.The constraint that just one machine can be maintained at a timeyields an additional dependency between two machine schedules. Without loss of generality, we assume that the machines are maintained inorder of their index. Since the machines are no longer identical, we usea different set of machine schedules for each machine, where we add aseries of constraints in our ILP-formulation that decree that the completion times of the maintenance activities are at least t t ime units apartbetween two consecutive machines. We can then solve the LP-relaxationusing column generation in the same fashion as for the case with an infinite capacity of the repair facility. When we apply a branch-and-boundalgorithm in which we branch on the immediate successor, we run therisk that we do not end up with a feasible solution to the original problem, albeit that Lee and Chen (2000), report that this never happenedin their computational experiments. If this might occur, though, thenwe can find an optimal, feasible solution by branching on the executioninterval.4. Time- indexed fo rmula t i on

We describe next th e scheduling problems to which column generationwas applied the first time, which are the problems that can be formulated using a time-indexed formulation. Time-indexed formulations formachine scheduling problems have received a great deal of attention; notonly do the linear programming relaxations provide strong lower bounds,but they are good guides for approximation algorithms as well (see Hall,


18/28

320 COL UMN GENERA TIONSchulz, Shm oys and Wein, 1997). Un fortunately, a time-ind exed form ulatio n yields a large ILP-fo rmu lation. Van den Akker, Hu rkens andSavelsbergh (2000), have shown how Dantzig-Wolfe decomposition techniques and column generation can be applied to alleviate to some extentthe difficulties associated with the size of time-indexed formulations. Inth e next subs ection, we discuss their appr oach . After th at we stu dy aDantzig-Wolfe reformulation for the flow-shop scheduling problem withearliness, tardiness and intermediate inventory holding cost developedby Blbl, Kaminsky and Yano (2001).4 . 1 S i n g l e - m a c h i n e s c h e d u l i n g

A time-indexed formulation is based on time-discretization, i.e., timeis divided into periods, where period t starts at t ime t 1 and endsat time t. Th e planning horizon is denoted by T, which mean s th atwe consider the time-period s 1,2, . . . , r . Consider any single-machinescheduling problem in which the jobs are independent and the objectivefunction is of th e sum typ e. Using bin ary variables Xjt that indicatewhether job job j {j = 1, . . . , n) s tar ts in t ime per iod t {t = 1 , . . . , T Pj -h 1), we get t he following ILP -form ulatio n:

j = i t = isubject to

V ^ Xji = 1 for each j = 1 ,. . .n , (11.7)t= i

n tY^ J2 ^js < 1 for each t=:: 1, . . . ,T, (11.8)j = l s=t-pj + l

Xjt G {0,1} for each j = 1 , . . . ,n ; t = 1 , . . . , T pj + 1,where Cjt is equal to the cost that job j contributes to the objectivefunction when it starts in time period t. The assignment constraints(11.7) stat e th at each job has to be sta rted exactly once, and the capacityconstraints (11.8) state that the machine can handle at most one jobduring any time period.We apply Dantzig-Wolfe decomposition to the LP-relaxation of theabove model. We obtain the reformulation by representing the polytopeP given by the capacity constraints (11.8) and the nonnegativity constrai nts as the convex hull of its extrem e points. Since the constrain t


19/28

11 Applying column generation to machine scheduling 321

Figure ILL The network N for a 2-job example.matrix of P is an interval matrix^ the extreme points are integral, andtherefore, they represent schedules. As the assignment constraints (11.7)are not involved in the description of P, jobs do not have to be started exactly once in such a schedule. Therefore, we call these ps endo-schedules.Let x^ {k l , . . . , i ^ ) be the extreme points of P, Any x e Pcan be written as J2k=^i ^k^^ ^^^ some nonnegative values A^ such thatYlk^i ^/c = 1- Using this, we can reformulate the LP-relaxation of thetime-indexed formulation with decision variables A/ . The cost coefficientof \k is then equal to the cost of the pseudo-schedule x^] the constraintthat each job j {j = l , . . . , n ) is started exactly once then becomesX^/c=i ^jk^k I5 where Ujk denotes the number of times that job j isstarted in pseudo-schedule x^, Finally, we have the convexity constraintstating that the sum of the lambda's is equal to one, and of course, thenonnegativity constraints.We solve the LP-relaxation through column generation, where we determine interesting pseudo-schedules. Pseudo-schedule x^ is characterized by the binary variables x^^, which indicate whether job j s tar ts att ime t. Given the dual variables TTJ ( j = 1, . . . ,n) , corresponding to thereformulated assignment con straint for job j , and a , corresponding tothe convexity constraint, we find that the reduced cost Ck of the variable\k is given by

n T-pj + 1^^^^ Yl {cjt-^j)x%-a, (11.9)Ignoring the constant a, we see that the pricing problem can be solved asfinding a shortest path in a network N. This network N has a node foreach of the time periods 1,2,. . . , T+\ and two types of arcs: Process arcsand idle time arcs. For each job j and each period t, with t < T pj -}-1,there is a process arc from t io t + pj representing that the machineprocesses job j during the time periods t , . , . , t + pj 1. Moreover, thereis an idle time arc from t to t + 1 (t = 1 , . . . , T ).If we set the length of the arc referring to starting job j in time periodt equal to Cjt TTJ, for all j and t, and we set the length of all idle time


20/28

322 COL UMN GENERA TIONarcs equal to 0, then the reduced cost of the variable \k is preciselythe length of path P^ minus the value of dual variable a. Therefore,solving the pricing problem corresponds to finding the shortest path inth e netwo rk A^ with arc length s defined as above. Since the ne twork isdirected and acyclic, the shortest path problem, and thus the pricingproblem, can be solved in 0{nT) t ime by dynamic programming.Van den Akker, Hurkens and Savelsbergh (2000), show that this column generation approach can be combined with polyhedral combinatorics. Here the goal is to strengthen the lower bound obtained from theLP-relaxation by adding inequalities that are violated by the current,fractional op tim um bu t th at are valid for the integral optim um . Vanden Akker, Hurkens and Savelsbergh (2000), show the following generalresult for any LP-problem obtained through Dantzig-Wolfe decomposition.T H E O R E M 11.3 If for an LF-problem obtained by Dantzig-Wolfe decomposition the pricing problem can be solved for arbitrary cost coefficients,i,e., if the algorithm for the solution of the pricing problem does not depend on the structure of the cost coefficients, then the addition of a validinequality dx < do in terms of the original variables does not complicatethe pricing problem.The computational results are somewhat disappointing, in the sensethat improving the quality of the lower bound by adding valid inequalities takes quite some. To find an optim al integral solution, we canapply branch-and-bound, where we can add valid inequalities in eachnode. Here we use a forward branching strategy, that is, we build a partial schedule from left to right, such that we can find a lower bound ineach node by solving the corresponding LP-relaxation through columngeneration.4 .2 F l o w s h o p s c h e d u l i n g

Blbl, Kaminsky and Yano (2004), consider a fiow shop schedulingproblem with earliness, tardiness, and intermediate inventory holdingcost. In a fiow shop each job m ust be processed by all of the m m achines, starting at machine 1, after which it moves to machine 2, etc.;the time needed to move from one machine to the next is negligible, butin the application studied by Blbl et al. intermediate products haveto be conserved, which cost is measured by the intermediate inventoryholding cost. The earliness and tardiness cost are defined on basis of thecompletion time on machine m. Finally, each job j has a release daterj at which it becomes available; the holding cost is computed from thistime on.


21/28

11 Applying column generation to machine scheduling 323For a given schedule a we use Cij to denote the time at which job j{j = 1 , . . . , n) finishes on machine i {i = 1, . , ^ ) , and we use qij todenote the t ime that job j spends in the queue before machine i. Wecompute the cost of schedule a as

n m n n

j= l i=2 3 = 1 j=lwhere hij is the holding cost per time unit for job j in the queue ofmachine i, and where aj and j are the earliness and tardiness cost ofjob j .We formulate this problem as an LP with variables Cij and qij. Tothis formulation we apply Dantzig-Wolfe decomposition, where we putthe constraints connecting the completion times of job j ( j = 1 , , . . ,m )on the different machines in the master problem, whereas we put thecon straints involving one machine at a time in the subproblem . An otherway to formulate th e problem is to use a time-ind exed formu lation. Sincethis time-indexed formulation has the same Dantzig-Wolfe reformulationas the formulation in terms of completions times, we can show that theoptimal value of the LP-relaxation of the Dantzig-Wolfe reformulationis at least equal to the value of the LP-relaxation of the time-indexedformu lation. For small instan ces, we can solve the latt er to o ptim alityusing CPLEX, and it turns out that the heuristic approach that we useto solve the former yields comparable bounds much faster.To apply the Dantzig-Wolfe reformulation for the model defined in Cijand Qij variables, we must for each machine i {i =^ 1 , . . . , m) e nume r ateall feasible schedules af^ which are expressed in completion times C^^-,{j = 1,... ,n). We then have to select one schedule total per machine(which can be a convex combination of a number of schedules af)^ suchthat the constraints stating that the jobs visit the machines in the rightorder are satisfied. Obviously, we apply column generation to avoid thefull enu m eratio n of th e single-machine schedu les. For machines 1 to m1the pricing problem boils down to a problem of the form l|rj | ^WjCj^whereas for machine m the pricing problem has the structure of probleml | r j | Yli^j^j'^j'^j)' Hence, all pricing problems are strongly A^P-hard.To solve the subproblems we apply a heuristic by Blbl, Kaminskyand Yano (2001), which is based on a time-indexed formulation thatis relaxed to an assignment problem. We further determine additionalcolumns in the column gen eration step by applying local improvem ent tothe already generated single-machine schedules. To speed up the process,a whole number of other engineering tricks is applied. To obtain a goodheuristic solution, we use the information present in the near-optimalfractional solutions.


22/28

324 COL UMN GENERA TION5* Column genera t ion and cons t ra in t sa t i s fac t ion

In this section we discuss a number of problems that are solved byapplying a constraint satisfaction approach; this is suitable if the objective function is of the m in m ax kin d, like th e m akesp an (which is thecase in the problems we discuss below). In a first step, the minimizationproblem is transformed into a feasibility problem by asking the questionwhether there exists a feasible solution with value no more than T; theminimization problem is then solved by applying binary search over T,Because of the upper bound T on the makespan we can then derive execution intervals [vj^dj] for each job j {j = l , . . . , n ) , w h ic h the n a r enarrowed by applying techniques from constraint satisfaction (we referto Baptiste, Le Pape and Nuijten (2001), for details). If it is not possibleto decide the feasibility problem now, then we check another necessarycondition, which is based on linear programming.5.1 R eso urce co ns t ra in t p ro jec t schedul ing

The main difference between scheduling problems and resource constrained project scheduling problems is that there are no machines butresources, which can be renewable or non-renewable^ where a resource iscalled renewable, if it is required during the execution of a task, whichdoes not 'con sum e' it. Brucker and Knu st (2000), look at a stan da rdprob lem in which n jobs have to be scheduled. Each job j has a processing time pj (j = 1,... , n), and preemption is not allowed. Executingjob j requires rjk units of each renewable resource k (fc 1 , . . . , r ) o fwhich there are R^ units available at any point in time. Moreover, thereare precedence constraints, which decree that a job cannot start untila given set of predecessors has been co m pleted. T he goal is to find aschedule with minim um mak espan, w hich is equal to the com pletion timeof the job that finishes last. Brucker and Knust (2000), solve this problem by first applying constraint satisfaction, like described above. If adecision has not been reached yet, the authors check another necessarycond ition. Th is condition checks wh ether it is possible to get all th e workdone while respecting the execution intervals and, partly, the precedenceconstraints; it can be checked by solving a linear programming problem.Hereto, we sort all release dates and deadlines in a combined list andpartition the time horizon accordingly into a set of intervals. For eachinterval we derive all sets of jobs that can be executed simultaneouslyin this time interval, and for each such set we include a variable thatindicates the amount of time during which this set is executed. Then wecombine all intervals into one LP. Here we have for each job a constraintthat decrees that the total amount of work done on this job is at least


23/28

11 Applying colum n generation to machine scheduling 325equa l to the p rocess ing t ime , and fo r each in te rva l we have a cons t ra in tt ha t t he t o t a l t ime spen t on p roces s ing t he subse t s co r r e spond ing to t h i sin te rva l is no mo re th an th e s ize o f th e in te rva l ; we check w he the r th i s L Padmi ts a feas ib le so lu t ion . Note tha t a ^es ' answer does no t necessar i lylead to a feas ib le , p reempt ive schedule , because o f the p recedence cons t ra in t s be tween jobs tha t a re execu ted in d i f fe ren t se t s . We tu rn th i sLP- fo rmu la t i on i n to an equ iva l en t op t im iza t ion p rob lem in w h ich w emin imize t he t o t a l pena l ty , w he re a pena l ty t e rm i s added to measu rethe amount o f work on a job tha t i s no t execu ted . We so lve th i s p rob lemthrough co lumn genera t ion . Here , we have to f ind fo r each in te rva l thesub se ts o f ind ep end en t job s wi t h nega t ive redu ced cos t . S ince th i s isan i ndepen den t s e t p rob l em , w h ich is i n t r ac t ab l e , w e app ly b r anc h -an d -bound to solve i t (see Baar , Brucker and Knust , 1998, for deta i ls) . I f theoutcome of the LP-formula t ion does no t dec ide the feas ib i l i ty p rob lem,then w e can app ly a b r anch -and -bound a lgo r i t hm w i th a b r anch ing ru l ein which the execut ion interval of a job is spht (see Carher , 1987); we canapp ly t he comb ina t ion of cons t r a in t s a t is f ac ti on an d li nea r p rog ram mi ngin each node .Note tha t i t i s no t necessary to app ly cons t ra in t sa t i s fac t ion a t a l l toso lve th i s p rob lem. Brucker , Knus t , Schoo and Thie le (1998) , p resen t ab ranch -and -bound a lgo r i t hm fo r t he op t im iza t ion ve r s ion o f t he r e sou rcecons t ra ined pro jec t scheduhng prob lem def ined above , where the lowerbound i s de te rmined by so lv ing a s imi la r LP l ike the one above , wi thoutexecu t ion in te rva ls , and wi th the ob jec t ive o f min imiz ing the to ta l t imetha t a l l subse ts a re p rocessed ; th i s LP-prob lem i s aga in so lved us ingco lum n gene ra t i on . T he c lea r adv an ta ge of app ly ing cons t r a in t s a t i s fact ion f i rs t is that the execut ion interval gets spl i t up, which makes i teas ie r to so lve the p r ic ing a lgor i thm. Brucker and Knus t (2000) , do no tp r e sen t an e l abo ra t e compar i son o f bo th me thods , bu t t hey r emark t ha t4t conf irms the conclusions of Klein and Schol l (1999) , who reportedtha t de s t ruc t i ve me thods a r e o f t en supe r io r t o cons t ruc t i ve app roaches ' .In a fo l low-up paper Brucker and Knus t (2003) , app ly the i r approachof combin ing cons t ra in t sa t i s fac t ion and l inear p rogramming to an extended vers ion of the bas ic resource-cons t ra ined pro jec t schedul ing problem. In th is more general problem act ivi t ies can be executed in dif f 'erentmodes^ which may result in a different use of resources and a differe n t p r o c es s in g t i m e . F u r t h e r m o r e , t h e r e a r e m i n i m u m a n d m a x i m u mt ime- l ags a s soc i a t ed w i th each p r ecedence cons t r a in t , w h ich bound thed i f fe rence in s ta r t ing t ime be tween the two cor responding ac t iv i t i es . F i na l ly , the re a re a l so nonrenewable resources invo lved , which makes sensein th is se t t in g, s ince job s can be carr ied out in dif ferent m od es . T h eob jec t i ve is aga in t o min im ize t he make span . I t t u rn s ou t t ha t t he


24/28

326 COL UMN GENERA TIONsame approach can be applied, but we need to pay special attention tothe possibility of processing activities in a different mode. In our LP-formulation for a given time interval, we conclude that a given subset ofoperations can be executed at the same time if they satisfy the precedence constraints, the capacity constraints, if no job occurs in two ormore different modes, and if the remaining quantity of each of the nonrenewable resources is sufficient for processing the remaining activitiesin the mode that requires the minimum of that resource. Brucker andKnust (2003), report that this approach leads to very promising results.5.2 Schedu l ing a t r a ns po r t a t i o n rob o t

A further contribution by Brucker and Knust (2002), in this field concerns their work on the problem of scheduling a transportation robot ina job shop scheduling problem. In a job shop problem each job consistsof a number of operations that have to be carried out in a given orderby a prespecified machine. When an operation in a job has been completed, then this job has to be moved to the machine that executes thenext opera tion. Th is moving around is carried out by a robo t, whichcan transport only one job at a time. Brucker and Knust look at theproblem that remains when the order in which each machine executesthe operations of the different jobs is given: We have to find an optimal schedule for the robot. We model this by considering the robot asa single machine. The tasks that it has to execute correspond to themoving of a job in between the execution of two consecutive operationsof this job; if the corresponding operations are Oi and Oj^ then we callthis task Tij. The processing time of Tij is put equal to the time neededto tra ns po rt th e job between the corresponding machines. Th ere is ageneralized precedence constraint between each pair of tasks Tij and Tjkand associated with it is a minimum time-lag of size pj, such that Ojcan be processed in between. Similarly, if Oi is a direct predecessor ofOj on the same machine, where Oi and Oj belong to different jobs, thenwe introduce a generalized precedence constraint between the tasks Tkiand Tjk^ where Oh is the direct predecessor of Oi and Ok is the directsuccessor of Oj in the job, with a minimum time-lag of size pi -f-pj. Sincethe robot may have to travel empty to a machine to pick up some job,we have a sequence-dependent set-up time: If task Tj^ follows some taskTfii^ then a minimum time Sij has to elapse between the completion ofTfii and the start of Tj/^, where Sij is equal to the time needed to travelbetween the machines executing Oi and Oj. Finally, to cope with thebeginning 0^ and ending operation O^ of a job, we introduce a releasedate (tail) for the first (last) task corresponding to this chain. The re-


25/28

11 Applying colum n generation to machine scheduling 327lease date is equal to the ear l ies t possible complet ion t ime of O^, andthe ta i l has s ize pe- O ur goa l i s t o m in imize t he max imum delivery time^which i s equa l to the comple t ion t ime of a t ask on the machine p lusi t s t a i l (which i s ze ro , i f undef ined) ; th i s maximum de l ivery t ime thenco r r e sponds t o t he makespan o f t he j ob shop s chedu le .We s ta r t by app ly ing the cons t ra in t sa t i s fac t ion techniques , whichgives us execut ion intervals that must be sat isf ied to get a schedule withm a x i m u m d e l i v e r y t i m e n o m o r e t h a n T. W e then p roceed w i th an add i t iona l feas ib i l i ty check us ing co lumn genera t ion ; the approach used hereresembles the approach used in the t ime- indexed formula t ion . We sp l i tup t he p r ecedence cons t r a in t s such tha t w e ob t a in a number o f cha in s(which have a t mos t one predecessor and successor ) , which con ta in eachtask , and a remain ing se t o f p recedence cons t ra in t s . Our ILP formula t ionis based on identifying for each chain a feasible schedule for this set ofjobs ( tak ing in to account the t ime- lags and the execu t ion in te rva ls ) tha tcan be combined into a feasible schedule for the whole ins tance, that is ,these so-ca l led cha in-schedules mus t respec t the remain ing precedenceco ns t ra in t s an d th e cap ac i ty o f th e ma chin e . Ea ch cha in-sch edule isencoded by denot ing fo r each t ime- in te rva l [t 1, t ] w he th er a jo b is being processed and by denot ing the comple t ion t imes o f the jobs in thecha in - schedu le . W e app ly co lumn gene ra t i on t o so lve t he LP- r e l axa t ion ,where we have to iden t i fy in te res t ing cha in-schedules in each i t e ra t ion .Brucker and Knus t (2002) , show tha t the p r ic ing prob lem can be so lvedt o o p t i m a l i t y u s i n g d y n a m i c p r o g r a m m i n g .The par t i t ion ing of the p recedence cons t ra in t s in to cha ins i s no t un ique .In fact, if we let each chain consist of only one task (and keep all precedence cons t r a in t s exp l ic i t l y ), t hen w e ob t a in a time - indexe d fo rmu la t i on .I t i s easy to show tha t the LP-re laxa t ion of the above fo rmula t ion domina t e s t he LP- r e l axa t ion o f t he t ime - indexed fo rmu la t i on .ReferencesVan den Akker , J .M. , Hoogeveen , J .A . , and Van de Velde , S .L . (1999) .Pa ra l l e l mach ine s chedu l ing by co lumn gene ra t i on . Operations Re

search, 47 :862 -872 .Van den Akker , J .M. , Hoogeveen , J .A . , and Van de Velde , S .L . (2002) .Combin ing co lumn gene ra t i on and Lag rangean r e l axa t ion t o so lvea s ing l e -mach ine common due da t e p rob l em. INFORM S Journal on

Computing, 1 4 : 3 7 -5 1 .Van den Akker , J .M. , and Hoogeveen , J .A . (2004) . Min imiz ing the number o f t a rdy jobs . In : Handbo ok of Scheduling ( J . Y . - T . L e u n g , e d . ) ,


26/28

328 COL UMN GENERA TIONAlgorithms, Models, and Performance Analysis, pp. 227-243, CRCPress, Inc. Boca Raton, Fl, USA.

Van den Akker, J.M., Hurkens, C.A.J., and Savelsbergh, M.W.P. (2000).Time-indexed formulations for single-machine scheduling problems:column generation. INFORM S Journal on Computing^ 12:111-124.Baar, T., Brucker, P., and Knust S. (1998). Tabu-search algorithmsand Lower bounds for the resource-constrained project schedulingproblem. In: Meta-heuristics: Advances and Trends in Local SearchParadigms for Optimization^ (S. Voss, S. Martello , I. Osman, and C.Roucairol, eds.), pp. 1-18, Kluwer, Dordrecht.Ba ptis te, P., Le Pa pe, C , and Nuijten, W. (2001). Cons traint-BasedScheduling: Applying Constraint Programming to Scheduling Problems. Kluwer Academic Publishers, Dordrecht, The Netherlands.Brucker, P., Knust, S., Schoo, A., and Thiele, O. (1998). A branch-and-bound algorithm for the resource-constrained project schedulingproblem. European Journal of Operational Research^ 107:272-288.Brucker, P. and Knust, S. (2000). A linear programming and constraintpropagation-based lower bound for the RCPSP. European Journal of

Operational Research^ 127:355-362.Brucker, P. and Knust, S. (2002). Lower bounds for scheduhng a single robot in a job-shop environment. Annals of Operations Research^115:147-172.Brucker, P. and Knust, S. (2003). Lower bounds for resource-constrainedproject scheduhng problems. European Journal of Operational Re

search, 149:302-313.Blbl, K., Kaminsky, P, and Yano, C. (2001). Preemption in single-machine earliness/tardiness scheduling. Submitted to: Naval ResearchLogistics for pubhcation Department of lEOR, University of California at Berkeley.Blbl, K., Kaminsky, P, and Yano, C. (2004). Flow Shop Scheduhngwith Earliness, Tardiness and Intermediate Inventory Holding Costs.

Naval Research Logistics, 51:1-39.Carlier, J. (1987). Scheduling jobs with release dates and tails on identical machines to minimize makespan. European Journal of Operational

Research, 29:298-306.


27/28

11 Applying column generation to machine scheduling 329Chen, Z.L. and Lee, C.-Y. (2002). Parallel machine scheduhng witha common due window. European Journal of Operational Research^136:512-527.Chen, Z.L. and Poweh, W.B. (1999). Solving parallel machine scheduhngproblems by column generation. INFORM S Journal on Computing^11:78-94.Chen, Z.L. and Powell, W.B. (1999). A column generation based decomposition algorithm for a parallel machine just-in-time schedulingproblem. European Journal of Operational Research^ 116:220-232.Chen, Z.L. and Powell, W.B. (2003). Exact algorithms for scheduhngmultiple families of jobs on parallel machines. Naval Research Logistics, 50:823-840.Graham, R.L., Lawler, E.L., Lenstra, J.K., and Rinnooy Kan A.H.G.(1979). Optimization and approximation in deterministic sequencingand scheduling: A survey. Annals of Discrete Mathematics, 5:287-326.Hall, L.A., Schulz, A.S,, Shmoys, D.B., and Wein, J. (1997). Schedulingto minimize average completion time: Off-line and on-line approximation algorithms. Mathematics of Operations Research, 22:513-544.Klein, R. and Scholl, A. (1999). Conm putin g lower bou nds by destructiveimprovementan application to resource-constrained project scheduling. European Journal of Operational Research, 112:322-346.Lawler, E.L., Lenstra, J.K., Rinnooy Kan, A.H.G., and Shmoys D.B.(1993). Sequencing and scheduhng: Algorithms and complexity. In:Logistics of Production and Inventory (S.C. Graves, P.H. Zipkin, and

A.H.G. Rinnooy Kan, eds.), Handbooks in Operations Research andManagement Science, Volume 4, pp. 445-522, North-Holland, Amste rdam.Lawler, E.L. and Moore, J.M. (1969). A functional equation and its application to resource allocation and sequencing problems. ManagementScience, 16:77-84.Lee, C.-Y. and Chen, Z.L. (2000). Scheduhng jobs and maintenance

activities on parallel machines. Naval Research Logistics, 47:145-165.Potts, C.N. and Van Wassenhove, L.N. (1992). Single machine scheduhngto minimize total late work. Operations Research, 40:586-595.Smith, W.E. (1956). Various optimizers for single-stage production.Naval Research Logistics Quarterly, 3:325-333.


28/28

330 COL UMN GENERA TIONVandevelde, A.M.G., Hoogeveen, J.A., Hurkens, C.A.J., and Lenstra,J.K. (2004). Lower bounds for the head-body-tail problem on parallelmachines: A computational study of the multiprocessor flow shop.Forthcoming in: INFORMS Journal on Computing.

Documents

Applying Column Generation to Machine Scheduling