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;
}