Revert to long long int since currently I don't know a better solution.
3 * This file is a part of LEMON, a generic C++ optimization library
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
19 #ifndef LEMON_MIN_COST_MAX_FLOW_H
20 #define LEMON_MIN_COST_MAX_FLOW_H
22 /// \ingroup min_cost_flow
25 /// \brief An efficient algorithm for finding a minimum cost maximum flow.
27 #include <lemon/preflow.h>
28 #include <lemon/network_simplex.h>
29 #include <lemon/maps.h>
33 /// \addtogroup min_cost_flow
36 /// \brief An efficient algorithm for finding a minimum cost
39 /// \ref MinCostMaxFlow implements an efficient algorithm for
40 /// finding a maximum flow having minimal total cost from a given
41 /// source node to a given target node in a directed graph.
43 /// \ref MinCostMaxFlow uses \ref Preflow for finding the maximum
44 /// flow value and \ref NetworkSimplex for finding a minimum cost
45 /// flow of that value.
46 /// According to our benchmark tests \ref Preflow is generally the
47 /// most efficient algorithm for the maximum flow problem and
48 /// \ref NetworkSimplex is the most efficient for the minimum cost
49 /// flow problem in LEMON.
51 /// \tparam Graph The directed graph type the algorithm runs on.
52 /// \tparam CapacityMap The type of the capacity (upper bound) map.
53 /// \tparam CostMap The type of the cost (length) map.
56 /// - Edge capacities and costs should be \e non-negative \e integers.
57 /// - \c CapacityMap::Value must be convertible to \c CostMap::Value.
58 /// - \c CostMap::Value must be signed type.
60 /// \author Peter Kovacs
62 template < typename Graph,
63 typename CapacityMap = typename Graph::template EdgeMap<int>,
64 typename CostMap = typename Graph::template EdgeMap<int> >
67 GRAPH_TYPEDEFS(typename Graph);
69 typedef typename CapacityMap::Value Capacity;
70 typedef typename CostMap::Value Cost;
71 typedef typename Graph::template NodeMap<Cost> SupplyMap;
73 typedef Preflow<Graph, CapacityMap> MaxFlowImpl;
74 typedef NetworkSimplex< Graph, CapacityMap, CapacityMap,
75 CostMap, SupplyMap > MinCostFlowImpl;
79 /// The type of the flow map.
80 typedef typename Graph::template EdgeMap<Capacity> FlowMap;
81 /// The type of the potential map.
82 typedef typename Graph::template NodeMap<Cost> PotentialMap;
86 // The directed graph the algorithm runs on
89 const CapacityMap &_capacity;
93 // Edge map of the found flow
96 // Node map of the current potentials
97 PotentialMap *_potential;
98 bool _local_potential;
107 /// \brief Constructor.
111 /// \param graph The directed graph the algorithm runs on.
112 /// \param capacity The capacities (upper bounds) of the edges.
113 /// \param cost The cost (length) values of the edges.
114 /// \param s The source node.
115 /// \param t The target node.
116 MinCostMaxFlow( const Graph &graph,
117 const CapacityMap &capacity,
120 _graph(graph), _capacity(capacity), _cost(cost), _flow(0),
121 _local_flow(false), _potential(0), _local_potential(false),
122 _source(s), _target(t) {}
126 if (_local_flow) delete _flow;
127 if (_local_potential) delete _potential;
130 /// \brief Sets the flow map.
132 /// Sets the flow map.
134 /// \return \c (*this)
135 MinCostMaxFlow& flowMap(FlowMap &map) {
144 /// \brief Sets the potential map.
146 /// Sets the potential map.
148 /// \return \c (*this)
149 MinCostMaxFlow& potentialMap(PotentialMap &map) {
150 if (_local_potential) {
152 _local_potential = false;
158 /// \name Execution control
159 /// The only way to execute the algorithm is to call the run()
164 /// \brief Runs the algorithm.
166 /// Runs the algorithm.
170 _flow = new FlowMap(_graph);
174 _potential = new PotentialMap(_graph);
175 _local_potential = true;
178 MaxFlowImpl preflow(_graph, _capacity, _source, _target);
179 preflow.flowMap(*_flow).runMinCut();
180 // Running NetworkSimplex
181 MinCostFlowImpl mcf( _graph, _capacity, _cost,
182 _source, _target, preflow.flowValue() );
183 mcf.flowMap(*_flow).potentialMap(*_potential).run();
188 /// \name Query Functions
189 /// The result of the algorithm can be obtained using these
191 /// \n run() must be called before using them.
195 /// \brief Returns a const reference to the edge map storing the
198 /// Returns a const reference to the edge map storing the found flow.
200 /// \pre \ref run() must be called before using this function.
201 const FlowMap& flowMap() const {
205 /// \brief Returns a const reference to the node map storing the
206 /// found potentials (the dual solution).
208 /// Returns a const reference to the node map storing the found
209 /// potentials (the dual solution).
211 /// \pre \ref run() must be called before using this function.
212 const PotentialMap& potentialMap() const {
216 /// \brief Returns the flow on the given edge.
218 /// Returns the flow on the given edge.
220 /// \pre \ref run() must be called before using this function.
221 Capacity flow(const Edge& edge) const {
222 return (*_flow)[edge];
225 /// \brief Returns the potential of the given node.
227 /// Returns the potential of the given node.
229 /// \pre \ref run() must be called before using this function.
230 Cost potential(const Node& node) const {
231 return (*_potential)[node];
234 /// \brief Returns the total cost of the found flow.
236 /// Returns the total cost of the found flow. The complexity of the
237 /// function is \f$ O(e) \f$.
239 /// \pre \ref run() must be called before using this function.
240 Cost totalCost() const {
242 for (EdgeIt e(_graph); e != INVALID; ++e)
243 c += (*_flow)[e] * _cost[e];
249 }; //class MinCostMaxFlow
255 #endif //LEMON_MIN_COST_MAX_FLOW_H