...one of the most highly
regarded and expertly designed C++ library projects in the
world.

— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards

// named parameter versiontemplate <class Graph, class P, class T, class R> void cycle_canceling( Graph &g, const bgl_named_params<P, T, R> & params =all defaults)// non-named parameter versiontemplate <class Graph, class Pred, class Distance, class Reversed, class ResidualCapacity, class Weight> void cycle_canceling(const Graph & g, Weight weight, Reversed rev, ResidualCapacity residual_capacity, Pred pred, Distance distance)

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)* 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

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 *G _{in} = (V,{E U
E^{T}})*. The

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

The algorithm is described in Network Flows.

In each round 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 now it.

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

`boost/graph/successive_shortest_path_nonnegative_weights.hpp`

A directed graph. The graph's type must be a model of VertexListGraph and IncidenceGraph For each edge(u,v)in the graph, the reverse edge(v,u)must also be in the graph.

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.IN:

Default:get(edge_residual_capacity, g)

An edge property map that maps every edgeIN:(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)

The weight (also know as ``length'' or ``cost'') of each edge in the graph. TheUTIL:WeightMaptype 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 beAddablewith the distance map's value type.

Default:get(edge_weight, g)

Use 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:

Default:aniterator_property_mapcreated from astd::vectorof edge descriptors of sizenum_vertices(g)and using thei_mapfor the index map.

The shortest path weight from the source vertexIN:sto each vertex in the graphgis recorded in this property map. The shortest path weight is the sum of the edge weights along the shortest path. The typeDistanceMapmust 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_mapcreated from astd::vectorof theWeightMap's value type of sizenum_vertices(g)and using thei_mapfor the index 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 internalvertex_indexproperty. For example,adjacency_listwithVertexList=listSdoes not have an internalvertex_indexproperty.

Copyright © 2013 | Piotr Wygocki, University of Warsaw (wygos at mimuw.edu.pl) |