Two machine preemptive scheduling problem with release dates, equal processing times and precedence constraints

European Journal of Operational Research 171 (2006) 107–122

www.elsevier.com/locate/ejor

Discrete Optimization

Two machine preemptive scheduling problemwith release dates, equal processing times and

precedence constraints

Irene N. Lushchakova *

Belarusian State University of Informatics and Radioelectronics, 6, P. Brovka str., Minsk 220027, Belarus

United Institute of Informatics Problems, National Academy of Sciences of Belarus, 6, Surganov str., Minsk 220012, Belarus

Received 3 June 2003; accepted 5 August 2004Available online 5 November 2004

Abstract

We consider a scheduling problem with two identical parallel machines and n jobs. For each job we are given itsrelease date when job becomes available for processing. All jobs have equal processing times. Preemptions are allowed.There are precedence constraints between jobs which are given by a (di)graph consisting of a set of outtrees and a num-ber of isolated vertices. The objective is to find a schedule minimizing mean flow time. We suggest an O(n2) algorithm tosolve this problem.The suggested algorithm also can be used to solve the related two-machine open shop problem with integer release

dates, unit processing times and analogous precedence constraints.� 2004 Elsevier B.V. All rights reserved.

Keywords: Scheduling theory; Identical parallel machines; Open shop

1. Introduction

We consider the following scheduling problem.There are M = 2 identical parallel machines and a set N = {1,2, . . .,n} of jobs. For each job i 2 N we

are given its release date ri P 0 when the job becomes available for processing. Each job i has to be proc-essed on any machine for pi time units. We suppose that all jobs have equal processing times, i.e. all

0377-2217/$ - see front matter � 2004 Elsevier B.V. All rights reserved.doi:10.1016/j.ejor.2004.08.037

* Address: Belarusian State University of Informatics and Radioelectronics, 6, P. Brovka str., Minsk 220027, Belarus. Fax: +375172 310914.E-mail address: [email protected]

mailto:[email protected]

108 I.N. Lushchakova / European Journal of Operational Research 171 (2006) 107–122

pi = p. Preemptions are allowed. After interrupting, job i may be processed on the other machine. Eachmachine can process at most one job at a time and each job can be processed on at most one machine ata time.There are precedence constraints between jobs of the set N, which are given by a reduction (di)graph G.

The set of vertices of the reduction graph G coincides with the set N of jobs and there is an arc from a vertexi to a vertex j iff job i immediately precedes job j.For a feasible schedule s, let Ci(s) be the completion time of job i. The objective is to find a schedule s*

minimizing mean flow timePi2NCi(s).

Following the notation system introduced by Graham et al. [5], we denote the described problem byP2jpi = p, ri,pmtn,precj

PCi.

Brucker and Knust [2] indicate that the P2jpi = p,pmtn, ri,chainsjPCi problem with graph G of a chain-

like structure is a minimal open one. In this paper we suggest an O(n2) algorithm to solve the more generalP2jpi = p,pmtn, ri,outtreesj

PCi problem where graph G contains a set of outtrees as well as a number of

isolated vertices (i.e. graph G is such that each vertex has no more than one predecessor).It should be mentioned that the P2jpi = p, ri,pmtnj

PCi problem without precedence constraints was

solved by Herrbach and Leung [6] in O(n logn) time.On the other hand, recently Brucker et al. [3] suggested an O(n2) algorithm to solve the Pjpi = 1, ri,out-

treesjPCi problem with arbitrary number of machines, integer release dates ri and unit processing times.

Brucker et al. [3] proved that for the Pjpi = 1, ri,pmtn,outtreesjPCi problem there exists an optimal sched-

ule without preemption. It follows that the Pjpi = 1, ri,pmtn,outtreesjPCi problem is solvable in O(n

2) time.Taking into account these results, we would like to emphasize that in the P2jpi = p,pmtn, ri,outtreesj

PCi

problem release dates are not sure to be integers (even if processing times are supposed to be unit). For thisproblem preemptions are advantageous.The paper is organized as follows. In Section 2 we explain the main idea of our method and describe the

algorithm for the P2jpi = p,pmtn,outtrees, rijPCi problem. The optimality of this algorithm is proved in

Section 3. In Section 4 we consider applications of the suggested algorithm to some other schedulingproblems.

2. The solution to the P2|pi = p,pmtn,outtrees, ri|+Ci problem

It is clear that any job having a predecessor cannot start the processing before the completion of its pred-ecessor. Algorithm 1 modifies the release dates of jobs, taking into account the given precedenceconstraints.

Algorithm 1

1. Form a set Q of jobs that have no predecessors.2. For each job i 2 Q set r0i ¼ ri.WHILE Q 5 ; DO3. Let i* be a job from the set Q. Form the set X(i*) of the direct successors of job i*.4. IF X(i*)5 ; THEN DO5. For each job i 2 X(i*) set r0i ¼ maxfri; r0i� þ pg.6. Supplement the set Q with the elements of the set X(i*).

END7. Eliminate job i* from the set Q.8. Go to Step 3.

END

Algorithm 1 can be implemented in O(n) running time.Now let us consider a simple example to illustrate the main idea of our approach.

Example 1. There are M = 2 identical parallel machines and n = 8 jobs with unit processing times. We aregiven the following release dates of the jobs:

I.N. Lushchakova / European Journal of Operational Research 171 (2006) 107–122 109

Fig. 2.schedu

r1 ¼ 0; r2 ¼ 0; r3 ¼ 0:25; r4 ¼ 0;

r5 ¼ 1; r6 ¼ 2:25; r7 ¼ 1; r8 ¼ 2:

The precedence constraints between jobs are given in Fig. 1. Using Algorithm 1, we obtain the followingmodified release dates of the jobs:

r01 ¼ 0; r02 ¼ 0; r03 ¼ 0:25; r04 ¼ 1;

r05 ¼ 1:25; r06 ¼ 2:25; r07 ¼ 2:25; r08 ¼ 3:25:

In this example the jobs are ordered according to nondecreasing order of their modified release dates.At first we assign jobs 1, 2, 3, 4 and 5 to machines. If we assign job 6 to machine 2 according to its release

date, we have an idle period on machine 2 (see Fig. 2a). Now we try to eliminate this idle period. We lookthrough the partial schedule backward in time until we meet the time period without any predecessor of job5. Since any job has no more than one predecessor, in that way we find the chain of continuously processedjobs in which job 5 is the last job. We call such a chain of jobs a ‘‘red chain’’. In this case we have the ‘‘redchain’’ (3;5). Notice that jobs 3 and 5 can start earlier by 0.25 unit. At the time moment 0.75 we interruptthe processing of job 2 on machine 2 and form the so called ‘‘green chain’’ which consists of a part of job 2

Fig. 1. The precedence constraints for the instance of Example 1.

(a) The partial schedule s6. (b) The transformed partial schedule s�6. (c) The partial schedule s8. (d) The transformed partialle s�8.


and job 4. Then we change this ‘‘green chain’’ and the ‘‘red chain’’ (3;5) on machines. Thus, we shift the‘‘green chain’’ forward in time and shift the ‘‘red chain’’ backward in time by 0.25 unit (see Fig. 2b). Assignjob 6 to machine 1 according to its release date. Notice that now we have no idle periods on machines. Thistransformation does not increase the value of the partial objective function.Assign job 7 to machine 2. It is clear that job 8 cannot start the processing before the completion of its

predecessor job 7. In this case we have an idle period on machine 1 before the start of job 8 (see Fig. 2c).Now we try to diminish this idle period. We look through the partial schedule backward in time until wemeet the time period without predecessors of job 7. We again find the so called ‘‘red chain’’ of jobs whichnow is (3;5;7). Jobs 3, 5 and 7 can start earlier by 0.5 unit. At the time moment 0.25 we interrupt theprocessing of job 2 on machine 2, transfer a part of job 2 after job 1 on machine 1 and shift the enlargedpart of job 2, job 4 and job 6 (the so called ‘‘green chain’’) forward in time. Then we shift the ‘‘red chain’’(3;5;7) backward in time. After this transformation job 8 can start earlier (see Fig. 2d). Suchtransformation does not increase the value of the objective function.

From Example 1 one can see that if we want to diminish an idle period on some machine, we shouldform the ‘‘red chain’’ and the ‘‘green chain’’ of jobs. Then we shift the ‘‘green chain’’ forward in timeand shift the ‘‘red chain’’ backward in time. Below we shall consider the procedure REDGREEN whichrealizes this transformation. Since any job has no more than one predecessor, we always can constructthe ‘‘red chain’’ of jobs without any ambiguity.Now let us denote F(L) the completion time of the last job assigned to machine L. Besides, denote Si the

starting time of job i.Algorithm 2 constructs an optimal schedule s* = sn for the problem under consideration.

Algorithm 2

1. Order the set N of jobs according to nondecreasing order of their modified release dates.2. Set L1 = 1, L2 = 2, F(1) = 0, F(2) = 0.3. Let i1 be the first job from the set N. Assign job i1 to machine 1 according to its release date r0i1 . Set

Si1 ¼ r0i1 , Ci1= Si1

+ p, F(1) = Ci1.

FOR k = 2 TO n DOStage k (constructs a partial schedule sk)4. IF job ik (the next job from the set N) is the successor of job ik1 THEN DO5. IF r0ik < F ðL1Þ THEN DO6. Set k ¼ minfF ðL1Þ r0ik ; F ðL1Þ F ðL2Þg, F1 = F(L1), F2 = F(L2).7. IF k = 0 THEN go to Step 9.8. REDGREEN(k,L1,L2, sk1,F1,F2)

END9. Assign job ik to machine L1. Set Sik ¼ maxfr0ik ; F ðL1Þg, Cik

= Sik+ p, F(L1) = Cik

.END

ELSE DO10. IF r0ik > F ðL2Þ THEN DO11. IF r0ik > F ðL1Þ THEN go to Step 14.12. Set k ¼ r0ik F ðL2Þ, F1 = F(L1), F2 = F(L2).13. REDGREEN(k,L1,L2, sk1,F1,F2)

END14. Assign job ik to machine L2. Set Sik ¼ maxfr0ik ; F ðL2Þg, Cik

= Sik+ p, F(L2) = Cik

.15. Set L = L2, L2 = L1, L1 = L.END


16. Go to stage k + 1.After stage n has been completed,Stop.

The procedure REDGREEN(k,L1,L2, sk1,F1,F2) diminishes as far as possible the idle interval of lengthk on machine L2. This procedure forms ‘‘red’’ and ‘‘green’’ chains of jobs and then shift the ‘‘green chain’’of jobs forward in time and the ‘‘red chain’’ of jobs backward in time. To describe the process of construct-ing ‘‘red’’ and ‘‘green’’ chains of jobs and their shifting we shall use the following images.Let us direct the time axis upwards. Then each time moment will be associated with the height above

zero level. We shall consider any job i as an item of size pi = p. Each item can be cut into pieces. If laterone piece of an item is put on the other piece of the same item, we assume that these pieces are pastedtogether. To each machine L, 1 6 L 6 2, we put in correspondence bin MB(L) which will be packed byitems. Each item i cannot be packed below the given level r0i. It is also easy to give the corresponding inter-pretation of precedence constraints between jobs. Each necessary idle interval on machine we shall treat ashollow filled by chips so that the following item can be packed exactly at the required level. We shall alsouse two auxiliary bins: a red bin RB and a green bin GB. Besides, it should be mentioned that a partialschedule sk1 determines the contents of bins MB(1) and MB(2). After the completion of the procedureREDGREEN(k,L1,L2, sk1,F1,F2) the transformed contents of these bins determine a new partial schedules�k1.

REDGREEN(k,L1,L2, sk1,F1,F2)

BEGIN(packs the red bin RB and the green bin GB)1. Set d = 0, l = 1.2. Put the top item u1 from bin MB(L1) into the red bin RB. Set q1 ¼ Su1 r0u1 .3. IF ql = 0 THEN go to Step 17.4. Let item (or piece) vl be the top item (or piece of item) from bin MB(L1).5. IF item vl is the predecessor of item ul THEN DO6. Put item vl into the red bin RB. Set ul+1 = vl. Set qlþ1 ¼ minfql; Sulþ1 r0ulþ1g. (ql+1 is the value by whichthe chain (ul+1,ul, . . .,u1) can be shifted backward in time)

7. Set l = l + 1. Go to Step 3.
END8. Let h be the height of the contents of bin MB(L1). Cut the contents of bin MB(L2) at the height h.Consider all items (and pieces of items) from bin MB(L2) that are above the height h. Put them oneafter another into the green bin GB.
9. IF vl is the whole item THEN DO10. Let item (or piece) wl be the top item (or piece of item) from bin MB(L2).11. Set L = L2, L2 = L1, L1 = L.12. IF item wl is the predecessor of item ul THEN set vl = wl and go to Step 6

ELSE set ak = wl.(ak is the top item (or piece of item) from bin MB(L1))

ENDELSE DO(vl is a piece of some item. This situation cannot occur if REDGREEN is used in the first time)13. Put the top piece of item from the green bin GB again into bin MB(L2).14. Set ak = vl.(ak is the top piece of item from bin MB(L1))END


15. Set d = min{k,ql}.16. Consider the top item (or piece of item) ak from bin MB(L1). Cut the piece a of height d from ak and

put the piece a into the green bin GB. The other piece of ak (if such piece exists) put again into binMB(L1).

END(BEGIN)17. Put one after another all items from the red bin RB into bin MB(L1).18. IF the green bin GB is nonempty THEN put one after another all items from the green bin GB into bin

MB(L2).(The contents of bins MB(L1) and MB(L2) define the partial schedule s�k1)19. Set F(L1) = F1 d, F(L2) = F2 + d.RETURNðL1; L2; s�k1; F ðL1Þ; F ðL2ÞÞ.

The following example shows how procedure REDGREEN works.

Example 2. There are M = 2 identical parallel machines and n = 11 jobs with unit processing times. Theprecedence constraints between jobs are given in Fig. 3. The jobs have the following modified release dates:

r01 ¼ 0; r02 ¼ 0; r03 ¼ 0; r04 ¼ 0;r05 ¼ 1:3; r06 ¼ 1:5; r07 ¼ 2:3; r08 ¼ 3:25;r09 ¼ 3:3; r010 ¼ 4:3; r011 ¼ 4:3:

At first we assign jobs 1, 2, 3, 4, 5, 6 and 7 to machines. But if we assign job 8 to machine L2 according toits modified release date, we have an idle period (see Fig. 4a). So we cancel the assignment of job 8 and dothe following. We put job (item) 7 into the red bin RB. The next item in bin MB(L1), job 5, is the prede-cessor of job 7. So we also put item 5 into the red bin RB. The next item in bin MB(L1), job 3, is not thepredecessor of job 5. We cut the contents of bin MB(L2) at the height of the contents of bin MB(L1). Item 6is above the indicated level, so we put it into the green bin GB.Now let us consider bin MB(L2). The next item in bin MB(L2), job 4, is the predecessor of job 5, so we

put it into the red bin RB. The next item in bin MB(L2), job 2, is not the predecessor of job 4. We cut thecontents of bin MB(L1) at the height of the contents of bin MB(L2). Item 3 is above the indicated level, sowe put it into the green bin GB. Since the next item in bin MB(L1), job 1, is not the predecessor of job 4, wehave formed the ‘‘red chain’’. Notice, that k = 0.25 and the chain (4;5;7) can start earlier by 0.7 unit. Sod = min{0.25;0.7} = 0.25. We cut a piece of the height d = 0.25 from item 1 and put it into the green binGB. Then we put one after another all items from the red bin RB into bin MB(L1) and all items from thegreen bin GB into bin MB(L2). Now we can assign job 8 to machine L2 without idle period before it (seeFig. 4a).Let us assign job 9 to machine L1. Job 10 cannot start the processing before the completion of its

predecessor job 9. So we have an idle period on machine L2 before the start of job 10 (see Fig. 4b). Wecancel the assignment of job 10 and do the following. We put job (item) 9 into the red bin RB. Since in bin

Fig. 3. The precedence constraints for the instance of Example 2.

Fig. 4. (a) The transformation of the partial schedule s8. (b) The transformation of the partial schedule s10.


MB(L1) the following items (jobs) 7, 5, 4 form the chain of predecessors of item (job) 9, we put them oneafter another into the red bin RB. The next item in bin MB(L1), job 1, is not the predecessor of job 4. Wecut the contents of binMB(L2) at the height of the contents of binMB(L1). Items 8, 6, 3 and pieces of items


1 and 2 are above the indicated level, so we put them one after another into the green bin GB. Notice, thatnow the size of the top item (item 1) in binMB(L1) is less than p = 1. This means that we have already cut apiece from item 1, but this piece cannot be the top item in the green bin GB. We put the top piece of item 2from the green bin GB again into bin MB(L2) (Steps 13–14 of procedure REDGREEN). Now the top itemin the green bin GB is the piece of item 1. At this stage k = 0.45 and the chain (4;5;7;9) can start earlier by0.45 unit too. So d = 0.45. We take a piece of item 1 from bin MB(L1), cut the piece a of height d = 0.45from it and put the piece a into the green bin GB. The other piece of item 1 we put again into bin MB(L1).Then we put one after another all items from the red bin RB into bin MB(L1) and all items from the greenbin GB into bin MB(L2). Finally, we assign jobs 10 and 11 to machines (see Fig. 4b).

It is clear that at each stage of Algorithm 2 we need no more than O(n) time to transform the partialschedule with the help of the procedure REDGREEN. Since there are n stages, we conclude that the prob-lem under consideration can be solved in O(n2) time.

3. Proof of the optimality of the algorithm for the P2|pi = p,pmtn,outtrees, ri|+Ci problem

At first let us prove two lemmas.

Lemma 1. The transformation of the partial schedule sk1 by the procedure REDGREEN is well defined and

does not change the value of the partial objective function.

Proof. It is clear that in the partial schedule sk1 and in the transformed partial schedule s�k1 no job i startsthe processing before its release date ri. Let us show that the procedure REDGREEN constructs a schedules�k1 in accordance with the given precedence constraints between jobs. Since each vertex of graph G has nomore than one predecessor, in the partial schedule sk1 we can find the maximal chain of predecessors of jobik1 such that all jobs of this chain and job ik1 are processed continuously one after another. Denote thischain of jobs (so called ‘‘red chain’’) by Rk1. The red bin RB contains the items from the set Rk1. At thesame time we form the contents of the green bin GB. In other words, we find the sequence Gk1 of jobs (socalled ‘‘green chain’’) with the following properties: (1) the job that (or a part of that) is the first in thesequence Gk1 starts the processing before the starting time of the chain Rk1 and completes the processingno earlier than the starting time of Rk1; (2) the other jobs of the sequence Gk1 are all jobs processedsimultaneously with the jobs of Rk1. No job from the sequence Gk1 can be the predecessor of somejob from the chain Rk1. So during the transformation of the partial schedule sk1 the jobs of the chainRk1 can be shifted backward in time and the jobs of the sequence Gk1 can be shifted forward in time with-out violating the precedence constraints.

Notice that during the construction of the schedule s�n by Algorithm 2 the processing of a job can beinterrupted only if we use the procedure REDGREEN. In this case the following property takes place.

Property 1. In the transformed partial schedule machine L1 processes a piece of preempted job along with

immediately followed ‘‘red chain’’. Further, in some time period the preempted job resumes the processing on

machine L2 as a leader of a ‘‘green chain’’ (see Example 2).

Consider the partial schedule sk1. Suppose that we have packed the red bin RB and the green bin GB(Steps 1–16 of procedure REDGREEN). Let Rk1 = (ul,ul1, . . .,u1), where u1 = ik1, be the found ‘‘redchain’’ of jobs. In other words, the red bin RB contains l items ul,ul1, . . .,u1. Let k > 0 and d > 0 (otherwisejobs will not be shifted in time, and therefore Lemma 1 holds). Since d > 0, one can see that in the schedulesk1 all jobs of the sequence Gk1 are processed one after another without idle periods between them (oth-erwise, we should use the procedure REDGREEN at some previous stage of Algorithm 2 to eliminate anidle period between jobs of the sequence Gk1).


The following two cases may occur.1. Suppose that ak = wl (Step 12), where wl is either some job i* or a piece of this job i*. Notice that

ak and ul are processed on different machines. According to Property 1 we conclude that in theschedule sk1 job i* is processed without preemption. Job i* is the first job of the ‘‘green chain’’Gk1.Consider the starting time Sul of job ul. We have Sul = F1 lp. The height of the contents of the green bin

GB is equal to F2 Sul + d. Since 0 < d 6 k 6 F1F2, we have F2 Sul + d = F2 F1 + lp + d 6

lp + d k 6 lp. On the other hand, since d > 0, we are sure to have F1 F2 6 p (otherwise, we shoulduse the procedure REDGREEN at the previous stage of Algorithm 2). So F2 Sul + d = F2 F1 + lp +d P lp p + d > (l 1)p.By the construction the green bin GB contains a set of items and no more than one piece of item. We

conclude that bin GB contains l elements. When we put all items from bins RB and GB into bins MB(L1)andMB(L2), respectively, we obtain the transformed partial schedule s�k1. One can see that in the schedules�k1 the completion times of l jobs from the chain Rk1 have diminished by d, while the completion times ofl jobs from the sequence Gk1 have increased by d. So the value of the partial objective function does notchange.Now let us show that the size l(ak) of item ak is no less than d, and so we can cut a piece a of the height d

from item ak (Step 16). We have l(ak) = Sul Si*. Recall, that in the schedule sk1 job i* is processed with-out preemption. Besides, there are no idle periods between jobs of the sequence Gk1. Therefore,Si* = F2 lp. So we obtain l(ak) = Sul Si* = F1 lp (F2 lp) = F1 F2 P d. Thus, it is possible tocut a piece a of the height d from item ak.2. Suppose that ak = vl (Step 14), where vl is a piece of some job i. Notice, that ak and ul are processed onthe same machine. Besides, we have l(ak) = l(vl) < p, where l(ak) is the size of a piece ak = vl of job i.Taking into account Property 1, we conclude that in the schedule sk1 job i is processed with preemp-tion. This means that job i was interrupted by procedure REDGREEN at some previous stage k,4 6 k < k.Without loss of generality we suppose that in the partial schedule sk1 case 1 takes place and there are no

transformations by procedure REDGREEN between stages k and k. Let d be the value of shifts at the stagek. Notice that lðakÞ ¼ lðakÞ d > 0. In the partial schedule sk1 denote bF 1 and bF 2 the completion times ofthe chain Rk1 and the sequence Gk1, respectively. It is clear that in this case d < lðakÞ ¼ bF 1 bF 2. After thetransformation the chain Rk1 (or, in other words, its last job ik1) completes at the time moment bF 1 d,while the sequence Gk1 completes at the time moment bF 2 þ d.We claim that the chain Rk1 contains all jobs of the chain Rk1. Indeed, suppose that in the chain Rk1

some job j1 2 Rk1, j1 6¼ ik1, is immediately followed by its successor j2 62 Rk1. This means that Cj1ðsk1Þd ¼ Cj1ðsk1Þ ¼ Sj2ðsk1Þ ¼ Sj2ðsk1Þ þ d. The case j2 2 Gk1 is impossible, because in the feasible sched-ule sk1 we have Cj1ðsk1Þ > Sj2ðsk1Þ, so j2 could not be a successor of j1. Recall, that all jobs of thesequence Gk1 (except the first one) are processed one after another without preemption. Since we supposethat j2 62 Gk1 [ Rk1, in sk1 job j2 can start the processing no earlier the time moment

minfbF 1 d; bF 2 þ dg.Suppose bF 2 þ d < bF 1 d. Since d > 0 and bF 1 bF 2 6 p, we have ðbF 1 dÞ ðbF 2 þ dÞ ¼ bF 1 bF 2

2d < p. Because ik1 is the last job of the chain Rk1 and j1 2 Rk1, j1 6¼ ik1, in the schedule sk1 we haveCj1 6 Cik1

p ¼ bF 1 d p < bF 2 þ d, i.e. job j2 cannot start the processing at the time moment Cj1 . It fol-lows that in this case j2 cannot be included in the chain Rk1 immediately (and at all) after job j1.If bF 2 þ d P bF 1 d, in sk1 job j2 starts the processing no earlier the time moment bF 1 d ¼ Cik1

, i.e.after the completion of job ik1. This contradicts the assumption j1 6¼ ik1.Thus, all jobs of the chain Rk1 are included in the chain Rk1 without other jobs between them. Besides,

it follows that all jobs of the sequence Gk1 are included in the sequence Gk1.


Now we consider the following cases.(a) Suppose that bF 1 d > bF 2 þ d. In the partial schedule sk1 we have F 1 ¼ bF 1 d þ l1p and F 2 ¼bF 2 þ d þ l2p, where l1 and l2 are positive integers. Since by the construction F1 > F2 and

ðbF 1 dÞ ðbF 2 þ dÞ < p, we obtain l1 P l2. As above F1 F2 6 p. Therefore, we have F 1 F 2 ¼ðbF 1 d þ l1pÞ ðbF 2 þ d þ l2pÞ ¼ ððbF 1 dÞ ðbF 2 þ dÞÞ þ ðl1 l2Þp 6 p. This inequality holds onlyif l1 = l2. Besides, Rk1 and Gk1 contain the equal number of jobs (we suppose that in sk1 case 1 takesplace). Thus, we conclude that the number of jobs in the chain Rk1 is equal to the number of jobs inGk1. So it is clear that after the transformation of the schedule sk1 the value of the partial objectivefunction does not change.Notice, that at stage k for the value d of shifts we have 0 < d 6 F 1 F 2 ¼ ðbF 1 dÞ ðbF 2 þ dÞ ¼ðbF 1 bF 2Þ 2d ¼ ðlðakÞ dÞ d ¼ lðakÞ d < lðakÞ. Therefore, we can cut a piece a of the height dfrom item ak (Step 16).

(b) Let bF 1 d < bF 2 þ d. Since in the schedule sk1 there is no idle period after the completion of the chainRk1, we conclude that this case is possible only if job ik1 is the predecessor of job ik (compare Steps 9and 14 of Algorithm 2). It is easy to see that job ik is included in the chain Rk1. Besides, we have shownthat Rk1 � Rk1. As it has been already mentioned, d < bF 1 bF 2. It follows that either some jobs of thechain Rk1 or job ik cannot be shifted backward in time by more than d units, and these shifts have al-ready been done during the transformation of the partial schedule sk1. Therefore, it is impossible toshift the chain Rk1 backward in time. This means that the partial schedule sk1 will not be transformed.It is clear that in this case Lemma 1 holds.

(c) Let bF 1 d ¼ bF 2 þ d. As in the case 2(b), it is easy to see that job ik1 is the predecessor of either job ik orjob ikþ1. Using the analogous arguments, we can show that it is impossible to transform the partialschedule sk1. Therefore, Lemma 1 holds. h

Assume that for a set N of jobs there are z distinct modified release dates R1 < R2 < � � � < Rz, and Rz+1 isdefined to be +1. For each b, 1 6 b 6 z, consider all jobs such that their modified release dates are nogreater than the time moment Rb and denote the set of these jobs by Nb.

Lemma 2. Among all preemptive schedules, the schedule s* constructed by Algorithm 2 for a set N of jobs has

the maximum amount of processing done within each time interval (Rb,Rb+1], 1 6 b < z.

Proof. Let (Rb*,Rb*+1] be the first time interval for which Lemma 2 does not hold. The following cases mayoccur.

1. In the schedule s* all jobs of the set Nb* are completed by the time moment Rb*+1. For any other scheduleit is impossible to do more amount of processing by the time moment Rb*+1. Hence, Lemma 2 holds.

2. In the schedule s* there is no idle machine within the time interval (Rb*,Rb*+1]. In this case Lemma 2holds again.

3. In the schedule s* some jobs of the set Nb* are not completed by the time moment Rb*+1. Besides, there isidle machine within some subinterval (s1,s2] � (Rb*,Rb*+1]. The following cases may occur.(a) Exactly one job of the set Nb*, say job i 0, is not completed by the time moment Rb*+1.

Since job i 0 cannot be processed on the idle machine, we conclude that during the interval (s1,s2]either job i 0 or its predecessor is processed on the other machine. Without loss of generality we as-sume that the modified release date of job i 0 is equal to Rb*.(i) Let in the schedule s* job i 0 start the processing at the time moment Si 0 = Rb*. Therefore, job i 0 isprocessed in the interval (s1,s2]. Since in this interval there is idle machine, job i 0 cannot beincluded by the procedure REDGREEN in any ‘‘green sequence’’ of jobs. We conclude thatin the schedule s* job i 0 is processed without preemption. Clearly, no schedule can process moreamount of i 0 within the time interval (Rb*,Rb*+1]. Hence, Lemma 2 holds.


(ii) In the schedule s* job i 0 starts the processing at the time moment Si 0 > Rb*. In this case duringthe interval (s1,s2] some machine processes job i 0 or its predecessor, the other machine is idle.Notice that the attempt of the procedure REDGREEN to eliminate the idle interval (s1,s2]has failed. This means that among the chain of predecessors of job i 0 there is a job which cannotbe shifted backward in time. Therefore, job i 0 (or its predecessor) cannot start earlier. This factcontradicts the assumption that the modified release date of job i 0 is no greater than Rb*. Hence,there is no idle machine within the time interval (Rb*,Rb*+1], and Lemma 2 holds.

(b) In the schedule s* at least two jobs of the set Nb*, say jobs i 0 and i00, are not completed by the timemoment Rb*+1.

Since jobs i 0 and i00 cannot be processed on the idle machine in the interval (s1,s2], we conclude thatduring the interval (s1,s2] the other machine processes the predecessor of at least one of these jobs. Theprocedure REDGREEN has not eliminated the idle interval (s1,s2] by shifting this predecessor backward intime. So we conclude that for at least one of jobs i 0 and i00 the modified release date should be greater thanRb*. We have the same contradiction as in case 3(a)ii). Hence, Lemma 2 holds.In all cases, we see that Lemma 2 holds for the interval (Rb*,Rb*+1], contradicting our assumption that it

does not. h

Further we shall consider three classes of instances for the problem under consideration.In any instance of the first class there are no precedence constraints between jobs. In this case Algorithm

2 works as a slight modification of the algorithm by Herrbach and Leung [6] developed for theP2jpi = p,pmtn, rij

PCi problem. Thus, for each instance without precedence constraints between jobs Algo-

rithm 2 constructs an optimal schedule.In any instance of the second class precedence constraints between jobs are of a chain-like structure.Finally, in any instance of the third class precedence constraints between jobs are given by a (di)graph G

which consists of a set of outtrees and a number of isolated vertices.Denote the above classes of instances by I(1), I(2) and I(3), respectively.

Theorem 1. Algorithm 2 produces an optimal schedule for the P2jpi = p,pmtn, ri, chainsjP

Ci problem.

Proof. We shall prove this theorem by contradiction. The proof is based on the scheme developed by Herr-bach and Leung [6].Consider an instance I 2 I(2) for which the following assumption takes place.

Assumption A. The instance I 2 I(2) is the smallest (in terms of number of distinct modified release dates)that violates the theorem.

Let there be z distinct modified release dates for jobs of the set N. It is clear that zP 2.Let s* be the schedule produced by Algorithm 2 for the instance I. We have supposed that s* is not opti-

mal schedule.Consider the set Nb of jobs such that their modified release dates are no greater than the time moment

Rb, 1 6 b < z. We claim that in the schedule s* some of jobs of the set Nb, 1 6 b < z, cannot be completed bythe time moment Rb+1.Indeed, suppose that it is not the case. In graph G = (N,E) that gives the precedence constraints between

jobs of the set N we can delete all arcs (i 0, i00) such that i 0 2 Nb, i00 2 Nb, where N b ¼ N n Nb. Then we candecompose the instance I into two instances Ib and Ib with the sets Nb and N b of jobs, respectively. If eitherIb 2 I(2) or Ib 2 Ið2Þ, we have the contradiction with Assumption A. Suppose that both Ib 2 I(1) and Ib 2 Ið1Þ.In this case Algorithm 2 constructs optimal schedules for Ib and Ib. Therefore, Algorithm 2 constructs anoptimal schedule for the instance I. This contradicts the assumption that I violates the theorem.Thus, in the schedule s* some jobs of each set Nb, 1 6 b < z, are not completed by the time moment Rb+1.


Notice that all jobs from the set Nb+1nNb, 1 6 b < z, have modified release dates Rb+1. We claim thatbefore assigning for processing the first job from the set Nb+1nNb, 1 6 b < z, Algorithm 2 calls the proce-dure REDGREEN.Indeed, suppose that we do not use the procedure REDGREEN immediately before the assignment for

processing the first job from the set Nb+1nNb, 1 6 b < z. This means that we can right away assign this jobto machine without an idle period before it on any machine. Moreover, all other jobs from the set Nb+1nNb,1 6 b < z, also can be assigned to machines without idle periods before them. In this case we can constructthe smaller instance I 0 (in terms of number of distinct modified release dates) in the following way. In graphG = (N,E) we delete all arcs (i 0, i00) such that i 0 2 Nb, i

00 2 Nb+1nNb. Then the modified release dates for alljobs from the set Nb+1nNb are set to be Rb. For the instance I Algorithm 2 at first ordered the set N of jobsaccording to nondecreasing order of their modified release dates. We conclude that the same order of jobscan be saved for the instance I 0. So Algorithm 2 will produce for instance I 0 the same schedule s*, while anoptimal schedule for I 0 must have the value of the objective function no larger than that for I. If I 0 2 I(2), wehave the contradiction with Assumption A. If I 0 2 I(1), we conclude that the schedule s* constructed byAlgorithm 2 for the instance I 0 is optimal. Therefore, the schedule s* is also optimal for the instance I. Thiscontradicts our assumption that I violates the theorem.Thus, before the assignment for processing the first job from the set Nb+1nNb, 1 6 b < z, Algorithm 2

calls the procedure REDGREEN.Moreover, we use the procedure REDGREEN only in this case, because all jobs of the set Nb+1nNb,

0 6 b < z, where N0 = ;, are independent and have the same modified release date.Now let s0 denote an optimal schedule for the instance I. Since s* is not optimal, we have

Xn

i¼1Ciðs0Þ <

Xn

i¼1Ciðs�Þ: ð1Þ

Let il, il+1, . . ., in (1 < l 6 n) be the jobs with the modified release date Rz. Assume for the moment that

Xl1k¼1

Cik ðs0Þ <Xl1k¼1

Cik ðs�Þ: ð2Þ

Consider the new instance eI with the set Nz1 = {i1, i2, . . ., il1} of jobs. In the instance eI the precedenceconstraints between jobs are given by graph eG ¼ ðNz1; eEÞ, where eE is the set of arcs obtained from the setE of arcs of graph G = (N,E) by deleting all arcs (i 0, i00), i 0 2 Nz1, i00 2 NznNz1.Denote ~s the schedule produced by Algorithm 2 for the instance eI . Notice, that in fact ~s is the par-

tial schedule sl1 produced by Algorithm 2 for the instance I. As it was shown in Lemma 1, the procedureREDGREEN applied to sl1 does not change the value of the partial objective function. This means that

Xl1k¼1

Cik ðs�Þ ¼Xl1k¼1

Cik ð~sÞ: ð3Þ

Let ~s0 denote an optimal schedule for the instance eI . From (2) and (3) we obtain

Xl1k¼1

Cik ð~s0Þ 6Xl1k¼1

Cik ðs0Þ <Xl1k¼1


Cik ð~sÞ: ð4Þ

If eI 2 Ið2Þ, we have the contradiction with Assumption A. If eI 2 Ið1Þ, the schedule ~s constructed by Algo-rithm 2 for the instance eI is optimal. Therefore, we conclude that the inequality (2) cannot take place. Thus,we have


Xl1k¼1

Cik ðs0Þ PXl1k¼1

Cik ðs�Þ: ð5Þ

From (1) and (5) we obtain

Xn

k¼l

Cik ðs0Þ <Xn

k¼l

Cik ðs�Þ: ð6Þ

Algorithm 2 schedules the jobs il, il+1, . . ., in optimally. Really, these jobs are independent and have thesame modified release date and equal processing times. Algorithm 2 assigns each job of the set{il, il+1, . . ., in} to the earliest available machine. Thus, if (6) holds, the difference must be due to the jobsof the set Nz1 that complete the processing after the time moment Rz.We claim that in the schedule s* at most one job of the set Nz1 completes the processing after the time

moment Rz.Indeed, recall that before the assignment of job il Algorithm 2 calls the procedure REDGREEN. As a

result, we obtain the transformed partial schedule s�l1. If job il is not a successor of job il1, it will be as-signed to machine L2 at the time moment r0il ¼ Rz. Therefore, among jobs of the set Nz1 only job il1 can becompleted after the time moment Rz.Suppose that job il is a successor of job il1. If in the partial schedule s�l1 we have F ðL1Þ ¼ r0il , job il will

be assigned to machine L1 at the time moment r0il ¼ Rz. In this case also only one job from the set Nz1 canbe completed after the time moment Rz.Now let F ðL1Þ > r0il in the partial schedule s

�l1. In the schedule s

* job il will be assigned to machine L1 atthe time moment F ðL1Þ > r0il ¼ Rz. Notice that in this case k = F1 F2 and F(L1) = F1 k = F2,F(L2) = F2 + k = F1. Construct the smaller (in terms of number of distinct modified release dates) instancebI in the following way. In graph G = (N,E) we delete all arcs (i 0, i00) such that i 0 2 Nz1, i00 2 NznNz1. Thenthe modified release dates for all jobs from the set NznNz1 are set to be Rz1. Without loss of generality weassume that the order of consideration the jobs of the instance bI by Algorithm 2 remains the same.Let s be the schedule produced by Algorithm 2 for the instance bI . Notice that for the instance bI we have

the same partial schedule sl1 as for the instance I. So due to Lemma 1 we have

Xl1k¼1


Cik ðsÞ:

But now jobs il1 and il are independent and have the same modified release date Rz1. So we can assign jobil to machine L2 at the time moment F2. Moreover, it is not difficult to see that in the schedule s jobsil, il+1, . . ., in have the same completion times as in the schedule s*. This means that

Xn

k¼1Cik ðs�Þ ¼

Xn

k¼1Cik ðsÞ;

while an optimal schedule for the instance bI must have the value of the objective function no larger thanthat for I. If bI 2 Ið2Þ, we have the contradiction with Assumption A. If bI 2 Ið1Þ, the schedule s constructed byAlgorithm 2 for the instance bI is optimal. Therefore, we conclude that the schedule s* is optimal for theinstance I. This contradicts the assumption that I violates the theorem.Thus, in the schedule s* at most one job of the set Nz1 completes the processing after the time moment

Rz. Moreover, from the above consideration we conclude that in the schedule s* exactly one job from the setNz1 completes the processing after the time moment Rz. Denote a(s*) the amount of this job processedafter the time moment Rz.From Lemma 2 it follows that among all preemptive schedules the schedule s* has the smallest amount

of processing done after the time moment Rz. It follows that in the schedule s0 some jobs from the set Nz1

Fig. 5. The schedules s* (a) and s0 (b).


complete the processing after the time moment Rz. Without loss of generality we assume that in the sched-ule s0 after the time moment Rz each machine at first processes the jobs from the set Nz1 (if it is necessary)and then the jobs from the set {il, il+1, . . ., in}. Denote a1(s

0) and a2(s0) the amounts of jobs from the set Nz1

processed in the schedule s0 after the time moment Rz on machines L1 and L2, respectively. It is clear that ifeither a1(s

0)P a(s*) or a2(s0)P a(s*), the inequality (6) cannot hold. Suppose that both a1(s

0) < a(s*) anda2(s

0) < a(s*). However, from Lemma 2 we have a1(s0) + a2(s

0)P a(s*). In terms of job completion times, s*

and s0 are identical to the schedules shown in Fig. 5. We have

Cilðs0Þ ¼ Cilðs�Þ þ a1ðs0Þ;Cilþ1ðs0Þ ¼ Cilþ1ðs�Þ ðaðs�Þ a2ðs0ÞÞ;Cilþ2ðs0Þ ¼ Cilþ2ðs�Þ þ a1ðs0Þ;Cilþ3ðs0Þ ¼ Cilþ3ðs�Þ ðaðs�Þ a2ðs�ÞÞ;� � �

Since a1(s0) + a2(s

0)P a(s*), we have

Xn

k¼l

Cik ðs0Þ PXn

k¼l

Cik ðs�Þ;

which contradicts (6). So we conclude that the inequality (6) cannot take place. It follows that the inequality(1) also cannot hold. Therefore, s* must be an optimal schedule. h

Theorem 2. Algorithm 2 produces an optimal schedule for the P2jpi = p,pmtn, ri,outtreesjP

Ci problem.

Proof. Replacing I(2) by I(3), and I(1) by I(2) [ I(1) throughout the proof of Theorem 1, we obtain the proofof Theorem 2. h

4. Other applications of the algorithm

In this paper we suggested an O(n2) algorithm to solve the P2j pi = p,pmtn, ri,outtreesjPCi problem.


Let us consider the following open shop problem.We are given M = 2 machines and a set N = {1,2, . . .,n} of jobs. An integer release date ri P 0 is asso-

ciated with each job i 2 N. Each job i has to be processed on machine L, 1 6 L 6 2, for piL time units with-out preemption. We suppose that all operations have unit processing times, i.e. all piL = 1. Each machinecan process at most one job at a time and each job can be processed on at most one machine at a time. Theorder of passing the machines is not given in advance and has to be chosen, different jobs being allowed toobtain different processing routes. There are precedence constraints between jobs of the set N, which arespecified by the relation !. The notation i! j (i precedes j) means that job j cannot start processing onany machine until the processing of job i has been completed on both machines. It is assumed that prece-dence constraints are given by graph G. Graph G consists of a set of outtrees and a number of isolatedvertices.For a schedule r, let Ci(r) be the completion time of job i. The objective is to find a schedule r* mini-

mizing the mean flow timePi2NCi(r).

According to the standard notation system [5], we denote this problem by O2jpiL = 1, ri,outtreesjPCi.

It should be mentioned, that the algorithm suggested in this paper can be used for theP2jpi = 2,pmtn, ri,outtreesj

PCi problem with the following restriction: all release dates, preemption times

and restart times are assumed to be integers.As it follows from the results of the papers [1,4,7], an optimal integer solution for the

P2jpi = 2,pmtn, ri,outtreesjPCi problem can be transformed into an optimal integer solution for the corre-

sponding open shop problem with unit processing times in O(n2) or in O(n log2n) time. Thus, we concludethat the O2jpiL = 1, ri,outtreesj

PCi problem can be solved in O(n

2) time. It should be mentioned that in [2]the O2jpiL = 1, ri,chainsj

PCi problem is also indicated as a minimal open one.

Now we would like to say a few words about the following particular cases of the P2jpi = p,pmtn, ri,out-treesj

PCi and O2jpiL = 1, ri,outtreesj

PCi problems.

In both problems we suppose that graph G consists of k chains of jobs. Each chain j, 1 6 j 6 k, isdetermined by the number nj of jobs in it. For each chain j we are given its release date cj. Weemphasize that release dates are given for chains but not for jobs. Denote these particular cases ofthe problems under consideration by P2jpi = p,pmtn,cj,chainsj

PCi and O2jpiL = 1,chains,cij

PCi. It

should be mentioned that in the O2jpiL = 1,chains,cijPCi problem all release dates cj are assumed

to be integers.Since the input of the P2jpi = p,pmtn,cj,chainsj

PCi problem is described by 2k numbers, the ques-

tion is whether the problem remains polynomially solvable. We developed the modification of the sug-gested algorithm which solves the P2jpi = p,pmtn,cj,chainsj

PCi problem in O(k2) time [8]. This

modified algorithm can be applied for the P2jpi = 2,pmtn,cj,chainsjPCi problem with the following

restriction: all release dates, preemption times and restart times are assumed to be integers. Usingthe constructed optimal integer solution to the P2jpi = 2,pmtn,cj,chainsj

PCi problem, we can determine

in O(1) time an optimal integer solution to the O2jpiL = 1,chains,cijPCi problem [8]. So the

O2jpiL = 1,chains,cijPCi problem is solvable in O(k2) time. Notice that the well-known O(n2) or

O(n log2n) transformations [1,4,7] of an integer solution to the parallel machine problem into an integersolution to the corresponding open shop problem are not polynomial when the input of the problem isdescribed by O(k) numbers.The mentioned results were not included in the paper because of their specific technical character.

Acknowledgments

The author is grateful to the referees for their useful remarks.


This research was partially supported by Belarussian Fund for Basic Research, Project U99-119, and byINTAS, Project 03-51-5501.

References

[1] P. Brucker, B. Jurisch, M. Jurisch, Open shop problems with unit time operations, Zeitschrift fur Operations Research–Methodsand Models of Operations Research 37 (1993) 59–73.

[2] P. Brucker, S. Knust, Operations research: Complexity results of scheduling problems. Available from: <http://www.mathema-tik.uni-osnabrueck.de/research/OR/class/>.

[3] P. Brucker, J. Hurink, S. Knust, A polynomial algorithm for Pjpj = 1,rj,outtreejPCj, Mathematical Methods of Operations

Research 56 (3) (2003) 407–412.[4] H.N. Gabow, O. Kariv, Algorithms for edge coloring bipartite graphs and multigraphs, SIAM Journal on Computing 11 (1982)117–129.

[5] R.L. Graham, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Optimization and approximation in deterministic scheduling andsequencing: A survey, Annals of Discrete Mathematics 5 (1979) 287–326.

[6] L.A. Herrbach, J.Y.-T. Leung, Preemptive scheduling of equal length jobs on two machines to minimize mean flow time,Operations Research 38 (1990) 487–494.

[7] C.Y. Liu, R.L. Bulfin, Scheduling open shops with unit execution times to minimize functions of due dates, Operations Research 36(1988) 553–559.

[8] Mathematical methods for optimal scheduling in the systems with variable parameters and resource constraints, The technicalreport on the project BFBR U99-119, Minsk, 2002.

http://www.mathematik.uni-osnabrueck.de/research/OR/class/

http://www.mathematik.uni-osnabrueck.de/research/OR/class/

Documents

Two machine preemptive scheduling problem with release dates, equal processing times and precedence constraints