Balachandran Vaidyanathan

Multicommodity network flow approach to the railroad crew-scheduling problem

We present our solution to the crew-scheduling problem Jor North American railroads. (Crew scheduling in North America is very different from scheduling in Europe, where it has been well studied.) The crew-scheduling problem is to assign operators to scheduled trains over a time horizon at minimal cost while honoring operational and contractual requirements. Currently, decisions related to crew are made manually. We present our work developing a network-flow-based crew-optimization model that can be applied at the tactical, planning, and strategic levels of crew scheduling. Our network flow model maps the assignment of crews to trains as the flow of crews on an underlying network, where different crew types are modeled as different commodities in this network. We formulate the problem as an integer programming problem on this network, which allows it to be solved to optimality. We also develop several highly efficient algorithms using problem decomposition and relaxation techniques, in which we use the special structure of the underlying network model to obtain significant increases in speed. We present very promising computational results of our algorithms on the data provided by a major North American railroad. Our network flow model is likely to form a backbone for a decision-support system for crew scheduling.

Fast Algorithms for Specially Structured Minimum Cost Flow Problems with Applications

The objective of the classical minimum cost flow problem is to send units of a good that reside at one or more points in a network (sources or supply nodes) with arc capacities to one or more other points in the network (sinks or demand nodes), incurring minimum cost. We develop fast algorithms for previously unstudied specially structured minimum cost flow problems that have applications in many areas, such as locomotive and airline scheduling, repositioning of empty rail freight cars, highway and river transportation, congestion pricing, shop loading, and production planning. First, we consider the case where the n1 supply and n2 demand nodes lie on a circle (or line) (n = n1 + n2) and flow is allowed only in one direction; our algorithm solves this problem in O(n) time. Next, we consider a constrained version of this problem and show that it can be solved in O(n log n2) time. Finally, we consider the version where the nodes lie on a circle (or line), flow is allowed in both directions, and the costs of flow between two nodes in the clockwise and the counterclockwise direction are different; our algorithm solves this problem in O(n log n) time. Our algorithms are based on the successive shortest-path algorithm for the minimum cost flow problem. We exploit the special structure of the problem and use advanced data structures, when required, to achieve short run times.

Faster strongly polynomial algorithms for the unbalanced transportation problem and assignment problem with monge costs

We consider a transportation problem where the cost matrix satisfies the Monge property. The problem has supply nodes N1(|N1| = n1), demand nodes N2(|N2| = n2), supply si ≥ 0 for i∈N1, and demand dj ≥ 0 for j∈N2(n = n1 + n2,m = n1n2). When the total supply is equal to the total demand, the problem can be solved in O(n) time using the northwest corner rule (Hoffman [10]). This algorithm and run-time, however, do not extend to the unbalanced case, where the total supply is not equal to the total demand. The fastest strongly polynomial run-time for the unbalanced transportation problem with Monge costs is O(nlog n(m + nlog n)), and for the unbalanced assignment problem (unit supplies and demands) with Monge costs is O(n(m + nlog n)). In this article, we describe a simple algorithm that solves the unbalanced transportation problem with Monge costs in O(mn1) time and the unbalanced assignment problem with Monge costs in O(m) time using elementary data structures. We also develop a faster implementation of the algorithm that utilizes a heap, a self-balancing binary search tree, and dynamic trees, and solves the transportation problem with Monge costs in O(mlog n1) time. Our algorithms improve the run-times for: (i) the unbalanced transportation problem with Monge costs by a factor of nlog n/log n1 or better and (ii) the unbalanced assignment problem with Monge costs by a factor of n or better.

Simple linear flow decomposition algorithms on trees, circles, and augmented trees

The flow decomposition algorithm transforms an arc flow-based solution to a network flow problem into flows on directed paths and cycles. When the undirected graph induced by arcs with positive flow is a tree, a circle, or an augmented tree (with n nodes), the standard implementation of the algorithm runs in O (n2) time. In this article, we exploit the structure of the network to develop an O (n) flow decomposition algorithm. The run-time relies on the property that for these networks, paths or cycles can be represented implicitly in O (1) space. The algorithm is easy to implement and does not use complicated data structures. Because the size of the input is O (n), our algorithm is the fastest possible for flow decomposition on these special networks. Our algorithm can be used to improve run-times for solving matching and transportation problems on trees and circles.

Fast algorithms for convex cost flow problems on circles, lines, and trees

We develop efficient algorithms to solve convex cost flow problems where the underlying graph is a circle, a line, or a tree. Each node i has an associated supply/demand b( i). The cost of sending flow on arc ( i, j) is a piecewise linear convex function fij defined over . Let n be the number of nodes and m = O(n) be the total number of pieces of all the convex functions. A flow x is feasible if the imbalances on all nodes are nonnegative. Excess stored on node i has an associated linear cost . We show that the problem on a circle can be transformed into an equivalent problem on a line in O( n) time. Thereafter, we develop an algorithm that solves the problem on a line in time, where sort( n) is the time to sort n real numbers and is the inverse Ackermann function. We also prove that when the nodes lie on a tree, the problem can be solved in time using the dynamic tree data structure. We describe applications in areas such as distributed computing, lot-sizing, computational biology, computational music, and transportation.