算法刷题day33

引言

这几天一直再写关于搜索的问题，我发现搜索不仅仅局限于网格中的那种搜索，还有状态的变换，也可以抽象成一个点，去找最小变换次数，这也是一种搜索，所以说还是得好好练啊，加油！

---

一、动态网格

标签：BFS

思路：这道题就是求多组连通块的数量的，除了输入输出要注意一下，另外每次查询连通块时要清空一下 $st$ 数组，并且这个函数的位置要在每次查找前清空一次即可。其余的就是模板了。

题目描述：

我们有一个 R 行 C 列的矩形网格，其中每个方格内的数字都是 0 或 1。

我们将在网格上执行 N 个操作，每个操作都是以下之一：

操作 M：将网格的一个单元格中的数字更改为 0 或 1。
操作 Q：确定 1 的不同连通区域的数量。 1 的连通区域是指矩阵内全部为 1 的连通的单元格的子集，在子集区域内通过沿着共享
边缘在单元格之间行进，可以从该区域中的任何单元格到达该区域中的任何其他单元格。

输入格式
第一行包含整数 T，表示共有 T 组测试数据。

每组数据第一行包含两个整数 R 和 C，表示矩形网格的行数和列数。

接下来 R 行，每行包含一个长度为 C 的由 1 和 0 构成的字符串，表示矩阵网格的初始状态。

接下来一行，包含整数 N，表示操作数量。

接下来 N 行，每行包含一个操作指令，操作指令共两种，如下所示：

M x y z，表示 M 指令，具体含义为将第 x 行第 y 列的方格内的值变为 z。
Q，表示 Q 指令，表示进行一次询问。输出格式对于每组测试数据，第一行输出 Case #x:，其中 x 为组别编号（从 1
 开始）。

接下来 Q 行，每行输出一个询问的结果。

数据范围
1≤T≤10,1≤R,C≤100,0≤x<R,0≤y<C,0≤z≤1,1≤N≤1000
输入样例：
1
4 4
0101
0010
0100
1111
7
Q
M 0 2 1
Q
M 2 2 0
Q
M 2 1 0
Q
输出样例：
Case #1:
4
2
2
2

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 110;

int T, q;
int n, m;
char g[N][N];
bool st[N][N];

int dir[4][2] = {0,1,0,-1,1,0,-1,0};

void bfs(PII S)
{
	st[S.x][S.y] = true;
	
	queue<PII> q; q.push(S);
	while(q.size())
	{
		auto t = q.front(); q.pop();
		
		for(int i = 0; i < 4; ++i)
		{
			int x = t.x + dir[i][0];
			int y = t.y + dir[i][1];
			if(x < 0 || x >= n || y < 0 || y >= m) continue;
			if(st[x][y] || g[x][y] == '0') continue;
			
			st[x][y] = true; q.push({x,y});
		}
	}
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> T;
	for(int C = 1; C <= T; ++C)
	{
		cin >> n >> m;
		for(int i = 0; i < n; ++i) cin >> g[i];
		cin >> q;
		printf("Case #%d:\n",C);
		while(q--)
		{
			string op; cin >> op;
			if(op == "Q")
			{
				int res = 0;
				memset(st, 0, sizeof st);
				for(int i = 0; i < n; ++i)
				{
					for(int j = 0; j < m; ++j)
					{
						if(!st[i][j] && g[i][j] == '1')
						{
							bfs({i,j});
							res++;
						}
					}
				}
				printf("%d\n", res);
			}
			else 
			{
				int x, y, z; cin >> x >> y >> z;
				g[x][y] = z + '0';
			}
		}
	}
	
	return 0;
}

---

二、画图

标签：BFS

思路：这道题画线段和填充字符其实都不难，循环和 $BFS$ 就可以解决，难的是题目定义的源点是左下角，而正常二维数组的源点在左上角。我们可以把 $x,y$ 下标反过来就好了，因为题意向左向右是x移动，而实际上的表达为y移动，题意的向上向下为y移动，而实际上的表达为x移动，只不过这个反过来了而已。只要在输入的时候交换一下顺序，最后再从后向前输出，就跟实际的操作一样了。

题目描述：

用 ASCII 字符来画图是一件有趣的事情，并形成了一门被称为 ASCII Art 的艺术。

例如，下图是用 ASCII 字符画出来的 CSPRO 字样。

　　..____.____..____..____...___..
　　./.___/.___||.._.\|.._.\./._.\.
　　|.|...\___.\|.|_).|.|_).|.|.|.|
　　|.|___.___).|..__/|.._.<|.|_|.|
　　.\____|____/|_|...|_|.\_\\___/.
本题要求编程实现一个用 ASCII 字符来画图的程序，支持以下两种操作：

画线：给出两个端点的坐标，画一条连接这两个端点的线段。简便起见题目保证要画的每条线段都是水平或者竖直的。水平线段
用字符 - 来画，竖直线段用字符 | 来画。如果一条水平线段和一条竖直线段在某个位置相交，则相交位置用字符 + 代替。
填充：给出填充的起始位置坐标和需要填充的字符，从起始位置开始，用该字符填充相邻位置，直到遇到画布边缘或已经画好的
线段。注意这里的相邻位置只需要考虑上下左右 4 个方向，如下图所示，字符 @ 只和 4 个字符 * 相邻。
　　.*.
　　*@*
　　.*.
输入格式
第 1 行有三个整数 m,n 和 q。m 和 n 分别表示画布的宽度和高度，以字符为单位。q 表示画图操作的个数。

第 2 行至第 q+1 行，每行是以下两种形式之一：

0 x1 y1 x2 y2：表示画线段的操作，(x1,y1) 和 (x2,y2) 分别是线段的两端，满足要么 x1=x2 且 y1≠y2，要么 y1=y2 且 x1≠x2。
1 x y c：表示填充操作，(x,y) 是起始位置，保证不会落在任何已有的线段上；c 为填充字符，是大小写字母。画布的左下角是坐
标为 (0,0) 的位置，向右为 x 坐标增大的方向，向上为 y 坐标增大的方向。

这 q 个操作按照数据给出的顺序依次执行。画布最初时所有位置都是字符 .（小数点）。

输出格式
输出有 n 行，每行 m 个字符，表示依次执行这 q 个操作后得到的画图结果。

数据范围
2≤m,n≤100，0≤q≤100，0≤x<m（x 表示输入数据中所有位置的 x 坐标），0≤y<n（y 表示输入数据中所有位置的 y 坐标）。

输入样例1：
4 2 3
1 0 0 B
0 1 0 2 0
1 0 0 A
输出样例1：
AAAA
A--A
输入样例2：
16 13 9
0 3 1 12 1
0 12 1 12 3
0 12 3 6 3
0 6 3 6 9
0 6 9 12 9
0 12 9 12 11
0 12 11 3 11
0 3 11 3 1
1 4 2 C
输出样例2：
................
...+--------+...
...|CCCCCCCC|...
...|CC+-----+...
...|CC|.........
...|CC|.........
...|CC|.........
...|CC|.........
...|CC|.........
...|CC+-----+...
...|CCCCCCCC|...
...+--------+...
................

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 110;

int n, m, q;
int dir[4][2] = {0,1,0,-1,1,0,-1,0};
char g[N][N], backup[N][N];
bool st[N][N];

void bfs(PII S, char c)
{
	memset(st, 0, sizeof st);
	st[S.x][S.y] = true;
	g[S.x][S.y] = c;
	
	queue<PII> q; q.push(S);
	while(q.size())
	{
		auto t = q.front(); q.pop();
		
		for(int i = 0; i < 4; ++i)
		{
			int x = t.x + dir[i][0];
			int y = t.y + dir[i][1];
			if(x < 0 || x >= n || y < 0 || y >= m) continue;
			if(st[x][y] || g[x][y] == '-' || g[x][y] == '|' || g[x][y] == '+') continue;
			
			st[x][y] = true; g[x][y] = c;
			q.push({x,y});
		}
	}
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> m >> n >> q;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < m; ++j)
		{
			g[i][j] = '.';
		}
	}

	while(q--)
	{
		int op; cin >> op;
		if(op)
		{
			int x, y; char c; cin >> y >> x >> c;
			bfs({x,y},c);
		}
		else
		{
			int x1,x2,y1,y2; cin >> y1 >> x1 >> y2 >> x2;
			if(x1 > x2) swap(x1,x2);
			if(y1 > y2) swap(y1,y2);

			if(x1 == x2)
			{
				for(int j = y1; j <= y2; ++j)
				{
					auto& t = g[x1][j];
					if(t == '|' || t == '+') t = '+';
					else t = '-';
				}
			}
			else
			{
				for(int i = x1; i <= x2; ++i)
				{
					auto& t = g[i][y1];
					if(t == '-' || t == '+') t = '+';
					else t = '|';
				}
			}
		}

	}
	
	for(int i = n - 1; i >= 0; --i) cout << g[i] << endl;
	
	return 0;
}

---

三、扫雷

标签：Flood Fill

思路：这道题要求最低的点击次数，那么会有这么几种情况，该格子为 $0$，那么会把所有的周围的格子展开，如果不是 $0$ ，那么要么周围有 $0$ ，要么周围没 $0$ ，那么最优解肯定是把是 $0$ 的都点了，然后再点周围没有 $0$ 的格子。

题目描述：

扫雷是一种计算机游戏，在 20 世纪 80 年代开始流行，并且仍然包含在某些版本的 Microsoft Windows 操作系统中。

在这个问题中，你正在一个矩形网格上玩扫雷游戏。

最初网格内的所有单元格都呈未打开状态。

其中 M 个不同的单元格中隐藏着 M 个地雷。

其他单元格内不包含地雷。

你可以单击任何单元格将其打开。

如果你点击到的单元格中包含一个地雷，那么游戏就会判定失败。

如果你点击到的单元格内不含地雷，则单元格内将显示一个 0 到 8 之间的数字（包括 0 和 8），这对应于该单元格的所有相邻单
元格中包含地雷的单元格的数量。

如果两个单元格共享一个角或边，则它们是相邻单元格。

另外，如果某个单元格被打开时显示数字 0，那么它的所有相邻单元格也会以递归方式自动打开。

当所有不含地雷的单元格都被打开时，游戏就会判定胜利。

例如，网格的初始状态可能如下所示（* 表示地雷，而 c 表示第一个点击的单元格）：

*..*...**.
....*.....
..c..*....
........*.
..........
被点击的单元格旁边没有地雷，因此当它被打开时显示数字 0，并且它的 8 个相邻单元也被自动打开，此过程不断继续，最终状态如下：

*..*...**.
1112*.....
00012*....
00001111*.
00000001..
此时，仍有不包含地雷的单元格（用 . 字符表示）未被打开，因此玩家必须继续点击未打开的单元格，使游戏继续进行。

你想尽快赢得游戏胜利并希望找到赢得游戏的最低点击次数。

给定网格的尺寸（N×N），输出能够获胜的最小点击次数。

输入格式
第一行包含整数 T，表示共有 T 组测试数据。

每组数据第一行包含整数 N，表示游戏网格的尺寸大小。

接下来 N 行，每行包含一个长度为 N 的字符串，字符串由 .（无雷）和 *（有雷）构成，表示游戏网格的初始状态。

输出格式
每组数据输出一个结果，每个结果占一行。

结果表示为 Case #x: y，其中 x 是组别编号（从 1 开始），y 是获胜所需的最小点击次数。

数据范围
1≤T≤100,1≤N≤300
输入样例：
2
3
..*
..*
**.
5
..*..
..*..
.*..*
.*...
.*...
输出样例：
Case #1: 2
Case #2: 8

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 310;

int T, n;
char str[N][N];
int g[N][N];

void dfs(int a, int b)
{
	int t = g[a][b];
	g[a][b] = -1;
	if(t) return;  // 说明已经到边界了，不能再扩展了
	
	for(int x = a - 1; x <= a + 1; ++x)
	{
		for(int y = b - 1; y <= b + 1; ++y)
		{
			if(x < 0 || x >= n || y < 0 || y >= n || g[x][y] == -1) continue;
			dfs(x,y);
		}
	}
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> T;
	for(int C = 1; C <= T; ++C)
	{
		cin >> 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(str[i][j] == '*') g[i][j] = -1;
				else
				{
					g[i][j] = 0;
					for(int x = i - 1; x <= i + 1; ++x)
					{
						for(int y = j - 1; y <= j + 1; ++y)
						{
							if(x < 0 || x >= n || y < 0 || y >= n) continue;
							if(str[x][y] == '*') g[i][j]++;
						}
					}
				}
			}
		}
		
		int res = 0;
		for(int i = 0; i < n; ++i)
		{
			for(int j = 0; j < n; ++j)
			{
				if(!g[i][j])
				{
					res++;
					dfs(i,j);
				}
			}
		}
		
		for(int i = 0; i < n; ++i)
		{
			for(int j = 0; j < n; ++j)
			{
				if(g[i][j] != -1) res++;
			}
		}
		
		printf("Case #%d: %d\n", C, res);
	}
	
	return 0;
}