Changes in / [789:8e68671af789:788:10c9c3a35b83] in lemon
- Files:
-
- 7 deleted
- 29 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/groups.dox
r789 r782 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 /** 229 237 @defgroup paths Path Structures 230 238 @ingroup datas … … 239 247 any kind of path structure. 240 248 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. 249 \sa lemon::concepts::Path 271 250 */ 272 251 … … 278 257 This group contains some data structures implemented in LEMON in 279 258 order to make it easier to implement combinatorial algorithms. 280 */281 282 /**283 @defgroup geomdat Geometric Data Structures284 @ingroup auxdat285 \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 dimensional290 vector with the usual operations.291 - \ref lemon::dim2::Box "dim2::Box" can be used to determine the292 rectangular bounding box of a set of \ref lemon::dim2::Point293 "dim2::Point"'s.294 */295 296 /**297 @defgroup matrices Matrices298 @ingroup auxdat299 \brief Two dimensional data storages implemented in LEMON.300 301 This group contains two dimensional data storages implemented in LEMON.302 259 */ 303 260 … … 342 299 343 300 /** 344 @defgroup spantree Minimum Spanning Tree Algorithms345 @ingroup algs346 \brief Algorithms for finding minimum cost spanning trees and arborescences.347 348 This group contains the algorithms for finding minimum cost spanning349 trees and arborescences.350 */351 352 /**353 301 @defgroup max_flow Maximum Flow Algorithms 354 302 @ingroup algs … … 428 376 429 377 \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} 430 \sum_{uv\in A :u\in X, v\not\in X}cap(uv) \f]378 \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f] 431 379 432 380 LEMON contains several algorithms related to minimum cut problems: … … 441 389 If you want to find minimum cut just between two distinict nodes, 442 390 see the \ref max_flow "maximum flow problem". 391 */ 392 393 /** 394 @defgroup graph_properties Connectivity and Other Graph Properties 395 @ingroup algs 396 \brief Algorithms for discovering the graph properties 397 398 This group contains the algorithms for discovering the graph properties 399 like connectivity, bipartiteness, euler property, simplicity etc. 400 401 \image html edge_biconnected_components.png 402 \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth 403 */ 404 405 /** 406 @defgroup planar Planarity Embedding and Drawing 407 @ingroup algs 408 \brief Algorithms for planarity checking, embedding and drawing 409 410 This group contains the algorithms for planarity checking, 411 embedding and drawing. 412 413 \image html planar.png 414 \image latex planar.eps "Plane graph" width=\textwidth 443 415 */ 444 416 … … 484 456 485 457 /** 486 @defgroup graph_properties Connectivity and Other Graph Properties 487 @ingroup algs 488 \brief Algorithms for discovering the graph properties 489 490 This group contains the algorithms for discovering the graph properties 491 like connectivity, bipartiteness, euler property, simplicity etc. 492 493 \image html connected_components.png 494 \image latex connected_components.eps "Connected components" width=\textwidth 495 */ 496 497 /** 498 @defgroup planar Planarity Embedding and Drawing 499 @ingroup algs 500 \brief Algorithms for planarity checking, embedding and drawing 501 502 This group contains the algorithms for planarity checking, 503 embedding and drawing. 504 505 \image html planar.png 506 \image latex planar.eps "Plane graph" width=\textwidth 458 @defgroup spantree Minimum Spanning Tree Algorithms 459 @ingroup algs 460 \brief Algorithms for finding minimum cost spanning trees and arborescences. 461 462 This group contains the algorithms for finding minimum cost spanning 463 trees and arborescences. 464 */ 465 466 /** 467 @defgroup auxalg Auxiliary Algorithms 468 @ingroup algs 469 \brief Auxiliary algorithms implemented in LEMON. 470 471 This group contains some algorithms implemented in LEMON 472 in order to make it easier to implement complex algorithms. 507 473 */ 508 474 … … 514 480 This group contains the approximation and heuristic algorithms 515 481 implemented in LEMON. 516 */517 518 /**519 @defgroup auxalg Auxiliary Algorithms520 @ingroup algs521 \brief Auxiliary algorithms implemented in LEMON.522 523 This group contains some algorithms implemented in LEMON524 in order to make it easier to implement complex algorithms.525 482 */ 526 483 … … 631 588 632 589 /** 633 @defgroup dimacs_group DIMACS Format590 @defgroup dimacs_group DIMACS format 634 591 @ingroup io_group 635 592 \brief Read and write files in DIMACS format … … 693 650 694 651 /** 652 \anchor demoprograms 653 654 @defgroup demos Demo Programs 655 656 Some demo programs are listed here. Their full source codes can be found in 657 the \c demo subdirectory of the source tree. 658 659 In order to compile them, use the <tt>make demo</tt> or the 660 <tt>make check</tt> commands. 661 */ 662 663 /** 695 664 @defgroup tools Standalone Utility Applications 696 665 … … 701 670 */ 702 671 703 /**704 \anchor demoprograms705 706 @defgroup demos Demo Programs707 708 Some demo programs are listed here. Their full source codes can be found in709 the \c demo subdirectory of the source tree.710 711 In order to compile them, use the <tt>make demo</tt> or the712 <tt>make check</tt> commands.713 */714 715 672 } -
lemon/Makefile.am
r755 r733 58 58 lemon/arg_parser.h \ 59 59 lemon/assert.h \ 60 lemon/bellman_ford.h \61 60 lemon/bfs.h \ 62 61 lemon/bin_heap.h \ 63 lemon/binom_heap.h \64 62 lemon/bucket_heap.h \ 65 63 lemon/cbc.h \ … … 81 79 lemon/euler.h \ 82 80 lemon/fib_heap.h \ 83 lemon/fourary_heap.h \84 81 lemon/full_graph.h \ 85 82 lemon/glpk.h \ … … 88 85 lemon/grid_graph.h \ 89 86 lemon/hypercube_graph.h \ 90 lemon/kary_heap.h \91 87 lemon/kruskal.h \ 92 88 lemon/hao_orlin.h \ … … 103 99 lemon/nauty_reader.h \ 104 100 lemon/network_simplex.h \ 105 lemon/pairing_heap.h \106 101 lemon/path.h \ 107 102 lemon/preflow.h \ -
lemon/bfs.h
r764 r525 48 48 ///The type of the map that stores the predecessor 49 49 ///arcs of the shortest paths. 50 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.50 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 51 51 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 52 52 ///Instantiates a \c PredMap. … … 63 63 64 64 ///The type of the map that indicates which nodes are processed. 65 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 66 ///By default it is a NullMap. 65 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 67 66 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; 68 67 ///Instantiates a \c ProcessedMap. … … 83 82 84 83 ///The type of the map that indicates which nodes are reached. 85 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.84 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 86 85 typedef typename Digraph::template NodeMap<bool> ReachedMap; 87 86 ///Instantiates a \c ReachedMap. … … 98 97 99 98 ///The type of the map that stores the distances of the nodes. 100 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.99 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 101 100 typedef typename Digraph::template NodeMap<int> DistMap; 102 101 ///Instantiates a \c DistMap. … … 227 226 ///\ref named-templ-param "Named parameter" for setting 228 227 ///\c PredMap type. 229 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.228 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 230 229 template <class T> 231 230 struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > { … … 247 246 ///\ref named-templ-param "Named parameter" for setting 248 247 ///\c DistMap type. 249 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.248 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 250 249 template <class T> 251 250 struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > { … … 267 266 ///\ref named-templ-param "Named parameter" for setting 268 267 ///\c ReachedMap type. 269 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.268 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 270 269 template <class T> 271 270 struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > { … … 287 286 ///\ref named-templ-param "Named parameter" for setting 288 287 ///\c ProcessedMap type. 289 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.288 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 290 289 template <class T> 291 290 struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > { … … 415 414 ///The simplest way to execute the BFS algorithm is to use one of the 416 415 ///member functions called \ref run(Node) "run()".\n 417 ///If you need better control on the execution,you have to call418 ///\ref init() first, then you can add several source nodes with416 ///If you need more control on the execution, first you have to call 417 ///\ref init(), then you can add several source nodes with 419 418 ///\ref addSource(). Finally the actual path computation can be 420 419 ///performed with one of the \ref start() functions. … … 739 738 ///@{ 740 739 741 ///The shortest path to the givennode.742 743 ///Returns the shortest path to the given node from the root(s).740 ///The shortest path to a node. 741 742 ///Returns the shortest path to a node. 744 743 /// 745 744 ///\warning \c t should be reached from the root(s). … … 749 748 Path path(Node t) const { return Path(*G, *_pred, t); } 750 749 751 ///The distance of the givennode from the root(s).752 753 ///Returns the distance of the givennode from the root(s).750 ///The distance of a node from the root(s). 751 752 ///Returns the distance of a node from the root(s). 754 753 /// 755 754 ///\warning If node \c v is not reached from the root(s), then … … 760 759 int dist(Node v) const { return (*_dist)[v]; } 761 760 762 ///\brief Returns the 'previous arc' of the shortest path tree for 763 ///the given node. 764 /// 761 ///Returns the 'previous arc' of the shortest path tree for a node. 762 765 763 ///This function returns the 'previous arc' of the shortest path 766 764 ///tree for the node \c v, i.e. it returns the last arc of a … … 769 767 /// 770 768 ///The shortest path tree used here is equal to the shortest path 771 ///tree used in \ref predNode() and \ref predMap().769 ///tree used in \ref predNode(). 772 770 /// 773 771 ///\pre Either \ref run(Node) "run()" or \ref init() … … 775 773 Arc predArc(Node v) const { return (*_pred)[v];} 776 774 777 ///\brief Returns the 'previous node' of the shortest path tree for 778 ///the given node. 779 /// 775 ///Returns the 'previous node' of the shortest path tree for a node. 776 780 777 ///This function returns the 'previous node' of the shortest path 781 778 ///tree for the node \c v, i.e. it returns the last but one node 782 /// ofa shortest path from a root to \c v. It is \c INVALID779 ///from a shortest path from a root to \c v. It is \c INVALID 783 780 ///if \c v is not reached from the root(s) or if \c v is a root. 784 781 /// 785 782 ///The shortest path tree used here is equal to the shortest path 786 ///tree used in \ref predArc() and \ref predMap().783 ///tree used in \ref predArc(). 787 784 /// 788 785 ///\pre Either \ref run(Node) "run()" or \ref init() … … 805 802 /// 806 803 ///Returns a const reference to the node map that stores the predecessor 807 ///arcs, which form the shortest path tree (forest).804 ///arcs, which form the shortest path tree. 808 805 /// 809 806 ///\pre Either \ref run(Node) "run()" or \ref init() … … 811 808 const PredMap &predMap() const { return *_pred;} 812 809 813 ///Checks if the givennode is reached from the root(s).810 ///Checks if a node is reached from the root(s). 814 811 815 812 ///Returns \c true if \c v is reached from the root(s). … … 837 834 ///The type of the map that stores the predecessor 838 835 ///arcs of the shortest paths. 839 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.836 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 840 837 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 841 838 ///Instantiates a PredMap. … … 852 849 853 850 ///The type of the map that indicates which nodes are processed. 854 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.851 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 855 852 ///By default it is a NullMap. 856 853 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 872 869 873 870 ///The type of the map that indicates which nodes are reached. 874 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.871 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 875 872 typedef typename Digraph::template NodeMap<bool> ReachedMap; 876 873 ///Instantiates a ReachedMap. … … 887 884 888 885 ///The type of the map that stores the distances of the nodes. 889 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.886 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 890 887 typedef typename Digraph::template NodeMap<int> DistMap; 891 888 ///Instantiates a DistMap. … … 902 899 903 900 ///The type of the shortest paths. 904 ///It must conform tothe \ref concepts::Path "Path" concept.901 ///It must meet the \ref concepts::Path "Path" concept. 905 902 typedef lemon::Path<Digraph> Path; 906 903 }; … … 908 905 /// Default traits class used by BfsWizard 909 906 910 /// Default traits class used by BfsWizard. 911 /// \tparam GR The type of the digraph. 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. 912 913 template<class GR> 913 914 class BfsWizardBase : public BfsWizardDefaultTraits<GR> … … 937 938 /// Constructor. 938 939 939 /// This constructor does not require parameters, it initiates940 /// This constructor does not require parameters, therefore it initiates 940 941 /// all of the attributes to \c 0. 941 942 BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), … … 967 968 typedef TR Base; 968 969 970 ///The type of the digraph the algorithm runs on. 969 971 typedef typename TR::Digraph Digraph; 970 972 … … 974 976 typedef typename Digraph::OutArcIt OutArcIt; 975 977 978 ///\brief The type of the map that stores the predecessor 979 ///arcs of the shortest paths. 976 980 typedef typename TR::PredMap PredMap; 981 ///\brief The type of the map that stores the distances of the nodes. 977 982 typedef typename TR::DistMap DistMap; 983 ///\brief The type of the map that indicates which nodes are reached. 978 984 typedef typename TR::ReachedMap ReachedMap; 985 ///\brief The type of the map that indicates which nodes are processed. 979 986 typedef typename TR::ProcessedMap ProcessedMap; 987 ///The type of the shortest paths 980 988 typedef typename TR::Path Path; 981 989 … … 1060 1068 SetPredMapBase(const TR &b) : TR(b) {} 1061 1069 }; 1062 1063 ///\brief \ref named-templ-param "Named parameter" for setting 1064 ///the predecessor map. 1065 /// 1066 ///\ref named-templ-param "Named parameter" function for setting 1067 ///the map that stores the predecessor arcs of the nodes. 1070 ///\brief \ref named-func-param "Named parameter" 1071 ///for setting PredMap object. 1072 /// 1073 ///\ref named-func-param "Named parameter" 1074 ///for setting PredMap object. 1068 1075 template<class T> 1069 1076 BfsWizard<SetPredMapBase<T> > predMap(const T &t) … … 1079 1086 SetReachedMapBase(const TR &b) : TR(b) {} 1080 1087 }; 1081 1082 ///\brief \ref named-templ-param "Named parameter" for setting 1083 ///the reached map. 1084 /// 1085 ///\ref named-templ-param "Named parameter" function for setting 1086 ///the map that indicates which nodes are reached. 1088 ///\brief \ref named-func-param "Named parameter" 1089 ///for setting ReachedMap object. 1090 /// 1091 /// \ref named-func-param "Named parameter" 1092 ///for setting ReachedMap object. 1087 1093 template<class T> 1088 1094 BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t) … … 1098 1104 SetDistMapBase(const TR &b) : TR(b) {} 1099 1105 }; 1100 1101 ///\brief \ref named-templ-param "Named parameter" for setting 1102 ///the distance map. 1103 /// 1104 ///\ref named-templ-param "Named parameter" function for setting 1105 ///the map that stores the distances of the nodes calculated 1106 ///by the algorithm. 1106 ///\brief \ref named-func-param "Named parameter" 1107 ///for setting DistMap object. 1108 /// 1109 /// \ref named-func-param "Named parameter" 1110 ///for setting DistMap object. 1107 1111 template<class T> 1108 1112 BfsWizard<SetDistMapBase<T> > distMap(const T &t) … … 1118 1122 SetProcessedMapBase(const TR &b) : TR(b) {} 1119 1123 }; 1120 1121 ///\brief \ref named-func-param "Named parameter" for setting 1122 ///the processed map. 1123 /// 1124 ///\ref named-templ-param "Named parameter" function for setting 1125 ///the map that indicates which nodes are processed. 1124 ///\brief \ref named-func-param "Named parameter" 1125 ///for setting ProcessedMap object. 1126 /// 1127 /// \ref named-func-param "Named parameter" 1128 ///for setting ProcessedMap object. 1126 1129 template<class T> 1127 1130 BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1262 1265 /// 1263 1266 /// The type of the map that indicates which nodes are reached. 1264 /// It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.1267 /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 1265 1268 typedef typename Digraph::template NodeMap<bool> ReachedMap; 1266 1269 … … 1423 1426 /// The simplest way to execute the BFS algorithm is to use one of the 1424 1427 /// member functions called \ref run(Node) "run()".\n 1425 /// If you need better control on the execution,you have to call1426 /// \ref init() first, then you can add several source nodes with1428 /// If you need more control on the execution, first you have to call 1429 /// \ref init(), then you can add several source nodes with 1427 1430 /// \ref addSource(). Finally the actual path computation can be 1428 1431 /// performed with one of the \ref start() functions. … … 1733 1736 ///@{ 1734 1737 1735 /// \brief Checks if the givennode is reached from the root(s).1738 /// \brief Checks if a node is reached from the root(s). 1736 1739 /// 1737 1740 /// Returns \c true if \c v is reached from the root(s). -
lemon/bin_heap.h
r758 r730 20 20 #define LEMON_BIN_HEAP_H 21 21 22 ///\ingroup heaps22 ///\ingroup auxdat 23 23 ///\file 24 ///\brief Binary heap implementation.24 ///\brief Binary Heap implementation. 25 25 26 26 #include <vector> … … 30 30 namespace lemon { 31 31 32 /// \ingroup heaps 33 /// 34 /// \brief Binary heap data structure. 35 /// 36 /// This class implements the \e binary \e heap data structure. 37 /// It fully conforms to the \ref concepts::Heap "heap concept". 38 /// 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 32 ///\ingroup auxdat 33 /// 34 ///\brief A Binary Heap implementation. 35 /// 36 ///This class implements the \e binary \e heap data structure. 37 /// 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 47 52 template <typename PR, typename IM, typename CMP = std::less<PR> > 48 #endif49 53 class BinHeap { 54 50 55 public: 51 52 /// Type of the item-int map. 56 ///\e 53 57 typedef IM ItemIntMap; 54 /// Type of the priorities.58 ///\e 55 59 typedef PR Prio; 56 /// Type of the items stored in the heap.60 ///\e 57 61 typedef typename ItemIntMap::Key Item; 58 /// Type of the item-priority pairs.62 ///\e 59 63 typedef std::pair<Item,Prio> Pair; 60 /// Functor type for comparing the priorities.64 ///\e 61 65 typedef CMP Compare; 62 66 63 /// \brief Type to represent the states of the items.64 /// 65 /// Each item has a state associated to it. It canbe "in heap",66 /// "pre -heap" or "post-heap". The latter two are indifferent from the67 /// \brief Type to represent the items states. 68 /// 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 67 71 /// heap's point of view, but may be useful to the user. 68 72 /// … … 81 85 82 86 public: 83 84 /// \brief Constructor. 85 /// 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. 87 /// \brief The constructor. 88 /// 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. 90 93 explicit BinHeap(ItemIntMap &map) : _iim(map) {} 91 94 92 /// \brief Constructor. 93 /// 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. 95 /// \brief The constructor. 96 /// 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. 99 103 BinHeap(ItemIntMap &map, const Compare &comp) 100 104 : _iim(map), _comp(comp) {} 101 105 102 106 103 /// \briefThe number of items stored in the heap.104 /// 105 /// This function returns the number of items stored in the heap.107 /// The number of items stored in the heap. 108 /// 109 /// \brief Returns the number of items stored in the heap. 106 110 int size() const { return _data.size(); } 107 111 108 /// \brief Check if the heap is empty.109 /// 110 /// This function returns \c true if the heap is empty.112 /// \brief Checks if the heap stores no items. 113 /// 114 /// Returns \c true if and only if the heap stores no items. 111 115 bool empty() const { return _data.empty(); } 112 116 113 /// \brief Make the heap empty. 114 /// 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. 117 /// \brief Make empty this heap. 118 /// 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. 120 123 void clear() { 121 124 _data.clear(); … … 125 128 static int parent(int i) { return (i-1)/2; } 126 129 127 static int second Child(int i) { return 2*i+2; }130 static int second_child(int i) { return 2*i+2; } 128 131 bool less(const Pair &p1, const Pair &p2) const { 129 132 return _comp(p1.second, p2.second); 130 133 } 131 134 132 int bubble Up(int hole, Pair p) {135 int bubble_up(int hole, Pair p) { 133 136 int par = parent(hole); 134 137 while( hole>0 && less(p,_data[par]) ) { … … 141 144 } 142 145 143 int bubble Down(int hole, Pair p, int length) {144 int child = second Child(hole);146 int bubble_down(int hole, Pair p, int length) { 147 int child = second_child(hole); 145 148 while(child < length) { 146 149 if( less(_data[child-1], _data[child]) ) { … … 151 154 move(_data[child], hole); 152 155 hole = child; 153 child = second Child(hole);156 child = second_child(hole); 154 157 } 155 158 child--; … … 169 172 170 173 public: 171 172 174 /// \brief Insert a pair of item and priority into the heap. 173 175 /// 174 /// This function inserts \c p.first to the heap with priority 175 /// \c p.second. 176 /// Adds \c p.first to the heap with priority \c p.second. 176 177 /// \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 bubbleUp(n, p); 182 } 183 184 /// \brief Insert an item into the heap with the given priority. 185 /// 186 /// This function inserts the given item into the heap with the 187 /// given priority. 181 bubble_up(n, p); 182 } 183 184 /// \brief Insert an item into the heap with the given heap. 185 /// 186 /// Adds \c i to the heap with priority \c p. 188 187 /// \param i The item to insert. 189 188 /// \param p The priority of the item. 190 /// \pre \e i must not be stored in the heap.191 189 void push(const Item &i, const Prio &p) { push(Pair(i,p)); } 192 190 193 /// \brief Return the item having minimum priority. 194 /// 195 /// This function returns the item having minimum priority. 196 /// \pre The heap must be non-empty. 191 /// \brief Returns the item with minimum priority relative to \c Compare. 192 /// 193 /// This method returns the item with minimum priority relative to \c 194 /// Compare. 195 /// \pre The heap must be nonempty. 197 196 Item top() const { 198 197 return _data[0].first; 199 198 } 200 199 201 /// \brief The minimum priority.202 /// 203 /// This function returns the minimum priority.204 /// \pre The heap must be non -empty.200 /// \brief Returns the minimum priority relative to \c Compare. 201 /// 202 /// It returns the minimum priority relative to \c Compare. 203 /// \pre The heap must be nonempty. 205 204 Prio prio() const { 206 205 return _data[0].second; 207 206 } 208 207 209 /// \brief Remove the item having minimum priority. 210 /// 211 /// This function removes the item having minimum priority. 208 /// \brief Deletes the item with minimum priority relative to \c Compare. 209 /// 210 /// This method deletes the item with minimum priority relative to \c 211 /// Compare from the heap. 212 212 /// \pre The heap must be non-empty. 213 213 void pop() { … … 215 215 _iim.set(_data[0].first, POST_HEAP); 216 216 if (n > 0) { 217 bubble Down(0, _data[n], n);217 bubble_down(0, _data[n], n); 218 218 } 219 219 _data.pop_back(); 220 220 } 221 221 222 /// \brief Remove the given item from the heap. 223 /// 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. 222 /// \brief Deletes \c i from the heap. 223 /// 224 /// This method deletes item \c i from the heap. 225 /// \param i The item to erase. 226 /// \pre The item should be in the heap. 228 227 void erase(const Item &i) { 229 228 int h = _iim[i]; … … 231 230 _iim.set(_data[h].first, POST_HEAP); 232 231 if( h < n ) { 233 if ( bubble Up(h, _data[n]) == h) {234 bubble Down(h, _data[n], n);232 if ( bubble_up(h, _data[n]) == h) { 233 bubble_down(h, _data[n], n); 235 234 } 236 235 } … … 238 237 } 239 238 240 /// \brief The priority of the given item. 241 /// 242 /// This function returns the priority of the given item. 243 /// \param i The item. 244 /// \pre \e i must be in the heap. 239 240 /// \brief Returns the priority of \c i. 241 /// 242 /// This function returns the priority of item \c i. 243 /// \param i The item. 244 /// \pre \c i must be in the heap. 245 245 Prio operator[](const Item &i) const { 246 246 int idx = _iim[i]; … … 248 248 } 249 249 250 /// \brief Set the priority of an item or insert it, if it is 251 /// not stored in the heap. 252 /// 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. 250 /// \brief \c i gets to the heap with priority \c p independently 251 /// if \c i was already there. 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. 256 255 /// \param i The item. 257 256 /// \param p The priority. … … 262 261 } 263 262 else if( _comp(p, _data[idx].second) ) { 264 bubble Up(idx, Pair(i,p));263 bubble_up(idx, Pair(i,p)); 265 264 } 266 265 else { 267 bubble Down(idx, Pair(i,p), _data.size());268 } 269 } 270 271 /// \brief Decrease the priority of an item to the given value.272 /// 273 /// This function decreases the priority of an item to the given value.266 bubble_down(idx, Pair(i,p), _data.size()); 267 } 268 } 269 270 /// \brief Decreases the priority of \c i to \c p. 271 /// 272 /// This method decreases the priority of item \c i to \c p. 274 273 /// \param i The item. 275 274 /// \param p The priority. 276 /// \pre \e i must be stored in the heap with priority at least \e p. 275 /// \pre \c i must be stored in the heap with priority at least \c 276 /// p relative to \c Compare. 277 277 void decrease(const Item &i, const Prio &p) { 278 278 int idx = _iim[i]; 279 bubble Up(idx, Pair(i,p));280 } 281 282 /// \brief Increase the priority of an item to the given value.283 /// 284 /// This function increases the priority of an item to the given value.279 bubble_up(idx, Pair(i,p)); 280 } 281 282 /// \brief Increases the priority of \c i to \c p. 283 /// 284 /// This method sets the priority of item \c i to \c p. 285 285 /// \param i The item. 286 286 /// \param p The priority. 287 /// \pre \e i must be stored in the heap with priority at most \e p. 287 /// \pre \c i must be stored in the heap with priority at most \c 288 /// p relative to \c Compare. 288 289 void increase(const Item &i, const Prio &p) { 289 290 int idx = _iim[i]; 290 bubble Down(idx, Pair(i,p), _data.size());291 } 292 293 /// \brief Return the state of an item.294 /// 295 /// This method returns \c PRE_HEAP if the given item has never296 /// 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 back299 /// to the heap again.291 bubble_down(idx, Pair(i,p), _data.size()); 292 } 293 294 /// \brief Returns if \c item is in, has already been in, or has 295 /// never been in the heap. 296 /// 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. 300 301 /// \param i The item. 301 302 State state(const Item &i) const { … … 306 307 } 307 308 308 /// \brief Set the state of anitem in the heap.309 /// 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 important312 /// to achivebetter time complexity.309 /// \brief Sets the state of the \c item in the heap. 310 /// 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 /// better time complexity. 313 314 /// \param i The item. 314 315 /// \param st The state. It should not be \c IN_HEAP. … … 327 328 } 328 329 329 /// \brief Replace an item in the heap. 330 /// 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. 330 /// \brief Replaces an item in the heap. 331 /// 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. 336 336 void replace(const Item& i, const Item& j) { 337 337 int idx = _iim[i]; -
lemon/bits/map_extender.h
r765 r664 50 50 typedef typename Parent::ConstReference ConstReference; 51 51 52 typedef typename Parent::ReferenceMapTag ReferenceMapTag;53 54 52 class MapIt; 55 53 class ConstMapIt; … … 194 192 typedef typename Parent::ConstReference ConstReference; 195 193 196 typedef typename Parent::ReferenceMapTag ReferenceMapTag;197 198 194 class MapIt; 199 195 class ConstMapIt; -
lemon/bucket_heap.h
r758 r730 20 20 #define LEMON_BUCKET_HEAP_H 21 21 22 ///\ingroup heaps22 ///\ingroup auxdat 23 23 ///\file 24 ///\brief Bucket heap implementation.24 ///\brief Bucket Heap implementation. 25 25 26 26 #include <vector> … … 54 54 } 55 55 56 /// \ingroup heaps 57 /// 58 /// \brief Bucket heap data structure. 59 /// 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. 63 /// 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 56 /// \ingroup auxdat 57 /// 58 /// \brief A Bucket Heap implementation. 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 priorities are small. It is not intended to use as dijkstra heap. 67 /// 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 /// prio() member functions. 78 73 template <typename IM, bool MIN = true> 79 74 class BucketHeap { 80 75 81 76 public: 82 83 /// Type of the item-int map. 77 /// \e 78 typedef typename IM::Key Item; 79 /// \e 80 typedef int Prio; 81 /// \e 82 typedef std::pair<Item, Prio> Pair; 83 /// \e 84 84 typedef IM ItemIntMap; 85 /// Type of the priorities.86 typedef int Prio;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;91 85 92 86 private: … … 96 90 public: 97 91 98 /// \brief Type to represent the states of the items.99 /// 100 /// Each item has a state associated to it. It canbe "in heap",101 /// "pre -heap" or "post-heap". The latter two are indifferent from the92 /// \brief Type to represent the items states. 93 /// 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 102 96 /// heap's point of view, but may be useful to the user. 103 97 /// … … 111 105 112 106 public: 113 114 /// \brief Constructor. 115 /// 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. 107 /// \brief The constructor. 108 /// 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. 120 113 explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {} 121 114 122 /// \briefThe number of items stored in the heap.123 /// 124 /// This function returns the number of items stored in the heap.115 /// The number of items stored in the heap. 116 /// 117 /// \brief Returns the number of items stored in the heap. 125 118 int size() const { return _data.size(); } 126 119 127 /// \brief Check if the heap is empty.128 /// 129 /// This function returns \c true if the heap is empty.120 /// \brief Checks if the heap stores no items. 121 /// 122 /// Returns \c true if and only if the heap stores no items. 130 123 bool empty() const { return _data.empty(); } 131 124 132 /// \brief Make the heap empty. 133 /// 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. 125 /// \brief Make empty this heap. 126 /// 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. 139 131 void clear() { 140 132 _data.clear(); _first.clear(); _minimum = 0; … … 143 135 private: 144 136 145 void relocate Last(int idx) {137 void relocate_last(int idx) { 146 138 if (idx + 1 < int(_data.size())) { 147 139 _data[idx] = _data.back(); … … 183 175 184 176 public: 185 186 177 /// \brief Insert a pair of item and priority into the heap. 187 178 /// 188 /// This function inserts \c p.first to the heap with priority 189 /// \c p.second. 179 /// Adds \c p.first to the heap with priority \c p.second. 190 180 /// \param p The pair to insert. 191 /// \pre \c p.first must not be stored in the heap.192 181 void push(const Pair& p) { 193 182 push(p.first, p.second); … … 196 185 /// \brief Insert an item into the heap with the given priority. 197 186 /// 198 /// This function inserts the given item into the heap with the 199 /// given priority. 187 /// Adds \c i to the heap with priority \c p. 200 188 /// \param i The item to insert. 201 189 /// \param p The priority of the item. 202 /// \pre \e i must not be stored in the heap.203 190 void push(const Item &i, const Prio &p) { 204 191 int idx = _data.size(); … … 211 198 } 212 199 213 /// \brief Return the item havingminimum priority.214 /// 215 /// This function returns the item havingminimum priority.216 /// \pre The heap must be non -empty.200 /// \brief Returns the item with minimum priority. 201 /// 202 /// This method returns the item with minimum priority. 203 /// \pre The heap must be nonempty. 217 204 Item top() const { 218 205 while (_first[_minimum] == -1) { … … 222 209 } 223 210 224 /// \brief The minimum priority.225 /// 226 /// This functionreturns the minimum priority.227 /// \pre The heap must be non -empty.211 /// \brief Returns the minimum priority. 212 /// 213 /// It returns the minimum priority. 214 /// \pre The heap must be nonempty. 228 215 Prio prio() const { 229 216 while (_first[_minimum] == -1) { … … 233 220 } 234 221 235 /// \brief Remove the item havingminimum priority.236 /// 237 /// This function removes the item having minimum priority.222 /// \brief Deletes the item with minimum priority. 223 /// 224 /// This method deletes the item with minimum priority from the heap. 238 225 /// \pre The heap must be non-empty. 239 226 void pop() { … … 244 231 _iim[_data[idx].item] = -2; 245 232 unlace(idx); 246 relocateLast(idx); 247 } 248 249 /// \brief Remove the given item from the heap. 250 /// 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. 233 relocate_last(idx); 234 } 235 236 /// \brief Deletes \c i from the heap. 237 /// 238 /// This method deletes item \c i from the heap, if \c i was 239 /// already stored in the heap. 240 /// \param i The item to erase. 255 241 void erase(const Item &i) { 256 242 int idx = _iim[i]; 257 243 _iim[_data[idx].item] = -2; 258 244 unlace(idx); 259 relocateLast(idx); 260 } 261 262 /// \brief The priority of the given item. 263 /// 264 /// This function returns the priority of the given item. 265 /// \param i The item. 266 /// \pre \e i must be in the heap. 245 relocate_last(idx); 246 } 247 248 249 /// \brief Returns the priority of \c i. 250 /// 251 /// This function returns the priority of item \c i. 252 /// \pre \c i must be in the heap. 253 /// \param i The item. 267 254 Prio operator[](const Item &i) const { 268 255 int idx = _iim[i]; … … 270 257 } 271 258 272 /// \brief Set the priority of an item or insert it, if it is 273 /// not stored in the heap. 274 /// 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. 259 /// \brief \c i gets to the heap with priority \c p independently 260 /// if \c i was already there. 261 /// 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. 278 264 /// \param i The item. 279 265 /// \param p The priority. … … 289 275 } 290 276 291 /// \brief Decrease the priority of an item to the given value. 292 /// 293 /// This function decreases the priority of an item to the given value. 277 /// \brief Decreases the priority of \c i to \c p. 278 /// 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 /// p relative to \c Compare. 294 282 /// \param i The item. 295 283 /// \param p The priority. 296 /// \pre \e i must be stored in the heap with priority at least \e p.297 284 void decrease(const Item &i, const Prio &p) { 298 285 int idx = _iim[i]; … … 305 292 } 306 293 307 /// \brief Increase the priority of an item to the given value. 308 /// 309 /// This function increases the priority of an item to the given value. 294 /// \brief Increases the priority of \c i to \c p. 295 /// 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 /// p relative to \c Compare. 310 299 /// \param i The item. 311 300 /// \param p The priority. 312 /// \pre \e i must be stored in the heap with priority at most \e p.313 301 void increase(const Item &i, const Prio &p) { 314 302 int idx = _iim[i]; … … 318 306 } 319 307 320 /// \brief Return the state of an item.321 /// 322 /// This method returns \c PRE_HEAP if the given item has never323 /// 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 back326 /// to the heap again.308 /// \brief Returns if \c item is in, has already been in, or has 309 /// never been in the heap. 310 /// 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. 327 315 /// \param i The item. 328 316 State state(const Item &i) const { … … 332 320 } 333 321 334 /// \brief Set the state of anitem in the heap.335 /// 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 important338 /// to achivebetter time complexity.322 /// \brief Sets the state of the \c item in the heap. 323 /// 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 /// better time complexity. 339 327 /// \param i The item. 340 328 /// \param st The state. It should not be \c IN_HEAP. … … 372 360 }; // class BucketHeap 373 361 374 /// \ingroup heaps375 /// 376 /// \brief Simplified bucket heap data structure.362 /// \ingroup auxdat 363 /// 364 /// \brief A Simplified Bucket Heap implementation. 377 365 /// 378 366 /// This class implements a simplified \e bucket \e heap data 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. 385 /// 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. 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. 373 /// 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 /// prio() member functions. 397 379 /// 398 380 /// \sa BucketHeap … … 401 383 402 384 public: 403 404 /// Type of the item-int map. 385 typedef typename IM::Key Item; 386 typedef int Prio; 387 typedef std::pair<Item, Prio> Pair; 405 388 typedef IM ItemIntMap; 406 /// Type of the priorities.407 typedef int Prio;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;412 389 413 390 private: … … 417 394 public: 418 395 419 /// \brief Type to represent the states of the items.420 /// 421 /// Each item has a state associated to it. It canbe "in heap",422 /// "pre -heap" or "post-heap". The latter two are indifferent from the396 /// \brief Type to represent the items states. 397 /// 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 423 400 /// heap's point of view, but may be useful to the user. 424 401 /// … … 433 410 public: 434 411 435 /// \brief Constructor.436 /// 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.412 /// \brief The constructor. 413 /// 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. 441 418 explicit SimpleBucketHeap(ItemIntMap &map) 442 419 : _iim(map), _free(-1), _num(0), _minimum(0) {} 443 420 444 /// \brief The number of items stored in the heap.445 /// 446 /// Th is function returns the number of items stored in the heap.421 /// \brief Returns the number of items stored in the heap. 422 /// 423 /// The number of items stored in the heap. 447 424 int size() const { return _num; } 448 425 449 /// \brief Check if the heap is empty.450 /// 451 /// This function returns \c true if the heap is empty.426 /// \brief Checks if the heap stores no items. 427 /// 428 /// Returns \c true if and only if the heap stores no items. 452 429 bool empty() const { return _num == 0; } 453 430 454 /// \brief Make the heap empty. 455 /// 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. 431 /// \brief Make empty this heap. 432 /// 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. 461 437 void clear() { 462 438 _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0; … … 465 441 /// \brief Insert a pair of item and priority into the heap. 466 442 /// 467 /// This function inserts \c p.first to the heap with priority 468 /// \c p.second. 443 /// Adds \c p.first to the heap with priority \c p.second. 469 444 /// \param p The pair to insert. 470 /// \pre \c p.first must not be stored in the heap.471 445 void push(const Pair& p) { 472 446 push(p.first, p.second); … … 475 449 /// \brief Insert an item into the heap with the given priority. 476 450 /// 477 /// This function inserts the given item into the heap with the 478 /// given priority. 451 /// Adds \c i to the heap with priority \c p. 479 452 /// \param i The item to insert. 480 453 /// \param p The priority of the item. 481 /// \pre \e i must not be stored in the heap.482 454 void push(const Item &i, const Prio &p) { 483 455 int idx; … … 500 472 } 501 473 502 /// \brief Return the item havingminimum priority.503 /// 504 /// This function returns the item havingminimum priority.505 /// \pre The heap must be non -empty.474 /// \brief Returns the item with minimum priority. 475 /// 476 /// This method returns the item with minimum priority. 477 /// \pre The heap must be nonempty. 506 478 Item top() const { 507 479 while (_first[_minimum] == -1) { … … 511 483 } 512 484 513 /// \brief The minimum priority.514 /// 515 /// This functionreturns the minimum priority.516 /// \pre The heap must be non -empty.485 /// \brief Returns the minimum priority. 486 /// 487 /// It returns the minimum priority. 488 /// \pre The heap must be nonempty. 517 489 Prio prio() const { 518 490 while (_first[_minimum] == -1) { … … 522 494 } 523 495 524 /// \brief Remove the item havingminimum priority.525 /// 526 /// This function removes the item having minimum priority.496 /// \brief Deletes the item with minimum priority. 497 /// 498 /// This method deletes the item with minimum priority from the heap. 527 499 /// \pre The heap must be non-empty. 528 500 void pop() { … … 538 510 } 539 511 540 /// \brief The priority of the given item. 541 /// 542 /// This function returns the priority of the given item. 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. 512 /// \brief Returns the priority of \c i. 513 /// 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 /// \pre \c i must be in the heap. 519 /// \param i The item. 547 520 Prio operator[](const Item &i) const { 548 for (int k = 0; k < int(_first.size()); ++k) {521 for (int k = 0; k < _first.size(); ++k) { 549 522 int idx = _first[k]; 550 523 while (idx != -1) { … … 558 531 } 559 532 560 /// \brief Return the state of an item.561 /// 562 /// This method returns \c PRE_HEAP if the given item has never563 /// 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 back566 /// to the heap again.533 /// \brief Returns if \c item is in, has already been in, or has 534 /// never been in the heap. 535 /// 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. 567 540 /// \param i The item. 568 541 State state(const Item &i) const { -
lemon/circulation.h
r762 r688 73 73 /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" 74 74 /// concept. 75 #ifdef DOXYGEN76 typedef GR::ArcMap<Value> FlowMap;77 #else78 75 typedef typename Digraph::template ArcMap<Value> FlowMap; 79 #endif80 76 81 77 /// \brief Instantiates a FlowMap. … … 92 88 /// The elevator type used by the algorithm. 93 89 /// 94 /// \sa Elevator, LinkedElevator 95 #ifdef DOXYGEN 96 typedef lemon::Elevator<GR, GR::Node> Elevator; 97 #else 90 /// \sa Elevator 91 /// \sa LinkedElevator 98 92 typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator; 99 #endif100 93 101 94 /// \brief Instantiates an Elevator. … … 458 451 } 459 452 460 /// \brief Sets the tolerance used by the algorithm. 461 /// 462 /// Sets the tolerance object used by the algorithm. 463 /// \return <tt>(*this)</tt> 464 Circulation& tolerance(const Tolerance& tolerance) { 453 /// \brief Sets the tolerance used by algorithm. 454 /// 455 /// Sets the tolerance used by algorithm. 456 Circulation& tolerance(const Tolerance& tolerance) const { 465 457 _tol = tolerance; 466 458 return *this; … … 469 461 /// \brief Returns a const reference to the tolerance. 470 462 /// 471 /// Returns a const reference to the tolerance object used by 472 /// the algorithm. 463 /// Returns a const reference to the tolerance. 473 464 const Tolerance& tolerance() const { 474 return _tol;465 return tolerance; 475 466 } 476 467 477 468 /// \name Execution Control 478 469 /// The simplest way to execute the algorithm is to call \ref run().\n 479 /// If you need bettercontrol on the initial solution or the execution,480 /// you have to call one of the \ref init() functions first, then470 /// 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 481 472 /// the \ref start() function. 482 473 -
lemon/concepts/heap.h
r757 r631 17 17 */ 18 18 19 #ifndef LEMON_CONCEPTS_HEAP_H20 #define LEMON_CONCEPTS_HEAP_H21 22 19 ///\ingroup concept 23 20 ///\file 24 21 ///\brief The concept of heaps. 25 22 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> … … 36 36 /// \brief The heap concept. 37 37 /// 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. 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 /// item, add or erase an item, etc. 45 43 /// 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 44 /// \tparam PR Type of the priority of the items. 45 /// \tparam IM A read and writable item map with int values, used 52 46 /// internally to handle the cross references. 53 /// \tparam C MP A functor class for comparingthe priorities.47 /// \tparam Comp A functor class for the ordering of the priorities. 54 48 /// The default is \c std::less<PR>. 55 49 #ifdef DOXYGEN 56 template <typename PR, typename IM, typename C MP>50 template <typename PR, typename IM, typename Comp = std::less<PR> > 57 51 #else 58 template <typename PR, typename IM , typename CMP = std::less<PR>>52 template <typename PR, typename IM> 59 53 #endif 60 54 class Heap { … … 71 65 /// 72 66 /// Each item has a state associated to it. It can be "in heap", 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. 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 /// the user. 75 70 /// 76 71 /// The item-int map must be initialized in such way that it assigns … … 78 73 enum State { 79 74 IN_HEAP = 0, ///< = 0. The "in heap" state constant. 80 PRE_HEAP = -1, ///< = -1. The "pre -heap" state constant.81 POST_HEAP = -2 ///< = -2. The "post -heap" state constant.75 PRE_HEAP = -1, ///< = -1. The "pre heap" state constant. 76 POST_HEAP = -2 ///< = -2. The "post heap" state constant. 82 77 }; 83 78 84 /// \brief Constructor.85 /// 86 /// Constructor.79 /// \brief The constructor. 80 /// 81 /// The constructor. 87 82 /// \param map A map that assigns \c int values to keys of type 88 83 /// \c Item. It is used internally by the heap implementations to 89 84 /// handle the cross references. The assigned value must be 90 /// \c PRE_HEAP (<tt>-1</tt>) for e achitem.85 /// \c PRE_HEAP (<tt>-1</tt>) for every item. 91 86 explicit Heap(ItemIntMap &map) {} 92 87 93 /// \brief Constructor.94 ///95 /// Constructor.96 /// \param map A map that assigns \c int values to keys of type97 /// \c Item. It is used internally by the heap implementations to98 /// handle the cross references. The assigned value must be99 /// \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 103 88 /// \brief The number of items stored in the heap. 104 89 /// 105 /// This function returns the number of items stored in the heap.90 /// Returns the number of items stored in the heap. 106 91 int size() const { return 0; } 107 92 108 /// \brief Check if the heap is empty.109 /// 110 /// This function returns \c true if the heap is empty.93 /// \brief Checks if the heap is empty. 94 /// 95 /// Returns \c true if the heap is empty. 111 96 bool empty() const { return false; } 112 97 113 /// \brief Make the heap empty. 114 /// 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() {} 121 122 /// \brief Insert an item into the heap with the given priority. 123 /// 124 /// This function inserts the given item into the heap with the 125 /// given priority. 98 /// \brief Makes the heap empty. 99 /// 100 /// Makes the heap empty. 101 void clear(); 102 103 /// \brief Inserts an item into the heap with the given priority. 104 /// 105 /// Inserts the given item into the heap with the given priority. 126 106 /// \param i The item to insert. 127 107 /// \param p The priority of the item. 128 /// \pre \e i must not be stored in the heap.129 108 void push(const Item &i, const Prio &p) {} 130 109 131 /// \brief Return the item having minimum priority.132 /// 133 /// This function returns the item having minimum priority.110 /// \brief Returns the item having minimum priority. 111 /// 112 /// Returns the item having minimum priority. 134 113 /// \pre The heap must be non-empty. 135 114 Item top() const {} … … 137 116 /// \brief The minimum priority. 138 117 /// 139 /// This function returns the minimum priority.118 /// Returns the minimum priority. 140 119 /// \pre The heap must be non-empty. 141 120 Prio prio() const {} 142 121 143 /// \brief Remove the item having minimum priority.144 /// 145 /// This function removes the item having minimum priority.122 /// \brief Removes the item having minimum priority. 123 /// 124 /// Removes the item having minimum priority. 146 125 /// \pre The heap must be non-empty. 147 126 void pop() {} 148 127 149 /// \brief Remove the given item from the heap. 150 /// 151 /// This function removes the given item from the heap if it is 152 /// already stored. 128 /// \brief Removes an item from the heap. 129 /// 130 /// Removes the given item from the heap if it is already stored. 153 131 /// \param i The item to delete. 154 /// \pre \e i must be in the heap.155 132 void erase(const Item &i) {} 156 133 157 /// \brief The priority of the given item.158 /// 159 /// This function returns the priority of the given item.160 /// \param i The item. 161 /// \pre \ ei must be in the heap.134 /// \brief The priority of an item. 135 /// 136 /// Returns the priority of the given item. 137 /// \param i The item. 138 /// \pre \c i must be in the heap. 162 139 Prio operator[](const Item &i) const {} 163 140 164 /// \brief Set the priority of an item or insertit, if it is141 /// \brief Sets the priority of an item or inserts it, if it is 165 142 /// not stored in the heap. 166 143 /// 167 144 /// This method sets the priority of the given item if it is 168 /// already stored in the heap. Otherwise it inserts the given169 /// item into the heapwith the given priority.145 /// already stored in the heap. 146 /// Otherwise it inserts the given item with the given priority. 170 147 /// 171 148 /// \param i The item. … … 173 150 void set(const Item &i, const Prio &p) {} 174 151 175 /// \brief Decrease the priority of an item to the given value.176 /// 177 /// This function decreases the priority of an item to the given value.152 /// \brief Decreases the priority of an item to the given value. 153 /// 154 /// Decreases the priority of an item to the given value. 178 155 /// \param i The item. 179 156 /// \param p The priority. 180 /// \pre \ e i must be stored in the heap with priority at least \ep.157 /// \pre \c i must be stored in the heap with priority at least \c p. 181 158 void decrease(const Item &i, const Prio &p) {} 182 159 183 /// \brief Increase the priority of an item to the given value.184 /// 185 /// This function increases the priority of an item to the given value.160 /// \brief Increases the priority of an item to the given value. 161 /// 162 /// Increases the priority of an item to the given value. 186 163 /// \param i The item. 187 164 /// \param p The priority. 188 /// \pre \ e i must be stored in the heap with priority at most \ep.165 /// \pre \c i must be stored in the heap with priority at most \c p. 189 166 void increase(const Item &i, const Prio &p) {} 190 167 191 /// \brief Return the state of an item. 168 /// \brief Returns if an item is in, has already been in, or has 169 /// never been in the heap. 192 170 /// 193 171 /// This method returns \c PRE_HEAP if the given item has never … … 199 177 State state(const Item &i) const {} 200 178 201 /// \brief Set the state of an item in the heap.202 /// 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 important205 /// to achivebetter time complexity.179 /// \brief Sets the state of an item in the heap. 180 /// 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 /// better time complexity. 206 184 /// \param i The item. 207 185 /// \param st The state. It should not be \c IN_HEAP. -
lemon/concepts/maps.h
r765 r576 183 183 template<typename _ReferenceMap> 184 184 struct Constraints { 185 typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type 186 constraints() { 185 void constraints() { 187 186 checkConcept<ReadWriteMap<K, T>, _ReferenceMap >(); 188 187 ref = m[key]; -
lemon/dfs.h
r764 r631 48 48 ///The type of the map that stores the predecessor 49 49 ///arcs of the %DFS paths. 50 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.50 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 51 51 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 52 52 ///Instantiates a \c PredMap. … … 63 63 64 64 ///The type of the map that indicates which nodes are processed. 65 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 66 ///By default it is a NullMap. 65 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 67 66 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; 68 67 ///Instantiates a \c ProcessedMap. … … 83 82 84 83 ///The type of the map that indicates which nodes are reached. 85 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.84 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 86 85 typedef typename Digraph::template NodeMap<bool> ReachedMap; 87 86 ///Instantiates a \c ReachedMap. … … 98 97 99 98 ///The type of the map that stores the distances of the nodes. 100 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.99 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 101 100 typedef typename Digraph::template NodeMap<int> DistMap; 102 101 ///Instantiates a \c DistMap. … … 226 225 ///\ref named-templ-param "Named parameter" for setting 227 226 ///\c PredMap type. 228 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.227 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 229 228 template <class T> 230 229 struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > { … … 246 245 ///\ref named-templ-param "Named parameter" for setting 247 246 ///\c DistMap type. 248 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.247 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 249 248 template <class T> 250 249 struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > { … … 266 265 ///\ref named-templ-param "Named parameter" for setting 267 266 ///\c ReachedMap type. 268 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.267 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 269 268 template <class T> 270 269 struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > { … … 286 285 ///\ref named-templ-param "Named parameter" for setting 287 286 ///\c ProcessedMap type. 288 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.287 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 289 288 template <class T> 290 289 struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > { … … 413 412 ///The simplest way to execute the DFS algorithm is to use one of the 414 413 ///member functions called \ref run(Node) "run()".\n 415 ///If you need better control on the execution,you have to call416 ///\ref init() first, then you can add a source node with \ref addSource()414 ///If you need more control on the execution, first you have to call 415 ///\ref init(), then you can add a source node with \ref addSource() 417 416 ///and perform the actual computation with \ref start(). 418 417 ///This procedure can be repeated if there are nodes that have not … … 671 670 ///@{ 672 671 673 ///The DFS path to the givennode.674 675 ///Returns the DFS path to the given node from the root(s).672 ///The DFS path to a node. 673 674 ///Returns the DFS path to a node. 676 675 /// 677 676 ///\warning \c t should be reached from the root(s). … … 681 680 Path path(Node t) const { return Path(*G, *_pred, t); } 682 681 683 ///The distance of the givennode from the root(s).684 685 ///Returns the distance of the givennode from the root(s).682 ///The distance of a node from the root(s). 683 684 ///Returns the distance of a node from the root(s). 686 685 /// 687 686 ///\warning If node \c v is not reached from the root(s), then … … 692 691 int dist(Node v) const { return (*_dist)[v]; } 693 692 694 ///Returns the 'previous arc' of the %DFS tree for the givennode.693 ///Returns the 'previous arc' of the %DFS tree for a node. 695 694 696 695 ///This function returns the 'previous arc' of the %DFS tree for the … … 700 699 /// 701 700 ///The %DFS tree used here is equal to the %DFS tree used in 702 ///\ref predNode() and \ref predMap().701 ///\ref predNode(). 703 702 /// 704 703 ///\pre Either \ref run(Node) "run()" or \ref init() … … 706 705 Arc predArc(Node v) const { return (*_pred)[v];} 707 706 708 ///Returns the 'previous node' of the %DFS tree for the given node.707 ///Returns the 'previous node' of the %DFS tree. 709 708 710 709 ///This function returns the 'previous node' of the %DFS 711 710 ///tree for the node \c v, i.e. it returns the last but one node 712 /// ofa %DFS path from a root to \c v. It is \c INVALID711 ///from a %DFS path from a root to \c v. It is \c INVALID 713 712 ///if \c v is not reached from the root(s) or if \c v is a root. 714 713 /// 715 714 ///The %DFS tree used here is equal to the %DFS tree used in 716 ///\ref predArc() and \ref predMap().715 ///\ref predArc(). 717 716 /// 718 717 ///\pre Either \ref run(Node) "run()" or \ref init() … … 735 734 /// 736 735 ///Returns a const reference to the node map that stores the predecessor 737 ///arcs, which form the DFS tree (forest).736 ///arcs, which form the DFS tree. 738 737 /// 739 738 ///\pre Either \ref run(Node) "run()" or \ref init() … … 741 740 const PredMap &predMap() const { return *_pred;} 742 741 743 ///Checks if the given node.node is reached from the root(s).742 ///Checks if a node is reached from the root(s). 744 743 745 744 ///Returns \c true if \c v is reached from the root(s). … … 767 766 ///The type of the map that stores the predecessor 768 767 ///arcs of the %DFS paths. 769 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.768 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 770 769 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 771 770 ///Instantiates a PredMap. … … 782 781 783 782 ///The type of the map that indicates which nodes are processed. 784 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.783 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 785 784 ///By default it is a NullMap. 786 785 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 802 801 803 802 ///The type of the map that indicates which nodes are reached. 804 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.803 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 805 804 typedef typename Digraph::template NodeMap<bool> ReachedMap; 806 805 ///Instantiates a ReachedMap. … … 817 816 818 817 ///The type of the map that stores the distances of the nodes. 819 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.818 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 820 819 typedef typename Digraph::template NodeMap<int> DistMap; 821 820 ///Instantiates a DistMap. … … 832 831 833 832 ///The type of the DFS paths. 834 ///It must conform tothe \ref concepts::Path "Path" concept.833 ///It must meet the \ref concepts::Path "Path" concept. 835 834 typedef lemon::Path<Digraph> Path; 836 835 }; … … 838 837 /// Default traits class used by DfsWizard 839 838 840 /// Default traits class used by DfsWizard. 841 /// \tparam GR The type of the digraph. 839 /// To make it easier to use Dfs algorithm 840 /// we have created a wizard class. 841 /// This \ref DfsWizard class needs default traits, 842 /// as well as the \ref Dfs class. 843 /// The \ref DfsWizardBase is a class to be the default traits of the 844 /// \ref DfsWizard class. 842 845 template<class GR> 843 846 class DfsWizardBase : public DfsWizardDefaultTraits<GR> … … 867 870 /// Constructor. 868 871 869 /// This constructor does not require parameters, it initiates872 /// This constructor does not require parameters, therefore it initiates 870 873 /// all of the attributes to \c 0. 871 874 DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), … … 897 900 typedef TR Base; 898 901 902 ///The type of the digraph the algorithm runs on. 899 903 typedef typename TR::Digraph Digraph; 900 904 … … 904 908 typedef typename Digraph::OutArcIt OutArcIt; 905 909 910 ///\brief The type of the map that stores the predecessor 911 ///arcs of the DFS paths. 906 912 typedef typename TR::PredMap PredMap; 913 ///\brief The type of the map that stores the distances of the nodes. 907 914 typedef typename TR::DistMap DistMap; 915 ///\brief The type of the map that indicates which nodes are reached. 908 916 typedef typename TR::ReachedMap ReachedMap; 917 ///\brief The type of the map that indicates which nodes are processed. 909 918 typedef typename TR::ProcessedMap ProcessedMap; 919 ///The type of the DFS paths 910 920 typedef typename TR::Path Path; 911 921 … … 990 1000 SetPredMapBase(const TR &b) : TR(b) {} 991 1001 }; 992 993 ///\brief \ref named-templ-param "Named parameter" for setting 994 ///the predecessor map. 995 /// 996 ///\ref named-templ-param "Named parameter" function for setting 997 ///the map that stores the predecessor arcs of the nodes. 1002 ///\brief \ref named-func-param "Named parameter" 1003 ///for setting PredMap object. 1004 /// 1005 ///\ref named-func-param "Named parameter" 1006 ///for setting PredMap object. 998 1007 template<class T> 999 1008 DfsWizard<SetPredMapBase<T> > predMap(const T &t) … … 1009 1018 SetReachedMapBase(const TR &b) : TR(b) {} 1010 1019 }; 1011 1012 ///\brief \ref named-templ-param "Named parameter" for setting 1013 ///the reached map. 1014 /// 1015 ///\ref named-templ-param "Named parameter" function for setting 1016 ///the map that indicates which nodes are reached. 1020 ///\brief \ref named-func-param "Named parameter" 1021 ///for setting ReachedMap object. 1022 /// 1023 /// \ref named-func-param "Named parameter" 1024 ///for setting ReachedMap object. 1017 1025 template<class T> 1018 1026 DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t) … … 1028 1036 SetDistMapBase(const TR &b) : TR(b) {} 1029 1037 }; 1030 1031 ///\brief \ref named-templ-param "Named parameter" for setting 1032 ///the distance map. 1033 /// 1034 ///\ref named-templ-param "Named parameter" function for setting 1035 ///the map that stores the distances of the nodes calculated 1036 ///by the algorithm. 1038 ///\brief \ref named-func-param "Named parameter" 1039 ///for setting DistMap object. 1040 /// 1041 /// \ref named-func-param "Named parameter" 1042 ///for setting DistMap object. 1037 1043 template<class T> 1038 1044 DfsWizard<SetDistMapBase<T> > distMap(const T &t) … … 1048 1054 SetProcessedMapBase(const TR &b) : TR(b) {} 1049 1055 }; 1050 1051 ///\brief \ref named-func-param "Named parameter" for setting 1052 ///the processed map. 1053 /// 1054 ///\ref named-templ-param "Named parameter" function for setting 1055 ///the map that indicates which nodes are processed. 1056 ///\brief \ref named-func-param "Named parameter" 1057 ///for setting ProcessedMap object. 1058 /// 1059 /// \ref named-func-param "Named parameter" 1060 ///for setting ProcessedMap object. 1056 1061 template<class T> 1057 1062 DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1204 1209 /// 1205 1210 /// The type of the map that indicates which nodes are reached. 1206 /// It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.1211 /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 1207 1212 typedef typename Digraph::template NodeMap<bool> ReachedMap; 1208 1213 … … 1365 1370 /// The simplest way to execute the DFS algorithm is to use one of the 1366 1371 /// member functions called \ref run(Node) "run()".\n 1367 /// If you need better control on the execution,you have to call1368 /// \ref init() first, then you can add a source node with \ref addSource()1372 /// If you need more control on the execution, first you have to call 1373 /// \ref init(), then you can add a source node with \ref addSource() 1369 1374 /// and perform the actual computation with \ref start(). 1370 1375 /// This procedure can be repeated if there are nodes that have not … … 1616 1621 ///@{ 1617 1622 1618 /// \brief Checks if the givennode is reached from the root(s).1623 /// \brief Checks if a node is reached from the root(s). 1619 1624 /// 1620 1625 /// Returns \c true if \c v is reached from the root(s). -
lemon/dijkstra.h
r764 r631 71 71 72 72 ///The type of the map that stores the arc lengths. 73 ///It must conform tothe \ref concepts::ReadMap "ReadMap" concept.73 ///It must meet the \ref concepts::ReadMap "ReadMap" concept. 74 74 typedef LEN LengthMap; 75 ///The type of the arc lengths.75 ///The type of the length of the arcs. 76 76 typedef typename LEN::Value Value; 77 77 … … 117 117 ///The type of the map that stores the predecessor 118 118 ///arcs of the shortest paths. 119 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.119 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 120 120 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 121 121 ///Instantiates a \c PredMap. … … 132 132 133 133 ///The type of the map that indicates which nodes are processed. 134 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.134 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 135 135 ///By default it is a NullMap. 136 136 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 152 152 153 153 ///The type of the map that stores the distances of the nodes. 154 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.154 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 155 155 typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap; 156 156 ///Instantiates a \c DistMap. … … 169 169 /// \ingroup shortest_path 170 170 ///This class provides an efficient implementation of the %Dijkstra algorithm. 171 ///172 ///The %Dijkstra algorithm solves the single-source shortest path problem173 ///when all arc lengths are non-negative. If there are negative lengths,174 ///the BellmanFord algorithm should be used instead.175 171 /// 176 172 ///The arc lengths are passed to the algorithm using a … … 206 202 typedef typename TR::Digraph Digraph; 207 203 208 ///The type of the arc lengths.204 ///The type of the length of the arcs. 209 205 typedef typename TR::LengthMap::Value Value; 210 206 ///The type of the map that stores the arc lengths. … … 309 305 ///\ref named-templ-param "Named parameter" for setting 310 306 ///\c PredMap type. 311 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.307 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 312 308 template <class T> 313 309 struct SetPredMap … … 330 326 ///\ref named-templ-param "Named parameter" for setting 331 327 ///\c DistMap type. 332 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.328 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 333 329 template <class T> 334 330 struct SetDistMap … … 351 347 ///\ref named-templ-param "Named parameter" for setting 352 348 ///\c ProcessedMap type. 353 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.349 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 354 350 template <class T> 355 351 struct SetProcessedMap … … 448 444 ///\ref named-templ-param "Named parameter" for setting 449 445 ///\c OperationTraits type. 450 /// For more information see \ref DijkstraDefaultOperationTraits.451 446 template <class T> 452 447 struct SetOperationTraits … … 590 585 ///The simplest way to execute the %Dijkstra algorithm is to use 591 586 ///one of the member functions called \ref run(Node) "run()".\n 592 ///If you need better control on the execution,you have to call593 ///\ref init() first, then you can add several source nodes with587 ///If you need more control on the execution, first you have to call 588 ///\ref init(), then you can add several source nodes with 594 589 ///\ref addSource(). Finally the actual path computation can be 595 590 ///performed with one of the \ref start() functions. … … 807 802 ///The results of the %Dijkstra algorithm can be obtained using these 808 803 ///functions.\n 809 ///Either \ref run(Node) "run()" or \ref init() should be called804 ///Either \ref run(Node) "run()" or \ref start() should be called 810 805 ///before using them. 811 806 812 807 ///@{ 813 808 814 ///The shortest path to the givennode.815 816 ///Returns the shortest path to the given node from the root(s).809 ///The shortest path to a node. 810 811 ///Returns the shortest path to a node. 817 812 /// 818 813 ///\warning \c t should be reached from the root(s). … … 822 817 Path path(Node t) const { return Path(*G, *_pred, t); } 823 818 824 ///The distance of the givennode from the root(s).825 826 ///Returns the distance of the givennode from the root(s).819 ///The distance of a node from the root(s). 820 821 ///Returns the distance of a node from the root(s). 827 822 /// 828 823 ///\warning If node \c v is not reached from the root(s), then … … 833 828 Value dist(Node v) const { return (*_dist)[v]; } 834 829 835 ///\brief Returns the 'previous arc' of the shortest path tree for 836 ///the given node. 837 /// 830 ///Returns the 'previous arc' of the shortest path tree for a node. 831 838 832 ///This function returns the 'previous arc' of the shortest path 839 833 ///tree for the node \c v, i.e. it returns the last arc of a … … 842 836 /// 843 837 ///The shortest path tree used here is equal to the shortest path 844 ///tree used in \ref predNode() and \ref predMap().838 ///tree used in \ref predNode(). 845 839 /// 846 840 ///\pre Either \ref run(Node) "run()" or \ref init() … … 848 842 Arc predArc(Node v) const { return (*_pred)[v]; } 849 843 850 ///\brief Returns the 'previous node' of the shortest path tree for 851 ///the given node. 852 /// 844 ///Returns the 'previous node' of the shortest path tree for a node. 845 853 846 ///This function returns the 'previous node' of the shortest path 854 847 ///tree for the node \c v, i.e. it returns the last but one node 855 /// ofa shortest path from a root to \c v. It is \c INVALID848 ///from a shortest path from a root to \c v. It is \c INVALID 856 849 ///if \c v is not reached from the root(s) or if \c v is a root. 857 850 /// 858 851 ///The shortest path tree used here is equal to the shortest path 859 ///tree used in \ref predArc() and \ref predMap().852 ///tree used in \ref predArc(). 860 853 /// 861 854 ///\pre Either \ref run(Node) "run()" or \ref init() … … 878 871 /// 879 872 ///Returns a const reference to the node map that stores the predecessor 880 ///arcs, which form the shortest path tree (forest).873 ///arcs, which form the shortest path tree. 881 874 /// 882 875 ///\pre Either \ref run(Node) "run()" or \ref init() … … 884 877 const PredMap &predMap() const { return *_pred;} 885 878 886 ///Checks if the givennode is reached from the root(s).879 ///Checks if a node is reached from the root(s). 887 880 888 881 ///Returns \c true if \c v is reached from the root(s). … … 903 896 Heap::POST_HEAP; } 904 897 905 ///The current distance of the givennode from the root(s).906 907 ///Returns the current distance of the givennode from the root(s).898 ///The current distance of a node from the root(s). 899 900 ///Returns the current distance of a node from the root(s). 908 901 ///It may be decreased in the following processes. 909 902 /// … … 932 925 933 926 ///The type of the map that stores the arc lengths. 934 ///It must conform tothe \ref concepts::ReadMap "ReadMap" concept.927 ///It must meet the \ref concepts::ReadMap "ReadMap" concept. 935 928 typedef LEN LengthMap; 936 ///The type of the arc lengths.929 ///The type of the length of the arcs. 937 930 typedef typename LEN::Value Value; 938 931 … … 981 974 ///The type of the map that stores the predecessor 982 975 ///arcs of the shortest paths. 983 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.976 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 984 977 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 985 978 ///Instantiates a PredMap. … … 996 989 997 990 ///The type of the map that indicates which nodes are processed. 998 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.991 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 999 992 ///By default it is a NullMap. 1000 993 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 1016 1009 1017 1010 ///The type of the map that stores the distances of the nodes. 1018 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.1011 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 1019 1012 typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap; 1020 1013 ///Instantiates a DistMap. … … 1031 1024 1032 1025 ///The type of the shortest paths. 1033 ///It must conform tothe \ref concepts::Path "Path" concept.1026 ///It must meet the \ref concepts::Path "Path" concept. 1034 1027 typedef lemon::Path<Digraph> Path; 1035 1028 }; … … 1037 1030 /// Default traits class used by DijkstraWizard 1038 1031 1039 /// Default traits class used by DijkstraWizard. 1040 /// \tparam GR The type of the digraph. 1041 /// \tparam LEN The type of the length map. 1032 /// To make it easier to use Dijkstra algorithm 1033 /// we have created a wizard class. 1034 /// This \ref DijkstraWizard class needs default traits, 1035 /// as well as the \ref Dijkstra class. 1036 /// The \ref DijkstraWizardBase is a class to be the default traits of the 1037 /// \ref DijkstraWizard class. 1042 1038 template<typename GR, typename LEN> 1043 1039 class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN> … … 1098 1094 typedef TR Base; 1099 1095 1096 ///The type of the digraph the algorithm runs on. 1100 1097 typedef typename TR::Digraph Digraph; 1101 1098 … … 1105 1102 typedef typename Digraph::OutArcIt OutArcIt; 1106 1103 1104 ///The type of the map that stores the arc lengths. 1107 1105 typedef typename TR::LengthMap LengthMap; 1106 ///The type of the length of the arcs. 1108 1107 typedef typename LengthMap::Value Value; 1108 ///\brief The type of the map that stores the predecessor 1109 ///arcs of the shortest paths. 1109 1110 typedef typename TR::PredMap PredMap; 1111 ///The type of the map that stores the distances of the nodes. 1110 1112 typedef typename TR::DistMap DistMap; 1113 ///The type of the map that indicates which nodes are processed. 1111 1114 typedef typename TR::ProcessedMap ProcessedMap; 1115 ///The type of the shortest paths 1112 1116 typedef typename TR::Path Path; 1117 ///The heap type used by the dijkstra algorithm. 1113 1118 typedef typename TR::Heap Heap; 1114 1119 … … 1182 1187 SetPredMapBase(const TR &b) : TR(b) {} 1183 1188 }; 1184 1185 ///\brief \ref named-templ-param "Named parameter" for setting 1186 ///the predecessor map. 1187 /// 1188 ///\ref named-templ-param "Named parameter" function for setting 1189 ///the map that stores the predecessor arcs of the nodes. 1189 ///\brief \ref named-func-param "Named parameter" 1190 ///for setting PredMap object. 1191 /// 1192 ///\ref named-func-param "Named parameter" 1193 ///for setting PredMap object. 1190 1194 template<class T> 1191 1195 DijkstraWizard<SetPredMapBase<T> > predMap(const T &t) … … 1201 1205 SetDistMapBase(const TR &b) : TR(b) {} 1202 1206 }; 1203 1204 ///\brief \ref named-templ-param "Named parameter" for setting 1205 ///the distance map. 1206 /// 1207 ///\ref named-templ-param "Named parameter" function for setting 1208 ///the map that stores the distances of the nodes calculated 1209 ///by the algorithm. 1207 ///\brief \ref named-func-param "Named parameter" 1208 ///for setting DistMap object. 1209 /// 1210 ///\ref named-func-param "Named parameter" 1211 ///for setting DistMap object. 1210 1212 template<class T> 1211 1213 DijkstraWizard<SetDistMapBase<T> > distMap(const T &t) … … 1221 1223 SetProcessedMapBase(const TR &b) : TR(b) {} 1222 1224 }; 1223 1224 ///\brief \ref named-func-param "Named parameter" for setting 1225 ///the processed map. 1226 /// 1227 ///\ref named-templ-param "Named parameter" function for setting 1228 ///the map that indicates which nodes are processed. 1225 ///\brief \ref named-func-param "Named parameter" 1226 ///for setting ProcessedMap object. 1227 /// 1228 /// \ref named-func-param "Named parameter" 1229 ///for setting ProcessedMap object. 1229 1230 template<class T> 1230 1231 DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1239 1240 SetPathBase(const TR &b) : TR(b) {} 1240 1241 }; 1241 1242 1242 ///\brief \ref named-func-param "Named parameter" 1243 1243 ///for getting the shortest path to the target node. -
lemon/dim2.h
r761 r463 22 22 #include <iostream> 23 23 24 ///\ingroup geomdat24 ///\ingroup misc 25 25 ///\file 26 26 ///\brief A simple two dimensional vector and a bounding box implementation 27 /// 28 /// The class \ref lemon::dim2::Point "dim2::Point" implements 29 /// a two dimensional vector with the usual operations. 30 /// 31 /// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine 32 /// the rectangular bounding box of a set of 33 /// \ref lemon::dim2::Point "dim2::Point"'s. 27 34 28 35 namespace lemon { … … 34 41 namespace dim2 { 35 42 36 /// \addtogroup geomdat43 /// \addtogroup misc 37 44 /// @{ 38 45 -
lemon/fib_heap.h
r758 r730 21 21 22 22 ///\file 23 ///\ingroup heaps24 ///\brief Fibonacci heap implementation.23 ///\ingroup auxdat 24 ///\brief Fibonacci Heap implementation. 25 25 26 26 #include <vector> 27 #include <utility>28 27 #include <functional> 29 28 #include <lemon/math.h> … … 31 30 namespace lemon { 32 31 33 /// \ingroup heaps32 /// \ingroup auxdat 34 33 /// 35 /// \brief Fibonacci heap data structure.34 ///\brief Fibonacci Heap. 36 35 /// 37 /// This class implements the \e Fibonacci \e heap data structure. 38 /// It fully conforms to the \ref concepts::Heap "heap concept". 36 ///This class implements the \e Fibonacci \e heap data structure. A \e heap 37 ///is a data structure for storing items with specified values called \e 38 ///priorities in such a way that finding the item with minimum priority is 39 ///efficient. \c CMP specifies the ordering of the priorities. In a heap 40 ///one can change the priority of an item, add or erase an item, etc. 39 41 /// 40 /// The methods \ref increase() and \ref erase() are not efficient in a41 /// Fibonacci heap. In case of many calls of these operations, it is42 /// better to use other heap structure, e.g.\ref BinHeap "binary heap".42 ///The methods \ref increase and \ref erase are not efficient in a Fibonacci 43 ///heap. In case of many calls to these operations, it is better to use a 44 ///\ref BinHeap "binary heap". 43 45 /// 44 /// \tparam PR Type of the priorities of the items. 45 /// \tparam IM A read-writable item map with \c int values, used 46 /// internally to handle the cross references. 47 /// \tparam CMP A functor class for comparing the priorities. 48 /// The default is \c std::less<PR>. 46 ///\param PRIO Type of the priority of the items. 47 ///\param IM A read and writable Item int map, used internally 48 ///to handle the cross references. 49 ///\param CMP A class for the ordering of the priorities. The 50 ///default is \c std::less<PRIO>. 51 /// 52 ///\sa BinHeap 53 ///\sa Dijkstra 49 54 #ifdef DOXYGEN 50 template <typename PR , typename IM, typename CMP>55 template <typename PRIO, typename IM, typename CMP> 51 56 #else 52 template <typename PR , typename IM, typename CMP = std::less<PR> >57 template <typename PRIO, typename IM, typename CMP = std::less<PRIO> > 53 58 #endif 54 59 class FibHeap { 55 60 public: 56 57 /// Type of the item-int map. 61 ///\e 58 62 typedef IM ItemIntMap; 59 /// Type of the priorities.60 typedef PR Prio;61 /// Type of the items stored in the heap.63 ///\e 64 typedef PRIO Prio; 65 ///\e 62 66 typedef typename ItemIntMap::Key Item; 63 /// Type of the item-priority pairs.67 ///\e 64 68 typedef std::pair<Item,Prio> Pair; 65 /// Functor type for comparing the priorities.69 ///\e 66 70 typedef CMP Compare; 67 71 … … 77 81 public: 78 82 79 /// \brief Type to represent the states of the items.80 /// 81 /// Each item has a state associated to it. It canbe "in heap",82 /// "pre -heap" or "post-heap". The latter two are indifferent from the83 /// \brief Type to represent the items states. 84 /// 85 /// Each Item element have a state associated to it. It may be "in heap", 86 /// "pre heap" or "post heap". The latter two are indifferent from the 83 87 /// heap's point of view, but may be useful to the user. 84 88 /// … … 91 95 }; 92 96 93 /// \brief Constructor. 94 /// 95 /// Constructor. 96 /// \param map A map that assigns \c int values to the items. 97 /// It is used internally to handle the cross references. 98 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. 97 /// \brief The constructor 98 /// 99 /// \c map should be given to the constructor, since it is 100 /// used internally to handle the cross references. 99 101 explicit FibHeap(ItemIntMap &map) 100 102 : _minimum(0), _iim(map), _num() {} 101 103 102 /// \brief Constructor. 103 /// 104 /// Constructor. 105 /// \param map A map that assigns \c int values to the items. 106 /// It is used internally to handle the cross references. 107 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. 108 /// \param comp The function object used for comparing the priorities. 104 /// \brief The constructor 105 /// 106 /// \c map should be given to the constructor, since it is used 107 /// internally to handle the cross references. \c comp is an 108 /// object for ordering of the priorities. 109 109 FibHeap(ItemIntMap &map, const Compare &comp) 110 110 : _minimum(0), _iim(map), _comp(comp), _num() {} … … 112 112 /// \brief The number of items stored in the heap. 113 113 /// 114 /// This function returns the number of items stored in the heap.114 /// Returns the number of items stored in the heap. 115 115 int size() const { return _num; } 116 116 117 /// \brief Check if the heap is empty.118 /// 119 /// This function returns \c true if the heap is empty.117 /// \brief Checks if the heap stores no items. 118 /// 119 /// Returns \c true if and only if the heap stores no items. 120 120 bool empty() const { return _num==0; } 121 121 122 /// \brief Make the heap empty. 123 /// 124 /// This functon makes the heap empty. 125 /// It does not change the cross reference map. If you want to reuse 126 /// a heap that is not surely empty, you should first clear it and 127 /// then you should set the cross reference map to \c PRE_HEAP 128 /// for each item. 122 /// \brief Make empty this heap. 123 /// 124 /// Make empty this heap. It does not change the cross reference 125 /// map. If you want to reuse a heap what is not surely empty you 126 /// should first clear the heap and after that you should set the 127 /// cross reference map for each item to \c PRE_HEAP. 129 128 void clear() { 130 129 _data.clear(); _minimum = 0; _num = 0; 131 130 } 132 131 133 /// \brief Insert an item into the heap with the given priority. 134 /// 135 /// This function inserts the given item into the heap with the 136 /// given priority. 137 /// \param item The item to insert. 138 /// \param prio The priority of the item. 139 /// \pre \e item must not be stored in the heap. 140 void push (const Item& item, const Prio& prio) { 132 /// \brief \c item gets to the heap with priority \c value independently 133 /// if \c item was already there. 134 /// 135 /// This method calls \ref push(\c item, \c value) if \c item is not 136 /// stored in the heap and it calls \ref decrease(\c item, \c value) or 137 /// \ref increase(\c item, \c value) otherwise. 138 void set (const Item& item, const Prio& value) { 139 int i=_iim[item]; 140 if ( i >= 0 && _data[i].in ) { 141 if ( _comp(value, _data[i].prio) ) decrease(item, value); 142 if ( _comp(_data[i].prio, value) ) increase(item, value); 143 } else push(item, value); 144 } 145 146 /// \brief Adds \c item to the heap with priority \c value. 147 /// 148 /// Adds \c item to the heap with priority \c value. 149 /// \pre \c item must not be stored in the heap. 150 void push (const Item& item, const Prio& value) { 141 151 int i=_iim[item]; 142 152 if ( i < 0 ) { … … 159 169 _data[_minimum].right_neighbor=i; 160 170 _data[i].left_neighbor=_minimum; 161 if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;171 if ( _comp( value, _data[_minimum].prio) ) _minimum=i; 162 172 } else { 163 173 _data[i].right_neighbor=_data[i].left_neighbor=i; 164 174 _minimum=i; 165 175 } 166 _data[i].prio= prio;176 _data[i].prio=value; 167 177 ++_num; 168 178 } 169 179 170 /// \brief Return the item having minimum priority. 171 /// 172 /// This function returns the item having minimum priority. 173 /// \pre The heap must be non-empty. 180 /// \brief Returns the item with minimum priority relative to \c Compare. 181 /// 182 /// This method returns the item with minimum priority relative to \c 183 /// Compare. 184 /// \pre The heap must be nonempty. 174 185 Item top() const { return _data[_minimum].name; } 175 186 176 /// \brief The minimum priority. 177 /// 178 /// This function returns the minimum priority. 179 /// \pre The heap must be non-empty. 180 Prio prio() const { return _data[_minimum].prio; } 181 182 /// \brief Remove the item having minimum priority. 183 /// 184 /// This function removes the item having minimum priority. 187 /// \brief Returns the minimum priority relative to \c Compare. 188 /// 189 /// It returns the minimum priority relative to \c Compare. 190 /// \pre The heap must be nonempty. 191 const Prio& prio() const { return _data[_minimum].prio; } 192 193 /// \brief Returns the priority of \c item. 194 /// 195 /// It returns the priority of \c item. 196 /// \pre \c item must be in the heap. 197 const Prio& operator[](const Item& item) const { 198 return _data[_iim[item]].prio; 199 } 200 201 /// \brief Deletes the item with minimum priority relative to \c Compare. 202 /// 203 /// This method deletes the item with minimum priority relative to \c 204 /// Compare from the heap. 185 205 /// \pre The heap must be non-empty. 186 206 void pop() { … … 189 209 _data[_minimum].in=false; 190 210 if ( _data[_minimum].degree!=0 ) { 191 make Root(_data[_minimum].child);211 makeroot(_data[_minimum].child); 192 212 _minimum=_data[_minimum].child; 193 213 balance(); … … 202 222 int last_child=_data[child].left_neighbor; 203 223 204 make Root(child);224 makeroot(child); 205 225 206 226 _data[left].right_neighbor=child; … … 215 235 } 216 236 217 /// \brief Remove the given item from the heap. 218 /// 219 /// This function removes the given item from the heap if it is 220 /// already stored. 221 /// \param item The item to delete. 222 /// \pre \e item must be in the heap. 237 /// \brief Deletes \c item from the heap. 238 /// 239 /// This method deletes \c item from the heap, if \c item was already 240 /// stored in the heap. It is quite inefficient in Fibonacci heaps. 223 241 void erase (const Item& item) { 224 242 int i=_iim[item]; … … 235 253 } 236 254 237 /// \brief The priority of the given item. 238 /// 239 /// This function returns the priority of the given item. 240 /// \param item The item. 241 /// \pre \e item must be in the heap. 242 Prio operator[](const Item& item) const { 243 return _data[_iim[item]].prio; 244 } 245 246 /// \brief Set the priority of an item or insert it, if it is 247 /// not stored in the heap. 248 /// 249 /// This method sets the priority of the given item if it is 250 /// already stored in the heap. Otherwise it inserts the given 251 /// item into the heap with the given priority. 252 /// \param item The item. 253 /// \param prio The priority. 254 void set (const Item& item, const Prio& prio) { 255 /// \brief Decreases the priority of \c item to \c value. 256 /// 257 /// This method decreases the priority of \c item to \c value. 258 /// \pre \c item must be stored in the heap with priority at least \c 259 /// value relative to \c Compare. 260 void decrease (Item item, const Prio& value) { 255 261 int i=_iim[item]; 256 if ( i >= 0 && _data[i].in ) { 257 if ( _comp(prio, _data[i].prio) ) decrease(item, prio); 258 if ( _comp(_data[i].prio, prio) ) increase(item, prio); 259 } else push(item, prio); 260 } 261 262 /// \brief Decrease the priority of an item to the given value. 263 /// 264 /// This function decreases the priority of an item to the given value. 265 /// \param item The item. 266 /// \param prio The priority. 267 /// \pre \e item must be stored in the heap with priority at least \e prio. 268 void decrease (const Item& item, const Prio& prio) { 269 int i=_iim[item]; 270 _data[i].prio=prio; 262 _data[i].prio=value; 271 263 int p=_data[i].parent; 272 264 273 if ( p!=-1 && _comp( prio, _data[p].prio) ) {265 if ( p!=-1 && _comp(value, _data[p].prio) ) { 274 266 cut(i,p); 275 267 cascade(p); 276 268 } 277 if ( _comp(prio, _data[_minimum].prio) ) _minimum=i; 278 } 279 280 /// \brief Increase the priority of an item to the given value. 281 /// 282 /// This function increases the priority of an item to the given value. 283 /// \param item The item. 284 /// \param prio The priority. 285 /// \pre \e item must be stored in the heap with priority at most \e prio. 286 void increase (const Item& item, const Prio& prio) { 269 if ( _comp(value, _data[_minimum].prio) ) _minimum=i; 270 } 271 272 /// \brief Increases the priority of \c item to \c value. 273 /// 274 /// This method sets the priority of \c item to \c value. Though 275 /// there is no precondition on the priority of \c item, this 276 /// method should be used only if it is indeed necessary to increase 277 /// (relative to \c Compare) the priority of \c item, because this 278 /// method is inefficient. 279 void increase (Item item, const Prio& value) { 287 280 erase(item); 288 push(item, prio);289 } 290 291 /// \brief Return the state of an item. 292 /// 293 /// This method returns \c PRE_HEAP if the given item has never294 /// been in the heap, \c IN_HEAP if it is in the heap at the moment,295 /// and \c POST_HEAP otherwise.296 /// In the latter case it is possible that the item will get back297 /// to the heap again.298 /// \param item The item.281 push(item, value); 282 } 283 284 285 /// \brief Returns if \c item is in, has already been in, or has never 286 /// been in the heap. 287 /// 288 /// This method returns PRE_HEAP if \c item has never been in the 289 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP 290 /// otherwise. In the latter case it is possible that \c item will 291 /// get back to the heap again. 299 292 State state(const Item &item) const { 300 293 int i=_iim[item]; … … 306 299 } 307 300 308 /// \brief Set the state of anitem in the heap.309 /// 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 important312 /// to achive better timecomplexity.301 /// \brief Sets the state of the \c item in the heap. 302 /// 303 /// Sets the state of the \c item in the heap. It can be used to 304 /// manually clear the heap when it is important to achive the 305 /// better time _complexity. 313 306 /// \param i The item. 314 307 /// \param st The state. It should not be \c IN_HEAP. … … 373 366 } 374 367 375 void make Root(int c) {368 void makeroot(int c) { 376 369 int s=c; 377 370 do { -
lemon/gomory_hu.h
r760 r643 360 360 /// \c t. 361 361 /// \code 362 /// Gomor yHu<Graph> gom(g, capacities);362 /// GomoruHu<Graph> gom(g, capacities); 363 363 /// gom.run(); 364 364 /// int cnt=0; 365 /// for(Gomor yHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;365 /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt; 366 366 /// \endcode 367 367 class MinCutNodeIt … … 457 457 /// \c t. 458 458 /// \code 459 /// Gomor yHu<Graph> gom(g, capacities);459 /// GomoruHu<Graph> gom(g, capacities); 460 460 /// gom.run(); 461 461 /// int value=0; 462 /// for(Gomor yHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)462 /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e) 463 463 /// value+=capacities[e]; 464 464 /// \endcode -
lemon/maps.h
r773 r731 23 23 #include <functional> 24 24 #include <vector> 25 #include <map>26 25 27 26 #include <lemon/core.h> … … 30 29 ///\ingroup maps 31 30 ///\brief Miscellaneous property maps 31 32 #include <map> 32 33 33 34 namespace lemon { … … 57 58 /// but data written to it is not required (i.e. it will be sent to 58 59 /// <tt>/dev/null</tt>). 59 /// It conforms t o the \ref concepts::ReadWriteMap "ReadWriteMap" concept.60 /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 60 61 /// 61 62 /// \sa ConstMap … … 90 91 /// 91 92 /// In other aspects it is equivalent to \c NullMap. 92 /// So it conforms t o the \ref concepts::ReadWriteMap "ReadWriteMap"93 /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" 93 94 /// concept, but it absorbs the data written to it. 94 95 /// … … 159 160 /// 160 161 /// In other aspects it is equivalent to \c NullMap. 161 /// So it conforms t o the \ref concepts::ReadWriteMap "ReadWriteMap"162 /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" 162 163 /// concept, but it absorbs the data written to it. 163 164 /// … … 233 234 /// It can be used with some data structures, for example 234 235 /// \c UnionFind, \c BinHeap, when the used items are small 235 /// integers. This map conforms t o the \ref concepts::ReferenceMap236 /// integers. This map conforms the \ref concepts::ReferenceMap 236 237 /// "ReferenceMap" concept. 237 238 /// … … 341 342 /// stored actually. This value can be different from the default 342 343 /// contructed value (i.e. \c %Value()). 343 /// This type conforms t o the \ref concepts::ReferenceMap "ReferenceMap"344 /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap" 344 345 /// concept. 345 346 /// … … 707 708 /// The \c Key type of it is inherited from \c M and the \c Value 708 709 /// type is \c V. 709 /// This type conforms t o the \ref concepts::ReadMap "ReadMap" concept.710 /// This type conforms the \ref concepts::ReadMap "ReadMap" concept. 710 711 /// 711 712 /// The simplest way of using this map is through the convertMap() … … 1790 1791 /// \code 1791 1792 /// std::vector<Node> v; 1792 /// dfs(g ).processedMap(loggerBoolMap(std::back_inserter(v))).run(s);1793 /// dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run(); 1793 1794 /// \endcode 1794 1795 /// \code 1795 1796 /// std::vector<Node> v(countNodes(g)); 1796 /// dfs(g ).processedMap(loggerBoolMap(v.begin())).run(s);1797 /// dfs(g,s).processedMap(loggerBoolMap(v.begin())).run(); 1797 1798 /// \endcode 1798 1799 /// … … 1818 1819 /// 1819 1820 /// IdMap provides a unique and immutable id for each item of the 1820 /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 1821 /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 1821 1822 /// - \b unique: different items get different ids, 1822 1823 /// - \b immutable: the id of an item does not change (even if you … … 1826 1827 /// the items stored in the graph, which is returned by the \c id() 1827 1828 /// function of the graph. This map can be inverted with its member 1828 /// class \c InverseMap or with the \c operator() ()member.1829 /// class \c InverseMap or with the \c operator() member. 1829 1830 /// 1830 1831 /// \tparam GR The graph type. … … 1866 1867 public: 1867 1868 1868 /// \brief The inverse map type of IdMap. 1869 /// 1870 /// The inverse map type of IdMap. The subscript operator gives back 1871 /// an item by its id. 1872 /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. 1869 /// \brief This class represents the inverse of its owner (IdMap). 1870 /// 1871 /// This class represents the inverse of its owner (IdMap). 1873 1872 /// \see inverse() 1874 1873 class InverseMap { … … 1885 1884 explicit InverseMap(const IdMap& map) : _graph(map._graph) {} 1886 1885 1887 /// \brief Gives back an item byits id.1886 /// \brief Gives back the given item from its id. 1888 1887 /// 1889 /// Gives back an item byits id.1888 /// Gives back the given item from its id. 1890 1889 Item operator[](int id) const { return _graph->fromId(id, Item());} 1891 1890 … … 1900 1899 }; 1901 1900 1902 /// \brief Returns an \c IdMap class.1903 ///1904 /// This function just returns an \c IdMap class.1905 /// \relates IdMap1906 template <typename K, typename GR>1907 inline IdMap<GR, K> idMap(const GR& graph) {1908 return IdMap<GR, K>(graph);1909 }1910 1901 1911 1902 /// \brief General cross reference graph map type. … … 1914 1905 /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap) 1915 1906 /// and if a key is set to a new value, then stores it in the inverse map. 1916 /// The graph items can be accessed by their values either using 1917 /// \c InverseMap or \c operator()(), and the values of the map can be 1918 /// accessed with an STL compatible forward iterator (\c ValueIt). 1919 /// 1920 /// This map is intended to be used when all associated values are 1921 /// different (the map is actually invertable) or there are only a few 1922 /// items with the same value. 1923 /// Otherwise consider to use \c IterableValueMap, which is more 1924 /// suitable and more efficient for such cases. It provides iterators 1925 /// to traverse the items with the same associated value, however 1926 /// it does not have \c InverseMap. 1907 /// The values of the map can be accessed 1908 /// with stl compatible forward iterator. 1927 1909 /// 1928 1910 /// This type is not reference map, so it cannot be modified with … … 1965 1947 /// \brief Forward iterator for values. 1966 1948 /// 1967 /// This iterator is an STLcompatible forward1949 /// This iterator is an stl compatible forward 1968 1950 /// iterator on the values of the map. The values can 1969 1951 /// be accessed in the <tt>[beginValue, endValue)</tt> range. 1970 1952 /// They are considered with multiplicity, so each value is 1971 1953 /// traversed for each item it is assigned to. 1972 class ValueIt 1954 class ValueIterator 1973 1955 : public std::iterator<std::forward_iterator_tag, Value> { 1974 1956 friend class CrossRefMap; 1975 1957 private: 1976 ValueIt (typename Container::const_iterator _it)1958 ValueIterator(typename Container::const_iterator _it) 1977 1959 : it(_it) {} 1978 1960 public: 1979 1961 1980 /// Constructor 1981 ValueIt() {} 1982 1983 /// \e 1984 ValueIt& operator++() { ++it; return *this; } 1985 /// \e 1986 ValueIt operator++(int) { 1987 ValueIt tmp(*this); 1962 ValueIterator() {} 1963 1964 ValueIterator& operator++() { ++it; return *this; } 1965 ValueIterator operator++(int) { 1966 ValueIterator tmp(*this); 1988 1967 operator++(); 1989 1968 return tmp; 1990 1969 } 1991 1970 1992 /// \e1993 1971 const Value& operator*() const { return it->first; } 1994 /// \e1995 1972 const Value* operator->() const { return &(it->first); } 1996 1973 1997 /// \e 1998 bool operator==(ValueIt jt) const { return it == jt.it; } 1999 /// \e 2000 bool operator!=(ValueIt jt) const { return it != jt.it; } 1974 bool operator==(ValueIterator jt) const { return it == jt.it; } 1975 bool operator!=(ValueIterator jt) const { return it != jt.it; } 2001 1976 2002 1977 private: 2003 1978 typename Container::const_iterator it; 2004 1979 }; 2005 2006 /// Alias for \c ValueIt2007 typedef ValueIt ValueIterator;2008 1980 2009 1981 /// \brief Returns an iterator to the first value. 2010 1982 /// 2011 /// Returns an STLcompatible iterator to the1983 /// Returns an stl compatible iterator to the 2012 1984 /// first value of the map. The values of the 2013 1985 /// map can be accessed in the <tt>[beginValue, endValue)</tt> 2014 1986 /// range. 2015 ValueIt beginValue() const {2016 return ValueIt (_inv_map.begin());1987 ValueIterator beginValue() const { 1988 return ValueIterator(_inv_map.begin()); 2017 1989 } 2018 1990 2019 1991 /// \brief Returns an iterator after the last value. 2020 1992 /// 2021 /// Returns an STLcompatible iterator after the1993 /// Returns an stl compatible iterator after the 2022 1994 /// last value of the map. The values of the 2023 1995 /// map can be accessed in the <tt>[beginValue, endValue)</tt> 2024 1996 /// range. 2025 ValueIt endValue() const {2026 return ValueIt (_inv_map.end());1997 ValueIterator endValue() const { 1998 return ValueIterator(_inv_map.end()); 2027 1999 } 2028 2000 … … 2061 2033 typename Container::const_iterator it = _inv_map.find(val); 2062 2034 return it != _inv_map.end() ? it->second : INVALID; 2063 }2064 2065 /// \brief Returns the number of items with the given value.2066 ///2067 /// This function returns the number of items with the given value2068 /// associated with it.2069 int count(const Value &val) const {2070 return _inv_map.count(val);2071 2035 } 2072 2036 … … 2120 2084 public: 2121 2085 2122 /// \brief The inverse map type of CrossRefMap. 2123 /// 2124 /// The inverse map type of CrossRefMap. The subscript operator gives 2125 /// back an item by its value. 2126 /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. 2127 /// \see inverse() 2086 /// \brief The inverse map type. 2087 /// 2088 /// The inverse of this map. The subscript operator of the map 2089 /// gives back the item that was last assigned to the value. 2128 2090 class InverseMap { 2129 2091 public: … … 2152 2114 }; 2153 2115 2154 /// \brief Gives back the inverse of the map.2155 /// 2156 /// Gives back the inverse of the CrossRefMap.2116 /// \brief It gives back the read-only inverse map. 2117 /// 2118 /// It gives back the read-only inverse map. 2157 2119 InverseMap inverse() const { 2158 2120 return InverseMap(*this); … … 2161 2123 }; 2162 2124 2163 /// \brief Provides continuous and unique idfor the2125 /// \brief Provides continuous and unique ID for the 2164 2126 /// items of a graph. 2165 2127 /// 2166 2128 /// RangeIdMap provides a unique and continuous 2167 /// idfor each item of a given type (\c Node, \c Arc or2129 /// ID for each item of a given type (\c Node, \c Arc or 2168 2130 /// \c Edge) in a graph. This id is 2169 2131 /// - \b unique: different items get different ids, … … 2176 2138 /// the \c id() function of the graph or \ref IdMap. 2177 2139 /// This map can be inverted with its member class \c InverseMap, 2178 /// or with the \c operator() ()member.2140 /// or with the \c operator() member. 2179 2141 /// 2180 2142 /// \tparam GR The graph type. … … 2304 2266 } 2305 2267 2306 /// \brief Gives back the \e range \e id of the item2307 /// 2308 /// Gives back the \e range \e id of the item.2268 /// \brief Gives back the \e RangeId of the item 2269 /// 2270 /// Gives back the \e RangeId of the item. 2309 2271 int operator[](const Item& item) const { 2310 2272 return Map::operator[](item); 2311 2273 } 2312 2274 2313 /// \brief Gives back the item belonging to a \e range \e id2314 /// 2315 /// Gives back the item belonging to the given \e range \e id.2275 /// \brief Gives back the item belonging to a \e RangeId 2276 /// 2277 /// Gives back the item belonging to a \e RangeId. 2316 2278 Item operator()(int id) const { 2317 2279 return _inv_map[id]; … … 2327 2289 /// \brief The inverse map type of RangeIdMap. 2328 2290 /// 2329 /// The inverse map type of RangeIdMap. The subscript operator gives 2330 /// back an item by its \e range \e id. 2331 /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. 2291 /// The inverse map type of RangeIdMap. 2332 2292 class InverseMap { 2333 2293 public: … … 2347 2307 /// 2348 2308 /// Subscript operator. It gives back the item 2349 /// that the given \e range \e idcurrently belongs to.2309 /// that the descriptor currently belongs to. 2350 2310 Value operator[](const Key& key) const { 2351 2311 return _inverted(key); … … 2365 2325 /// \brief Gives back the inverse of the map. 2366 2326 /// 2367 /// Gives back the inverse of the RangeIdMap.2327 /// Gives back the inverse of the map. 2368 2328 const InverseMap inverse() const { 2369 2329 return InverseMap(*this); 2370 2330 } 2371 };2372 2373 /// \brief Returns a \c RangeIdMap class.2374 ///2375 /// This function just returns an \c RangeIdMap class.2376 /// \relates RangeIdMap2377 template <typename K, typename GR>2378 inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {2379 return RangeIdMap<GR, K>(graph);2380 }2381 2382 /// \brief Dynamic iterable \c bool map.2383 ///2384 /// This class provides a special graph map type which can store a2385 /// \c bool value for graph items (\c Node, \c Arc or \c Edge).2386 /// For both \c true and \c false values it is possible to iterate on2387 /// the keys mapped to the value.2388 ///2389 /// This type is a reference map, so it can be modified with the2390 /// subscript operator.2391 ///2392 /// \tparam GR The graph type.2393 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or2394 /// \c GR::Edge).2395 ///2396 /// \see IterableIntMap, IterableValueMap2397 /// \see CrossRefMap2398 template <typename GR, typename K>2399 class IterableBoolMap2400 : protected ItemSetTraits<GR, K>::template Map<int>::Type {2401 private:2402 typedef GR Graph;2403 2404 typedef typename ItemSetTraits<GR, K>::ItemIt KeyIt;2405 typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Parent;2406 2407 std::vector<K> _array;2408 int _sep;2409 2410 public:2411 2412 /// Indicates that the map is reference map.2413 typedef True ReferenceMapTag;2414 2415 /// The key type2416 typedef K Key;2417 /// The value type2418 typedef bool Value;2419 /// The const reference type.2420 typedef const Value& ConstReference;2421 2422 private:2423 2424 int position(const Key& key) const {2425 return Parent::operator[](key);2426 }2427 2428 public:2429 2430 /// \brief Reference to the value of the map.2431 ///2432 /// This class is similar to the \c bool type. It can be converted to2433 /// \c bool and it provides the same operators.2434 class Reference {2435 friend class IterableBoolMap;2436 private:2437 Reference(IterableBoolMap& map, const Key& key)2438 : _key(key), _map(map) {}2439 public:2440 2441 Reference& operator=(const Reference& value) {2442 _map.set(_key, static_cast<bool>(value));2443 return *this;2444 }2445 2446 operator bool() const {2447 return static_cast<const IterableBoolMap&>(_map)[_key];2448 }2449 2450 Reference& operator=(bool value) {2451 _map.set(_key, value);2452 return *this;2453 }2454 Reference& operator&=(bool value) {2455 _map.set(_key, _map[_key] & value);2456 return *this;2457 }2458 Reference& operator|=(bool value) {2459 _map.set(_key, _map[_key] | value);2460 return *this;2461 }2462 Reference& operator^=(bool value) {2463 _map.set(_key, _map[_key] ^ value);2464 return *this;2465 }2466 private:2467 Key _key;2468 IterableBoolMap& _map;2469 };2470 2471 /// \brief Constructor of the map with a default value.2472 ///2473 /// Constructor of the map with a default value.2474 explicit IterableBoolMap(const Graph& graph, bool def = false)2475 : Parent(graph) {2476 typename Parent::Notifier* nf = Parent::notifier();2477 Key it;2478 for (nf->first(it); it != INVALID; nf->next(it)) {2479 Parent::set(it, _array.size());2480 _array.push_back(it);2481 }2482 _sep = (def ? _array.size() : 0);2483 }2484 2485 /// \brief Const subscript operator of the map.2486 ///2487 /// Const subscript operator of the map.2488 bool operator[](const Key& key) const {2489 return position(key) < _sep;2490 }2491 2492 /// \brief Subscript operator of the map.2493 ///2494 /// Subscript operator of the map.2495 Reference operator[](const Key& key) {2496 return Reference(*this, key);2497 }2498 2499 /// \brief Set operation of the map.2500 ///2501 /// Set operation of the map.2502 void set(const Key& key, bool value) {2503 int pos = position(key);2504 if (value) {2505 if (pos < _sep) return;2506 Key tmp = _array[_sep];2507 _array[_sep] = key;2508 Parent::set(key, _sep);2509 _array[pos] = tmp;2510 Parent::set(tmp, pos);2511 ++_sep;2512 } else {2513 if (pos >= _sep) return;2514 --_sep;2515 Key tmp = _array[_sep];2516 _array[_sep] = key;2517 Parent::set(key, _sep);2518 _array[pos] = tmp;2519 Parent::set(tmp, pos);2520 }2521 }2522 2523 /// \brief Set all items.2524 ///2525 /// Set all items in the map.2526 /// \note Constant time operation.2527 void setAll(bool value) {2528 _sep = (value ? _array.size() : 0);2529 }2530 2531 /// \brief Returns the number of the keys mapped to \c true.2532 ///2533 /// Returns the number of the keys mapped to \c true.2534 int trueNum() const {2535 return _sep;2536 }2537 2538 /// \brief Returns the number of the keys mapped to \c false.2539 ///2540 /// Returns the number of the keys mapped to \c false.2541 int falseNum() const {2542 return _array.size() - _sep;2543 }2544 2545 /// \brief Iterator for the keys mapped to \c true.2546 ///2547 /// Iterator for the keys mapped to \c true. It works2548 /// like a graph item iterator, it can be converted to2549 /// the key type of the map, incremented with \c ++ operator, and2550 /// if the iterator leaves the last valid key, it will be equal to2551 /// \c INVALID.2552 class TrueIt : public Key {2553 public:2554 typedef Key Parent;2555 2556 /// \brief Creates an iterator.2557 ///2558 /// Creates an iterator. It iterates on the2559 /// keys mapped to \c true.2560 /// \param map The IterableBoolMap.2561 explicit TrueIt(const IterableBoolMap& map)2562 : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID),2563 _map(&map) {}2564 2565 /// \brief Invalid constructor \& conversion.2566 ///2567 /// This constructor initializes the iterator to be invalid.2568 /// \sa Invalid for more details.2569 TrueIt(Invalid) : Parent(INVALID), _map(0) {}2570 2571 /// \brief Increment operator.2572 ///2573 /// Increment operator.2574 TrueIt& operator++() {2575 int pos = _map->position(*this);2576 Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID);2577 return *this;2578 }2579 2580 private:2581 const IterableBoolMap* _map;2582 };2583 2584 /// \brief Iterator for the keys mapped to \c false.2585 ///2586 /// Iterator for the keys mapped to \c false. It works2587 /// like a graph item iterator, it can be converted to2588 /// the key type of the map, incremented with \c ++ operator, and2589 /// if the iterator leaves the last valid key, it will be equal to2590 /// \c INVALID.2591 class FalseIt : public Key {2592 public:2593 typedef Key Parent;2594 2595 /// \brief Creates an iterator.2596 ///2597 /// Creates an iterator. It iterates on the2598 /// keys mapped to \c false.2599 /// \param map The IterableBoolMap.2600 explicit FalseIt(const IterableBoolMap& map)2601 : Parent(map._sep < int(map._array.size()) ?2602 map._array.back() : INVALID), _map(&map) {}2603 2604 /// \brief Invalid constructor \& conversion.2605 ///2606 /// This constructor initializes the iterator to be invalid.2607 /// \sa Invalid for more details.2608 FalseIt(Invalid) : Parent(INVALID), _map(0) {}2609 2610 /// \brief Increment operator.2611 ///2612 /// Increment operator.2613 FalseIt& operator++() {2614 int pos = _map->position(*this);2615 Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID);2616 return *this;2617 }2618 2619 private:2620 const IterableBoolMap* _map;2621 };2622 2623 /// \brief Iterator for the keys mapped to a given value.2624 ///2625 /// Iterator for the keys mapped to a given value. It works2626 /// like a graph item iterator, it can be converted to2627 /// the key type of the map, incremented with \c ++ operator, and2628 /// if the iterator leaves the last valid key, it will be equal to2629 /// \c INVALID.2630 class ItemIt : public Key {2631 public:2632 typedef Key Parent;2633 2634 /// \brief Creates an iterator with a value.2635 ///2636 /// Creates an iterator with a value. It iterates on the2637 /// keys mapped to the given value.2638 /// \param map The IterableBoolMap.2639 /// \param value The value.2640 ItemIt(const IterableBoolMap& map, bool value)2641 : Parent(value ?2642 (map._sep > 0 ?2643 map._array[map._sep - 1] : INVALID) :2644 (map._sep < int(map._array.size()) ?2645 map._array.back() : INVALID)), _map(&map) {}2646 2647 /// \brief Invalid constructor \& conversion.2648 ///2649 /// This constructor initializes the iterator to be invalid.2650 /// \sa Invalid for more details.2651 ItemIt(Invalid) : Parent(INVALID), _map(0) {}2652 2653 /// \brief Increment operator.2654 ///2655 /// Increment operator.2656 ItemIt& operator++() {2657 int pos = _map->position(*this);2658 int _sep = pos >= _map->_sep ? _map->_sep : 0;2659 Parent::operator=(pos > _sep ? _map->_array[pos - 1] : INVALID);2660 return *this;2661 }2662 2663 private:2664 const IterableBoolMap* _map;2665 };2666 2667 protected:2668 2669 virtual void add(const Key& key) {2670 Parent::add(key);2671 Parent::set(key, _array.size());2672 _array.push_back(key);2673 }2674 2675 virtual void add(const std::vector<Key>& keys) {2676 Parent::add(keys);2677 for (int i = 0; i < int(keys.size()); ++i) {2678 Parent::set(keys[i], _array.size());2679 _array.push_back(keys[i]);2680 }2681 }2682 2683 virtual void erase(const Key& key) {2684 int pos = position(key);2685 if (pos < _sep) {2686 --_sep;2687 Parent::set(_array[_sep], pos);2688 _array[pos] = _array[_sep];2689 Parent::set(_array.back(), _sep);2690 _array[_sep] = _array.back();2691 _array.pop_back();2692 } else {2693 Parent::set(_array.back(), pos);2694 _array[pos] = _array.back();2695 _array.pop_back();2696 }2697 Parent::erase(key);2698 }2699 2700 virtual void erase(const std::vector<Key>& keys) {2701 for (int i = 0; i < int(keys.size()); ++i) {2702 int pos = position(keys[i]);2703 if (pos < _sep) {2704 --_sep;2705 Parent::set(_array[_sep], pos);2706 _array[pos] = _array[_sep];2707 Parent::set(_array.back(), _sep);2708 _array[_sep] = _array.back();2709 _array.pop_back();2710 } else {2711 Parent::set(_array.back(), pos);2712 _array[pos] = _array.back();2713 _array.pop_back();2714 }2715 }2716 Parent::erase(keys);2717 }2718 2719 virtual void build() {2720 Parent::build();2721 typename Parent::Notifier* nf = Parent::notifier();2722 Key it;2723 for (nf->first(it); it != INVALID; nf->next(it)) {2724 Parent::set(it, _array.size());2725 _array.push_back(it);2726 }2727 _sep = 0;2728 }2729 2730 virtual void clear() {2731 _array.clear();2732 _sep = 0;2733 Parent::clear();2734 }2735 2736 };2737 2738 2739 namespace _maps_bits {2740 template <typename Item>2741 struct IterableIntMapNode {2742 IterableIntMapNode() : value(-1) {}2743 IterableIntMapNode(int _value) : value(_value) {}2744 Item prev, next;2745 int value;2746 };2747 }2748 2749 /// \brief Dynamic iterable integer map.2750 ///2751 /// This class provides a special graph map type which can store an2752 /// integer value for graph items (\c Node, \c Arc or \c Edge).2753 /// For each non-negative value it is possible to iterate on the keys2754 /// mapped to the value.2755 ///2756 /// This map is intended to be used with small integer values, for which2757 /// it is efficient, and supports iteration only for non-negative values.2758 /// If you need large values and/or iteration for negative integers,2759 /// consider to use \ref IterableValueMap instead.2760 ///2761 /// This type is a reference map, so it can be modified with the2762 /// subscript operator.2763 ///2764 /// \note The size of the data structure depends on the largest2765 /// value in the map.2766 ///2767 /// \tparam GR The graph type.2768 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or2769 /// \c GR::Edge).2770 ///2771 /// \see IterableBoolMap, IterableValueMap2772 /// \see CrossRefMap2773 template <typename GR, typename K>2774 class IterableIntMap2775 : protected ItemSetTraits<GR, K>::2776 template Map<_maps_bits::IterableIntMapNode<K> >::Type {2777 public:2778 typedef typename ItemSetTraits<GR, K>::2779 template Map<_maps_bits::IterableIntMapNode<K> >::Type Parent;2780 2781 /// The key type2782 typedef K Key;2783 /// The value type2784 typedef int Value;2785 /// The graph type2786 typedef GR Graph;2787 2788 /// \brief Constructor of the map.2789 ///2790 /// Constructor of the map. It sets all values to -1.2791 explicit IterableIntMap(const Graph& graph)2792 : Parent(graph) {}2793 2794 /// \brief Constructor of the map with a given value.2795 ///2796 /// Constructor of the map with a given value.2797 explicit IterableIntMap(const Graph& graph, int value)2798 : Parent(graph, _maps_bits::IterableIntMapNode<K>(value)) {2799 if (value >= 0) {2800 for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {2801 lace(it);2802 }2803 }2804 }2805 2806 private:2807 2808 void unlace(const Key& key) {2809 typename Parent::Value& node = Parent::operator[](key);2810 if (node.value < 0) return;2811 if (node.prev != INVALID) {2812 Parent::operator[](node.prev).next = node.next;2813 } else {2814 _first[node.value] = node.next;2815 }2816 if (node.next != INVALID) {2817 Parent::operator[](node.next).prev = node.prev;2818 }2819 while (!_first.empty() && _first.back() == INVALID) {2820 _first.pop_back();2821 }2822 }2823 2824 void lace(const Key& key) {2825 typename Parent::Value& node = Parent::operator[](key);2826 if (node.value < 0) return;2827 if (node.value >= int(_first.size())) {2828 _first.resize(node.value + 1, INVALID);2829 }2830 node.prev = INVALID;2831 node.next = _first[node.value];2832 if (node.next != INVALID) {2833 Parent::operator[](node.next).prev = key;2834 }2835 _first[node.value] = key;2836 }2837 2838 public:2839 2840 /// Indicates that the map is reference map.2841 typedef True ReferenceMapTag;2842 2843 /// \brief Reference to the value of the map.2844 ///2845 /// This class is similar to the \c int type. It can2846 /// be converted to \c int and it has the same operators.2847 class Reference {2848 friend class IterableIntMap;2849 private:2850 Reference(IterableIntMap& map, const Key& key)2851 : _key(key), _map(map) {}2852 public:2853 2854 Reference& operator=(const Reference& value) {2855 _map.set(_key, static_cast<const int&>(value));2856 return *this;2857 }2858 2859 operator const int&() const {2860 return static_cast<const IterableIntMap&>(_map)[_key];2861 }2862 2863 Reference& operator=(int value) {2864 _map.set(_key, value);2865 return *this;2866 }2867 Reference& operator++() {2868 _map.set(_key, _map[_key] + 1);2869 return *this;2870 }2871 int operator++(int) {2872 int value = _map[_key];2873 _map.set(_key, value + 1);2874 return value;2875 }2876 Reference& operator--() {2877 _map.set(_key, _map[_key] - 1);2878 return *this;2879 }2880 int operator--(int) {2881 int value = _map[_key];2882 _map.set(_key, value - 1);2883 return value;2884 }2885 Reference& operator+=(int value) {2886 _map.set(_key, _map[_key] + value);2887 return *this;2888 }2889 Reference& operator-=(int value) {2890 _map.set(_key, _map[_key] - value);2891 return *this;2892 }2893 Reference& operator*=(int value) {2894 _map.set(_key, _map[_key] * value);2895 return *this;2896 }2897 Reference& operator/=(int value) {2898 _map.set(_key, _map[_key] / value);2899 return *this;2900 }2901 Reference& operator%=(int value) {2902 _map.set(_key, _map[_key] % value);2903 return *this;2904 }2905 Reference& operator&=(int value) {2906 _map.set(_key, _map[_key] & value);2907 return *this;2908 }2909 Reference& operator|=(int value) {2910 _map.set(_key, _map[_key] | value);2911 return *this;2912 }2913 Reference& operator^=(int value) {2914 _map.set(_key, _map[_key] ^ value);2915 return *this;2916 }2917 Reference& operator<<=(int value) {2918 _map.set(_key, _map[_key] << value);2919 return *this;2920 }2921 Reference& operator>>=(int value) {2922 _map.set(_key, _map[_key] >> value);2923 return *this;2924 }2925 2926 private:2927 Key _key;2928 IterableIntMap& _map;2929 };2930 2931 /// The const reference type.2932 typedef const Value& ConstReference;2933 2934 /// \brief Gives back the maximal value plus one.2935 ///2936 /// Gives back the maximal value plus one.2937 int size() const {2938 return _first.size();2939 }2940 2941 /// \brief Set operation of the map.2942 ///2943 /// Set operation of the map.2944 void set(const Key& key, const Value& value) {2945 unlace(key);2946 Parent::operator[](key).value = value;2947 lace(key);2948 }2949 2950 /// \brief Const subscript operator of the map.2951 ///2952 /// Const subscript operator of the map.2953 const Value& operator[](const Key& key) const {2954 return Parent::operator[](key).value;2955 }2956 2957 /// \brief Subscript operator of the map.2958 ///2959 /// Subscript operator of the map.2960 Reference operator[](const Key& key) {2961 return Reference(*this, key);2962 }2963 2964 /// \brief Iterator for the keys with the same value.2965 ///2966 /// Iterator for the keys with the same value. It works2967 /// like a graph item iterator, it can be converted to2968 /// the item type of the map, incremented with \c ++ operator, and2969 /// if the iterator leaves the last valid item, it will be equal to2970 /// \c INVALID.2971 class ItemIt : public Key {2972 public:2973 typedef Key Parent;2974 2975 /// \brief Invalid constructor \& conversion.2976 ///2977 /// This constructor initializes the iterator to be invalid.2978 /// \sa Invalid for more details.2979 ItemIt(Invalid) : Parent(INVALID), _map(0) {}2980 2981 /// \brief Creates an iterator with a value.2982 ///2983 /// Creates an iterator with a value. It iterates on the2984 /// keys mapped to the given value.2985 /// \param map The IterableIntMap.2986 /// \param value The value.2987 ItemIt(const IterableIntMap& map, int value) : _map(&map) {2988 if (value < 0 || value >= int(_map->_first.size())) {2989 Parent::operator=(INVALID);2990 } else {2991 Parent::operator=(_map->_first[value]);2992 }2993 }2994 2995 /// \brief Increment operator.2996 ///2997 /// Increment operator.2998 ItemIt& operator++() {2999 Parent::operator=(_map->IterableIntMap::Parent::3000 operator[](static_cast<Parent&>(*this)).next);3001 return *this;3002 }3003 3004 private:3005 const IterableIntMap* _map;3006 };3007 3008 protected:3009 3010 virtual void erase(const Key& key) {3011 unlace(key);3012 Parent::erase(key);3013 }3014 3015 virtual void erase(const std::vector<Key>& keys) {3016 for (int i = 0; i < int(keys.size()); ++i) {3017 unlace(keys[i]);3018 }3019 Parent::erase(keys);3020 }3021 3022 virtual void clear() {3023 _first.clear();3024 Parent::clear();3025 }3026 3027 private:3028 std::vector<Key> _first;3029 };3030 3031 namespace _maps_bits {3032 template <typename Item, typename Value>3033 struct IterableValueMapNode {3034 IterableValueMapNode(Value _value = Value()) : value(_value) {}3035 Item prev, next;3036 Value value;3037 };3038 }3039 3040 /// \brief Dynamic iterable map for comparable values.3041 ///3042 /// This class provides a special graph map type which can store a3043 /// comparable value for graph items (\c Node, \c Arc or \c Edge).3044 /// For each value it is possible to iterate on the keys mapped to3045 /// the value (\c ItemIt), and the values of the map can be accessed3046 /// with an STL compatible forward iterator (\c ValueIt).3047 /// The map stores a linked list for each value, which contains3048 /// the items mapped to the value, and the used values are stored3049 /// in balanced binary tree (\c std::map).3050 ///3051 /// \ref IterableBoolMap and \ref IterableIntMap are similar classes3052 /// specialized for \c bool and \c int values, respectively.3053 ///3054 /// This type is not reference map, so it cannot be modified with3055 /// the subscript operator.3056 ///3057 /// \tparam GR The graph type.3058 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or3059 /// \c GR::Edge).3060 /// \tparam V The value type of the map. It can be any comparable3061 /// value type.3062 ///3063 /// \see IterableBoolMap, IterableIntMap3064 /// \see CrossRefMap3065 template <typename GR, typename K, typename V>3066 class IterableValueMap3067 : protected ItemSetTraits<GR, K>::3068 template Map<_maps_bits::IterableValueMapNode<K, V> >::Type {3069 public:3070 typedef typename ItemSetTraits<GR, K>::3071 template Map<_maps_bits::IterableValueMapNode<K, V> >::Type Parent;3072 3073 /// The key type3074 typedef K Key;3075 /// The value type3076 typedef V Value;3077 /// The graph type3078 typedef GR Graph;3079 3080 public:3081 3082 /// \brief Constructor of the map with a given value.3083 ///3084 /// Constructor of the map with a given value.3085 explicit IterableValueMap(const Graph& graph,3086 const Value& value = Value())3087 : Parent(graph, _maps_bits::IterableValueMapNode<K, V>(value)) {3088 for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {3089 lace(it);3090 }3091 }3092 3093 protected:3094 3095 void unlace(const Key& key) {3096 typename Parent::Value& node = Parent::operator[](key);3097 if (node.prev != INVALID) {3098 Parent::operator[](node.prev).next = node.next;3099 } else {3100 if (node.next != INVALID) {3101 _first[node.value] = node.next;3102 } else {3103 _first.erase(node.value);3104 }3105 }3106 if (node.next != INVALID) {3107 Parent::operator[](node.next).prev = node.prev;3108 }3109 }3110 3111 void lace(const Key& key) {3112 typename Parent::Value& node = Parent::operator[](key);3113 typename std::map<Value, Key>::iterator it = _first.find(node.value);3114 if (it == _first.end()) {3115 node.prev = node.next = INVALID;3116 _first.insert(std::make_pair(node.value, key));3117 } else {3118 node.prev = INVALID;3119 node.next = it->second;3120 if (node.next != INVALID) {3121 Parent::operator[](node.next).prev = key;3122 }3123 it->second = key;3124 }3125 }3126 3127 public:3128 3129 /// \brief Forward iterator for values.3130 ///3131 /// This iterator is an STL compatible forward3132 /// iterator on the values of the map. The values can3133 /// be accessed in the <tt>[beginValue, endValue)</tt> range.3134 class ValueIt3135 : public std::iterator<std::forward_iterator_tag, Value> {3136 friend class IterableValueMap;3137 private:3138 ValueIt(typename std::map<Value, Key>::const_iterator _it)3139 : it(_it) {}3140 public:3141 3142 /// Constructor3143 ValueIt() {}3144 3145 /// \e3146 ValueIt& operator++() { ++it; return *this; }3147 /// \e3148 ValueIt operator++(int) {3149 ValueIt tmp(*this);3150 operator++();3151 return tmp;3152 }3153 3154 /// \e3155 const Value& operator*() const { return it->first; }3156 /// \e3157 const Value* operator->() const { return &(it->first); }3158 3159 /// \e3160 bool operator==(ValueIt jt) const { return it == jt.it; }3161 /// \e3162 bool operator!=(ValueIt jt) const { return it != jt.it; }3163 3164 private:3165 typename std::map<Value, Key>::const_iterator it;3166 };3167 3168 /// \brief Returns an iterator to the first value.3169 ///3170 /// Returns an STL compatible iterator to the3171 /// first value of the map. The values of the3172 /// map can be accessed in the <tt>[beginValue, endValue)</tt>3173 /// range.3174 ValueIt beginValue() const {3175 return ValueIt(_first.begin());3176 }3177 3178 /// \brief Returns an iterator after the last value.3179 ///3180 /// Returns an STL compatible iterator after the3181 /// last value of the map. The values of the3182 /// map can be accessed in the <tt>[beginValue, endValue)</tt>3183 /// range.3184 ValueIt endValue() const {3185 return ValueIt(_first.end());3186 }3187 3188 /// \brief Set operation of the map.3189 ///3190 /// Set operation of the map.3191 void set(const Key& key, const Value& value) {3192 unlace(key);3193 Parent::operator[](key).value = value;3194 lace(key);3195 }3196 3197 /// \brief Const subscript operator of the map.3198 ///3199 /// Const subscript operator of the map.3200 const Value& operator[](const Key& key) const {3201 return Parent::operator[](key).value;3202 }3203 3204 /// \brief Iterator for the keys with the same value.3205 ///3206 /// Iterator for the keys with the same value. It works3207 /// like a graph item iterator, it can be converted to3208 /// the item type of the map, incremented with \c ++ operator, and3209 /// if the iterator leaves the last valid item, it will be equal to3210 /// \c INVALID.3211 class ItemIt : public Key {3212 public:3213 typedef Key Parent;3214 3215 /// \brief Invalid constructor \& conversion.3216 ///3217 /// This constructor initializes the iterator to be invalid.3218 /// \sa Invalid for more details.3219 ItemIt(Invalid) : Parent(INVALID), _map(0) {}3220 3221 /// \brief Creates an iterator with a value.3222 ///3223 /// Creates an iterator with a value. It iterates on the3224 /// keys which have the given value.3225 /// \param map The IterableValueMap3226 /// \param value The value3227 ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) {3228 typename std::map<Value, Key>::const_iterator it =3229 map._first.find(value);3230 if (it == map._first.end()) {3231 Parent::operator=(INVALID);3232 } else {3233 Parent::operator=(it->second);3234 }3235 }3236 3237 /// \brief Increment operator.3238 ///3239 /// Increment Operator.3240 ItemIt& operator++() {3241 Parent::operator=(_map->IterableValueMap::Parent::3242 operator[](static_cast<Parent&>(*this)).next);3243 return *this;3244 }3245 3246 3247 private:3248 const IterableValueMap* _map;3249 };3250 3251 protected:3252 3253 virtual void add(const Key& key) {3254 Parent::add(key);3255 unlace(key);3256 }3257 3258 virtual void add(const std::vector<Key>& keys) {3259 Parent::add(keys);3260 for (int i = 0; i < int(keys.size()); ++i) {3261 lace(keys[i]);3262 }3263 }3264 3265 virtual void erase(const Key& key) {3266 unlace(key);3267 Parent::erase(key);3268 }3269 3270 virtual void erase(const std::vector<Key>& keys) {3271 for (int i = 0; i < int(keys.size()); ++i) {3272 unlace(keys[i]);3273 }3274 Parent::erase(keys);3275 }3276 3277 virtual void build() {3278 Parent::build();3279 for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {3280 lace(it);3281 }3282 }3283 3284 virtual void clear() {3285 _first.clear();3286 Parent::clear();3287 }3288 3289 private:3290 std::map<Value, Key> _first;3291 2331 }; 3292 2332 … … 3301 2341 public: 3302 2342 3303 /// The key type (the \c Arc type of the digraph).2343 ///\e 3304 2344 typedef typename GR::Arc Key; 3305 /// The value type (the \c Node type of the digraph).2345 ///\e 3306 2346 typedef typename GR::Node Value; 3307 2347 … … 3342 2382 public: 3343 2383 3344 /// The key type (the \c Arc type of the digraph).2384 ///\e 3345 2385 typedef typename GR::Arc Key; 3346 /// The value type (the \c Node type of the digraph).2386 ///\e 3347 2387 typedef typename GR::Node Value; 3348 2388 … … 3384 2424 public: 3385 2425 3386 /// The key type (the \c Edge type of the digraph).2426 typedef typename GR::Arc Value; 3387 2427 typedef typename GR::Edge Key; 3388 /// The value type (the \c Arc type of the digraph).3389 typedef typename GR::Arc Value;3390 2428 3391 2429 /// \brief Constructor … … 3426 2464 public: 3427 2465 3428 /// The key type (the \c Edge type of the digraph).2466 typedef typename GR::Arc Value; 3429 2467 typedef typename GR::Edge Key; 3430 /// The value type (the \c Arc type of the digraph).3431 typedef typename GR::Arc Value;3432 2468 3433 2469 /// \brief Constructor … … 3464 2500 /// whenever the digraph changes. 3465 2501 /// 3466 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 2502 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 3467 2503 /// may provide alternative ways to modify the digraph. 3468 2504 /// The correct behavior of InDegMap is not guarantied if these additional … … 3480 2516 3481 2517 public: 3482 2518 3483 2519 /// The graph type of InDegMap 3484 2520 typedef GR Graph; … … 3594 2630 /// whenever the digraph changes. 3595 2631 /// 3596 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 2632 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 3597 2633 /// may provide alternative ways to modify the digraph. 3598 2634 /// The correct behavior of OutDegMap is not guarantied if these additional -
lemon/min_cost_arborescence.h
r760 r672 489 489 /// The simplest way to execute the algorithm is to use 490 490 /// one of the member functions called \c run(...). \n 491 /// If you need bettercontrol on the execution,492 /// you have to call \ref init() first, then you can add several491 /// If you need more control on the execution, 492 /// first you must call \ref init(), then you can add several 493 493 /// source nodes with \ref addSource(). 494 494 /// Finally \ref start() will perform the arborescence -
lemon/network_simplex.h
r777 r710 162 162 TEMPLATE_DIGRAPH_TYPEDEFS(GR); 163 163 164 typedef std::vector<Arc> ArcVector; 165 typedef std::vector<Node> NodeVector; 164 166 typedef std::vector<int> IntVector; 165 167 typedef std::vector<bool> BoolVector; … … 363 365 Cost c, min = 0; 364 366 int cnt = _block_size; 365 int e ;367 int e, min_arc = _next_arc; 366 368 for (e = _next_arc; e < _search_arc_num; ++e) { 367 369 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 368 370 if (c < min) { 369 371 min = c; 370 _in_arc = e;372 min_arc = e; 371 373 } 372 374 if (--cnt == 0) { 373 if (min < 0) goto search_end;375 if (min < 0) break; 374 376 cnt = _block_size; 375 377 } 376 378 } 377 for (e = 0; e < _next_arc; ++e) { 378 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 379 if (c < min) { 380 min = c; 381 _in_arc = e; 382 } 383 if (--cnt == 0) { 384 if (min < 0) goto search_end; 385 cnt = _block_size; 379 if (min == 0 || cnt > 0) { 380 for (e = 0; e < _next_arc; ++e) { 381 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 382 if (c < min) { 383 min = c; 384 min_arc = e; 385 } 386 if (--cnt == 0) { 387 if (min < 0) break; 388 cnt = _block_size; 389 } 386 390 } 387 391 } 388 392 if (min >= 0) return false; 389 390 search_end: 393 _in_arc = min_arc; 391 394 _next_arc = e; 392 395 return true; … … 426 429 { 427 430 // The main parameters of the pivot rule 428 const double LIST_LENGTH_FACTOR = 0.25;431 const double LIST_LENGTH_FACTOR = 1.0; 429 432 const int MIN_LIST_LENGTH = 10; 430 433 const double MINOR_LIMIT_FACTOR = 0.1; … … 443 446 bool findEnteringArc() { 444 447 Cost min, c; 445 int e ;448 int e, min_arc = _next_arc; 446 449 if (_curr_length > 0 && _minor_count < _minor_limit) { 447 450 // Minor iteration: select the best eligible arc from the … … 454 457 if (c < min) { 455 458 min = c; 456 _in_arc = e;459 min_arc = e; 457 460 } 458 elseif (c >= 0) {461 if (c >= 0) { 459 462 _candidates[i--] = _candidates[--_curr_length]; 460 463 } 461 464 } 462 if (min < 0) return true; 465 if (min < 0) { 466 _in_arc = min_arc; 467 return true; 468 } 463 469 } 464 470 … … 472 478 if (c < min) { 473 479 min = c; 474 _in_arc = e;480 min_arc = e; 475 481 } 476 if (_curr_length == _list_length) goto search_end; 477 } 478 } 479 for (e = 0; e < _next_arc; ++e) { 480 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 481 if (c < 0) { 482 _candidates[_curr_length++] = e; 483 if (c < min) { 484 min = c; 485 _in_arc = e; 482 if (_curr_length == _list_length) break; 483 } 484 } 485 if (_curr_length < _list_length) { 486 for (e = 0; e < _next_arc; ++e) { 487 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 488 if (c < 0) { 489 _candidates[_curr_length++] = e; 490 if (c < min) { 491 min = c; 492 min_arc = e; 493 } 494 if (_curr_length == _list_length) break; 486 495 } 487 if (_curr_length == _list_length) goto search_end;488 496 } 489 497 } 490 498 if (_curr_length == 0) return false; 491 492 search_end:493 499 _minor_count = 1; 500 _in_arc = min_arc; 494 501 _next_arc = e; 495 502 return true; … … 543 550 { 544 551 // The main parameters of the pivot rule 545 const double BLOCK_SIZE_FACTOR = 1. 0;552 const double BLOCK_SIZE_FACTOR = 1.5; 546 553 const int MIN_BLOCK_SIZE = 10; 547 554 const double HEAD_LENGTH_FACTOR = 0.1; … … 572 579 // Extend the list 573 580 int cnt = _block_size; 581 int last_arc = 0; 574 582 int limit = _head_length; 575 583 576 for ( e = _next_arc; e < _search_arc_num; ++e) {584 for (int e = _next_arc; e < _search_arc_num; ++e) { 577 585 _cand_cost[e] = _state[e] * 578 586 (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 579 587 if (_cand_cost[e] < 0) { 580 588 _candidates[_curr_length++] = e; 589 last_arc = e; 581 590 } 582 591 if (--cnt == 0) { 583 if (_curr_length > limit) goto search_end;592 if (_curr_length > limit) break; 584 593 limit = 0; 585 594 cnt = _block_size; 586 595 } 587 596 } 588 for (e = 0; e < _next_arc; ++e) { 589 _cand_cost[e] = _state[e] * 590 (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 591 if (_cand_cost[e] < 0) { 592 _candidates[_curr_length++] = e; 593 } 594 if (--cnt == 0) { 595 if (_curr_length > limit) goto search_end; 596 limit = 0; 597 cnt = _block_size; 597 if (_curr_length <= limit) { 598 for (int e = 0; e < _next_arc; ++e) { 599 _cand_cost[e] = _state[e] * 600 (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 601 if (_cand_cost[e] < 0) { 602 _candidates[_curr_length++] = e; 603 last_arc = e; 604 } 605 if (--cnt == 0) { 606 if (_curr_length > limit) break; 607 limit = 0; 608 cnt = _block_size; 609 } 598 610 } 599 611 } 600 612 if (_curr_length == 0) return false; 601 602 search_end: 613 _next_arc = last_arc + 1; 603 614 604 615 // Make heap of the candidate list (approximating a partial sort) … … 608 619 // Pop the first element of the heap 609 620 _in_arc = _candidates[0]; 610 _next_arc = e;611 621 pop_heap( _candidates.begin(), _candidates.begin() + _curr_length, 612 622 _sort_func ); … … 624 634 /// 625 635 /// \param graph The digraph the algorithm runs on. 626 /// \param arc_mixing Indicate if the arcs have to be stored in a 627 /// mixed order in the internal data structure. 628 /// In special cases, it could lead to better overall performance, 629 /// but it is usually slower. Therefore it is disabled by default. 630 NetworkSimplex(const GR& graph, bool arc_mixing = false) : 636 NetworkSimplex(const GR& graph) : 631 637 _graph(graph), _node_id(graph), _arc_id(graph), 632 638 INF(std::numeric_limits<Value>::has_infinity ? … … 666 672 _state.resize(max_arc_num); 667 673 668 // Copy the graph 674 // Copy the graph (store the arcs in a mixed order) 669 675 int i = 0; 670 676 for (NodeIt n(_graph); n != INVALID; ++n, ++i) { 671 677 _node_id[n] = i; 672 678 } 673 if (arc_mixing) { 674 // Store the arcs in a mixed order 675 int k = std::max(int(std::sqrt(double(_arc_num))), 10); 676 int i = 0, j = 0; 677 for (ArcIt a(_graph); a != INVALID; ++a) { 678 _arc_id[a] = i; 679 _source[i] = _node_id[_graph.source(a)]; 680 _target[i] = _node_id[_graph.target(a)]; 681 if ((i += k) >= _arc_num) i = ++j; 682 } 683 } else { 684 // Store the arcs in the original order 685 int i = 0; 686 for (ArcIt a(_graph); a != INVALID; ++a, ++i) { 687 _arc_id[a] = i; 688 _source[i] = _node_id[_graph.source(a)]; 689 _target[i] = _node_id[_graph.target(a)]; 690 } 679 int k = std::max(int(std::sqrt(double(_arc_num))), 10); 680 i = 0; 681 for (ArcIt a(_graph); a != INVALID; ++a) { 682 _arc_id[a] = i; 683 _source[i] = _node_id[_graph.source(a)]; 684 _target[i] = _node_id[_graph.target(a)]; 685 if ((i += k) >= _arc_num) i = (i % k) + 1; 691 686 } 692 687 693 // Reset parameters 694 reset(); 688 // Initialize maps 689 for (int i = 0; i != _node_num; ++i) { 690 _supply[i] = 0; 691 } 692 for (int i = 0; i != _arc_num; ++i) { 693 _lower[i] = 0; 694 _upper[i] = INF; 695 _cost[i] = 1; 696 } 697 _have_lower = false; 698 _stype = GEQ; 695 699 } 696 700 … … 765 769 /// If neither this function nor \ref stSupply() is used before 766 770 /// calling \ref run(), the supply of each node will be set to zero. 771 /// (It makes sense only if non-zero lower bounds are given.) 767 772 /// 768 773 /// \param map A node map storing the supply values. … … 785 790 /// If neither this function nor \ref supplyMap() is used before 786 791 /// calling \ref run(), the supply of each node will be set to zero. 792 /// (It makes sense only if non-zero lower bounds are given.) 787 793 /// 788 794 /// Using this function has the same effect as using \ref supplyMap() -
lemon/preflow.h
r762 r688 53 53 /// The type of the map that stores the flow values. 54 54 /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 55 #ifdef DOXYGEN56 typedef GR::ArcMap<Value> FlowMap;57 #else58 55 typedef typename Digraph::template ArcMap<Value> FlowMap; 59 #endif60 56 61 57 /// \brief Instantiates a FlowMap. … … 72 68 /// The elevator type used by Preflow algorithm. 73 69 /// 74 /// \sa Elevator, LinkedElevator 75 #ifdef DOXYGEN 76 typedef lemon::Elevator<GR, GR::Node> Elevator; 77 #else 78 typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator; 79 #endif 70 /// \sa Elevator 71 /// \sa LinkedElevator 72 typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator; 80 73 81 74 /// \brief Instantiates an Elevator. … … 105 98 /// "flow of maximum value" in a digraph. 106 99 /// The preflow algorithms are the fastest known maximum 107 /// flow algorithms. The current implementation use sa mixture of the100 /// flow algorithms. The current implementation use a mixture of the 108 101 /// \e "highest label" and the \e "bound decrease" heuristics. 109 102 /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$. … … 379 372 } 380 373 381 /// \brief Sets the tolerance used by the algorithm. 382 /// 383 /// Sets the tolerance object used by the algorithm. 384 /// \return <tt>(*this)</tt> 385 Preflow& tolerance(const Tolerance& tolerance) { 374 /// \brief Sets the tolerance used by algorithm. 375 /// 376 /// Sets the tolerance used by algorithm. 377 Preflow& tolerance(const Tolerance& tolerance) const { 386 378 _tolerance = tolerance; 387 379 return *this; … … 390 382 /// \brief Returns a const reference to the tolerance. 391 383 /// 392 /// Returns a const reference to the tolerance object used by 393 /// the algorithm. 384 /// Returns a const reference to the tolerance. 394 385 const Tolerance& tolerance() const { 395 return _tolerance;386 return tolerance; 396 387 } 397 388 … … 399 390 /// The simplest way to execute the preflow algorithm is to use 400 391 /// \ref run() or \ref runMinCut().\n 401 /// If you need bettercontrol on the initial solution or the execution,402 /// you have to call one of the \ref init() functions first, then392 /// If you need more control on the initial solution or the execution, 393 /// first you have to call one of the \ref init() functions, then 403 394 /// \ref startFirstPhase() and if you need it \ref startSecondPhase(). 404 395 -
lemon/radix_heap.h
r758 r730 20 20 #define LEMON_RADIX_HEAP_H 21 21 22 ///\ingroup heaps22 ///\ingroup auxdat 23 23 ///\file 24 ///\brief Radix heap implementation.24 ///\brief Radix Heap implementation. 25 25 26 26 #include <vector> … … 30 30 31 31 32 /// \ingroup heaps32 /// \ingroup auxdata 33 33 /// 34 /// \brief Radix heap data structure.34 /// \brief A Radix Heap implementation. 35 35 /// 36 /// This class implements the \e radix \e heap data structure. 37 /// It practically conforms to the \ref concepts::Heap "heap concept", 38 /// but it has some limitations due its special implementation. 39 /// The type of the priorities must be \c int and the priority of an 40 /// item cannot be decreased under the priority of the last removed item. 36 /// This class implements the \e radix \e heap data structure. A \e heap 37 /// is a data structure for storing items with specified values called \e 38 /// priorities in such a way that finding the item with minimum priority is 39 /// efficient. This heap type can store only items with \e int priority. 40 /// In a heap one can change the priority of an item, add or erase an 41 /// item, but the priority cannot be decreased under the last removed 42 /// item's priority. 41 43 /// 42 /// \tparam IM A read-writable item map with \c int values, used 43 /// internally to handle the cross references. 44 /// \param IM A read and writable Item int map, used internally 45 /// to handle the cross references. 46 /// 47 /// \see BinHeap 48 /// \see Dijkstra 44 49 template <typename IM> 45 50 class RadixHeap { 46 51 47 52 public: 48 49 /// Type of the item-int map.53 typedef typename IM::Key Item; 54 typedef int Prio; 50 55 typedef IM ItemIntMap; 51 /// Type of the priorities.52 typedef int Prio;53 /// Type of the items stored in the heap.54 typedef typename ItemIntMap::Key Item;55 56 56 57 /// \brief Exception thrown by RadixHeap. 57 58 /// 58 /// This exception is thrown when an item is inserted into a59 /// RadixHeap with a priority smaller than the last erased one.59 /// This Exception is thrown when a smaller priority 60 /// is inserted into the \e RadixHeap then the last time erased. 60 61 /// \see RadixHeap 61 class PriorityUnderflowError : public Exception { 62 63 class UnderFlowPriorityError : public Exception { 62 64 public: 63 65 virtual const char* what() const throw() { 64 return "lemon::RadixHeap:: PriorityUnderflowError";66 return "lemon::RadixHeap::UnderFlowPriorityError"; 65 67 } 66 68 }; 67 69 68 /// \brief Type to represent the states of the items.69 /// 70 /// Each item has a state associated to it. It canbe "in heap",71 /// "pre -heap" or "post-heap". The latter two are indifferent from the70 /// \brief Type to represent the items states. 71 /// 72 /// Each Item element have a state associated to it. It may be "in heap", 73 /// "pre heap" or "post heap". The latter two are indifferent from the 72 74 /// heap's point of view, but may be useful to the user. 73 75 /// 74 /// The item-int map must be initialized in such way that it assigns75 /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.76 /// The ItemIntMap \e should be initialized in such way that it maps 77 /// PRE_HEAP (-1) to any element to be put in the heap... 76 78 enum State { 77 IN_HEAP = 0, ///< = 0.78 PRE_HEAP = -1, ///< = -1.79 POST_HEAP = -2 ///< = -2.79 IN_HEAP = 0, 80 PRE_HEAP = -1, 81 POST_HEAP = -2 80 82 }; 81 83 … … 95 97 }; 96 98 97 std::vector<RadixItem> _data;98 std::vector<RadixBox> _boxes;99 std::vector<RadixItem> data; 100 std::vector<RadixBox> boxes; 99 101 100 102 ItemIntMap &_iim; 101 103 104 102 105 public: 103 104 /// \brief Constructor.105 /// 106 /// Constructor.107 /// \param map A map that assigns \c int values to the items.108 /// It is used internally to handle the cross references.109 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.110 /// \param minimum The initial minimum value of the heap.111 /// \param capacity The initial capacityof the heap.112 RadixHeap(ItemIntMap &map, int minimum = 0, int capacity = 0)113 : _iim(map)114 {115 _boxes.push_back(RadixBox(minimum, 1));116 _boxes.push_back(RadixBox(minimum+ 1, 1));117 while (lower( _boxes.size() - 1, capacity + minimum- 1)) {106 /// \brief The constructor. 107 /// 108 /// The constructor. 109 /// 110 /// \param map It 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. 113 /// 114 /// \param minimal The initial minimal value of the heap. 115 /// \param capacity It determines the initial capacity of the heap. 116 RadixHeap(ItemIntMap &map, int minimal = 0, int capacity = 0) 117 : _iim(map) { 118 boxes.push_back(RadixBox(minimal, 1)); 119 boxes.push_back(RadixBox(minimal + 1, 1)); 120 while (lower(boxes.size() - 1, capacity + minimal - 1)) { 118 121 extend(); 119 122 } 120 123 } 121 124 122 /// \brief The number of items stored in the heap. 123 /// 124 /// This function returns the number of items stored in the heap. 125 int size() const { return _data.size(); } 126 127 /// \brief Check if the heap is empty. 128 /// 129 /// This function returns \c true if the heap is empty. 130 bool empty() const { return _data.empty(); } 131 132 /// \brief Make the heap empty. 133 /// 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. 139 /// \param minimum The minimum value of the heap. 140 /// \param capacity The capacity of the heap. 141 void clear(int minimum = 0, int capacity = 0) { 142 _data.clear(); _boxes.clear(); 143 _boxes.push_back(RadixBox(minimum, 1)); 144 _boxes.push_back(RadixBox(minimum + 1, 1)); 145 while (lower(_boxes.size() - 1, capacity + minimum - 1)) { 125 /// The number of items stored in the heap. 126 /// 127 /// \brief Returns the number of items stored in the heap. 128 int size() const { return data.size(); } 129 /// \brief Checks if the heap stores no items. 130 /// 131 /// Returns \c true if and only if the heap stores no items. 132 bool empty() const { return data.empty(); } 133 134 /// \brief Make empty this heap. 135 /// 136 /// Make empty this heap. It does not change the cross reference 137 /// map. If you want to reuse a heap what is not surely empty you 138 /// should first clear the heap and after that you should set the 139 /// cross reference map for each item to \c PRE_HEAP. 140 void clear(int minimal = 0, int capacity = 0) { 141 data.clear(); boxes.clear(); 142 boxes.push_back(RadixBox(minimal, 1)); 143 boxes.push_back(RadixBox(minimal + 1, 1)); 144 while (lower(boxes.size() - 1, capacity + minimal - 1)) { 146 145 extend(); 147 146 } … … 151 150 152 151 bool upper(int box, Prio pr) { 153 return pr < _boxes[box].min;152 return pr < boxes[box].min; 154 153 } 155 154 156 155 bool lower(int box, Prio pr) { 157 return pr >= _boxes[box].min + _boxes[box].size;158 } 159 160 // Remove item from the box list156 return pr >= boxes[box].min + boxes[box].size; 157 } 158 159 /// \brief Remove item from the box list. 161 160 void remove(int index) { 162 if ( _data[index].prev >= 0) {163 _data[_data[index].prev].next = _data[index].next;161 if (data[index].prev >= 0) { 162 data[data[index].prev].next = data[index].next; 164 163 } else { 165 _boxes[_data[index].box].first = _data[index].next;166 } 167 if ( _data[index].next >= 0) {168 _data[_data[index].next].prev = _data[index].prev;169 } 170 } 171 172 // Insert item into the box list164 boxes[data[index].box].first = data[index].next; 165 } 166 if (data[index].next >= 0) { 167 data[data[index].next].prev = data[index].prev; 168 } 169 } 170 171 /// \brief Insert item into the box list. 173 172 void insert(int box, int index) { 174 if ( _boxes[box].first == -1) {175 _boxes[box].first = index;176 _data[index].next = _data[index].prev = -1;173 if (boxes[box].first == -1) { 174 boxes[box].first = index; 175 data[index].next = data[index].prev = -1; 177 176 } else { 178 _data[index].next = _boxes[box].first;179 _data[_boxes[box].first].prev = index;180 _data[index].prev = -1;181 _boxes[box].first = index;182 } 183 _data[index].box = box;184 } 185 186 // Add a new box to the box list177 data[index].next = boxes[box].first; 178 data[boxes[box].first].prev = index; 179 data[index].prev = -1; 180 boxes[box].first = index; 181 } 182 data[index].box = box; 183 } 184 185 /// \brief Add a new box to the box list. 187 186 void extend() { 188 int min = _boxes.back().min + _boxes.back().size;189 int bs = 2 * _boxes.back().size;190 _boxes.push_back(RadixBox(min, bs));191 } 192 193 // Move an item up into the proper box.194 void bubble Up(int index) {195 if (!lower( _data[index].box, _data[index].prio)) return;187 int min = boxes.back().min + boxes.back().size; 188 int bs = 2 * boxes.back().size; 189 boxes.push_back(RadixBox(min, bs)); 190 } 191 192 /// \brief Move an item up into the proper box. 193 void bubble_up(int index) { 194 if (!lower(data[index].box, data[index].prio)) return; 196 195 remove(index); 197 int box = findUp( _data[index].box, _data[index].prio);196 int box = findUp(data[index].box, data[index].prio); 198 197 insert(box, index); 199 198 } 200 199 201 // Find up the proper box for the item with the given priority200 /// \brief Find up the proper box for the item with the given prio. 202 201 int findUp(int start, int pr) { 203 202 while (lower(start, pr)) { 204 if (++start == int( _boxes.size())) {203 if (++start == int(boxes.size())) { 205 204 extend(); 206 205 } … … 209 208 } 210 209 211 // Move an item down into the proper box212 void bubble Down(int index) {213 if (!upper( _data[index].box, _data[index].prio)) return;210 /// \brief Move an item down into the proper box. 211 void bubble_down(int index) { 212 if (!upper(data[index].box, data[index].prio)) return; 214 213 remove(index); 215 int box = findDown( _data[index].box, _data[index].prio);214 int box = findDown(data[index].box, data[index].prio); 216 215 insert(box, index); 217 216 } 218 217 219 // Find down the proper box for the item with the given priority218 /// \brief Find up the proper box for the item with the given prio. 220 219 int findDown(int start, int pr) { 221 220 while (upper(start, pr)) { 222 if (--start < 0) throw PriorityUnderflowError();221 if (--start < 0) throw UnderFlowPriorityError(); 223 222 } 224 223 return start; 225 224 } 226 225 227 // Find the first non-empty box226 /// \brief Find the first not empty box. 228 227 int findFirst() { 229 228 int first = 0; 230 while ( _boxes[first].first == -1) ++first;229 while (boxes[first].first == -1) ++first; 231 230 return first; 232 231 } 233 232 234 // Gives back the minimum priority of the given box233 /// \brief Gives back the minimal prio of the box. 235 234 int minValue(int box) { 236 int min = _data[_boxes[box].first].prio;237 for (int k = _boxes[box].first; k != -1; k = _data[k].next) {238 if ( _data[k].prio < min) min = _data[k].prio;235 int min = data[boxes[box].first].prio; 236 for (int k = boxes[box].first; k != -1; k = data[k].next) { 237 if (data[k].prio < min) min = data[k].prio; 239 238 } 240 239 return min; 241 240 } 242 241 243 // Rearrange the items of the heap and make the first box non-empty 242 /// \brief Rearrange the items of the heap and makes the 243 /// first box not empty. 244 244 void moveDown() { 245 245 int box = findFirst(); … … 247 247 int min = minValue(box); 248 248 for (int i = 0; i <= box; ++i) { 249 _boxes[i].min = min;250 min += _boxes[i].size;251 } 252 int curr = _boxes[box].first, next;249 boxes[i].min = min; 250 min += boxes[i].size; 251 } 252 int curr = boxes[box].first, next; 253 253 while (curr != -1) { 254 next = _data[curr].next;255 bubble Down(curr);254 next = data[curr].next; 255 bubble_down(curr); 256 256 curr = next; 257 257 } 258 258 } 259 259 260 void relocate Last(int index) {261 if (index != int( _data.size()) - 1) {262 _data[index] = _data.back();263 if ( _data[index].prev != -1) {264 _data[_data[index].prev].next = index;260 void relocate_last(int index) { 261 if (index != int(data.size()) - 1) { 262 data[index] = data.back(); 263 if (data[index].prev != -1) { 264 data[data[index].prev].next = index; 265 265 } else { 266 _boxes[_data[index].box].first = index;266 boxes[data[index].box].first = index; 267 267 } 268 if ( _data[index].next != -1) {269 _data[_data[index].next].prev = index;268 if (data[index].next != -1) { 269 data[data[index].next].prev = index; 270 270 } 271 _iim[ _data[index].item] = index;272 } 273 _data.pop_back();271 _iim[data[index].item] = index; 272 } 273 data.pop_back(); 274 274 } 275 275 … … 278 278 /// \brief Insert an item into the heap with the given priority. 279 279 /// 280 /// This function inserts the given item into the heap with the 281 /// given priority. 280 /// Adds \c i to the heap with priority \c p. 282 281 /// \param i The item to insert. 283 282 /// \param p The priority of the item. 284 /// \pre \e i must not be stored in the heap.285 /// \warning This method may throw an \c UnderFlowPriorityException.286 283 void push(const Item &i, const Prio &p) { 287 int n = _data.size();284 int n = data.size(); 288 285 _iim.set(i, n); 289 _data.push_back(RadixItem(i, p));290 while (lower( _boxes.size() - 1, p)) {286 data.push_back(RadixItem(i, p)); 287 while (lower(boxes.size() - 1, p)) { 291 288 extend(); 292 289 } 293 int box = findDown( _boxes.size() - 1, p);290 int box = findDown(boxes.size() - 1, p); 294 291 insert(box, n); 295 292 } 296 293 297 /// \brief Return the item havingminimum priority.298 /// 299 /// This function returns the item havingminimum priority.300 /// \pre The heap must be non -empty.294 /// \brief Returns the item with minimum priority. 295 /// 296 /// This method returns the item with minimum priority. 297 /// \pre The heap must be nonempty. 301 298 Item top() const { 302 299 const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown(); 303 return _data[_boxes[0].first].item;304 } 305 306 /// \brief The minimum priority.307 /// 308 /// This functionreturns the minimum priority.309 /// \pre The heap must be non -empty.300 return data[boxes[0].first].item; 301 } 302 303 /// \brief Returns the minimum priority. 304 /// 305 /// It returns the minimum priority. 306 /// \pre The heap must be nonempty. 310 307 Prio prio() const { 311 308 const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown(); 312 return _data[_boxes[0].first].prio;309 return data[boxes[0].first].prio; 313 310 } 314 311 315 /// \brief Remove the item havingminimum priority.316 /// 317 /// This function removes the item havingminimum priority.312 /// \brief Deletes the item with minimum priority. 313 /// 314 /// This method deletes the item with minimum priority. 318 315 /// \pre The heap must be non-empty. 319 316 void pop() { 320 317 moveDown(); 321 int index = _boxes[0].first;322 _iim[ _data[index].item] = POST_HEAP;318 int index = boxes[0].first; 319 _iim[data[index].item] = POST_HEAP; 323 320 remove(index); 324 relocateLast(index); 325 } 326 327 /// \brief Remove the given item from the heap. 328 /// 329 /// This function removes the given item from the heap if it is 330 /// already stored. 331 /// \param i The item to delete. 332 /// \pre \e i must be in the heap. 321 relocate_last(index); 322 } 323 324 /// \brief Deletes \c i from the heap. 325 /// 326 /// This method deletes item \c i from the heap, if \c i was 327 /// already stored in the heap. 328 /// \param i The item to erase. 333 329 void erase(const Item &i) { 334 330 int index = _iim[i]; 335 331 _iim[i] = POST_HEAP; 336 332 remove(index); 337 relocate Last(index);333 relocate_last(index); 338 334 } 339 335 340 /// \brief The priority of the given item.341 /// 342 /// This function returns the priority of the given item.343 /// \p aram i The item.344 /// \p re \e i must be in the heap.336 /// \brief Returns the priority of \c i. 337 /// 338 /// This function returns the priority of item \c i. 339 /// \pre \c i must be in the heap. 340 /// \param i The item. 345 341 Prio operator[](const Item &i) const { 346 342 int idx = _iim[i]; 347 return _data[idx].prio;348 } 349 350 /// \brief Set the priority of an item or insert it, if it is351 /// not stored in the heap.352 /// 353 /// This method sets the priority of the given item if it is354 /// already stored in the heap. Otherwise it inserts the given355 /// item into the heap with the given priority.343 return data[idx].prio; 344 } 345 346 /// \brief \c i gets to the heap with priority \c p independently 347 /// if \c i was already there. 348 /// 349 /// This method calls \ref push(\c i, \c p) if \c i is not stored 350 /// in the heap and sets the priority of \c i to \c p otherwise. 351 /// It may throw an \e UnderFlowPriorityException. 356 352 /// \param i The item. 357 353 /// \param p The priority. 358 /// \pre \e i must be in the heap.359 /// \warning This method may throw an \c UnderFlowPriorityException.360 354 void set(const Item &i, const Prio &p) { 361 355 int idx = _iim[i]; … … 363 357 push(i, p); 364 358 } 365 else if( p >= _data[idx].prio ) {366 _data[idx].prio = p;367 bubble Up(idx);359 else if( p >= data[idx].prio ) { 360 data[idx].prio = p; 361 bubble_up(idx); 368 362 } else { 369 _data[idx].prio = p; 370 bubbleDown(idx); 371 } 372 } 373 374 /// \brief Decrease the priority of an item to the given value. 375 /// 376 /// This function decreases the priority of an item to the given value. 363 data[idx].prio = p; 364 bubble_down(idx); 365 } 366 } 367 368 369 /// \brief Decreases the priority of \c i to \c p. 370 /// 371 /// This method decreases the priority of item \c i to \c p. 372 /// \pre \c i must be stored in the heap with priority at least \c p, and 373 /// \c should be greater or equal to the last removed item's priority. 377 374 /// \param i The item. 378 375 /// \param p The priority. 379 /// \pre \e i must be stored in the heap with priority at least \e p.380 /// \warning This method may throw an \c UnderFlowPriorityException.381 376 void decrease(const Item &i, const Prio &p) { 382 377 int idx = _iim[i]; 383 _data[idx].prio = p; 384 bubbleDown(idx); 385 } 386 387 /// \brief Increase the priority of an item to the given value. 388 /// 389 /// This function increases the priority of an item to the given value. 378 data[idx].prio = p; 379 bubble_down(idx); 380 } 381 382 /// \brief Increases the priority of \c i to \c p. 383 /// 384 /// This method sets the priority of item \c i to \c p. 385 /// \pre \c i must be stored in the heap with priority at most \c p 390 386 /// \param i The item. 391 387 /// \param p The priority. 392 /// \pre \e i must be stored in the heap with priority at most \e p.393 388 void increase(const Item &i, const Prio &p) { 394 389 int idx = _iim[i]; 395 _data[idx].prio = p;396 bubble Up(idx);397 } 398 399 /// \brief Return the state of an item.400 /// 401 /// This method returns \c PRE_HEAP if the given item has never402 /// been in the heap, \c IN_HEAP if it is in the heap at the moment,403 /// and \c POST_HEAP otherwise.404 /// In the latter case it is possible that the item will get back405 /// to the heap again.390 data[idx].prio = p; 391 bubble_up(idx); 392 } 393 394 /// \brief Returns if \c item is in, has already been in, or has 395 /// never been in the heap. 396 /// 397 /// This method returns PRE_HEAP if \c item has never been in the 398 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP 399 /// otherwise. In the latter case it is possible that \c item will 400 /// get back to the heap again. 406 401 /// \param i The item. 407 402 State state(const Item &i) const { … … 411 406 } 412 407 413 /// \brief Set the state of anitem in the heap.414 /// 415 /// This function sets the state of the given item in the heap.416 /// It can be used to manually clear the heap when it is important417 /// to achivebetter time complexity.408 /// \brief Sets the state of the \c item in the heap. 409 /// 410 /// Sets the state of the \c item in the heap. It can be used to 411 /// manually clear the heap when it is important to achive the 412 /// better time complexity. 418 413 /// \param i The item. 419 414 /// \param st The state. It should not be \c IN_HEAP. -
scripts/chg-len.py
r780 r439 1 1 #! /usr/bin/env python 2 #3 # This file is a part of LEMON, a generic C++ optimization library.4 #5 # Copyright (C) 2003-20096 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport7 # (Egervary Research Group on Combinatorial Optimization, EGRES).8 #9 # Permission to use, modify and distribute this software is granted10 # provided that this copyright notice appears in all copies. For11 # 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 any15 # purpose.16 2 17 3 import sys -
scripts/mk-release.sh
r780 r611 1 1 #!/bin/bash 2 #3 # This file is a part of LEMON, a generic C++ optimization library.4 #5 # Copyright (C) 2003-20096 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport7 # (Egervary Research Group on Combinatorial Optimization, EGRES).8 #9 # Permission to use, modify and distribute this software is granted10 # provided that this copyright notice appears in all copies. For11 # 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 any15 # purpose.16 2 17 3 set -e -
scripts/unify-sources.sh
r780 r702 1 1 #!/bin/bash 2 #3 # This file is a part of LEMON, a generic C++ optimization library.4 #5 # Copyright (C) 2003-20096 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport7 # (Egervary Research Group on Combinatorial Optimization, EGRES).8 #9 # Permission to use, modify and distribute this software is granted10 # provided that this copyright notice appears in all copies. For11 # 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 any15 # purpose.16 2 17 3 YEAR=`date +%Y` -
test/CMakeLists.txt
r745 r726 10 10 SET(TESTS 11 11 adaptors_test 12 bellman_ford_test13 12 bfs_test 14 13 circulation_test -
test/Makefile.am
r745 r696 8 8 check_PROGRAMS += \ 9 9 test/adaptors_test \ 10 test/bellman_ford_test \11 10 test/bfs_test \ 12 11 test/circulation_test \ … … 54 53 55 54 test_adaptors_test_SOURCES = test/adaptors_test.cc 56 test_bellman_ford_test_SOURCES = test/bellman_ford_test.cc57 55 test_bfs_test_SOURCES = test/bfs_test.cc 58 56 test_circulation_test_SOURCES = test/circulation_test.cc -
test/circulation_test.cc
r736 r658 88 88 .supplyMap(supply) 89 89 .flowMap(flow); 90 91 const CirculationType::Elevator& elev = const_circ_test.elevator();92 circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));93 CirculationType::Tolerance tol = const_circ_test.tolerance();94 circ_test.tolerance(tol);95 90 96 91 circ_test.init(); -
test/heap_test.cc
r749 r728 26 26 27 27 #include <lemon/smart_graph.h> 28 28 29 #include <lemon/lgf_reader.h> 29 30 #include <lemon/dijkstra.h> … … 31 32 32 33 #include <lemon/bin_heap.h> 33 #include <lemon/fourary_heap.h>34 #include <lemon/kary_heap.h>35 34 #include <lemon/fib_heap.h> 36 #include <lemon/pairing_heap.h>37 35 #include <lemon/radix_heap.h> 38 #include <lemon/binom_heap.h>39 36 #include <lemon/bucket_heap.h> 40 37 … … 93 90 void heapSortTest() { 94 91 RangeMap<int> map(test_len, -1); 92 95 93 Heap heap(map); 96 94 97 95 std::vector<int> v(test_len); 96 98 97 for (int i = 0; i < test_len; ++i) { 99 98 v[i] = test_seq[i]; … … 102 101 std::sort(v.begin(), v.end()); 103 102 for (int i = 0; i < test_len; ++i) { 104 check(v[i] == heap.prio() ,"Wrong order in heap sort.");103 check(v[i] == heap.prio() ,"Wrong order in heap sort."); 105 104 heap.pop(); 106 105 } … … 114 113 115 114 std::vector<int> v(test_len); 115 116 116 for (int i = 0; i < test_len; ++i) { 117 117 v[i] = test_seq[i]; … … 124 124 std::sort(v.begin(), v.end()); 125 125 for (int i = 0; i < test_len; ++i) { 126 check(v[i] == heap.prio() ,"Wrong order in heap increase test.");126 check(v[i] == heap.prio() ,"Wrong order in heap increase test."); 127 127 heap.pop(); 128 128 } 129 129 } 130 131 130 132 131 133 template <typename Heap> … … 143 145 if (dijkstra.reached(s)) { 144 146 check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a], 145 "Error in shortest path tree.");147 "Error in a shortest path tree!"); 146 148 } 147 149 } … … 152 154 Node s = digraph.source(a); 153 155 check( dijkstra.dist(n) - dijkstra.dist(s) == length[a], 154 "Error in shortest path tree.");156 "Error in a shortest path tree!"); 155 157 } 156 158 } … … 174 176 run(); 175 177 176 // BinHeap177 178 { 178 179 typedef BinHeap<Prio, ItemIntMap> IntHeap; … … 186 187 } 187 188 188 // FouraryHeap189 {190 typedef FouraryHeap<Prio, ItemIntMap> IntHeap;191 checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();192 heapSortTest<IntHeap>();193 heapIncreaseTest<IntHeap>();194 195 typedef FouraryHeap<Prio, IntNodeMap > NodeHeap;196 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();197 dijkstraHeapTest<NodeHeap>(digraph, length, source);198 }199 200 // KaryHeap201 {202 typedef KaryHeap<Prio, ItemIntMap> IntHeap;203 checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();204 heapSortTest<IntHeap>();205 heapIncreaseTest<IntHeap>();206 207 typedef KaryHeap<Prio, IntNodeMap > NodeHeap;208 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();209 dijkstraHeapTest<NodeHeap>(digraph, length, source);210 }211 212 // FibHeap213 189 { 214 190 typedef FibHeap<Prio, ItemIntMap> IntHeap; … … 222 198 } 223 199 224 // PairingHeap225 {226 typedef PairingHeap<Prio, ItemIntMap> IntHeap;227 checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();228 heapSortTest<IntHeap>();229 heapIncreaseTest<IntHeap>();230 231 typedef PairingHeap<Prio, IntNodeMap > NodeHeap;232 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();233 dijkstraHeapTest<NodeHeap>(digraph, length, source);234 }235 236 // RadixHeap237 200 { 238 201 typedef RadixHeap<ItemIntMap> IntHeap; … … 246 209 } 247 210 248 // BinomHeap249 {250 typedef BinomHeap<Prio, ItemIntMap> IntHeap;251 checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();252 heapSortTest<IntHeap>();253 heapIncreaseTest<IntHeap>();254 255 typedef BinomHeap<Prio, IntNodeMap > NodeHeap;256 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();257 dijkstraHeapTest<NodeHeap>(digraph, length, source);258 }259 260 // BucketHeap, SimpleBucketHeap261 211 { 262 212 typedef BucketHeap<ItemIntMap> IntHeap; … … 268 218 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>(); 269 219 dijkstraHeapTest<NodeHeap>(digraph, length, source); 270 271 typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap; 272 heapSortTest<SimpleIntHeap>(); 273 } 220 } 221 274 222 275 223 return 0; -
test/maps_test.cc
r773 r731 24 24 #include <lemon/maps.h> 25 25 #include <lemon/list_graph.h> 26 #include <lemon/smart_graph.h>27 #include <lemon/adaptors.h>28 #include <lemon/dfs.h>29 26 30 27 #include "test_tools.h" … … 64 61 typedef ReadWriteMap<A, bool> BoolWriteMap; 65 62 typedef ReferenceMap<A, bool, bool&, const bool&> BoolRefMap; 66 67 template<typename Map1, typename Map2, typename ItemIt>68 void compareMap(const Map1& map1, const Map2& map2, ItemIt it) {69 for (; it != INVALID; ++it)70 check(map1[it] == map2[it], "The maps are not equal");71 }72 63 73 64 int main() … … 339 330 { 340 331 typedef std::vector<int> vec; 341 checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >();342 checkConcept<WriteMap<int, bool>,343 LoggerBoolMap<std::back_insert_iterator<vec> > >();344 345 332 vec v1; 346 333 vec v2(10); … … 362 349 it != map2.end(); ++it ) 363 350 check(v1[i++] == *it, "Something is wrong with LoggerBoolMap"); 364 365 typedef ListDigraph Graph;366 DIGRAPH_TYPEDEFS(Graph);367 Graph gr;368 369 Node n0 = gr.addNode();370 Node n1 = gr.addNode();371 Node n2 = gr.addNode();372 Node n3 = gr.addNode();373 374 gr.addArc(n3, n0);375 gr.addArc(n3, n2);376 gr.addArc(n0, n2);377 gr.addArc(n2, n1);378 gr.addArc(n0, n1);379 380 {381 std::vector<Node> v;382 dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();383 384 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,385 "Something is wrong with LoggerBoolMap");386 }387 {388 std::vector<Node> v(countNodes(gr));389 dfs(gr).processedMap(loggerBoolMap(v.begin())).run();390 391 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,392 "Something is wrong with LoggerBoolMap");393 }394 }395 396 // IdMap, RangeIdMap397 {398 typedef ListDigraph Graph;399 DIGRAPH_TYPEDEFS(Graph);400 401 checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();402 checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();403 checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();404 checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();405 406 Graph gr;407 IdMap<Graph, Node> nmap(gr);408 IdMap<Graph, Arc> amap(gr);409 RangeIdMap<Graph, Node> nrmap(gr);410 RangeIdMap<Graph, Arc> armap(gr);411 412 Node n0 = gr.addNode();413 Node n1 = gr.addNode();414 Node n2 = gr.addNode();415 416 Arc a0 = gr.addArc(n0, n1);417 Arc a1 = gr.addArc(n0, n2);418 Arc a2 = gr.addArc(n2, n1);419 Arc a3 = gr.addArc(n2, n0);420 421 check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");422 check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");423 check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");424 425 check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");426 check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");427 check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");428 check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");429 430 check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");431 check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");432 433 check(nrmap.size() == 3 && armap.size() == 4,434 "Wrong RangeIdMap::size()");435 436 check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");437 check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");438 check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");439 440 check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");441 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");442 check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");443 check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");444 445 check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");446 check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");447 448 gr.erase(n1);449 450 if (nrmap[n0] == 1) nrmap.swap(n0, n2);451 nrmap.swap(n2, n0);452 if (armap[a1] == 1) armap.swap(a1, a3);453 armap.swap(a3, a1);454 455 check(nrmap.size() == 2 && armap.size() == 2,456 "Wrong RangeIdMap::size()");457 458 check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");459 check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");460 461 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");462 check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");463 464 check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");465 check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");466 }467 468 // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap469 {470 typedef ListGraph Graph;471 GRAPH_TYPEDEFS(Graph);472 473 checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();474 checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();475 checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();476 checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();477 checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();478 checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();479 480 Graph gr;481 Node n0 = gr.addNode();482 Node n1 = gr.addNode();483 Node n2 = gr.addNode();484 485 gr.addEdge(n0,n1);486 gr.addEdge(n1,n2);487 gr.addEdge(n0,n2);488 gr.addEdge(n2,n1);489 gr.addEdge(n1,n2);490 gr.addEdge(n0,n1);491 492 for (EdgeIt e(gr); e != INVALID; ++e) {493 check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");494 check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");495 }496 497 compareMap(sourceMap(orienter(gr, constMap<Edge, bool>(true))),498 targetMap(orienter(gr, constMap<Edge, bool>(false))),499 EdgeIt(gr));500 501 typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;502 Digraph dgr(gr, constMap<Edge, bool>(true));503 OutDegMap<Digraph> odm(dgr);504 InDegMap<Digraph> idm(dgr);505 506 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");507 check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");508 509 gr.addEdge(n2, n0);510 511 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");512 check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");513 351 } 514 352 … … 516 354 { 517 355 typedef ListDigraph Graph; 518 DIGRAPH_TYPEDEFS(Graph);519 520 checkConcept<ReadWriteMap<Node, int>,521 CrossRefMap<Graph, Node, int> >();522 checkConcept<ReadWriteMap<Node, bool>,523 CrossRefMap<Graph, Node, bool> >();524 checkConcept<ReadWriteMap<Node, double>,525 CrossRefMap<Graph, Node, double> >();526 527 Graph gr;528 typedef CrossRefMap<Graph, Node, char> CRMap;529 CRMap map(gr);530 531 Node n0 = gr.addNode();532 Node n1 = gr.addNode();533 Node n2 = gr.addNode();534 535 map.set(n0, 'A');536 map.set(n1, 'B');537 map.set(n2, 'C');538 539 check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,540 "Wrong CrossRefMap");541 check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,542 "Wrong CrossRefMap");543 check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,544 "Wrong CrossRefMap");545 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,546 "Wrong CrossRefMap::count()");547 548 CRMap::ValueIt it = map.beginValue();549 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&550 it == map.endValue(), "Wrong value iterator");551 552 map.set(n2, 'A');553 554 check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',555 "Wrong CrossRefMap");556 check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");557 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");558 check(map('C') == INVALID && map.inverse()['C'] == INVALID,559 "Wrong CrossRefMap");560 check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0,561 "Wrong CrossRefMap::count()");562 563 it = map.beginValue();564 check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' &&565 it == map.endValue(), "Wrong value iterator");566 567 map.set(n0, 'C');568 569 check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',570 "Wrong CrossRefMap");571 check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");572 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");573 check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");574 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,575 "Wrong CrossRefMap::count()");576 577 it = map.beginValue();578 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&579 it == map.endValue(), "Wrong value iterator");580 }581 582 // CrossRefMap583 {584 typedef SmartDigraph Graph;585 356 DIGRAPH_TYPEDEFS(Graph); 586 357 … … 613 384 it == map.endValue(), "Wrong value iterator"); 614 385 } 615 616 // Iterable bool map 617 { 618 typedef SmartGraph Graph; 619 typedef SmartGraph::Node Item; 620 621 typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm; 622 checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>(); 623 624 const int num = 10; 625 Graph g; 626 std::vector<Item> items; 627 for (int i = 0; i < num; ++i) { 628 items.push_back(g.addNode()); 629 } 630 631 Ibm map1(g, true); 632 int n = 0; 633 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 634 check(map1[static_cast<Item>(it)], "Wrong TrueIt"); 635 ++n; 636 } 637 check(n == num, "Wrong number"); 638 639 n = 0; 640 for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { 641 check(map1[static_cast<Item>(it)], "Wrong ItemIt for true"); 642 ++n; 643 } 644 check(n == num, "Wrong number"); 645 check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt"); 646 check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false"); 647 648 map1[items[5]] = true; 649 650 n = 0; 651 for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { 652 check(map1[static_cast<Item>(it)], "Wrong ItemIt for true"); 653 ++n; 654 } 655 check(n == num, "Wrong number"); 656 657 map1[items[num / 2]] = false; 658 check(map1[items[num / 2]] == false, "Wrong map value"); 659 660 n = 0; 661 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 662 check(map1[static_cast<Item>(it)], "Wrong TrueIt for true"); 663 ++n; 664 } 665 check(n == num - 1, "Wrong number"); 666 667 n = 0; 668 for (Ibm::FalseIt it(map1); it != INVALID; ++it) { 669 check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true"); 670 ++n; 671 } 672 check(n == 1, "Wrong number"); 673 674 map1[items[0]] = false; 675 check(map1[items[0]] == false, "Wrong map value"); 676 677 map1[items[num - 1]] = false; 678 check(map1[items[num - 1]] == false, "Wrong map value"); 679 680 n = 0; 681 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 682 check(map1[static_cast<Item>(it)], "Wrong TrueIt for true"); 683 ++n; 684 } 685 check(n == num - 3, "Wrong number"); 686 check(map1.trueNum() == num - 3, "Wrong number"); 687 688 n = 0; 689 for (Ibm::FalseIt it(map1); it != INVALID; ++it) { 690 check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true"); 691 ++n; 692 } 693 check(n == 3, "Wrong number"); 694 check(map1.falseNum() == 3, "Wrong number"); 695 } 696 697 // Iterable int map 698 { 699 typedef SmartGraph Graph; 700 typedef SmartGraph::Node Item; 701 typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim; 702 703 checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>(); 704 705 const int num = 10; 706 Graph g; 707 std::vector<Item> items; 708 for (int i = 0; i < num; ++i) { 709 items.push_back(g.addNode()); 710 } 711 712 Iim map1(g); 713 check(map1.size() == 0, "Wrong size"); 714 715 for (int i = 0; i < num; ++i) { 716 map1[items[i]] = i; 717 } 718 check(map1.size() == num, "Wrong size"); 719 720 for (int i = 0; i < num; ++i) { 721 Iim::ItemIt it(map1, i); 722 check(static_cast<Item>(it) == items[i], "Wrong value"); 723 ++it; 724 check(static_cast<Item>(it) == INVALID, "Wrong value"); 725 } 726 727 for (int i = 0; i < num; ++i) { 728 map1[items[i]] = i % 2; 729 } 730 check(map1.size() == 2, "Wrong size"); 731 732 int n = 0; 733 for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) { 734 check(map1[static_cast<Item>(it)] == 0, "Wrong value"); 735 ++n; 736 } 737 check(n == (num + 1) / 2, "Wrong number"); 738 739 for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) { 740 check(map1[static_cast<Item>(it)] == 1, "Wrong value"); 741 ++n; 742 } 743 check(n == num, "Wrong number"); 744 745 } 746 747 // Iterable value map 748 { 749 typedef SmartGraph Graph; 750 typedef SmartGraph::Node Item; 751 typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm; 752 753 checkConcept<ReadWriteMap<Item, double>, Ivm>(); 754 755 const int num = 10; 756 Graph g; 757 std::vector<Item> items; 758 for (int i = 0; i < num; ++i) { 759 items.push_back(g.addNode()); 760 } 761 762 Ivm map1(g, 0.0); 763 check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size"); 764 check(*map1.beginValue() == 0.0, "Wrong value"); 765 766 for (int i = 0; i < num; ++i) { 767 map1.set(items[i], static_cast<double>(i)); 768 } 769 check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size"); 770 771 for (int i = 0; i < num; ++i) { 772 Ivm::ItemIt it(map1, static_cast<double>(i)); 773 check(static_cast<Item>(it) == items[i], "Wrong value"); 774 ++it; 775 check(static_cast<Item>(it) == INVALID, "Wrong value"); 776 } 777 778 for (Ivm::ValueIt vit = map1.beginValue(); 779 vit != map1.endValue(); ++vit) { 780 check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit, 781 "Wrong ValueIt"); 782 } 783 784 for (int i = 0; i < num; ++i) { 785 map1.set(items[i], static_cast<double>(i % 2)); 786 } 787 check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size"); 788 789 int n = 0; 790 for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) { 791 check(map1[static_cast<Item>(it)] == 0.0, "Wrong value"); 792 ++n; 793 } 794 check(n == (num + 1) / 2, "Wrong number"); 795 796 for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) { 797 check(map1[static_cast<Item>(it)] == 1.0, "Wrong value"); 798 ++n; 799 } 800 check(n == num, "Wrong number"); 801 802 } 386 803 387 return 0; 804 388 } -
test/preflow_test.cc
r736 r632 95 95 PreflowType preflow_test(g, cap, n, n); 96 96 const PreflowType& const_preflow_test = preflow_test; 97 98 const PreflowType::Elevator& elev = const_preflow_test.elevator();99 preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));100 PreflowType::Tolerance tol = const_preflow_test.tolerance();101 preflow_test.tolerance(tol);102 97 103 98 preflow_test -
tools/lemon-0.x-to-1.x.sh
r738 r621 36 36 -e "s/Edge\>/_Ar_c_label_/g"\ 37 37 -e "s/\<edge\>/_ar_c_label_/g"\ 38 -e "s/_edge\>/_ _ar_c_label_/g"\38 -e "s/_edge\>/_ar_c_label_/g"\ 39 39 -e "s/Edges\>/_Ar_c_label_s/g"\ 40 40 -e "s/\<edges\>/_ar_c_label_s/g"\ 41 -e "s/_edges\>/_ _ar_c_label_s/g"\41 -e "s/_edges\>/_ar_c_label_s/g"\ 42 42 -e "s/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\ 43 43 -e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\ … … 69 69 -e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\ 70 70 -e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\ 71 -e "s/\<digraph_adaptor\.h\>/adaptors.h/g"\72 -e "s/\<digraph_utils\.h\>/core.h/g"\73 -e "s/\<digraph_reader\.h\>/lgf_reader.h/g"\74 -e "s/\<digraph_writer\.h\>/lgf_writer.h/g"\75 -e "s/\<topology\.h\>/connectivity.h/g"\76 71 -e "s/DigraphToEps/GraphToEps/g"\ 77 72 -e "s/digraphToEps/graphToEps/g"\
Note: See TracChangeset
for help on using the changeset viewer.