Test setup

Our test suite comprises numerous networks of various sizes and characteristics. Most of these networks were generated using standard random generators NETGEN, GRIDGEN, GOTO, and GRIDGRAPH, which are available as source codes on the website of the 1st DIMACS Implementation Challenge [80]. We used these generators with similar parameter settings as previous works (e.g., [34, 35,50,99,118,120,168]), but we created larger networks as well. Other problem families were also generated based on either real-life road networks or maximum flow problems arising in computer vision applications. All instances involve solely integer data.

This collection was introduced in [2, 3] and can be accessed at [8]. Later, other inde-pendent studies also used some of these problem families, for example, [23, 200].

The presented experiments were conducted on a machine with AMD Opteron Dual Core 2.2 GHz CPU and 16 GB RAM (1 MB cache), running openSUSE 11.4 operating system. All codes were compiled with GCC 4.5.3 using -O3 optimization flag.

NETGEN networks

NETGEN is a classic generator developed by Klingman et al. [157]. It produces ran-dom instances of the MCF problem and other network optimization problems. In fact, NETGEN is known to create easy MCF instances.

We generated NETGEN networks as follows. Arc capacities and costs were selected uniformly at random from the ranges [1..1000] and [1..10000], respectively. The number of supply nodes and the number of demand nodes were both set to√

n (rounded to integer), and the average amount of supply per supply node was set to 1000. We defined two

problem families that differ in the density of the networks since this parameter turned out to have the most significant impact on the performance of different algorithms.

• NETGEN-8. Sparse networks; m = 8n.

• NETGEN-SR. Dense networks; m ≈ n√ n.

GRIDGEN networks

GRIDGEN is a random generator that produces grid-like networks. It was written by Lee and Orlin [163]. We used the same parameters for GRIDGEN families as for the corre-sponding NETGEN families. Furthermore, we set the width of the grid to √

n (rounded to integer) for each instance. In fact, the shape of the grid did not turn out to be an important parameter, as GRIDGEN selects the supply and demand nodes uniformly at random.

• GRIDGEN-8. Sparse networks; m = 8n.

• GRIDGEN-SR. Dense networks; m ≈ n√ n.

GOTO networks

Another standard generator for the MCF problem is GOTO (“Grid On Torus”), which was developed by Goldberg [120]. It generates instances that are known to be rather hard, using a grid layout on the surface of a torus. Each GOTO instance has one supply node and one demand node, and the supply value is adjusted according to the arc capacities.

Similarly to the previous generators, we generated two GOTO families. The maximum arc capacity and cost were set to 1000 and 10000, respectively.

• GOTO-8. Sparse networks; m = 8n.

• GOTO-SR. Dense networks; m ≈ n√ n.

GRIDGRAPH networks

GRIDGRAPH generator was written by Resende and Veiga [208]. It also produces grid networks similarly to GRIDGEN but using a stricter scheme. A GRIDGRAPH network consists of transshipment nodes forming a grid of W rows and L columns, together with a single source node s and a single sink node t. Arcs go from s to the nodes of the first column; from the nodes of the last column to t; and from each transshipment node (w, l) to nodes (w + 1, l) and (w, l + 1), except for the last row and column, respectively. The arc capacities and costs are set uniformly at random within a specified range.

The shape of the grid is the most important property in the case of a GRIDGRAPH instance, so we specified two families based on grids of different shapes. The maximum arc capacity and cost were set to 1000 and 10000, respectively.

• GRID-WIDE. Wide grids; L = 16 and W increases.

• GRID-LONG. Long grids; W = 16 and L increases.

ROAD networks

Special MCF instances based on real-world road networks were also included in our exper-iments. To generate such instances, we used the TIGER/Line road network files of several states of the USA. These data files are available on the website of the 9th DIMACS Implementation Challenge [79].

We selected seven states having road networks of increasing size (namely, DC, DE, NH, NV, WI, FL, and TX) and generated MCF problem instances as follows. The orig-inal undirected graphs were converted to directed graphs by replacing each edge with two oppositely directed arcs. The cost of an arc was set to the travel time on the cor-responding road section. We selected K supply nodes and K demand nodes randomly, where K = b√

n/10c. Then the supply-demand values were determined by a maximum flow computation to maximize the total supply with respect to the fixed arc capacities and fixed set of supply and demand nodes.

We generated two problem families with different arc capacity settings.

• ROAD-PATHS. The capacity of each arc is 1. That is, a specified number of arc-disjoint directed paths are to be found from supply nodes to demand nodes with minimum total cost.

• ROAD-FLOW. The capacity of an arc is set to 40, 60, 80, or 100 according to the category of the corresponding road section.

VISION networks

Our test suite also contains MCF instances based on large-scale maximum flow problems arising in computer vision applications. The corresponding data files were made available by the Computer Vision Research Group at the University of Western Ontario [63] for benchmarking maximum flow algorithms (see, e.g., [119]).

We used some of the segmentation instances related to medical image analysis, which are defined on three-dimensional grid networks. Those variants were selected in which the underlying graphs are 6-connected and the maximum arc capacity is 100 (the bone sub* n6c100 files). We converted these networks to minimum-cost maximum flow instances using different arc cost functions. The original networks also contain arcs of zero capacity, but we skipped these arcs during the transformation and thereby did not preserve the exact 6-connectivity.

• VISION-RND. The arc costs are selected uniformly at random from the range [1..100].

• VISION-PROP. The cost of an arc is approximately proportional to its capacity:

c_ij = bα_iju_ijc, where α_ij is a random factor selected uniformly from the range [0.9, 1.1).

• VISION-INV. The cost of an arc is approximately inversely proportional to its capacity: c_ij = bα_ijK/u_ijc, where K = 1000 and α_ij is a random factor selected uniformly from the range [0.9, 1.1).

For all problem families introduced above, we generated five instances of each network size using different random seeds. Throughout this section, we always report the average running time over such five instances.