#### Abstract

We study a batch scheduling problem on a 2-machine flowshop. We assume unit processing time jobs, batch availability, and machine-dependent setup times. The objective is to find a job allocation to batches of integer size and a batch schedule that minimize makespan. We introduce a very efficient closed form solution for the problem.

#### 1. Introduction

The recent survey paper “A Survey on Scheduling Problems with Setup Times and Costs” [1], classifies batch scheduling problems into those with batching and nonbatching considerations, with sequence-independent and sequence-dependent setup times, and according to the machine environment and the objective function. The survey contains approximately 300 references, a clear indication of the importance and relevance of this topic.

In this paper we study batch scheduling problems on a 2-machine flowshop. The objective function is minimum makespan. The underlying assumptions in the model studied are as follows.

(i)*Batch availability*: all the jobs are completed when the last job of the batch is completed (and then the entire batch is available for processing on the second machine, or for delivery to customers).(ii)

*Nonanticipatory setups*: setups on the second machine may be performed only after processing of the batch on the first machine has been completed.(iii)

*Batch consistency*: batch formation is identical on both machines.(iv)

*Machine-dependent setup times*: machine 1 and machine 2 have different setup times (which are identical for all batches).

The 2-machine flow-shop under the above assumptions was shown to be strongly NP-hard by Cheng et al. [2], and Glass et al. [3]. We focus, however, on an important special case, which is shown to have an elegant closed form solution. Specifically, we assume *unit processing time jobs*. This setting is known to have various applications, and in the manufacturing context, for example, it reflects the common systems in which sequences of identical items are produced. Scheduling with unit jobs has been studied extensively in many scheduling contexts. Batch scheduling on flowshops with unit processing time jobs have been studied by Mosheiov and Oron [4, 5], Ng and Kovalyov [6], and Mosheiov, et al. [7].

In all the above papers, the authors consider identical (i.e., machine-independent) setup times. Our study, as mentioned, focuses on *machine-dependent* setups. Scheduling problems containing machine-dependent setups exist in numerous real-life applications, and have been extensively studied in various contexts. It appears, however, that a model assuming both unit jobs and machine-dependent setups is considered in this paper for the first time. Possible applications for such a setting, when similar or identical operations, are performed on the jobs on the different machines, but an additional operation requiring constant time must be performed on one of the machines (or different constant time operations are performed on the different machines). These operations may be viewed as batching operations, where all jobs of a given batch undergo some type of process which is performed in constant time, independent of the number of jobs in the batch. Such operations may include special loading or recording of arriving batches on the first machine, initial quality assurance, or special preparation of batches prior to processing. Constant time operations on the last machine include, again, preparation of batches for shipment and dispatching of batches (stamping, spray painting), quality assurance procedures (random testing of a fixed number of items or batching procedures such as scanning), or administrative operations which may include paperwork, recording of data, and so forth.

We distinguish between the following two (similar but nonsymmetric) cases: the setup on the first machine is larger than the setup on the second machine, and, the setup on the first machine is smaller than the setup on the second machine. For both cases, we show that the makespan minimization problem is solved efficiently in time, where *n* is the number of jobs. It is important to note that the existing algorithms solve a special case of the problem studied in this paper, namely, when , in time. Thus, the algorithm presented in this paper reduces the computational effort required to obtain an optimal solution even if the problem is more complex. It should be noted that both the existing algorithms and the current solution procedure are not polynomial in the problem input size. Since we consider unit processing time jobs, the input consists of three values (), the number of jobs, and the setup time on each of the two machines. Thus, even a procedure requiring time is exponential in the input size. Nevertheless, we doubt that there is a way to express the optimal solution to this problem more efficiently.

It should be noted that a first step in the solution consists of solving the “relaxed version” in which integrality of the batch sizes is not required (see below). This, in fact, is a *lot streaming* problem, as it consists of splitting given jobs into sublots in order to allow their overlapping processing on the two successive machines of the flowshop. Chen and Steiner [8, 9], and Liu [10] addressed lot streaming problems on flow-shops with batches of integer size. Vickson [11] addressed lot streaming of a flow-shop with machine-dependent setup times. However, to the best of our knowledge, the model considered in this paper (assuming machine-dependent setups, and requiring integrality of batch sizes), has not been studied before.

In Section 2, we present the notation and formulation of the problem. The optimal solution is provided in Section 3 (and the appendix). Section 4 contains concluding remarks and ideas for future research.

#### 2. Formulation

independent jobs are available for processing on a 2-machine flowshop at time zero. denotes the processing time of job on machine . We assume unit processing times, therefore for and for *i* = 1,2. The scheduler's task is to partition jobs into batches (i.e., find their optimal number and size), and to schedule the batches so as to minimize makespan.

Prior to processing a new batch, an (integer) machine dependent setup time, , is incurred. As mentioned above, setups are assumed to be *nonanticipatory*. For a given allocation to batches, let denote the number of batches, and let denote the size of the batch. The total processing time of batch is clearly equal to its size. We assume (see above) *batch-availability* and *batch consistency*. denotes the completion time of batch , which is the completion time of all the jobs contained in batch . Using the conventional three field notation, the problem studied in this paper is .

*Comment 1. *A standard assumption is that all input parameters are nonnegative integers, implying in our case that both the (identical) processing times and the (machine-dependent) setups are integers. One can assume that after appropriate scaling all processing times have unit time, but clearly the setups do not necessarily remain integers. Thus, we do allow and investigate the case of noninteger setup times; see Comment 3 in Section 3 and Comment A.1 in the appendix. (Note that the computational effort for this more general case remains through the use of the proposed algorithm.)

#### 3. A Closed Form Solution for

We focus here on the case that the setup time on the first machine is smaller, that is (The case although not completely symmetric, is similar and its analysis appears in the appendix. The case of machine independent setups, that is, when is studied in [4, 6].) For convenience we begin by solving the *relaxed* version of the problem (denoted by ), in which batch sizes are allowed to have noninteger values.

First, we introduce a lower bound on the optimal makespan for a given number of batches, *k*. As in the classical 2-machine flow-shop problem, a lower bound is obtained when no idle time is incurred between consecutive batches on the second machine. Given the unavoidable idle time prior to the processing of the first batch on the second machine, we obtain

A schedule attaining this lower bound must contain no idle time between consecutive jobs on the second machine. A necessary and sufficient condition for no idle time is the following: This is true since the completion time of batch on the first machine cannot exceed the completion time of batch on the second machine One schedule satisfying these conditions consists of batch sizes obtained by the following set of *equalities*: The resulting schedule consists of the following sequence of increasing batch sizes: . Given the fact that , we easily obtain that

The above schedule has a makespan value which is equal to the lower bound, and is therefore optimal for problem and a given *k* value.

The makespan value of the above schedule is

Note that (3.3) is a strictly convex function in *k* and the unique minimum is given by

Recall that *k* denotes the optimal (integer) number of batches, and therefore, due to the convexity of(3.3)

Both and should be considered.

We conclude that an optimal solution for the relaxed version of the problem () is given by (3.4), (3.5), and (3.2).

We now consider the original problem, where batch sizes are restricted to be integers, denoted by. A lower bound on the optimal solution is

(Note that as defined above is the size of the first batch of the solution of relaxed version. In the special case that is integer, then, clearly, the “ceiling” is redundant, and the lower bound is identical to the makespan value given in (3.3).)

The lower bound given in (3.6) is the smallest integer which is larger than or equal to the makespan value for problem . Any schedule that consists of batches of *integer size* yielding this makespan is clearly optimal.

If (given in (3.2) is integer, then clearly all batches are integers and the solution for problem is optimal for the original problem, . For the general case, where is not necessarily integer, let .

Since , we obtain that is an integer (strictly smaller than *k*). Based on the solution for problem , we construct a solution for problem by rounding down the size of batches and rounding up the size of the remaining batches, where . One option is to round up the size of the first batches, and round down the size of the last *l* batches. The resulting job allocation to batches is It is easily verified that in the above schedule: the idle time prior to batch 1 on machine 2 is and there is no idle time between consecutive batches on machine 2. Thus, the makespan value of this schedule is

Note that the above value for the makespan is identical to the lower bound for problem given in (3.6). We conclude that for any value of , the above schedule is optimal.

*Comment 2. *It is worth mentioning that the optimal solution is not unique, and other rounding procedures may lead to other optimal schedules. One alternative example consists of rounding down the first *l* batches and rounding up the last batches.

The resulting job allocation to batches is .

In this case, it is easily verified that there is no idle time between consecutive batches on machine 2 for , there exists 1 unit of idle time between batches and , and there is no idle time between consecutive batches on machine 2 for . The makespan value of this schedule (clearly, given that is not integer) is
This value for the makespan is identical to the value given in (3.7), implying that this schedule is optimal as well.

It remains to find the optimal number of batches, . Note that due to the integrality of and , the makespan function (3.7) can be slightly modified as follows:

It follows that the value minimizing (3.7) also minimizes (3.9). Hence the optimal *k* value for the relaxed version given in (3.4) and (3.5) is optimal for the integer version. We denote the latter by A formal algorithm is provided in Algorithm 3.1.

*Algorithm 3.1 (flowshop_makespan_). *Input: *Step 1 (Optimal number of batches). *Calculate and (from (3.4) and (3.5).

If (in (3.7), then otherwise *Step 2 (Optimal batches). *
(from (3.2).*Step 3 (Rounding). *Calculate the non-integer part of the batch size,.

Calculate the number of batches to be rounded down,

An optimal integer allocation to batches is

*Running Time*

It is easily verified that the algorithm is performed in time. While the calculation of the optimal number of batches and the optimal makespan are performed in constant time, Step 2 of the algorithm requires calculating the batch sizes. Since the number of batches is , the computational effort required is . Step 3 can easily be performed in time, and consequently, the total running time Algorithm 3.1is .

The use of Algorithm 3.1 is demonstrated in the following example.

*Example 3.2. *Assume , and , . In Step 1 we calculate and (the associate optimal makespan value is 111). In Step 2 we obtain the batch sizes (for the relaxed problem): , and . The rounding procedure (Step 3) leads to the following optimal sequence of batch sizes: and ; see Figure 1. The makespan as a function of the number of batches (both for the relaxed and for the integer versions) is presented in Figure 2.

*Comment 3. *Consider the interesting generalization to the case of *non-integer* setup times. In this case, the optimal *k* value for (3.7) may be different from that of (3.3), (e.g., if , and we obtain implying that the optimal value for the relaxed problem is either 6 or 7, however, the optimal value for the integer version is 5.) It appears that in this general case (non-integer setups), a closed form expression for the optimal value does not seem to exist, and a search must be performed. Clearly, a search over all possible values (1 through *n*) guarantees an optimal solution. However, a limited search appears to be sufficient, due to the fact that the smallest batch must be nonnegative. From (3.2) we obtain . Consequently, . The first term is strictly negative (recall that ), implying that *k* is an integer in the range , where
We conclude that despite the need to consider a range of possible values for the number of batches, *k*, the computational effort required for solving the problem with non-integer setup times remains .

*Comment 4. *It is easily verified that the algorithm proposed in this section generalizes the algorithm introduced in Mosheiov and Oron [4], for the case of machine-independent setups. When substituting in the expressions along the above algorithm, we obtain the optimal solution for this special case. In particular, substituting in Step 2 leads to “equal allocation” to batches (using the terminology of [4]), and the rounding procedure, that is, rounding up the size of the first batches and rounding down the size of the remaining batches generates an optimal integer solution.

#### 4. Conclusion

We study a new version of makespan minimization on a 2-machine flowshop. We consider unit time jobs which may be grouped into batches. The setup times are assumed to be machine-dependent. We introduce an elegant closed form solution for two different cases.

A challenging extension is to the setting of an *m*-machine flowshop . Another interesting question refers to a 2-machine jobshop setting. Although not published yet, both problems appear to have similar properties and structures and may have closed form solutions for the number of batches and their sizes. The *m*-machine jobshop case is known to be strongly NP-hard even with no setups [12]. Thus, future research dealing with this extension may focus either on an introduction of heuristics/approximations or on developing exact (pseudopolynomial) solution algorithms.

#### Appendix

#### The Case

As mentioned, the analysis of the case is similar to that of the case Again, we focus first on the relaxed version. It is easily verified that lower bound (3.1) for a given number of batches *k*, still holds. As in the previous case, a schedule attaining this lower bound must have no idle time between consecutive jobs on the second machine. The conditions are still valid, and since these could be written as A schedule based on equalities clearly satisfies these conditions, leading, again, to a constant difference between the size of consecutive batches: . Since the total size of all the batches is *n*, we obtain the following schedule of decreasing batch sizes:

Note that the resulting schedule is identical to the one obtained for the case , in a reversed order: the largest batch becomes first, the second-to-largest second, and so forth. This schedule has a makespan value identical to the lower bound (3.1), and is therefore optimal for the relaxed problem and a given *k* value.

The makespan value is given by

(Note that (A.2) is identical to the makespan value (3.3) obtained earlier.) Since the function (A.2) is strictly convex, the optimal (integer) *k*-value is obtained by a simple differentiation and rounding to one of the two nearest integers (see (3.4) and (3.5). Given this optimal solution for the relaxed problem, we consider again the integer version. We suggest the rounding procedure introduced earlier, that is, round up the first *k*-*l* batches, and round down the remaining *l* batches (where , and ). This schedule of integer batch sizes is optimal since its makespan value (given by (3.7) is identical to the lower bound (3.6). Our last argument refers to the optimal number of integer batches. As in the previous case, due to the integrality of and the (integer) makespan value is given by

which is minimized by the same *k* value that minimizes the objective of the relaxed version (A.2). Hence the optimal number of batches is given, as before, by (3.4) and (3.5).

We conclude that an optimal solution for the case is obtained by a very similar (constant time) algorithm to the one introduced for the case . (Step 2 is slightly different due to the fact that the sequence of batch sizes is decreasing.) For the sake of briefness, we omit the formal algorithm.

*Example A.1. *We replace the values of *s*_{1} and *s*_{2} in Example 3.2: *n* = 80, *s*_{1} = 3, *s*_{2} = 2. The optimal number of batches (Step 1) remains 6. In Step 2 we obtain the batch sizes (for the relaxed problem): *n*_{1} = 15.833, *n*_{2} = 14.833, *n*_{3} = 13.833, *n*_{4} = 12.833, *n*_{5} = 11.833, and *n*_{6} = 10.833. (Note that this sequence is the reversed sequence obtained for the relaxed problem in Example 3.2.) An optimal integer solution (Step 3) consists of the following sequence of batch sizes: *n*_{1 }= 16, *n*_{2 }= 15, *n*_{3 }= 14, *n*_{4 }= 13, *n*_{5 }= 12, *n*_{6 }= 10; see Figure 3.

*Comment A.1. *In the case where the setup times are not necessarily integers, finding the optimal number of batches requires a search. Using the fact that the size of the smallest batch (now ) must be non-negative, we obtain (as in the previous case) the following upper bound on *k*: Since the search is limited to the integers in the interval [1,*m*], the total running time in this case becomes