01 Matrix 基本动态规划：二维--力扣101算法题解笔记

7.3 01 Matrix 基本动态规划：二维

题目描述

给定一个由0和1组成的二维矩阵，求每个位置到最近的0的距离

输入输出样例

Input ：

\[0, 0, 0\], \[0, 1, 0\], \[1, 1, 1\]

Output： [[0, 0, 0],

0, 1, 0\], \[1, 2, 1\]

输入的是一个二维的0-1数组，输出的是一个同样大小的非负整数数组，表示每个位置到最近的0的距离。

题解

这道题涉及到四个方向上的最近搜索，一般的解法使用广度优先搜索，but，这个二维数组是O(m,n)，如果真用广度优先搜索，时间复杂度是O(m^2n^2)直接爆炸。

所以我们从左上到右下进行动态搜索，再从右下到左上进行一次动态搜索，两次动态搜索就可以完成四个方向上的查找。

#include <iostream>
#include <vector>
using namespace std;

vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
    if (matrix.empty()) return {};
    int n = matrix.size(), m = matrix[0].size();
    vector<vector<int>> dp(n, vector<int>(m, INT_MAX - 1));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (matrix[i][j] == 0) {
                dp[i][j] = 0;
            }
            else {
                if (j > 0) {
                    dp[i][j] = min(dp[i][j], dp[i][j - 1] + 1);
                }
                if (i > 0) {
                    dp[i][j] = min(dp[i][j], dp[i - 1][j] + 1);
                }
            }
        }
    }
    for (int i = n - 1; i >= 0; --i) {
        for (int j = m - 1; j >= 0; --j) {
            if (matrix[i][j] != 0) {
                if (j < m - 1) {
                    dp[i][j] = min(dp[i][j], dp[i][j + 1] + 1);
                }
                if (i < n - 1) {
                    dp[i][j] = min(dp[i][j], dp[i + 1][j] + 1);
                }
            }
        }
    }
    return dp;
}

int main() {
    vector<vector<int>> matrix = { {0,0,0},{0,1,0},{1,1,1} };
    vector<vector<int>> res = updateMatrix(matrix);
    for (const auto& row : res) {  
        for (int num : row) {
            cout << num << " ";
        }
        cout << endl;
    }
    return 0;
}