算法十：DFS深度优先搜索（DFS子序列问题、迷宫问题、全排列）

最新推荐文章于 2024-09-28 23:00:16 发布
最新推荐文章于 2024-09-28 23:00:16 发布
阅读量685 收藏 7
点赞数 4
分类专栏： 算法和数据结构 文章标签： 算法 dfs 程序人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44631615/article/details/112283666
版权
本文深入探讨深度优先搜索算法，包括其原理、DFS在背包问题、子序列问题及迷宫问题中的应用，并提供优化版本的代码示例。理解DFS如何选择路径，以及在实际问题中的灵活运用和性能提升技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

深度优先搜索概述

深度优先搜索和广度优先搜索一样，都是对图进行搜索的算法，目的也都是从起点开始搜索直到到达指定顶点（终点）。深度优先搜索会沿着一条路径不断往下搜索直到不能再继续为止，然后再折返，开始搜索下一条候补路径。

DFS思想

A为起点，G为终点。一开始我们在起点A上。
在这里插入图片描述
将可以从A直达的三个顶点B、C、D设为下一步的候补顶点。
在这里插入图片描述
从候补顶点中选出一个顶点。优先选择最新成为候补的点，如果几个顶点同时成为候补，那么可以从中随意选择一个。
在这里插入图片描述
注：此处，候补顶点是用“后入先出”（LIFO）的方式来管理的，因此可以使用“栈”这个数据结构。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
到达终点G，搜索结束。
在这里插入图片描述
深度优先搜索的特征为沿着一条路径不断往下，进行深度搜索。虽然广度优先搜索和深度优先搜索在搜索顺序上有很大的差异，但是在操作步骤上却只有一点不同，那就是选择哪一个候补顶点作为下一个顶点的基准不同。

广度优先搜索选择的是最早成为候补的顶点，因为顶点离起点越近就越早成为候补，所以会从离起点近的地方开始按顺序搜索；而深度优先搜索选择的则是最新成为候补的顶点，所以会一路往下，沿着新发现的路径不断深入搜索。

背包问题

题目描述

现有n件物品，重量分别为w[0]，w[1]，…w[n-1]，价值为c[i]，现需要选出若干件物品放入一个容量为V的背包中，使得在选入背包的物品总重量不超过容量V的前提下，让背包中物品的价值之和最大，求最大价值（1 <= n <= 20）

思路：

这就相当于迷宫问题，当物品总重量超过V，则到达死胡同，而岔道口就是选或不选这个物品

示例代码如下：

#include<cstdio>

const int maxn = 30;

int n, V, maxValue = 0;		//物品件数n,背包容量V 
int w[maxn], c[maxn];		//w[i]每件物品的重量,c[i]为每件物品的价值 

void DFS(int index, int sumW, int sumC)
{
	if(index == n)
	{
		if(sumW <= V && sumC > maxValue)
		{
			maxValue = sumC;		//不超过背包容量时更新最大价值maxValue 
		}
		return;
	}
	
	DFS(index + 1, sumW, sumC);
	DFS(index + 1, sumW + w[index], sumC + c[index]);
} 

int main()
{
	scanf("%d%d", &n, &V);
	for(int i = 0; i < n; i++)
	{
		scanf("%d", &w[i]);
	}
	for(int i = 0; i < n; i++)
	{
		scanf("%d", &c[i]);
	}
	
	DFS(0, 0, 0);
	printf("%d\n", maxValue);
	return 0;
}

样例运行结果：
在这里插入图片描述
优化版代码：

#include<cstdio>

const int maxn = 30;

int n, V, maxValue = 0;		//物品件数n,背包容量V 
int ans = 0;
int w[maxn], c[maxn];		//w[i]每件物品的重量,c[i]为每件物品的价值 

void DFS(int index, int sumW, int sumC)
{
	if(index == n)
	{
		if(sumW <= V && sumC > maxValue)
		{
			maxValue = sumC;		//不超过背包容量时更新最大价值maxValue 
			ans = maxValue;
		}
		return;
	}
	
	DFS(index + 1, sumW, sumC);
	
	if(sumW + w[index] <= V)
	{
		if(sumC + c[index] > ans)
		{
			ans = sumC + c[index];
		}
		DFS(index + 1, sumW + w[index], sumC + c[index]);
	 } 
	
} 

int main()
{
	scanf("%d%d", &n, &V);
	for(int i = 0; i < n; i++)
	{
		scanf("%d", &w[i]);
	}
	for(int i = 0; i < n; i++)
	{
		scanf("%d", &c[i]);
	}
	
	DFS(0, 0, 0);
	printf("%d\n", maxValue);
	return 0;
}

上面优化的代码在于，只有当加入的第index件物品后背包未超重，才能进入岔路，否则就不走该岔路。这样做可以节省计算量

DFS子序列问题

题目描述

给定N个整数（可能有负数），从中选择K个数，使得这K个数之和恰好等于一个给定的整数X；如果有多种方案，选择它们中元素平方和最大的一个。数据保证这样的方案唯一。例如，从4个整数（2，3，3，4}中选择2个数，使它们的和为6，显然有两种方案{2，4}与{3，3}，其中平方和最大的方案为{2，4}。

思路：
使用深度搜索遍历来实现，一般每次只有两种选择：
1、将当前数字放入已选序列
2、不将当前数字放入已选序列

注：若将当前数字放入已选序列，则当要执行不放入序列的时候，需要将当前数字去掉

详细C++代码如下：

#include<iostream>
#include<vector>
using namespace std;

const int maxn = 50;

int n, k, x, maxSumSqu = -1, A[maxn];

vector<int> temp, ans;		//存放最优方案的数组ans 

//sum是整数之和,sumSqu是整数平方和
//nowK是已选整数的个数 
//index是当前的序列号 
void DFS(int index, int nowK, int sum, int sumSqu)
{
	if(nowK == k && sum == x)
	{
		if(sumSqu > maxSumSqu)
		{
			maxSumSqu = sumSqu;
			ans = temp;
		}
		return;
	}
	
	if(index == n || nowK > k || sum > x)
		return;
		
	temp.push_back(A[index]);
	DFS(index + 1, nowK + 1, sum + A[index], sumSqu + A[index] * A[index]);
	temp.pop_back();
	
	DFS(index + 1, nowK, sum, sumSqu);
}

int main()
{
	int num;
	cin >> num;
	for(int i = 0; i < num; i++)
	{
		cin >> A[i];
	}
	cout << "please input 限定选择的K个数中的K, 要求数字的和x:";
	cin >> k >> x;
	n = num;
	
	DFS(0, 0, 0, 0); 
	int sum = 0;
	cout << "ans:";
	for(int i = 0; i < ans.size(); i++)
	{
		cout << ans[i] << " ";
		sum += ans[i];
	}
	
	cout << "\nsum:" << sum << endl;
	cout << "maxSumSqu:" << maxSumSqu << endl;
	return 0;
}

样例运行结果如下：
在这里插入图片描述

变式题

题目描述

假设N个整数中的每一个都可以被选择多次，那么选择K个数，使得K个数之和恰好为X。

思路：

这个问题只需要对上面的代码进行少量的修改即可。由于每个整数可以被选择多次，因此当选择了index号数时，不应当直接进入index + 1号进行处理，应当继续选择index号数，知道某个时刻决定不再选择index号数，就会通过"不选index号数"这条分支进入处理，即
DFS(index + 1, nowK, sum, sumSqu);

需要修改的代码为

DFS(index + 1, nowK + 1, sum + A[index], sumSqu + A[index] * A[index]);

改成

DFS(index, nowK + 1, sum + A[index], sumSqu + A[index] * A[index]);

完整C++代码如下：

#include<iostream>
#include<vector>
using namespace std;

const int maxn = 50;

int n, k, x, maxSumSqu = -1, A[maxn];

vector<int> temp, ans;		//存放最优方案的数组ans 

//sum是整数之和,sumSqu是整数平方和
//nowK是已选整数的个数 
//index是当前的序列号 
void DFS(int index, int nowK, int sum, int sumSqu)
{
	if(nowK == k && sum == x)
	{
		if(sumSqu > maxSumSqu)
		{
			maxSumSqu = sumSqu;
			ans = temp;
		}
		return;
	}
	
	if(index == n || nowK > k || sum > x)
		return;
		
	temp.push_back(A[index]);
	DFS(index, nowK + 1, sum + A[index], sumSqu + A[index] * A[index]);
	temp.pop_back();
	
	DFS(index + 1, nowK, sum, sumSqu);
}

int main()
{
	int num;
	cin >> num;
	for(int i = 0; i < num; i++)
	{
		cin >> A[i];
	}
	cout << "please input 限定选择的K个数中的K, 要求数字的和x:";
	cin >> k >> x;
	n = num;
	
	DFS(0, 0, 0, 0); 
	int sum = 0;
	cout << "ans:";
	for(int i = 0; i < ans.size(); i++)
	{
		cout << ans[i] << " ";
		sum += ans[i];
	}
	
	cout << "\nsum:" << sum << endl;
	cout << "maxSumSqu:" << maxSumSqu << endl;
	return 0;
}

样例运行结果如下：
在这里插入图片描述

迷宫问题

题目描述

在这里插入图片描述

解题思路

dfs函数中有三个关键参数：横坐标、纵坐标、到目前为止所走的步数
在这里插入图片描述
方向数组
在这里插入图片描述
在这里插入图片描述

C代码：

#include<stdio.h>

int n, m, p, q, min = 99999999;

int a[51][51], book[51][51];

void dfs(int x, int y, int step)
{
	/*右   下   左   上 
	*/ 
	int next[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
	
	int tx, ty, k;
	if(x == p && y == q)
	{
		if(step < min)
		{
			min = step;
		} 
	} 
	
	for(k = 0; k <= 3; k++)
	{
		tx = x + next[k][1];
		ty = y + next[k][0];
		
		if(tx < 1 || tx > n || ty < 1 || ty > m)
		{
			continue;
		}
		if(a[tx][ty] == 0 && book[tx][ty] == 0)
		{
			book[tx][ty] = 1;
			dfs(tx, ty, step + 1);
			book[tx][ty] = 0;
		}
	}
} 

int main()
{
	int i, j, startx, starty;
	
	scanf("%d %d", &n, &m);
	
	for(i = 1; i <= n; i++)
	{
		for(j = 1; j <= m; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}
	scanf("%d %d %d %d", &startx, &starty, &p, &q);
	
	book[startx][startx] = 1;
	dfs(startx, starty, 0);
	
	printf("%d", min);
	getchar();
	return 0;
}

完整C++代码如下：

#include<bits/stdc++.h>
using namespace std;

//n, m是迷宫的行列数，p,q是目标位置 
int n, m, p, q, minn = 999999;
int a[51][51], book[51][51];

void dfs(int x, int y, int step)
{
	//方向数组 
	int next[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
	
	int tx, ty, k;
	
	//判断是否达到目标位置 
	if(x == p && y == q)
	{
		if(step < minn)
		{
			minn = step;
		}
		return;
	}
	
	//枚举4种走法 
	for(k = 0; k <= 3; k++)
	{
		tx = x + next[k][0];
		ty = y + next[k][1];
		//判断是否越界 
		if(tx < 1 || tx > n || ty < 1 || ty > n)
		{
			continue;
		}
		
		if(a[tx][ty] == 0 && book[tx][ty] == 0)
		{
			book[tx][ty] = 1;
			dfs(tx, ty, step + 1);
			book[tx][ty] = 0;
		}
	}
}

int main()
{
	int i, j, startx, starty;
	
	cin >> n >> m;
	for(i = 1; i <= n; i++)
	{
		for(j = 1; j <= m; j++)
		{
			cin >> a[i][j];
		}
	} 
	//输入起点和终点 
	cin >> startx >> starty >> p >> q;
	book[startx][starty] = 1;
	dfs(startx, starty, 0);
	
	cout << minn << endl;	
	return 0;
}

样例运行结果：
在这里插入图片描述

完善版C++代码

#include<bits/stdc++.h>
using namespace std;

int m, n, p, q, minn = 99999999;
//a数组记录原始地图情况,book数组记录路径是否已被走过 
int a[100][100], book[100][100];
//二维数组不要用memset(book, 0, sizeof(book));

void dfs(int x, int y, int step)
{
	//方向数组(x, y)   右   下   左   上 
	int next[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
	
	int tx, ty, k; 
	
	if(x == p && y == q)
	{		
		//更新最小步数 
		if(step < minn)
		{
			minn = step;
		}
	}
	for(k = 0; k <= 3; k++)
	{
		tx = x + next[k][0];
		ty = y + next[k][1];
		
		//m表示行,n表示列 
		if(tx < 1 || tx > n || ty < 1 || ty > m)
		{
			continue;
		}
		//判断该点是否为障碍物或者已经走过了 
		if(a[tx][ty] == 0 && book[tx][ty] == 0)
		{
			book[tx][ty] = 1;
			dfs(tx, ty, step + 1);
			book[tx][ty] = 0;
		}
	}
	
}

int main()
{
	cin >> m >> n;
	for(int i = 1; i <= m; i++)
	{
		for(int j = 1; j <= n; j++)
		{
			cin >>a[i][j];
		}
	}
	
	int startx, starty;
	book[startx][starty] = 1;
	cin >> startx >> starty >> p >> q;
	dfs(startx, starty, 0); 
	cout << minn << endl;
	return 0; 
}

样例运行结果：
在这里插入图片描述

全排列问题

题目描述

在这里插入图片描述

解题思路：

dfs的演化过程：

首先建立第step个盒子的处理函数
在这里插入图片描述
（注释里很详细了，这里就不做过多说明了）
在这里插入图片描述
完整C++代码如下：

#include<iostream>
using namespace std;

int n;
int a[10];
int book[10];

void dfs(int step)
{
	int i;
	if(step == n + 1)
	{
		for(i = 1; i <= n; i++)
		{
			cout << a[i] << " ";
		}
		cout << "\n";
		return;
	}
	
	for(i = 1; i <= n; i++)
	{
		if(book[i] == 0)
		{
			a[step] = i;
			book[i] = 1;
			dfs(step + 1);
			book[i] = 0;
		}
	}
}

int main()
{
	cin >> n;
	dfs(1);
	return 0;
}

C代码如下：

#include<stdio.h>

int a[10], book[10], n;

void dfs(int step)
{
	int i;
	if(step == n + 1)
	{
		for(i = 1; i <= n; i++)
		{
			printf("%d ", a[i]);
		}
		printf("\n");
		return;
	}
	
	for(i = 1; i <= n; i++)
	{
		if(book[i] == 0)		//表示扑克牌在手上
		{
			a[step] = i;
			book[i] = 1;		//标记扑克牌不在手上 
			
			dfs(step + 1);
			book[i] = 0; 
		}
	}
	
} 

int main()
{
	scanf("%d", &n);
	dfs(1);
	return 0;
}

运行结果：
在这里插入图片描述

之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！

基于DFS深度优先搜索算法的迷宫路线搜索matlab仿真.包含程序操作录像,代码中文注释
10-14
3.内容： 基于DFS深度优先搜索算法的迷宫路线搜索matlab仿真。深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。这种算法会尽可能深的搜索树的分支，当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那...
C语言使用深度优先搜索算法解决迷宫问题(堆栈)
08-29
深度优先搜索（Depth-First Search，DFS）是一种常用的搜索算法，它可以解决迷宫问题。在迷宫问题中，我们需要从起点出发，找到到达终点的路径。C语言可以使用堆栈来实现深度优先搜索算法，以解决迷宫问题。 深度...
DFS深度优先搜索算法
zhangxing
05-07 776
DFS即深度优化搜索 eg: 现有根结点 root [3, 9, 20, null, null, 15, 17] 求二叉树距叶子节点最短路径 求二叉树的最大深度 构造二叉树数据结构 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int val) { this.val = val; } } 二叉树距叶子节点最短路径 private static.
深度优先搜索 DFS
zwycsu的专栏
11-12 2110
深度优先搜索 DFS正如算法名称那样，深度优先搜索所遵循的搜索策略是尽可能“深”地搜索图。在深度优先搜索中，对于最新发现的顶点，如果它还有以此为起点而未探测到的边，就沿此边继续汉下去。当结点v的所有边都己被探寻过，搜索将回溯到发现结点v有那条边的始结点。这一过程一直进行到已发现从源结点可达的所有结点为止。如果还存在未被发现的结点，则选择其中一个作为源结点并重复以上过程，整个进程反复进行直到所有
dfs序七个经典问题
weixin_30721077的博客
05-12 323
update-2018.07.23:　　原文问题五思路描述有误，已更正。 　参考自：《数据结构漫谈》-许昊然 dfs序是树在dfs先序遍历时的序列，将树形结构转化成序列问题处理。 dfs有一个很好的性质：一棵子树所在的位置处于一个连续区间中。 ps:deep[x]为x的深度，l[x]为dfs序中x的位置，r[x]为dfs序中x子树的结束位置 1.点修改，子树和查询 　　在dfs序中，子...
（DFS）深度优先搜索算法详解
202xxx的博客
09-13 3万+
背景 DFS 英文全称为（Depth First Search），中文简称深度优先搜索算法，其过程为沿着每一个可能的路径向下进行搜索，直到不能再深入为止，并且每一个节点只能访问一次。 算法的搜索遍历图的步骤 （1）首先找到初始节点A， （2）依此从A未被访问的邻接点出发，对图进行深度优先遍历 （3）若有节点未被访问，则回溯到该节点，继续进行深度优先遍历 （4）直到所有与顶点A路径想通的节点都被访问过一次 举个例子，在下方的无向连通图中，假设我们要从起始点A出发，使用深度优先搜索算法进行搜..
蓝桥杯C++算法题解集：深度优先搜索与递归剪枝技术的应用实例分析
最新发布
03-01
内容概要：本文档包含了多个基于深度优先搜索（DFS）算法解决的问题示例，涵盖范围广泛，包括排列组合、路径规划、迷宫求解以及一些特定条件下的优化问题。每个案例都展示了具体的代码实现方式和逻辑流程。例如，'...
【图计算算法‌】深度优先搜索（DFS）算法
大雨淅淅的博客
09-28 4356
深度优先搜索算法（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。该算法沿着树的深度遍历树的节点，尽可能深地搜索树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点，这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为新的源节点并重复以上过程，直到所有节点都被访问为止。
深度优先搜索算法—DFS
04-23
该代码是DFS算法的实现，讲解部分可以查看我的博客
深度优先搜索算法（DFS）
weixin_41636030的博客
10-24 1871
BFS java：用hashmap/hashset来去重 python:dict/set来去重 分治法 divide & conquer 将大规模问题拆分为若干个小规模同类型问题去处理 再把子问题分为更小的问题，直到最后子问题可以简单求解 最后将子问题的解合并就是原问题的解 通常用递归方法来解决 搜索 宽度优先搜索 深度优先搜索(DFS) = 回溯 遍历法：可用递归或迭代（非递归） 分治法：可用递归或迭代（非递归） 注：递归和非递归是算法的一种实现方式而不是算法 递归三要素： 1.
（dfs）（深度优先搜索算法）
2302_80364740的博客
01-23 6545
深度优先搜索。
深度优先搜索（DFS）算法
陆
01-08 602
深度优先搜索（Depth First Search, DFS），在选择DFS算法时，往往是需要“分身”，需要不断尝试要完成的事情的情况。 DFS算法对每一个可能的分支路径深入到不能再深入为止，且每个节点只能访问1次。它其实就是一个递归的过程，就像是一棵树的前序遍历。 比如：从图中某个定点v出发，访问此顶点，然后从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相通的顶点都被访问到。 ...
算法-深度优先搜索（dfs）
你是小新吗
04-29 232
深度优先算法（dfs） 概念：在进行某种查找的时候，当一个节点的下挂节点有多中场景时，西安选择一种场景往下走，下面节点依旧按照这种思路，如果到达末尾节点时任务满足结束条件，则返回上一节点执行其他场景，直到发现满足结束条件或者所有分支场景都覆盖一遍时结束查找。 使用的方式是递归，需要确认结束标识以及保证回退上一节点时内存数据不应该发生变更 题：9*9数独的计算 package com...
DFS深度优先搜索算法（适合初学者）
weixin_52206295的博客
02-19 5207
前言 本文旨在帮助小白熟悉DFS的基本流程和递归算法的理解，主要包括我们用回溯的思想对题目进行分析的过程，编写代码过程中递归函数语义以及参数的确定等一系列细节。 基本的概念 官方解释：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。 其实说白了就跟咱们闯关游戏一样，遇到分岔
深度优先算法DFS（Depth First Search）
Iamme
03-07 8031
不撞南墙不回头。
算法之DFS（深度优先搜索）
G925010178的博客
05-20 427
深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次 纪念今天520，找女朋友用深度优先搜索的都是好男人，广度优先搜索的都是渣渣男【捂脸】 一、具体步骤 1、从一个支点开始，选择一条分支 2、沿着分支一直走到无路可走 3、重新回到分支，选择另一条路，重复第二步 4、直到所有点全部遍历完成。 二、举例分析 例：从3出发，有多少路可以选择 3->1->2->5 3->
DFS (深度优先搜索) 算法详解 + 模板 + 例题，这一篇就够了
热门推荐
Layman的博客
04-10 15万+
俗称的“不撞南墙不回头算法”！！！在本篇文章中详细介绍了DFS算法的基本步骤，详解了包括，排列组合问题、n皇后问题、素数问题等DFS的基本例题，后续会不断补充例题！！！
解决迷宫问题的三种算法：BFS、DFS与启发式搜索
在探讨如何利用状态空间法解决走迷宫游戏问题时，首先需要明确几个关键概念：状态空间法、迷宫问题、以及BFS（广度优先搜索）、DFS（深度优先搜索）和启发式搜索。 状态空间法是一种在人工智能领域中常用的问题求解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值