Triangle

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.

 

public class Solution {
    public int minimumTotal(ArrayList<ArrayList<Integer>> triangle) {
        // Start typing your Java solution below
        // DO NOT write main() function
        ArrayList<Integer> current = triangle.get(triangle.size()-1);
        if (triangle.size() == 1){
            return current.get(0);
        }
        Map<String, Integer> cache = new HashMap<String, Integer>();
        int min = current.get(0) + calculate(triangle, triangle.size()-2, 0, cache);
        
        for (int i=1 ; i<=current.size()-2 ; i++) {
            int up = current.get(i) + calculate(triangle, triangle.size()-2, i-1, cache);
            if (up < min)
                min = up;
            up = current.get(i) + calculate(triangle, triangle.size()-2, i, cache);
            if (up < min)
                min = up;
        }
        
        int up = current.get(current.size()-1) + calculate(triangle, triangle.size()-2, current.size()-2, cache);
        if (up < min)
            min = up;
        return min;
    }
    
    private int calculate(ArrayList<ArrayList<Integer>> triangle, int listIndex, int numIndex, Map<String, Integer> cache) {
        ArrayList<Integer> current = triangle.get(listIndex);
        if (listIndex == 0){
            return current.get(0);
        }
        
        if (numIndex == 0){
            int resultTmp = calculate(triangle, listIndex-1, 0, cache);
            cache.put((listIndex-1) + "--" + 0, resultTmp);
            return current.get(0) + resultTmp;
        }
        
        if (numIndex == current.size()-1) {
            
            return current.get(current.size()-1) + cache.get((listIndex-1) + "--" + (current.size()-2));
        }
        
        int upLeft = current.get(numIndex) + cache.get((listIndex-1) + "--" + (numIndex-1));
        
        int rightResultTmp = calculate(triangle, listIndex-1, numIndex, cache);
        int upRight = current.get(numIndex) + rightResultTmp;
        cache.put((listIndex-1) + "--" + numIndex, rightResultTmp);
        
        return (upLeft<upRight) ? upLeft : upRight;
    }
}