0
73
18
1101
17
13
1
163
70
15
9
66
77
110
110
166
139
12
19
10
13
172
171
344
324
Changeset was too big and was cut off... Show full diff
1 |
%%%%% Defining LEMON %%%%% |
|
2 |
|
|
3 |
@misc{lemon, |
|
4 |
key = {LEMON}, |
|
5 |
title = {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and |
|
6 |
{O}ptimization in {N}etworks}, |
|
7 |
howpublished = {\url{http://lemon.cs.elte.hu/}}, |
|
8 |
year = 2009 |
|
9 |
} |
|
10 |
|
|
11 |
@misc{egres, |
|
12 |
key = {EGRES}, |
|
13 |
title = {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on |
|
14 |
{C}ombinatorial {O}ptimization}, |
|
15 |
url = {http://www.cs.elte.hu/egres/} |
|
16 |
} |
|
17 |
|
|
18 |
@misc{coinor, |
|
19 |
key = {COIN-OR}, |
|
20 |
title = {{COIN-OR} -- {C}omputational {I}nfrastructure for |
|
21 |
{O}perations {R}esearch}, |
|
22 |
url = {http://www.coin-or.org/} |
|
23 |
} |
|
24 |
|
|
25 |
|
|
26 |
%%%%% Other libraries %%%%%% |
|
27 |
|
|
28 |
@misc{boost, |
|
29 |
key = {Boost}, |
|
30 |
title = {{B}oost {C++} {L}ibraries}, |
|
31 |
url = {http://www.boost.org/} |
|
32 |
} |
|
33 |
|
|
34 |
@book{bglbook, |
|
35 |
author = {Jeremy G. Siek and Lee-Quan Lee and Andrew |
|
36 |
Lumsdaine}, |
|
37 |
title = {The Boost Graph Library: User Guide and Reference |
|
38 |
Manual}, |
|
39 |
publisher = {Addison-Wesley}, |
|
40 |
year = 2002 |
|
41 |
} |
|
42 |
|
|
43 |
@misc{leda, |
|
44 |
key = {LEDA}, |
|
45 |
title = {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and |
|
46 |
{A}lgorithms}, |
|
47 |
url = {http://www.algorithmic-solutions.com/} |
|
48 |
} |
|
49 |
|
|
50 |
@book{ledabook, |
|
51 |
author = {Kurt Mehlhorn and Stefan N{\"a}her}, |
|
52 |
title = {{LEDA}: {A} platform for combinatorial and geometric |
|
53 |
computing}, |
|
54 |
isbn = {0-521-56329-1}, |
|
55 |
publisher = {Cambridge University Press}, |
|
56 |
address = {New York, NY, USA}, |
|
57 |
year = 1999 |
|
58 |
} |
|
59 |
|
|
60 |
|
|
61 |
%%%%% Tools that LEMON depends on %%%%% |
|
62 |
|
|
63 |
@misc{cmake, |
|
64 |
key = {CMake}, |
|
65 |
title = {{CMake} -- {C}ross {P}latform {M}ake}, |
|
66 |
url = {http://www.cmake.org/} |
|
67 |
} |
|
68 |
|
|
69 |
@misc{doxygen, |
|
70 |
key = {Doxygen}, |
|
71 |
title = {{Doxygen} -- {S}ource code documentation generator |
|
72 |
tool}, |
|
73 |
url = {http://www.doxygen.org/} |
|
74 |
} |
|
75 |
|
|
76 |
|
|
77 |
%%%%% LP/MIP libraries %%%%% |
|
78 |
|
|
79 |
@misc{glpk, |
|
80 |
key = {GLPK}, |
|
81 |
title = {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it}, |
|
82 |
url = {http://www.gnu.org/software/glpk/} |
|
83 |
} |
|
84 |
|
|
85 |
@misc{clp, |
|
86 |
key = {Clp}, |
|
87 |
title = {{Clp} -- {Coin-Or} {L}inear {P}rogramming}, |
|
88 |
url = {http://projects.coin-or.org/Clp/} |
|
89 |
} |
|
90 |
|
|
91 |
@misc{cbc, |
|
92 |
key = {Cbc}, |
|
93 |
title = {{Cbc} -- {Coin-Or} {B}ranch and {C}ut}, |
|
94 |
url = {http://projects.coin-or.org/Cbc/} |
|
95 |
} |
|
96 |
|
|
97 |
@misc{cplex, |
|
98 |
key = {CPLEX}, |
|
99 |
title = {{ILOG} {CPLEX}}, |
|
100 |
url = {http://www.ilog.com/} |
|
101 |
} |
|
102 |
|
|
103 |
@misc{soplex, |
|
104 |
key = {SoPlex}, |
|
105 |
title = {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented |
|
106 |
{S}implex}, |
|
107 |
url = {http://soplex.zib.de/} |
|
108 |
} |
|
109 |
|
|
110 |
|
|
111 |
%%%%% General books %%%%% |
|
112 |
|
|
113 |
@book{amo93networkflows, |
|
114 |
author = {Ravindra K. Ahuja and Thomas L. Magnanti and James |
|
115 |
B. Orlin}, |
|
116 |
title = {Network Flows: Theory, Algorithms, and Applications}, |
|
117 |
publisher = {Prentice-Hall, Inc.}, |
|
118 |
year = 1993, |
|
119 |
month = feb, |
|
120 |
isbn = {978-0136175490} |
|
121 |
} |
|
122 |
|
|
123 |
@book{schrijver03combinatorial, |
|
124 |
author = {Alexander Schrijver}, |
|
125 |
title = {Combinatorial Optimization: Polyhedra and Efficiency}, |
|
126 |
publisher = {Springer-Verlag}, |
|
127 |
year = 2003, |
|
128 |
isbn = {978-3540443896} |
|
129 |
} |
|
130 |
|
|
131 |
@book{clrs01algorithms, |
|
132 |
author = {Thomas H. Cormen and Charles E. Leiserson and Ronald |
|
133 |
L. Rivest and Clifford Stein}, |
|
134 |
title = {Introduction to Algorithms}, |
|
135 |
publisher = {The MIT Press}, |
|
136 |
year = 2001, |
|
137 |
edition = {2nd} |
|
138 |
} |
|
139 |
|
|
140 |
@book{stroustrup00cpp, |
|
141 |
author = {Bjarne Stroustrup}, |
|
142 |
title = {The C++ Programming Language}, |
|
143 |
edition = {3rd}, |
|
144 |
publisher = {Addison-Wesley Professional}, |
|
145 |
isbn = 0201700735, |
|
146 |
month = {February}, |
|
147 |
year = 2000 |
|
148 |
} |
|
149 |
|
|
150 |
|
|
151 |
%%%%% Maximum flow algorithms %%%%% |
|
152 |
|
|
153 |
@article{edmondskarp72theoretical, |
|
154 |
author = {Jack Edmonds and Richard M. Karp}, |
|
155 |
title = {Theoretical improvements in algorithmic efficiency |
|
156 |
for network flow problems}, |
|
157 |
journal = {Journal of the ACM}, |
|
158 |
year = 1972, |
|
159 |
volume = 19, |
|
160 |
number = 2, |
|
161 |
pages = {248-264} |
|
162 |
} |
|
163 |
|
|
164 |
@article{goldberg88newapproach, |
|
165 |
author = {Andrew V. Goldberg and Robert E. Tarjan}, |
|
166 |
title = {A new approach to the maximum flow problem}, |
|
167 |
journal = {Journal of the ACM}, |
|
168 |
year = 1988, |
|
169 |
volume = 35, |
|
170 |
number = 4, |
|
171 |
pages = {921-940} |
|
172 |
} |
|
173 |
|
|
174 |
@article{dinic70algorithm, |
|
175 |
author = {E. A. Dinic}, |
|
176 |
title = {Algorithm for solution of a problem of maximum flow |
|
177 |
in a network with power estimation}, |
|
178 |
journal = {Soviet Math. Doklady}, |
|
179 |
year = 1970, |
|
180 |
volume = 11, |
|
181 |
pages = {1277-1280} |
|
182 |
} |
|
183 |
|
|
184 |
@article{goldberg08partial, |
|
185 |
author = {Andrew V. Goldberg}, |
|
186 |
title = {The Partial Augment-Relabel Algorithm for the |
|
187 |
Maximum Flow Problem}, |
|
188 |
journal = {16th Annual European Symposium on Algorithms}, |
|
189 |
year = 2008, |
|
190 |
pages = {466-477} |
|
191 |
} |
|
192 |
|
|
193 |
@article{sleator83dynamic, |
|
194 |
author = {Daniel D. Sleator and Robert E. Tarjan}, |
|
195 |
title = {A data structure for dynamic trees}, |
|
196 |
journal = {Journal of Computer and System Sciences}, |
|
197 |
year = 1983, |
|
198 |
volume = 26, |
|
199 |
number = 3, |
|
200 |
pages = {362-391} |
|
201 |
} |
|
202 |
|
|
203 |
|
|
204 |
%%%%% Minimum mean cycle algorithms %%%%% |
|
205 |
|
|
206 |
@article{karp78characterization, |
|
207 |
author = {Richard M. Karp}, |
|
208 |
title = {A characterization of the minimum cycle mean in a |
|
209 |
digraph}, |
|
210 |
journal = {Discrete Math.}, |
|
211 |
year = 1978, |
|
212 |
volume = 23, |
|
213 |
pages = {309-311} |
|
214 |
} |
|
215 |
|
|
216 |
@article{dasdan98minmeancycle, |
|
217 |
author = {Ali Dasdan and Rajesh K. Gupta}, |
|
218 |
title = {Faster Maximum and Minimum Mean Cycle Alogrithms for |
|
219 |
System Performance Analysis}, |
|
220 |
journal = {IEEE Transactions on Computer-Aided Design of |
|
221 |
Integrated Circuits and Systems}, |
|
222 |
year = 1998, |
|
223 |
volume = 17, |
|
224 |
number = 10, |
|
225 |
pages = {889-899} |
|
226 |
} |
|
227 |
|
|
228 |
|
|
229 |
%%%%% Minimum cost flow algorithms %%%%% |
|
230 |
|
|
231 |
@article{klein67primal, |
|
232 |
author = {Morton Klein}, |
|
233 |
title = {A primal method for minimal cost flows with |
|
234 |
applications to the assignment and transportation |
|
235 |
problems}, |
|
236 |
journal = {Management Science}, |
|
237 |
year = 1967, |
|
238 |
volume = 14, |
|
239 |
pages = {205-220} |
|
240 |
} |
|
241 |
|
|
242 |
@article{goldberg89cyclecanceling, |
|
243 |
author = {Andrew V. Goldberg and Robert E. Tarjan}, |
|
244 |
title = {Finding minimum-cost circulations by canceling |
|
245 |
negative cycles}, |
|
246 |
journal = {Journal of the ACM}, |
|
247 |
year = 1989, |
|
248 |
volume = 36, |
|
249 |
number = 4, |
|
250 |
pages = {873-886} |
|
251 |
} |
|
252 |
|
|
253 |
@article{goldberg90approximation, |
|
254 |
author = {Andrew V. Goldberg and Robert E. Tarjan}, |
|
255 |
title = {Finding Minimum-Cost Circulations by Successive |
|
256 |
Approximation}, |
|
257 |
journal = {Mathematics of Operations Research}, |
|
258 |
year = 1990, |
|
259 |
volume = 15, |
|
260 |
number = 3, |
|
261 |
pages = {430-466} |
|
262 |
} |
|
263 |
|
|
264 |
@article{goldberg97efficient, |
|
265 |
author = {Andrew V. Goldberg}, |
|
266 |
title = {An Efficient Implementation of a Scaling |
|
267 |
Minimum-Cost Flow Algorithm}, |
|
268 |
journal = {Journal of Algorithms}, |
|
269 |
year = 1997, |
|
270 |
volume = 22, |
|
271 |
number = 1, |
|
272 |
pages = {1-29} |
|
273 |
} |
|
274 |
|
|
275 |
@article{bunnagel98efficient, |
|
276 |
author = {Ursula B{\"u}nnagel and Bernhard Korte and Jens |
|
277 |
Vygen}, |
|
278 |
title = {Efficient implementation of the {G}oldberg-{T}arjan |
|
279 |
minimum-cost flow algorithm}, |
|
280 |
journal = {Optimization Methods and Software}, |
|
281 |
year = 1998, |
|
282 |
volume = 10, |
|
283 |
pages = {157-174} |
|
284 |
} |
|
285 |
|
|
286 |
@book{dantzig63linearprog, |
|
287 |
author = {George B. Dantzig}, |
|
288 |
title = {Linear Programming and Extensions}, |
|
289 |
publisher = {Princeton University Press}, |
|
290 |
year = 1963 |
|
291 |
} |
|
292 |
|
|
293 |
@mastersthesis{kellyoneill91netsimplex, |
|
294 |
author = {Damian J. Kelly and Garrett M. O'Neill}, |
|
295 |
title = {The Minimum Cost Flow Problem and The Network |
|
296 |
Simplex Method}, |
|
297 |
school = {University College}, |
|
298 |
address = {Dublin, Ireland}, |
|
299 |
year = 1991, |
|
300 |
month = sep, |
|
301 |
} |
1 |
/* -*- C++ -*- |
|
2 |
* |
|
3 |
* This file is a part of LEMON, a generic C++ optimization library |
|
4 |
* |
|
5 |
* Copyright (C) 2003-2008 |
|
6 |
* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport |
|
7 |
* (Egervary Research Group on Combinatorial Optimization, EGRES). |
|
8 |
* |
|
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. |
|
12 |
* |
|
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 |
|
15 |
* purpose. |
|
16 |
* |
|
17 |
*/ |
|
18 |
|
|
19 |
#ifndef LEMON_BELLMAN_FORD_H |
|
20 |
#define LEMON_BELLMAN_FORD_H |
|
21 |
|
|
22 |
/// \ingroup shortest_path |
|
23 |
/// \file |
|
24 |
/// \brief Bellman-Ford algorithm. |
|
25 |
|
|
26 |
#include <lemon/list_graph.h> |
|
27 |
#include <lemon/bits/path_dump.h> |
|
28 |
#include <lemon/core.h> |
|
29 |
#include <lemon/error.h> |
|
30 |
#include <lemon/maps.h> |
|
31 |
#include <lemon/path.h> |
|
32 |
|
|
33 |
#include <limits> |
|
34 |
|
|
35 |
namespace lemon { |
|
36 |
|
|
37 |
/// \brief Default OperationTraits for the BellmanFord algorithm class. |
|
38 |
/// |
|
39 |
/// This operation traits class defines all computational operations |
|
40 |
/// and constants that are used in the Bellman-Ford algorithm. |
|
41 |
/// The default implementation is based on the \c numeric_limits class. |
|
42 |
/// If the numeric type does not have infinity value, then the maximum |
|
43 |
/// value is used as extremal infinity value. |
|
44 |
template < |
|
45 |
typename V, |
|
46 |
bool has_inf = std::numeric_limits<V>::has_infinity> |
|
47 |
struct BellmanFordDefaultOperationTraits { |
|
48 |
/// \e |
|
49 |
typedef V Value; |
|
50 |
/// \brief Gives back the zero value of the type. |
|
51 |
static Value zero() { |
|
52 |
return static_cast<Value>(0); |
|
53 |
} |
|
54 |
/// \brief Gives back the positive infinity value of the type. |
|
55 |
static Value infinity() { |
|
56 |
return std::numeric_limits<Value>::infinity(); |
|
57 |
} |
|
58 |
/// \brief Gives back the sum of the given two elements. |
|
59 |
static Value plus(const Value& left, const Value& right) { |
|
60 |
return left + right; |
|
61 |
} |
|
62 |
/// \brief Gives back \c true only if the first value is less than |
|
63 |
/// the second. |
|
64 |
static bool less(const Value& left, const Value& right) { |
|
65 |
return left < right; |
|
66 |
} |
|
67 |
}; |
|
68 |
|
|
69 |
template <typename V> |
|
70 |
struct BellmanFordDefaultOperationTraits<V, false> { |
|
71 |
typedef V Value; |
|
72 |
static Value zero() { |
|
73 |
return static_cast<Value>(0); |
|
74 |
} |
|
75 |
static Value infinity() { |
|
76 |
return std::numeric_limits<Value>::max(); |
|
77 |
} |
|
78 |
static Value plus(const Value& left, const Value& right) { |
|
79 |
if (left == infinity() || right == infinity()) return infinity(); |
|
80 |
return left + right; |
|
81 |
} |
|
82 |
static bool less(const Value& left, const Value& right) { |
|
83 |
return left < right; |
|
84 |
} |
|
85 |
}; |
|
86 |
|
|
87 |
/// \brief Default traits class of BellmanFord class. |
|
88 |
/// |
|
89 |
/// Default traits class of BellmanFord class. |
|
90 |
/// \param GR The type of the digraph. |
|
91 |
/// \param LEN The type of the length map. |
|
92 |
template<typename GR, typename LEN> |
|
93 |
struct BellmanFordDefaultTraits { |
|
94 |
/// The type of the digraph the algorithm runs on. |
|
95 |
typedef GR Digraph; |
|
96 |
|
|
97 |
/// \brief The type of the map that stores the arc lengths. |
|
98 |
/// |
|
99 |
/// The type of the map that stores the arc lengths. |
|
100 |
/// It must conform to the \ref concepts::ReadMap "ReadMap" concept. |
|
101 |
typedef LEN LengthMap; |
|
102 |
|
|
103 |
/// The type of the arc lengths. |
|
104 |
typedef typename LEN::Value Value; |
|
105 |
|
|
106 |
/// \brief Operation traits for Bellman-Ford algorithm. |
|
107 |
/// |
|
108 |
/// It defines the used operations and the infinity value for the |
|
109 |
/// given \c Value type. |
|
110 |
/// \see BellmanFordDefaultOperationTraits |
|
111 |
typedef BellmanFordDefaultOperationTraits<Value> OperationTraits; |
|
112 |
|
|
113 |
/// \brief The type of the map that stores the last arcs of the |
|
114 |
/// shortest paths. |
|
115 |
/// |
|
116 |
/// The type of the map that stores the last |
|
117 |
/// arcs of the shortest paths. |
|
118 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
119 |
typedef typename GR::template NodeMap<typename GR::Arc> PredMap; |
|
120 |
|
|
121 |
/// \brief Instantiates a \c PredMap. |
|
122 |
/// |
|
123 |
/// This function instantiates a \ref PredMap. |
|
124 |
/// \param g is the digraph to which we would like to define the |
|
125 |
/// \ref PredMap. |
|
126 |
static PredMap *createPredMap(const GR& g) { |
|
127 |
return new PredMap(g); |
|
128 |
} |
|
129 |
|
|
130 |
/// \brief The type of the map that stores the distances of the nodes. |
|
131 |
/// |
|
132 |
/// The type of the map that stores the distances of the nodes. |
|
133 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
134 |
typedef typename GR::template NodeMap<typename LEN::Value> DistMap; |
|
135 |
|
|
136 |
/// \brief Instantiates a \c DistMap. |
|
137 |
/// |
|
138 |
/// This function instantiates a \ref DistMap. |
|
139 |
/// \param g is the digraph to which we would like to define the |
|
140 |
/// \ref DistMap. |
|
141 |
static DistMap *createDistMap(const GR& g) { |
|
142 |
return new DistMap(g); |
|
143 |
} |
|
144 |
|
|
145 |
}; |
|
146 |
|
|
147 |
/// \brief %BellmanFord algorithm class. |
|
148 |
/// |
|
149 |
/// \ingroup shortest_path |
|
150 |
/// This class provides an efficient implementation of the Bellman-Ford |
|
151 |
/// algorithm. The maximum time complexity of the algorithm is |
|
152 |
/// <tt>O(ne)</tt>. |
|
153 |
/// |
|
154 |
/// The Bellman-Ford algorithm solves the single-source shortest path |
|
155 |
/// problem when the arcs can have negative lengths, but the digraph |
|
156 |
/// should not contain directed cycles with negative total length. |
|
157 |
/// If all arc costs are non-negative, consider to use the Dijkstra |
|
158 |
/// algorithm instead, since it is more efficient. |
|
159 |
/// |
|
160 |
/// The arc lengths are passed to the algorithm using a |
|
161 |
/// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any |
|
162 |
/// kind of length. The type of the length values is determined by the |
|
163 |
/// \ref concepts::ReadMap::Value "Value" type of the length map. |
|
164 |
/// |
|
165 |
/// There is also a \ref bellmanFord() "function-type interface" for the |
|
166 |
/// Bellman-Ford algorithm, which is convenient in the simplier cases and |
|
167 |
/// it can be used easier. |
|
168 |
/// |
|
169 |
/// \tparam GR The type of the digraph the algorithm runs on. |
|
170 |
/// The default type is \ref ListDigraph. |
|
171 |
/// \tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies |
|
172 |
/// the lengths of the arcs. The default map type is |
|
173 |
/// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>". |
|
174 |
#ifdef DOXYGEN |
|
175 |
template <typename GR, typename LEN, typename TR> |
|
176 |
#else |
|
177 |
template <typename GR=ListDigraph, |
|
178 |
typename LEN=typename GR::template ArcMap<int>, |
|
179 |
typename TR=BellmanFordDefaultTraits<GR,LEN> > |
|
180 |
#endif |
|
181 |
class BellmanFord { |
|
182 |
public: |
|
183 |
|
|
184 |
///The type of the underlying digraph. |
|
185 |
typedef typename TR::Digraph Digraph; |
|
186 |
|
|
187 |
/// \brief The type of the arc lengths. |
|
188 |
typedef typename TR::LengthMap::Value Value; |
|
189 |
/// \brief The type of the map that stores the arc lengths. |
|
190 |
typedef typename TR::LengthMap LengthMap; |
|
191 |
/// \brief The type of the map that stores the last |
|
192 |
/// arcs of the shortest paths. |
|
193 |
typedef typename TR::PredMap PredMap; |
|
194 |
/// \brief The type of the map that stores the distances of the nodes. |
|
195 |
typedef typename TR::DistMap DistMap; |
|
196 |
/// The type of the paths. |
|
197 |
typedef PredMapPath<Digraph, PredMap> Path; |
|
198 |
///\brief The \ref BellmanFordDefaultOperationTraits |
|
199 |
/// "operation traits class" of the algorithm. |
|
200 |
typedef typename TR::OperationTraits OperationTraits; |
|
201 |
|
|
202 |
///The \ref BellmanFordDefaultTraits "traits class" of the algorithm. |
|
203 |
typedef TR Traits; |
|
204 |
|
|
205 |
private: |
|
206 |
|
|
207 |
typedef typename Digraph::Node Node; |
|
208 |
typedef typename Digraph::NodeIt NodeIt; |
|
209 |
typedef typename Digraph::Arc Arc; |
|
210 |
typedef typename Digraph::OutArcIt OutArcIt; |
|
211 |
|
|
212 |
// Pointer to the underlying digraph. |
|
213 |
const Digraph *_gr; |
|
214 |
// Pointer to the length map |
|
215 |
const LengthMap *_length; |
|
216 |
// Pointer to the map of predecessors arcs. |
|
217 |
PredMap *_pred; |
|
218 |
// Indicates if _pred is locally allocated (true) or not. |
|
219 |
bool _local_pred; |
|
220 |
// Pointer to the map of distances. |
|
221 |
DistMap *_dist; |
|
222 |
// Indicates if _dist is locally allocated (true) or not. |
|
223 |
bool _local_dist; |
|
224 |
|
|
225 |
typedef typename Digraph::template NodeMap<bool> MaskMap; |
|
226 |
MaskMap *_mask; |
|
227 |
|
|
228 |
std::vector<Node> _process; |
|
229 |
|
|
230 |
// Creates the maps if necessary. |
|
231 |
void create_maps() { |
|
232 |
if(!_pred) { |
|
233 |
_local_pred = true; |
|
234 |
_pred = Traits::createPredMap(*_gr); |
|
235 |
} |
|
236 |
if(!_dist) { |
|
237 |
_local_dist = true; |
|
238 |
_dist = Traits::createDistMap(*_gr); |
|
239 |
} |
|
240 |
_mask = new MaskMap(*_gr, false); |
|
241 |
} |
|
242 |
|
|
243 |
public : |
|
244 |
|
|
245 |
typedef BellmanFord Create; |
|
246 |
|
|
247 |
/// \name Named Template Parameters |
|
248 |
|
|
249 |
///@{ |
|
250 |
|
|
251 |
template <class T> |
|
252 |
struct SetPredMapTraits : public Traits { |
|
253 |
typedef T PredMap; |
|
254 |
static PredMap *createPredMap(const Digraph&) { |
|
255 |
LEMON_ASSERT(false, "PredMap is not initialized"); |
|
256 |
return 0; // ignore warnings |
|
257 |
} |
|
258 |
}; |
|
259 |
|
|
260 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
261 |
/// \c PredMap type. |
|
262 |
/// |
|
263 |
/// \ref named-templ-param "Named parameter" for setting |
|
264 |
/// \c PredMap type. |
|
265 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
266 |
template <class T> |
|
267 |
struct SetPredMap |
|
268 |
: public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > { |
|
269 |
typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create; |
|
270 |
}; |
|
271 |
|
|
272 |
template <class T> |
|
273 |
struct SetDistMapTraits : public Traits { |
|
274 |
typedef T DistMap; |
|
275 |
static DistMap *createDistMap(const Digraph&) { |
|
276 |
LEMON_ASSERT(false, "DistMap is not initialized"); |
|
277 |
return 0; // ignore warnings |
|
278 |
} |
|
279 |
}; |
|
280 |
|
|
281 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
282 |
/// \c DistMap type. |
|
283 |
/// |
|
284 |
/// \ref named-templ-param "Named parameter" for setting |
|
285 |
/// \c DistMap type. |
|
286 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
287 |
template <class T> |
|
288 |
struct SetDistMap |
|
289 |
: public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > { |
|
290 |
typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create; |
|
291 |
}; |
|
292 |
|
|
293 |
template <class T> |
|
294 |
struct SetOperationTraitsTraits : public Traits { |
|
295 |
typedef T OperationTraits; |
|
296 |
}; |
|
297 |
|
|
298 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
299 |
/// \c OperationTraits type. |
|
300 |
/// |
|
301 |
/// \ref named-templ-param "Named parameter" for setting |
|
302 |
/// \c OperationTraits type. |
|
303 |
/// For more information, see \ref BellmanFordDefaultOperationTraits. |
|
304 |
template <class T> |
|
305 |
struct SetOperationTraits |
|
306 |
: public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > { |
|
307 |
typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > |
|
308 |
Create; |
|
309 |
}; |
|
310 |
|
|
311 |
///@} |
|
312 |
|
|
313 |
protected: |
|
314 |
|
|
315 |
BellmanFord() {} |
|
316 |
|
|
317 |
public: |
|
318 |
|
|
319 |
/// \brief Constructor. |
|
320 |
/// |
|
321 |
/// Constructor. |
|
322 |
/// \param g The digraph the algorithm runs on. |
|
323 |
/// \param length The length map used by the algorithm. |
|
324 |
BellmanFord(const Digraph& g, const LengthMap& length) : |
|
325 |
_gr(&g), _length(&length), |
|
326 |
_pred(0), _local_pred(false), |
|
327 |
_dist(0), _local_dist(false), _mask(0) {} |
|
328 |
|
|
329 |
///Destructor. |
|
330 |
~BellmanFord() { |
|
331 |
if(_local_pred) delete _pred; |
|
332 |
if(_local_dist) delete _dist; |
|
333 |
if(_mask) delete _mask; |
|
334 |
} |
|
335 |
|
|
336 |
/// \brief Sets the length map. |
|
337 |
/// |
|
338 |
/// Sets the length map. |
|
339 |
/// \return <tt>(*this)</tt> |
|
340 |
BellmanFord &lengthMap(const LengthMap &map) { |
|
341 |
_length = ↦ |
|
342 |
return *this; |
|
343 |
} |
|
344 |
|
|
345 |
/// \brief Sets the map that stores the predecessor arcs. |
|
346 |
/// |
|
347 |
/// Sets the map that stores the predecessor arcs. |
|
348 |
/// If you don't use this function before calling \ref run() |
|
349 |
/// or \ref init(), an instance will be allocated automatically. |
|
350 |
/// The destructor deallocates this automatically allocated map, |
|
351 |
/// of course. |
|
352 |
/// \return <tt>(*this)</tt> |
|
353 |
BellmanFord &predMap(PredMap &map) { |
|
354 |
if(_local_pred) { |
|
355 |
delete _pred; |
|
356 |
_local_pred=false; |
|
357 |
} |
|
358 |
_pred = ↦ |
|
359 |
return *this; |
|
360 |
} |
|
361 |
|
|
362 |
/// \brief Sets the map that stores the distances of the nodes. |
|
363 |
/// |
|
364 |
/// Sets the map that stores the distances of the nodes calculated |
|
365 |
/// by the algorithm. |
|
366 |
/// If you don't use this function before calling \ref run() |
|
367 |
/// or \ref init(), an instance will be allocated automatically. |
|
368 |
/// The destructor deallocates this automatically allocated map, |
|
369 |
/// of course. |
|
370 |
/// \return <tt>(*this)</tt> |
|
371 |
BellmanFord &distMap(DistMap &map) { |
|
372 |
if(_local_dist) { |
|
373 |
delete _dist; |
|
374 |
_local_dist=false; |
|
375 |
} |
|
376 |
_dist = ↦ |
|
377 |
return *this; |
|
378 |
} |
|
379 |
|
|
380 |
/// \name Execution Control |
|
381 |
/// The simplest way to execute the Bellman-Ford algorithm is to use |
|
382 |
/// one of the member functions called \ref run().\n |
|
383 |
/// If you need better control on the execution, you have to call |
|
384 |
/// \ref init() first, then you can add several source nodes |
|
385 |
/// with \ref addSource(). Finally the actual path computation can be |
|
386 |
/// performed with \ref start(), \ref checkedStart() or |
|
387 |
/// \ref limitedStart(). |
|
388 |
|
|
389 |
///@{ |
|
390 |
|
|
391 |
/// \brief Initializes the internal data structures. |
|
392 |
/// |
|
393 |
/// Initializes the internal data structures. The optional parameter |
|
394 |
/// is the initial distance of each node. |
|
395 |
void init(const Value value = OperationTraits::infinity()) { |
|
396 |
create_maps(); |
|
397 |
for (NodeIt it(*_gr); it != INVALID; ++it) { |
|
398 |
_pred->set(it, INVALID); |
|
399 |
_dist->set(it, value); |
|
400 |
} |
|
401 |
_process.clear(); |
|
402 |
if (OperationTraits::less(value, OperationTraits::infinity())) { |
|
403 |
for (NodeIt it(*_gr); it != INVALID; ++it) { |
|
404 |
_process.push_back(it); |
|
405 |
_mask->set(it, true); |
|
406 |
} |
|
407 |
} |
|
408 |
} |
|
409 |
|
|
410 |
/// \brief Adds a new source node. |
|
411 |
/// |
|
412 |
/// This function adds a new source node. The optional second parameter |
|
413 |
/// is the initial distance of the node. |
|
414 |
void addSource(Node source, Value dst = OperationTraits::zero()) { |
|
415 |
_dist->set(source, dst); |
|
416 |
if (!(*_mask)[source]) { |
|
417 |
_process.push_back(source); |
|
418 |
_mask->set(source, true); |
|
419 |
} |
|
420 |
} |
|
421 |
|
|
422 |
/// \brief Executes one round from the Bellman-Ford algorithm. |
|
423 |
/// |
|
424 |
/// If the algoritm calculated the distances in the previous round |
|
425 |
/// exactly for the paths of at most \c k arcs, then this function |
|
426 |
/// will calculate the distances exactly for the paths of at most |
|
427 |
/// <tt>k+1</tt> arcs. Performing \c k iterations using this function |
|
428 |
/// calculates the shortest path distances exactly for the paths |
|
429 |
/// consisting of at most \c k arcs. |
|
430 |
/// |
|
431 |
/// \warning The paths with limited arc number cannot be retrieved |
|
432 |
/// easily with \ref path() or \ref predArc() functions. If you also |
|
433 |
/// need the shortest paths and not only the distances, you should |
|
434 |
/// store the \ref predMap() "predecessor map" after each iteration |
|
435 |
/// and build the path manually. |
|
436 |
/// |
|
437 |
/// \return \c true when the algorithm have not found more shorter |
|
438 |
/// paths. |
|
439 |
/// |
|
440 |
/// \see ActiveIt |
|
441 |
bool processNextRound() { |
|
442 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
443 |
_mask->set(_process[i], false); |
|
444 |
} |
|
445 |
std::vector<Node> nextProcess; |
|
446 |
std::vector<Value> values(_process.size()); |
|
447 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
448 |
values[i] = (*_dist)[_process[i]]; |
|
449 |
} |
|
450 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
451 |
for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) { |
|
452 |
Node target = _gr->target(it); |
|
453 |
Value relaxed = OperationTraits::plus(values[i], (*_length)[it]); |
|
454 |
if (OperationTraits::less(relaxed, (*_dist)[target])) { |
|
455 |
_pred->set(target, it); |
|
456 |
_dist->set(target, relaxed); |
|
457 |
if (!(*_mask)[target]) { |
|
458 |
_mask->set(target, true); |
|
459 |
nextProcess.push_back(target); |
|
460 |
} |
|
461 |
} |
|
462 |
} |
|
463 |
} |
|
464 |
_process.swap(nextProcess); |
|
465 |
return _process.empty(); |
|
466 |
} |
|
467 |
|
|
468 |
/// \brief Executes one weak round from the Bellman-Ford algorithm. |
|
469 |
/// |
|
470 |
/// If the algorithm calculated the distances in the previous round |
|
471 |
/// at least for the paths of at most \c k arcs, then this function |
|
472 |
/// will calculate the distances at least for the paths of at most |
|
473 |
/// <tt>k+1</tt> arcs. |
|
474 |
/// This function does not make it possible to calculate the shortest |
|
475 |
/// path distances exactly for paths consisting of at most \c k arcs, |
|
476 |
/// this is why it is called weak round. |
|
477 |
/// |
|
478 |
/// \return \c true when the algorithm have not found more shorter |
|
479 |
/// paths. |
|
480 |
/// |
|
481 |
/// \see ActiveIt |
|
482 |
bool processNextWeakRound() { |
|
483 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
484 |
_mask->set(_process[i], false); |
|
485 |
} |
|
486 |
std::vector<Node> nextProcess; |
|
487 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
488 |
for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) { |
|
489 |
Node target = _gr->target(it); |
|
490 |
Value relaxed = |
|
491 |
OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]); |
|
492 |
if (OperationTraits::less(relaxed, (*_dist)[target])) { |
|
493 |
_pred->set(target, it); |
|
494 |
_dist->set(target, relaxed); |
|
495 |
if (!(*_mask)[target]) { |
|
496 |
_mask->set(target, true); |
|
497 |
nextProcess.push_back(target); |
|
498 |
} |
|
499 |
} |
|
500 |
} |
|
501 |
} |
|
502 |
_process.swap(nextProcess); |
|
503 |
return _process.empty(); |
|
504 |
} |
|
505 |
|
|
506 |
/// \brief Executes the algorithm. |
|
507 |
/// |
|
508 |
/// Executes the algorithm. |
|
509 |
/// |
|
510 |
/// This method runs the Bellman-Ford algorithm from the root node(s) |
|
511 |
/// in order to compute the shortest path to each node. |
|
512 |
/// |
|
513 |
/// The algorithm computes |
|
514 |
/// - the shortest path tree (forest), |
|
515 |
/// - the distance of each node from the root(s). |
|
516 |
/// |
|
517 |
/// \pre init() must be called and at least one root node should be |
|
518 |
/// added with addSource() before using this function. |
|
519 |
void start() { |
|
520 |
int num = countNodes(*_gr) - 1; |
|
521 |
for (int i = 0; i < num; ++i) { |
|
522 |
if (processNextWeakRound()) break; |
|
523 |
} |
|
524 |
} |
|
525 |
|
|
526 |
/// \brief Executes the algorithm and checks the negative cycles. |
|
527 |
/// |
|
528 |
/// Executes the algorithm and checks the negative cycles. |
|
529 |
/// |
|
530 |
/// This method runs the Bellman-Ford algorithm from the root node(s) |
|
531 |
/// in order to compute the shortest path to each node and also checks |
|
532 |
/// if the digraph contains cycles with negative total length. |
|
533 |
/// |
|
534 |
/// The algorithm computes |
|
535 |
/// - the shortest path tree (forest), |
|
536 |
/// - the distance of each node from the root(s). |
|
537 |
/// |
|
538 |
/// \return \c false if there is a negative cycle in the digraph. |
|
539 |
/// |
|
540 |
/// \pre init() must be called and at least one root node should be |
|
541 |
/// added with addSource() before using this function. |
|
542 |
bool checkedStart() { |
|
543 |
int num = countNodes(*_gr); |
|
544 |
for (int i = 0; i < num; ++i) { |
|
545 |
if (processNextWeakRound()) return true; |
|
546 |
} |
|
547 |
return _process.empty(); |
|
548 |
} |
|
549 |
|
|
550 |
/// \brief Executes the algorithm with arc number limit. |
|
551 |
/// |
|
552 |
/// Executes the algorithm with arc number limit. |
|
553 |
/// |
|
554 |
/// This method runs the Bellman-Ford algorithm from the root node(s) |
|
555 |
/// in order to compute the shortest path distance for each node |
|
556 |
/// using only the paths consisting of at most \c num arcs. |
|
557 |
/// |
|
558 |
/// The algorithm computes |
|
559 |
/// - the limited distance of each node from the root(s), |
|
560 |
/// - the predecessor arc for each node. |
|
561 |
/// |
|
562 |
/// \warning The paths with limited arc number cannot be retrieved |
|
563 |
/// easily with \ref path() or \ref predArc() functions. If you also |
|
564 |
/// need the shortest paths and not only the distances, you should |
|
565 |
/// store the \ref predMap() "predecessor map" after each iteration |
|
566 |
/// and build the path manually. |
|
567 |
/// |
|
568 |
/// \pre init() must be called and at least one root node should be |
|
569 |
/// added with addSource() before using this function. |
|
570 |
void limitedStart(int num) { |
|
571 |
for (int i = 0; i < num; ++i) { |
|
572 |
if (processNextRound()) break; |
|
573 |
} |
|
574 |
} |
|
575 |
|
|
576 |
/// \brief Runs the algorithm from the given root node. |
|
577 |
/// |
|
578 |
/// This method runs the Bellman-Ford algorithm from the given root |
|
579 |
/// node \c s in order to compute the shortest path to each node. |
|
580 |
/// |
|
581 |
/// The algorithm computes |
|
582 |
/// - the shortest path tree (forest), |
|
583 |
/// - the distance of each node from the root(s). |
|
584 |
/// |
|
585 |
/// \note bf.run(s) is just a shortcut of the following code. |
|
586 |
/// \code |
|
587 |
/// bf.init(); |
|
588 |
/// bf.addSource(s); |
|
589 |
/// bf.start(); |
|
590 |
/// \endcode |
|
591 |
void run(Node s) { |
|
592 |
init(); |
|
593 |
addSource(s); |
|
594 |
start(); |
|
595 |
} |
|
596 |
|
|
597 |
/// \brief Runs the algorithm from the given root node with arc |
|
598 |
/// number limit. |
|
599 |
/// |
|
600 |
/// This method runs the Bellman-Ford algorithm from the given root |
|
601 |
/// node \c s in order to compute the shortest path distance for each |
|
602 |
/// node using only the paths consisting of at most \c num arcs. |
|
603 |
/// |
|
604 |
/// The algorithm computes |
|
605 |
/// - the limited distance of each node from the root(s), |
|
606 |
/// - the predecessor arc for each node. |
|
607 |
/// |
|
608 |
/// \warning The paths with limited arc number cannot be retrieved |
|
609 |
/// easily with \ref path() or \ref predArc() functions. If you also |
|
610 |
/// need the shortest paths and not only the distances, you should |
|
611 |
/// store the \ref predMap() "predecessor map" after each iteration |
|
612 |
/// and build the path manually. |
|
613 |
/// |
|
614 |
/// \note bf.run(s, num) is just a shortcut of the following code. |
|
615 |
/// \code |
|
616 |
/// bf.init(); |
|
617 |
/// bf.addSource(s); |
|
618 |
/// bf.limitedStart(num); |
|
619 |
/// \endcode |
|
620 |
void run(Node s, int num) { |
|
621 |
init(); |
|
622 |
addSource(s); |
|
623 |
limitedStart(num); |
|
624 |
} |
|
625 |
|
|
626 |
///@} |
|
627 |
|
|
628 |
/// \brief LEMON iterator for getting the active nodes. |
|
629 |
/// |
|
630 |
/// This class provides a common style LEMON iterator that traverses |
|
631 |
/// the active nodes of the Bellman-Ford algorithm after the last |
|
632 |
/// phase. These nodes should be checked in the next phase to |
|
633 |
/// find augmenting arcs outgoing from them. |
|
634 |
class ActiveIt { |
|
635 |
public: |
|
636 |
|
|
637 |
/// \brief Constructor. |
|
638 |
/// |
|
639 |
/// Constructor for getting the active nodes of the given BellmanFord |
|
640 |
/// instance. |
|
641 |
ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm) |
|
642 |
{ |
|
643 |
_index = _algorithm->_process.size() - 1; |
|
644 |
} |
|
645 |
|
|
646 |
/// \brief Invalid constructor. |
|
647 |
/// |
|
648 |
/// Invalid constructor. |
|
649 |
ActiveIt(Invalid) : _algorithm(0), _index(-1) {} |
|
650 |
|
|
651 |
/// \brief Conversion to \c Node. |
|
652 |
/// |
|
653 |
/// Conversion to \c Node. |
|
654 |
operator Node() const { |
|
655 |
return _index >= 0 ? _algorithm->_process[_index] : INVALID; |
|
656 |
} |
|
657 |
|
|
658 |
/// \brief Increment operator. |
|
659 |
/// |
|
660 |
/// Increment operator. |
|
661 |
ActiveIt& operator++() { |
|
662 |
--_index; |
|
663 |
return *this; |
|
664 |
} |
|
665 |
|
|
666 |
bool operator==(const ActiveIt& it) const { |
|
667 |
return static_cast<Node>(*this) == static_cast<Node>(it); |
|
668 |
} |
|
669 |
bool operator!=(const ActiveIt& it) const { |
|
670 |
return static_cast<Node>(*this) != static_cast<Node>(it); |
|
671 |
} |
|
672 |
bool operator<(const ActiveIt& it) const { |
|
673 |
return static_cast<Node>(*this) < static_cast<Node>(it); |
|
674 |
} |
|
675 |
|
|
676 |
private: |
|
677 |
const BellmanFord* _algorithm; |
|
678 |
int _index; |
|
679 |
}; |
|
680 |
|
|
681 |
/// \name Query Functions |
|
682 |
/// The result of the Bellman-Ford algorithm can be obtained using these |
|
683 |
/// functions.\n |
|
684 |
/// Either \ref run() or \ref init() should be called before using them. |
|
685 |
|
|
686 |
///@{ |
|
687 |
|
|
688 |
/// \brief The shortest path to the given node. |
|
689 |
/// |
|
690 |
/// Gives back the shortest path to the given node from the root(s). |
|
691 |
/// |
|
692 |
/// \warning \c t should be reached from the root(s). |
|
693 |
/// |
|
694 |
/// \pre Either \ref run() or \ref init() must be called before |
|
695 |
/// using this function. |
|
696 |
Path path(Node t) const |
|
697 |
{ |
|
698 |
return Path(*_gr, *_pred, t); |
|
699 |
} |
|
700 |
|
|
701 |
/// \brief The distance of the given node from the root(s). |
|
702 |
/// |
|
703 |
/// Returns the distance of the given node from the root(s). |
|
704 |
/// |
|
705 |
/// \warning If node \c v is not reached from the root(s), then |
|
706 |
/// the return value of this function is undefined. |
|
707 |
/// |
|
708 |
/// \pre Either \ref run() or \ref init() must be called before |
|
709 |
/// using this function. |
|
710 |
Value dist(Node v) const { return (*_dist)[v]; } |
|
711 |
|
|
712 |
/// \brief Returns the 'previous arc' of the shortest path tree for |
|
713 |
/// the given node. |
|
714 |
/// |
|
715 |
/// This function returns the 'previous arc' of the shortest path |
|
716 |
/// tree for node \c v, i.e. it returns the last arc of a |
|
717 |
/// shortest path from a root to \c v. It is \c INVALID if \c v |
|
718 |
/// is not reached from the root(s) or if \c v is a root. |
|
719 |
/// |
|
720 |
/// The shortest path tree used here is equal to the shortest path |
|
721 |
/// tree used in \ref predNode() and \ref predMap(). |
|
722 |
/// |
|
723 |
/// \pre Either \ref run() or \ref init() must be called before |
|
724 |
/// using this function. |
|
725 |
Arc predArc(Node v) const { return (*_pred)[v]; } |
|
726 |
|
|
727 |
/// \brief Returns the 'previous node' of the shortest path tree for |
|
728 |
/// the given node. |
|
729 |
/// |
|
730 |
/// This function returns the 'previous node' of the shortest path |
|
731 |
/// tree for node \c v, i.e. it returns the last but one node of |
|
732 |
/// a shortest path from a root to \c v. It is \c INVALID if \c v |
|
733 |
/// is not reached from the root(s) or if \c v is a root. |
|
734 |
/// |
|
735 |
/// The shortest path tree used here is equal to the shortest path |
|
736 |
/// tree used in \ref predArc() and \ref predMap(). |
|
737 |
/// |
|
738 |
/// \pre Either \ref run() or \ref init() must be called before |
|
739 |
/// using this function. |
|
740 |
Node predNode(Node v) const { |
|
741 |
return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]); |
|
742 |
} |
|
743 |
|
|
744 |
/// \brief Returns a const reference to the node map that stores the |
|
745 |
/// distances of the nodes. |
|
746 |
/// |
|
747 |
/// Returns a const reference to the node map that stores the distances |
|
748 |
/// of the nodes calculated by the algorithm. |
|
749 |
/// |
|
750 |
/// \pre Either \ref run() or \ref init() must be called before |
|
751 |
/// using this function. |
|
752 |
const DistMap &distMap() const { return *_dist;} |
|
753 |
|
|
754 |
/// \brief Returns a const reference to the node map that stores the |
|
755 |
/// predecessor arcs. |
|
756 |
/// |
|
757 |
/// Returns a const reference to the node map that stores the predecessor |
|
758 |
/// arcs, which form the shortest path tree (forest). |
|
759 |
/// |
|
760 |
/// \pre Either \ref run() or \ref init() must be called before |
|
761 |
/// using this function. |
|
762 |
const PredMap &predMap() const { return *_pred; } |
|
763 |
|
|
764 |
/// \brief Checks if a node is reached from the root(s). |
|
765 |
/// |
|
766 |
/// Returns \c true if \c v is reached from the root(s). |
|
767 |
/// |
|
768 |
/// \pre Either \ref run() or \ref init() must be called before |
|
769 |
/// using this function. |
|
770 |
bool reached(Node v) const { |
|
771 |
return (*_dist)[v] != OperationTraits::infinity(); |
|
772 |
} |
|
773 |
|
|
774 |
/// \brief Gives back a negative cycle. |
|
775 |
/// |
|
776 |
/// This function gives back a directed cycle with negative total |
|
777 |
/// length if the algorithm has already found one. |
|
778 |
/// Otherwise it gives back an empty path. |
|
779 |
lemon::Path<Digraph> negativeCycle() const { |
|
780 |
typename Digraph::template NodeMap<int> state(*_gr, -1); |
|
781 |
lemon::Path<Digraph> cycle; |
|
782 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
783 |
if (state[_process[i]] != -1) continue; |
|
784 |
for (Node v = _process[i]; (*_pred)[v] != INVALID; |
|
785 |
v = _gr->source((*_pred)[v])) { |
|
786 |
if (state[v] == i) { |
|
787 |
cycle.addFront((*_pred)[v]); |
|
788 |
for (Node u = _gr->source((*_pred)[v]); u != v; |
|
789 |
u = _gr->source((*_pred)[u])) { |
|
790 |
cycle.addFront((*_pred)[u]); |
|
791 |
} |
|
792 |
return cycle; |
|
793 |
} |
|
794 |
else if (state[v] >= 0) { |
|
795 |
break; |
|
796 |
} |
|
797 |
state[v] = i; |
|
798 |
} |
|
799 |
} |
|
800 |
return cycle; |
|
801 |
} |
|
802 |
|
|
803 |
///@} |
|
804 |
}; |
|
805 |
|
|
806 |
/// \brief Default traits class of bellmanFord() function. |
|
807 |
/// |
|
808 |
/// Default traits class of bellmanFord() function. |
|
809 |
/// \tparam GR The type of the digraph. |
|
810 |
/// \tparam LEN The type of the length map. |
|
811 |
template <typename GR, typename LEN> |
|
812 |
struct BellmanFordWizardDefaultTraits { |
|
813 |
/// The type of the digraph the algorithm runs on. |
|
814 |
typedef GR Digraph; |
|
815 |
|
|
816 |
/// \brief The type of the map that stores the arc lengths. |
|
817 |
/// |
|
818 |
/// The type of the map that stores the arc lengths. |
|
819 |
/// It must meet the \ref concepts::ReadMap "ReadMap" concept. |
|
820 |
typedef LEN LengthMap; |
|
821 |
|
|
822 |
/// The type of the arc lengths. |
|
823 |
typedef typename LEN::Value Value; |
|
824 |
|
|
825 |
/// \brief Operation traits for Bellman-Ford algorithm. |
|
826 |
/// |
|
827 |
/// It defines the used operations and the infinity value for the |
|
828 |
/// given \c Value type. |
|
829 |
/// \see BellmanFordDefaultOperationTraits |
|
830 |
typedef BellmanFordDefaultOperationTraits<Value> OperationTraits; |
|
831 |
|
|
832 |
/// \brief The type of the map that stores the last |
|
833 |
/// arcs of the shortest paths. |
|
834 |
/// |
|
835 |
/// The type of the map that stores the last arcs of the shortest paths. |
|
836 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
837 |
typedef typename GR::template NodeMap<typename GR::Arc> PredMap; |
|
838 |
|
|
839 |
/// \brief Instantiates a \c PredMap. |
|
840 |
/// |
|
841 |
/// This function instantiates a \ref PredMap. |
|
842 |
/// \param g is the digraph to which we would like to define the |
|
843 |
/// \ref PredMap. |
|
844 |
static PredMap *createPredMap(const GR &g) { |
|
845 |
return new PredMap(g); |
|
846 |
} |
|
847 |
|
|
848 |
/// \brief The type of the map that stores the distances of the nodes. |
|
849 |
/// |
|
850 |
/// The type of the map that stores the distances of the nodes. |
|
851 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
852 |
typedef typename GR::template NodeMap<Value> DistMap; |
|
853 |
|
|
854 |
/// \brief Instantiates a \c DistMap. |
|
855 |
/// |
|
856 |
/// This function instantiates a \ref DistMap. |
|
857 |
/// \param g is the digraph to which we would like to define the |
|
858 |
/// \ref DistMap. |
|
859 |
static DistMap *createDistMap(const GR &g) { |
|
860 |
return new DistMap(g); |
|
861 |
} |
|
862 |
|
|
863 |
///The type of the shortest paths. |
|
864 |
|
|
865 |
///The type of the shortest paths. |
|
866 |
///It must meet the \ref concepts::Path "Path" concept. |
|
867 |
typedef lemon::Path<Digraph> Path; |
|
868 |
}; |
|
869 |
|
|
870 |
/// \brief Default traits class used by BellmanFordWizard. |
|
871 |
/// |
|
872 |
/// Default traits class used by BellmanFordWizard. |
|
873 |
/// \tparam GR The type of the digraph. |
|
874 |
/// \tparam LEN The type of the length map. |
|
875 |
template <typename GR, typename LEN> |
|
876 |
class BellmanFordWizardBase |
|
877 |
: public BellmanFordWizardDefaultTraits<GR, LEN> { |
|
878 |
|
|
879 |
typedef BellmanFordWizardDefaultTraits<GR, LEN> Base; |
|
880 |
protected: |
|
881 |
// Type of the nodes in the digraph. |
|
882 |
typedef typename Base::Digraph::Node Node; |
|
883 |
|
|
884 |
// Pointer to the underlying digraph. |
|
885 |
void *_graph; |
|
886 |
// Pointer to the length map |
|
887 |
void *_length; |
|
888 |
// Pointer to the map of predecessors arcs. |
|
889 |
void *_pred; |
|
890 |
// Pointer to the map of distances. |
|
891 |
void *_dist; |
|
892 |
//Pointer to the shortest path to the target node. |
|
893 |
void *_path; |
|
894 |
//Pointer to the distance of the target node. |
|
895 |
void *_di; |
|
896 |
|
|
897 |
public: |
|
898 |
/// Constructor. |
|
899 |
|
|
900 |
/// This constructor does not require parameters, it initiates |
|
901 |
/// all of the attributes to default values \c 0. |
|
902 |
BellmanFordWizardBase() : |
|
903 |
_graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {} |
|
904 |
|
|
905 |
/// Constructor. |
|
906 |
|
|
907 |
/// This constructor requires two parameters, |
|
908 |
/// others are initiated to \c 0. |
|
909 |
/// \param gr The digraph the algorithm runs on. |
|
910 |
/// \param len The length map. |
|
911 |
BellmanFordWizardBase(const GR& gr, |
|
912 |
const LEN& len) : |
|
913 |
_graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))), |
|
914 |
_length(reinterpret_cast<void*>(const_cast<LEN*>(&len))), |
|
915 |
_pred(0), _dist(0), _path(0), _di(0) {} |
|
916 |
|
|
917 |
}; |
|
918 |
|
|
919 |
/// \brief Auxiliary class for the function-type interface of the |
|
920 |
/// \ref BellmanFord "Bellman-Ford" algorithm. |
|
921 |
/// |
|
922 |
/// This auxiliary class is created to implement the |
|
923 |
/// \ref bellmanFord() "function-type interface" of the |
|
924 |
/// \ref BellmanFord "Bellman-Ford" algorithm. |
|
925 |
/// It does not have own \ref run() method, it uses the |
|
926 |
/// functions and features of the plain \ref BellmanFord. |
|
927 |
/// |
|
928 |
/// This class should only be used through the \ref bellmanFord() |
|
929 |
/// function, which makes it easier to use the algorithm. |
|
930 |
template<class TR> |
|
931 |
class BellmanFordWizard : public TR { |
|
932 |
typedef TR Base; |
|
933 |
|
|
934 |
typedef typename TR::Digraph Digraph; |
|
935 |
|
|
936 |
typedef typename Digraph::Node Node; |
|
937 |
typedef typename Digraph::NodeIt NodeIt; |
|
938 |
typedef typename Digraph::Arc Arc; |
|
939 |
typedef typename Digraph::OutArcIt ArcIt; |
|
940 |
|
|
941 |
typedef typename TR::LengthMap LengthMap; |
|
942 |
typedef typename LengthMap::Value Value; |
|
943 |
typedef typename TR::PredMap PredMap; |
|
944 |
typedef typename TR::DistMap DistMap; |
|
945 |
typedef typename TR::Path Path; |
|
946 |
|
|
947 |
public: |
|
948 |
/// Constructor. |
|
949 |
BellmanFordWizard() : TR() {} |
|
950 |
|
|
951 |
/// \brief Constructor that requires parameters. |
|
952 |
/// |
|
953 |
/// Constructor that requires parameters. |
|
954 |
/// These parameters will be the default values for the traits class. |
|
955 |
/// \param gr The digraph the algorithm runs on. |
|
956 |
/// \param len The length map. |
|
957 |
BellmanFordWizard(const Digraph& gr, const LengthMap& len) |
|
958 |
: TR(gr, len) {} |
|
959 |
|
|
960 |
/// \brief Copy constructor |
|
961 |
BellmanFordWizard(const TR &b) : TR(b) {} |
|
962 |
|
|
963 |
~BellmanFordWizard() {} |
|
964 |
|
|
965 |
/// \brief Runs the Bellman-Ford algorithm from the given source node. |
|
966 |
/// |
|
967 |
/// This method runs the Bellman-Ford algorithm from the given source |
|
968 |
/// node in order to compute the shortest path to each node. |
|
969 |
void run(Node s) { |
|
970 |
BellmanFord<Digraph,LengthMap,TR> |
|
971 |
bf(*reinterpret_cast<const Digraph*>(Base::_graph), |
|
972 |
*reinterpret_cast<const LengthMap*>(Base::_length)); |
|
973 |
if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred)); |
|
974 |
if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist)); |
|
975 |
bf.run(s); |
|
976 |
} |
|
977 |
|
|
978 |
/// \brief Runs the Bellman-Ford algorithm to find the shortest path |
|
979 |
/// between \c s and \c t. |
|
980 |
/// |
|
981 |
/// This method runs the Bellman-Ford algorithm from node \c s |
|
982 |
/// in order to compute the shortest path to node \c t. |
|
983 |
/// Actually, it computes the shortest path to each node, but using |
|
984 |
/// this function you can retrieve the distance and the shortest path |
|
985 |
/// for a single target node easier. |
|
986 |
/// |
|
987 |
/// \return \c true if \c t is reachable form \c s. |
|
988 |
bool run(Node s, Node t) { |
|
989 |
BellmanFord<Digraph,LengthMap,TR> |
|
990 |
bf(*reinterpret_cast<const Digraph*>(Base::_graph), |
|
991 |
*reinterpret_cast<const LengthMap*>(Base::_length)); |
|
992 |
if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred)); |
|
993 |
if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist)); |
|
994 |
bf.run(s); |
|
995 |
if (Base::_path) *reinterpret_cast<Path*>(Base::_path) = bf.path(t); |
|
996 |
if (Base::_di) *reinterpret_cast<Value*>(Base::_di) = bf.dist(t); |
|
997 |
return bf.reached(t); |
|
998 |
} |
|
999 |
|
|
1000 |
template<class T> |
|
1001 |
struct SetPredMapBase : public Base { |
|
1002 |
typedef T PredMap; |
|
1003 |
static PredMap *createPredMap(const Digraph &) { return 0; }; |
|
1004 |
SetPredMapBase(const TR &b) : TR(b) {} |
|
1005 |
}; |
|
1006 |
|
|
1007 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
1008 |
/// the predecessor map. |
|
1009 |
/// |
|
1010 |
/// \ref named-templ-param "Named parameter" for setting |
|
1011 |
/// the map that stores the predecessor arcs of the nodes. |
|
1012 |
template<class T> |
|
1013 |
BellmanFordWizard<SetPredMapBase<T> > predMap(const T &t) { |
|
1014 |
Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t)); |
|
1015 |
return BellmanFordWizard<SetPredMapBase<T> >(*this); |
|
1016 |
} |
|
1017 |
|
|
1018 |
template<class T> |
|
1019 |
struct SetDistMapBase : public Base { |
|
1020 |
typedef T DistMap; |
|
1021 |
static DistMap *createDistMap(const Digraph &) { return 0; }; |
|
1022 |
SetDistMapBase(const TR &b) : TR(b) {} |
|
1023 |
}; |
|
1024 |
|
|
1025 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
1026 |
/// the distance map. |
|
1027 |
/// |
|
1028 |
/// \ref named-templ-param "Named parameter" for setting |
|
1029 |
/// the map that stores the distances of the nodes calculated |
|
1030 |
/// by the algorithm. |
|
1031 |
template<class T> |
|
1032 |
BellmanFordWizard<SetDistMapBase<T> > distMap(const T &t) { |
|
1033 |
Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t)); |
|
1034 |
return BellmanFordWizard<SetDistMapBase<T> >(*this); |
|
1035 |
} |
|
1036 |
|
|
1037 |
template<class T> |
|
1038 |
struct SetPathBase : public Base { |
|
1039 |
typedef T Path; |
|
1040 |
SetPathBase(const TR &b) : TR(b) {} |
|
1041 |
}; |
|
1042 |
|
|
1043 |
/// \brief \ref named-func-param "Named parameter" for getting |
|
1044 |
/// the shortest path to the target node. |
|
1045 |
/// |
|
1046 |
/// \ref named-func-param "Named parameter" for getting |
|
1047 |
/// the shortest path to the target node. |
|
1048 |
template<class T> |
|
1049 |
BellmanFordWizard<SetPathBase<T> > path(const T &t) |
|
1050 |
{ |
|
1051 |
Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t)); |
|
1052 |
return BellmanFordWizard<SetPathBase<T> >(*this); |
|
1053 |
} |
|
1054 |
|
|
1055 |
/// \brief \ref named-func-param "Named parameter" for getting |
|
1056 |
/// the distance of the target node. |
|
1057 |
/// |
|
1058 |
/// \ref named-func-param "Named parameter" for getting |
|
1059 |
/// the distance of the target node. |
|
1060 |
BellmanFordWizard dist(const Value &d) |
|
1061 |
{ |
|
1062 |
Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d)); |
|
1063 |
return *this; |
|
1064 |
} |
|
1065 |
|
|
1066 |
}; |
|
1067 |
|
|
1068 |
/// \brief Function type interface for the \ref BellmanFord "Bellman-Ford" |
|
1069 |
/// algorithm. |
|
1070 |
/// |
|
1071 |
/// \ingroup shortest_path |
|
1072 |
/// Function type interface for the \ref BellmanFord "Bellman-Ford" |
|
1073 |
/// algorithm. |
|
1074 |
/// |
|
1075 |
/// This function also has several \ref named-templ-func-param |
|
1076 |
/// "named parameters", they are declared as the members of class |
|
1077 |
/// \ref BellmanFordWizard. |
|
1078 |
/// The following examples show how to use these parameters. |
|
1079 |
/// \code |
|
1080 |
/// // Compute shortest path from node s to each node |
|
1081 |
/// bellmanFord(g,length).predMap(preds).distMap(dists).run(s); |
|
1082 |
/// |
|
1083 |
/// // Compute shortest path from s to t |
|
1084 |
/// bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t); |
|
1085 |
/// \endcode |
|
1086 |
/// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()" |
|
1087 |
/// to the end of the parameter list. |
|
1088 |
/// \sa BellmanFordWizard |
|
1089 |
/// \sa BellmanFord |
|
1090 |
template<typename GR, typename LEN> |
|
1091 |
BellmanFordWizard<BellmanFordWizardBase<GR,LEN> > |
|
1092 |
bellmanFord(const GR& digraph, |
|
1093 |
const LEN& length) |
|
1094 |
{ |
|
1095 |
return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length); |
|
1096 |
} |
|
1097 |
|
|
1098 |
} //END OF NAMESPACE LEMON |
|
1099 |
|
|
1100 |
#endif |
|
1101 |
1 |
/* -*- mode: C++; indent-tabs-mode: nil; -*- |
|
2 |
* |
|
3 |
* This file is a part of LEMON, a generic C++ optimization library. |
|
4 |
* |
|
5 |
* Copyright (C) 2003-2009 |
|
6 |
* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport |
|
7 |
* (Egervary Research Group on Combinatorial Optimization, EGRES). |
|
8 |
* |
|
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. |
|
12 |
* |
|
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 |
|
15 |
* purpose. |
|
16 |
* |
|
17 |
*/ |
|
18 |
|
|
19 |
#ifndef LEMON_BINOM_HEAP_H |
|
20 |
#define LEMON_BINOM_HEAP_H |
|
21 |
|
|
22 |
///\file |
|
23 |
///\ingroup heaps |
|
24 |
///\brief Binomial Heap implementation. |
|
25 |
|
|
26 |
#include <vector> |
|
27 |
#include <utility> |
|
28 |
#include <functional> |
|
29 |
#include <lemon/math.h> |
|
30 |
#include <lemon/counter.h> |
|
31 |
|
|
32 |
namespace lemon { |
|
33 |
|
|
34 |
/// \ingroup heaps |
|
35 |
/// |
|
36 |
///\brief Binomial heap data structure. |
|
37 |
/// |
|
38 |
/// This class implements the \e binomial \e heap data structure. |
|
39 |
/// It fully conforms to the \ref concepts::Heap "heap concept". |
|
40 |
/// |
|
41 |
/// The methods \ref increase() and \ref erase() are not efficient |
|
42 |
/// in a binomial heap. In case of many calls of these operations, |
|
43 |
/// it is better to use other heap structure, e.g. \ref BinHeap |
|
44 |
/// "binary heap". |
|
45 |
/// |
|
46 |
/// \tparam PR Type of the priorities of the items. |
|
47 |
/// \tparam IM A read-writable item map with \c int values, used |
|
48 |
/// internally to handle the cross references. |
|
49 |
/// \tparam CMP A functor class for comparing the priorities. |
|
50 |
/// The default is \c std::less<PR>. |
|
51 |
#ifdef DOXYGEN |
|
52 |
template <typename PR, typename IM, typename CMP> |
|
53 |
#else |
|
54 |
template <typename PR, typename IM, typename CMP = std::less<PR> > |
|
55 |
#endif |
|
56 |
class BinomHeap { |
|
57 |
public: |
|
58 |
/// Type of the item-int map. |
|
59 |
typedef IM ItemIntMap; |
|
60 |
/// Type of the priorities. |
|
61 |
typedef PR Prio; |
|
62 |
/// Type of the items stored in the heap. |
|
63 |
typedef typename ItemIntMap::Key Item; |
|
64 |
/// Functor type for comparing the priorities. |
|
65 |
typedef CMP Compare; |
|
66 |
|
|
67 |
/// \brief Type to represent the states of the items. |
|
68 |
/// |
|
69 |
/// Each item has a state associated to it. It can be "in heap", |
|
70 |
/// "pre-heap" or "post-heap". The latter two are indifferent from the |
|
71 |
/// heap's point of view, but may be useful to the user. |
|
72 |
/// |
|
73 |
/// The item-int map must be initialized in such way that it assigns |
|
74 |
/// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap. |
|
75 |
enum State { |
|
76 |
IN_HEAP = 0, ///< = 0. |
|
77 |
PRE_HEAP = -1, ///< = -1. |
|
78 |
POST_HEAP = -2 ///< = -2. |
|
79 |
}; |
|
80 |
|
|
81 |
private: |
|
82 |
class Store; |
|
83 |
|
|
84 |
std::vector<Store> _data; |
|
85 |
int _min, _head; |
|
86 |
ItemIntMap &_iim; |
|
87 |
Compare _comp; |
|
88 |
int _num_items; |
|
89 |
|
|
90 |
public: |
|
91 |
/// \brief Constructor. |
|
92 |
/// |
|
93 |
/// Constructor. |
|
94 |
/// \param map A map that assigns \c int values to the items. |
|
95 |
/// It is used internally to handle the cross references. |
|
96 |
/// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. |
|
97 |
explicit BinomHeap(ItemIntMap &map) |
|
98 |
: _min(0), _head(-1), _iim(map), _num_items(0) {} |
|
99 |
|
|
100 |
/// \brief Constructor. |
|
101 |
/// |
|
102 |
/// Constructor. |
|
103 |
/// \param map A map that assigns \c int values to the items. |
|
104 |
/// It is used internally to handle the cross references. |
|
105 |
/// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. |
|
106 |
/// \param comp The function object used for comparing the priorities. |
|
107 |
BinomHeap(ItemIntMap &map, const Compare &comp) |
|
108 |
: _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {} |
|
109 |
|
|
110 |
/// \brief The number of items stored in the heap. |
|
111 |
/// |
|
112 |
/// This function returns the number of items stored in the heap. |
|
113 |
int size() const { return _num_items; } |
|
114 |
|
|
115 |
/// \brief Check if the heap is empty. |
|
116 |
/// |
|
117 |
/// This function returns \c true if the heap is empty. |
|
118 |
bool empty() const { return _num_items==0; } |
|
119 |
|
|
120 |
/// \brief Make the heap empty. |
|
121 |
/// |
|
122 |
/// This functon makes the heap empty. |
|
123 |
/// It does not change the cross reference map. If you want to reuse |
|
124 |
/// a heap that is not surely empty, you should first clear it and |
|
125 |
/// then you should set the cross reference map to \c PRE_HEAP |
|
126 |
/// for each item. |
|
127 |
void clear() { |
|
128 |
_data.clear(); _min=0; _num_items=0; _head=-1; |
|
129 |
} |
|
130 |
|
|
131 |
/// \brief Set the priority of an item or insert it, if it is |
|
132 |
/// not stored in the heap. |
|
133 |
/// |
|
134 |
/// This method sets the priority of the given item if it is |
|
135 |
/// already stored in the heap. Otherwise it inserts the given |
|
136 |
/// item into the heap with the given priority. |
|
137 |
/// \param item The item. |
|
138 |
/// \param value The priority. |
|
139 |
void set (const Item& item, const Prio& value) { |
|
140 |
int i=_iim[item]; |
|
141 |
if ( i >= 0 && _data[i].in ) { |
|
142 |
if ( _comp(value, _data[i].prio) ) decrease(item, value); |
|
143 |
if ( _comp(_data[i].prio, value) ) increase(item, value); |
|
144 |
} else push(item, value); |
|
145 |
} |
|
146 |
|
|
147 |
/// \brief Insert an item into the heap with the given priority. |
|
148 |
/// |
|
149 |
/// This function inserts the given item into the heap with the |
|
150 |
/// given priority. |
|
151 |
/// \param item The item to insert. |
|
152 |
/// \param value The priority of the item. |
|
153 |
/// \pre \e item must not be stored in the heap. |
|
154 |
void push (const Item& item, const Prio& value) { |
|
155 |
int i=_iim[item]; |
|
156 |
if ( i<0 ) { |
|
157 |
int s=_data.size(); |
|
158 |
_iim.set( item,s ); |
|
159 |
Store st; |
|
160 |
st.name=item; |
|
161 |
st.prio=value; |
|
162 |
_data.push_back(st); |
|
163 |
i=s; |
|
164 |
} |
|
165 |
else { |
|
166 |
_data[i].parent=_data[i].right_neighbor=_data[i].child=-1; |
|
167 |
_data[i].degree=0; |
|
168 |
_data[i].in=true; |
|
169 |
_data[i].prio=value; |
|
170 |
} |
|
171 |
|
|
172 |
if( 0==_num_items ) { |
|
173 |
_head=i; |
|
174 |
_min=i; |
|
175 |
} else { |
|
176 |
merge(i); |
|
177 |
if( _comp(_data[i].prio, _data[_min].prio) ) _min=i; |
|
178 |
} |
|
179 |
++_num_items; |
|
180 |
} |
|
181 |
|
|
182 |
/// \brief Return the item having minimum priority. |
|
183 |
/// |
|
184 |
/// This function returns the item having minimum priority. |
|
185 |
/// \pre The heap must be non-empty. |
|
186 |
Item top() const { return _data[_min].name; } |
|
187 |
|
|
188 |
/// \brief The minimum priority. |
|
189 |
/// |
|
190 |
/// This function returns the minimum priority. |
|
191 |
/// \pre The heap must be non-empty. |
|
192 |
Prio prio() const { return _data[_min].prio; } |
|
193 |
|
|
194 |
/// \brief The priority of the given item. |
|
195 |
/// |
|
196 |
/// This function returns the priority of the given item. |
|
197 |
/// \param item The item. |
|
198 |
/// \pre \e item must be in the heap. |
|
199 |
const Prio& operator[](const Item& item) const { |
|
200 |
return _data[_iim[item]].prio; |
|
201 |
} |
|
202 |
|
|
203 |
/// \brief Remove the item having minimum priority. |
|
204 |
/// |
|
205 |
/// This function removes the item having minimum priority. |
|
206 |
/// \pre The heap must be non-empty. |
|
207 |
void pop() { |
|
208 |
_data[_min].in=false; |
|
209 |
|
|
210 |
int head_child=-1; |
|
211 |
if ( _data[_min].child!=-1 ) { |
|
212 |
int child=_data[_min].child; |
|
213 |
int neighb; |
|
214 |
while( child!=-1 ) { |
|
215 |
neighb=_data[child].right_neighbor; |
|
216 |
_data[child].parent=-1; |
|
217 |
_data[child].right_neighbor=head_child; |
|
218 |
head_child=child; |
|
219 |
child=neighb; |
|
220 |
} |
|
221 |
} |
|
222 |
|
|
223 |
if ( _data[_head].right_neighbor==-1 ) { |
|
224 |
// there was only one root |
|
225 |
_head=head_child; |
|
226 |
} |
|
227 |
else { |
|
228 |
// there were more roots |
|
229 |
if( _head!=_min ) { unlace(_min); } |
|
230 |
else { _head=_data[_head].right_neighbor; } |
|
231 |
merge(head_child); |
|
232 |
} |
|
233 |
_min=findMin(); |
|
234 |
--_num_items; |
|
235 |
} |
|
236 |
|
|
237 |
/// \brief Remove the given item from the heap. |
|
238 |
/// |
|
239 |
/// This function removes the given item from the heap if it is |
|
240 |
/// already stored. |
|
241 |
/// \param item The item to delete. |
|
242 |
/// \pre \e item must be in the heap. |
|
243 |
void erase (const Item& item) { |
|
244 |
int i=_iim[item]; |
|
245 |
if ( i >= 0 && _data[i].in ) { |
|
246 |
decrease( item, _data[_min].prio-1 ); |
|
247 |
pop(); |
|
248 |
} |
|
249 |
} |
|
250 |
|
|
251 |
/// \brief Decrease the priority of an item to the given value. |
|
252 |
/// |
|
253 |
/// This function decreases the priority of an item to the given value. |
|
254 |
/// \param item The item. |
|
255 |
/// \param value The priority. |
|
256 |
/// \pre \e item must be stored in the heap with priority at least \e value. |
|
257 |
void decrease (Item item, const Prio& value) { |
|
258 |
int i=_iim[item]; |
|
259 |
int p=_data[i].parent; |
|
260 |
_data[i].prio=value; |
|
261 |
|
|
262 |
while( p!=-1 && _comp(value, _data[p].prio) ) { |
|
263 |
_data[i].name=_data[p].name; |
|
264 |
_data[i].prio=_data[p].prio; |
|
265 |
_data[p].name=item; |
|
266 |
_data[p].prio=value; |
|
267 |
_iim[_data[i].name]=i; |
|
268 |
i=p; |
|
269 |
p=_data[p].parent; |
|
270 |
} |
|
271 |
_iim[item]=i; |
|
272 |
if ( _comp(value, _data[_min].prio) ) _min=i; |
|
273 |
} |
|
274 |
|
|
275 |
/// \brief Increase the priority of an item to the given value. |
|
276 |
/// |
|
277 |
/// This function increases the priority of an item to the given value. |
|
278 |
/// \param item The item. |
|
279 |
/// \param value The priority. |
|
280 |
/// \pre \e item must be stored in the heap with priority at most \e value. |
|
281 |
void increase (Item item, const Prio& value) { |
|
282 |
erase(item); |
|
283 |
push(item, value); |
|
284 |
} |
|
285 |
|
|
286 |
/// \brief Return the state of an item. |
|
287 |
/// |
|
288 |
/// This method returns \c PRE_HEAP if the given item has never |
|
289 |
/// been in the heap, \c IN_HEAP if it is in the heap at the moment, |
|
290 |
/// and \c POST_HEAP otherwise. |
|
291 |
/// In the latter case it is possible that the item will get back |
|
292 |
/// to the heap again. |
|
293 |
/// \param item The item. |
|
294 |
State state(const Item &item) const { |
|
295 |
int i=_iim[item]; |
|
296 |
if( i>=0 ) { |
|
297 |
if ( _data[i].in ) i=0; |
|
298 |
else i=-2; |
|
299 |
} |
|
300 |
return State(i); |
|
301 |
} |
|
302 |
|
|
303 |
/// \brief Set the state of an item in the heap. |
|
304 |
/// |
|
305 |
/// This function sets the state of the given item in the heap. |
|
306 |
/// It can be used to manually clear the heap when it is important |
|
307 |
/// to achive better time complexity. |
|
308 |
/// \param i The item. |
|
309 |
/// \param st The state. It should not be \c IN_HEAP. |
|
310 |
void state(const Item& i, State st) { |
|
311 |
switch (st) { |
|
312 |
case POST_HEAP: |
|
313 |
case PRE_HEAP: |
|
314 |
if (state(i) == IN_HEAP) { |
|
315 |
erase(i); |
|
316 |
} |
|
317 |
_iim[i] = st; |
|
318 |
break; |
|
319 |
case IN_HEAP: |
|
320 |
break; |
|
321 |
} |
|
322 |
} |
|
323 |
|
|
324 |
private: |
|
325 |
|
|
326 |
// Find the minimum of the roots |
|
327 |
int findMin() { |
|
328 |
if( _head!=-1 ) { |
|
329 |
int min_loc=_head, min_val=_data[_head].prio; |
|
330 |
for( int x=_data[_head].right_neighbor; x!=-1; |
|
331 |
x=_data[x].right_neighbor ) { |
|
332 |
if( _comp( _data[x].prio,min_val ) ) { |
|
333 |
min_val=_data[x].prio; |
|
334 |
min_loc=x; |
|
335 |
} |
|
336 |
} |
|
337 |
return min_loc; |
|
338 |
} |
|
339 |
else return -1; |
|
340 |
} |
|
341 |
|
|
342 |
// Merge the heap with another heap starting at the given position |
|
343 |
void merge(int a) { |
|
344 |
if( _head==-1 || a==-1 ) return; |
|
345 |
if( _data[a].right_neighbor==-1 && |
|
346 |
_data[a].degree<=_data[_head].degree ) { |
|
347 |
_data[a].right_neighbor=_head; |
|
348 |
_head=a; |
|
349 |
} else { |
|
350 |
interleave(a); |
|
351 |
} |
|
352 |
if( _data[_head].right_neighbor==-1 ) return; |
|
353 |
|
|
354 |
int x=_head; |
|
355 |
int x_prev=-1, x_next=_data[x].right_neighbor; |
|
356 |
while( x_next!=-1 ) { |
|
357 |
if( _data[x].degree!=_data[x_next].degree || |
|
358 |
( _data[x_next].right_neighbor!=-1 && |
|
359 |
_data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) { |
|
360 |
x_prev=x; |
|
361 |
x=x_next; |
|
362 |
} |
|
363 |
else { |
|
364 |
if( _comp(_data[x_next].prio,_data[x].prio) ) { |
|
365 |
if( x_prev==-1 ) { |
|
366 |
_head=x_next; |
|
367 |
} else { |
|
368 |
_data[x_prev].right_neighbor=x_next; |
|
369 |
} |
|
370 |
fuse(x,x_next); |
|
371 |
x=x_next; |
|
372 |
} |
|
373 |
else { |
|
374 |
_data[x].right_neighbor=_data[x_next].right_neighbor; |
|
375 |
fuse(x_next,x); |
|
376 |
} |
|
377 |
} |
|
378 |
x_next=_data[x].right_neighbor; |
|
379 |
} |
|
380 |
} |
|
381 |
|
|
382 |
// Interleave the elements of the given list into the list of the roots |
|
383 |
void interleave(int a) { |
|
384 |
int p=_head, q=a; |
|
385 |
int curr=_data.size(); |
|
386 |
_data.push_back(Store()); |
|
387 |
|
|
388 |
while( p!=-1 || q!=-1 ) { |
|
389 |
if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) { |
|
390 |
_data[curr].right_neighbor=p; |
|
391 |
curr=p; |
|
392 |
p=_data[p].right_neighbor; |
|
393 |
} |
|
394 |
else { |
|
395 |
_data[curr].right_neighbor=q; |
|
396 |
curr=q; |
|
397 |
q=_data[q].right_neighbor; |
|
398 |
} |
|
399 |
} |
|
400 |
|
|
401 |
_head=_data.back().right_neighbor; |
|
402 |
_data.pop_back(); |
|
403 |
} |
|
404 |
|
|
405 |
// Lace node a under node b |
|
406 |
void fuse(int a, int b) { |
|
407 |
_data[a].parent=b; |
|
408 |
_data[a].right_neighbor=_data[b].child; |
|
409 |
_data[b].child=a; |
|
410 |
|
|
411 |
++_data[b].degree; |
|
412 |
} |
|
413 |
|
|
414 |
// Unlace node a (if it has siblings) |
|
415 |
void unlace(int a) { |
|
416 |
int neighb=_data[a].right_neighbor; |
|
417 |
int other=_head; |
|
418 |
|
|
419 |
while( _data[other].right_neighbor!=a ) |
|
420 |
other=_data[other].right_neighbor; |
|
421 |
_data[other].right_neighbor=neighb; |
|
422 |
} |
|
423 |
|
|
424 |
private: |
|
425 |
|
|
426 |
class Store { |
|
427 |
friend class BinomHeap; |
|
428 |
|
|
429 |
Item name; |
|
430 |
int parent; |
|
431 |
int right_neighbor; |
|
432 |
int child; |
|
433 |
int degree; |
|
434 |
bool in; |
|
435 |
Prio prio; |
|
436 |
|
|
437 |
Store() : parent(-1), right_neighbor(-1), child(-1), degree(0), |
|
438 |
in(true) {} |
|
439 |
}; |
|
440 |
}; |
|
441 |
|
|
442 |
} //namespace lemon |
|
443 |
|
|
444 |
#endif //LEMON_BINOM_HEAP_H |
|
445 |
... | ... |
@@ -32,12 +32,14 @@ |
32 | 32 |
FIND_PACKAGE(COIN) |
33 | 33 |
|
34 | 34 |
INCLUDE(CheckTypeSize) |
35 | 35 |
CHECK_TYPE_SIZE("long long" LONG_LONG) |
36 | 36 |
SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG}) |
37 | 37 |
|
38 |
INCLUDE(FindPythonInterp) |
|
39 |
|
|
38 | 40 |
ENABLE_TESTING() |
39 | 41 |
|
40 | 42 |
ADD_SUBDIRECTORY(lemon) |
41 | 43 |
IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR}) |
42 | 44 |
ADD_SUBDIRECTORY(demo) |
43 | 45 |
ADD_SUBDIRECTORY(tools) |
... | ... |
@@ -14,12 +14,13 @@ |
14 | 14 |
m4/lx_check_coin.m4 \ |
15 | 15 |
CMakeLists.txt \ |
16 | 16 |
cmake/FindGhostscript.cmake \ |
17 | 17 |
cmake/FindCPLEX.cmake \ |
18 | 18 |
cmake/FindGLPK.cmake \ |
19 | 19 |
cmake/FindCOIN.cmake \ |
20 |
cmake/LEMONConfig.cmake.in \ |
|
20 | 21 |
cmake/version.cmake.in \ |
21 | 22 |
cmake/version.cmake \ |
22 | 23 |
cmake/nsis/lemon.ico \ |
23 | 24 |
cmake/nsis/uninstall.ico |
24 | 25 |
|
25 | 26 |
pkgconfigdir = $(libdir)/pkgconfig |
... | ... |
@@ -40,12 +41,13 @@ |
40 | 41 |
XFAIL_TESTS = |
41 | 42 |
|
42 | 43 |
include lemon/Makefile.am |
43 | 44 |
include test/Makefile.am |
44 | 45 |
include doc/Makefile.am |
45 | 46 |
include tools/Makefile.am |
47 |
include scripts/Makefile.am |
|
46 | 48 |
|
47 | 49 |
DIST_SUBDIRS = demo |
48 | 50 |
|
49 | 51 |
demo: |
50 | 52 |
$(MAKE) $(AM_MAKEFLAGS) -C demo |
51 | 53 |
... | ... |
@@ -38,12 +38,13 @@ |
38 | 38 |
AC_PROG_CXXCPP |
39 | 39 |
AC_PROG_INSTALL |
40 | 40 |
AC_DISABLE_SHARED |
41 | 41 |
AC_PROG_LIBTOOL |
42 | 42 |
|
43 | 43 |
AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no]) |
44 |
AC_CHECK_PROG([python_found],[python],[yes],[no]) |
|
44 | 45 |
AC_CHECK_PROG([gs_found],[gs],[yes],[no]) |
45 | 46 |
|
46 | 47 |
dnl Detect Intel compiler. |
47 | 48 |
AC_MSG_CHECKING([whether we are using the Intel C++ compiler]) |
48 | 49 |
AC_COMPILE_IFELSE([#ifndef __INTEL_COMPILER |
49 | 50 |
choke me |
... | ... |
@@ -79,12 +80,27 @@ |
79 | 80 |
AC_MSG_RESULT([yes]) |
80 | 81 |
else |
81 | 82 |
AC_MSG_RESULT([no]) |
82 | 83 |
fi |
83 | 84 |
AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"]) |
84 | 85 |
|
86 |
dnl Support for running test cases using valgrind. |
|
87 |
use_valgrind=no |
|
88 |
AC_ARG_ENABLE([valgrind], |
|
89 |
AS_HELP_STRING([--enable-valgrind], [use valgrind when running tests]), |
|
90 |
[use_valgrind=yes]) |
|
91 |
|
|
92 |
if [[ "$use_valgrind" = "yes" ]]; then |
|
93 |
AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no) |
|
94 |
|
|
95 |
if [[ "$HAVE_VALGRIND" = "no" ]]; then |
|
96 |
AC_MSG_ERROR([Valgrind not found in PATH.]) |
|
97 |
fi |
|
98 |
fi |
|
99 |
AM_CONDITIONAL(USE_VALGRIND, [test "$use_valgrind" = "yes"]) |
|
100 |
|
|
85 | 101 |
dnl Checks for header files. |
86 | 102 |
AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h) |
87 | 103 |
|
88 | 104 |
dnl Checks for typedefs, structures, and compiler characteristics. |
89 | 105 |
AC_C_CONST |
90 | 106 |
AC_C_INLINE |
... | ... |
@@ -124,12 +140,13 @@ |
124 | 140 |
echo CPLEX support................. : $lx_cplex_found |
125 | 141 |
echo SOPLEX support................ : $lx_soplex_found |
126 | 142 |
echo CLP support................... : $lx_clp_found |
127 | 143 |
echo CBC support................... : $lx_cbc_found |
128 | 144 |
echo |
129 | 145 |
echo Build additional tools........ : $enable_tools |
146 |
echo Use valgrind for tests........ : $use_valgrind |
|
130 | 147 |
echo |
131 | 148 |
echo The packace will be installed in |
132 | 149 |
echo -n ' ' |
133 | 150 |
echo $prefix. |
134 | 151 |
echo |
135 | 152 |
echo '*********************************************************************' |
... | ... |
@@ -6,13 +6,13 @@ |
6 | 6 |
CONFIGURE_FILE( |
7 | 7 |
${PROJECT_SOURCE_DIR}/doc/Doxyfile.in |
8 | 8 |
${PROJECT_BINARY_DIR}/doc/Doxyfile |
9 | 9 |
@ONLY |
10 | 10 |
) |
11 | 11 |
|
12 |
IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE) |
|
12 |
IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE) |
|
13 | 13 |
FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/) |
14 | 14 |
SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha) |
15 | 15 |
ADD_CUSTOM_TARGET(html |
16 | 16 |
COMMAND ${CMAKE_COMMAND} -E remove_directory gen-images |
17 | 17 |
COMMAND ${CMAKE_COMMAND} -E make_directory gen-images |
18 | 18 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/bipartite_matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_matching.eps |
... | ... |
@@ -25,12 +25,13 @@ |
25 | 25 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps |
26 | 26 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps |
27 | 27 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps |
28 | 28 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps |
29 | 29 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps |
30 | 30 |
COMMAND ${CMAKE_COMMAND} -E remove_directory html |
31 |
COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox |
|
31 | 32 |
COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile |
32 | 33 |
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} |
33 | 34 |
) |
34 | 35 |
|
35 | 36 |
SET_TARGET_PROPERTIES(html PROPERTIES PROJECT_LABEL BUILD_DOC) |
36 | 37 |
1 |
# Doxyfile 1.5. |
|
1 |
# Doxyfile 1.5.9 |
|
2 | 2 |
|
3 | 3 |
#--------------------------------------------------------------------------- |
4 | 4 |
# Project related configuration options |
5 | 5 |
#--------------------------------------------------------------------------- |
6 | 6 |
DOXYFILE_ENCODING = UTF-8 |
7 | 7 |
PROJECT_NAME = @PACKAGE_NAME@ |
... | ... |
@@ -18,13 +18,12 @@ |
18 | 18 |
STRIP_FROM_PATH = "@abs_top_srcdir@" |
19 | 19 |
STRIP_FROM_INC_PATH = "@abs_top_srcdir@" |
20 | 20 |
SHORT_NAMES = YES |
21 | 21 |
JAVADOC_AUTOBRIEF = NO |
22 | 22 |
QT_AUTOBRIEF = NO |
23 | 23 |
MULTILINE_CPP_IS_BRIEF = NO |
24 |
DETAILS_AT_TOP = YES |
|
25 | 24 |
INHERIT_DOCS = NO |
26 | 25 |
SEPARATE_MEMBER_PAGES = NO |
27 | 26 |
TAB_SIZE = 8 |
28 | 27 |
ALIASES = |
29 | 28 |
OPTIMIZE_OUTPUT_FOR_C = NO |
30 | 29 |
OPTIMIZE_OUTPUT_JAVA = NO |
... | ... |
@@ -88,13 +87,14 @@ |
88 | 87 |
INPUT = "@abs_top_srcdir@/doc" \ |
89 | 88 |
"@abs_top_srcdir@/lemon" \ |
90 | 89 |
"@abs_top_srcdir@/lemon/bits" \ |
91 | 90 |
"@abs_top_srcdir@/lemon/concepts" \ |
92 | 91 |
"@abs_top_srcdir@/demo" \ |
93 | 92 |
"@abs_top_srcdir@/tools" \ |
94 |
"@abs_top_srcdir@/test/test_tools.h" |
|
93 |
"@abs_top_srcdir@/test/test_tools.h" \ |
|
94 |
"@abs_top_builddir@/doc/references.dox" |
|
95 | 95 |
INPUT_ENCODING = UTF-8 |
96 | 96 |
FILE_PATTERNS = *.h \ |
97 | 97 |
*.cc \ |
98 | 98 |
*.dox |
99 | 99 |
RECURSIVE = NO |
100 | 100 |
EXCLUDE = |
... | ... |
@@ -220,13 +220,13 @@ |
220 | 220 |
INCLUDE_PATH = |
221 | 221 |
INCLUDE_FILE_PATTERNS = |
222 | 222 |
PREDEFINED = DOXYGEN |
223 | 223 |
EXPAND_AS_DEFINED = |
224 | 224 |
SKIP_FUNCTION_MACROS = YES |
225 | 225 |
#--------------------------------------------------------------------------- |
226 |
# |
|
226 |
# Options related to the search engine |
|
227 | 227 |
#--------------------------------------------------------------------------- |
228 | 228 |
TAGFILES = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/ " |
229 | 229 |
GENERATE_TAGFILE = html/lemon.tag |
230 | 230 |
ALLEXTERNALS = NO |
231 | 231 |
EXTERNAL_GROUPS = NO |
232 | 232 |
PERL_PATH = /usr/bin/perl |
... | ... |
@@ -63,13 +63,25 @@ |
63 | 63 |
echo; \ |
64 | 64 |
echo "Ghostscript not found."; \ |
65 | 65 |
echo; \ |
66 | 66 |
exit 1; \ |
67 | 67 |
fi |
68 | 68 |
|
69 |
|
|
69 |
references.dox: doc/references.bib |
|
70 |
if test ${python_found} = yes; then \ |
|
71 |
cd doc; \ |
|
72 |
python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \ |
|
73 |
cd ..; \ |
|
74 |
else \ |
|
75 |
echo; \ |
|
76 |
echo "Python not found."; \ |
|
77 |
echo; \ |
|
78 |
exit 1; \ |
|
79 |
fi |
|
80 |
|
|
81 |
html-local: $(DOC_PNG_IMAGES) references.dox |
|
70 | 82 |
if test ${doxygen_found} = yes; then \ |
71 | 83 |
cd doc; \ |
72 | 84 |
doxygen Doxyfile; \ |
73 | 85 |
cd ..; \ |
74 | 86 |
else \ |
75 | 87 |
echo; \ |
... | ... |
@@ -223,45 +223,88 @@ |
223 | 223 |
the two maps which can be done implicitly with the \c DivMap template |
224 | 224 |
class. We use the implicit minimum time map as the length map of the |
225 | 225 |
\c Dijkstra algorithm. |
226 | 226 |
*/ |
227 | 227 |
|
228 | 228 |
/** |
229 |
@defgroup matrices Matrices |
|
230 |
@ingroup datas |
|
231 |
\brief Two dimensional data storages implemented in LEMON. |
|
232 |
|
|
233 |
This group contains two dimensional data storages implemented in LEMON. |
|
234 |
*/ |
|
235 |
|
|
236 |
/** |
|
237 | 229 |
@defgroup paths Path Structures |
238 | 230 |
@ingroup datas |
239 | 231 |
\brief %Path structures implemented in LEMON. |
240 | 232 |
|
241 | 233 |
This group contains the path structures implemented in LEMON. |
242 | 234 |
|
243 | 235 |
LEMON provides flexible data structures to work with paths. |
244 | 236 |
All of them have similar interfaces and they can be copied easily with |
245 | 237 |
assignment operators and copy constructors. This makes it easy and |
246 | 238 |
efficient to have e.g. the Dijkstra algorithm to store its result in |
247 | 239 |
any kind of path structure. |
248 | 240 |
|
249 |
\sa |
|
241 |
\sa \ref concepts::Path "Path concept" |
|
242 |
*/ |
|
243 |
|
|
244 |
/** |
|
245 |
@defgroup heaps Heap Structures |
|
246 |
@ingroup datas |
|
247 |
\brief %Heap structures implemented in LEMON. |
|
248 |
|
|
249 |
This group contains the heap structures implemented in LEMON. |
|
250 |
|
|
251 |
LEMON provides several heap classes. They are efficient implementations |
|
252 |
of the abstract data type \e priority \e queue. They store items with |
|
253 |
specified values called \e priorities in such a way that finding and |
|
254 |
removing the item with minimum priority are efficient. |
|
255 |
The basic operations are adding and erasing items, changing the priority |
|
256 |
of an item, etc. |
|
257 |
|
|
258 |
Heaps are crucial in several algorithms, such as Dijkstra and Prim. |
|
259 |
The heap implementations have the same interface, thus any of them can be |
|
260 |
used easily in such algorithms. |
|
261 |
|
|
262 |
\sa \ref concepts::Heap "Heap concept" |
|
263 |
*/ |
|
264 |
|
|
265 |
/** |
|
266 |
@defgroup matrices Matrices |
|
267 |
@ingroup datas |
|
268 |
\brief Two dimensional data storages implemented in LEMON. |
|
269 |
|
|
270 |
This group contains two dimensional data storages implemented in LEMON. |
|
250 | 271 |
*/ |
251 | 272 |
|
252 | 273 |
/** |
253 | 274 |
@defgroup auxdat Auxiliary Data Structures |
254 | 275 |
@ingroup datas |
255 | 276 |
\brief Auxiliary data structures implemented in LEMON. |
256 | 277 |
|
257 | 278 |
This group contains some data structures implemented in LEMON in |
258 | 279 |
order to make it easier to implement combinatorial algorithms. |
259 | 280 |
*/ |
260 | 281 |
|
261 | 282 |
/** |
283 |
@defgroup geomdat Geometric Data Structures |
|
284 |
@ingroup auxdat |
|
285 |
\brief Geometric data structures implemented in LEMON. |
|
286 |
|
|
287 |
This group contains geometric data structures implemented in LEMON. |
|
288 |
|
|
289 |
- \ref lemon::dim2::Point "dim2::Point" implements a two dimensional |
|
290 |
vector with the usual operations. |
|
291 |
- \ref lemon::dim2::Box "dim2::Box" can be used to determine the |
|
292 |
rectangular bounding box of a set of \ref lemon::dim2::Point |
|
293 |
"dim2::Point"'s. |
|
294 |
*/ |
|
295 |
|
|
296 |
/** |
|
297 |
@defgroup matrices Matrices |
|
298 |
@ingroup auxdat |
|
299 |
\brief Two dimensional data storages implemented in LEMON. |
|
300 |
|
|
301 |
This group contains two dimensional data storages implemented in LEMON. |
|
302 |
*/ |
|
303 |
|
|
304 |
/** |
|
262 | 305 |
@defgroup algs Algorithms |
263 | 306 |
\brief This group contains the several algorithms |
264 | 307 |
implemented in LEMON. |
265 | 308 |
|
266 | 309 |
This group contains the several algorithms |
267 | 310 |
implemented in LEMON. |
... | ... |
@@ -270,21 +313,23 @@ |
270 | 313 |
/** |
271 | 314 |
@defgroup search Graph Search |
272 | 315 |
@ingroup algs |
273 | 316 |
\brief Common graph search algorithms. |
274 | 317 |
|
275 | 318 |
This group contains the common graph search algorithms, namely |
276 |
\e breadth-first \e search (BFS) and \e depth-first \e search (DFS) |
|
319 |
\e breadth-first \e search (BFS) and \e depth-first \e search (DFS) |
|
320 |
\ref clrs01algorithms. |
|
277 | 321 |
*/ |
278 | 322 |
|
279 | 323 |
/** |
280 | 324 |
@defgroup shortest_path Shortest Path Algorithms |
281 | 325 |
@ingroup algs |
282 | 326 |
\brief Algorithms for finding shortest paths. |
283 | 327 |
|
284 |
This group contains the algorithms for finding shortest paths in digraphs |
|
328 |
This group contains the algorithms for finding shortest paths in digraphs |
|
329 |
\ref clrs01algorithms. |
|
285 | 330 |
|
286 | 331 |
- \ref Dijkstra algorithm for finding shortest paths from a source node |
287 | 332 |
when all arc lengths are non-negative. |
288 | 333 |
- \ref BellmanFord "Bellman-Ford" algorithm for finding shortest paths |
289 | 334 |
from a source node when arc lenghts can be either positive or negative, |
290 | 335 |
but the digraph should not contain directed cycles with negative total |
... | ... |
@@ -295,18 +340,27 @@ |
295 | 340 |
not contain directed cycles with negative total length. |
296 | 341 |
- \ref Suurballe A successive shortest path algorithm for finding |
297 | 342 |
arc-disjoint paths between two nodes having minimum total length. |
298 | 343 |
*/ |
299 | 344 |
|
300 | 345 |
/** |
346 |
@defgroup spantree Minimum Spanning Tree Algorithms |
|
347 |
@ingroup algs |
|
348 |
\brief Algorithms for finding minimum cost spanning trees and arborescences. |
|
349 |
|
|
350 |
This group contains the algorithms for finding minimum cost spanning |
|
351 |
trees and arborescences \ref clrs01algorithms. |
|
352 |
*/ |
|
353 |
|
|
354 |
/** |
|
301 | 355 |
@defgroup max_flow Maximum Flow Algorithms |
302 | 356 |
@ingroup algs |
303 | 357 |
\brief Algorithms for finding maximum flows. |
304 | 358 |
|
305 | 359 |
This group contains the algorithms for finding maximum flows and |
306 |
feasible circulations. |
|
360 |
feasible circulations \ref clrs01algorithms, \ref amo93networkflows. |
|
307 | 361 |
|
308 | 362 |
The \e maximum \e flow \e problem is to find a flow of maximum value between |
309 | 363 |
a single source and a single target. Formally, there is a \f$G=(V,A)\f$ |
310 | 364 |
digraph, a \f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function and |
311 | 365 |
\f$s, t \in V\f$ source and target nodes. |
312 | 366 |
A maximum flow is an \f$f: A\rightarrow\mathbf{R}^+_0\f$ solution of the |
... | ... |
@@ -315,18 +369,22 @@ |
315 | 369 |
\f[ \max\sum_{sv\in A} f(sv) - \sum_{vs\in A} f(vs) \f] |
316 | 370 |
\f[ \sum_{uv\in A} f(uv) = \sum_{vu\in A} f(vu) |
317 | 371 |
\quad \forall u\in V\setminus\{s,t\} \f] |
318 | 372 |
\f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f] |
319 | 373 |
|
320 | 374 |
LEMON contains several algorithms for solving maximum flow problems: |
321 |
- \ref EdmondsKarp Edmonds-Karp algorithm. |
|
322 |
- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm. |
|
323 |
- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees. |
|
324 |
- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees. |
|
375 |
- \ref EdmondsKarp Edmonds-Karp algorithm |
|
376 |
\ref edmondskarp72theoretical. |
|
377 |
- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm |
|
378 |
\ref goldberg88newapproach. |
|
379 |
- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees |
|
380 |
\ref dinic70algorithm, \ref sleator83dynamic. |
|
381 |
- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees |
|
382 |
\ref goldberg88newapproach, \ref sleator83dynamic. |
|
325 | 383 |
|
326 |
In most cases the \ref Preflow |
|
384 |
In most cases the \ref Preflow algorithm provides the |
|
327 | 385 |
fastest method for computing a maximum flow. All implementations |
328 | 386 |
also provide functions to query the minimum cut, which is the dual |
329 | 387 |
problem of maximum flow. |
330 | 388 |
|
331 | 389 |
\ref Circulation is a preflow push-relabel algorithm implemented directly |
332 | 390 |
for finding feasible circulations, which is a somewhat different problem, |
... | ... |
@@ -338,24 +396,28 @@ |
338 | 396 |
@defgroup min_cost_flow_algs Minimum Cost Flow Algorithms |
339 | 397 |
@ingroup algs |
340 | 398 |
|
341 | 399 |
\brief Algorithms for finding minimum cost flows and circulations. |
342 | 400 |
|
343 | 401 |
This group contains the algorithms for finding minimum cost flows and |
344 |
circulations. For more information about this problem and its dual |
|
345 |
solution see \ref min_cost_flow "Minimum Cost Flow Problem". |
|
402 |
circulations \ref amo93networkflows. For more information about this |
|
403 |
problem and its dual solution, see \ref min_cost_flow |
|
404 |
"Minimum Cost Flow Problem". |
|
346 | 405 |
|
347 | 406 |
LEMON contains several algorithms for this problem. |
348 | 407 |
- \ref NetworkSimplex Primal Network Simplex algorithm with various |
349 |
pivot strategies. |
|
408 |
pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex. |
|
350 | 409 |
- \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on |
351 |
cost scaling |
|
410 |
cost scaling \ref goldberg90approximation, \ref goldberg97efficient, |
|
411 |
\ref bunnagel98efficient. |
|
352 | 412 |
- \ref CapacityScaling Successive Shortest %Path algorithm with optional |
353 |
capacity scaling. |
|
354 |
- \ref CancelAndTighten The Cancel and Tighten algorithm. |
|
355 |
|
|
413 |
capacity scaling \ref edmondskarp72theoretical. |
|
414 |
- \ref CancelAndTighten The Cancel and Tighten algorithm |
|
415 |
\ref goldberg89cyclecanceling. |
|
416 |
- \ref CycleCanceling Cycle-Canceling algorithms |
|
417 |
\ref klein67primal, \ref goldberg89cyclecanceling. |
|
356 | 418 |
|
357 | 419 |
In general NetworkSimplex is the most efficient implementation, |
358 | 420 |
but in special cases other algorithms could be faster. |
359 | 421 |
For example, if the total supply and/or capacities are rather small, |
360 | 422 |
CapacityScaling is usually the fastest algorithm (without effective scaling). |
361 | 423 |
*/ |
... | ... |
@@ -372,13 +434,13 @@ |
372 | 434 |
\f$X\f$ subset of the nodes with minimum overall capacity on |
373 | 435 |
outgoing arcs. Formally, there is a \f$G=(V,A)\f$ digraph, a |
374 | 436 |
\f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum |
375 | 437 |
cut is the \f$X\f$ solution of the next optimization problem: |
376 | 438 |
|
377 | 439 |
\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} |
378 |
\sum_{uv\in A |
|
440 |
\sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f] |
|
379 | 441 |
|
380 | 442 |
LEMON contains several algorithms related to minimum cut problems: |
381 | 443 |
|
382 | 444 |
- \ref HaoOrlin "Hao-Orlin algorithm" for calculating minimum cut |
383 | 445 |
in directed graphs. |
384 | 446 |
- \ref NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for |
... | ... |
@@ -388,33 +450,46 @@ |
388 | 450 |
|
389 | 451 |
If you want to find minimum cut just between two distinict nodes, |
390 | 452 |
see the \ref max_flow "maximum flow problem". |
391 | 453 |
*/ |
392 | 454 |
|
393 | 455 |
/** |
394 |
@defgroup |
|
456 |
@defgroup min_mean_cycle Minimum Mean Cycle Algorithms |
|
395 | 457 |
@ingroup algs |
396 |
\brief Algorithms for |
|
458 |
\brief Algorithms for finding minimum mean cycles. |
|
397 | 459 |
|
398 |
This group contains the algorithms for discovering the graph properties |
|
399 |
like connectivity, bipartiteness, euler property, simplicity etc. |
|
460 |
This group contains the algorithms for finding minimum mean cycles |
|
461 |
\ref clrs01algorithms, \ref amo93networkflows. |
|
400 | 462 |
|
401 |
\image html edge_biconnected_components.png |
|
402 |
\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth |
|
403 |
|
|
463 |
The \e minimum \e mean \e cycle \e problem is to find a directed cycle |
|
464 |
of minimum mean length (cost) in a digraph. |
|
465 |
The mean length of a cycle is the average length of its arcs, i.e. the |
|
466 |
ratio between the total length of the cycle and the number of arcs on it. |
|
404 | 467 |
|
405 |
/** |
|
406 |
@defgroup planar Planarity Embedding and Drawing |
|
407 |
@ingroup algs |
|
408 |
\brief Algorithms for planarity checking, embedding and drawing |
|
468 |
This problem has an important connection to \e conservative \e length |
|
469 |
\e functions, too. A length function on the arcs of a digraph is called |
|
470 |
conservative if and only if there is no directed cycle of negative total |
|
471 |
length. For an arbitrary length function, the negative of the minimum |
|
472 |
cycle mean is the smallest \f$\epsilon\f$ value so that increasing the |
|
473 |
arc lengths uniformly by \f$\epsilon\f$ results in a conservative length |
|
474 |
function. |
|
409 | 475 |
|
410 |
This group contains the algorithms for planarity checking, |
|
411 |
embedding and drawing. |
|
476 |
LEMON contains three algorithms for solving the minimum mean cycle problem: |
|
477 |
- \ref Karp "Karp"'s original algorithm \ref amo93networkflows, |
|
478 |
\ref dasdan98minmeancycle. |
|
479 |
- \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved |
|
480 |
version of Karp's algorithm \ref dasdan98minmeancycle. |
|
481 |
- \ref Howard "Howard"'s policy iteration algorithm |
|
482 |
\ref dasdan98minmeancycle. |
|
412 | 483 |
|
413 |
\image html planar.png |
|
414 |
\image latex planar.eps "Plane graph" width=\textwidth |
|
484 |
In practice, the Howard algorithm proved to be by far the most efficient |
|
485 |
one, though the best known theoretical bound on its running time is |
|
486 |
exponential. |
|
487 |
Both Karp and HartmannOrlin algorithms run in time O(ne) and use space |
|
488 |
O(n<sup>2</sup>+e), but the latter one is typically faster due to the |
|
489 |
applied early termination scheme. |
|
415 | 490 |
*/ |
416 | 491 |
|
417 | 492 |
/** |
418 | 493 |
@defgroup matching Matching Algorithms |
419 | 494 |
@ingroup algs |
420 | 495 |
\brief Algorithms for finding matchings in graphs and bipartite graphs. |
... | ... |
@@ -452,55 +527,73 @@ |
452 | 527 |
|
453 | 528 |
\image html bipartite_matching.png |
454 | 529 |
\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth |
455 | 530 |
*/ |
456 | 531 |
|
457 | 532 |
/** |
458 |
@defgroup |
|
533 |
@defgroup graph_properties Connectivity and Other Graph Properties |
|
459 | 534 |
@ingroup algs |
460 |
\brief Algorithms for |
|
535 |
\brief Algorithms for discovering the graph properties |
|
461 | 536 |
|
462 |
This group contains the algorithms for finding minimum cost spanning |
|
463 |
trees and arborescences. |
|
537 |
This group contains the algorithms for discovering the graph properties |
|
538 |
like connectivity, bipartiteness, euler property, simplicity etc. |
|
539 |
|
|
540 |
\image html connected_components.png |
|
541 |
\image latex connected_components.eps "Connected components" width=\textwidth |
|
542 |
*/ |
|
543 |
|
|
544 |
/** |
|
545 |
@defgroup planar Planarity Embedding and Drawing |
|
546 |
@ingroup algs |
|
547 |
\brief Algorithms for planarity checking, embedding and drawing |
|
548 |
|
|
549 |
This group contains the algorithms for planarity checking, |
|
550 |
embedding and drawing. |
|
551 |
|
|
552 |
\image html planar.png |
|
553 |
\image latex planar.eps "Plane graph" width=\textwidth |
|
554 |
*/ |
|
555 |
|
|
556 |
/** |
|
557 |
@defgroup approx Approximation Algorithms |
|
558 |
@ingroup algs |
|
559 |
\brief Approximation algorithms. |
|
560 |
|
|
561 |
This group contains the approximation and heuristic algorithms |
|
562 |
implemented in LEMON. |
|
464 | 563 |
*/ |
465 | 564 |
|
466 | 565 |
/** |
467 | 566 |
@defgroup auxalg Auxiliary Algorithms |
468 | 567 |
@ingroup algs |
469 | 568 |
\brief Auxiliary algorithms implemented in LEMON. |
470 | 569 |
|
471 | 570 |
This group contains some algorithms implemented in LEMON |
472 | 571 |
in order to make it easier to implement complex algorithms. |
473 | 572 |
*/ |
474 | 573 |
|
475 | 574 |
/** |
476 |
@defgroup approx Approximation Algorithms |
|
477 |
@ingroup algs |
|
478 |
\brief Approximation algorithms. |
|
479 |
|
|
480 |
This group contains the approximation and heuristic algorithms |
|
481 |
implemented in LEMON. |
|
482 |
*/ |
|
483 |
|
|
484 |
/** |
|
485 | 575 |
@defgroup gen_opt_group General Optimization Tools |
486 | 576 |
\brief This group contains some general optimization frameworks |
487 | 577 |
implemented in LEMON. |
488 | 578 |
|
489 | 579 |
This group contains some general optimization frameworks |
490 | 580 |
implemented in LEMON. |
491 | 581 |
*/ |
492 | 582 |
|
493 | 583 |
/** |
494 |
@defgroup lp_group |
|
584 |
@defgroup lp_group LP and MIP Solvers |
|
495 | 585 |
@ingroup gen_opt_group |
496 |
\brief |
|
586 |
\brief LP and MIP solver interfaces for LEMON. |
|
497 | 587 |
|
498 |
This group contains Lp and Mip solver interfaces for LEMON. The |
|
499 |
various LP solvers could be used in the same manner with this |
|
500 |
|
|
588 |
This group contains LP and MIP solver interfaces for LEMON. |
|
589 |
Various LP solvers could be used in the same manner with this |
|
590 |
high-level interface. |
|
591 |
|
|
592 |
The currently supported solvers are \ref glpk, \ref clp, \ref cbc, |
|
593 |
\ref cplex, \ref soplex. |
|
501 | 594 |
*/ |
502 | 595 |
|
503 | 596 |
/** |
504 | 597 |
@defgroup lp_utils Tools for Lp and Mip Solvers |
505 | 598 |
@ingroup lp_group |
506 | 599 |
\brief Helper tools to the Lp and Mip solvers. |
... | ... |
@@ -584,13 +677,13 @@ |
584 | 677 |
|
585 | 678 |
This group contains general \c EPS drawing methods and special |
586 | 679 |
graph exporting tools. |
587 | 680 |
*/ |
588 | 681 |
|
589 | 682 |
/** |
590 |
@defgroup dimacs_group DIMACS |
|
683 |
@defgroup dimacs_group DIMACS Format |
|
591 | 684 |
@ingroup io_group |
592 | 685 |
\brief Read and write files in DIMACS format |
593 | 686 |
|
594 | 687 |
Tools to read a digraph from or write it to a file in DIMACS format data. |
595 | 688 |
*/ |
596 | 689 |
|
... | ... |
@@ -633,40 +726,40 @@ |
633 | 726 |
|
634 | 727 |
/** |
635 | 728 |
@defgroup graph_concepts Graph Structure Concepts |
636 | 729 |
@ingroup concept |
637 | 730 |
\brief Skeleton and concept checking classes for graph structures |
638 | 731 |
|
639 |
This group contains the skeletons and concept checking classes of LEMON's |
|
640 |
graph structures and helper classes used to implement these. |
|
732 |
This group contains the skeletons and concept checking classes of |
|
733 |
graph structures. |
|
641 | 734 |
*/ |
642 | 735 |
|
643 | 736 |
/** |
644 | 737 |
@defgroup map_concepts Map Concepts |
645 | 738 |
@ingroup concept |
646 | 739 |
\brief Skeleton and concept checking classes for maps |
647 | 740 |
|
648 | 741 |
This group contains the skeletons and concept checking classes of maps. |
649 | 742 |
*/ |
650 | 743 |
|
651 | 744 |
/** |
745 |
@defgroup tools Standalone Utility Applications |
|
746 |
|
|
747 |
Some utility applications are listed here. |
|
748 |
|
|
749 |
The standard compilation procedure (<tt>./configure;make</tt>) will compile |
|
750 |
them, as well. |
|
751 |
*/ |
|
752 |
|
|
753 |
/** |
|
652 | 754 |
\anchor demoprograms |
653 | 755 |
|
654 | 756 |
@defgroup demos Demo Programs |
655 | 757 |
|
656 | 758 |
Some demo programs are listed here. Their full source codes can be found in |
657 | 759 |
the \c demo subdirectory of the source tree. |
658 | 760 |
|
659 | 761 |
In order to compile them, use the <tt>make demo</tt> or the |
660 | 762 |
<tt>make check</tt> commands. |
661 | 763 |
*/ |
662 | 764 |
|
663 |
/** |
|
664 |
@defgroup tools Standalone Utility Applications |
|
665 |
|
|
666 |
Some utility applications are listed here. |
|
667 |
|
|
668 |
The standard compilation procedure (<tt>./configure;make</tt>) will compile |
|
669 |
them, as well. |
|
670 |
*/ |
|
671 |
|
|
672 | 765 |
} |
... | ... |
@@ -18,30 +18,36 @@ |
18 | 18 |
|
19 | 19 |
/** |
20 | 20 |
\mainpage LEMON Documentation |
21 | 21 |
|
22 | 22 |
\section intro Introduction |
23 | 23 |
|
24 |
\subsection whatis What is LEMON |
|
25 |
|
|
26 |
LEMON stands for <b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling |
|
27 |
and <b>O</b>ptimization in <b>N</b>etworks. |
|
28 |
It is a C++ template |
|
29 |
library aimed at combinatorial optimization tasks which |
|
30 |
often involve in working |
|
31 |
with graphs. |
|
24 |
<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling |
|
25 |
and <b>O</b>ptimization in <b>N</b>etworks</i>. |
|
26 |
It is a C++ template library providing efficient implementation of common |
|
27 |
data structures and algorithms with focus on combinatorial optimization |
|
28 |
problems in graphs and networks. |
|
32 | 29 |
|
33 | 30 |
<b> |
34 | 31 |
LEMON is an <a class="el" href="http://opensource.org/">open source</a> |
35 | 32 |
project. |
36 | 33 |
You are free to use it in your commercial or |
37 | 34 |
non-commercial applications under very permissive |
38 | 35 |
\ref license "license terms". |
39 | 36 |
</b> |
40 | 37 |
|
41 |
|
|
38 |
The project is maintained by the |
|
39 |
<a href="http://www.cs.elte.hu/egres/">Egerváry Research Group on |
|
40 |
Combinatorial Optimization</a> \ref egres |
|
41 |
at the Operations Research Department of the |
|
42 |
<a href="http://www.elte.hu/">Eötvös Loránd University, |
|
43 |
Budapest</a>, Hungary. |
|
44 |
LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a> |
|
45 |
initiative \ref coinor. |
|
46 |
|
|
47 |
\section howtoread How to Read the Documentation |
|
42 | 48 |
|
43 | 49 |
If you would like to get to know the library, see |
44 | 50 |
<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>. |
45 | 51 |
|
46 | 52 |
If you know what you are looking for, then try to find it under the |
47 | 53 |
<a class="el" href="modules.html">Modules</a> section. |
... | ... |
@@ -23,13 +23,13 @@ |
23 | 23 |
|
24 | 24 |
\section mcf_def Definition (GEQ form) |
25 | 25 |
|
26 | 26 |
The \e minimum \e cost \e flow \e problem is to find a feasible flow of |
27 | 27 |
minimum total cost from a set of supply nodes to a set of demand nodes |
28 | 28 |
in a network with capacity constraints (lower and upper bounds) |
29 |
and arc costs. |
|
29 |
and arc costs \ref amo93networkflows. |
|
30 | 30 |
|
31 | 31 |
Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$, |
32 | 32 |
\f$upper: A\rightarrow\mathbf{R}\cup\{+\infty\}\f$ denote the lower and |
33 | 33 |
upper bounds for the flow values on the arcs, for which |
34 | 34 |
\f$lower(uv) \leq upper(uv)\f$ must hold for all \f$uv\in A\f$, |
35 | 35 |
\f$cost: A\rightarrow\mathbf{R}\f$ denotes the cost per unit flow |
... | ... |
@@ -75,13 +75,13 @@ |
75 | 75 |
|
76 | 76 |
- For all \f$uv\in A\f$ arcs: |
77 | 77 |
- if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$; |
78 | 78 |
- if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$; |
79 | 79 |
- if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$. |
80 | 80 |
- For all \f$u\in V\f$ nodes: |
81 |
- \f$\pi(u) |
|
81 |
- \f$\pi(u)\leq 0\f$; |
|
82 | 82 |
- if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$, |
83 | 83 |
then \f$\pi(u)=0\f$. |
84 | 84 |
|
85 | 85 |
Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc |
86 | 86 |
\f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e. |
87 | 87 |
\f[ cost^\pi(uv) = cost(uv) + \pi(u) - \pi(v).\f] |
... | ... |
@@ -142,12 +142,12 @@ |
142 | 142 |
|
143 | 143 |
- For all \f$uv\in A\f$ arcs: |
144 | 144 |
- if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$; |
145 | 145 |
- if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$; |
146 | 146 |
- if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$. |
147 | 147 |
- For all \f$u\in V\f$ nodes: |
148 |
- \f$\pi(u) |
|
148 |
- \f$\pi(u)\geq 0\f$; |
|
149 | 149 |
- if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$, |
150 | 150 |
then \f$\pi(u)=0\f$. |
151 | 151 |
|
152 | 152 |
*/ |
153 | 153 |
} |
... | ... |
@@ -54,14 +54,16 @@ |
54 | 54 |
endif |
55 | 55 |
|
56 | 56 |
lemon_HEADERS += \ |
57 | 57 |
lemon/adaptors.h \ |
58 | 58 |
lemon/arg_parser.h \ |
59 | 59 |
lemon/assert.h \ |
60 |
lemon/bellman_ford.h \ |
|
60 | 61 |
lemon/bfs.h \ |
61 | 62 |
lemon/bin_heap.h \ |
63 |
lemon/binom_heap.h \ |
|
62 | 64 |
lemon/bucket_heap.h \ |
63 | 65 |
lemon/cbc.h \ |
64 | 66 |
lemon/circulation.h \ |
65 | 67 |
lemon/clp.h \ |
66 | 68 |
lemon/color.h \ |
67 | 69 |
lemon/concept_check.h \ |
... | ... |
@@ -75,40 +77,47 @@ |
75 | 77 |
lemon/dimacs.h \ |
76 | 78 |
lemon/edge_set.h \ |
77 | 79 |
lemon/elevator.h \ |
78 | 80 |
lemon/error.h \ |
79 | 81 |
lemon/euler.h \ |
80 | 82 |
lemon/fib_heap.h \ |
83 |
lemon/fourary_heap.h \ |
|
81 | 84 |
lemon/full_graph.h \ |
82 | 85 |
lemon/glpk.h \ |
83 | 86 |
lemon/gomory_hu.h \ |
84 | 87 |
lemon/graph_to_eps.h \ |
85 | 88 |
lemon/grid_graph.h \ |
89 |
lemon/hartmann_orlin.h \ |
|
90 |
lemon/howard.h \ |
|
86 | 91 |
lemon/hypercube_graph.h \ |
92 |
lemon/karp.h \ |
|
93 |
lemon/kary_heap.h \ |
|
87 | 94 |
lemon/kruskal.h \ |
88 | 95 |
lemon/hao_orlin.h \ |
89 | 96 |
lemon/lgf_reader.h \ |
90 | 97 |
lemon/lgf_writer.h \ |
91 | 98 |
lemon/list_graph.h \ |
92 | 99 |
lemon/lp.h \ |
93 | 100 |
lemon/lp_base.h \ |
94 | 101 |
lemon/lp_skeleton.h \ |
95 |
lemon/list_graph.h \ |
|
96 | 102 |
lemon/maps.h \ |
97 | 103 |
lemon/matching.h \ |
98 | 104 |
lemon/math.h \ |
99 | 105 |
lemon/min_cost_arborescence.h \ |
100 | 106 |
lemon/nauty_reader.h \ |
101 | 107 |
lemon/network_simplex.h \ |
108 |
lemon/pairing_heap.h \ |
|
102 | 109 |
lemon/path.h \ |
110 |
lemon/planarity.h \ |
|
103 | 111 |
lemon/preflow.h \ |
104 | 112 |
lemon/radix_heap.h \ |
105 | 113 |
lemon/radix_sort.h \ |
106 | 114 |
lemon/random.h \ |
107 | 115 |
lemon/smart_graph.h \ |
108 | 116 |
lemon/soplex.h \ |
117 |
lemon/static_graph.h \ |
|
109 | 118 |
lemon/suurballe.h \ |
110 | 119 |
lemon/time_measure.h \ |
111 | 120 |
lemon/tolerance.h \ |
112 | 121 |
lemon/unionfind.h \ |
113 | 122 |
lemon/bits/windows.h |
114 | 123 |
... | ... |
@@ -357,12 +357,15 @@ |
357 | 357 |
/// It conforms to the \ref concepts::Digraph "Digraph" concept. |
358 | 358 |
/// |
359 | 359 |
/// The adapted digraph can also be modified through this adaptor |
360 | 360 |
/// by adding or removing nodes or arcs, unless the \c GR template |
361 | 361 |
/// parameter is set to be \c const. |
362 | 362 |
/// |
363 |
/// This class provides item counting in the same time as the adapted |
|
364 |
/// digraph structure. |
|
365 |
/// |
|
363 | 366 |
/// \tparam DGR The type of the adapted digraph. |
364 | 367 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
365 | 368 |
/// It can also be specified to be \c const. |
366 | 369 |
/// |
367 | 370 |
/// \note The \c Node and \c Arc types of this adaptor and the adapted |
368 | 371 |
/// digraph are convertible to each other. |
... | ... |
@@ -716,12 +719,14 @@ |
716 | 719 |
/// This adaptor conforms to the \ref concepts::Digraph "Digraph" concept. |
717 | 720 |
/// |
718 | 721 |
/// The adapted digraph can also be modified through this adaptor |
719 | 722 |
/// by adding or removing nodes or arcs, unless the \c GR template |
720 | 723 |
/// parameter is set to be \c const. |
721 | 724 |
/// |
725 |
/// This class provides only linear time counting for nodes and arcs. |
|
726 |
/// |
|
722 | 727 |
/// \tparam DGR The type of the adapted digraph. |
723 | 728 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
724 | 729 |
/// It can also be specified to be \c const. |
725 | 730 |
/// \tparam NF The type of the node filter map. |
726 | 731 |
/// It must be a \c bool (or convertible) node map of the |
727 | 732 |
/// adapted digraph. The default type is |
... | ... |
@@ -1311,12 +1316,14 @@ |
1311 | 1316 |
/// This adaptor conforms to the \ref concepts::Graph "Graph" concept. |
1312 | 1317 |
/// |
1313 | 1318 |
/// The adapted graph can also be modified through this adaptor |
1314 | 1319 |
/// by adding or removing nodes or edges, unless the \c GR template |
1315 | 1320 |
/// parameter is set to be \c const. |
1316 | 1321 |
/// |
1322 |
/// This class provides only linear time counting for nodes, edges and arcs. |
|
1323 |
/// |
|
1317 | 1324 |
/// \tparam GR The type of the adapted graph. |
1318 | 1325 |
/// It must conform to the \ref concepts::Graph "Graph" concept. |
1319 | 1326 |
/// It can also be specified to be \c const. |
1320 | 1327 |
/// \tparam NF The type of the node filter map. |
1321 | 1328 |
/// It must be a \c bool (or convertible) node map of the |
1322 | 1329 |
/// adapted graph. The default type is |
... | ... |
@@ -1468,12 +1475,14 @@ |
1468 | 1475 |
/// depending on the \c GR template parameter. |
1469 | 1476 |
/// |
1470 | 1477 |
/// The adapted (di)graph can also be modified through this adaptor |
1471 | 1478 |
/// by adding or removing nodes or arcs/edges, unless the \c GR template |
1472 | 1479 |
/// parameter is set to be \c const. |
1473 | 1480 |
/// |
1481 |
/// This class provides only linear time item counting. |
|
1482 |
/// |
|
1474 | 1483 |
/// \tparam GR The type of the adapted digraph or graph. |
1475 | 1484 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept |
1476 | 1485 |
/// or the \ref concepts::Graph "Graph" concept. |
1477 | 1486 |
/// It can also be specified to be \c const. |
1478 | 1487 |
/// \tparam NF The type of the node filter map. |
1479 | 1488 |
/// It must be a \c bool (or convertible) node map of the |
... | ... |
@@ -1616,12 +1625,14 @@ |
1616 | 1625 |
/// "Digraph" concept. |
1617 | 1626 |
/// |
1618 | 1627 |
/// The adapted digraph can also be modified through this adaptor |
1619 | 1628 |
/// by adding or removing nodes or arcs, unless the \c GR template |
1620 | 1629 |
/// parameter is set to be \c const. |
1621 | 1630 |
/// |
1631 |
/// This class provides only linear time counting for nodes and arcs. |
|
1632 |
/// |
|
1622 | 1633 |
/// \tparam DGR The type of the adapted digraph. |
1623 | 1634 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
1624 | 1635 |
/// It can also be specified to be \c const. |
1625 | 1636 |
/// \tparam AF The type of the arc filter map. |
1626 | 1637 |
/// It must be a \c bool (or convertible) arc map of the |
1627 | 1638 |
/// adapted digraph. The default type is |
... | ... |
@@ -1726,12 +1737,14 @@ |
1726 | 1737 |
/// "Graph" concept. |
1727 | 1738 |
/// |
1728 | 1739 |
/// The adapted graph can also be modified through this adaptor |
1729 | 1740 |
/// by adding or removing nodes or edges, unless the \c GR template |
1730 | 1741 |
/// parameter is set to be \c const. |
1731 | 1742 |
/// |
1743 |
/// This class provides only linear time counting for nodes, edges and arcs. |
|
1744 |
/// |
|
1732 | 1745 |
/// \tparam GR The type of the adapted graph. |
1733 | 1746 |
/// It must conform to the \ref concepts::Graph "Graph" concept. |
1734 | 1747 |
/// It can also be specified to be \c const. |
1735 | 1748 |
/// \tparam EF The type of the edge filter map. |
1736 | 1749 |
/// It must be a \c bool (or convertible) edge map of the |
1737 | 1750 |
/// adapted graph. The default type is |
... | ... |
@@ -2229,12 +2242,15 @@ |
2229 | 2242 |
/// This adaptor conforms to the \ref concepts::Graph "Graph" concept. |
2230 | 2243 |
/// |
2231 | 2244 |
/// The adapted digraph can also be modified through this adaptor |
2232 | 2245 |
/// by adding or removing nodes or edges, unless the \c GR template |
2233 | 2246 |
/// parameter is set to be \c const. |
2234 | 2247 |
/// |
2248 |
/// This class provides item counting in the same time as the adapted |
|
2249 |
/// digraph structure. |
|
2250 |
/// |
|
2235 | 2251 |
/// \tparam DGR The type of the adapted digraph. |
2236 | 2252 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
2237 | 2253 |
/// It can also be specified to be \c const. |
2238 | 2254 |
/// |
2239 | 2255 |
/// \note The \c Node type of this adaptor and the adapted digraph are |
2240 | 2256 |
/// convertible to each other, moreover the \c Edge type of the adaptor |
... | ... |
@@ -2532,12 +2548,15 @@ |
2532 | 2548 |
/// This class conforms to the \ref concepts::Digraph "Digraph" concept. |
2533 | 2549 |
/// |
2534 | 2550 |
/// The adapted graph can also be modified through this adaptor |
2535 | 2551 |
/// by adding or removing nodes or arcs, unless the \c GR template |
2536 | 2552 |
/// parameter is set to be \c const. |
2537 | 2553 |
/// |
2554 |
/// This class provides item counting in the same time as the adapted |
|
2555 |
/// graph structure. |
|
2556 |
/// |
|
2538 | 2557 |
/// \tparam GR The type of the adapted graph. |
2539 | 2558 |
/// It must conform to the \ref concepts::Graph "Graph" concept. |
2540 | 2559 |
/// It can also be specified to be \c const. |
2541 | 2560 |
/// \tparam DM The type of the direction map. |
2542 | 2561 |
/// It must be a \c bool (or convertible) edge map of the |
2543 | 2562 |
/// adapted graph. The default type is |
... | ... |
@@ -2675,12 +2694,14 @@ |
2675 | 2694 |
/// When the union \f$ A_{forward}\cup A_{backward} \f$ is taken, |
2676 | 2695 |
/// multiplicities are counted, i.e. the adaptor has exactly |
2677 | 2696 |
/// \f$ |A_{forward}| + |A_{backward}|\f$ arcs (it may have parallel |
2678 | 2697 |
/// arcs). |
2679 | 2698 |
/// This class conforms to the \ref concepts::Digraph "Digraph" concept. |
2680 | 2699 |
/// |
2700 |
/// This class provides only linear time counting for nodes and arcs. |
|
2701 |
/// |
|
2681 | 2702 |
/// \tparam DGR The type of the adapted digraph. |
2682 | 2703 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
2683 | 2704 |
/// It is implicitly \c const. |
2684 | 2705 |
/// \tparam CM The type of the capacity map. |
2685 | 2706 |
/// It must be an arc map of some numerical type, which defines |
2686 | 2707 |
/// the capacities in the flow problem. It is implicitly \c const. |
... | ... |
@@ -3322,12 +3343,15 @@ |
3322 | 3343 |
/// costs or capacities if the algorithm considers only arc costs or |
3323 | 3344 |
/// capacities directly. |
3324 | 3345 |
/// In this case you can use \c SplitNodes adaptor, and set the node |
3325 | 3346 |
/// costs/capacities of the original digraph to the \e bind \e arcs |
3326 | 3347 |
/// in the adaptor. |
3327 | 3348 |
/// |
3349 |
/// This class provides item counting in the same time as the adapted |
|
3350 |
/// digraph structure. |
|
3351 |
/// |
|
3328 | 3352 |
/// \tparam DGR The type of the adapted digraph. |
3329 | 3353 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
3330 | 3354 |
/// It is implicitly \c const. |
3331 | 3355 |
/// |
3332 | 3356 |
/// \note The \c Node type of this adaptor is converible to the \c Node |
3333 | 3357 |
/// type of the adapted digraph. |
... | ... |
@@ -44,13 +44,13 @@ |
44 | 44 |
|
45 | 45 |
///\brief The type of the map that stores the predecessor |
46 | 46 |
///arcs of the shortest paths. |
47 | 47 |
/// |
48 | 48 |
///The type of the map that stores the predecessor |
49 | 49 |
///arcs of the shortest paths. |
50 |
///It must |
|
50 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
51 | 51 |
typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; |
52 | 52 |
///Instantiates a \c PredMap. |
53 | 53 |
|
54 | 54 |
///This function instantiates a \ref PredMap. |
55 | 55 |
///\param g is the digraph, to which we would like to define the |
56 | 56 |
///\ref PredMap. |
... | ... |
@@ -59,13 +59,14 @@ |
59 | 59 |
return new PredMap(g); |
60 | 60 |
} |
61 | 61 |
|
62 | 62 |
///The type of the map that indicates which nodes are processed. |
63 | 63 |
|
64 | 64 |
///The type of the map that indicates which nodes are processed. |
65 |
///It must |
|
65 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
66 |
///By default, it is a NullMap. |
|
66 | 67 |
typedef NullMap<typename Digraph::Node,bool> ProcessedMap; |
67 | 68 |
///Instantiates a \c ProcessedMap. |
68 | 69 |
|
69 | 70 |
///This function instantiates a \ref ProcessedMap. |
70 | 71 |
///\param g is the digraph, to which |
71 | 72 |
///we would like to define the \ref ProcessedMap |
... | ... |
@@ -78,13 +79,13 @@ |
78 | 79 |
return new ProcessedMap(); |
79 | 80 |
} |
80 | 81 |
|
81 | 82 |
///The type of the map that indicates which nodes are reached. |
82 | 83 |
|
83 | 84 |
///The type of the map that indicates which nodes are reached. |
84 |
///It must |
|
85 |
///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. |
|
85 | 86 |
typedef typename Digraph::template NodeMap<bool> ReachedMap; |
86 | 87 |
///Instantiates a \c ReachedMap. |
87 | 88 |
|
88 | 89 |
///This function instantiates a \ref ReachedMap. |
89 | 90 |
///\param g is the digraph, to which |
90 | 91 |
///we would like to define the \ref ReachedMap. |
... | ... |
@@ -93,13 +94,13 @@ |
93 | 94 |
return new ReachedMap(g); |
94 | 95 |
} |
95 | 96 |
|
96 | 97 |
///The type of the map that stores the distances of the nodes. |
97 | 98 |
|
98 | 99 |
///The type of the map that stores the distances of the nodes. |
99 |
///It must |
|
100 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
100 | 101 |
typedef typename Digraph::template NodeMap<int> DistMap; |
101 | 102 |
///Instantiates a \c DistMap. |
102 | 103 |
|
103 | 104 |
///This function instantiates a \ref DistMap. |
104 | 105 |
///\param g is the digraph, to which we would like to define the |
105 | 106 |
///\ref DistMap. |
... | ... |
@@ -222,13 +223,13 @@ |
222 | 223 |
}; |
223 | 224 |
///\brief \ref named-templ-param "Named parameter" for setting |
224 | 225 |
///\c PredMap type. |
225 | 226 |
/// |
226 | 227 |
///\ref named-templ-param "Named parameter" for setting |
227 | 228 |
///\c PredMap type. |
228 |
///It must |
|
229 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
229 | 230 |
template <class T> |
230 | 231 |
struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > { |
231 | 232 |
typedef Bfs< Digraph, SetPredMapTraits<T> > Create; |
232 | 233 |
}; |
233 | 234 |
|
234 | 235 |
template <class T> |
... | ... |
@@ -242,13 +243,13 @@ |
242 | 243 |
}; |
243 | 244 |
///\brief \ref named-templ-param "Named parameter" for setting |
244 | 245 |
///\c DistMap type. |
245 | 246 |
/// |
246 | 247 |
///\ref named-templ-param "Named parameter" for setting |
247 | 248 |
///\c DistMap type. |
248 |
///It must |
|
249 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
249 | 250 |
template <class T> |
250 | 251 |
struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > { |
251 | 252 |
typedef Bfs< Digraph, SetDistMapTraits<T> > Create; |
252 | 253 |
}; |
253 | 254 |
|
254 | 255 |
template <class T> |
... | ... |
@@ -262,13 +263,13 @@ |
262 | 263 |
}; |
263 | 264 |
///\brief \ref named-templ-param "Named parameter" for setting |
264 | 265 |
///\c ReachedMap type. |
265 | 266 |
/// |
266 | 267 |
///\ref named-templ-param "Named parameter" for setting |
267 | 268 |
///\c ReachedMap type. |
268 |
///It must |
|
269 |
///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. |
|
269 | 270 |
template <class T> |
270 | 271 |
struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > { |
271 | 272 |
typedef Bfs< Digraph, SetReachedMapTraits<T> > Create; |
272 | 273 |
}; |
273 | 274 |
|
274 | 275 |
template <class T> |
... | ... |
@@ -282,13 +283,13 @@ |
282 | 283 |
}; |
283 | 284 |
///\brief \ref named-templ-param "Named parameter" for setting |
284 | 285 |
///\c ProcessedMap type. |
285 | 286 |
/// |
286 | 287 |
///\ref named-templ-param "Named parameter" for setting |
287 | 288 |
///\c ProcessedMap type. |
288 |
///It must |
|
289 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
289 | 290 |
template <class T> |
290 | 291 |
struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > { |
291 | 292 |
typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create; |
292 | 293 |
}; |
293 | 294 |
|
294 | 295 |
struct SetStandardProcessedMapTraits : public Traits { |
... | ... |
@@ -410,14 +411,14 @@ |
410 | 411 |
|
411 | 412 |
public: |
412 | 413 |
|
413 | 414 |
///\name Execution Control |
414 | 415 |
///The simplest way to execute the BFS algorithm is to use one of the |
415 | 416 |
///member functions called \ref run(Node) "run()".\n |
416 |
///If you need more control on the execution, first you have to call |
|
417 |
///\ref init(), then you can add several source nodes with |
|
417 |
///If you need better control on the execution, you have to call |
|
418 |
///\ref init() first, then you can add several source nodes with |
|
418 | 419 |
///\ref addSource(). Finally the actual path computation can be |
419 | 420 |
///performed with one of the \ref start() functions. |
420 | 421 |
|
421 | 422 |
///@{ |
422 | 423 |
|
423 | 424 |
///\brief Initializes the internal data structures. |
... | ... |
@@ -697,18 +698,14 @@ |
697 | 698 |
start(t); |
698 | 699 |
return reached(t); |
699 | 700 |
} |
700 | 701 |
|
701 | 702 |
///Runs the algorithm to visit all nodes in the digraph. |
702 | 703 |
|
703 |
///This method runs the %BFS algorithm in order to |
|
704 |
///compute the shortest path to each node. |
|
705 |
/// |
|
706 |
///The algorithm computes |
|
707 |
///- the shortest path tree (forest), |
|
708 |
///- the distance of each node from the root(s). |
|
704 |
///This method runs the %BFS algorithm in order to visit all nodes |
|
705 |
///in the digraph. |
|
709 | 706 |
/// |
710 | 707 |
///\note <tt>b.run(s)</tt> is just a shortcut of the following code. |
711 | 708 |
///\code |
712 | 709 |
/// b.init(); |
713 | 710 |
/// for (NodeIt n(gr); n != INVALID; ++n) { |
714 | 711 |
/// if (!b.reached(n)) { |
... | ... |
@@ -734,56 +731,58 @@ |
734 | 731 |
///functions.\n |
735 | 732 |
///Either \ref run(Node) "run()" or \ref start() should be called |
736 | 733 |
///before using them. |
737 | 734 |
|
738 | 735 |
///@{ |
739 | 736 |
|
740 |
///The shortest path to |
|
737 |
///The shortest path to the given node. |
|
741 | 738 |
|
742 |
///Returns the shortest path to |
|
739 |
///Returns the shortest path to the given node from the root(s). |
|
743 | 740 |
/// |
744 | 741 |
///\warning \c t should be reached from the root(s). |
745 | 742 |
/// |
746 | 743 |
///\pre Either \ref run(Node) "run()" or \ref init() |
747 | 744 |
///must be called before using this function. |
748 | 745 |
Path path(Node t) const { return Path(*G, *_pred, t); } |
749 | 746 |
|
750 |
///The distance of |
|
747 |
///The distance of the given node from the root(s). |
|
751 | 748 |
|
752 |
///Returns the distance of |
|
749 |
///Returns the distance of the given node from the root(s). |
|
753 | 750 |
/// |
754 | 751 |
///\warning If node \c v is not reached from the root(s), then |
755 | 752 |
///the return value of this function is undefined. |
756 | 753 |
/// |
757 | 754 |
///\pre Either \ref run(Node) "run()" or \ref init() |
758 | 755 |
///must be called before using this function. |
759 | 756 |
int dist(Node v) const { return (*_dist)[v]; } |
760 | 757 |
|
761 |
///Returns the 'previous arc' of the shortest path tree for a node. |
|
762 |
|
|
758 |
///\brief Returns the 'previous arc' of the shortest path tree for |
|
759 |
///the given node. |
|
760 |
/// |
|
763 | 761 |
///This function returns the 'previous arc' of the shortest path |
764 | 762 |
///tree for the node \c v, i.e. it returns the last arc of a |
765 | 763 |
///shortest path from a root to \c v. It is \c INVALID if \c v |
766 | 764 |
///is not reached from the root(s) or if \c v is a root. |
767 | 765 |
/// |
768 | 766 |
///The shortest path tree used here is equal to the shortest path |
769 |
///tree used in \ref predNode(). |
|
767 |
///tree used in \ref predNode() and \ref predMap(). |
|
770 | 768 |
/// |
771 | 769 |
///\pre Either \ref run(Node) "run()" or \ref init() |
772 | 770 |
///must be called before using this function. |
773 | 771 |
Arc predArc(Node v) const { return (*_pred)[v];} |
774 | 772 |
|
775 |
///Returns the 'previous node' of the shortest path tree for a node. |
|
776 |
|
|
773 |
///\brief Returns the 'previous node' of the shortest path tree for |
|
774 |
///the given node. |
|
775 |
/// |
|
777 | 776 |
///This function returns the 'previous node' of the shortest path |
778 | 777 |
///tree for the node \c v, i.e. it returns the last but one node |
779 |
/// |
|
778 |
///of a shortest path from a root to \c v. It is \c INVALID |
|
780 | 779 |
///if \c v is not reached from the root(s) or if \c v is a root. |
781 | 780 |
/// |
782 | 781 |
///The shortest path tree used here is equal to the shortest path |
783 |
///tree used in \ref predArc(). |
|
782 |
///tree used in \ref predArc() and \ref predMap(). |
|
784 | 783 |
/// |
785 | 784 |
///\pre Either \ref run(Node) "run()" or \ref init() |
786 | 785 |
///must be called before using this function. |
787 | 786 |
Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID: |
788 | 787 |
G->source((*_pred)[v]); } |
789 | 788 |
|
... | ... |
@@ -798,19 +797,19 @@ |
798 | 797 |
const DistMap &distMap() const { return *_dist;} |
799 | 798 |
|
800 | 799 |
///\brief Returns a const reference to the node map that stores the |
801 | 800 |
///predecessor arcs. |
802 | 801 |
/// |
803 | 802 |
///Returns a const reference to the node map that stores the predecessor |
804 |
///arcs, which form the shortest path tree. |
|
803 |
///arcs, which form the shortest path tree (forest). |
|
805 | 804 |
/// |
806 | 805 |
///\pre Either \ref run(Node) "run()" or \ref init() |
807 | 806 |
///must be called before using this function. |
808 | 807 |
const PredMap &predMap() const { return *_pred;} |
809 | 808 |
|
810 |
///Checks if |
|
809 |
///Checks if the given node is reached from the root(s). |
|
811 | 810 |
|
812 | 811 |
///Returns \c true if \c v is reached from the root(s). |
813 | 812 |
/// |
814 | 813 |
///\pre Either \ref run(Node) "run()" or \ref init() |
815 | 814 |
///must be called before using this function. |
816 | 815 |
bool reached(Node v) const { return (*_reached)[v]; } |
... | ... |
@@ -830,13 +829,13 @@ |
830 | 829 |
|
831 | 830 |
///\brief The type of the map that stores the predecessor |
832 | 831 |
///arcs of the shortest paths. |
833 | 832 |
/// |
834 | 833 |
///The type of the map that stores the predecessor |
835 | 834 |
///arcs of the shortest paths. |
836 |
///It must |
|
835 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
837 | 836 |
typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; |
838 | 837 |
///Instantiates a PredMap. |
839 | 838 |
|
840 | 839 |
///This function instantiates a PredMap. |
841 | 840 |
///\param g is the digraph, to which we would like to define the |
842 | 841 |
///PredMap. |
... | ... |
@@ -845,14 +844,14 @@ |
845 | 844 |
return new PredMap(g); |
846 | 845 |
} |
847 | 846 |
|
848 | 847 |
///The type of the map that indicates which nodes are processed. |
849 | 848 |
|
850 | 849 |
///The type of the map that indicates which nodes are processed. |
851 |
///It must meet the \ref concepts::WriteMap "WriteMap" concept. |
|
852 |
///By default it is a NullMap. |
|
850 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
851 |
///By default, it is a NullMap. |
|
853 | 852 |
typedef NullMap<typename Digraph::Node,bool> ProcessedMap; |
854 | 853 |
///Instantiates a ProcessedMap. |
855 | 854 |
|
856 | 855 |
///This function instantiates a ProcessedMap. |
857 | 856 |
///\param g is the digraph, to which |
858 | 857 |
///we would like to define the ProcessedMap. |
... | ... |
@@ -865,13 +864,13 @@ |
865 | 864 |
return new ProcessedMap(); |
866 | 865 |
} |
867 | 866 |
|
868 | 867 |
///The type of the map that indicates which nodes are reached. |
869 | 868 |
|
870 | 869 |
///The type of the map that indicates which nodes are reached. |
871 |
///It must |
|
870 |
///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. |
|
872 | 871 |
typedef typename Digraph::template NodeMap<bool> ReachedMap; |
873 | 872 |
///Instantiates a ReachedMap. |
874 | 873 |
|
875 | 874 |
///This function instantiates a ReachedMap. |
876 | 875 |
///\param g is the digraph, to which |
877 | 876 |
///we would like to define the ReachedMap. |
... | ... |
@@ -880,13 +879,13 @@ |
880 | 879 |
return new ReachedMap(g); |
881 | 880 |
} |
882 | 881 |
|
883 | 882 |
///The type of the map that stores the distances of the nodes. |
884 | 883 |
|
885 | 884 |
///The type of the map that stores the distances of the nodes. |
886 |
///It must |
|
885 |
///It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
887 | 886 |
typedef typename Digraph::template NodeMap<int> DistMap; |
888 | 887 |
///Instantiates a DistMap. |
889 | 888 |
|
890 | 889 |
///This function instantiates a DistMap. |
891 | 890 |
///\param g is the digraph, to which we would like to define |
892 | 891 |
///the DistMap |
... | ... |
@@ -895,24 +894,20 @@ |
895 | 894 |
return new DistMap(g); |
896 | 895 |
} |
897 | 896 |
|
898 | 897 |
///The type of the shortest paths. |
899 | 898 |
|
900 | 899 |
///The type of the shortest paths. |
901 |
///It must |
|
900 |
///It must conform to the \ref concepts::Path "Path" concept. |
|
902 | 901 |
typedef lemon::Path<Digraph> Path; |
903 | 902 |
}; |
904 | 903 |
|
905 | 904 |
/// Default traits class used by BfsWizard |
906 | 905 |
|
907 |
/// To make it easier to use Bfs algorithm |
|
908 |
/// we have created a wizard class. |
|
909 |
/// This \ref BfsWizard class needs default traits, |
|
910 |
/// as well as the \ref Bfs class. |
|
911 |
/// The \ref BfsWizardBase is a class to be the default traits of the |
|
912 |
/// \ref BfsWizard class. |
|
906 |
/// Default traits class used by BfsWizard. |
|
907 |
/// \tparam GR The type of the digraph. |
|
913 | 908 |
template<class GR> |
914 | 909 |
class BfsWizardBase : public BfsWizardDefaultTraits<GR> |
915 | 910 |
{ |
916 | 911 |
|
917 | 912 |
typedef BfsWizardDefaultTraits<GR> Base; |
918 | 913 |
protected: |
... | ... |
@@ -934,13 +929,13 @@ |
934 | 929 |
//Pointer to the distance of the target node. |
935 | 930 |
int *_di; |
936 | 931 |
|
937 | 932 |
public: |
938 | 933 |
/// Constructor. |
939 | 934 |
|
940 |
/// This constructor does not require parameters, |
|
935 |
/// This constructor does not require parameters, it initiates |
|
941 | 936 |
/// all of the attributes to \c 0. |
942 | 937 |
BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), |
943 | 938 |
_dist(0), _path(0), _di(0) {} |
944 | 939 |
|
945 | 940 |
/// Constructor. |
946 | 941 |
|
... | ... |
@@ -964,30 +959,23 @@ |
964 | 959 |
/// which makes it easier to use the algorithm. |
965 | 960 |
template<class TR> |
966 | 961 |
class BfsWizard : public TR |
967 | 962 |
{ |
968 | 963 |
typedef TR Base; |
969 | 964 |
|
970 |
///The type of the digraph the algorithm runs on. |
|
971 | 965 |
typedef typename TR::Digraph Digraph; |
972 | 966 |
|
973 | 967 |
typedef typename Digraph::Node Node; |
974 | 968 |
typedef typename Digraph::NodeIt NodeIt; |
975 | 969 |
typedef typename Digraph::Arc Arc; |
976 | 970 |
typedef typename Digraph::OutArcIt OutArcIt; |
977 | 971 |
|
978 |
///\brief The type of the map that stores the predecessor |
|
979 |
///arcs of the shortest paths. |
|
980 | 972 |
typedef typename TR::PredMap PredMap; |
981 |
///\brief The type of the map that stores the distances of the nodes. |
|
982 | 973 |
typedef typename TR::DistMap DistMap; |
983 |
///\brief The type of the map that indicates which nodes are reached. |
|
984 | 974 |
typedef typename TR::ReachedMap ReachedMap; |
985 |
///\brief The type of the map that indicates which nodes are processed. |
|
986 | 975 |
typedef typename TR::ProcessedMap ProcessedMap; |
987 |
///The type of the shortest paths |
|
988 | 976 |
typedef typename TR::Path Path; |
989 | 977 |
|
990 | 978 |
public: |
991 | 979 |
|
992 | 980 |
/// Constructor. |
993 | 981 |
BfsWizard() : TR() {} |
... | ... |
@@ -1051,30 +1039,31 @@ |
1051 | 1039 |
*Base::_di = alg.dist(t); |
1052 | 1040 |
return alg.reached(t); |
1053 | 1041 |
} |
1054 | 1042 |
|
1055 | 1043 |
///Runs BFS algorithm to visit all nodes in the digraph. |
1056 | 1044 |
|
1057 |
///This method runs BFS algorithm in order to compute |
|
1058 |
///the shortest path to each node. |
|
1045 |
///This method runs BFS algorithm in order to visit all nodes |
|
1046 |
///in the digraph. |
|
1059 | 1047 |
void run() |
1060 | 1048 |
{ |
1061 | 1049 |
run(INVALID); |
1062 | 1050 |
} |
1063 | 1051 |
|
1064 | 1052 |
template<class T> |
1065 | 1053 |
struct SetPredMapBase : public Base { |
1066 | 1054 |
typedef T PredMap; |
1067 | 1055 |
static PredMap *createPredMap(const Digraph &) { return 0; }; |
1068 | 1056 |
SetPredMapBase(const TR &b) : TR(b) {} |
1069 | 1057 |
}; |
1070 |
///\brief \ref named-func-param "Named parameter" |
|
1071 |
///for setting PredMap object. |
|
1058 |
|
|
1059 |
///\brief \ref named-templ-param "Named parameter" for setting |
|
1060 |
///the predecessor map. |
|
1072 | 1061 |
/// |
1073 |
///\ref named-func-param "Named parameter" |
|
1074 |
///for setting PredMap object. |
|
1062 |
///\ref named-templ-param "Named parameter" function for setting |
|
1063 |
///the map that stores the predecessor arcs of the nodes. |
|
1075 | 1064 |
template<class T> |
1076 | 1065 |
BfsWizard<SetPredMapBase<T> > predMap(const T &t) |
1077 | 1066 |
{ |
1078 | 1067 |
Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t)); |
1079 | 1068 |
return BfsWizard<SetPredMapBase<T> >(*this); |
1080 | 1069 |
} |
... | ... |
@@ -1082,17 +1071,18 @@ |
1082 | 1071 |
template<class T> |
1083 | 1072 |
struct SetReachedMapBase : public Base { |
1084 | 1073 |
typedef T ReachedMap; |
1085 | 1074 |
static ReachedMap *createReachedMap(const Digraph &) { return 0; }; |
1086 | 1075 |
SetReachedMapBase(const TR &b) : TR(b) {} |
1087 | 1076 |
}; |
1088 |
///\brief \ref named-func-param "Named parameter" |
|
1089 |
///for setting ReachedMap object. |
|
1077 |
|
|
1078 |
///\brief \ref named-templ-param "Named parameter" for setting |
|
1079 |
///the reached map. |
|
1090 | 1080 |
/// |
1091 |
/// \ref named-func-param "Named parameter" |
|
1092 |
///for setting ReachedMap object. |
|
1081 |
///\ref named-templ-param "Named parameter" function for setting |
|
1082 |
///the map that indicates which nodes are reached. |
|
1093 | 1083 |
template<class T> |
1094 | 1084 |
BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t) |
1095 | 1085 |
{ |
1096 | 1086 |
Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t)); |
1097 | 1087 |
return BfsWizard<SetReachedMapBase<T> >(*this); |
1098 | 1088 |
} |
... | ... |
@@ -1100,17 +1090,19 @@ |
1100 | 1090 |
template<class T> |
1101 | 1091 |
struct SetDistMapBase : public Base { |
1102 | 1092 |
typedef T DistMap; |
1103 | 1093 |
static DistMap *createDistMap(const Digraph &) { return 0; }; |
1104 | 1094 |
SetDistMapBase(const TR &b) : TR(b) {} |
1105 | 1095 |
}; |
1106 |
///\brief \ref named-func-param "Named parameter" |
|
1107 |
///for setting DistMap object. |
|
1096 |
|
|
1097 |
///\brief \ref named-templ-param "Named parameter" for setting |
|
1098 |
///the distance map. |
|
1108 | 1099 |
/// |
1109 |
/// \ref named-func-param "Named parameter" |
|
1110 |
///for setting DistMap object. |
|
1100 |
///\ref named-templ-param "Named parameter" function for setting |
|
1101 |
///the map that stores the distances of the nodes calculated |
|
1102 |
///by the algorithm. |
|
1111 | 1103 |
template<class T> |
1112 | 1104 |
BfsWizard<SetDistMapBase<T> > distMap(const T &t) |
1113 | 1105 |
{ |
1114 | 1106 |
Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t)); |
1115 | 1107 |
return BfsWizard<SetDistMapBase<T> >(*this); |
1116 | 1108 |
} |
... | ... |
@@ -1118,17 +1110,18 @@ |
1118 | 1110 |
template<class T> |
1119 | 1111 |
struct SetProcessedMapBase : public Base { |
1120 | 1112 |
typedef T ProcessedMap; |
1121 | 1113 |
static ProcessedMap *createProcessedMap(const Digraph &) { return 0; }; |
1122 | 1114 |
SetProcessedMapBase(const TR &b) : TR(b) {} |
1123 | 1115 |
}; |
1124 |
///\brief \ref named-func-param "Named parameter" |
|
1125 |
///for setting ProcessedMap object. |
|
1116 |
|
|
1117 |
///\brief \ref named-func-param "Named parameter" for setting |
|
1118 |
///the processed map. |
|
1126 | 1119 |
/// |
1127 |
/// \ref named-func-param "Named parameter" |
|
1128 |
///for setting ProcessedMap object. |
|
1120 |
///\ref named-templ-param "Named parameter" function for setting |
|
1121 |
///the map that indicates which nodes are processed. |
|
1129 | 1122 |
template<class T> |
1130 | 1123 |
BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t) |
1131 | 1124 |
{ |
1132 | 1125 |
Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t)); |
1133 | 1126 |
return BfsWizard<SetProcessedMapBase<T> >(*this); |
1134 | 1127 |
} |
... | ... |
@@ -1261,13 +1254,13 @@ |
1261 | 1254 |
/// \brief The type of the digraph the algorithm runs on. |
1262 | 1255 |
typedef GR Digraph; |
1263 | 1256 |
|
1264 | 1257 |
/// \brief The type of the map that indicates which nodes are reached. |
1265 | 1258 |
/// |
1266 | 1259 |
/// The type of the map that indicates which nodes are reached. |
1267 |
/// It must |
|
1260 |
/// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. |
|
1268 | 1261 |
typedef typename Digraph::template NodeMap<bool> ReachedMap; |
1269 | 1262 |
|
1270 | 1263 |
/// \brief Instantiates a ReachedMap. |
1271 | 1264 |
/// |
1272 | 1265 |
/// This function instantiates a ReachedMap. |
1273 | 1266 |
/// \param digraph is the digraph, to which |
... | ... |
@@ -1422,14 +1415,14 @@ |
1422 | 1415 |
|
1423 | 1416 |
public: |
1424 | 1417 |
|
1425 | 1418 |
/// \name Execution Control |
1426 | 1419 |
/// The simplest way to execute the BFS algorithm is to use one of the |
1427 | 1420 |
/// member functions called \ref run(Node) "run()".\n |
1428 |
/// If you need more control on the execution, first you have to call |
|
1429 |
/// \ref init(), then you can add several source nodes with |
|
1421 |
/// If you need better control on the execution, you have to call |
|
1422 |
/// \ref init() first, then you can add several source nodes with |
|
1430 | 1423 |
/// \ref addSource(). Finally the actual path computation can be |
1431 | 1424 |
/// performed with one of the \ref start() functions. |
1432 | 1425 |
|
1433 | 1426 |
/// @{ |
1434 | 1427 |
|
1435 | 1428 |
/// \brief Initializes the internal data structures. |
... | ... |
@@ -1695,18 +1688,14 @@ |
1695 | 1688 |
start(t); |
1696 | 1689 |
return reached(t); |
1697 | 1690 |
} |
1698 | 1691 |
|
1699 | 1692 |
/// \brief Runs the algorithm to visit all nodes in the digraph. |
1700 | 1693 |
/// |
1701 |
/// This method runs the %BFS algorithm in order to |
|
1702 |
/// compute the shortest path to each node. |
|
1703 |
/// |
|
1704 |
/// The algorithm computes |
|
1705 |
/// - the shortest path tree (forest), |
|
1706 |
/// - the distance of each node from the root(s). |
|
1694 |
/// This method runs the %BFS algorithm in order to visit all nodes |
|
1695 |
/// in the digraph. |
|
1707 | 1696 |
/// |
1708 | 1697 |
/// \note <tt>b.run(s)</tt> is just a shortcut of the following code. |
1709 | 1698 |
///\code |
1710 | 1699 |
/// b.init(); |
1711 | 1700 |
/// for (NodeIt n(gr); n != INVALID; ++n) { |
1712 | 1701 |
/// if (!b.reached(n)) { |
... | ... |
@@ -1732,13 +1721,13 @@ |
1732 | 1721 |
/// functions.\n |
1733 | 1722 |
/// Either \ref run(Node) "run()" or \ref start() should be called |
1734 | 1723 |
/// before using them. |
1735 | 1724 |
|
1736 | 1725 |
///@{ |
1737 | 1726 |
|
1738 |
/// \brief Checks if |
|
1727 |
/// \brief Checks if the given node is reached from the root(s). |
|
1739 | 1728 |
/// |
1740 | 1729 |
/// Returns \c true if \c v is reached from the root(s). |
1741 | 1730 |
/// |
1742 | 1731 |
/// \pre Either \ref run(Node) "run()" or \ref init() |
1743 | 1732 |
/// must be called before using this function. |
1744 | 1733 |
bool reached(Node v) const { return (*_reached)[v]; } |
... | ... |
@@ -16,61 +16,57 @@ |
16 | 16 |
* |
17 | 17 |
*/ |
18 | 18 |
|
19 | 19 |
#ifndef LEMON_BIN_HEAP_H |
20 | 20 |
#define LEMON_BIN_HEAP_H |
21 | 21 |
|
22 |
///\ingroup |
|
22 |
///\ingroup heaps |
|
23 | 23 |
///\file |
24 |
///\brief Binary |
|
24 |
///\brief Binary heap implementation. |
|
25 | 25 |
|
26 | 26 |
#include <vector> |
27 | 27 |
#include <utility> |
28 | 28 |
#include <functional> |
29 | 29 |
|
30 | 30 |
namespace lemon { |
31 | 31 |
|
32 |
///\ingroup |
|
32 |
/// \ingroup heaps |
|
33 | 33 |
/// |
34 |
///\brief |
|
34 |
/// \brief Binary heap data structure. |
|
35 | 35 |
/// |
36 |
///This class implements the \e binary \e heap data structure. |
|
36 |
/// This class implements the \e binary \e heap data structure. |
|
37 |
/// It fully conforms to the \ref concepts::Heap "heap concept". |
|
37 | 38 |
/// |
38 |
///A \e heap is a data structure for storing items with specified values |
|
39 |
///called \e priorities in such a way that finding the item with minimum |
|
40 |
///priority is efficient. \c CMP specifies the ordering of the priorities. |
|
41 |
///In a heap one can change the priority of an item, add or erase an |
|
42 |
///item, etc. |
|
43 |
/// |
|
44 |
///\tparam PR Type of the priority of the items. |
|
45 |
///\tparam IM A read and writable item map with int values, used internally |
|
46 |
///to handle the cross references. |
|
47 |
///\tparam CMP A functor class for the ordering of the priorities. |
|
48 |
///The default is \c std::less<PR>. |
|
49 |
/// |
|
50 |
///\sa FibHeap |
|
51 |
///\sa Dijkstra |
|
39 |
/// \tparam PR Type of the priorities of the items. |
|
40 |
/// \tparam IM A read-writable item map with \c int values, used |
|
41 |
/// internally to handle the cross references. |
|
42 |
/// \tparam CMP A functor class for comparing the priorities. |
|
43 |
/// The default is \c std::less<PR>. |
|
44 |
#ifdef DOXYGEN |
|
45 |
template <typename PR, typename IM, typename CMP> |
|
46 |
#else |
|
52 | 47 |
template <typename PR, typename IM, typename CMP = std::less<PR> > |
48 |
#endif |
|
53 | 49 |
class BinHeap { |
50 |
public: |
|
54 | 51 |
|
55 |
public: |
|
56 |
///\e |
|
52 |
/// Type of the item-int map. |
|
57 | 53 |
typedef IM ItemIntMap; |
58 |
/// |
|
54 |
/// Type of the priorities. |
|
59 | 55 |
typedef PR Prio; |
60 |
/// |
|
56 |
/// Type of the items stored in the heap. |
|
61 | 57 |
typedef typename ItemIntMap::Key Item; |
62 |
/// |
|
58 |
/// Type of the item-priority pairs. |
|
63 | 59 |
typedef std::pair<Item,Prio> Pair; |
64 |
/// |
|
60 |
/// Functor type for comparing the priorities. |
|
65 | 61 |
typedef CMP Compare; |
66 | 62 |
|
67 |
/// \brief Type to represent the |
|
63 |
/// \brief Type to represent the states of the items. |
|
68 | 64 |
/// |
69 |
/// Each Item element have a state associated to it. It may be "in heap", |
|
70 |
/// "pre heap" or "post heap". The latter two are indifferent from the |
|
65 |
/// Each item has a state associated to it. It can be "in heap", |
|
66 |
/// "pre-heap" or "post-heap". The latter two are indifferent from the |
|
71 | 67 |
/// heap's point of view, but may be useful to the user. |
72 | 68 |
/// |
73 | 69 |
/// The item-int map must be initialized in such way that it assigns |
74 | 70 |
/// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap. |
75 | 71 |
enum State { |
76 | 72 |
IN_HEAP = 0, ///< = 0. |
... | ... |
@@ -81,82 +77,83 @@ |
81 | 77 |
private: |
82 | 78 |
std::vector<Pair> _data; |
83 | 79 |
Compare _comp; |
84 | 80 |
ItemIntMap &_iim; |
85 | 81 |
|
86 | 82 |
public: |
87 |
|
|
83 |
|
|
84 |
/// \brief Constructor. |
|
88 | 85 |
/// |
89 |
/// The constructor. |
|
90 |
/// \param map should be given to the constructor, since it is used |
|
91 |
/// internally to handle the cross references. The value of the map |
|
92 |
/// must be \c PRE_HEAP (<tt>-1</tt>) for every item. |
|
86 |
/// Constructor. |
|
87 |
/// \param map A map that assigns \c int values to the items. |
|
88 |
/// It is used internally to handle the cross references. |
|
89 |
/// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. |
|
93 | 90 |
explicit BinHeap(ItemIntMap &map) : _iim(map) {} |
94 | 91 |
|
95 |
/// \brief |
|
92 |
/// \brief Constructor. |
|
96 | 93 |
/// |
97 |
/// The constructor. |
|
98 |
/// \param map should be given to the constructor, since it is used |
|
99 |
/// internally to handle the cross references. The value of the map |
|
100 |
/// should be PRE_HEAP (-1) for each element. |
|
101 |
/// |
|
102 |
/// \param comp The comparator function object. |
|
94 |
/// Constructor. |
|
95 |
/// \param map A map that assigns \c int values to the items. |
|
96 |
/// It is used internally to handle the cross references. |
|
97 |
/// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. |
|
98 |
/// \param comp The function object used for comparing the priorities. |
|
103 | 99 |
BinHeap(ItemIntMap &map, const Compare &comp) |
104 | 100 |
: _iim(map), _comp(comp) {} |
105 | 101 |
|
106 | 102 |
|
107 |
/// The number of items stored in the heap. |
|
103 |
/// \brief The number of items stored in the heap. |
|
108 | 104 |
/// |
109 |
/// |
|
105 |
/// This function returns the number of items stored in the heap. |
|
110 | 106 |
int size() const { return _data.size(); } |
111 | 107 |
|
112 |
/// \brief |
|
108 |
/// \brief Check if the heap is empty. |
|
113 | 109 |
/// |
114 |
/// |
|
110 |
/// This function returns \c true if the heap is empty. |
|
115 | 111 |
bool empty() const { return _data.empty(); } |
116 | 112 |
|
117 |
/// \brief Make |
|
113 |
/// \brief Make the heap empty. |
|
118 | 114 |
/// |
119 |
/// Make empty this heap. It does not change the cross reference map. |
|
120 |
/// If you want to reuse what is not surely empty you should first clear |
|
121 |
/// the heap and after that you should set the cross reference map for |
|
122 |
/// each item to \c PRE_HEAP. |
|
115 |
/// This functon makes the heap empty. |
|
116 |
/// It does not change the cross reference map. If you want to reuse |
|
117 |
/// a heap that is not surely empty, you should first clear it and |
|
118 |
/// then you should set the cross reference map to \c PRE_HEAP |
|
119 |
/// for each item. |
|
123 | 120 |
void clear() { |
124 | 121 |
_data.clear(); |
125 | 122 |
} |
126 | 123 |
|
127 | 124 |
private: |
128 | 125 |
static int parent(int i) { return (i-1)/2; } |
129 | 126 |
|
130 |
static int |
|
127 |
static int secondChild(int i) { return 2*i+2; } |
|
131 | 128 |
bool less(const Pair &p1, const Pair &p2) const { |
132 | 129 |
return _comp(p1.second, p2.second); |
133 | 130 |
} |
134 | 131 |
|
135 |
int |
|
132 |
int bubbleUp(int hole, Pair p) { |
|
136 | 133 |
int par = parent(hole); |
137 | 134 |
while( hole>0 && less(p,_data[par]) ) { |
138 | 135 |
move(_data[par],hole); |
139 | 136 |
hole = par; |
140 | 137 |
par = parent(hole); |
141 | 138 |
} |
142 | 139 |
move(p, hole); |
143 | 140 |
return hole; |
144 | 141 |
} |
145 | 142 |
|
146 |
int bubble_down(int hole, Pair p, int length) { |
|
147 |
int child = second_child(hole); |
|
143 |
int bubbleDown(int hole, Pair p, int length) { |
|
144 |
int child = secondChild(hole); |
|
148 | 145 |
while(child < length) { |
149 | 146 |
if( less(_data[child-1], _data[child]) ) { |
150 | 147 |
--child; |
151 | 148 |
} |
152 | 149 |
if( !less(_data[child], p) ) |
153 | 150 |
goto ok; |
154 | 151 |
move(_data[child], hole); |
155 | 152 |
hole = child; |
156 |
child = |
|
153 |
child = secondChild(hole); |
|
157 | 154 |
} |
158 | 155 |
child--; |
159 | 156 |
if( child<length && less(_data[child], p) ) { |
160 | 157 |
move(_data[child], hole); |
161 | 158 |
hole=child; |
162 | 159 |
} |
... | ... |
@@ -168,152 +165,154 @@ |
168 | 165 |
void move(const Pair &p, int i) { |
169 | 166 |
_data[i] = p; |
170 | 167 |
_iim.set(p.first, i); |
171 | 168 |
} |
172 | 169 |
|
173 | 170 |
public: |
171 |
|
|
174 | 172 |
/// \brief Insert a pair of item and priority into the heap. |
175 | 173 |
/// |
176 |
/// |
|
174 |
/// This function inserts \c p.first to the heap with priority |
|
175 |
/// \c p.second. |
|
177 | 176 |
/// \param p The pair to insert. |
177 |
/// \pre \c p.first must not be stored in the heap. |
|
178 | 178 |
void push(const Pair &p) { |
179 | 179 |
int n = _data.size(); |
180 | 180 |
_data.resize(n+1); |
181 |
|
|
181 |
bubbleUp(n, p); |
|
182 | 182 |
} |
183 | 183 |
|
184 |
/// \brief Insert an item into the heap with the given |
|
184 |
/// \brief Insert an item into the heap with the given priority. |
|
185 | 185 |
/// |
186 |
/// |
|
186 |
/// This function inserts the given item into the heap with the |
|
187 |
/// given priority. |
|
187 | 188 |
/// \param i The item to insert. |
188 | 189 |
/// \param p The priority of the item. |
190 |
/// \pre \e i must not be stored in the heap. |
|
189 | 191 |
void push(const Item &i, const Prio &p) { push(Pair(i,p)); } |
190 | 192 |
|
191 |
/// \brief |
|
193 |
/// \brief Return the item having minimum priority. |
|
192 | 194 |
/// |
193 |
/// This method returns the item with minimum priority relative to \c |
|
194 |
/// Compare. |
|
195 |
/// |
|
195 |
/// This function returns the item having minimum priority. |
|
196 |
/// \pre The heap must be non-empty. |
|
196 | 197 |
Item top() const { |
197 | 198 |
return _data[0].first; |
198 | 199 |
} |
199 | 200 |
|
200 |
/// \brief |
|
201 |
/// \brief The minimum priority. |
|
201 | 202 |
/// |
202 |
/// It returns the minimum priority relative to \c Compare. |
|
203 |
/// \pre The heap must be nonempty. |
|
203 |
/// This function returns the minimum priority. |
|
204 |
/// \pre The heap must be non-empty. |
|
204 | 205 |
Prio prio() const { |
205 | 206 |
return _data[0].second; |
206 | 207 |
} |
207 | 208 |
|
208 |
/// \brief |
|
209 |
/// \brief Remove the item having minimum priority. |
|
209 | 210 |
/// |
210 |
/// This method deletes the item with minimum priority relative to \c |
|
211 |
/// Compare from the heap. |
|
211 |
/// This function removes the item having minimum priority. |
|
212 | 212 |
/// \pre The heap must be non-empty. |
213 | 213 |
void pop() { |
214 | 214 |
int n = _data.size()-1; |
215 | 215 |
_iim.set(_data[0].first, POST_HEAP); |
216 | 216 |
if (n > 0) { |
217 |
|
|
217 |
bubbleDown(0, _data[n], n); |
|
218 | 218 |
} |
219 | 219 |
_data.pop_back(); |
220 | 220 |
} |
221 | 221 |
|
222 |
/// \brief |
|
222 |
/// \brief Remove the given item from the heap. |
|
223 | 223 |
/// |
224 |
/// This method deletes item \c i from the heap. |
|
225 |
/// \param i The item to erase. |
|
226 |
/// |
|
224 |
/// This function removes the given item from the heap if it is |
|
225 |
/// already stored. |
|
226 |
/// \param i The item to delete. |
|
227 |
/// \pre \e i must be in the heap. |
|
227 | 228 |
void erase(const Item &i) { |
228 | 229 |
int h = _iim[i]; |
229 | 230 |
int n = _data.size()-1; |
230 | 231 |
_iim.set(_data[h].first, POST_HEAP); |
231 | 232 |
if( h < n ) { |
232 |
if ( bubble_up(h, _data[n]) == h) { |
|
233 |
bubble_down(h, _data[n], n); |
|
233 |
if ( bubbleUp(h, _data[n]) == h) { |
|
234 |
bubbleDown(h, _data[n], n); |
|
234 | 235 |
} |
235 | 236 |
} |
236 | 237 |
_data.pop_back(); |
237 | 238 |
} |
238 | 239 |
|
239 |
|
|
240 |
/// \brief Returns the priority of \c i. |
|
240 |
/// \brief The priority of the given item. |
|
241 | 241 |
/// |
242 |
/// This function returns the priority of |
|
242 |
/// This function returns the priority of the given item. |
|
243 | 243 |
/// \param i The item. |
244 |
/// \pre \ |
|
244 |
/// \pre \e i must be in the heap. |
|
245 | 245 |
Prio operator[](const Item &i) const { |
246 | 246 |
int idx = _iim[i]; |
247 | 247 |
return _data[idx].second; |
248 | 248 |
} |
249 | 249 |
|
250 |
/// \brief \c i gets to the heap with priority \c p independently |
|
251 |
/// if \c i was already there. |
|
250 |
/// \brief Set the priority of an item or insert it, if it is |
|
251 |
/// not stored in the heap. |
|
252 | 252 |
/// |
253 |
/// This method calls \ref push(\c i, \c p) if \c i is not stored |
|
254 |
/// in the heap and sets the priority of \c i to \c p otherwise. |
|
253 |
/// This method sets the priority of the given item if it is |
|
254 |
/// already stored in the heap. Otherwise it inserts the given |
|
255 |
/// item into the heap with the given priority. |
|
255 | 256 |
/// \param i The item. |
256 | 257 |
/// \param p The priority. |
257 | 258 |
void set(const Item &i, const Prio &p) { |
258 | 259 |
int idx = _iim[i]; |
259 | 260 |
if( idx < 0 ) { |
260 | 261 |
push(i,p); |
261 | 262 |
} |
262 | 263 |
else if( _comp(p, _data[idx].second) ) { |
263 |
|
|
264 |
bubbleUp(idx, Pair(i,p)); |
|
264 | 265 |
} |
265 | 266 |
else { |
266 |
|
|
267 |
bubbleDown(idx, Pair(i,p), _data.size()); |
|
267 | 268 |
} |
268 | 269 |
} |
269 | 270 |
|
270 |
/// \brief |
|
271 |
/// \brief Decrease the priority of an item to the given value. |
|
271 | 272 |
/// |
272 |
/// This |
|
273 |
/// This function decreases the priority of an item to the given value. |
|
273 | 274 |
/// \param i The item. |
274 | 275 |
/// \param p The priority. |
275 |
/// \pre \c i must be stored in the heap with priority at least \c |
|
276 |
/// p relative to \c Compare. |
|
276 |
/// \pre \e i must be stored in the heap with priority at least \e p. |
|
277 | 277 |
void decrease(const Item &i, const Prio &p) { |
278 | 278 |
int idx = _iim[i]; |
279 |
|
|
279 |
bubbleUp(idx, Pair(i,p)); |
|
280 | 280 |
} |
281 | 281 |
|
282 |
/// \brief |
|
282 |
/// \brief Increase the priority of an item to the given value. |
|
283 | 283 |
/// |
284 |
/// This |
|
284 |
/// This function increases the priority of an item to the given value. |
|
285 | 285 |
/// \param i The item. |
286 | 286 |
/// \param p The priority. |
287 |
/// \pre \c i must be stored in the heap with priority at most \c |
|
288 |
/// p relative to \c Compare. |
|
287 |
/// \pre \e i must be stored in the heap with priority at most \e p. |
|
289 | 288 |
void increase(const Item &i, const Prio &p) { |
290 | 289 |
int idx = _iim[i]; |
291 |
|
|
290 |
bubbleDown(idx, Pair(i,p), _data.size()); |
|
292 | 291 |
} |
293 | 292 |
|
294 |
/// \brief Returns if \c item is in, has already been in, or has |
|
295 |
/// never been in the heap. |
|
293 |
/// \brief Return the state of an item. |
|
296 | 294 |
/// |
297 |
/// This method returns PRE_HEAP if \c item has never been in the |
|
298 |
/// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP |
|
299 |
/// otherwise. In the latter case it is possible that \c item will |
|
300 |
/// get back to the heap again. |
|
295 |
/// This method returns \c PRE_HEAP if the given item has never |
|
296 |
/// been in the heap, \c IN_HEAP if it is in the heap at the moment, |
|
297 |
/// and \c POST_HEAP otherwise. |
|
298 |
/// In the latter case it is possible that the item will get back |
|
299 |
/// to the heap again. |
|
301 | 300 |
/// \param i The item. |
302 | 301 |
State state(const Item &i) const { |
303 | 302 |
int s = _iim[i]; |
304 | 303 |
if( s>=0 ) |
305 | 304 |
s=0; |
306 | 305 |
return State(s); |
307 | 306 |
} |
308 | 307 |
|
309 |
/// \brief |
|
308 |
/// \brief Set the state of an item in the heap. |
|
310 | 309 |
/// |
311 |
/// Sets the state of the \c item in the heap. It can be used to |
|
312 |
/// manually clear the heap when it is important to achive the |
|
313 |
/// |
|
310 |
/// This function sets the state of the given item in the heap. |
|
311 |
/// It can be used to manually clear the heap when it is important |
|
312 |
/// to achive better time complexity. |
|
314 | 313 |
/// \param i The item. |
315 | 314 |
/// \param st The state. It should not be \c IN_HEAP. |
316 | 315 |
void state(const Item& i, State st) { |
317 | 316 |
switch (st) { |
318 | 317 |
case POST_HEAP: |
319 | 318 |
case PRE_HEAP: |
... | ... |
@@ -324,18 +323,19 @@ |
324 | 323 |
break; |
325 | 324 |
case IN_HEAP: |
326 | 325 |
break; |
327 | 326 |
} |
328 | 327 |
} |
329 | 328 |
|
330 |
/// \brief |
|
329 |
/// \brief Replace an item in the heap. |
|
331 | 330 |
/// |
332 |
/// The \c i item is replaced with \c j item. The \c i item should |
|
333 |
/// be in the heap, while the \c j should be out of the heap. The |
|
334 |
/// \c i item will out of the heap and \c j will be in the heap |
|
335 |
/// with the same prioriority as prevoiusly the \c i item. |
|
331 |
/// This function replaces item \c i with item \c j. |
|
332 |
/// Item \c i must be in the heap, while \c j must be out of the heap. |
|
333 |
/// After calling this method, item \c i will be out of the |
|
334 |
/// heap and \c j will be in the heap with the same prioriority |
|
335 |
/// as item \c i had before. |
|
336 | 336 |
void replace(const Item& i, const Item& j) { |
337 | 337 |
int idx = _iim[i]; |
338 | 338 |
_iim.set(i, _iim[j]); |
339 | 339 |
_iim.set(j, idx); |
340 | 340 |
_data[idx].first = j; |
341 | 341 |
} |
... | ... |
@@ -534,13 +534,13 @@ |
534 | 534 |
template <typename _Value> |
535 | 535 |
class ArcMap |
536 | 536 |
: public MapExtender<DefaultMap<Graph, Arc, _Value> > { |
537 | 537 |
typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent; |
538 | 538 |
|
539 | 539 |
public: |
540 |
ArcMap(const Graph& _g) |
|
540 |
explicit ArcMap(const Graph& _g) |
|
541 | 541 |
: Parent(_g) {} |
542 | 542 |
ArcMap(const Graph& _g, const _Value& _v) |
543 | 543 |
: Parent(_g, _v) {} |
544 | 544 |
|
545 | 545 |
ArcMap& operator=(const ArcMap& cmap) { |
546 | 546 |
return operator=<ArcMap>(cmap); |
... | ... |
@@ -558,13 +558,13 @@ |
558 | 558 |
template <typename _Value> |
559 | 559 |
class EdgeMap |
560 | 560 |
: public MapExtender<DefaultMap<Graph, Edge, _Value> > { |
561 | 561 |
typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent; |
562 | 562 |
|
563 | 563 |
public: |
564 |
EdgeMap(const Graph& _g) |
|
564 |
explicit EdgeMap(const Graph& _g) |
|
565 | 565 |
: Parent(_g) {} |
566 | 566 |
|
567 | 567 |
EdgeMap(const Graph& _g, const _Value& _v) |
568 | 568 |
: Parent(_g, _v) {} |
569 | 569 |
|
570 | 570 |
EdgeMap& operator=(const EdgeMap& cmap) { |
... | ... |
@@ -53,17 +53,17 @@ |
53 | 53 |
} |
54 | 54 |
|
55 | 55 |
int maxId(Arc) const { |
56 | 56 |
return Parent::maxArcId(); |
57 | 57 |
} |
58 | 58 |
|
59 |
Node fromId(int id, Node) |
|
59 |
static Node fromId(int id, Node) { |
|
60 | 60 |
return Parent::nodeFromId(id); |
61 | 61 |
} |
62 | 62 |
|
63 |
Arc fromId(int id, Arc) |
|
63 |
static Arc fromId(int id, Arc) { |
|
64 | 64 |
return Parent::arcFromId(id); |
65 | 65 |
} |
66 | 66 |
|
67 | 67 |
Node oppositeNode(const Node &node, const Arc &arc) const { |
68 | 68 |
if (node == Parent::source(arc)) |
69 | 69 |
return Parent::target(arc); |
... | ... |
@@ -352,21 +352,21 @@ |
352 | 352 |
} |
353 | 353 |
|
354 | 354 |
int maxId(Edge) const { |
355 | 355 |
return Parent::maxEdgeId(); |
356 | 356 |
} |
357 | 357 |
|
358 |
Node fromId(int id, Node) |
|
358 |
static Node fromId(int id, Node) { |
|
359 | 359 |
return Parent::nodeFromId(id); |
360 | 360 |
} |
361 | 361 |
|
362 |
Arc fromId(int id, Arc) |
|
362 |
static Arc fromId(int id, Arc) { |
|
363 | 363 |
return Parent::arcFromId(id); |
364 | 364 |
} |
365 | 365 |
|
366 |
Edge fromId(int id, Edge) |
|
366 |
static Edge fromId(int id, Edge) { |
|
367 | 367 |
return Parent::edgeFromId(id); |
368 | 368 |
} |
369 | 369 |
|
370 | 370 |
Node oppositeNode(const Node &n, const Edge &e) const { |
371 | 371 |
if( n == Parent::u(e)) |
372 | 372 |
return Parent::v(e); |
... | ... |
@@ -601,13 +601,13 @@ |
601 | 601 |
template <typename _Value> |
602 | 602 |
class NodeMap |
603 | 603 |
: public MapExtender<DefaultMap<Graph, Node, _Value> > { |
604 | 604 |
typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent; |
605 | 605 |
|
606 | 606 |
public: |
607 |
NodeMap(const Graph& graph) |
|
607 |
explicit NodeMap(const Graph& graph) |
|
608 | 608 |
: Parent(graph) {} |
609 | 609 |
NodeMap(const Graph& graph, const _Value& value) |
610 | 610 |
: Parent(graph, value) {} |
611 | 611 |
|
612 | 612 |
private: |
613 | 613 |
NodeMap& operator=(const NodeMap& cmap) { |
... | ... |
@@ -625,13 +625,13 @@ |
625 | 625 |
template <typename _Value> |
626 | 626 |
class ArcMap |
627 | 627 |
: public MapExtender<DefaultMap<Graph, Arc, _Value> > { |
628 | 628 |
typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent; |
629 | 629 |
|
630 | 630 |
public: |
631 |
ArcMap(const Graph& graph) |
|
631 |
explicit ArcMap(const Graph& graph) |
|
632 | 632 |
: Parent(graph) {} |
633 | 633 |
ArcMap(const Graph& graph, const _Value& value) |
634 | 634 |
: Parent(graph, value) {} |
635 | 635 |
|
636 | 636 |
private: |
637 | 637 |
ArcMap& operator=(const ArcMap& cmap) { |
... | ... |
@@ -649,13 +649,13 @@ |
649 | 649 |
template <typename _Value> |
650 | 650 |
class EdgeMap |
651 | 651 |
: public MapExtender<DefaultMap<Graph, Edge, _Value> > { |
652 | 652 |
typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent; |
653 | 653 |
|
654 | 654 |
public: |
655 |
EdgeMap(const Graph& graph) |
|
655 |
explicit EdgeMap(const Graph& graph) |
|
656 | 656 |
: Parent(graph) {} |
657 | 657 |
|
658 | 658 |
EdgeMap(const Graph& graph, const _Value& value) |
659 | 659 |
: Parent(graph, value) {} |
660 | 660 |
|
661 | 661 |
private: |
... | ... |
@@ -16,15 +16,15 @@ |
16 | 16 |
* |
17 | 17 |
*/ |
18 | 18 |
|
19 | 19 |
#ifndef LEMON_BUCKET_HEAP_H |
20 | 20 |
#define LEMON_BUCKET_HEAP_H |
21 | 21 |
|
22 |
///\ingroup |
|
22 |
///\ingroup heaps |
|
23 | 23 |
///\file |
24 |
///\brief Bucket |
|
24 |
///\brief Bucket heap implementation. |
|
25 | 25 |
|
26 | 26 |
#include <vector> |
27 | 27 |
#include <utility> |
28 | 28 |
#include <functional> |
29 | 29 |
|
30 | 30 |
namespace lemon { |
... | ... |
@@ -50,94 +50,102 @@ |
50 | 50 |
--value; |
51 | 51 |
} |
52 | 52 |
}; |
53 | 53 |
|
54 | 54 |
} |
55 | 55 |
|
56 |
/// \ingroup |
|
56 |
/// \ingroup heaps |
|
57 | 57 |
/// |
58 |
/// \brief |
|
58 |
/// \brief Bucket heap data structure. |
|
59 | 59 |
/// |
60 |
/// This class implements the \e bucket \e heap data structure. A \e heap |
|
61 |
/// is a data structure for storing items with specified values called \e |
|
62 |
/// priorities in such a way that finding the item with minimum priority is |
|
63 |
/// efficient. The bucket heap is very simple implementation, it can store |
|
64 |
/// only integer priorities and it stores for each priority in the |
|
65 |
/// \f$ [0..C) \f$ range a list of items. So it should be used only when |
|
66 |
/// the |
|
60 |
/// This class implements the \e bucket \e heap data structure. |
|
61 |
/// It practically conforms to the \ref concepts::Heap "heap concept", |
|
62 |
/// but it has some limitations. |
|
67 | 63 |
/// |
68 |
/// \param IM A read and write Item int map, used internally |
|
69 |
/// to handle the cross references. |
|
70 |
/// \param MIN If the given parameter is false then instead of the |
|
71 |
/// minimum value the maximum can be retrivied with the top() and |
|
72 |
/// |
|
64 |
/// The bucket heap is a very simple structure. It can store only |
|
65 |
/// \c int priorities and it maintains a list of items for each priority |
|
66 |
/// in the range <tt>[0..C)</tt>. So it should only be used when the |
|
67 |
/// priorities are small. It is not intended to use as a Dijkstra heap. |
|
68 |
/// |
|
69 |
/// \tparam IM A read-writable item map with \c int values, used |
|
70 |
/// internally to handle the cross references. |
|
71 |
/// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. |
|
72 |
/// The default is \e min-heap. If this parameter is set to \c false, |
|
73 |
/// then the comparison is reversed, so the top(), prio() and pop() |
|
74 |
/// functions deal with the item having maximum priority instead of the |
|
75 |
/// minimum. |
|
76 |
/// |
|
77 |
/// \sa SimpleBucketHeap |
|
73 | 78 |
template <typename IM, bool MIN = true> |
74 | 79 |
class BucketHeap { |
75 | 80 |
|
76 | 81 |
public: |
77 |
/// \e |
|
78 |
typedef typename IM::Key Item; |
|
79 |
|
|
82 |
|
|
83 |
/// Type of the item-int map. |
|
84 |
typedef IM ItemIntMap; |
|
85 |
/// Type of the priorities. |
|
80 | 86 |
typedef int Prio; |
81 |
/// \e |
|
82 |
typedef std::pair<Item, Prio> Pair; |
|
83 |
/// \e |
|
84 |
typedef IM ItemIntMap; |
|
87 |
/// Type of the items stored in the heap. |
|
88 |
typedef typename ItemIntMap::Key Item; |
|
89 |
/// Type of the item-priority pairs. |
|
90 |
typedef std::pair<Item,Prio> Pair; |
|
85 | 91 |
|
86 | 92 |
private: |
87 | 93 |
|
88 | 94 |
typedef _bucket_heap_bits::DirectionTraits<MIN> Direction; |
89 | 95 |
|
90 | 96 |
public: |
91 | 97 |
|
92 |
/// \brief Type to represent the |
|
98 |
/// \brief Type to represent the states of the items. |
|
93 | 99 |
/// |
94 |
/// Each Item element have a state associated to it. It may be "in heap", |
|
95 |
/// "pre heap" or "post heap". The latter two are indifferent from the |
|
100 |
/// Each item has a state associated to it. It can be "in heap", |
|
101 |
/// "pre-heap" or "post-heap". The latter two are indifferent from the |
|
96 | 102 |
/// heap's point of view, but may be useful to the user. |
97 | 103 |
/// |
98 | 104 |
/// The item-int map must be initialized in such way that it assigns |
99 | 105 |
/// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap. |
100 | 106 |
enum State { |
101 | 107 |
IN_HEAP = 0, ///< = 0. |
102 | 108 |
PRE_HEAP = -1, ///< = -1. |
103 | 109 |
POST_HEAP = -2 ///< = -2. |
104 | 110 |
}; |
105 | 111 |
|
106 | 112 |
public: |
107 |
|
|
113 |
|
|
114 |
/// \brief Constructor. |
|
108 | 115 |
/// |
109 |
/// The constructor. |
|
110 |
/// \param map should be given to the constructor, since it is used |
|
111 |
/// internally to handle the cross references. The value of the map |
|
112 |
/// should be PRE_HEAP (-1) for each element. |
|
116 |
/// Constructor. |
|
117 |
/// \param map A map that assigns \c int values to the items. |
|
118 |
/// It is used internally to handle the cross references. |
|
119 |
/// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. |
|
113 | 120 |
explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {} |
114 | 121 |
|
115 |
/// The number of items stored in the heap. |
|
122 |
/// \brief The number of items stored in the heap. |
|
116 | 123 |
/// |
117 |
/// |
|
124 |
/// This function returns the number of items stored in the heap. |
|
118 | 125 |
int size() const { return _data.size(); } |
119 | 126 |
|
120 |
/// \brief |
|
127 |
/// \brief Check if the heap is empty. |
|
121 | 128 |
/// |
122 |
/// |
|
129 |
/// This function returns \c true if the heap is empty. |
|
123 | 130 |
bool empty() const { return _data.empty(); } |
124 | 131 |
|
125 |
/// \brief Make |
|
132 |
/// \brief Make the heap empty. |
|
126 | 133 |
/// |
127 |
/// Make empty this heap. It does not change the cross reference |
|
128 |
/// map. If you want to reuse a heap what is not surely empty you |
|
129 |
/// should first clear the heap and after that you should set the |
|
130 |
/// cross reference map for each item to \c PRE_HEAP. |
|
134 |
/// This functon makes the heap empty. |
|
135 |
/// It does not change the cross reference map. If you want to reuse |
|
136 |
/// a heap that is not surely empty, you should first clear it and |
|
137 |
/// then you should set the cross reference map to \c PRE_HEAP |
|
138 |
/// for each item. |
|
131 | 139 |
void clear() { |
132 | 140 |
_data.clear(); _first.clear(); _minimum = 0; |
133 | 141 |
} |
134 | 142 |
|
135 | 143 |
private: |
136 | 144 |
|
137 |
void |
|
145 |
void relocateLast(int idx) { |
|
138 | 146 |
if (idx + 1 < int(_data.size())) { |
139 | 147 |
_data[idx] = _data.back(); |
140 | 148 |
if (_data[idx].prev != -1) { |
141 | 149 |
_data[_data[idx].prev].next = idx; |
142 | 150 |
} else { |
143 | 151 |
_first[_data[idx].value] = idx; |
... | ... |
@@ -171,99 +179,105 @@ |
171 | 179 |
} |
172 | 180 |
_first[_data[idx].value] = idx; |
173 | 181 |
_data[idx].prev = -1; |
174 | 182 |
} |
175 | 183 |
|
176 | 184 |
public: |
185 |
|
|
177 | 186 |
/// \brief Insert a pair of item and priority into the heap. |
178 | 187 |
/// |
179 |
/// |
|
188 |
/// This function inserts \c p.first to the heap with priority |
|
189 |
/// \c p.second. |
|
180 | 190 |
/// \param p The pair to insert. |
191 |
/// \pre \c p.first must not be stored in the heap. |
|
181 | 192 |
void push(const Pair& p) { |
182 | 193 |
push(p.first, p.second); |
183 | 194 |
} |
184 | 195 |
|
185 | 196 |
/// \brief Insert an item into the heap with the given priority. |
186 | 197 |
/// |
187 |
/// |
|
198 |
/// This function inserts the given item into the heap with the |
|
199 |
/// given priority. |
|
188 | 200 |
/// \param i The item to insert. |
189 | 201 |
/// \param p The priority of the item. |
202 |
/// \pre \e i must not be stored in the heap. |
|
190 | 203 |
void push(const Item &i, const Prio &p) { |
191 | 204 |
int idx = _data.size(); |
192 | 205 |
_iim[i] = idx; |
193 | 206 |
_data.push_back(BucketItem(i, p)); |
194 | 207 |
lace(idx); |
195 | 208 |
if (Direction::less(p, _minimum)) { |
196 | 209 |
_minimum = p; |
197 | 210 |
} |
198 | 211 |
} |
199 | 212 |
|
200 |
/// \brief |
|
213 |
/// \brief Return the item having minimum priority. |
|
201 | 214 |
/// |
202 |
/// This method returns the item with minimum priority. |
|
203 |
/// \pre The heap must be nonempty. |
|
215 |
/// This function returns the item having minimum priority. |
|
216 |
/// \pre The heap must be non-empty. |
|
204 | 217 |
Item top() const { |
205 | 218 |
while (_first[_minimum] == -1) { |
206 | 219 |
Direction::increase(_minimum); |
207 | 220 |
} |
208 | 221 |
return _data[_first[_minimum]].item; |
209 | 222 |
} |
210 | 223 |
|
211 |
/// \brief |
|
224 |
/// \brief The minimum priority. |
|
212 | 225 |
/// |
213 |
/// It returns the minimum priority. |
|
214 |
/// \pre The heap must be nonempty. |
|
226 |
/// This function returns the minimum priority. |
|
227 |
/// \pre The heap must be non-empty. |
|
215 | 228 |
Prio prio() const { |
216 | 229 |
while (_first[_minimum] == -1) { |
217 | 230 |
Direction::increase(_minimum); |
218 | 231 |
} |
219 | 232 |
return _minimum; |
220 | 233 |
} |
221 | 234 |
|
222 |
/// \brief |
|
235 |
/// \brief Remove the item having minimum priority. |
|
223 | 236 |
/// |
224 |
/// This |
|
237 |
/// This function removes the item having minimum priority. |
|
225 | 238 |
/// \pre The heap must be non-empty. |
226 | 239 |
void pop() { |
227 | 240 |
while (_first[_minimum] == -1) { |
228 | 241 |
Direction::increase(_minimum); |
229 | 242 |
} |
230 | 243 |
int idx = _first[_minimum]; |
231 | 244 |
_iim[_data[idx].item] = -2; |
232 | 245 |
unlace(idx); |
233 |
|
|
246 |
relocateLast(idx); |
|
234 | 247 |
} |
235 | 248 |
|
236 |
/// \brief |
|
249 |
/// \brief Remove the given item from the heap. |
|
237 | 250 |
/// |
238 |
/// This method deletes item \c i from the heap, if \c i was |
|
239 |
/// already stored in the heap. |
|
240 |
/// |
|
251 |
/// This function removes the given item from the heap if it is |
|
252 |
/// already stored. |
|
253 |
/// \param i The item to delete. |
|
254 |
/// \pre \e i must be in the heap. |
|
241 | 255 |
void erase(const Item &i) { |
242 | 256 |
int idx = _iim[i]; |
243 | 257 |
_iim[_data[idx].item] = -2; |
244 | 258 |
unlace(idx); |
245 |
|
|
259 |
relocateLast(idx); |
|
246 | 260 |
} |
247 | 261 |
|
248 |
|
|
249 |
/// \brief Returns the priority of \c i. |
|
262 |
/// \brief The priority of the given item. |
|
250 | 263 |
/// |
251 |
/// This function returns the priority of item \c i. |
|
252 |
/// \pre \c i must be in the heap. |
|
264 |
/// This function returns the priority of the given item. |
|
253 | 265 |
/// \param i The item. |
266 |
/// \pre \e i must be in the heap. |
|
254 | 267 |
Prio operator[](const Item &i) const { |
255 | 268 |
int idx = _iim[i]; |
256 | 269 |
return _data[idx].value; |
257 | 270 |
} |
258 | 271 |
|
259 |
/// \brief \c i gets to the heap with priority \c p independently |
|
260 |
/// if \c i was already there. |
|
272 |
/// \brief Set the priority of an item or insert it, if it is |
|
273 |
/// not stored in the heap. |
|
261 | 274 |
/// |
262 |
/// This method calls \ref push(\c i, \c p) if \c i is not stored |
|
263 |
/// in the heap and sets the priority of \c i to \c p otherwise. |
|
275 |
/// This method sets the priority of the given item if it is |
|
276 |
/// already stored in the heap. Otherwise it inserts the given |
|
277 |
/// item into the heap with the given priority. |
|
264 | 278 |
/// \param i The item. |
265 | 279 |
/// \param p The priority. |
266 | 280 |
void set(const Item &i, const Prio &p) { |
267 | 281 |
int idx = _iim[i]; |
268 | 282 |
if (idx < 0) { |
269 | 283 |
push(i, p); |
... | ... |
@@ -271,62 +285,60 @@ |
271 | 285 |
decrease(i, p); |
272 | 286 |
} else { |
273 | 287 |
increase(i, p); |
274 | 288 |
} |
275 | 289 |
} |
276 | 290 |
|
277 |
/// \brief |
|
291 |
/// \brief Decrease the priority of an item to the given value. |
|
278 | 292 |
/// |
279 |
/// This method decreases the priority of item \c i to \c p. |
|
280 |
/// \pre \c i must be stored in the heap with priority at least \c |
|
281 |
/// |
|
293 |
/// This function decreases the priority of an item to the given value. |
|
282 | 294 |
/// \param i The item. |
283 | 295 |
/// \param p The priority. |
296 |
/// \pre \e i must be stored in the heap with priority at least \e p. |
|
284 | 297 |
void decrease(const Item &i, const Prio &p) { |
285 | 298 |
int idx = _iim[i]; |
286 | 299 |
unlace(idx); |
287 | 300 |
_data[idx].value = p; |
288 | 301 |
if (Direction::less(p, _minimum)) { |
289 | 302 |
_minimum = p; |
290 | 303 |
} |
291 | 304 |
lace(idx); |
292 | 305 |
} |
293 | 306 |
|
294 |
/// \brief |
|
307 |
/// \brief Increase the priority of an item to the given value. |
|
295 | 308 |
/// |
296 |
/// This method sets the priority of item \c i to \c p. |
|
297 |
/// \pre \c i must be stored in the heap with priority at most \c |
|
298 |
/// |
|
309 |
/// This function increases the priority of an item to the given value. |
|
299 | 310 |
/// \param i The item. |
300 | 311 |
/// \param p The priority. |
312 |
/// \pre \e i must be stored in the heap with priority at most \e p. |
|
301 | 313 |
void increase(const Item &i, const Prio &p) { |
302 | 314 |
int idx = _iim[i]; |
303 | 315 |
unlace(idx); |
304 | 316 |
_data[idx].value = p; |
305 | 317 |
lace(idx); |
306 | 318 |
} |
307 | 319 |
|
308 |
/// \brief Returns if \c item is in, has already been in, or has |
|
309 |
/// never been in the heap. |
|
320 |
/// \brief Return the state of an item. |
|
310 | 321 |
/// |
311 |
/// This method returns PRE_HEAP if \c item has never been in the |
|
312 |
/// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP |
|
313 |
/// otherwise. In the latter case it is possible that \c item will |
|
314 |
/// get back to the heap again. |
|
322 |
/// This method returns \c PRE_HEAP if the given item has never |
|
323 |
/// been in the heap, \c IN_HEAP if it is in the heap at the moment, |
|
324 |
/// and \c POST_HEAP otherwise. |
|
325 |
/// In the latter case it is possible that the item will get back |
|
326 |
/// to the heap again. |
|
315 | 327 |
/// \param i The item. |
316 | 328 |
State state(const Item &i) const { |
317 | 329 |
int idx = _iim[i]; |
318 | 330 |
if (idx >= 0) idx = 0; |
319 | 331 |
return State(idx); |
320 | 332 |
} |
321 | 333 |
|
322 |
/// \brief |
|
334 |
/// \brief Set the state of an item in the heap. |
|
323 | 335 |
/// |
324 |
/// Sets the state of the \c item in the heap. It can be used to |
|
325 |
/// manually clear the heap when it is important to achive the |
|
326 |
/// |
|
336 |
/// This function sets the state of the given item in the heap. |
|
337 |
/// It can be used to manually clear the heap when it is important |
|
338 |
/// to achive better time complexity. |
|
327 | 339 |
/// \param i The item. |
328 | 340 |
/// \param st The state. It should not be \c IN_HEAP. |
329 | 341 |
void state(const Item& i, State st) { |
330 | 342 |
switch (st) { |
331 | 343 |
case POST_HEAP: |
332 | 344 |
case PRE_HEAP: |
... | ... |
@@ -356,104 +368,120 @@ |
356 | 368 |
std::vector<int> _first; |
357 | 369 |
std::vector<BucketItem> _data; |
358 | 370 |
mutable int _minimum; |
359 | 371 |
|
360 | 372 |
}; // class BucketHeap |
361 | 373 |
|
362 |
/// \ingroup |
|
374 |
/// \ingroup heaps |
|
363 | 375 |
/// |
364 |
/// \brief |
|
376 |
/// \brief Simplified bucket heap data structure. |
|
365 | 377 |
/// |
366 | 378 |
/// This class implements a simplified \e bucket \e heap data |
367 |
/// structure. It does not provide some functionality but it faster |
|
368 |
/// and simplier data structure than the BucketHeap. The main |
|
369 |
/// difference is that the BucketHeap stores for every key a double |
|
370 |
/// linked list while this class stores just simple lists. In the |
|
371 |
/// other way it does not support erasing each elements just the |
|
372 |
/// minimal and it does not supports key increasing, decreasing. |
|
379 |
/// structure. It does not provide some functionality, but it is |
|
380 |
/// faster and simpler than BucketHeap. The main difference is |
|
381 |
/// that BucketHeap stores a doubly-linked list for each key while |
|
382 |
/// this class stores only simply-linked lists. It supports erasing |
|
383 |
/// only for the item having minimum priority and it does not support |
|
384 |
/// key increasing and decreasing. |
|
373 | 385 |
/// |
374 |
/// \param IM A read and write Item int map, used internally |
|
375 |
/// to handle the cross references. |
|
376 |
/// \param MIN If the given parameter is false then instead of the |
|
377 |
/// minimum value the maximum can be retrivied with the top() and |
|
378 |
/// |
|
386 |
/// Note that this implementation does not conform to the |
|
387 |
/// \ref concepts::Heap "heap concept" due to the lack of some |
|
388 |
/// functionality. |
|
389 |
/// |
|
390 |
/// \tparam IM A read-writable item map with \c int values, used |
|
391 |
/// internally to handle the cross references. |
|
392 |
/// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. |
|
393 |
/// The default is \e min-heap. If this parameter is set to \c false, |
|
394 |
/// then the comparison is reversed, so the top(), prio() and pop() |
|
395 |
/// functions deal with the item having maximum priority instead of the |
|
396 |
/// minimum. |
|
379 | 397 |
/// |
380 | 398 |
/// \sa BucketHeap |
381 | 399 |
template <typename IM, bool MIN = true > |
382 | 400 |
class SimpleBucketHeap { |
383 | 401 |
|
384 | 402 |
public: |
385 |
|
|
403 |
|
|
404 |
/// Type of the item-int map. |
|
405 |
typedef IM ItemIntMap; |
|
406 |
/// Type of the priorities. |
|
386 | 407 |
typedef int Prio; |
387 |
typedef std::pair<Item, Prio> Pair; |
|
388 |
typedef IM ItemIntMap; |
|
408 |
/// Type of the items stored in the heap. |
|
409 |
typedef typename ItemIntMap::Key Item; |
|
410 |
/// Type of the item-priority pairs. |
|
411 |
typedef std::pair<Item,Prio> Pair; |
|
389 | 412 |
|
390 | 413 |
private: |
391 | 414 |
|
392 | 415 |
typedef _bucket_heap_bits::DirectionTraits<MIN> Direction; |
393 | 416 |
|
394 | 417 |
public: |
395 | 418 |
|
396 |
/// \brief Type to represent the |
|
419 |
/// \brief Type to represent the states of the items. |
|
397 | 420 |
/// |
398 |
/// Each Item element have a state associated to it. It may be "in heap", |
|
399 |
/// "pre heap" or "post heap". The latter two are indifferent from the |
|
421 |
/// Each item has a state associated to it. It can be "in heap", |
|
422 |
/// "pre-heap" or "post-heap". The latter two are indifferent from the |
|
400 | 423 |
/// heap's point of view, but may be useful to the user. |
401 | 424 |
/// |
402 | 425 |
/// The item-int map must be initialized in such way that it assigns |
403 | 426 |
/// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap. |
404 | 427 |
enum State { |
405 | 428 |
IN_HEAP = 0, ///< = 0. |
406 | 429 |
PRE_HEAP = -1, ///< = -1. |
407 | 430 |
POST_HEAP = -2 ///< = -2. |
408 | 431 |
}; |
409 | 432 |
|
410 | 433 |
public: |
411 | 434 |
|
412 |
/// \brief |
|
435 |
/// \brief Constructor. |
|
413 | 436 |
/// |
414 |
/// The constructor. |
|
415 |
/// \param map should be given to the constructor, since it is used |
|
416 |
/// internally to handle the cross references. The value of the map |
|
417 |
/// should be PRE_HEAP (-1) for each element. |
|
437 |
/// Constructor. |
|
438 |
/// \param map A map that assigns \c int values to the items. |
|
439 |
/// It is used internally to handle the cross references. |
|
440 |
/// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. |
|
418 | 441 |
explicit SimpleBucketHeap(ItemIntMap &map) |
419 | 442 |
: _iim(map), _free(-1), _num(0), _minimum(0) {} |
420 | 443 |
|
421 |
/// \brief |
|
444 |
/// \brief The number of items stored in the heap. |
|
422 | 445 |
/// |
423 |
/// |
|
446 |
/// This function returns the number of items stored in the heap. |
|
424 | 447 |
int size() const { return _num; } |
425 | 448 |
|
426 |
/// \brief |
|
449 |
/// \brief Check if the heap is empty. |
|
427 | 450 |
/// |
428 |
/// |
|
451 |
/// This function returns \c true if the heap is empty. |
|
429 | 452 |
bool empty() const { return _num == 0; } |
430 | 453 |
|
431 |
/// \brief Make |
|
454 |
/// \brief Make the heap empty. |
|
432 | 455 |
/// |
433 |
/// Make empty this heap. It does not change the cross reference |
|
434 |
/// map. If you want to reuse a heap what is not surely empty you |
|
435 |
/// should first clear the heap and after that you should set the |
|
436 |
/// cross reference map for each item to \c PRE_HEAP. |
|
456 |
/// This functon makes the heap empty. |
|
457 |
/// It does not change the cross reference map. If you want to reuse |
|
458 |
/// a heap that is not surely empty, you should first clear it and |
|
459 |
/// then you should set the cross reference map to \c PRE_HEAP |
|
460 |
/// for each item. |
|
437 | 461 |
void clear() { |
438 | 462 |
_data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0; |
439 | 463 |
} |
440 | 464 |
|
441 | 465 |
/// \brief Insert a pair of item and priority into the heap. |
442 | 466 |
/// |
443 |
/// |
|
467 |
/// This function inserts \c p.first to the heap with priority |
|
468 |
/// \c p.second. |
|
444 | 469 |
/// \param p The pair to insert. |
470 |
/// \pre \c p.first must not be stored in the heap. |
|
445 | 471 |
void push(const Pair& p) { |
446 | 472 |
push(p.first, p.second); |
447 | 473 |
} |
448 | 474 |
|
449 | 475 |
/// \brief Insert an item into the heap with the given priority. |
450 | 476 |
/// |
451 |
/// |
|
477 |
/// This function inserts the given item into the heap with the |
|
478 |
/// given priority. |
|
452 | 479 |
/// \param i The item to insert. |
453 | 480 |
/// \param p The priority of the item. |
481 |
/// \pre \e i must not be stored in the heap. |
|
454 | 482 |
void push(const Item &i, const Prio &p) { |
455 | 483 |
int idx; |
456 | 484 |
if (_free == -1) { |
457 | 485 |
idx = _data.size(); |
458 | 486 |
_data.push_back(BucketItem(i)); |
459 | 487 |
} else { |
... | ... |
@@ -468,37 +496,37 @@ |
468 | 496 |
if (Direction::less(p, _minimum)) { |
469 | 497 |
_minimum = p; |
470 | 498 |
} |
471 | 499 |
++_num; |
472 | 500 |
} |
473 | 501 |
|
474 |
/// \brief |
|
502 |
/// \brief Return the item having minimum priority. |
|
475 | 503 |
/// |
476 |
/// This method returns the item with minimum priority. |
|
477 |
/// \pre The heap must be nonempty. |
|
504 |
/// This function returns the item having minimum priority. |
|
505 |
/// \pre The heap must be non-empty. |
|
478 | 506 |
Item top() const { |
479 | 507 |
while (_first[_minimum] == -1) { |
480 | 508 |
Direction::increase(_minimum); |
481 | 509 |
} |
482 | 510 |
return _data[_first[_minimum]].item; |
483 | 511 |
} |
484 | 512 |
|
485 |
/// \brief |
|
513 |
/// \brief The minimum priority. |
|
486 | 514 |
/// |
487 |
/// It returns the minimum priority. |
|
488 |
/// \pre The heap must be nonempty. |
|
515 |
/// This function returns the minimum priority. |
|
516 |
/// \pre The heap must be non-empty. |
|
489 | 517 |
Prio prio() const { |
490 | 518 |
while (_first[_minimum] == -1) { |
491 | 519 |
Direction::increase(_minimum); |
492 | 520 |
} |
493 | 521 |
return _minimum; |
494 | 522 |
} |
495 | 523 |
|
496 |
/// \brief |
|
524 |
/// \brief Remove the item having minimum priority. |
|
497 | 525 |
/// |
498 |
/// This |
|
526 |
/// This function removes the item having minimum priority. |
|
499 | 527 |
/// \pre The heap must be non-empty. |
500 | 528 |
void pop() { |
501 | 529 |
while (_first[_minimum] == -1) { |
502 | 530 |
Direction::increase(_minimum); |
503 | 531 |
} |
504 | 532 |
int idx = _first[_minimum]; |
... | ... |
@@ -506,40 +534,39 @@ |
506 | 534 |
_first[_minimum] = _data[idx].next; |
507 | 535 |
_data[idx].next = _free; |
508 | 536 |
_free = idx; |
509 | 537 |
--_num; |
510 | 538 |
} |
511 | 539 |
|
512 |
/// \brief |
|
540 |
/// \brief The priority of the given item. |
|
513 | 541 |
/// |
514 |
/// This function returns the priority of item \c i. |
|
515 |
/// \warning This operator is not a constant time function |
|
516 |
/// because it scans the whole data structure to find the proper |
|
517 |
/// value. |
|
518 |
/// |
|
542 |
/// This function returns the priority of the given item. |
|
519 | 543 |
/// \param i The item. |
544 |
/// \pre \e i must be in the heap. |
|
545 |
/// \warning This operator is not a constant time function because |
|
546 |
/// it scans the whole data structure to find the proper value. |
|
520 | 547 |
Prio operator[](const Item &i) const { |
521 |
for (int k = 0; k < _first.size(); ++k) { |
|
548 |
for (int k = 0; k < int(_first.size()); ++k) { |
|
522 | 549 |
int idx = _first[k]; |
523 | 550 |
while (idx != -1) { |
524 | 551 |
if (_data[idx].item == i) { |
525 | 552 |
return k; |
526 | 553 |
} |
527 | 554 |
idx = _data[idx].next; |
528 | 555 |
} |
529 | 556 |
} |
530 | 557 |
return -1; |
531 | 558 |
} |
532 | 559 |
|
533 |
/// \brief Returns if \c item is in, has already been in, or has |
|
534 |
/// never been in the heap. |
|
560 |
/// \brief Return the state of an item. |
|
535 | 561 |
/// |
536 |
/// This method returns PRE_HEAP if \c item has never been in the |
|
537 |
/// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP |
|
538 |
/// otherwise. In the latter case it is possible that \c item will |
|
539 |
/// get back to the heap again. |
|
562 |
/// This method returns \c PRE_HEAP if the given item has never |
|
563 |
/// been in the heap, \c IN_HEAP if it is in the heap at the moment, |
|
564 |
/// and \c POST_HEAP otherwise. |
|
565 |
/// In the latter case it is possible that the item will get back |
|
566 |
/// to the heap again. |
|
540 | 567 |
/// \param i The item. |
541 | 568 |
State state(const Item &i) const { |
542 | 569 |
int idx = _iim[i]; |
543 | 570 |
if (idx >= 0) idx = 0; |
544 | 571 |
return State(idx); |
545 | 572 |
} |
... | ... |
@@ -91,12 +91,24 @@ |
91 | 91 |
|
92 | 92 |
int CbcMip::_addRow() { |
93 | 93 |
_prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX); |
94 | 94 |
return _prob->numberRows() - 1; |
95 | 95 |
} |
96 | 96 |
|
97 |
int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { |
|
98 |
std::vector<int> indexes; |
|
99 |
std::vector<Value> values; |
|
100 |
|
|
101 |
for(ExprIterator it = b; it != e; ++it) { |
|
102 |
indexes.push_back(it->first); |
|
103 |
values.push_back(it->second); |
|
104 |
} |
|
105 |
|
|
106 |
_prob->addRow(values.size(), &indexes.front(), &values.front(), l, u); |
|
107 |
return _prob->numberRows() - 1; |
|
108 |
} |
|
97 | 109 |
|
98 | 110 |
void CbcMip::_eraseCol(int i) { |
99 | 111 |
_prob->deleteColumn(i); |
100 | 112 |
} |
101 | 113 |
|
102 | 114 |
void CbcMip::_eraseRow(int i) { |
... | ... |
@@ -59,12 +59,13 @@ |
59 | 59 |
protected: |
60 | 60 |
|
61 | 61 |
virtual const char* _solverName() const; |
62 | 62 |
|
63 | 63 |
virtual int _addCol(); |
64 | 64 |
virtual int _addRow(); |
65 |
virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); |
|
65 | 66 |
|
66 | 67 |
virtual void _eraseCol(int i); |
67 | 68 |
virtual void _eraseRow(int i); |
68 | 69 |
|
69 | 70 |
virtual void _eraseColId(int i); |
70 | 71 |
virtual void _eraseRowId(int i); |
... | ... |
@@ -69,13 +69,17 @@ |
69 | 69 |
|
70 | 70 |
/// \brief The type of the map that stores the flow values. |
71 | 71 |
/// |
72 | 72 |
/// The type of the map that stores the flow values. |
73 | 73 |
/// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" |
74 | 74 |
/// concept. |
75 |
#ifdef DOXYGEN |
|
76 |
typedef GR::ArcMap<Value> FlowMap; |
|
77 |
#else |
|
75 | 78 |
typedef typename Digraph::template ArcMap<Value> FlowMap; |
79 |
#endif |
|
76 | 80 |
|
77 | 81 |
/// \brief Instantiates a FlowMap. |
78 | 82 |
/// |
79 | 83 |
/// This function instantiates a \ref FlowMap. |
80 | 84 |
/// \param digraph The digraph for which we would like to define |
81 | 85 |
/// the flow map. |
... | ... |
@@ -84,15 +88,18 @@ |
84 | 88 |
} |
85 | 89 |
|
86 | 90 |
/// \brief The elevator type used by the algorithm. |
87 | 91 |
/// |
88 | 92 |
/// The elevator type used by the algorithm. |
89 | 93 |
/// |
90 |
/// \sa Elevator |
|
91 |
/// \sa LinkedElevator |
|
94 |
/// \sa Elevator, LinkedElevator |
|
95 |
#ifdef DOXYGEN |
|
96 |
typedef lemon::Elevator<GR, GR::Node> Elevator; |
|
97 |
#else |
|
92 | 98 |
typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator; |
99 |
#endif |
|
93 | 100 |
|
94 | 101 |
/// \brief Instantiates an Elevator. |
95 | 102 |
/// |
96 | 103 |
/// This function instantiates an \ref Elevator. |
97 | 104 |
/// \param digraph The digraph for which we would like to define |
98 | 105 |
/// the elevator. |
... | ... |
@@ -296,13 +303,13 @@ |
296 | 303 |
/// |
297 | 304 |
/// \ref named-templ-param "Named parameter" for setting Elevator |
298 | 305 |
/// type with automatic allocation. |
299 | 306 |
/// The Elevator should have standard constructor interface to be |
300 | 307 |
/// able to automatically created by the algorithm (i.e. the |
301 | 308 |
/// digraph and the maximum level should be passed to it). |
302 |
/// However an external elevator object could also be passed to the |
|
309 |
/// However, an external elevator object could also be passed to the |
|
303 | 310 |
/// algorithm with the \ref elevator(Elevator&) "elevator()" function |
304 | 311 |
/// before calling \ref run() or \ref init(). |
305 | 312 |
/// \sa SetElevator |
306 | 313 |
template <typename T> |
307 | 314 |
struct SetStandardElevator |
308 | 315 |
: public Circulation<Digraph, LowerMap, UpperMap, SupplyMap, |
... | ... |
@@ -447,31 +454,33 @@ |
447 | 454 |
/// \pre Either \ref run() or \ref init() must be called before |
448 | 455 |
/// using this function. |
449 | 456 |
const Elevator& elevator() const { |
450 | 457 |
return *_level; |
451 | 458 |
} |
452 | 459 |
|
453 |
/// \brief Sets the tolerance used by algorithm. |
|
460 |
/// \brief Sets the tolerance used by the algorithm. |
|
454 | 461 |
/// |
455 |
/// Sets the tolerance used by algorithm. |
|
456 |
Circulation& tolerance(const Tolerance& tolerance) const { |
|
462 |
/// Sets the tolerance object used by the algorithm. |
|
463 |
/// \return <tt>(*this)</tt> |
|
464 |
Circulation& tolerance(const Tolerance& tolerance) { |
|
457 | 465 |
_tol = tolerance; |
458 | 466 |
return *this; |
459 | 467 |
} |
460 | 468 |
|
461 | 469 |
/// \brief Returns a const reference to the tolerance. |
462 | 470 |
/// |
463 |
/// Returns a const reference to the tolerance |
|
471 |
/// Returns a const reference to the tolerance object used by |
|
472 |
/// the algorithm. |
|
464 | 473 |
const Tolerance& tolerance() const { |
465 |
return |
|
474 |
return _tol; |
|
466 | 475 |
} |
467 | 476 |
|
468 | 477 |
/// \name Execution Control |
469 | 478 |
/// The simplest way to execute the algorithm is to call \ref run().\n |
470 |
/// If you need more control on the initial solution or the execution, |
|
471 |
/// first you have to call one of the \ref init() functions, then |
|
479 |
/// If you need better control on the initial solution or the execution, |
|
480 |
/// you have to call one of the \ref init() functions first, then |
|
472 | 481 |
/// the \ref start() function. |
473 | 482 |
|
474 | 483 |
///@{ |
475 | 484 |
|
476 | 485 |
/// Initializes the internal data structures. |
477 | 486 |
... | ... |
@@ -75,12 +75,25 @@ |
75 | 75 |
|
76 | 76 |
int ClpLp::_addRow() { |
77 | 77 |
_prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX); |
78 | 78 |
return _prob->numberRows() - 1; |
79 | 79 |
} |
80 | 80 |
|
81 |
int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { |
|
82 |
std::vector<int> indexes; |
|
83 |
std::vector<Value> values; |
|
84 |
|
|
85 |
for(ExprIterator it = b; it != e; ++it) { |
|
86 |
indexes.push_back(it->first); |
|
87 |
values.push_back(it->second); |
|
88 |
} |
|
89 |
|
|
90 |
_prob->addRow(values.size(), &indexes.front(), &values.front(), l, u); |
|
91 |
return _prob->numberRows() - 1; |
|
92 |
} |
|
93 |
|
|
81 | 94 |
|
82 | 95 |
void ClpLp::_eraseCol(int c) { |
83 | 96 |
_col_names_ref.erase(_prob->getColumnName(c)); |
84 | 97 |
_prob->deleteColumns(1, &c); |
85 | 98 |
} |
86 | 99 |
... | ... |
@@ -72,12 +72,13 @@ |
72 | 72 |
protected: |
73 | 73 |
|
74 | 74 |
virtual const char* _solverName() const; |
75 | 75 |
|
76 | 76 |
virtual int _addCol(); |
77 | 77 |
virtual int _addRow(); |
78 |
virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); |
|
78 | 79 |
|
79 | 80 |
virtual void _eraseCol(int i); |
80 | 81 |
virtual void _eraseRow(int i); |
81 | 82 |
|
82 | 83 |
virtual void _eraseColId(int i); |
83 | 84 |
virtual void _eraseRowId(int i); |
... | ... |
@@ -32,344 +32,342 @@ |
32 | 32 |
namespace concepts { |
33 | 33 |
|
34 | 34 |
/// \ingroup graph_concepts |
35 | 35 |
/// |
36 | 36 |
/// \brief Class describing the concept of directed graphs. |
37 | 37 |
/// |
38 |
/// This class describes the \ref concept "concept" of the |
|
39 |
/// immutable directed digraphs. |
|
38 |
/// This class describes the common interface of all directed |
|
39 |
/// graphs (digraphs). |
|
40 | 40 |
/// |
41 |
/// Note that actual digraph implementation like @ref ListDigraph or |
|
42 |
/// @ref SmartDigraph may have several additional functionality. |
|
41 |
/// Like all concept classes, it only provides an interface |
|
42 |
/// without any sensible implementation. So any general algorithm for |
|
43 |
/// directed graphs should compile with this class, but it will not |
|
44 |
/// run properly, of course. |
|
45 |
/// An actual digraph implementation like \ref ListDigraph or |
|
46 |
/// \ref SmartDigraph may have additional functionality. |
|
43 | 47 |
/// |
44 |
/// \sa |
|
48 |
/// \sa Graph |
|
45 | 49 |
class Digraph { |
46 | 50 |
private: |
47 |
/// |
|
51 |
/// Diraphs are \e not copy constructible. Use DigraphCopy instead. |
|
52 |
Digraph(const Digraph &) {} |
|
53 |
/// \brief Assignment of a digraph to another one is \e not allowed. |
|
54 |
/// Use DigraphCopy instead. |
|
55 |
void operator=(const Digraph &) {} |
|
48 | 56 |
|
49 |
///Digraphs are \e not copy constructible. Use DigraphCopy() instead. |
|
50 |
/// |
|
51 |
Digraph(const Digraph &) {}; |
|
52 |
///\brief Assignment of \ref Digraph "Digraph"s to another ones are |
|
53 |
|
|
57 |
public: |
|
58 |
/// Default constructor. |
|
59 |
Digraph() { } |
|
54 | 60 |
|
55 |
///Assignment of \ref Digraph "Digraph"s to another ones are |
|
56 |
///\e not allowed. Use DigraphCopy() instead. |
|
57 |
|
|
58 |
void operator=(const Digraph &) {} |
|
59 |
public: |
|
60 |
///\e |
|
61 |
|
|
62 |
/// Defalult constructor. |
|
63 |
|
|
64 |
/// Defalult constructor. |
|
65 |
/// |
|
66 |
Digraph() { } |
|
67 |
/// |
|
61 |
/// The node type of the digraph |
|
68 | 62 |
|
69 | 63 |
/// This class identifies a node of the digraph. It also serves |
70 | 64 |
/// as a base class of the node iterators, |
71 |
/// thus they |
|
65 |
/// thus they convert to this type. |
|
72 | 66 |
class Node { |
73 | 67 |
public: |
74 | 68 |
/// Default constructor |
75 | 69 |
|
76 |
/// @warning The default constructor sets the iterator |
|
77 |
/// to an undefined value. |
|
70 |
/// Default constructor. |
|
71 |
/// \warning It sets the object to an undefined value. |
|
78 | 72 |
Node() { } |
79 | 73 |
/// Copy constructor. |
80 | 74 |
|
81 | 75 |
/// Copy constructor. |
82 | 76 |
/// |
83 | 77 |
Node(const Node&) { } |
84 | 78 |
|
85 |
/// Invalid constructor \& conversion. |
|
79 |
/// %Invalid constructor \& conversion. |
|
86 | 80 |
|
87 |
/// |
|
81 |
/// Initializes the object to be invalid. |
|
88 | 82 |
/// \sa Invalid for more details. |
89 | 83 |
Node(Invalid) { } |
90 | 84 |
/// Equality operator |
91 | 85 |
|
86 |
/// Equality operator. |
|
87 |
/// |
|
92 | 88 |
/// Two iterators are equal if and only if they point to the |
93 |
/// same object or both are |
|
89 |
/// same object or both are \c INVALID. |
|
94 | 90 |
bool operator==(Node) const { return true; } |
95 | 91 |
|
96 | 92 |
/// Inequality operator |
97 | 93 |
|
98 |
/// \sa operator==(Node n) |
|
99 |
/// |
|
94 |
/// Inequality operator. |
|
100 | 95 |
bool operator!=(Node) const { return true; } |
101 | 96 |
|
102 | 97 |
/// Artificial ordering operator. |
103 | 98 |
|
104 |
/// To allow the use of digraph descriptors as key type in std::map or |
|
105 |
/// similar associative container we require this. |
|
99 |
/// Artificial ordering operator. |
|
106 | 100 |
/// |
107 |
/// \note This operator only have to define some strict ordering of |
|
108 |
/// the items; this order has nothing to do with the iteration |
|
109 |
/// ordering of |
|
101 |
/// \note This operator only has to define some strict ordering of |
|
102 |
/// the nodes; this order has nothing to do with the iteration |
|
103 |
/// ordering of the nodes. |
|
110 | 104 |
bool operator<(Node) const { return false; } |
111 |
|
|
112 | 105 |
}; |
113 | 106 |
|
114 |
/// |
|
107 |
/// Iterator class for the nodes. |
|
115 | 108 |
|
116 |
/// This iterator goes through each node. |
|
117 |
/// Its usage is quite simple, for example you can count the number |
|
118 |
/// |
|
109 |
/// This iterator goes through each node of the digraph. |
|
110 |
/// Its usage is quite simple, for example, you can count the number |
|
111 |
/// of nodes in a digraph \c g of type \c %Digraph like this: |
|
119 | 112 |
///\code |
120 | 113 |
/// int count=0; |
121 | 114 |
/// for (Digraph::NodeIt n(g); n!=INVALID; ++n) ++count; |
122 | 115 |
///\endcode |
123 | 116 |
class NodeIt : public Node { |
124 | 117 |
public: |
125 | 118 |
/// Default constructor |
126 | 119 |
|
127 |
/// @warning The default constructor sets the iterator |
|
128 |
/// to an undefined value. |
|
120 |
/// Default constructor. |
|
121 |
/// \warning It sets the iterator to an undefined value. |
|
129 | 122 |
NodeIt() { } |
130 | 123 |
/// Copy constructor. |
131 | 124 |
|
132 | 125 |
/// Copy constructor. |
133 | 126 |
/// |
134 | 127 |
NodeIt(const NodeIt& n) : Node(n) { } |
135 |
/// Invalid constructor \& conversion. |
|
128 |
/// %Invalid constructor \& conversion. |
|
136 | 129 |
|
137 |
/// |
|
130 |
/// Initializes the iterator to be invalid. |
|
138 | 131 |
/// \sa Invalid for more details. |
139 | 132 |
NodeIt(Invalid) { } |
140 | 133 |
/// Sets the iterator to the first node. |
141 | 134 |
|
142 |
/// Sets the iterator to the first node of |
|
135 |
/// Sets the iterator to the first node of the given digraph. |
|
143 | 136 |
/// |
144 |
NodeIt(const Digraph&) { } |
|
145 |
/// Node -> NodeIt conversion. |
|
137 |
explicit NodeIt(const Digraph&) { } |
|
138 |
/// Sets the iterator to the given node. |
|
146 | 139 |
|
147 |
/// Sets the iterator to the node of \c the digraph pointed by |
|
148 |
/// the trivial iterator. |
|
149 |
/// This feature necessitates that each time we |
|
150 |
/// iterate the arc-set, the iteration order is the same. |
|
140 |
/// Sets the iterator to the given node of the given digraph. |
|
141 |
/// |
|
151 | 142 |
NodeIt(const Digraph&, const Node&) { } |
152 | 143 |
/// Next node. |
153 | 144 |
|
154 | 145 |
/// Assign the iterator to the next node. |
155 | 146 |
/// |
156 | 147 |
NodeIt& operator++() { return *this; } |
157 | 148 |
}; |
158 | 149 |
|
159 | 150 |
|
160 |
/// |
|
151 |
/// The arc type of the digraph |
|
161 | 152 |
|
162 | 153 |
/// This class identifies an arc of the digraph. It also serves |
163 | 154 |
/// as a base class of the arc iterators, |
164 | 155 |
/// thus they will convert to this type. |
165 | 156 |
class Arc { |
166 | 157 |
public: |
167 | 158 |
/// Default constructor |
168 | 159 |
|
169 |
/// @warning The default constructor sets the iterator |
|
170 |
/// to an undefined value. |
|
160 |
/// Default constructor. |
|
161 |
/// \warning It sets the object to an undefined value. |
|
171 | 162 |
Arc() { } |
172 | 163 |
/// Copy constructor. |
173 | 164 |
|
174 | 165 |
/// Copy constructor. |
175 | 166 |
/// |
176 | 167 |
Arc(const Arc&) { } |
177 |
/// |
|
168 |
/// %Invalid constructor \& conversion. |
|
178 | 169 |
|
179 |
/// Initialize the iterator to be invalid. |
|
180 |
/// |
|
170 |
/// Initializes the object to be invalid. |
|
171 |
/// \sa Invalid for more details. |
|
181 | 172 |
Arc(Invalid) { } |
182 | 173 |
/// Equality operator |
183 | 174 |
|
175 |
/// Equality operator. |
|
176 |
/// |
|
184 | 177 |
/// Two iterators are equal if and only if they point to the |
185 |
/// same object or both are |
|
178 |
/// same object or both are \c INVALID. |
|
186 | 179 |
bool operator==(Arc) const { return true; } |
187 | 180 |
/// Inequality operator |
188 | 181 |
|
189 |
/// \sa operator==(Arc n) |
|
190 |
/// |
|
182 |
/// Inequality operator. |
|
191 | 183 |
bool operator!=(Arc) const { return true; } |
192 | 184 |
|
193 | 185 |
/// Artificial ordering operator. |
194 | 186 |
|
195 |
/// To allow the use of digraph descriptors as key type in std::map or |
|
196 |
/// similar associative container we require this. |
|
187 |
/// Artificial ordering operator. |
|
197 | 188 |
/// |
198 |
/// \note This operator only have to define some strict ordering of |
|
199 |
/// the items; this order has nothing to do with the iteration |
|
200 |
/// ordering of |
|
189 |
/// \note This operator only has to define some strict ordering of |
|
190 |
/// the arcs; this order has nothing to do with the iteration |
|
191 |
/// ordering of the arcs. |
|
201 | 192 |
bool operator<(Arc) const { return false; } |
202 | 193 |
}; |
203 | 194 |
|
204 |
/// |
|
195 |
/// Iterator class for the outgoing arcs of a node. |
|
205 | 196 |
|
206 | 197 |
/// This iterator goes trough the \e outgoing arcs of a certain node |
207 | 198 |
/// of a digraph. |
208 |
/// Its usage is quite simple, for example you can count the number |
|
199 |
/// Its usage is quite simple, for example, you can count the number |
|
209 | 200 |
/// of outgoing arcs of a node \c n |
210 |
/// in digraph \c g of type \c Digraph as follows. |
|
201 |
/// in a digraph \c g of type \c %Digraph as follows. |
|
211 | 202 |
///\code |
212 | 203 |
/// int count=0; |
213 |
/// for (Digraph::OutArcIt |
|
204 |
/// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; |
|
214 | 205 |
///\endcode |
215 |
|
|
216 | 206 |
class OutArcIt : public Arc { |
217 | 207 |
public: |
218 | 208 |
/// Default constructor |
219 | 209 |
|
220 |
/// @warning The default constructor sets the iterator |
|
221 |
/// to an undefined value. |
|
210 |
/// Default constructor. |
|
211 |
/// \warning It sets the iterator to an undefined value. |
|
222 | 212 |
OutArcIt() { } |
223 | 213 |
/// Copy constructor. |
224 | 214 |
|
225 | 215 |
/// Copy constructor. |
226 | 216 |
/// |
227 | 217 |
OutArcIt(const OutArcIt& e) : Arc(e) { } |
228 |
/// |
|
218 |
/// %Invalid constructor \& conversion. |
|
229 | 219 |
|
230 |
/// |
|
220 |
/// Initializes the iterator to be invalid. |
|
221 |
/// \sa Invalid for more details. |
|
222 |
OutArcIt(Invalid) { } |
|
223 |
/// Sets the iterator to the first outgoing arc. |
|
224 |
|
|
225 |
/// Sets the iterator to the first outgoing arc of the given node. |
|
231 | 226 |
/// |
232 |
OutArcIt(Invalid) { } |
|
233 |
/// This constructor sets the iterator to the first outgoing arc. |
|
227 |
OutArcIt(const Digraph&, const Node&) { } |
|
228 |
/// Sets the iterator to the given arc. |
|
234 | 229 |
|
235 |
/// This constructor sets the iterator to the first outgoing arc of |
|
236 |
/// the node. |
|
237 |
OutArcIt(const Digraph&, const Node&) { } |
|
238 |
/// Arc -> OutArcIt conversion |
|
239 |
|
|
240 |
/// Sets the iterator to the value of the trivial iterator. |
|
241 |
/// This feature necessitates that each time we |
|
242 |
/// iterate the arc-set, the iteration order is the same. |
|
230 |
/// Sets the iterator to the given arc of the given digraph. |
|
231 |
/// |
|
243 | 232 |
OutArcIt(const Digraph&, const Arc&) { } |
244 |
///Next outgoing arc |
|
233 |
/// Next outgoing arc |
|
245 | 234 |
|
246 | 235 |
/// Assign the iterator to the next |
247 | 236 |
/// outgoing arc of the corresponding node. |
248 | 237 |
OutArcIt& operator++() { return *this; } |
249 | 238 |
}; |
250 | 239 |
|
251 |
/// |
|
240 |
/// Iterator class for the incoming arcs of a node. |
|
252 | 241 |
|
253 | 242 |
/// This iterator goes trough the \e incoming arcs of a certain node |
254 | 243 |
/// of a digraph. |
255 |
/// Its usage is quite simple, for example you can count the number |
|
256 |
/// of outgoing arcs of a node \c n |
|
257 |
/// |
|
244 |
/// Its usage is quite simple, for example, you can count the number |
|
245 |
/// of incoming arcs of a node \c n |
|
246 |
/// in a digraph \c g of type \c %Digraph as follows. |
|
258 | 247 |
///\code |
259 | 248 |
/// int count=0; |
260 |
/// for(Digraph::InArcIt |
|
249 |
/// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; |
|
261 | 250 |
///\endcode |
262 |
|
|
263 | 251 |
class InArcIt : public Arc { |
264 | 252 |
public: |
265 | 253 |
/// Default constructor |
266 | 254 |
|
267 |
/// @warning The default constructor sets the iterator |
|
268 |
/// to an undefined value. |
|
255 |
/// Default constructor. |
|
256 |
/// \warning It sets the iterator to an undefined value. |
|
269 | 257 |
InArcIt() { } |
270 | 258 |
/// Copy constructor. |
271 | 259 |
|
272 | 260 |
/// Copy constructor. |
273 | 261 |
/// |
274 | 262 |
InArcIt(const InArcIt& e) : Arc(e) { } |
275 |
/// |
|
263 |
/// %Invalid constructor \& conversion. |
|
276 | 264 |
|
277 |
/// |
|
265 |
/// Initializes the iterator to be invalid. |
|
266 |
/// \sa Invalid for more details. |
|
267 |
InArcIt(Invalid) { } |
|
268 |
/// Sets the iterator to the first incoming arc. |
|
269 |
|
|
270 |
/// Sets the iterator to the first incoming arc of the given node. |
|
278 | 271 |
/// |
279 |
InArcIt(Invalid) { } |
|
280 |
/// This constructor sets the iterator to first incoming arc. |
|
272 |
InArcIt(const Digraph&, const Node&) { } |
|
273 |
/// Sets the iterator to the given arc. |
|
281 | 274 |
|
282 |
/// This constructor set the iterator to the first incoming arc of |
|
283 |
/// the node. |
|
284 |
InArcIt(const Digraph&, const Node&) { } |
|
285 |
/// Arc -> InArcIt conversion |
|
286 |
|
|
287 |
/// Sets the iterator to the value of the trivial iterator \c e. |
|
288 |
/// This feature necessitates that each time we |
|
289 |
/// iterate the arc-set, the iteration order is the same. |
|
275 |
/// Sets the iterator to the given arc of the given digraph. |
|
276 |
/// |
|
290 | 277 |
InArcIt(const Digraph&, const Arc&) { } |
291 | 278 |
/// Next incoming arc |
292 | 279 |
|
293 |
/// Assign the iterator to the next inarc of the corresponding node. |
|
294 |
/// |
|
280 |
/// Assign the iterator to the next |
|
281 |
/// incoming arc of the corresponding node. |
|
295 | 282 |
InArcIt& operator++() { return *this; } |
296 | 283 |
}; |
297 |
/// This iterator goes through each arc. |
|
298 | 284 |
|
299 |
/// This iterator goes through each arc of a digraph. |
|
300 |
/// Its usage is quite simple, for example you can count the number |
|
301 |
/// |
|
285 |
/// Iterator class for the arcs. |
|
286 |
|
|
287 |
/// This iterator goes through each arc of the digraph. |
|
288 |
/// Its usage is quite simple, for example, you can count the number |
|
289 |
/// of arcs in a digraph \c g of type \c %Digraph as follows: |
|
302 | 290 |
///\code |
303 | 291 |
/// int count=0; |
304 |
/// for(Digraph::ArcIt |
|
292 |
/// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count; |
|
305 | 293 |
///\endcode |
306 | 294 |
class ArcIt : public Arc { |
307 | 295 |
public: |
308 | 296 |
/// Default constructor |
309 | 297 |
|
310 |
/// @warning The default constructor sets the iterator |
|
311 |
/// to an undefined value. |
|
298 |
/// Default constructor. |
|
299 |
/// \warning It sets the iterator to an undefined value. |
|
312 | 300 |
ArcIt() { } |
313 | 301 |
/// Copy constructor. |
314 | 302 |
|
315 | 303 |
/// Copy constructor. |
316 | 304 |
/// |
317 | 305 |
ArcIt(const ArcIt& e) : Arc(e) { } |
318 |
/// |
|
306 |
/// %Invalid constructor \& conversion. |
|
319 | 307 |
|
320 |
/// |
|
308 |
/// Initializes the iterator to be invalid. |
|
309 |
/// \sa Invalid for more details. |
|
310 |
ArcIt(Invalid) { } |
|
311 |
/// Sets the iterator to the first arc. |
|
312 |
|
|
313 |
/// Sets the iterator to the first arc of the given digraph. |
|
321 | 314 |
/// |
322 |
ArcIt(Invalid) { } |
|
323 |
/// This constructor sets the iterator to the first arc. |
|
315 |
explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } |
|
316 |
/// Sets the iterator to the given arc. |
|
324 | 317 |
|
325 |
/// This constructor sets the iterator to the first arc of \c g. |
|
326 |
///@param g the digraph |
|
327 |
ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } |
|
328 |
/// Arc -> ArcIt conversion |
|
329 |
|
|
330 |
/// Sets the iterator to the value of the trivial iterator \c e. |
|
331 |
/// This feature necessitates that each time we |
|
332 |
/// iterate the arc-set, the iteration order is the same. |
|
318 |
/// Sets the iterator to the given arc of the given digraph. |
|
319 |
/// |
|
333 | 320 |
ArcIt(const Digraph&, const Arc&) { } |
334 |
///Next arc |
|
321 |
/// Next arc |
|
335 | 322 |
|
336 | 323 |
/// Assign the iterator to the next arc. |
324 |
/// |
|
337 | 325 |
ArcIt& operator++() { return *this; } |
338 | 326 |
}; |
339 |
///Gives back the target node of an arc. |
|
340 | 327 |
|
341 |
/// |
|
328 |
/// \brief The source node of the arc. |
|
342 | 329 |
/// |
343 |
Node target(Arc) const { return INVALID; } |
|
344 |
///Gives back the source node of an arc. |
|
345 |
|
|
346 |
///Gives back the source node of an arc. |
|
347 |
/// |
|
330 |
/// Returns the source node of the given arc. |
|
348 | 331 |
Node source(Arc) const { return INVALID; } |
349 | 332 |
|
350 |
/// \brief |
|
333 |
/// \brief The target node of the arc. |
|
334 |
/// |
|
335 |
/// Returns the target node of the given arc. |
|
336 |
Node target(Arc) const { return INVALID; } |
|
337 |
|
|
338 |
/// \brief The ID of the node. |
|
339 |
/// |
|
340 |
/// Returns the ID of the given node. |
|
351 | 341 |
int id(Node) const { return -1; } |
352 | 342 |
|
353 |
/// \brief |
|
343 |
/// \brief The ID of the arc. |
|
344 |
/// |
|
345 |
/// Returns the ID of the given arc. |
|
354 | 346 |
int id(Arc) const { return -1; } |
355 | 347 |
|
356 |
/// \brief |
|
348 |
/// \brief The node with the given ID. |
|
357 | 349 |
/// |
358 |
/// |
|
350 |
/// Returns the node with the given ID. |
|
351 |
/// \pre The argument should be a valid node ID in the digraph. |
|
359 | 352 |
Node nodeFromId(int) const { return INVALID; } |
360 | 353 |
|
361 |
/// \brief |
|
354 |
/// \brief The arc with the given ID. |
|
362 | 355 |
/// |
363 |
/// |
|
356 |
/// Returns the arc with the given ID. |
|
357 |
/// \pre The argument should be a valid arc ID in the digraph. |
|
364 | 358 |
Arc arcFromId(int) const { return INVALID; } |
365 | 359 |
|
366 |
/// \brief |
|
360 |
/// \brief An upper bound on the node IDs. |
|
361 |
/// |
|
362 |
/// Returns an upper bound on the node IDs. |
|
367 | 363 |
int maxNodeId() const { return -1; } |
368 | 364 |
|
369 |
/// \brief |
|
365 |
/// \brief An upper bound on the arc IDs. |
|
366 |
/// |
|
367 |
/// Returns an upper bound on the arc IDs. |
|
370 | 368 |
int maxArcId() const { return -1; } |
371 | 369 |
|
372 | 370 |
void first(Node&) const {} |
373 | 371 |
void next(Node&) const {} |
374 | 372 |
|
375 | 373 |
void first(Arc&) const {} |
... | ... |
@@ -389,51 +387,52 @@ |
389 | 387 |
|
390 | 388 |
// Dummy parameter. |
391 | 389 |
int maxId(Node) const { return -1; } |
392 | 390 |
// Dummy parameter. |
393 | 391 |
int maxId(Arc) const { return -1; } |
394 | 392 |
|
393 |
/// \brief The opposite node on the arc. |
|
394 |
/// |
|
395 |
/// Returns the opposite node on the given arc. |
|
396 |
Node oppositeNode(Node, Arc) const { return INVALID; } |
|
397 |
|
|
395 | 398 |
/// \brief The base node of the iterator. |
396 | 399 |
/// |
397 |
/// Gives back the base node of the iterator. |
|
398 |
/// It is always the target of the pointed arc. |
|
399 |
|
|
400 |
/// Returns the base node of the given outgoing arc iterator |
|
401 |
/// (i.e. the source node of the corresponding arc). |
|
402 |
Node baseNode(OutArcIt) const { return INVALID; } |
|
400 | 403 |
|
401 | 404 |
/// \brief The running node of the iterator. |
402 | 405 |
/// |
403 |
/// Gives back the running node of the iterator. |
|
404 |
/// It is always the source of the pointed arc. |
|
405 |
|
|
406 |
/// Returns the running node of the given outgoing arc iterator |
|
407 |
/// (i.e. the target node of the corresponding arc). |
|
408 |
Node runningNode(OutArcIt) const { return INVALID; } |
|
406 | 409 |
|
407 | 410 |
/// \brief The base node of the iterator. |
408 | 411 |
/// |
409 |
/// Gives back the base node of the iterator. |
|
410 |
/// It is always the source of the pointed arc. |
|
411 |
|
|
412 |
/// Returns the base node of the given incomming arc iterator |
|
413 |
/// (i.e. the target node of the corresponding arc). |
|
414 |
Node baseNode(InArcIt) const { return INVALID; } |
|
412 | 415 |
|
413 | 416 |
/// \brief The running node of the iterator. |
414 | 417 |
/// |
415 |
/// Gives back the running node of the iterator. |
|
416 |
/// It is always the target of the pointed arc. |
|
417 |
|
|
418 |
/// Returns the running node of the given incomming arc iterator |
|
419 |
/// (i.e. the source node of the corresponding arc). |
|
420 |
Node runningNode(InArcIt) const { return INVALID; } |
|
418 | 421 |
|
419 |
/// \brief |
|
422 |
/// \brief Standard graph map type for the nodes. |
|
420 | 423 |
/// |
421 |
/// Gives back the opposite node on the given arc. |
|
422 |
Node oppositeNode(const Node&, const Arc&) const { return INVALID; } |
|
423 |
|
|
424 |
/// \brief Reference map of the nodes to type \c T. |
|
425 |
/// |
|
426 |
/// Reference map of the nodes to type \c T. |
|
424 |
/// Standard graph map type for the nodes. |
|
425 |
/// It conforms to the ReferenceMap concept. |
|
427 | 426 |
template<class T> |
428 | 427 |
class NodeMap : public ReferenceMap<Node, T, T&, const T&> { |
429 | 428 |
public: |
430 | 429 |
|
431 |
///\e |
|
432 |
NodeMap(const Digraph&) { } |
|
433 |
/// |
|
430 |
/// Constructor |
|
431 |
explicit NodeMap(const Digraph&) { } |
|
432 |
/// Constructor with given initial value |
|
434 | 433 |
NodeMap(const Digraph&, T) { } |
435 | 434 |
|
436 | 435 |
private: |
437 | 436 |
///Copy constructor |
438 | 437 |
NodeMap(const NodeMap& nm) : |
439 | 438 |
ReferenceMap<Node, T, T&, const T&>(nm) { } |
... | ... |
@@ -442,23 +441,25 @@ |
442 | 441 |
NodeMap& operator=(const CMap&) { |
443 | 442 |
checkConcept<ReadMap<Node, T>, CMap>(); |
444 | 443 |
return *this; |
445 | 444 |
} |
446 | 445 |
}; |
447 | 446 |
|
448 |
/// \brief |
|
447 |
/// \brief Standard graph map type for the arcs. |
|
449 | 448 |
/// |
450 |
/// |
|
449 |
/// Standard graph map type for the arcs. |
|
450 |
/// It conforms to the ReferenceMap concept. |
|
451 | 451 |
template<class T> |
452 | 452 |
class ArcMap : public ReferenceMap<Arc, T, T&, const T&> { |
453 | 453 |
public: |
454 | 454 |
|
455 |
///\e |
|
456 |
ArcMap(const Digraph&) { } |
|
457 |
/// |
|
455 |
/// Constructor |
|
456 |
explicit ArcMap(const Digraph&) { } |
|
457 |
/// Constructor with given initial value |
|
458 | 458 |
ArcMap(const Digraph&, T) { } |
459 |
|
|
459 | 460 |
private: |
460 | 461 |
///Copy constructor |
461 | 462 |
ArcMap(const ArcMap& em) : |
462 | 463 |
ReferenceMap<Arc, T, T&, const T&>(em) { } |
463 | 464 |
///Assignment operator |
464 | 465 |
template <typename CMap> |
... | ... |
@@ -15,504 +15,511 @@ |
15 | 15 |
* purpose. |
16 | 16 |
* |
17 | 17 |
*/ |
18 | 18 |
|
19 | 19 |
///\ingroup graph_concepts |
20 | 20 |
///\file |
21 |
///\brief The concept of |
|
21 |
///\brief The concept of undirected graphs. |
|
22 | 22 |
|
23 | 23 |
#ifndef LEMON_CONCEPTS_GRAPH_H |
24 | 24 |
#define LEMON_CONCEPTS_GRAPH_H |
25 | 25 |
|
26 | 26 |
#include <lemon/concepts/graph_components.h> |
27 |
#include <lemon/concepts/maps.h> |
|
28 |
#include <lemon/concept_check.h> |
|
27 | 29 |
#include <lemon/core.h> |
28 | 30 |
|
29 | 31 |
namespace lemon { |
30 | 32 |
namespace concepts { |
31 | 33 |
|
32 | 34 |
/// \ingroup graph_concepts |
33 | 35 |
/// |
34 |
/// \brief Class describing the concept of |
|
36 |
/// \brief Class describing the concept of undirected graphs. |
|
35 | 37 |
/// |
36 |
/// This class describes the common interface of all Undirected |
|
37 |
/// Graphs. |
|
38 |
/// This class describes the common interface of all undirected |
|
39 |
/// graphs. |
|
38 | 40 |
/// |
39 |
/// As all concept describing classes it provides only interface |
|
40 |
/// without any sensible implementation. So any algorithm for |
|
41 |
/// |
|
41 |
/// Like all concept classes, it only provides an interface |
|
42 |
/// without any sensible implementation. So any general algorithm for |
|
43 |
/// undirected graphs should compile with this class, but it will not |
|
42 | 44 |
/// run properly, of course. |
45 |
/// An actual graph implementation like \ref ListGraph or |
|
46 |
/// \ref SmartGraph may have additional functionality. |
|
43 | 47 |
/// |
44 |
/// The LEMON undirected graphs also fulfill the concept of |
|
45 |
/// directed graphs (\ref lemon::concepts::Digraph "Digraph |
|
46 |
/// Concept"). Each edges can be seen as two opposite |
|
47 |
/// directed arc and consequently the undirected graph can be |
|
48 |
/// seen as the direceted graph of these directed arcs. The |
|
49 |
/// Graph has the Edge inner class for the edges and |
|
50 |
/// the Arc type for the directed arcs. The Arc type is |
|
51 |
/// convertible to Edge or inherited from it so from a directed |
|
52 |
/// |
|
48 |
/// The undirected graphs also fulfill the concept of \ref Digraph |
|
49 |
/// "directed graphs", since each edge can also be regarded as two |
|
50 |
/// oppositely directed arcs. |
|
51 |
/// Undirected graphs provide an Edge type for the undirected edges and |
|
52 |
/// an Arc type for the directed arcs. The Arc type is convertible to |
|
53 |
/// Edge or inherited from it, i.e. the corresponding edge can be |
|
54 |
/// obtained from an arc. |
|
55 |
/// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt |
|
56 |
/// and ArcMap classes can be used for the arcs (just like in digraphs). |
|
57 |
/// Both InArcIt and OutArcIt iterates on the same edges but with |
|
58 |
/// opposite direction. IncEdgeIt also iterates on the same edges |
|
59 |
/// as OutArcIt and InArcIt, but it is not convertible to Arc, |
|
60 |
/// only to Edge. |
|
53 | 61 |
/// |
54 |
/// In the sense of the LEMON each edge has a default |
|
55 |
/// direction (it should be in every computer implementation, |
|
56 |
/// because the order of edge's nodes defines an |
|
57 |
/// orientation). With the default orientation we can define that |
|
58 |
/// the directed arc is forward or backward directed. With the \c |
|
59 |
/// direction() and \c direct() function we can get the direction |
|
60 |
/// |
|
62 |
/// In LEMON, each undirected edge has an inherent orientation. |
|
63 |
/// Thus it can defined if an arc is forward or backward oriented in |
|
64 |
/// an undirected graph with respect to this default oriantation of |
|
65 |
/// the represented edge. |
|
66 |
/// With the direction() and direct() functions the direction |
|
67 |
/// of an arc can be obtained and set, respectively. |
|
61 | 68 |
/// |
62 |
/// The EdgeIt is an iterator for the edges. We can use |
|
63 |
/// the EdgeMap to map values for the edges. The InArcIt and |
|
64 |
/// OutArcIt iterates on the same edges but with opposite |
|
65 |
/// direction. The IncEdgeIt iterates also on the same edges |
|
66 |
/// as the OutArcIt and InArcIt but it is not convertible to Arc just |
|
67 |
/// to Edge. |
|
69 |
/// Only nodes and edges can be added to or removed from an undirected |
|
70 |
/// graph and the corresponding arcs are added or removed automatically. |
|
71 |
/// |
|
72 |
/// \sa Digraph |
|
68 | 73 |
class Graph { |
74 |
private: |
|
75 |
/// Graphs are \e not copy constructible. Use DigraphCopy instead. |
|
76 |
Graph(const Graph&) {} |
|
77 |
/// \brief Assignment of a graph to another one is \e not allowed. |
|
78 |
/// Use DigraphCopy instead. |
|
79 |
void operator=(const Graph&) {} |
|
80 |
|
|
69 | 81 |
public: |
70 |
/// \brief The undirected graph should be tagged by the |
|
71 |
/// UndirectedTag. |
|
82 |
/// Default constructor. |
|
83 |
Graph() {} |
|
84 |
|
|
85 |
/// \brief Undirected graphs should be tagged with \c UndirectedTag. |
|
72 | 86 |
/// |
73 |
/// The undirected graph should be tagged by the UndirectedTag. This |
|
74 |
/// tag helps the enable_if technics to make compile time |
|
87 |
/// Undirected graphs should be tagged with \c UndirectedTag. |
|
88 |
/// |
|
89 |
/// This tag helps the \c enable_if technics to make compile time |
|
75 | 90 |
/// specializations for undirected graphs. |
76 | 91 |
typedef True UndirectedTag; |
77 | 92 |
|
78 |
/// \brief The base type of node iterators, |
|
79 |
/// or in other words, the trivial node iterator. |
|
80 |
/// |
|
81 |
/// This is the base type of each node iterator, |
|
82 |
/// thus each kind of node iterator converts to this. |
|
83 |
/// More precisely each kind of node iterator should be inherited |
|
84 |
/// |
|
93 |
/// The node type of the graph |
|
94 |
|
|
95 |
/// This class identifies a node of the graph. It also serves |
|
96 |
/// as a base class of the node iterators, |
|
97 |
/// thus they convert to this type. |
|
85 | 98 |
class Node { |
86 | 99 |
public: |
87 | 100 |
/// Default constructor |
88 | 101 |
|
89 |
/// @warning The default constructor sets the iterator |
|
90 |
/// to an undefined value. |
|
102 |
/// Default constructor. |
|
103 |
/// \warning It sets the object to an undefined value. |
|
91 | 104 |
Node() { } |
92 | 105 |
/// Copy constructor. |
93 | 106 |
|
94 | 107 |
/// Copy constructor. |
95 | 108 |
/// |
96 | 109 |
Node(const Node&) { } |
97 | 110 |
|
98 |
/// Invalid constructor \& conversion. |
|
111 |
/// %Invalid constructor \& conversion. |
|
99 | 112 |
|
100 |
/// |
|
113 |
/// Initializes the object to be invalid. |
|
101 | 114 |
/// \sa Invalid for more details. |
102 | 115 |
Node(Invalid) { } |
103 | 116 |
/// Equality operator |
104 | 117 |
|
118 |
/// Equality operator. |
|
119 |
/// |
|
105 | 120 |
/// Two iterators are equal if and only if they point to the |
106 |
/// same object or both are |
|
121 |
/// same object or both are \c INVALID. |
|
107 | 122 |
bool operator==(Node) const { return true; } |
108 | 123 |
|
109 | 124 |
/// Inequality operator |
110 | 125 |
|
111 |
/// \sa operator==(Node n) |
|
112 |
/// |
|
126 |
/// Inequality operator. |
|
113 | 127 |
bool operator!=(Node) const { return true; } |
114 | 128 |
|
115 | 129 |
/// Artificial ordering operator. |
116 | 130 |
|
117 |
/// To allow the use of graph descriptors as key type in std::map or |
|
118 |
/// similar associative container we require this. |
|
131 |
/// Artificial ordering operator. |
|
119 | 132 |
/// |
120 |
/// \note This operator only |
|
133 |
/// \note This operator only has to define some strict ordering of |
|
121 | 134 |
/// the items; this order has nothing to do with the iteration |
122 | 135 |
/// ordering of the items. |
123 | 136 |
bool operator<(Node) const { return false; } |
124 | 137 |
|
125 | 138 |
}; |
126 | 139 |
|
127 |
/// |
|
140 |
/// Iterator class for the nodes. |
|
128 | 141 |
|
129 |
/// This iterator goes through each node. |
|
130 |
/// Its usage is quite simple, for example you can count the number |
|
131 |
/// |
|
142 |
/// This iterator goes through each node of the graph. |
|
143 |
/// Its usage is quite simple, for example, you can count the number |
|
144 |
/// of nodes in a graph \c g of type \c %Graph like this: |
|
132 | 145 |
///\code |
133 | 146 |
/// int count=0; |
134 | 147 |
/// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count; |
135 | 148 |
///\endcode |
136 | 149 |
class NodeIt : public Node { |
137 | 150 |
public: |
138 | 151 |
/// Default constructor |
139 | 152 |
|
140 |
/// @warning The default constructor sets the iterator |
|
141 |
/// to an undefined value. |
|
153 |
/// Default constructor. |
|
154 |
/// \warning It sets the iterator to an undefined value. |
|
142 | 155 |
NodeIt() { } |
143 | 156 |
/// Copy constructor. |
144 | 157 |
|
145 | 158 |
/// Copy constructor. |
146 | 159 |
/// |
147 | 160 |
NodeIt(const NodeIt& n) : Node(n) { } |
148 |
/// Invalid constructor \& conversion. |
|
161 |
/// %Invalid constructor \& conversion. |
|
149 | 162 |
|
150 |
/// |
|
163 |
/// Initializes the iterator to be invalid. |
|
151 | 164 |
/// \sa Invalid for more details. |
152 | 165 |
NodeIt(Invalid) { } |
153 | 166 |
/// Sets the iterator to the first node. |
154 | 167 |
|
155 |
/// Sets the iterator to the first node of |
|
168 |
/// Sets the iterator to the first node of the given digraph. |
|
156 | 169 |
/// |
157 |
NodeIt(const Graph&) { } |
|
158 |
/// Node -> NodeIt conversion. |
|
170 |
explicit NodeIt(const Graph&) { } |
|
171 |
/// Sets the iterator to the given node. |
|
159 | 172 |
|
160 |
/// Sets the iterator to the node of \c the graph pointed by |
|
161 |
/// the trivial iterator. |
|
162 |
/// This feature necessitates that each time we |
|
163 |
/// iterate the arc-set, the iteration order is the same. |
|
173 |
/// Sets the iterator to the given node of the given digraph. |
|
174 |
/// |
|
164 | 175 |
NodeIt(const Graph&, const Node&) { } |
165 | 176 |
/// Next node. |
166 | 177 |
|
167 | 178 |
/// Assign the iterator to the next node. |
168 | 179 |
/// |
169 | 180 |
NodeIt& operator++() { return *this; } |
170 | 181 |
}; |
171 | 182 |
|
172 | 183 |
|
173 |
/// The |
|
184 |
/// The edge type of the graph |
|
174 | 185 |
|
175 |
/// The base type of the edge iterators. |
|
176 |
/// |
|
186 |
/// This class identifies an edge of the graph. It also serves |
|
187 |
/// as a base class of the edge iterators, |
|
188 |
/// thus they will convert to this type. |
|
177 | 189 |
class Edge { |
178 | 190 |
public: |
179 | 191 |
/// Default constructor |
180 | 192 |
|
181 |
/// @warning The default constructor sets the iterator |
|
182 |
/// to an undefined value. |
|
193 |
/// Default constructor. |
|
194 |
/// \warning It sets the object to an undefined value. |
|
183 | 195 |
Edge() { } |
184 | 196 |
/// Copy constructor. |
185 | 197 |
|
186 | 198 |
/// Copy constructor. |
187 | 199 |
/// |
188 | 200 |
Edge(const Edge&) { } |
189 |
/// |
|
201 |
/// %Invalid constructor \& conversion. |
|
190 | 202 |
|
191 |
/// Initialize the iterator to be invalid. |
|
192 |
/// |
|
203 |
/// Initializes the object to be invalid. |
|
204 |
/// \sa Invalid for more details. |
|
193 | 205 |
Edge(Invalid) { } |
194 | 206 |
/// Equality operator |
195 | 207 |
|
208 |
/// Equality operator. |
|
209 |
/// |
|
196 | 210 |
/// Two iterators are equal if and only if they point to the |
197 |
/// same object or both are |
|
211 |
/// same object or both are \c INVALID. |
|
198 | 212 |
bool operator==(Edge) const { return true; } |
199 | 213 |
/// Inequality operator |
200 | 214 |
|
201 |
/// \sa operator==(Edge n) |
|
202 |
/// |
|
215 |
/// Inequality operator. |
|
203 | 216 |
bool operator!=(Edge) const { return true; } |
204 | 217 |
|
205 | 218 |
/// Artificial ordering operator. |
206 | 219 |
|
207 |
/// To allow the use of graph descriptors as key type in std::map or |
|
208 |
/// similar associative container we require this. |
|
220 |
/// Artificial ordering operator. |
|
209 | 221 |
/// |
210 |
/// \note This operator only have to define some strict ordering of |
|
211 |
/// the items; this order has nothing to do with the iteration |
|
212 |
/// ordering of |
|
222 |
/// \note This operator only has to define some strict ordering of |
|
223 |
/// the edges; this order has nothing to do with the iteration |
|
224 |
/// ordering of the edges. |
|
213 | 225 |
bool operator<(Edge) const { return false; } |
214 | 226 |
}; |
215 | 227 |
|
216 |
/// |
|
228 |
/// Iterator class for the edges. |
|
217 | 229 |
|
218 |
/// This iterator goes through each edge of a graph. |
|
219 |
/// Its usage is quite simple, for example you can count the number |
|
220 |
/// |
|
230 |
/// This iterator goes through each edge of the graph. |
|
231 |
/// Its usage is quite simple, for example, you can count the number |
|
232 |
/// of edges in a graph \c g of type \c %Graph as follows: |
|
221 | 233 |
///\code |
222 | 234 |
/// int count=0; |
223 | 235 |
/// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count; |
224 | 236 |
///\endcode |
225 | 237 |
class EdgeIt : public Edge { |
226 | 238 |
public: |
227 | 239 |
/// Default constructor |
228 | 240 |
|
229 |
/// @warning The default constructor sets the iterator |
|
230 |
/// to an undefined value. |
|
241 |
/// Default constructor. |
|
242 |
/// \warning It sets the iterator to an undefined value. |
|
231 | 243 |
EdgeIt() { } |
232 | 244 |
/// Copy constructor. |
233 | 245 |
|
234 | 246 |
/// Copy constructor. |
235 | 247 |
/// |
236 | 248 |
EdgeIt(const EdgeIt& e) : Edge(e) { } |
237 |
/// |
|
249 |
/// %Invalid constructor \& conversion. |
|
238 | 250 |
|
239 |
/// |
|
251 |
/// Initializes the iterator to be invalid. |
|
252 |
/// \sa Invalid for more details. |
|
253 |
EdgeIt(Invalid) { } |
|
254 |
/// Sets the iterator to the first edge. |
|
255 |
|
|
256 |
/// Sets the iterator to the first edge of the given graph. |
|
240 | 257 |
/// |
241 |
EdgeIt(Invalid) { } |
|
242 |
/// This constructor sets the iterator to the first edge. |
|
258 |
explicit EdgeIt(const Graph&) { } |
|
259 |
/// Sets the iterator to the given edge. |
|
243 | 260 |
|
244 |
/// This constructor sets the iterator to the first edge. |
|
245 |
EdgeIt(const Graph&) { } |
|
246 |
/// Edge -> EdgeIt conversion |
|
247 |
|
|
248 |
/// Sets the iterator to the value of the trivial iterator. |
|
249 |
/// This feature necessitates that each time we |
|
250 |
/// iterate the edge-set, the iteration order is the |
|
251 |
/// same. |
|
261 |
/// Sets the iterator to the given edge of the given graph. |
|
262 |
/// |
|
252 | 263 |
EdgeIt(const Graph&, const Edge&) { } |
253 | 264 |
/// Next edge |
254 | 265 |
|
255 | 266 |
/// Assign the iterator to the next edge. |
267 |
/// |
|
256 | 268 |
EdgeIt& operator++() { return *this; } |
257 | 269 |
}; |
258 | 270 |
|
259 |
/// \brief This iterator goes trough the incident undirected |
|
260 |
/// arcs of a node. |
|
261 |
/// |
|
262 |
/// This iterator goes trough the incident edges |
|
263 |
/// of a certain node of a graph. You should assume that the |
|
264 |
/// loop arcs will be iterated twice. |
|
265 |
/// |
|
266 |
/// Its usage is quite simple, for example you can compute the |
|
267 |
/// degree (i.e. count the number of incident arcs of a node \c n |
|
268 |
/// in graph \c g of type \c Graph as follows. |
|
271 |
/// Iterator class for the incident edges of a node. |
|
272 |
|
|
273 |
/// This iterator goes trough the incident undirected edges |
|
274 |
/// of a certain node of a graph. |
|
275 |
/// Its usage is quite simple, for example, you can compute the |
|
276 |
/// degree (i.e. the number of incident edges) of a node \c n |
|
277 |
/// in a graph \c g of type \c %Graph as follows. |
|
269 | 278 |
/// |
270 | 279 |
///\code |
271 | 280 |
/// int count=0; |
272 | 281 |
/// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; |
273 | 282 |
///\endcode |
283 |
/// |
|
284 |
/// \warning Loop edges will be iterated twice. |
|
274 | 285 |
class IncEdgeIt : public Edge { |
275 | 286 |
public: |
276 | 287 |
/// Default constructor |
277 | 288 |
|
278 |
/// @warning The default constructor sets the iterator |
|
279 |
/// to an undefined value. |
|
289 |
/// Default constructor. |
|
290 |
/// \warning It sets the iterator to an undefined value. |
|
280 | 291 |
IncEdgeIt() { } |
281 | 292 |
/// Copy constructor. |
282 | 293 |
|
283 | 294 |
/// Copy constructor. |
284 | 295 |
/// |
285 | 296 |
IncEdgeIt(const IncEdgeIt& e) : Edge(e) { } |
286 |
/// |
|
297 |
/// %Invalid constructor \& conversion. |
|
287 | 298 |
|
288 |
/// |
|
299 |
/// Initializes the iterator to be invalid. |
|
300 |
/// \sa Invalid for more details. |
|
301 |
IncEdgeIt(Invalid) { } |
|
302 |
/// Sets the iterator to the first incident edge. |
|
303 |
|
|
304 |
/// Sets the iterator to the first incident edge of the given node. |
|
289 | 305 |
/// |
290 |
IncEdgeIt(Invalid) { } |
|
291 |
/// This constructor sets the iterator to first incident arc. |
|
306 |
IncEdgeIt(const Graph&, const Node&) { } |
|
307 |
/// Sets the iterator to the given edge. |
|
292 | 308 |
|
293 |
/// This constructor set the iterator to the first incident arc of |
|
294 |
/// the node. |
|
295 |
IncEdgeIt(const Graph&, const Node&) { } |
|
296 |
/// Edge -> IncEdgeIt conversion |
|
309 |
/// Sets the iterator to the given edge of the given graph. |
|
310 |
/// |
|
311 |
IncEdgeIt(const Graph&, const Edge&) { } |
|
312 |
/// Next incident edge |
|
297 | 313 |
|
298 |
/// Sets the iterator to the value of the trivial iterator \c e. |
|
299 |
/// This feature necessitates that each time we |
|
300 |
/// iterate the arc-set, the iteration order is the same. |
|
301 |
IncEdgeIt(const Graph&, const Edge&) { } |
|
302 |
/// Next incident arc |
|
303 |
|
|
304 |
/// Assign the iterator to the next incident |
|
314 |
/// Assign the iterator to the next incident edge |
|
305 | 315 |
/// of the corresponding node. |
306 | 316 |
IncEdgeIt& operator++() { return *this; } |
307 | 317 |
}; |
308 | 318 |
|
309 |
/// The |
|
319 |
/// The arc type of the graph |
|
310 | 320 |
|
311 |
/// The directed arc type. It can be converted to the |
|
312 |
/// edge or it should be inherited from the undirected |
|
313 |
/// |
|
321 |
/// This class identifies a directed arc of the graph. It also serves |
|
322 |
/// as a base class of the arc iterators, |
|
323 |
/// thus they will convert to this type. |
|
314 | 324 |
class Arc { |
315 | 325 |
public: |
316 | 326 |
/// Default constructor |
317 | 327 |
|
318 |
/// @warning The default constructor sets the iterator |
|
319 |
/// to an undefined value. |
|
328 |
/// Default constructor. |
|
329 |
/// \warning It sets the object to an undefined value. |
|
320 | 330 |
Arc() { } |
321 | 331 |
/// Copy constructor. |
322 | 332 |
|
323 | 333 |
/// Copy constructor. |
324 | 334 |
/// |
325 | 335 |
Arc(const Arc&) { } |
326 |
/// |
|
336 |
/// %Invalid constructor \& conversion. |
|
327 | 337 |
|
328 |
/// Initialize the iterator to be invalid. |
|
329 |
/// |
|
338 |
/// Initializes the object to be invalid. |
|
339 |
/// \sa Invalid for more details. |
|
330 | 340 |
Arc(Invalid) { } |
331 | 341 |
/// Equality operator |
332 | 342 |
|
343 |
/// Equality operator. |
|
344 |
/// |
|
333 | 345 |
/// Two iterators are equal if and only if they point to the |
334 |
/// same object or both are |
|
346 |
/// same object or both are \c INVALID. |
|
335 | 347 |
bool operator==(Arc) const { return true; } |
336 | 348 |
/// Inequality operator |
337 | 349 |
|
338 |
/// \sa operator==(Arc n) |
|
339 |
/// |
|
350 |
/// Inequality operator. |
|
340 | 351 |
bool operator!=(Arc) const { return true; } |
341 | 352 |
|
342 | 353 |
/// Artificial ordering operator. |
343 | 354 |
|
344 |
/// To allow the use of graph descriptors as key type in std::map or |
|
345 |
/// similar associative container we require this. |
|
355 |
/// Artificial ordering operator. |
|
346 | 356 |
/// |
347 |
/// \note This operator only have to define some strict ordering of |
|
348 |
/// the items; this order has nothing to do with the iteration |
|
349 |
/// ordering of |
|
357 |
/// \note This operator only has to define some strict ordering of |
|
358 |
/// the arcs; this order has nothing to do with the iteration |
|
359 |
/// ordering of the arcs. |
|
350 | 360 |
bool operator<(Arc) const { return false; } |
351 | 361 |
|
352 |
/// Converison to Edge |
|
362 |
/// Converison to \c Edge |
|
363 |
|
|
364 |
/// Converison to \c Edge. |
|
365 |
/// |
|
353 | 366 |
operator Edge() const { return Edge(); } |
354 | 367 |
}; |
355 |
/// This iterator goes through each directed arc. |
|
356 | 368 |
|
357 |
/// This iterator goes through each arc of a graph. |
|
358 |
/// Its usage is quite simple, for example you can count the number |
|
359 |
/// |
|
369 |
/// Iterator class for the arcs. |
|
370 |
|
|
371 |
/// This iterator goes through each directed arc of the graph. |
|
372 |
/// Its usage is quite simple, for example, you can count the number |
|
373 |
/// of arcs in a graph \c g of type \c %Graph as follows: |
|
360 | 374 |
///\code |
361 | 375 |
/// int count=0; |
362 |
/// for(Graph::ArcIt |
|
376 |
/// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count; |
|
363 | 377 |
///\endcode |
364 | 378 |
class ArcIt : public Arc { |
365 | 379 |
public: |
366 | 380 |
/// Default constructor |
367 | 381 |
|
368 |
/// @warning The default constructor sets the iterator |
|
369 |
/// to an undefined value. |
|
382 |
/// Default constructor. |
|
383 |
/// \warning It sets the iterator to an undefined value. |
|
370 | 384 |
ArcIt() { } |
371 | 385 |
/// Copy constructor. |
372 | 386 |
|
373 | 387 |
/// Copy constructor. |
374 | 388 |
/// |
375 | 389 |
ArcIt(const ArcIt& e) : Arc(e) { } |
376 |
/// |
|
390 |
/// %Invalid constructor \& conversion. |
|
377 | 391 |
|
378 |
/// |
|
392 |
/// Initializes the iterator to be invalid. |
|
393 |
/// \sa Invalid for more details. |
|
394 |
ArcIt(Invalid) { } |
|
395 |
/// Sets the iterator to the first arc. |
|
396 |
|
|
397 |
/// Sets the iterator to the first arc of the given graph. |
|
379 | 398 |
/// |
380 |
ArcIt(Invalid) { } |
|
381 |
/// This constructor sets the iterator to the first arc. |
|
399 |
explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } |
|
400 |
/// Sets the iterator to the given arc. |
|
382 | 401 |
|
383 |
/// This constructor sets the iterator to the first arc of \c g. |
|
384 |
///@param g the graph |
|
385 |
ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } |
|
386 |
/// Arc -> ArcIt conversion |
|
387 |
|
|
388 |
/// Sets the iterator to the value of the trivial iterator \c e. |
|
389 |
/// This feature necessitates that each time we |
|
390 |
/// iterate the arc-set, the iteration order is the same. |
|
402 |
/// Sets the iterator to the given arc of the given graph. |
|
403 |
/// |
|
391 | 404 |
ArcIt(const Graph&, const Arc&) { } |
392 |
///Next arc |
|
405 |
/// Next arc |
|
393 | 406 |
|
394 | 407 |
/// Assign the iterator to the next arc. |
408 |
/// |
|
395 | 409 |
ArcIt& operator++() { return *this; } |
396 | 410 |
}; |
397 | 411 |
|
398 |
/// |
|
412 |
/// Iterator class for the outgoing arcs of a node. |
|
399 | 413 |
|
400 |
/// This iterator goes trough the \e outgoing arcs of a certain node |
|
401 |
/// of a graph. |
|
402 |
/// |
|
414 |
/// This iterator goes trough the \e outgoing directed arcs of a |
|
415 |
/// certain node of a graph. |
|
416 |
/// Its usage is quite simple, for example, you can count the number |
|
403 | 417 |
/// of outgoing arcs of a node \c n |
404 |
/// in graph \c g of type \c Graph as follows. |
|
418 |
/// in a graph \c g of type \c %Graph as follows. |
|
405 | 419 |
///\code |
406 | 420 |
/// int count=0; |
407 |
/// for ( |
|
421 |
/// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; |
|
408 | 422 |
///\endcode |
409 |
|
|
410 | 423 |
class OutArcIt : public Arc { |
411 | 424 |
public: |
412 | 425 |
/// Default constructor |
413 | 426 |
|
414 |
/// @warning The default constructor sets the iterator |
|
415 |
/// to an undefined value. |
|
427 |
/// Default constructor. |
|
428 |
/// \warning It sets the iterator to an undefined value. |
|
416 | 429 |
OutArcIt() { } |
417 | 430 |
/// Copy constructor. |
418 | 431 |
|
419 | 432 |
/// Copy constructor. |
420 | 433 |
/// |
421 | 434 |
OutArcIt(const OutArcIt& e) : Arc(e) { } |
422 |
/// |
|
435 |
/// %Invalid constructor \& conversion. |
|
423 | 436 |
|
424 |
/// |
|
437 |
/// Initializes the iterator to be invalid. |
|
438 |
/// \sa Invalid for more details. |
|
439 |
OutArcIt(Invalid) { } |
|
440 |
/// Sets the iterator to the first outgoing arc. |
|
441 |
|
|
442 |
/// Sets the iterator to the first outgoing arc of the given node. |
|
425 | 443 |
/// |
426 |
OutArcIt(Invalid) { } |
|
427 |
/// This constructor sets the iterator to the first outgoing arc. |
|
428 |
|
|
429 |
/// This constructor sets the iterator to the first outgoing arc of |
|
430 |
/// the node. |
|
431 |
///@param n the node |
|
432 |
///@param g the graph |
|
433 | 444 |
OutArcIt(const Graph& n, const Node& g) { |
434 | 445 |
ignore_unused_variable_warning(n); |
435 | 446 |
ignore_unused_variable_warning(g); |
436 | 447 |
} |
437 |
/// |
|
448 |
/// Sets the iterator to the given arc. |
|
438 | 449 |
|
439 |
/// Sets the iterator to the value of the trivial iterator. |
|
440 |
/// This feature necessitates that each time we |
|
441 |
/// |
|
450 |
/// Sets the iterator to the given arc of the given graph. |
|
451 |
/// |
|
442 | 452 |
OutArcIt(const Graph&, const Arc&) { } |
443 |
///Next outgoing arc |
|
453 |
/// Next outgoing arc |
|
444 | 454 |
|
445 | 455 |
/// Assign the iterator to the next |
446 | 456 |
/// outgoing arc of the corresponding node. |
447 | 457 |
OutArcIt& operator++() { return *this; } |
448 | 458 |
}; |
449 | 459 |
|
450 |
/// |
|
460 |
/// Iterator class for the incoming arcs of a node. |
|
451 | 461 |
|
452 |
/// This iterator goes trough the \e incoming arcs of a certain node |
|
453 |
/// of a graph. |
|
454 |
/// Its usage is quite simple, for example you can count the number |
|
455 |
/// of outgoing arcs of a node \c n |
|
456 |
/// |
|
462 |
/// This iterator goes trough the \e incoming directed arcs of a |
|
463 |
/// certain node of a graph. |
|
464 |
/// Its usage is quite simple, for example, you can count the number |
|
465 |
/// of incoming arcs of a node \c n |
|
466 |
/// in a graph \c g of type \c %Graph as follows. |
|
457 | 467 |
///\code |
458 | 468 |
/// int count=0; |
459 |
/// for( |
|
469 |
/// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; |
|
460 | 470 |
///\endcode |
461 |
|
|
462 | 471 |
class InArcIt : public Arc { |
463 | 472 |
public: |
464 | 473 |
/// Default constructor |
465 | 474 |
|
466 |
/// @warning The default constructor sets the iterator |
|
467 |
/// to an undefined value. |
|
475 |
/// Default constructor. |
|
476 |
/// \warning It sets the iterator to an undefined value. |
|
468 | 477 |
InArcIt() { } |
469 | 478 |
/// Copy constructor. |
470 | 479 |
|
471 | 480 |
/// Copy constructor. |
472 | 481 |
/// |
473 | 482 |
InArcIt(const InArcIt& e) : Arc(e) { } |
474 |
/// |
|
483 |
/// %Invalid constructor \& conversion. |
|
475 | 484 |
|
476 |
/// |
|
485 |
/// Initializes the iterator to be invalid. |
|
486 |
/// \sa Invalid for more details. |
|
487 |
InArcIt(Invalid) { } |
|
488 |
/// Sets the iterator to the first incoming arc. |
|
489 |
|
|
490 |
/// Sets the iterator to the first incoming arc of the given node. |
|
477 | 491 |
/// |
478 |
InArcIt(Invalid) { } |
|
479 |
/// This constructor sets the iterator to first incoming arc. |
|
480 |
|
|
481 |
/// This constructor set the iterator to the first incoming arc of |
|
482 |
/// the node. |
|
483 |
///@param n the node |
|
484 |
///@param g the graph |
|
485 | 492 |
InArcIt(const Graph& g, const Node& n) { |
486 | 493 |
ignore_unused_variable_warning(n); |
487 | 494 |
ignore_unused_variable_warning(g); |
488 | 495 |
} |
489 |
/// |
|
496 |
/// Sets the iterator to the given arc. |
|
490 | 497 |
|
491 |
/// Sets the iterator to the value of the trivial iterator \c e. |
|
492 |
/// This feature necessitates that each time we |
|
493 |
/// |
|
498 |
/// Sets the iterator to the given arc of the given graph. |
|
499 |
/// |
|
494 | 500 |
InArcIt(const Graph&, const Arc&) { } |
495 | 501 |
/// Next incoming arc |
496 | 502 |
|
497 |
/// Assign the iterator to the next inarc of the corresponding node. |
|
498 |
/// |
|
503 |
/// Assign the iterator to the next |
|
504 |
/// incoming arc of the corresponding node. |
|
499 | 505 |
InArcIt& operator++() { return *this; } |
500 | 506 |
}; |
501 | 507 |
|
502 |
/// \brief |
|
508 |
/// \brief Standard graph map type for the nodes. |
|
503 | 509 |
/// |
504 |
/// |
|
510 |
/// Standard graph map type for the nodes. |
|
511 |
/// It conforms to the ReferenceMap concept. |
|
505 | 512 |
template<class T> |
506 | 513 |
class NodeMap : public ReferenceMap<Node, T, T&, const T&> |
507 | 514 |
{ |
508 | 515 |
public: |
509 | 516 |
|
510 |
///\e |
|
511 |
NodeMap(const Graph&) { } |
|
512 |
/// |
|
517 |
/// Constructor |
|
518 |
explicit NodeMap(const Graph&) { } |
|
519 |
/// Constructor with given initial value |
|
513 | 520 |
NodeMap(const Graph&, T) { } |
514 | 521 |
|
515 | 522 |
private: |
516 | 523 |
///Copy constructor |
517 | 524 |
NodeMap(const NodeMap& nm) : |
518 | 525 |
ReferenceMap<Node, T, T&, const T&>(nm) { } |
... | ... |
@@ -521,161 +528,182 @@ |
521 | 528 |
NodeMap& operator=(const CMap&) { |
522 | 529 |
checkConcept<ReadMap<Node, T>, CMap>(); |
523 | 530 |
return *this; |
524 | 531 |
} |
525 | 532 |
}; |
526 | 533 |
|
527 |
/// \brief |
|
534 |
/// \brief Standard graph map type for the arcs. |
|
528 | 535 |
/// |
529 |
/// |
|
536 |
/// Standard graph map type for the arcs. |
|
537 |
/// It conforms to the ReferenceMap concept. |
|
530 | 538 |
template<class T> |
531 | 539 |
class ArcMap : public ReferenceMap<Arc, T, T&, const T&> |
532 | 540 |
{ |
533 | 541 |
public: |
534 | 542 |
|
535 |
///\e |
|
536 |
ArcMap(const Graph&) { } |
|
537 |
/// |
|
543 |
/// Constructor |
|
544 |
explicit ArcMap(const Graph&) { } |
|
545 |
/// Constructor with given initial value |
|
538 | 546 |
ArcMap(const Graph&, T) { } |
547 |
|
|
539 | 548 |
private: |
540 | 549 |
///Copy constructor |
541 | 550 |
ArcMap(const ArcMap& em) : |
542 | 551 |
ReferenceMap<Arc, T, T&, const T&>(em) { } |
543 | 552 |
///Assignment operator |
544 | 553 |
template <typename CMap> |
545 | 554 |
ArcMap& operator=(const CMap&) { |
546 | 555 |
checkConcept<ReadMap<Arc, T>, CMap>(); |
547 | 556 |
return *this; |
548 | 557 |
} |
549 | 558 |
}; |
550 | 559 |
|
551 |
/// Reference map of the edges to type \c T. |
|
552 |
|
|
553 |
/// |
|
560 |
/// \brief Standard graph map type for the edges. |
|
561 |
/// |
|
562 |
/// Standard graph map type for the edges. |
|
563 |
/// It conforms to the ReferenceMap concept. |
|
554 | 564 |
template<class T> |
555 | 565 |
class EdgeMap : public ReferenceMap<Edge, T, T&, const T&> |
556 | 566 |
{ |
557 | 567 |
public: |
558 | 568 |
|
559 |
///\e |
|
560 |
EdgeMap(const Graph&) { } |
|
561 |
/// |
|
569 |
/// Constructor |
|
570 |
explicit EdgeMap(const Graph&) { } |
|
571 |
/// Constructor with given initial value |
|
562 | 572 |
EdgeMap(const Graph&, T) { } |
573 |
|
|
563 | 574 |
private: |
564 | 575 |
///Copy constructor |
565 | 576 |
EdgeMap(const EdgeMap& em) : |
566 | 577 |
ReferenceMap<Edge, T, T&, const T&>(em) {} |
567 | 578 |
///Assignment operator |
568 | 579 |
template <typename CMap> |
569 | 580 |
EdgeMap& operator=(const CMap&) { |
570 | 581 |
checkConcept<ReadMap<Edge, T>, CMap>(); |
571 | 582 |
return *this; |
572 | 583 |
} |
573 | 584 |
}; |
574 | 585 |
|
575 |
/// \brief |
|
586 |
/// \brief The first node of the edge. |
|
576 | 587 |
/// |
577 |
/// Direct the given edge. The returned arc source |
|
578 |
/// will be the given node. |
|
579 |
Arc direct(const Edge&, const Node&) const { |
|
580 |
return INVALID; |
|
581 |
} |
|
582 |
|
|
583 |
/// |
|
588 |
/// Returns the first node of the given edge. |
|
584 | 589 |
/// |
585 |
/// Direct the given edge. The returned arc |
|
586 |
/// represents the given edge and the direction comes |
|
587 |
/// from the bool parameter. The source of the edge and |
|
588 |
/// the directed arc is the same when the given bool is true. |
|
589 |
Arc direct(const Edge&, bool) const { |
|
590 |
return INVALID; |
|
591 |
} |
|
592 |
|
|
593 |
/// \brief Returns true if the arc has default orientation. |
|
594 |
/// |
|
595 |
/// Returns whether the given directed arc is same orientation as |
|
596 |
/// the corresponding edge's default orientation. |
|
597 |
bool direction(Arc) const { return true; } |
|
598 |
|
|
599 |
/// \brief Returns the opposite directed arc. |
|
600 |
/// |
|
601 |
/// Returns the opposite directed arc. |
|
602 |
Arc oppositeArc(Arc) const { return INVALID; } |
|
603 |
|
|
604 |
/// \brief Opposite node on an arc |
|
605 |
/// |
|
606 |
/// \return The opposite of the given node on the given edge. |
|
607 |
Node oppositeNode(Node, Edge) const { return INVALID; } |
|
608 |
|
|
609 |
/// \brief First node of the edge. |
|
610 |
/// |
|
611 |
/// \return The first node of the given edge. |
|
612 |
/// |
|
613 |
/// Naturally edges don't have direction and thus |
|
614 |
/// don't have source and target node. However we use \c u() and \c v() |
|
615 |
/// methods to query the two nodes of the arc. The direction of the |
|
616 |
/// arc which arises this way is called the inherent direction of the |
|
617 |
/// edge, and is used to define the "default" direction |
|
618 |
/// of the directed versions of the arcs. |
|
590 |
/// Edges don't have source and target nodes, however, methods |
|
591 |
/// u() and v() are used to query the two end-nodes of an edge. |
|
592 |
/// The orientation of an edge that arises this way is called |
|
593 |
/// the inherent direction, it is used to define the default |
|
594 |
/// direction for the corresponding arcs. |
|
619 | 595 |
/// \sa v() |
620 | 596 |
/// \sa direction() |
621 | 597 |
Node u(Edge) const { return INVALID; } |
622 | 598 |
|
623 |
/// \brief |
|
599 |
/// \brief The second node of the edge. |
|
624 | 600 |
/// |
625 |
/// |
|
601 |
/// Returns the second node of the given edge. |
|
626 | 602 |
/// |
627 |
/// Naturally edges don't have direction and thus |
|
628 |
/// don't have source and target node. However we use \c u() and \c v() |
|
629 |
/// methods to query the two nodes of the arc. The direction of the |
|
630 |
/// arc which arises this way is called the inherent direction of the |
|
631 |
/// edge, and is used to define the "default" direction |
|
632 |
/// of the directed versions of the arcs. |
|
603 |
/// Edges don't have source and target nodes, however, methods |
|
604 |
/// u() and v() are used to query the two end-nodes of an edge. |
|
605 |
/// The orientation of an edge that arises this way is called |
|
606 |
/// the inherent direction, it is used to define the default |
|
607 |
/// direction for the corresponding arcs. |
|
633 | 608 |
/// \sa u() |
634 | 609 |
/// \sa direction() |
635 | 610 |
Node v(Edge) const { return INVALID; } |
636 | 611 |
|
637 |
/// \brief |
|
612 |
/// \brief The source node of the arc. |
|
613 |
/// |
|
614 |
/// Returns the source node of the given arc. |
|
638 | 615 |
Node source(Arc) const { return INVALID; } |
639 | 616 |
|
640 |
/// \brief |
|
617 |
/// \brief The target node of the arc. |
|
618 |
/// |
|
619 |
/// Returns the target node of the given arc. |
|
641 | 620 |
Node target(Arc) const { return INVALID; } |
642 | 621 |
|
643 |
/// \brief |
|
622 |
/// \brief The ID of the node. |
|
623 |
/// |
|
624 |
/// Returns the ID of the given node. |
|
644 | 625 |
int id(Node) const { return -1; } |
645 | 626 |
|
646 |
/// \brief |
|
627 |
/// \brief The ID of the edge. |
|
628 |
/// |
|
629 |
/// Returns the ID of the given edge. |
|
647 | 630 |
int id(Edge) const { return -1; } |
648 | 631 |
|
649 |
/// \brief |
|
632 |
/// \brief The ID of the arc. |
|
633 |
/// |
|
634 |
/// Returns the ID of the given arc. |
|
650 | 635 |
int id(Arc) const { return -1; } |
651 | 636 |
|
652 |
/// \brief |
|
637 |
/// \brief The node with the given ID. |
|
653 | 638 |
/// |
654 |
/// |
|
639 |
/// Returns the node with the given ID. |
|
640 |
/// \pre The argument should be a valid node ID in the graph. |
|
655 | 641 |
Node nodeFromId(int) const { return INVALID; } |
656 | 642 |
|
657 |
/// \brief |
|
643 |
/// \brief The edge with the given ID. |
|
658 | 644 |
/// |
659 |
/// |
|
645 |
/// Returns the edge with the given ID. |
|
646 |
/// \pre The argument should be a valid edge ID in the graph. |
|
660 | 647 |
Edge edgeFromId(int) const { return INVALID; } |
661 | 648 |
|
662 |
/// \brief |
|
649 |
/// \brief The arc with the given ID. |
|
663 | 650 |
/// |
664 |
/// |
|
651 |
/// Returns the arc with the given ID. |
|
652 |
/// \pre The argument should be a valid arc ID in the graph. |
|
665 | 653 |
Arc arcFromId(int) const { return INVALID; } |
666 | 654 |
|
667 |
/// \brief |
|
655 |
/// \brief An upper bound on the node IDs. |
|
656 |
/// |
|
657 |
/// Returns an upper bound on the node IDs. |
|
668 | 658 |
int maxNodeId() const { return -1; } |
669 | 659 |
|
670 |
/// \brief |
|
660 |
/// \brief An upper bound on the edge IDs. |
|
661 |
/// |
|
662 |
/// Returns an upper bound on the edge IDs. |
|
671 | 663 |
int maxEdgeId() const { return -1; } |
672 | 664 |
|
673 |
/// \brief |
|
665 |
/// \brief An upper bound on the arc IDs. |
|
666 |
/// |
|
667 |
/// Returns an upper bound on the arc IDs. |
|
674 | 668 |
int maxArcId() const { return -1; } |
675 | 669 |
|
670 |
/// \brief The direction of the arc. |
|
671 |
/// |
|
672 |
/// Returns \c true if the direction of the given arc is the same as |
|
673 |
/// the inherent orientation of the represented edge. |
|
674 |
bool direction(Arc) const { return true; } |
|
675 |
|
|
676 |
/// \brief Direct the edge. |
|
677 |
/// |
|
678 |
/// Direct the given edge. The returned arc |
|
679 |
/// represents the given edge and its direction comes |
|
680 |
/// from the bool parameter. If it is \c true, then the direction |
|
681 |
/// of the arc is the same as the inherent orientation of the edge. |
|
682 |
Arc direct(Edge, bool) const { |
|
683 |
return INVALID; |
|
684 |
} |
|
685 |
|
|
686 |
/// \brief Direct the edge. |
|
687 |
/// |
|
688 |
/// Direct the given edge. The returned arc represents the given |
|
689 |
/// edge and its source node is the given node. |
|
690 |
Arc direct(Edge, Node) const { |
|
691 |
return INVALID; |
|
692 |
} |
|
693 |
|
|
694 |
/// \brief The oppositely directed arc. |
|
695 |
/// |
|
696 |
/// Returns the oppositely directed arc representing the same edge. |
|
697 |
Arc oppositeArc(Arc) const { return INVALID; } |
|
698 |
|
|
699 |
/// \brief The opposite node on the edge. |
|
700 |
/// |
|
701 |
/// Returns the opposite node on the given edge. |
|
702 |
Node oppositeNode(Node, Edge) const { return INVALID; } |
|
703 |
|
|
676 | 704 |
void first(Node&) const {} |
677 | 705 |
void next(Node&) const {} |
678 | 706 |
|
679 | 707 |
void first(Edge&) const {} |
680 | 708 |
void next(Edge&) const {} |
681 | 709 |
|
... | ... |
@@ -702,53 +730,45 @@ |
702 | 730 |
int maxId(Node) const { return -1; } |
703 | 731 |
// Dummy parameter. |
704 | 732 |
int maxId(Edge) const { return -1; } |
705 | 733 |
// Dummy parameter. |
706 | 734 |
int maxId(Arc) const { return -1; } |
707 | 735 |
|
708 |
/// \brief |
|
736 |
/// \brief The base node of the iterator. |
|
709 | 737 |
/// |
710 |
/// Returns the base node (the source in this case) of the iterator |
|
711 |
Node baseNode(OutArcIt e) const { |
|
712 |
return source(e); |
|
713 |
} |
|
714 |
/// |
|
738 |
/// Returns the base node of the given incident edge iterator. |
|
739 |
Node baseNode(IncEdgeIt) const { return INVALID; } |
|
740 |
|
|
741 |
/// \brief The running node of the iterator. |
|
715 | 742 |
/// |
716 |
/// Returns the running node (the target in this case) of the |
|
717 |
/// iterator |
|
718 |
Node runningNode(OutArcIt e) const { |
|
719 |
return target(e); |
|
720 |
|
|
743 |
/// Returns the running node of the given incident edge iterator. |
|
744 |
Node runningNode(IncEdgeIt) const { return INVALID; } |
|
721 | 745 |
|
722 |
/// \brief |
|
746 |
/// \brief The base node of the iterator. |
|
723 | 747 |
/// |
724 |
/// Returns the base node (the target in this case) of the iterator |
|
725 |
Node baseNode(InArcIt e) const { |
|
726 |
return target(e); |
|
727 |
} |
|
728 |
/// |
|
748 |
/// Returns the base node of the given outgoing arc iterator |
|
749 |
/// (i.e. the source node of the corresponding arc). |
|
750 |
Node baseNode(OutArcIt) const { return INVALID; } |
|
751 |
|
|
752 |
/// \brief The running node of the iterator. |
|
729 | 753 |
/// |
730 |
/// Returns the running node (the source in this case) of the |
|
731 |
/// iterator |
|
732 |
Node runningNode(InArcIt e) const { |
|
733 |
return source(e); |
|
734 |
|
|
754 |
/// Returns the running node of the given outgoing arc iterator |
|
755 |
/// (i.e. the target node of the corresponding arc). |
|
756 |
Node runningNode(OutArcIt) const { return INVALID; } |
|
735 | 757 |
|
736 |
/// \brief |
|
758 |
/// \brief The base node of the iterator. |
|
737 | 759 |
/// |
738 |
/// Returns the base node of the iterator |
|
739 |
Node baseNode(IncEdgeIt) const { |
|
740 |
return INVALID; |
|
741 |
} |
|
760 |
/// Returns the base node of the given incomming arc iterator |
|
761 |
/// (i.e. the target node of the corresponding arc). |
|
762 |
Node baseNode(InArcIt) const { return INVALID; } |
|
742 | 763 |
|
743 |
/// \brief |
|
764 |
/// \brief The running node of the iterator. |
|
744 | 765 |
/// |
745 |
/// Returns the running node of the iterator |
|
746 |
Node runningNode(IncEdgeIt) const { |
|
747 |
return INVALID; |
|
748 |
} |
|
766 |
/// Returns the running node of the given incomming arc iterator |
|
767 |
/// (i.e. the source node of the corresponding arc). |
|
768 |
Node runningNode(InArcIt) const { return INVALID; } |
|
749 | 769 |
|
750 | 770 |
template <typename _Graph> |
751 | 771 |
struct Constraints { |
752 | 772 |
void constraints() { |
753 | 773 |
checkConcept<BaseGraphComponent, _Graph>(); |
754 | 774 |
checkConcept<IterableGraphComponent<>, _Graph>(); |
... | ... |
@@ -15,13 +15,13 @@ |
15 | 15 |
* purpose. |
16 | 16 |
* |
17 | 17 |
*/ |
18 | 18 |
|
19 | 19 |
///\ingroup graph_concepts |
20 | 20 |
///\file |
21 |
///\brief The |
|
21 |
///\brief The concepts of graph components. |
|
22 | 22 |
|
23 | 23 |
#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H |
24 | 24 |
#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H |
25 | 25 |
|
26 | 26 |
#include <lemon/core.h> |
27 | 27 |
#include <lemon/concepts/maps.h> |
... | ... |
@@ -89,13 +89,13 @@ |
89 | 89 |
/// \brief Ordering operator. |
90 | 90 |
/// |
91 | 91 |
/// This operator defines an ordering of the items. |
92 | 92 |
/// It makes possible to use graph item types as key types in |
93 | 93 |
/// associative containers (e.g. \c std::map). |
94 | 94 |
/// |
95 |
/// \note This operator only |
|
95 |
/// \note This operator only has to define some strict ordering of |
|
96 | 96 |
/// the items; this order has nothing to do with the iteration |
97 | 97 |
/// ordering of the items. |
98 | 98 |
bool operator<(const GraphItem&) const { return false; } |
99 | 99 |
|
100 | 100 |
template<typename _GraphItem> |
101 | 101 |
struct Constraints { |
... | ... |
@@ -13,46 +13,52 @@ |
13 | 13 |
* This software is provided "AS IS" with no warranty of any kind, |
14 | 14 |
* express or implied, and with no claim as to its suitability for any |
15 | 15 |
* purpose. |
16 | 16 |
* |
17 | 17 |
*/ |
18 | 18 |
|
19 |
#ifndef LEMON_CONCEPTS_HEAP_H |
|
20 |
#define LEMON_CONCEPTS_HEAP_H |
|
21 |
|
|
19 | 22 |
///\ingroup concept |
20 | 23 |
///\file |
21 | 24 |
///\brief The concept of heaps. |
22 | 25 |
|
23 |
#ifndef LEMON_CONCEPTS_HEAP_H |
|
24 |
#define LEMON_CONCEPTS_HEAP_H |
|
25 |
|
|
26 | 26 |
#include <lemon/core.h> |
27 | 27 |
#include <lemon/concept_check.h> |
28 | 28 |
|
29 | 29 |
namespace lemon { |
30 | 30 |
|
31 | 31 |
namespace concepts { |
32 | 32 |
|
33 | 33 |
/// \addtogroup concept |
34 | 34 |
/// @{ |
35 | 35 |
|
36 | 36 |
/// \brief The heap concept. |
37 | 37 |
/// |
38 |
/// Concept class describing the main interface of heaps. A \e heap |
|
39 |
/// is a data structure for storing items with specified values called |
|
40 |
/// \e priorities in such a way that finding the item with minimum |
|
41 |
/// priority is efficient. In a heap one can change the priority of an |
|
42 |
/// |
|
38 |
/// This concept class describes the main interface of heaps. |
|
39 |
/// The various \ref heaps "heap structures" are efficient |
|
40 |
/// implementations of the abstract data type \e priority \e queue. |
|
41 |
/// They store items with specified values called \e priorities |
|
42 |
/// in such a way that finding and removing the item with minimum |
|
43 |
/// priority are efficient. The basic operations are adding and |
|
44 |
/// erasing items, changing the priority of an item, etc. |
|
43 | 45 |
/// |
44 |
/// \tparam PR Type of the priority of the items. |
|
45 |
/// \tparam IM A read and writable item map with int values, used |
|
46 |
/// Heaps are crucial in several algorithms, such as Dijkstra and Prim. |
|
47 |
/// Any class that conforms to this concept can be used easily in such |
|
48 |
/// algorithms. |
|
49 |
/// |
|
50 |
/// \tparam PR Type of the priorities of the items. |
|
51 |
/// \tparam IM A read-writable item map with \c int values, used |
|
46 | 52 |
/// internally to handle the cross references. |
47 |
/// \tparam |
|
53 |
/// \tparam CMP A functor class for comparing the priorities. |
|
48 | 54 |
/// The default is \c std::less<PR>. |
49 | 55 |
#ifdef DOXYGEN |
50 |
template <typename PR, typename IM, typename |
|
56 |
template <typename PR, typename IM, typename CMP> |
|
51 | 57 |
#else |
52 |
template <typename PR, typename IM> |
|
58 |
template <typename PR, typename IM, typename CMP = std::less<PR> > |
|
53 | 59 |
#endif |
54 | 60 |
class Heap { |
55 | 61 |
public: |
56 | 62 |
|
57 | 63 |
/// Type of the item-int map. |
58 | 64 |
typedef IM ItemIntMap; |
... | ... |
@@ -61,129 +67,145 @@ |
61 | 67 |
/// Type of the items stored in the heap. |
62 | 68 |
typedef typename ItemIntMap::Key Item; |
63 | 69 |
|
64 | 70 |
/// \brief Type to represent the states of the items. |
65 | 71 |
/// |
66 | 72 |
/// Each item has a state associated to it. It can be "in heap", |
67 |
/// "pre heap" or "post heap". The later two are indifferent |
|
68 |
/// from the point of view of the heap, but may be useful for |
|
69 |
/// |
|
73 |
/// "pre-heap" or "post-heap". The latter two are indifferent from the |
|
74 |
/// heap's point of view, but may be useful to the user. |
|
70 | 75 |
/// |
71 | 76 |
/// The item-int map must be initialized in such way that it assigns |
72 | 77 |
/// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap. |
73 | 78 |
enum State { |
74 | 79 |
IN_HEAP = 0, ///< = 0. The "in heap" state constant. |
75 |
PRE_HEAP = -1, ///< = -1. The "pre heap" state constant. |
|
76 |
POST_HEAP = -2 ///< = -2. The "post heap" state constant. |
|
80 |
PRE_HEAP = -1, ///< = -1. The "pre-heap" state constant. |
|
81 |
POST_HEAP = -2 ///< = -2. The "post-heap" state constant. |
|
77 | 82 |
}; |
78 | 83 |
|
79 |
/// \brief |
|
84 |
/// \brief Constructor. |
|
80 | 85 |
/// |
81 |
/// |
|
86 |
/// Constructor. |
|
82 | 87 |
/// \param map A map that assigns \c int values to keys of type |
83 | 88 |
/// \c Item. It is used internally by the heap implementations to |
84 | 89 |
/// handle the cross references. The assigned value must be |
85 |
/// \c PRE_HEAP (<tt>-1</tt>) for |
|
90 |
/// \c PRE_HEAP (<tt>-1</tt>) for each item. |
|
86 | 91 |
explicit Heap(ItemIntMap &map) {} |
87 | 92 |
|
93 |
/// \brief Constructor. |
|
94 |
/// |
|
95 |
/// Constructor. |
|
96 |
/// \param map A map that assigns \c int values to keys of type |
|
97 |
/// \c Item. It is used internally by the heap implementations to |
|
98 |
/// handle the cross references. The assigned value must be |
|
99 |
/// \c PRE_HEAP (<tt>-1</tt>) for each item. |
|
100 |
/// \param comp The function object used for comparing the priorities. |
|
101 |
explicit Heap(ItemIntMap &map, const CMP &comp) {} |
|
102 |
|
|
88 | 103 |
/// \brief The number of items stored in the heap. |
89 | 104 |
/// |
90 |
/// |
|
105 |
/// This function returns the number of items stored in the heap. |
|
91 | 106 |
int size() const { return 0; } |
92 | 107 |
|
93 |
/// \brief |
|
108 |
/// \brief Check if the heap is empty. |
|
94 | 109 |
/// |
95 |
/// |
|
110 |
/// This function returns \c true if the heap is empty. |
|
96 | 111 |
bool empty() const { return false; } |
97 | 112 |
|
98 |
/// \brief |
|
113 |
/// \brief Make the heap empty. |
|
99 | 114 |
/// |
100 |
/// Makes the heap empty. |
|
101 |
void clear(); |
|
115 |
/// This functon makes the heap empty. |
|
116 |
/// It does not change the cross reference map. If you want to reuse |
|
117 |
/// a heap that is not surely empty, you should first clear it and |
|
118 |
/// then you should set the cross reference map to \c PRE_HEAP |
|
119 |
/// for each item. |
|
120 |
void clear() {} |
|
102 | 121 |
|
103 |
/// \brief |
|
122 |
/// \brief Insert an item into the heap with the given priority. |
|
104 | 123 |
/// |
105 |
/// |
|
124 |
/// This function inserts the given item into the heap with the |
|
125 |
/// given priority. |
|
106 | 126 |
/// \param i The item to insert. |
107 | 127 |
/// \param p The priority of the item. |
128 |
/// \pre \e i must not be stored in the heap. |
|
108 | 129 |
void push(const Item &i, const Prio &p) {} |
109 | 130 |
|
110 |
/// \brief |
|
131 |
/// \brief Return the item having minimum priority. |
|
111 | 132 |
/// |
112 |
/// |
|
133 |
/// This function returns the item having minimum priority. |
|
113 | 134 |
/// \pre The heap must be non-empty. |
114 | 135 |
Item top() const {} |
115 | 136 |
|
116 | 137 |
/// \brief The minimum priority. |
117 | 138 |
/// |
118 |
/// |
|
139 |
/// This function returns the minimum priority. |
|
119 | 140 |
/// \pre The heap must be non-empty. |
120 | 141 |
Prio prio() const {} |
121 | 142 |
|
122 |
/// \brief |
|
143 |
/// \brief Remove the item having minimum priority. |
|
123 | 144 |
/// |
124 |
/// |
|
145 |
/// This function removes the item having minimum priority. |
|
125 | 146 |
/// \pre The heap must be non-empty. |
126 | 147 |
void pop() {} |
127 | 148 |
|
128 |
/// \brief |
|
149 |
/// \brief Remove the given item from the heap. |
|
129 | 150 |
/// |
130 |
/// |
|
151 |
/// This function removes the given item from the heap if it is |
|
152 |
/// already stored. |
|
131 | 153 |
/// \param i The item to delete. |
154 |
/// \pre \e i must be in the heap. |
|
132 | 155 |
void erase(const Item &i) {} |
133 | 156 |
|
134 |
/// \brief The priority of |
|
157 |
/// \brief The priority of the given item. |
|
135 | 158 |
/// |
136 |
/// |
|
159 |
/// This function returns the priority of the given item. |
|
137 | 160 |
/// \param i The item. |
138 |
/// \pre \ |
|
161 |
/// \pre \e i must be in the heap. |
|
139 | 162 |
Prio operator[](const Item &i) const {} |
140 | 163 |
|
141 |
/// \brief |
|
164 |
/// \brief Set the priority of an item or insert it, if it is |
|
142 | 165 |
/// not stored in the heap. |
143 | 166 |
/// |
144 | 167 |
/// This method sets the priority of the given item if it is |
145 |
/// already stored in the heap. |
|
146 |
/// Otherwise it inserts the given item with the given priority. |
|
168 |
/// already stored in the heap. Otherwise it inserts the given |
|
169 |
/// item into the heap with the given priority. |
|
147 | 170 |
/// |
148 | 171 |
/// \param i The item. |
149 | 172 |
/// \param p The priority. |
150 | 173 |
void set(const Item &i, const Prio &p) {} |
151 | 174 |
|
152 |
/// \brief |
|
175 |
/// \brief Decrease the priority of an item to the given value. |
|
153 | 176 |
/// |
154 |
/// |
|
177 |
/// This function decreases the priority of an item to the given value. |
|
155 | 178 |
/// \param i The item. |
156 | 179 |
/// \param p The priority. |
157 |
/// \pre \ |
|
180 |
/// \pre \e i must be stored in the heap with priority at least \e p. |
|
158 | 181 |
void decrease(const Item &i, const Prio &p) {} |
159 | 182 |
|
160 |
/// \brief |
|
183 |
/// \brief Increase the priority of an item to the given value. |
|
161 | 184 |
/// |
162 |
/// |
|
185 |
/// This function increases the priority of an item to the given value. |
|
163 | 186 |
/// \param i The item. |
164 | 187 |
/// \param p The priority. |
165 |
/// \pre \ |
|
188 |
/// \pre \e i must be stored in the heap with priority at most \e p. |
|
166 | 189 |
void increase(const Item &i, const Prio &p) {} |
167 | 190 |
|
168 |
/// \brief Returns if an item is in, has already been in, or has |
|
169 |
/// never been in the heap. |
|
191 |
/// \brief Return the state of an item. |
|
170 | 192 |
/// |
171 | 193 |
/// This method returns \c PRE_HEAP if the given item has never |
172 | 194 |
/// been in the heap, \c IN_HEAP if it is in the heap at the moment, |
173 | 195 |
/// and \c POST_HEAP otherwise. |
174 | 196 |
/// In the latter case it is possible that the item will get back |
175 | 197 |
/// to the heap again. |
176 | 198 |
/// \param i The item. |
177 | 199 |
State state(const Item &i) const {} |
178 | 200 |
|
179 |
/// \brief |
|
201 |
/// \brief Set the state of an item in the heap. |
|
180 | 202 |
/// |
181 |
/// Sets the state of the given item in the heap. It can be used |
|
182 |
/// to manually clear the heap when it is important to achive the |
|
183 |
/// |
|
203 |
/// This function sets the state of the given item in the heap. |
|
204 |
/// It can be used to manually clear the heap when it is important |
|
205 |
/// to achive better time complexity. |
|
184 | 206 |
/// \param i The item. |
185 | 207 |
/// \param st The state. It should not be \c IN_HEAP. |
186 | 208 |
void state(const Item& i, State st) {} |
187 | 209 |
|
188 | 210 |
|
189 | 211 |
template <typename _Heap> |
... | ... |
@@ -15,13 +15,13 @@ |
15 | 15 |
* purpose. |
16 | 16 |
* |
17 | 17 |
*/ |
18 | 18 |
|
19 | 19 |
///\ingroup concept |
20 | 20 |
///\file |
21 |
///\brief |
|
21 |
///\brief The concept of paths |
|
22 | 22 |
/// |
23 | 23 |
|
24 | 24 |
#ifndef LEMON_CONCEPTS_PATH_H |
25 | 25 |
#define LEMON_CONCEPTS_PATH_H |
26 | 26 |
|
27 | 27 |
#include <lemon/core.h> |
... | ... |
@@ -35,19 +35,28 @@ |
35 | 35 |
|
36 | 36 |
/// \brief A skeleton structure for representing directed paths in |
37 | 37 |
/// a digraph. |
38 | 38 |
/// |
39 | 39 |
/// A skeleton structure for representing directed paths in a |
40 | 40 |
/// digraph. |
41 |
/// In a sense, a path can be treated as a list of arcs. |
|
42 |
/// LEMON path types just store this list. As a consequence, they cannot |
|
43 |
/// enumerate the nodes on the path directly and a zero length path |
|
44 |
/// cannot store its source node. |
|
45 |
/// |
|
46 |
/// The arcs of a path should be stored in the order of their directions, |
|
47 |
/// i.e. the target node of each arc should be the same as the source |
|
48 |
/// node of the next arc. This consistency could be checked using |
|
49 |
/// \ref checkPath(). |
|
50 |
/// The source and target nodes of a (consistent) path can be obtained |
|
51 |
/// using \ref pathSource() and \ref pathTarget(). |
|
52 |
/// |
|
53 |
/// A path can be constructed from another path of any type using the |
|
54 |
/// copy constructor or the assignment operator. |
|
55 |
/// |
|
41 | 56 |
/// \tparam GR The digraph type in which the path is. |
42 |
/// |
|
43 |
/// In a sense, the path can be treated as a list of arcs. The |
|
44 |
/// lemon path type stores just this list. As a consequence it |
|
45 |
/// cannot enumerate the nodes in the path and the zero length |
|
46 |
/// paths cannot store the source. |
|
47 |
/// |
|
48 | 57 |
template <typename GR> |
49 | 58 |
class Path { |
50 | 59 |
public: |
51 | 60 |
|
52 | 61 |
/// Type of the underlying digraph. |
53 | 62 |
typedef GR Digraph; |
... | ... |
@@ -56,45 +65,45 @@ |
56 | 65 |
|
57 | 66 |
class ArcIt; |
58 | 67 |
|
59 | 68 |
/// \brief Default constructor |
60 | 69 |
Path() {} |
61 | 70 |
|
62 |
/// \brief Template constructor |
|
71 |
/// \brief Template copy constructor |
|
63 | 72 |
template <typename CPath> |
64 | 73 |
Path(const CPath& cpath) {} |
65 | 74 |
|
66 |
/// \brief Template assigment |
|
75 |
/// \brief Template assigment operator |
|
67 | 76 |
template <typename CPath> |
68 | 77 |
Path& operator=(const CPath& cpath) { |
69 | 78 |
ignore_unused_variable_warning(cpath); |
70 | 79 |
return *this; |
71 | 80 |
} |
72 | 81 |
|
73 |
/// Length of the path |
|
82 |
/// Length of the path, i.e. the number of arcs on the path. |
|
74 | 83 |
int length() const { return 0;} |
75 | 84 |
|
76 | 85 |
/// Returns whether the path is empty. |
77 | 86 |
bool empty() const { return true;} |
78 | 87 |
|
79 | 88 |
/// Resets the path to an empty path. |
80 | 89 |
void clear() {} |
81 | 90 |
|
82 |
/// \brief LEMON style iterator for |
|
91 |
/// \brief LEMON style iterator for enumerating the arcs of a path. |
|
83 | 92 |
/// |
84 |
/// |
|
93 |
/// LEMON style iterator class for enumerating the arcs of a path. |
|
85 | 94 |
class ArcIt { |
86 | 95 |
public: |
87 | 96 |
/// Default constructor |
88 | 97 |
ArcIt() {} |
89 | 98 |
/// Invalid constructor |
90 | 99 |
ArcIt(Invalid) {} |
91 |
/// |
|
100 |
/// Sets the iterator to the first arc of the given path |
|
92 | 101 |
ArcIt(const Path &) {} |
93 | 102 |
|
94 |
/// Conversion to Arc |
|
103 |
/// Conversion to \c Arc |
|
95 | 104 |
operator Arc() const { return INVALID; } |
96 | 105 |
|
97 | 106 |
/// Next arc |
98 | 107 |
ArcIt& operator++() {return *this;} |
99 | 108 |
|
100 | 109 |
/// Comparison operator |
... | ... |
@@ -189,66 +198,59 @@ |
189 | 198 |
} |
190 | 199 |
|
191 | 200 |
|
192 | 201 |
/// \brief A skeleton structure for path dumpers. |
193 | 202 |
/// |
194 | 203 |
/// A skeleton structure for path dumpers. The path dumpers are |
195 |
/// the generalization of the paths. The path dumpers can |
|
196 |
/// enumerate the arcs of the path wheter in forward or in |
|
197 |
/// backward order. In most time these classes are not used |
|
198 |
/// directly rather it used to assign a dumped class to a real |
|
199 |
/// |
|
204 |
/// the generalization of the paths, they can enumerate the arcs |
|
205 |
/// of the path either in forward or in backward order. |
|
206 |
/// These classes are typically not used directly, they are rather |
|
207 |
/// used to be assigned to a real path type. |
|
200 | 208 |
/// |
201 | 209 |
/// The main purpose of this concept is that the shortest path |
202 |
/// algorithms can enumerate easily the arcs in reverse order. |
|
203 |
/// If we would like to give back a real path from these |
|
204 |
/// algorithms then we should create a temporarly path object. In |
|
205 |
/// LEMON such algorithms gives back a path dumper what can |
|
206 |
/// |
|
210 |
/// algorithms can enumerate the arcs easily in reverse order. |
|
211 |
/// In LEMON, such algorithms give back a (reverse) path dumper that |
|
212 |
/// can be assigned to a real path. The dumpers can be implemented as |
|
207 | 213 |
/// an adaptor class to the predecessor map. |
208 | 214 |
/// |
209 | 215 |
/// \tparam GR The digraph type in which the path is. |
210 |
/// |
|
211 |
/// The paths can be constructed from any path type by a |
|
212 |
/// template constructor or a template assignment operator. |
|
213 | 216 |
template <typename GR> |
214 | 217 |
class PathDumper { |
215 | 218 |
public: |
216 | 219 |
|
217 | 220 |
/// Type of the underlying digraph. |
218 | 221 |
typedef GR Digraph; |
219 | 222 |
/// Arc type of the underlying digraph. |
220 | 223 |
typedef typename Digraph::Arc Arc; |
221 | 224 |
|
222 |
/// Length of the path |
|
225 |
/// Length of the path, i.e. the number of arcs on the path. |
|
223 | 226 |
int length() const { return 0;} |
224 | 227 |
|
225 | 228 |
/// Returns whether the path is empty. |
226 | 229 |
bool empty() const { return true;} |
227 | 230 |
|
228 | 231 |
/// \brief Forward or reverse dumping |
229 | 232 |
/// |
230 |
/// If the RevPathTag is defined and true then reverse dumping |
|
231 |
/// is provided in the path dumper. In this case instead of the |
|
232 |
/// ArcIt the RevArcIt iterator should be implemented in the |
|
233 |
/// dumper. |
|
233 |
/// If this tag is defined to be \c True, then reverse dumping |
|
234 |
/// is provided in the path dumper. In this case, \c RevArcIt |
|
235 |
/// iterator should be implemented instead of \c ArcIt iterator. |
|
234 | 236 |
typedef False RevPathTag; |
235 | 237 |
|
236 |
/// \brief LEMON style iterator for |
|
238 |
/// \brief LEMON style iterator for enumerating the arcs of a path. |
|
237 | 239 |
/// |
238 |
/// |
|
240 |
/// LEMON style iterator class for enumerating the arcs of a path. |
|
239 | 241 |
class ArcIt { |
240 | 242 |
public: |
241 | 243 |
/// Default constructor |
242 | 244 |
ArcIt() {} |
243 | 245 |
/// Invalid constructor |
244 | 246 |
ArcIt(Invalid) {} |
245 |
/// |
|
247 |
/// Sets the iterator to the first arc of the given path |
|
246 | 248 |
ArcIt(const PathDumper&) {} |
247 | 249 |
|
248 |
/// Conversion to Arc |
|
250 |
/// Conversion to \c Arc |
|
249 | 251 |
operator Arc() const { return INVALID; } |
250 | 252 |
|
251 | 253 |
/// Next arc |
252 | 254 |
ArcIt& operator++() {return *this;} |
253 | 255 |
|
254 | 256 |
/// Comparison operator |
... | ... |
@@ -257,26 +259,27 @@ |
257 | 259 |
bool operator!=(const ArcIt&) const {return true;} |
258 | 260 |
/// Comparison operator |
259 | 261 |
bool operator<(const ArcIt&) const {return false;} |
260 | 262 |
|
261 | 263 |
}; |
262 | 264 |
|
263 |
/// \brief LEMON style iterator for |
|
265 |
/// \brief LEMON style iterator for enumerating the arcs of a path |
|
266 |
/// in reverse direction. |
|
264 | 267 |
/// |
265 |
/// This class is used to iterate on the arcs of the paths in |
|
266 |
/// reverse direction. |
|
268 |
/// LEMON style iterator class for enumerating the arcs of a path |
|
269 |
/// in reverse direction. |
|
267 | 270 |
class RevArcIt { |
268 | 271 |
public: |
269 | 272 |
/// Default constructor |
270 | 273 |
RevArcIt() {} |
271 | 274 |
/// Invalid constructor |
272 | 275 |
RevArcIt(Invalid) {} |
273 |
/// |
|
276 |
/// Sets the iterator to the last arc of the given path |
|
274 | 277 |
RevArcIt(const PathDumper &) {} |
275 | 278 |
|
276 |
/// Conversion to Arc |
|
279 |
/// Conversion to \c Arc |
|
277 | 280 |
operator Arc() const { return INVALID; } |
278 | 281 |
|
279 | 282 |
/// Next arc |
280 | 283 |
RevArcIt& operator++() {return *this;} |
281 | 284 |
|
282 | 285 |
/// Comparison operator |
... | ... |
@@ -209,13 +209,13 @@ |
209 | 209 |
/// Returns the value of the counter. |
210 | 210 |
operator int() {return count;} |
211 | 211 |
}; |
212 | 212 |
|
213 | 213 |
/// 'Do nothing' version of Counter. |
214 | 214 |
|
215 |
/// This class can be used in the same way as \ref Counter |
|
215 |
/// This class can be used in the same way as \ref Counter, but it |
|
216 | 216 |
/// does not count at all and does not print report on destruction. |
217 | 217 |
/// |
218 | 218 |
/// Replacing a \ref Counter with a \ref NoCounter makes it possible |
219 | 219 |
/// to turn off all counting and reporting (SubCounters should also |
220 | 220 |
/// be replaced with NoSubCounters), so it does not affect the |
221 | 221 |
/// efficiency of the program at all. |
... | ... |
@@ -108,12 +108,45 @@ |
108 | 108 |
const double ub = INF; |
109 | 109 |
const char s = 'L'; |
110 | 110 |
CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0); |
111 | 111 |
return i; |
112 | 112 |
} |
113 | 113 |
|
114 |
int CplexBase::_addRow(Value lb, ExprIterator b, |
|
115 |
ExprIterator e, Value ub) { |
|
116 |
int i = CPXgetnumrows(cplexEnv(), _prob); |
|
117 |
if (lb == -INF) { |
|
118 |
const char s = 'L'; |
|
119 |
CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0); |
|
120 |
} else if (ub == INF) { |
|
121 |
const char s = 'G'; |
|
122 |
CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); |
|
123 |
} else if (lb == ub){ |
|
124 |
const char s = 'E'; |
|
125 |
CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); |
|
126 |
} else { |
|
127 |
const char s = 'R'; |
|
128 |
double len = ub - lb; |
|
129 |
CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0); |
|
130 |
} |
|
131 |
|
|
132 |
std::vector<int> indices; |
|
133 |
std::vector<int> rowlist; |
|
134 |
std::vector<Value> values; |
|
135 |
|
|
136 |
for(ExprIterator it=b; it!=e; ++it) { |
|
137 |
indices.push_back(it->first); |
|
138 |
values.push_back(it->second); |
|
139 |
rowlist.push_back(i); |
|
140 |
} |
|
141 |
|
|
142 |
CPXchgcoeflist(cplexEnv(), _prob, values.size(), |
|
143 |
&rowlist.front(), &indices.front(), &values.front()); |
|
144 |
|
|
145 |
return i; |
|
146 |
} |
|
114 | 147 |
|
115 | 148 |
void CplexBase::_eraseCol(int i) { |
116 | 149 |
CPXdelcols(cplexEnv(), _prob, i, i); |
117 | 150 |
} |
118 | 151 |
|
119 | 152 |
void CplexBase::_eraseRow(int i) { |
... | ... |
@@ -90,12 +90,13 @@ |
90 | 90 |
CplexBase(const CplexEnv&); |
91 | 91 |
CplexBase(const CplexBase &); |
92 | 92 |
virtual ~CplexBase(); |
93 | 93 |
|
94 | 94 |
virtual int _addCol(); |
95 | 95 |
virtual int _addRow(); |
96 |
virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); |
|
96 | 97 |
|
97 | 98 |
virtual void _eraseCol(int i); |
98 | 99 |
virtual void _eraseRow(int i); |
99 | 100 |
|
100 | 101 |
virtual void _eraseColId(int i); |
101 | 102 |
virtual void _eraseRowId(int i); |
Changeset was too big and was cut off... Show full diff
0 comments (0 inline)