Leetcode-64_. Minimum Path Sum(最小路径和)—动态规划解法+记忆化搜索解法-C++解

Leetcode 64. Minimum Path Sum(最小路径和)

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 1:

[[1,3,1],
 [1,5,1],
 [4,2,1]]

Given the above grid map, return 7. Because the path 1→3→1→1→1 minimizes the sum.

这道题也是典型的动态规划问题，但是我一开始用动态规划做得有点费劲，就用记忆化搜索先做出来了：

int m,n,res;
vector<vector<int> > memo;
int minPath(int i,int j,vector<vector<int> >& grid)
{
    if(i==m-1&&j==n-1)
        return grid[i][j];
    if(memo[i][j]!=-1)
        return memo[i][j];
    if(i==m-1)
    {
        return minPath(i,j+1,grid)+grid[i][j];
    }
    if(j==n-1)
    {
        return minPath(i+1,j,grid)+grid[i][j];
    }
    res=min(minPath(i,j+1,grid),minPath(i+1,j,grid))+grid[i][j];
    memo[i][j] = res;
    return res;
}
int minPathSum(vector<vector<int> >& grid) {
    m=grid.size();//行 
    n=grid[0].size();//列 
    memo=vector<vector<int> >(m,vector<int> (n,-1));
    minPath(0,0,grid);
}

然后后面看了别人的代码才把动态规划的部分理解了：

class Solution {
public:

    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size(); 

        vector<vector<int> > sum(m, vector<int>(n, grid[0][0]));

        for (int i = 1; i < m; i++)
            sum[i][0] = sum[i - 1][0] + grid[i][0];
        for (int j = 1; j < n; j++)
            sum[0][j] = sum[0][j - 1] + grid[0][j];
        for (int i = 1; i < m; i++)
            for (int j = 1; j < n; j++)
                sum[i][j]  = min(sum[i - 1][j], sum[i][j - 1]) + grid[i][j];
        return sum[m - 1][n - 1];

    }
};

自制测试用例

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

int m,n,res;
vector<vector<int> > memo;
int minPathSum(vector<vector<int> >& grid) {
    m=grid.size();//行 
    n=grid[0].size();//列 
    memo=vector<vector<int> >(m,vector<int> (n,grid[0][0]));
    for (int i = 1; i < m; i++)
        memo[i][0] = memo[i - 1][0] + grid[i][0];
    for (int j = 1; j < n; j++)
        memo[0][j] = memo[0][j - 1] + grid[0][j];    

    for (int i = 1; i < m; i++)
        for (int j = 1; j < n; j++)
            memo[i][j]  = min(memo[i - 1][j], memo[i][j - 1]) + grid[i][j];
    return memo[m - 1][n - 1];
}


int main(int argc, char *argv[]) {
    vector<vector<int> >tt ;
    vector<int> v;
    v.push_back(4);
    v.push_back(3);
    v.push_back(1);
    tt.push_back(v);
    v.clear();
    v.push_back(6);
    v.push_back(2);
    v.push_back(3);
    tt.push_back(v);
    v.clear();
    v.push_back(4);
    v.push_back(2);
    v.push_back(1);
    tt.push_back(v);
    v.clear();
    for(int i=0;i<tt.size();i++)
    {
        for(int j=0;j<tt[0].size();j++)
            cout<<tt[i][j];
        cout<<endl;
    }
    int min = minPathSum(tt);
    cout<<"min:"<<min;
    return 0;
}