[Lemon-commits] Alpar Juttner: Port Suurballe algorithm from svn...
Lemon HG
hg at lemon.cs.elte.hu
Wed Oct 29 07:23:18 CET 2008
details: http://lemon.cs.elte.hu/hg/lemon/rev/2f64c4a692a8
changeset: 357:2f64c4a692a8
user: Alpar Juttner <alpar [at] cs.elte.hu>
date: Tue Oct 28 18:39:53 2008 +0000
description:
Port Suurballe algorithm from svn -r3512
diffstat:
5 files changed, 708 insertions(+), 1 deletion(-)
lemon/Makefile.am | 1
lemon/suurballe.h | 499 +++++++++++++++++++++++++++++++++++++++++++
test/Makefile.am | 5
test/min_cost_flow_test.lgf | 44 +++
test/suurballe_test.cc | 160 +++++++++++++
diffs (truncated from 753 to 300 lines):
diff -r 956a29f30887 -r 2f64c4a692a8 lemon/Makefile.am
--- a/lemon/Makefile.am Tue Oct 28 18:33:51 2008 +0100
+++ b/lemon/Makefile.am Tue Oct 28 18:39:53 2008 +0000
@@ -40,6 +40,7 @@
lemon/path.h \
lemon/random.h \
lemon/smart_graph.h \
+ lemon/suurballe.h \
lemon/time_measure.h \
lemon/tolerance.h \
lemon/unionfind.h
diff -r 956a29f30887 -r 2f64c4a692a8 lemon/suurballe.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/suurballe.h Tue Oct 28 18:39:53 2008 +0000
@@ -0,0 +1,499 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * 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
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_SUURBALLE_H
+#define LEMON_SUURBALLE_H
+
+///\ingroup shortest_path
+///\file
+///\brief An algorithm for finding arc-disjoint paths between two
+/// nodes having minimum total length.
+
+#include <vector>
+#include <lemon/bin_heap.h>
+#include <lemon/path.h>
+
+namespace lemon {
+
+ /// \addtogroup shortest_path
+ /// @{
+
+ /// \brief Implementation of an algorithm for finding arc-disjoint
+ /// paths between two nodes having minimum total length.
+ ///
+ /// \ref lemon::Suurballe "Suurballe" implements an algorithm for
+ /// finding arc-disjoint paths having minimum total length (cost)
+ /// from a given source node to a given target node in a directed
+ /// digraph.
+ ///
+ /// In fact, this implementation is the specialization of the
+ /// \ref CapacityScaling "successive shortest path" algorithm.
+ ///
+ /// \tparam Digraph The directed digraph type the algorithm runs on.
+ /// \tparam LengthMap The type of the length (cost) map.
+ ///
+ /// \warning Length values should be \e non-negative \e integers.
+ ///
+ /// \note For finding node-disjoint paths this algorithm can be used
+ /// with \ref SplitDigraphAdaptor.
+ ///
+ /// \author Attila Bernath and Peter Kovacs
+
+ template < typename Digraph,
+ typename LengthMap = typename Digraph::template ArcMap<int> >
+ class Suurballe
+ {
+ TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+
+ typedef typename LengthMap::Value Length;
+ typedef ConstMap<Arc, int> ConstArcMap;
+ typedef typename Digraph::template NodeMap<Arc> PredMap;
+
+ public:
+
+ /// The type of the flow map.
+ typedef typename Digraph::template ArcMap<int> FlowMap;
+ /// The type of the potential map.
+ typedef typename Digraph::template NodeMap<Length> PotentialMap;
+ /// The type of the path structures.
+ typedef SimplePath<Digraph> Path;
+
+ private:
+
+ /// \brief Special implementation of the \ref Dijkstra algorithm
+ /// for finding shortest paths in the residual network.
+ ///
+ /// \ref ResidualDijkstra is a special implementation of the
+ /// \ref Dijkstra algorithm for finding shortest paths in the
+ /// residual network of the digraph with respect to the reduced arc
+ /// lengths and modifying the node potentials according to the
+ /// distance of the nodes.
+ class ResidualDijkstra
+ {
+ typedef typename Digraph::template NodeMap<int> HeapCrossRef;
+ typedef BinHeap<Length, HeapCrossRef> Heap;
+
+ private:
+
+ // The directed digraph the algorithm runs on
+ const Digraph &_graph;
+
+ // The main maps
+ const FlowMap &_flow;
+ const LengthMap &_length;
+ PotentialMap &_potential;
+
+ // The distance map
+ PotentialMap _dist;
+ // The pred arc map
+ PredMap &_pred;
+ // The processed (i.e. permanently labeled) nodes
+ std::vector<Node> _proc_nodes;
+
+ Node _s;
+ Node _t;
+
+ public:
+
+ /// Constructor.
+ ResidualDijkstra( const Digraph &digraph,
+ const FlowMap &flow,
+ const LengthMap &length,
+ PotentialMap &potential,
+ PredMap &pred,
+ Node s, Node t ) :
+ _graph(digraph), _flow(flow), _length(length), _potential(potential),
+ _dist(digraph), _pred(pred), _s(s), _t(t) {}
+
+ /// \brief Runs the algorithm. Returns \c true if a path is found
+ /// from the source node to the target node.
+ bool run() {
+ HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
+ Heap heap(heap_cross_ref);
+ heap.push(_s, 0);
+ _pred[_s] = INVALID;
+ _proc_nodes.clear();
+
+ // Processing nodes
+ while (!heap.empty() && heap.top() != _t) {
+ Node u = heap.top(), v;
+ Length d = heap.prio() + _potential[u], nd;
+ _dist[u] = heap.prio();
+ heap.pop();
+ _proc_nodes.push_back(u);
+
+ // Traversing outgoing arcs
+ for (OutArcIt e(_graph, u); e != INVALID; ++e) {
+ if (_flow[e] == 0) {
+ v = _graph.target(e);
+ switch(heap.state(v)) {
+ case Heap::PRE_HEAP:
+ heap.push(v, d + _length[e] - _potential[v]);
+ _pred[v] = e;
+ break;
+ case Heap::IN_HEAP:
+ nd = d + _length[e] - _potential[v];
+ if (nd < heap[v]) {
+ heap.decrease(v, nd);
+ _pred[v] = e;
+ }
+ break;
+ case Heap::POST_HEAP:
+ break;
+ }
+ }
+ }
+
+ // Traversing incoming arcs
+ for (InArcIt e(_graph, u); e != INVALID; ++e) {
+ if (_flow[e] == 1) {
+ v = _graph.source(e);
+ switch(heap.state(v)) {
+ case Heap::PRE_HEAP:
+ heap.push(v, d - _length[e] - _potential[v]);
+ _pred[v] = e;
+ break;
+ case Heap::IN_HEAP:
+ nd = d - _length[e] - _potential[v];
+ if (nd < heap[v]) {
+ heap.decrease(v, nd);
+ _pred[v] = e;
+ }
+ break;
+ case Heap::POST_HEAP:
+ break;
+ }
+ }
+ }
+ }
+ if (heap.empty()) return false;
+
+ // Updating potentials of processed nodes
+ Length t_dist = heap.prio();
+ for (int i = 0; i < int(_proc_nodes.size()); ++i)
+ _potential[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist;
+ return true;
+ }
+
+ }; //class ResidualDijkstra
+
+ private:
+
+ // The directed digraph the algorithm runs on
+ const Digraph &_graph;
+ // The length map
+ const LengthMap &_length;
+
+ // Arc map of the current flow
+ FlowMap *_flow;
+ bool _local_flow;
+ // Node map of the current potentials
+ PotentialMap *_potential;
+ bool _local_potential;
+
+ // The source node
+ Node _source;
+ // The target node
+ Node _target;
+
+ // Container to store the found paths
+ std::vector< SimplePath<Digraph> > paths;
+ int _path_num;
+
+ // The pred arc map
+ PredMap _pred;
+ // Implementation of the Dijkstra algorithm for finding augmenting
+ // shortest paths in the residual network
+ ResidualDijkstra *_dijkstra;
+
+ public:
+
+ /// \brief Constructor.
+ ///
+ /// Constructor.
+ ///
+ /// \param digraph The directed digraph the algorithm runs on.
+ /// \param length The length (cost) values of the arcs.
+ /// \param s The source node.
+ /// \param t The target node.
+ Suurballe( const Digraph &digraph,
+ const LengthMap &length,
+ Node s, Node t ) :
+ _graph(digraph), _length(length), _flow(0), _local_flow(false),
+ _potential(0), _local_potential(false), _source(s), _target(t),
+ _pred(digraph) {}
+
+ /// Destructor.
+ ~Suurballe() {
+ if (_local_flow) delete _flow;
+ if (_local_potential) delete _potential;
+ delete _dijkstra;
+ }
+
+ /// \brief Sets the flow map.
+ ///
+ /// Sets the flow map.
+ ///
+ /// The found flow contains only 0 and 1 values. It is the union of
+ /// the found arc-disjoint paths.
+ ///
+ /// \return \c (*this)
+ Suurballe& flowMap(FlowMap &map) {
+ if (_local_flow) {
+ delete _flow;
+ _local_flow = false;
+ }
+ _flow = ↦
+ return *this;
+ }
+
+ /// \brief Sets the potential map.
+ ///
+ /// Sets the potential map.
+ ///
+ /// The potentials provide the dual solution of the underlying
+ /// minimum cost flow problem.
+ ///
+ /// \return \c (*this)
+ Suurballe& potentialMap(PotentialMap &map) {
+ if (_local_potential) {
+ delete _potential;
+ _local_potential = false;
+ }
+ _potential = ↦
+ return *this;
+ }
+
+ /// \name Execution control
+ /// The simplest way to execute the algorithm is to call the run()
+ /// function.
+ /// \n
More information about the Lemon-commits
mailing list