RhodeCode

 * 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.

 *

 */

#include <lemon/dfs.h>

#include <lemon/bfs.h>

#include <lemon/core.h>

#include <lemon/maps.h>

#include <lemon/adaptors.h>

        ++compNum;

      }

    }

    return compNum;

  }

    template <typename Digraph, typename Iterator >

    struct LeaveOrderVisitor : public DfsVisitor<Digraph> {

    public:

      typedef typename Digraph::Node Node;

      LeaveOrderVisitor(Iterator it) : _it(it) {}

    private:

      Map& _map;

      Value& _value;

    };

    template <typename Digraph, typename ArcMap>

    public:

      typedef typename Digraph::Node Node;

      typedef typename Digraph::Arc Arc;

                                       ArcMap& cutMap,

                                       int& cutNum)

        : _digraph(digraph), _cutMap(cutMap), _cutNum(cutNum),

      }

        ++_num;

      }

      void reach(const Node& node) {

        _compMap.set(node, _num);

      }

    typedef typename Digraph::Node Node;

    typedef typename Digraph::NodeIt NodeIt;

    typename Digraph::Node source = NodeIt(digraph);

    if (source == INVALID) return true;

    typedef DfsVisitor<Digraph> Visitor;

    Visitor visitor;

    DfsVisit<Digraph, Visitor> dfs(digraph, visitor);

    dfs.init();

      if (!dfs.reached(it)) {

        return false;

      }

    }

    typedef ReverseDigraph<const Digraph> RDigraph;

    RDigraph rdigraph(digraph);

    typedef DfsVisitor<Digraph> RVisitor;

    RVisitor rvisitor;

    DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);

    rdfs.init();

    rdfs.addSource(source);

    rdfs.start();

      if (!rdfs.reached(it)) {

        return false;

      }

    }

    return true;

  /// \note By definition, the empty graph has zero

  /// strongly connected components.

  template <typename Digraph>

  int countStronglyConnectedComponents(const Digraph& digraph) {

    checkConcept<concepts::Digraph, Digraph>();

    typedef typename Digraph::Node Node;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::NodeIt NodeIt;

    typedef typename Digraph::ArcIt ArcIt;

  int stronglyConnectedComponents(const Digraph& digraph, NodeMap& compMap) {

    checkConcept<concepts::Digraph, Digraph>();

    typedef typename Digraph::Node Node;

    typedef typename Digraph::NodeIt NodeIt;

    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();

    typedef std::vector<Node> Container;

    typedef typename Container::iterator Iterator;

    Container nodes(countNodes(digraph));

    typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;

    checkConcept<concepts::Digraph, Digraph>();

    typedef typename Digraph::Node Node;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::NodeIt NodeIt;

    checkConcept<concepts::WriteMap<Arc, bool>, ArcMap>();

    typedef std::vector<Node> Container;

    typedef typename Container::iterator Iterator;

    Container nodes(countNodes(graph));

    typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;

    typedef ReverseDigraph<const Digraph> RDigraph;

    RDigraph rgraph(graph);

    int cutNum = 0;

    RVisitor rvisitor(rgraph, cutMap, cutNum);

    DfsVisit<RDigraph, RVisitor> rdfs(rgraph, rvisitor);

    rdfs.init();

    for (RIterator it = nodes.rbegin(); it != nodes.rend(); ++it) {

        rdfs.start();

      }

    }

    return cutNum;

  }

    template <typename Digraph>

    class CountBiNodeConnectedComponentsVisitor : public DfsVisitor<Digraph> {

    public:

      typedef typename Digraph::Node Node;

      typedef typename Digraph::Arc Arc;

  /// \return The number of components.

  template <typename Graph>

  int countBiNodeConnectedComponents(const Graph& graph) {

    checkConcept<concepts::Graph, Graph>();

    typedef typename Graph::NodeIt NodeIt;

    typedef CountBiNodeConnectedComponentsVisitor<Graph> Visitor;

    int compNum = 0;

    Visitor visitor(graph, compNum);

                                EdgeMap& compMap) {

    checkConcept<concepts::Graph, Graph>();

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::Edge Edge;

    checkConcept<concepts::WriteMap<Edge, int>, EdgeMap>();

    typedef BiNodeConnectedComponentsVisitor<Graph, EdgeMap> Visitor;

    int compNum = 0;

    Visitor visitor(graph, compMap, compNum);

  int biNodeConnectedCutNodes(const Graph& graph, NodeMap& cutMap) {

    checkConcept<concepts::Graph, Graph>();

    typedef typename Graph::Node Node;

    typedef typename Graph::NodeIt NodeIt;

    checkConcept<concepts::WriteMap<Node, bool>, NodeMap>();

    typedef BiNodeConnectedCutNodesVisitor<Graph, NodeMap> Visitor;

    int cutNum = 0;

    Visitor visitor(graph, cutMap, cutNum);

        dfs.start();

      }

    }

    return cutNum;

  }

    template <typename Digraph>

    class CountBiEdgeConnectedComponentsVisitor : public DfsVisitor<Digraph> {

    public:

      typedef typename Digraph::Node Node;

      typedef typename Digraph::Arc Arc;

  /// \return The number of components.

  template <typename Graph>

  int countBiEdgeConnectedComponents(const Graph& graph) {

    checkConcept<concepts::Graph, Graph>();

    typedef typename Graph::NodeIt NodeIt;

    typedef CountBiEdgeConnectedComponentsVisitor<Graph> Visitor;

    int compNum = 0;

    Visitor visitor(graph, compNum);

  int biEdgeConnectedComponents(const Graph& graph, NodeMap& compMap) {

    checkConcept<concepts::Graph, Graph>();

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::Node Node;

    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();

    typedef BiEdgeConnectedComponentsVisitor<Graph, NodeMap> Visitor;

    int compNum = 0;

    Visitor visitor(graph, compMap, compNum);

  int biEdgeConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) {

    checkConcept<concepts::Graph, Graph>();

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::Edge Edge;

    checkConcept<concepts::WriteMap<Edge, bool>, EdgeMap>();

    typedef BiEdgeConnectedCutEdgesVisitor<Graph, EdgeMap> Visitor;

    int cutNum = 0;

    Visitor visitor(graph, cutMap, cutNum);

      }

    }

    return cutNum;

  }

    template <typename Digraph, typename IntNodeMap>

    class TopologicalSortVisitor : public DfsVisitor<Digraph> {

    public:

      typedef typename Digraph::Node Node;

      typedef typename Digraph::Arc edge;

  /// will be set exactly once, the values  will be set descending order.

  ///

  /// \see checkedTopologicalSort

  /// \see dag

  template <typename Digraph, typename NodeMap>

  void topologicalSort(const Digraph& graph, NodeMap& order) {

    checkConcept<concepts::Digraph, Digraph>();

    checkConcept<concepts::WriteMap<typename Digraph::Node, int>, NodeMap>();

    typedef typename Digraph::Node Node;

    typedef typename Digraph::NodeIt NodeIt;

  /// order.

  /// \return %False when the graph is not DAG.

  ///

  /// \see topologicalSort

  /// \see dag

  template <typename Digraph, typename NodeMap>

    checkConcept<concepts::Digraph, Digraph>();

    checkConcept<concepts::ReadWriteMap<typename Digraph::Node, int>,

      NodeMap>();

    typedef typename Digraph::Node Node;

    typedef typename Digraph::NodeIt NodeIt;

    typedef typename Digraph::Arc Arc;

    TopologicalSortVisitor<Digraph, NodeMap>

    DfsVisit<Digraph, TopologicalSortVisitor<Digraph, NodeMap> >

    dfs.init();

      if (!dfs.reached(it)) {

        dfs.addSource(it);

        while (!dfs.emptyQueue()) {

           if (dfs.reached(target) && order[target] == -1) {

             return false;

           }

           dfs.processNextArc();

         }

      }

  ///

  /// Check that the given directed graph is a DAG. The DAG is

  /// an Directed Acyclic Digraph.

  /// \return %False when the graph is not DAG.

  /// \see acyclic

  template <typename Digraph>

    checkConcept<concepts::Digraph, Digraph>();

    typedef typename Digraph::Node Node;

    typedef typename Digraph::NodeIt NodeIt;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::template NodeMap<bool> ProcessedMap;

    typename Dfs<Digraph>::template SetProcessedMap<ProcessedMap>::

    dfs.processedMap(processed);

    dfs.init();

      if (!dfs.reached(it)) {

        dfs.addSource(it);

        while (!dfs.emptyQueue()) {

          Arc edge = dfs.nextArc();

          if (dfs.reached(target) && !processed[target]) {

            return false;

          }

          dfs.processNextArc();

        }

      }

        return false;

      }

    }

    return true;

  }

    template <typename Digraph>

    class BipartiteVisitor : public BfsVisitor<Digraph> {

    public:

      typedef typename Digraph::Arc Arc;

      typedef typename Digraph::Node Node;

  /// or not. The \ref Bfs algorithm is used to calculate the result.

  /// \param graph The undirected graph.

  /// \return %True if \c graph is bipartite, %false otherwise.

  /// \sa bipartitePartitions

  template<typename Graph>

  inline bool bipartite(const Graph &graph){

    checkConcept<concepts::Graph, Graph>();

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::ArcIt ArcIt;

  /// \param graph The undirected graph.

  /// \retval partMap A writable bool map of nodes. It will be set as the

  /// two partitions of the graph.

  /// \return %True if \c graph is bipartite, %false otherwise.

  template<typename Graph, typename NodeMap>

  inline bool bipartitePartitions(const Graph &graph, NodeMap &partMap){

    checkConcept<concepts::Graph, Graph>();

    typedef typename Graph::Node Node;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::ArcIt ArcIt;

  }

  /// \brief Returns true when there are not loop edges in the graph.

  ///

  /// Returns true when there are not loop edges in the graph.

  template <typename Digraph>

    }

    return true;

  }

  /// \brief Returns true when there are not parallel edges in the graph.

  ///

  /// Returns true when there are not parallel edges in the graph.

  template <typename Digraph>

      }

      }

    }

    return true;

  }

  /// \brief Returns true when there are not loop edges and parallel

  /// edges in the graph.

  ///

  /// Returns true when there are not loop edges and parallel edges in

  /// the graph.

  template <typename Digraph>

      reached.set(n, true);

      }

      }

      reached.set(n, false);

    }

    return true;

  }

} //namespace lemon

          Arc e;

          _digraph->firstOut(e, s);

          if (e != INVALID) {

            _stack[++_stack_head] = e;

          } else {

            _visitor->leave(s);

          }

        }

    }

    /// \brief Processes the next arc.

    ///