FOUNDATIONS OF COMPUTING AND DECISION SCIENCES Vol. 39 (2014) No. 1

DOI: 10.2478/fcds-2014-0001

ISSN 0867-6356 e-ISSN 2300-3405

BATCH SCHEDULING IN A TWO-STAGE FLEXIBLE FLOW

SHOP PROBLEM

Enrique Gerstl*, Gur Mosheiov * and Assaf Sarig**

Abstract. We study a special two-stage flexible flowshop, which consists of several parallel identical machines in the first stage and a single machine in the second stage. We assume identical jobs, and the option of batching, with a required setup time prior to the processing of a new batch. We also consider the option to use only a subset of the available machines. The objective is minimum makespan. A unique optimal solution is introduced, containing the optimal number of machines to be used, the sequence of batch sizes, and the batch schedule. The running time of our proposed solution algorithm is independent of the number of jobs, and linear in the number of machines.

Keywords: Deterministic Scheduling, Flexible Flowshop, Batch Scheduling

1. Introduction

A flexible flowshop is a machine setting consisting of several stages in series, where each stage contains a number of parallel machines. Minimizing makespan on a general flexible flowshop is clearly NP-hard, since it is a generalization of both minimum makespan on parallel identical machines and minimum makespan on a classical flowshop (with at least three machines). In fact, minimum makespan on a flexible flowshop was shown to be strongly NP-hard even for the special case of (i) two stages, (ii) two identical machines in one stage and a single machine in the second stage, and (Hi) when preemption is allowed (Hoogeveen et al. [11]). We refer the reader to the recent survey on flexible flowshops by

* Enrique Gerstl, School of Business Administration, The Hebrew University, Jerusalem, Israel;

Gur Mosheiov, School of Business Administration, The Hebrew University, Jerusalem, Israel.

** Assaf Sarig, The Center for Academics Studies, Or Yehuda, Israel

Acknowledgement: This paper was supported in part by The Recanati Fund and The Charles Rosen Chair of Management, The School of Business Administration, The Hebrew University, Jerusalem, Israel.

Ruiz and Vazquez-Rodriguez [25], which contains 225 references, dealing with various combinations of flexible flowshop settings and objective functions.

Several researchers studied the special two-stage flexible flowshop setting, where the first stage consists of m parallel identical machines and the second stage contains a single machine. This setting is known in the literature as look-behind flowshop (LBFS); see e.g., Lee and Vairaktarakis [15]. LFBS has numerous applications, including the standard manufacturing system of several parallel identical production machines followed by a single machine (station) for painting, rapping, loading, assembly, etc. [Lee and Vairaktarakis [15] also defined the symmetric setting, in which the first stage contains a single machine and the second stage consists of m parallel identical machines. They denoted this setting by LAFS (look-ahead flexible flowshop)] A similar setting of a two-stage flowshop with a single (critical) machine in one of these stages and several dedicated machines in the other stage has been studied by e.g., Oguz et al. [23], Cheng and Kovalyov [5], Lin [16], Kyparisis and Koulamas [14], Lin and Liao [17], Mosheiov and Yovel [21], Cheng et al. [6], Oguz and Ercan [22], and Gerstl and Mosheiov [9], among others.

In this paper we focus on an LFBS system, in the context of batch scheduling; see e.g., Monma and Potts [18] and Allahverdi et al. [1]. Recall that in batch scheduling jobs may be grouped and processed in batches. The processing time of a batch is identical to the total processing times of the jobs contained in the batch. Prior to starting a new batch (either on one of the first stage machines, or on the second stage machine), a setup time is performed, during which the production process is stopped. Each of the batches is performed on one of the first stage machines, and upon completion, continues (as a batch) to the second stage machine. Each first-stage machine can process (at most) a single batch. As commonly assumed in batch scheduling models, we consider: (i) batch availability, i.e., jobs can start processing on the second-stage machine only when their entire batch is completed on the first-stage machine; (ii) non-anticipatory setup times, i.e., prior to starting the batch setup on the second-stage machine, the entire batch must be completed and released from the first-stage machine; (Hi) batch consistency, i.e., a batch remains unchanged on the firststage and on the second-stage machine. Finally, we consider here the very practical setting of identical processing time jobs. The numerous studies of scheduling identical jobs reflect the many applications of this setting, in particular the many types of production lines of identical items (see e.g., the two recent surveys: Baptiste and Brucker [2], and Kravchenko and Werner [13]). We note that the special case of the problem studied here; where the parallel machines in each stage of the flexible flowshop are replaced by a single machine (i.e., minimizing makespan on an m-machine flowshop with identical jobs and batching) has been solved in Mosheiov and Oron [19].

In a recent paper, Fanjul-Peyro and Ruiz [7] introduced and tested numerically algorithms for solving systems with the option of using only a subset of all the available machines. They focused on the option of Not-All-Machines (NAM) on parallel-unrelated machines. Previously, Cao et al. [3] introduced a tabu search algorithm to minimize the machine holding cost for a NAM model on parallel identical machines; Chen and Li [4] considered the case that the number of machines can be reduced by outsourcing jobs to an external production line; Finke et al. [8] studied a NAM model with precedence constraints, and Kravchenko and Werner [12] considered NAM problems with release dates and deadlines. Among the many applications of the NAM decision, Fanjul-Peyro and Ruiz [7] mention a typical setting of a shop in which some machines remain idle due to the large capacity of the system, which exceeds the total demand.

Given all the above (unit jobs, batching, NAM), an optimal solution for our proposed LBFS model consists of the following decisions: (i) How many first-stage machines to use; (ii) Given the number of machines - how to allocate jobs to batches; and (iii) How to schedule these batches. First we introduce a lower bound on the optimal makespan, obtained by solving to optimality the relaxed version of the problem in which non-integer batch sizes are permitted. This solution consists of a unique increasing sequence of batch sizes. Then, we convert this solution into an optimal integer schedule. The total running time is shown to be independent of the number of jobs, and is linear in the number of firststage machines. (As indicated later, the running time of the algorithm is not polynomial in the input size. However, since the number of batches that need to be calculated and stored is of the order of the number of the machines, this running time seems to be the smallest possible.)

In a recent paper, Gerstl and Mosheiov [10] studied the LAFS version of the problem, i.e., when a single machine is considered in stage 1, and m parallel identical machines in stage 2. LAFS and LBFS may have significantly different applications. An LAFS system may consist of a single common production machine followed by several parallel customization stations. LBFS may model a plant having a number of parallel manufacturing units in stage one, followed by e.g., a common quality-control/rapping/painting station. Despite the different nature of the two models, the analysis of both appears to be related. Using a similar approach to that used by Gerstl and Mosheiov [10], we obtain a nonstandard sequence of optimal batch sizes for the relaxed version of the problem (where noninteger batch sizes are allowed). We then introduce a rounding procedure, which guarantees an optimal solution for the original (integer) version.

The paper is organized as follows: Section 2 contains the notation and the problem formulation; Section 3 provides the lower bound based on the solution of the relaxed version; Section 4 presents the optimal integer solution.

2. Formulation

We study a 2-stage flexible flowshop (FFs), where the first stage consists of m parallel identical machines, and the second stage consists of a single common machine (called critical). We denote this special flowshop structure by FFs(m, 1). There are n identical jobs, which are assumed to have unit processing times after appropriate scaling. Thus, if ptj denotes the processing time of job j on machine i, we have ptj = 1, i = 1,..., m + 1, j = 1,..., n (where machine m + 1 is the critical machine). The jobs processed on machine i (i = 1,..., m) are processed later as a single block (batch) on the critical machine. An integer setup time, denoted by S, is required prior to starting the process of a batch on each of the first m machines, as well as on the critical machine. We assume a machine-independent setup time. If k machines are used in the first stage (k < m), then for a given allocation of jobs to these k machines, the number of jobs assigned to machine i is denoted by nt, i = 1,..., k. Clearly, E!=1 ni = n. Finally, recall that our model assumes batch availability, non-anticipatory setup times, and batch consistency; see above.

For a given schedule, the completion time of the last job on machine i (i.e., the completion time of batch i on the first stage machine) is denoted by Ct, i = 1,..., k. The

completion time of batch i on the critical machine is denoted by C( , i = 1,..., k. Let Cmax = max {C! , i = 1, ..., k}. Thus, the problem studied in this paper is: FFs^ 1)/ S, Pij = 1 /Cmax.

3. A lower bound on the optimal makespan value

A solution for the problem FFs(m, 1)/ S, p^ = 1 /Cmax consists of: (i) a decision on the

optimal number of (the first-stage) machines to be used, (ii) the allocation of jobs to

machines, and (Hi) the job schedule. According to the well-known reversibility property in

flowshops, the makespan does not change if the jobs go through the flowshop in the

opposite direction in the reverse order; see e.g. Pinedo [24]. Thus, a possible solution

procedure could be based on the reversed solution of FFs( 1, m)/ S, ptj = 1 /Cmax, given

in (10). However, due to the different structure of the optimal schedules in both cases, we

introduce in the following the properties of an optimal schedule for FFs(m, 1), and

consequently we provide a complete solution for this problem.

We first solve the relaxed version of the problem, allowing non-integer batch sizes. The

optimal solution for the relaxed version is clearly a lower bound on the optimal makespan

of FFs(m, 1)/ S, pij = 1 /Cmax. We use the following notation for the relaxed version:

(!) (!) n( ) is the size of batch i in the relaxed version, C!( )is the completion time of batch i on

the first stage machine, and cfCR'RR is the completion time of batch i on the critical

machine. C:m'ax is the optimal makespan for the relaxed version. In the following we prove several properties of an optimal schedule:

Property 1: If S > n, an optimal schedule exists such that a single machine is used in the first stage (k = 1).

Proof: For k = 1 (single machine is used in the first stage) the makespan is 2S + 2n. For k > 2 the makespan is at least (fc + 1)S + n, which is larger than 2S + 2 n. ■

In the remainder of this paper we assume S < n.

Property 2: For a given number k of machines used, an optimal schedule exists such that n^ = 5 + 2n(!), i = 1,..., k - 1.

(!) (!)

Proof: We focus first on the first two batches, and prove that n2 ) = S + 2n( ).

Assume that an optimal schedule q exists such that: > S + 2n[R\ The completion time of the second batch on the critical machine is given by: c!°R'!(q) = 2S + 2n^p. Let e = n!! — S — 2n<(R! > 0. We create a schedule q' by increasing n^ by e/3 (n1 = n+ e/3), and decreasing n^ by e/3 (n2 = — e/3). We obtain: c!°R'!(q ) = 2S + 2n2 = 2S + 2(n(R) - e/3) < c!CR"(q).

Assume now that in schedule q: n^ < S + 2 n^. The completion time of the second batch on the critical machine is given by: c!fR'!(q) = 3S + 2n^ + n^. Let e = 2n^ + S — n> 0. We create a schedule q' by decreasing n<(R! by e/3 (n[ = n<(R! — e/3), and increasing n^ by e/3 (n'2 = n^ + e/3). We obtain: c!°R'! (q') = 3 S + 2 n! + n2 =

3S + 2(n(R) - e/3) + (nf) + e/3) < c(CR'!(q).

(!) (!)

We conclude that schedule q' (with n2 ) = S + 2n( )) is optimal as well.

The remaining proof is by induction. Assume that = S + 2n(R\ i = 1, ..., I for

(!) (!)

some I < k — 1. A similar proof leads to the equality n(+2 = S + 2n(+!. It follows that for a given k values, = S + 2n(R\ i = 1,..., k — 1. ■

Property 3: For a given number k of machines used, an optimal schedule exists such that

n(fl) = n^S^ (1)

Proof: Since = S + 2n(R!, i = 1, ..., k — 1 (Property 2), we can easily express n^ as a function of n!!) and 5:

n(«) = 2!-!n[R) + (2fc_1 - (2)

From 2i=i = n and Property 2, it follows: n = £!=1 n(!) = + £!=2 n(!) = n(R) + E?=2(2ni(!)1 + 5) = n(R) + (fc - 1)S + 2 £!-!n(!) = n+ (fc - 1)5 + 2!(n -

(!) _ n+n^' + Cfc-l)S

From equations (2) and (3) we obtain that 2k~1n(R) + (2fc!l - 1)S = . It

follows that:

«) = n^zf-^. (4)

Based on Properties 2 and 3, the makespan value for a given k value is the sum of the idle time on the critical machine (which is identical to the setup time and the total

processing time of the first batch, i.e., 5 + n( )), and the total processing time of the k batches on the critical machine (i.e., kS + n). Thus,

cjfR'RR = S + n[RR + kS + n = 5( k + 1) + + n. (5)

In order to find the optimal makespan value (for the relaxed version), we have to solve (5) for all k values. Let k* denote the optimal number of machines used. Clearly, 1 < k * < m. The following property introduces better bounds on k *:

Property 4: The optimal number of machines to be used is bounded by:

log2 (l + (! + l) In (2)) < fc* < log2( 1 + g + m) ln(2)). (6)

Proof. Allowing k to be non-integer, c'^R'RR is continuous and convex in k. Thus, the optimal (non-integer) k value can be found by standard derivation. The derivative of (5) with respect to k is:

dc(C",X) (_S2k ln(2)+s)(2!-l)-(n-S(2k-k-l))2k 1"2)

~~dk _ S + (2!-l)2 .

dc(CR,R)

kdk = 0 leads to. S2k - Sk ln(2) = S + n ln(2) , or

2k - k ln(2) = 1 + ^. (7)

Since 1 < k < m, the left-hand-side of (7) is bounded by:

2k - m ln(2) < 2k - k ln(2) < 2k - ln(2).

It follows that:

2k - m ln(2) < 1 + ^^ < 2k - ln(2) . We obtain the following bounds on the optimal number of machines used:

k* < log2 (l + (! + m) ln(2));

fc* > log2( 1 + (! + l) ln(2)). ■

Since k is clearly bounded by m, and must be an integer, the actual upper bound on its value is

kUB = min [m, [log2 ( 1 + + mj ln(2))|}. (8)

Similarly, the actual lower bound on k is

kLB = min [m, [log2 ( 1 + + l) ln(2))]J. (9)

The optimal number of machines, k *, is a non-decreasing function of the number of jobs n, and a non-increasing function of the setup time S. Figure 1 demonstrates k * as a function of n (for a given S value; S = 20). Similarly, Figure 2 demonstrates k* as a function of S (for a given n value; n = 1000).

Figure 1. The optimal number of used machines as a function of the number of jobs

(S = 20).

Figure 2. The optimal number of used machines as a function of the setup time

(n = 1000).

Based on all the above, we introduce in the following a formal algorithm:

Lower Bound Algorithm (optimum of the relaxed version): Input: m, n, S;

SStep 1: Calculate kUB and kLB from (8) and (9). Step 2: For k = kLB to kUB

Calculate C,(CR'R) from (5). Step 3: The optimal makespan is given by (5): = minfcLB!fc!fcu^C^"'^}. k* is the appropriate k value.

The optimal sequence of batch sizes is given by (4) and (2) (for k *).

Running Time: Step 1 requires a constant time. Step 2 is performed 0(m) times, and each iteration requires a constant time. Finding C!min Step 3 requires 0(m), and then calculating the batch sizes requires 0 (m) as well. Thus, the total running time is 0 (m).

Numerical Examples: In the following we provide the solution for three 20-machine problems. The problems are different significantly from each other in the ratio n/S. As expected (see (8) and (9)), the number of candidates for the optimal number of machines decreases as this ratio increases.

Example 1: n = 1,000, S = 8, m = 20. In Step 1 of the algorithm we calculate the following bounds: kUB = 6.665; kLB = 6.465. It follows that k = 6 and k = 7 are candidates. We check the makespan of both k values (Step 2). This leads to the following optimal number of batches: k* = 7, and to the optimal solution (Step 3): n(R) = 0.315, n(R) = 8.630, n(R) = 25.259, n(R) = 58.520, n™ = 125.039, n(R) = 258.079,n(7R) = 524.157; C^J = 1064.315; see Figure 3.

Machine 1 Machine 2

Machine 3

l -1064.3

Figure 3. Optimal solution for Example 1 (the relaxed version): k* = 7; n^ ; = 0.315, n(2R) = 8.630, nf = 25.259, nf> = 58.520, nf) = 125.039, n(6R) = 258. 079, n(7R) = 524.157; C^ = 1064. 315.

Example 2: n = 1,000,S = 75,m = 20. The bounds on the optimal number of machines used are: kUB = 4.591; kLB = 3.451. The candidates are k = 3,4, 5. After checking all

(!) (!)

three candidates, we obtain the following optimum: k* = 4; n( ) = 11.667, n2 ) = 98.333, n(R) = 271.667, n^ = 618.333; C= 1386.667.

Example 3: n = 100,000,S = 8,m = 20. The bounds on the optimal number of batches are: kUB = 13.083; kLB = 13.081. The candidates are k = 13,14. The optimal solution consists of: k" = 13; n[R) = 4.221, n(R) = 16.442, n(R) = 40.885, n^ = 89.770, n(R) = 187.539, nC6R) = 383.079, n(R) = 774.158, n(R) = 1,556.316, n(R) = 3,120.632, nH" = 6,249.264, n!!) = 12,506.528, = 25,021.055, n[f = 50,050.111; C^ = 110,116.221..

4. An optimal integer solution

In the previous section we introduced a lower bound on the optimal makespan, obtained by solving the relaxed version of the problem, i.e., when non-integer batch sizes are permitted. In this section we convert this schedule into an optimal integer solution (with integer batch sizes). The optimal makespan value for the relaxed version, C^"?, is a lower bound on the optimal makespan for the integer version. It is clear that even the smallest integer larger than or equal to C^'J^!, i.e., [C^"?], remains a lower bound. Hence, an integer solution whose makespan is [C,!^] is optimal. In the following we introduce an algorithm that creates a schedule with this makespan value. We refer the reader to Mosheiov et al. [20], where a similar procedure was used to obtain an integer (not necessarily optimal) solution for a single machine batch-scheduling problem.

The optimal solution for the relaxed version of the problem consists of k* (the optimal number of batches) and n^,n~R!,... n^ïP (the batch sizes). Let Aj = n(!) — [n-^J, i = 1,..., k*, i.e., Aj is the "non-integer" part of the size of batch i. Let A= 2!=1 Aj. Since n =£!=1 =2!=1(|nJ + Aj) = A + 2!=1|nJ, A must be an integer. Based on these values, we convert the non-integer solution into an integer solution, using the following Rounding Procedure: we round up the first A batch sizes, and round down the remaining k* — A batch sizes. We use the following notation for the integer solution obtained by this procedure: is the (integer) size of batch i, C£(i)is the completion time of batch i on the

(C! !)

first stage machine, and Cj( ') is the completion time of batch i on the critical machine.

Note that the batch sizes obtained by the above procedure are given by:

= [nH, i = 1.....A;

nP = |n(!)J, i = A + 1,..., r. (10)

Clearly, the total "rounded up processing time" is identical to the total "rounded down processing time", i.e.,

Z?=i(1 - Aj) =Z?:A+1 Aj. (11)

Property 5: The solution based on the integer batch sizes n-7), i = 1,..., k* contains no idle time between consecutive batches on the critical machine.

Proof: In order to prove this property, we have to show that C£(/) < C^f"''11, i = 2,..., k*. We focus first on the first A batches (Claim 1 and Claim 2), and then on the remaining k* — A batches (Claim 3).

Claim 1: C( < C(_1' , i = 2,..., A (i.e., there is no idle time between consecutive batches among the set of the first (rounded-up) A batches). We have to show that for i = 2,..., A: 5 + n(/) < 2S + 2n^, or

[nH < 5 + 2[n(!)1l, or (by Property 2) \S + 2n(!)1] < 5 + 2[n(!)1l.

Since S is integer, we have to show that

5 + f2ni(!)J < 5 + 2\n^l, (12)

which is always correct.

We conclude that for the first A batches, there is no idle time between any two consecutive batches on the critical machine. Note that (12) is either equality or strict

(CR !) (!)

inequality, implying that the difference C!(_1 — C( cannot decrease when proceeding from one batch to the next. The maximum difference is obtained after completing the entire set of the A rounded up batches. Denote by X the total rounded up processing times of the first A batches, i.e., X = £f=1(1 - A,).

Claim 2: C(ACR',) - cf+\ > ^J.

C^ - C« = CiCR'R! + £^ 1 - A.) + (1 - Ai) - (cW - Aa+i).

(Note that Aa+1 is the non-integer part of the A + 1-st batch.)

Since Cf^ = C^!! (in the relaxed version the completion time of a given bacth on the first-sage machine is identical to the completion time of the previous batch on the critical machine), it follows that,

C<fR'I) - C« = E?=1( 1 - Aj) + (1 - AJ + Aa+1= X + (1 - AJ + Aa+1> [X\.

Since C£R'1) — is an integer, it follows from Claim 2 that C(fR'11 — > .

Claim 3: C£(/) < C^f"'71, i = A + 1,..., k* (i.e., there is no idle time between consecutive batches among the set of the last (rounded down) k* — A batches).

Now we have to show that for i = A,..., k* — 1: S + nf^ < S + + iS + EJ=1 n^p, or 5 + L»!;!J < 5 + \n™] + is + 2 ?= Jnf 1 + 2 > j, or

^ + n!!! - A!+1<

5 + n™ + (1 - Aj + is + £4=1 nf + £?=1( 1 - Aj) + £j.=A+1 „W - £j.=A+1 Aj.

From the solution of the relaxed version we have:

5 + n£\ = S + n[! + iS + 2!=1 n)! . Thus, we have to prove that:

-Ai+1< (1 - Aj + E?=1( 1 - Aj) -Zj.=A+1 Aj. (13)

Recall that 1 — Aj) = X is the total rounded up processing times of the first A batches. E;=a+i Aj is the total rounded down processing times of batches A + 1, A + 2,..., i. From (11) it follows that A+1 Aj = X. Thus, if Y = £j=A+1 Aj, then Y < X for any i = A + 1,..., k*. Hence, the left-hand-side of (13) is not positive, whereas the right-hand-side is not negative, which completes the proof. ■

Corollary 6: The makespan value obtained by the batch sizes n-7), i = 1,..., k* (defined in (10)) is given by:

CL = 5 + [nfl + k *S + n = SQc* + 1 +

n_S(2!*-fc*-l)

Note that (14) is identical to the lower bound on the optimal makespan ([C,!"?], see above), implying that our proposed procedure guarantees an optimal solution, i.e.,

C * = C(!)

°max °max■

Running time: Given the batch sizes of the relaxed version, calculation of each Aj requires a constant time, i.e., an 0(m) effort for all batches (since k* < m). Calculation of A as well the C,!"# values requires 0(m) time as well. Hence, the running time of the solution procedure of the integer version requires 0(m) time.

It follows that the entire solution procedure (consisting of (i) obtaining the optimal batch sizes for the relaxed version by the algorithm specified in Section 3, and of (ii) the above procedure for obtaining integer batches) requires 0(m) time.

Comment 1: We note that the input contains three numbers only: m, n and S, implying that the proposed (0(m)) algorithm is not polynomial in the input size. However, as mentioned in the introduction, since there are 0(m) batch sizes to be calculated and stored, a faster algorithm appears to be impossible.

Comment 2: In Gerstl and Mosheiov [10], a rounding procedure for FFs(l, m) was introduced, in order to convert the solution of the relaxed version into an integer solution. No proof of optimality of the resulting (integer) solution was provided. Due to (t) the fact that the rounding procedure suggested above (for FFs(m, 1)) was proved to be optimal, and (ii) the reversibility property in flowshops mentioned above, we claim that the rounding procedure guarantees an optimal solution for FFs(l, m) as well.

Numerical Examples: In the following we provide the integer solution for Examples 1-3 solved above for the relaxed version.

Example 1 (integer): n = 1,000, S = 8, m = 20. Recall that the optimal solution of the relaxed version consists of: k* = 7, n<(R! = 0.315,n^ = 8.630,n<3RR = 25.259,= 58.520,nfR = 125.039,n(R) = 258.079,n(R) = 524.157, and = 1064.315. We

obtain A= 2. It follows that the size of the first two batches is rounded up and that of the remaining (5 batches) is rounded down. Hence, an optimal solution to the problem is: n(1) = n! = 1, n! = n2 = 9, n(i) = = 25, n!! = n\ = 58, n= n*s = 125, n= n*6 = 258, n{.}) = n*7 = 524; = C^ax = 1065.

Example 2 (integer): n = 1,000,S = 75,m = 20. Given the optimal solution of the relaxed version we obtain A= 2. Thus, the size of two batches is rounded up and that of the remaining (2 batches) is rounded down. Hence, nl = 12,n*2 = 99,= 271,n\ = 618; C! ax = 1387.

Example 3 (integer): n = 100,000,S = 8,m = 20. We obtain A= 5. Thus, 5 batch sizes are rounded up and 8 batch sizes are rounded down. Hence, nl = 5, n'ti = 17, n*3 = 41, n*4 = 90, n*5 = 188, n! = 383, n; = 774, n*8 = 1,556, n*9 = 3,120, n*10 = 6,249, n*11 = 12,506, n*12 = 25,021, n*13 = 50,050; Q ax = 110,117.

5. Conclusion and future research

We solved a makespan minimization problem on a 2-stage flexible flowshop with m parallel identical machines in stage 1 and a single machine in stage 2. We considered the option of batching (each first-stage machine processes a single batch), and focused on the special case of identical jobs. The paper introduces an efficient solution algorithm, which provides answers to the following questions: (i) the optimal number of first-stage machines to be used, (it), the batch sizes, and (Hi) the optimal schedule of the batches. The running time of the algorithm is independent of the number of jobs, and is linear with the number of machines.

Future research may focus on the extension to general job processing times and/or to more general (not necessarily 2-stage) flowshops.

References

[1] Allahverdi, A., Ng, C.T., Cheng, T.C.E., Kovalyov, M.Y., A survey of scheduling problems with setup times or costs. European Journal of Operational Research, 187, 2008, 985-1032.

[2] Baptiste, P., Brucker, P., Scheduling equal processing time jobs. In: Leung J.Y.T. (Ed.), Handbook of Scheduling: Algorithms, Models, and Performance Analysis, Chapman & HALL/CRC, 2004.

[3] Cao, D., Chen, M., Wan, G., Parallel machine selection and job scheduling to minimize machine cost and job tardiness, Computers & Operations Research, 32, 2005, 19952012.

[4] Chen, Z.L., Li, C.L., Scheduling with subcontracting options. IIE Transactions, 40, 2008, 1171-1184.

[5] Cheng, T.C.E., Kovalyov, M.Y., An exact algorithm for batching and scheduling two part types in a mixed shop: A technical note, International Journal of Production Economics, 55, 1998, 53-56.

[6] Cheng, T.C.E., Kovalyov, M.Y., Chakhlevich, K.N., Batching in a two-stage flowshop with dedicated machines in second stage. IIE Transactions, 36, 2004, 87-93.

[7] Fanjul-Peyro, L., Ruiz, R., Scheduling unrelated parallel machines with optional machines and jobs selection, Computers and Operational Research, 39, 2012, 17451753.

[8] Finke, G., Lemaire, P., Proth, J. M., Queyranne, M., Minimizing the number of machines for minimum length schedules, European Journal of Operational Research, 199, 2009, 702-705.

[9] Gerstl, E., Mosheiov, G., A two-stage flow shop scheduling with a critical machine and batch availability, Foundations of Computing and Decision Sciences, 37, 2012, 39-56.

[10] Gerstl, E., Mosheiov, G., The optimal number of used machines in a two-stage flexible flowshop scheduling problem, Journal of Scheduling, 2013, DOI 10.1007/s10951-013-0343-z.

[11] Hoogeveen J.A., Lenstra, J.K., Veltman, B., Preemptive scheduling in a two-stage multi-processor flow-shop is NP-hard, European Journal of Operational Research, 89, 1996, 172-175.

[12] Kravchenko, S.A., Werner, F., Minimizing the number of machines for scheduling jobs with equal processing times, European Journal of Operational Research, 199, 2009, 595-600.

[13] Kravchenko, S.A., Werner, F., Parallel machine problems with equal processing times: a survey, Journal of Scheduling, 14, 2011, 435-444.

[14] Kyparisis, G.J., Koulamas, C., Flow shop and open shop scheduling with a critical machine and two operations per job, European Journal of Operational Research, 127, 2000, 120-125. '

[15] Lee C.-Y., Vairaktarakis, G.L., Performance comparison of some classes of flexible flowshops and jobshops, The International Journal of Flexible Manufacturing Systems, 10, 1998, 379-405.

[16] Lin, M.T.B., The strong NP-hardness of two-stage flowshop scheduling with common second-stage machine. Computers and Operations Research, 26, 1999, 695-69.

[17] Lin, H.-T., Liao, C.-J., A case study in a two-stage hybrid flow shop with setup time and dedicated machines, International Journal of Production Economics, 86, 2003, 133-143.

[18] Monma, C.L., Potts, C.N., On the complexity of scheduling with batch setup times. Operations Research, 37, 1989, 789-804.

[19] Mosheiov, G., Oron, D., A note on flow-shop and job-shop batch scheduling with identical processing-time jobs, European Journal of Operational Research, 161, 2005, 285-291.

[20] Mosheiov, G., Oron, D., Ritov, Y., Minimizing flowtime on a single machine with integer batch sizes, Operations Research Letters, 33, 2005, 497-501.

[21] Mosheiov, G., Yovel, U., Comments on "Flow shop and open shop scheduling with critical machine and two operations per job", European Journal of Operational Research, 157, 2004, 257-261.

[22] Oguz, C., Ercan, M.F., A Genetic Algorithm for Hybrid Flow-Shop Scheduling with Multiprocessor Tasks, Journal of Scheduling, 8, 2005, 323-351.

[23] Oguz, C., Lin, M.T.B., Cheng, T. C. E., Two-stage scheduling with a common second-stage machine, Computers and Operations Research, 24, 1997, 1169-1174.

[24] Pinedo, M., Scheduling: Theory, Algorithms, and Systems. Prentice-Hall, 1995.

[25] Ruiz, R., Vazquez-Rodriguez, J.A., The hybrid flow shop scheduling problem, European Journal of Operational Research, 205, 2010, 1-18.

Received October, 2013