路径总和问题

1. 方法就两种 普通dfs和 双层dfs（也就是for循环遍历每一个节点）

2. 有的情况 比如你要操作到全局变量的时候 必须恢复现场 

1.路径总和2

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<Integer> list1 = new ArrayList<>();
        helper(root,targetSum,list1);
        return ans;
    }

    public void helper(TreeNode root, int targetSum, List<Integer> list) {
        
        if (root == null) {
            return;
        }
        list.add(root.val);
        targetSum -= root.val;

        if (root.left == null && root.right == null && targetSum == 0) {
            ans.add(new ArrayList(list));   //一定要新创建
            list.remove(list.size() - 1);    // 恢复现场
            return;
        }

        helper(root.left, targetSum,list);
        helper(root.right, targetSum,list);
        list.remove(list.size() - 1);
    }
 
}

 注意

 就很简单的dfs遍历，但是有两个注意点：

1. 你要回溯，也就是 在你走到头之后， 如果当前情况不符合答案，你要恢复现场，不然会对结果造成影响

2. 你用全局变量ans将他们存起来，在发现找到答案的时候，你要进行重新创一个new ArrayList来存储，否则 你在后续恢复现场的时候，会对刚才的ans里面的东西也造成改变。 List好蠢。。。

回溯很重要，

一般来说，如果你操作的东西 是你现场捏造的，那你不用回溯。

但是如果是大家都会用的，你分类讨论的时候都去操作它，那由于内存共享，永远都是错的。

   public void helper(TreeNode root, int targetSum, List<Integer> list) {
        
        if (root == null) {
            return;
        }


        if (root.left == null && root.right == null && targetSum == 0) {
            ans.add(new ArrayList(list));
            return;
        }

        if(root.left != null) {
            list.add(root.left.val);
            helper(root.left, targetSum-root.left.val,list);
            
        }

        if(root.right != null) {
            list.add(root.right.val);
            helper(root.right, targetSum-root.right.val,list);
           
        }

        
    }
 
}

---

 路径总和3

思路

碰见这种题，你想的是 每一步分类讨论，

因为他含括了 1. 求sum    2. 必须是连续的     3. 分类讨论每一步拿或不拿

class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        
        return helper(root,targetSum,0,0);
    }

    public int helper(TreeNode root, int targetSum, int now, int index) {
        
        if(root == null) return 0;
        if(targetSum == now && index>0) return 1;
        if(now > targetSum) return 0;
        int sum = 0;

        if(now == 0) {
            int l = helper(root.left,targetSum,now,index++);
            int r = helper(root.right,targetSum,now,index++);
            if(root.val == targetSum) return l+r+1;
            int l1 = helper(root.left,targetSum, root.val + now,index++);
            int r1 = helper(root.right,targetSum,root.val + now,index++);
        sum =  l + r + l1 + r1;
        }
        else {
            if(now + root.val == targetSum) return 1;
            int l1 = helper(root.left,targetSum, root.val + now,index++);
            int r1 = helper(root.right,targetSum,root.val + now,index++);
            sum = l1 + r1;
        }
        return sum;
        
}
}

这就是你的思路，但是你有没有发现：

其实你这种类型的题换成数组去做的话，只是两个for循环，撑死一个for循环+递归函数。

不可能像你一样 对数组去求目标和数目还用 递归分布讨论。

直接 用一个外循环（第一个递归函数），套用另一个循环（另一个遍历东西的递归）即可。

class Solution {
    int sum = 0;
    public int pathSum(TreeNode root, int targetSum) {
        if(root == null) return 0;
        dfs(root, targetSum);
        pathSum(root.left, targetSum);
        pathSum(root.right, targetSum);
        return sum;
    }


    public void dfs(TreeNode root, long targetSum) {
        if(root == null) return;
        if(targetSum == root.val) {sum++;}
        dfs(root.left, targetSum-root.val);
        dfs(root.right, targetSum-root.val);
    }
}

但是 你也要注意 ：

1.  即便你在某一时候找到符合答案的路jin了，还要继续向深处递归。因为有负数啊 -2 2 -2 2你这目标两个0  相当于有好几种情况
2.  targetSum不能向rest那样去等于0 就因为他这个不是背包问题。 数组里的东西可能是负数或0  如果用rest == 0的话 目标是0的情况 你上来就会判断一个sum++ 直接出错。 你可以用 当前累计是否等于 root.val
3.  root.val能取到10^9  tarsum要用long形式 不然会溢出错误 

---

招数

如果有某种情况，在某一时刻的值你不能用，另一种情况才能用的时候，你可以上标志flag = false；或者利用index++ index == 0 的时候不能利用

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
    boolean flag ;
    public int findSecondMinimumValue(TreeNode root) {
        
        min1 = root.val;
        dfs(root);
        if(min2 == Integer.MAX_VALUE && flag==false) return -1;
        return min2;
    }

    public void dfs(TreeNode root) {
        if(root == null) return;
        
        if(root.val <= min2 && root.val > min1) {min2 = root.val; flag = true;}
        dfs(root.left);

        dfs(root.right);
    }
}

防的就是当第二大的时候是Integer.MAX_VALUE；