递归，动态规划，回溯算法，在实战中区分它们。

这一题方法很多，比如递归，动态规划。递归又分优化去重，不优化暴力。总体来说怎么弄可以。递归就是从自顶向下，动态规划就是自下而上。大同小异。如果数据量不大，这一题还可以用回溯算法。

如何回溯？

回溯思路：回溯其实很简单，我们先不管计算机，先想一下人怎么解题。最直接的方式不就是从第一行开始，把所有情况列出来，最后看条路径和最小么。回溯其实就是描述的这样的过程。
我们先来看下回溯的代码

class Solution {
    int min=Integer.MAX_VALUE;
    public int minimumTotal(List<List<Integer>> triangle) {
        back(triangle,0,0,0);
        return min;
    }
    void back(List<List<Integer>> triangle,int k,int sum,int count){
        if(k==triangle.size()){
            if(sum<min)
                sum=min;
            return;
        }
        sum+=triangle.get(k).get(count);
        //做出选择，把当前数加和sum加和
        back(triangle,k+1,sum,count+1);
        //进入下一行
        sum-=triangle.get(k).get(count);
        //撤销选择，不要这个数了，减去它
    }
}

当数据量不大时没问题。但不可忽视的是，有很多重复的递归计算。所以这一题回溯算法不太优雅。
有重复不怕，改一改，加个备忘录。计算过的递归，用本子记下来，下次直接拿出来用。
递归求解思路：
以图中例子解析，要求2到最下面的最小值，那不就是要求第二排的3或者4到最小面的最小值么，求出来加2不就完了。

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int[][] table=new int[triangle.size()][triangle.size()];
        //备忘录
      return  back(triangle,0,0,table);
        
    }
    int back(List<List<Integer>> triangle,int k,int count,int[][] table){
        if(k==triangle.size()-1){
            return triangle.get(k).get(count);
        }
        if(table[k][count]==0) 
table[k][count]=
Math.min(back(triangle,k+1,count,table),back(triangle,k+1,count+1,table))
+triangle.get(k).get(count);//递归求和
     return table[k][count];

    }
}

这是自顶向下的递归，大家可以考虑一下自底向上的动态规划。和这个过程完全相反。
快乐的编程从今天开始。再小的帆也要起航。欢迎关注微信公众号。