leetcode最短路径专题

542.01矩阵

思路

复杂度

时间复杂度：$O(rc)$，其中 r 为矩阵行数，c 为矩阵列数，即矩阵元素个数。广度优先搜索中每个位置最多只会被加入队列一次，因此只需要 $O(rc)$ 的时间复杂度。

空间复杂度：$O(rc)$，其中 r 为矩阵行数，c 为矩阵列数，即矩阵元素个数。除答案数组外，最坏情况下矩阵里所有元素都为 0，全部被加入队列中，此时需要 $O(rc)$ 的空间复杂度。

超级源点最短路径

cpp

class Solution {
private:
	static constexpr int dirs[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };

public:
	vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
		int m = matrix.size(), n = matrix[0].size();
		vector<vector<int>> dist(m, vector<int>(n));//距离矩阵
		vector<vector<int>> seen(m, vector<int>(n));//访问矩阵
		queue<pair<int, int>> q;
		// 将所有的 0 添加进初始队列中
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j) {
				if (matrix[i][j] == 0) {
					q.emplace(i, j);
					seen[i][j] = 1;
				}
			}
		}
		// 广度优先搜索bfs
		while (!q.empty()) {
			auto top = q.front();
			int i = top.first;//行下标
			int j = top.second;//列下标
			q.pop();
			for (int d = 0; d < 4; ++d) {
				int ni = i + dirs[d][0];
				int nj = j + dirs[d][1];
				if (ni >= 0 && ni < m && nj >= 0 && nj < n && !seen[ni][nj]) {
					dist[ni][nj] = dist[i][j] + 1;
					q.emplace(ni, nj);//入队
					seen[ni][nj] = 1;
				}
			}
		}
		return dist;
	}
};

python3

from collections import deque
class Solution:
    def updateMatrix(self, matrix: List[List[int]]) -> List[List[int]]:
        r, c = len(matrix), len(matrix[0])  # 行列数
        seen = [[False]*c for _ in range(r)]
        dist = [[0] * c for _ in range(r)]
        q = deque()
        # 位置为0的入队，且访问矩阵对应值为true
        for i in range(r):
            for j in range(c):
                if not matrix[i][j]:
                    q.append((i, j))
                    seen[i][j] = True

        while q:
            i, j = q.popleft()
            for ni, nj in [(i - 1, j), (i + 1, j), (i, j - 1), (i, j + 1)]:
                if 0 <= ni < r and 0 <= nj < c and not seen[ni][nj]:
                    dist[ni][nj] = dist[i][j] + 1
                    q.append((ni, nj))
                    seen[ni][nj] = True
        return dist