LeetCode 64. Minimum Path Sum 二维路线最短路径

这里直接用的是二维，每次判断左边小，还是上边小，然后做dp。

#define INF 0x7ffffff
class Solution {
int pathl[1000][1000];    
public:
    int minPathSum(vector>& grid) {
        int m = grid.size(), n = grid[0].size();
        int i,j,leftl ,upl;
        
        for(i = 0;i < m;i++){
            for(j = 0; j < n;j++){
                if(i == 0 && j == 0){
                    pathl[i][j] = grid[0][0];
                    continue;
                }
                if(j != 0)
                    leftl = pathl[i][j-1] + grid[i][j];
                else leftl = INF;
                if(i != 0)
                    upl = pathl[i-1][j] + grid[i][j];
                else upl = INF;
                pathl[i][j] = leftl < upl?leftl : upl;
            }
        }
        return pathl[m-1][n-1];
    }
};

但是显然这样有很多不必要的开销，特别是内存方面，开得太多。

实际上可以开一个一维数组即可。 每次维护一个每列当前最小值

然后按照一行行下去进行当前最小值的判断

class Solution {
public:
    int minPathSum(vector>& grid) {
        int m = grid.size(), n = grid[0].size();
        int i,j,leftl ,upl;
        vector pathl(n,0);  //每一列的当前最小值
        pathl[0] = grid[0][0];
        for(j = 1;j < n; j++)
            pathl[j] = pathl[j-1] + grid[0][j];
        for(i = 1;i < m; i++){
            pathl[0] = pathl[0] + grid[i][0];
            for(j = 1;j < n;j++)
                pathl[j] = grid[i][j] + min(pathl[j-1],pathl[j]);
        }   
        return pathl[n-1];
    }
};

方法1需要30ms， 而方法二只需要9ms