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

最新推荐文章于 2020-09-14 22:07:08 发布
最新推荐文章于 2020-09-14 22:07:08 发布
阅读量560 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/double_app_le/article/details/105207537
版权

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。
————————————————
版权声明：本文为CSDN博主「埋没。」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/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
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DFS+回溯
zhuxiaoqiang1hao的博客
07-07 186
回溯就是对一个问题的所有可能结果进行搜索的一种方法，通过深度优先遍历的思想来实现。本质上回溯算法就是一种遍历算法，它会搜索得到一个问题的所有解，时间复杂度很高。 对于所有可能的情况，我们一种一种的去尝试（一般按照顺序来枚举，这样保证每一个情况都能搜索到）如果是我们想要的结果就放到结果集中。另外，在满足某些条件的时候可以进行剪枝。一般都是将这种问题转换成一个树形结构来进行分析。既然是树形结构，就要知道 1.每个节点中是什么：可以根据节点中的值来判断是否要加index，来表示下一次从哪里开始遍历 2.每条路径上
DFS与回溯法
liuxingbusi的博客
12-10 6573
DFS与回溯法DFS排列数问题: 生成1~n的排列 思路: 穷举所有可能 在生成结果数组前把重复的去掉 python codeA = [None for i in range(10)] N = 3def dfs(cur): if cur == N: print(A[:N]) else: for i in range(1, N+1):
2n皇后问题
qq_43585641的博客
02-26 393
问题描述 给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。 输入格式 输入的第一行为一个整数n，表示棋盘的大小。 　　接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，如果一个整数为0...
2N皇后问题
acm_JL的博客
03-09 3774
问题描述 　　给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。 输入格式 　　输入的第一行为一个整数n，表示棋盘的大小。 　　接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，
回溯DFS法
qq_43265072的博客
09-14 654
1.抢占棋盘 在下棋过程中，如果白子或者黑子将对方全部围住，则所围区域中的棋子将更换颜色。用1表示黑子，0表示白子，给出如下实例： 1111 0101 1101 0010 因为第2行第3列的白子（0）和第三行第3列的白子（0）全被黑子包围，需要将这两个0变成1.结果变为： 1111 0111 1111 0010 为了简化问题，只需找出所有被黑子围住的白子。 输入描述： 单组输入。 第一行：n（n<=1000)，表示棋盘大小 接下来的n行输入n×n的0/1矩阵 输出描述： 输出转换之后的0/1矩阵
BFS与DFS算法详解：从入门到精通
"本文主要介绍了ACM算法设计中的两种经典搜索策略：BFS（广度优先搜索）和DFS（深度优先搜索），并结合迷宫问题进行了详细的解释和示例演示。" BFS（广度优先搜索）是一种用于遍历或搜索树或图的算法。它的基本思想...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值