关于递归在求解路经和中的应用

觉得递归其实就是数学归纳法的逆运算。

做递归相关的题目时，有三点：

第一：明确要递归的函数要实现的功能，一定要相信这个函数可以完成任务；

第二：不要去考虑细枝末节和它时如何实现的，只考虑当前。

第三：找好终止条件；

下面我们来做路径总和的三道题：

112. 路径总和

这个题目是判断从根到叶子节点的路径和是否等于一个数。首先我们hasPathSum（root，sum）这个函数的作用是找出以root为根的树的路径和等于sum的个数，我们相信它可以实现。接下来找终止条件如果root是叶子节点的话，那么只能判断它是否等于sum，如果不等于返回0，等于返回1。如果不是的话，那么就判断左右子树和sum-root.val.

按照上面做三点来做题，首先明确hasPathSum函数可以实现判断以root为节点的树有没有和为sum的功能，如何进行下一步呢，是不是就是以左节点或者右节点为根，sum为sun-root,val呢，然后再去考虑终止条件。

代码如下：

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root==null) return false;
        if(root.left==null && root.right==null) return sum-root.val==0;
        return hasPathSum(root.left,sum-root.val) ||hasPathSum(root.right,sum-root.val);
    }
}

113. 路径总和 II

这个题目和上一题不同的是，要返回所有的路径。首先想到的是使用回溯算法。

代码如下：

class Solution {
    LinkedList<List<Integer>> res=new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        LinkedList<Integer> list=new LinkedList<>();
        dfs(root,sum,list);
        return res;
    }
    public void dfs(TreeNode root,int sum,LinkedList<Integer> list){
        if(root==null) return;
        list.add(root.val);
        if(sum==root.val && root.left==null && root.right==null){//如果是叶子节点的话，判断是否相等，相等则需要加入
            res.add(new LinkedList<>(list));  //java是值传递，需要拷贝一份，不然的话，直接add(list),最后都是同一个对象
        }
        dfs(root.left,sum-root.val,list);
        dfs(root.right,sum-root.val,list);
        list.removeLast();
    }
}

437. 路径总和 III

这个题目也是统计路径和等于某个sum的路径数量并且返回 ，但是和第一题不同的是路径不需要从根节点开始，也不需要在叶子节点结束，但是路径的方向是向下的。

这个题目使用双重递归来做。首先第一个用来递归遍历每一个节点，第二个用来统计以每个节点为根的所有满足条件的路径。代码如下

class Solution {
    public int pathSum(TreeNode root, int sum) {
        if(root==null) return 0;
        return count(root,sum)+pathSum(root.left,sum)+pathSum(root.right,sum);
    }
    //count(root,sum)统计以根为节点的路径数量；
    //pathSum(root.left,sum)以根的左子树为节点
    
  
    //寻找以此刻节点为根，路径和等于sum的路径数量
    public int count(TreeNode root,int sum){
        if(root==null) return 0;
        int head=root.val==sum?1:0;
        return head+count(root.left,sum-root.val)+count(root.right,sum-root.val);
    }
}

这个题目也可以使用前缀和来做。前缀和就是从根节点到当前节点的所有节点的和。因为存在节点值为负数的情况，因此可能存在当前前缀和等于sum的情况，继续向下遍历几个节点之后，前缀和还等于sum的情况。用map记录<当前的前缀和currsum，这个前缀和出现的次数>。此时假如我们到了C节点，此时的前缀和是currsum,我们计算一下currsum-sum,如果在map里存在这样的前缀和的话，那么说明从那个节点到C节点这个路径就是我们要的路径。那么我们将这个前缀和的数量加上即可。然后再递归进入C节点的左右子树。

还有

代码如下：

class Solution {
    public int pathSum(TreeNode root, int sum) {
        // key是前缀和, value是大小为key的前缀和出现的次数
        Map<Integer, Integer> prefixSumCount = new HashMap<>();
        // 前缀和为0的一条路径
        prefixSumCount.put(0, 1);
        // 前缀和的递归回溯思路
        return recursionPathSum(root, prefixSumCount, sum, 0);
    }

    /**
     * 前缀和的递归回溯思路
     * 从当前节点反推到根节点(反推比较好理解，正向其实也只有一条)，有且仅有一条路径，因为这是一棵树
     * 如果此前有和为currSum-target,而当前的和又为currSum,两者的差就肯定为target了
     * 所以前缀和对于当前路径来说是唯一的，当前记录的前缀和，在回溯结束，回到本层时去除，保证其不影响其他分支的结果
     * @param node 树节点
     * @param prefixSumCount 前缀和Map
     * @param target 目标值
     * @param currSum 当前路径和
     * @return 满足题意的解
     */
    private int recursionPathSum(TreeNode node, Map<Integer, Integer> prefixSumCount, int target, int currSum) {
        // 1.递归终止条件
        if (node == null) {
            return 0;
        }
        // 2.本层要做的事情
        int res = 0;
        // 当前路径上的和
        currSum += node.val;

        //---核心代码
        // 看看root到当前节点这条路上是否存在节点前缀和加target为currSum的路径
        // 当前节点->root节点反推，有且仅有一条路径，如果此前有和为currSum-target,而当前的和又为currSum,两者的差就肯定为target了
        // currSum-target相当于找路径的起点，起点的sum+target=currSum，当前点到起点的距离就是target
        res += prefixSumCount.getOrDefault(currSum - target, 0);
        // 更新路径上当前节点前缀和的个数
        prefixSumCount.put(currSum, prefixSumCount.getOrDefault(currSum, 0) + 1);
        //---核心代码

        // 3.进入下一层
        res += recursionPathSum(node.left, prefixSumCount, target, currSum);
        res += recursionPathSum(node.right, prefixSumCount, target, currSum);

        // 4.回到本层，恢复状态，去除当前节点的前缀和数量
        prefixSumCount.put(currSum, prefixSumCount.get(currSum) - 1);
        return res;
    }
}

124. 二叉树中的最大路径和

这个题目不好理解，很容易绕进去。

因为要遍历二叉树所以还是要用递归。

针对某个节点，只有三种选择：

它自己作为根，那么它的左右子节点都可以要；

要么向上返回它加上左节点，要么向上返回它加上右节点。

因为如果把节点和它的左右节点都返回的话，那么就会会出现路径交叉了。

class Solution {
    public int max=Integer.MIN_VALUE;   //这里需要一个全局变量
    public int maxPathSum(TreeNode root) {   
        getmax(root,max);
        return max;
    }
    public int getmax(TreeNode root){
        if(root==null) return 0;  //终止条件
        int left=Math.max(0,getmax(root.left));  //返回左子节点的贡献值，并和0比较，如果是负数，还不如不要。
        int right=Math.max(0,getmax(root.right));//同理
        max=Math.max(max,root.val+left+right);  //虽然不能同时将节点和他的左右节点同时返回，但是他们的值还是可以比较一下的，万一就是最大的呢
        return root.val+Math.max(left,right);  //返回节点和左右节点中较大的一个
    }
}