回溯算法之路径总和III

总结

今天就只做了一道题，发现自己似乎平时撸代码都很狂暴，不考虑时间空间，所以回溯算法的时候也从来不考虑恢复状态什么的，但是之后得慢慢改了！
今天遇见了一个讲算法讲得很好的gitbook，码一下
link

题目I

题解I

	int pathSum(TreeNode* root, int sum) {
        if(root==NULL){
            return 0;
        }
        int result=0;
        vector<int> temp;
        traverse(root,temp,sum,result);
        return result;
    }
    void traverse(TreeNode* p,vector<int> temp,int sum,int & result){
        if(p!=NULL){
            for(int i=0;i<temp.size();i++){
                temp[i]+=p->val;
                if(temp[i]==sum){
                    result++;
                }
            }
            if(p->val==sum){
                result++;
            }
            temp.push_back(p->val);
        }
        if(p->left!=NULL){
            traverse(p->left,temp,sum,result);
        }
        if(p->right!=NULL){
            traverse(p->right,temp,sum,result);
        }
    }

题解II

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
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.回到本层，恢复状态，去除当前节点的前缀和数量
        // 为什么要恢复状态呢？
        // 可能因为Java是引用传递而C++是值传递？
        // 对
        prefixSumCount.put(currSum, prefixSumCount.get(currSum) - 1);
        return res;
    }
}

感悟

用我自己的方法的话，就是DFS的应用，但是时间空间耗费都比较大，采用前缀和的方式，会更加巧妙