Path Sum II 总结DFS

https://oj.leetcode.com/problems/path-sum-ii/

Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.

For example:
Given the below binary tree and sum = 22,

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

return

[
   [5,4,11,2],
   [5,8,4,5]
]

解题思路：

这题和上题 Path Sum 很类似，在他的基础上，要求输出所有和为sum的path。上题讲过，这种题目一般用DFS来做，那么在递归DFS的时候，同时维护一个总的结果的List<List<Integer>> resultList，和一个当前可能的子结果List<Integer> currentList。

这道题本该一次性就写出来，无奈犯了一个非常低级的语言层面的错误。符合条件的时候，直接将currentList加入到resultList中了。这样resultList中等于是存了N个一模一样的list对象了。应该每次拷贝currenList生成一个新的对象放入resultList，就不会有问题了。代码如下：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> resultList = new ArrayList<List<Integer>>();
        List<Integer> currentList = new ArrayList<Integer>();
        DFS(root, sum, 0, resultList, currentList);
        return resultList;
    }

    public void DFS(TreeNode root, int sum, int sumCurrent, List<List<Integer>> resultList, List<Integer> currentList){
        if(root == null){
            return;
        }

        currentList.add(root.val);
        sumCurrent = sumCurrent + root.val;
        if(root.left == null && root.right == null){
            if(sumCurrent == sum){
                //之前一直错，犯了低级错误！！！resultList.add(currentList);
                resultList.add(new LinkedList(currentList));
            }
        }
        DFS(root.left, sum, sumCurrent, resultList, currentList);
        DFS(root.right, sum, sumCurrent, resultList, currentList);
        currentList.remove(currentList.size() - 1);
        //下面一行可要可不要
        // sumCurrent = sumCurrent - root.val;
    }
}

可是至少有一个问题，为什么同样是子状态，前面currentList就一定要回溯，currentSum就不要回溯？

上面的算法中，我们看到一个DFS+回溯算法的基本模样，前面提到的另外两道题DFS题目，Letter Combinations of a Phone Number 和 Word Break II 也都是这个模型。可以说，这种算法无论是在面试中还是实际编程中都是相当重要的，理解了它会有种豁然开朗的感觉。我们可以稍微总结一下。

首先，判断递归返回的条件，写在最开始。然后，处理当前节点。处理完当前节点后，DFS下一节点，最后回溯。或者循环处理当前节点内的所有可能的状态（比如上面电话号码簿里一个数字所有代表的字母，这时一般用for循环）。

回溯是这个算法的关键，下面我借用一个网友的伪代码，讲讲自己对上面的问题，也就是回溯，为什么要回溯的理解。引用的网址在下面有。

void dfs(int 当前状态)
    {
          if(当前状态为边界状态)
          {
            记录或输出
            return;
          }
          for(i=0;i<n;i++)        //横向遍历解答树所有子节点
         {
               //扩展出一个子状态。
               修改了全局变量
               if(子状态满足约束条件)
                {
                  dfs(子状态)
               }
                恢复全局变量//回溯部分
            }
    }

从上面的伪代码里我们可以看到，对当前节点的一个状态的操作，往往会包含对全局变量的修改，类似于本题中的currentList。想想递归的过程，实际上是一个树形的占空间，每个子状态都有自己的栈，存放当前的临时变量，这也就是为什么有时候递归非常耗费空间的原因。

这时我们再来看上面提出的问题，为什么同样是子状态，前面currentList就一定要回溯，currentSum就不要回溯？这里我只说Java，因为自己对C或者C++不了解。

在Java里，所有方法（或函数）的参数，只有pass by value，这和C++可以传引用是非常不同的。所以所有的primitive type，比如int, char等，传的都是值。在本题中，DFS方法的参数，sum和sumCurrent传的都是他们的数值，而不是本身，他们都是每个递归状态都会维护在自己占空间内的，所以后面的修改不会影响前面栈内的值。这就是currentSum不需要回溯的原因。用上面的伪代码来说，它不是全局变量。最后一行sumCurrent = sumCurrent - root.val;是多余的，因为它减也是减去当前栈内的值，和其他栈并不相关。

反过来，currenList是一个对象。严格来说，Java中，currentList中存的是一个内存地址，这片内存内才住着真正的对象。所以DFS方法传参的时候，pass by value，就将这个地址传了进去。在整个递归的过程中，所有对currenList的修改，都是修改的这一个内存地址，也就是这一个对象。各自自状态的栈空间里，保存的副本也仅仅是这个内存地址的值。各个递归状态对currenList的修改，都会影响其他状态。这也就是为什么currentList需要回溯的原因。dfs修改后，需要立刻恢复它到修改前的状态。

有其他网友总结的更好，我来转载下。

http://blog.csdn.net/fightforyourdream/article/details/12866861

http://blog.chinaunix.net/uid-26602509-id-3178938.html

http://blog.sina.com.cn/s/blog_779fba530100wqz9.html

http://blog.csdn.net/cdfr2321388/article/details/5725863

从这个问题上，我们还能比较好的理解Java里pass by value的实质，为什么primitive就是pass by value，而object type却感觉是pass by reference，实际上也是pass by value。

那么思路来了，我们能不能将这个currenList在每次递归的栈空间里都维护一个副本，这样就不需要回溯了嘛。下面的代码便是这样的一个实现。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> resultList = new ArrayList<List<Integer>>();
        List<Integer> currentList = new ArrayList<Integer>();
        DFS(root, sum, 0, resultList, currentList);
        return resultList;
    }

    public void DFS(TreeNode root, int sum, int sumCurrent, List<List<Integer>> resultList, List<Integer> currentList){
        if(root == null){
            return;
        }

        //回溯的关键，每次申明一个新的内存放当前状态的结果currentList，后面就不要回溯了
        List<Integer> soFarList = new LinkedList(currentList);
        soFarList.add(root.val);
        sumCurrent = sumCurrent + root.val;
        if(root.left == null && root.right == null){
            if(sumCurrent == sum){
                //之前一直错，犯了低级错误！！！resultList.add(currentList);
                resultList.add(new LinkedList(soFarList));
            }
        }
        DFS(root.left, sum, sumCurrent, resultList, soFarList);
        DFS(root.right, sum, sumCurrent, resultList, soFarList);
        //下面一步就不必要了，这个对理解回溯很重要
        // currentList.remove(currentList.size() - 1);
        //下面一行可要可不要
        // sumCurrent = sumCurrent - root.val;
    }
}

应该说，回溯放在递归方法的最后面，理解起来是有点难度的，这样一解释应该能清楚很多。

这类题目在面试中经常出现，以及DFS和BFS的区别，啥时候用啥，各自优缺点之类，需要好好理解。