A branch-and-bound algorithm for single-machine scheduling with batch delivery and job release times

Computers & Operations Research 35 (2008) 1099–1111www.elsevier.com/locate/cor

A branch-and-bound algorithm for single-machine scheduling withbatch delivery and job release times

Mohammad Mahdavi Mazdeha, Mansoor Sarhadia, Khalil S. Hindib,∗aDepartment of Design and Systems Engineering, Brunel University, Uxbridge, Middlesex, UK

bFaculty of Engineering and Architecture and the School of Business, American University of Beirut (AUB), P.O. BOX 11-0236, Riad El Solh,Beirut 1107 2020, Lebanon

Available online 25 September 2006

Abstract

This paper addresses scheduling a set of jobs with specified release times on a single machine for delivery in batches to customersor to other machines for further processing. This problem is a natural extension of minimizing the sum of flow times in the presenceof release time by considering the possibility of delivering jobs in batches and introducing batch delivery costs. The schedulingobjective adopted is that of minimizing the sum of flow times and delivery costs. The extended problem arises in the context ofcoordination between machine scheduling and a distribution system in a supply chain network. Structural properties of the problemare investigated and used to devise a branch-and-bound solution scheme. Computational experiments show significant improvementover an existing dynamic programming algorithm.� 2006 Elsevier Ltd. All rights reserved.

Keywords: Scheduling; Single machine; Batch delivery; Branch and bound

1. Introduction

Single-machine scheduling has been studied extensively with different objective functions. In this paper, we describea model for minimizing total flow times plus delivery cost for a set of jobs that are to be processed on a single machinefor delivery in batch form to customers when each job is available for processing at its release time. This situation mayoccur in a supply chain networks when jobs arrive at different times to a manufacturer who has to process them fordelivery to some customers or transfer them in batch form to other machines for further processing. In this model, thetime at which each job, j, is delivered from supplier to manufacturer defines a release time from the viewpoint of themanufacturer. This is the recognition version of the 1|rj | ∑ Fj classical problem with an additional term. The classicalproblem is unary NP-complete [1] and its preemptive version, 1|rj , prmp| ∑ Fj , can be solved in polynomial timeby the shortest remaining processing time (SRPT) rule [2]. Also, where all the jobs have identical release times, theproblem can be solved in O(n log n) time by applying the shortest processing time (SPT) [3] rule. The complexity

∗ Corresponding author. Tel.: +961 1350000x3486.E-mail address: [email protected] (K.S. Hindi).URL: http://www.aub.edu.lb/∼kh08.

0305-0548/$ - see front matter � 2006 Elsevier Ltd. All rights reserved.doi:10.1016/j.cor.2006.07.006

http://www.elsevier.com/locate/cor

mailto:[email protected]

http://www.aub.edu.lb/~kh08

1100 M. Mahdavi Mazdeh et al. / Computers & Operations Research 35 (2008) 1099–1111

of this problem has motivated the development of a heuristic method [4] and some branch-and-bound algorithms forsolving it [5,6]. Also, for the same problem when the objective is to minimize total weighted completion time, Biancoand Ricciardelli [7] and Belouadah et al. [8] propose branch-and-bound algorithms.

Problems that address an objective function that combines machine scheduling with delivery costs appear to be rathercomplex, though they are more practical than those that involve just one of these two factors. These types of combinedoptimizations are often encountered when real-world supply chain management is considered. However, although thereis a large body of research on the classical version of the problem, few articles address combined optimization problemsthat seek to coordinate machine scheduling with delivering jobs in batches. Cheng et al. [9] consider a problem thatarises when the objective is to minimize the sum of a function of the number of batches and earliness penalties, wherethe earliness of a job is defined as the difference between batch delivery time and job completion time. However, theydo not consider the problem in the presence of release times; i.e., they assume that all jobs are available at time 0. Thecomplexity of some combined problems, such as makespan and completion times, when the jobs are to be deliveredafter their processing time to a customer or warehouse, is measured by Lee and Chen [10].

Hall and Potts [11] consider a variety of scheduling, batching and delivery problems that arise in an arborescentsupply chain, where a supplier makes deliveries to several manufacturers, who also make deliveries to customers.The objective is to minimize overall scheduling and delivery costs, using several classical scheduling objectives. Foreach problem, they either derive a dynamic programming algorithm or demonstrate that the problem is intractable.One of the problems identified is that of batching and sequencing on a single machine under the batch availabilityassumption, with the objective of minimizing the sum of flow times plus delivery costs in the presence of release times.They derive a forward dynamic programming algorithm for the problem with an overall time complexity of O(n3H ),where n and H identify the number of jobs and customers, respectively. The algorithm is derived assuming batchconsistency, under which the supplier’s batch schedule and the manufacturer’s batch schedule are batch consistent,in the sense that for each pair of jobs i and j, whenever job i is in a strictly earlier batch than job j in the supplier’sbatch schedule, then i is in an earlier batch or in the same batch as j in the manufacturer’s batch schedule [11]. Theyalso make the further assumption of SPT-batch consistency, under which jobs with the same release time (i.e., jobsdelivered by the supplier in one batch) that are destined for the same customer are processed by the manufacturer inSPT order.

In this paper we consider the same problem, but with the additional assumption that for each pair of jobs i and j,whenever pi < pj then ri < rj where p and r denote the processing times and release times of jobs, respectively. Thisassumption may appear restrictive at first sight. However, within the framework of supply chain management, thiscondition may be enforced as part of the coordination between the supplier (upstream stage) and the manufacturer. Thecurrent paper follows from earlier work by the authors, which considered scheduling with batch delivery but withoutjob release times [12].

In what follows, we study the structural properties of the problem, derive upper and lower bounds and offer abranch-and-bound solution scheme.

2. Problem definition

Let {1, . . . , n} denote the set of jobs to be scheduled on a single machine that can process at most one job at time.Each job is available at its release time and no preemption is allowed. Each job starts processing on the machine eitherat its release time if the machine is ready or immediately after another job. Each job is produced for one customerand jobs are delivered to customers in batches. We denote the processing time and release time of job j by pj andrj , respectively. A group of jobs form a batch if all are delivered to their respective customer at the same time. Twoalternative batch formation strategies are allowed. The first is that of continuous batching, under which the jobs thatform a batch are processed continuously, i.e., no job that belongs to another customer is processed between themand there is no idle time. The second strategy is that of discontinuous batching, where the jobs that form a batch areprocessed separately but delivered together, in which case at least one job that belongs to another customer is processedin between or there is idle time between some pairs of jobs. Let Rk denote the ready time of a continuous batch suchthat if processing of the first job of the batch is started at time Rk (or later), then all the other jobs of the batch can beprocessed continuously, i.e., at least the first job of the batch is ready at time Rk and other jobs are either already readyor become ready during the processing of earlier jobs. Let dc denote the non-negative cost of delivering a batch tocustomer c.

M. Mahdavi Mazdeh et al. / Computers & Operations Research 35 (2008) 1099–1111 1101

The objective function that we consider is to minimize total flow time plus delivery cost, which presumes thatcost terms and flow-time terms are scaled such that the sum becomes meaningful. This is a natural extension of the1|rj | ∑ Fj problem to cater for coordination between the manufacturing and distribution systems. Since the objectivefunction contains an additional term, signifying the cost of delivering batches to customers, it is, according to thestandard classification scheme for scheduling problems [13], a 1|rj | ∑ Fj + ∑

dckc problem, where kc identifies thenumber of batches delivered to each customer. As described in the last section, the classical problem is NP-completein the strong sense, even without the additional term that refers to batch delivery costs, and it is easy to show that therecognition version of the problem is also NP-complete.

By carefully analyzing the structural properties of the problem (Section 3), we develop an efficient branch-and-boundalgorithm (Section 4) under the assumptions stated earlier, viz., that for each pair of jobs, ri �rj whenever pi �pj andthat the jobs for each customer are to be processed in the SPT order.

3. Structural properties

In this section, structural properties of the problem, used subsequently to derive upper and lower bounds, are analyzed.It is worth noting that since any result that is proved for completion time applies also to flow time, we state and provethe following propositions and properties in terms of flow time, when in fact they are based on completion timeconsiderations.

Proposition 3.1. For a set of jobs, the sequence ordered by SPT is optimal in terms of total flow time.

Proof (By contradiction). Consider a schedule formed from a sequence S that is not ordered by SPT. In this schedule,there must be at least two adjacent jobs, say j followed by i, such that pi < pj and ri < rj . Assume that the machine isready for processing the two jobs at time t. The total flow time of the partial schedule composed of the two jobs is

F = max{t, rj } + pj + max{t, rj } + pj + pi .

Now perform adjacent pairwise interchange on jobs j and i to form a new sequence, S′, with all other jobs remainingin their original positions. The completion times of all preceding jobs remain unchanged. However, the completiontimes of the two jobs interchanged and all succeeding jobs need to be considered. The new total flow time of the partialschedule of the two jobs is

F ′ = max{t, ri} + pi + max{rj , max{t, ri} + pi} + pj .

Hence,

F − F ′ = (max{t, rj } − max{t, ri}) + (pj + max{t, rj } − max{rj , max{t, ri} + pi}).Since pi < pj and ri < rj then max{t, rj } − max{t, ri}�0 and pj + max{t, rj } − max{rj , max{t, ri} + pi} > 0.Therefore F ′ − F < 0. Thus, interchanging the positions of j and i reduces overall flow time, since the completion

time of jobs i and j combined is earlier and so, as a result, the completion times of all succeeding jobs. Carrying outany beneficial pairwise interchanges will ultimately yield a schedule based on a sequence ordered by SPT. �

The following corollary then follows immediately.

Corollary 3.2. For a set of discontinuous batches with job release times, the sequence ordered by SPT is optimal interms of total flow time.

Property 3.3. When two jobs with processing times pi and pj and release times ri and rj form a continuous batch,b, with a total processing time Fb = pi + pj , ready for processing time, Rb, and machine ready time, t, then Rb =max{ri, rj − pi, t}. This property is easily extendible to more than two jobs.

Proposition 3.4. For a set of continuous batches with constraints on the ready times, R, such that whenever Ti �Tj

then Ri �Rj , where T is the batch effective time defined as T = Fb/�b, with Fb being the total processing time of


the batch and �b the batch size (number of jobs in the batch), which could be equal to 1, the sequence ordered by theshortest effective batch time (SEBT) is optimal in terms of total flow time.

Proof (By contradiction). Consider a schedule S that is not ordered by the SEBT rule. In this schedule, there must beat least two adjacent batches, say Y and X such that Y is followed by X when RX < RY and TX < TY .

Assume that the machine is ready for processing the two batches at time t. The total flow time of the partial schedulecomposed of the two batches is

F = (max{t, RY } + FY )�Y + (max{t, RY } + FY + FX)�X.

Now perform adjacent pairwise interchange on batches Y and X to form a new sequence, S′, with all other batchesremaining in their original positions. The completion times of all preceding batches remain unchanged. However, thecompletion times of the two batches interchanged and all succeeding batches need to be considered. The new total flowtime of the partial schedule of the two jobs is

F ′ = (max{t, RX} + FX)�X + (max{RY , max{t, RX} + FX} + FY )�Y .

Since RX < RY then F ′ �A, where

A = (max{t, RX} + FX)�X + (max{RY , max{t, RY } + FX} + FY )�Y .

After simplifying, we get

A = (max{t, RX} + FX)�X + (max{t, RY } + FX + FY )�Y .

Also, F �B, where

B = (max{t, RY } + FY )�Y + (max{t, RX} + FY + FX)�X.

Hence,

B − A = FY �X − FX�Y .

Since FX/�X < FY /�Y , then B > A and F ′ < F .Therefore, total flow time decreases since the combined completion time of batches X and Y is earlier and so, as a

result, are the completion times of all succeeding batches.Thus, interchanging the positions of X and Y reduces total flow time. Proceeding in this manner, carrying out any

beneficial pairwise interchanges will ultimately yield a schedule based on a sequence ordered by SEBT. �

Proposition 3.5. For a set of continuous batches, in the absence of any constraints on the inter-relationships amongjob release times, if preempt–resume is allowed then the sequence ordered by the shortest effective remaining batchtime (SERBT) is optimal in terms of total flow time, with batch effective time being T = Fb/�b.

Proof. Generalizing an idea from Baker for minimizing the sum of flow times for a set of jobs [2] and in the light ofProposition 3.4, we can show that when preempt–resume prevails, the optimal rule for a set of batches is always tokeep the machine assigned to the available batch with minimum remaining effective batch time. �

Proposition 3.6. In a partial schedule, where some batches have been formed, but no decision has been taken yeton batching the remaining ‘un-batched’ jobs, a lower bound on the sum of job flow times of an optimally completedschedule corresponds to the sum of job flow times in a schedule formed by considering each un-batched job as asingle-job batch and sequencing all batches in the order of SEBT or SERBT.

Proof. Any batching of un-batched jobs to complete the schedule will necessarily delay some jobs. Hence, consideringeach such job as a single-job batch ensures no delay. Thereafter, SEBT sequencing ensures that the resulting scheduleminimizes total flow time by virtue of Proposition 3.4. Otherwise, SERBT sequencing ensures that the resulting scheduleminimizes total flow time by virtue of Proposition 3.5. �


Proposition 3.7. In an optimal solution, any batch destined for a customer j that has �b > 1 jobs will have the propertythat (�b − 1)pl < dj , where �b is the number of jobs in the batch and l is the last job in the batch.

Proof (By contradiction). Consider a batch that does not have the indicated property. Removing the last job anddelivering it in a batch of its own will decrease the overall objective function by (�b − 1)pl − dj , no matter where thebatch happens to be in the sequence of batches. �

The following corollary then follows immediately.

Corollary 3.8. In an optimal solution, any job that has a processing time greater than the batch delivery cost to thecorresponding customer, i.e., such that pi > dj , will form a single-job batch.

Proposition 3.9. If batches belonging to the same customer are concatenated in the same order with which they occurin the optimal schedule, then the jobs will appear ordered by SPT.

Proof (By contradiction). Consider a schedule S that does not have the indicated property. Such a schedule will havetwo jobs i and k such that pk < pi and k starts later than i. If both jobs belong to the same batch, then exchanging themwill not affect total flow time. However, if they belong to two separate batches, then exchanging them will reduce thedelivery time of the batch containing i and the delivery times of all batches succeeding that of i and preceding that ofk. This clearly reduces total flow time. Proceeding with carrying out any beneficial pairwise exchanges will ultimatelyyield a schedule that has the indicated property. It is also worth noting that the exchanges may yield opportunities forfurther batching, thereby reducing total delivery cost as well. �

The above proposition makes it possible to derive a lower bound on the number of batches destined for a customer,a result that we present in the next proposition.

Proposition 3.10. A lower bound on the number of batches destined for a customer in an optimal solution can befound by the following greedy maximum batching algorithm: take the jobs destined for the customer concerned in SPTorder; if the job may be added to the current batch by virtue of Proposition 3.7, then add it; else start a new batch.

Proof. In accordance with Proposition 3.9, jobs have to be taken in SPT order. Since each batch is augmented until itcan take no more jobs, the number of batches is minimized. Moreover, since this is done while relaxing (forgetting)the constraints of interaction with jobs for other customers due to batching, the number found is a lower bound, asclaimed. �

In carrying out the search, we will be continually evaluating the worth of moves that add a job to a preceding batchfor the same customer. It is, therefore, important that this evaluation be carried out in a computationally efficient way.The following proposition helps achieve that aim.

Proposition 3.11. Let each batch be denoted by its position in a SEBT sequence and let k be a single-job batch to theright of another batch b. If k may be added to b by virtue of Proposition 3.7, then the change in the sum of job flowtimes resulting from doing so could be found by updating the contributions of the batches between b and k inclusive.

Proof. Upon forming it, the new batch may have to be moved to restore the SEBT property. If it does not have to bemoved, then the flow time of its old jobs, as well as the flow times of the batches b + 1, . . . , k − 1, will increase bypk , but the delivery time of k itself will decrease, while the delivery times of all other batches remain unchanged. If,alternatively, the new batch has to be moved, then it will have to be moved to the right, since its effective batch time hasincreased, but to the left of k + 1, since its new effective batch time is �pk . Thus, in this case also the contributionsof batches 1, . . . , b − 1 and the contributions of batches k + 1, . . . remain unchanged. �

In consequence of the above proposition, evaluating the worth of a job joining an earlier batch can be calculatedefficiently, provided the delivery time, the number of jobs and the contribution of each batch to total flow time are keptupdated.


Proposition 3.12. In completing a partial schedule, where some batches have been formed, but no decision has beentaken yet on batching the remaining ‘un-batched’ jobs, a ‘batching penalty’, �k , attaches to each unbatched job k,since if the job is added to the last formed batch for the customer concerned, total flow time will increase, and if a newbatch is started with it, an additional batch delivery cost will be incurred. Moreover, �k = min{�bpk, dj }, where �b isthe number of jobs in the batch that it may join and dj is the appropriate batch delivery cost.

Proof. If an unbatched job is added to the last formed batch for the customer concerned, total flow time will increase,and if a new batch is started with it, an additional batch delivery cost will be incurred. Clearly, the ‘batching penalty’is the smaller of the two.

Consider a partial schedule. Add the jobs that have not been scheduled as if they were single-job batches and orderall in SEBT sequence. Let batches be denoted by their positions and let job k be the first unscheduled job to the rightof the last batch b for the same customer. If the job may not be added to the batch by virtue of Corollary 3.8 or is notadded to it, then a penalty equal to dj will be incurred. Otherwise, total flow time will increase. To assess this increase,recall from Proposition 3.4 that

Fb

�b

� Fb+1

�b+1� · · · � Fk−1

�k−1�pk ,

and that batches or jobs to the left of batch b and the right of job k will not be affected (see proof of Proposition 3.11).Four cases need to be distinguished:Case 1. k = b + 1:

�k = �bpk .

Case 2. k > b + 1 and the newly formed batch remains in position b:

�k = �bpk + (�b+1 + · · · + �k−1)pk − (Fb+1 + · · · + Fk−1) > �bpk .

Case 3. k > b + 1 and the newly formed batch moves to the end of the subsequence, i.e., after the batch that was inposition k − 1:

�k = �bpk + (Fb+1 + · · · + Fk−1)�b − (�b+1 + · · · + �k−1)Fb > �bpk .

Case 4. k > b + 1 and the newly formed batch moves to a position b + � different from the positions indicated bythe above three cases:

�k = �bpk + (Fb+1 + · · · + Fb+�)�b + (��+1 + · · · + �k−1)pk

− (�b+1 + · · · + �b+�)Fb − (F�+1 + · · · + Fk−1)

> �bpk .

Thus in each case, �k ��bpk , which completes the proof. �

Proposition 3.13. If the optimum set of batches established under the conditions defined is sequenced in SEBT order,then either:

• the ready times of the batches happen to be in non-decreasing order, or• for some subsequences, the ready times are in an increasing order, in which case for any two batches x and y in the

subsequence, Rx + Fx �Ry , where R and F denote, respectively, the ready time and the total processing time.

Proof. The proposition can be proven by induction through a somewhat tedious process of book-keeping. Details arein Mahdavi Mazdeh [14]. �

4. Branch-and-bound scheme

Search of the solution space is structured as a trivalent 0–1–2 search tree, where each node is partitioned into three:one indicating the start of a new batch that could be a single-job batch (0), another indicating that a job is added to the


last batch for the customer concerned continuously (1), and the third indicating that a job is added to the last batch forthe customer concerned discontinuously (2). The tree is constructed in a depth-first fashion. At the beginning, all jobsthat have to form single-job batches by virtue of Corollary 3.8 are identified and their corresponding variables are setto 0 once and for all. Other components of the branch-and-bound scheme are presented in the following subsections.

4.1. Branching and ordering of variables

Variables are ordered in accordance with the SPT of the corresponding jobs. At each node of the decision tree, twotasks are performed. First, variables that have to be set to zero, because either no batch for the customer concerned hasbeen formed or by virtue of Proposition 3.7, are set to zero. Secondly, the first free variable (free variables are the onesthat have not yet been committed to either 0, 1 or 2) in the SPT sequence is set to one.

4.2. Fathoming and backtracking

A node is fathomed if:

1. It is a leaf node, i.e., all variables are fixed.2. The lower bound exceeds or equals the incumbent upper bound.

Fathoming initiates backtracking to the first node associated with a variable whose value is either 1 or 2. If the valueof this variable is 1 then it is set to 2; else it is set to zero. If no such node is found, the search terminates.

4.3. Upper bound

Providing a sharp, i.e., low, initial upper bound is critically important for enhancing the exclusion rate of the branch-and-bound algorithm, i.e., the rate with which nodes are fathomed. Hence, it is worth expending some computationaleffort to achieve that end. The proposed algorithm has two phases: a construction phase followed by an improvementphase.

Phase 1—ConstructionConsider all jobs to be single-job batches and sequence them in SEBT (SPT).while there is a single-job batch that has not been selected do

Select the first not-yet-selected single-job batch, i.for j = i + 1 to batches do

Scan forward until the first single-job batch with the same customerto the selected batch, i.e. batch i, is found and call it k.Test moving k to join i in a batch; if profitable then form batch.

end {for}end {while}

In the second phase, an improving move is defined as moving the first (last) job of a batch to join the preceding(succeeding) batch for the same customer.

Phase 2—Improvementrepeat

Find an improving move and execute it.until no further improvement is possible.

4.4. Lower bounds

It is worth recalling that at each node of the decision tree, if, in view of the batching decisions already taken, a jobhas to start a new a batch, then the partial solution is immediately augmented by a batch starting with that job.


At each node of the decision tree, a lower bound on total flow time is calculated in accordance with Proposition 3.6.Additionally, batch delivery costs are added for each batch already formed.

Furthermore, a lower bound on the batching penalties is calculated by applying the logic of Proposition 3.12 in thefollowing way. The first unbatched job of a customer, k, will either start a new batch or join the last batch. It would,therefore, attract a lower bound on its batching penalty = �bpk , where �b is the number of jobs in the last batch of thecustomer concerned. Since for each subsequent job, we do not know the number of jobs in the batch that it may joinin the optimal completion of the current partial solution, each such job would attract a lower bound on its batchingpenalty = pk (i.e., the lowest batching penalty that it may incur if it joined a single-job batch).

At the initial stages of the search, opportunities arise for tightening the overall lower bound still further by consideringProposition 3.10. Assume that the number of batches already formed for a particular customer in the current partialsolution is bk and that the minimum number of batches is bmin. It would then be possible to raise the sum of lowerbounds on batching penalties by identifying the bmin − bk highest individual lower bounds on batching penalties andreplacing each by the batch delivery cost.

The overall lower bound is then the sum of the lower bound on the total flow time, batch delivery costs of the batchesalready formed and the sum of the lower bounds on the batching penalties for the unbatched jobs.

4.5. Optimizing at leaf nodes

If in calculating the lower bound at a leaf node, the corresponding schedule does not exhibit preempt–resume, thenthis is a valid schedule, even though preempt–resume may have been used to derive lower bounds at preceding nodes.It can, therefore, be considered as an upper bound, and compared with the incumbent in the usual way.

Contrariwise, if that schedule exhibits preempt–resume, then a valid schedule needs to be derived. This is done inthe following way. The batches are sequenced in SEBT. Subsequences in which the ready times of batches are notin non-decreasing order may then need to be re-sequenced. Starting from left to right, whenever such a subsequenceis encountered, all possible permutations are considered and the one that corresponds to the least total flow time isadopted.

It is worth noting that the number of permutations that need be considered for any partial schedule is less than orequal to the number of customers; i.e., small. This is so because Proposition 3.13 ensures that when the processingof a batch of a given partial schedule is completed, all of the remaining batches of the partial schedule will be readyfor processing, which means that the number of permutations cannot be more than the number batches involved, sinceeach permutation corresponds to a first batch. Moreover, since the jobs for each customer should be processed in SPTorder, only the first batch for a customer can start a permutation and, therefore, the total number of permutations cannotbe larger than the number of customers.

4.6. Numerical example

Consider the following two-customer problem, with delivery costs of 200 and 100, respectively:

Customer 1 Customer 2

Job processing time 10 65 160 20 60Job release time 0 50 60 15 40

Let (ij) denote the ith job destined for the jth customer.Initial lower bound: The lower bound on total flow time, corresponding to flow time under SPT, LBF = 635. The

lower bound on batch delivery costs, LBD = 300 (we have to start a batch for each customer). The lower bound onbatching penalties, LBP = (65 + 200) + (60) = 325, where the numbers within brackets correspond to the penaltiesincurred by each job of the two customers in turn. Note that the 200 for the first customer results from substituting theinitial lower bound on the batching penalty, which is equal to 160, by the batch delivery cost, by virtue of the fact thatthe minimum number of batches for the first customer is two.

Thus, LB = LBF + LBD + LBP = 635 + 300 + 325 = 1260.


Initial upper bound:Applying phase 1 to the five single-job batches leads to the following schedule: |(11)|, |(12)(22)|,|(21)(31)|, with a total flow time of 835. Adding total batch delivery costs gives UB∗ = 835 + 500 = 1360. Applyingphase 2 to this schedule cannot improve the upper bound.

Thus, UB∗ = 1360.Branch and bound: Note that batches enclosed by {} are discontinuous; diagrams are not to scale; and an explanation

is provided whenever necessary.

S0 = |(11)|, |(12)|; LBF = 635, LBD = 300, LBP = 65 + 200 + 60 = 325; LB = 1260.

S1 = |(11)|, |(12)(22)|; LBF = 700, LBD = 300, LBP = 65 + 200 = 265; LB = 1265.

S2 = |(12)(22)|, |(11)(21)|, |(31)|; LBF = 885, LBD = 500, LBP = 0; LB = 1385. Since LB > UB∗, backtrack. Note

that at this node we have used preempt–resume.

Explanation:

• At time 0, job (11) is ready, but cannot be processed because it is part of batch b1 = |(11)(21)|, which is not readyuntil t = 40.

• At t = 20, batch b2 = |(12)(22)| is ready.• The process continues until b1 gets ready. At this time, we need to consider preempt–resume. The remaining pro-

cessing time of b1 is 75, while the remaining processing time of b2 is 60. Since the size of both batches is the same,the process continues with b2 without preemption.

S3 = {|(11)(21)|}, |(12)(22)|, |(31)|; LBF = 855, LBD = 500, LBP = 0; LB = 1355. As this is a leaf node and the

schedule is valid, UB∗ = 1355 and backtrack.

Explanation:

• At t = 0, the first job of the discontinuous batch b′1 = {|(11)(21)|} starts and is completed at t = 10.

• The second job of batch b′1 is ready at t = 50, while batch b2 =|(12)(22)| is ready at t = 20. Using preempt–resume,

the process continues with b2 until the second job of b′1 is ready at t = 50.

• At t = 50, the remaining processing time of b′1 is 65, while the remaining processing time of b2 is 50. Since the size

of both batches is the same, the process continues with b2.• The second job of b′

1 starts at t = 100 and is completed at t = 165.

S4 = |(11)|, |(12)(22)|, |(21)|; LBF = 700, LBD = 500, LBP = 160; LB = 1360. Since LB > UB∗, backtrack.

S5 = |(11)|, {|(12)(22)|}; LBF = 700, LBD = 300, LBP = 65 + 200 = 265; LB = 1265.

S6 = |(11)(21)|, {|(12)(22)|}, |(31)|; LBF = 885, LBD = 500, LBP = 0; LB = 1385. Since LB > UB∗, backtrack.Note that at this node we have used preempt–resume.


S7 = {|(11)(21)|}, {|(12)(22)|}, |(31)|; LBF = 855, LBD = 500, LBP = 0; LB = 1355. Since LB = UB∗, backtrack.

S8 = |(11)|, {|(12)(22)|}, |(21)|; LBF = 700, LBD = 500, LBP = 160; LB = 1360. Since LB > UB∗, backtrack.

S9 = |(11)|, |(12)|, |(22)|; LBF = 635, LBD = 400, LBP = 65 + 200 = 265; LB = 1300.

S10 = |(12)|, |(11)(21)|, |(22)|, |(13)|; LBF = 775, LBD = 600, LBP = 0; LB = 1375. Since LB > UB∗, backtrack.

S11 = {|(11)(21)|}, |(12)|, |(22)|, |(13)|; LBF = 755, LBD = 600, LBP = 0; LB = 1355. Since LB = UB∗, backtrack.Note that at this node we have used preempt–resume.

Explanation:

• At t = 0, the first job of the discontinuous batch b′1 = {|(11)(21)|} starts and is completed at t = 10.

• At t = 15, the single-job batch |(12)| starts and is completed at t = 35.• At t = 35, no batch (jobs) is ready; the machine idles.• Job |(22)| is ready at t = 40.• At t = 50, job |(21)| is ready. The processing time of this job is 65 and it belongs to b′

1, with a size of 2. On the otherhand, the remaining processing time of the single-job batch being processed, |(22)|, is 50 and its size is 1. Therefore,job |(22)| must be interrupted and |(21)| starts (i.e., preempt–resume).

S12 = |(11)|, |(12)|, |(22)|, |(21)|; LBF = 635, LBD = 600, LBP = 160; LB = 1395. Since LB > UB∗, backtrack.

Search completed.The search tree is shown in Fig. 1.

5. Computational results

There are no benchmark test problem instances upon which to test the branch-and-bound algorithm (B&B) andcompare its performance with the dynamic programming algorithm (DP) of Hall and Potts. We, therefore, resorted togenerating a set of problem instances, consisting of three subsets: one with two customers, another with three and thethird with four. In each subset, the number of jobs was varied up to a total of 40. The jobs were randomly distributedamong customers, with each being assigned at least two jobs. Processing times were randomly generated integers fromthe uniform distribution defined on [1,1000]. To ensure that results are representative, 20 instances were generated foreach combination of number of jobs–number of customers. Each of the running times in Table 1 represents the averageover the appropriate 20 instances.

Since interaction between batch delivery costs and job processing times may affect problem hardness, we generatedtwo classes of problems. In classA, all job processing times are less than the delivery cost of the relevant customer, whilein class B it is possible randomly that some jobs have a processing time that exceeds the delivery cost. Furthermore,to assess the efficiency of B&B, another subset with eight customers was also generated. Table 2 shows the results forthis subset.

The computational experiments were run on a Pentium 4 computer with 2.80 GHz of CPU and 512 MB of RAM.Both B&B and DP were coded in C + +.


{|(11)(21)|},|(12)(22)|,|(31)|

|(11)|,|(12)|,|(22)|

S0

S1

S2

S3

S4

S5

S6

S7

S8

S9

S10

S11

S12

|(11)|,|(12)(22)|

|(12)(22)|,|(11)(21)|,|(31)|

|(11)|,|(12)(22)|,|(21)|

|(11)|,{|(12)(22)|}

|(11)(21)|,{|(12)(22)|},|31|

{|(11)(21)|},{|(12)(22)|},|31|

|(11)|,{|(12)(22)|},|(21)|

|(12)|,|(11)(21)|,|(22)|,|(13)|

|(11)|,|(12)|,|(22)|,|(21)|

{|(11)(21)|},|(12)(22)|,|31|

|(11)|,|(12)|

Fig. 1. Search tree.

Stars in Table 1 indicate that the corresponding dynamic programming problems could not be solved with thecomputing resources at our disposal. As can be clearly seen from that table, the DP algorithm has advantage over B&Bonly for some class A problem instances having two customers. For all other instances, B&B is more efficient by far.This is due to the time complexity of the DP algorithm, which can be clearly observed in the escalation of computingtime with the increase in the number of jobs. On the other hand, the efficiency of the B&B, which enables it to solvemost problem instances in less than 1 s, is attributable to the tightness of the lower bound, which has been derived onthe basis of careful analysis of the structural properties of the problem.

Effectiveness of the upper bound makes it possible to use it as a fast heuristic. Table 3 shows that on average itproduces solutions that are within 0.25% of the optimum (relative error = (UB/optimal − 1)). Moreover, the error issmaller for larger instances. However, it may be argued that the efficiency of the B&B obviates the need for a heuristicsolution.


Table 1Average running times (s) for problem instances with jobs randomly distributed among customers

Customers Jobs Class A Class B

DP B&B DP B&B

2 7 0.03 0.02 0.03 0.0112 0.24 0.02 0.24 0.0217 1.44 0.04 1.48 0.0222 5.86 0.56 5.88 0.0327 20.04 5.51 19.57 0.2232 50.20 84.73 50 0.6437 130.12 1076.04 125.40 2.1040 210.26 4556.58 204.55 5.64

3 7 0.11 0.01 0.11 0.0112 2.52 0.02 2.66 0.0217 35.09 0.03 38.49 0.0320 128.80 0.05 143.95 0.0222 387.59 0.14 999.81 0.0227 * 1.06 * 0.1632 * 22.82 * 0.1837 * 186.27 * 0.3340 * 398.14 * 0.90

4 8 0.84 0.01 0.83 0.0110 4.28 0.02 4.23 0.0213 36.78 0.02 38.40 0.0216 908.86 0.03 936.77 0.0318 5799.52 0.03 * 0.0323 * 0.09 * 0.0428 * 0.67 * 0.0232 * 4.23 * 0.1537 * 30.10 * 0.3440 * 112.56 * 1.04

Table 2Average running times (s) for problem instances with jobs randomly distributed among customers

Customers Jobs Class A Class B

8 16 0.02 0.0221 0.03 0.0326 0.06 0.0431 0.22 0.0436 3.14 0.5140 5.54 0.27

Table 3Average percentage relative error for upper bound heuristic

Customers Class A Class B

2 0.25 0.063 0.24 0.074 0.25 0.078 0.18 0.11

The complexity of the dynamic programming algorithm is such that for the same number of jobs, problem instanceswith a larger number of customers are more difficult. Interestingly, the opposite is true for the branch-and-boundalgorithm. This is so because when the number of customers is large, the algorithm is in effect searching over a largernumber of smaller subsequences, with much smaller numbers of possible permutations.


6. Conclusions

A branch-and-bound algorithm for scheduling a set of jobs with specified release times to be processed on a singlemachine for delivery in batches to customers has been presented. The scheduling objective adopted is that of minimizingthe sum of flow times and delivery costs. The problem arises in the context of coordination between machine schedulingand a distribution system in a supply chain network.

The branch-and-bound algorithm proved to be very efficient. Indeed, it proved to be far more efficient than the onlyexisting algorithm for solving the problem, which is based on dynamic programming. This efficiency is attributable tothe tightness of the lower bound derived.

A very effective heuristic solution procedure has also been developed. However, it may be argued that since the timerequired for the branch-and-bound algorithm to find a provably optimum solution is very short indeed, the value of theheuristic algorithm is thereby diminished.

The lower bound, the heuristic solution and the design of various elements of the branch-and-bound search are basedon careful analysis of the structural properties of the problem. This analysis provides useful insights into problems ofscheduling with batching in general. In this regard, Propositions 3.1 and 3.4 and Property 3.3 seem most important.

Acknowledgment

The authors wish to thank an anonymous referee for helpful comments that helped make some of the proofs moreconcise.

References

[1] Lenstra JK, Rinnooy Kan AHG, Brucker P. Complexity of machine scheduling problems. Annals of Discrete Mathematics 1977;1:343–62.[2] Baker KR. Introduction to sequencing and scheduling. New York: Wiley; 1974.[3] Smith WE. Various optimizers for single stage production. Naval Research Logistic Quarterly 1956;3:59–66.[4] Chu C. Efficient heuristics to minimize total flow time with release dates. Operations Research Letters 1992;12:321–30.[5] Deogun JS. On scheduling with ready times to minimize mean flow time. The Computer Journal 1983;26:320–8.[6] Dessouky MI, Deogun JS. Sequencing jobs with unequal ready times to minimize mean flow time. SIAM Journal on Computing 1981;10:

192–202.[7] Bianco L, Ricciardelli S. Scheduling of a single machine to minimize total weighted completion time subject to release dates. Naval Research

Logistics Quarterly 1982;29:151–67.[8] Belouadah H, Posner ME, Potts CN. Scheduling with release dates on a single machine to minimize total weighted completion time. Discrete

Applied Mathematics 1992;36:213–31.[9] Cheng TCE, Gordon VS, Kovalyov MY. Single machine scheduling with batch deliveries. European Journal of Operational Research

1996;115:227–83.[10] Lee C-Y, Chen Z-L. Machine scheduling with transportation consideration. Journal of Scheduling 2001;4:3–24.[11] Hall NG, Potts CN. Supply chain scheduling: batching and delivery. Operations Research 2003;51:566–84.[12] Mahdavi Mazdeh M, Sarhadi M, Hindi KS. A branch-and-bound algorithm for single-machine scheduling with batch delivery minimizing flow

times and delivery costs; 2006, submitted for publication.[13] Graham RL, Lawler EL, Lenstra JK, Rinnooy Kan AHG. Optimization and approximation in deterministic machine scheduling: a survey.

Annals of Discrete Mathematics 1979;5:287–326.[14] Mahdavi Mazdeh M. Minimizing the sum of flow times with batching and delivery in a supply chain. PhD thesis, Brunel University, England,

2005.

Documents

A branch-and-bound algorithm for single-machine scheduling with batch delivery and job release times