A Novel Dynamic Programming Approach to the Train Marshalling Problem

TL;DR

This paper introduces a new dynamic programming algorithm for the Train Marshalling Problem, significantly improving computational efficiency over existing methods and effectively reordering railcars with fewer classification tracks.

Contribution

The paper presents a novel exact DP algorithm for TMP with lower worst-case complexity and better practical performance than existing algorithms.

Findings

The new DP algorithm reduces computational complexity.

Experimental results show improved performance over existing algorithms.

The approach effectively minimizes the number of classification tracks needed.

Abstract

Train marshalling is the process of reordering the railcars of a train in such a way that the railcars with the same destination appear consecutively in the final, reassembled train. The process takes place in the shunting yard by means of a number of classification tracks. In the Train Marshalling Problem (TMP), the objective is to perform this rearrangement of the railcars with the use of as few classification tracks as possible. The problem has been shown to be NP-hard, and several exact and approximation algorithms have been developed for it. In this paper, we propose a novel exact dynamic programming (DP) algorithm for the TMP. The worst-case time complexity of this algorithm (which is exponential in the number of destinations and linear in the number of railcars) is lower than that of the best presently available algorithm for the problem, which is an inclusion-exclusion-based DP algorithm. In practice, the proposed algorithm can provide a substantially improved performance compared to its inclusion-exclusion-based counterpart, as demonstrated by the experimental results.

Figures

Tables

Table 1. TABLE I: A comparison of the average running times (in seconds) of our method (the procedure Memoized-DP-TMP ) against those of the method of  [ 5 ] . The acronym “TLE” stands for “Time Limit Exceeded”

$n$	Approach	$t=5$	$t=7$	$t=9$	$t=11$	$t=13$	$t=15$
50	Rinaldi & Rizzi (2017)	12.019	153.997	1114.678	TLE	TLE	TLE
	Our Algorithm 3	0.042	0.196	1.228	7.053	28.991	144.902
75	Rinaldi & Rizzi (2017)	18.067	249.447	1964.511	TLE	TLE	TLE
	Our Algorithm 3	0.053	0.245	1.801	11.209	49.844	269.347
100	Rinaldi & Rizzi (2017)	24.219	337.292	3288.679	TLE	TLE	TLE
	Our Algorithm 3	0.061	0.294	2.225	15.588	72.216	470.611
200	Rinaldi & Rizzi (2017)	50.036	710.131	TLE	TLE	TLE	TLE
	Our Algorithm 3	0.075	0.522	3.775	27.152	167.992	1157.106
300	Rinaldi & Rizzi (2017)	78.106	1131.708	TLE	TLE	TLE	TLE
	Our Algorithm 3	0.103	0.678	5.260	30.840	227.534	1595.130
400	Rinaldi & Rizzi (2017)	108.283	1599.885	TLE	TLE	TLE	TLE
	Our Algorithm 3	0.119	0.861	7.044	41.290	281.694	1918.972
500	Rinaldi & Rizzi (2017)	140.439	2112.443	TLE	TLE	TLE	TLE
	Our Algorithm 3	0.139	1.055	8.602	48.536	348.833	2341.133
750	Rinaldi & Rizzi (2017)	231.226	3248.614	TLE	TLE	TLE	TLE
	Our Algorithm 3	0.206	1.694	12.958	72.902	493.286	3438.906
1000	Rinaldi & Rizzi (2017)	334.431	4825.828	TLE	TLE	TLE	TLE
	Our Algorithm 3	0.288	2.336	17.233	97.056	677.042	4565.083

Table 2. TABLE II: A comparison of the average running times of our procedure Memoized-DP-TMP with those of each of the calls to the procedure DTMP presented in [ 5 , Algorithm 3]

$n$	$t$	Approach		Time (in secs.)
50	5		$k=2$	2.161
		DTMP [5, Algorithm 3]	$k=3$	3.994
			$k=4$	5.864
		Memoized-DP-TMP		0.042
500	5		$k=2$	22.655
		DTMP [5, Algorithm 3]	$k=3$	46.047
			$k=4$	71.738
		Memoized-DP-TMP		0.139
1000	5		$k=2$	51.017
		DTMP [5, Algorithm 3]	$k=3$	107.788
			$k=4$	175.627
		Memoized-DP-TMP		0.288
50	7		$k=3$	30.855
		DTMP [5, Algorithm 3]	$k=4$	45.442
			$k=5$	60.072
			$k=6$	74.823
		Memoized-DP-TMP		0.196
500	7		$k=3$	345.878
		DTMP [5, Algorithm 3]	$k=5$	765.925
			$k=6$	1000.639
		Memoized-DP-TMP		1.055
1000	7		$k=3$	737.058
		DTMP [5, Algorithm 3]	$k=5$	1738.398
			$k=6$	2350.372
		Memoized-DP-TMP		2.336
50	9		$k=4$	269.248
		DTMP [5, Algorithm 3]	$k=5$	359.379
			$k=6$	446.749
			$k=7$	555.890
		Memoized-DP-TMP		1.228
100	9		$k=4$	526.833
		DTMP [5, Algorithm 3]	$k=6$	897.484
			$k=7$	1090.555
			$k=8$	1289.678
		Memoized-DP-TMP		2.225

Equations

$$\begin{gathered} (n=17,t=5,\mathcal{B}=\{B_1=⟨1,4,10⟩,B_2=⟨5,12,14⟩, \\ {B}_3=⟨11,13,17⟩,B_4=⟨2,3,8,9⟩,B_5=⟨6,7,15,16⟩\}). \end{gathered}$$

$$\begin{gathered} ⟨\dots ,17,\underset{B_1}{\underbrace{1,2,3,4,5,6,7,8,9,10}},11, \\ \underset{B_2}{\underbrace{12,13,14,15,16,17,1,2,3,4,5}},6,\dots ⟩. \end{gathered}$$

$$\begin{gathered} ⟨1,\underset{B_4}{\underbrace{2,3,4,5,6,7,8,9}},10,\underset{B_3}{\underbrace{11,12,13,14,15,16,17}}, \\ \underset{B_1}{\underbrace{1,2,3,4,5,6,7,8,9,10}},11,\underset{B_2}{\underbrace{12,13,14,15,16,17,1,2,3,4,5}}, \\ \underset{B_5}{\underbrace{6,7,8,9,10,11,12,13,14,15,16}},17,\dots ⟩. \end{gathered}$$

$$\begin{gathered} ⟨\dots ,17,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17, \\ 1,2,3,4,\dots ⟩. \end{gathered}$$

$$\begin{gathered} ⟨\dots ,5,\underset{B_5}{\underbrace{6,7,8,9,10,11,12,13,14,15,16}},17, \\ 1,2,3,4,5,6,7,\underset{B_4}{\underbrace{8,9,10,11,12,13,14,15,16,17,1,2,3}},4,\dots ⟩. \end{gathered}$$

$$\begin{gathered} ⟨\dots ,5,\underset{B_5}{\underbrace{6,7,8,9,10,11,12,13,14,15,16}},17, \\ 1,\underset{B_4}{\underbrace{2,3,4,5,6,7,8,9}},10,\dots ⟩. \end{gathered}$$

$$\underset{\text{In the first segment}}{\underbrace{i_{l+1},i_{l+2},\dots ,i_{\ell -1},i_{\ell }}},\underset{\text{In the second segment}}{\underbrace{i_1,i_2,\dots ,i_l}}.$$

$$\delta (\underline{i},\underline{B})=\{\begin{array}{ll}0,& \text{i≤i1 and iℓ<n},\\ 1,& \text{otherwise}.\end{array}$$

$$K[\underline{i},{\mathcal{B}}^{\prime }]=\underset{\underline{B}\in {\mathcal{B}}^{\prime }}{\min }\left\{\delta (\underline{i},\underline{B})+K[\omega (\underline{i},\underline{B}){+}_{n}1,{\mathcal{B}}^{\prime }\setminus \{\underline{B}\}]\right\}.$$

$$(n-|\underline{B}|,t-1,\mathcal{B}\setminus \{\underline{B}\},\omega (1,\underline{B}){+}_{n}1),\text{ for each B∈B}.$$

$$K[\underline{i},\varnothing ]=\{\begin{array}{ll}0,& \text{if i=1},\\ 1,& \text{otherwise}.\end{array}$$

$$K[i{+}_{n}1,\{\overline{B}\}]=\delta (i{+}_{n}1,\overline{B})+K[\omega (i{+}_{n}1,\overline{B}){+}_{n}1,\varnothing ],$$

$$n\sum _{j=1}^{t-1}j\left(\genfrac{}{}{0ex}{}{t}{j}\right)=n\sum _{j=1}^{t-1}t\left(\genfrac{}{}{0ex}{}{t-1}{j-1}\right)=nt\sum _{j=0}^{t-2}\left(\genfrac{}{}{0ex}{}{t-1}{j}\right)=nt(2^{t-1}-1).$$

$$K[\underline{i}{+}_{n}1,{\mathcal{B}}^{\prime }],\underline{i}\in \bigcup _{B\in {\mathcal{B}}^{\prime }}B,$$

Full text

I Introduction

In a shunting yard (a.k.a. classification or marshalling yard), the railcars of an incoming (inbound) train are uncoupled, rearranged, and then reassembled to form an outgoing (outbound) train [1, 2, 3, 4]. A shunting yard consists of multiple parallel classification tracks (a.k.a. auxiliary rails) on which partial outbound trains can be assembled before being pulled together to form an outbound train. In a shunting yard, one primary objective is to rearrange the railcars of an inbound train into groups that share the same destination [3, 5, 6, 7, 8]. These groups, which we refer to as blocks, are then coupled together to form a new outbound train. This process is referred to as train marshalling, and is accomplished by means of a number of classification tracks. While a shunting yard has only a limited number of classification tracks, there may be several trains to be processed at the same time. Therefore, it is obvious that the aim should be to keep the number of classification tracks per inbound train as small as possible [9, 6, 10]. In the Train Marshalling Problem (TMP), using as few classification tracks as possible is the only objective [2, 11]. For a detailed survey about other commonly used and more recent train classification methods (from an algorithmic point of view), see [4].

Let an inbound train ${\cal T}$ be given. In the TMP, in its optimization version, the goal is to find the minimum number of classification tracks needed to rearrange the railcars of $\cal T$ in such a way that the railcars sharing the same destination are grouped together. (Obviously, the number of classification tracks needed for a train is never more than the number of destinations.) The decision version of the problem can be stated as follows: Given an inbound train $\cal T$ and a positive integer $k$, decide whether or not the railcars of $\cal T$ can properly be rearranged by means of at most $k$ classification tracks.

The TMP has been proved to be NP-hard (using a reduction from the numerical matching with target sums problem) [6]. Generally, approaches for solving a particular NP-hard problem can be classified into two main categories: exact and inexact methods. Exact methods are guaranteed to find an optimal solution if one exists (see, e.g., [5, 12, 13]). However, they generally require exponential time in the worst case. If the actual instances are small-to-moderate-sized, such algorithms may be perfectly satisfactory. The worst-case exponential complexity is acceptable if the algorithm is effective and fast enough for the problem instances appearing in the specific application considered [14, 15]. For some interesting discussions on exact algorithms in general, the reader is referred to [16, 17, 15]. Inexact techniques, on the other hand, can find reasonable suboptimal solutions in polynomial time. Inexact methods themselves can be grouped into two families: approximation algorithms, which guarantee to return a (suboptimal) solution that is within a certain factor of the optimal solution (see, e.g., [18, 19]), and heurstic/metahueristic approaches, which do not offer any performance guarantee but have been found to be very successful in solving NP-hard problems (see, e.g., [20, 21, 22, 23, 3, 12, 13]). It should be noted that some tractable cases of the TMP have been identified in the literature [24, 25]. In fact, some special cases of an NP-hard problem may be solvable in polynomial time [14]. (Reference [24] is the paper in which the TMP originally posed.)

In [25], Dahlhaus et al. showed that the problem is approximable within ratio $2$. In [11], both online and offline versions of the TMP have been considered. In the offline scenario, some basic results and lower bounds on the optimal solutions have been presented. Furthermore, an analysis of the online version of the problem and a 2-competitive deterministic greedy online algorithm have been provided. It has also be shown that the competitive factor of 2 is indeed best possible among all deterministic online algorithms. In [26], Brueggeman et al. established that the TMP is fixed parameter tractable with respect to the number of classification tracks $k$. To be more precise, if an inbound train $\cal T$ with $n$ railcars having $t$ different destinations, and a positive integer $k$ are given, then for deciding whether or not the railcars of $\cal T$ can be rearranged in an appropriate order by using at most $k$ classification tracks, the algorithm proposed in [26] requires $O(2^{O(k)}\mathrm{poly}(n))$ time and $O(n^{2}k2^{8k})$ space. The algorithm is based on the dynamic programming (DP) paradigm. Finally, very recently, Rinaldi and Rizzi have developed an exact dynamic programming algorithm for the problem in which the TMP is solved as a problem of finding a rainbow path in an edge-colored directed graph [5]. This algorithm, which is based on the principle of inclusion-exclusion, is of time complexity $O(nkt^{2}2^{t})$ and space complexity $O(nkt)$. This implies that the TMP is fixed parameter tractable with the number of destinations $t$. The readily apparent advantage of this approach is its polynomial space complexity. When used to solve the optimization version of the TMP, in a binary search fashion, the time complexity of the approach becomes $O(nt^{2}2^{t}U\log_{2}⁡U)$, where $U$ is an upper bound on the optimal number of classification tracks. Although elegant, this procedure only returns the value of an optimal solution, i.e. the minimum number of required classification tracks, but not an optimal solution itself.

In this paper, we propose a novel exact DP algorithm for the TMP. DP is indeed an approach of great importance in the design of both polynomial-time and exponential-time algorithms [14, 16, 15, 17]. In contrast to the exact methods described in [5, 26], our method is developed to directly solve the optimization version of the TMP (i.e., it does not need to make successive calls to a procedure that solves the decision version of the problem).111It should be remembered that, there is not a significant difference between the optimization version of the TMP and its decision version. Obviously, an algorithm that can solve the optimization version of the problem, can automatically solve the decision version as well (for any given $k\in\mathbb{N}$). On the other hand, if one can solve the decision version of the TMP for any given $k$, then one can also minimize the number of classification tracks needed to obtain a train of desired property: For a given inbound train $\cal T$ with $n$ railcars having $t$ different destinations, the decision version of the problem is solved repeatedly, by incrementally increasing the value of $k$ from $1$. When the answer turns from “no” to “yes”, then the solution is at hand. Furthermore, using binary search (instead of linear search), one needs to solve the decision version only for $O(\log_{2}U)$ different values of $k$, where $U$ is an upper-bound on the optimal number of classification tracks. The proposed algorithm is capable of finding not only the minimum number of required classification tracks, but also the classification track that each railcar is assigned to, in an optimal solution, as well. The algorithm is of worst-case time complexity $O(nt2^{t})$ and worst-case space complexity $O(n2^{t})$. The Numerical experiments presented in Section IV demonstrate that the algorithm substantially outperforms its inclusion-exclusion-based counterpart in terms of computation time.

The outline of this paper is as follows. In Section II, we provide some notations, and present a rigorous formulation of the TMP. Section III is dedicated to the presentation of our novel dynamic programming algorithm for the TMP. Section IV is devoted to experimental results, and to numerical comparisons with the best currently available approach to the problem. (We extensively compared our technique with the approach presented in [5].) Finally, some concluding remarks are given in Section V.

II Notations and Problem Statement

We begin this section by introducing some notation that will be used throughout the paper. For a positive integer $N\in{\mathbb{N}}$, we denote by $[N]$ the set $\{1,2,\ldots,N\}$. Each railcar of the train is identified by its index. The order of the railcars in the inbound train corresponds therefore to the sequence $\langle 1,2,\ldots,n\rangle$. By a block, we refer to an increasing sequence consisting of all railcars that share the same destination. A TMP instance can be described by a triple $(n,t,{\cal B})$, where $n$ is the number of railcars of the train, $t$ is the number of destinations, and $\cal B$ is the set of all blocks. (Obviously, $|{\cal B}|=t$ and $\bigcup_{B\in{\cal B}}B=[n]$.) The objective is to find the smallest number of classification tracks by which the inbound train can be rearranged according to the destinations. The railcars are considered one after another according to their order in the inbound train. The railcars assigned to each classification track form a sequence. In fact, each railcar is guided to one of the classification tracks, and placed behind the already sequenced railcars. The outbound train is obtained by reassembling the railcars on the first track (based on their order of arrival) followed by the railcars on the second track and so on.

Example 1**.**

Figure 1 depicts an instance of the problem in which $n=9$, $t=3$, and the set of blocks is $\mathcal{B}=\{\langle 1,3,5\rangle,\langle 2,6,8\rangle,\langle 4,7,9\rangle\}$. As can be seen from the figure, to rearrange the railcars according to their destinations, only two classification tracks are needed.

The TMP can be stated in an equivalent way, which is more convenient for our purposes:222This alternative statement of the problem has been proposed by Donald E. Knuth, in a personal letter to the authors of [6]. Let an instance $(n,t,{\cal B})$ of the TMP be given. We define $A(n)$ to be an infinite sequence obtained by concatenating infinitely many copies of the sequence $\langle 1,2,\ldots,n\rangle$. We refer to each subsequence $\langle 1,2,\ldots,n\rangle$ of $A(n)$ as a segment. (We will shortly see that each segment corresponds to a classification track.) The entries of $A(n)$ can be seen as unoccupied positions in which the elements of $\bigcup_{B\in{\cal B}}B=[n]$ can be placed. Each element of the set $[n]$ must occur exactly once in $A(n)$. The occurrence of the element $i\in[n]$ in the $\kappa$th segment of $A(n)$ is equivalent to the assignment of the $i$th railcar of the inbound train to the $\kappa$th classification track. It can readily be verified that a placement in which the elements of every block $B\in{\cal B}$ occur right next to each other, leads to a solution to the given TMP instance, and vice versa. (We refer to such a placement as a solution as well.) More precisely speaking, a placement can be considered as a solution if and only if for every two distinct blocks $B$ and $B^{\prime}$ in $\cal B$, none of the elements of $B$ occur in the interval occupied by the elements of $B^{\prime}$. It is now clear that, in the alternative statement of the TMP, the aim is to find a placement that uses the minimum number of segments. In other words, the goal is to find a permutation $\pi$ of the set $[t]$ such that the occurrence of the blocks of $\cal B$ one after another, in the order specified by $\pi$, uses the least number of segments. In the following, we stick to the above-described alternative statement of the problem.

Example 2**.**

Consider the following instance of the TMP:

[TABLE]

In a solution to the above-given instance, the elements of $B_{1}$ and $B_{2}$ may appear in $A(17)$ in the following way:

[TABLE]

It should be remarked that we defined a block as an increasing sequence consisting of all railcars that share the same destination, but the element of a block $B\in\mathcal{B}$ do not necessarily appear in $A(n)$ in an increasing order. The following is an optimal solution for the TMP instance described by (1), which uses three segments:

[TABLE]

This solution is depicted schematically in Figure 2.

Before proceeding further, we need to impose a number of simplifying assumptions, which can be made without loss of generality. Let an instance $(n,t,{\cal B})$ of the TMP be given. We can confine our attention to those solutions of this instance in which, firstly, there are no “unused positions” before the first element of the first block of $\cal B$ that appears in $A(n)$; secondly, there are no unused positions between the elements of two adjacent blocks; and finally, if $B$ is an arbitrary block in $\cal B$, then the elements of $B$ occur in $A(n)$ contiguous with each other, i.e., without any unused positions between them. Collectively, the above three cases indicate that we can, without loss of generality, narrow our attention to only those solutions in which there are no positions left unused, neither within the range of appearance of the elements of a single block $B\in{\cal B}$, nor between the elements of two successive blocks, nor before the first block of $\cal B$ that appears in $A(n)$.

Example 3**.**

In a solution to the TMP instance described by (1), the elements of $B_{4}=\langle 2,3,8,9\rangle$ may appear in $A(17)$ as follows:

[TABLE]

But in this placement, there is an unused position between the elements $2$ and $8$, because the element $3$ has not been placed immediately after $2$. However, placing the elements of $B_{4}$ one next to the other, as required by the assumptions, can lead to a solution that is at least as good:

[TABLE]

As another example, in a solution to the TMP instance given by (1), the elements of the blocks $B_{4}$ and $B_{5}$ can appear in $A(17)$ as follows:

[TABLE]

But in this placement, there are two unused positions between $16$ (the last appearance of an element of $B_{5}$) and $8$ (the first appearance of an element of $B_{4}$), which can contain the elements $2$ and $3$ of $B_{4}$. By placing these two elements immediately after $16$, we obtain a solution that satisfies our assumptions, and is at least as good:

[TABLE]

We conclude this section by introducing two more notations. Let an instance $(n,t,{\cal B})$ of the TMP be given, and let $\underline{i}\in[n]$. For reasons that will become clear in what follows, we may impose the condition that none of the elements of $\bigcup_{B\in{\cal B}}B$ could be placed before the $\underline{i}$th position of the first segment of $A(n)$. In the presence of this condition, we specify the instance by a quadruple $(n,t,{\cal B},\underline{i})$. We will refer to such instances as TMP instances as well. (According to this notation, a TMP instance $(n,t,{\cal B})$ can be expressed as $(n,t,{\cal B},1)$.) Finally, in this paper, the notation ‘$+_{n}$’ symbolizes the usual modulo-$n$ addition, except that if the result is [math], it is replaced by $n$. Therefore, for example, $16+_{17}1=17$ and $17+_{17}1=1$.

III A Dynamic Programming Approach to the Train Marshalling Problem

Let an instance $(n,t,{\cal B},\underline{i})$ of the TMP be given, and let $\underline{B}=\langle i_{1},i_{2},\ldots,i_{\ell}\rangle$ be the first block of ${\cal B}$ that appears in $A(n)$. The first element of $\underline{B}$ that appears in $A(n)$ is its smallest element that is greater than or equal to $\underline{i}$. If no such element exists, then the first occurrence of an element of $\underline{B}$ in $A(n)$ is $i_{1}$, which in fact occurs in the second segment. We denote the first occurrence of an element of $\underline{B}$ in $A(n)$ by $\alpha(\underline{i},\underline{B})$, and the last occurrence of an element of $\underline{B}$ in $A(n)$ by $\omega(\underline{i},\underline{B})$. Under the condition that none of the elements of $\underline{B}$ can be placed before the $\underline{i}$th position of the first segment of $A(n)$, there are two different cases to consider. The aim in examining these cases is to investigate what happens when the first available position in the first segment of the sequence $A(n)$ is $\underline{i}$, and the block whose elements appear immediately following $\underline{i}$ is $\underline{B}$. The cases are as follows:

• •

Case 1, $\underline{i}\leq i_{1}$ or $i_{\ell}<\underline{i}$: In this case, the first element of $\underline{B}$ that appears in $A(n)$ is $i_{1}$, the last element of $\underline{B}$ that appears in $A(n)$ is $i_{\ell}$, and $i_{\ell}$ occurs in the same segment as $i_{1}$. According to the above-defined notations, we have $\alpha(\underline{i},\underline{B})=i_{1}$ and $\omega(\underline{i},\underline{B})=i_{\ell}$. If $i_{\ell}<\underline{i}$, then none of the elements of $\underline{B}$ can be placed in the first segment. Therefore, $i_{1}$ and $i_{\ell}$ both occur in the second segment.

• •

Case 2, $i_{1}<\underline{i}\leq i_{\ell}$: In this case, we have $i_{l}<\underline{i}\leq i_{l+1}$ for some $l\in[\ell-1]$. The first element of $\underline{B}$ that appears in $A(n)$ is $i_{l+1}$ (i.e., $\alpha(\underline{i},\underline{B})=i_{l+1}$), and the last element of $\underline{B}$ that appears in $A(n)$ is $i_{l}$ (i.e., $\omega(\underline{i},\underline{B})=i_{l}$). Notice that $\alpha(\underline{i},\underline{B})=i_{l+1}$ occurs in the first segment, but $\omega(\underline{i},\underline{B})=i_{l}$ occurs in the second segment. Therefore, the elements of $\underline{B}$ appear in $A(n)$ in the following order:

[TABLE]

In Case 1, if $i_{\ell}<n$, then the block $\underline{B}$ does not completely exhaust its containing segment. This means that there remain $n-i_{\ell}$ positions available in the segment (i.e., $i_{\ell}+1,i_{\ell}+2,\ldots,n$), in which the elements of the next block may occur. Otherwise (i.e., if $\underline{i}\leq i_{1}$ and $i_{\ell}=n$), the block $\underline{B}$ completely exhausts its containing segment (which is the first segment). This means that the (yet-to-be-placed) block in $\cal B$ that immediately follows $\underline{B}$, starts somewhere in the second segment.

To distinguish between the cases in which $\underline{B}$ exhausts the first segment and the cases in which there remains at least one position in the first segment that can be utilized for the placement of the block that follows $\underline{B}$, we define an indicator function $\delta:[n]\times{\cal B}\mapsto\{0,1\}$ as follows. (The symbol $\times$ denotes the Cartesian product.) Let $\underline{i}\in[n]$ and $\underline{B}\in{\cal B}$ be given. $\delta(\underline{i},\underline{B})$ takes the value $1$ if $\omega(\underline{i},\underline{B})$ occurs in the last position of the first segment (i.e., $\omega(\underline{i},\underline{B})=n$) or occurs somewhere in the second segment, and [math] otherwise (i.e., if $\omega(\underline{i},\underline{B})$ occurs in the first segment and $\omega(\underline{i},\underline{B})<n$). Therefore,

[TABLE]

We are now ready to describe the algorithm. Let $(n,t,{\cal B})$ be a given TMP instance. Our algorithm will make use of an $n\times 2^{t}$ table $K$ whose rows are labeled by the elements of $[n]$, and whose columns are labeled by the subsets of $\cal B$. For a nonempty subset ${\cal B}^{\prime}$ of ${\cal B}$, and an integer $\underline{i}\in[n]$, we define $K[\underline{i},{\cal B}^{\prime}]$ (the entry at row $\underline{i}$ and column ${\cal B}^{\prime}$ of $K$) to be the minimum number of segments needed for placing the elements of ${\cal B}^{\prime}$ in $A(n)$, with the restriction that the first element of $\bigcup_{B\in{\cal B}^{\prime}}B$ cannot appear before the $\underline{i}$th position of the first segment. It can clearly be seen from the above definition that the goal is in fact to find $K[1,{\cal B}]$. The most crucial component of a dynamic programming algorithm is a recurrence relation that expresses the optimal solution to an instance (recursively) in terms of optimal solutions to smaller subinstances. Our aim here is to derive such a recurrence relation. In fact, although we are interested only in $K[1,{\cal B}]$, we need to find the values of the entries of $K$ corresponding to smaller instances of the problem. One question to be addressed here is that what does small mean in this context? Some notion of the “size” of a subinstance is required here. We sort the subinstances by size (from smallest to largest), and solve them in increasing order of size. As we shall see shortly, the only factor that determines the size of the subinstance corresponding to $K[\underline{i},{\cal B}^{\prime}]$ is indeed the size of ${\cal B}^{\prime}$.

The objective here is to derive a recurrence for $K[\underline{i},{\cal B}^{\prime}]$. To derive this underlying recurrence relation, we need to consider all possible ways to choose the first block of ${\cal B}^{\prime}$ that appears in $A(n)$. If $\underline{B}$ is the first block of ${\cal B}^{\prime}$ that appears in $A(n)$, then according to our definition of $K[\underline{i},{\cal B}^{\prime}]$, the minimum number of segments needed for placing the elements of the remaining blocks in the sequence $A(n)$ is $K[\omega(\underline{i},\underline{B})+_{n}1,{\cal B}^{\prime}\setminus\{\underline{B}\}]$. Therefore, under the restriction that none of the elements of $\bigcup_{B\in{\cal B^{\prime}}}B$ is permitted to appear before the $\underline{i}$th position of the first segment, if $\underline{B}$ is the first block of ${\cal B}^{\prime}$ that appears in $A(n)$, then the blocks of ${\cal B}^{\prime}$ together occupy $\delta(\underline{i},\underline{B})+K[\omega(\underline{i},\underline{B})+_{n}1,{\cal B}^{\prime}\setminus\{\underline{B}\}]$ segments. Hence, we have the following recurrence:

[TABLE]

Therefore, the recursive property that yields the optimal solution value of the original instance of the problem is $K[1,{\cal B}]=\min_{\underline{B}\in{\cal B}}\left\{\delta(1,\underline{B})+K[\omega(1,\underline{B})+_{n}1,{\cal B}\setminus\{\underline{B}\}]\right\}$. This implies that to obtain the value of an optimal solution to the original instance $(n,t,{\cal B},1)$, we need to determine the optimal solution values of the following $t$ subinstances:

[TABLE]

It remains to specify the initial conditions. We define the initial conditions as

[TABLE]

The rationale behind this definition is as follows. Assume that in a solution to a given TMP instance $(n,t,{\cal B})$, the $(t-1)$th block (i.e., the next-to-last block) of $\cal B$ that appears in $A(n)$, ends at the $i$th position of the $\kappa$th segment, $i\in[n]$. If the last block of $\cal B$ that appears in $A(n)$ is $\overline{B}\in{\cal B}$, then we have the following equation, which is obtained by setting $\underline{i}=i+_{n}1$ and ${\cal B}^{\prime}=\{\overline{B}\}$ in equation (4):

[TABLE]

There are three cases to consider. The first case indicates that $K[1,\varnothing]=0$, and the second and third cases together imply that if $\underline{i}\neq 1$, then $K[\underline{i},\varnothing]=1$:

• •

If $\omega(i+_{n}1,\overline{B})=n$, then we necessarily have $K[i+_{n}1,\{\overline{B}\}]=1$. Moreover, according to Equation (3), $\delta(i+_{n}1,\overline{B})=1$. Now, Equation (5) implies that $K[\omega(i+_{n}1,\overline{B})+_{n}1,\varnothing]=0$. Since $\omega(i+_{n}1,\overline{B})=n$, we have $K[1,\varnothing]=0$. Notice that, in this case, the block $\overline{B}$ starts and ends at the $\kappa$th segment.

• •

If $\omega(i+_{n}1,\overline{B})<n$ and $\delta(i+_{n}1,\overline{B})=0$, then we necessarily have $K[i+_{n}1,\{\overline{B}\}]=1$. Now, Equation (5) implies that $K[\omega(i+_{n}1,\overline{B})+_{n}1,\varnothing]=1$. In this case, as in the first case, the block $\overline{B}$ starts and ends at the $\kappa$th segment.

• •

If $\omega(i+_{n}1,\overline{B})<n$ and $\delta(i+_{n}1,\overline{B})=1$, then we must have $K[i+_{n}1,\{\overline{B}\}]=2$. Again, Equation (5) implies that $K[\omega(i+_{n}1,\overline{B})+_{n}1,\varnothing]=1$. In this case, as opposed to the first two cases, the block $\overline{B}$ either starts at the $\kappa$th segment and ends at the $(\kappa+1)$th segment, or starts and ends at the $(\kappa+1)$th segment.

The (bottom-up table-based) version of our dynamic programming algorithm for the Train Marshalling Problem, the procedure Bottom-Up-DP-TMP, is presented in Algorithm 1. The correctness of this algorithm follows directly from (4). Notice that in the table $K$, the only entry in the column corresponding to $\cal B$ that we need to compute is $K[1,{\cal B}]$. Hence, Bottom-Up-DP-TMP does not compute all the entries of this column, but only $K[1,{\cal B}]$ (see line 16). Although this procedure determines the minimum number of classification tracks needed to rearrange the railcars in an appropriate order, it does not directly show how to rearrange them. Therefore, besides the minimum number of needed classification tracks, it returns a table $T$ using which an optimal solution itself can be constructed. (This table provides us with the information we need to do so.) $T$ has its rows indexed by the elements of $[n]$ and its columns indexed by the subsets of $\cal B$. The entry $T[\underline{i},{\cal B}^{\prime}]$ contains the first block that appears in $A(n)$ in an optimal solution to the TMP instance $\left(\left|\bigcup_{B\in{\cal B}^{\prime}}B\right|,\left|{\cal B}^{\prime}\right|,{\cal B}^{\prime},\underline{i}\right)$. Using this table, the procedure Print-Optimal-Solution, which is shown in Algorithm 2, prints out an optimal solution to a given TMP instance. The rationale behind this procedure is easy to grasp, so we omit a detailed discussion.

In Bottom-Up-DP-TMP, the time in both the first loop (lines 5–7) and the last loop (line 16) is insignificant compared to the time in the middle loop (lines 8–15), because the middle loop contains various levels of nesting. (The loops are nested four deep.) The time complexity of this nested loop is

[TABLE]

Therefore, the time complexity of the whole algorithm is also in $O(nt2^{t})$. It can easily be verified that the space complexity of the algorithm is $O(n2^{t})$. If we need only the value of an optimal solution, and not an optimal solution itself, then we do not need to compute the table $T$ anymore. Moreover, in such a case, if $K_{j}$ denotes the subtable of $K$ consisting of columns whose corresponding subsets of $\cal B$ are of size $j$, $1\leq j\leq t$, then for computing the entries of $K_{j}$, we only need the entries of $K_{j-1}$. By virtue of this fact, the memory complexity of Bottom-Up-DP-TMP can be reduced to $O\left(n\binom{t}{\lfloor\frac{t}{2}\rfloor}\right)$. (With respect to the facts that the number of $j$-subsets of $\cal B$ is $\binom{t}{j}$, and that $\binom{t}{\lfloor\frac{t}{2}\rfloor}$ is the largest of the binomial coefficients $\binom{t}{j}$, $0\leq j\leq t$.)

The time complexity of the procedure Bottom-Up-DP-TMP is better than that of the best currently known algorithm for the TMP [5]. However, it still has room for improvement. We will now discuss some modifications that can be made to improve the effectiveness of this procedure. We first state two lemmas.

Lemma 1**.**

Let an instance $(n,t,{\cal B})$ of the TMP be given. When applying the procedure Bottom-Up-DP-TMP to this instance, for each ${\cal B}^{\prime}\subseteq{\cal B}$, the entries

[TABLE]

are not required to be computed.

Proof.

It can be observed from lines 11 and 16 of Bottom-Up-DP-TMP that for any $\underline{i}\in[n]$ and any ${\cal B}^{\prime}\subseteq{\cal B}$, the entry $K[\underline{i},{\cal B}^{\prime}]$ is required to be computed only if for some $h\in[n]$ and some $B\in{\cal B}\setminus{\cal B}^{\prime}$, we have $\underline{i}=\omega(h,B)+_{n}1$. It is not difficult to verify that $\{\omega(h,B)+_{n}1\,|\,h\in[n],\,B\in{\cal B}\setminus{\cal B}^{\prime}\}=\left\{h+_{n}1\,|\,h\in\bigcup_{B\in{\cal B}\setminus{\cal B}^{\prime}}B\right\}$. Now, in the column corresponding to ${\cal B}^{\prime}$, none of the entries whose row indices belong to the set $\left\{h+_{n}1\,|\,h\in\bigcup_{B\in{\cal B}^{\prime}}B\right\}=[n]\setminus\left\{h+_{n}1\,|\,h\in\bigcup_{B\in{\cal B}\setminus{\cal B}^{\prime}}B\right\}$ need to be computed. ∎

Lemma 2**.**

Consider an instance $(n,t,{\cal B})$ of the TMP. Let ${\cal B}^{\prime}\subseteq{\cal B}$ be given, and let $\ell=\sum_{B\in{\cal B}^{\prime}}|B|$. ($|B|$ denotes the length of $B$.) Let $\sigma({\cal B}^{\prime})=\left\langle i_{1},i_{2},\ldots,i_{\ell}\right\rangle$ be an increasing sequence whose elements are the elements of $\bigcup_{B\in{\cal B}^{\prime}}B$. If $l\in[\ell-1]$, then for all distinct integers $i_{l}<\underline{i},\underline{i^{\prime}}\leq i_{l+1}$ we have $K[\underline{i},{\cal B}^{\prime}]=K[\underline{i^{\prime}},{\cal B}^{\prime}]$. This fact holds also for all distinct integers $1\leq\underline{i},\underline{i^{\prime}}\leq i_{1}$, and all distinct integers $i_{\ell}<\underline{i},\underline{i^{\prime}}\leq n$.

Proof.

Let $i_{l}<\underline{i}\neq\underline{i^{\prime}}\leq i_{l+1}$, for some $l\in[\ell-1]$. In the optimal solutions corresponding to the entries $K[\underline{i},{\cal B}^{\prime}]$ and $K[\underline{i^{\prime}},{\cal B}^{\prime}]$, no matter which block occurs first, the first element of $\bigcup_{B\in{\cal B}^{\prime}}B$ cannot appear before the $i_{l+1}$th position of the first segment. Therefore, due to our definition of the table $K$, it can be verified that $K[\underline{i},{\cal B}^{\prime}]=K[\underline{i^{\prime}},{\cal B}^{\prime}]=K[i_{l+1},{\cal B}^{\prime}]$. The proof of the remaining assertions of the lemma (i.e., $K[\underline{i},{\cal B}^{\prime}]=K[\underline{i^{\prime}},{\cal B}^{\prime}]$ for $1\leq\underline{i}\neq\underline{i^{\prime}}\leq i_{1}$, and $K[\underline{i},{\cal B}^{\prime}]=K[\underline{i^{\prime}},{\cal B}^{\prime}]$ for $i_{\ell}<\underline{i}\neq\underline{i^{\prime}}\leq n$) is analogous. ∎

The first lemma asserts that, in the column of the table $K$ corresponding to ${\cal B}^{\prime}$, the entries of the rows whose indices belong to $\left\{h+_{n}1\,|\,h\in\bigcup_{B\in{\cal B}^{\prime}}B\right\}$ do not need to be computed. The second lemma states that, if $\sigma({\cal B}^{\prime})=\left\langle i_{1},i_{2},\ldots,i_{\ell}\right\rangle$ is an increasing sequence whose elements are the elements of $\bigcup_{B\in{\cal B}^{\prime}}B$, then in the column of the table $K$ corresponding to ${\cal B}^{\prime}$, the entries of the rows whose indices belong to $\{1,2,\ldots,i_{1}\}$ are all equal to each other, the entries of the rows whose indices belong to $\{i_{l}+2,i_{l}+3\ldots,i_{l+1}\}$, $l\in[\ell-1]$, are all equal to each other, and the entries of the rows whose indices belong to $\{i_{\ell}+2,i_{\ell}+3\ldots,n\}$ are all equal to each other. It should be highlighted that, if for some $l\in[\ell-1]$, $i_{l}$ and $i_{l+1}$ are two consecutive integers, then $\{i_{l}+2,i_{l}+3\ldots,i_{l+1}\}$ is empty. Therefore, we do not need to do anything about it, which means even less computational effort. Similarly, if $i_{\ell}=n-1$, then $\{i_{\ell}+2,i_{\ell}+3\ldots,n\}$ is empty, and the same conclusion holds.

Example 4**.**

Consider the TMP instance given by (1). For the subset ${\cal B}^{\prime}=\{B_{1},B_{2},B_{3}\}$ of ${\cal B}$, we have $\sigma({\cal B}^{\prime})=\langle 1,4,5,10,11,12,13,14,17\rangle.$ Therefore, only four entries in the column corresponding to ${\cal B}^{\prime}$ need be computed, one corresponding to each of the sets $\{1\}$, $\{3,4\}$, $\{7,8,9,10\}$, and $\{16,17\}$. The other entries in this column either do not need to be computed at all or require to simply be retrieved according to Lemma 2. Without the aid of the above two lemmas, we need to obtain all $n=17$ entries in this column.

Now we are ready to present the improved version of our algorithm. The improved version, the procedure Memoized-DP-TMP, which is detailed in Algorithm 3, is indeed a top-down (recursive) memoized version of the procedure Bottom-Up-DP-TMP that takes advantage of the results stated in Lemmas 1 and 2. In a bottom-up dynamic-programming algorithm, we fill a table with solutions to all smaller subinstances. But solutions to some of these smaller subinstances may not be necessarily required for obtaining a solution to the original instance. In fact, in a DP framework, we do not necessarily need to solve all the subinstances in order to find an optimal solution to the original problem. It is natural to try to develop an improved mechanism that solves only those subinstances that are necessarily needed. This approach is called Memoization [14]. The procedure Memoized-DP-TMP, shown in Algorithm 3, exactly as in the procedure Bottom-Up-DP-TMP, makes use of a table, but it computes the entries of this table in an as-needed fashion. The table is initially filled with $-1$s. The value $-1$ indicates that the corresponding subinstance has not yet been solved. Indeed, the table entries initially contain $-1$ values to indicate that they have not yet been filled in. Whenever the optimal value of a subinstance needs to be obtained, the procedure Lookup, shown in Algorithm 3, checks the corresponding entry in the table $K$ first. If the entry is not equal to $-1$, it is simply retrieved from the table (lines 2–4 of the procedure Lookup); otherwise, it is computed by making recursive calls (line 5 of the procedure Lookup). The result is then recorded in the table with respect to Lemmas 1 and 2. This means that when the value of the $(\underline{i},{\cal B}^{\prime})$-entry of $K$ is computed recursively, then the result is stored not only in the entry itself, but also in the entries whose values are equal to that of the $(\underline{i},{\cal B}^{\prime})$-entry by virtue of Lemmas 1 and 2 (lines 8–20 of the procedure Lookup). Notice that the procedure Memoized-DP-TMP only returns the value of an optimal solution. This is for the sake of brevity and clarity. It can easily be modified so that it can produce the table $T$, which is required as an input to Print-Optimal-Solution, as well.

IV Computational Results

This section is devoted to evaluating the performance of the proposed technique against the best currently available approach to the TMP, which is a DP procedure based on the principle of inclusion-exclusion, proposed in [5]. The comparison has been made using 540 randomly generated instances of the TMP, in its optimization version (10 instances for each considered value of $n$ and $t$).333The literature on the Train Marshalling Problem is relatively recent. To our knowledge, there is no benchmark dataset available in the literature for the problem. We therefore created our own dataset, which introduces a rather wide range of TMP instances, with varying values of $n$ and $t$. We have made all the problem instances, as well as their optimal solutions, available online on the webpage https://github.com/hfalsafain/Train-Marshalling-Problem. All codes will also be made available to download after publication.

No experimental results have been reported in [5]. The following results are therefore based on our own implementation of the algorithm described in [5]. Care was taken to implement the algorithms as efficiently as possible. However, this certainly does not mean that there is no room for improvement. The algorithms have been implemented in Maple 18.00, and the experiments have been carried out on an Intel Core i5-3330 CPU at 3.0–3.2 GHz desktop computer with 4.00 GB of RAM, running Microsoft Windows 8.1 operating system.

Before going further, let us describe a simple preprocessing step that, without altering the optimal value, can reduce the number of railcars in the input instance (see [5, Lemma 1]). This consequently can reduce the execution time of the algorithms. Let an instance $(n,t,{\cal B})$ of the TMP be given. If there exist $n^{\prime}\geq 2$ consecutive railcars that all share the same destination, then the instance $(n-n^{\prime}+1,t,{\cal B}^{\prime})$ obtained by keeping only one of these railcars and removing the others, has the same optimal value as the original. Therefore, we can safely shrink the number of railcars in the given instance by repeatedly eliminating all such railcars.

A comparison of the average running times (in seconds) of our method (the procedure Memoized-DP-TMP) against those of the method of [5] is tabulated in Table I. As stated above, for each considered value of $n$ and $t$, 10 instances have been solved. The table reports the average solution time per instance. In all runs, we imposed a time limit of 5000 seconds. In the table, “TLE” stands for “Time Limit Exceeded.” It should be noticed that the method of [5] is inherently designed for solving the decision version of the TMP. But it can be employed for solving the optimization version of the problem as well, by means of a binary search procedure, as stated in Section I. The resulting algorithm is of time complexity $O(nt^{2}2^{t}U\log_{2}U)$, where $U$ is an upper-bound on the optimal number of classification tracks. In our implementation of the approach of [5], we have used the upper bound $U=\min\left\{t,\left\lceil\frac{n}{4}+\frac{1}{2}\right\rceil\right\}$. (Trivially, the minimum number of classification tracks needed for rearranging the railcars in an appropriate order is at most $t$. Furthermore, it has been shown in [6, Section 3] that the value of an optimal solution to a TMP instance with $n$ railcars is at most $\left\lceil\frac{n}{4}+\frac{1}{2}\right\rceil$. See also [5, Theorem 3].) Using a more restrictive upper bound, can obviously reduce the number of calls to a procedure for solving the decision problem (during the binary search procedure). However, our Algorithm 3 requires much less computation time, even compared to the time required for a single call to the algorithm given in [5] for solving a specific decision problem instance (i.e., for a specific value of $k$). For some of the considered values of $n$ and $t$, Table II provides a comparison of the average running times of our procedure Memoized-DP-TMP with those of each of the calls to the procedure described in [5] for solving the decision version of the problem (called as DTMP in [5, Algorithm 3]). As is evident from both Tables I and II, our algorithm substantially outperforms its inclusion-exclusion-based counterpart in terms of computation time.

We conclude this section by making a remark concerning the space complexity of our approach. Given a TMP instance $(n,t,{\cal B})$ and given $k\in{\mathbb{N}}$, for deciding whether or not the railcars can be rearranged in an appropriate order by using at most $k$ classification tracks, the algorithm described in [5] requires $O(nkt^{2}2^{t})$ time and $O(nkt)$ space. On the other hand, our approach, in its worst-case behavior, requires $O(nt2^{t})$ time and $O(n2^{t})$ space for making such a decision. Therefore, from the time complexity point of view, our approach is superior to the approach described in [5]. However, in contrast to the method of [5], our algorithm requires exponential space with respect to $t$.444As stated in Section I, the method of [5] does not return an optimal solution itself. In fact, this algorithm, when used for solving the decision version of the TMP, only returns a yes/no answer, and when used for solving the optimization version of the TMP (in the manner descrined in Section I), only computes the value of an optimal solution. On the other hand, as has been discussed in the previous section, our approach not only returns the value of an optimal solution, but also the solution itself. Although typically a dynamic programming algorithm that only returns the value of an optimal solution can easily be modified in such a way that it can return an optimal solution itself [14, Chapter 15], it seems to us that modification of the method of [5] so that it can construct an optimal solution itself leads to an exponential growth in the space complexity.

V Conclusions

In this contribution, we developed a novel dynamic programming approach to the Train Marshalling Problem (TMP) whose worst-case time complexity is linear in the number of railcars, exponential in the number of destinations. One noticeable difference between our approach and the previously proposed exact approaches to the TMP is that, in contrast with the previous works, our algorithm is designed to deal directly with the optimization version of the problem. The worst-case time complexity of our method, like that of previous exact methods, is exponential with respect to the number of destinations. However, in practice, our approach performs substantially better than the best currently available approach, which is an inclusion-exclusion-based dynamic programming algorithm. Our algorithm can effectively tackle instances with relatively large values of $t$. For example, it can solve, to optimality, instances involving $1000$ railcars and $15$ destinations in about $1\frac{1}{4}$ hours. The superior performance of the proposed technique can mainly be attributed to the following two reasons. Firstly, we group together the subinstances that have the same optimal solution. The optimal solution is computed only once for each group. Secondly, we employ the memoization technique to solve only those subinstances whose optimal solutions are necessarily needed to solve the original instance. In fact, the main benefit of this technique is that only those table entries that are needed are computed, whereas in the bottom-up implementation, all table entries get computed blindly. This can significantly reduce the amount of computation necessary. Another advantage of our method compared to its inclusion-exclusion-based counterpart is that our exact algorithm is capable of finding not only the value of an optimal solution (i.e., the minimum number of required classification tracks), but also the solution itself as well.