LeetCode-64 最小路径和

问题描述：

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-path-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：

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


class Solution {
private:
    int INF = 1000000;
public:
    /*
    // 递归
    int minPathSum(vector<vector<int>>& grid) {
        return helper(grid, 0, 0);
    }

    int helper(vector<vector<int>>& grid, int i, int j){
        if (i == grid.size() - 1 && j == grid[0].size() - 1){
            return grid[i][j];
        }

        if (i <= grid.size() - 1 && j <= grid[0].size() - 1){
            return grid[i][j] + min(helper(grid, i, j+1), helper(grid, i+1, j));
        }

        return INF;
    }
     */

    /*
    // 记忆话搜索
    vector<vector<int>> memo;
    int minPathSum(vector<vector<int>>& grid) {
        memo.resize(grid.size());
        for (int i = 0; i < grid.size(); ++i) {
            memo[i].resize(grid[0].size(), -1);
        }
        return helper(grid, 0, 0);
    }

    int helper(vector<vector<int>>& grid, int i, int j){
        if (i == grid.size() - 1 && j == grid[0].size() - 1){
            memo[i][j] = grid[i][j];
            return memo[i][j];
        }

        if (i <= grid.size() - 1
            && j <= grid[0].size() - 1
            && memo[i][j] == -1){

            memo[i][j] = grid[i][j] + min(helper(grid, i, j+1), helper(grid, i+1, j));
            return memo[i][j];

        } else if (i <= grid.size() - 1
                   && j <= grid[0].size() - 1
                   && memo[i][j] != -1){

            return memo[i][j];

        } else {

            return INF;
        }
    }
     */

    // DP
    int minPathSum(vector<vector<int>>& grid) {
        vector<vector<int>> dp(grid.size(), vector<int>(grid[0].size(), -1));
        for (int i = grid.size() - 1; i >= 0; --i) {
            for (int j = grid[0].size() - 1; j >= 0; --j) {
                if (i == grid.size() - 1 && j == grid[0].size() - 1)
                    dp[i][j] = grid[i][j];
                else {
                    if (i == grid.size() - 1){
                        dp[i][j] = dp[i][j+1] + grid[i][j];
                    } else if (j == grid[0].size() - 1){
                        dp[i][j] = dp[i + 1][j] + grid[i][j];
                    } else {
                        dp[i][j] = min(dp[i+1][j], dp[i][j+1]) + grid[i][j];
                    }

                }
            }
        }
        return dp[0][0];
    }
};

int main() {
    vector<vector<int>> grid = {
            {1, 3, 1},
            {1, 5, 1},
            {4, 2, 1}
    };

    Solution solution;
    cout << solution.minPathSum(grid);
    return 0;
}