访问N * M网格的所有角所需的最少步骤

当你需要在一个 N * M 的网格中访问所有的四个角时，如果不考虑最短路径，那么我们可以直接从某一个角出发，顺时针或逆时针地遍历整个网格。但是如果要求最少步骤，我们需要思考一下最短路径的问题。

解决方案

宽度优先搜索算法

最短路径问题可以使用宽度优先搜索算法来解决。我们从一个起点出发，逐层探索，直到找到终点为止。在网格中，我们可以将每个格子看作是图中的一个节点，然后将相邻的格子之间连边，形成一个无向图，其中边的权重为 1。然后我们使用宽度优先搜索算法，在从起点到终点的所有可能路径中，找到长度最短的一条路径。

具体的实现方法是：

1. 将起点加入队列中。
2. 当队列非空时，取出队头元素，并将其标记为已访问。
3. 遍历该节点的所有邻居节点，如果该邻居节点没被访问，且不是障碍物，则将其加入队列中，并标记为已访问。
4. 如果遍历到终点，则返回当前步数作为最少步数，结束搜索。
5. 如果队列为空仍然未找到终点，则无法到达所有角，返回 -1。

实现代码如下：

from collections import deque

def shortestPath(grid):
    if not grid or not grid[0]:
        return -1
    
    rows, cols = len(grid), len(grid[0])
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    queue = deque([(0, 0, 0)])
    visited = {(0, 0)}
    while queue:
        i, j, steps = queue.popleft()
        if (i, j) == (rows - 1, cols - 1):
            return steps

        for di, dj in directions:
            ni, nj = i + di, j + dj
            if 0 <= ni < rows and 0 <= nj < cols and (ni, nj) not in visited and grid[ni][nj] != -1:
                queue.append((ni, nj, steps + 1))
                visited.add((ni, nj))
    
    return -1

动态规划算法

另一种解决方法是使用动态规划算法。我们从左上角出发，以每个格子为状态，记录从起点到该格子的最少步数，然后计算最右下角的格子的最少步数即可。

具体的实现方法是：

1. 初始化边界状态：第一行和第一列的格子的最少步数分别为当前格子和上一个格子的最少步数之和。
2. 对于其余格子，如果该格子不是障碍物，则其最少步数为上一个格子和上一个列的格子的最少步数之和，否则该格子没有最少步数。
3. 返回右下角格子的最少步数。

实现代码如下：

def shortestPath(grid):
    if not grid or not grid[0]:
        return -1

    rows, cols = len(grid), len(grid[0])
    dp = [[float('inf')] * (cols + 1) for _ in range(rows + 1)]
    dp[0][0] = 0

    for i in range(1, rows + 1):
        for j in range(1, cols + 1):
            if grid[i - 1][j - 1] == -1:
                continue
            dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1

    return dp[rows][cols] if dp[rows][cols] != float('inf') else -1

性能分析

使用宽度优先搜索算法的时间复杂度为 O(nm)，其中 n 和 m 分别为网格的行数和列数，空间复杂度为 O(nm)，其中最坏情况下所有的节点都需要加入队列，即整个网格都是空地。

使用动态规划算法的时间复杂度为 O(nm)，空间复杂度为 O(nm)，其中 n 和 m 分别为网格的行数和列数。

因此，在时间和空间效率上，两种算法都是可行的，具体使用哪种算法可以视情况而定。