LeetCode - Triangle

Triangle

2014.1.9 22:56

Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]

The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).

Note:
Bonus point if you are able to do this using only O(n) extra space, where n is the total number of rows in the triangle.

Solution:

　　First of all, you can't solve this problem with greedy strategy, i.e. choosing the smaller one on every branch you go down. It's dynamic programming.

　　Let f[i][j] be the minimum path sum you can get with a path ending at position (i, j). We have the following:

　　　　1. f[0][0] = a[0][0]; // You surely know a is an array, right?

　　　　2. f[i][i] = f[i - 1][i - 1] + a[i][i]; // i > 0

　　　　3. f[i][j] = min(f[i - 1][j - 1], f[i - 1][j]) + a[i][j]; // j > 0 && j < i

　　Time complexity is O(n^2). Space complexity is O(n). The recurrence relation indicates that the current row is only related to the previous row, thus the space needed is O(n), instead of O(n^2).

Accepted code:

// 4CE, 2WA, 1AC, calm down~
class Solution {
public:
    int minimumTotal(vector<vector<int> > &triangle) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int n;
        vector<vector<int>> vv;
        int ff;
        
        n = triangle.size();
        if(n == 0){
            return 0;
        }
        
        int i, j;
        
        for(i = 0; i < 2; ++i){
            vv.push_back(vector<int>());
            for(j = 0; j < n; ++j){
                vv[i].push_back(0);
            }
        }
        
        ff = 0;
        vv[ff][0] = triangle[0][0];
        for(i = 1; i < n; ++i){
            vv[!ff][0] = vv[ff][0] + triangle[i][0];
            for(j = 1; j < i; ++j){
                // 2WA here, wrong coding
                vv[!ff][j] = mymin(vv[ff][j - 1], vv[ff][j]) + triangle[i][j];
            }
            // 4CE here, foolish coding!!!
            vv[!ff][i] = vv[ff][i - 1] + triangle[i][i];
            ff = !ff;
        }
        
        int res = vv[ff][0];
        for(i = 1; i < n; ++i){
            res = mymin(res, vv[ff][i]);
        }
        
        vv[0].clear();
        vv[1].clear();
        vv.clear();
        
        return res;
    }
private:
    const int mymin(const int &x, const int &y) {
        return (x < y ? x : y);
    }
};