leetcode：64. 最小路径和

题目来源

• leetcode

题目描述

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {

    }
};

题目解析

暴力递归：从终点往前面看

定义一个函数：

int minPathSum(vector<vector<int>>& grid, int i, int j){
        
} 

int minPathSum(vector<vector<int>>& grid, int i, int j)表示从左上角到坐标(i, j)的最短路径和。从而有：

    int minPathSum(vector<vector<int>>& grid, int i, int j){
        if (边界条件的判断) {
            return
        }

        //一些逻辑处理

        //取从上面走下来和从左边走过来的最小值+当前坐标的值
        return grid[i][j] + std::min(minPathSum(grid, i - 1, j), minPathSum(grid, i, j - 1));
    }

下面再来看下完整代码

class Solution {
    int minPathSum(vector<vector<int>>& grid, int i, int j){
        if (i == 0 && j == 0)
            return grid[i][j];
        //第一行只能从左边走过来
        if (i == 0)
            return grid[i][j] + minPathSum(grid, i, j - 1);
        //第一列只能从上面走下来
        if (j == 0)
            return grid[i][j] + minPathSum(grid, i - 1, j);
        //取从上面走下来和从左边走过来的最小值+当前坐标的值
        return grid[i][j] + std::min(minPathSum(grid, i - 1, j), minPathSum(grid, i, j - 1));
    }
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        return minPathSum(grid, m - 1, n - 1);
    }
};

因为这里面的递归会导致大量的重复计算，所以加备忘录：

class Solution {
    std::map<std::string, int> memo;

    int minPathSum(vector<vector<int>>& grid, int i, int j){
        if (i == 0 && j == 0)
            return grid[i][j];

        std::string key = std::to_string(i) + "*" + std::to_string(j);
        if(memo.count(key)){
            return memo[key];
        }

        int res = 0;
        //第一行只能从左边走过来
        if (i == 0)
            res =  grid[i][j] + minPathSum(grid, i, j - 1);
        //第一列只能从上面走下来
        else if (j == 0)
            res =  grid[i][j] + minPathSum(grid, i - 1, j);
        //取从上面走下来和从左边走过来的最小值+当前坐标的值
        else
            res =  grid[i][j] + std::min(minPathSum(grid, i - 1, j), minPathSum(grid, i, j - 1));

        return memo[key] = res;
    }
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        return minPathSum(grid, m - 1, n - 1);
    }
};

最值型动态规划：从起点到终点计算

（1）确定状态

• 最后一步：
  • 无论用何种方式到达右下角，总有最后一步。
  • 设右下角坐标为(m - 1, n- 1 )，因为只能向下或者向右，所以前一步一定是在(m - 2, n - 1)或者(m - 1, n - 2)
  • 最优策略的路径总和最小，那么：
    • 如果倒数第二步在(m - 1, n - 2)，那么前面一定是从(0, 0)到达(m - 2, n - 1)总和最小的路径
    • 如果倒数第二步在(m - 2, n - 1)，那么前面一定是从(0, 0)到达(m - 2, n - 1)总和最小的路径
• 子问题：
  • 子问题：从左上角走到(m - 1, n - 2)的路径的最小数字总和以及走到(m - 2, n - 1)的路径的最小数字总和
  • 原问题：从左上角走到(m - 1, n - 1)的路径的最小数字总和
• 状态：
  • f[i][j]：从(0, 0)走到(i, j)的路径最小数字和

（2）转移方程

（3）初始条件和边界条件

• 初始条件：f[0][0] = A[0][0]
• 边界条件：i = 0或j = 0，则前一步只能有一个方向过来

（4）计算顺序：

• 从上到下，从左到右
• 时间复杂度（计算步数）O(MN)，空间复杂度（数组大小）O(MN)

（5）空间优化：

• 计算第i行时，只需要第i行和第i-1行
• 所以，只需要保存两行的f值：f[i][0...n-1]和f[i - 1][0...n-1]
• 从而可以用滚动数组实现

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

        std::vector<std::vector<int>> dp(m , std::vector<int>(n ));

        dp[0][0] = grid[0][0];

        //第一行只能从左边走过来
        for (int i = 1; i < n; ++i) {
            dp[0][i] = dp[0][i - 1] + grid[0][i];
        }

        //第一列只能从上面走下来
        for (int i = 1; i < m; ++i) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }

        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                dp[i][j] = std::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
            }
        }

        return dp[m - 1][n - 1];
    }
};

我们看到二维数组dp和二维数组grid的长和宽都是一样的，没必要再申请一个dp数组，完全可以使用grid，来看下代码

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

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 && j == 0)
                    continue;
                if (i == 0) {
                    //第一行只能从左边走过来
                    grid[i][j] += grid[i][j - 1];
                } else if (j == 0) {
                    //第一列只能从上面走下来
                    grid[i][j] += grid[i - 1][j];
                } else {
                    //递推公式，取从上面走下来和从左边走过来的最小值+当前坐标的值
                    grid[i][j] += std::min(grid[i - 1][j], grid[i][j - 1]);
                }
            }
        }
        
        return grid[m - 1][n - 1];
    }
};

滚动数组

仔细观察上面的依赖，因为它只依赖上面一个和左边一个格子，所以可以用一个一维滚动数组来优化

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        if(grid.empty()){
            return 0;
        }
        
        int m = grid.size(), n = grid[0].size();
        std::vector<int> dp(n);
        dp[0] = grid[0][0];
        for (int j = 1; j < n; ++j) {
            dp[j] = dp[j - 1] + grid[0][j];
        }
        for (int i = 1; i < m; ++i) {
            dp[0] += grid[i][0];
            for (int j = 1; j < n; ++j) {
                dp[j] = grid[i][j] + std::min(dp[j - 1], dp[j]);
            }
        }
        return dp[n - 1];
    }
};