比特派app下载2023版本|dfsdfs

作者：比特派app下载2023版本

2024-03-07 18:11:46

DFS(小白式超详细讲解以及代码讲解)_dfs()这个代码怎么解释-CSDN博客

DFS(小白式超详细讲解以及代码讲解)

最新推荐文章于 2024-01-01 09:47:55 发布

ypw44

最新推荐文章于 2024-01-01 09:47:55 发布

阅读量1.9w

230

点赞数

分类专栏：

课外学习

本文链接：https://blog.csdn.net/qq_45585519/article/details/103299544

版权

课外学习

专栏收录该内容

115 篇文章

0 订阅

订阅专栏

图的遍历算法是求解图的连通性，拓扑排序和关键路径等算法的基础。

根剧搜索路径的方向，通常有两条遍历图的路径：深度优先搜索（DFS）和广度优先搜索（BFS）。对于有向图和无向图都适用。

DFS DFS类似于树的先序遍历，是树的先序遍历的推广。那么对于一个联通图来说，深度搜索遍历的过程如下： 1.从图中某个顶点v出发，访问v; 2.找出刚访问过得顶点的第一个未被访问的邻接点，访问该顶点。以该顶点为新顶点，重复此步骤，直至访问过的顶点没有未被访问的邻接点为止。 3.返回前一个访问过的且乃有未被访问的邻接点的顶点，找出下一个未被访问的邻接点，访问该顶点。 4.重复（2）（3），直至所以的顶点都被访问过，搜索结束。深度优先搜索遍历连通图 1）从图中某个顶点出发，访问v，并置visited[v]的值为true. 2) 依次检查v的所有的邻接点w，如果visited[w]的值为false,再从w出发进行递归遍历，直至图中所有的顶点都被访问过。

代码实现如下：

bool visited[maxn];//访问标志数组，初值为false;

void DFS(Graph G,int v){//从顶点v出发递归的深度优先遍历图G

cout<

visited[v] = true;

for(顶点v的第一个邻接顶点w;w >= 0;下一个邻接点)

if(!visited[w]) DFS(G,w);//对v尚未访问的邻接点w递归调用DFS;

}

那么对于非连通图的遍历，我们可以看做是一个个连通分量，循环调用多少次，那么就有多少个连通分量。用深度优先遍历非连通图

void DFS(Graph G){//对非连通图G做深度优先遍历

for(v = 0;v < G.num;++v) visited[v] = false;

for(v = 0;v < G.num; ++v)//循环调用连通图遍历

if(!visited[v]) DFS(G,v);// 对未访问的顶点调用DFS；

}

我们知道，在调用DFS之前，我们需要选择合适的存储方式把我们的图存起来。

常见的存图方式有如下：

采用邻接矩阵表示图的深度优先搜索遍历

void DFS(Graph G,int v){//图G为邻接矩阵类型，从第v个顶点出发深度优先搜索遍历图G

cout<

visited[v] = 1;

for(w = 0 ;w < G.num;w++)//依次检查邻接矩阵v所在的行

if((G.arcs[v][w] != 0)&&(!visted[w]))//G.arcs[v][w]表示w是v的邻接点，如果w未被访问，则递归调用DFS

DFS(G,w);

}

采用邻接表表示的图深度优先搜索遍历

void DFS(Graph G,int v){

cout<

visited[v] = 1;

p = G.vertices[v].firstarc;//p指向v的边链表的第一个节点

while(p != NULL){//边链表非空

w = p -> adjvex;//如果w是v的邻接点

if(!visited[w]) DFS(G,w);//如果w未访问，则递归调用DFS；

p = p -> nextarc;//指向下一个边结点

}

好了，最基础的理论知识我们已经了解完了，接下来我们要跟深一步了解这个算法，并写代码做题了

DFS算法思想：一直往深处走，直到找到解或者走不下去为止；

一般DFS使用栈保存未被检测的结点，结点深度优先的次序被访问并被依次压入栈中，并以相反的次序出栈进行新的检测。

深搜解决栗子：走迷宫。不撞南墙不回头！

下面是我做题的一个基础模板！

#include

using namespace std;

const int maxn = 100;

bool vis[maxn][maxn];//访问标记

int mapp[maxn][maxn];//坐标范围

bool check(int x,int y){//边界条件和约束条件的判断

if(!vis[x][y] && ...)//满足条件

return 1;

else

return 0;

}

void DFS(int x,int y){

vis[x][y] = 1;//标记该节点被访问

if(mapp[x][y] == G){//出现目标态G

...//做相应处理

return ;

}

for(int i=0;i<4;i++){

if(check(x + dir[i][0],y+dir[i][1]))//按照规矩生成下一个节点

DFS(x + dir[i][0],y+dir[i][1]);

}

return ;//没有下层搜索节点，回溯

}

int main(){

.....

return 0;

}

DFS实现全排列

思路：我们可以这样来想： 1.首先我们考虑1号盒子，我们约定每到一个盒子面前都按数字递增的顺序摆放扑克牌。于是把1号扑克牌放到1号盒子中。 2.接着考虑2号盒子，现在我们手里剩下2号和3号扑克牌，于是我们可以把2号扑克牌放入2号盒子中。于是在3号盒子只剩一种可能性，我们继续把3号扑克放入3号盒子。此时产生了一种排列——{1,2,3}。 3.接着我们收回3号盒子中的3号扑克牌，尝试一种新的可能，此时发现别无他选。于是选择回到2号盒子收回2号扑克。 4.在2号盒子中我们放入3号扑克，于是自然而然的在3号盒子中只能放入2号扑克。此时产生另一种排列——{1,3,2}； 5.重复以上步骤就能得到数字{123}的全排列。

#include

using namespace std;

int a[101],b[101],n;

void print()

{

int i;

for(i=1;i<=n;i++)

{

cout<

}

cout<

}

inline void dfs(int i)

{

int j;

if(i==n+1)

{

print();

return;

}

for(j=1;j<=n;j++)

{

if(b[j]==0)

{

a[i]=j;

b[j]=1;

dfs(i+1);

b[j]=0;

}

int main()

{

ios::sync_with_stdio(false);

cin>>n;

dfs(1);

return 0;

}

我简单的写了一下运行过程，大家可以自己调试着这段程序理解一下！

优惠劵

ypw44

关注

踩

230

觉得还不错?

一键收藏

知道了

DFS(小白式超详细讲解以及代码讲解)

图的遍历算法是求解图的连通性，拓扑排序和关键路径等算法的基础。根剧搜索路径的方向，通常有两条遍历图的路径：深度优先搜索（DFS）和广度优先搜索（BFS）。对于有向图和无向图都适用。DFSDFS类似于树的先序遍历，是树的先序遍历的推广。那么对于一个联通图来说，深度搜索遍历的过程如下：1.从图中某个顶点v出发，访问v;2.找出刚访问过得顶点的第一个未被访问的邻接点，访问该顶点。以该顶点...

复制链接

扫一扫

专栏目录

DFS及BFS的算法讲解含例题.ppt

09-15

DFS及BFS的算法讲解含例题.ppt

二叉树遍历BFS与DFS详细代码python版

01-18

二叉树遍历BFS与DFS详细代码python版

3 条评论

您还未登录，请先

后发表或查看评论

dfs算法的详解（代码版）

alongwaywith的博客

03-01

2673

这个算法比起bfs，他多了return的部分。多了回溯的功能。旨在解决多种路径的问题。

（主要要能先能走，才能在去周围搜）

解决的话，读入地图是和之前一样的，比较困难的部分是是搜索。

void dfs(int x ,int y)//判断合法和出界

{

if(x<0||x>=n||y<0||y>=m||vis[x][y]||mp[x][y]=='.')//先能走，才能搜索

return ;

vis[x][y]=true;//把这个点标记为已经

cnt++;

C#，深度优先搜索（DFS）、广度优先搜索（BFS）算法的源代码与数据可视化

深度混淆

01-01

3979

深度优先搜索算法DFS,广度优先搜索算法BFS是很基础的算法，也是大家很熟悉的。

一、深度优先搜索算法DFS,广度优先搜索算法BFS的基本概念

广度优先搜索算法类似于二叉树的层序遍历，是一种分层的查找过程，每向前一步可能访问一批顶点，没有回退的情况，因此不是一个递归的算法。首先访问起始顶点v，接着由v出发，依存访问v的各个未访问过的邻接顶点w1，w2，…，wi，然后依次访问w1，w2，…，wi的所有未被访问过的.

FastDFS详解（一）——简介

u011230736的专栏

11-06

1万+

在使用fdfs之前，需要对其有一定的了解，这篇文章作为准备篇，将针对fdfs的简介，功能性，使用场景等方面进行介绍

（一）起源

淘宝网开放平台技术部资深架构师余庆先生首先回顾了自己在Yahoo工作时的经历，他表示Yahoo当时的相册和论坛系统整个结构都进行了针对大规模分布式存储和并发操作的改进。余庆从整个分布式文件系统的发展说起，谈到了FastDFS文件系统的概念和具体优缺点。

深度优先(DFS)、广度优先(BFS)、一致代价(UCS)搜索算法的实现（附代码）

DFS算法介绍 - 知乎

DFS算法介绍 - 知乎切换模式写文章登录/注册DFS算法介绍电线不加ele基础搜索算法之DFSDFS介绍DFS(Deep First Search)“深度优先搜索”和BFS(Breath First Search)“广度优先搜索”一并为搜索算法中的基础算法。DFS可描述为：用于遍历或搜索树或图的算法，它会尽可能深地搜索树或图的分支，直到找到目标或者回溯到没有未探索的边为止。我们通常会将DFS与递归绑定，因为递归的核心思想与DFS的思想是一致的，用递归来实现更容易理解和书写。例子描述举个例子：Anne Happy中萩生响是个天生顶级路痴，为了能到达学校。好胜的她想到了个办法：走过一段距离就用粉笔个画一个标记，然后按照一定规律——对岔路口按照的优先级的选择为下 > 右 > 上 > 下选择方向，并用粉笔纪录方向，如果走到了死胡同，那就倒回上一个岔路口，走没有被粉笔标记的路，就这样一直走下去，终会有一条路能走向学校。下面我们来构建一个简单的城市地图来模拟响的思路。这是一份简单的地图，红字体的响字代表响的位置，而#则代表建筑物，无法通行。S则代表她的目的地——学校。响第一步就遇见了岔路口，她对路口的优先级的选择为：下 > 右 > 上 > 下。因此，她将一路下行。然而一路下行下来她却发现了问题，她走到了死胡同，因此她要倒回到最后遇到的岔路口。然后根据优先级，下已经走过了，接下来往右走。最后，她走到了小镇的边上，不能再往前了，再次按照优先级，她要往下走，然后惊奇地发现自己到达了学校。这就是通过DFS来寻路，让顶级路痴萩生响也能找到去往学校的路，是不是十分神奇。下面就来看看DFS思想在计算机中的实现。DFS模板（C++）：char graph[Max][Max];

int used[Max][Max]; //标记已经走过的路

int px[] = {-1, 0, 1, 0};

int py[] = {0, -1, 0, 1};

void DFS(int x, int y)

{

if(x==goal_x&&y==goal_y)

{

return;

}

// 遍历四个方向

for (int i = 0; i != 4; ++i)

{

// 更新方向

int new_x = x + px[i], new_y = y + py[i];

// 检验方向

if(new_x > 0 && new_x <= n && new_y > 0 && new_y <= m && used[new_x][new_y] == 0 && !flag&&graph[new_x][new_y]!='#')

{

used[new_x][new_y] = 1; // 将该格子设为走过

DFS(new_x, new_y); // 使用递归寻找路径

}

从模板中我们可以观察到，每次前往新方向是使用递归实现的。同时还使用到另一个表used[Max][Max]来标记已经走过的路，这种方法叫去重。那么下面就用一个小题目来熟悉一下DFS的代码实现吧。题目描述萩生响又一次迷了路。小镇的布局可以视为一个 n\times m 矩阵，每个位置要么是可通过的路，要么是建筑。响能在道路上上下左右移动。现在响的初始位置为 (1, 1) ，请帮响找到一条通往学校 (x, y) 的路径。输入格式第一行，两个正整数 n,m 。第二行，两个正整数 x,y 。接下来 n 行，输入小镇的布局。每行输入一个长为 m 的字符串，# 表示建筑，. 表示空地。输出格式仅一行，使用↑ ↓ ← →组合，输出一条响能到达学校的路径。样例样例输入3 5

4 2

.##.#

.#...

...#.样例输出↓ ↓ → → ↑ →例题代码（C++）#include

using namespace std;

const int Max = 110;

char graph[Max][Max];

int used[Max][Max]; //标记已经走过的路

int n, m, goal_x, goal_y;

int px[] = {0, 1, 0, -1};

int py[] = {1, 0, -1, 0};

vector ans_dir;

void DFS(int x, int y, vector dir)

{

if (x == goal_x && y == goal_y) // 到达终点的条件

{

ans_dir = dir;

return;

}

// 遍历四个方向

for (int i = 0; i < 4; i++)

{

// 更新方向

int new_x = x + px[i], new_y = y + py[i];

vector new_dir;

new_dir = dir;

if (i == 0) // 将路径载入容器

new_dir.push_back("↓");

if (i == 1)

new_dir.push_back("→");

if (i == 2)

new_dir.push_back("↑");

if (i == 3)

new_dir.push_back("←");

// 检验新方向是否可走

if (new_x > 0 && new_x <= m && new_y > 0 && new_y <= n && used[new_x][new_y] == 0 && graph[new_x][new_y] != '#')

{

used[new_x][new_y] = 1; // 将该格子设为走过

DFS(new_x, new_y, new_dir); // 递归下去

}

int main()

{

cin >> n >> m;

cin>>goal_x;

cin>>goal_y;

// 构造地图，注意哪个下表代表是x，哪个下表代表的是y

for (int i = 1; i <= n; i++)

{

for (int j = 1; j <= m; j++)

cin >> graph[j][i];

}

vector dir; // 使用vector容器来存储答案路径

DFS(1, 1, dir);

for (int i = 0; i < ans_dir.size(); i++) // 输出结果

{

cout << ans_dir[i] << " ";

}

cout << endl;

return 0;

}

编辑于 2023-09-23 22:04・IP 属地湖北算法赞同 51 条评论分享喜欢收藏申请

DFS和BFS的算法实现(java) - 知乎

DFS和BFS的算法实现(java) - 知乎首发于橙子的算法学习之路（java版）切换模式写文章登录/注册DFS和BFS的算法实现(java)Orans以下图为例，解释部分参考DFSDFS（深度优先遍历）深度优先搜索是从起始顶点开始，递归访问其所有邻近节点，比如A节点是其第一个邻近节点，而C节点又是A的一个邻近节点，则DFS访问A节点后再访问C节点，如果C节点有未访问的邻近节点的话将继续访问其邻近节点，否则继续访问A的未访问邻近节点，当所有从A节点出去的路径都访问完之后，继续递归访问除A以外未被访问的邻近节点。所以上面我们的示意图的遍历顺序会是A->C->B->D->E->F。代码实现递归代码/**

用一个矩阵matrix表示一张图,相连的节点在矩阵表示为1

矩阵：int[][] matrix

visited数组表示是否访问过，true表示访问

numNode 表示一共多少个节点，numNode == matrix.length

**/

public void dfs(int[][] matrix, boolean[] visited, int numNode， int i){

for(int j=0; j

if(matrix[i][j] == 1 && !visited[j]){ //如果和i节点相连且未被访问过，访问它

visited[j] = true; //标记为访问过

dfs(matrix, visited, numNode, j)；

}

非递归代码public void dfs(int[][] matrix, boolean[] visited, int numNode， int i){

Stack stack = new Stack<>();

stack.push(i); //第一个节点入栈

while(!stack.isEmpty()){

int v = stack.pop(); //节点出栈查找相连节点

for(int j=0; j

if(matrix[v][j] == 1 && !visited[j]){ //如果和i节点相连且未被访问过，访问它

visited[j] == true; //标记为访问过

stack.push(j)

}

}主函数public void dfsMain(int[][] matrix){

int numNode = matrix.length;

boolean[] visited = new boolean[numNode];

for(int i=0; i

if(!visited[i]){

dfs(matrix, visited, numNode, i);

}

}BFSBFS（广度优先遍历）其主要思想是从起始点开始，将其邻近的所有顶点都加到一个队列（FIFO）中去，然后标记下这些顶点离起始顶点的距离为1.最后将起始顶点标记为已访问，今后就不会再访问。然后再从队列中取出最先进队的顶点A，也取出其周边邻近节点，加入队列末尾，将这些顶点的距离相对A再加1，最后离开这个顶点A。依次下去，直到队列为空为止。从上面描述的过程我们知道每个顶点被访问的次数最多一次（已访问的节点不会再访问），而对于连通图来说，每个顶点都会被访问。加上每个顶点的邻接链表都会被遍历，因此BFS的时间复杂度是Θ（V+E），其中V是顶点个数，E是边数，也就是所有邻接表中的元素个数。所以我们上图的遍历顺序将会为：A->C->D->B->E->F代码实现// 使用队列

public void dfsMain(int[][] matrix){

int numNode = matrix.length;

boolean[] visited = new boolean[numNode];

Queue queue = new LinkedList<>();

for(int i=0; i

if(!visited[i]){ //将没访问过的节点入队

queue.offer(i);

while(!queue.isEmpty()){

v = queue.poll(); //出队判断其是否有未访问过的连接节点，有的话入队标记为以访问

for(int j=0; j

if(matrix[v][j] == 1 && !visited[j]){

visited[j] = true;

queue.offer[j]

}

}编辑于 2022-02-28 14:38Java广度优先搜索赞同 4添加评论分享喜欢收藏申请转载文章被以下专栏收录橙子的算法学习之路（jav

关于DFS和BFS算法——Python的代码实现和讲解。_dfs算法python代码-CSDN博客

关于DFS和BFS算法——Python的代码实现和讲解。

置顶

Kinght_123

已于 2022-04-11 19:04:42 修改

阅读量7.4k

点赞数

分类专栏：

# 算法

# 数据结构

文章标签：

队列

python

dfs

数据结构

于 2021-01-13 10:23:55 首次发布

本文链接：https://blog.csdn.net/Kinght_123/article/details/112553755

版权

数据结构

同时被 2 个专栏收录

20 篇文章

2 订阅

订阅专栏

算法

15 篇文章

2 订阅

订阅专栏

1.什么是DFS和BFS？1.1DFS1.2BFS

2.DFS和BFS的代码实现2.1DFS的代码实现2.2BFS的代码实现

1.什么是DFS和BFS？

1.1DFS

DFS，通俗来讲，就是深度优先搜索，它可以通过栈来实现。举个例子：图中的例子以A为出发点。那么DFS的其中一个结果就是ABDFEC。

简单点概括就是一条路走到黑，如果无路可走了，就会有一个回溯的过程，直到所有的节点都已经走过了。

1.2BFS

BFS，通俗来讲，就是广度优先搜索，它可以通过队列来实现。也是上面的图片的例子： BFS的其中一个结果就是：ABCDEF，概括来说，就是把每个的相关点都依次的写出来。

2.DFS和BFS的代码实现

2.1DFS的代码实现

graph = {

'A':['B','C'],

'B':['A','C','D'],

'C':['A','B','D','E'],

'D':['B','C','E','F'],

'E':['C','D'],

'F':['D'],

}

def DFS(graph,s): #graph表示图表关系，s表示开始的节点

stack = [] #新建栈

stack.append(s) #将初始节点加入到栈中

seen = set() #建立一个集合，后续判断是否重复

seen.add(s)

while (len(stack) > 0):

vertex = stack.pop() #移出栈的最后一个元素

nodes = graph[vertex] #找到那个元素的相关节点并保存起来

for w in nodes:

if w not in seen: #如果节点不重复，就添加到栈中

stack.append(w)

seen.add(w)

print(vertex)

DFS(graph,'A')

2.2BFS的代码实现

graph = {

'A':['B','C'],

'B':['A','C','D'],

'C':['A','B','D','E'],

'D':['B','C','E','F'],

'E':['C','D'],

'F':['D'],

}

def BFS(graph,s): #graph表示图表关系，s表示开始的节点

queue = [] #新建队列

queue.append(s) #将初始节点加入到队列中

seen = set() #建立一个集合，后续判断是否重复

seen.add(s)

while (len(queue) > 0):

vertex = queue.pop(0) #移出队列的第一个元素

nodes = graph[vertex] #找到那个元素的相关节点并保存起来

for w in nodes:

if w not in seen: #如果节点不重复，就添加到队列中

queue.append(w)

seen.add(w)

print(vertex)

BFS(graph,'A')

关注博主即可阅读全文

优惠劵

Kinght_123

关注

踩

觉得还不错?

一键收藏

打赏

知道了

关于DFS和BFS算法——Python的代码实现和讲解。

1.什么是DFS和BFS？DFSDFS，通俗来讲，就是深度优先搜索，它可以通过栈来实现。举个例子：图中的例子以A为出发点。那么DFS的其中一个结果就是ABDFEC。简单点概括就是一条路走到黑，如果无路可走了，就会有一个回溯的过程，直到所有的节点都已经走过了。BFSBFS，通俗来讲，就是广度优先搜索，它可以通过队列来实现。也是上面的图片的例子：BFS的其中一个结果就是：ABCDEF，概括来说，就是把每个的相关点都依次的写出来。2.DFS和BFS的代码实现DFS的代码实现

复制链接

扫一扫

专栏目录

BFS, DFS, Dijkstra, Greedy Best First Search, A*五种路径规划算法Python实现

03-07

1.直接运行main_csdn.py检查路径

2.算法的具体实现在BasicAlgorithm.py文件中，里面涵盖了BFS、DFS、Dijkstra、Greedy Best First Search、A*五种静态场景的路径规划算法，算法应用于二维的栅格场景

3.几种算法的基本关系：

（BFS、DFS）广度和深度优先搜索，最基本的暴力求解算法

（Dijkstra）在BFS的基础之上添加了低成本优先的贪心策略（估价函数）

（Greedy Best First Search）在BFS的基础之上添加了启发式

（A*）结合了估价函数和启发式

以上是我个人的理解以及代码实现，具体原理可参考站内其他资源~

Python BFS和DFS算法

qq_43540763的博客

03-23

7588

Python BFS和DFS算法

看了b站灯神的视频，整理如下。最后再加上几条实战题。

1.BFS

bfs全称是广度优先搜索，任选一个点作为起始点，然后选择和其直接相连的（按顺序展开）走下去。主要用队列实现，直接上图。两个搜索算法都只需要把图全都遍历下来就好。

具体实现时：用字典来表示图；队列直接用python里的列表就好

python代码：

graph={

"A":["B","C"],

"B":["A","C","D"],

"C":["A","B","D","E"],

8 条评论

您还未登录，请先

后发表或查看评论

python实现BFS（广度优先搜索）& DFS（深度优先搜索）

Huangkaihong的博客

05-15

7934

BFS（广度优先搜索）：

图1 BFS

图2 BFS

图3 Queue of BFS

图一是BFS（广度优先搜索）在树的情况下的执行过程，从A出发，搜索A的第二层，发现有B，C，D（必须从左到右搜索），再搜索B的第二层，发现B的第二层没有元素，再搜索C的第二层，发现有E，F，放置于D后面，再搜索D的第二层，发现有G，放置于F后面，再往下搜索E，F，G，发现只有G有第二层H和I，所以最后得到：

A B C D E F G H I

图二是BF..

C#，深度优先搜索（DFS）、广度优先搜索（BFS）算法的源代码与数据可视化

深度混淆

01-01

3979

深度优先搜索算法DFS,广度优先搜索算法BFS是很基础的算法，也是大家很熟悉的。

一、深度优先搜索算法DFS,广度优先搜索算法BFS的基本概念

基于python实现的经典算法题解源码（含二分，贪心，DP，回溯，暴力，DFS,BFS，并查集等）+代码注释.zip

09-06

【资源说明】

基于python实现的经典算法题解源码（含二分，贪心，DP，回溯，暴力，DFS,BFS，并查集等）+代码注释.zip

【备注】

1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！

2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。

3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可直接用于毕设、课设、作业等。

欢迎下载，沟通交流，互相学习，共同进步！

python 随机生成迷宫并使用DFS和BFS来找到迷宫路径

07-29

使用python 随机生成迷宫，带有界面。界面还有按钮，能够采用DFS和BFS算法来找到从起点到终点的路径，生成的迷宫没有一条路径能够到达起点和终点，会做提示。

界面采用PySimpleGUI实现，总共200多行代码，需要可以下载哈

基于python的DFS算法设计与实现

05-28

基于python的DFS算法设计与实现

算法第六期——DFS初入门(深度优先搜索)(Python)

荷叶田田的博客

12-30

4867

深度优先搜索算法（ DFS ）是一种用于遍历或搜索树或图的算法。这个算法会尽可能深的搜索树的分支。. 当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。.如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。这种算法不会根据图的结构等信息调整执行策略

基于python实现深度优先遍历搜索(DFS)

01-18

7754

基于python实现深度优先遍历搜索(DFS)

Python算法：深度优先搜索—DFS（模板及其样例）

qq_65144447的博客

02-08

4943

【介绍】•沿着一条路径一直搜索下去，在无法搜索时，回退到刚刚访问过的节点。•并且每个节点只能访问一次。•本质上是持续搜索，遍历了所有可能的情况，必然能得到解。•流程是一个树的形式，每次一条路走到黑。•目的主要是达到被搜索结构的叶结点直到最后一层，然后回退到上层，被访问过的节点会被标记，然后查看是否有其他节点，如果有则继续下一层，直到最后一层。一次类推直到所有节点都被查找。【思想】后访问的节点，其邻接点先被访问。根据深度优先遍历的定义，后来的先搜索（栈、递归）。【步骤】

DFS算法（python）

DFS（环球免税店）_百度百科

环球免税店）_百度百科网页新闻贴吧知道网盘图片视频地图文库资讯采购百科百度首页登录注册进入词条全站搜索帮助首页秒懂百科特色百科知识专题加入百科百科团队权威合作下载百科APP个人中心DFS是一个多义词，请在下列义项上选择浏览（共8个义项）展开添加义项DFS播报讨论上传视频环球免税店收藏查看我的收藏0有用+10DFS是一个奢侈品旅游零售商。自1960年于香港成立，其免税店网络已包括18个主要国际机场及14个市区T广场店铺，同时其附属及度假村据点亦遍布全球。集团为私营企业并由奢侈品企业集团酩悦·轩尼诗─路易威登（LVMH）及DFS创始人兼股东罗伯特·米勒（Robert Miller）持有大部分股权。至2012年为止，已有超过2亿旅行者曾造访DFS店铺。DFS集团聘用超过9千名员工，其总部位于香港，并于夏威夷、洛杉矶、上海、新加坡及东京设有分公司。 [1]公司名称Duty Free Shop（DFS）成立时间1960年11月7日总部地点香港 [2]经营范围奢侈品零售商公司类型国际性公司员工数9000多员工目录1历史沿革2分店网络历史沿革播报编辑DFS(4张)1960年，美国人查尔斯·菲尼（Charles Feeney）和罗伯特·米勒（Robert Miller）在香港创办了Tourists International，也就是Duty Free Shoppers（DFS）免税店。当时，免税购物还处于起步阶段。随着二次世界大战后国际航空旅游业取得极大的发展，两位企业家预示到军务人员的消费力将进一步提高，同时，来自亚洲的环球旅行者也会越来越多。 [1]在随后的几十年里，DFS以海外旅行风潮正热的亚洲旅客为投资客群，先后在各大机场开设店铺及市区店，让旅行者能用更悠闲的步伐享受购物乐趣，并在出发前轻松获得所购买的商品。1996年，轩尼诗─路易威登（LVMH收购了查尔斯·菲尼手上大部分的DFS集团股份，收购了查尔斯·菲尼并提出一个结合旅行及奢侈品元素的全新重点方案。DFS发展出一套围绕五大核心支柱——美妆及香水、腕表及珠宝、时装及配饰、酒类及烟草和美食及礼品——的采购策略，配搭一个全新的品牌口号：“旅行者的奢侈精品店”。它还始创出名为“大师系列”的年度活动，以周年大典的形式展示横跨其不同品类最高级优秀的精品。来自各个领导品牌的代表、顶级顾客、媒体和业界分析家们皆在这个奢华的盛会中共聚一堂。2013年，DFS重塑其市区店的形象为“T广场”并转移对机场店实施本地化策略，通过与当地供应商合作以增加其“目的地商品”组合。它亦活跃于国际机场的界别，加强了航空业和其利益相关者以至与政府和国际组织的合作关系。 [3]邵峰立是DFS集团的主席暨行政总裁，也是轩尼诗─路易威登（LVMH）董事会成员之一。他在2011年加入DFS成为采购及市场推广部总裁，并于2012年获委任现职。 [4]2014年，DFS销售额达到37.5亿欧元，位于全球大型免税店销售额排行的第二名。 [5] [7]分店网络播报编辑DFS店铺位于：澳大利亚DFS旗下凯恩斯T广场DFS旗下悉尼T广场中国DFS海口美兰国际机场店DFS旗下香港T广场广东道店DFS旗下香港T广场尖东店DFS香港国际机场店DFS旗下香港T广场美妆世界铜锣湾店DFS旗下澳门T广场新濠天地店· DFS旗下澳门T广场四季名店· DFS旗下澳门T广场美妆世界澳门银河店· DFS旗下澳门T广场新濠影汇店印度DFS孟买国际机场免税店印度尼西亚· DFS旗下巴厘T广场· DFS雅加达苏加诺－哈达国际机场店· DFS巴厘国际机场店· DFS印尼棉兰瓜拉纳姆国际机场店日本· DFS旗下冲绳T广场· DFS那霸机场店· TAIT免税店北 / 时尚精品店· JAL免税店中东DFS阿布扎比国际机场店新西兰位于新西兰奥克兰Customhouse的DFS旗下奥克兰T广场DFS旗下奥克兰T广场太平洋岛屿· DFS旗下关岛T广场· DFS旗下塞班岛T广场· DFS塞班岛国际机场店· 帛琉DFS环球免税店· 帕劳机场DFS环球免税店· 帕劳太平洋度假酒店DFS环球免税店新加坡· DFS旗下新加坡T广场· DFS新加坡邮轮中心丹那美拉店· DFS新加坡邮轮中心店· DFS新加坡樟宜机场店美国· DFS旗下夏威夷T广场· DFS旧金山国际机场店· DFS洛杉矶国际机场店· DFS纽约肯尼迪国际机场店· DFS火奴鲁鲁国际机场店· DFS卡胡鲁伊机场店越南胡志明市新山一国际机场(SASCO免税店)河内市内排国际机场(NASCO免税店)岘港国际机场(DIA免税店)金兰湾金兰湾国际机场(CRAC免税店)柬埔寨暹粒吴哥T广场 (2016年开业)欧洲意大利威尼斯TFondacodeiTedeschi(2016年开业) [6]新手上路成长任务编辑入门编辑规则本人编辑我有疑问内容质疑在线客服官方贴吧意见反馈投诉建议举报不良信息未通过词条申诉投诉侵权信息封禁查询与解封©2024 Baidu 使用百度前必读 | 百科协议 | 隐私政策 | 百度百科合作平台 | 京ICP证030173号京公网安备110000020000

[算法系列]搞懂DFS(1)——经典例题(数独游戏, 部分和, 水洼数目)图文详解 - 知乎

[算法系列]搞懂DFS(1)——经典例题(数独游戏, 部分和, 水洼数目)图文详解 - 知乎切换模式写文章登录/注册[算法系列]搞懂DFS(1)——经典例题(数独游戏, 部分和, 水洼数目)图文详解0xCAFEBABEご侒荃第﹄,蕷防為紸,綜閤治理ミ↗ 本文是递归系列的第四篇文章.在前面的递归相关的设计思路, 例题介绍的基础上, 本文通过图文并茂的方式详细介绍三道比较经典的dfs题的思考方向和解题步骤, 以此介绍dfs的一般思路,以及加深对递归设计的认识. 觉得不错就小赞一下啦~1. 数独游戏数独游戏大家一定都玩过吧: 简单来说就如下的格子中, 填上剩余空白处的数字1-9,使得每行每列以及所在的小九宫格的所有数字均不同. 我以前并没有玩过数独..也不知道这类题有什么奇技淫巧没, 下面介绍下大概是普通人能够想到思路 :(1a代表左上第一个格子) 根据规则,1a不能填3,4,5,7,8. 为了体现规律性, 我们对剩下的可选数字排序, 每次选都从小开始往上挑 --- 选1a为1 接下来是1b, 选1b为2,符合; 接下来1e为4; 1f6; 1g为8;1h为7;目前有如下结果: 现在1i只剩下9可选了,由于7i已经是9,所以该填法出错了.. 然后我们拿着小橡皮, 将1h上的7 "擦掉", 填上剩下的一种可能--9,现在1i只能填7了, 检查一下,完美. 接下来继续是第二行...第三行..好了, 现在引出今天的主题: dfs(深度优先搜索), 以及回溯dfs通俗来讲, 就像小时走大迷宫一样. 遇到岔路口后, 选择其中一条 ,不撞南墙不回头不回头. 遇到尽头后, 回溯到之前的岔路的位置, 然后选择另一条路径. 如果所有的岔路都试完了均是死路的话, 就说明我正处的这个岔路所在的路径是走错了, 因而就得再一次回溯到前一个岔路口, 选择另一个岔路..抽理一下:在上述走迷宫中, 站在每一个岔路口时,我们都定义是一种状态 Si, 当我们(通常按照一定顺序) 选择某一条路径时 ,:要么是死路, 这时我们需要回到刚刚的状态 Si(回溯), 选择另一条路径要么达到下一个路口, 就进入了下一个状态 Si+1而对这个下一个状态 Si+1 , 我们使用和上述同样的做法 . 这就是DFS的精髓了.下面继续通过数独题目介绍dfs及其解法思路输入数独游戏题目, 格式为 9 * 9 的二维数组 ,0 表示未知,其他数字已知

每个零处需填入数字1-9,使得每行每列以及所在的小九宫格的所有数字均不同.

输入:

005 300 000

800 000 020

070 010 500

400 005 300

010 070 006

003 200 080

060 500 009

004 000 030

000 009 700下面给出 dfs 思路, 定义状态 : 坐标为(x,y), 且需要填数字的格子状态转移: 当前位置填好后, 填它右边最近那个需要填数字的格子, 若是最后一个则提行选择路径顺序(这里是选择数字顺序): 从1~9中选出满足条件的最小的那个, 回溯后, 选倒数第二小的, 依次类推而通过走迷宫的方法可以看出, 解决Si和解决Si+1的方法相同, 这其实更是个递归问题:找出口: 当遍历到 x = 9时 , 则说明下标为0-8的9行全部填完, 即可退出.找重复: 对每一个状态,判断填入数字的合法规则, 以及选择填入数字的顺序是相同的找变化: 很显然, 每个状态的数组的完成度是不同的, 同时待填入格子的下标也是不同的 .上述三部曲也是前面提到过的递归设计方法,详情链接: 搞懂递归, 看这篇就够了 !! 递归设计思路 + 经典例题层层递进好了, 伪代码也能上了:dfs(table, x, y): # table为当前的数组, x,y为当前状态所需填的格子坐标

# 出口条件

if x == 9:

exit(0)

if table[x][y] == 0: # 如果为0, 表示需要填

for i in range(1, 10): # 选1-9之间的数字放进去, 从小的开始选

flag = checked(table, x, y, i) # 判断是否符合同行同列等

if flag: # 如果满足就填入 i

table[x][y] = i

# 然后转移到下一个状态

dfs(table, x + (y + 1) / 9, (y + 1) % 9)

table[x][y] = 0 # for循环完了, 都不满足, 先将此处恢复成0

# 该层代码完成, 返回上一层调用 ==> 回溯

else:

# 选择下一个需要处理的位置

dfs(table, x + (y + 1) / 9, (y + 1) % 9)刚开始学的时候可能对其中核心部分还是有些疑惑:for i in range (1,10):# 选1-9之间的数字放进去, 从小的开始选

flag = checked(table,x,y,i) # 判断是否符合同行同列等

if flag: # 如果满足就

table[x][y] = i # 填入 i

dfs(table, x + (y+1) /9 , (y+1) % 9) #递归调用 ,转移到下一个状态

table[x][y] = 0 #for循环完了, 都不满足, 先将此处恢复成0

# 函数执行完成, 返回上一层调用处 ==> 回溯从1-9中选了一个数字, 如果满足, 则填上此数, 同时考察下一个位置 ;如果不满足, 即flag = false: 就会对1-9中的下一个数进行考察, 如果全都不满足flag = true, 则说明无路可走(死路), 此时需要先将该处恢复成0 , 然后紧接着函数执行完成, 也就返回到上一次调用的地方, 依然在for循环中, 会重新选择上次的数字(比如:上次选了i=5满足, 递归调用后发现下一个位置是怎么填都是死路, 那么回溯后 i 就会继续遍历得到下个满足的数字)代码如下:def shudu(table, x, y):

if x == 9 : #此时表明x已经将0-8的9行全部搞定了

print_matrix(table)

exit(0) #找到一个解即可退出

if table[x][y] == 0:

# 选1-9之间的数字放进去

for i in range(1, 10):

flag = checked(table, x, y, i)

if flag:

table[x][y] = i

# 转移到下一个状态

shudu(table, x + (y+1) // 9 , (y+1)%9)

table[x][y] = 0 #恢复该位置为0, 并进行回溯回溯

else:

# 选择下一个需要处理的位置

shudu(table, x + (y + 1) // 9, (y + 1) % 9)

def checked(table, x, y, k):

# 检查同行同列

for i in range(0, 9):

if table[x][i] == k:

return False

if table[i][y] == k:

return False

# 检查小九宫格

sx = (x // 3) * 3

ex = (x // 3 + 1)*3

sy = (y // 3) * 3

ey = (y // 3 + 1) * 3

for i in range(sx, ex):

for j in range(sy, ey):

if table[i][j] == k:

return False

return True2. 部分和给定整数序列a1,a2,...,an,判断是否可以从中选出m个数,使它们的和恰好为k

1<= n <= 20

-10^8 < ai < 10^8

-10^8 < k < 10^8

输入: n = 4

a=[1,4,2,7]

k = 13

输出: [[4,2,7]]解法1:针对每一个数字, 都有取(1)和不取(0)两种可能, 换句话说, 在不考虑元素重复的情况下, 和为 k 的情况一定是从原序列的子集中产生. 回忆上一篇文章[算法系列] 深入递归本质+经典例题解析——如何逐步生成, 以此类推,步步为营中求解全部子集的讨论. 其中提到了一个很强劲的二进制表示法来求解. 下面简述该法:用一个长度为n的二进制数来表示该序列中某个元素选还是不选的情况, 其中 n= len(arr), 位置 i 上为1表示选上arr[i] , 为0表示arr[i]不选. 比如 arr = [1,2,3] , 0 表示全部不选 ;101表示选出1,3; 111 表全部选出. 那么我们从0开始是遍历二进制数到2^n-1 对每一种情况考察是否和为k 即可. 伪代码for each binary_num from 0 to 2^n-1: for 每一位i in binary_num : if 该为上为1: k = k-arr[i] 遍历完后,若此时k = 0: return true实际代码也相当简洁:def bin_part_sum(arr , k):

n = len(arr) # n为arr的长度

k_copy = k # 备份一个k的值

for bin in range(1 , 2**n): # 遍历0到2^n-1的所有二进制数

for i in range(0 ,len(arr) ): #考察这些数的每一位

if (bin >> i) & 1 == 1: #若此位上为1

k = k - arr[i]

if k == 0 : #k 为0, 表示选出来的各数字和为k

return True

else:

k = k_copy #恢复k

return False要是想把所有的解都打印出来也很方便:def bin_part_sum(arr , k):

n = len(arr)

k_copy = k

res = list() #结果集

item = list()

for bin in range (1, 2 ** n):

for i in range(0 , len (arr)):

if (bin >> i) & 1 == 1:

k = k - arr[i]

item.append(arr[i])

if k == 0:

p_item = item.copy() # 注意这里item是个引用, 而我们实际上需要放的是他的内容

item.clear()

res.append(p_item)

else:

item.clear()

k = k_copy

print(res)

arr = [1,2,3,4]

bin_part_sum(arr , 6)

'''

[[1, 2, 3], [2, 4]]

'''解法2:很显然此题也是可以用dfs进行求解的, 如下为dfs思路:定义状态 : 当前考察的数字: arr[cur] , 已选择的数字集合状态转移: 当前已选数字和小于k 时 , 顺次cur +1, 若大于了k, 则为死路, 考虑回退选择路径顺序 : 对每一个状态时, 先考虑选 , 其回溯后考虑不选和上面数独题类似, 也要考虑递归设计三要素:找出口: 要么sum=k, 表示找到一个解, 此时退出, 若要寻找所有解, 则应当返回; 要么sum > k , 则说明此路径错误, 返回找重复: 对于每一个状态的选择方法一致, 要么选要么不选, 属于同问题不同规模找变化: sum变化, cur变化, 若需要保留每一组解, 则需引入的最终结果集res, 以及每个结果item 均在变化 (回忆找变化的作用: 往往用来定参数)下面依然以 arr = [1, 2, 4,7 ] , k =13 为例, 其中cur为当前考虑的arr下标, sum为当前选了的数字和, item用于存放当前选了的数字蓝色数字是调用顺序, 其中部分调用数省略代码如下: 这里图方便省去了sum , 直接在k上进行操作, 即当k减到0时, 也说明当前和是k# dfs

def dfs_part_sum(arr, k):

res = list()

item = list()

part_sum(arr ,item,res, k , 0)

print(res)

def part_sum(arr , item, res, k ,cur):

if k == 0 :

res.append(item)

return #这里得到结果也要返回

if k < 0 or cur == len(arr):

return

#为了代码方便,这里先考虑不选这个元素

c_item_0= item.copy()

part_sum(arr, c_item_0 , res, k , cur+1) #item 不变, k不减少, 只是cur++

#选择这个元素

item.append(arr[cur]) # 选择, 即加入当前item

c_item = item.copy()

part_sum(arr , c_item , res, k - arr[cur] , cur+1) # 目标k值缩小

arr = [1,2,3,4,5]

dfs_part_sum(arr , 6)

'''res

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

'''3. 水洼数目有一个大小为N×M的园子，雨后积起了水。

其中: 1代表有水, 0代表没水

八连通的积水被认为是连通在一起的。请求出园子里总共有多少水洼？（八连通指的是下图中相对w的*部分）

***

*W*

***

例如某园子如图:

100000000110

011100000111

000011000110

000000000110

000000000100

001000000100

010100000110

101010000010

010100000010

001000000010

输出3思路: 寻找8连通的数目. 此题也是一个很经典的题目, 和前面两题的dfs模式小有不同. 抽理一下题意 :从一个值为1的位置出发, 能够向四周八个方向同样是1的地方走, 假设有如下, 一个"1" 选择了自己右下角的路径:那么相类似, 这个1 同样有如蓝色的路径可以选择. 但是请注意, 这时刚刚走过的这个1 , 在进入下一步时应当舍弃, 否则就会出现: 左上角的1 进入到右下角的1, 紧接着右下角的1 回到左上角去. 这种循环死局不是我们希望的. 那么可以怎么办? 其实很简单, 到达一个 "1" 时, 先将该处置为"0" , 然后再去找八个方向的1. 下面演示一下过程: 现在回到左上角的1 了 , 然而他已经无路可走, 只能继续返回, 此时, 我们就认为这个水洼遍历完成, count++ 即可.接下来, 在整个二维数组内遍历寻找下一个 1 , 一个新的故事上演 ... 直到整个界面中的1 全部变为0时, 遍历结束, count即为结果伪代码如下:def fun():

对数组arr中的每个位置元素arr[i][j]:

if arr[i][j] == 1:

dfs(arr, i ,j)

count ++

return count

def dfs(arr , i , j):

if 上方有数字且为1:

dfs(arr ,i - 1 , j )

if 左上方有数字且为1:

dfs(arr ,i - 1 , j - 1 )

if 右上方有数字且为1:

dfs(arr ,i - 1 , j + 1 )

if 左方有数字且为1:

dfs(arr ,i , j - 1 )

...

//8个方向均需考虑下面是实现代码 :def get_water_num(arr):

count = 0

for i in range(0 , len(arr)):

for j in range(0 , len(arr[0])):

if arr[i][j] == 1:

dfs_get_water_num(arr,i,j)

count +=1

return count

def dfs_get_water_num(arr,i,j):

arr[i][j] = 0

# 更快捷地遍历8个方向

for k in range(-1 , 2): # -1, 0 ,1 也就是向左1, 不动,向右1

for l in range(-1 , 2): #-1 ,0 ,1

if k == 0 and l == 0: #如果没动

continue

if i+k >= 0 and i+k <= len(arr) -1 and j+l>= 0 and j+l<=len(arr[0]) - 1: #不能移动出边界

if arr[i+k][j+l] == 1:

dfs_get_water_num(arr , i + k , j + l)变式: 在此基础上, 不但要求出水洼数量, 还要求得各个水洼的大小(1的个数)#变式: 求出水洼数量, 还要求得各个水洼的大小(1的个数)

def get_water_max(arr):

res = [] #结果list

for i in range(0 , len(arr)):

for j in range(0 , len(arr[0])):

if arr[i][j] == 1:

area = 0

t_a = dfs_get_water_max(arr,i,j,area + 1 )

res.append(t_a)

return res

def dfs_get_water_max(arr,i,j ,area): #area 表示目前的面积大小

arr[i][j] = 0

for k in range(-1 , 2): # -1, 0 ,1

for l in range(-1 , 2): # -1 ,0 ,1

if k == 0 and l == 0:

continue

if i+k >= 0 and i+k <= len(arr) -1 and j+l>= 0 and j+l<=len(arr[0]) - 1:

if arr[i+k][j+l] == 1:

return dfs_get_water_max(arr , i + k , j + l ,area +1) # area + 1

return area # area 没变化,作为结果返回

print(get_water_max(arr))在这个问题需要注意的一点就是: area 作为当前水洼面积的大小, 我是设计成作为参数进行传递的, 每当成功调用的时候(发现周围有个1了), 传入area + 1作为下一次的area. 由于最终需要保存每个水洼的area,故也要作为返回值返回.arr=[

[1,0,0,0,0,0,0,0,0,1,1,0],

[0,1,1,1,0,0,0,0,0,1,1,1],

[0,0,0,0,1,1,0,0,0,1,1,0],

[0,0,0,0,0,0,0,0,0,1,1,0],

[0,0,0,0,0,0,0,0,0,1,0,0],

[0,0,1,0,0,0,1,0,0,1,0,0],

[0,1,0,1,0,0,1,0,0,1,1,0],

[1,0,1,0,1,0,0,1,0,0,1,0],

[0,1,0,1,0,0,0,0,0,0,1,0],

[0,0,1,0,0,0,0,0,0,0,1,0]

]

print(get_water_max(arr))

'''res

[6, 16, 9, 3]#4

'''在下一文章中, 将继续介绍DFS概念以及一些诸如n皇后等经典题目往期回顾: 2. [算法系列] 递归应用: 快速排序+归并排序算法及其核心思想与拓展 .. 附赠堆排序算法编辑于 2020-10-01 11:28递归算法设计算法赞同 193 条评论分享喜欢收藏申请

DFS----深度优先搜索与记忆化数组例题分析_深度优先搜索和记忆化搜索-CSDN博客

DFS----深度优先搜索与记忆化数组例题分析

最新推荐文章于 2022-09-21 22:17:04 发布

向光.

最新推荐文章于 2022-09-21 22:17:04 发布

阅读量464

点赞数

分类专栏：

编程

# DFS与递归及回溯

文章标签：

dfs

动态规划

c++

算法

本文链接：https://blog.csdn.net/xiangguang_fight/article/details/115311010

版权

DFS与递归及回溯

同时被 2 个专栏收录

42 篇文章

0 订阅

订阅专栏

编程

7 篇文章

0 订阅

订阅专栏

DFS与BFS的简单理解

DFS

DFS(即深度优先搜索)是一种利用递归和循环结构将所有可能的路径和方法都搜索一遍的方式，其本质上与暴力解法类似，不过是利用了递归结构省去了大量代码。主要思想是运用了回溯，保存这次的位置并深入搜索，都搜索完便回溯回来，搜下一个位置，直到把所有最深位置都搜一遍（找到目的解返回或者全部遍历完返回一个事先定好的值）。要注意的一点是，搜索的时候有记录走过的位置，标记完后可能要改回来。

例题1：滑雪问题

Michael喜欢滑雪这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道在一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。

下面是一个例子：

1 2 3 4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-…-3-2-1更长。事实上，这是最长的一条。 Input 输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。 Output 输出最长区域的长度。

Sample Input 5 5

1 2 3 4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

Sample Output 25

题解：

首先由于路径的可能性实在太多，使用暴力for循环无法写出，于是我们可以考虑dfs解决。

即我们可以构造一个dfs函数，然后将输入的每一个数都输入到dfs函数中求其路径的可能性，最后求最大值即可。

dfs函数怎么构成呢？我们通常使用递归实现。我们可以只传入目标值的两个下标，然后对其进行四个方向的搜索。如果满足其中一个方向没有越界且符合题意时，我们就按照此种可能性继续搜索下去，即秉着“深度优先搜索”的思想，将这一条路走到不能走为止。因此这里使用递归进行搞定。

若此方向不满足搜索下去的条件那么我们就换个方向看一看，如果四个方向都不可以，那么我们认为这一个点不符合题意，因此不对其进行任何操作，直接查看下一个点即可。需要注意的是每个点自己就算一个点了，因此长度至少为1。并且多次递归我们要的只是次数最大的那一个。还需要注意的是由于a数组一直在多个函数都用到了，所以不妨直接定义全局化。另外另外这题为了节省时间而使用了一个非常重要的东西——————记忆化数组！！！因为在进行dfs时由于我们秉承着“深度优先”的思想，因此必定会有重复搜索的现象。所以我们不妨定义一个hash数组当做我们的记忆化数组，保存我们每次搜索后得到的结果，这样的话可以大大的省去了我们的时间。如:我们在遍历24时，查找到了其一个方向17，而17这个在我们前面的搜索中其实已经搜索过了，所以我们不用搜索了，直接使用前面搜索的结果即可。所以这里也同时蕴含动态规划和回溯的思想。

代码：

#include

using namespace std;

int a[101][101];

int hash[101][101];//记忆化数组

int m,n;

int dir[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};//定义方向数组以免需要过多的if来模拟四种方向

bool inspect(int x0,int y0)//判断是否可行

{

if(x0<0||x0>=m||y0<0||y0>=n)

{

return 0;

}

return 1;

}

int dfs(int x,int y)

{

if(hash[x][y])//一旦满足记忆化数组保存过的地方

return hash[x][y];//直接取它

int res = 1;//保存每次的长度，最少为1

for(int k=0;k<4;k++)//遍历四种方向

{

int tx = x+dir[k][0];//这样通过一个步骤即可完成四个if的情况

int ty = y+dir[k][1];

if(inspect(tx,ty)&&a[tx][ty]

{

res = max(res,dfs(tx,ty)+1);

}

hash[x][y] = res;

return res;

}

int main()

{

cin>>m>>n;

for(int i=0;i

{

for(int j=0;j

{

cin>>a[i][j];

}

int sum = 1;//次数最少为1

for(int i=0;i

{

for(int j=0;j

{

sum = max(sum,dfs(i,j));

}

cout<

return 0;

}

例题2：八皇后问题

八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。八皇后问题可以推广为更一般的n皇后摆放问题：这时棋盘的大小变为n×n，而皇后个数也变成n。当且仅当 n = 1 或 n ≥ 4 时问题有解。 Input 无输入。 Output 按给定顺序和格式输出所有八皇后问题的解（见Sample Output）。 Sample Input

Sample Output

No. 1

1 0 0 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 0 0 1 0 0 0

0 0 0 0 0 0 0 1

0 1 0 0 0 0 0 0

0 0 0 1 0 0 0 0

0 0 0 0 0 1 0 0

0 0 1 0 0 0 0 0

No. 2

1 0 0 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 0 1 0 0 0 0

0 0 0 0 0 1 0 0

0 0 0 0 0 0 0 1

0 1 0 0 0 0 0 0

0 0 0 0 1 0 0 0

0 0 1 0 0 0 0 0

No. 3

1 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0

0 0 0 0 0 0 0 1

0 0 1 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 0 1 0 0 0 0

0 1 0 0 0 0 0 0

0 0 0 0 1 0 0 0

No. 4

1 0 0 0 0 0 0 0

0 0 0 0 1 0 0 0

0 0 0 0 0 0 0 1

0 0 0 0 0 1 0 0

0 0 1 0 0 0 0 0

0 0 0 0 0 0 1 0

0 1 0 0 0 0 0 0

0 0 0 1 0 0 0 0

No. 5

0 0 0 0 0 1 0 0

1 0 0 0 0 0 0 0

0 0 0 0 1 0 0 0

0 1 0 0 0 0 0 0

0 0 0 0 0 0 0 1

0 0 1 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 0 1 0 0 0 0

No. 6

0 0 0 1 0 0 0 0

1 0 0 0 0 0 0 0

0 0 0 0 1 0 0 0

0 0 0 0 0 0 0 1

0 1 0 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 1 0 0 0 0 0

0 0 0 0 0 1 0 0

No. 7

0 0 0 0 1 0 0 0

1 0 0 0 0 0 0 0

0 0 0 0 0 0 0 1

0 0 0 1 0 0 0 0

0 1 0 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 1 0 0 0 0 0

0 0 0 0 0 1 0 0

No. 8

0 0 1 0 0 0 0 0

1 0 0 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 0 0 1 0 0 0

0 0 0 0 0 0 0 1

0 1 0 0 0 0 0 0

0 0 0 1 0 0 0 0

0 0 0 0 0 1 0 0

No. 9

0 0 0 0 1 0 0 0

1 0 0 0 0 0 0 0

0 0 0 1 0 0 0 0

0 0 0 0 0 1 0 0

0 0 0 0 0 0 0 1

0 1 0 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 1 0 0 0 0 0

...以下省略

题解：

此题同样为许多种组合方式，过于繁杂，因此我们也可以使用dfs简化思考过程。即将一个庞大的问题化为若干个小问题，接着对小问题进行求解即可。我们可以将行列分离来看，同样创建dfs函数，将第一行先传入dfs中，然后给其找上一列，然后对其分析，看其是否能满足放置皇后的条件，若能则放上皇后，并秉承“深度优先”的思想，继续此深度的搜索，即给其行数加1代入dfs中直到这种方法搜索完毕，即此方法对八行都进行判断完全，因此我们可以打印出这种方法，接着对原数组进行“回溯”操作，再进行下一轮判断即可。而回溯的关键即在于记忆化数组的构建。

需要注意的是对于繁杂的程序我们尽量将程序碎片化，即将程序分解为多个模块，这样有助于我们分析哪步操作该办哪步的事情。如此代码中的reflect函数和check函数，其实也可以不单独定义，但那样会显得代码过于繁杂，可读性低，分解为小函数后更能增加可读性，只要注意函数名的选择即可。

代码：

#include

using namespace std;

int hash[8][8] = {0};//既是棋盘同时也承担着“回溯”的操作，即也是记忆化数组

//先变成0表示棋盘初始化

int queen_col[8];//其表示第n行时皇后所在的列数

int sum = 1;//表示方法数量，用于打印

bool check(int row)//将行数传进来

{

for(int i=0;i

//这也是我们分解行列的原因，省去判断行的情况了

{

if(queen_col[row]==queen_col[i]||abs(queen_col[row]-queen_col[i])==row-i)

//满足斜线的条件是列下标相减与行下标相减绝对值大小相同

{

return 0;

}

}//因为检查的是前面的那些行，该行不包括在内，所以只检查列就相当于检查了行与列

return 1;

}

void reflect()

{

for(int i=0;i<8;i++)

{

hash[i][queen_col[i]] = 1;//queen_col[i]就是我们经过判断的结果，其表示列，因此遍历行

}

cout<<"方法"<

for(int i=0;i<8;i++)

{

for(int j=0;j<8;j++)

{

cout<

}

cout<

}

void dfs(int row)//其会遍历许多次，因为有许多不同的摆法，每种摆法都要遍历八行才可打印

{

if(row==8)//表示一种方法遍历完毕

{

reflect();

}

for(int i=0;i<8;i++)

{

queen_col[row] = i;//将列代入

if(check(row)!=0)

{

hash[row][i] = 1;//满足即放上，与后面打印中的赋值操作有关系的

dfs(row+1);

hash[row][i] = 0;//“回溯”操作

//因为在前面的dfs递归完成后即代表八行已经遍历过了，即一种方法已经确定了，因此我们可以“回溯”了

}

int main()

{

dfs(0);//将第一行代入

return 0;

}

优惠劵

向光.

关注

踩

觉得还不错?

一键收藏

打赏

知道了

DFS----深度优先搜索与记忆化数组例题分析

DFSDFS(即深度优先搜索)是一种利用递归和循环结构将所有可能的路径和方法都搜索一遍的方式，其本质上与暴力解法类似，不过是利用了递归结构省去了大量代码。主要思想是运用了回溯，保存这次的位置并深入搜索，都搜索完便回溯回来，搜下一个位置，直到把所有最深位置都搜一遍（找到目的解返回或者全部遍历完返回一个事先定好的值）。要注意的一点是，搜索的时候有记录走过的位置，标记完后可能要改回来。例题1：滑雪问题Michael喜欢滑雪这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑

复制链接

扫一扫

专栏目录

对记忆化搜索+深度优先搜索的理解与比较

qq_45706306的博客

12-17

541

#记忆化搜索是动态规划和搜索的综合体，结合了两者的优点。因为动态规划往往要遍历所有的状态，而搜索可以排除一些无效状态。更重要的是搜索还可以剪枝（比如0-1背包问题减去了大量的无用搜索），因此在时间和空间开销上往往比动态规划要低很多。记忆化算法在求解的时候还是按着自顶向下的顺序，但是每求解一个状态，就将它的解保存下来，以后再次遇到这个状态的时候，就不必重新求解了。

#深度优先搜索属于图算法的一种，缩写为DFS。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次，特别的它在搜索

深度优先搜索（DFS）剪枝：记忆化搜索（C++）

小天狼星_布莱克的博客

12-10

2403

今天我们来讲一下深搜的剪枝方法中的一个：记忆化搜索。顾名思义，记忆化搜索就是让程序记住一些东西，然后可以在需要用的时候可以瞬间调用，不需要再进行一次复杂的计算！首先，记忆需要大脑来存储数据，什么来模拟大脑？数组其次，记忆需要现有的知识用来记住，知识从哪里来？以前求出的数据。这样，我们如果要用到以前求过的数据，就可以从数组中调用，可以大大提高我们程序的运行速度。

参与评论

您还未登录，请先

后发表或查看评论

记忆数组

beijingFC的博客

12-18

297

记忆数组

斐波那契数优化

#include

using namespace std;

long long num[50];

long long f(int n){

if(n==0||n==1) return 1;

if(num[n]) return num[n];

return num[n]= f(n-1) + f(n-2);

}

int main(){

for(int i=1;i<=40;i++){

cout<

动态规划经验分享

weixin_60295600的博客

04-20

131

动态规划适用场景

一般使用暴力搜索的题都可用动态规划进行优化。进行枚举（暴力搜索）时会出现重复的子问题，这些重复的子问题会大大增加程序运行所需时间，动态规划的出现就是解决重复子问题重复出现的情况，使用记忆数据将子问题的最优解记录下来，下次直接重记忆数组中取就好了。

动态规划的构成

1.记忆数组：在问题回溯过程中，使用记忆数组记录当前问题的最优解,方便我们在遇到重复子问题时不用再计算，直接在表中取值就行。

2.状态转移方程: 状态转移方程分为两部分

1> 初始状态：想当于出口，也就是最小子问题

记忆化搜索以及记忆数组大小的影响

DRZ_2000的博客

01-23

390

记忆化搜索以及记忆数组大小的影响

一问题的引入

小编在回顾欧拉计划时遇到记忆化搜索问题，略有感触，感觉有必要和大家分享。

话不多说咱们直接上截图：

问题大意：

一个数，若为偶数，则它下一次将变化为n / 2；若为奇数，则将变化为3 * n + 1；这样变化最后一定会以1结尾，为此，我们得到一个转换序列。

现在我们要做的就是在1～1000000之间，找到一个数，该数字对应的转换序列的长度最长。

...

dfs-深度优先搜索之组合的输出

DFS 命名空间概述 | Microsoft Learn

跳转至主内容

此浏览器不再受支持。

请升级到 Microsoft Edge 以使用最新的功能、安全更新和技术支持。

下载 Microsoft Edge

有关 Internet Explorer 和 Microsoft Edge 的详细信息

退出焦点模式

使用英语阅读

保存

使用英语阅读

保存

打印

Twitter

Facebook

电子邮件

DFS 命名空间概述

项目

09/03/2023

15 个参与者

反馈

本文内容

适用范围：Windows Server 2022、Windows Server 2019、Windows Server 2016、Windows Server 2012 R2、Windows Server 2012、Windows Server 2008 R2、Windows Server 2008

DFS（分布式文件系统）命名空间是 Windows Server 中的一种角色服务，可用于将不同服务器上的共享文件夹组合到一个或多个逻辑结构的命名空间。这使用户能够获得共享文件夹的虚拟视图，其中单个路径导致文件位于多个服务器上，如下图所示：

下面是构成 DFS 命名空间的元素的说明：

命名空间服务器 - 命名空间服务器托管命名空间。命名空间服务器可以是成员服务器或域控制器。

命名空间根路径–命名空间根路径是命名空间的起点。在上图中，根路径的名称为 Public，命名空间的路径为 \\Contoso\Public。此类型命名空间是基于域的命名空间，因为它以域名开头（例如 Contoso），并且其元数据存储在 Active Directory 域服务 (AD DS) 中。尽管上图中显示单个命名空间服务器，但是基于域的命名空间可以存放在多个命名空间服务器上，以提高命名空间的可用性。

文件夹–没有文件夹目标的文件夹将结构和层次结构添加到命名空间，具有文件夹目标的文件夹为用户提供实际内容。用户浏览命名空间中包含文件夹目标的文件夹时，客户端计算机将收到透明地将客户端计算机重定向到一个文件夹目标的引用。

文件夹目标–文件夹目标是共享文件夹或与命名空间中的某个文件夹关联的另一个命名空间的 UNC 路径。文件夹目标是存储数据和内容的位置。在上图中，名为 Tools 的文件夹包含两个文件夹目标，一个位于伦敦，一个位于纽约，名为 Training Guides 的文件夹包含一个文件夹目标，位于纽约。浏览到 \\Contoso\Public\Software\Tools 的用户透明地重定向到共享文件夹 \\LDN-SVR-01\Tools 或 \\NYC-SVR-01\Tools（取决于用户当前所处的位置）。

本文讨论了 DFS 安装方法、新增功能和查找评估与部署信息的位置。

可以使用 DFS 管理、Windows PowerShell 中的 DFS 命名空间 (DFSN) Cmdlet、DfsUtil 命令或调用 WMI 的脚本来管理命名空间。

服务器要求和限制

运行 DFS 管理或使用 DFS 命名空间没有其他硬件或软件要求。

命名空间服务器是承载命名空间的域控制器或成员服务器。可以在服务器上承载的命名空间数由命名空间服务器上运行的操作系统决定。

除了单个独立命名空间之外，运行以下操作系统的服务器还可以承载多个基于域的命名空间。

Windows Server 2022

Windows Server 2019

Windows Server 2016

Windows Server 2012 R2

Windows Server 2012

Windows Server 2008 R2 Datacenter 和 Enterprise Edition

Windows Server（半年频道）

运行以下操作系统的服务器可以承载单个独立命名空间：

Windows Server 2008 R2 标准版

下表说明在选择承载命名空间的服务器时要考虑的其他因素。

承载独立命名空间的服务器

承载基于域的命名空间的服务器

必须包含承载命名空间的 NTFS 卷。

可以是成员服务器或域控制器。

必须是配置了命名空间的域中的成员服务器或域控制器。（此要求适用于承载给定的基于域的命名空间的每个命名空间服务器。）

可以由故障转移群集承载，以提高命名空间的可用性。

命名空间不能是故障转移群集中的群集资源。但是，如果将命名空间配置为仅使用该服务器上的本地资源，则可以在故障转移群集中充当节点的服务器上找到该命名空间。

安装 DFS 命名空间

DFS 命名空间和 DFS 复制是文件和存储服务角色中的一部分。 DFS 的管理工具（DFS 管理、Windows PowerShell 的 DFS 命名空间模块及命令行工具）分别安装为远程服务器管理工具的一部分。

使用 Windows Admin Center、服务器管理器或 PowerShell 安装 DFS 命名空间，具体如后续部分所述。

使用服务器管理器安装 DFS 的步骤

打开服务器管理器，单击 “管理” ，然后单击 “添加角色和功能” 。将出现“添加角色和功能向导”。

在 “服务器选择” 页面上，选择你想要在其上安装 DFS 的脱机虚拟机的服务器或虚拟硬盘 (VHD)。

选择要安装的角色服务和功能。

要安装 DFS 命名空间服务，请在“服务器角色”页上选择“DFS 命名空间”。

若只安装 DFS 管理工具，请在 “功能” 页上，展开 “远程服务器管理工具” 、 “角色管理工具” 、 “文件服务工具” ，然后选择 “DFS 管理工具” 。

“DFS 管理工具”安装 DFS 管理管理单元、Windows PowerShell 的 DFS 命名空间模块和命令行工具，但它不在服务器上安装任何 DFS 服务。

使用 Windows PowerShell 安装 DFS 的步骤

使用提升的用户权限打开 Windows PowerShell 会话，然后键入以下命令，其中是你想要安装的角色服务或功能（请参阅下表以获取一列相关角色服务或功能名称）：

Install-WindowsFeature

角色服务或功能

名称

DFS 命名空间

FS-DFS-Namespace

DFS 管理工具

RSAT-DFS-Mgmt-Con

例如，若要安装远程服务器管理工具功能中的分布式文件系统工具部分，请键入：

Install-WindowsFeature "RSAT-DFS-Mgmt-Con"

若要为客户端设备安装分布式文件系统工具部分，请键入：

Add-WindowsCapability -Name Rsat.FileServices.Tools~~~~0.0.1.0 -Online

要安装 DFS 命名空间和远程服务器管理工具功能中的分布式文件系统工具部分，请键入：

Install-WindowsFeature "FS-DFS-Namespace", "RSAT-DFS-Mgmt-Con"

Azure 虚拟机的互操作性

在 Microsoft Azure 中的虚拟机上使用 DFS 命名空间已经过测试。

可在 Azure 虚拟机中托管基于域的命名空间，包括附带 Microsoft Entra ID 的环境。

可以借助使用共享磁盘或超级磁盘的故障转移群集在 Azure 虚拟机中将独立命名空间进行聚类。

要了解如何开始使用 Azure 虚拟机，请参阅 Azure 虚拟机文档。

其他参考

有关其他相关信息，请参阅以下资源。

内容类型

参考

产品评估

Windows Server 中的 DFS 命名空间和 DFS 复制的新增功能

部署

DFS 命名空间可伸缩性注意事项

操作

DFS 命名空间：常见问题

社区资源

文件服务和存储 TechNet 论坛

协议

Windows Server 中的文件服务协议（已弃用）

DFSDFS - CC - 单曲 - 网易云音乐

生成外链播放器

DFSDFS

歌手：CC

所属专辑：非

播放

下载

相似歌曲

GEWFEEWF

IHUCA

QWFASFAS

VOR

网易云音乐多端下载

iPhone

Android

同步歌单，随时畅听好音乐

用户wiki

补充或修改歌曲资料

用户wiki任务中心

音乐开放平台

云村交易所

Amped Studio

X StudioAI歌手

用户认证

音乐交易平台

云推歌

赞赏

服务条款|

隐私政策|

儿童隐私政策|

版权投诉|

投资者关系|

广告合作

联系我们

廉正举报

不良信息举报邮箱: 51jubao@service.netease.com

客服热线：95163298

互联网宗教信息服务许可证：浙（2022）0000120

增值电信业务经营许可证：浙B2-20150198

粤B2-20090191-18 工业和信息化部备案管理系统网站

浙公网安备 33010802013307号

回到顶部

{if degrade}

手机号登录

注　册

微信登录

QQ登录

微博登录

网易邮箱账号登录

同意

《服务条款》

《隐私政策》

《儿童隐私政策》

{else}

手机号登录

注　册

微信登录

QQ登录

微博登录

网易邮箱账号登录

同意

《服务条款》

《隐私政策》

《儿童隐私政策》

扫码登录

二维码已失效

点击刷新

使用网易云音乐APP 扫码登录

扫描成功

请在手机上确认登录

选择其他登录模式

{/if}

忘记密码？

短信登录

自动登录

获取验证码

密码登录

自动登录

登　录

< 其他登录方式

没有账号？免费注册 >

自动登录

忘记密码？

登　录

< 其他登录方式

{list suggests as item}

${item|escape}

{/list}

手机号：

密码：

密码不能包含空格

包含字母、数字、符号中至少两种

密码长度为8-20位

下一步

< 返回登录

云音乐将不再支持腾讯微博登录方式，请绑定手机号，以免后续无法使用该账号

你的手机号：+

为了安全，我们会给你发送短信验证码

验证码：

< 返回登录

云音乐将不再支持腾讯微博登录方式，请绑定手机号，以免后续无法使用该账号

你的手机号：+

为了安全，我们会给你发送短信验证码

输入要解绑的完整手机号，用于验证您的身份

下一步

< 返回登录

跳过 >

获取验证码

取一个昵称，让大家记住你

完成注册，开启云音乐

取一个昵称，让大家记住你

完成注册，开启云音乐

云音乐将不再支持腾讯微博登录方式，设置登录密码，以后可以使用手机号登录

你的手机号：+

设置密码后，可以直接用该手机号+密码登录

密码不能包含空格

包含字母、数字、符号中至少两种

密码长度为8-20位

跳过 >

如果你不是机器人输入验证码一定没问题！

账号或密码错误

确定

取消

+86

{list countries as x}

${x.zh}

+${x.code}

{/list}

由于你在非受信任的设备上登录，需要进行短信验证()

通过短信验证身份

{list data as x}${x.t}{/list}

歌单名：

错误提示

可通过“收藏”将音乐添加到新歌单中

新建

取消

评论共0条评论

◆◆

后面还有0条评论，查看更多>

收起

{list beg..end as y}

{var x=xlist[y]}

{if !!x}

${escape(x.user.nickname)}

{if x.user.avatarDetail && x.user.avatarDetail.identityIconUrl}

{/if}

{if x.user.vipRights}

{if x.user.vipRights.redplus && x.user.vipRights.redplus.vipCode === 300 && x.user.vipRights.redplus.rights && x.user.vipRights.redplus.iconUrl}

{elseif x.user.vipRights.associator && x.user.vipRights.associator.rights && x.user.vipRights.redVipLevel}

{if x.user.vipRights.associator.iconUrl}

{elseif x.user.vipRights.redVipLevel == 1}

{if useNewVipIcon}

{else}

{/if}

{elseif x.user.vipRights.redVipLevel == 2}

{if useNewVipIcon}

{else}

{/if}

{elseif x.user.vipRights.redVipLevel == 3}

{if useNewVipIcon}

{else}

{/if}

{elseif x.user.vipRights.redVipLevel == 4}

{if useNewVipIcon}

{else}

{/if}

{elseif x.user.vipRights.redVipLevel == 5}

{if useNewVipIcon}

{else}

{/if}

{elseif x.user.vipRights.redVipLevel == 6}

{if useNewVipIcon}

{else}

{/if}

{elseif x.user.vipRights.redVipLevel == 7}

{if useNewVipIcon}

{else}

{/if}

{elseif x.user.vipRights.musicPackage && x.user.vipRights.musicPackage.rights}

{if x.user.vipRights.musicPackage.iconUrl}

{else}

{/if}

{elseif x.user.vipRights.redVipAnnualCount >= 1}

{if useNewVipIcon}

{else}

{/if}

{elseif x.user.vipRights.associator && x.user.vipRights.associator.rights}

{if useNewVipIcon}

{else}

{/if}

{if !!x.beRepliedUser}

回复 ${escape(x.beRepliedUser.nickname)}

${getAuthIcon(x.beRepliedUser)}

{if x.beRepliedUser.vipRights}

{if x.beRepliedUser.vipRights.redplus && x.beRepliedUser.vipRights.redplus.vipCode === 300 && x.beRepliedUser.vipRights.redplus.rights && x.beRepliedUser.vipRights.redplus.iconUrl}

{elseif x.beRepliedUser.vipRights.associator && x.beRepliedUser.vipRights.associator.rights}

{if x.beRepliedUser.vipRights.redVipAnnualCount >= 1}

{if useNewVipIcon}

{else}

{/if}

{elseif x.beRepliedUser.vipRights.associator.iconUrl}

{else}

{if useNewVipIcon}

{else}

{/if}

{elseif x.beRepliedUser.vipRights.musicPackage && x.beRepliedUser.vipRights.musicPackage.rights}

{if x.beRepliedUser.vipRights.musicPackage.iconUrl}

{else}

{/if}

：${getRichText(escape(x.content),'s-fc7')}

{if !!x.expressionUrl}

{/if}

{if x.beReplied&&x.beReplied.length}

{var replied = x.beReplied[0]}

◆◆

{if (replied && replied.status>=0) && (replied.content || replied.expressionUrl)}

${replied.user.nickname}${getAuthIcon(replied.user)}

{if replied.user.vipRights}

{if replied.user.vipRights.redplus && replied.user.vipRights.redplus.vipCode === 300 && replied.user.vipRights.redplus.rights && replied.user.vipRights.redplus.iconUrl}

{elseif replied.user.vipRights.associator && replied.user.vipRights.associator.rights}

{if replied.user.vipRights.redVipAnnualCount >= 1}

{if useNewVipIcon}

{else}

{/if}

{elseif replied.user.vipRights.associator.iconUrl}

{else}

{if useNewVipIcon}

{else}

{/if}

{elseif replied.user.vipRights.musicPackage && replied.user.vipRights.musicPackage.rights}

{if replied.user.vipRights.musicPackage.iconUrl}

{else}

{/if}

：${getRichText(escape(replied.content),'s-fc7')}

{if !!replied.expressionUrl}

{/if}

{else}

该评论已删除

{/if}

${timeformat(x.time)}

{if x.topCommentId}音乐人置顶{/if}

{if canTop()&&GUser&&GUser.userId&&(GUser.userId==x.user.userId)}

{if x.topCommentId}解除置顶{else}置顶评论{/if}|

{/if}

{if GUser&&GUser.userId&&(GUser.userId==x.user.userId||GUser.userId==resUserId)}

删除|

{else}

删除|

{/if}

{if GAllowRejectComment}

{if hot||!x.isRemoveHotComment}

移除精彩评论|

{else}

已移除精彩评论|

{/if}

{if !x.topCommentId}{if x.likedCount} (${getPlayCount(x.likedCount)}){/if}

|{/if}

{/if}

{/list}

{list beg..end as y}

{var x=xlist[y]}

${escape(x.user.nickname)}

{if x.user.avatarDetail && x.user.avatarDetail.identityIconUrl}

{/if}

{if x.user.vipRights}

{if x.user.vipRights.redplus && x.user.vipRights.redplus.vipCode === 300 && x.user.vipRights.redplus.rights && x.user.vipRights.redplus.iconUrl}

{elseif x.user.vipRights.associator && x.user.vipRights.associator.rights}

{if x.user.vipRights.associator.iconUrl}

{elseif x.user.vipRights.redVipLevel == 1}

{elseif x.user.vipRights.redVipLevel == 2}

{elseif x.user.vipRights.redVipLevel == 3}

{elseif x.user.vipRights.redVipLevel == 4}

{elseif x.user.vipRights.redVipLevel == 5}

{elseif x.user.vipRights.redVipLevel == 6}

{elseif x.user.vipRights.redVipLevel == 7}

{/if}

{elseif x.user.vipRights.musicPackage && x.user.vipRights.musicPackage.rights}

{if x.user.vipRights.musicPackage.iconUrl}

{else}

{/if}

{if !!x.beRepliedUser}

回复 ${escape(x.beRepliedUser.nickname)}

${getAuthIcon(x.beRepliedUser)}

{if x.beRepliedUser.vipRights}

{if x.beRepliedUser.vipRights.redplus && x.beRepliedUser.vipRights.redplus.vipCode === 300 && x.beRepliedUser.vipRights.redplus.rights && x.beRepliedUser.vipRights.redplus.iconUrl}

{elseif x.beRepliedUser.vipRights.associator && x.beRepliedUser.vipRights.associator.rights}

{if x.beRepliedUser.vipRights.redVipAnnualCount >= 1}

{elseif x.beRepliedUser.vipRights.associator.iconUrl}

{else}

{/if}

{elseif x.beRepliedUser.vipRights.musicPackage && x.beRepliedUser.vipRights.musicPackage.rights}

{if x.beRepliedUser.vipRights.musicPackage.iconUrl}

{else}

{/if}

：${getRichText(escape(x.content),'s-fc7')}

{if !!x.expressionUrl}

{/if}

{if x.beReplied&&x.beReplied.length}

{var replied = x.beReplied[0]}

◆◆

{if replied&&replied.content}

${replied.user.nickname}${getAuthIcon(replied.user)}

{if replied.user.vipRights}

{if replied.user.vipRights.redplus && replied.user.vipRights.redplus.vipCode === 300 && replied.user.vipRights.redplus.rights && replied.user.vipRights.redplus.iconUrl}

{elseif replied.user.vipRights.associator && replied.user.vipRights.associator.rights}

{if replied.user.vipRights.redVipAnnualCount >= 1}

{elseif replied.user.vipRights.associator.iconUrl}

{else}

{/if}

{elseif replied.user.vipRights.musicPackage && replied.user.vipRights.musicPackage.rights}

{if replied.user.vipRights.musicPackage.iconUrl}

{else}

{/if}

：${getRichText(escape(replied.content),'s-fc7')}

{else}

该评论已删除

{/if}

${timeformat(x.time)}

{if GUser&&GUser.userId&&(GUser.userId==x.user.userId||GUser.userId==resUserId)}

删除|

{else}

删除|

{/if}

{if x.likedCount} (${getPlayCount(x.likedCount)}){/if}

{/list}

110/120

◆◆

110/120

发送110/120

110/120

发送

110/120

新歌单

加载中...

{list beg..end as y}

{var x=xlist[y]}

{if x.highQuality}{/if}

${escape(cutStr(x.name,40))}

${x.trackCount}首

{if x.trackCount+size>10000}歌单已满{/if}

{/list}

说点什么

140

取消

歌曲同步完成

查看我的音乐

{if suggests.length == 0}

轻敲空格完成输入

{else}

选择最近@的人或直接输入

{/if}

{list suggests as suggest}

${suggest.nickname}

{/list}

{if receiver}

${receiver.nickname}×

{/if}

选择或输入好友昵称

{list users as user}

${user.nickname}

{/list}

{list users as user}

${user.nickname}

{/list}

分享给大家

私信分享

最多选择10位好友

140/140

取消

同时分享到：

{macro listArtists(artists)}

{list artists as art}

${art.name|mark}

{/list}

{/macro}

搜“${keyword|cutStr}” 相关用户 >

{list result.order as index}

{var lst=result[index]}

{if !!lst&&!!lst.length}

{if index=="songs"}

单曲

{list lst as song}

${song.name|mark}-${listArtists(song.artists)}

{/list}

{elseif index=="artists"}

歌手

{list lst as artist}

${artist.name|mark}

{/list}

{elseif index=="albums"}

专辑

{list lst as album}

${album.name|mark}{if album.artist}-${album.artist.name|mark}{/if}

{/list}

{elseif index=="playlists"}

歌单

{list lst as playlist}

${playlist.name|mark}

{/list}

{elseif index=="mvs"}

视频

{list lst as mv}

MV:${mv.name|mark}{if mv.artistName}-${mv.artistName|mark}{/if}

{/list}

{/if}

{/list}

${info|escape}

{if canChange}{/if}

${title}

{if !fail}

{else}

${fail}

{/if}

{if !fail}

{else}

${fail}

{/if}

知道了

上传节目

删除

取消

服务条款和隐私政策更新

服务条款

同意

{list buttons as item}

${item.text}

{/list}

微信

易信

QQ空间

LOFTER

message

知道了

新浪微博

腾讯微博

豆瓣

140

取消

${tip}

${oktext}

${cctext}

${tip}

${oktext}

{if showSongText}${songTxt}{/if}

${tip}

{if typeof(oktext) != 'undefined'}${oktext}{/if}

{if typeof(cctext) != 'undefined'}${cctext}{/if}

${tip}

{if typeof(oktext) != 'undefined'}${oktext}{/if}

{if typeof(cctext) != 'undefined'}${cctext}{/if}

该资源为公益歌曲

捐赠任意金额（2~4999元）即可无限畅听下载

新浪微博

微信

易信好友

QQ空间

LOFTER

豆瓣

悬赏1积分让大家来帮你补歌词，是否继续？

若30天内歌词未补充，积分将退还给您

继续求

取消

原手机号已停用

(使用其他方式验证)

原手机号仍能使用

(使用手机验证码验证)

{if hasWx}

点击使用微信验证

{/if}

{if hasQQ}

点击使用QQ验证

{/if}

请填写以下安全问题的答案

问题：

回答：

账号或密码错误

上一步

下一步

－请选择－

deepin15（64位）

ubuntu18.04（64位）

您的系统为Windows 10，推荐下载UWP版

下载UWP版本

继续下载PC版本

{list options as o}

${o|filter}

{/list}

使用云音乐客户端

即可无限下载高品质音乐

Mac版V1.9.1

PC版V1.9.1

已安装PC版

扫描下载手机版

该资源为付费内容，扫描下方二维码，使用最新的安卓或iPhone版本购买后即可畅享

{var title=""}

{if artists && artists.length}

{list artists as x}

{if x}

{var title = title + x.name}

{if x_index < x_length - 1}

{var title = title + " / "}

{/if}

{/list}

{/if}

${escape(title)}

{if artists && artists.length}

{list artists as x}

{if !!x}

{if !!x.id}

${mark(escape(x.name))}

{else}

${mark(escape(x.name))}

{/if}

{if x_index < x_length - 1} / {/if}

{/if}

{/list}

{/if}

${comJST('com-mv-artists', artists, clazz, mark, boxClazz)}

{if x.userType==4}${before}${after}{elseif x.authStatus==1}${before}${after}{elseif (x.expertTags && x.expertTags.length>0) || !isEmptyObject(x.experts)}${before}${after}{/if}

{if loginUserProfile.avatarDetail&&loginUserProfile.avatarDetail.identityIconUrl}

{/if}

{if x.avatarDetail && x.avatarDetail.identityIconUrl}

{/if}

1/2

{list plist as item}

{/list}

{list beg..end as y}

{var x=xlist[y]}

${y+1}

{if type=='rank'}

{if x.lastRank>=0}

{if y-x.lastRank>0}

${y-x.lastRank}

{elseif y-x.lastRank==0}

{else}

${x.lastRank-y}

{/if}

{else}

{/if}

{var alia=songAlia(x)}

${soil(x.name)}{if alia} - (${soil(alia)}){/if}

{if x.mvid>0}

{/if}

${dur2time(x.duration/1000)}{if x.ftype==2}{/if}

{if canDel}

删除

{/if}

${getArtistName(x.artists, '', '', false, false, true)}

{if type=='dayRcmd'}

{if x.album}${x.album.name}{/if}

不感兴趣

{else}

{if x.album}

${soil(x.album.name)}

{/if}

{/list}

歌曲标题

时长

歌手

{list beg..end as y}

{var x=xlist[y]}

${y+1}

{if type=='rank'}

{if x.lastRank>=0}

{if y-x.lastRank>0}

${y-x.lastRank}

{elseif y-x.lastRank==0}

{else}

${x.lastRank-y}

{/if}

{else}

{/if}

{if x.privilege.fee == 1}

{var alia=songAlia(x)}

${soil(x.name)}{if alia} - (${soil(alia)}){/if}

{if x.mvid>0}

{/if}

{else}

{var alia=songAlia(x)}

${soil(x.name)}{if alia} - (${soil(alia)}){/if}

{if x.mvid>0}

{/if}

${dur2time(x.duration/1000)}{if x.ftype==2}{/if}

{if canDel}

删除

{/if}

${getArtistName(x.artists, '', '/', false, true, true)}

{/list}

{list beg..end as y}

{var x=xlist[y]}

${y+1}

{var alia=songAlia(x)}

${soil(x.name)}{if alia} - (${soil(alia)}){/if}

{if x.mvid>0}

{/if}

${dur2time(x.duration/1000)}{if x.ftype==2}{/if}

{if canDel}

删除

{/if}

{if x.album}

{var transName = x.album.tns && x.album.tns.length > 0 ? x.album.tns[0] : ''}

${soil(x.album.name)}

{if transName}

- (${transName|escape})

{/if}

{/list}

标题

时长

歌手

{list beg..end as y}

{var x=xlist[y]}

{if y<3}

${y+1}

{if x.lastRank>=0}

{if y-x.lastRank>0}

${y-x.lastRank}

{elseif y-x.lastRank==0}

{else}

${x.lastRank-y}

{/if}

{else}

{/if}

{if x.album}{/if}

{var alia=songAlia(x)}

${soil(x.name)}{if alia} - (${soil(alia)}){/if}

{if x.mvid>0}

{/if}

{else}

${y+1}

{if x.lastRank>=0}

{if y-x.lastRank>0}

${y-x.lastRank}

{elseif y-x.lastRank==0}

{else}

${x.lastRank-y}

{/if}

{else}

{/if}

{var alia=songAlia(x)}

${soil(x.name)}{if alia} - (${soil(alia)}){/if}

{if x.mvid>0}

{/if}

${dur2time(x.duration/1000)}{if x.ftype==2}{/if}

{if canDel}

删除

{/if}

${getArtistName(x.artists, '', '', false, false, true)}

{/list}

{list beg..end as y}

{var x=xlist[y]}

${y+1}

{var alia=songAlia(x)}

${soil(x.name)}{if alia} - (${soil(alia)}){/if}

{if x.mvid>0}

{/if}

${dur2time(x.duration/1000)}{if x.ftype==2}{/if}

{if canDel}

删除

{/if}

${getArtistName(x.artists, '', '', false, false, true)}

{if x.album}

${soil(x.album.name)}

{/if}

{/list}

{list beg..end as y}

{var x=xlist[y]}

{if extData&&extData.limit&&y>=extData.limit}

{break}

{/if}

{var from=getFrom()}

${y+1}.

${x.name}

${getArtistName(x.artists, 's-fc8')}

下载

{if extData.showCount&&x.playCount}${x.playCount}次{/if}

{/list}

{if extData&&extData.limit&&xlist.length>extData.limit}

{/if}

{list beg..end as y}

{var x=xlist[y]}

${y+1}

{if type=='rank'}

{if x.lastRank>=0}

{if y-x.lastRank>0}

${y-x.lastRank}

{elseif y-x.lastRank==0}

{else}

${x.lastRank-y}

{/if}

{else}

{/if}

{var alia=songAlia(x)}

${soil(x.name)}{if alia} - (${soil(alia)}){/if}

{if x.mvid>0}

{/if}

{if canDel}

删除

{/if}

${getArtistName(x.artists, '', '', false, false, true)}

{if x.album}

${soil(x.album.name)}

{/if}

${formatTime(x.paidTime)}

{/list}

最多选择10位好友

发给：

内容：

{if nolyric}

纯音乐，无歌词

{if thirdCopy}

${copyFrom}

{/if}

{elseif !lines.length}

暂时没有歌词求歌词

{if thirdCopy}

${copyFrom}

{/if}

{else}

{list lines as l}

{if lines.length >limit && l_index==limit}

{/if}

${l.lyric}

{if lines.length > limit && l_index==lines.length-1}

展开

{/if}

{/list}

{/if}

{if !nolyric}

{if sgc}

上传歌词

{/if}

{if lrc&&lrc.lyric&&sfy}

翻译歌词

{/if}

{if !(lrc&&lrc.lyric)}歌曲{/if}报错

{if !nolyric}

{if lyricUser&&lyricUser.userid}

贡献滚动歌词：${lyricUser.nickname}

{/if}

{if lyricUser&&lyricUser.userid==0}

贡献滚动歌词：${lyricUser.nickname}

{/if}

{if transUser&&transUser.userid}

贡献翻译：${transUser.nickname}

{/if}

{if transUser&&transUser.userid==0}

贡献翻译：${transUser.nickname}

{/if}

{if lrc&&lrc.lyric&&qfy}

暂时没有翻译，求翻译

{/if}

{if degrade}

手机号登录

注　册

微信登录

QQ登录

微博登录

网易邮箱账号登录

同意

《服务条款》

《隐私政策》

《儿童隐私政策》

{else}

手机号登录

注　册

微信登录

QQ登录

微博登录

网易邮箱账号登录

同意

《服务条款》

《隐私政策》

《儿童隐私政策》

扫码登录

二维码已失效

点击刷新

使用网易云音乐APP 扫码登录

扫描成功

请在手机上确认登录

选择其他登录模式

{/if}

忘记密码？

短信登录

自动登录

获取验证码

密码登录

自动登录

登　录

< 其他登录方式

没有账号？免费注册 >

自动登录

忘记密码？

登　录

< 其他登录方式

{list suggests as item}

${item|escape}

{/list}

手机号：

密码：

密码不能包含空格

包含字母、数字、符号中至少两种

密码长度为8-20位

下一步

< 返回登录

云音乐将不再支持腾讯微博登录方式，请绑定手机号，以免后续无法使用该账号

你的手机号：+

为了安全，我们会给你发送短信验证码

验证码：

< 返回登录

云音乐将不再支持腾讯微博登录方式，请绑定手机号，以免后续无法使用该账号

你的手机号：+

为了安全，我们会给你发送短信验证码

输入要解绑的完整手机号，用于验证您的身份

下一步

< 返回登录

跳过 >

获取验证码

取一个昵称，让大家记住你

完成注册，开启云音乐

取一个昵称，让大家记住你

完成注册，开启云音乐

云音乐将不再支持腾讯微博登录方式，设置登录密码，以后可以使用手机号登录

你的手机号：+

设置密码后，可以直接用该手机号+密码登录

密码不能包含空格

包含字母、数字、符号中至少两种

密码长度为8-20位

跳过 >

如果你不是机器人输入验证码一定没问题！

账号或密码错误

确定

取消

+86

{list countries as x}

${x.zh}

+${x.code}

{/list}

由于你在非受信任的设备上登录，需要进行短信验证()

通过短信验证身份

Graph Traversal (Depth/Breadth First Search) - VisuAlgo

VisuAlgo.net

/dfsbfs

Graph Traversal (DFS/BFS)

Exploration Mode ▿

e-Lecture Mode

Profile

Training

Tests

Log Out

-7

1. DFS & BFS

2. Visualization

3. Specifying an Input Graph

4. Recap

4-1. Binary Tree Traversal - Source = Root

4-2. Binary Tree Traversal - Pre-/In-/Post-order

4-3. The Answer

4-4. Binary Tree Traversal - Acyclic

4-5. Issues in General Graph

5. DFS

5-1. Analogy

5-2. Trying All Options

5-3. Avoiding Cycle

5-4. Memorizing the Path

5-5. Hands-on Example

5-6. O(V+E) Time Complexity

5-7. O(V+E) at all times?

5-8. The Answer

6. BFS

6-1. Analogy

6-2. Try All, Avoid Cycle, Memorize Path

6-3. Hands-on Example

6-4. O(V+E) Time Complexity

7. Simple DFS/BFS Applications

7-1. Reachability Test

7-2. Print the Traversal Path

7-3. Identifying a Connected Component (CC)

7-4. Counting the Number of/Labeling the CCs

7-5. Wait, What is the Time Complexity?

7-6. The Answer

7-7. Detecting Cycle - Part 1

7-8. Detecting Cycle - Part 2

7-9. Hands-on Example (Detailed)

7-10. Topological Sort - Definition

7-11. Topological Sort

8. More Advanced DFS/BFS Applications

9. Bipartite Graph Checker

10. Find Cut Vertices & Bridges

11. Find Strongly Connected Components

12. 2-SAT Checker Algorithm

13. Which One is Better?

13-1. The Answer

14. Extras

14-1. Online Quiz

14-2. Online Judge Exercises

14-3. Discussion

✍

✘

Given a graph, we can use the O(V+E) DFS (Depth-First Search) or BFS (Breadth-First Search) algorithm to traverse the graph and explore the features/properties of the graph. Each algorithm has its own characteristics, features, and side-effects that we will explore in this visualization.This visualization is rich with a lot of DFS and BFS variants (all run in O(V+E)) such as: Topological Sort algorithm (both DFS and BFS/Kahn's algorithm version),Bipartite Graph Checker algorithm (both DFS and BFS version),Cut Vertex & Bridge finding algorithm,Strongly Connected Components (SCC) finding algorithms(both Kosaraju's and Tarjan's version), and2-SAT Checker algorithm.

Remarks: By default, we show e-Lecture Mode for first time (or non logged-in) visitor.

If you are an NUS student and a repeat visitor, please login.

→

When the chosen graph traversal algorithm is running, the animation will be shown here.We use vertex+edge color (the color scheme will be elaborated soon) and occasionally the extra text under the vertex (in red font) to highlight the changes.All graph traversal algorithms work on directed graphs (this is the default setting, where each edge has an arrowtip to indicate its direction) but the Bipartite Graph Check algorithm and the Cut Vertex & Bridge finding algorithm requires the undirected graphs (the conversion is done automatically by this visualization).

Pro-tip 1: Since you are not logged-in, you may be a first time visitor (or not an NUS student) who are not aware of the following keyboard shortcuts to navigate this e-Lecture mode: [PageDown]/[PageUp] to go to the next/previous slide, respectively, (and if the drop-down box is highlighted, you can also use [→ or ↓/← or ↑] to do the same),and [Esc] to toggle between this e-Lecture mode and exploration mode.

←

→

There are two different sources for specifying an input graph:Edit Graph: You can draw a new graph or edit an example unweighted directed graph as the input graph (to draw bidirectional edge (u, v), you can draw two directed edges u → v and v → u).Example Graphs: You can select from the list of our selected example graphs to get you started.

Pro-tip 2: We designed this visualization and this e-Lecture mode to look good on 1366x768 resolution or larger (typical modern laptop resolution in 2021). We recommend using Google Chrome to access VisuAlgo. Go to full screen mode (F11) to enjoy this setup. However, you can use zoom-in (Ctrl +) or zoom-out (Ctrl -) to calibrate this.

←

→

If you arrive at this e-Lecture without having first explore/master the concept of Binary Heap and especially Binary Search Tree, we suggest that you explore them first, as traversing a (Binary) Tree structure is much simpler than traversing a general graph.Quiz: Mini pre-requisite check. What are the Pre-/In-/Post-order traversal of the binary tree shown (root = vertex 0), left and right child are as drawn? Pre = 0, 2, 4, 3, 1 Post = 4, 3, 2, 1, 0 In = 1, 0, 3, 2, 4 Post = 1, 3, 4, 2, 0 Pre = 0, 1, 2, 3, 4 In = 4, 2, 3, 0, 1Submit

Pro-tip 3: Other than using the typical media UI at the bottom of the page, you can also control the animation playback using keyboard shortcuts (in Exploration Mode): Spacebar to play/pause/replay the animation, ←/→ to step the animation backwards/forwards, respectively, and -/+ to decrease/increase the animation speed, respectively.

←

→

We normally start from the most important vertex of a (binary) tree: The root vertex.If the given tree is not 'rooted' (see the example picture), we can pick any one vertex (for example, vertex 0 in the example picture) and designate it as the root. If we imagine that all edges are strings of similar length, then after "virtually pulling the designated root upwards" and let gravity pulls the rest downwards, we have a rooted directed (downwards) tree — see the next slide.PS: Technically, this transformation is done by running DFS(0) that we will explore soon.

←

→

In a binary tree, we only have up to two neighboring choices: From the current vertex, we can go to the left subtree first or go to the right subtree first. We also have option to visit the current vertex before or after visiting one of the (or both) subtree(s).This gives rise to the classics: pre-order (visit current vertex, visit its left subtree, visit its right subtree), in-order (left, current, right), and post-order (left, right, current) traversals.Discussion: Do you notice that there are three other possible binary tree traversal combinations? What are they?

←

→

The content of this interesting slide (the answer of the usually intriguing discussion point from the earlier slide) is hidden and only available for legitimate CS lecturer worldwide. This mechanism is used in the various flipped classrooms in NUS.

If you are really a CS lecturer (or an IT teacher) (outside of NUS) and are interested to know the answers, please drop an email to stevenhalim at gmail dot com (show your University staff profile/relevant proof to Steven) for Steven to manually activate this CS lecturer-only feature for you.

FAQ: This feature will NOT be given to anyone else who is not a CS lecturer.

←

→

In a binary tree, or in a tree structure in general, there is no (non-trivial) cycle involving 3 or more distinct vertices to worry about (we do not consider the trivial cycle involving bi-directional edges which can be taken care of easily — see three slides earlier).

←

→

In general graph, we do not have the notion of root vertex. Instead, we need to pick one distinguished vertex to be the starting point of the traversal, i.e. the source vertex s.We also have 0, 1, ..., k neighbors of a vertex instead of just ≤ 2. We may (or actually very likely) have cycle(s) in our general graph instead of acyclic tree, be it the trivial one like u → v → u or the non-trivial one like a → b → c → a.But fret not, graph traversal is an easy problem with two classic algorithms: DFS and BFS.

←

→

One of the most basic graph traversal algorithm is the O(V+E) Depth-First Search (DFS).DFS takes one input parameter: The source vertex s.DFS is one of the most fundamental graph algorithm, so please spend time to understand the key steps of this algorithm.

←

→

The closest analogy of the behavior of DFS is to imagine a maze with only one entrance and one exit. You are at the entrance and want to explore the maze to reach the exit. Obviously you cannot split yourself into more than one.Ask these reflective questions before continuing: What will you do if there are branching options in front of you? How to avoid going in cycle? How to mark your own path? Hint: You need a chalk, stones (or any other marker) and a (long) string.

←

→

As it name implies, DFS starts from a distinguished source vertex s and uses recursion (an implicit stack) to order the visitation sequence as deep as possible before backtracking.If DFS is at a vertex u and it has X neighbors, it will pick the first neighbor V1 (usually the vertex with the lowest vertex number), recursively explore all reachable vertices from vertex V1, and eventually backtrack to vertex u. DFS will then do the same for the other neighbors until it finishes exploring the last neighbor VX and its reachable vertices.This wordy explanation will be clearer with DFS animation later.

←

→

If the graph is cyclic, the previous 'try-all' strategy may lead DFS to run in cycle.So the basic form of DFS uses an array status[u] of size V vertices to decide between binary conditions: Whether vertex u has been visited or unvisited. Only if vertex u is still unvisited, then DFS can visit vertex u.When DFS runs out of option, it backtrack to previous vertex (p[u], see the next slide) as the recursion unwinds.

←

→

DFS uses another array p[u] of size V vertices to remember the parent/predecessor/previous of each vertex u along the DFS traversal path.The predecessor of the source vertex, i.e., p[s] is set to -1 to say that the source vertex has no predecessor (as the lowest vertex number is vertex 0).The sequence of vertices from a vertex u that is reachable from the source vertex s back to s forms the DFS spanning tree. We color these tree edges with red color.

←

→

For now, ignore the extra status[u] = explored in the displayed pseudocode and the presence of blue and grey edges in the visualization (to be explained soon).Without further ado, let's execute DFS(0) on the default example graph for this e-Lecture (CP3 Figure 4.1). Recap DFS ExampleThe basic version of DFS presented so far is already enough for most simple cases.

←

→

The time complexity of DFS is O(V+E) because:Each vertex is only visited once due to the fact that DFS will only recursively explore a vertex u if status[u] = unvisited — O(V)Every time a vertex is visited, all its k neighbors are explored and therefore after all vertices are visited, we have examined all E edges — (O(E) as the total number of neighbors of each vertex equals to E).

←

→

The O(V+E) time complexity of DFS only achievable if we can visit all k neighboring vertices of a vertex in O(k) time.Quiz: Which underlying graph data structure support that operation? Adjacency Matrix Edge List Adjacency ListSubmit Discussion: Why?

←

→

FAQ: This feature will NOT be given to anyone else who is not a CS lecturer.

←

→

Another basic graph traversal algorithm is the O(V+E) Breadth-First Search (BFS).As with DFS, BFS also takes one input parameter: The source vertex s.Both DFS and BFS have their own strengths and weaknesses. It is important to learn both and apply the correct graph traversal algorithm for the correct situation.

←

→

Imagine a still body of water and then you throw a stone into it. The first location where the stone hits the water surface is the position of the source vertex and the subsequent ripple effect across the water surface is like the BFS traversal pattern.

←

→

BFS is very similar with DFS that have been discussed earlier, but with some differences.BFS starts from a source vertex s but it uses a queue to order the visitation sequence as breadth as possible before going deeper.BFS also uses a Boolean array of size V vertices to distinguish between two states: visited and unvisited vertices (we will not use BFS to detect back edge(s) as with DFS).In this visualization, we also show that starting from the same source vertex s in an unweighted graph, BFS spanning tree of the graph equals to its SSSP spanning tree.

←

→

Without further ado, let's execute BFS(5) on the default example graph for this e-Lecture (CP3 Figure 4.3). Recap BFS Example.Notice the Breadth-first exploration due to the usage of FIFO data structure: Queue?

←

→

The time complexity of BFS is O(V+E) because:Each vertex is only visited once as it can only enter the queue once — O(V)Every time a vertex is dequeued from the queue, all its k neighbors are explored and therefore after all vertices are visited, we have examined all E edges — (O(E) as the total number of neighbors of each vertex equals to E).As with DFS, this O(V+E) time complexity is only possible if we use Adjacency List graph data structure — same reason as with DFS analysis.

←

→

So far, we can use DFS/BFS to solve a few graph traversal problem variants:Reachability test,Actually printing the traversal path,Identifying/Counting/Labeling Connected Components (CCs) of undirected graphs,Detecting if a graph is cyclic,Topological Sort (only on DAGs),For most data structures and algorithms courses, the applications of DFS/BFS are up to these few basic ones only, although DFS/BFS can do much more...

←

→

If you are asked to test whether a vertex s and a (different) vertex t in a graph are reachable, i.e., connected directly (via a direct edge) or indirectly (via a simple, non cyclic, path), you can call the O(V+E) DFS(s) (or BFS(s)) and check if status[t] = visited.Example 1: s = 0 and t = 4, run DFS(0) and notice that status[4] = visited.Example 2: s = 0 and t = 7, run DFS(0) and notice that status[7] = unvisited.

←

→

Remember that we set p[v] = u every time we manage to extend DFS/BFS traversal from vertex u to vertex v — a tree edge in the DFS/BFS spanning tree. Thus, we can use following simple recursive function to print out the path stored in array p. Possible follow-up discussion: Can you write this in iterative form? (trivial)method backtrack(u) if (u == -1) stop backtrack(p[u]); output vertex uTo print out the path from a source vertex s to a target vertex t in a graph, you can call O(V+E) DFS(s) (or BFS(s)) and then O(V) backtrack(t). Example: s = 0 and t = 4, you can call DFS(0) and then backtrack(4). Elaborate

←

→

We can enumerate all vertices that are reachable from a vertex s in an undirected graph (as the example graph shown above) by simply calling O(V+E) DFS(s) (or BFS(s)) and enumerate all vertex v that has status[v] = visited.Example: s = 0, run DFS(0) and notice that status[{0,1,2,3,4}] = visited so they are all reachable vertices from vertex 0, i.e., they form one Connected Component (CC).

←

→

We can use the following pseudo-code to count the number of CCs:CC = 0for all u in V, set status[u] = unvisitedfor all u in V if (status[u] == unvisited) ++CC // we can use CC counter number as the CC label DFS(u) // or BFS(u), that will flag its members as visitedoutput CC // the answer is 3 for the example graph above, i.e.// CC 0 = {0,1,2,3,4}, CC 1 = {5}, CC 2 = {6,7,8}You can modify the DFS(u)/BFS(u) code a bit if you want to use it to label each CC with the identifier of that CC.

←

→

Quiz: What is the time complexity of Counting the Number of CCs algorithm? Calling O(V+E) DFS/BFS V times, so O(V*(V+E)) = O(V^2 + VE) Trick question, the answer is none of the above, it is O(_____) It is still O(V+E)Submit Discussion: Why?

←

→

FAQ: This feature will NOT be given to anyone else who is not a CS lecturer.

←

→

We can actually augment the basic DFS further to give more insights about the underlying graph.In this visualization, we use blue color to highlight back edge(s) of the DFS spanning tree. The presence of at least one back edge shows that the traversed graph (component) is cyclic while its absence shows that at least the component connected to the source vertex of the traversed graph is acyclic.

←

→

Back edge can be detected by modifying array status[u] to record three different states:unvisited: same as earlier, DFS has not reach vertex u before,explored: DFS has visited vertex u, but at least one neighbor of vertex u has not been visited yet (DFS will go depth-first to that neighbor first),visited: now stronger definition: all neighbors of vertex u have also been visited and DFS is about to backtrack from vertex u to vertex p[u].If DFS is now at vertex x and explore edge x → y and encounter status[y] = explored, we can declare x → y is a back edge (a cycle is found as we were previously at vertex y (hence status[y] = explored), go deep to neighbor of y and so on, but we are now at vertex x that is reachable from y but vertex x leads back to vertex y).

←

→

The edges in the graph that are not tree edge(s) nor back edge(s) are colored grey. They are called forward or cross edge(s) and currently have limited use (not elaborated).Now try DFS(0) on the example graph above with this new understanding, especially about the 3 possible status of a vertex (unvisited/normal black circle, explored/blue circle, visited/orange circle) and back edge. Edge 2 → 1 will be discovered as a back edge as it is part of cycle 1 → 3 → 2 → 1 (as vertex 2 is `explored' to vertex 1 which is currently `explored') (similarly with Edge 6 → 4 as part of cycle 4 → 5 → 7 → 6 → 4).Note that if edges 2 → 1 and 6 → 4 are reversed to 1 → 2 and 4 → 6, then the graph is correctly classified as acyclic as edge 3 → 2 and 4 → 6 go from `explored' to `fully visited'. If we only use binary states: `unvisited' vs `visited', we cannot distinguish these two cases.

←

→

There is another DFS (and also BFS) application that can be treated as 'simple': Performing Topological Sort(ing) of a Directed Acyclic Graph (DAG) — see example above.Topological sort of a DAG is a linear ordering of the DAG's vertices in which each vertex comes before all vertices to which it has outbound edges.Every DAG (can be checked with DFS earlier) has at least one but possibly more topological sorts/ordering.One of the main purpose of (at least one) topological sort of a DAG is for Dynamic Programming (DP) technique. For example, this topological sorting process is used internally in DP solution for SSSP on DAG.

←

→

We can use either the O(V+E) DFS or BFS to perform Topological Sort of a Directed Acyclic Graph (DAG).The DFS version requires just one additional line compared to the normal DFS and is basically the post-order traversal of the graph. Try Toposort (DFS) on the example DAG.The BFS version is based on the idea of vertices without incoming edge and is also called as Kahn's algorithm. Try Toposort (BFS/Kahn's) on the example DAG.

←

→

As of now, you have seen DFS/BFS and what it can solve (with just minor tweaks). There are a few more advanced applications that require more tweaks and we will let advanced students to explore them on their own:Bipartite Graph Checker (DFS and BFS variants),Finding Articulation Points (Cut Vertices) and Bridges of an Undirected Graph (DFS only),Finding Strongly Connected Components (SCCs) of a Directed Graph (Tarjan's and Kosaraju's algorithms), and2-SAT(isfiability) Checker algorithms.Advertisement: The details are written in Competitive Programming book.

←

→

We can use the O(V+E) DFS or BFS (they work similarly) to check if a given graph is a Bipartite Graph by giving alternating color (orange versus blue in this visualization) between neighboring vertices and report 'non bipartite' if we ends up assigning same color to two adjacent vertices or 'bipartite' if it is possible to do such '2-coloring' process. Try DFS_Checker or BFS_Checker on the example Bipartite Graph.Bipartite Graphs have useful applications in (Bipartite) Graph Matching problem.Note that Bipartite Graphs are usually only defined for undirected graphs so this visualization will convert directed input graphs into its undirected version automatically before continuing. This action is irreversible and you may have to redraw the directed input graph again for other purposes.

←

→

We can modify (but unfortunately, not trivially) the O(V+E) DFS algorithm into an algorithm to find Cut Vertices & Bridges of an Undirected Graph.A Cut Vertex, or an Articulation Point, is a vertex of an undirected graph which removal disconnects the graph. Similarly, a bridge is an edge of an undirected graph which removal disconnects the graph.Note that this algorithm for finding Cut Vertices & Bridges only works for undirected graphs so this visualization will convert directed input graphs into its undirected version automatically before continuing. This action is irreversible and you may have to redraw the directed input graph again for other purposes. You can try to Find Cut Vertices & Bridges on the example graph above.

←

→

We can modify (but unfortunately, not trivially) the O(V+E) DFS algorithm into an algorithm to find Strongly Connected Components (SCCs) of a Directed Graph G.An SCC of a directed graph G a is defined as a subgraph S of G such that for any two vertices u and v in S, vertex u can reach vertex v directly or via a path, and vertex v can also reach vertex u back directly or via a path.There are two known algorithms for finding SCCs of a Directed Graph: Kosaraju's and Tarjan's. Both of them are available in this visualization. Try Kosaraju's Algorithm and/or Tarjan's Algorithm on the example directed graph above.

←

→

We also have the 2-SAT Checker algorithm. Given a 2-Satisfiability (2-SAT) instance in the form of conjuction of clauses: (clause1) ^ (clause2) ^ ... ^ (clausen) and each clause is in form of disjunction of up to two variables (vara v varb), determine if we can assign True/False values to these variables so that the entire 2-SAT instance is evaluated to be true, i.e. satisfiable.It turns out that each clause (a v b) can be turned into four vertices a, not a, b, and not b with two edges: (not a → b) and (not b → a). Thus we have a Directed Graph. If there is at least one variable and its negation inside an SCC of such graph, we know that it is impossible to satisfy the 2-SAT instance.After such directed graph modeling, we can run an SCC finding algorithm (Kosaraju's or Tarjan's algorithm) to determine the satisfiability of the 2-SAT instance.

←

→

Quiz: Which Graph Traversal Algorithm is Better? It Depends on the Situation Both are Equally Good Always DFS Always BFSSubmit Discussion: Why?

←

→

FAQ: This feature will NOT be given to anyone else who is not a CS lecturer.

←

→

There are lots of things that we can still do with just DFS and/or BFS...

←

→

There are interesting questions about these two graph traversal algorithms: DFS+BFS and variants of graph traversal problems, please practice on Graph Traversal training module (no login is required, but short and of medium difficulty setting only).However, for registered users, you should login and then go to the Main Training Page to officially clear this module and such achievement will be recorded in your user account.

←

→

We also have a few programming problems that somewhat requires the usage of DFS and/or BFS: Kattis - reachableroads and Kattis - breakingbad.Try to solve them and then try the many more interesting twists/variants of this simple graph traversal problem and/or algorithm.You are allowed to use/modify our implementation code for DFS/BFS Algorithms:dfs_cc.cpp/bfs.cppdfs_cc.java/bfs.javadfs_cc.py/bfs.pydfs_cc.ml/bfs.ml

←

→

FAQ: This feature will NOT be given to anyone else who is not a CS lecturer.

You have reached the last slide. Return to 'Exploration Mode' to start exploring!

Note that if you notice any bug in this visualization or if you want to request for a new visualization feature, do not hesitate to drop an email to the project leader: Dr Steven Halim via his email address: stevenhalim at gmail dot com.

←

X Close

Please rotate your device to landscape mode for a better user experience

Please make the window wider for a better user experience

Visualisation Scale

Toggle V. Number for 0.5x

Edit Graph

Example Graphs

Depth-First Search

Breadth-First Search

Topological Sort

Bipartite Graph Check

Cut Vertex & Bridge

SCC Algorithms

2-SAT Checker

1.0x (Default)

0.5x (Minimal Details)

CP3 4.1

CP3 4.3

CP3 4.4 DAG

CP3 4.9

CP3 4.17 DAG

CP3 4.18 DAG, Bipartite

CP3 4.19 Bipartite

Large Graph

Large, Cycles

s =

DFS version

BFS version (Kahn's algorithm)

DFS version

BFS version

Kosaraju's Algorithm

Tarjan's Algorithm

Number of clauses =

Number of variables =

1.0x

About

Team

About✕

Initially conceived in 2011 by Associate Professor Steven Halim, VisuAlgo aimed to facilitate a deeper understanding of data structures and algorithms for his students by providing a self-paced, interactive learning platform.Featuring numerous advanced algorithms discussed in Dr. Steven Halim's book, 'Competitive Programming' — co-authored with Dr. Felix Halim and Dr. Suhendry Effendy — VisuAlgo remains the exclusive platform for visualizing and animating several of these complex algorithms even after a decade.While primarily designed for National University of Singapore (NUS) students enrolled in various data structure and algorithm courses (e.g., CS1010/equivalent, CS2040/equivalent (including IT5003), CS3230, CS3233, and CS4234), VisuAlgo also serves as a valuable resource for inquisitive minds worldwide, promoting online learning.Initially, VisuAlgo was not designed for small touch screens like smartphones, as intricate algorithm visualizations required substantial pixel space and click-and-drag interactions. For an optimal user experience, a minimum screen resolution of 1366x768 is recommended. However, since April 2022, a mobile (lite) version of VisuAlgo has been made available, making it possible to use a subset of VisuAlgo features on smartphone screens.VisuAlgo remains a work in progress, with the ongoing development of more complex visualizations. At present, the platform features 24 visualization modules.Equipped with a built-in question generator and answer verifier, VisuAlgo's "online quiz system" enables students to test their knowledge of basic data structures and algorithms. Questions are randomly generated based on specific rules, and students' answers are automatically graded upon submission to our grading server. As more CS instructors adopt this online quiz system worldwide, it could effectively eliminate manual basic data structure and algorithm questions from standard Computer Science exams in many universities. By assigning a small (but non-zero) weight to passing the online quiz, CS instructors can significantly enhance their students' mastery of these basic concepts, as they have access to an almost unlimited number of practice questions that can be instantly verified before taking the online quiz. Each VisuAlgo visualization module now includes its own online quiz component.VisuAlgo has been translated into three primary languages: English, Chinese, and Indonesian. Additionally, we have authored public notes about VisuAlgo in various languages, including Indonesian, Korean, Vietnamese, and Thai:

id,

kr,

vn,

th.

Team✕

Project Leader & Advisor (Jul 2011-present)

Associate Professor Steven Halim, School of Computing (SoC), National University of Singapore (NUS)

Dr Felix Halim, Senior Software Engineer, Google (Mountain View)

Undergraduate Student Researchers 1

CDTL TEG 1: Jul 2011-Apr 2012: Koh Zi Chun, Victor Loh Bo Huai

Final Year Project/UROP students 1

Jul 2012-Dec 2013: Phan Thi Quynh Trang, Peter Phandi, Albert Millardo Tjindradinata, Nguyen Hoang Duy

Jun 2013-Apr 2014 Rose Marie Tan Zhao Yun, Ivan Reinaldo

Undergraduate Student Researchers 2

CDTL TEG 2: May 2014-Jul 2014: Jonathan Irvin Gunawan, Nathan Azaria, Ian Leow Tze Wei, Nguyen Viet Dung, Nguyen Khac Tung, Steven Kester Yuwono, Cao Shengze, Mohan Jishnu

Final Year Project/UROP students 2

Jun 2014-Apr 2015: Erin Teo Yi Ling, Wang Zi

Jun 2016-Dec 2017: Truong Ngoc Khanh, John Kevin Tjahjadi, Gabriella Michelle, Muhammad Rais Fathin Mudzakir

Aug 2021-Apr 2023: Liu Guangyuan, Manas Vegi, Sha Long, Vuong Hoang Long, Ting Xiao, Lim Dewen Aloysius

Undergraduate Student Researchers 3

Optiver: Aug 2023-Oct 2023: Bui Hong Duc, Oleh Naver, Tay Ngan Lin

Final Year Project/UROP students 3

Aug 2023-Apr 2024: Xiong Jingya, Radian Krisno, Ng Wee Han

List of translators who have contributed ≥ 100 translations can be found at statistics page.

Acknowledgements

NUS CDTL gave Teaching Enhancement Grant to kickstart this project.For Academic Year 2023/24, a generous donation from Optiver will be used to further develop VisuAlgo.

VisuAlgo is generously offered at no cost to the global Computer Science community. If you appreciate VisuAlgo, we kindly request that you spread the word about its existence to fellow Computer Science students and instructors. You can share VisuAlgo through social media platforms (e.g., Facebook, YouTube, Instagram, TikTok, Twitter, etc), course webpages, blog reviews, emails, and more.Data Structures and Algorithms (DSA) students and instructors are welcome to use this website directly for their classes. If you capture screenshots or videos from this site, feel free to use them elsewhere, provided that you cite the URL of this website (https://visualgo.net) and/or the list of publications below as references. However, please refrain from downloading VisuAlgo's client-side files and hosting them on your website, as this constitutes plagiarism. At this time, we do not permit others to fork this project or create VisuAlgo variants. Personal use of an offline copy of the client-side VisuAlgo is acceptable.Please note that VisuAlgo's online quiz component has a substantial server-side element, and it is not easy to save server-side scripts and databases locally. Currently, the general public can access the online quiz system only through the 'training mode.' The 'test mode' offers a more controlled environment for using randomly generated questions and automatic verification in real examinations at NUS.List of Publications This work has been presented at the CLI Workshop at the ICPC World Finals 2012 (Poland, Warsaw) and at the IOI Conference at IOI 2012 (Sirmione-Montichiari, Italy). You can click this link to read our 2012 paper about this system (it was not yet called VisuAlgo back in 2012) and this link for the short update in 2015 (to link VisuAlgo name with the previous project).Bug Reports or Request for New Features VisuAlgo is not a finished project. Associate Professor Steven Halim is still actively improving VisuAlgo. If you are using VisuAlgo and spot a bug in any of our visualization page/online quiz tool or if you want to request for new features, please contact Associate Professor Steven Halim. His contact is the concatenation of his name and add gmail dot com.

Version 1.2 (Updated Fri, 18 Aug 2023).Since Fri, 18 Aug 2023, we no longer use Google Analytics. Thus, all cookies that we use now are solely for the operations of this website. The annoying cookie-consent popup is now turned off even for first-time visitors.Since Fri, 07 Jun 2023, thanks to a generous donation by Optiver, anyone in the world can self-create a VisuAlgo account to store a few customization settings (e.g., layout mode, default language, playback speed, etc).Additionally, for NUS students, by using a VisuAlgo account (a tuple of NUS official email address, student name as in the class roster, and a password that is encrypted on the server side — no other personal data is stored), you are giving a consent for your course lecturer to keep track of your e-lecture slides reading and online quiz training progresses that is needed to run the course smoothly. Your VisuAlgo account will also be needed for taking NUS official VisuAlgo Online Quizzes and thus passing your account credentials to another person to do the Online Quiz on your behalf constitutes an academic offense. Your user account will be purged after the conclusion of the course unless you choose to keep your account (OPT-IN). Access to the full VisuAlgo database (with encrypted passwords) is limited to Prof Halim himself.For other CS lecturers worldwide who have written to Steven, a VisuAlgo account (your (non-NUS) email address, you can use any display name, and encrypted password) is needed to distinguish your online credential versus the rest of the world. Your account will have CS lecturer specific features, namely the ability to see the hidden slides that contain (interesting) answers to the questions presented in the preceding slides before the hidden slides. You can also access Hard setting of the VisuAlgo Online Quizzes. You can freely use the material to enhance your data structures and algorithm classes. Note that there can be other CS lecturer specific features in the future.For anyone with VisuAlgo account, you can remove your own account by yourself should you wish to no longer be associated with VisuAlgo tool.

Follow

比特派app下载2023版本|dfsdfs

比特派app下载2023版本|dfsdfs

DFS(小白式超详细讲解以及代码讲解)_dfs()这个代码怎么解释-CSDN博客

DFS算法介绍 - 知乎

DFS和BFS的算法实现(java) - 知乎

关于DFS和BFS算法——Python的代码实现和讲解。_dfs算法python代码-CSDN博客

DFS（环球免税店）_百度百科

[算法系列]搞懂DFS(1)——经典例题(数独游戏, 部分和, 水洼数目)图文详解 - 知乎

DFS----深度优先搜索与记忆化数组例题分析_深度优先搜索和记忆化搜索-CSDN博客

DFS 命名空间概述 | Microsoft Learn

DFSDFS - CC - 单曲 - 网易云音乐

Graph Traversal (Depth/Breadth First Search) - VisuAlgo

最近的新闻

您可能喜欢的文章

比特派钱包安全下载|dbx

imToken苹果下载|dstt

比特派转错地址了怎么办

比特派二维码怎么找

bitpie比特派转不了账怎么办

比特派扫码被盗怎么办啊

比特派被攻击了怎么办啊