全球变暖（dfs）

题目


 

麻了麻了，dfs杀我。

// 通过v数组来控制陆地所在的岛屿，搜索到第一个陆地时，其会遍历到该岛屿其他的所有陆地 
// 岛屿中只要有一个陆地块四周都是陆地块，那么其不会被淹没
// 看岛屿的第一个陆地块就可以判断其是否会被淹没 （因为深搜的过程会遍历每一个陆地块） 

#include<iostream> 
using namespace std;

const int N = 1e3 + 10;
int n;
char mp[N][N];
int v[N][N];   
int ans = 0;
int dx[4] = {0,0,-1,1};
int dy[4] = {1,-1,0,0};

void input() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			cin >> mp[i][j];
		}
	}
}

bool dfs(int x, int y) {   //返回true表示该陆地块所在的岛屿会被淹没 
	v[x][y] = 1;
	int cnt = 0;
	bool flag = true;  // 用来判断相邻的下一个陆地块是否四周都是陆地块 
	for (int i = 0; i < 4; i++) {
		int tx = x + dx[i];
		int ty = y + dy[i];
		if (tx <= 0 || tx > n || ty <= 0 || ty > n) continue;   //判断新点的合法性 
		if (mp[tx][ty] == '#') {  // 只管统计该陆地块四周的陆地块数量，而不管其是否被访问过 
			cnt++;
			if (!v[tx][ty]) {  // 能够保证不走回头路 
				flag &= dfs(tx, ty);
				// 不能回溯。岛屿的其他部分在接下来的循环中不能被访问 
			}
		}
	}
	if (cnt == 4) {
		return false;
	}
	return flag;
}

void deal() {
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			if (mp[i][j] == '#' && !v[i][j] && dfs(i, j)) {
				ans++;
			}
		}
	}
}


int main()
{
	input();
	deal();
	cout << ans;
	return 0; 
	
}

 

18天后，再来做这道题，不仅dfs完全理解了，也掌握了bfs的写法

 dfs写法

#include <bits/stdc++.h>
using namespace std;
// 只要有一个块四周都是陆地，那么该陆地就逃过计数 
const int N = 1e3 + 10;
int n, ans = 0;	
string ss;
char a[N][N];
int vis[N][N];
int dx[] = {-1,1,0,0};
int dy[] = {0,0,1,-1};

bool dfs(int x, int y) {
	vis[x][y] = 1;
	bool flag = false;
	int cnt = 0;
	for (int i = 0; i < 4; i++) {
		int tx = x + dx[i];
		int ty = y + dy[i];
		if (tx < 0 || tx > (n-1) || ty < 0 || ty > (n-1)) continue;
		if (a[tx][ty] == '#') {
			cnt++;
			if (!vis[tx][ty]) {  // 要想进一步往下搜，绝不能走回头路 
				flag = dfs(tx, ty);  // 返回true：不会被淹没
			}
		}
	}
	return cnt == 4 || flag;
}


int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> ss;
		for (int j = 0; j < n; j++) {
			a[i][j] = ss[j];	
		}
	}
	
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			if (a[i][j] == '#' && !vis[i][j]) {
				if (!dfs(i, j)) {
					ans++;
				}
			}
		}
	}
	cout << ans;
	
	return 0;
} 

bfs写法

 

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


const int N = 1e3 + 10;
int n, ans = 0;
char a[N][N];
int vis[N][N];
int dx[] = {0,0,1,-1};
int dy[] = {1,-1,0,0};
struct node {
	int x, y;
	node() {} 
	node(int x_, int y_) {
		x = x_;
		y = y_;
	}
};
queue<node> qq;

bool bfs(int x, int y) {
	// reset清空队列 
	while (!qq.empty()) {
		qq.pop();
	}	
	bool flag = false;
	qq.push(node(x, y));
	vis[x][y] = 1;
	while (!qq.empty()) {
		node t = qq.front();
		qq.pop();
		int cnt = 0;
		for (int i = 0; i < 4; i++) {
			int tx = t.x + dx[i];
			int ty = t.y + dy[i];
			if (tx < 0 || tx > (n-1) || ty < 0 || ty > (n-1)) continue;
			if (a[tx][ty] == '#') {
				cnt++;
				if (!vis[tx][ty]) {   // 避免重复入队 
					qq.push(node(tx, ty));
					vis[tx][ty] = 1;
				}
			}
		}
		if (cnt == 4) {   // 返回true：不会被淹没 
		//  return true;  要让所有结点都被搜完，不能直接return了，否则main函数里的ans会重复计数的
			flag = true;   
		}
	}
	return flag;
}



int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			cin >> a[i][j];
		}
	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			if (a[i][j] == '#' && !vis[i][j]) {
				if (!bfs(i, j)) {
					ans++;
				}
			}
		}
	}
	cout << ans;
	return 0;
}