LeetCode

Minimum Path Sum

2013.12.21 23:32

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.

Solution1:

　　Given a 2-d matrix of size m x n, with all elements non-negative, find a down-right path that adds up to a minimal sum. This problem can be solved using dynamic programming.

　　Recurrence relation is sum[x][y] = min(sum[x - 1][y], sum[x][y - 1]) + a[x][y], where sum[x][y] is the minimum path sum of position (x, y), and a[x][y] is the element at position (x, y).

　　Time complexity is O(m * n), space complexity is O(m * n).

Accepted code:

// 1AC
class Solution {
public:
    int minPathSum(vector<vector<int> > &grid) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int m, n;
        
        m = grid.size();
        if(m <= 0){
            return 0;
        }
        
        n = grid[0].size();
        if(n <= 0){
            return 0;
        }
        
        int **arr = new int*[m];
        int i, j;
        
        for(i = 0; i < m; ++i){
            arr[i] = new int[n];
        }
        
        arr[0][0] = grid[0][0];
        for(i = 1; i < m; ++i){
            arr[i][0] = arr[i - 1][0] + grid[i][0];
        }
        for(i = 1; i < n; ++i){
            arr[0][i] = arr[0][i - 1] + grid[0][i];
        }
        for(i = 1; i < m; ++i){
            for(j = 1; j < n; ++j){
                arr[i][j] = mymin(arr[i - 1][j], arr[i][j - 1]) + grid[i][j];
            }
        }
        
        j = arr[m - 1][n - 1];
        
        for(i = 0; i < m; ++i){
            delete[] arr[i];
        }
        delete[] arr;
        return j;
    }
private:
    const int &mymin(const int &x, const int &y) {
        return (x < y ? x : y);
    }
};

Solution2:

　　Apparently, this problem still has some space for optimization. The space complexity can be reduced to linear. Since the recurrence relation only involves sum[x - 1][y] and sum[x][y - 1], the calculation of sum[x][y] only depends on the (x - 1)th and xth row (or column, if you like). Therefore, only two rows of extra space are needed for dynamic programming.

　　Time complexity is O(m * n), space complexity is O(n).

Accepted code:

// 1WA, 1AC, could've been perfect
class Solution {
public:
    int minPathSum(vector<vector<int> > &grid) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int m, n;
        
        m = grid.size();
        if(m <= 0){
            return 0;
        }
        
        n = grid[0].size();
        if(n <= 0){
            return 0;
        }
        
        int **arr = new int*[2];
        int i, j;
        int flag;
        
        for(i = 0; i < 2; ++i){
            arr[i] = new int[n];
        }
        
        flag = 0;
        arr[flag][0] = grid[0][0];
        for(i = 1; i < n; ++i){
            arr[flag][i] = arr[flag][i - 1] + grid[0][i];
        }
        for(i = 1; i < m; ++i){
            flag = !flag;
            // 1WA here, forgot to add grid[i][0]
            arr[flag][0] = arr[!flag][0] + grid[i][0];
            for(j = 1; j < n; ++j){
                arr[flag][j] = mymin(arr[!flag][j], arr[flag][j - 1]) + grid[i][j];
            }
        }
        
        j = arr[flag][n - 1];
        
        for(i = 0; i < 2; ++i){
            delete[] arr[i];
        }
        delete[] arr;
        return j;
    }
private:
    const int &mymin(const int &x, const int &y) {
        return (x < y ? x : y);
    }
};