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[].size();
         vector<vector<int>> dp(row, vector<int>(col));

         for (int i = ; i < row; i++) {
             for (int j = ; j < col; j++) {
                 if (!i && !j) {
                     dp[i][j] = grid[i][j];
                 }
                 else if (!i && j) {
                     dp[i][j] = dp[i][j - ] + grid[i][j];
                 }
                 else if (i && !j) {
                     dp[i][j] = dp[i - ][j] + grid[i][j];
                 }
                 else {
                     dp[i][j] = min(dp[i - ][j], dp[i][j - ]) + grid[i][j];
                 }
             }
         }

         return dp[row - ][col - ];
     }
 };

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

 class Solution {
 public:
     int minPathSum(vector<vector<int>>& grid) {
         int row = grid.size(), col = grid[].size();
         vector<int> dp(col);

         dp[] = grid[][];
         for (int i = ; i < row; i++) {
             for (int j = ; j < col; j++) {
                 if (!i && !j) {
                     dp[j] = grid[i][j];
                 }
                 else if (!i && j) {
                     dp[j] = dp[j - ] + grid[i][j];
                 }
                 else if (i && !j) {
                     dp[j] += grid[i][j];
                 }
                 else {
                     dp[j] = min(dp[j], dp[j - ]) + grid[i][j];
                 }
             }
         }

         return dp[col - ];
     }
 };