RhodeCode

#include <vector>

#include <limits>

#include <lemon/bin_heap.h>

#include <lemon/path.h>

#include <lemon/list_graph.h>

#include <lemon/maps.h>

namespace lemon {

  /// \addtogroup shortest_path

  /// @{

    /// The type of the path structures.

    typedef SimplePath<GR> Path;

  private:

    // ResidualDijkstra is a special implementation of the

    // Dijkstra algorithm for finding shortest paths in the

    // residual network with respect to the reduced arc lengths

    // and modifying the node potentials according to the

    // distance of the nodes.

    class ResidualDijkstra

    {

    private:

      const Digraph &_graph;

      const LengthMap &_length;

      const FlowMap &_flow;

      PotentialMap &_pi;

    // Container to store the found paths

    std::vector<Path> _paths;

    int _path_num;

    // The pred arc map

    PredMap _pred;

  public:

    /// \brief Constructor.

    ///

    /// Constructor.

    ///

    /// \param graph The digraph the algorithm runs on.

    /// \param length The length (cost) values of the arcs.

    Suurballe( const Digraph &graph,

               const LengthMap &length ) :

      _graph(graph), _length(length), _flow(0), _local_flow(false),

    {}

    /// Destructor.

    ~Suurballe() {

      if (_local_flow) delete _flow;

      if (_local_potential) delete _potential;

    }

    /// \brief Set the flow map.

    ///

    /// This function sets the flow map.

    /// If it is not used before calling \ref run() or \ref init(),

      _potential = ↦

      return *this;

    }

    /// \name Execution Control

    /// The simplest way to execute the algorithm is to call the run()

    /// If you only need the flow that is the union of the found

    /// @{

    /// \brief Run the algorithm.

    ///

    /// This function runs the algorithm.

    /// arc-disjoint paths found.

    ///

    /// \note Apart from the return value, <tt>s.run(s, t, k)</tt> is

    /// just a shortcut of the following code.

    /// \code

    ///   s.init(s);

    /// \endcode

    int run(const Node& s, const Node& t, int k = 2) {

      init(s);

      return _path_num;

    }

    /// \brief Initialize the algorithm.

    ///

    ///

    /// \param s The source node.

    void init(const Node& s) {

      _s = s;

      // Initialize maps

        _local_flow = true;

      }

      if (!_potential) {

        _potential = new PotentialMap(_graph);

        _local_potential = true;

      }

    }

    /// \brief Execute the algorithm to find an optimal flow.

    ///

    /// This function executes the successive shortest path algorithm to

    /// find a minimum cost flow, which is the union of \c k (or less)

    /// Otherwise it returns the number of arc-disjoint paths found.

    ///

    /// \pre \ref init() must be called before using this function.

    int findFlow(const Node& t, int k = 2) {

      _t = t;

      ResidualDijkstra dijkstra(*this);

      // Find shortest paths

      while (_path_num < k) {

        // Run Dijkstra

        if (!dijkstra.run(_path_num)) break;

        ++_path_num;

        // Set the flow along the found shortest path

    .potentialMap(pi);

  int k;

  k = suurb_test.run(n, n);

  k = suurb_test.run(n, n, k);

  suurb_test.init(n);

  k = suurb_test.findFlow(n);

  k = suurb_test.findFlow(n, k);

  suurb_test.findPaths();

  int f;

  VType c;