怎样通过boost库的breadth_first_search算法查找点到点的最短路径

最新推荐文章于 2022-07-08 09:35:21 发布
最新推荐文章于 2022-07-08 09:35:21 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： Boost 文章标签： Boost 遍历 算法

From：http://stackoverflow.com/questions/8950188/is-it-possible-to-apply-breadth-first-search-algorithm-of-boost-library-to-matri/8953750#8953750

我的任务是找出矩阵中一个点到另一个点的最短路径，且只能按照上下左右移动

0 0 0 0 1 0 0 0
1 0 0 0 0 0 0 0
0 0 0 1 0 1 F 0
0 1 0 1 0 0 0 0
0 0 0 1 0 0 0 0
0 S 0 1 0 0 1 0
0 0 0 0 0 0 1 0
0 0 0 0 0 0 1 0

S - 起点

F - 终点

0 - 可以穿过的点

1 - 不能穿过的点

很明显广度优先搜索是解决该问题的最佳方法，我知道Boost库支持该算法，但是我对Boost库不是特别熟悉。

我如何使用Boost库的广度优先搜索算法解决我的问题？据我了解，Boost库的广度优先搜索算法是专门为图而设计的，我感觉把m*n的矩阵转换成一个包含m*n个点和m*(n-1) + (m-1)*n条边的图不是一个好主意

我可以直接将Boost库的广度优先搜索算法应用于矩阵（不是转换成图）吗，或者是能使用我自己定义的函数就更好了？

注：以上是对提问者的翻译


以下是对回答者的翻译：

 （首先很抱歉给的答案篇幅这么长。我使用Boost Graph Library已经有些日子了，写这些也可以很好的复习一下。全部代码在最底部）

         Boost图形库（和通常的泛型编程）的好处就在于你不需要在既定的算法中使用特定的数据结构。你上述提到的遍历矩阵的规则已经和图差不多了,你需要做的就是将这些规则归纳成可以被BGL（Boost图形库）算法使用的traits class。

         明确的说，就是我们要为你的graph定义一个特定的boost::graph_traits<T>结构。让我们假定你的矩阵是一个以行优先的int型的一维数组。但很不幸的是，只包含int[N]的graph_traits是不够的，因为它没有提供矩阵中维度的信息。所以我们按照以下形式定义你的graph：

namespace matrix
{
  typedef int cell;

  static const int FREE = 0;
  static const int WALL = 1;

  template< size_t ROWS, size_t COLS >
  struct graph
  {
    cell cells[ROWS*COLS];
  };
}

       我这里使用了一个数组来表示单元格数据，如果在外面管理这些数据的话你可以使用指针更简单一些。现在我们已经有了一个可以用于graph_traits的表示矩阵的类型了，但是首先让我们定义一些我们需要的类型和函数：

顶点类型和辅助函数：

namespace matrix
{
  typedef size_t vertex_descriptor;

  template< size_t ROWS, size_t COLS >
  size_t get_row(
    vertex_descriptor vertex,
    graph< ROWS, COLS > const & )
  {
    return vertex / COLS;
  }

  template< size_t ROWS, size_t COLS >
  size_t get_col(
    vertex_descriptor vertex,
    graph< ROWS, COLS > const & )
  {
    return vertex % COLS;
  }

  template< size_t ROWS, size_t COLS >
  vertex_descriptor make_vertex(
    size_t row,
    size_t col,
    graph< ROWS, COLS > const & )
  {
    return row * COLS + col;
  }
}


遍历顶点的类型和函数：

namespace matrix
{
  typedef const cell * vertex_iterator;

  template< size_t ROWS, size_t COLS >
  std::pair< vertex_iterator, vertex_iterator >
  vertices( graph< ROWS, COLS > const & g )
  {
    return std::make_pair( g.cells, g.cells + ROWS*COLS );
  }

  typedef size_t vertices_size_type;

  template< size_t ROWS, size_t COLS >
  vertices_size_type
  num_vertices( graph< ROWS, COLS > const & g )
  {
    return ROWS*COLS;
  }
}

边类型： 
namespace matrix
{
  typedef std::pair< vertex_descriptor, vertex_descriptor > edge_descriptor;

  bool operator==(
    edge_descriptor const & lhs,
    edge_descriptor const & rhs )
  {
    return
      lhs.first == rhs.first && lhs.second == rhs.second ||
      lhs.first == rhs.second && lhs.second == rhs.first;
  }

  bool operator!=(
    edge_descriptor const & lhs,
    edge_descriptor const & rhs )
  {
    return !(lhs == rhs);
  }
}

最后，迭代器和函数来帮助我们遍历出顶点和边存在的关联关系： 
namespace matrix
{
  template< size_t ROWS, size_t COLS >
  vertex_descriptor
  source(
    edge_descriptor const & edge,
    graph< ROWS, COLS > const & )
  {
    return edge.first;
  }

  template< size_t ROWS, size_t COLS >
  vertex_descriptor
  target(
    edge_descriptor const & edge,
    graph< ROWS, COLS > const & )
  {
    return edge.second;
  }

  typedef boost::shared_container_iterator< std::vector< edge_descriptor > > out_edge_iterator;

  template< size_t ROWS, size_t COLS >
  std::pair< out_edge_iterator, out_edge_iterator >
  out_edges(
    vertex_descriptor vertex,
    graph< ROWS, COLS > const & g )
  {
    boost::shared_ptr< std::vector< edge_descriptor > > edges( new std::vector< edge_descriptor >() );

    if( g.cells[vertex] == FREE )
    {
      size_t
        row = get_row( vertex, g ),
        col = get_col( vertex, g );

      if( row != 0 )
      {
        vertex_descriptor up = make_vertex( row - 1, col, g );

        if( g.cells[up] == FREE )
          edges->push_back( edge_descriptor( vertex, up ) );
      }

      if( row != ROWS-1 )
      {
        vertex_descriptor down = make_vertex( row + 1, col, g );

        if( g.cells[down] == FREE )
          edges->push_back( edge_descriptor( vertex, down ) );
      }

      if( col != 0 )
      {
        vertex_descriptor left = make_vertex( row, col - 1, g );

        if( g.cells[left] == FREE )
          edges->push_back( edge_descriptor( vertex, left ) );
      }

      if( col != COLS-1 )
      {
        vertex_descriptor right = make_vertex( row, col + 1, g );

        if( g.cells[right] == FREE )
          edges->push_back( edge_descriptor( vertex, right ) );
      }
    }

    return boost::make_shared_container_range( edges );
  }

  typedef size_t degree_size_type;

  template< size_t ROWS, size_t COLS >
  degree_size_type
  out_degree(
    vertex_descriptor vertex,
    graph< ROWS, COLS > const & g )
  {
    std::pair< out_edge_iterator, out_edge_iterator > edges = out_edges( vertex, g );
    return std::distance( edges.first, edges.second );
  }
}

到现在未知我们已经定义好了我们需要的boost::graph_traits结构

namespace boost
{
  template< size_t ROWS, size_t COLS >
  struct graph_traits< matrix::graph< ROWS, COLS > >
  {
    typedef matrix::vertex_descriptor vertex_descriptor;
    typedef matrix::edge_descriptor edge_descriptor;

    typedef matrix::out_edge_iterator out_edge_iterator;
    typedef matrix::vertex_iterator vertex_iterator;

    typedef boost::undirected_tag directed_category;
    typedef boost::disallow_parallel_edge_tag edge_parallel_category;
    struct traversal_category :
      virtual boost::vertex_list_graph_tag,
      virtual boost::incidence_graph_tag {};

    typedef matrix::vertices_size_type vertices_size_type;
    typedef matrix::degree_size_type degree_size_type;

    static vertex_descriptor null_vertex() { return ROWS*COLS; }
  };
}

接下来就是如何展示使用BFS算法查找最短路径：

int main()
{
  const size_t rows = 8, cols = 8;

  using namespace matrix;

  typedef graph< rows, cols > my_graph;

  my_graph g =
  {
    FREE, FREE, FREE, FREE, WALL, FREE, FREE, FREE,
    WALL, FREE, FREE, FREE, FREE, FREE, FREE, FREE,
    FREE, FREE, FREE, WALL, FREE, WALL, FREE, FREE,
    FREE, WALL, FREE, WALL, FREE, FREE, FREE, FREE,
    FREE, FREE, FREE, WALL, FREE, FREE, FREE, FREE,
    FREE, FREE, FREE, WALL, FREE, FREE, WALL, FREE,
    FREE, FREE, FREE, FREE, FREE, FREE, WALL, FREE,
    FREE, FREE, FREE, FREE, FREE, FREE, WALL, FREE,
  };

  const vertex_descriptor
    start_vertex = make_vertex( 5, 1, g ),
    finish_vertex = make_vertex( 2, 6, g );

  vertex_descriptor predecessors[rows*cols] = { 0 };

  using namespace boost;

  breadth_first_search(
    g,
    start_vertex,
    visitor( make_bfs_visitor( record_predecessors( predecessors, on_tree_edge() ) ) ).
    vertex_index_map( identity_property_map() ) );

  typedef std::list< vertex_descriptor > path;

  path p;

  for( vertex_descriptor vertex = finish_vertex; vertex != start_vertex; vertex = predecessors[vertex] )
    p.push_front( vertex );

  p.push_front( start_vertex );

  for( path::const_iterator cell = p.begin(); cell != p.end(); ++cell )
    std::cout << "[" << get_row( *cell, g ) << ", " << get_col( *cell, g ) << "]\n" ;

  return 0;
}

以下是输出的从起点到终点的最短路径：

[5, 1]
[4, 1]
[4, 2]
[3, 2]
[2, 2]
[1, 2]
[1, 3]
[1, 4]
[1, 5]
[1, 6]
[2, 6]


源码如下：

#include <boost/graph/graph_traits.hpp>
#include <boost/graph/breadth_first_search.hpp>
#include <boost/graph/visitors.hpp>
#include <boost/shared_container_iterator.hpp>
#include <boost/shared_ptr.hpp>
#include <vector>
#include <boost/iterator/counting_iterator.hpp>
#include <list>

namespace matrix
{
  typedef int cell;

  static const int FREE = 0;
  static const int WALL = 1;

  template< size_t ROWS, size_t COLS >
  struct graph
  {
    cell cells[ROWS*COLS];
  };

  typedef size_t vertex_descriptor;

  template< size_t ROWS, size_t COLS >
  size_t get_row(
    vertex_descriptor vertex,
    graph< ROWS, COLS > const & )
  {
    return vertex / COLS;
  }

  template< size_t ROWS, size_t COLS >
  size_t get_col(
    vertex_descriptor vertex,
    graph< ROWS, COLS > const & )
  {
    return vertex % COLS;
  }

  template< size_t ROWS, size_t COLS >
  vertex_descriptor make_vertex(
    size_t row,
    size_t col,
    graph< ROWS, COLS > const & )
  {
    return row * COLS + col;
  }

  typedef const cell * vertex_iterator;

  template< size_t ROWS, size_t COLS >
  std::pair< vertex_iterator, vertex_iterator >
  vertices( graph< ROWS, COLS > const & g )
  {
    return std::make_pair( g.cells, g.cells + ROWS*COLS );
  }

  typedef size_t vertices_size_type;

  template< size_t ROWS, size_t COLS >
  vertices_size_type
  num_vertices( graph< ROWS, COLS > const & g )
  {
    return ROWS*COLS;
  }
  
  typedef std::pair< vertex_descriptor, vertex_descriptor > edge_descriptor;

  bool operator==(
    edge_descriptor const & lhs,
    edge_descriptor const & rhs )
  {
    return
      lhs.first == rhs.first && lhs.second == rhs.second ||
      lhs.first == rhs.second && lhs.second == rhs.first;
  }

  bool operator!=(
    edge_descriptor const & lhs,
    edge_descriptor const & rhs )
  {
    return !(lhs == rhs);
  }

  template< size_t ROWS, size_t COLS >
  vertex_descriptor
  source(
    edge_descriptor const & edge,
    graph< ROWS, COLS > const & )
  {
    return edge.first;
  }

  template< size_t ROWS, size_t COLS >
  vertex_descriptor
  target(
    edge_descriptor const & edge,
    graph< ROWS, COLS > const & )
  {
    return edge.second;
  }

  typedef boost::shared_container_iterator< std::vector< edge_descriptor > > out_edge_iterator;

  template< size_t ROWS, size_t COLS >
  std::pair< out_edge_iterator, out_edge_iterator >
  out_edges(
    vertex_descriptor vertex,
    graph< ROWS, COLS > const & g )
  {
    boost::shared_ptr< std::vector< edge_descriptor > > edges( new std::vector< edge_descriptor >() );

    if( g.cells[vertex] == FREE )
    {
      size_t
        row = get_row( vertex, g ),
        col = get_col( vertex, g );

      if( row != 0 )
      {
        vertex_descriptor up = make_vertex( row - 1, col, g );

        if( g.cells[up] == FREE )
          edges->push_back( edge_descriptor( vertex, up ) );
      }

      if( row != ROWS-1 )
      {
        vertex_descriptor down = make_vertex( row + 1, col, g );

        if( g.cells[down] == FREE )
          edges->push_back( edge_descriptor( vertex, down ) );
      }

      if( col != 0 )
      {
        vertex_descriptor left = make_vertex( row, col - 1, g );

        if( g.cells[left] == FREE )
          edges->push_back( edge_descriptor( vertex, left ) );
      }

      if( col != COLS-1 )
      {
        vertex_descriptor right = make_vertex( row, col + 1, g );

        if( g.cells[right] == FREE )
          edges->push_back( edge_descriptor( vertex, right ) );
      }
    }

    return boost::make_shared_container_range( edges );
  }

  typedef size_t degree_size_type;

  template< size_t ROWS, size_t COLS >
  degree_size_type
  out_degree(
    vertex_descriptor vertex,
    graph< ROWS, COLS > const & g )
  {
    std::pair< out_edge_iterator, out_edge_iterator > edges = out_edges( vertex, g );
    return std::distance( edges.first, edges.second );
  }
}

namespace boost
{
  template< size_t ROWS, size_t COLS >
  struct graph_traits< matrix::graph< ROWS, COLS > >
  {
    typedef matrix::vertex_descriptor vertex_descriptor;
    typedef matrix::edge_descriptor edge_descriptor;

    typedef matrix::out_edge_iterator out_edge_iterator;
    typedef matrix::vertex_iterator vertex_iterator;

    typedef boost::undirected_tag directed_category;
    typedef boost::disallow_parallel_edge_tag edge_parallel_category;
    struct traversal_category :
      virtual boost::vertex_list_graph_tag,
      virtual boost::incidence_graph_tag {};

    typedef matrix::vertices_size_type vertices_size_type;
    typedef matrix::degree_size_type degree_size_type;

    static vertex_descriptor null_vertex() { return ROWS*COLS; }
  };
}

int main()
{
  const size_t rows = 8, cols = 8;

  using namespace matrix;

  typedef matrix::graph< rows, cols > my_graph;
  
  my_graph g =
  {
    FREE, FREE, FREE, FREE, WALL, FREE, FREE, FREE,
    WALL, FREE, FREE, FREE, FREE, FREE, FREE, FREE,
    FREE, FREE, FREE, WALL, FREE, WALL, FREE, FREE,
    FREE, WALL, FREE, WALL, FREE, FREE, FREE, FREE,
    FREE, FREE, FREE, WALL, FREE, FREE, FREE, FREE,
    FREE, FREE, FREE, WALL, FREE, FREE, WALL, FREE,
    FREE, FREE, FREE, FREE, FREE, FREE, WALL, FREE,
    FREE, FREE, FREE, FREE, FREE, FREE, WALL, FREE,
  };

  const vertex_descriptor
    start_vertex = make_vertex( 5, 1, g ),
    finish_vertex = make_vertex( 2, 6, g );

  vertex_descriptor predecessors[rows*cols] = { 0 };

  using namespace boost;

  breadth_first_search(
    g,
    start_vertex,
    visitor( make_bfs_visitor( record_predecessors( predecessors, on_tree_edge() ) ) ).
    vertex_index_map( boost::identity_property_map() ) );

  typedef std::list< vertex_descriptor > path;
  
  path p;

  for( vertex_descriptor vertex = finish_vertex; vertex != start_vertex; vertex = predecessors[vertex] )
    p.push_front( vertex );

  p.push_front( start_vertex );

  for( path::const_iterator cell = p.begin(); cell != p.end(); ++cell )
    std::cout << "[" << get_row( *cell, g ) << ", " << get_col( *cell, g ) << "]\n" ;

  return 0;
}
输出： 

    [5, 1]
    [4, 1]
    [4, 2]
    [3, 2]
    [2, 2]
    [1, 2]
    [1, 3]
    [1, 4]
    [1, 5]
    [1, 6]
    [2, 6]

yuanhubilie
关注
专栏目录
boost::graph模块使用breadth_first_search()实现GGCL算法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-04 267
boost::graph模块使用breadth_first_search实现GGCL算法的测试程序实现功能C++实现代码 实现功能 boost::graph模块使用breadth_first_search()实现GGCL算法的测试程序 C++实现代码 #include <boost/config.hpp> #include <algorithm> #include <vector> #include <utility> #include <iostrea
广度优先搜索（Breadth First Search）
qq_45566099的博客
05-13 368
广度优先搜索简称BFS，是一种以“广度”为第一关键词的算法，当碰到岔道口时，总是优先考虑从该岔道口能直接到达的所有节点，以此类推，直到所有节点都被访问位置，类似于掉入水面的石子，激起的水波纹总是以石子掉落点为圆心向周围以圆的方式扩散开来。 BFS的运行方式类似于队列，所以，基本上所有的BFS题目大多都采用队列的形式来解决，例：对于当前模拟到的任意一个元素，将其按规定条件能访问到的每一个元素按访问次序入队，接着遵循以上的规律逐个处理队列内的元素，直到队列空为止，对队列的操作遵循模板如下： #include&l
Breadth-first Search
tianye00011的博客
06-03 228
Prompt You’re given a Node class that has a name and an array of optional children nodes. When put together, nodes form an acyclic tree-like structure. Implement the breadthFirstSearch method on the Node class, which takes in an empty array, traverses the
boost 最短路径 johnson
天地蜉蝣
04-29 793
#include #include #include #include #include #include #include #include #include int main() { using namespace boost; typedef adjacency_list<vecS, vecS, undirectedS, no_property,
广度优先搜索(breadth_first search)
晨识草的博客
05-21 1421
广度优先搜索用队列(边进边出)日字形走法(象棋) 题目: InputThere are multiple test cases.The first line contains an integer T, indicating the number of test cases.Each test case consists of one line containing two squares sep
广度优先搜索（Breadth-first search）
weixin_43859149的博客
08-03 2157
广度优先搜索（Breadth-first search） 广度优先搜索简称广搜或者BFS，BFS和DFS一样是一种图算法，dijkstra算法和最小生成树prim算法也有用到BFS的思想。通俗一点讲BFS就是暴力的辐射状一样搜索每一种可能出现的情况来找到答案。 下面来我们还是先看个图 让我们从1开始，同时我们用队列来模拟（因为大部分BFS程序都是拿队列来实现的）， 选到1我们就把1从队列中拿出去...
breadth_first_search_algorithm.rar_广度搜索算法
最新发布
09-23
广度优先搜索（Breadth-First Search，简称BFS）是一种用于遍历或搜索树或图的算法。它从根节点开始，并沿着树的宽度进行探索，直到找到目标节点或者遍历完所有节点。在图中，BFS通常用于找出两个节点之间的最短路径...
BreadthFirstSearch_Tim_queue_广度优先搜索_NEW_算法导论_breadth-first-searc
10-03
广度优先搜索，BFS，breadth-first-search queue 队列，new 算法导论 ，Introduction to Algorithms是对算法导论上的广度优先搜索的实现，关键步骤都打印出了提示信息和当时的运行结果，VSCode有时候调试看不到变量...
图：广度优先搜索（Breadth_First Search）
u010721079的专栏
06-08 864
广度优先搜索（Breadth_first Search)：假设从图中的顶点v出发，在访问了v之后依次访问v的各个为曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于"后被访问的顶点的邻接点"被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到
广度优先搜索（breadth-first-search）
量子孤岛
03-21 316
from collections import deque def person_is_seller(name): return name[-1] == 'm' graph = {} graph["you"] = ["alice", "bob", "claire"] graph["bob"] = ["anuj", "peggy"] graph["alice"] = ["peggy"...
基于boost的最短路径和最小生成树
random_liu_2013
08-21 575
#pragma once #include <iostream> #include <utility> #include <vector> typedef struct { int v1,v2; int w; }EdgeEx; int shortest_path(const std::vector< EdgeEx>& ed...
广度优先搜索（breadth-first search，BFS）
冷月无声的博客
08-17 728
广度优先搜索让你能够找出两样东西之间的最短距离。 在广度优先搜索的执行过程中，搜索范围从起点开始逐渐向外延伸，即先检查一度关系，再检查二度关系。一度关系在二度关系之前加入查找名单。广度优先搜索不仅查找从A到B的路径，而只有按添加顺序查找时找到的是最短的路径。 用队列（queue）这种数据结构来实现。类似于栈，不能随机地访问队列中的元素。队列只支持两种操作：入队和出队。 队列是一种先进先出（F...
Tree-BFS(Breadth-First-Search)
Dufre
08-19 2141
BFS-Breadth First Search-广度优先搜索 广度优先搜索（Breadth First Search）又叫宽度优先搜索或层次优先搜索或横向优先搜索，从根结点开始沿着树的宽度搜索，可以利用队列实现BFS。 Ex：BFS遍历是ABCDEF 我们可以用队列来实现它，队列-先进先出（first in first out），C++有队列的模版库。 Ex： queue q; /
boost::breadth_first_search用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-04 323
boost::breadth_first_search用法的测试程序实现功能C++实现代码 实现功能 boost::breadth_first_search用法的测试程序 C++实现代码 #include <boost/concept_archetype.hpp> #include <boost/graph/breadth_first_search.hpp> #include <boost/graph/graph_archetypes.hpp> int main() {
breadth first search -广度优先搜索
m0_51711089的博客
07-08 250
广度优先搜索的核心：广度优先搜索的核心是以广度为第一关键词，碰到岔路口时，总是先依次访问从该岔路口能直接到达的所有结点； 可以理解为广度优先搜索是发散的广度优先搜索的实现---队列 广度优先搜索的模板： 例题：题目描述 给出一个mxn的矩阵，矩阵中的元素为0或1。称位置（x,y)与其上下左右四个位置(x,y+1)、(x,y-1)、（x+1,y)、(x-1,y)是相邻的。如果矩阵中有若干个1是相邻的（不必两两相邻），那么称这些1构成了一个“块”。求给定的矩阵中“块”的个数。【输入样例】 【输出样例
宽度优先遍历(Breadth-First Search, BFS)
努力学习的DS
06-14 1386
BFS，其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。目的是系统地展开并检查图中的所有节点，以找寻结果。 ...
C++ 算法篇 广度（宽度）优先搜索（BFS）
流年的博客
01-28 9405
广度优先遍历 广度优先遍历(Breadth_First_Search)，又称为广度优先搜索，简称BFS。 图的BFS类似于树的层序遍历。 广度优先遍历 如图将左边的图变形，得到右边的图，然后一层一层的遍历。 这里借助一个队列来实现一层一层的遍历。 邻接矩阵的BFS 核心代码 /** * 邻接矩阵的广度优先遍历算法 */ void BFSTraverse(MGraph G){...
Boost算法库——搜索算法（Knuth-Morris-Pratt Search）
一世豁然的专栏
10-26 703
一、概论 头文件“boyer_moore_horspool.hpp”包含用于搜索值序列的Boyer-Moore-Horspool算法的实现。 Boyer-Moore-Horspool搜索算法在1980年由Nigel Horspool发表。它是对时间交易空间的Boyer-Moore算法的改进。 内部表比Boyer-Moore使用的空间更小，而且性能较差。 Boyer-M
A*算法详解：提升无人驾驶汽车最短路径搜索效率
本篇文章聚焦于A*算法，这是一种改进版的最短路径搜索算法，尤其针对Breadth-First Search (BFS) 的不足进行优化。 BFS是一种基础的搜索算法，其核心思想是从起点出发，按层次（距离）顺序遍历所有可能的节点，直到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值