120. Triangle

Problem Statement: 

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 one(NOT AC): 

Divide and conquer

It is constructed in a triangle shape, however, it is a tree, but, eahc node is connectd by two node of it`s upper level except the left and right end.

For each node, we get the minimum from it`s left and right children, and goes on until it reach the next level of all leaf node.

class Solution {
public:
    // divide && conquer solution
    int FindMinPathSum(int i, int j, vector<vector<int>>& triangle){
        // termination condition
        // no any value, nothing to add to the final value.
        if (i == triangle.size()) {
            return 0;
        }
        return min(FindMinPathSum(i + 1, j, triangle), FindMinPathSum(i + 1, j + 1, triangle)) + triangle[i][j];
    }
    int minimumTotal(vector<vector<int>>& triangle) {     
        return FindMinPathSum(0, 0, triangle);
    }
};

Solution one follow up:

Dynamic programming

However, this is not an accepted solution in Leetcode since it is time limited exceeded.

Each node is connected with two upper level nodes, for this node, we need do two times dfs to find the solution, it is duplicated.

The solution is to keep a hash table or the same two dimension array with original triangle, it stores the optimal solution, if it existes, return, no need to do iteration.

I give the Solution two, it is an accepted solution(AC):

class Solution {
public:
    // dynamic programming
    int FindMinPathSum(int i, int j, vector<vector<int>>& hash_table, vector<vector<int>>& triangle){
        // termination condition
        // no any value, nothing to add to the final value.
        if (i == triangle.size()) {
            return 0;
        }
        if(hash_table[i][j] != INT_MAX){
            return hash_table[i][j];
        } else {
            hash_table[i][j] = min(FindMinPathSum(i + 1, j, hash_table, triangle), FindMinPathSum(i + 1, j + 1, hash_table, triangle)) + triangle[i][j];
            return hash_table[i][j];
        }
    }
    int minimumTotal(vector<vector<int>>& triangle) {
        // initialize the hash table to store the optimal solution for current node
        // to avoid duplicated dfs
        vector<vector<int>> hash_table;
        vector<int> one_level;
        for(int row = 0; row < triangle.size(); row++){
            one_level.clear();
            for(int col = 0; col < triangle[row].size(); col++){
                one_level.push_back(INT_MAX);
            }
            hash_table.push_back(one_level);
        }
        return FindMinPathSum(0, 0, hash_table, triangle);
    }
};

Solution three(AC):

It is a bottom to top, it is pretty easy to understand, we should start from the last two level to loop, the code is as following:

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        for(int i = triangle.size()-2; i>=0; i--){
            for(int j = 0; j<triangle[i].size(); j++){
                triangle[i][j] += min(triangle[i+1][j], triangle[i+1][j+1]);
            }
        }
        return triangle[0][0];
    }
};

Solution four(AC):

It is a top to bottom solution, we start to loop from second row and do boundary check for the first and last element in each row. The code is as following:

class Solution {
public:
    // top to bottom 
    int minimumTotal(vector<vector<int>>& triangle) {
        for(int i = 1; i < triangle.size(); i++){
            for(int j = 0; j < triangle[i].size(); j++){
                // boundary check
                // the minimum path sum of the first element in each row
                if (j == 0) {
                    triangle[i][j] += triangle[i - 1][0];
                } else if (j == triangle[i].size() - 1) {
                    // the minimum path sum of the last element in each row
                    triangle[i][j] += triangle[i - 1][j - 1];
                } else {
                    // other elements
                    triangle[i][j] += min(triangle[i - 1][j - 1], triangle[i - 1][j]);
                }
            }
        }
        int last_row_idx = triangle.size() - 1;
        int min_path_sum = INT_MAX;
        // find the minimum value of last row
        for(int i = 0; i < triangle[last_row_idx].size(); i++){
            min_path_sum = min(min_path_sum, triangle[last_row_idx][i]);    
        }
        return min_path_sum;
    }
};