2060 奶牛选美（dfs-bfs）

1. 问题描述：

听说最近两斑点的奶牛最受欢迎，约翰立即购进了一批两斑点牛。不幸的是，时尚潮流往往变化很快，当前最受欢迎的牛变成了一斑点牛。约翰希望通过给每头奶牛涂色，使得它们身上的两个斑点能够合为一个斑点，让它们能够更加时尚。牛皮可用一个 N×M 的字符矩阵来表示，如下所示：
................
..XXXX....XXX...
...XXXX....XX...
.XXXX......XXX..
........XXXXX...
.........XXX....
其中，X 表示斑点部分。如果两个 X 在垂直或水平方向上相邻（对角相邻不算在内），则它们属于同一个斑点，由此看出上图中恰好有两个斑点。约翰牛群里所有的牛都有两个斑点。约翰希望通过使用油漆给奶牛尽可能少的区域内涂色，将两个斑点合为一个。在上面的例子中，他只需要给三个 . 区域内涂色即可（新涂色区域用 ∗ 表示）：
................
..XXXX....XXX...
...XXXX*...XX...
.XXXX..**..XXX..
........XXXXX...
.........XXX....
请帮助约翰确定，为了使两个斑点合为一个，他需要涂色区域的最少数量。

输入格式

第一行包含两个整数 N 和 M。接下来 N 行，每行包含一个长度为 M 的由 X 和 . 构成的字符串，用来表示描述牛皮图案的字符矩阵。

输出格式

输出需要涂色区域的最少数量。

数据范围

1 ≤ N，M ≤ 50

输入样例：

6 16
................
..XXXX....XXX...
...XXXX....XX...
.XXXX......XXX..
........XXXXX...
.........XXX....

输出样例：

3
来源：https://www.acwing.com/problem/content/description/2062/

2. 思路分析：

分析题目可以知道这是一道连通性检验的问题，可以使用dfs或者bfs来解决，首先最容易想到的是先搜出第一个连通块的所有位置，使用一个二维的dis数组来标记从一个连通块到另外一个连通块的最短距离（第一个连通块到第二个连通块的最短距离为0），然后使用bfs从第一个连通块开始的位置进行搜索，bfs第一次搜到"X"的时候说明从第一个连通块至少需要走多少步才能够到达第二个连通块，直接返回最短距离即可。第二种方法是基于暴力枚举的思想，我们可以先使用dfs搜索出两个连通块的所有位置，然后计算从第一个连通块的点到第二个连通块的点的最短距离，我们猜想第一个连通块到第二个连通块的最短距离一定可以使用曼哈顿距离计算出来，因为假如当前两个连通块的点不是最优解那么他们之间的曼哈顿距离也不是最优解，所以最优解一定可以使用曼哈顿距离计算出来，但是对于其他不是最优解的点来说则不一定，而我们只关心最优解所以这种方法一定可以计算出两个连通块的最短距离的。

3. 代码如下：

曼哈顿距离：

from typing import List
import sys

class Solution:
    # 使用dfs搜索出当前的连通块中的所有位置记录到q中
    def dfs(self, x: int, y: int, n: int, m: int, pos: List[List[int]], g: List[List[str]], q: List[tuple]):
        # 防止重复搜索
        g[x][y] = "."
        # 记录"X"的位置信息
        q.append((x, y))
        for i in range(4):
            a, b = x + pos[i][0], y + pos[i][1]
            if 0 <= a < n and 0 <= b < m and g[a][b] == "X":
                self.dfs(a, b, n, m, pos, g, q)

    def process(self):
        n, m = map(int, input().split())
        g = list()
        for i in range(n):
            g.append(list(input()))
        q = [list() for i in range(2)]
        k = 0
        pos = [[0, 1], [0, -1], [1, 0], [-1, 0]]
        for i in range(n):
            for j in range(m):
                if g[i][j] == "X":
                    self.dfs(i, j, n, m, pos, g, q[k])
                    k += 1
        res = 10 ** 10
        for x in q[0]:
            for y in q[1]:
                # 求解两点的曼哈顿距离, 最终答案要减去1表示需要至少修改的方块数量
                res = min(res, abs(x[0] - y[0]) + abs(x[1] - y[1]) - 1)
        return res


if __name__ == '__main__':
    # 设置递归最大调用次数, 不设置会爆栈
    sys.setrecursionlimit(10000)
    print(Solution().process())

dfs + bfs：

import collections
from typing import List


class Solution:
    pos = [[0, 1], [0, -1], [1, 0], [-1, 0]]

    def dfs(self, x: int, y: int, n: int, m: int, q: collections.deque, g: List[List[str]], dis: List[List[int]]):
        dis[x][y] = 0
        g[x][y] = "."
        q.append((x, y))
        for i in range(4):
            a, b = x + self.pos[i][0], y + self.pos[i][1]
            if 0 <= a < n and 0 <= b < m and g[a][b] == "X":
                self.dfs(a, b, n, m, q, g, dis)
    
    # 从第一个连通块开始搜索, 第一次搜到的点就是两个连通块的最短距离
    def bfs(self, n: int, m: int, q: collections.deque, g: List[List[str]], dis: List[List[int]]):
        while q:
            x, y = q.popleft()
            for i in range(4):
                a, b = x + self.pos[i][0], y + self.pos[i][1]
                if 0 <= a < n and 0 <= b < m:
                    if g[a][b] == "X":
                        return dis[x][y]
                    elif dis[a][b] > dis[x][y] + 1:
                        dis[a][b] = dis[x][y] + 1
                        q.append((a, b))
        return 0

    def process(self):
        n, m = map(int, input().split())
        g = list()
        for i in range(n):
            g.append(list(input()))
        res = 0
        INF = 10 ** 10
        dis = [[INF] * (m + 10) for i in range(n + 10)]
        q = collections.deque()
        for i in range(n):
            for j in range(m):
                if g[i][j] == "X":
                    self.dfs(i, j, n, m, q, g, dis)
                    return self.bfs(n, m, q, g, dis)
        return res


if __name__ == "__main__":
    import sys
    sys.setrecursionlimit(10000)
    print(Solution().process())