BFS(3)搜索过程中的结果记录:P1141 01迷宫——最大染色区域/最大可走区域/最大联通块大小

最新推荐文章于 2023-04-04 13:45:25 发布

糖琴心

最新推荐文章于 2023-04-04 13:45:25 发布

阅读量334

点赞数 1

本文链接：https://blog.csdn.net/qq_35299223/article/details/102817920

版权

在这里插入图片描述

输入输出样例
输入 #1复制
2 2
01
10
1 1
2 2
输出 #1复制
4
4

总结目录

1 本题广搜思路，如何解决一开始遇到的问题
2 本题的剪枝方法

1 题意理解与思路

这题一开始要求能移动多少格子，我的理解一开始真的以为是算一个路径的长短。但是后来发现这不是题目的原意，题目的本意是要我们求一个能够走的最大的区域的大小（面积），只不过这个面积是用步数来衡量的。所以这个题目在重新理解之后，其本质就转换为了求一个联通面积的大小了。

一开始做这个题目的时候，我遇到的困难是：把它看成路程来算，那么每条路线不一样，不一样的起点面积就不一样，那么为了剪枝，每个过程的路线要记录下来，这个时候状态完全相同的定义是位置相同且步数相同，而这实现起来其实是很难的。

后来把它当成连通域来计算，那么BFS就比较好写了。计算连通域的大小只要用一个count来计算就行。这里是一个记录BFS总个数的题目，在搜索中需要对元素进行标记防止反复搜索（即将同一个位置两次压入队列），因此我整理了一个模板，其实在算法笔记上也有提过这个问题，可以回去翻来看看。模板的关键是，计数永远在队列q弹出后才计数，初始化为0；另外就是每次压入队列马上进行标记。

完成了这个模板后，基本上写这题的搜索就是if的条件怎么写了，这里path_ok就是判断是否越界+判断是否访问过+判断下一个和当前是否匹配，还是比较简单的。这样写完就能达到70%，如代码2所示。

int bfs(){
count=0;//计数初始化
node tmp;
q.push(tmp);
mark(tmp);//压入队列后就进行记录，压入多少次就记录多少次


while(!q.empty()){
	q.pop();
	count++;//弹出的时候进行记录
	for(....){
		if(满足搜索条件）{
			node tmp2;
			q.push(tmp2);
			mark(tmp2);//满足搜索条件，重新压入队列，压入后要进行记录标记
		}
	}
}

return count;

2 本题的剪枝方法

本题的剪枝在于同一个连通域内的连通域面积其实是一样的，因此搜索的时候没有必要反复搜索，我们只需要进行记录一下就可以了。那么关键就是我们要用什么方法进行记录？还有就是如何在搜索的过程中进行记录？

这一题中，剪枝的关键在于同一个连通域内的得数是一样的。一个题解的作者给出了一个比较好的方法。
在广度搜索的过程中，我们把所有队列遍历过的点引向一个索引，然后在搜索完得到答案后，把答案填到那个索引里面，那么所有遍历过的节点都能够访问到这个结果下次遍历的时候只要先查找，看看有没有已经存在答案就可以了；深搜其实也可以这么做，每次深搜一个点的时候，先指向一个索引，最后把结果返回那个索引也可以。

//参考模板
int d;//索引起始
int index[maxsize][maxsize];
int mem[maxsize];

int bfs(int x,int y){
	queue q;
	node tmp;
	q.push(tmp);
	
	while(!q.empty()){
		q.pop();
		for(....){
			if(...){
				node newpoint
				q.push(newpoint);
				f(newpoint,d);//把newpoint和索引d对应起来,关键！
				//例如，这里可以这么写
				// index[newpoint.x][newpoint.y]=d;//此时，index矩阵的newpoint坐标下记录下了对应的索引d！
			}
	}
return ...;
}

AC代码

#include<iostream>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#define maxsize 1005
char mat[maxsize][maxsize];//输入矩阵
int origin[100005][2];//输入起点
int mark[maxsize][maxsize];//记录搜索过的点，防止反复搜索
int memry[maxsize][maxsize];//记忆化搜索索引
int ans[1000005];//记忆化结果结果记录
int dir[][2] = { {0,-1},{0,1},{1,0},{-1,0} };
int n, m;
int d = 0;
using namespace std;

struct node {
	int row;
	int col;
	node(int r,int c):row(r),col(c){}
};

bool path_ok(int currow, int curcol, int nextrow, int nextcol) {
	if (nextrow >= 1 && nextrow <= n&&nextcol >= 1 && nextcol <= n&&mat[currow][curcol] != mat[nextrow][nextcol]) {
			return mark[nextrow][nextcol] == 0;//不越界,不同元素的情况下可以访问该点
	}
	else {
		return false;
	}
}

int bfs(int row, int col) {
	queue<node> q;
	node start(row, col);
	q.push(start);
	int count = 0;
	mark[row][col] = 1;
	memry[row][col] = d;

	while (!q.empty()) {
		node tmp = q.front();
		q.pop();
		count++;

		for (int i = 0; i < 4; i++) {
			int nextrow = tmp.row + dir[i][0];
			int nextcol = tmp.col + dir[i][1];
			if (path_ok(tmp.row, tmp.col, nextrow, nextcol)) {
				node NewNode(nextrow, nextcol);
				mark[nextrow][nextcol] = 1;//访问过记为1，没访问过记为0
				q.push(NewNode);
				memry[nextrow][nextcol] = d;
			}
		}
	}

	return count;
}

int main() {
	cin >> n >> m;
	for (int row = 1; row <= n; row++) {
		for (int col = 1; col <= n; col++) {
			cin >> mat[row][col];
		}
	}

	for (int i = 0; i < m; i++) {
		cin >> origin[i][0] >> origin[i][1];
	}

	memset(memry, -1, sizeof(memry));//记忆化搜索

	for (int i = 0; i < m; i++) {
		int r = origin[i][0];
		int c = origin[i][1];
		if (memry[r][c]==-1) {//首先判断是否可以得到结果
			d++;
			ans[d]=bfs(r, c);
			cout << ans[d]<<endl;
		}
		else {
			cout << ans[memry[r][c]] << endl;
		}
	}

	return 0;
}

代码（70% 3处TLE）

#include<iostream>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#define maxsize 1005
char mat[maxsize][maxsize];
int origin[100005][2];
int mark[maxsize][maxsize];
int dir[][2] = { {0,-1},{0,1},{1,0},{-1,0} };
int n, m;
using namespace std;

struct node {
	int row;
	int col;
	node(int r,int c):row(r),col(c){}
};

bool path_ok(int currow, int curcol, int nextrow, int nextcol) {
	if (nextrow >= 1 && nextrow <= n&&nextcol >= 1 && nextcol <= n&&mat[currow][curcol] != mat[nextrow][nextcol]) {
			return mark[nextrow][nextcol] == 0;//不越界,不同元素的情况下可以访问该点
	}
	else {
		return false;
	}
}

int bfs(int row, int col) {
	queue<node> q;
	node start(row, col);
	q.push(start);
	memset(mark, 0, sizeof(mark));
	int count = 0;
	mark[row][col] = 1;

	while (!q.empty()) {
		node tmp = q.front();
		q.pop();
		count++;

		for (int i = 0; i < 4; i++) {
			int nextrow = tmp.row + dir[i][0];
			int nextcol = tmp.col + dir[i][1];
			if (path_ok(tmp.row, tmp.col, nextrow, nextcol)) {
				node NewNode(nextrow, nextcol);
				mark[nextrow][nextcol] = 1;//访问过记为1，没访问过记为0
				q.push(NewNode);
				
			}
		}
	}

	return count;
}

int main() {
	cin >> n >> m;
	for (int row = 1; row <= n; row++) {
		for (int col = 1; col <= n; col++) {
			cin >> mat[row][col];
		}
	}

	for (int i = 0; i < m; i++) {
		cin >> origin[i][0] >> origin[i][1];
	}

	for (int i = 0; i < m; i++) {
		cout << bfs(origin[i][0], origin[i][1])<<endl;
	}

	return 0;
}

DFS代码

#include<iostream>
#include<cstring>
using namespace std;
#define maxsize 1005
char mat[maxsize][maxsize];
int mark[maxsize][maxsize];
int memry[maxsize][maxsize];
int origin[100005][2];//输入起点
int dir[][2] = { { 0,-1 },{ 0,1 },{ 1,0 },{ -1,0 } };
int ans[1000005];//记忆化结果结果记录
int total = 0;
int n, m;
int d;


bool path_ok(int currow, int curcol, int newrow, int newcol) {
	if (newrow >= 1 && newrow <= n&&newcol >= 1 && newcol <= n&&mark[newrow][newcol] != 1) {
		return mat[currow][curcol] != mat[newrow][newcol];//不越界不访问情况下不相等才返回true
	}
	else {
		return false;
	}
}

void dfs(int row, int col) {
	if (row<1 || row>n || col<1 || col>n || mark[row][col] == 1) {
		return;//越界或者已经访问过就返回
	}
	total++;
	mark[row][col] = 1;//标记为已经访问过,之后不再搜索该图
	memry[row][col] = d;
	for (int i = 0; i < 4; i++) {
		int newrow = row + dir[i][0];
		int newcol = col + dir[i][1];
		if (path_ok(row, col, newrow, newcol)) {
			dfs(newrow, newcol);//这题不需要回溯清理标记
		}
	}

}

int main() {
	cin >> n >> m;
	for (int row = 1; row <= n; row++) {
		for (int col = 1; col <= n; col++) {
			cin >> mat[row][col];
		}
	}

	for (int i = 0; i < m; i++) {
		cin >> origin[i][0] >> origin[i][1];
	}
	memset(memry, -1, sizeof(memry));

	for (int i = 0; i < m; i++) {
		int r = origin[i][0];
		int c = origin[i][1];
		if (memry[r][c] == -1) {//首先判断是否可以得到结果
			d++;
			total = 0;
			dfs(r, c);
			ans[d] = total;
			cout << ans[d] << endl;
		}
		else {
			cout << ans[memry[r][c]] << endl;
		}
	}
	return 0;
}

糖琴心

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
BFS(3)搜索过程中的结果记录:P1141 01迷宫——最大染色区域/最大可走区域/最大联通块大小

输入输出样例输入 #1复制2 201101 12 2输出 #1复制44总结目录1 本题广搜思路，如何解决一开始遇到的问题2 本题的剪枝方法代码（70% 3处TLE）#include<iostream>#include<queue>#include<map>#include<algorithm>#include&...
复制链接

扫一扫