三角形最小路径和

原题链接

做了这个题之后 感觉收获很大

做这道题之前，以为这种题需要用记忆性递归dfs，由上而下一个节点一个节点地相加。

于是我一开始地代码是这样地：

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
 for (int i = 0; i < t.length; i++) {
            for (int j = 0; j < t[0].length; j++) {
                t[i][j] = -1;
            }
        }
        int [][] arr = new int[triangle.size()][triangle.get(triangle.size()-1).size()];
        for (int i = 0; i < triangle.size(); i++) {
            for (int j = 0; j < triangle.get(i).size(); j++) {
                arr[i][j] = triangle.get(i).get(j);
            }
        }
       return minimumTotals(arr,0,0);
    }
      int [][] t = new int[1000][1000];
    private  int minimumTotals(int [][] arr, int x,int y) {
       
        if(x==arr.length){
            return 0;
        }
         if(t[x][y]!=-1) return t[x][y];
        int a ;
        int b ;
        a=arr[x][y]+minimumTotals(arr,x+1,y+1);
        b=arr[x][y]+minimumTotals(arr,x+1,y);
        t[x][y] = Math.min(a,b);
        return Math.min(a,b);
    }
}

虽然通过了，但是消耗地时间和内存也是非常多的。

于是我将，用来记忆地数组打印了出来，发现这完全就可以用两个for循环搞定呀。
于是我将代码改成了这样

 public  static int minimumTotal(List<List<Integer>> triangle) {
        int [][] arr = new int[triangle.size()][triangle.get(triangle.size()-1).size()];
        for (int i = 0; i < triangle.size(); i++) {
            for (int j = 0; j < triangle.get(i).size(); j++) {
                arr[i][j] = triangle.get(i).get(j);
            }
        }
        System.out.println(Arrays.deepToString(arr));
       return minimumTotals(arr);
    }
    private static int minimumTotals(int [][] arr) {
        for (int i = arr.length - 2; i >= 0; i--) {
            for (int j = arr[0].length-2; j >= 0; j--) {
                arr[i][j]=Math.min(arr[i+1][j+1]+arr[i][j],arr[i+1][j]+arr[i][j]);
            }
        }
        System.out.println(Arrays.deepToString(arr));
        return arr[0][0];
    }

虽然没达到双九十，但是比记忆性递归强的太多了。

启发：
遇到题尽量想着用for循环做，因为for循环地执行效率比递归好很多。