lemon: comparison lemon/max_cardinality

equal deleted inserted replaced

-:8c33e0e3b900
+:59e83e675aa5
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* This file is a part of LEMON, a generic C++ optimization library.
 *
-* Copyright (C) 2003-2010
+* Copyright (C) 2003-2013
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 #ifndef LEMON_MAX_CARDINALITY_SEARCH_H
 #define LEMON_MAX_CARDINALITY_SEARCH_H
 /// \ingroup search
 /// \file
 /// \brief Maximum cardinality search in undirected digraphs.
 #include <lemon/bin_heap.h>
 #include <lemon/bucket_heap.h>
 /// Default traits class of MaxCardinalitySearch class.
 /// \param Digraph Digraph type.
 /// \param CapacityMap Type of capacity map.
 template <typename GR, typename CAP>
 struct MaxCardinalitySearchDefaultTraits {
 /// The digraph type the algorithm runs on.
 typedef GR Digraph;
 template <typename CM>
 struct CapMapSelector {
 typedef CM CapacityMap;
 static CapacityMap *createCapacityMap(const Digraph& g) {
-	return new CapacityMap(g);
+return new CapacityMap(g);
 }
 };
 template <typename CM>
 struct CapMapSelector<ConstMap<CM, Const<int, 1> > > {
 typedef ConstMap<CM, Const<int, 1> > CapacityMap;
 static CapacityMap *createCapacityMap(const Digraph&) {
-	return new CapacityMap;
+return new CapacityMap;
 }
 };
 /// \brief The type of the map that stores the arc capacities.
 ///
 /// Usually it is \c Digraph::NodeMap<int>.
 typedef typename Digraph::template NodeMap<int> HeapCrossRef;
 /// \brief Instantiates a HeapCrossRef.
 ///
 /// This function instantiates a \ref HeapCrossRef.
 /// \param digraph is the digraph, to which we would like to define the
 /// HeapCrossRef.
 static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
 return new HeapCrossRef(digraph);
 }
 template <typename CapacityMap>
 struct HeapSelector {
 template <typename Value, typename Ref>
 struct Selector {
 typedef BinHeap<Value, Ref, std::greater<Value> > Heap;
 };
 };
 template <typename CapacityKey>
 ::template Selector<Value, HeapCrossRef>
 ::Heap Heap;
 /// \brief Instantiates a Heap.
 ///
 /// This function instantiates a \ref Heap.
 /// \param crossref The cross reference of the heap.
 static Heap *createHeap(HeapCrossRef& crossref) {
 return new Heap(crossref);
 }
 /// By default it is a NullMap.
 typedef NullMap<typename Digraph::Node, bool> ProcessedMap;
 /// \brief Instantiates a ProcessedMap.
 ///
 /// This function instantiates a \ref ProcessedMap.
 /// \param digraph is the digraph, to which
 /// we would like to define the \ref ProcessedMap
 #ifdef DOXYGEN
 static ProcessedMap *createProcessedMap(const Digraph &digraph)
 #else
 {
 return new ProcessedMap();
 }
 /// \brief The type of the map that stores the cardinalities of the nodes.
 ///
 /// The type of the map that stores the cardinalities of the nodes.
 /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
 typedef typename Digraph::template NodeMap<Value> CardinalityMap;
 /// \brief Instantiates a CardinalityMap.
 ///
 /// This function instantiates a \ref CardinalityMap.
 /// \param digraph is the digraph, to which we would like to define the \ref
 /// CardinalityMap
 static CardinalityMap *createCardinalityMap(const Digraph &digraph) {
 return new CardinalityMap(digraph);
 }
 };
 /// \ingroup search
 ///
 /// \brief Maximum Cardinality Search algorithm class.
 ///
 /// This class provides an efficient implementation of Maximum Cardinality
 /// Search algorithm. The maximum cardinality search first chooses any
 /// node of the digraph. Then every time it chooses one unprocessed node
 /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes
 /// which were previusly processed.
 /// If there is a cut in the digraph the algorithm should choose
 /// again any unprocessed node of the digraph.
 /// The arc capacities are passed to the algorithm using a
 /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
 /// kind of capacity.
 ///
 /// The type of the capacity is determined by the \ref
 /// concepts::ReadMap::Value "Value" of the capacity map.
 ///
 /// It is also possible to change the underlying priority heap.
 ///
 ///
 /// \param GR The digraph type the algorithm runs on. The value of
 /// Digraph is not used directly by the search algorithm, it
 /// is only passed to \ref MaxCardinalitySearchDefaultTraits.
 /// \param CAP This read-only ArcMap determines the capacities of
 /// the arcs. It is read once for each arc, so the map may involve in
 /// relatively time consuming process to compute the arc capacity if
 /// it is necessary. The default map type is \ref
 /// ConstMap "ConstMap<concepts::Digraph::Arc, Const<int,1> >". The value
 /// of CapacityMap is not used directly by search algorithm, it is only
 /// passed to \ref MaxCardinalitySearchDefaultTraits.
 /// \param TR Traits class to set various data types used by the
 /// algorithm.  The default traits class is
 /// \ref MaxCardinalitySearchDefaultTraits
 /// "MaxCardinalitySearchDefaultTraits<GR, CAP>".
 /// See \ref MaxCardinalitySearchDefaultTraits
 /// for the documentation of a MaxCardinalitySearch traits class.
 #ifdef DOXYGEN
 template <typename GR, typename CAP, typename TR>
 #else
 template <typename GR, typename CAP =
-	    ConstMap<typename GR::Arc, Const<int,1> >,
+ConstMap<typename GR::Arc, Const<int,1> >,
-	    typename TR =
+typename TR =
 MaxCardinalitySearchDefaultTraits<GR, CAP> >
 #endif
 class MaxCardinalitySearch {
 public:
 typedef TR Traits;
 ///The type of the underlying digraph.
 typedef typename Traits::Digraph Digraph;
 ///The type of the capacity of the arcs.
 typedef typename Traits::CapacityMap::Value Value;
 ///The type of the map that stores the arc capacities.
 typedef typename Traits::CapacityMap CapacityMap;
 ///The type of the map indicating if a node is processed.
 bool local_heap;
 public :
 typedef MaxCardinalitySearch Create;
 ///\name Named template parameters
 ///@{
 template <class T>
 struct DefCapacityMapTraits : public Traits {
 typedef T CapacityMap;
 static CapacityMap *createCapacityMap(const Digraph &) {
-	LEMON_ASSERT(false,"Uninitialized parameter.");
+LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
+return 0;
 }
 };
 /// \brief \ref named-templ-param "Named parameter" for setting
 /// CapacityMap type
 ///
 /// \ref named-templ-param "Named parameter" for setting CapacityMap type
 /// for the algorithm.
 template <class T>
 struct SetCapacityMap
 : public MaxCardinalitySearch<Digraph, CapacityMap,
 DefCapacityMapTraits<T> > {
 typedef MaxCardinalitySearch<Digraph, CapacityMap,
 DefCapacityMapTraits<T> > Create;
 };
 template <class T>
 struct DefCardinalityMapTraits : public Traits {
 typedef T CardinalityMap;
 static CardinalityMap *createCardinalityMap(const Digraph &)
 {
-	LEMON_ASSERT(false,"Uninitialized parameter.");
+LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
+return 0;
 }
 };
 /// \brief \ref named-templ-param "Named parameter" for setting
 /// CardinalityMap type
 ///
 /// \ref named-templ-param "Named parameter" for setting CardinalityMap
 /// type for the algorithm.
 template <class T>
 struct SetCardinalityMap
 : public MaxCardinalitySearch<Digraph, CapacityMap,
 DefCardinalityMapTraits<T> > {
 typedef MaxCardinalitySearch<Digraph, CapacityMap,
 DefCardinalityMapTraits<T> > Create;
 };
 template <class T>
 struct DefProcessedMapTraits : public Traits {
 typedef T ProcessedMap;
 static ProcessedMap *createProcessedMap(const Digraph &) {
-	LEMON_ASSERT(false,"Uninitialized parameter.");
+LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
+return 0;
 }
 };
 /// \brief \ref named-templ-param "Named parameter" for setting
 /// ProcessedMap type
 ///
 /// \ref named-templ-param "Named parameter" for setting ProcessedMap type
 /// for the algorithm.
 template <class T>
 struct SetProcessedMap
 : public MaxCardinalitySearch<Digraph, CapacityMap,
 DefProcessedMapTraits<T> > {
 typedef MaxCardinalitySearch<Digraph, CapacityMap,
 DefProcessedMapTraits<T> > Create;
 };
 template <class H, class CR>
 struct DefHeapTraits : public Traits {
 typedef CR HeapCrossRef;
 typedef H Heap;
 static HeapCrossRef *createHeapCrossRef(const Digraph &) {
-	LEMON_ASSERT(false,"Uninitialized parameter.");
+LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
+return 0;
 }
 static Heap *createHeap(HeapCrossRef &) {
-	LEMON_ASSERT(false,"Uninitialized parameter.");
+LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
+return 0;
 }
 };
 /// \brief \ref named-templ-param "Named parameter" for setting heap
 /// and cross reference type
 ///
 /// \ref named-templ-param "Named parameter" for setting heap and cross
 /// reference type for the algorithm.
 template <class H, class CR = typename Digraph::template NodeMap<int> >
 struct SetHeap
 : public MaxCardinalitySearch<Digraph, CapacityMap,
 DefHeapTraits<H, CR> > {
 typedef MaxCardinalitySearch< Digraph, CapacityMap,
 DefHeapTraits<H, CR> > Create;
 };
 template <class H, class CR>
 struct DefStandardHeapTraits : public Traits {
 typedef CR HeapCrossRef;
 typedef H Heap;
 static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
-	return new HeapCrossRef(digraph);
+return new HeapCrossRef(digraph);
 }
 static Heap *createHeap(HeapCrossRef &crossref) {
-	return new Heap(crossref);
+return new Heap(crossref);
 }
 };
 /// \brief \ref named-templ-param "Named parameter" for setting heap and
 /// cross reference type with automatic allocation
 ///
 /// \ref named-templ-param "Named parameter" for setting heap and cross
 /// reference type. It can allocate the heap and the cross reference
 /// object if the cross reference's constructor waits for the digraph as
 /// parameter and the heap's constructor waits for the cross reference.
 template <class H, class CR = typename Digraph::template NodeMap<int> >
 struct SetStandardHeap
 : public MaxCardinalitySearch<Digraph, CapacityMap,
 DefStandardHeapTraits<H, CR> > {
 typedef MaxCardinalitySearch<Digraph, CapacityMap,
 DefStandardHeapTraits<H, CR> >
 Create;
 };
 ///@}
 protected:
 MaxCardinalitySearch() {}
 public:
 /// \brief Constructor.
 ///
 ///\param digraph the digraph the algorithm will run on.
 ///\param capacity the capacity map used by the algorithm.
 MaxCardinalitySearch(const Digraph& digraph,
-			 const CapacityMap& capacity) :
+const CapacityMap& capacity) :
 _graph(&digraph),
 _capacity(&capacity), local_capacity(false),
 _cardinality(0), local_cardinality(false),
 _processed(0), local_processed(false),
 _heap_cross_ref(0), local_heap_cross_ref(false),
 ///
 /// Sets the capacity map.
 /// \return <tt> (*this) </tt>
 MaxCardinalitySearch &capacityMap(const CapacityMap &m) {
 if (local_capacity) {
-	delete _capacity;
+delete _capacity;
-	local_capacity=false;
+local_capacity=false;
 }
 _capacity=&m;
 return *this;
 }
 /// the algorithm.
 const CapacityMap &capacityMap() const {
 return *_capacity;
 }
 /// \brief Sets the map storing the cardinalities calculated by the
 /// algorithm.
 ///
 /// Sets the map storing the cardinalities calculated by the algorithm.
 /// If you don't use this function before calling \ref run(),
 /// it will allocate one. The destuctor deallocates this
 /// automatically allocated map, of course.
 /// \return <tt> (*this) </tt>
 MaxCardinalitySearch &cardinalityMap(CardinalityMap &m) {
 if(local_cardinality) {
-	delete _cardinality;
+delete _cardinality;
-	local_cardinality=false;
+local_cardinality=false;
 }
 _cardinality = &m;
 return *this;
 }
 /// Sets the map storing the processed nodes.
 /// If you don't use this function before calling \ref run(),
 /// it will allocate one. The destuctor deallocates this
 /// automatically allocated map, of course.
 /// \return <tt> (*this) </tt>
 MaxCardinalitySearch &processedMap(ProcessedMap &m)
 {
 if(local_processed) {
-	delete _processed;
+delete _processed;
-	local_processed=false;
+local_processed=false;
 }
 _processed = &m;
 return *this;
 }
 /// it will allocate one. The destuctor deallocates this
 /// automatically allocated map, of course.
 /// \return <tt> (*this) </tt>
 MaxCardinalitySearch &heap(Heap& hp, HeapCrossRef &cr) {
 if(local_heap_cross_ref) {
-	delete _heap_cross_ref;
+delete _heap_cross_ref;
-	local_heap_cross_ref = false;
+local_heap_cross_ref = false;
 }
 _heap_cross_ref = &cr;
 if(local_heap) {
-	delete _heap;
+delete _heap;
-	local_heap = false;
+local_heap = false;
 }
 _heap = &hp;
 return *this;
 }
 typedef typename Digraph::Arc Arc;
 typedef typename Digraph::InArcIt InArcIt;
 void create_maps() {
 if(!_capacity) {
-	local_capacity = true;
+local_capacity = true;
-	_capacity = Traits::createCapacityMap(*_graph);
+_capacity = Traits::createCapacityMap(*_graph);
 }
 if(!_cardinality) {
-	local_cardinality = true;
+local_cardinality = true;
-	_cardinality = Traits::createCardinalityMap(*_graph);
+_cardinality = Traits::createCardinalityMap(*_graph);
 }
 if(!_processed) {
-	local_processed = true;
+local_processed = true;
-	_processed = Traits::createProcessedMap(*_graph);
+_processed = Traits::createProcessedMap(*_graph);
 }
 if (!_heap_cross_ref) {
-	local_heap_cross_ref = true;
+local_heap_cross_ref = true;
-	_heap_cross_ref = Traits::createHeapCrossRef(*_graph);
+_heap_cross_ref = Traits::createHeapCrossRef(*_graph);
 }
 if (!_heap) {
-	local_heap = true;
+local_heap = true;
-	_heap = Traits::createHeap(*_heap_cross_ref);
+_heap = Traits::createHeap(*_heap_cross_ref);
 }
 }
 void finalizeNodeData(Node node, Value capacity) {
 _processed->set(node, true);
 _cardinality->set(node, capacity);
 }
 /// Initializes the internal data structures, and clears the heap.
 void init() {
 create_maps();
 _heap->clear();
 for (NodeIt it(*_graph) ; it != INVALID ; ++it) {
-	_processed->set(it, false);
+_processed->set(it, false);
-	_heap_cross_ref->set(it, Heap::PRE_HEAP);
+_heap_cross_ref->set(it, Heap::PRE_HEAP);
 }
 }
 /// \brief Adds a new source node.
 ///
 /// Adds a new source node to the priority heap.
 ///
 /// It checks if the node has not yet been added to the heap.
 void addSource(Node source, Value capacity = 0) {
 if(_heap->state(source) == Heap::PRE_HEAP) {
-	_heap->push(source, capacity);
+_heap->push(source, capacity);
 }
 }
 /// \brief Processes the next node in the priority heap
 ///
 /// Processes the next node in the priority heap.
 ///
 /// \return The processed node.
 ///
 /// \warning The priority heap must not be empty!
 Node processNextNode() {
 Node node = _heap->top();
 finalizeNodeData(node, _heap->prio());
 _heap->pop();
 for (InArcIt it(*_graph, node); it != INVALID; ++it) {
-	Node source = _graph->source(it);
+Node source = _graph->source(it);
-	switch (_heap->state(source)) {
+switch (_heap->state(source)) {
-	case Heap::PRE_HEAP:
+case Heap::PRE_HEAP:
-	  _heap->push(source, (*_capacity)[it]);
+_heap->push(source, (*_capacity)[it]);
-	  break;
+break;
-	case Heap::IN_HEAP:
+case Heap::IN_HEAP:
-	  _heap->decrease(source, (*_heap)[source] + (*_capacity)[it]);
+_heap->decrease(source, (*_heap)[source] + (*_capacity)[it]);
-	  break;
+break;
-	case Heap::POST_HEAP:
+case Heap::POST_HEAP:
-	  break;
+break;
-	}
+}
 }
 return node;
 }
 /// \brief Next node to be processed.
 ///
 /// Next node to be processed.
 ///
 /// \return The next node to be processed or INVALID if the
 /// priority heap is empty.
 Node nextNode() {
 return !_heap->empty() ? _heap->top() : INVALID;
 }
 /// \brief Returns \c false if there are nodes
 /// to be processed in the priority heap
 ///
 /// Returns \c false if there are nodes
 /// to be processed in the priority heap
 bool emptyQueue() { return _heap->empty(); }
 /// \brief Returns the number of the nodes to be processed
 /// in the priority heap
 ///
 /// Returns the number of the nodes to be processed in the priority heap
 int emptySize() { return _heap->size(); }
 /// \brief Executes the algorithm.
 ///
 /// Executes the algorithm.
 ///
 ///\pre init() must be called and at least one node should be added
 /// with addSource() before using this function.
 ///
 /// This method runs the Maximum Cardinality Search algorithm from the
 /// source node(s).
 void start() {
 while ( !_heap->empty() ) processNextNode();
 }
 /// \brief Executes the algorithm until \c dest is reached.
 ///
 /// Executes the algorithm until \c dest is reached.
 ///
 /// \pre init() must be called and at least one node should be added
 /// with addSource() before using this function.
 ///
 /// This method runs the %MaxCardinalitySearch algorithm from the source
 /// nodes.
 void start(Node dest) {
 while ( !_heap->empty() && _heap->top()!=dest ) processNextNode();
 if ( !_heap->empty() ) finalizeNodeData(_heap->top(), _heap->prio());
 }
 /// \brief Executes the algorithm until a condition is met.
 ///
 /// Executes the algorithm until a condition is met.
 ///
 /// \pre init() must be called and at least one node should be added
 template <typename NodeBoolMap>
 void start(const NodeBoolMap &nm) {
 while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
 if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
 }
 /// \brief Runs the maximum cardinality search algorithm from node \c s.
 ///
 /// This method runs the %MaxCardinalitySearch algorithm from a root
 /// node \c s.
 ///
 ///\note d.run(s) is just a shortcut of the following code.
 ///\code
 ///  d.init();
 init();
 addSource(s);
 start();
 }
 /// \brief Runs the maximum cardinality search algorithm for the
 /// whole digraph.
 ///
 /// This method runs the %MaxCardinalitySearch algorithm from all
 /// unprocessed node of the digraph.
 ///
 ///\note d.run(s) is just a shortcut of the following code.
 ///\code
 ///  d.init();
 addSource(it);
 start();
 }
 }
 }
 ///@}
 /// \name Query Functions
 /// The results of the maximum cardinality search algorithm can be
 /// obtained using these functions.
 /// \n
 /// Before the use of these functions, either run() or start() must be
 /// called.
 ///@{
 /// \brief The cardinality of a node.
 ///
 /// Returns the cardinality of a node.
 /// \pre the given node should be reached but not processed
 Value currentCardinality(Node node) const { return (*_heap)[node]; }
 /// \brief Returns a reference to the NodeMap of cardinalities.
 ///
 /// Returns a reference to the NodeMap of cardinalities. \pre \ref run()
 /// must be called before using this function.
 const CardinalityMap &cardinalityMap() const { return *_cardinality;}
 /// \brief Checks if a node is reachable from the root.
 ///
 /// Returns \c true if \c v is reachable from the root.
 /// \warning The source nodes are initated as unreached.
 /// \pre \ref run() must be called before using this function.
 ///
 /// Returns \c true if \c v is processed, i.e. the shortest
 /// path to \c v has already found.
 /// \pre \ref run() must be called before using this function.
 bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; }
 ///@}
 };
 }

changeset 1270	dceba191c00d
parent 1129	9a3187204242
child 1271	fb1c7da561ce