将X转换为Y所需的最少步骤

给定一个二进制矩阵表示可能的转换，计算将X转换为Y所需的最少步骤。

代码实现

def minSteps(x, y, matrix):
    """
    :type x: tuple[int, int]
    :type y: tuple[int, int]
    :type matrix: List[List[int]]
    :rtype: int
    """
    m, n = len(matrix), len(matrix[0])
    queue = collections.deque([(x[0], x[1], 0)])
    visited = set([(x[0], x[1])])
    while queue:
        i, j, steps = queue.popleft()
        if (i, j) == y:
            return steps
        for di, dj in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            ni, nj = i + di, j + dj
            if ni >= 0 and ni < m and nj >= 0 and nj < n and matrix[ni][nj] == 0 and (ni, nj) not in visited:
                queue.append((ni, nj, steps + 1))
                visited.add((ni, nj))
    return -1

算法思路

我们可以使用广度优先搜索 (BFS) 来解决这个问题。

假设起始点为 x，我们可以将它作为 BFS 的起点，从起点开始探索到达其他点的最少步骤。每当我们遍历到一个新的点时，我们都会将其横坐标和纵坐标记录在队列中。

对于任何一个点，我们都可以通过四个方向来探索：向上、向下、向左或向右。如果中心点 (i,j) 还没有超出数组的边界并且是零，我们将在 (i,j) 上方、下方、左侧或右侧重复这个过程。

在搜索到达目标点 y 之后，我们将会获得从 x 到 y 的所需最少步骤。

复杂度分析

• 时间复杂度：$O(mn)$，其中 $m,n$ 是矩阵中的行数和列数。我们最多遍历矩阵 $m \times n$ 中的每个元素，每个元素只会被遍历一次。
• 空间复杂度：$O(mn)$。在最坏的情况下，队列中会包含矩阵中的所有，所以空间复杂度是 $O(mn)$ 。

示例

matrix = [[0, 0, 0, 0, 0], [1, 0, 0, 0, 1], [0, 1, 0, 1, 0], [0, 0, 0, 0, 0], [1, 0, 1, 0, 0]]
x, y = (0, 0), (4, 4)
print(minSteps(x, y, matrix))  # Output: 8