J Sched (2012) 15:391–398 DOI 10.1007/s10951-011-0260-y
On-line integrated production and outbound distribution scheduling to minimize the maximum delivery completion time C.T. Ng · Lingfa Lu
Published online: 10 November 2011 © Springer Science+Business Media, LLC 2011
Abstract In this paper, we consider the on-line integrated production and outbound distribution scheduling problem to minimize the maximum delivery completion time. All jobs arrive over time, and each job and its processing time become known at its arrival time. The jobs are first processed on a single machine and then delivered by a vehicle to a single customer. The vehicle can deliver at most c jobs to the customer at a time. When preemption is allowed and c ≥ 2, we can provide an on-line algorithm with the best compet√ ≈ 1.618. When preemption is not allowed, itive ratio 5+1 2 we provide an on-line algorithm which has the best competi√ tive ratio 5+1 2 ≈ 1.618 for the case c = 1 and has an asymp√
totic competitive ratio
5+1 2
≈ 1.618 for the case c ≥ 2.
Keywords Scheduling · On-line algorithm · Competitive ratio
1 Introduction and problem formulation The on-line integrated production and outbound distribution scheduling problem to minimize the maximum delivery completion time can be described as follows. At the beginning of the planning horizon, the manufacturer has a single machine and a capacitated vehicle. The manufacturer receives some jobs (orders) at different arrival times from a C.T. Ng () · L. Lu Department of Logistics and Maritime Studies, The Hong Kong Polytechnic University, Hung Hom, Kowloon, Hong Kong e-mail:
[email protected] L. Lu Department of Mathematics, Zhengzhou University, Zhengzhou, Henan 450001, People’s Republic of China
single customer. That is, the manufacturer does not know any information of these jobs in advance, including total number, arrival times and processing times of these jobs. Job Jj and its processing time pj become known when job Jj arrives at its arrival time rj . The jobs are first processed on the single machine. When the vehicle is available at the machine, the finished jobs can be delivered directly in batches by the vehicle to the single customer. The vehicle has a capacity c, i.e., the vehicle can deliver at most c jobs to the customer at a time. All jobs delivered together in one shipment are defined as a delivery batch. The transportation time of each delivery batch is a fixed constant T > 0 known in advance, which represents the round-trip transportation time between the machine and the customer. The delivery completion time of job Jj , denoted by Cj , is defined as the time at which the vehicle returns to the machine after job Jj has been delivered to the customer by the vehicle. Our objective is to find a schedule such that the maximum delivery completion time, denoted by Cmax = maxnj=1 {Cj }, is minimized. Using the five-field notation proposed by Chen (2010), this problem can be denoted by 1|rj , on-line|v(1, c), direct|k = 1|Cmax , where “v(1, c)” represents that there is a vehicle with capacity c; “k = 1” represents that there is a single customer; and “direct” represents that the finished jobs are delivered directly in batches by the vehicle to the single customer. If preemption is allowed for all the jobs on the machine, the corresponding scheduling problem is denoted by 1|rj , on-line, pmtn|v(1, c), direct|k = 1|Cmax . If all information of the jobs is known in advance, the corresponding off-line scheduling problems are denoted by 1|rj |v(1, c), direct|k = 1|Cmax when preemption is not allowed, and 1|rj , pmtn|v(1, c), direct|k = 1|Cmax when preemption is allowed, respectively. When preemption is allowed, Lu et al. (2008) presented a polynomial-time algorithm for the problem. When preemption is not allowed,
392
Lu et al. (2008) showed that the problem is strongly NPhard for each fixed c ≥ 1 and presented a 53 -approximation algorithm. In fact, if we consider the vehicle as a batchprocessing machine, then the above problem is actually equivalent to a two-machine flow-shop scheduling problem with a single machine and a batch-processing machine. The batch-processing machine can process at most c jobs simultaneously as a batch and each batch has the same processing time T > 0. For the latter problem, Sung and Kim (2002) showed that the problem is polynomially solvable when preemption is allowed, the problem is strongly NPhard when preemption is not allowed and c = 4. For the nonpreemptive scheduling problem, Sung and Kim (2002) also presented a 2-approximation algorithm. Note that the problem considered by Lu et al. (2008) is in fact equivalent to the problem considered by Sung and Kim (2002). Thus, Lu et al. (2008) improved some results obtained by Sung and Kim (2002). In the recent three decades, various integrated production and distribution scheduling problems have been studied in the literature. Chen (2010) provided a comprehensive survey for most existing models. The earliest paper on this topic is the one by Potts (1980). He considered the single-machine scheduling problem with release dates to minimize the maximum delivery completion time. In this model, all jobs have non-identical delivery times. It is also assumed that there are a sufficient number of vehicles so that each finished job can be delivered individually and immediately to the customer. The author presented a heuristic algorithm with the worst-case performance ratio 32 for the problem. Hall and Shmoys (1992) presented two polynomial-time approximation schemes for the same problem. For the on-line version of the problem, Hoogeveen and Vestjen (2000) provided an on-line algorithm with the best-possible competitive ratio √ 5+1 2 . When restarts are allowed for the jobs, van de Akker et al. (2000) presented an on-line algorithm with the bestpossible competitive ratio 32 . Lee and Chen (2001) considered the machine scheduling problem with transportation considerations (subject to a limited number of vehicles and a limited vehicle capacity). In this model, when some vehicles are available at the machine, the finished jobs can be delivered directly in batches to the customers. Chang and Lee (2004) extended this model by considering the situation where each job might occupy a different amount of physical space in a vehicle. Lu and Yuan (2008a, 2008b) considered the single-machine scheduling problem and the unbounded parallel-batch machine scheduling problem to minimize the maximum delivery completion time, respectively. In addition, Hall and Potts (2003) studied a variety of scheduling, batching, and delivery problems that arise in an arborescent supply chain. Chen and Vairaktarakis (2005) considered the integrated scheduling of production and distribution operations. Averbakh (2010) considered the on-line integrated
J Sched (2012) 15:391–398
production and distribution scheduling problems to minimize the sum of the total weighted flow time and the total delivery cost. Zhong et al. (2010) considered the integrated production and distribution scheduling problem with committed delivery dates. For other models and results on this topic, we refer the reader to Chen (2010). In this paper, we consider the on-line integrated production and outbound distribution scheduling problem to minimize the maximum delivery completion time. This is the on-line version of the problem studied in Lu et al. (2008) and Sung and Kim (2002). To the best of our knowledge, no paper has considered on-line flow-shop model with release dates and a batch-processing machine, like what this paper does. When preemption is allowed and c ≥ 2, we provide an on-line algorithm with the best competitive ratio √ 5+1 ≈ 1.618. When preemption is not allowed, we pro2 vide√an on-line algorithm which has the best competitive ra≈ 1.618 for the case c = 1 and has the asymptotic tio 5+1 2 √
competitive ratio
5+1 2
≈ 1.618 for the case c ≥ 2.
2 Preliminaries For any instance I , let C ∗ (I ) and C A (I ) be the maximum delivery completion times given by an off-line optimal algorithm and an on-line algorithm A, respectively. If C A (I ) ≤ kC ∗ (I ) holds for each instance I , we say that A has the competitive ratio k. Furthermore, if C A (I ) ≤ kC ∗ (I ) + b holds for each instance I and b is a fixed constant, we say that A has the asymptotic competitive ratio k. Let π be a feasible preemptive or non-preemptive schedule; we define the following notation: • Jπ(j ) , the j th finished job in π on the machine. • tπ(j ) , the starting time of job Jπ(j ) on the machine. • ρπ(j ) , the ready time of job Jπ(j ) , which represents the time at which job Jπ(j ) completes its processing on the machine. • δπ(j ) , the departure time for the vehicle to deliver job Jπ(j ) from the machine to the customer. • Bπ(k) , the kth delivery batch in π . Batches delivered earlier have smaller indices. • ρ(Bπ(k) ), the ready time of batch Bπ(k) , which is the maximum ready time of the jobs assigned to batch Bπ(k) . • δ(Bπ(k) ), the departure time for the vehicle to transport batch Bπ(k) from the machine to the customer. Note that δ(Bπ(k) ) ≥ ρ(Bπ(k) ) in any feasible solution. 3 Preemptive scheduling First, we consider the off-line scheduling problem 1|rj , pmtn|v(1, c), direct|k = 1|Cmax . For this problem, Lu et al. (2008) presented a polynomial-time algorithm A1 as follows.
J Sched (2012) 15:391–398
Polynomial-time algorithm A1 Step 1: All jobs are processed on the machine by the shortest remaining processing time rule (SRPT-rule). That is, if some job finishes its processing or a new job is released at time t, among all unfinished jobs released by time t, the job with the shortest remaining processing time is scheduled. Step 2: Assign all jobs to delivery batches such that we have the following. (1) The job with a smaller ready time is delivered no later than that with a larger ready time. (2) Each delivery batch, except the first delivery batch, contains exactly c jobs. Step 3: Whenever the vehicle and a delivery batch are available, transport the delivery batch with the smallest ready time. Now, we consider the on-line problem 1|rj , on-line, pmtn|v(1, c), direct|k = 1|Cmax . Note that the SRPT-rule is in fact an on-line rule. Thus, we know how to process the jobs on the machine. It is easy to see that, once all delivery batches are determined, we can transport all delivery batches by the greedy rule as in Step 3 of algorithm A1 . Thus, the remaining problem is how to assign all the jobs to delivery batches. Clearly, when c = 1, each job is transported as a delivery batch. Thus, algorithm A1 is in fact an optimal on-line algorithm for the case c = 1. When c ≥ 2, since the number of jobs n is not known in advance, we cannot assign all the jobs into nc delivery batches as in Step 2 of algorithm A1 . In fact, by considering the vehicle as a batch-processing machine with the capacity c, the remaining job delivery problem is equivalent to an on-line batch-processing scheduling problem considered by Zhang et al. (2001) as follows: All jobs arrive over time, i.e., each job and its processing time become available at its arrival time. There is a batch-processing machine which can handle up to c ≥ 2 jobs simultaneously. The processing time of a batch is given by the longest processing time of the jobs in the batch. The objective is to minimize the makespan. For this problem, Zhang et al. (2001) showed that any deterministic on-line algorithm has a competitive ratio at least √ 5+1 2 ≈ 1.618. By using a similar idea, we have the following theorem. Theorem 3.1 For problem 1|rj , on-line, pmtn|v(1, c), direct|k = 1|Cmax with c ≥ 2, there is no deterministic √ on-line algorithm with a competitive ratio less than 5+1 2 ≈ 1.618. Proof Given any on-line algorithm A, we consider the following instance: Job J1 with p1 = 0 arrives at time 0. Assume that the vehicle transports J1 at time t in algorithm A. √ If t ≥ 5−1 2 T , then no other job arrive. Thus, we have
393 CA C∗
≥
t+T T
≥
√
5+1 2
since the vehicle transports J1 at time 0 √
in the optimal schedule. If t < 5−1 2 T , then job J2 with t+2T → p2 = 0 arrives at time t + . Thus, we have CCA∗ ≥ t++T 1+
T t+T
≥1+
√
T 5−1 2 T +T
=
√
5+1 2
when → 0 since the ve-
hicle transports J1 and J2 as a delivery batch at time t + in the optimal schedule. For the on-line batch-processing scheduling problem with non-identical processing times, Zhang et al. (2001) presented an on-line algorithm with the competitive ratio 2. Note that all jobs have the same transportation time T in our model. Thus, it is possible to present an on-line algorithm with a smaller competitive ratio. Next, we will present an on-line algorithm A2 with the best-possible competitive ra√ 5+1 tio 2 for problem 1|rj , on-line, pmtn|v(1, c), direct|k = 1|Cmax with c ≥ 2. On-line algorithm A2 Phase 1: Assign the jobs for processing on the machine as follows: All jobs are processed on the machine by the SRPT-rule. That is, at any time t, among jobs released by time t, the job with the shortest remaining processing time is scheduled. Phase 2: Assign the finished jobs in Phase 1 for delivering by the vehicle as follows: √
Step 0: Set α = 5−1 2 ≈ 0.618 and t = αT . Step 1: If there are some jobs which have been finished in Phase 1 and have not been delivered to the customer at time t, then the vehicle transports the finished jobs as many as possible in a delivery batch to the customer. Set t = t + T , go to Step 1. If there is no job available to be delivered by the vehicle at time t, let t with t > t be the earliest time at which some job is finished in Phase 1. Set t = t , go to Step 1. Lemma 3.2 For any instance I = {J1 , . . . , Jn }, we have C A2 (I ) ≤ C ∗ (I ) + T . Proof Let π and π ∗ be the schedules obtained by the online algorithm A2 and the optimal off-line algorithm A1 , respectively. Note that all jobs are processed on the machine in the SRPT-rule in both algorithm A1 and algorithm A2 . Thus, we have ρπ(j ) = ρπ ∗ (j ) for each j = 1, . . . , n. Suppose that Bπ(1) , . . . , Bπ(b) are the delivery batches in π , where b is the number of delivery batches in π . By algorithm A2 , we have δ(Bπ(1) ) = max{αT , ρπ(1) } and δ(Bπ(i) ) = max{δ(Bπ(i−1) ) + T , ρ(Bπ(i) )} for each i = 2, . . . , b. Let Bπ(k) be the first delivery batch such that Bπ(k) , . . . , Bπ(b) are transported contiguously to the customer by the vehicle. Thus, we have C A2 (I ) = δ(Bπ(k) ) + (b − k + 1)T .
394
First, we assume that each delivery batch in Bπ(k) , . . . , Bπ(b−1) contains c jobs. If k = 1, then we have b = nc = b∗ . Thus, we have C A2 (I ) = max{αT , ρπ(1) } + nc T ≤ C ∗ (I ) + T . If k > 1, by the definition of Bπ(k) , then we have δ(Bπ(k) ) = ρ(Bπ(k) ) > δ(Bπ(k−1) ) + T . Since the vehicle is idle at the time interval [δ(Bπ(k−1) ) + T , δ(Bπ(k) )), by algorithm A2 , the jobs in Bπ(k) , . . . , Bπ(b) are completed at or after δ(Bπ(k) ) = ρ(Bπ(k) ). Note that each delivery batch in Bπ(k) , . . . , Bπ(b−1) contains exactly c jobs. Thus, there are at least (b − k)c + 1 jobs in Bπ(k) , . . . , Bπ(b) . T = Furthermore, we have C ∗ (I ) ≥ δ(Bπ(k) ) + (b−k)c+1 c δ(Bπ(k) ) + (b − k + 1)T = C A2 (I ). Thus, we also have C A2 (I ) ≤ C ∗ (I ) + T . Next, we assume that some delivery batch in Bπ(k) , . . . , Bπ(b−1) contains less than c jobs. Without loss of generality, let Bπ(r) be the last delivery batch in Bπ(k) , . . . , Bπ(b−1) containing less than c jobs. Then, each delivery batch in Bπ(r+1) , . . . , Bπ(b−1) contains c jobs. Furthermore, by algorithm A2 , all the jobs in Bπ(r+1) , . . . , Bπ(b) are completed after δ(Bπ(r) ). Thus, there are at least (b − r − 1)c + 1 jobs in Bπ(r+1) , . . . , Bπ(b) which complete after δ(Bπ(r) ). Consequently, we have C ∗ (I ) ≥ δ(Bπ(r) ) + T = δ(Bπ(r) ) + (b − r)T = C A2 (I ) − T . Thus, (b−r−1)c+1 c we also have C A2 (I ) ≤ C ∗ (I ) + T . This completes the proof of Lemma 3.2. Theorem 3.3 For any instance I = {J1 , . . . , Jn }, we have C A2 (I ) ≤ (1 + α)C ∗ (I ). 1 Proof If C ∗ (I ) ≥ (1 + α)T , then we have T ≤ 1+α C ∗ (I ) = ∗ αC (I ). Furthermore, by Lemma 3.2, we have C A2 (I ) ≤ C ∗ (I ) + T ≤ (1 + α)C ∗ (I ). If C ∗ (I ) < (1 + α)T , then all the jobs complete their processing at or before αT in the optimal schedule. In this case, we have C A2 (I ) = αT + nc T ≤ (1 + α)C ∗ (I ). Theorem 3.3 follows.
4 Non-preemptive scheduling In this section, we consider the problem 1|rj , on-line|v(1, c), direct|k = 1|Cmax . We have the following theorem. Theorem 4.1 For problem 1|rj , on-line|v(1, c), direct|k = has a competi1|Cmax , any deterministic on-line algorithm √ 5−1 tive ratio at least 1 + α, where α = 2 ≈ 0.618 is a root 1 of the equation 1+α = α. Proof Given any on-line algorithm A, we consider the following instance: Job J1 with the processing time p1 = (k − 1)T arrives at time 0. Assume that algorithm A starts processing J1 at time t. If t ≥ αkT , then no other jobs arrive. Clearly, we have C A ≥ t + (k − 1)T + T ≥ (1 + α)kT . However, the optimal schedule is to process J1 at time 0 and
J Sched (2012) 15:391–398
deliver it at time (k − 1)T . That is, we have C ∗ = kT . Thus, (1+α)kT CA = 1 + α. C∗ ≥ kT If t < αkT , then (k − 1)c jobs J2 , . . . , J(k−1)c+1 with the processing time 0 arrive at time t + . Clearly, we have C A ≥ t + (k − 1)T + kT . However, the optimal schedule is to process and deliver these jobs in the order of J2 , . . . , J(k−1)c+1 , J1 . That is, C ∗ = t + + kT . A +kT − = 1 + (k−1)T Thus, we have CC ∗ ≥ t+(k−1)T t++kT t++kT ≥ 1 + (k−1)T − αkT ++kT → 1 + α when k → +∞ and → 0. Note that when preemption is allowed, the jobs are processed according to the SRPT-rule in the optimal schedule. Thus, when preemption is not allowed, it is easy to propose some on-line algorithm based on the shortest processing time rule (SPT-rule). That is, at any time, the shortest job is always prior to other jobs to be processed on the machine. Next, we will show that the competitive ratio is at least 1 + β for any on-line algorithm A based on the SPT√ 17+1 rule, where β = 8 ≈ 0.640 is a root of the equation 4β 2 − β − 1 = 0. Theorem 4.2 For problem 1|rj , on-line|v(1, c), direct|k = 1|Cmax , any deterministic on-line algorithm based on the SPT-rule has a competitive ratio at least 1 + β. Proof We consider the following instance with c = 1: Job J1 with the processing time p1 = (k − 1)T arrives at time 0. If algorithm A starts processing J1 at time t and t ≤ 1−β β p1 , then k − 1 jobs J2 , . . . , Jk with the processing time 0 arrive at time t + . Clearly, we have C A ≥ t + (k − 1)T + kT . However, the optimal schedule is to process and deliver these jobs in the order J2 , . . . , Jk , J1 . That is, C ∗ = t + A +kT + kT . Thus, we have CC ∗ ≥ t+(k−1)T → 1 + (k−1)T t++kT t+kT ≥ (k−1)T 1 1 = 1 + 1−β k → 1 + 1−β =1+β 1 + 1−β β
(k−1)T +kT
β
+ k−1
β
+1
when k → +∞ and → 0. If algorithm A does not start to process J1 in the time interval [0, 1−β β p1 ], then a job J2 with p2 =
1−β 1+β p1
arrives at time
1−β β p1 .
Note that p2 < p1 ,
1−β β p1
+ p2 = β(p1 + p2 ) and p1 = (1 + β)p2 + βp1 . If J2 is not scheduled before time β(p1 + p2 ), then no jobs arrive in the future. In this case, we have C A ≥ β(p1 +p2 )+p1 +p2 +T = (1+β)(p1 +p2 )+T . However, the optimal schedule first schedules J1 and then J2 . That is, A 1 +p2 )+T C ∗ = p1 + p2 + T . Thus, we have CC ∗ ≥ (1+β)(p = p1 +p2 +T 1+β−
βT (k−1)T + 1−β 1+β (k−1)T +T
→ 1 + β when k → +∞. 1−β β p1 ≤ t < 1−β β p1 + p 2 ≤ t
If J2 is scheduled at time t and
β(p1 +
p2 ), then we have β(p1 + p2 ) = + p2 < β(p1 + p2 ) + p2 = p1 . Furthermore, if algorithm A schedules J1 after or at time β(p1 + p2 ) + p2 = p1 , then no A jobs arrive in the future. In this case, we also have CC ∗ ≥ (1+β)(p1 +p2 )+T → 1 + β when k → +∞. If algorithm A p1 +p2 +T
J Sched (2012) 15:391–398
395
schedules J1 at time t1 with β(p1 + p2 ) ≤ t + p2 ≤ t1 < β(p1 + p2 ) + p2 = p1 , then m = pT2 jobs J3 , . . . , J2+m with the processing time 0 arrive at time p1 . In this case, we have C A ≥ t + p2 + p1 + (m + 1)T ≥ (1 + β)(p1 + p2 ). However, the optimal schedule processes and delivers all the jobs in the order J1 , J3 , . . . , Jm+2 , J2 . Thus, we have C ∗ ≤ A 1 +p2 ) p1 + p2 + 2T . Furthermore, we have CC ∗ ≥ (1+β)(p p1 +p2 +2T = 1+β −
(1+β)2T (k−1)T + 1−β 1+β (k−1)T +2T
→ 1 + β when k → +∞.
By Theorem 4.2, in order to design an on-line algorithm √ with the best-possible competitive ratio 5+1 2 , we cannot always choose the shortest job. Next, we propose an on-line √ algorithm A3 with the (asymptotic) competitive ratio 5+1 2 . Before proposing algorithm A3 , we introduce some important notation. • p(S), the total processing time of all the jobs in S, i.e., p(S) = Jj ∈S pj . • |S|, the number of jobs in S. • A(t), the set of the unscheduled jobs which are available at time t. • e(t), the earliest time such that the machine is always busy in time interval [e(t), t]. • B(t), the set of jobs which are processed in time interval [e(t), t] on the machine. • C(t), the set of jobs which are in A(t) or B(t). That is, C(t) = A(t) ∪ B(t). • Js(t) , the job with the shortest processing time in A(t). • ps(t) , the processing time of the job Js(t) . • Jl(t) , the job with the longest processing time in A(t). • pl(t) , the processing time of the job Jl(t) .
Phase 2: Assign the finished jobs in Phase 1 for delivering by the vehicle as follows: Step 0: Set t = 0. Step 1: If there are some jobs which have been finished in Phase 1 and have not been delivered to the customer at time t, then the vehicle transports the finished jobs as many as possible in a delivery batch to the customer. Set t = t + T , go to Step 1. If there is no job available to be delivered by the vehicle at time t, let t with t > t be the earliest time at which some job is finished in Phase 1. Set t = t , go to Step 1. To prove the competitive ratio of the on-line algorithm A3 , we first replace Phase 2 of algorithm A3 by Phase 2 in the following way: Assign all the jobs to delivery batches and transport these delivery batches such that we have the following. (1) The job with a smaller ready time is delivered no later than that with a larger ready time. (2) Each delivery batch, except the first delivery batch, contains exactly c jobs. (3) After an undelivered batch is formed at its ready time, whenever the vehicle is available, the vehicle transports the undelivered batch with the smallest ready time to the customer. Let A 3 be the algorithm obtained by the above modification from algorithm A3 . Note that A 3 is not an on-line algorithm when c ≥ 2. We use algorithm A 3 only as a transition to prove the competitive ratio of the online algorithm A3 . Next, we will show that the following lemma holds.
Lemma 4.3 For each instance I , we have C A3 (I ) ≤ (1 + A 3 α)C ∗ (I ) + c−1 c T . Specially, when c = 1, we have C (I ) ≤ (1 + α)C ∗ (I ).
On-line algorithm A3 Phase 1: Assign the jobs for processing on the machine as follows: √
Step 0: Set t = 0 and α = 5−1 2 ≈ 0.618. Step 1: If |A(t)| = 0, then we wait until a new job arrives at time t . Set t = t , go to Step 1. If |A(t)| = 1, i.e., A(t) = {Js(t) }, we distinguish two cases in the discussion. Case 1: If t < rs(t) + α(ps(t) + T ), then we wait until the first time t such that either a new job arrives at time t or t = rs(t) + α(ps(t) + T ). Set t = t , go to Step 1. Case 2: If t ≥ rs(t) + α(ps(t) + T ), then we schedule Js(t) at time t. Set t = t + ps(t) , go to Step 1. If |A(t)| ≥ 2, we also distinguish two cases in the discussion. Case 3: If ps(t) ≤ Tc , or t + ps(t) ≤ max{rl(t) + α(pl(t) + T ), α(p(C(t)) + T )} or pl(t) ≤ αp(C(t)) holds, then we schedule Js(t) at time t. Set t = t + ps(t) , go to Step 1. Case 4: Otherwise, we schedule Jl(t) at time t. Set t = t + pl(t) , go to Step 1.
Proof Without loss of generality, we assume that I = {J1 , J2 , . . . , Jn } with r1 ≤ · · · ≤ rn is a smallest counter
example such that C A3 (I ) > (1 + α)C ∗ (I ) + c−1 c T . Let π be the schedule for instance I obtained by algorithm A 3 . Furthermore, let Jπ(j ) be the j th scheduled job in π . Thus, we have ρπ(1) ≤ · · · ≤ ρπ(n) . By Phase 2 , there are d = nc delivery batches Bπ(1) , . . . , Bπ(d) in π . Furthermore, we have δ(Bπ(1) ) = ρ(Bπ(1) ) and δ(Bπ(i) ) = max{ρ(Bπ(i) ), δ(Bπ(i−1) ) + T } for each i = 2, . . . , d. Denote by Bπ(k) the last delivery batch satisfying ρ(Bπ(k) ) = δ(Bπ(k) ) in π . Let Jπ(h) be the last completed job in Bπ(k) . Note that there are exactly c jobs in each delivery batch Bπ(i) for each i = k + 1, . . . , d. Thus, we have n−h c = d − k.
Furthermore, we have C A3 (I ) = ρ(Bπ(k) ) + (d − k + 1)T = ρπ(h) + (d − k + 1)T . Next, we have the following claims. Claim 1 The jobs in {Jπ(1) , . . . , Jπ(h) } are processed contiguously in π , i.e., there is no idle time between these jobs on the machine.
396
J Sched (2012) 15:391–398
Otherwise, let Jπ(i) (2 ≤ i ≤ h) be the last job such that Jπ(i) , . . . , Jπ(h) are processed contiguously in π . Since the machine is idle at time ρπ(i−1) , there are only two possibilities by algorithm A 3 : either |A(ρπ(i−1) )| = 0, or |A(ρπ(i−1) )| = 1 and ρπ(i−1) < rs(ρπ(i−1) ) + α(ps(ρπ(i−1) ) + T ). No matter which possibility occurs, if we remove Jπ(1) , . . . , Jπ(i−1) from I , this does not change the value
C A3 (I ). Furthermore, the value C ∗ (I ) is not increased. Thus, we obtain a smaller counter-example than I , a contradiction. Therefore, we have i = 1. Claim 1 follows.
By Claim 1, we have C A3 (I ) = tπ(1) + hj=1 pπ(j ) + (d − k + 1)T . Furthermore, by algorithm A 3 , we have tπ(1) = min{r1 + α(p1 + T ), r2 }. Now, we modify the arrival times of the jobs in I by the following way: (1) If Jπ(j ) = J1 ,
we define rπ(j ) = tπ(1) . (2) If Jπ(j ) = J1 , let i < j be the maximum integer such that pπ(j ) < pπ(i) . If such an i does
not exist or i > h, we define rπ(j ) = rπ(j ) . Otherwise, we
define rπ(j ) = max{rπ(j ) , ρπ(i) }. Let I be the new instance obtained from I by the above modification. Clearly, π is a feasible schedule for I . Note that, in instance I , Jπ(i) (1 ≤ i ≤ h) is always the job with the shortest remaining processing time from tπ(i) to ρπ(i) . ∗ (I ) for inNow, we consider the optimal schedule πpmtn
stance I when preemption is allowed for all the jobs. Fur∗ (I ) be the makespan of π ∗ (I ). Note thermore, let Cpmtn pmtn ∗ (I ) are the same as those in π . that the first h jobs in πpmtn Thus, there are at least n − h + 1 jobs which need to be transported by the vehicle after or at time ρπ(h) . Furthern−h+1 ∗ (I ) ≥ ρ more, we have Cpmtn T = ρπ(h) + π(h) + c
Furthermore, since pπ(x) > αp(C(tπ(x) ), we have αpπ(x) > p C(tπ(x) ) − pπ(x) = p A(tπ(x) ) ∪ B(tπ(x) ) − pπ(x) ≥ p B(tπ(x) ) . Specially, if |A(tπ(x) )| ≥ 2, we have αpπ(x) > p A(tπ(x) ) ∪ B(tπ(x) ) − pπ(x) ≥ p B(tπ(x) ) + ps(tπ(x) ) . Furthermore, since the job Jπ(x) is scheduled at time tπ(x) , by algorithm A 3 , we have two possibilities: either |A(tπ(x) )| = 1 and tπ(x) ≥ rπ(x) + α(pπ(x) + T ), or |A(tπ(x) )| ≥ 2 and tπ(x) + ps(tπ(x) ) > max{rπ(x) + α(pπ(x) + T ), α(p(C(tπ(x) )) + T )}. If |A(tπ(x) )| = 1 and tπ(x) ≥ rπ(x) + α(pπ(x) + T ), then tπ(x) = tπ(1) + p(B(tπ(x) )) ≥ rπ(x) + α(pπ(x) + T ). Thus, we have rπ(x) < tπ(1) ≤ r2 since p(B(tπ(x) )) < αpπ(x) . If |A(tπ(x) )| ≥ 2 and tπ(x) + ps(tπ(x) ) > max{rπ(x) + α(pπ(x) + T ), α(p(C(tπ(x) )) + T )}, then tπ(1) + p B(tπ(x) ) + ps(tπ(x) ) = tπ(x) + ps(tπ(x) ) ≥ rπ(x) + α(pπ(x) + T ). Thus, we have rπ(x) < tπ(1) ≤ r2 since αpπ(x) > p(B(tπ(x) )) + ps(tπ(x) ) . Combining the above two cases, we have rπ(x) = r1 , i.e., Jπ(x) = J1 . Claim 2 follows.
A3 ( n−h c + 1)T = C (I ). Therefore, π is an optimal sched
∗ (I ) = C ∗ (I ). ule for instance I . That is, C A3 (I ) = Cpmtn
Write Δ = max{rπ(j ) − rπ(j ) : j = 1, . . . , n}. Let π ∗ be an optimal schedule for instance I . By delaying the processing and delivery of each job in π ∗ by a time length Δ, we obtain a feasible schedule for I with the makespan C ∗ (I ) + Δ. Thus, we have C ∗ (I ) ≤ C ∗ (I ) + Δ. Furthermore, we have
C A3 (I ) = C ∗ (I ) ≤ C ∗ (I ) + Δ.
Claim 2 There must exist some job Jπ(x) with 1 ≤ x ≤ h such that pπ(x) > αp(C(tπ(x) )). Furthermore, we have Jπ(x) = J1 . Otherwise, we assume that pπ(i) ≤ αp(C(tπ(i) )) for each i = 1, . . . , h. By algorithm A 3 , Jπ(i) is the shortest job in A(tπ(i) ) and pπ(i) ≤ αp(C(tπ(i) )) ≤ αC ∗ (I ). For any job Jπ(j ) , if there exists the maximum integer i with i < j such that pπ(j ) < pπ(i) , then we have rπ(j ) > tπ(i) . Fur
∗ thermore, we have rπ(j ) − rπ(j ) ≤ pπ(i) ≤ αC (I ). Set pmax (h) = max{pπ(i) : i = 1, . . . , h}, then we have Δ ≤
max{tπ(1) − r1 , pmax (h)} ≤ αC ∗ (I ). Thus, we have C A3 (I ) ≤ C ∗ (I ) + Δ ≤ (1 + α)C ∗ (I ), a contradiction. Thus, there must exist some job Jπ(x) with 1 ≤ x ≤ h such that pπ(x) > αp(C(tπ(x) )).
Claim 3
x
j =1 pπ(j )
> αC ∗ (I ).
Otherwise, we assume that xj =1 pπ(j ) ≤ αC ∗ (I ) holds. Let I be the instance obtained from I by the above modifications of the arrival times. Clearly, if Jπ(j ) = J1 , we
∗ have rπ(j ) − rπ(j ) ≤ α(p1 + T ) ≤ αC (I ). If Jπ(j ) = J1 and some integer i with i ≤ j is the maximum integer such that pπ(i) > pπ(j ) , we distinguish two cases in the follow
ing discussion. If Jπ(i) = Jπ(x) , we have rπ(j ) − rπ(j ) ≤ ∗ ρπ(x) − r2 ≤ pπ(1) + · · · + pπ(x) ≤ αC (I ). If Jπ(i) = Jπ(x) , we have pπ(i) ≤ αp(C(tπ(i) )) by Claim 2 and rπ(j ) > tπ(i) since Jπ(i) is the shortest job in A(tπ(i) ). Thus, we have
∗ rπ(j ) − rπ(j ) ≤ pπ(i) ≤ αp(C(tπ(i) )) ≤ αC (I ). Further
more, we have C A3 (I ) ≤ C ∗ (I ) + Δ ≤ (1 + α)C ∗ (I ), a contradiction. Claim 3 follows. h Claim 4 j =x+1 pπ(j ) ≤ T > αC ∗ (I ).
c−1 c T
< T and p(A(tπ(x) )) +
First, we consider the delivery batch Bπ(k) . Since δ(Bπ(k−1) ) + T ≤ δ(Bπ(k) ) = ρ(Bπ(k) ) = ρ(Bπ(k−1) ) + p(Bπ(k) ) and ρ(Bπ(k−1) ) ≤ δ(Bπ(k−1) ), we have p(Bπ(k) ) ≥ T . Thus, there must exist some job Jπ(y) with
J Sched (2012) 15:391–398
397
Jπ(y) ∈ Bπ(k) such that pπ(y) ≥ Tc . Without loss of generality, we assume that Jπ(y) is the last job in Bπ(k) such that pπ(y) ≥ Tc . If y < x, we have αp(C(tπ(x) )) ≤ pπ(x) < T c < pπ(y) , a contradiction. Thus, we have x ≤ y ≤ h. If y = x, by algorithm A 3 , we have pj > Tc for each job Jj ∈ A(tπ(x) ). If y > x, then Jπ(y) is the shortest job in A(tπ(y) ). Furthermore, we have pj ≥ pπ(y) ≥ Tc for each job Jj ∈ A(tπ(y) ). Let G(tπ(y) ) = {Jj : rj > tπ(y) } be the set of jobs which arrive after time tπ(y) . Note that, in the optimal schedule π ∗ , the jobs in G(tπ(y) ) are assigned to |G(t
)|
π(y) at least delivery batches and each delivery batch c must be transported by the vehicle after time tπ(y) . Thus,
|G(t
)|
π(y) we have C ∗ (I ) > tπ(y) + T . Furthermore, since c T pj ≥ pπ(y) ≥ c for each job Jj ∈ A(tπ(y) ), we have
C A3 (I )
= ρπ(h) + = tπ(y) +
n−h +1 T c
h
pπ(j )
j =y
|(A(tπ(y) ) ∪ G(tπ(y) )) \ {Jπ(j ) : y ≤ j ≤ h}| c +1 T
+
≤ tπ(y) +
h
pπ(j ) + p A(tπ(y) ) \ {Jπ(j ) : y ≤ j ≤ h}
j =y
|G(tπ(y) ) \ {Jπ(j ) : y ≤ j ≤ h}| + + 1 T. c
Note that C A3 (I ) > (1 + α)C ∗ (I ) and C ∗ (I ) > tπ(y) + |G(tπ(y) )|
T . Thus, we have p(A(tπ(y) )) + p(G(tπ(y) )) + T ≥ j =y pπ(j ) + p(A(tπ(y) ) \ {Jπ(j ) : y ≤ j ≤ h}) + T > αC ∗ (I ). Furthermore, we can conclude that y = x. Otherwise, if x < y, we have C ∗ (I ) ≥ xj =1 pπ(j ) + p(A(tπ(y) )) + p(G(tπ(y) )) + T > 2αC ∗ (I ) > C ∗ (I ), a contradiction. Since y = x, we have pπ(j ) < Tc for each j = x + 1, . . . , h. Furthermore, we have Jπ(j ) ∈ G(tπ(x) ) for each j = x + 1, . . . , h. Now, we consider the delivery batch Bπ(k) again. Note that pπ(j ) < Tc for each j = x + 1, . . . , h. Thus, we can conclude that Jπ(x) ∈ Bπ(k) and hj=x+1 pπ(j ) ≤ (c − 1) × T T c < T . Note that pj ≥ pπ(x) ≥ c for each Jj ∈ A(tπ(x) ) and pπ(j ) < Tc for each j = x + 1, . . . , h. Thus, we have h
C A3 (I ) = ρπ(h) + ( n−h j =x pπ(j ) + c + 1)T = tπ(x) + hc
|(A(tπ(x) )∪G(tπ(x) ))\{Jπ(j ) :x≤j ≤h}| + 1)T ≤ tπ(x) + p(A(tπ(x) )) c |G(t )| + 1)T . Thus, we have p(A(tπ(x) )) + T > + ( π(x) c
(
αC ∗ (I ) since C A3 (I ) > (1 + α)C ∗ (I ) and C ∗ (I ) > tπ(x) + |G(tπ(x) )| T . Claim 4 follows. c Claim 5 Jπ(x) = J1 must be the first scheduled job in the optimal schedule π ∗ . Otherwise, we assume that Jπ(x) = J1 is not the first scheduled job in π ∗ . Thus, all the jobs must be processed after or at time r2 . Furthermore, we have C ∗ (I ) ≥ r2 + nj=1 pπ(j ) + T ≥ tπ(1) + p(B(tπ(x) )) + p(A(tπ(x) )) + T . Note that tπ(1) + p(B(tπ(x) )) + p(A(tπ(x) )) + T + h
|G(tπ(x) )| T ≥ C A3 (I ) = tπ(x) + j =x pπ(j ) + T + c
|A(tπ(x) )\Jπ(x) |+|G(tπ(x) )\{Jπ(j ) :x (1+α)C ∗ (I ). Thus, c |G(tπ(x) )| T ≥ αC ∗ (I ). Furthermore, we have tπ(x) ≤ we have c |G(t π(x) )| T ≤ (1 − α)C ∗ (I ) = α 2 C ∗ (I ) ≤ C ∗ (I ) − c α(p(A(tπ(x) )) + T ). Next, we will show that pπ(x) + T > αC ∗ in two cases. If |A(tπ(x) )| = 1, we have pπ(x) + T = p(A(tπ(x) )) + T > αC ∗ . If |A(tπ(x) )| > 1, we write pmin (x) = min{pj : Jj ∈ A(tπ(x) ) \ Jπ(x) }. By algorithm A 3 , we have tπ(x) + pmin (x) > α(p(A(tπ(x) ) ∪ B(tπ(x) )) + T ). Thus, we have pmin (h) > αp(B(tπ(x) )) > 12 p(B(tπ(x) )). Thus, there is at most a job in A(tπ(x) ) which can com-
plete its processing in the time interval [tπ(1) , tπ(x) ). In this case, some job in B(tπ(x) ) must complete its processing af|A(tπ(x) )|+|G(tπ(x) )| T. ter tπ(x) . Thus, we have C ∗ (I ) ≥ tπ(x) + c |A(t
)|+|G(t
)|
Furthermore, we have tπ(x) +pπ(x) +T + π(x) c π(x) T h
≥ C A3 (I ) = tπ(x) + pπ(x) + j =x+1 pπ(j ) + T +
|A(tπ(x) )|+|G(tπ(x) )\{Jπ(j ) :x≤j ≤h}| T > (1 + α)C ∗ (I ). Thus, we c ∗ have pπ(x) + T > αC (I ). Furthermore, since Jπ(x) = J1 is not the first scheduled job in π ∗ , we have C ∗ (I ) ≥
r2 + p(B(tπ(x) )) + p(A(tπ(x) )) + T ≥ tπ(1) + p(B(tπ(x) )) + p(A(tπ(x) )) + T ≥ rπ(x) + (1 + α)(pπ(x) + T ) > C ∗ (I ), a contradiction. Claim 5 follows. By Claim 5, we have C ∗ (I ) ≥ r1 + p1 + nc T . If tπ(x) ≤
r1 + αC ∗ (I ), we have C A3 (I ) = tπ(x) + pπ(x) + h ∗ pπ(j ) + ( n−h c + 1)T ≤ r1 + αC (I ) + p1 + jh=x+1 n−h c−1 ∗ j =x+1 pπ(j ) + ( c + 1)T ≤ (1 + α)C (I ) + c T . If ∗ tπ(x) > r1 + αC (I ) ≥ max{rπ(x) + α(pπ(x) + T ), α(p(C(tπ(x) )) + T )}. Let Jπ(z) with 1 ≤ z < x be the job such that tπ(z) ≤ max{rπ(x) + (αpπ(x) + T ), α(p(C(tπ(x) )) + T )} < ρπ(z) . By algorithm A 3 , each job Jπ(j ) with z ≤ j < x is scheduled before Jπ(x) = J1 since pπ(j ) ≤ Tc . Thus, we have x−1 h n−h A 3 +1 T pπ(j ) + pπ(j ) + C (I ) = tπ(z) + c j =z
j =x
≤ max rπ(x) + (αpπ(x) + T ), α p C(tπ(x) ) + T +
h j =x
n T pπ(j ) + c
398
J Sched (2012) 15:391–398
≤ r1 + αC ∗ (I ) + pπ(x) + ≤ (1 + α)C ∗ (I ) +
c−1 n T+ T c c
c−1 T, c
a contradiction. This completes the proof of Lemma 4.3. Theorem 4.4 For each instance I , we have C A3 (I ) ≤ (1 + α)C ∗ (I ) when c = 1 and C A3 (I ) ≤ (1 + α)C ∗ (I ) + 2c−1 c T when c ≥ 2. Proof When c = 1, each job is transported as a delivery batch in algorithms A3 and A 3 . Thus, we have C A3 (I ) =
C A3 (I ) for any instance I . By Lemma 4.3, we have
C A3 (I ) = C A3 (I ) ≤ (1 + α)C ∗ (I ). When c ≥ 2, similar to
the proof of Lemma 3.2, we have C A3 (I ) ≤ C A3 (I ) + T for any instance I . Furthermore, by Lemma 4.3, we have C A3 (I ) ≤ (1 + α)C ∗ (I ) + 2c−1 c T . Theorem 4.4 follows. Remark When c = 1, algorithm A3 has the best-possible √ 5+1 competitive ratio 1 + α = 2 ≈ 1.618. In fact, when c = 1, the problem is equivalent to problem F 2|rj , on-line, p2j = T |Cmax which is a special case of problem F 2|rj , on-line|Cmax . For F 2|rj , on-line|Cmax , Zhang and van de Velde (2010) showed that any greedy algorithm has a competitive ratio 2. Thus, we improve the results obtained by Zhang and van de Velde (2010) in the special case with p2j = T . When c ≥ 2, our problem is not equivalent to F 2|rj , on-line, p2j = T |Cmax because batch delivery is used in the vehicle. For this case, algorithm A3 has an asymptotic competitive ratio 1 + α. Note that the asymptotic competitive ratio 1 + α is valid when T is a constant or T is bounded by a constant. Acknowledgements This research was supported in part by The Hong Kong Polytechnic University under Grant Number G-YX1S. The second author was also supported in part by grants NSFC (10901142) and NFSC-RGC (70731160633).
References Averbakh, I. (2010). On-line integrated production-distribution scheduling problems with capacitated deliveries. European Journal of Operational Research, 200, 377–384.
Chang, Y.-C., & Lee, C.-Y. (2004). Machine scheduling with job delivery coordination. European Journal of Operational Research, 158, 470–487. Chen, Z.-L. (2010). Integrated production and outbound distribution scheduling: review and extensions. Operations Research, 58, 130–148. Chen, Z.-L., & Vairaktarakis, G. L. (2005). Integrated scheduling of production and distribution operations. Management Science, 51, 614–628. Hall, N. G., & Potts, C. N. (2003). Supply chain scheduling: batching and delivery. Operations Research, 51, 566–584. Hall, L. A., & Shmoys, D. B. (1992). Johnson’s rule for single-machine scheduling: making a good heuristic better. Mathematics of Operations Research, 17, 22–35. Hoogeveen, J. A., & Vestjen, A. P. A. (2000). A best possible deterministic on-line algorithm for minimizing maximum delivery time on a single machine. SIAM Journal on Discrete Mathematics, 13, 56– 63. Lee, C.-Y., & Chen, Z.-L. (2001). Machine scheduling with transportation considerations. Journal of Scheduling, 4, 3–24. Lu, L. F., & Yuan, J. J. (2008a). Unbounded parallel batch scheduling problem with job delivery to minimize makespan. Operations Research Letters, 36, 477–480. Lu, L. F., & Yuan, J. J. (2008b). Single machine scheduling with job delivery to minimize makespan. Asia-Pacific Journal of Operational Research, 25, 1–10. Lu, L. F., Yuan, J. J., & Zhang, L. Q. (2008). Single machine scheduling with release dates and job delivery to minimize the makespan. Theoretical Computer Science, 393, 102–108. Potts, C. N. (1980). Analysis of a heuristic for one machine sequencing with release dates and delivery times. Operations Research, 28, 1436–1441. Sung, C. S., & Kim, Y. H. (2002). Minimizing makespan in a twomachine flowshop with dynamic arrivals allowed. Computers & Operations Research, 29, 275–294. van de Akker, M., Hoogeveen, H., & Vakhania, N. (2000). Restarts can help in the on-line minimization of the maximum delivery time on a single machine. Journal of Scheduling, 3, 333–341. Zhang, G. C., Cai, X. Q., & Wong, C. K. (2001). On-line algorithms for minimizing makespan on batch processing machines. Naval Research Logistics, 48, 241–258. Zhang, X. D., & van de Velde, S. (2010). On-line two-machine job shop scheduling with time lags. Information Processing Letters, 110, 510–513. Zhong, W. Y., Chen, Z.-L., & Chen, M. (2010). Integrated production and distribution scheduling with committed delivery dates. Operations Research Letters, 38, 133–138.
