Two-machine flowshop batching and scheduling

(1)

 2005 Springer Science + Business Media, Inc. Manufactured in The Netherlands.

Two-Machine Flowshop Batching and Scheduling

Department of Information and Finance Management, National Chiao Tung University, Hsinchu, Taiwan 545

Department of Logistics, The Hong Kong Polytechnic University, Kowloon, Hong Kong

Abstract. We consider in this paper a two-machine flowshop scheduling problem in which the first machine

processes jobs individually while the second machine processes jobs in batches. The forming of each batch on the second machine incurs a constant setup time. The objective is to minimize the makespan. This problem was previously shown to be NP-hard in the ordinary sense. In this paper, we first present a strong NP-hardness result of the problem. We also identify a polynomially solvable case with either anticipatory or non-anticipatory setups. We then establish a property that an optimal solution for the special case is a lower bound for the general problem. To obtain near-optimal solutions for the general problem, we devise some heuristics. The lower bound is used to evaluate the quality of the heuristic solutions. Results of computational experiments reveal that the heuristics produce solutions with small error ratios. They also suggest that the lower bound is close to the optimal solution.

Keywords: production scheduling, flowshop, batch processing, makespan, strong NP-hardness, lower

bound, heuristics

1. Introduction

Flowshop scheduling, initiated by Johnson (1954), is one of the most extensively studied topics in scheduling research. In a recent paper, Cheng and Wang (1998) consider batch scheduling problems in a two-machine flowshop which comprises a discrete processor and a batch processor. There is a set of jobs simultaneously available for processing in the flowshop. All jobs are first processed by the discrete processor, which processes one job at a time. The batch processor processes the jobs, transferred from the discrete processor, in batches. The forming of each batch on the batch processor incurs a constant setup time. The processing time of a batch on the batch processor is the sum of the constant setup time and the processing times of all jobs belonging to it. All jobs in a batch have a common completion time which is equal to the completion time of the last job of the batch. The objective is to batch, as well as schedule, the jobs so as to minimize the makespan.

This scheduling problem arises from the manufacturing of custom-built very large-scale integrated circuits by flexible manufacturing cells organized into a two-stage flow-line. In the first stage, chips of various types are picked and placed on a circuit board according to its individual technical specifications by a pick and insertion machine –

(2)

the discrete processor. Each circuit board is unique and represents a discrete job. Upon completion of this operation, the circuit board is loaded onto a pallet to be transferred to the second stage for further processing. Circuit boards loaded on the same pallet corre-spond to a batch. Pallets are installed and removed by a robot before and after processing on the second machine. The fixed time incurred in removing a previous pallet and in-stalling a new one is the constant setup time. In the second stage, each pallet will have its circuit boards soldered and tested one at a time by an integrated soldering and testing equipment – the batch processor. This is a highly sophisticated and expensive piece of equipment and so operations on it are performed in batches to minimize idle time caused by frequent setups. Thus, the batch processing time is equal to the sum of the setup time and the individual soldering and testing time for each circuit board loaded on the same pallet. The objective of the scheduling problem is to determine the optimal sequence and batching compositions so as to minimize the makespan.

In the literature, most of the previous research on batch scheduling problems is related to the single machine case to minimize the total flow time. An O(n) algorithm is first given by Naddef and Santos (1988) for the case where all jobs have the same processing time. Coffman, Nozari and Yannakakis (1989) later devise an improved O(√n)algorithm. Albers and Brucker (1993) identify many NP-hard problems in which precedence constraints between jobs are imposed. They also show that many problems can be transformed into the shortest path problem, which is solvable by an algorithm with a time complexity linear in the number of vertices visited. In (Cheng, Kovalyov and Lin, 1997), the problem of minimizing the sum of total weighted job earliness and mean batch delivery penalties is investigated. On m parallel machines, Cheng et al. (1996) present an O(nm+2₎_{dynamic programming algorithm to determine the minimum}

total completion time.

Considering the two-machine flowshop environment, Ahmadi et al. (1992) study a class of batching and scheduling problems. In their model, a batch can accommodate all of its jobs simultaneously and the batch processing time is constant and independent of the batch size. A study similar to the problem of interest in this paper is conducted by Cheng, Lin and Toker (2000). In the two-machine flowshop environment they consider, both machines process the jobs in batches. After processing on the first machine, a batch is transferred to the second machine with the batch composition preserved. They prove that the general problem is strongly NP-hard and propose polynomial algorithms for some special cases. Glass, Potts and Strusevich (2001) consider a similar problem where setups on the second machine are anticipatory. The reader is referred to (Cheng, Gupta and Wang, 2000; Allahverdi, Gupta and Aldowaisan, 1999; Potts and Kovalyov, 2000) for comprehensive surveys on batch scheduling in flowshop environments.

The rest of this paper is organized as follows. In section 2, we introduce the no-tation that will be used throughout this paper. In section 3, we present the strong NP-hardness result by a reduction from 3-PARTITION. We identify special cases that are polynomially solvable in section 4. Besides, we also establish an interesting property concerning a lower bound for the general problem. In section 5, four heuristic methods are given to generate sub-optimal solutions. A series of computational experiments is

(3)

conducted, and the results demonstrate the practical effectiveness of the proposed heuris-tics. Finally, some conclusions are given in section 6.

2. Problem formulation

In this section, we present the notation that will be used throughout this paper.

Notation.

• N = {1, 2, . . . , n}: the job set to be processed;

• pi: the processing time of job i on the discrete processor, 1 i n;

• qi: the processing time of job i on the batch processor, 1 i n;

• s: batch setup time; • Bl: batch l;

• Pl: total processing time of batch Blon the discrete processor;

• Ql: total processing time of batch Bl on the batch processor;

• Z(S): makespan of schedule S; • S∗_{: optimal schedule;}

• Z∗_{: optimal makespan.}

We adopt the three-field notation F (δ → β)//Cmax used by Cheng and Wang (1998) to denote the general problem. In this notation, δ and β stand for the dis-crete processor and the batch processor, respectively. In this paper, both cases with non-anticipatory and anticipatory setups, denoted by F (δ → β)/ns/Cmaxand F (δ →

β)/as/Cmax, respectively, are considered. Non-anticipatory setups mean that all jobs

forming a batch must be present at the batch processor for batch initialization, and an-ticipatory setups mean that the setup for the batch processor can be performed prior to arrivals of jobs which form a batch from the discrete processor. Due to the batch con-siderations, to compose a schedule, we needs to determine how the jobs are grouped into batches and how the batches are sequenced. In this paper, we consider permutation sequences only, i.e. the processing sequences on both machines are the same.

3. Strong NP-hardness

In this section, we show that both F (δ → β)/ns/Cmax and F (δ → β)/as/Cmax are strongly NP-hard by a reduction from 3-PARTITION, which is known to be NP-hard in the strong sense (see (Garey and Johnson, 1979)).

(4)

3-PARTITION: Given an integer M and a set A of 3n positive integers{x1, x2, . . . , x3n}, M/4 < xi < M/2, 1 i 3n, such that

3n

i=1xi = nM, does there exist a partition

A1, A2, . . . , Anof the set A such that|Al| = 3 and

xi∈Alxi = M, 1 l n?

Before proceeding to the main result, we first assume without loss of generality that M > n+ 1 in 3-PARTITION. If it is not the case, we may scale the instance by multiplying the value of each xi with integer n.

Theorem 1. The F (δ → β)/ns/Cmaxproblem is strongly NP-hard even if pi qi for

all job i.

Proof. It is clear that the decision version of F (δ → β)/ns/Cmax is in NP. We

next perform a polynomial-time reduction from 3-PARTITION. Given an instance of 3-PARTITION, we construct an instance of F (δ → β)/ns/Cmax consisting of 4n + 1 jobs as follows:

Initial job: p0= 0, q0= ω1+ ω2+ 2M2;

Ordinary jobs: pi = xiM, qi = 2xiM, 1 i 3n;

Enforcer jobs: p3n+i = ω1+ iω2+ M2+ 1, q3n+i = ω1+ (i + 1)ω2, 1 i n, where ω2>4nM2and ω1>2nω2;

Setup time s= 1.

Note that, in the above instance, pi qi for any job i, 1 i 4n + 1. The

sum of the processing times of all jobs on the discrete processor is 2nM2_{+ n + nω} 1+ n(n+ 1)ω2/2; the sum of the processing times of all jobs on the batch processor is (n+ 1)ω1+ (n + 1)ω2+ 2(n + 1)M2+ n(n + 1)ω2/2. We claim that there is a desired partition for the set A if and only if there exists an optimal schedule for the instance of F (δ→ β)/ns/Cmaxwith a makespan Cmax (n + 1)ω1+ (n + 1)ω2+ 2(n + 1)M2+ n(n+ 1)ω2/2+ (n + 1).

(⇒) Let the subsets A1, A2, . . . , An be a partition as specified for set A in

3-PARTITION. Let the initial job be the first job, and let it solely form batch B0on the batch processor. Let job 3n+ l and the jobs corresponding to the elements of Al form

batch Bl, 1 l n. Figure 1 illustrates the configuration of the schedule. In the derived

schedule, the makespan is (n+1)ω1+(n+1)ω2+2(n+1)M2+n(n+1)ω2/2+(n+1),

(5)

where the last item (n+ 1) corresponds to the sum of the setup times incurred by the n+ 1 batches.

(⇐) Suppose that there is an optimal schedule S for F (δ → β)/ns/Cmaxwhose completion time is no more than (n+ 1)ω1+ (n + 1)ω2+ 2(n + 1)M2+ n(n + 1)ω2/2+ (n+ 1). For schedule S, the sum of the idle times and setup times on the batch processor cannot be greater than n+ 1.

First of all, we know that the number of batches on the batch processor must be less than or equal to n+ 1. Furthermore, because any job, except the initial job, has a processing time longer than n+ 1 on the discrete processor, the first batch must contain only the initial job.

Recall that Pland Ql, 0 l n, denote the processing times, including the setup

time, of batch Bl on the discrete processor and the batch processor, respectively.

Fact 1. In schedule S, each batch contains at most one enforcer job.

Proof. Assume batch Bl is the first batch containing two or more enforcer jobs. The

processing time of Bl will be no less than 2ω1. Let η be the total idle time before the completion of all predecessor batches B0, B1, B2, . . . , Bl−1 on the batch processor.

That is, these predecessor batches finish their processing on the batch processor at time η+l_i−1₌₀Qi. Therefore, the total idle time before the completion of batch Blon the batch

processor is no less than η+max{0, 2ω1+ l−1 i=0Pi−(η+ l−1 i=0Qi)}. If 2ω1+ l−1 i=0Pi−

(η+l_i−1₌₀Qi) 0, the total idle time is no less than 2ω1− l−1 i=0(Qi−Pi). On the other hand, if 2ω1+ l−1 i=0Pi− (η + l−1

i=0Qi) < 0, the total idle time is no less than η, which

then is greater than 2ω1− l−1

i=0(Qi − Pi). In other words, the total idle time before the

completion of batch Blon the batch processor is no less than 2ω1− l−1

i=0(Qi − Pi).

The valuel_i−1₌₀(Qi − Pi)is maximized by the contributions made by the initial

jobs, all ordinary jobs, the n− 2 enforcer jobs, and the setup times of up to n batches. It is evaluated to be (ω1+ ω2+ 2M2)+ nM2+ (n − 2)(ω2− M2− 1) + n. By subtracting this number from 2ω1, we have

ω1−(n− 1)ω2+ 4M2+ 2 > (n+ 1)ω2− 4M2− 2 >4n2M2+ 4nM2− 4M2− 2 >4n2M2− 2 > n+ 1 (because M > n + 1).

In other words, the induced idle time is greater than n+ 1, a contradiction.

There-fore, any batch cannot contain more than one enforcer job.

With the above observations, we have that schedule S must contain exactly n+ 1 batches, say B0, B1, B2, . . . , Bn, such that the initial job is the only element in B0and the enforcer job 3n+ l, 1 l n, belongs to batch Bl. Besides, no idle time is permitted

(6)

Fact 2. In schedule S, Pl = ω1+ lω2+ 2M2+ 1, 1 l n.

Proof. Because on the discrete processor a batch containing the enforcer job 3n+i has

a shorter processing time than any other batch containing the enforcer job 3n+ j with 1 i < j n, we assume that in schedule S the enforcer job 3n + l is included in batch Bl, 1 l n. Let Pl = ω1+iω2+M2+ρl+1, 1 l n, where ρlcorresponds

to the sum of the processing times of the ordinary jobs in batch Bl. We now show that

ρ1= ρ2= · · · = ρn= M2must hold.

Assume that ρ1 ρ2 · · · ρn, for otherwise we may exchange, without

increasing the makespan, all ordinary jobs of any two consecutive batches not satisfying the inequality. Let k, k > 1, be the first batch such that ρk > M2. We now determine

the idle time incurred before batch Bkon the batch processor. On the discrete processor,

the total processing time of jobs in B0, B1, B2, . . . , Bk is

ω1+ ω2+ M2+ ρ1+ 1 +ω1+ 2ω2+ M2+ ρ2+ 1 + · · · +ω1+ kω2+ M2+ ρk+ 1 . (1)

On the batch processor, the total processing time of jobs in B0, B1, B2, . . . , Bk−1is

ω1+ ω2+ 2M2+ 1 +ω1+ 2ω2+ 2ρ1+ 1 +ω1+ 3ω2+ 2ρ2+ 1 + · · · +ω1+ kω2+ 2ρk−1+ 1 . (2)

Subtracting (1) from (2) yields ω1+ ω2+ 2M2+ 1 +ω2− M2+ ρ1 +ω2− M2+ ρ2 + · · · +ω2− M2+ ρk−1 −ω1+ kω2+ M2+ ρk+ 1 =ρ1− M2+ρ2− M2+ · · · +ρk−1− M2 − ρk+ M2 <0 (because ρk > M2).

In other words, nonzero idle time will be incurred before batch Bk on the batch

processor, a contradiction. Therefore, ρl = M must hold for l = 1, 2, . . . , n and the

proof is concluded.

Proof of 3-PARTION. With fact 2, a partition for the set A is obtained by letting the

elements corresponding to the ordinary jobs in batch Bl, 1 l n, to form the

sub-set Al. Then,

xi∈Al xi = M, and |Al| = 3 because M/4 xi M/2.

Referring to figure 1 for the proof of F (δ → β)/ns/Cmax, we see that in the optimal schedule, there is no idle time incurred on the batch processor. That is, the proof is valid regardless of whether anticipatory or non-anticipatory setups are considered.

Corollary 1. The F (δ→ β)/as/Cmaxproblem is strongly NP-hard even if pi qi for

(7)

4. Polynomially solvable cases and their implications

In this section, we consider two special cases where a total order on the job set is satisfied and show their polynomial solvability. We first focus the study on F (δ→ β)/ns/Cmax. The results are similarly valid for the special case of F (δ→ β)/as/Cmax.

Define a total order on the set of jobs as a relation between any pair of jobs i and j such that i  j if and only if pi pj and qi qj. For example, the relation is

satisfied in the case where pi = p for all i. We denote the special case that satisfies the

relation by F (δ → β)/ns, /Cmax.

Lemma 1. For F (δ→ β)/ns, /Cmax, there is an optimal schedule in which for jobs iand j , if i j, then either job i precedes job j or they are in the same batch.

Proof. Suppose that there are jobs i ∈ Bl and j ∈ Bmin some optimal schedule with

i  j and l > m. By swapping the positions of jobs i and j, the idle time before any batch on the batch processor may be decreased or unchanged. Therefore, the total idle

time will not be increased by the job interchange operation.

By virtue of lemma 1, we may renumber the jobs in F (δ→ β)/ns, /Cmaxsuch that 1 2 3 · · · n.

Lemma 2. For F (δ → β)/ns, /Cmaxwith the job set N , let S

∗

be optimal among all schedules for the subset N −{r, r +1, . . . , n}. Then, for the set N , schedule S ∗∪Bk,

where Bk is the batch comprising jobs r, r + 1, . . . , n, is optimal among all schedules

with Bkas the last batch.

Proof. Let S be any schedule for N −Bk. Batches S and S

∗

have the same completion time on the discrete processor. Furthermore, the completion time of S ∗ on the batch processor is the same or smaller than that of S . It is evident that Z(S ∗ ∪ Bk) is no

greater than Z(S ∪ Bk). The proof readily follows.

Based on lemmas 1 and 2, we can construct a simple dynamic programming algo-rithm to solve F (δ → β)/ns, /Cmax. Let C(i) denote the makespan of an optimal solution for scheduling jobs in{1, 2, . . . , i}. An optimal schedule for F (δ → β)/ns,  /Cmaxwith the job set N can be obtained by the following algorithm.

Algorithm NS.

Line 1: C(0)= 0.

Line 2: For i=1 to n do line 3. Line 3: C(i)= minl=1,2,...,i{max{

i j=1pj, C(i− l)} + (s + i j=i−l+1qj)}. Line 4: Return C(n). Line 5: Stop.

(8)

In the recurrence relation in line 3, variable l indicates the number of jobs to be included in the last batch Bk. If an O(n2)preprocessing procedure is used to compute

the values of i_j₌₁pj and

i

j=i−l+1qj, each iteration of line 3 can be done in O(n)

time. As line 3 iterates n times, the overall time complexity of algorithm NS is O(n2₎_.

Theorem 2. The problem F (δ→ β)/ns, /Cmaxcan be solved in O(n2)time. Next, we give an insight into the relationship between F (δ → β)/ns/Cmax and F (δ → β)/ns, /Cmax. Let N be a job set for F (δ → β)/ns/Cmax. We transform N into a job set N for F (δ → β)/ns, /Cmaxby defining pi as the ith smallest pi in

N and q_i as the ith largest qi in N . Clearly, the job set N satisfies the total order in

F (δ→ β)/ns, /Cmax.

Lemma 3. For any schedule S for F (δ → β)/ns/Cmax with the job set N , there is a schedule S for F (δ→ β)/ns, /Cmaxwith the job set N such that Z(S ) Z(S).

Proof. Given any schedule S for F (δ→ β)/ns/Cmaxwith the job set N , we make the

following transformation: For any jobs i and j in schedule S, if job j precedes job i and pi pj, then we swap the operations of i and j on the discrete processor but leave

the operations on the batch processor unchanged. That is, the processing times of job i on both machines are pj and qi, and the processing times of job j are pi and qj. It is

not hard to see that the makespan will not increase. Continuing the interchange process, we will have a new schedule in which all jobs on the discrete processor are arranged in nondecreasing order of their processing times. With the derived schedule, we further adjust the operations on the batch processor such that the operations are arranged in non-increasing order of their processing times. Similarly, the makespan will not increase. Note that the jobs in the final schedule make up the job set N . Therefore, the proof is

complete.

This lemma suggests that, given an instance of F (δ → β)/ns/Cmax with N , we can find an optimal schedule S ∗for an instance of the problem F (δ → β)/ns, /Cmax with N , and Z(S ∗)is a lower bound for the optimal solution for the original problem. Therefore, we conclude with the following theorem.

Theorem 3. For any schedule S for F (δ → β)/ns/Cmax with the job set N and an optimal schedule S ∗for the corresponding F (δ→ β)/ns, /Cmaxwith the job set N , Z(S ∗) Z(S).

When considering the other case F (δ → β)/as, /Cmax, it is not hard to see that the above results are still valid if we replace the recurrence formula in line 3 of

(9)

algorithm NS by C(i)= min l=1,2,...,i max _i j=1 pj, C(i− l) + s + i j=i−l+1 qj .

The corresponding solution method is denoted by algorithm AS. We have the results for the problem F (δ→ β)/as, /Cmaxin the following corollaries.

Corollary 2. The problem F (δ→ β)/as, /Cmaxcan be solved in O(n2)time.

Corollary 3. For any schedule S for F (δ → β)/as/Cmax with the job set N and an optimal schedule S ∗for the corresponding F (δ → β)/as, /Cmaxwith the job set N , Z(S ∗) Z(S).

5. Heuristics

In this section, we present heuristics to find approximation solutions for F (δ→ β)

/ns/Cmax and F (δ → β)/as/Cmax. We focus our study first on F (δ → β)/ns/Cmax.

Given an instance of F (δ → β)/ns/Cmaxwith N , we first transform it into an instance of F (δ → β)/ns, /Cmaxwith N . Algorithm NS is used to find an optimal solution for F (δ → β)/ns, /Cmax, which is a lower bound for F (δ → β)/ns/Cmaxand can be used to evaluate the quality of the heuristic solutions.

From the results presented in the previous section, we know that given a job se-quence, we can find an optimal batching policy using algorithm NS. Therefore, our heuristic methods simply foucs on determining job sequences. We use Z_nsH i to de-note the makespan reported by sequencing rule N SH i, i = 1, 2, 3. ZnsH4 is defined as

min{ZH1

ns , ZnsH2, ZnsH3}.

Rule N SH1: Order the jobs by nondecreasing order of pi.

Rule N SH2: Order the jobs by non-increasing order of qi.

Rule N SH3: Order the jobs by Johnson’s rule.

With a slight modification, we have another set of methods, ASH1, ASH2, ASH3 and ASH4, for the situations where anticipatory setups are allowed.

To evaluate the effectiveness of the heuristics, we conduct a series of computational experiments. Let Z_ns∗ and Z_as∗ denote the makespans of the schedules obtained from using algorithm NS and algorithm AS to solve F (δ → β)/ns, /Cmax and F (δ → β)/as, /Cmaxwith the job set N , respectively. The error ratio of a heuristic is defined as

Zxy− Zx∗

Z∗_x × 100%,

where x ∈ {ns, as} and y ∈ {H 1, H 2, H 3, H 4}. Note that an optimal solution is encountered when the error ratio is zero.

(10)

Table 1

Numerical results for non-anticipatory setup with factor= 1.

Average error (%) Largest error (%) Number of optimal solutions

n H1 H2 H3 H4 H1 H2 H3 H4 H1 H2 H3 H4 50 3.07 3.48 1.25 1.25 8.23 8.34 3.30 3.30 0 7 10 10 100 2.15 2.84 0.87 0.87 5.26 6.96 2.12 2.12 0 5 10 10 150 1.46 1.76 0.52 0.52 4.01 4.33 1.59 1.59 0 19 23 23 200 1.21 1.67 0.46 0.46 3.00 3.82 1.29 1.29 0 8 12 12 250 0.89 1.32 0.35 0.35 2.40 3.14 1.13 1.13 0 18 21 21 300 0.84 1.08 0.29 0.29 2.26 2.82 0.97 0.97 0 19 24 24 500 0.59 0.75 0.18 0.18 1.51 2.21 0.66 0.66 0 11 15 15 Table 2

n H1 H2 H3 H4 H1 H2 H3 H4 H1 H2 H3 H4 50 4.72 6.17 2.74 2.74 10.76 10.35 6.40 6.40 0 2 2 2 100 3.44 4.42 1.85 1.85 8.36 7.40 4.86 4.86 0 3 5 5 150 2.85 3.58 1.36 1.36 6.16 6.37 3.19 3.19 0 3 4 4 200 2.65 3.41 1.31 1.31 5.59 6.22 2.75 2.75 0 3 4 4 250 2.33 3.07 1.10 1.10 4.70 5.13 2.16 2.16 0 2 3 3 300 2.02 2.68 0.96 0.96 5.00 5.54 2.57 2.57 0 5 7 7 500 1.26 1.68 0.51 0.51 3.30 3.60 1.43 1.43 1 8 8 8

In the experiment setting, the processing times pi and qi are set to be uniformly

distributed over the interval[0, 100]. The problem size n takes values from {50, 100, 150, 200, 250, 300, 500}. To contrast the impacts the setup time might have, we randomly se-lect s from[0, 100 · factor], where factor is 1, 2 or 3. For each combination of s and n, each proposed method runs through 100 input instances. We keep track of the average error ratio, the largest error ratio, and the number of optimal solutions found amongst the 100 instances. The results for non-anticipatory setups are shown in tables 1–3. Ta-bles 4–6 contain the results for the situations where anticipatory setups are allowed.

(11)

Table 4

Numerical results for anticipatory setup with factor= 1.

n H1 H2 H3 H4 H1 H2 H3 H4 H1 H2 H3 H4 50 3.17 3.97 1.73 1.73 7.65 7.81 7.10 7.10 6 2 21 21 100 3.56 4.11 2.10 2.10 5.89 6.83 5.29 5.29 0 2 5 5 150 2.73 3.29 1.40 1.40 6.60 6.26 3.59 3.59 0 4 7 7 200 2.42 2.72 0.06 1.06 5.72 4.97 2.74 2.74 0 6 6 6 250 2.23 2.60 0.98 0.98 4.31 4.93 2.06 2.06 0 3 4 4 300 1.89 2.35 0.91 0.91 4.12 4.13 2.04 2.04 0 1 2 2 500 1.39 1.67 0.58 0.58 3.06 3.33 1.52 1.52 0 1 3 3

From the numerical results, we clearly see that Johnson’s rule (H 3) almost totally dominates the other two methods. From the point of view of error ratios, all algorithms have better performance when the setup time is relatively small, i.e., factor = 1. Fur-thermore, the error ratios decrease when the problem sizes grow. By and large, the solutions generated by the heuristic algorithms are close to optimal solutions. This ob-servation also suggests that the solutions for the total order problem with the job set N provide nontrivial lower bounds for the original problem with the job set N . In other

(12)

words, we may easily spend O(n2₎_{time to obtain near-optimal solutions for the} prob-lems F (δ→ β)/as/Cmaxand F (δ → β)/ns/Cmax.

6. Conclusions

In this paper, we have shown that, by a polynomial-time reduction from 3-PARTITION, F (δ → β)/as/Cmax and F (δ → β)/ns/Cmaxare strongly NP-hard. In other words, it is very unlikely that polynomial or pseudo-polynomial algorithms for these problems can be found. We have also identified two polynomially solvable problems, F (δ → β)/ns, /Cmaxand F (δ→ β)/as, /Cmax, by giving an O(n2)solution algorithm for each problem. The solution for F (δ → β)/ns, /Cmax(or F (δ → β)/as, /Cmax) with N is a lower bound for the original problem with N .

To derive approximation solutions, we have designed some heuristics for deter-mining initial job sequences and conducted computational experiments to test their ef-fectiveness. Using the lower bounds obtained from solving F (δ → β)/ns, /Cmax and F (δ→ β)/as, /Cmax, we evaluate the error ratios of the heuristic solutions. The results show that the error ratios are small. They not only establish the effectiveness of the proposed heuristics, but also reveal that the lower bounds are close to the optimal solutions.

An important implication of our study is that the transformation of a hard prob-lem to an easy one may provide a viable approach to dealing with different variants of flowshop-type problems. Following this line of transformation, Lin and Wu (2002) has designed a lower bound for the development of branch-and-bound algorithms for the classical flowshop scheduling to minimize the total completion time. Their algorithms can solve several instances with up to 65 jobs, while the best algorithm known in the literature can solve instances with 35 jobs.

Acknowledgments

The first author was partially supported by the National Science Council of the R.O.C. under contract number 90-2416-H-260-013-C. The second author was partially sup-ported by The Hong Kong Polytechnic University under a grant from the ASD in China Business Services.

References

Ahmadi, J.H., R.H. Ahmadi, S. Dasu, and C.S. Tang. (1992). “Batching and Scheduling on Batch and Discrete Processors.” Operations Research 40, 750–763.

Albers, A. and P. Brucker. (1993). “The Complexity of One-Machine Batching Problem.” Discrete Applied Mathatmematics 47, 87–107.

Allahverdi, A., J.N.D. Gupta, and T. Aldowaisan. (1999). “A Review of Scheduling Research Involving Setup Considerations.” Omega 27, 219–239.

(13)

Cheng, T.C.E., Z.-L. Chen, M.Y. Kovalyov, and B.M.T. Lin. (1996). “Parallel-Machine Batching and Scheduling to Minimize Total Completion Time.” IIE Transactions 28, 953–956.

Cheng, T.C.E., J.N.D. Gupta, and G. Wang. (2000). “A Review of Flowshop Scheduling Research with Setup Times.” Production and Operations Management 9, 262–282.

Cheng, T.C.E., M.Y. Kovalyov, and B.M.T. Lin. (1997). “Single Machine Scheduling to Minimize Batch Delivery and Job Earliness Penalties.” SIAM Journal on Optimization 7, 547–559.

Cheng, T.C.E., B.M.T. Lin, and A. Toker. (2000). “Makespan Minimization in the Two-Machine Flowshop Batch Scheduling Problem.” Naval Research Logistics 47, 128–144.

Cheng, T.C.E. and G. Wang. (1998). “Batching and Scheduling to Minimize the Makespan in the Two-Machine Flowshop.” IIE Transactions 30, 447–453.

Coffmann, E.G., A. Nozari, and M. Yannakakis. (1989). “Optimal Scheduling of Products with Two Sub-assemblies on a Single Machine.” Operations Research 37, 426–436.

Garey, M.R. and D.S. Johnson. (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. San Francisco: Freeman.

Glass, C.A., C.N. Potts, and A.V. Strusevich. (2001). “Scheduling Batches with Sequential Job Processing for Two-Machine Flow and Open Shops.” INFORMS Journal on Computing 13, 120–137.

Johnson, S.M. (1954). “Optimal Two- and Three-Stage Production Schedules with Setup Times Included.” Naval Research Logistics Quarterly 1, 61–67.

Lin, B.M.T. and J.M. Wu. (2002). “A New Lower Bound Scheme for the Two-Machine Flowshop Schedul-ing to Minimize the Total Completion Time.” In Electronic ProceedSchedul-ings of the Fourth Asia-Pacific Con-ference on Industrial Engineering and Management Systems, Taipei, Taiwan, December 2002. Naddef, D. and C. Santos. (1988). “One-Pass Batching Algorithms for the One-Machine Problem.” Discrete

Applied Matthematics 21, 133–146.

Potts, C.N. and M.K. Kovalyov. (2000). “Scheduling with Batching: A Review.” European Journal of Operational Research 102, 228–249.