动态规划 DP （二）

3.二维动态规划

1)

力扣https://leetcode.cn/problems/minimum-path-sum/第一行的的路径只与左边的元素有关，第一列的路径只与上面的元素有关。

除了第一行和第一列，其他元素的路径取决于左边和上面元素的最小值。

只要每次都选择值最小的路径，最后得到的就是最小路径。

class Solution {
public:
    int minPathSum(vector>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        vector> path = grid;
        for(int i=1;i

上述代码用到了二维数组，为了空间压缩，可以只用一个一维数组：

path[j]表示二维数组中的path[i-1][j]（未更新）

path[j-1]表示二维数组中的path[i][j-1]（已更新）

class Solution {
public:
    int minPathSum(vector>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        vector path(n,0);

        for(int i=0;i

2)

力扣https://leetcode.cn/problems/01-matrix/当元素值为0时，最近距离就是0。

当元素值为1时，最近距离为周围四个元素的最近距离的最小值加1。

因为做BFS，最差时间复杂度为O(m*n*m*n)。

所以还是用DP记录最近距离速度会更快些。

很直观地能发现，先从左上往右下扫描，得到只考虑左边元素和上边元素时的最小距离。

再从右下往左上扫描，可以得到考虑右边元素和下边元素的最小距离。

做完两遍扫描，就把周围四个元素都考虑进去了。

时间复杂度为O(2*m*n)。

注意最小距离数组一开始要设置为最大距离减一

class Solution {
public:
    vector> updateMatrix(vector>& mat) {
        int m = mat.size(), n = mat[0].size();
        vector> res(m,vector(n,INT_MAX-1));

        for(int i=0;i0){
                        res[i][j] = min(res[i][j], res[i-1][j]+1);
                    }
                    if(j>0){
                        res[i][j] = min(res[i][j], res[i][j-1]+1);
                    }
                }
            }
        }


        for(int i=m-1;i>=0;i--){
            for(int j=n-1;j>=0;j--){
                if(res[i][j]){
                    if(i

3)

力扣https://leetcode.cn/problems/maximal-square/假设当前元素是正方形右下角的元素

若想要正方形边长为1，那么当前元素值为'1'就行了

若想要正方形变成为2，那么不仅要当前元素值为’1‘，还需要上边，左边，左上角三个元素分别所能构成的最大正方形边长>=1。

若想要正方形变成为3，那么不仅要当前元素值为’1‘，还需要上边，左边，左上角三个元素分别所能构成的最大正方形边长>=2。

依此类推，得到状态转移方程：

dp[i][j] = 1 + min(dp[i-1][j],min(dp[i][j-1], dp[i-1][j-1]))

每次记录边长最长的值，最终就能得到最大正方形的面积。

class Solution {
public:
    int maximalSquare(vector>& matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        int res = 0;
        vector> dp(m,vector(n,0));
        for(int i=0;i