A m-parallel crane scheduling problem with a ... - Wiley Online Library

4 downloads 4742 Views 301KB Size Report
2Lee Kong Chian School of Business, Singapore Management University, ... modeling; machine scheduling; crane; approximation; heuristics; search. 1.
A m-Parallel Crane Scheduling Problem with a Non-crossing Constraint Andrew Lim,1 Brian Rodrigues,2 Zhou Xu1 1

Department of Industrial Engineering and Logistics Management, Hong Kong University of Science and Technology, Clear Water Bay, Kowloon, Hong Kong 2

Lee Kong Chian School of Business, Singapore Management University, 50 Stamford Road, Singapore 178899

Received 8 April 2005; revised 8 April 2006; accepted 8 July 2006 DOI 10.1002/nav.20189 Published online 5 September 2006 in Wiley InterScience (www.interscience.wiley.com).

Abstract: In this paper, we study a m-parallel machine scheduling problem with a non-crossing constraint motivated by crane scheduling in ports. We decompose the problem to allow time allocations to be determined once crane assignments are known and construct a backtracking search scheme that manipulates domain reduction and pruning strategies. Simple approximation heuristics are developed, one of which guarantees solutions to be at most two times the optimum. For large-scale problems, a simulated annealing heuristic that uses random neighborhood generation is provided. Computational experiments are conducted to test the algorithms. © 2006 Wiley Periodicals, Inc. Naval Research Logistics 54: 115–127, 2007. Keywords:

modeling; machine scheduling; crane; approximation; heuristics; search

1.

INTRODUCTION

In this work, we study a machine scheduling problem motivated by crane assignments at the Port of Singapore. The problem is similar to m-parallel machine scheduling problems (e.g., [8], [13]) where the objective is to minimize the latest completion time of the operation, but is different from these since it includes a spatial constraint. This condition is necessary since cranes move on tracks and cannot cross over each other when loading and unloading cargo. The Port of Singapore is the world’s largest container transshipment hub with connections to 600 ports in 123 countries. Berths are equipped with quay cranes with an outreach of 55 meters that can service container vessels with 18 container rows across and are coordinated by an integrated terminal operations system. This system controls resources, including cranes, and maintains a crane assignment plan that is updated periodically since the uncertainty in activities (e.g., berthing, vehicle routing, yard storage) contiguous with crane movements makes it impossible to plan assignments over a long period of time. Figure 1 illustrates crane-to-job assignments in the port. The port Partial findings presented in the Ninth Scandinavian Workshop on Algorithm Theory (SWAT), 2004 [15]. Correspondence to: Z. Xu ([email protected]) © 2006 Wiley Periodicals, Inc.

operates approximately 120 quay cranes at any time where up to 4 cranes are assigned to each ship. Each crane processes a cluster or parcel (job) of containers located on deck or below the deck and completes the job before moving to the next job. Each ship can have up to 1200 containers, which are parcelled into jobs. When processing each job, cranes move right to left to maintain a minimum separation distance (usually 3 ship bays) as far as possible. Cranes can move from ship to ship depending on the jobs assigned. Since cranes and crane arms cannot cross, the crane scheduling problem is different from time-constrained machine scheduling studies found in the literature. Early work on crane scheduling without spatial constraints can be found in [4] and [18]. In the first study to address crane scheduling, Daganzo [4] studied a static problem where cranes are allowed to move freely from hold to hold and only one crane is allowed to work on a hold at any given time. In the model in [18], cranes performed at constant rates and were allowed to be interrupted. This constituted a parallel and identical machine problem where jobs consist of independent, single-stage, and preemptive tasks. Other studies on port operations involving cranes can be found in [1], [12], [22], and [19]. Studies of crane operations in manufacturing environments can be found in [6] and [16]. In the literature, work on crane scheduling prior to Kim and Park [10] and Lim et al. [14] does not address spatial

116

Naval Research Logistics, Vol. 54 (2007)

Figure 1. Cranes and jobs. [Color figure can be viewed in the online issue, which is available at www.interscience.wiley.com.]

constraints that arise in crane movements although it is common for cranes to move on single tracks parallel to the length of ships to reach jobs located in different areas on ships. Kim and Park [10] modeled a scheduling problem that included spatial constraints as a mixed-integer program and provided a branch-and-bound algorithm and heuristics to solve the problem. Lim et al. [14] studied a model that provided for a non-crossing spatial constraint and proposed a tabu search heuristic solution approach. In their study, a job-to-crane allocation is executed only once to maximize the total throughput, without taking time into consideration. Zhu and Lim [23] studied the same problem to minimize the latest completion time of all the jobs instead of throughput and used a branch-and-bound with a simulated annealing algorithm. Although they provided good solutions, these were limited to small scale problems. Lim et al. [15] provided several approximation algorithms that guaranteed solutions to be at most two times the optimal in the worse case, but that had relatively large deviations from the optimal solutions. Early work on parallel machine scheduling can be found in [7], [17], and [9]. Graham [7] gave a fully polynomial time approximation scheme for the parallel machine scheduling latest completion time minimization problem with a fixed number of machines. McNaugton [17] and Hu [9] studied other variants of the parallel machines scheduling problems, such as for jobs with preemptive jobs, jobs with deadlines, jobs with order, or jobs with loss functions. For an overview of early parallel machine scheduling literature [3]. Recent studies, including heuristic approaches, on the subject include [8], [13], and [21]. In the literature, research available on parallel machine scheduling problems has focused on models with temporal constraints that do not take spatial constraints into consideration. Naval Research Logistics DOI 10.1002/nav

The scheduling of cranes is typically constrained by many other practical considerations. For example, this includes berthing operations; sequencing jobs to maintain ship ballast and center of gravity; and coordination with vehicle routing plans. This poses immense challenges to model construction and solution. In order to gain theoretical insight into the problem structure and solution, this paper focuses on the crane scheduling problem with a non-crossing constraint. We study this basic problem as a m-parallel crane scheduling problem to provide a link with the body of related work on machine scheduling. In this paper, we first show how the minimum latest completion time can be found by limiting the search only to crane allocations (Section 2). Based on this, constraint and integer programs for the problem require smaller search spaces and fewer decision variables when compared with models given in [23]. A suite of optimization algorithms is developed to solve the problem, and a carefully designed backtracking scheme, which uses domain reduction and pruning, is implemented (Section 3). Approximation heuristics, based on algorithms available for parallel machine scheduling problems, are provided (Section 4), one of which guarantees an approximation factor of 2. For large problems, a simulated annealing heuristic (Section 5) is developed. In computational experiments, the algorithms are tested using randomly generated instances, and experimental results, reported in Section 6, are analyzed in Section 7. The algorithms are shown to improve on those available in the literature [23], [15]. 2.

THE MODEL

The objective in the m-parallel crane problem is to minimize the latest completion time (makespan) of all jobs

Lim, Rodrigues, and Xu: m-Parallel Crane Scheduling Problem

117

Figure 2. Instance of a crane scheduling. (a) A feasible scheduling with latest completion time is 5; (b) An optimal scheduling with latest completion time is 4.

where assignments are restricted by a non-crossing constraint (c.f. Zhu and Lim [23]). Each crane is assumed to complete a job it is allocated, and jobs cannot be shared by cranes and are not preemptive. Take the set of n jobs to be given by J ⫽ {1,2, . . . , n} and m cranes to be given by I ⫽ {1, 2, . . . , m}. Jobs and cranes are located in parallel. For jobs a, b 僆 J, a ⬍ b is equivalent to a is left of b and likewise for cranes. Because positioning cranes takes relatively little time [18], the processing time, Pj 僆 Z⫹, for each job j 僆 J is given only by the time a crane takes to complete the job, assumed to be the same for all cranes. We seek a scheduling scheme that includes a starting-time allocation map s: J 3 Z⫹ and a job-to-crane allocation map ␴: J 3 I. For each j 僆 J, the processing time on crane ␴j is given by [sj, sj ⫹ Pj). Because of the non-crossing constraint, a scheme is feasible if and only if for any k, j 僆 J, where k ⬍ j, either k and j are processed separately in time, i.e., [sk, sk ⫹ Pk) 艚 (sj, sj ⫹ Pj) ⫽ A, or k and j are processed on cranes that do not cross, i.e., ␴k ⬍ ␴j. The objective of the crane scheduling problem is to find a feasible schedule, consisting of s and ␴, which minimizes the latest completion time, i.e., which minimizes maxj僆J sj ⫹ Pj. A constraint programming model of the problem is given as follows. mins, ␴ s.t.

maxj僆J sj ⫹ Pj

for all k, j 僆 J and k ⬍ j,

共 ␴ j ⱕ ␴ k兲 3 关共s j ⫹ P j ⱕ s k兲 ⵪ 共s k ⫹ P k ⱕ s j兲兴. Figure 2 illustrates an instance of the problem. A feasible schedule shown in Figure 2a has a latest completion time of 5, with crane allocations ␴3 ⫽ ␴1 ⫽ 1 and ␴2 ⫽ ␴4 ⫽ 2 and time allocations s2 ⫽ 0, s3 ⫽ s4 ⫽ 1, and s1 ⫽ 2. Jobs 3 and 2 cannot start on cranes 1 and 2 simultaneously because of the non-crossing constraint for cranes 1 and 2. However, if job 2 is started after job 3 is completed, as shown in Figure 2b, the latest completion time will become 4, which is optimum. When only a single crane is considered, the problem is trivial. However, in the general case, the problem is intrac-

table. In [23], the problem is shown to be strongly ᏺᏼ-hard when m ⫽ 2. This can be extended to show that the problem is strongly ᏺᏼ-hard if m ⱖ 2. Theorem 1. The m-parallel crane scheduling problem is strongly ᏺᏼ-hard if m ⱖ 2. Proof. See Appendix A. Since constraints on the time-allocation map depend on the crane-allocation map, we can decompose decisions for ␴ and s so that once ␴ is given, the problem will depend only on s and becomes mins

maxj僆J sj ⫹ Pj

for all k, j 僆 J with k ⬍ j and ␴j ⱕ ␴k ,

s.t.

共s j ⫹ P j ⱕ s k兲 ⵪ 共s k ⫹ P k ⱕ s j兲. The following theorem allows the optimum time-allocation map s for a given crane-allocation map ␴ to be found implicitly. Theorem 2. Given a crane-allocation ␴, the time-allocation s defined in (1) minimizes the latest completion time (i.e., maxj僆J sj ⫹ Pj). sj ⫽



0 when j ⫽ 1 maxk⬍j, ␴ jⱕ ␴ k sk ⫹ Pk when j ⫽ 2, . . . ,n.

(1)

Proof. Given ␴j for 1 ⱕ j ⱕ n, consider the timeallocation schedule sj for 1 ⱕ j ⱕ n that is computed according to (1). For each job j where 1 ⱕ j ⱕ n and sj ⬎ 0, we say that a job i with 1 ⱕ i ⱕ n is a predecessor of job j, if and only if sj ⫽ si ⫹ Pi and ␴i ⱖ ␴j. In other words, job i is a predecessor of job j, if and only if job i is actively delaying the processing of job j in schedule s. Now consider some job jr with maximum completion time in schedule s. As shown in Figure 3, let j1 ⬍ j2 ⬍ . . . ⬍ jr be a job sequence such that the first job j1 starts at time sj1 ⫽ 0 and Naval Research Logistics DOI 10.1002/nav

118

Naval Research Logistics, Vol. 54 (2007)

Figure 4. Illustration of using Algorithm 1 to generate optimum time allocation for the given crane allocation.

Figure 3. Illustration of the proof for Theorem 2.

such that jk always is a predecessor of jk ⫹ 1. Note that ␴j1 ⱖ ␴j2 ⱖ . . . ⱖ ␴jr, and that the latest completion time of r schedule s equals ⌺k⫽1 Pjk. r Now, we show ⌺k⫽1 Pjk is not bigger than the latest completion time of any feasible schedule s* for the given ␴. Note that the processing intervals of any two jobs jx and jy (with x ⬍ y) in this sequence cannot overlap for the following reasons. Since x ⬍ y, we have jx ⬍ jy and ␴jx ⱖ ␴jy. If ␴jx ⬎ ␴jy, then the non-crossing condition implies that the two processing intervals do not overlap. And, if ␴jx ⫽ ␴jy, then the two jobs are run on the same crane and hence cannot have overlapping intervals. Since no two of these intervals can overlap in s*, and since the lengths of these intervals are Pj1, . . . , Pjr, this yields a lower bound of r ⌺k⫽1 Pjk on the latest completion time of any feasible schedule s*. Hence, the make-span of schedule s meets this lower bound exactly and is optimum. (Cf. [15], where a more complicated proof than above is given). 䊐 Now, using an array C[i] to record the latest completion time of each crane i, Algorithm 1 can be used to compute the optimum time-allocation map (1) for a given craneallocation map in O(mn) time. Algorithm 1 (A time-allocation algorithm for a given craneallocation map ␴) 1: 2: 3: 4: 5: 6:

C[i] 4 0, for 1 ⱕ i ⱕ m, s(1) 4 0; for j ⫽ 2 to n do sj 4 max{C[i] : i ⱖ ␴j} C[␴j] 4 sj ⫹ Pj; end for Return s;

In addition to this, Theorem 2 provides an optimum scheduling policy for a given crane-allocation map. Let every crane process jobs it is assigned in order, from left to right. If two cranes need to move in opposite directions (i.e., cross), the leftmost crane will not start its next job until the Naval Research Logistics DOI 10.1002/nav

rightmost crane completes its assigned job. This simple policy guarantees a minimum latest completion time without cranes crossing. Figure 4 shows the time allocation generated by Algorithm 1 for instance shown in Figure 2, given a crane allocation ␴3 ⫽ ␴1 ⫽ 1 and ␴2 ⫽ ␴4 ⫽ 2. Although it has a different form from Figure 2b, its latest completion time is also 4, which is optimum for the given crane allocation. The problem of finding a crane-allocation map ␴ can now be described concisely by a constraint programming model (CP). min␴ s.t.

maxj僆J sj ⫹ Pj (1) is satisfied.

In the problem, the objective function can be written as min c, where c denotes the latest completion time. By the definition of c, we must have c ⱖ sj ⫹ Pj for j 僆 J. In view of (1), for any two jobs j, k 僆 J where k ⬍ j, we require either sj ⱖ sk ⫹ Pk or ␴j ⱖ ␴k ⫹ 1. This can be formulated by introducing binary auxiliary variables yk,j and sufficiently large constants M1 and M2 (which could be ⌺j僆J Pj and m, respectively), such that sj ⱖ sk ⫹ Pk ⫺ M1yk,j for k, j 僆 J and k ⬍ j and ␴j ⱖ ␴k ⫹ 1 ⫺ M2(1 ⫺ yk,j) for k,j 僆 J and k ⬍ j. Here, the variable domains are given by yk,j 僆 {0, 1} for k,j 僆 J and k ⬍ j, ␴j 僆 {1, 2, . . . , m} for j 僆 J and sj ⱖ 0 for j 僆 J; and c ⱖ 0. By the above arguments, the CP model can now be transformed into an equivalent mixed-integer program (MIP) given by minc s.t. c ⱖ s j ⫹ P j, for j 僆 J s j ⱖ s k ⫹ P k ⫺ M 1y k,j, for k,j 僆 J and k ⬍ j

␴ j ⱖ ␴ k ⫹ 1 ⫺ M 2共1 ⫺ y k,j), for k,j 僆 J and k ⬍ j

Lim, Rodrigues, and Xu: m-Parallel Crane Scheduling Problem

119

y k,j僆{0,1}, for k,j 僆 J and k ⬍ j

␴ j 僆 兵1,2,. . . ,m其, for j 僆 J s j ⱖ 0, for j 僆 J. Note that the MIP requires O(n2) integral variables and O(n2) constraints and is smaller in scale compared with the model given in [23], which has O(n2m2) variables and constraints. As it is easy to see that the latest completion time must be at least as large as the average processing time of all jobs over all cranes, the following inequality is valid for the MIP: cⱖ

冋 册

¥ j僆JP j . m

Experimental results provided in Section 6 verify a significant improvement in the performance of the integer programming models given here when compared with those given in [23]. By using Theorem 2, a fully polynomial approximation algorithm can be derived to solve the problem when the number of cranes is fixed [15]. Using such an algorithm is, however, not practical when the number of cranes is large. For this, we exploit the properties given by Theorem 2 in the following sections. 3.

EXACT SEARCH

From the CP model, we know that only crane allocations must be determined to minimize latest completion times. To achieve optimum crane allocations, a carefully designed backtracking algorithm given in Algorithm 2 is used. Here, a tree search is utilized to obtain the optimum crane-allocation map. Each path in the search tree consists of n cranes, ␴1, ␴2, . . . , ␴n, corresponding to a craneallocation map, and the approach attempts to avoid redundant enumeration of crane allocations by using domain reduction. It also generates nodes in the search tree using data-structures and prunes branches using estimation functions. 3.1.

Domain Reduction

For every job j 僆 J, the domain of decision variable ␴j, D(␴j), is the set of cranes that can be allocated to process job j. Initially, we let D(␴j) ⫽ {1, 2, . . . , m}, which can be reduced during the search. Consider the stage when ␴k has been decided for all jobs k left of j. For each crane i 僆 I, let T[i] ⫽ max{sk ⫹ Pk兩␴k ⱖ i, k ⫽ 1, 2, . . . , j ⫺ 1} denote the

Figure 5. Illustration of proof of Theorem 3, where T[i⬘] ⫽ T[i] ⬍ T[i ⫺ 1] and i⬘ ⬎ i.

latest completion time of jobs left of j processed by cranes on the right of crane i, where T[0] ⫽ ⫺1. Hence, we have T[i ⫺ 1] ⱖ T[i] for i 僆 I. By (1), we know that the time sj to process job j must equal T[i] if crane i is allocated to job j. Based on these observations, the following theorem can be used to restrict the domain of ␴j without delaying the optimum latest completion time. Algorithm 2 Backtracking(j) 1: Compute EST by (2); 2: if EST ⬍ Cbest then 3: if j ⬎ n then 4: Update the optimum solution with Cbest by the current scheduling. 5: else 6: for each crane w 僆 D(␴j) do 7: Attempt to allocate crane w to job j, i.e., ␴j 4 w; 8: Let T⬘[i] 4 T[i] for all i ⱖ w; 9: Update T[i] for all i ⱖ w, i.e., T[i] 4 max{T[i], T[w] ⫹ Pj}; 10: Call Backtracking (j ⫹ 1); 11: Restore T[i] by T[i] 4 T⬘[i] for i ⱕ w; 12: end for 13: end if 14: end if 15: Return.

Theorem 3. Given ␴k for k ⱕ j ⫺ 1, allocating job j to cranes in D(␴j) ⫽ {i兩T ⬍ T[i ⫺ 1], i 僆 I} will not change the optimum latest completion time. Proof. We refer to Figure 5. Suppose we allocate ␴j ⫽ i⬘ ⰻ D(␴j). Hence, T[i⬘] ⱖ T[i⬘ ⫺ 1] implies the existence of a crane i ⬍ i⬘ so that T[i⬘] ⫽ T[i] ⬍ T[i ⫺ 1] and i 僆 I. Crane i must therefore be idle until job j is completed. For this reason, we can reallocate job j to crane i instead of i⬘ and keep other crane allocations unchanged, without delaying the latest completion time. 䊐 3.2.

Node Generation

A depth-first order is used to generate nodes in the search tree as shown in Algorithm 2. The back-tracking process Naval Research Logistics DOI 10.1002/nav

120

Naval Research Logistics, Vol. 54 (2007)

Figure 6.

By noticing that when j ⫽ n, EST equals T[1], which is the latest completion time of the current schedule, we can guarantee that the backtracking in Algorithm 2 gives an optimum crane-allocation map. It is worth noting here that estimation function values given by (2) were found in the experiments to be close to actual optimal values, which therefore improved backtracking performance. Moreover, when j ⫽ 1 implying no jobs have been allocated, the value of EST from (2) can serve as a lower bound of the actual optimum value.

Example of backtracking.

begins with the job j ⫽ 1. When ␴k has been decided for all jobs k ⱕ j ⫺ 1, the domain D(␴j) of ␴j can be obtained from T[i] for i 僆 I. The algorithm then attempts to allocate every crane w 僆 D(␴j sequentially to job j. For each attempt, the corresponding time-allocation map sj is equal to T[␴j] in view of (1). Following this, T[i] is updated for all i ⱖ w, and a new enumeration is executed for job j ⫹ 1, unless j ⫹ 1 equals n ⫹ 1. If j equals n ⫹ 1, the current best schedule is updated and backtracking occurs. After all nodes are generated, an optimum schedule is generated. Figure 6 illustrates the backtracking process that schedules three jobs to two cranes. Note that only one attempt is made on job 3 on the right branch of the root, because T[1] equals to T[2] at that node. 3.3.

Pruning Conditions

Suppose crane allocations have been determined for jobs 1, 2, . . . , j ⫺ 1. Before enumerating cranes for ␴j, it is useful to estimate lower bounds (EST) for the latest completion times. If a lower bound is not less than the current smallest objective value (Cbest), any attempt to find ␴j is pruned. In [23], a simple lower bound was found as follows. By (1), every job q ⱖ j will not be started until T[m]. Hence, the latest completion time cannot be earlier than T[m] ⫹ MAX[j], where MAX[j] for j 僆 J denotes the longest processing time among jobs equal to or to right of j. We provide a more refined lower bound here. As shown in Figure 7, let RDT ⫽ ⌺ni⫽1 (T[1] ⫺ T[i]) represent the total number of free time slots of the m cranes before the current latest completion time T[1] by which jobs 1, 2, . . . , j ⫺ 1 n are processed. Let LEFT[j] ⫽ ⌺k⫽j Pk denote the total processing time of remaining jobs j, j ⫹ 1, . . . , n. Therefore, in order to complete all remaining n ⫺ j ⫹ 1 jobs, if LEFT[j] ⬎ RDT, there is at least one crane that cannot stop until time T[1] ⫹(LEFT[j] ⫺ RDT)/min{m, n ⫺ j ⫹ 1}. The lower bound estimation function can therefore be defined by



T关m兴 ⫹ MAX关j兴, LEFT[j]⫺RDT EST ⫽ max T关1兴 ⫹ min 0, min兵m,n ⫺ j ⫹ 1其



Naval Research Logistics DOI 10.1002/nav

冎冎

.

4.

HEURISTICS

The exact algorithm given in Section 3 increases exponentially in time when the number of cranes increases. To guarantee performance in practice, simple heuristics have been proposed. In [23], an earliest-fit scheduling policy, denoted EF, which allocates the earliest free crane to job 1, job 2, . . . , and job n sequentially, is used. If the earliest free crane is not unique, the leftmost crane is chosen. However, the EF policy cannot guarantee a constant approximation factor in the worst case. For instance, consider m cranes and m2 jobs. For 0 ⱕ a ⱕ m ⫺ 1 and 1 ⱕ b ⱕ m, the processing time of job am ⫹ b is Pam ⫹ b, which is 1 if b ⬍ m and m if b ⫽ m. It is easy to see that EF produces a schedule completed in m2 time, with minimum completion of 2m ⫺ 1. Hence, the approximation factor here is at least as large as m/2, which can be arbitrarily large when the number of cranes increase. (See Figure 8.) In view of this, a best-fit scheduling policy (BF) is constructed motivated by the backtracking scheme of Section 3. The BF policy allocates cranes to job j, for j ⫽ 1, 2, . . . , n sequentially, where the

(2) Figure 7. Pruning.

Lim, Rodrigues, and Xu: m-Parallel Crane Scheduling Problem

121

Figure 8. An instance for EF policy.

best crane is chosen for j to minimize the estimation function (2). If more than one crane minimizes this function, the leftmost one is chosen. Although no constant approximation factor has been proven for BF, experimental results show that its performance is much better than EF. However, neither BF nor EF can be shown to have a constant approximation ratio. Recall that a ␳-approximation algorithm produces a schedule whose latest completion time is at most ␳ times the optimal solution in polynomial time, where ␳ is called the approximation ratio [20]. For the crane scheduling problem, three 2-approximation algorithms were given in [15]. The idea behind these approximations is found in algorithms available for parallel machine scheduling problems [7]. Although all three algorithms admit the same approximation factor of two, they performed differently in the experiments and varied in difficulty in implementation. For completeness, the best of the three is given here. This algorithm, denoted APPX, uses a dynamic programming approach. Consider a job sequence, S ⫽ {a, a ⫹ 1, . . . , b ⫺ 1, b}, for c cranes to process. Let k denote the division point of two job subsequences given by S1 ⫽ {a, a ⫹ 1, . . . , k} and S2 ⫽ {k ⫹ 1, k ⫹ 2, . . . , b}. There are two ways to process jobs in S1 and S2: (i) process jobs in S2 after all jobs in S1 are completed; (ii) process jobs in S1 by the leftmost p cranes and jobs in S2 by the rightmost c ⫺ p cranes, independently. It is easy to verify that both methods do not violate the non-crossing constraint. By restricting ourselves to processing jobs by the above methods, a dynamic programming algorithm to obtain optimum division point that minimizes the latest completion time can be developed. Let B [c, a, b] denote the minimum latest completion time found by dividing the job sequence {a, a ⫹ 1, . . . , b ⫺ 1, b} among c cranes. Dynamic programming equations can be given as follows. Initially, set B[1, a, b] ⫽ T[a, b], for 1 ⱕ c ⱕ m, 1 ⱕ a ⱕ b ⱕ n. When c ⱖ 2, for 1 ⱕ c ⱕ m, 1 ⱕ a ⱕ b ⱕ n,

B关c,a,b兴



minaⱕk⬍b B关c,a,k兴 ⫹ B关c,k ⫹ 1,b兴, ⫽ min min max兵B关p,a,k兴,B关c ⫺ p,k ⫹ 1,b兴其 , 1ⱕp⬍c,aⱕkⱕb (3) where T[a, b] ⫽ ⌺bj⫽a Pj denotes the total processing time of jobs a, a ⫹ 1, . . . , b. The time complexity here is O(m2n3). To obtain the approximation ratio, let OPT denote the optimum latest completion time, and consider the following division of the job sequence. Let AVG denote the average processing time of the n jobs. Allocate crane 1 to process 1 job 1, job 2, . . . , until job j1 sequentially, where ⌺jj⫽1 Pj ⱖ j1⫺1 AVG ⬎ ⌺j⫽1 Pj. In the same manner, for 2 ⱕ i ⱕ m ⫺ 1, allocate crane i to process job ji ⫺ 1 ⫹ 1, job ji ⫺ 1 ⫹ 2, . . . , ji ji⫺1 job ji sequentially, where ⌺j⫽j Pj ⱖ AVG ⬎ ⌺j⫽j Pj. The i i remaining (n ⫺ jm ⫺ 1) jobs, from jm ⫺ 1 ⫹ 1 to n, are processed by the last crane m. For each crane i ⱕ m ⫺ 1, the completion time is at most as large as AVG ⫹ Pji ⱕ 2OPT. For the last crane m, the completion time is at most as large as AVG, which is not more than OPT. The division of the job sequence therefore leads to a schedule whose latest completion time is no more than two times the optimum. Since the division provided by dynamic programming must be better, APPX must at least have an approximation of 2. We note here that schedules obtained using this approach require less movement for cranes compared with other heuristics, which allows this method to be better suited to applications. 5.

SIMULATED ANNEALING

Although simple heuristics were developed, experiments show that solutions obtained using these deviated significantly from optimal solutions. To improve on solutions, a metaheuristic approach can be used. In [23], a simulated annealing algorithm is used that required both crane-and time-allocation searches. Here, Theorem 2 can be exploited so that only crane allocations need to be determined. A simulated annealing (see, e.g., [2,11]) algorithm is conNaval Research Logistics DOI 10.1002/nav

122

Naval Research Logistics, Vol. 54 (2007)

structed to solve the problem, which can then be compared with [23]. In the algorithm, a stochastic method is used to generate neighborhoods. 5.1.

Framework

In using simulated annealing (SA), we represent solutions using only crane-allocation maps ␴ ⫽ 具␴1, ␴2, . . . , ␴m典. As shown in Algorithm 3, SA is used beginning with an initial ␴ found from the earliest-fit policy, which assigns the earliest free crane to jobs 1, 2, . . . , n, sequentially. Then, to improve ␴, a new schedule ␴⬘ is generated in a neighborhood of ␴ where a move from ␴ to ␴⬘ is accepted with a probability p ⫽ exp(⫺⌬/T), where ⌬ denotes the difference between the cost of ␴⬘ and ␴, and T is the temperature. The initial value T0 is decreased exponentially by a cooling factor r, and, for a given T, a solution ␴ can be moved at most a given number, M, times. The best schedule obtained as T approaches a predetermined termination value, Te, is taken as a solution. Different from typical implementations of SA, a stochastic mechanism is used to generate a new neighborhood ␴⬘ from a neighborhood of ␴. To do this, a subset W(␴) 債 I using random factors is first selected. Then, by reallocating cranes to jobs in W(␴), a new schedule is produced. Iterating the selection and reallocating for a constant number, Q, of times, the new schedule with the minimum latest completion time is chosen to be ␴⬘. The selection of W(␴) from I has Algorithm 3 Simulated Annealing (SA) 1: Obtain an initial solution ␴ by the Earliest-Fit (EF) policy and let ␴best 4 ␴; 2: Set the initial annealing temperature T 4 T0; 3: while T is higher than the terminating one Te do 4: for L ⫽ 1 to M do 5: Generate a new solution ␴⬘ within the neighborhood of ␴ by Algorithm 4, and let ⌬ denote the differential cost between ␴⬘ and ␴; 6: If ␴⬘ has a smaller cost than ␴best, then ␴best 4 ␴⬘; 7: Decide whether to perform the move from ␴ to ␴⬘, with the probability, p ⫽ exp(⫺⌬/T), which determines the acceptance rate. If the move is performed, let ␴ 4 ␴⬘; 8: Decrease the annealing temperature T by a cooling factor r, i.e. T 4 rT; 9: end for 10: end while 11: Return ␴best.

two objectives. One is to increase the chance of reducing the latest completion time, while the other is to introduce random factors. To achieve this, we define a job j 僆 J to be a key job under ␴, if and only if ●

job j is completed exactly at C␴, where C␴ is the latest completion time, or

Naval Research Logistics DOI 10.1002/nav

Figure 9. Example of key jobs.



there exists a j⬘ 僆 J to the right of j with ␴j ⱕ ␴j that is started exactly when job j is completed.

Figure 9 gives an example of this, where jobs 4, 3, and 2 are the key jobs in the schedule. It is easy to see that key jobs constrain the latest completion time; therefore, by reallocating some of these jobs, the latest completion time can be reduced. Each job j 僆 J is selected to be allocated to W(␴) with probability p1 if j 僆 K and with probability 1 ⫺ p2 otherwise, where p1 determines the probability of reallocating key jobs. This is summarized in Algorithm 4. Algorithm 4 Generating ␴⬘ from ␴ 1: Calculate the set K of key jobs; 2: for P ⫽ 1 to Q do 3: Construct S from K with parameter p1 and p2; 4: For each job j 僆 J ⫺ K, let ␶(j) 4 ␴j; 5: For each job j 僆 K, ␶(j) is determined by a best-fit policy. 6: If the latest completion time of schedule ␶ is smaller than that of ␴⬘, update ␴⬘ by ␶. 7: end for 8: Return ␴⬘;

5.2.

Reallocation by Best Fit

Given W (␴) ⫽ {i1, i2, . . . , iw}, ordered from left to right, reallocate i1, i2, . . . , iw sequentially by a best-fit policy. The best-fit policy, extended from the approximation policy BF given in Section 4, reallocates jobs {i1, i2, . . . , iw} arbitrarily and does not restrict them to be contiguous with job 1. Suppose i1, i2, . . . , ik⫺1 have been reallocated and job ik needs to be reallocated. Let LEFT[k] denote the total processing time of the remaining jobs from ik ⫹ 1 to iw. A lower estimate of the best possible minimum latest completion time (EST[i]) is found for every attempt at allocating crane i 僆 I to job ik. The crane i 僆 I with the smallest value of EST[i] is allocated to job ik. If two cranes have the same estimate value, the leftmost one is preferred. EST[i] is calculated as follows. Let C[i] denote the latest completion time to process jobs 1,2, . . . , j if we allocate crane i to job j. Compute RDT[i], the total idle time slots of all cranes

Lim, Rodrigues, and Xu: m-Parallel Crane Scheduling Problem

before C[i] after the completion of jk for cranes left of and including i. For similar reasons provided in deriving (2), if LEFT[k] is greater than RDT[i] at least one crane will stop after C[i] ⫹ min {0, (LEFT[k] ⫺ RDT[i])/(min{m, n ⫺ k})}. This leads to the estimate to be given by



EST ⫽ C ⫹ min 0,



LEFT关k兴 ⫺ RDT . min兵m,n ⫺ k其

(4)

As mentioned, a SA algorithm was applied in [23] to solve the crane scheduling problem with limited success. The authors used a static neighborhood that reallocates all key jobs by an earliest-fit policy. Here, we use a best-fit policy instead of earliest-fit since it provides better results, as we will see in Section 7. 6.

EXPERIMENTS 6.1.

Design

Extensive experiments were conducted using a Pentium IV 2.40GHz machine with programs coded in C⫹⫹ and ILOG CPLEX 8.0 was used to solve integer programming models. The following notation denotes the algorithms tested. EF: approximation by an earliest-fit policy BF: approximation by a best-fit policy APPX: the 2-approximation algorithm BT: the backtracking algorithm 2 SA: the simulated annealing algorithm 3 MIP: CPLEX 8.0 solver used on the MIP In addition, we take BT-H to denote the heuristic BT when the number of nodes is restricted to be less than a constant Nnode, where Nnode is equal to 2 ⫻ 108 if m ⱕ 10 and equal to 2 ⫻ 109 if m ⬎ 10. The choice of Nnode is to allocate more computational efforts for larger scale cases so that it is fair for BT-H to be compared with other algorithms. For comparison, branch-and-bound and the simulated annealing algorithm from [23], denoted by ZL-BB and ZL-SA, respectively, were used. Both these algorithms do not reduce the search space and the number of decision variables. Four sets of test instances were randomly generated in [23] since there were no real data. These test sets, denoted S1, S2, S3, and S4, can be used as benchmarks for the experiments. Of these, S1 and S2 include small-size instances, while S3 includes medium-size instances and were

123

reported to be solved optimally in [23]. We see later that the backtracking algorithm (BT) solves these three sets optimally but much more quickly. The last set, S4, which contains large-size instances, is therefore used in the experiments. This set contains instance which are difficult, since neither the integer programming model nor the branch-and-bound solver proposed in [23] was able to provide good heuristic solutions within reasonable times. Even the new integer programming model (MIP) was not able to handle instances in S4 well. For example, consider 10 large-scale instances in S4 with m ⫽ 20 and n ⫽ 100. When MIP is used to solve these, the best solutions, obtained after an hour, deviated from lower bounds estimated by (2) by 14.18 to 25.26%, averaging 18.05% with a standard deviation of 3.58%. Moreover, the simulated annealing algorithm proposed in [23] did not solve instances in S4 well, especially when the number of cranes was large with deviations from lower bounds close to 10% even after running for an hour. However, with Theorem 2, BT and the new simulated annealing algorithm (SA) provided much improved heuristic solutions in shorter running times. Significantly, all instances in S4 were solved by SA with near optimal solutions and with deviations from lower bounds less than 2% within 20 minutes. Before providing experimental results, we explain how the parameters for the SA are determined. To limit the number of parameters tuned in the SA algorithm, the basic parameters were given values similar to those used in [23]. The initial and the terminating temperatures were T0 ⫽ 100 and Te ⫽ 1, respectively; the cooling factor r ⫽ 0.9; and the maximum number of moves M ⫽ 50. To determine an effective method for generating stochastic neighborhoods, a preliminary experiment was conducted to decide the number of loops, Q, to be used, and the probability, p1, of reallocating key jobs. Ten large-scale instances were picked from S4 with m ⫽ 20 and n ⫽ 100. Table 1 shows the CPU seconds and the average deviation (gap) ␦ of the lower bound as a percentage of the lower bound estimated by (2), when p1 is chosen from 0.1 to 0.9 and Q from 100 to 900. From Table 1, it can be seen that p1 ⫽ 60% and Q ⫽ 900 gives the minimum average deviation (1.45%) in the SA algorithm, but requires long running times (greater than 750 seconds on average). When the time is limited to be less than 300 seconds, p1 ⫽ 80% and Q ⫽ 500 provide the best results with an average deviation of 1.61%, only 0.2% higher than the minimum, but require less than 280 seconds. In a trade off between solution quality and running time, the following two pairs of values for p1 and Q were used in testing the algorithm. Here SA1 and SA2 denote the SA algorithm with the respective parameters shown. ● ●

SA1: SA with p1 ⫽ 80% and Q ⫽ 500; SA2: SA with p1 ⫽ 60% and Q ⫽ 900. Naval Research Logistics DOI 10.1002/nav

124

Naval Research Logistics, Vol. 54 (2007) Table 1. Preliminary testing for parameters, p1 and Q. Q 100

300

500

700

900

p1 (%)

␦(%)

CPU

␦(%)

CPU

␦(%)

CPU

␦(%)

CPU

␦(%)

CPU

10 20 30 40 50 60 70 80 90

4.11 2.88 2.74 2.50 2.40 2.18 2.07 2.30 12.51

124.95 124.86 120.41 111.72 100.40 84.21 68.88 54.24 34.88

3.65 2.86 2.64 2.40 1.99 1.86 1.75 2.09 5.06

372.09 373.34 358.35 331.60 297.07 256.64 211.99 158.29 114.37

3.45 2.80 2.72 2.22 2.14 2.14 1.57 1.61 3.34

618.34 612.40 588.06 552.39 500.11 435.47 353.18 279.18 212.57

3.65 2.68 2.46 2.32 1.93 1.51 1.75 2.00 4.01

868.66 869.82 830.62 774.03 690.90 607.76 479.05 439.07 307.83

3.15 2.72 2.54 2.14 2.11 1.45 1.73 1.87 4.59

1152.59 1142.01 1096.86 1014.98 904.15 776.14 640.90 532.51 411.80

6.2. Results Table 2 gives results for the S4 set. To measure the performance of each algorithm, the deviation ␦ was calculated using the lower bound estimated by (2) and the running times (in seconds) recorded. As shown in Table 2, instances in S4 have 24 different combinations of the number of cranes and the number of jobs, with 10 instances each. Further, to test the search capacity of the BT algorithm, an additional set of instances was generated as suggested

in [23]. The value m is varied from 3 to 5 and n from 5m, 6m, . . . , 9m to 10m. For each m, n, 10 instances were generated, where the job processing times of each job were randomly generated integers between 10 and 50. These instances were also used to test the performance of the CPLEX solver on the MIP model. Table 3 shows the number of the times (#OPT) BT obtains an optimum after searching 2 ⫻ 108 nodes and the number of times (#OPT) the CPLEX solver, when applied to the MIP model, finds an

Table 2. Experimental results for S4.

␦ (%) m 5

10

15

20

BT-H

SA1

SA2

ZL-SA

n

EF

BF

APPX

␦(%)

CPU

␦(%)

CPU

␦(%)

CPU

␦(%)

CPU

25 30 35 40 45 50 Mean 50 60 70 80 90 100 Mean 75 90 105 120 135 150 Mean 100 120 140 160 180 200 Mean

61.87 59.14 57.97 60.47 51.33 58.60 58.23 82.78 75.56 84.75 87.88 87.19 82.84 83.50 109.65 109.79 106.11 106.30 101.17 103.30 106.05 89.63 121.73 107.76 104.61 118.50 110.57 108.80

14.70 8.42 9.92 6.58 6.13 4.83 8.43 19.15 14.83 12.78 12.94 8.53 10.34 13.10 26.26 21.45 17.00 15.38 14.93 12.49 17.92 34.30 27.54 21.09 20.02 17.95 15.18 22.68

5.47 3.65 3.29 2.36 2.24 1.95 3.16 5.41 4.57 3.58 2.99 2.77 2.16 3.58 6.07 4.54 3.62 3.36 2.71 2.16 3.74 5.92 4.63 3.67 3.27 2.75 2.42 3.78

0.29 0.02 0.29 0.41 1.00 1.07 0.51 1.46 2.57 2.47 1.75 1.56 1.76 1.93 2.83 2.90 2.40 2.33 2.12 1.70 2.38 3.76 3.00 2.78 2.35 2.00 2.06 2.66

0.43 6.05 88.08 118.97 116.40 114.15 74.01 205.60 178.08 157.60 161.77 161.87 138.95 167.31 2110.17 2089.34 1570.52 1649.46 1429.83 1555.93 1734.21 2018.93 1969.85 1711.73 1772.12 1683.48 1554.48 1785.10

0.74 0.37 0.13 0.01 0.01 0.00 0.21 1.25 0.70 0.24 0.35 0.22 0.17 0.49 1.62 0.50 0.46 0.43 0.30 0.27 0.60 1.61 1.12 0.50 0.54 0.50 0.46 0.79

26.85 37.74 37.04 53.61 63.92 79.96 49.85 90.46 104.25 153.50 174.98 223.29 253.82 166.72 197.43 251.38 327.23 397.23 489.26 605.19 377.95 279.18 443.33 587.32 756.73 947.70 1102.90 686.19

0.68 0.17 0.13 0.02 0.03 0.01 0.18 0.75 0.50 0.33 0.31 0.26 0.13 0.38 1.29 0.67 0.53 0.59 0.42 0.35 0.64 1.45 1.00 0.79 0.75 0.63 0.55 0.86

50.24 69.83 84.96 107.62 129.15 156.71 99.75 197.89 253.39 339.27 413.36 517.31 638.31 393.25 413.91 589.31 788.54 973.24 1196.95 1443.86 900.97 776.14 1108.12 1439.82 1831.31 2295.97 2746.83 1699.70

1.63 0.92 0.72 0.44 0.54 0.52 0.80 3.03 2.10 2.10 1.70 1.75 1.33 2.00 6.27 6.88 4.05 3.71 2.81 1.74 4.24 16.47 12.67 7.18 7.35 4.86 4.21 8.79

70.83 101.53 147.06 200.77 265.35 340.48 187.67 318.53 499.53 700.92 929.21 1291.23 1661.65 900.18 828.44 1218.66 1762.01 2574.11 3423.90 4308.03 2352.53 1804.63 2796.65 3642.35 4930.64 6395.42 8392.81 4660.42

Naval Research Logistics DOI 10.1002/nav

Lim, Rodrigues, and Xu: m-Parallel Crane Scheduling Problem Table 3. Performance of exact algorithms using instances of different sizes. MIP

BT

m⫻n

#OPT

CPU

#OPT

CPU

3 ⫻ 15 3 ⫻ 18 3 ⫻ 21 3 ⫻ 24 3 ⫻ 27 3 ⫻ 30 4 ⫻ 20 4 ⫻ 24 4 ⫻ 28 4 ⫻ 32 4 ⫻ 36 4 ⫻ 40 5 ⫻ 25 5 ⫻ 30 5 ⫻ 35 5 ⫻ 40 5 ⫻ 45 5 ⫻ 50

10 10 10 9 9 8 5 3 1 0 0 0 0 0 0 0 0 0

1.72 28.28 41.2 120.6 95.17 154.7 241.77 281.52 279.45 300.07 300.08 300.08 300.07 300.06 300.08 300.08 300.11 300.08

10 10 10 10 10 10 10 10 10 10 8 4 10 10 6 1 0 0

0.00 0.00 0.01 0.01 0.07 0.03 0.01 0.14 1.36 9.40 35.09 70.03 0.43 6.05 88.08 118.96 116.40 114.15

optimum for all 10 instances of the same size within 300 seconds. 7.

DISCUSSION ON PERFORMANCE 7.1.

Backtracking

By restricting the number of search nodes to be less than 2 ⫻ 108 and taking current best solutions in the backtracking heuristic, we find from Table 2 that the deviations of solutions from the BT-H algorithm are small (less than 4%) and increased slowly as the number of cranes increased. Table 3 shows that the BT algorithm is able to find the optimum when m ⫽ 4 and n ⫽ 40. In contrast, [23] reported that ZL-BB requires longer times (greater than 50 minutes) even for smaller instances with m ⫽ 5 and n ⫽ 15. The improvement can be attributed to the following. First, the ZL-BB algorithm enumerates not only crane allocations but also the order in which they are processed. This causes the size of the search space to be O (n!mn). In the method used here, the space is reduced to O(mn) since, in view of Theorem 2, only crane allocations need to be enumerated. Second, search node generation and estimation functions accelerated backtracking. For example, with m ⫽ 5 and n ⫽ 50 in Table 3, while noting that 2 ⫻ 108 nodes are searched in total, a node is generated in less than 10⫺6 seconds on average. The performance of the backtracking scheme and the CPLEX solver on the MIP model was compared with the branch-and-bound algorithm (ZL-BB) provided in [23]. The running time for the relatively undemanding test set S3 is given in Table 4. Optimum solutions were found for all

125

Table 4. Comparison of the time performance between search schemes using S3. No.

MIP

BT

ZL-BB

1 2 3 4 5 6 7 8 9 10

0.24 0.09 0.17 0.16 0.14 1.11 0.69 0.33 0.63 0.66

0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00

272.31 250.54 109.07 174.17 1728.57 2132.06 939.26 1010.57 14134.29 3390.25

cases by BT almost instantaneously and in very short times by CPLEX, while ZL-BB required relatively longer times (in the order of hundreds of seconds). 7.2.

Heuristics

Figure 10 shows the difference in performance between the three heuristics given in Section 4 in terms of the average deviation for instances with different numbers of cranes. The EF policy produced the worst schedules compared with BF and APPX. Since BF does much better than EF, it is used in the SA algorithm. From Table 2, it can be seen that APPX performed better than the other algorithms, with deviations less than 6.5%. In addition, the deviations have small variance ranging from 3.16 to 3.78 as the number of cranes increases. The performance of APPX far exceeds the proven 2-approximation factor. Moreover, schedules provided by APPX exhibited a regular form that required little crane movements. 7.3.

Simulated Annealing

The simulated annealing algorithms developed here were compared with the best approximation method APPX, the backtracking heuristics BT-H, and the simulated annealing

Figure 10. Comparison of performance among heuristics. Naval Research Logistics DOI 10.1002/nav

126

Naval Research Logistics, Vol. 54 (2007)

algorithm ZL-SA of [23]. Table 2 shows that the SA1 and SA2 provided superior solution quality for all instances, with deviations mostly within 2%. From Table 2, we see that SA1 provided better solutions than SA2 in most cases, i.e., 15 of 24 cases. Moreover, SA1 required much shorter running times than SA2 The performance of various algorithms is given in Figure 11, which plots the average deviations for different algorithms. When the number of cranes increases (say, by 5), the ZL-SA algorithm can be seen to deteriorate significantly (by more than 2%). In contrast, the SA algorithm exhibits stability where the deviation increases only marginally (by 0.2% on average). In addition, the SA algorithm performed significantly better in terms of the running time. Figure 12 shows that SA1 required much less time than ZL-SA of [23], even as it provided superior solutions. The advantage of the SA1 over the other algorithms is apparent when the number of cranes increases. From Table 2 it is clear that BT-H was not able to provide better solutions than SA1 even given longer times. In fact, for large cases, although BT-H is allowed to explore 10 times more nodes, the observations show that improvements are limited and less than 0.1%. In summary, the SA algorithm proposed in this paper performed much better than other algorithms. The improvements can be attributed to the reduction of search space and the use of the best-fit policy in neighborhood moves. Further, using stochastic neighborhoods provided a more effective method for generating new schedules when compared with simply reallocating key jobs. 8.

CONCLUSION

In this paper, we studied a m-parallel machine scheduling problem which incorporates a non-crossing spatial con-

Figure 12. Comparison of time performance between two simulated annealing algorithms.

straint. The problem is studied in the context of port crane scheduling and is applicable to other scheduling environments, for example, in automobile manufacturing where welding robots are used or in assembly lines where workers need to follow jobs through. Although a number of other practical constraints arise in applications, we focused on a basic space constraint—the non-crossing constraint—since it is a common restriction in environments where machines are required to move in parallel. This allowed us to study the model in depth and gain insight into problem structure and solution. In developing a solution, we showed that the problem can be decomposed. Based on this, a constraint programming model was solved using dynamic programming and backtracking exact algorithms. The dynamic programming approach guaranteed an approximation factor of 2 and provided solutions of good quality while the backtracking algorithm was able to provide exact solutions for average size problems. A simulated annealing heuristic solved the problem efficiently and can be used when the numbers of machines and jobs are of realistic sizes. APPENDIX A.

Proof for Theorem 1

Proof. We use a reduction from the following well-known NP-complete problem.

Figure 11. Comparison of performance of heuristics and simulated annealing algorithms. Naval Research Logistics DOI 10.1002/nav

Figure 13. Reduction from Partition.

Lim, Rodrigues, and Xu: m-Parallel Crane Scheduling Problem Partition [5]: Given a set X ⫽ {1, . . . , r} and a positive integer valued function g(i) for each i 僆 X such that ⌺i僆X g(i) ⫽ 2B, does there exist a subset X⬘ with ⌺i僆X⬘ g(i) ⫽ B? From an instance of Partition, consider the following instance of the crane scheduling problem with the crane number m ⱖ 2. As shown in Figure 13, let the job set be J ⫽ {1, 2, . . . , n} where n ⫽ r ⫹ m, and the crane set is P ⫽ {1, 2, . . . , m}. Let the processing times Pj be g(j ⫺ 1) if 2 ⱕ j ⱕ r ⫹ 1, B if j ⫽ 1 or r ⫹ 2, and 2B otherwise. We now prove that there exists a feasible schedule whose latest completion time is at most B if and only if a solution exists for an instance of Partition. On one hand, if Partition has a X⬘ 債 X with ⌺i僆X⬘ g(i) ⫽ B, then let J1 ⫽ {j兩j ⫺ 1 兩 X} and J2 ⫽ {2, 3, . . . , r ⫹ 1} ⫺ J1. Then, for both J1 and J2, the total processing time is B. We can let crane 1 and crane 2 complete jobs in J1 and job r ⫹ 2, respectively, in the time slot [0, B). Then, in [B, 2B), let cranes 1 and 2 complete job 1 and jobs of J2, respectively. We then let the (j ⫺ r)th crane complete any remaining jobs j, where r ⫹ 3 ⱕ j ⱕ m ⫹ r, in [0, 2B). It is easy to verify that such a schedule is feasible and has a latest completion time of at most 2B. On the other hand, if there is a feasible schedule whose latest completion time is at most 2B, then jobs, r ⫹ 3, r ⫹ 4, . . . , and r ⫹ m must be processed by m ⫺ 2 distinct cranes for the entire [0, 2B). Suppose a and b are two remaining cranes where a ⬍ b. These must complete the remaining r ⫹ 2 jobs by 2B, which is equal to their total processing time. Thus, both crane a and crane b cannot be idle. However, if crane a processes job (r ⫹ 2), crane b must be idle because of the spatial constraint, and similarly, if crane b processes the job 1, then crane a must be idle. So job 1 and job (r ⫹ 2) must be processed by a and b, respectively. Because both consume B time, the job sets processed by a lead to a solution X⬘ for Partition, where X⬘ ⫽ {j ⫺ 1兩the jth job is processed by a, where 2 ⱕ j ⱕ r ⫹ 1}. 䊐

ACKNOWLEDGMENTS The authors thank the associate editor and the anonymous referees for their suggestions, which have helped improve the presentation of the paper. REFERENCES [1] E.K. Bish, T.Y. Leong, C.L. Li, J.W.C. Ng, and D. SimchiLevi, Analysis of a new vehicle scheduling and location problem, Nav Res Logist 48(5) (2001), 363–385. [2] V. Cerny, A thermodynamical approach to the travelling salesman problem: An efficient simulation algorithm, J Optimiz Theor Appl 45 (1985), 41–51. [3] T.C.E. Cheng and C.C.S. Sin, A state of the art review of parallel machine scheduling research, Eur J Oper Res 47 (1990), 271–292. [4] C.F. Daganzo, The crane scheduling problem, Transport Res B 23(3) (1989), 159 –175. [5] M.R. Garey and D.S. Johnson, Computers and intractability: A guide to the theory of NP-completeness, Freeman, New York, 1983.

127

[6] Y. Ge and Y. Yih, Crane scheduling with time windows in circuit board production lines, Int J Prod Res 33(5) (1995), 1187–1189. [7] R.L. Graham, Bounds for certain multiprocessing anomalies, Bell Syst Tech J 45 (1966), 1563–1581. 1966 [8] A. Guinet, Scheduling sequence-dependent jobs on identical parallel machines to minimize completion time criteria, Int J Prod Res 31 (1993), 1579 –1594. [9] T.C. Hu, Parallel sequencing and assembly line problems, Oper Res 9 (1961), 841–948. [10] K.H. Kim and Y.M. Park, A crane scheduling method for port container terminals, Eur J Oper Res 156(3) (2004), 752–768. [11] S. Kirkpatrick, C.D. Gelatt, and M.P. Vecchi, Optimization by simulated annealing, Science 220(4598) (1983), 671– 680. [12] E. Kozan, Increasing the operational efficiency of container terminals in Australia, J Oper Res Soc 48 (1997), 151–161. [13] Y.H. Lee and M. Pinedo, Scheduling jobs on parallel machines with sequence-dependent setup times, Eur J Oper Res 100 (1997), 464 – 474. [14] A. Lim, B. Rodrigues, F. Xiao, and Y. Zhu, Crane scheduling with spatial constraints, Nav Res Logist 51(3) (2004), 386 – 406. (conference version appeared in Proceedings of the 14th IEEE International Conference on Tools with Artificial Intelligence, 2002) [15] A. Lim, B. Rodrigues, and Z. Xu, Approximation schemes for the crane scheduling problem. In Proceedings of the Ninth Scandinavian Workshop on Algorithm Theory (SWAT), 2004. [16] H. Matsuo, J.S. Shang, and R.S. Sullivan, A knowledgebased system for stacker crane control in a manufacturing environment, IEEE Trans Syst Man Cybernet 19(5) (1989), 932–945. [17] R. McNaugton, Scheduling with deadlines and loss functions, Manage Sci 6 (1959), 1–12. [18] R.I. Peterkofsky and C.F. Daganzo, A branch and bound solution method for the crane scheduling problem, Transport Res 24B (1990), 159 –172. [19] D. Steenken, S. Voss, and R. Stahlbock, Container terminal operation and operations research — A classification and literature review, OR Spectr 26 (2004), 3– 49. [20] V.V. Vazirani, Approximation algorithms, Springer-Verlag, 2001. [21] F. Yalaoui and C. Chu, An efficient heuristic approach for parallel machine scheduling with job splitting and sequencedependent setup times, IIE Trans 35 (2003), 183–190. [22] C. Zhang, Y.W. Wan, J. Liu, and R.J. Linn, Dynamic crane deployment in container storage yards, Transport Res B, 36 (2002), 537–555. [23] Y. Zhu and A. Lim, Crane scheduling with non-crossing constraints, J Oper Res Soc published online in advance, Dec. 2005. (conference version appeared in Proceedings of the Eighth International Symposium on Artificial Intelligence and Mathematics, 2003)

Naval Research Logistics DOI 10.1002/nav