【刷题】路径总和 III的思路历程

【题目】437. 路径总和 III

给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

方法1

递归可以类似dp一样的考虑。

定义 rootSum(p,val) 表示以节点 p 为起点向下且满足路径总和为 val 的路径数目

// 本身复杂度O(n)
int rootSum(TreeNode* root, int targetSum) { 
    if (!root) {
        return 0;
    }

    int ret = 0;
    if (root->val == targetSum) {
        ret++;
    } 
    // 左右两边进行
    ret += rootSum(root->left, targetSum - root->val);
    ret += rootSum(root->right, targetSum - root->val);
    return ret;
}

int pathSum(){
    int ret = rootSum();
    ret += pathSum(root->left,); // 所有节点都求一遍从头开始的个数
    ret += pathSum(root->right,);
    return ret;
}

复杂度分析：对于每一个节点，求以该节点为起点的路径数目时，则需要遍历以该节点为根节点的子树的所有节点，因此求该路径所花费的最大时间为 O(N)，我们会对每个节点都求一次以该节点为起点的路径数目，因此时间复杂度为 O(N^{2})

方法2 使用前缀和。

遇到寻找一段路经，起点和终点不确定，就想到前缀和。

前缀和 = unordered_map + 初始化

反例（我的方法）

// 我的思路：没用到前缀和，记录了最复杂的所有结果

void dfs(unordered_map<int, int>maps, TreeNode* root, int targetSum){
    if(root==nullptr){
        return;
    }

    unordered_map<int, int> new_maps;，重新移动到一个新的map里
    // 遍历所有map中的值
    for(auto &p:maps){
        new_maps[p.first+(root->val)] = p.second;
    }
    if(new_maps.find(root->val) == new_maps.end()){
        new_maps[root->val] = 1;
    }else{
        new_maps[root->val] += 1;
    }
    maps = new_maps;
    if(maps.find(targetSum) != maps.end()){
        // 这里发现ans加的其实只是maps中和targetSum相关的内容。
        ans += maps[targetSum];
    }

    dfs(maps, root->left, targetSum);
    dfs(maps, root->right, targetSum);
}

前缀和的思想：

以当前节点作为终止节点。全程使用一个【unordered_map+初始化】
// 从根节点到目前的长度curr
prefix[curr]更新，然后结合unordered_map判断是否有（curr-traget）存在

// 伪代码
int dfs(){
    
    ret = 0;
    
    ret += prefix[curr - targetSum]// 当前节点为终止节点的值
    ret += dfs(root->left, curr, targetSum); // 左树节点为终止节点的值
    ret += dfs(root->right, curr, targetSum); // 右树为终止节点的值
    
    prefix[curr]--; // 进行完之后要更新unordered_map。但是这一步不用考虑并发同步的问题，因为递归是进站出站。所以可以共用一个prefix全局变量
    
    return ret;
}

// 全部代码
unordered_map<int, int> pre;

int dfs(TreeNode* root, int curr, int targetSum){
    if(root==nullptr){
        return 0;
    }
    int ret = 0;
    curr += root->val;
    if(pre.count(curr-targetSum)){
        ret += pre[curr-targetSum];
    }

    if(pre.count(curr))
        pre[curr] ++;
    else
        pre[curr] = 1;

    ret += dfs(root->left, curr, targetSum);
    ret += dfs(root->right, curr, targetSum);

    pre[curr] --;
    return ret;
}
int pathSum(TreeNode* root, int targetSum) {
    pre[0] = 1; // 这里需要设置一个
    return dfs(root,0, targetSum);
}