New bounds and algorithms for the transshipment yard scheduling ...

J Sched DOI 10.1007/s10951-010-0200-2

New bounds and algorithms for the transshipment yard scheduling problem Nils Boysen · Florian Jaehn · Erwin Pesch

© Springer Science+Business Media, LLC 2010

Abstract In a modern rail–rail transshipment yard huge gantry cranes transship containers between different freight trains, so that hub-and-spoke railway systems are enabled. In this context, we consider the transshipment yard scheduling problem (TYSP) where trains have to be assigned to bundles, which jointly enter and leave the yard. The objective is to minimize split moves and revisits. Split moves appear whenever containers have to be exchanged between trains of different bundles, whereas revisits occur if a train has to enter the yard twice, because some container dedicated to this train was not available during its first visit. We extend the basic TYSP, so that additional real-world requirements of modern rail–rail yards, e.g., the one currently constructed in Hannover-Lehrte, are considered. We provide complexity proofs for different problem settings and present several heuristic procedures as well as one exact algorithm. The paper concludes with computational results showing the efficiency of the proposed algorithms. Keywords Railway systems · Transshipment yard · Train scheduling · Branch-and-bound · Ejection chain

N. Boysen Lehrstuhl für Allgemeine Betriebswirtschaftslehre/Operations Management, Friedrich-Schiller-Universität Jena, Carl-Zeiß-Straße 3, 07743 Jena, Germany e-mail: [email protected] F. Jaehn · E. Pesch Institut für Wirtschaftsinformatik, Universität Siegen, Hölderlinstraße 3, 57068 Siegen, Germany F. Jaehn e-mail: [email protected] E. Pesch () e-mail: [email protected]

1 Introduction With increasing traffic volume especially in the big transit nations in the center of Europe and ongoing environmental pollution the European Union (EU) aims at transferring freight traffic from road to rail (EU 2007). One starting-point is to enable hub-and-spoke railway systems, so that economies in transportation can be realized like it is exemplified by other modes of transport, i.e., ship, truck and airplane, since many years. For this purpose the EU increasingly subsidizes investment into rail–rail transshipment yards, which allow for a rapid consolidation of different freight trains. For instance, in Germany currently a highly automated transshipment yard in Hannover-Lehrte (Megahub) is constructed. Such a modern rail–rail transshipment yard consists of multiple parallel railway tracks, where successive bundles (one train per track) of freight trains are processed. Container transshipment among trains is conducted by multiple rail-borne gantry cranes spanning the railway tracks. To avoid crane interferences and to enable a container exchange between different bundles, an additional sorting system is applied, where automated guided vehicles (Bostel and Dejax 1998) or some rail-mounted vehicles (Alicke 2002) move and preposition containers. To allow containers overtaking each other within the sorter a typical system consists of separate moving and buffer lanes (see Rotter 2004). Figure 1 depicts a schematic representation of a transshipment yard. Clearly, a sophisticated operation of such complex systems assuring an efficient usage of resources, requires elaborate and computerized scheduling procedures. However, the overall scheduling task seems far too complicated to allow a simultaneous solution, so that a hierarchical decomposition of the overall problem is recommendable (Boysen and Fliedner 2010):

J Sched

train. Thus, when deciding on the service slot of a train it is to be ensured that all containers to be loaded on this train have already been delivered by trains assigned to the same or a preceding slot. If this is not possible, there are two general alternatives to cope with such a situation.

Fig. 1 Schematic representation of a rail–rail transshipment yard

(i) Schedule the succession of trains by assigning them to bundles (TYSP). (ii) Decide on the containers’ positions on trains. (iii) Determine crane areas. (iv) Decide on the trains’ vertical and horizontal parking positions. (v) Decide on the sequence of container moves per crane. This paper exclusively treats problem (i) and provides scheduling procedures to assign trains to service slots. The problem, which we label the transshipment yard scheduling problem (TYSP), can be characterized as follows: There is a given set I of trains, each of which has a predefined number of wagons and a certain load factor, defining the number of containers carried by this train. Each train is now to be assigned to a service slot t = 1, . . . , T of G simultaneously served trains. This assignment is restricted by the earliest available slot ei of train i (earliest arrival time) and its latest available slot li (latest departure time). A transshipment yard is typically operated in distinct so-called pulses (Bostel and Dejax 1998) or bundles (Alicke 2002; Rotter 2004) of trains, which means that G trains (one per track) are simultaneously served and jointly leave the system not before all container moves are processed, which are required for the respective bundle of trains. Then, another bundle of G trains enters the yard, while it is impossible for a train belonging to more than one bundle. Thus, for each train it is to be decided, in which of the successive t = 1, . . . , T service slots of size G it is to be served. This assignment decision faces two important peculiarities: Revisits/delayed containers Each train stopping at the transshipment yard carries a given set of containers, which depends on the number of wagons and a load factor. A given subset of these containers is already dedicated to the final destination of the train and, thus, remains untouched. The other part is to be unloaded at the yard to be either stacked on other trains or to leave the rail system by truck. Afterwards, vacant railway cars can be filled with other containers (for the trains destination) either delivered from the storage lanes of the sorting system or directly by another freight

1. Trains, which have not received all the containers dedicated to them, have to leave the yard, wait on holding tracks until all respective trains have been processed, and revisit the yard in a later slot. Obviously, revisits delay shipment completion and are to be reduced to a minimum. If a revisit is inevitable, it is a common policy to process it after all other trains have visited the yard at least once. This policy ensures that all containers dedicated to the revisiting train have arrived in the meantime and at most one revisit is required per train. 2. All trains leaving the yard after their first visit in all cases head to their next destination. This implies that there might remain some containers, which are not loaded onto their dedicated trains. These containers stay at the transshipment yard and are re-assigned to the next train heading to the same destination (usually on the next day). Clearly, such a delay of containers is undesirable, as they might arrive late at their customers and require space in the storage area. Furthermore, it has to be ensured that the next train has enough vacant rail waggons. However, this policy enables all trains to leave the yard on time (or needs to be applied if there are no holding tracks). Thus, delaying containers to the next day seems reasonable, whenever the length of a stay of trains is limited. This holds true, e.g., for the Megahub in Hannover-Lehrte, where trains arrive in the middle of the night and have to reach their final destinations before morning (see Rotter 2004). As a yard manager was to decide for one of both policies, we assume that either revisits or delayed containers are minimized (but not both). Split moves Picking and dropping of containers by gantry cranes is precision work and, thus, very time-consuming (typically only 20–25 moves per crane and hour can be processed, see Rotter 2004). If train i, which carries a container dedicated to another train j , is served in the same slot as train j , then, container handling can be conducted by a single crane move directly from train i to j . On the other hand, an assignment of train i to a prior slot than train j requires that the container is intermediately stocked in the sorter. The container movement is interrupted and two separated and time-consuming crane picks and drops are required, which we label as a split move. Hence, train scheduling aims at avoiding split moves to accelerate container handling.

J Sched

This paper provides train scheduling procedures, which cover both peculiarities, i.e., in addition to split moves either revisits or delayed containers are minimized. For this purpose the remainder of the paper is structured as follows. Section 2 summarizes existing literature on transshipment yards. In Sect. 3, a formal problem description is given and new complexity results as well as novel bounding arguments are presented. Novel algorithms for solving this problem are proposed in Sect. 4. These algorithms are computationally evaluated and compared to existing approaches in Sect. 5. Finally, Sect. 6 summarizes our findings and contains an outlook on future research.

2 Literature review Although there is a lot of attention paid to railway optimization (see, e.g., Cordeau et al. 1998) and intermodal transportation (see Crainic and Kim 2007) in general, literature on rail–rail transshipment yards is scarce. Current research on transshipment in rail systems mainly focuses on traditional shunting yards. In these conventional yards, scheduling trains and rearranging freight trains via shunting hills and a system of track switches is covered, e.g., by Blasum et al. (1999), Dahlhaus et al. (2000), He et al. (2000), Winter and Zimmermann (2000) and Freling et al. (2005). However, modern rail–rail transshipment yards, where container transshipment is conducted by gantry cranes without rearranging the railway cars by themselves (see Sect. 1), are an emerging technology in rail systems (see the surveys by Bontekoning et al. (2004) as well as Macharis and Bontekoning (2004)) and promise a more efficient transshipment. In-depth descriptions of structural properties and different operational policies employed in rail–rail transshipment yards are provided by Ballis and Golias (2002) as well as Rotter (2004). Meyer (1999) and Wiegmans et al. (2007) specifically address the design process of an optimal terminal layout. However, only very few research papers deal with the scheduling problems perpetually arising during the daily operations of a transshipment yard. According to the hierarchical decomposition scheme of the overall scheduling problem (see Sect. 1) Bostel and Dejax (1998) as well as Corry and Kozan (2008) treat problem (ii) and provide scheduling procedures to determine the optimal positions of containers on inbound and outbound trains so that crane moves at the yard are minimized. Crane areas (problem (iii)) for processing a given train bundle are determined by Boysen and Fliedner (2010) and Boysen et al. (2010b). Here, each crane is assigned a specific yard area, which is exclusively processed by the respective crane, so that the workload is equally shared among cranes. Problem (iv), the assignment of trains to tracks (parking of trains), can be solved as a quadratic assignment problem, which is shown by Alicke and Arnold (1998) and Kellner et al. (2010). Finally,

Alicke (2002) provides a scheduling procedure, which sequences the moves of gantry cranes (problem (v)). His approach is based on constraint programming. Related problems also occur within seaport container terminals (see, e.g., Zhu and Lim 2006; Moccia et al. 2006; Lim et al. 2007; Sammarra et al. 2007). Up to now, only Boysen et al. (2010a) treat the scheduling of trains to service slots (i). In that paper, a first problem formulation of TYSP, an exact and heuristic algorithm, and a test set have been presented. It is the basis of our paper at hand. The novelty of our paper can be summarized as follows. A different problem formulation is presented, which now includes the possibility of delaying containers. An issue, which has not been considered in any model found in literature, although it bears a high practical relevance (see Rotter 2004). A new, more general complexity proof is presented, showing that the problem remains NP-hard even if some parts of the objective are not considered. Finally, bounds are derived and with the help of these bounds, more efficient algorithms are developed. The efficiency of these algorithms is shown in a comprehensive computational study. Next, we present a detailed problem statement of how to schedule arrival and processing of trains within available service slots.

3 Problem statement 3.1 Mathematical program The basic decision of the transshipment yard scheduling problem (TYSP) is to assign each train i of a given train set I to a service slot t = 1, . . . , T . To each slot t at most G trains can be assigned, because G is the number of parallel railway tracks of the transshipment yard. Note that an assignment of trains to dedicated tracks is not part of TYSP (see Sect. 1), so that the assignment decision can be recorded by binary variables xit , which receives the value one, whenever train i is assigned to slot t (0, otherwise). The overall number T of slots required to process the given set of trains I amounts to: T =  |IG| . However to ease the description, w.l.o.g. we assume that: |I | = G · T , which can be easily ensured for any problem instance by inserting empty trains carrying no containers. Furthermore, there might be additional restrictions for feasible train-slot assignments. Every train i ∈ I has an earliest arrival time slot ei , 1 ≤ ei ≤ T , which restricts an assignment of i to a period t ≥ ei . A latest departure time slot li , ei ≤ li ≤ T , prohibits any assignments of i after period li . In real life application, it is more likely that there are exact arrival and departure times defined by the rail schedule than time slot restrictions. However, as the length of each service slot is to some extend predictable, exact arrival (departure)

J Sched

times can easily be transformed to earliest arrival (departure) time slots. It requires that the service slots are executed uninterruptedly. We may assume this as otherwise the problem could be decomposed. We consider two similar problem formulations only differing by the objective function. Firstly, the (original) TYSP aims at realizing two objectives: The number of revisits of trains (objective 1) and the number of split moves of containers (objective 3) are to be minimized. To operationalize the simultaneous optimization of both objectives we assume that a linear combination of the single objectives is to be minimized and weights α1 and α3 can be assigned to the objective. In this problem setting, delayed containers (objective 2) are not considered. Secondly, TYSP2 uses a similar objective in which the number of delayed containers (objective 2) and split moves (objective 3) are minimized whereas objective 1 is omitted. Again, we suppose that suited weights α2 and α3 already exist. Using the notation summarized in Table 1, TYSP consists of objective function (1) and constraints (3) to (6) and (8) for the relevant variables, whereas TYSP2 consists of objective function (2) and constraints (3), (4), (6), (7) and (8) for the relevant variables: (TYSP) Minimize   α1 yi + α3 zij · Aij

(1)

i∈I j ∈Li

i∈I

(TYSP2) Minimize   α2 wij · Aij + α3 zij · Aij i∈I j ∈Li

(2)

i∈I j ∈Li

subject to li 

3.2 Complexity and bounds xit = 1 ∀i ∈ I,

(3)

xit ≤ G ∀t = 1, . . . , T ,

(4)

t=ei

 i∈I T 

xit · t + yi · M ≥

t=1

T 

xj t · t

 T  T      xit · t − xj t · t  ≤ zij · M    t=1

T 

T 

t=1

∀i ∈ I ; j ∈ Li ,

(5)

∀i ∈ I ; j ∈ Li ,

(6)

∀i ∈ I ; j ∈ Li ,

(7)

t=1

t=1

xj t · t −

Objective function (1) minimizes a linear combination of objectives 1 (number of revisits) and 3 (number of split moves) weighted by α1 and α3 , respectively. Similarly, objective function (2) considers objectives 2 (number of delayed containers) and 3 (number of split moves). The number of revisits is calculated by summing binary variables yi , which record whether train i has to revisit (yi = 1) or not (yi = 0). The calculation of split moves relies on the observation, that once a train j carries a number Aij of containers dedicated to train i all of these Aij containers must be picked and dropped twice and, thus, require split moves, whenever trains i and j are not assigned to the same slot (zij = 1). The number of delayed containers and the number of split moves differ only in one point. Containers from a train j dedicated to a train i assigned to a later slot cause a split move, but not a delayed container. Thus, a container is delayed if Aij · zij > 0 and train i is assigned to an earlier slot than train j . Defining wij = zij if i’s slot is before j ’s, and zero otherwise, leads to the objective as presented in (2). Equalities (3) ensure that each train is assigned to exactly one slot in the range of its feasible slots. Constraints (4) force the number of trains per slot not to exceed the given number G of tracks. Constraints (5) force binary variable yi to receive the value 1, whenever a train j , which carries containers dedicated to train i, is assigned to a later slot than train i. In a similar fashion, constraints (6) ensure, that binary variables zij receive the value 1, whenever trains i and j are assigned to different slots (0, otherwise). Constraints (7) force wij to be 1, whenever the slot of j is later than the slot of i. Big integer M, applied in constraints (5) to (7), can be set to T − 1. Note that constraints (6) can be easily linearized, however, for conciseness we abstain from a detailed description.

xit · t ≤ wij · M

t=1

xit ; yi ; zij ; wij ∈ {0, 1} ∀i ∈ I ; t = 1, . . . , T ; j ∈ Li .

(8)

TYSP is NP-complete in the strong sense (see Boysen et al. 2010a). However, in the proposed proof it is essential that α1 and α3 are non-zero. In the following, we will show that TYSP remains strongly NP-complete, even if α1 or α3 (but not both) are zero. If S is a set and S  ⊆ S then S\S  consists of all elements of S that do not belong to S  . We will use reductions from Feedback Vertex/Arc Set (see Garey and Johnson 1979 and Tanaev et al. 1994, for a thorough introduction into the theory of computational complexity) and problem k-Partition of a graph (see Feo et al. 1992): Feedback Vertex Set An instance of the Feedback Vertex Set problem consists of a directed graph Γ = (V , A) with vertex set V and arc set A and a positive integer K ≤ |V |. Is there a subset V  ⊆ V with |V  | ≤ K such that V  contains at least one vertex from every directed cycle of Γ ?

J Sched Table 1 Notation

I

Set of trains (indices i and j ) with n := |I |

Li

Set of trains carrying containers dedicated to train i

T

Number of time slots for (un-)loading trains (index t)

G

Number of parallel tracks within transshipment yard

Aij

Number of containers train i receives from train j

ei

Earliest time slot train i may be assigned to

li

Latest time slot train i may be assigned to

M

Big integer (e.g., M = T − 1)

α1 , α2 , α3

Given weights for objectives 1, 2 and 3 with α1 , α2 , α3 ≥ 0

xit

Binary variable: 1, if train i is assigned to slot t; 0, otherwise

yi

Binary variable: 1, if train i has to revisit the yard; 0, otherwise

zij

Binary variable: 1, if trains i and j are served during different slots; 0, otherwise

wij

Binary variable: 1, if train i is served during a slot prior to the slot of train j ; 0, otherwise

k-Partition of a graph Consider a complete undirected graph Γ = (V , E) with vertex set V and edge set E and non-negative edge weights, and integers k, m, and λ such that |V | = k · m. Is there a partitioning of the vertices of Γ into k sets of m vertices each, such that the total weight of the edges having both endpoints in different sets is at most λ? The problem is NP-hard even if m = 3. Feedback Arc Set An instance of the Feedback Arc Set problem consists of a directed graph Γ = (V , A) with vertex set V and arc set A and a positive integer K ≤ |A|. Is there a subset A ⊆ A with |A | ≤ K such that A contains at least one arc from every directed cycle of Γ ? Theorem 3.1 (i) TYSP is NP-hard, even if α3 = 0 and G = 1 or if α1 = 0 and G is at least 3. (ii) TYSP2 is NP-hard, even if α3 = 0 and G = 1 or if α2 = 0 and G is at least 3. Proof (i) For a given instance I (FVS) of the Feedback Vertex Set problem we construct an instance I (TYSP) of TYSP: Define α1 = 1, α3 = 0 and G = 1. The set of trains I corresponds to the vertex set V of graph Γ and for each arc a ∈ A connecting vertex vj and vi the number Aij of containers (delivered from train j to train i) is a least 1 i.e., Aij > 0. Furthermore let ei = 1, li = T for all i ∈ I . We will show that I (FVS) has a solution with |V  | ≤ K if and only if there exists a train schedule for I (TYSP) with an objective value not exceeding K. If I (FVS) has a solution then the directed graph Γ  consisting of the vertex set V \V  , i.e. the vertices from V not belonging to V  , and of all induced arcs is acyclic. Thus an arc of Γ  is induced if it is an arc in Γ and its defining vertices belong to V \V  . Let I  be the set of trains corresponding to V  . Γ  may be topologically ordered where

the train represented by the ith vertex of the topological order is assigned to time slot t = i and any arc connecting vertex vj to vi in Γ  implies i > j . Thus, there are no revisits for the (reduced) train scheduling problem consisting of the trains I \I  , yi = 0 for all i ∈ I \I  , and the number of time slots needed to schedule all trains from I \I  is not more than T − K. As |I  | = |V  | ≤ K there is a solution of I (TYSP) with  slots, G = 1 and objective  at most T time function value i∈I \I  yi + i∈I  yi + 0 ≤ 0 + |V  | ≤ K. Consider a train schedule for I (TYSP) with an objective  value i∈I yi ≤ K. Let I  be the set of revisiting trains, i.e. i ∈ I  if yi = 1. Let V  be the set of verticesfrom I (FVS) corresponding to the set of trains in I  . As i∈I \I  yi = 0 the subgraph Γ  of Γ induced by the vertex set V \V  is acyclic. Thus, the set of vertices to be removed from Γ in order to obtain an acyclic subgraph is a subset of V  of size at most K. Consider an instance I (P ) of k-partition of a graph. Define an instance I (TYSP) as follows: α1 := 0, α3 := 1 and ei = 1, li = T for all i ∈ I . Moreover for each vertex pair vi and vj of I (P ) there are two opposite directed arcs (i, j ) and (j, i) in a I (TYSP) representing graph (trains i and j exchange containers) with arc weights Aij = Aj i of the weight of the edge connecting i and j in I (P ). Additionally define T := k and G := m. As zij = 1 if and only if trains i and j are assigned to different  time slots, we obtain a solution to I (TYSP) with i∈I j ∈Li zij · Aij ≤ 2 · λ if and only if there is a k-partition of Γ into k = T sets of m = G vertices such that the total weight of the edges having both endpoints in different sets is at most λ where λ is a nonnegative integer. (ii) We only need to prove the first part. For a given instance I (FAS) of the Feedback Arc Set problem we construct an instance I (TYSP2) of TYSP2: Define α2 = 1, α3 = 0 and G = 1. The set of trains I corresponds to the vertex set V of graph Γ and for each arc (vj , vi ) ∈ A connecting vertex vj and vi the number Aij of containers (delivered from train j to train i) is equal to 1. Furthermore let

J Sched

ei = 1, li = T for all i ∈ I . We will show that I (FAS) has a solution with |A | ≤ K if and only if there exists a train schedule for I (TYSP2) with an objective value not exceeding K. If I (FAS) has a solution then the directed graph Γ  consisting of the arc set A\A , i.e. the arcs from A not belonging to A , is acyclic. Let Li ⊆ Li ,i ∈ I , be the set of trains j such that Aij = 1 and (vj , vi ) ∈ A . Γ  may be topologically ordered where the train represented by the ith vertex of the topological order is assigned to time slot t = i and any arc connecting vertex vj to vi in Γ  implies i > j . Thus, there are no revisits and therefore no delayed containers for the (reduced) train scheduling problem consisting of the trains I , wij = 0 for all containers corresponding to arcs (vj , vi ) ∈ A\A . As |A | ≤ K there is a solution of I (TYSP) with atmostT time slots, G = 1and  objective function value i∈I j ∈Li \L wij · Aij + i∈I j ∈L wij · Aij + i i   0 = i∈I j ∈L wij · Aij ≤ |A | ≤ K. i Consider a train schedule for I (TYSP) with an objective value of at most K. Let Li be the set of trains with delayed containers dedicated to i, i.e. j ∈ Li if wij = 1. Let A be the set of arcs (vj , vi ) from I (FAS) corresponding to the  set of train pairs j, i where j ∈ Li for all i ∈ I . As   i∈I j ∈Li \Li wij · Aij = 0 the subgraph Γ of Γ consist ing of the vertex set V and the arc set A\A is acyclic. Thus, the set of arcs to be removed from Γ in order to obtain an acyclic subgraph is a subset of A of size at most K.  For α1 = 0 and G = 2, TYSP is equivalent to maximum weight perfect matching, for which an O(T 3 ) time algorithm exists (see Papadimitriou and Steiglitz 1982). The theorem shows that TYSP and TYSP2 remain hard to solve, even if only one objective is considered. This is a relevant result for practical applications, as some transshipment yards (almost) exclusively try to minimize the number of revisits or the number of delayed containers. In order to derive efficient algorithms for solving TYSP and TYSP2, let us record some more facts. Theorem 3.2 Given an instance of TYSP. A lower bound for the number of revisits (objective 1) is given by   max |It | − G · (T − t) t∈{1,...,T −1}

with It := {i ∈ I | |Li | ≥ t · G}. Proof Obviously, it is sufficient to show that |It | − G · (T − t) is a lower bound for any t = 1, . . . , T − 1. It contains all trains, which receive containers from at least t · G other trains. Thus, each element of It has to be assigned to slot t + 1 or later in order not to cause a revisit. However, at most G·(T −t) trains can be assigned no earlier than t + 1. If It contains more trains, each extra train causes a revisit. 

This lower bound can similarly be applied for objective 2 of minimizing delayed containers. If It contains more elements than G · (T − t), some elements of It will cause delayed containers, because they cannot be assigned to slot t + 1 or later. It is possible to check, which elements will cause the least delayed containers, if they are assigned to slot t or earlier. For the next theorem, consider the (n − 1)–tuple A(i) := (i) (i) (i) (i) (i) (i) (a1 , a2 , . . . , ai−1 , ai+1 , . . . an ) with aj := Aij + Aj i , which describes all container exchanges from or to train i. Let us assume, w.l.o.g., that the values of A(i) are sorted in (i) (i) descending order, i.e. a1 ≥ a2 ≥ · · · . Theorem 3.3 Given an instance of TYSP or TYSP2. Each of the following is a lower bound for the number of split moves (objective 3): T ·G 

(i)

∀i ∈ I,

aj

(9)

j =G



i∈I

T ·G

(i)  j =G aj

2

,

(10)

Proof Each train i is assigned to a slot with G − 1 other trains. If i exchanges containers with more than G−1 trains, (i) this leads to split moves, i.e. each aj with j > G − 1 describes inevitable split moves. Thus, (9) holds. The result of (9) cannot be simply summed up in order to obtain a lower bound. The value (Aij + Aj i ) of two trains i and j could appear twice in this sum. However, they certainly can appear at most two times. Thus, dividing this sum by two delivers the lower bound. 

4 Algorithms In the following, we will present algorithms for solving TYSP and TYSP2. For the simplicity of the descriptions of the algorithms, we do not consider the earliest and latest slot ei and li of a train i. H owever, all the presented algorithms can easily be adapted such that these kinds of constraints are satisfied. In our computational study, we have tested our algorithms on instances with earliest and latest slot constraints. Note that it can be easily checked whether a feasible solution for TYSP or TYSP2 exists. The following algorithm delivers a feasible solution, if there exists one. Algorithm 1 (Feasible solution) 0. Initialization: Set t = 1, IA := ∅ (set of assigned trains) 1. Assignment: Do G times: 1. Set xi ∗ t = 1 with i ∗ = argmin{i∈I |ei ≤t;i∈I \IA } li ,

J Sched

2. If there is no such i ∗ or if li ∗ < t: Stop, there is no feasible solution. 3. IA = IA ∪ {i ∗ } 2. Iteration: If t = T : Stop, the solution is feasible. Else, t = t + 1 and go to 1. Obviously, this algorithm can easily be implemented in O(n2 ). 4.1 Heuristic algorithms Firstly, let us present a quick but efficient procedure for obtaining a start solution. The idea of this procedure is to split the set I into T clusters, each consisting of G elements. Afterwards, each cluster is assigned to one slot. If these clusters are chosen homogeneously, i.e. if trains exchanging a high number of containers are put together, this is favorable for all three objectives. The ordering of these clusters is irrelevant for the split moves, but it should be chosen in such way that revisits or delayed containers are minimized. Algorithm 2 (Cluster based start procedure, CBSP) 1.0 Initialization Clustering: Set c = 1, I (1) := · · · := I (T ) := ∅ (T clusters), IA := ∅ 1.1 Train Assignment: 1. For an arbitrary element i ∈ I \IA : I (c) = I (c) ∪ {i}, IA = IA ∪ {i}. 

2. Determine i ∗ := argmax (Ai ∗ j + Aj i ∗ ) . i∈I \IA

j ∈I (c)

3. I (c) = I (c) ∪ {i ∗ }, IA = IA ∪ {i ∗ }. 1.2 Iteration: If |I (c)| < G, go to Step 1.1.2. Else, if c < T , set c = c + 1 and go to step 1.1. Else, go to Step 2.0. 2.0 Initialization Sequencing: Set t = 1, C = {1, . . . , T } (set of cluster indices), CA := ∅ (indices of assigned clusters). 2.1 Cluster Assignment: Determine      ⎧ argminc∈C\CA i∈I (c) min 1, c ∈C\CA j ∈I (c ) Aij ⎪ ⎪  ⎪ c =c ⎪ ⎨ if TYSP is considered, ∗   c =   ⎪ argminc∈C\CA ⎪ i∈I (c) c ∈C\CA j ∈I (c ) Aij ⎪ ⎪ c =c ⎩ if TYSP2 is considered

and assign c∗ to the time slot t. CA = CA ∪ {c∗ }. 2.2 Iteration: If t < T , set t = t + 1 and go to step 2.1. Else, stop. The first part of the algorithm runs in O(n2 ), the second as well. Thus, the overall runtime is O(n2 ). Based on an initial solution as obtained in Algorithm 2, we now want to improve this solution. Let us define a neighborhood, in which two solutions are called neighbors, if the assignment of trains to slots is the same in both solutions for all trains except for two of them.

Algorithm 3 (Hillclimber, HC) 0. Initialization: Determine an initial solution x using Algorithm 2. 1. Neighbor solution: For all pairs of trains (i, j ) ∈ I × I , there is a (unique) pair of slots (t, t  ) such that xit = xj t  = 1. Determine for each such pair a solution x  (i, j ) defined by ⎧ if (k = i ∧ l = t  ) ∨ (k = j ∧ l = t), ⎪ ⎨1  xkl (i, j ) := 0 if (k = i ∧ l = t) ∨ (k = j ∧ l = t  ), ⎪ ⎩ xkl else. 2. Improvement: If the objective function value (either TYSP or TYSP2) of x is better than the one of x  (i, j ) for any (i, j ), then stop. Else, determine the best objective function value of x  , obtained by (i ∗ , j ∗ ). Set x = x  (i ∗ , j ∗ ) and go to Step 1. Each recursion of the algorithm, in which the solution is improved, has runtime O(n2 ). In the following, we will call the transfer from one solution to a neighboring solution, which was described in Step 1 of Algorithm 3, a “move”. Although Algorithm 3 delivers good results within a very short amount of time (see Sect. 5), the algorithm might be trapped in a local optimum. Thus, we propose an Ejection Chain Algorithm (see e.g. Pesch and Glover 1997), which can escape local optima. Starting from a feasible solution, our algorithm greedily searches for a sequence of at most n/2 moves. Each move minimizes the objective function value (TYSP or TYSP2) under the restriction that a train must not be moved more than once in this sequence. Practically this means that every train is moved from its current slot to another slot. However, to reach an improved feasible solution for the next iteration, only the subsequence is performed, which raises the objective most. If there is no such subsequence, the algorithm will stop. Algorithm 4 (Ejection Chain, EC1) 0. Initialization: Determine an initial (incumbent) solution x using Algorithm 3. 1. Finding a sequence of at most n2 moves: Copy the incumbent solution and obtain an interim solution. Denote all n trains of the interim solution as non-taboo. 1.1 Finding a best move: Among all moves of nontaboo trains of the interim solution, find the one, which minimizes the objective function. Perform this move to the interim solution, mark the moved trains i ∗ and j ∗ as taboo. Repeat 1.1 to the interim solution until all trains are marked taboo or until no feasible move is found. Determine r ∈ {0, . . . , n/2} so that the interim’s objective is minimized after performing the first r moves.

J Sched Fig. 2 Illustration of Algorithm 4 and 5

2. Improving the solution: If r > 0 perform the first r moves to the incumbent solution and go to step 1. If r = 0 then stop and return the current (incumbent) solution. The procedure of the algorithm is also illustrated in Fig. 2. Each horizontal arrow denotes a move. As the best move in step 1.1 can be determined in O(n2 ) and as each sequence consists of n2 best moves, the complexity of a whole iteration is O(n3 ). Besides Algorithm 4, we have tested a very similar ejection chain algorithm, which uses a different taboo list. In Algorithm 5, each train may be assigned to different slots more than once in a sequence, but a pair of trains must not be exchanged more than once. Algorithm 5 (Ejection Chain, EC2) 0. Initialization: Determine an initial (incumbent) solution x using Algorithm 3. 2 1. Finding a sequence of at most n 2−n moves: Copy the incumbent solution and obtain an interim solution. Denote all pairs (i, j ) ∈ I × I, i = j of trains of the interim solution as non-taboo. 1.1 Finding a best move: Among all moves of non-taboo pairs of trains of the interim solution, find the one, which minimizes the objective function. Perform this move to the interim solution, mark the moved pair of trains (i ∗ , j ∗ ) and (j ∗ , i ∗ ) as taboo. Repeat 1.1 to the interim solution until all pairs are marked taboo or until no feasible move is found. Determine r ∈ {0, . . . , n(n − 1)/2} so that the interim’s objective is minimized after performing the first r moves. 2. Improving the solution: If r > 0 perform the first r moves to the incumbent solution and go to step 1.

If r = 0 then stop and return the current (incumbent) solution. Each iteration of this algorithm has a complexity of O(n4 ). 4.2 An exact algorithm Motivated by the good performance of the heuristic algorithms and by the results of Sect. 3, we have developed a branch and bound algorithm. The branching is done by assigning G trains to the last available slot. Thus, each node  has up to G·T branches, at which T  denotes the remainG ing available slots. We have implemented this procedure in such a way that the algorithm invokes itself whenever a new node is to be fathomed. We therefore present the algorithm in the same way. Algorithm 6 (Branch and Bound, BB) 0. Initialization: Determine a (global) upper bound UB of the objective function score using the solution of Algorithm 5. Go to Step 1 and pass over (I, T , ∅, 0). 1. Fetch: Input: I (current train set), T (number of slots remaining), IR ⊆ I (trains that have to revisit), LB (lower bound) Determine a (local) lower bound LB using Theorem 3.2 and (10). If LB + LB ≥ UB, then return. Else go to Step 2. 2. Branching: For any subset IT ⊆ I with |IT | = G do the following: 1. Assign each element of IT to slot T . Set IR = IR and LB = LB. 2. For each pair (i, j ) with i ∈ / IT and j ∈ IT do: (a) LB = LB + α3 · (Aij + Aj i ) (only TYSP2) (b) LB = LB + α2 · Aij

J Sched

(c) If i ∈ / IR and Aij > 0: LB = LB + α1 , IR = IR ∪ {i} (only TYSP) 3. If LB ≥ UB, then return. 4. If T = 1 and UB > LB , then UB = LB and return. Else, go to Step 1 and pass over (I \IT , (T − 1), IR , LB ). The algorithm uses depth first search. Thus, Step 1 may be started many times, but at most T threads can be active, i.e. not fathomed. Note that if this algorithm is used for TYSP2, the set of trains surely revisiting (IR ) need not be considered. It would also be possible to always fill the first slot instead of the last one in Step 2.1. However, it turned out that this is unfavorable, as the lower bounds in 2.2(b) and 2.2(c) are weaker. This is caused by the fact, that in the latter case, only elements of IT can tighten the bound, whereas in Algorithm 6 all elements of I \IT can tighten the bound.

5 Computational study All methods presented in the previous section have been implemented in Java 2 and run on an Intel® Core™2 Duo, 2.53 GHz PC, with 2.96 GB of memory. There is one test bed available for the train scheduling problem, which has been presented by Boysen et al. (2010a). The instances are randomly generated according to the following attributes: • • • •

The number of tracks G The set of trains I The matrix (Aij )i,j ∈I For each train, the earliest and latest slot.

In each instance, there are between 12 and 48 trains to be assigned to 2–8 tracks. These instances also differ with regard to matrix (Aij )i,j ∈I , being either very sparse, or with only few zeros, or somewhere in-between. Furthermore, either no time restrictions, only arrival time restrictions, or arrival and departure time restrictions are considered. In total, the test bed consists of 30,240 instances. In Boysen et al. (2010a), a heuristic Beam Search Procedure (BS) and an exact Dynamic Programming Approach (DP) have been presented and tested. Furthermore, they present results of a first-come-first-serve heuristic (FCFS) as it is applied at many real-world transshipment yards. Only results for TYSP are presented as TYSP2 has not been considered. Thus, we restrict our comparison to TYSP. The objective weights were set to α1 = 24 and α3 = 1. This is based on the observation that a revisit takes on average 60 minutes whereas a split move on average causes 2.5 minutes extra operational time, leading to a ratio of 24:1 (Boysen et al. 2010a).

First, solution performance of heuristic approaches is evaluated (see Table 2). The results are differentiated according to time restrictions with aggregated results being presented, as well. For each algorithm, the number of revisits, split moves, the objective function score, and CPU time (in seconds) aggregated over all respective instances are listed. As one might expect, the results of CBSP (Algorithm 2) are improved by the ones of HC (Algorithm 3), which again are outperformed by EC1 and EC2 (Algorithms 4 and 5). Except for the start procedure, all these algorithms deliver better results than Beam Search in a much shorter time span. Beam Search required over 24 hours to solve all 30,240 instances. Additionally, its results are on average almost 10% above the ones of Algorithm 5, which required only 2 hours and 5 minutes solving all instances. Clearly, the results reveal FCFS being the least efficient procedure. The existence of time restrictions obviously leads to worse objective function scores. However, as the restrictions reduce the search space of all algorithms (except the starting procedures), run times are lower compared to the unrestricted case. The branch and bound algorithm was tested on 17,280 instances, for which optimal solutions are known. Again, aggregated results as well as results differing with respect to time restrictions are shown (see Table 3). Additionally, heuristic results (especially the average relative gap to the optimal solution values) are presented. Interestingly, the second ejection chain algorithm delivers solutions that are only 0.6% above optimal ones. This is a very promising result as the algorithm obtains its solutions in a very short amount of time, even for big instances. The second ejection chain algorithm gets even closer to the optimal solutions, if time restrictions are considered. Otherwise, its results are on average 1.1% above optimal solution value. The branch and bound algorithm solves instances with time restrictions much faster than those without. On average, the branch and bound algorithm requires 165 seconds for solving one of the 17,280 instances with a maximum runtime up to 3 hours. Using dynamic programming, many instances could not be solved within our time limit of 8 hours, even in cases in which branch and bound needed less than a minute. Thus, dynamic programming and branch and bound can only be compared using small instances. We obtained 8,640 instances being solved by both algorithms. Although BB and DP do not always find the same solution, they always find solutions with the same objective function score. Clearly, branch and bound finds solutions much faster (53 seconds in total) than dynamic programming (142 seconds). Furthermore, we have modeled TYSP in GAMS and applied CPLEX 10 for solving the instances presented in Table 3. Unfortunately, we had to stop the test run after 40 (easy) instances, as the total runtime reached almost 2.5 hours. On average it took 218 seconds solving each instance,

J Sched Table 2 Comparison of the heuristics on 3 · 10080 instances

Time restrictions none CBSP

HC

EC1

EC2

FCFS

BS

Sum arrival

Rev.

184418

190013

189751

564182

18.66

Split

7686552

8389445

8189710

24265707

Obj.

12112584

12949757

12743734

37806075

802.44 1250.20

CPU

0.59

8.30

7.24

16.13

0.00

Rev.

138801

163161

153894

455856

15.07

Split

7711839

8300733

8138036

24150608

Obj.

11043063

12216597

11831492

35091152

798.63 1160.42

CPU

29.29

18.08

19.01

66.38

0.00

Rev.

133289

160026

149332

442647

14.64

Split

7707789

8285839

8119785

24113413

Obj.

10906725

12126463

11703753

34736941

797.40 1148.71

CPU

78.07

34.02

38.72

150.81

0.00

Rev.

115960

150072

134386

400418

13.24

Split

7647103

8236861

8062679

23946643

Obj.

10430143

11838589

11287943

33556675

791.89 1109.68

CPU

4663.42

1089.69

1714.40

7467.51

0.25

Rev.

196079

195871

196148

588098

19.45

Split

9966648

9957081

9960165

29883894

Obj.

14672544

14657985

14667717

43998246

988.22 1454.97

CPU

0.22

0.09

0.19

0.50

0.00

Rev.

145025

172752

164075

481852

15.93

Split

8082932

8648282

8606588

25337802

Obj.

11563532

12794330

12544388

36902250

837.89 1220.31

CPU

51942.65

13018.82

23550.51

88511.98

2.93

Table 3 Comparison of the methods on 3 · 5760 exactly solved instances

Time restrictions none BB

EC2

FCFS

BS

Mean

arr. & dep.

Sum

arrival

Mean

Gap

arr. & dep.

Rev.

43765

56990

51871

152626

8.83

Split

2593064

2903676

2814119

8310859

Obj.

3643424

4271436

4059023

11973883

480.95 692.93

CPU

2058683

384133

402927

2845743

164.68

Rev.

45228

57415

52708

155351

8.99

Split

2599496

2904491

2815654

8319641

Obj.

3684968

4282451

4080646

12048065

481.46 697.23

CPU

157

31

46

234

0.01

Rev.

69203

69083

69194

207480

12.01

Split

3448510

3440928

3442394

10331832

Obj.

5109382

5098920

5103050

15311352

597.91 886.07

CPU

0

0

0

0

0.00

Rev.

51921

61956

59223

173100

10.02

Split

2716207

2992442

2943189

8651838

Obj.

3962311

4479386

4364541

12806238

500.69 741.10

CPU

2002

580

1011

3593

0.21

0.00

0.62

27.87

6.95

J Sched

with the fastest requiring 21 seconds. On the other hand, DP and BB consumed only 2.56 and 0.21 seconds, respectively, for solving these 40 instances. Thus, it can be concluded that off-the-shelf solvers are not applicable for solving realworld TYSP instances. Let us now consider the influence of the number of trains. This parameter seems to be the most important determinant on whether the branch and bound algorithm delivers optimal results in reasonable time. All instances with up to 24 trains have been solved to optimality by BB, whereas many instances with 36 trains could not be solved within several hours. In order to extract the influence of the train number on solution quality, we consider a fixed number of tracks. Thus, in Table 4 only instances with four tracks are summarized. With increasing train number objective values seem to increase in linear fashion. Runtime of heuristics increases polynomially, so that even an instance with 48 trains requires merely several seconds to be solved by the second ejection chain algorithm. On the other hand runtime increase is much worse if branch and bound is considered. It takes only fractions of a second solving an instance with 12 trains, but on average almost 25 minutes are required if an instance with 24 trains is to be solved. Furthermore, we consider the influence of a varying number of tracks. In Table 5, results of heuristic procedures (with a variable number of tracks) are listed. Note that there only exist instances with up to 36 trains having more than 4 tracks, so that we omit instances with more than 36 trains. Clearly, for a given set of trains, the number of revisits and split moves decreases with an increasing number of tracks, as more trains can be jointly served in a bundle. Thus, for an increasing number of tracks objective vales decrease no matter, which algorithm is chosen. As an increasing track number leads to fewer slots, the neighborhood used by the hillclimber and ejection chain procedures gets smaller. Therefore, these procedures show a lower runtime for instances with higher track number. Contrarily, beam search shows an increasing runtime with fewer tracks. This is caused by the fact that the number of edges of the underlying graph (representing the search space) is positively correlated with the number of tracks. For different track numbers results of all 17,280 instances solved to optimality are listed in Table 6. As in Table 5, EC2 has decreasing and BS increasing runtime for an increasing number of tracks. Branch and bound shows its largest runtime for instances with 4 and 6 tracks. Clearly, the runtime of branch and bound should be positively correlated with the number of feasible solutions. If there are no time restrictions, the number of solutions can be described using the binomial coefficient as follows (with n trains, G tracks, and T = n/G time slots):  T   n − iG i=0

G

.

Table 4 Results of 4 · 720 instances with 4 tracks Number of trains 12 CBSP

HC

EC1

EC2

FCFS

BS

BB

Rev.

24

36

48

15557

35871

55403

75122

Split

678062

1512209

2350699

3176902

Obj.

1051430

2373113

3680371

4979830

CPU

0.10

0.51

1.63

3.76

Rev.

14360

29531

44419

58771

Split

662095

1498896

2346833

3189794

Obj.

1006735

2207640

3412889

4600298

CPU

0.14

1.45

6.12

17.48

Rev.

14153

28631

43003

56804

Split

661152

1496362

2345874

3190157

Obj.

1000824

2183506

3377946

4553453

CPU

0.21

2.90

13.37

43.33

Rev.

13742

26107

38288

49506

Split

659363

1482733

2322476

3163026

Obj.

989171

2109301

3241388

4351170

CPU

1.22

62.77

535.30

2538.94

Rev.

16092

37503

58254

78845

Split

787124

1895873

2987373

4076468

Obj.

1173332

2795945

4385469

5968748

CPU

0.03

0.03

0.03

0.09

Rev.

14200

30610

46882

62884

Split

670494

1572481

2507385

3430519

Obj.

1011294

2307121

3632553

4939735

CPU

1.86

109.46

1290.41

7283.23

Rev.

13653

25512

Split

659493

1478719

Obj.

987165

2091007

CPU

5.01

1072930

Thus, the binomial coefficient is comparatively small, if G is either small or large, so that the number of solutions is the highest if there exists a medium track number (of 4 or 6 tracks). Furthermore, it seems noteworthy that results of the second ejection chain algorithm and beam search are closer to the optimal solutions for a higher number of tracks. In case of only 2 tracks, EC2 delivers results, which are on average 1.1% above optimum (BS 9.4%), whereas the results for 8 tracks are only 0.2% above optimum (BS 3.4%).

6 Conclusions The paper on hand considers the transshipment yard scheduling problem (TYSP), which perpetually arises during the daily operations of rail–rail transshipment yards. Trains have

J Sched Table 5 Heuristic results of 4 · 6480 instances with up to 36 trains

Table 6 Results of 4 · 4320 instances with up to 24 trains

Number of tracks 2 CBSP

HC

EC1

EC2

FCFS

BS

Number of tracks

4

6

8

2 BB

4

6

8

Rev.

118326

106831

96556

87544

Rev.

39481

39165

35715

38265

Split

5311158

4540970

4011126

3632877

Split

2666446

2138212

1749892

1756309

Obj.

8150982

7104914

6328470

5733933

Obj.

3613990

3078172

2607052

2674669

CPU

2.10

2.24

2.41

1.99

CPU

83608

1072935

1043072

646129

Rev.

91792

88310

81575

76388

Rev.

41086

39849

35981

38435

Split

6608903

4507824

3909811

3488347

EC2

Split

2667802

2142096

1752650

1757093

Obj.

9332524

6627264

5867611

5321659

Obj.

3653866

3098472

2616194

2679533

CPU

9.03

7.70

7.01

4.89

CPU

78.34

64.00

51.02

41.15

Rev.

89139

85787

79209

74556

Rev.

59747

53595

46873

47265

Split

5397654

4503388

3894751

3464998

Split

3067601

2682997

2294297

2286937

Obj.

7536990

6562276

5795767

5254342

Obj.

4501529

3969277

3419249

3421297

CPU

18.64

16.48

15.41

9.80

CPU

0.02

0.06

0.03

0.00

Rev.

78854

78137

73534

71369

Rev.

50456

44810

38563

39271

Split

5397527

4464572

3841360

3422306

Split

2744474

2242975

1841599

1822790

Obj.

7290023

6339860

5606176

5135162

Obj.

3955418

3318415

2767111

2765294

CPU

723.41

599.30

520.62

255.06

CPU

12.48

111.31

707.19

2761.89

Rev.

120613

111849

102434

93034

Split

6241312

5670370

5094681

4538864

Obj.

9136024

8354746

7553097

6771680

CPU

0.05

0.10

0.14

0.05

Rev.

100913

91692

82881

75884

Split

5591398

4750360

4112250

3621791

Obj.

8013310

6950968

6101394

5443007

CPU

60.23

1401.72

20669.57

58960.09

to be assigned to time slots, so that in each slot a given number of G trains jointly enter and leave the yard while arrival and departure time restrictions are observed. The objective is to minimize split moves and either revisits or delayed containers. We show that the problem remains NP-hard, even if only one of the objectives is considered. Furthermore, we derive lower bound arguments, which are applied in an exact branch and bound procedure. Several heuristic algorithms are introduced and shown to be superior to previous approaches in a comprehensive computational study. Within a fraction of a second, a novel ejection chain heuristic delivers results being very close to optimal solution values. Further research should focus on two areas. The promising performance of the procedures introduced in this paper might allow for a combined solution approach of interdependent problems arising at transshipment yards. For instance, it seems reasonable to solve TYSP (or TYSP2) and to simultaneously determine the rail track for each train (problems (i) and (iv) as defined in Sect. 1). In such a setting, two trains with a large number of containers to be exchanged should

FCFS

BS

not only be assigned to the same bundle but also to neighboring tracks. Additionally, future research should concentrate on the fact that time tables of trains are often subject to changes. Containers arriving late on delayed trains obstruct train processing within the yard, which potentially leads to even more delays of other trains. Therefore, it seems reasonable to integrate some kind of robustness measure into TYSP making the assignment of trains to slots unassailable to small changes in input data. Acknowledgement This work has been supported by the German Science Foundation (DFG) through the grant “Optimierung der Containerabfertigung in Umschlagbahnhöfen” (BO 3148/1-1 and PE 514/16-1).

References Alicke, K. (2002). Modeling and optimization of the intermodal terminal mega hub. OR Spectrum, 24, 1–17. Alicke, K., & Arnold, D. (1998). Modellierung und Optimierung von mehrstufigen Umschlagsystemen. Fördern und Heben, 8, 769– 772. Ballis, A., & Golias, J. (2002). Comparative evaluation of existing and innovative rail–road freight transport terminals. Transportation Research Part A: Policy and Practice, 36, 593–611. Blasum, U., Bussieck, M., Hochstättler, W., Moll, C., Scheel, H.-H., & Winter, T. (1999). Scheduling trams in the morning. Mathematical Methods of Operations Research, 49, 137–148. Bontekoning, Y., Macharis, C., & Trip, J. (2004). Is a new applied transportation research field emerging? A review of intermodal rail-truck freight transport literature. Transportation Research Part A: Policy and Practice, 38, 1–24.

J Sched Bostel, N., & Dejax, P. (1998). Models and algorithms for container allocation problems on trains in a rapid transshipment shunting yard. Transportation Science, 32, 370–379. Boysen, N., & Fliedner, M. (2010). Determining crane areas in intermodal transshipment yards: The yard partition problem. European Journal of Operational Research, 204, 336–342. Boysen, N., Jaehn, F., & Pesch, E. (2010a). Scheduling freight trains in rail–rail transshipment yards, Transportation Science, to apppear Boysen, N., Fliedner, M., & Kellner, M. (2010b). Determining fixed crane areas in rail–rail transshipment yards. Transportation Research Part E, 46, 1005–1016. Cordeau, J.-F., Toth, P., & Vigo, D. (1998). A survey of optimization models for train routing and scheduling. Transportation Science, 32, 380–404. Corry, P., & Kozan, E. (2008). Optimised loading patterns for intermodal trains. OR Spectrum, 30, 721–750. Crainic, T., & Kim, K. (2007). Intermodal transport. In C. Barnhart & G. Laporte (Eds.), Transportation: Vol. 14. Handbooks in operations research and management science (pp. 467–538). Amsterdam: North-Holland. Dahlhaus, E., Horak, P., Miller, M., & Ryan, J. (2000). Optimised loading patterns for intermodal trains. Discrete Applied Mathematics, 103, 41–54. EU (2007). Mitteilung der Kommission an den Rat und das europäische Parlament: Aufbau eines vorrangig für den Güterverkehr bestimmten Schienennetzes. Feo, T., Goldschmidt, O., & Khellaf, M. (1992). One-half approximation algorithms for the k-partition problem. Operations Research, 40, 170–173. Freling, R., Lentink, R., Kroon, L., & Huisman, D. (2005). Shunting of passenger train units in a railway station. Transportation Science, 39, 261–272. Garey, M., & Johnson, D. (1979). Computers and intractability: A guide to the theory of NP-completeness. New York: Freeman. He, S., Song, R., & Chaudhry, S. (2000). Fuzzy dispatching model and genetic algorithms for railyards operations. European Journal of Operational Research, 124, 307–331.

Kellner, M., Boysen, N., & Fliedner, M. (2010). How to park freight trains on rail–rail transshipment yards: The train location problem, submitted. Lim, A., Rodrigues, B., & Xu, Z. (2007). A m-parallel crane scheduling problem with a non-crossing constraint. Naval Research Logistics, 54, 115–127. Macharis, C., & Bontekoning, Y. (2004). Opportunities for or in intermodal freight transport research: A review. European Journal of Operational Research, 153, 400–416. Meyer, P. (1999). Entwicklung eines Simulationsprogramms für Umschlagterminals des Kombinierten Verkehrs. Aachen: Shaker Verlag. Moccia, L., Cordeau, J., Gaudioso, M., & Laporte, G. (2006). A branch-and-cut algorithm for the quay crane scheduling problem in a container terminal. Naval Research Logistics, 53, 45–59. Papadimitriou, C., & Steiglitz, K. (1982). Combinatorial optimization: Algorithms and Complexity. Prentice-Hall: Englewood Cliffs. Pesch, E., & Glover, F. (1997). TSP ejection chains. Discrete Applied Mathematics, 76, 165–181. Rotter, H. (2004). New operating concepts for intermodal transport: The mega hub in Hanover/Lehrte in Germany. Transportation Planning and Technology, 27, 347–365. Sammarra, M., Cordeau, J., Laporte, G., & Monaco, M. (2007). A tabu search heuristic for the quay crane scheduling problem. Journal of Scheduling, 10, 327–336. Tanaev, V. S., Gordon, V. S., & Shafransky, Y. M. (1994). Scheduling theory. Single-stage systems. Kluwer: Dordrecht. Wiegmans, B., Stekelenburg, D., Versteegt, C., & Bontekoning, Y. (2007). Modeling rail–rail exchange operations: An analysis of conventional and new-generation terminals. Transportation Journal, 46, 5–20. Winter, T., & Zimmermann, U. (2000). Real-time dispatch of trams in storage yards. Annals of Operations Research, 96, 287–315. Zhu, Y., & Lim, A. (2006). Crane scheduling with non-crossing constraints. Journal of Operational Research Society, 57, 1464– 1471.