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.
Example:
Input: [ [1,3,1], [1,5,1], [4,2,1] ] Output: 7 Explanation: Because the path 1→3→1→1→1 minimizes the sum.
這道題給了我們一個只有非負數的二維數組，讓找一條從左上到右下的路徑，使得路徑和最小，限定了每次只能向下或者向右移動。一個常見的錯誤解法就是每次走右邊或下邊數字中較小的那個，這樣的貪婪算法獲得的局部最優解不一定是全局最優解，因此是不行的。實際上這道題跟之前那道 Dungeon Game 沒有什么太大的區別，都需要用動態規划 Dynamic Programming 來做，這應該算是 DP 問題中比較簡單的一類，我們維護一個二維的 dp 數組，其中 dp[i][j] 表示到達當前位置的最小路徑和。接下來找狀態轉移方程，因為到達當前位置 (i, j) 只有兩種情況，要么從上方 (i-1, j) 過來，要么從左邊 (i, j-1) 過來，我們選擇 dp 值較小的那個路徑，即比較 dp[i-1][j] 和 dp[i][j-1]，將其中的較小值加上當前的數字 grid[i][j]，就是當前位置的 dp 值了。但是有些特殊情況要提前賦值，比如起點位置，直接賦值為 grid[0][0]，還有就是第一行和第一列，其中第一行的位置只能從左邊過來，第一列的位置從能從上面過來，所以這兩行要提前初始化好，然后再從 (1, 1) 的位置開始更新到右下角即可，反正難度不算大，代碼如下：
解法一：
class Solution { public: int minPathSum(vector<vector<int>>& grid) { if (grid.empty() || grid[0].empty()) return 0; int m = grid.size(), n = grid[0].size(); vector<vector<int>> dp(m, vector<int>(n)); dp[0][0] = grid[0][0]; for (int i = 1; i < m; ++i) dp[i][0] = grid[i][0] + dp[i - 1][0]; for (int j = 1; j < n; ++j) dp[0][j] = grid[0][j] + dp[0][j - 1]; for (int i = 1; i < m; ++i) { for (int j = 1; j < n; ++j) { dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1]); } } return dp[m - 1][n - 1]; } };
我們可以優化空間復雜度，可以使用一個一維的 dp 數組就可以了，初始化為整型最大值，但是 dp[0][0] 要初始化為0。之所以可以用一維數組代替之前的二維數組，是因為當前的 dp 值只跟左邊和上面的 dp 值有關。這里我們並不提前更新第一行或是第一列，而是在遍歷的時候判斷，若j等於0時，說明是第一列，我們直接加上當前的數字，否則就要比較是左邊的 dp[j-1] 小還是上面的 dp[j] 小，當是第一行的時候，dp[j] 是整型最大值，所以肯定會取到 dp[j-1] 的值，然后再加上當前位置的數字即可，參見代碼如下：
解法二：
class Solution { public: int minPathSum(vector<vector<int>>& grid) { if (grid.empty() || grid[0].empty()) return 0; int m = grid.size(), n = grid[0].size(); vector<int> dp(n, INT_MAX); dp[0] = 0; for (int i = 0; i < m; ++i) { for (int j = 0; j < n; ++j) { if (j == 0) dp[j] += grid[i][j]; else dp[j] = grid[i][j] + min(dp[j], dp[j - 1]); } } return dp[n - 1]; } };
我們還可以進一步的優化空間，連一維數組都不用新建，而是直接使用原數組 grid 進行累加，這里的累加方式跟解法一稍有不同，沒有提前對第一行和第一列進行賦值，而是放在一起判斷了，當i和j同時為0時，直接跳過。否則當i等於0時，只加上左邊的值，當j等於0時，只加上面的值，否則就比較左邊和上面的值，加上較小的那個即可，參見代碼如下：
解法三：
class Solution { public: int minPathSum(vector<vector<int>>& grid) { if (grid.empty() || grid[0].empty()) return 0; for (int i = 0; i < grid.size(); ++i) { for (int j = 0; j < grid[i].size(); ++j) { if (i == 0 && j == 0) continue; if (i == 0) grid[0][j] += grid[0][j - 1]; else if (j == 0) grid[i][0] += grid[i - 1][0]; else grid[i][j] += min(grid[i - 1][j], grid[i][j - 1]); } } return grid.back().back(); } };
下面這種寫法跟上面的基本相同，只不過用了 up 和 left 兩個變量來計算上面和左邊的值，看起來稍稍簡潔一點，參見代碼如下：
解法四：
class Solution { public: int minPathSum(vector<vector<int>>& grid) { if (grid.empty() || grid[0].empty()) return 0; for (int i = 0; i < grid.size(); ++i) { for (int j = 0; j < grid[i].size(); ++j) { if (i == 0 && j == 0) continue; int up = (i == 0) ? INT_MAX : grid[i - 1][j]; int left = (j == 0) ? INT_MAX : grid[i][j - 1]; grid[i][j] += min(up, left); } } return grid.back().back(); } };
Github 同步地址：
https://github.com/grandyang/leetcode/issues/64
類似題目：
參考資料：
https://leetcode.com/problems/minimum-path-sum/
https://leetcode.com/problems/minimum-path-sum/discuss/23457/C%2B%2B-DP
https://leetcode.com/problems/minimum-path-sum/discuss/23617/C%2B%2B-solution-beat-98.59
https://leetcode.com/problems/minimum-path-sum/discuss/23611/My-Java-clean-code-DP-no-extra-space