最小化路径翻转

本文介绍了如何最小化所需的翻转，以使从二进制矩阵的左上角到右下角的所有最短路径等于 S。下面将依次介绍问题背景、解决方案、代码实现和时间复杂度分析。

背景

给定一个 n×n 的二进制矩阵，其中 0 表示可以通过的路径，1 表示不能通过的障碍物。现在需要找到从左上角到右下角的所有最短路径，并使这些路径经过的所有 1 尽可能少。也就是说，需要最小化所需的翻转次数。

例如，下面的矩阵中，从左上角到右下角的最短路经为 00-11-10-11-11，需要翻转 2 次才能让所有最短路径都经过的 1 最少。

0 0 0 1 1
0 1 1 1 0
0 0 1 0 0
1 0 0 1 1
0 0 0 0 1

解决方案

本问题可以使用广度优先搜索（BFS）来解决。具体步骤如下：

1. 定义一个状态表示节点 (i, j, flip)，其中 (i, j) 表示当前节点的坐标，flip 表示当前路径已经经过的 1 的个数；
2. 将起点 (0, 0, 0) 加入队列，并将其标记为已访问；
3. 依次从队列中取出节点，遍历其所有邻居节点；
4. 对于邻居节点 (ni, nj)，如果其为终点 (n-1, n-1)，则更新最小翻转次数的值；
5. 否则，如果邻居节点为 0，则直接加入队列；如果邻居节点为 1，则加入队列，并将 flip 值加一。

在遍历完所有可能的路径后，最小翻转次数就是求得的最小值。

代码实现

下面给出用 Python 实现 BFS 算法的代码，其时间复杂度为 O(n^4)：

from collections import deque

def minFlips(mat: List[List[int]]) -> int:
    n = len(mat)
    queue = deque([(0, 0, 0)])
    seen = {(0, 0, 0)}

    while queue:
        i, j, flip = queue.popleft()
        if i == j == n - 1:
            return flip
        for ni, nj in ((i+1, j), (i, j+1), (i-1, j), (i, j-1)):
            if 0 <= ni < n and 0 <= nj < n:
                new_flip = flip + mat[ni][nj]
                new_state = ni, nj, new_flip
                if new_state not in seen:
                    seen.add(new_state)
                    queue.append(new_state)

    return -1

时间复杂度分析

本问题使用 BFS 算法求解，其时间复杂度为 O(n^4)。在最坏情况下，所有节点都需要遍历一遍，并且每个节点都有四个邻居点，因此总共需要遍历 n^2 个节点，每个节点需要遍历其四个邻居节点，因此总时间复杂度为 O(n^4)。