/// \ingroup min_cost_flow

 /// \ingroup min_cost_flow_algs

 ///

 /// \brief Cycle-canceling algorithm for finding a minimum cost flow.

 /// \brief Cycle-canceling algorithms for finding a minimum cost flow.

   /// \addtogroup min_cost_flow

   /// \addtogroup min_cost_flow_algs

   /// \brief Implementation of a cycle-canceling algorithm for

   /// \brief Implementation of cycle-canceling algorithms for

   /// finding a minimum cost flow.

   /// finding a \ref min_cost_flow "minimum cost flow".

   /// \ref CycleCanceling implements a cycle-canceling algorithm for

   /// \ref CycleCanceling implements three different cycle-canceling

   /// finding a minimum cost flow.

   /// algorithms for finding a \ref min_cost_flow "minimum cost flow".

   /// The most efficent one (both theoretically and practically)

   /// is the \ref CANCEL_AND_TIGHTEN "Cancel and Tighten" algorithm,

   /// thus it is the default method.

   /// It is strongly polynomial, but in practice, it is typically much

   /// slower than the scaling algorithms and NetworkSimplex.

   /// \tparam Digraph The digraph type the algorithm runs on.

   /// Most of the parameters of the problem (except for the digraph)

   /// \tparam LowerMap The type of the lower bound map.

   /// can be given using separate functions, and the algorithm can be

   /// \tparam CapacityMap The type of the capacity (upper bound) map.

   /// executed using the \ref run() function. If some parameters are not

   /// \tparam CostMap The type of the cost (length) map.

   /// specified, then default values will be used.

   /// \tparam SupplyMap The type of the supply map.

   /// \warning

   /// \tparam GR The digraph type the algorithm runs on.

   /// - Arc capacities and costs should be \e non-negative \e integers.

   /// \tparam V The number type used for flow amounts, capacity bounds

   /// - Supply values should be \e signed \e integers.

   /// and supply values in the algorithm. By default, it is \c int.

   /// - The value types of the maps should be convertible to each other.

   /// \tparam C The number type used for costs and potentials in the

   /// - \c CostMap::Value must be signed type.

   /// algorithm. By default, it is the same as \c V.

   /// \note By default the \ref BellmanFord "Bellman-Ford" algorithm is

   /// \warning Both number types must be signed and all input data must

   /// used for negative cycle detection with limited iteration number.

   /// be integer.

   /// However \ref CycleCanceling also provides the "Minimum Mean

   /// \warning This algorithm does not support negative costs for such

   /// Cycle-Canceling" algorithm, which is \e strongly \e polynomial,

   /// arcs that have infinite upper bound.

   /// but rather slower in practice.

   /// To use this version of the algorithm, call \ref run() with \c true

   /// parameter.

   /// \author Peter Kovacs

   /// \note For more information about the three available methods,

   template < typename Digraph,

   /// see \ref Method.

              typename LowerMap = typename Digraph::template ArcMap<int>,

 #ifdef DOXYGEN

              typename CapacityMap = typename Digraph::template ArcMap<int>,

   template <typename GR, typename V, typename C>

              typename CostMap = typename Digraph::template ArcMap<int>,

 #else

              typename SupplyMap = typename Digraph::template NodeMap<int> >

   template <typename GR, typename V = int, typename C = V>

 #endif

     /// The type of the flow map.

     /// The type of the digraph

     typedef typename Digraph::template ArcMap<Capacity> FlowMap;

     typedef GR Digraph;

     /// The type of the potential map.

     /// The type of the flow amounts, capacity bounds and supply values

     typedef typename Digraph::template NodeMap<Cost> PotentialMap;

     typedef V Value;

     /// The type of the arc costs

     typedef C Cost;

   public:

     /// \brief Problem type constants for the \c run() function.

     ///

     /// Enum type containing the problem type constants that can be

     /// returned by the \ref run() function of the algorithm.

     enum ProblemType {

       /// The problem has no feasible solution (flow).

       INFEASIBLE,

       /// The problem has optimal solution (i.e. it is feasible and

       /// bounded), and the algorithm has found optimal flow and node

       /// potentials (primal and dual solutions).

       OPTIMAL,

       /// The digraph contains an arc of negative cost and infinite

       /// upper bound. It means that the objective function is unbounded

       /// on that arc, however, note that it could actually be bounded

       /// over the feasible flows, but this algroithm cannot handle

       /// these cases.

       UNBOUNDED

     };

     /// \brief Constants for selecting the used method.

     ///

     /// Enum type containing constants for selecting the used method

     /// for the \ref run() function.

     ///

     /// \ref CycleCanceling provides three different cycle-canceling

     /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel and Tighten"

     /// is used, which proved to be the most efficient and the most robust

     /// on various test inputs.

     /// However, the other methods can be selected using the \ref run()

     /// function with the proper parameter.

     enum Method {

       /// A simple cycle-canceling method, which uses the

       /// \ref BellmanFord "Bellman-Ford" algorithm with limited iteration

       /// number for detecting negative cycles in the residual network.

       SIMPLE_CYCLE_CANCELING,

       /// The "Minimum Mean Cycle-Canceling" algorithm, which is a

       /// well-known strongly polynomial method. It improves along a

       /// \ref min_mean_cycle "minimum mean cycle" in each iteration.

       /// Its running time complexity is O(n<sup>2</sup>m<sup>3</sup>log(n)).

       MINIMUM_MEAN_CYCLE_CANCELING,

       /// The "Cancel And Tighten" algorithm, which can be viewed as an

       /// improved version of the previous method.

       /// It is faster both in theory and in practice, its running time

       /// complexity is O(n<sup>2</sup>m<sup>2</sup>log(n)).

       CANCEL_AND_TIGHTEN

     };

     /// \brief Map adaptor class for handling residual arc costs.

     TEMPLATE_DIGRAPH_TYPEDEFS(GR);

     ///

     /// Map adaptor class for handling residual arc costs.

     typedef std::vector<int> IntVector;

     class ResidualCostMap : public MapBase<ResArc, Cost>

     typedef std::vector<char> CharVector;

     typedef std::vector<double> DoubleVector;

     typedef std::vector<Value> ValueVector;

     typedef std::vector<Cost> CostVector;

   private:

     template <typename KT, typename VT>

     class VectorMap {

     public:

       typedef KT Key;

       typedef VT Value;

       VectorMap(std::vector<Value>& v) : _v(v) {}

       const Value& operator[](const Key& key) const {

         return _v[StaticDigraph::id(key)];

       }

       Value& operator[](const Key& key) {

         return _v[StaticDigraph::id(key)];

       }

       void set(const Key& key, const Value& val) {

         _v[StaticDigraph::id(key)] = val;

       }

     private:

       std::vector<Value>& _v;

     };

     typedef VectorMap<StaticDigraph::Node, Cost> CostNodeMap;

     typedef VectorMap<StaticDigraph::Arc, Cost> CostArcMap;

   private:

     // Data related to the underlying digraph

     const GR &_graph;

     int _node_num;

     int _arc_num;

     int _res_node_num;

     int _res_arc_num;

     int _root;

     // Parameters of the problem

     bool _have_lower;

     Value _sum_supply;

     // Data structures for storing the digraph

     IntNodeMap _node_id;

     IntArcMap _arc_idf;

     IntArcMap _arc_idb;

     IntVector _first_out;

     CharVector _forward;

     IntVector _source;

     IntVector _target;

     IntVector _reverse;

     // Node and arc data

     ValueVector _lower;

     ValueVector _upper;

     CostVector _cost;

     ValueVector _supply;

     ValueVector _res_cap;

     CostVector _pi;

     // Data for a StaticDigraph structure

     typedef std::pair<int, int> IntPair;

     StaticDigraph _sgr;

     std::vector<IntPair> _arc_vec;

     std::vector<Cost> _cost_vec;

     IntVector _id_vec;

     CostArcMap _cost_map;

     CostNodeMap _pi_map;

   public:

     /// \brief Constant for infinite upper bounds (capacities).

     ///

     /// Constant for infinite upper bounds (capacities).

     /// It is \c std::numeric_limits<Value>::infinity() if available,

     /// \c std::numeric_limits<Value>::max() otherwise.

     const Value INF;

   public:

     /// \brief Constructor.

     ///

     /// The constructor of the class.

     ///

     /// \param graph The digraph the algorithm runs on.

     CycleCanceling(const GR& graph) :

       _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph),

       _cost_map(_cost_vec), _pi_map(_pi),

       INF(std::numeric_limits<Value>::has_infinity ?

           std::numeric_limits<Value>::infinity() :

           std::numeric_limits<Value>::max())

     private:

       // Check the number types

       LEMON_ASSERT(std::numeric_limits<Value>::is_signed,

       const CostMap &_cost_map;

         "The flow type of CycleCanceling must be signed");

       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,

     public:

         "The cost type of CycleCanceling must be signed");

       ///\e

       // Resize vectors

       ResidualCostMap(const CostMap &cost_map) : _cost_map(cost_map) {}

       _node_num = countNodes(_graph);

       _arc_num = countArcs(_graph);

       ///\e

       _res_node_num = _node_num + 1;

       Cost operator[](const ResArc &e) const {

       _res_arc_num = 2 * (_arc_num + _node_num);

         return ResDigraph::forward(e) ? _cost_map[e] : -_cost_map[e];

       _root = _node_num;

       }

       _first_out.resize(_res_node_num + 1);

     }; //class ResidualCostMap

       _forward.resize(_res_arc_num);

       _source.resize(_res_arc_num);

   private:

       _target.resize(_res_arc_num);

       _reverse.resize(_res_arc_num);

     // The maximum number of iterations for the first execution of the

     // Bellman-Ford algorithm. It should be at least 2.

       _lower.resize(_res_arc_num);

     static const int BF_FIRST_LIMIT  = 2;

       _upper.resize(_res_arc_num);

     // The iteration limit for the Bellman-Ford algorithm is multiplied

       _cost.resize(_res_arc_num);

     // by BF_LIMIT_FACTOR/100 in every round.

       _supply.resize(_res_node_num);

     static const int BF_LIMIT_FACTOR = 150;

       _res_cap.resize(_res_arc_num);

   private:

       _pi.resize(_res_node_num);

     // The digraph the algorithm runs on

       _arc_vec.reserve(_res_arc_num);

     const Digraph &_graph;

       _cost_vec.reserve(_res_arc_num);

     // The original lower bound map

       _id_vec.reserve(_res_arc_num);

     const LowerMap *_lower;

     // The modified capacity map

       // Copy the graph

     CapacityArcMap _capacity;

       int i = 0, j = 0, k = 2 * _arc_num + _node_num;

     // The original cost map

       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {

     const CostMap &_cost;

         _node_id[n] = i;

     // The modified supply map

       }

     SupplyNodeMap _supply;

       i = 0;

     bool _valid_supply;

       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {

         _first_out[i] = j;

     // Arc map of the current flow

         for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {

     FlowMap *_flow;

           _arc_idf[a] = j;

     bool _local_flow;

           _forward[j] = true;

     // Node map of the current potentials

           _source[j] = i;

     PotentialMap *_potential;

           _target[j] = _node_id[_graph.runningNode(a)];

     bool _local_potential;

         }

         for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {

     // The residual digraph

           _arc_idb[a] = j;

     ResDigraph *_res_graph;

           _forward[j] = false;

     // The residual cost map

           _source[j] = i;

     ResidualCostMap _res_cost;

           _target[j] = _node_id[_graph.runningNode(a)];

         }

   public:

         _forward[j] = false;

         _source[j] = i;

     /// \brief General constructor (with lower bounds).

         _target[j] = _root;

     ///

         _reverse[j] = k;

     /// General constructor (with lower bounds).

         _forward[k] = true;

     ///

         _source[k] = _root;

     /// \param digraph The digraph the algorithm runs on.

         _target[k] = i;

     /// \param lower The lower bounds of the arcs.

         _reverse[k] = j;

     /// \param capacity The capacities (upper bounds) of the arcs.

         ++j; ++k;

     /// \param cost The cost (length) values of the arcs.

       }

     /// \param supply The supply values of the nodes (signed).

       _first_out[i] = j;

     CycleCanceling( const Digraph &digraph,

       _first_out[_res_node_num] = k;

                     const LowerMap &lower,

       for (ArcIt a(_graph); a != INVALID; ++a) {

                     const CapacityMap &capacity,

         int fi = _arc_idf[a];

                     const CostMap &cost,

         int bi = _arc_idb[a];

                     const SupplyMap &supply ) :

         _reverse[fi] = bi;

       _graph(digraph), _lower(&lower), _capacity(digraph), _cost(cost),

         _reverse[bi] = fi;

       _supply(digraph), _flow(NULL), _local_flow(false),

       }

       _potential(NULL), _local_potential(false),

       _res_graph(NULL), _res_cost(_cost)

       // Reset parameters

     {

       reset();

       // Check the sum of supply values

     }

       Supply sum = 0;

     /// \name Parameters

     /// The parameters of the algorithm can be specified using these

     /// functions.

     /// @{

     /// \brief Set the lower bounds on the arcs.

     ///

     /// This function sets the lower bounds on the arcs.

     /// If it is not used before calling \ref run(), the lower bounds

     /// will be set to zero on all arcs.

     ///

     /// \param map An arc map storing the lower bounds.

     /// Its \c Value type must be convertible to the \c Value type

     /// of the algorithm.

     ///

     /// \return <tt>(*this)</tt>

     template <typename LowerMap>

     CycleCanceling& lowerMap(const LowerMap& map) {

       _have_lower = true;

       for (ArcIt a(_graph); a != INVALID; ++a) {

         _lower[_arc_idf[a]] = map[a];

         _lower[_arc_idb[a]] = map[a];

       }

       return *this;

     }

     /// \brief Set the upper bounds (capacities) on the arcs.

     ///

     /// This function sets the upper bounds (capacities) on the arcs.

     /// If it is not used before calling \ref run(), the upper bounds

     /// will be set to \ref INF on all arcs (i.e. the flow value will be

     /// unbounded from above).

     ///

     /// \param map An arc map storing the upper bounds.

     /// Its \c Value type must be convertible to the \c Value type

     /// of the algorithm.

     ///

     /// \return <tt>(*this)</tt>

     template<typename UpperMap>

     CycleCanceling& upperMap(const UpperMap& map) {

       for (ArcIt a(_graph); a != INVALID; ++a) {

         _upper[_arc_idf[a]] = map[a];

       }

       return *this;

     }

     /// \brief Set the costs of the arcs.

     ///

     /// This function sets the costs of the arcs.

     /// If it is not used before calling \ref run(), the costs

     /// will be set to \c 1 on all arcs.

     ///

     /// \param map An arc map storing the costs.

     /// Its \c Value type must be convertible to the \c Cost type

     /// of the algorithm.

     ///

     /// \return <tt>(*this)</tt>

     template<typename CostMap>

     CycleCanceling& costMap(const CostMap& map) {

       for (ArcIt a(_graph); a != INVALID; ++a) {

         _cost[_arc_idf[a]] =  map[a];

         _cost[_arc_idb[a]] = -map[a];

       }

       return *this;

     }

     /// \brief Set the supply values of the nodes.

     ///

     /// This function sets the supply values of the nodes.

     /// If neither this function nor \ref stSupply() is used before

     /// calling \ref run(), the supply of each node will be set to zero.

     ///

     /// \param map A node map storing the supply values.

     /// Its \c Value type must be convertible to the \c Value type

     /// of the algorithm.

     ///

     /// \return <tt>(*this)</tt>

     template<typename SupplyMap>

     CycleCanceling& supplyMap(const SupplyMap& map) {

         _supply[n] = supply[n];

         _supply[_node_id[n]] = map[n];

         sum += _supply[n];

       }

       }

       return *this;

       _valid_supply = sum == 0;

     }

       // Remove non-zero lower bounds

     /// \brief Set single source and target nodes and a supply value.

       for (ArcIt e(_graph); e != INVALID; ++e) {

     ///

         _capacity[e] = capacity[e];

     /// This function sets a single source node and a single target node

         if (lower[e] != 0) {

     /// and the required flow value.

           _capacity[e] -= lower[e];

     /// If neither this function nor \ref supplyMap() is used before

           _supply[_graph.source(e)] -= lower[e];

     /// calling \ref run(), the supply of each node will be set to zero.

           _supply[_graph.target(e)] += lower[e];

     ///

         }

     /// Using this function has the same effect as using \ref supplyMap()

       }

     /// with such a map in which \c k is assigned to \c s, \c -k is

     }

     /// assigned to \c t and all other nodes have zero supply value.

 /*

     ///

     /// \brief General constructor (without lower bounds).

     ///

     /// General constructor (without lower bounds).

     ///

     /// \param digraph The digraph the algorithm runs on.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param supply The supply values of the nodes (signed).

     CycleCanceling( const Digraph &digraph,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     const SupplyMap &supply ) :

       _graph(digraph), _lower(NULL), _capacity(capacity), _cost(cost),

       _supply(supply), _flow(NULL), _local_flow(false),

       _potential(NULL), _local_potential(false), _res_graph(NULL),

       _res_cost(_cost)

     {

       // Check the sum of supply values

       Supply sum = 0;

       for (NodeIt n(_graph); n != INVALID; ++n) sum += _supply[n];

       _valid_supply = sum == 0;

     }

     /// \brief Simple constructor (with lower bounds).

     ///

     /// Simple constructor (with lower bounds).

     ///

     /// \param digraph The digraph the algorithm runs on.

     /// \param lower The lower bounds of the arcs.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param flow_value The required amount of flow from node \c s

     /// \param k The required amount of flow from node \c s to node \c t

     /// to node \c t (i.e. the supply of \c s and the demand of \c t).

     /// (i.e. the supply of \c s and the demand of \c t).

     CycleCanceling( const Digraph &digraph,

     ///

                     const LowerMap &lower,

     /// \return <tt>(*this)</tt>

                     const CapacityMap &capacity,

     CycleCanceling& stSupply(const Node& s, const Node& t, Value k) {

                     const CostMap &cost,

       for (int i = 0; i != _res_node_num; ++i) {

                     Node s, Node t,

         _supply[i] = 0;

                     Supply flow_value ) :

       }

       _graph(digraph), _lower(&lower), _capacity(capacity), _cost(cost),

       _supply[_node_id[s]] =  k;

       _supply(digraph, 0), _flow(NULL), _local_flow(false),

       _supply[_node_id[t]] = -k;

       _potential(NULL), _local_potential(false), _res_graph(NULL),

       _res_cost(_cost)

     {

       // Remove non-zero lower bounds

       _supply[s] =  flow_value;

       _supply[t] = -flow_value;

       for (ArcIt e(_graph); e != INVALID; ++e) {

         if (lower[e] != 0) {

           _capacity[e] -= lower[e];

           _supply[_graph.source(e)] -= lower[e];

           _supply[_graph.target(e)] += lower[e];

         }

       }

       _valid_supply = true;

     }

     /// \brief Simple constructor (without lower bounds).

     ///

     /// Simple constructor (without lower bounds).

     ///

     /// \param digraph The digraph the algorithm runs on.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param s The source node.

     /// \param t The target node.

     /// \param flow_value The required amount of flow from node \c s

     /// to node \c t (i.e. the supply of \c s and the demand of \c t).

     CycleCanceling( const Digraph &digraph,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     Node s, Node t,

                     Supply flow_value ) :

       _graph(digraph), _lower(NULL), _capacity(capacity), _cost(cost),

       _supply(digraph, 0), _flow(NULL), _local_flow(false),

       _potential(NULL), _local_potential(false), _res_graph(NULL),

       _res_cost(_cost)

     {

       _supply[s] =  flow_value;

       _supply[t] = -flow_value;

       _valid_supply = true;

     }

 */

     /// Destructor.

     ~CycleCanceling() {

       if (_local_flow) delete _flow;

       if (_local_potential) delete _potential;

       delete _res_graph;

     }

     /// \brief Set the flow map.

     ///

     /// Set the flow map.

     ///

     /// \return \c (*this)

     CycleCanceling& flowMap(FlowMap &map) {

       if (_local_flow) {

         delete _flow;

         _local_flow = false;

       }

       _flow = ↦

     /// \brief Set the potential map.

     /// @}

     ///

     /// Set the potential map.

     /// \name Execution control

     ///

     /// The algorithm can be executed using \ref run().

     /// \return \c (*this)

     CycleCanceling& potentialMap(PotentialMap &map) {

     /// @{

       if (_local_potential) {

         delete _potential;

     /// \brief Run the algorithm.

         _local_potential = false;

     ///

       }

     /// This function runs the algorithm.

       _potential = ↦

     /// The paramters can be specified using functions \ref lowerMap(),

     /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().

     /// For example,

     /// \code

     ///   CycleCanceling<ListDigraph> cc(graph);

     ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)

     ///     .supplyMap(sup).run();

     /// \endcode

     ///

     /// This function can be called more than once. All the parameters

     /// that have been given are kept for the next call, unless

     /// \ref reset() is called, thus only the modified parameters

     /// have to be set again. See \ref reset() for examples.

     /// However, the underlying digraph must not be modified after this

     /// class have been constructed, since it copies and extends the graph.

     ///

     /// \param method The cycle-canceling method that will be used.

     /// For more information, see \ref Method.

     ///

     /// \return \c INFEASIBLE if no feasible flow exists,

     /// \n \c OPTIMAL if the problem has optimal solution

     /// (i.e. it is feasible and bounded), and the algorithm has found

     /// optimal flow and node potentials (primal and dual solutions),

     /// \n \c UNBOUNDED if the digraph contains an arc of negative cost

     /// and infinite upper bound. It means that the objective function

     /// is unbounded on that arc, however, note that it could actually be

     /// bounded over the feasible flows, but this algroithm cannot handle

     /// these cases.

     ///

     /// \see ProblemType, Method

     ProblemType run(Method method = CANCEL_AND_TIGHTEN) {

       ProblemType pt = init();

       if (pt != OPTIMAL) return pt;

       start(method);

       return OPTIMAL;

     }

     /// \brief Reset all the parameters that have been given before.

     ///

     /// This function resets all the paramaters that have been given

     /// before using functions \ref lowerMap(), \ref upperMap(),

     /// \ref costMap(), \ref supplyMap(), \ref stSupply().

     ///

     /// It is useful for multiple run() calls. If this function is not

     /// used, all the parameters given before are kept for the next

     /// \ref run() call.

     /// However, the underlying digraph must not be modified after this

     /// class have been constructed, since it copies and extends the graph.

     ///

     /// For example,

     /// \code

     ///   CycleCanceling<ListDigraph> cs(graph);

     ///

     ///   // First run

     ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)

     ///     .supplyMap(sup).run();

     ///

     ///   // Run again with modified cost map (reset() is not called,

     ///   // so only the cost map have to be set again)

     ///   cost[e] += 100;

     ///   cc.costMap(cost).run();

     ///

     ///   // Run again from scratch using reset()

     ///   // (the lower bounds will be set to zero on all arcs)

     ///   cc.reset();

     ///   cc.upperMap(capacity).costMap(cost)

     ///     .supplyMap(sup).run();

     /// \endcode

     ///

     /// \return <tt>(*this)</tt>

     CycleCanceling& reset() {

       for (int i = 0; i != _res_node_num; ++i) {

         _supply[i] = 0;

       }

       int limit = _first_out[_root];

       for (int j = 0; j != limit; ++j) {

         _lower[j] = 0;

         _upper[j] = INF;

         _cost[j] = _forward[j] ? 1 : -1;

       }

       for (int j = limit; j != _res_arc_num; ++j) {

         _lower[j] = 0;

         _upper[j] = INF;

         _cost[j] = 0;

         _cost[_reverse[j]] = 0;

       }      

       _have_lower = false;

     /// \name Execution control

     /// @}

     /// \name Query Functions

     /// The results of the algorithm can be obtained using these

     /// functions.\n

     /// The \ref run() function must be called before using them.

     /// \brief Run the algorithm.

     /// \brief Return the total cost of the found flow.

     ///

     ///

     /// Run the algorithm.

     /// This function returns the total cost of the found flow.

     ///

     /// Its complexity is O(e).

     /// \param min_mean_cc Set this parameter to \c true to run the

     ///

     /// "Minimum Mean Cycle-Canceling" algorithm, which is strongly

     /// \note The return type of the function can be specified as a

     /// polynomial, but rather slower in practice.

     /// template parameter. For example,

     ///

     /// \code

     /// \return \c true if a feasible flow can be found.

     ///   cc.totalCost<double>();

     bool run(bool min_mean_cc = false) {

     /// \endcode

       return init() && start(min_mean_cc);

     /// It is useful if the total cost cannot be stored in the \c Cost

     /// type of the algorithm, which is the default return type of the

     /// function.

     ///

     /// \pre \ref run() must be called before using this function.

     template <typename Number>

     Number totalCost() const {

       Number c = 0;

       for (ArcIt a(_graph); a != INVALID; ++a) {

         int i = _arc_idb[a];

         c += static_cast<Number>(_res_cap[i]) *

              (-static_cast<Number>(_cost[i]));

       }

       return c;

     }

 #ifndef DOXYGEN

     Cost totalCost() const {

       return totalCost<Cost>();

     }

 #endif

     /// \brief Return the flow on the given arc.

     ///

     /// This function returns the flow on the given arc.

     ///

     /// \pre \ref run() must be called before using this function.

     Value flow(const Arc& a) const {

       return _res_cap[_arc_idb[a]];

     }

     /// \brief Return the flow map (the primal solution).

     ///

     /// This function copies the flow value on each arc into the given

     /// map. The \c Value type of the algorithm must be convertible to

     /// the \c Value type of the map.

     ///

     /// \pre \ref run() must be called before using this function.

     template <typename FlowMap>

     void flowMap(FlowMap &map) const {

       for (ArcIt a(_graph); a != INVALID; ++a) {

         map.set(a, _res_cap[_arc_idb[a]]);

       }

     }

     /// \brief Return the potential (dual value) of the given node.

     ///

     /// This function returns the potential (dual value) of the

     /// given node.

     ///

     /// \pre \ref run() must be called before using this function.

     Cost potential(const Node& n) const {

       return static_cast<Cost>(_pi[_node_id[n]]);

     }

     /// \brief Return the potential map (the dual solution).

     ///

     /// This function copies the potential (dual value) of each node

     /// into the given map.

     /// The \c Cost type of the algorithm must be convertible to the

     /// \c Value type of the map.

     ///

     /// \pre \ref run() must be called before using this function.

     template <typename PotentialMap>

     void potentialMap(PotentialMap &map) const {

       for (NodeIt n(_graph); n != INVALID; ++n) {

         map.set(n, static_cast<Cost>(_pi[_node_id[n]]));

       }

     /// Initialize the algorithm.

     // Initialize the algorithm

     bool init() {

     ProblemType init() {

       if (!_valid_supply) return false;

       if (_res_node_num <= 1) return INFEASIBLE;

       // Initializing flow and potential maps

       // Check the sum of supply values

       if (!_flow) {

       _sum_supply = 0;

         _flow = new FlowMap(_graph);

       for (int i = 0; i != _root; ++i) {

         _local_flow = true;

         _sum_supply += _supply[i];

       }

       }

       if (!_potential) {

       if (_sum_supply > 0) return INFEASIBLE;

         _potential = new PotentialMap(_graph);

         _local_potential = true;

       }

       // Initialize vectors

       for (int i = 0; i != _res_node_num; ++i) {

       _res_graph = new ResDigraph(_graph, _capacity, *_flow);

         _pi[i] = 0;

       }

       // Finding a feasible flow using Circulation

       ValueVector excess(_supply);

       Circulation< Digraph, ConstMap<Arc, Capacity>, CapacityArcMap,

                    SupplyMap >

       // Remove infinite upper bounds and check negative arcs

         circulation( _graph, constMap<Arc>(Capacity(0)), _capacity,

       const Value MAX = std::numeric_limits<Value>::max();

                      _supply );

       int last_out;

       return circulation.flowMap(*_flow).run();

       if (_have_lower) {

     }

         for (int i = 0; i != _root; ++i) {

           last_out = _first_out[i+1];

     bool start(bool min_mean_cc) {

           for (int j = _first_out[i]; j != last_out; ++j) {

       if (min_mean_cc)

             if (_forward[j]) {

         startMinMean();

               Value c = _cost[j] < 0 ? _upper[j] : _lower[j];

       else

               if (c >= MAX) return UNBOUNDED;

         start();

               excess[i] -= c;

               excess[_target[j]] += c;

       // Handling non-zero lower bounds

             }

       if (_lower) {

           }

         for (ArcIt e(_graph); e != INVALID; ++e)

         }

           (*_flow)[e] += (*_lower)[e];

       } else {

       }

         for (int i = 0; i != _root; ++i) {

       return true;

           last_out = _first_out[i+1];

     }

           for (int j = _first_out[i]; j != last_out; ++j) {

             if (_forward[j] && _cost[j] < 0) {

     /// \brief Execute the algorithm using \ref BellmanFord.

               Value c = _upper[j];

     ///

               if (c >= MAX) return UNBOUNDED;

     /// Execute the algorithm using the \ref BellmanFord

               excess[i] -= c;

     /// "Bellman-Ford" algorithm for negative cycle detection with

               excess[_target[j]] += c;

     /// successively larger limit for the number of iterations.

             }

     void start() {

           }

       typename BellmanFord<ResDigraph, ResidualCostMap>::PredMap pred(*_res_graph);

         }

       typename ResDigraph::template NodeMap<int> visited(*_res_graph);

       }

       std::vector<ResArc> cycle;

       Value ex, max_cap = 0;

       int node_num = countNodes(_graph);

       for (int i = 0; i != _res_node_num; ++i) {

         ex = excess[i];

         if (ex < 0) max_cap -= ex;

       }

       for (int j = 0; j != _res_arc_num; ++j) {

         if (_upper[j] >= MAX) _upper[j] = max_cap;

       }

       // Initialize maps for Circulation and remove non-zero lower bounds

       ConstMap<Arc, Value> low(0);

       typedef typename Digraph::template ArcMap<Value> ValueArcMap;

       typedef typename Digraph::template NodeMap<Value> ValueNodeMap;

       ValueArcMap cap(_graph), flow(_graph);

       ValueNodeMap sup(_graph);

       for (NodeIt n(_graph); n != INVALID; ++n) {

         sup[n] = _supply[_node_id[n]];

       }

       if (_have_lower) {

         for (ArcIt a(_graph); a != INVALID; ++a) {

           int j = _arc_idf[a];

           Value c = _lower[j];

           cap[a] = _upper[j] - c;

           sup[_graph.source(a)] -= c;

           sup[_graph.target(a)] += c;

         }

       } else {

         for (ArcIt a(_graph); a != INVALID; ++a) {

           cap[a] = _upper[_arc_idf[a]];

         }

       }

       // Find a feasible flow using Circulation

       Circulation<Digraph, ConstMap<Arc, Value>, ValueArcMap, ValueNodeMap>

         circ(_graph, low, cap, sup);

       if (!circ.flowMap(flow).run()) return INFEASIBLE;

       // Set residual capacities and handle GEQ supply type

       if (_sum_supply < 0) {

         for (ArcIt a(_graph); a != INVALID; ++a) {

           Value fa = flow[a];

           _res_cap[_arc_idf[a]] = cap[a] - fa;

           _res_cap[_arc_idb[a]] = fa;

           sup[_graph.source(a)] -= fa;

           sup[_graph.target(a)] += fa;

         }

         for (NodeIt n(_graph); n != INVALID; ++n) {

           excess[_node_id[n]] = sup[n];

         }

         for (int a = _first_out[_root]; a != _res_arc_num; ++a) {

           int u = _target[a];

           int ra = _reverse[a];

           _res_cap[a] = -_sum_supply + 1;

           _res_cap[ra] = -excess[u];

           _cost[a] = 0;

           _cost[ra] = 0;

         }

       } else {

         for (ArcIt a(_graph); a != INVALID; ++a) {

           Value fa = flow[a];

           _res_cap[_arc_idf[a]] = cap[a] - fa;

           _res_cap[_arc_idb[a]] = fa;

         }

         for (int a = _first_out[_root]; a != _res_arc_num; ++a) {

           int ra = _reverse[a];

           _res_cap[a] = 1;

           _res_cap[ra] = 0;

           _cost[a] = 0;

           _cost[ra] = 0;

         }

       }

       return OPTIMAL;

     }

     // Build a StaticDigraph structure containing the current

     // residual network

     void buildResidualNetwork() {

       _arc_vec.clear();

       _cost_vec.clear();

       _id_vec.clear();

       for (int j = 0; j != _res_arc_num; ++j) {

         if (_res_cap[j] > 0) {

           _arc_vec.push_back(IntPair(_source[j], _target[j]));

           _cost_vec.push_back(_cost[j]);

           _id_vec.push_back(j);

         }

       }

       _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());

     }

     // Execute the algorithm and transform the results

     void start(Method method) {

       // Execute the algorithm

       switch (method) {

         case SIMPLE_CYCLE_CANCELING:

           startSimpleCycleCanceling();

           break;

         case MINIMUM_MEAN_CYCLE_CANCELING:

           startMinMeanCycleCanceling();

           break;

         case CANCEL_AND_TIGHTEN:

           startCancelAndTighten();

           break;

       }

       // Compute node potentials

       if (method != SIMPLE_CYCLE_CANCELING) {

         buildResidualNetwork();

         typename BellmanFord<StaticDigraph, CostArcMap>

           ::template SetDistMap<CostNodeMap>::Create bf(_sgr, _cost_map);

         bf.distMap(_pi_map);

         bf.init(0);

         bf.start();

       }

       // Handle non-zero lower bounds

       if (_have_lower) {

         int limit = _first_out[_root];

         for (int j = 0; j != limit; ++j) {

           if (!_forward[j]) _res_cap[j] += _lower[j];

         }

       }

     }

     // Execute the "Simple Cycle Canceling" method

     void startSimpleCycleCanceling() {

       // Constants for computing the iteration limits

       const int BF_FIRST_LIMIT  = 2;

       const double BF_LIMIT_FACTOR = 1.5;

       typedef VectorMap<StaticDigraph::Arc, Value> FilterMap;

       typedef FilterArcs<StaticDigraph, FilterMap> ResDigraph;

       typedef VectorMap<StaticDigraph::Node, StaticDigraph::Arc> PredMap;

       typedef typename BellmanFord<ResDigraph, CostArcMap>

         ::template SetDistMap<CostNodeMap>

         ::template SetPredMap<PredMap>::Create BF;

       // Build the residual network

       _arc_vec.clear();

       _cost_vec.clear();

       for (int j = 0; j != _res_arc_num; ++j) {

         _arc_vec.push_back(IntPair(_source[j], _target[j]));

         _cost_vec.push_back(_cost[j]);

       }

       _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());

       FilterMap filter_map(_res_cap);

       ResDigraph rgr(_sgr, filter_map);

       std::vector<int> cycle;

       std::vector<StaticDigraph::Arc> pred(_res_arc_num);

       PredMap pred_map(pred);

       BF bf(rgr, _cost_map);

       bf.distMap(_pi_map).predMap(pred_map);

           int curr_iter_num = iter_num + length_bound <= node_num ?

           // Perform some iterations of the Bellman-Ford algorithm

                               length_bound : node_num - iter_num;

           int curr_iter_num = iter_num + length_bound <= _node_num ?

             length_bound : _node_num - iter_num;

             // Searching for node disjoint negative cycles

             // Search for node disjoint negative cycles

             for (ResNodeIt n(*_res_graph); n != INVALID; ++n)

             std::vector<int> state(_res_node_num, 0);

               visited[n] = 0;

             for (ResNodeIt n(*_res_graph); n != INVALID; ++n) {

             for (int u = 0; u != _res_node_num; ++u) {

               if (visited[n] > 0) continue;

               if (state[u] != 0) continue;

               visited[n] = ++id;

               ++id;

               ResNode u = pred[n] == INVALID ?

               int v = u;

                           INVALID : _res_graph->source(pred[n]);

               for (; v != -1 && state[v] == 0; v = pred[v] == INVALID ?

               while (u != INVALID && visited[u] == 0) {

                    -1 : rgr.id(rgr.source(pred[v]))) {

                 visited[u] = id;

                 state[v] = id;

                 u = pred[u] == INVALID ?

                     INVALID : _res_graph->source(pred[u]);

               if (u != INVALID && visited[u] == id) {

               if (v != -1 && state[v] == id) {

                 // Finding the negative cycle

                 // A negative cycle is found

                 ResArc e = pred[u];

                 StaticDigraph::Arc a = pred[v];

                 cycle.push_back(e);

                 Value d, delta = _res_cap[rgr.id(a)];

                 Capacity d = _res_graph->residualCapacity(e);

                 cycle.push_back(rgr.id(a));

                 while (_res_graph->source(e) != u) {

                 while (rgr.id(rgr.source(a)) != v) {

                   cycle.push_back(e = pred[_res_graph->source(e)]);

                   a = pred_map[rgr.source(a)];

                   if (_res_graph->residualCapacity(e) < d)

                   d = _res_cap[rgr.id(a)];

                     d = _res_graph->residualCapacity(e);

                   if (d < delta) delta = d;

                   cycle.push_back(rgr.id(a));

                 // Augmenting along the cycle

                 // Augment along the cycle

                 for (int i = 0; i < int(cycle.size()); ++i)

                 for (int i = 0; i < int(cycle.size()); ++i) {

                   _res_graph->augment(cycle[i], d);

                   int j = cycle[i];

                   _res_cap[j] -= delta;

                   _res_cap[_reverse[j]] += delta;

                 }

           if (!cycle_found)

           // Increase iteration limit if no cycle is found

             length_bound = length_bound * BF_LIMIT_FACTOR / 100;

           if (!cycle_found) {

         }

             length_bound = static_cast<int>(length_bound * BF_LIMIT_FACTOR);

       }

           }

     }

         }

       }

     /// \brief Execute the algorithm using \ref Howard.

     }

     ///

     /// Execute the algorithm using \ref Howard for negative

     // Execute the "Minimum Mean Cycle Canceling" method

     /// cycle detection.

     void startMinMeanCycleCanceling() {

     void startMinMean() {

       typedef SimplePath<StaticDigraph> SPath;

       typedef Path<ResDigraph> ResPath;

       typedef typename SPath::ArcIt SPathArcIt;

       Howard<ResDigraph, ResidualCostMap> mmc(*_res_graph, _res_cost);

       typedef typename Howard<StaticDigraph, CostArcMap>

       ResPath cycle;

         ::template SetPath<SPath>::Create MMC;

       SPath cycle;

       MMC mmc(_sgr, _cost_map);

       if (mmc.findMinMean()) {

       buildResidualNetwork();

         while (mmc.cycleLength() < 0) {

       while (mmc.findMinMean() && mmc.cycleLength() < 0) {

           // Finding the cycle

         // Find the cycle

           mmc.findCycle();

         mmc.findCycle();

           // Finding the largest flow amount that can be augmented

         // Compute delta value

           // along the cycle

         Value delta = INF;

           Capacity delta = 0;

         for (SPathArcIt a(cycle); a != INVALID; ++a) {

           for (typename ResPath::ArcIt e(cycle); e != INVALID; ++e) {

           Value d = _res_cap[_id_vec[_sgr.id(a)]];

             if (delta == 0 || _res_graph->residualCapacity(e) < delta)

           if (d < delta) delta = d;

               delta = _res_graph->residualCapacity(e);

         }

           }

         // Augment along the cycle

           // Augmenting along the cycle

         for (SPathArcIt a(cycle); a != INVALID; ++a) {

           for (typename ResPath::ArcIt e(cycle); e != INVALID; ++e)

           int j = _id_vec[_sgr.id(a)];

             _res_graph->augment(e, delta);

           _res_cap[j] -= delta;

           _res_cap[_reverse[j]] += delta;

           // Finding the minimum cycle mean for the modified residual

         }

           // digraph

           if (!mmc.findMinMean()) break;

         // Rebuild the residual network        

         }

         buildResidualNetwork();

       }

       }

     }

       // Computing node potentials

       BellmanFord<ResDigraph, ResidualCostMap> bf(*_res_graph, _res_cost);

     // Execute the "Cancel And Tighten" method

       bf.init(0); bf.start();

     void startCancelAndTighten() {

       for (NodeIt n(_graph); n != INVALID; ++n)

       // Constants for the min mean cycle computations

         (*_potential)[n] = bf.dist(n);

       const double LIMIT_FACTOR = 1.0;

       const int MIN_LIMIT = 5;

       // Contruct auxiliary data vectors

       DoubleVector pi(_res_node_num, 0.0);

       IntVector level(_res_node_num);

       CharVector reached(_res_node_num);

       CharVector processed(_res_node_num);

       IntVector pred_node(_res_node_num);

       IntVector pred_arc(_res_node_num);

       std::vector<int> stack(_res_node_num);

       std::vector<int> proc_vector(_res_node_num);

       // Initialize epsilon

       double epsilon = 0;

       for (int a = 0; a != _res_arc_num; ++a) {

         if (_res_cap[a] > 0 && -_cost[a] > epsilon)

           epsilon = -_cost[a];

       }

       // Start phases

       Tolerance<double> tol;

       tol.epsilon(1e-6);

       int limit = int(LIMIT_FACTOR * std::sqrt(double(_res_node_num)));

       if (limit < MIN_LIMIT) limit = MIN_LIMIT;

       int iter = limit;

       while (epsilon * _res_node_num >= 1) {

         // Find and cancel cycles in the admissible network using DFS

         for (int u = 0; u != _res_node_num; ++u) {

           reached[u] = false;

           processed[u] = false;

         }

         int stack_head = -1;

         int proc_head = -1;

         for (int start = 0; start != _res_node_num; ++start) {

           if (reached[start]) continue;

           // New start node

           reached[start] = true;

           pred_arc[start] = -1;

           pred_node[start] = -1;

           // Find the first admissible outgoing arc

           double p = pi[start];