[含泪总结] 1365: [蓝桥杯2018初赛]全球变暖(dfs+bfs)

最新推荐文章于 2024-08-03 18:12:04 发布

原创最新推荐文章于 2024-08-03 18:12:04 发布 · 718 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#dfs #数据结构

蓝桥杯专栏收录该内容

18 篇文章

订阅专栏

本文介绍了如何利用深度优先搜索（DFS）和回溯算法解决全球变暖导致的岛屿完全淹没问题。在给定的海域照片中，预测因海平面上升而被完全淹没的岛屿数量。通过示例代码详细解释了DFS和BFS两种方法，以及在解题过程中的关键策略和注意事项。同时，文章提供了相关算法的背景知识，包括回溯法的基本思想和步骤，以及深度优先搜索与广度优先搜索的区别。

1365: [蓝桥杯2018初赛]全球变暖

时间限制: 1 Sec  
内存限制: 256 MB

题目描述
你有一张某海域NxN像素的照片，".“表示海洋、”#"表示陆地，如下所示：
…
.##…
.##…
…##.
…####.
…###.
…
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。
具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
…
…
…
…
…#…
…
…
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
输入
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
输出
一个整数表示答案。
样例输入 Copy
7
…
.##…
.##…
…##.
…####.
…###.
…
样例输出 Copy
1

如果对深度优先搜索与回溯有疑惑的可以看这里，没有疑惑的童鞋直接跳过此段

回溯（英语：backtracking）
回溯法是暴力搜索法中的一种。
对于某些计算问题而言，回溯法是一种可以找出所有（或一部分）解的一般性算法，尤其适用于约束满足问题（在解决约束满足问题时，我们逐步构造更多的候选解，
并且在确定某一部分候选解不可能补全成正确解之后放弃继续搜索这个部分候选解本身及其可以拓展出的子候选解，转而测试其他的部分候选解）。
1、基本思想
在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。当探索到某一结点时，要先判断该结点是否包含问题的解，
如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。（其实回溯法就是对隐式图的深度优先搜索算法）。
若用回溯法求问题的所有解时，要回溯到根，且根结点的所有可行的子树都要已被搜索遍才结束。
而若使用回溯法求任一个解时，只要搜索到问题的一个解就可以结束。
2、用回溯法解题的一般步骤：
（1）针对所给问题，确定问题的解空间：
首先应明确定义问题的解空间，问题的解空间应至少包含问题的一个（最优）解。
（2）确定结点的扩展搜索规则
（3）以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。
‘’’
‘’’
其实回溯算法关键在于:不合适就退回上一步
然后通过约束条件, 减少时间复杂度.
‘’’
深度优先DFS
什么是DFS？
所谓的深度优先指的是从某个状态开始，不断地转移到下一个状态，直到不能继续转移为止，这时候返回前一步，转移到其他的状态，直到到达解状态。
emmm有亿点抽象，那…具体在这个迷宫问题上来看呢？
在迷宫问题上翻译一下深度优先的定义的话：就是说从某个格子出发，不断地往四周的格子走，如果考虑不走回头路的话，那么总会出现不能继续走的情况。这时候，退回到上一步，在上一步走其他的路，如果上一步没有其他的路可走了就再退回到上一步…不断重复这个过程，直到走到终点为止。
这就很直观了，就像一个人通过试错法来走迷宫的过程：先一路走到死路，然后回到前一步选另一条路，不断地试错，这样就遍历了所有能走的路。事实上也就是一种回溯法。
画成搜索树的话就是这样👇

这个搜索过程对应LIFO的栈结构：不断push新的状态入栈，不能继续时，pop出最后push的状态，push另一个状态。而众所周知，所有的栈操作和递归函数是等价的，所以DFS通常用递归来实现。
严格来讲，我这里由于采用了离开的时候才标记的策略，把状态修改给延后了。
如果按照到达时就标记的策略，应该把状态修改塞到每个if分支里。
也就是每个if分支都该是一个完整的
状态转移→递归调用→状态还原过程

回到正文
我们在思考的过程中会想到这样一种情况，一片陆地，被海域淹没成几块仅存的小陆地，幸存下来的陆地是初始时的高地，即上下左右四个方向都紧挨陆地
所以只要搜索初始的某个陆地连通块中是否存在高地，在查找连通块时，cnt_gd标记当前搜索的连通块中的高地数量，搜索完当前连通块后，检查cnt_gd数目是否为零，据此来判断是否存在高地

#include<bits/stdc++.h>
using namespace std;
int n,gd,ans=0;
bool value[1010][1010];
bool check(string str[],int x,int y){
	if(str[x-1][y]=='#'&&str[x+1][y]=='#'&&str[x][y-1]=='#'&&str[x][y+1]=='#'){
		return true;
	}
}
void dfs(string str[],int x,int y){
	if(!value[x][y-1]&&str[x][y-1]=='#'){
		value[x][y-1]=true;
		if(check(str,x,y-1)) gd++;
		dfs(str,x,y-1);
	}
	if(!value[x][y+1]&&str[x][y+1]=='#'){
		value[x][y+1]=true;
		if(check(str,x,y+1)) gd++;
		dfs(str,x,y+1);
	}
	if(!value[x-1][y]&&str[x-1][y]=='#'){
		value[x-1][y]=true;
		if(check(str,x-1,y)) gd++;
		dfs(str,x-1,y);
	}
	if(!value[x+1][y]&&str[x+1][y]=='#'){
		value[x+1][y]=true;
		if(check(str,x+1,y)) gd++;
		dfs(str,x+1,y);
	}
	
}
int main(){
	
	cin>>n;
	string str[n];
	for(int i=0;i<n;i++){
		cin>>str[i];
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(!value[i][j]&&str[i][j]=='#'){
				value[i][j]=true;
				gd=0;
				dfs(str,i,j);
				if(gd==0) ans++;
			}
		}
	}
	cout<<ans;
}

广度优先BFS
什么是BFS？
BFS和DFS很类似，区别只在于搜索的顺序不同：BFS总是先搜索距离初始状态近的状态。
也就是说，它是按照 开始状态→1次转移可以到达的所有状态→2次转移可以到达的所有状态→…… 这样的顺序进行搜索。
在迷宫的例子里，就是说我们按照走1步能到达的位置，走2步能到达的位置…这样的顺序逐一搜索，直到不再有能到达的位置。
想象我们拿着地图，画出一系列的“等高线”，先标距离为1的，再标距离为2的，直到地图上的每一个位置都被标上了要到达所需的步数。
画成搜索树的话就是这样👇

这个搜索过程对应 FIFO 的队列结构：enqueue加入一层的状态，再dequeue丢出最先加入的那一层状态。当然由于BFS依赖于“步数”的概念，所以有时也可以考虑直接利用循环来实现
不懂pair的童鞋可以参考一下，懂直接跳过
Pair容器
类模板：template <class T1, class T2> struct pair
参数：T1是第一个值的数据类型，T2是第二个值的数据类型。
功能：pair将一对值组合成一个值，这一对值可以具有不同的数据类型（T1和T2），两个值可以分别用pair的两个公有函数first和second访问。
具体用法：
//1.定义（构造）：
pair<int, double> p1; //使用默认构造函数
pair<int, double> p2(1, 2.4); //用给定值初始化
pair<int, double> p3(p2); //拷贝构造函数
//2.访问两个元素（通过first和second）：
pair<int, double> p1; //使用默认构造函数
p1.first = 1;
p1.second = 2.5;
cout << p1.first << ’ ’ << p1.second << endl;
//3.赋值operator = ：
//（1）利用make_pair：
pair<int, double> p1;
p1 = make_pair(1, 1.2);
//（2）变量间赋值：
pair<int, double> p1(1, 1.2);
pair<int, double> p2 = p1;
回到正文
bfs与上面思路一样，只不过上面用的是dfs

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

string mp[1001];
int cnt_gd;//标记每个连通块中高地的数目
int cnt=0;//被完全淹没的岛屿
int go[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
struct node{
	
};
void bfs(int x,int y){
	queue<pair<int,int> > q;//最后面两个尖括号需要用空格隔开
	q.push({x,y});
	mp[x][y]='2';
	while(!q.empty()){
		for(int i=0;i<4;i++){
			int now_x=q.front().first+go[i][0];
			int now_y=q.front().second+go[i][1];
			if(mp[now_x][now_y]=='1'||mp[now_x][now_y]=='#'){
				if(mp[now_x][now_y]=='1') cnt_gd++;
				mp[now_x][now_y]='2';//将陆地标记为2，对整个岛都进行标记，防止重复计算
				q.push({now_x,now_y});
			}
		}
		q.pop();
	}
}
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>mp[i];
	}

	//修改地图
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(i-1>=0&&j-1>=0&&i+1<=n-1&&j+1<=n-1&&mp[i-1][j]!='.'&&mp[i+1][j]!='.'&&mp[i][j-1]!='.'&&mp[i][j+1]!='.'){
				mp[i][j]='1';//标记高地为1
			}
		}
	}

	//查找连通块
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(mp[i][j]=='#'){
				cnt_gd=0;
				bfs(i,j);
				if(cnt_gd==0) cnt++;
			}
		}
	}

	cout<<cnt;
	return 0;
}