dfs +回溯算法（入门题详解）

最新推荐文章于 2025-05-08 21:53:46 发布
原创 最新推荐文章于 2025-05-08 21:53:46 发布 · 591 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入解析深度优先搜索（DFS）算法，涵盖迷宫寻路、全排列问题、n皇后问题及凑数问题等经典应用案例，阐述参数设定、边界处理、状态标记等关键概念，适合初学者快速掌握。

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

dfs深搜！dfs递归使用，满足某种条件就return 退出或者回溯！不难的！

核心代码：
关于dfs参数问题，什么在变化，就把什么设置成参数。


```cpp
 void dfs()//参数用来表示状态  
    {  
        if(到达终点状态)  
        {  
            ...//根据题意添加  
            return;  
        }  
        if(越界或者是不合法状态)  
            return;  
        if(特殊状态)//剪枝
            return ;
        for(扩展方式)  
        {  
            if(扩展方式所达到状态合法)  
            {  
                修改操作;//根据题意来添加  
                标记；  
                dfs（）；  
                (还原标记)；  
                //是否还原标记根据题意  
                //如果加上（还原标记）就是 回溯法  
            }  
     
        }  
    }  


   为什么有的时候得要标记，因为这可以防止打转现象的发生，你可以想象如果没有标记，你在迷宫围绕着某条路径打转

  但有的时候需要标记却不需要还原标记，为何不需要还原标记，不还原的意义是防止下次递归时走到已走过的位置，还原是可   以让下次递归可以在经过原先递归走过的路径，当然不可能和原先一模一样的路径


```bash
不重复的全排列问题：

1

 #include<iostream>

#define Equ(a,b) ((fabs((a)-(b)))<(eps)) //等于
#define More(a,b) (((a)-(b))>(esp)) //大于
#define Less(a,b) (((a)-(b))<(-esp))//小于
#define MoreEqu(a,b) (((a)-(b))>(-esp))//大于等于
#define LessEqu(a,b) (((a)-(b))<(esp))//小于等于

#define  MAX( x, y )  ( ((x) > (y)) ? (x) : (y) )//
//使用了algorithm头文件就可以直接使用max函数；
#define  MIN( x, y )  ( ((x) < (y)) ? (x) : (y) )
#define ll long long
#define PI 3.1415926
#define eps 1e-8
#define Conn(x,y) x##y

using namespace std;

const int maxx=0x7f7f7f7f;//0x7f7f7f7f表示数据的无穷大

int visit[10];
int n;
int a[10];
int b[10];

void dfs(int i)
{
	if(i==n+1)
	{
		for(int j=1;j<=n;j++)
			cout<<a[j];
		cout<<endl;
		return;
	}
	else
	{
		for(int j=1;j<=n;j++)
		{
			if(!visit[j])
			{
				visit[j]=1;
				a[i]=b[j];
				dfs(i+1);
				visit[j]=0;
				a[i]=0;
			}
		}
	}
}

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++ )
	{
		cin>>b[i];
	}
	dfs(1);
	return 0;
}

走出迷宫
小明现在在玩一个游戏，游戏来到了教学关卡，迷宫是一个N*M的矩阵。 小明的起点在地图中用“S”来表示，终点用“E”来表示，障碍物用“#”来表示，空地用“.”来表示。 障碍物不能通过。小明如果现在在点（x，y）处，那么下一步只能走到相邻的四个格子中的某一个：（x+1，y），（x-1，y），（x，y+1），（x，y-1）； 小明想要知道，现在他能否从起点走到终点。

输入描述：
本题包含多组数据。每组数据先输入两个数字N,M接下来N行，每行M个字符，表示地图的状态。数据范围：2<=N,M<=500保证有一个起点S，同时保证有一个终点E.
输出描述：
每组数据输出一行，如果小明能够从起点走到终点，那么输出Yes，否则输出No

输入：
3 3
S…
…E
…
3 3
S##

##E
输出：
Yes
No
这题可以说是很简单的一题，属于看完题目就可以做下去的。
注意：三点就行
1 走过的地方进行标记，不然会跑不出来
2 限制最外一层范围 越界return
3 碰壁return

#include<iostream>

#define Equ(a,b) ((fabs((a)-(b)))<(eps)) //等于
#define More(a,b) (((a)-(b))>(esp)) //大于
#define Less(a,b) (((a)-(b))<(-esp))//小于
#define MoreEqu(a,b) (((a)-(b))>(-esp))//大于等于
#define LessEqu(a,b) (((a)-(b))<(esp))//小于等于

#define  MAX( x, y )  ( ((x) > (y)) ? (x) : (y) )//
//使用了algorithm头文件就可以直接使用max函数；
#define  MIN( x, y )  ( ((x) < (y)) ? (x) : (y) )
#define ll long long
#define PI 3.1415926
#define eps 1e-8
#define Conn(x,y) x##y

using namespace std;

const int maxx=0x7f7f7f7f;//0x7f7f7f7f表示数据的无穷大

int n,m;
int si,sj;
int flag=0;

char a[505][505];



void dfs( int i,int j) 
{
	if(i<1||j<1) return ;
	if(i>n||j>m) return;
	if(a[i][j]=='#') return ;
//	if(a[i][j]=='1') return;
//	if(a[i][j]=='.')
//	{
//		a[i][j]='1';
//	}
	
	if(a[i][j]=='E') 
	{
		flag=1;
		return ;
	}
	dfs(i,j+1);
	dfs(i+1,j);
	dfs(i-1,j);
	dfs(i,j-1);
}

int main()
{
	while(cin>>n>>m)
	{
		flag=0;
		for(int i=1;i<=n;i++) 
	{
		for(int j=1;j<=m;j++)
		{
			
			cin>>a[i][j];
			if(a[i][j]=='S') 
			{
				si=i;
				sj=j;
			}
		}
	}
	dfs(si,sj);
	if(flag==1) cout<<"YES";
	else cout<<"NO";
	}
	
	return 0;
}

4行4列的皇后问题：
每两个皇后不能在，一行一竖一斜线上。
主要看put（）回溯递归函数


```cpp
#include<iostream>
#include<cmath>

#define Equ(a,b) ((fabs((a)-(b)))<(eps)) //等于
#define More(a,b) (((a)-(b))>(esp)) //大于
#define Less(a,b) (((a)-(b))<(-esp))//小于
#define MoreEqu(a,b) (((a)-(b))>(-esp))//大于等于
#define LessEqu(a,b) (((a)-(b))<(esp))//小于等于

#define  MAX( x, y )  ( ((x) > (y)) ? (x) : (y) )//
//使用了algorithm头文件就可以直接使用max函数；
#define  MIN( x, y )  ( ((x) < (y)) ? (x) : (y) )
#define ll long long
#define PI 3.1415926
#define eps 1e-8
#define Conn(x,y) x##y

using namespace std;

const int maxx=0x7f7f7f7f;//0x7f7f7f7f表示数据的无穷大

int a[5];


void put(int index)//index表示第index个，或者第index行
{
	
	
	for(int i=1;i<=4;i++)//遍历一遍，所有情况都有.
	{
		int flag=1;
		a[index]=i;//设放在第index行 第i列
		for(int j=1;j<=index-1;j++)//j代表之前放好的皇后
		{
			if(a[index]==a[j]||abs(a[index]-a[j])==index-j)
			{//用现在马上要放的a[index]与之前放好的a[j]皇后比较，
			//同列 斜角 的话 就flag=0；
				flag=0;
				continue;
			}
		}
		if(flag)
		{
			if(index==4)
			{//显示出 一组可行的皇后位置
				for(int i=1;i<=4;i++)
				{
					cout<<i<<","<<a[i]<<endl;
				} 
				cout<<endl;
			}
			else
			put(index+1);
		}
	}
}

int main()
{
	put(1) ;
	return 0;
}






***2n皇后问题***
问题描述
给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。

输入格式
输入的第一行为一个整数n，表示棋盘的大小。
　　接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，如果一个整数为0，表示对应的位置不可以放皇后。

输出格式
输出一个整数，表示总共有多少种放法。

样例输入
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1

样例输出
2

样例输入
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1
样例输出
0

解题思路
首先我们要了解普通n皇后问题是怎样做的，dfs每一行，然后对每一列进行回溯标记，标记是用三个布尔数组进行标记，分别代表当前列是否被使用过，正斜线是否被使用过，反斜线是否被使用过。
然后我们再来看2n皇后问题，在原来n皇后的问题上就加入了一个黑皇后和白皇后不能同时放在同一个地方，那我们就可以有一个基本的思路了，就是先进行一次dfs把黑皇后先放，然后我们再进行一次dfs放白皇后，如果我们两次都放完了就代表当前的放置位置可行，然后我们进行回溯以便下种选择。当然在这途中要判断两种皇后不能放在同一个点上，我们可以在进行第一次dfs的时候就将该点置为0，然后回溯为1。
————————————————
版权声明：本文为优快云博主「埋没。」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/qq_43585641/article/details/104516501

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

int sum;
int n;
int a[10][10];
int posb[10]={0};
int posw[10]={0};//每一列的位置 

int checkb(int cur)
{
	for(int i=1;i<cur;i++)
	{
		if(posb[i]==posb[cur]||abs(cur-i)==abs(posb[cur]-posb[i]))
			return 0;
	}
	return 1;
}

int checkw(int cur)
{
	for(int i=1;i<cur;i++)
	{
		if(posw[i]==posw[cur]||abs(cur-i)==abs(posw[cur]-posw[i]))
			return 0;
	}
	return 1;
}

void dfs_w(int cur)
{
	if(cur==n+1)  
	{
		sum++;
	}
		for(int i=1;i<=n;i++)
		{
			if(posb[cur]==i) continue;
			if(a[cur][i]==0) continue;
			posw[cur]=i;
			if(checkw(cur))
			{
				dfs_w(cur+1);
			}
		}
}

void dfs_b(int cur)
{
	if(cur==n+1)  
	{
		dfs_w(1);
	}
	
		for(int i=1;i<=n;i++)
		{
			if(a[cur][i]==0) continue;
			posb[cur]=i;
			if(checkb(cur))
			{
				dfs_b(cur+1);
			}
		}
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		cin>>a[i][j];
	dfs_b(1);
	cout<<sum;
 	return 0;
}

凑数问题：
试题D：抽刀断水水更流，举杯销愁愁更愁 10’
描述
忧郁的JM，借酒消愁。略微喝醉的他，和下酒花生聊起了天。

JM：“你知道质数是什么吗？”

花生：“…”

JM：“质数是指在大于11的自然数中，除了11和它本身以外不再有其他因数的自然数。”

花生：“…”

JM：“现在我有一个质数集合{3, 5, 7, 11, 13, 19, 23, 29, 31, 37, 41, 53, 59, 61, 67, 71, 97, 101, 127, 197, 211, 431}3,5,7,11,13,19,23,29,31,37,41,53,59,61,67,71,97,101,127,197,211,431，你可以从中挑出任意多个(0-12个)不同的数出来构成一个新数（取出数的和）”

JM：“构成的新数从小到大依次为：0, 3, 5, 7, 8, 10, 11, 12, 13…，0,3,5,7,8,10,11,12,13…，你知道[0, 1694][0,1694]中有多少个数是没法构成的吗？”
花生：”…“

JM：“例如：1，2，4…1，2，4…均是不能够从质数集合中挑数构成”

你来帮帮花生吧~

#include<iostream>
using namespace std;
int a[22]={3,5,7,11,13,19,23,29,31,37,41,53,59,61,67,71,97,101,127,197,211,431};
int b[1695]={0};
void dfs_zhi(int sum,int c,int i)
{
	b[sum]=1;
	if(c==12) return;
	if(i==22) return ;
	dfs_zhi(sum,c,i+1);//不包含
	dfs_zhi(sum+a[i],c+1,i+1) ;
	
}

int main()
{
	dfs_zhi(0,0,0);
	int ans=0;
	for(int i=0;i<1695;i++  )
	{
		if(!b[i])  ans++;
	}
	cout<<ans;
	
 	return 0;
}
double__apple
关注
2n皇后问题
wolfGuiDao的博客
10-11 1333
2n皇后问题 问题描述： 给定一个n*n的棋盘，棋盘中的有些位置不能放皇后，有些位置可以放皇后，现规定任意两个黑皇后不能在同一行，同一列，同一正反对角线，任意两个白皇后不能在同一行，同一列，同一正反对角线，问共有多少种放法 输入： 第一行输入n，表示棋盘大小； 第二行给棋盘赋值，1代表该位置可以放皇后，0表示该位置不可以放皇后； 输出： 输出共有多少种放置放法； #define _CRT_SECU...
Java实现回溯算法入门（排列+组合+子集）
小朱小朱绝不认输的博客
10-27 8829
回溯是递归的副产品，只要有递归就会有回溯，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都是用了递归。 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况： 找到一个可能存在的正确的答案； 在尝试了所有可能的分步方法后宣告该问题没有答案。 回
深度优先搜索（dfs）——回溯法
WuYiCheng666的博客
05-08 195
回溯法是一种通过试错来寻找所有或部分解的算法，也是深度优先搜索的一种。它通过逐步构建候选解，并在确定当前路径无法得到有效解时进行回溯，尝试其他可能性。回溯法通过系统性地遍历解空间，适用于组合、排列、子集等经典问题，是解决NP难问题的有效策略之一。在搜索算法中，dfs是指利用递归函数方便的实现暴力枚举的算法。所谓深度优先，就是说每次都尝试向更深的节点走。通常为指数级（如O(n!生成数组的所有排列（无重复元素）
2N皇后问题
acm_JL的博客
03-09 3831
问题描述 　　给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。 输入格式 　　输入的第一行为一个整数n，表示棋盘的大小。 　　接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，
ACM算法设计-BFS(广度搜索)-DFS入门(深度搜索)详解.ppt
最新发布
06-25
ACM算法设计是计算机科学竞赛中一项重要技能，其中包括广度优先搜索（BFS）和深度优先搜索（DFS）两种基本的图搜索算法。本篇内容将对这两种算法进行详细解析。 首先，深度优先搜索（DFS）是一种用于遍历或搜索树或...
ACM算法设计-BFS-DFS详解_算法_dfs_ACM_zoouts_bfs_
10-01
在"ACM算法设计-BFS(广度搜索)-DFS入门(深度搜索)详解.ppt"这个文件中，你可能会学到如何使用这两种算法的详细步骤，包括它们的伪代码、实际示例和应用场景。文件可能还会包含相关的编程语言实现，如C++或Python，...
详解DFS（深度优先搜索）算法+模板+指数+排列+组合型枚举+带分数四道例题
m0_62662646的博客
01-16 5197
山上雪的算法之路
《C++dfs从入门到精通》
xv201319的博客
06-25 628
深度优先搜索（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。其核心思想是沿着树的深度遍历树的节点，尽可能深地搜索树的分支。当节点v的所有边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程持续到已发现从源节点可达的所有节点为止。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值