RhodeCode

	lemon/error.h \

	lemon/euler.h \

	lemon/full_graph.h \

	lemon/glpk.h \

	lemon/graph_to_eps.h \

	lemon/grid_graph.h \

	lemon/hypercube_graph.h \

	lemon/kruskal.h \

  /// it is typename GR::template EdgeMap<int> by default.

  template <typename GR,

	    typename CAP = typename GR::template EdgeMap<int>

            >

  public:

    /// The graph type

    typedef GR Graph;

    ///

    /// Constructor

    /// \param graph The graph the algorithm will run on.

    /// \param capacity The capacity map.

      : _graph(graph), _capacity(capacity),

	_pred(0), _weight(0), _order(0) 

    {

      checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();

    /// \brief Destructor

    ///

    /// Destructor

      destroyStructures();

    }

    // \brief Initialize the internal data structures.

    /// Iterate on the nodes of a minimum cut

    /// This iterator class lists the nodes of a minimum cut found by

    ///

    /// This example counts the nodes in the minimum cut separating \c s from

    /// \c t.

    /// \code

    /// gom.run();

    /// int sum=0;

    /// \endcode

    class MinCutNodeIt

    {

      bool _side;

      /// Constructor

      /// Constructor

      ///

                   ///  run() method

                   ///  before initializing this iterator

                   const Node& s, ///< Base node

                   const Node& t,

    /// Iterate on the edges of a minimum cut

    /// This iterator class lists the edges of a minimum cut found by

    ///

    /// This example computes the value of the minimum cut separating \c s from

    /// \c t.

    /// \code

    /// gom.run();

    /// int value=0;

    ///   value+=capacities[e];

    /// \endcode

    /// the result will be the same as it is returned by

    class MinCutEdgeIt

    {

      bool _side;

      const Graph &_graph;

          }

      }

    public:

                   ///  run() method

                   ///  before initializing this iterator

                   const Node& s,  ///< Base node

                   const Node& t,

#include "test_tools.h"

#include <lemon/smart_graph.h>

#include <lemon/lgf_reader.h>

#include <cstdlib>

using namespace std;

using namespace lemon;

  std::istringstream input(test_lgf);

  GraphReader<Graph>(graph, input).

    edgeMap("capacity", capacity).run();

  ght.init();

  ght.run();

  for (NodeIt u(graph); u != INVALID; ++u) {

      check(cm[u] != cm[v], "Wrong cut 3");

      check(pf.flowValue() == cutValue(graph, cm, capacity), "Wrong cut 2");

      int sum=0;

        sum+=capacity[a]; 

      check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");

      sum=0;

        sum++;

        sum++;

      check(sum == countNodes(graph), "Problem with MinCutNodeIt");

    }