LeetCode 64 Minimum Path Sum

Problem:

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

Summary:

想要从m*n的整型数矩阵左上角走到右下角，每次只可以向右或向下移动一步，求路径上的整型数最小情况下的数字之和。

Solution:

1. 暴力法：枚举从左上角到右下角的所有路径，分别计算出路径和并比较。但效率过低且明显不可行，故不考虑。

2. 动态规划：由于只可以向右或向下移动，若已知(i, j)位置上一格(i - 1, j)以及左一格(i, j - 1)的路径数字之和，即可确定该位置的路径数字和：

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

　　初始化：dp[0][0] = grid[0][0]

　　　　　　dp[0][j] = dp[0][j - 1] + grid[0][j]

　　　　　　dp[i][0] = dp[i - 1][0] + grid[i][0]

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int row = grid.size(), col = grid[0].size();
        vector<vector<int>> dp(row, vector<int>(col));
        
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (!i && !j) {
                    dp[i][j] = grid[i][j];
                }
                else if (!i && j) {
                    dp[i][j] = dp[i][j - 1] + grid[i][j];
                }
                else if (i && !j) {
                    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[row - 1][col - 1];
    }
};

3. 在法2的基础上优化空间

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