depht limited search for grapht

This performs a depth limited depth-first search on a grapht

Author: polgreen

src/util/graph.h

@@ -252,6 +252,16 @@ class grapht
   std::vector<node_indext>
   get_reachable(const std::vector<node_indext> &src, bool forwards) const;
 
+  std::vector<node_indext> depth_limited_search(
+    const node_indext &src,
+    std::size_t &limit,
+    bool forwards) const;
+
+  std::vector<node_indext> depth_limited_search(
+    const std::vector<node_indext> &src,
+    std::size_t &limit,
+    bool forwards) const;
+
   void make_chordal();
 
   // return value: number of connected subgraphs
@@ -275,6 +285,12 @@ class grapht
     std::function<void(const node_indext &)> f) const;
 
 protected:
+  std::vector<node_indext> depth_limited_search(
+    const std::vector<node_indext> &src,
+    std::size_t &limit,
+    std::vector<bool> &visited,
+    bool forwards) const;
+
   class tarjant
   {
   public:
@@ -544,6 +560,92 @@ std::vector<typename N::node_indext> grapht<N>::get_reachable(
   return result;
 }
 
+/// Run recursive depth-limited search on the graph, starting
+/// from multiple source nodes, to find the nodes reachable within n steps.
+/// This function initialises the search.
+/// \param src The node to start the search from.
+/// \param forwards true (false) if the forward (backward) reachability
+/// should be performed.
+/// \param limit  limit on steps
+template <class N>
+std::vector<typename N::node_indext> grapht<N>::depth_limited_search(
+  const node_indext &src,
+  std::size_t &limit,
+  bool forwards) const
+{
+  std::vector<node_indext> start_vector(1, src);
+  return depth_limited_search(start_vector, limit, forwards);
+}
+
+/// Run recursive depth-limited search on the graph, starting
+/// from multiple source nodes, to find the nodes reachable within n steps.
+/// This function initialises the search.
+/// \param src The nodes to start the search from.
+/// \param forwards true (false) if the forward (backward) reachability
+/// should be performed.
+/// \param limit  limit on steps
+template <class N>
+std::vector<typename N::node_indext> grapht<N>::depth_limited_search(
+  const std::vector<node_indext> &src,
+  std::size_t &limit,
+  bool forwards) const
+{
+  std::vector<bool> visited(nodes.size(), false);
+
+  for(const auto &node : src)
+    visited[node] = true;
+
+  return depth_limited_search(src, limit, visited, forwards);
+}
+
+/// Run recursive depth-limited search on the graph, starting
+// from multiple source nodes, to find the nodes reachable within n steps
+/// \param src The nodes to start the search from.
+/// \param limit  limit on steps
+/// \param visited vector of booleans indicating whether a node has been visited
+/// \param forwards true (false) if the forward (backward) reachability
+/// should be performed.
+template <class N>
+std::vector<typename N::node_indext> grapht<N>::depth_limited_search(
+  const std::vector<node_indext> &src,
+  std::size_t &limit,
+  std::vector<bool> &visited,
+  bool forwards) const
+{
+  PRECONDITION(nodes.size() < std::numeric_limits<std::size_t>::max());
+
+  if(limit <= 0)
+    return src;
+
+  std::vector<node_indext> result;
+  std::vector<node_indext> next_ring;
+
+  for(const auto &n : src)
+  {
+    result.push_back(n);
+
+    for(const auto &o : nodes[n].out)
+    {
+      if(!visited[o.first])
+      {
+        next_ring.push_back(o.first);
+        visited[o.first] = true;
+      }
+    }
+  }
+
+  if(next_ring.empty())
+    return result;
+
+  limit--;
+
+  for(const auto &succ :
+      depth_limited_search(next_ring, limit, visited, forwards))
+    result.push_back(succ);
+
+  return result;
+}
+
 template<class N>
 std::size_t grapht<N>::connected_subgraphs(
   std::vector<node_indext> &subgraph_nr)