This documentation is being rewritten. If something looks off, please cross-check with the Boost 1.91.0 Boost.Graph docs and open an issue.

Cycle Canceling for Min Cost Max Flow

Calculates the minimum cost flow of a network with given flow by iteratively canceling negative-cost cycles in the residual graph.

Complexity: O(C * |V| * |E|) for integer capacities/weights, where C is the initial flow cost
Defined in: <boost/graph/cycle_canceling.hpp>

Example

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/cycle_canceling.hpp>
#include <boost/graph/edmonds_karp_max_flow.hpp>
#include <boost/graph/find_flow_cost.hpp>
#include <iostream>
#include <vector>

using namespace boost;

using Traits = adjacency_list_traits<vecS, vecS, directedS>;
struct Edge {
    int capacity;
    int residual_capacity;
    int weight;
    Traits::edge_descriptor reverse;
};

using Graph = adjacency_list<vecS, vecS, directedS, no_property, Edge>;
using Descriptor = graph_traits<Graph>::edge_descriptor;
using Vertex = graph_traits<Graph>::vertex_descriptor;

void add_edge_pair(Graph& g, int u, int v, int cap, int cost) {
    Descriptor e = add_edge(u, v, g).first;
    Descriptor r = add_edge(v, u, g).first;
    g[e].capacity = cap;  g[r].capacity = 0;
    g[e].weight = cost;   g[r].weight = -cost;
    g[e].reverse = r;     g[r].reverse = e;
}

int main() {
    Graph g(4);
    add_edge_pair(g, 0, 1, 2, 1);
    add_edge_pair(g, 0, 2, 1, 3);
    add_edge_pair(g, 1, 3, 2, 2);
    add_edge_pair(g, 2, 3, 3, 1);

    auto cap = get(&Edge::capacity, g);
    auto res = get(&Edge::residual_capacity, g);
    auto rev = get(&Edge::reverse, g);
    auto wgt = get(&Edge::weight, g);

    std::vector<default_color_type> color(num_vertices(g));
    std::vector<Descriptor> pred(num_vertices(g));
    std::vector<int> dist(num_vertices(g));
    auto idx = get(vertex_index, g);

    edmonds_karp_max_flow(g, Vertex(0), Vertex(3), cap, res, rev,
        make_iterator_property_map(color.begin(), idx),
        make_iterator_property_map(pred.begin(), idx));

    cycle_canceling(g, wgt, rev, res,
        make_iterator_property_map(pred.begin(), idx),
        make_iterator_property_map(dist.begin(), idx));

    int cost = find_flow_cost(g, cap, res, wgt);
    std::cout << "Min cost: " << cost << "\n";
}
Min cost: 10

(1) Positional version

template <typename Graph, typename Pred, typename Distance,
          typename Reversed, typename ResidualCapacity,
          typename Weight>
void cycle_canceling(
    const Graph& g,
    Weight weight,
    Reversed rev,
    ResidualCapacity residual_capacity,
    Pred pred,
    Distance distance);
Direction Parameter Description

IN

const Graph& g

A directed graph. The graph’s type must be a model of Vertex List Graph and Incidence Graph. For each edge (u,v) in the graph, the reverse edge (v,u) must also be in the graph.

IN

Weight weight

The weight (also known as "length" or "cost") of each edge in the graph. The Weight type must be a model of Readable Property Map. The key type for this property map must be the edge descriptor of the graph. The value type for the weight map must be Addable with the distance map’s value type.

IN

Reversed rev

An edge property map that maps every edge (u,v) in the graph to the reverse edge (v,u). The map must be a model of constant Lvalue Property Map. The key type of the map must be the graph’s edge descriptor type.

IN/OUT

ResidualCapacity residual_capacity

This maps edges to their residual capacity. The type must be a model of a mutable Lvalue Property Map. The key type of the map must be the graph’s edge descriptor type.

UTIL

Pred pred

Used by the algorithm to store augmenting paths. The map must be a model of mutable Lvalue Property Map. The key type must be the graph’s vertex descriptor type and the value type must be the graph’s edge descriptor type.

UTIL

Distance distance

The shortest path weight from the source vertex to each vertex in the graph g is recorded in this property map. The shortest path weight is the sum of the edge weights along the shortest path. The type Distance must be a model of Read/Write Property Map. The vertex descriptor type of the graph needs to be usable as the key type of the distance map.

(2) Named parameter version

template <typename Graph, typename P, typename T, typename R>
void cycle_canceling(
    Graph& g,
    const bgl_named_params<P, T, R>& params = all defaults);
Direction Parameter Description

IN

Graph& g

A directed graph. The graph’s type must be a model of Vertex List Graph and Incidence Graph. For each edge (u,v) in the graph, the reverse edge (v,u) must also be in the graph.

IN

params

Named parameters passed via bgl_named_params. The following are accepted:
Direction Named Parameter Description / Default

IN/OUT

residual_capacity_map(ResidualCapacityEdgeMap res)

This maps edges to their residual capacity. The type must be a model of a mutable Lvalue Property Map. The key type of the map must be the graph’s edge descriptor type.
Default: get(edge_residual_capacity, g)

IN

reverse_edge_map(ReverseEdgeMap rev)

An edge property map that maps every edge (u,v) in the graph to the reverse edge (v,u). The map must be a model of constant Lvalue Property Map. The key type of the map must be the graph’s edge descriptor type.
Default: get(edge_reverse, g)

IN

weight_map(WeightMap w)

The weight (also known as "length" or "cost") of each edge in the graph. The WeightMap type must be a model of Readable Property Map. The key type for this property map must be the edge descriptor of the graph. The value type for the weight map must be Addable with the distance map’s value type.
Default: get(edge_weight, g)

UTIL

predecessor_map(PredEdgeMap pred)

Used by the algorithm to store augmenting paths. The map must be a model of mutable Lvalue Property Map. The key type must be the graph’s vertex descriptor type and the value type must be the graph’s edge descriptor type.
Default: an iterator_property_map created from a std::vector of edge descriptors of size num_vertices(g) and using the i_map for the index map.

UTIL

distance_map(DistanceMap d_map)

The shortest path weight from the source vertex to each vertex in the graph g is recorded in this property map. The shortest path weight is the sum of the edge weights along the shortest path. The type DistanceMap must be a model of Read/Write Property Map. The vertex descriptor type of the graph needs to be usable as the key type of the distance map.
Default: iterator_property_map created from a std::vector of the WeightMap’s value type of size `num_vertices(g) and using the i_map for the index map.

IN

vertex_index_map(VertexIndexMap i_map)

Maps each vertex of the graph to a unique integer in the range [0, num_vertices(g)). This property map is only needed if the default for the distance or predecessor map is used. The vertex index map must be a model of Readable Property Map. The key type of the map must be the graph’s vertex descriptor type.
Default: get(vertex_index, g). Note: if you use this default, make sure your graph has an internal vertex_index property. For example, adjacency_list with VertexList=listS does not have an internal vertex_index property.

Description

The cycle_canceling() function calculates the minimum cost flow of a network with given flow. See Section Network Flow Algorithms for a description of maximum flow. For given flow values f(u,v), the function minimizes flow cost in such a way that for each v in V the sum~u in V~ f(v,u) is preserved. Particularly if the input flow was the maximum flow, the function produces min cost max flow.

The function calculates the flow values f(u,v) for all (u,v) in E, which are returned in the form of the residual capacity r(u,v) = c(u,v) - f(u,v).

There are several special requirements on the input graph and property map parameters for this algorithm. First, the directed graph G=(V,E) that represents the network must be augmented to include the reverse edge for every edge in E. That is, the input graph should be Gin = (V,{E U ET}). The ReverseEdgeMap argument rev must map each edge in the original graph to its reverse edge, that is (u,v) → (v,u) for all (u,v) in E. The WeightMap has to map each edge from ET to -weight of its reversed edge. Note that edges from E can have negative weights.

If weights in the graph are nonnegative, the successive_shortest_path_nonnegative_weights() might be a better choice for min cost max flow.

The algorithm is described in Network Flows.

In each round the algorithm augments the negative cycle (in terms of weight) in the residual graph. If there is no negative cycle in the network, the cost is optimized.

Note that, although we mention capacity in the problem description, the actual algorithm doesn’t have to know it.

In order to find the cost of the result flow use: find_flow_cost().

Edit this Page