Concurrent Open Shops
B. M. T. Lin,1T. C. E. Cheng21Department of Information and Finance Management, Institute of Information Management, National Chiao Tung University, Hsinchu, Taiwan
2Department of Logistics and Maritime Studies, The Hong Kong Polytechnic University, Kowloon, Hong Kong
Received 1 January 2010; revised 30 September 2010; accepted 4 October 2010 DOI 10.1002/nav.20437
Published online 2 December 2010 in Wiley Online Library (wileyonlinelibrary.com).
Abstract: This article considers batch scheduling with centralized and decentralized decisions. The context of our study is concur-rent open shop scheduling where the jobs are to be processed on a set of independent dedicated machines, which process designated operations of the jobs in batches. The batching policy across the machines can be centralized or decentralized. We study such scheduling problems with the objectives of minimizing the maximum lateness, weighted number of tardy jobs, and total weighted completion time, when the job sequence is determined in advance. We present polynomial time dynamic programming algorithms for some cases of these problems and pseudo-polynomial time algorithms for some problems that are NP-hard in the ordinary sense.
© 2010 Wiley Periodicals, Inc. Naval Research Logistics 58: 17–27, 2011
Keywords: batch scheduling; centralized and decentralized decisions; concurrent open shop; dynamic programming
1. INTRODUCTION
This article considers concurrent open shop scheduling with batching policies. The concurrent open shop model is defined as follows: A set ofn jobsJ = {J1,J2,. . . , Jn} is to be processed. Each job Ji ∈ J has m tasks or opera-tionsOki, 1 ≤ k ≤ m, to be processed on m independent dedicated machinesM1,M2,. . . , Mm, subject to the condi-tion that operacondi-tionOki, 1≤ k ≤ m, can only be processed on machineMk and requires a processing timepki. Them operations of a job are independent and their processing can overlap, i.e., they can be simultaneously processed on their dedicated machines. Each machine can process at most one operation at a time and no preemption is allowed. This production model is similar to open shops except that the operations of the same job can be simultaneously processed. Leung et al. [15] provided several practical applications of concurrent open shop scheduling. In this study, we assume that the job operations are processed in batches on each machine. A practical example of the scheduling model is as follows: A manufacturer produces different types of foam products, like pillows and bed mattresses, on dedicated
Correspondence to: B.M.T. Lin ([email protected])
production lines. Due to differences in material properties, each dedicated machine requires a setup time to prepare the molds and mixture of raw materials, and to adjust the machine setting (e.g., temperature) whenever a batch of products of the same type is to be processed. A client who places an order that consists of several different products would like to receive the products in a single shipment. The manufacturer wants to optimize certain performance metrics by batching and sequencing the production of all the products on the dedicated machines.
The batching decision considered in this study is described as follows: Whenever a batch is formed on machineMk, 1≤
k≤ m, a machine-dependent setup time skwill be incurred. Batch processing is assumed to be sequential, i.e., the pro-cessing length of a batch is equal to the setup time plus the processing times of all the operations contained in the batch. Completion of an operation follows the batch availability mode, which means that the completion time of an opera-tion coincides with the time when the batch it belongs to is finished. If all the machines have the same batching decision, then the model is called centralized, which signifies the fact that a centralized decision is applied to all the machines. On the other hand, if each machine has its own batching decision, then the model is called decentralized.
Setups1= s2= 5. J1 J2 J3 J4
p1i 9 9 8 8
p2i 4 5 15 11
Decentralized Batching Centralized Batching
MachineM1:{O11}, {O12}, {O13,O14} Machine M1:{O11,O12}, {O13,O14}
MachineM2:{O21,O22}, {O23}, {O24} Machine M2:{O21,O22}, {O23,O24} C11= 14, C12= 28, C13 = C14= 49 C11= C12 = 23, C13 = C14= 44 C21= C22= 14, C23 = 34, C24= 50 C21= C22 = 14, C23 = C24= 45 C1= 14, C2= 28, C3= 49, C4 = 50 C1= C2= 23, C3= C4= 45
Figure 1. Centralized vs. decentralized batching.
Denote the completion time of operationOki on machine
MkbyCki. Because a job is completed only if all of its opera-tions are finished, the completion time of jobJiis defined as
Ci = max1≤k≤m{Cki}. Associated with each job Ji ∈ J are a weightwiand a due datedi, which specifies the time by which the job is expected to be completed. In a particular schedule, the lateness of job Ji is defined asLi = Ci − di and the maximum lateness of the schedule isLmax = maxJi∈J{Li}.
Subject to the due date constraints, we use the binary vari-ableUito denote the status of jobJias being tardy or not by lettingUi = 1 if Ci > di, andUi = 0 otherwise.
Scheduling of jobs in the proposed production model con-sists of sequencing, as well as grouping the jobs, so as to optimize a certain objective function. We use the three-field notation ID|batch∗|γ to denote the concurrent open shop
scheduling problem with batching considerations. The first fieldID stands for independent dedicated machines. For our
problem,batch∗is present in the second field as a short form of “s-batch(b/a, sk)”, i.e., sequential batch processing of the jobs in the batch availability mode with different machine set-up times given bysk(k= 1, . . . , m). The last field γ is the objective function to be minimized. In this article, we study three objective functions, namelyγ = Lmax,γ =
wiUi, and γ = wiCi (i.e., the total weighted job comple-tion time). The objective minwiCiwill be studied based upon the assumption that the operation sequences on all the machines are known a priori. Figure 1 shows an instance of four jobs to be processed on two dedicated machines. With decentralized batching, the operations on different machines are grouped in different ways. While operationsO11andO12
are in different batches and have different completion times 14 and 28, operations O21 andO22 are in the same batch
and have the same completion time 14. Therefore, the com-pletion times of jobsJ1 andJ2are 14 and 28, respectively.
When centralized batching is adopted, all the machines have the same grouping of jobs and the jobs of a batch have the same completion time.
Note that decentralized batching does not necessarily mean that we make an individually optimal decision on each
machine. A combination of individual optimal decisions may turn out to be an unfavorable decision. For example, to min-imize the number of tardy jobs, we can easily construct an example in which all the machines have early operations, but no job is early. Suppose there are two jobs J1 andJ2
withp11 = 4, p12 = 7, p21= 7, p22 = 4, and d1 = d2 = 7.
Applying Moore-Hodgson algorithm [21], we determine that operation O11 is scheduled early on machineM1 and oper-ationO22is scheduled early on machineM2. Based on this result, no job is early because one operation of each job is completed later than the given due date. Here an operation is early if it is completed on its dedicated machine no later than the due date of the job it belongs to and a job is early if all of its operations are completed no later than its due date. Therefore, if we treat each machine as an individual deci-sion maker, then the decideci-sion makers need to coordinate their decisions so as to avoid causing trouble to one another. More-over, similar to the relationship between an integer program and its corresponding linear program, the solution space of centralized batching is a subset of that of decentralized batch-ing. For any specific objective function studied in this article, the optimal solution value for centralized batching cannot be better than that for decentralized batching.
The first study of scheduling in the concurrent open shop appears to be due to Ahmadi and Bagchi [2]. The assembly-type flowshops proposed by Lee et al. [13] and Potts et al. [25] are a generalization by including a second-stage assembly machine. Wagneur and Sriskandarajah [29] studied the same model using the term “concurrent open shops with job over-laps.” Wang and Cheng [30] and Cheng et al. [5] provided another interpretation: jobs and operations are replaced by orders and products, respectively. An order specifies a set of product items that can be produced simultaneously and the order is fulfilled when all the product items are produced. We refer the reader to [26] for an up-to-date and compre-hensive summary of results on scheduling in the concurrent open shop. To the best of our knowledge, scheduling in the concurrent open shop consisting of batching machines has not been studied in the literature. The critical issue
concerning centralized or decentralized batching decisions across concurrent machines is new and reflects realistic man-ufacturing environments. If we extend the notion of machines to companies, then the model can deal with coordination of suppliers in supply chain management. Under the cir-cumstances where a company that is relatively dominant in the supply chain places orders (jobs) with manufacturers (machines) for different products, the company can dictate the production rates of the manufacturers. Or the company, intending to optimize its own operations performance, can pay the manufacturers to offset their losses resulting from coordination Li and Xiao [17]. The batching issue consid-ered in Kovalyov et al. [11] is probably the most relevant to our model. They investigated an assembly-type flowshop in which the stage-one machines are assumed to produce components in batches. The objective is to minimize the max-imum completion time, i.e., the makespan. They considered two different types of batching, namely sequential and paral-lel batching. For the paralparal-lel-batching mode, the processing length of a batch is defined as the maximum of the process-ing times of the jobs in it. Cheng et al. [4] and Potts and Kovalyov [24] are two excellent reviews on scheduling with batching and related results.
The rest of this article is organized as follows: We study the problem to minimize the maximum lateness in Section 2. We discuss previous works, along with the development of dynamic programming algorithms for the studied problems. In Section 3, we study the problem to minimize the weighted number of tardy jobs. In Section 4, we discuss the problem to minimize the total weighted completion time. In Section 5, we conclude the paper and suggest potential research topics for further study.
2. PRELIMINARIES AND ID|batch∗|Lmax In this section we study the concurrent open shop batch scheduling problem to minimize the maximum lateness, i.e., ID|batch∗|Lmax. We start by presenting some known
related results on concurrent open shop scheduling and batch scheduling.
2.1. Preliminary Properties
We assume that the cost functionfj(Cj) is defined for job
Jj, wherefj is nondecreasing inCj. The following results are fundamental to concurrent open shop scheduling.
LEMMA 1: [29] For concurrent open shop scheduling with the max-objective max1≤j≤nfj(Cj), as well as the sum-objectivenj=1fj(Cj), there is an optimal schedule in which all the machines have the same processing sequence.
In view of Lemma 1, we only need to consider permuta-tion schedules, in which all the machines process operapermuta-tions
in the same sequence of job indices, for concurrent open shop scheduling with separable functions of the “sum” and “max” types. It is not hard to see that Lemma 1 holds for any regular objective function (to minimize). When batch-ing is incorporated, the order of operations in the same batch is immaterial. Nevertheless, a sequence of operations is still required for each dedicated machine. The next lemma reveals the implication of the property of identical sequence for
ID|batch∗|γ .
LEMMA 2: It suffices to consider only permutation sched-ules for ID|batch∗|γ , where γ is an arbitrary regular
objective function to minimize.
PROOF: Assume that there is an optimal schedule for the
ID|batch∗|γ problem that is nonpermutational. There exist
two jobs Ji and Jj that do not abide by the requirement of a permutation schedule. Assume that Ci ≤ Cj and that
Cj = Ckj, i.e., the last operation of jobJj is completed on machineMk. We then have two operationsOliandOlj such that operationOlj precedesOli on machineMl. Operation
Oljis moved to the batch containing operationOliand make operationOljthe immediate successor of operationOli. The processing sequences of jobs Ji andJj are now the same on machines Mk andMl, and the completion time of any operation will not be increased by the move. Repeating the above process, if necessary, we eventually come up with a per-mutation schedule without increasing the optimal objective
value.
With Lemma 2, we can determine a single sequence of job indices that is applied across all the machines for the three objectivesLmax,
wiUi, and
wiCistudied in this article. 2.2. Lmaxwith Decentralized Batching
In what follows, we introduce some known results on minimizing the maximum lateness in the concurrent open shop.
LEMMA 3: [15] The earliest due date (EDD) rule solves theID||Lmaxproblem.
LEMMA 4: [31] There is an optimal schedule for the 1|batch∗|L
maxproblem in which the jobs are sequenced in
the EDD order.
Based upon Lemma 4, Webster and Baker [31] devel-oped a backward dynamic programming algorithm for the 1|batch∗|Lmaxproblem. Assume that the jobs are indexed in
non-decreasing order of their due dates. LetG(i) denote the
optimal maximum lateness of the single-machine problem for jobsJi,Ji+1,. . . , Jn. The dynamic program defines a recur-sive formulation to deriveG(i) from G(j ), 1≤ i < j ≤ n,
by inserting a batch of jobs {Ji,. . . , Jj−1} in front of the schedule associated with G(j ). The algorithm is given as
follows:
ALGORITHM WB Initialization:
SetG(n+ 1) = −∞.
Recursion: Compute the recursion in the order of i: i = n, n− 1, . . . , 1. G(i)= min i+1≤j≤n+1 s1+ j−1 r=i p1r+ max{−di,G(j )} . (1)
The optimal maximum lateness isG(1). Algorithm WB
has a time complexity ofO(n2). To study the ID|batch∗|L max
problem, we generalize Lemma 4 to the concurrent open shop model.
LEMMA 5: There is an optimal schedule for the
ID|batch∗|Lmaxproblem, regardless of whether centralized
or decentralized batching is in effect, in which the jobs are sequenced in the EDD order.
PROOF: Assume that in some optimal schedule there are two consecutive jobs violating the EDD rule. When cen-tralized batching is in effect, the proof is similar to that of Lemma 4 because the operations of a job follow the same way as batching. For decentralized batching, letJiandJjbe the first pair of such jobs. Consider operationsOkiandOkjon machineMk. If they are in the same batch, we can swap their positions without increasing the maximum lateness. Without loss of generality, letdi < dj and the batch containingOkj precede that containingOki. SinceJiandJjare the first pair of such jobs, the two batches must be consecutive andOkj is the last operation of its batch andOki is the first operation of its batch. We move operationOkjto the batch containing operationOki. The lateness of all the jobs, exceptJj, will not increase. The completion timeCj could increase due to the movement of operationOkj. Sincedi < dj, the lateness of jobJj after the movement is less than the lateness of jobJi. Therefore, the maximum lateness will not increase after the movement. Continuing the process of operation movements until the EDD order emerges, we obtain the result. With Lemma 5, we can re-index the jobs in the EDD order. While the job ordering issue is resolved, the grouping issue remains to be addressed. We need to determine how the jobs are partitioned into batches on the machines. In the follow-ing, we first develop a solution algorithm for decentralized batching.
Algorithm DB-Lmaxfor decentralized batching:
Step 1: Apply Algorithm WB to the n operations on each
machineMk, 1≤ k ≤ m, individually.
Step 2: Return max1≤k≤m{Lk,max}, where Lk,maxis the opti-mal lateness obtained for machineMkin Step 1. THEOREM 1: Algorithm DB-Lmax optimally solves in O(mn2) time the ID|batch∗|L
maxproblem subject to
decen-tralized batching.
PROOF: Let L∗ki denote the lateness of operationOki in an optimal schedule. Denote the optimal objective value as
L∗max= max1≤k≤m,1≤i≤n{L∗ki}. Let Lkibe the lateness of oper-ationOkireturned by Algorithm DB-Lmax. By the optimality
of Algorithm WB, we have max
1≤i≤n{Lki} ≤ max1≤i≤n{L ∗
ki}
on each machineMk. The solution value given by Algorithm DB-Lmaxis
Lmax= max
1≤i≤n{ max1≤k≤m{Lki}}.
We re-write the above expression to obtain the following inequality
Lmax= max
1≤k≤m{ max1≤i≤n{Lki}} ≤ max1≤k≤m{ max1≤i≤n
L∗ki} = L∗max. With regard to the computational time, since Algorithm WB is invoked just m times, the total running time of the
algorithm isO(mn2).
2.3. Lmaxwith Centralized Batching
When centralized batching is in effect, we need to make decisions jointly across all the machines. The first idea to approach this problem is to modify Algorithm WB. Untunately, this approach will not work. In the backward for-mulation of Algorithm WB, no detailed information on each machine is revealed to determine the completion times of the jobs. Therefore, the lateness cannot be determined in the backward recursive process. To acquire and keep track of the necessary information, we circumvent this difficulty by designing a dynamic program using forward chaining. We need to know the exact completion time of the last batch, so we incorporate two extra parameters into our algorithm, namely the number of batches formed and the size of the last batch. The proposed algorithm therefore has a higher com-plexity than that of Algorithm WB. However, our algorithm solves the case subject to centralized batching.
Recall that the jobs are indexed and sequenced in the EDD order. Define function G(i, u, v), 0 ≤ u ≤ i, 0 ≤ v ≤
i− u + 1, as the optimal maximum lateness of the first i jobs J1,J2,. . . , Ji, given that they are partitioned into exactlyu batches and the last batch contains exactlyv jobs. When a
decision on jobJi is to be made, we either insertJi in the last batch or form a new batch containing onlyJi. In the for-mer case, we need to calculate the lateness of the first job in the last batch. This goal is attainable because we know the completion times of the last batches on all the machines and the due date of the first job in the last batch. The dynamic programming algorithm is given as follows:
Algorithm CB-Lmaxfor centralized batching:
Initialization:
G(i, u, v)=
0, ifi= u = v = 0;
∞, otherwise.
Recursion: Compute the recursion for i = 1, . . . , n; u =
1,. . . , i; v= 1, . . . , i − u + 1: G(i, u, v) = min 1≤v≤i−u+1 maxG(i− 1, u − 1, v), Ciu− di , ifv= 1; maxG(i− 1, u, v − 1), Cu i − di−v+1 , ifv > 1,
whereCiu= max1≤k≤m{usk+ i
r=1pkr}.
The optimal maximum lateness subject to centralized batching is
min{G(n, u, v) : 1 ≤ u ≤ n, 1 ≤ v ≤ n − u + 1}. We justify the algorithm as follows: When the last batch consists of a single job Ji, the recursion will proceed to
G(i − 1, u − 1, v) for all the feasible v and the lateness of jobJican be determined by its due datediand completion timeCiu. On the other hand,v > 1 implies that including job Jiin the last batch will increase the lateness of any job con-tained in the last batch. Specifically, the leading jobJi−v+1in
the last batch has the largest lateness within this batch. There-fore, we take the maximum betweenG(i− 1, u, v − 1) and Li−v+1, which is equal toCiu− di−v+1. The minimum value
is selected from among all the feasibleg(n, u, v) values.
To determine the time complexity of the above algorithm, we first note that in the formulation, functionG(·, ·, ·)
con-sists ofO(n3) entries. Once the input instance is given, the
partial sumsir=1pkr for alli and a fixed k can be incre-mentally computed in O(n) time. Therefore, for all i and k, we can derive all the partial sumsir=1pkr in O(mn) time. Knowing ir=1pkr, we can further compute Ciu in
O(m) time for a fixed i and a fixed u. In other words, an O(mn+ mn2)= O(mn2) preprocessing procedure can
cal-culateCiufor alli and u. With all Ciuknown in advance, the
time required to determine the value of each entryG(i, u, v)
isO(n) by examining different v values whenv = 1 and O(1) when v > 1. There are O(n2) entries for v = 1
andO(n3) entries for v > 1. Therefore the overall running
time of the algorithm, including the preprocessing step, is
O(max{n3,mn2}). The result is summarized in the following
theorem.
THEOREM 2: The ID|batch∗|Lmax problem subject to
centralized batching can be solved inO(n2max{m, n}) time.
3. WEIGHTED NUMBER OF TARDY JOBS
In this section, we address another due-date related objec-tive function—the weighted number of tardy jobs. Hochbaum and Landy [7] proposed a pseudo-polynomial time dynamic programming algorithm for the 1|batch∗|wiUi prob-lem. The running time is O(n2W ), where W = n
j=1wj. The algorithm solves the case where the jobs have equal weights in O(n3) time. Brucker and Kovalyov [3]
devel-oped a dynamic programming algorithm for the general case. By scaling the weights used in the dynamic programming algorithm, they proposed a fully polynomial time approxima-tion scheme, each(1+ )-approximation algorithm of which
requires O(n3+ n3logn) time. The algorithm solves the
unit-weighted case inO(n3) time. In the context of the
con-current open shop, Wagneur and Sriskandarajah [29] showed that ID||wiUi is NP-hard in the ordinary sense even if
m = 2, di = d, and wi = 1. Ng et al. [22] proved the strong NP-hardness of theP D|pki ∈ {0, 1}, di = d|
Ui problem.
From the above review, we see that scheduling with the objective function Lmax and scheduling with the objective
functionwiUiexhibit different computational complexity, although the optimal solutions for both problems are based on the EDD rule (as will be shown in this section for the second function). The Ui problem remains intractable because of the difficulty from not only sequencing but also select-ing jobs. A simple proof of the strong NP-hardness of the
ID|pki ∈ {0, 1}, di = 1|
Ui problem by a reduction from three-Dimensional Matching [19] reflects the intractability of the job selection issue. As a generalization ofID||Ui, theID|batch∗|wiUi problem of interest in this paper is strongly NP-hard, too. In the following we develop solu-tion algorithms, which have exponential running times, for scheduling with different batching policies. The following properties inspire the development of our algorithms.
LEMMA 6: [5] There exists an optimal solution for the
ID||wiUiproblem in which the early jobs are sequenced in the EDD order and the late jobs are sequenced in an arbitrary order.
LEMMA 7: Regardless of whether centralized or decen-tralized batching is in effect, there is an optimal solution for the ID|batch∗|F (U1,. . . , Un) problem in which the early jobs are sequenced in the EDD order, whereF (U1,. . . , Un) is any regular function.
PROOF: Assume in some optimal schedule there are two early jobsJiandJjsuch thatdi < djandJjprecedesJion all the machines. We move operationOkj, for eachk, 1≤ k ≤ m, to make it the immediate successor ofOkiin the same batch. The completion times of all the operations, except opera-tions{Okj}, do not increase by the move. Furthermore, since NewCj = New Ci = Ci ≤ di < dj, the equalityUj = 0 remains true. In other words, no early job will become late after the move. Repeating the same process, we eventually obtain a schedule in which all the early jobs are arranged by the EDD rule, and no early job in the original schedule will be tardy in the new schedule. We thus complete the proof.
Common examples of the objective functionF (U1,. . . , Un) specified in Lemma 7 include iwiUi, maxiwiUi, max{n/2i=1wiUi,
n
i=n/2+1wiUi}, etc.
3.1. wiUiwith Centralized Batching
We now tackle theID|batch∗|wiUiproblem subject to centralized batching. For convenience of description, we seek to maximize the weighted number of early jobs instead. Again recall that the jobs are first sequenced in non-decreasing order of their due dates. The recursive functionG(i, t1,. . . , tm,j ) for max1≤k≤m{tk} ≤ dj is defined as the maximum weighted number of early jobs out of the firsti jobs{J1,J2,. . . , Ji}, subject to the conditions that the completion time of the last early job on machine Mk, 1 ≤ k ≤ m, is exactly tk and that the leading job in the last batch on all the machines is
Jj, 0≤ j ≤ i. The recursion proceeds by considering job Ji. If max1≤k≤m{tk} ≤ diandJisolely constitutes the last batch, then in the recursion we consider the firsti− 1 jobs with
different leading jobs in the last batch. On the other hand, if jobJidoes not form the last batch alone, then it can be in the last batch or discarded as tardy. The dynamic programming algorithm is given as follows:
Algorithm CB-Sum-of-wiUi for centralized batching: Initialization:
G(i, t1,. . . , tm,j )=
0, ifi= t1= · · · = tm= j = 0; −∞, otherwise.
Recursion: Compute the recursion for i = 1, . . . , n; j =
1,. . . , i; tk = 1, . . . , dj(1≤ k ≤ m): (i, t1,. . . , tm,j ) = max{G(i − 1, t1− p1i,. . . , tm− pmi,j )+ wi, G(i− 1, t1,. . . , tm,j )}, ifj < i; max 0≤j<iG(i− 1, t1− s1− p1i,. . . , tm− sm− pmi,j)+ wi, ifj = i.
The maximum weighted number of early jobs is
max{G(n, t1,. . . , tm,j ) : 0≤ tk≤ dj, 1≤ k ≤ m; 1≤ j ≤ n}. We justify the formulation as follows: In the recursion, the condition “j < i” dictates that job Ji can be early if it is included in the last early batch but it is not the leading job in the last batch. Subject to this condition, we can either select jobJi for processing or discard it. The second condition is given for the scenario that jobJiis early and solely forms the last batch. For further recursion, we need to consider all the possible jobsJj acting as the leading job in the last batch
after removing jobJi.
With regard to the required running time, we note that each state needsO(m) time to calculate tk−pkiortk−s −pki, 1≤
k ≤ m, for the recursions. For the case j < i, there are O(n2dm
max) states, each of which can be computed in O(1)
time. On the other hand, for the case j = i, there are O(ndm
max) states, each of which requires O(n) time to
con-sider different leading jobsJj. The overall running time is thusO(mn2dm
max), which becomes pseudo-polynomial when
the number of machinesm is fixed or is not part of the input.
We thus have the following theorem.
THEOREM 3: TheID|batch∗|wiUi problem subject to centralized batching can be solved in pseudo-polynomial time if the number of dedicated machines is constant. As discussed before, Brucker and Kovalyov [3] used the rounding technique to design anO(n3/ε+n3log logn)
algo-rithm with a performance ratio of 1+ε for 1|batch∗|w
iUi, which is ordinary NP-hard. Although Algorithm CB-Sum-of-wiUi solves problem IDm|batch∗|wiUi in pseudo-polynomial time for a fixed m, it cannot be improved to
be a polynomial time algorithm, since Lin and Kononov [20] proved that unless N P = P , there exists no FPTAS
for ID2|di = d|
Ui. Therefore, the above algorithm gives a tight result on the computational complexity of
IDm|batch|wiUi subject to centralized batching and a fixed number of machines. It is also tight in another sense: when the number of machines is part of the input, there is no pseudo-polynomial time solution, due to Theorem 3.
3.2. wiUiwith Decentralized Batching In this subsection, we modify Algorithm CB-Sum-of-wiUi to cope with the decentralized case. Here we need such detailed information as the completion time of each machine and the leading job in the last batch on each machine. Define
G(i, t1,. . . , tm,j1,. . . , jm) for tk ≤ djk, 1≤ k ≤ m, as the
optimal weighted number of early jobs for the first i jobs
{J1,. . . , Ji}, subject to the conditions that the completion time of the last early job on machineMk is exactly tk and that the leading job in the last batch on machineMk isJjk.
The most crucial part in the design of an exact algorithm is to handle the situation in which jobJi must be included in the solution whenJiis considered for recursion and it solely forms the last batch on some machineMk, i.e.,i= jk. Algorithm DB-Sum-of-wiUi for decentralized batching: Initialization: G(i, t1,. . . , tm,j1,. . . , jm) = 0, ifi= t1= · · · = tm= j1 = · · · = jm= 0; −∞, otherwise.
Recursion: Compute the recursion for i = 1, . . . , n; jk = 1,. . . , i; tk= 1, . . . , djk(1≤ k ≤ m): G(i, t1,. . . , tm,j1,. . . , jm) = max{G(i − 1, t1− p1i,. . . , tm− pmi,j1,. . . , jm)+ wi,
G(i− 1, t1,. . . , tm,j1,. . . , jm)}, if jk< i for all k; maxDG i− 1, t1,. . . , tm,j1,. . . , jm)+ wi,
ifi= jkfor somek;
where D is the set of feasible 2m-tuple vectors (t1,. . . , tm,j1,. . . , jm) defined in the following way:
Ifjk< i, then tk = tk− pki,jk = jk.
Ifjk= i, then tk = tk−sk−pki,jk∈ {0, 1, . . . , i−1}. The maximum weighted number of early jobs subject to decentralized batching is
max{G(n, t1,. . . , tm,j1,. . . , jm) : 0≤ tk≤ djk, 1
≤ jk≤ n, 1 ≤ k ≤ m}. In the first case of the recursion formula, job Ji does not form the last batch alone on any machine so we either accept jobJias early or discard it. The size of the space with such states is O(nm+1dm
max) and the value of each state can be
computed in O(m) time, which is required for computing
the valuest1− p1i,. . . , tm− pmi. In the second case, jobJi solely forms the last batch on at least one machine and it is anyway accepted as an early job. SetD contains all the
admissible combinations of (t1,. . . , tm,j1,. . . , jm) for
fur-ther recursions. There are O( ml nm−l+1dm
max) states where
exactlyl jk’s are equal toi and the cardinality of setD is
O(nl). Therefore, the total (over all the states) time complex-ity isO(m2mnm+1dm
max), which is exponential and becomes
pseudo-polynomial when the number of machines m is
constant. We conclude the result in the following theorem. THEOREM 4: TheID|batch∗|wiUi problem subject to decentralized batching can be solved in pseudo-polynomial time if the number of dedicated machines is constant.
4. TOTAL WEIGHTED COMPLETION TIME
In the context of batch scheduling, Albers and Brucker [1] proved that the single-machine problem to minimize the total weighted completion time, i.e., 1|batch∗|w
iCi, is NP-hard in the ordinary sense. If the job sequence is fixed, an
O(n) dynamic program can be designed to optimally solve
the problem. The case with equal processing times can be solved by sequencing the jobs in non-increasing order of their weights. Coffman et al. [6] investigated the unit-weighted version 1|batch∗|Ciand obtained the following result.
LEMMA 8: [6] There exists an optimal schedule for the 1|batch∗|Ci problem in which the jobs are sequenced in the shortest processing time (SPT) order.
In view of this property, for the unweighted single-machine case, we can re-index the jobs in the SPT order. Based upon this property, Coffman et al. [6] proposed a backward dynamic programming algorithm. They definedG(i) as the
optimal total completion time of the jobsJi,Ji+1,. . . , Jnand sought the value of G(1). The algorithm is outlined in the
following: Algorithm CYMS Initialization:
SetG(n+ 1) = 0.
Recursion: Compute the recursion fori= n, n − 1, . . . , 1:
G(i)= min i+1≤j≤n+1 G(j )+ (n − i + 1) s1+ j−1 r=i p1r .
The optimal total completion time is given byG(1). The
algorithm is justified by considering the increase in the total completion time caused by a prefix batch{Ji,. . . , Jj−1} to
all of the jobs in the schedule. The overall running time of the algorithm isO(n2). Coffman et al. [6] provided an
candidate jobs that can start the next batch. As reviewed in Potts and Kovalyov [24], the geometric approach developed by van Hoesel et al. [8] can attain the same reduction in time complexity.
With regard to the minimization of the total comple-tion time in concurrent open shop scheduling, Wagneur and Sriskandarajah [29] first showed that the ID||Ci prob-lem is strongly NP-hard. Due to the intractability of the problem, Lann et al. [12] proposed a simple heuristic and proved its asymptotic optimality in a probabilistic sense. Sung and Yoon [28] studied the weighted case of the two-machine problem, i.e., ID2||wiCi, and showed that the worst case performance ratio of the weighted shortest pro-cessing time (WSPT) rule is 2. Nevertheless, Leung et al. [16] gave a counter-example to the proof of Wagneur and Sriskandarajah [29]. Leung et al. [14] further showed that the problem is strongly NP-hard form ≥ 3. Roemer [26]
further sharpened the complexity boundary by showing that the problem remains strongly NP-hard even if there are only two machines. Therefore, theID|batch∗|Ci problem is hard to solve, too.
In this article, we assume that a job sequence is given and the decision is how to group the jobs into batches. A fixed sequence of the jobs can be admitted by, e.g., an agree-able condition that for any two jobs Ji,Jj ∈ J , p1i ≤
p1j ⇔ p2i ≤ p2j ⇔ · · · ⇔ pmi ≤ pmj. In most sched-uling problems, schedules are easily implied from sequences for most scheduling problems. However, for some prob-lems it is nontrivial to determine the optimal solution to the instance associated with a given job sequence. The assump-tion of a fixed job sequence has been considered in several scheduling problems. Due to technical constraints on specific machines, Shafransky and Strusevich [27] investigated open shop scheduling problems subject to the condition that the job sequence on each machine is fixed. Studies on schedul-ing problems with fixed job sequences also inspire different theoretical interests. Lin and Cheng [18] proposed an algo-rithm to determine the optimal makespan of a sequence of jobs in a two-machine flowshop with conditional stage-two processing times. Solving the special case with a fixed job sequence facilitates the development of lower bounds. Ng and Kovalyov [23] proposed a dynamic programming algorithm for batch scheduling in a flowshop with a given sequence of jobs. Hwang et al. [9] studied three flowshop scheduling problems with decisions of batching and idle time insertion subject to a given job sequence. The devel-opment of dynamic programs demands the exploration of several theoretical properties. Based upon the concept of optimal blocks, they developed polynomial-time dynamic programming algorithms. Hwang and Lin [10] introduced several intriguing properties of coupled-task scheduling sub-ject to a fixed job sequence. In this paper we denote the problem to minimize the total weighted completion time as
ID|batch∗,f ixed_seq|wiCi, where “fixed_seq” in the second field indicates that a job sequence is given.
4.1. wiCiwith a Fixed Sequence and Centralized Batching
Our discussion begins with centralized batching. An attempt to deploy Algorithm CYMS to solve the problem may fail because the increase in the total completion time caused by the insertion of a prefix batch cannot be determined. Consider a partial schedule of the jobs {Jj,Jj+1,. . . , Jn}. JobsJi,Ji+1,Jj−1 constitute a batch to be added in front of the partial schedule. While the completion times of the jobs
Ji,Ji+1,Jj−1 are easily determined, there is no information
on how the completion times of the jobsJj,Jj+1,. . . , Jnwill increase because the operation completion times of any job are different on different machines and they are not recorded along with each state. Thus the contribution to the objec-tive value made by the new batch cannot be calculated. To circumvent this difficulty, we adopt forward recursion. DefineG(i, u) as the optimal total weighted completion time
of the jobs J1,. . . , Ji, given that the jobs are grouped into exactlyu, 1≤ u ≤ i, batches. To find the value of G(i, u),
we consider different numbers of jobs (or sizes) in the last batch of the associated partial schedule of jobs J1,. . . , Ji. If Jj+1,. . . , Ji constitute the last batch, then the problem reduces to solving G(j , u − 1). The increase in the total
weighted completion time caused by the jobs in this batch can be calculated as follows:
max 1≤k≤m usk+ i r=1 pkr × i r=j+1 wr,
where max1≤k≤m{usk+ i
r=1pkr} calculates the completion time of the last batch. Therefore, we can develop the following dynamic program accordingly.
Algorithm CB-WTCT for centralized batching: Initialization:
G(i, u)=
0, ifi= u = 0;
∞, otherwise.
Recursion: Compute the recursion for i = 1, . . . , n; u =
1,. . . , i: G(i, u)= min max{0,u−1}≤j<i G(j , u− 1) + max 1≤k≤m usk+ i r=1 pkr × i r=j+1 wr .
The total weighted completion time is min{G(n, u) : 1 ≤
u ≤ n}. The partial sums ir=1pkr for all i and a fixed
k can be incrementally computed in O(n) time in a
pre-processing procedure. With these partial sums, the terms max1≤k≤m{usk+
i
r=1pkr} can be computed for all i and for allu by an O(mn2)-time preprocessing procedure.
Simi-larly, for alli and j , the termsir=j+1wr can be derived in
O(n2) time. The preprocessing step requires O(mn2) time
in all. To compute for each state G(i, u), O(n) iterations
are required to examine all the different jobsJj and each iteration takesO(1) time. The main body of Algorithm
CB-WTCT depends onO(n2) states for all the possible values of i and u. Therefore, the overall running time of the algorithm
isO(n2max{m, n}).
THEOREM 5: TheID|batch∗,f ixed_seq|wiCi prob-lem subject to centralized batching can be solved in
O(n2max{m, n}) time.
4.2. wiCiwith Decentralized Batching We proceed to deal with the decentralized case. The suc-cess of the solution approach for theID|batch∗|Lmax
prob-lem suggests the use of Algorithm CYMS for scheduling operations on each machine. Unfortunately, this approach fails to work for the ID|batch∗|Ci problem subject to decentralized batching. Consider a two-machine, 10-job instance defined bys1 = 5, p1,1 = · · · = p1,9 = 2, p1,10 =
3;s2 = 10, p2,1 = · · · = p2,10 = 2. Optimally solving
for each machine individually, we have the optimal batching {J1,. . . , J6}, {J7,. . . , J10} on M1 and {J1,. . . , J10} on M2.
Taking the maximum completion time of each operation on the two machines, the total completion time is calculated as 6× 30 + 4 × 31 = 304. On the other hand, if we group the operations on each machine into a single batch, then all the operations have a completion time of 26 onM1and a
com-pletion time of 30 onM2, thus achieving a total completion
time of 300, which is smaller than 304.
To deal with the decentralized case, we first note that there are un−1
k−1
ways to groupn operations into uk batches on machine Mk. Therefore the total number of possible solutions ismk=1nuk=1 un−1
k−1
, which grows exponentially. Without the successful development of a polynomial time approach, we again resort to the design of a dynamic pro-gramming algorithm, which however exhibits an exponential time complexity when the number of machinesm is a
vari-able. The dynamic program runs using backward chaining. DefineG(i, u1,. . . , um,j1,. . . , jm) as the optimal contribu-tion of the jobsJi,. . . , Jnto the total weighted completion time, given that there are exactlyuk, 1≤ uk≤ i − 1, setups before operationOkiand that operationOkjk is the last
oper-ation in the batch containing operoper-ationOki. Note that here we use the term “optimal contribution” instead of the optimal
total weighted completion time of the jobsJi,. . . , Jnbecause function G does not compute their optimal total weighted
completion time. A dummy job Jn+1 withwn+1 = 0 and
pk,n+1 = 0 for all k is added to define the boundary condition. Subject to the scenario defining G(i, u1,. . . , um,j1,. . . , jm), operations Oki andOkjk have the same completion time
uksk+ jk
r=1pkr. Therefore, the completion time of jobJiis given by max 1≤k≤m uksk+ jk r=1 pkr .
The recursion of the dynamic programming algorithm pre-sented below proceeds by jobs, instead of by batches as in the centralized case.
Algorithm DB-WTCT for decentralized batching: Initialization: G(n+ 1, u1,. . . , um,j1,. . . , jm) = 0, if 1≤ uk≤ n + 1, 1 ≤ k ≤ m; j1= · · · = jm= n + 1; ∞, otherwise.
Recursion: Compute the recursion for i = n, . . . , 1; uk = 1. . . , i; jk= 1, . . . , i − uk+ 1 (1 ≤ k ≤ m): G(i, u1,. . . , um,j1,. . . , jm) = wi× max 1≤k≤m uksk+ jk r=1 pkr + min D G i+ 1, u1,. . . , um,j1,. . . , jm , where D is the set of feasible 2m-tuple vectors
(u1,. . . , um,j1,. . . , jm) defined in the following way:
Ifi < jk, thenuk= uk,jk= jk.
Ifi= jk, thenuk = uk+1, jk ∈ {i +1, i +2, . . . , n+1}. The optimal total weighted completion time subject to decentralized batching is
min{G(1, 1, . . . , 1, j1,. . . , jm) : 1≤ jk≤ n for 1 ≤ k ≤ m}. For eachjk, the sum
jk
r=1pkrcan be computed by anO(mn) preprocessing procedure before the dynamic program starts. Under the specifications i, u1,. . . , um,j1,. . . , jm, the first termwi×max1≤k≤m{uksk+
jk
r=1pkr} calculates the contri-bution of jobJito the total weighted completion time, which can be derived inO(m) time. There are O( ml n2m−l+1) dif-ferent states of functionG where there are exactly l jks equal
Table 1. Summary of the results. Objective,
batching mode DP’s complexity Remark
Lmax, decentralized O(mn2) Theorem 1 Lmax, centralized O(n2max{m, n}) Theorem 2
wiUi, centralized O(mn2dmaxm ) Theorem 3:
Pseudo-polynomial for fixedm
wiUi, O(m2mnm+1dmaxm ) Theorem 4:
Pseudo-decentralized polynomial for fixedm
wiCi(fixed_seq), O(n2max{m, n}) Theorem 5
centralized
wiCi(fixed_seq), O(2mn2m+1) Theorem 6
decentralized Polynomial for fixedm
toi and the cardinality of setD is O(nl). The overall running time of Algorithm DB-WTCT isO(2mn2m+1).
THEOREM 6: The ID|batch∗, fixed_seq|wiCi prob-lem subject to decentralized batching can be solved in
O(2mn2m+1), which is polynomial if the number of dedicated
machines is constant.
Before closing this section, we note that using the same design scheme of Algorithm DB-WTCT, we can design a backward chaining dynamic programming algorithm for the case subject to centralized batching. Nevertheless, we cannot use the forward scheme of Algorithm CB-WTCT to design an algorithm for the case subject to decentralized batching. Without the information on the last operation in the batch containing the current operationOki, we cannot determine the contribution of jobJi.
5. CONCLUSIONS
In this article, we considered a new model that includes batching decisions in concurrent open shop scheduling. Batching decisions can be centralized or decentralized. We studied three objectives, namely the maximum lateness, num-ber of tardy jobs, and total weighted completion time. We proposed polynomial time exact algorithms to minimize the maximum lateness subject to either centralized or decentral-ized batching. When the objective is to minimize the number of tardy jobs, the problem remains strongly NP-hard even if a fixed job sequence is given. To minimize the total weighted completion time of a fixed or predetermined job sequence, we presented a polynomial time algorithm for the case where centralized batching is in effect. The algorithm designed for decentralized batching however has an exponential running time. When the number of dedicated machines is constant, the time complexity becomes polynomial. We summarize the results of this article in Table 1.
For further study, it will be interesting to determine the complexity status of the ID|batch∗,f ixed_seq|wiCi problem subject to decentralized batching with a vari-able number of machines. Moreover, at present we cannot find approximation approaches admitting perfor-mance analysis. Another complexity issue is related to ID|batch∗,agr|Ui. While the restricted problem
ID2|di = d,pik ∈ {0, 1}|
Ui is strongly NP-hard, prob-lem ID|agr|Ui with agreeable conditions, which were defined in Section 4 on wiUi, can be solved in polyno-mial time [15]. If the agreeable conditions are satisfied, then an optimal schedule can be obtained by first scheduling the jobs in the EDD order. It will be interesting to investigate the complexity status ofID|batch∗,agr|Ui. The reduc-tion from 3DM used in the proof of Lin and Kononov [19] does not work here because the constructed instance does not meet the agreeable condition. Extending the study of the con-current open shop to simultaneously include other batching models, such as simultaneous batch processing, is another direction worthy of research.
ACKNOWLEDGMENTS
This research was supported in part by the Logistics Research Centre of The Hong Kong Polytechnic University. Lin was partially supported by the National Science Coun-cil of Taiwan under grant number 96-2416-H-009-001 as well. The authors are grateful to the anonymous referees for their constructive comments that have helped improve the presentation of the article.
REFERENCES
[1] S. Albers and P. Brucker, The complexity of one-machine batching problems, Discrete Appl Math 47 (1993), 87–107. [2] R.H. Ahmadi and U. Bagchi, Scheduling of multi-job
cus-tomer orders in multi-machine environments, ORSA/TIMS Philadelphia, 1990.
[3] P. Brucker and M.Y. Kovalyov, Single machine batch sched-uling to minimize the weighted number of late jobs, Math Methods Oper Res 43 (1996), 1–8.
[4] T.C.E. Cheng, J.N.D. Gupta, and G. Wang, A review of flow-shop scheduling research with setup times, Prod Oper Manage 9 (2000), 262–282.
[5] T.C.E. Cheng, Q. Wang, and J.J. Yuan, “Customer order sched-uling on multiple facilities,” Working Paper, Department of Logistics, The Hong Kong Polytechnic University, 2006. [6] E.G. Coffman Jr., M. Yannakakis, M.J. Magazine, and C.A.
Santos, Batch sizing and job sequencing on a single machine, Ann Oper Res 26 (1990), 135–147.
[7] D.S. Hochbaum and D. Landy, Scheduling with batching: Minimizing the weighted number of tardy jobs, Oper Res Lett 16 (1994), 79–86.
[8] S. van Hoesel, A. Wagelmans, and B. Moerman, Using geo-metric techniques to improve dynamic programming algo-rithms for the economic lot-sizing problem and extensions, Eur J Oper Res 75 (1994), 312–331.
[9] F.J. Hwang, M.Y. Kovalyov, and B.M.T. Lin, “Total com-pletion time minimization in flow shop scheduling problems with a fixed job sequence,” Presented at The 12th Inter-national Workshop on Project Management and Scheduling (PMS2010), Tours, France, 2010.
[10] F.J. Hwang and B.M.T. Lin, Coupled-task scheduling on a single machine subject to a fixed job sequence (in press). [11] M.Y. Kovalyov, C.N. Potts, and V.A. Strusevich, Batching
decisions for assembly production systems, Eur J Oper Res 157 (2004), 620–642.
[12] A. Lann, G. Mosheiov, and Y. Rinott, Asymptotic optimality in probability of a heuristic schedule for open shops with job overlaps, Oper Res Lett 22 (1998), 63–68.
[13] C.Y. Lee, T.C.E. Cheng, and B.M.T. Lin, Minimizing the makespan in three-machine assembly type flow shop problem, Manage Sci 39 (1993), 616–625.
[14] J.Y.T. Leung, H. Li, and M. Pinedo, Order scheduling in an environment with dedicated resources in parallel, J Scheduling 8 (2005), 355–386.
[15] J.Y.T. Leung, H. Li, and M. Pinedo, Scheduling orders for mul-tiple product types with due date related objectives, Eur J Oper Res 168 (2006), 370–389.
[16] J.Y.T. Leung, H. Li, M. Pinedo, and S. Sriskandarajah, Open shops with jobs overlap—Revisited, Eur J Oper Res 163 (2005), 569–571.
[17] C.L. Li and W.Q. Xiao, Lot streaming with supplier-manufacturer coordination, Nav Res Logist 51 (2004), 522–542.
[18] B.M.T. Lin and T.C.E. Cheng, Two-machine flowshop sched-uling with conditional deteriorating second operations, Int Trans Oper Res 13 (2006), 91–174.
[19] B.M.T. Lin and A.V. Kononov, A study on customer order scheduling, Technical Report 2006-NSC-95-2416-H-009-003, National Chiao Tung University, Taiwan, 2006.
[20] B.M.T. Lin and A.V. Kononov, Customer order scheduling to minimize the number of late jobs, Eur J Oper Res 183 (2007), 944–948.
[21] J.M. Moore, Ann Job, one machine sequencing algorithm for
minimizing the number of late jobs, Manage Sci 15 (1968), 102–109.
[22] C.T. Ng, T.C.E. Cheng, and J.J. Yuan, Concurrent open shop scheduling to minimize the weighted number of tardy jobs, J Scheduling 6 (2003), 405–412.
[23] C.T. Ng and M.Y. Kovalyov, Batching and scheduling in a multi-machine flow shop, J Scheduling 10 (2007), 353–364.
[24] C.N. Potts and M.Y. Kovalyov, Scheduling with batching: A review, Eur J Oper Res 120 (2000), 228–249.
[25] C.N. Potts, S.V. Sevastyanov, V.A. Strusevich, L.N. Van Wassenhove, and C.M. Zwaneveld, The two-stage assembly scheduling problem: Complexity and approximation, Oper Res 43 (1995), 346–355.
[26] T.A. Roemer, A note on the complexity of the concurrent open shop problem, J Scheduling 9 (2006), 389–396.
[27] Y.M. Shafransky and V.A. Strusevich, The open shop sched-uling problem with a given sequence of jobs on one machine, Nav Res Logist 45 (1998), 705–731.
[28] C.S. Sung and S.H. Yoon, Minimizing total weighted comple-tion time at a pre-assembly stage composed of two feeding machines, Int J Prod Econ 54 (1998), 247–255.
[29] E. Wagneur and C. Sriskandarajah, Open shops with jobs overlap, Eur J Oper Res 71 (1993), 366–378.
[30] G. Wang and T.C.E. Cheng, Customer order scheduling to minimize total weighted completion time, Proceedings of the 1st Multidisciplinary Conference on Scheduling Theory and Applications, 2003, pp. 409–416.
[31] S.T. Webster and K.R. Baker, Scheduling groups of jobs on a single machine, Oper Res 43 (1995), 692–703.
