<LeetCode OJ> 112/113. Path Sum(I / II)

本文探讨了给定二叉树及目标和的情况下,寻找所有从根节点到叶节点且路径数值等于给定和的问题。提供了两种解决方案,一种判断是否存在满足条件的路径,另一种收集所有满足条件的路径。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Given a binary tree and a sum, determine if the tree has a root-to-leaf path 

such that adding up all the values along the path equals the given sum.

For example:
Given the below binary tree and  sum = 22,
              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.



分析:

写在看别人答案之前:

1,不知道如何判断不是pathsum的情况,因为无法根据某一条不是就返回fasle。如果是倒数好判断

以下是错误答案,只通过了69个案例,有朝一日再来看

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
     bool getDfsSums (TreeNode* node, int pathsum) {
            if(!node->left && !node->right )    
             {
                if(pathsum==dstsum)  
                    return true;
                else
                    return false;
             }
            if(node->left)  
                getDfsSums(node->left, pathsum+node->val);  
            if(node->right)  
                getDfsSums(node->right, pathsum+node->val);
        } 
    bool hasPathSum(TreeNode* root, int sum) {
        if(!root)   
            return false;
        dstsum=sum;
        return getDfsSums(root, root->val);  
    }
    int dstsum;
};


别人的答案

原来用或运算来判断有true的路劲

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
//别人的答案:(我的分析)分多条路劲找,寻找结果进行或运算,只要有一条是真的,全部都是真的
//这么简单的答案,艹...我有罪!
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(!root)
            return false;
        if(!root->left && !root->right ){
            if(root->val==sum)
                return true;
            else
                return false;
        }
        return hasPathSum(root->left, sum-(root->val)) || hasPathSum(root->right, sum-(root->val));
    }
};


学习和改写别人的答案:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
     bool IsPathSum (TreeNode* node, int pathsum) {  //此时的pathsum并未机上当前node的节点值(如果不为NULL的话)
        if(!node)  
            return false;  
        if(!node->left && !node->right ){  
            if(pathsum+node->val==dstsum)  //如果加上当前节点就是sum,结果已出
                return true;  
            else  
                return false;  
        }           
        return IsPathSum(node->left, pathsum+node->val)||IsPathSum(node->right, pathsum+node->val); //直接在函数中加上当前节点的值 
    }   
    bool hasPathSum(TreeNode* root, int sum) {
        if(!root)  
            return false;  
        dstsum=sum;    
        return IsPathSum(root,0);  
    }
    int dstsum;
};




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]
]



分析:
深度优先搜索,利用递归保存中间的计算结果,递归到叶子即刻判断和是否为目标sum

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    void getDfsSums(vector<int> ans, TreeNode* node, int pathsum) {  
            ans.push_back(node->val);
            pathsum+=node->val;
            
            if(!node->left && !node->right)  {    
                if(pathsum==dstsum) result.push_back(ans);
                return;  
            }
           
            if(node->left)  
                getDfsSums(ans, node->left, pathsum);  
            if(node->right)  
                getDfsSums(ans, node->right, pathsum);
        } 
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        if(!root)   
            return result;
        vector<int> ans;
        dstsum=sum;
        getDfsSums(ans, root, 0);  
        return result;     
    }
    int dstsum;
    vector< vector<int> > result;  
};


注:本博文为EbowTang原创,后续可能继续更新本文。如果转载,请务必复制本条信息!

原文地址:http://blog.csdn.net/ebowtang/article/details/50495606

原作者博客:http://blog.csdn.net/ebowtang

<think>好的,我现在需要帮助用户了解“树上差分、树链剖分、树上分治、树上DUS”这几个概念。首先,用户之前已经询问过“树上统计”,现在继续深入询问更具体的算法和技术,说明他们可能正在学习算法竞赛或高级数据结构,特别是树相关的问题。 首先,我需要确定每个术语的正确含义和常见中文翻译。用户提到的“树上DUS”可能是指Disjoint Set Union(并查集)在树上的应用,但“DUS”可能是拼写错误,正确缩写应为DSU(Disjoint Set Union),也就是并查集。因此,我需要确认这一点,并在回答时做出说明。 接下来,每个术语的解释需要准确且易于理解。用户可能希望了解这些技术的基本思想、应用场景以及可能的代码示例。考虑到用户之前的问题中有代码示例,可能期望这里也有类似的示例,但需要根据复杂度决定是否提供。 对于“树上差分”,需要解释其与数组差分的区别,以及在树结构中的应用,比如处理路径更新和子树查询。常见的例子是离线处理多次路径修改后的节点值统计。 树链剖分(重链剖分)主要用于将树分割成链,以便高效处理路径查询。需要解释其原理、步骤(如重儿子选择、DFS序划分)以及应用,比如结合线段树处理路径上的操作。 树上分治可能指的是点分治或边分治,用于处理树上的路径问题,比如统计满足某些条件的路径数量。点分治通过选择重心分解树,降低问题复杂度,需要说明其步骤和优势,比如处理O(n log n)复杂度的问题。 “DUS”如果是DSU的话,通常用于处理连通性问题,但在树上的应用可能涉及离线查询,比如Tarjan算法求LCA。需要说明如何利用并查集处理树上的离线查询,如连接节点并处理查询。 在组织回答时,需要结构清晰,每个部分分点说明,包括基本思想、应用场景、实现步骤和示例。同时,要注意术语的正确性,例如确认“DUS”的正确性,并在回答中做出提示,避免误解。 用户可能的深层需求是准备算法竞赛,或者解决实际问题中的树结构相关问题,因此需要强调每个技术的适用场景和优势,帮助他们选择合适的方法。此外,可能需要提供参考资料或例题链接,如LeetCode或OJ题目,方便用户进一步练习。 需要检查每个解释是否准确,比如树链剖分是否确实用于路径查询,点分治是否用于路径统计等。同时,确保语言简洁,避免过于技术化的术语,必要时用比喻或示例帮助理解。 最后,确保回答覆盖用户提到的所有四个术语,没有遗漏,并对可能的拼写错误进行纠正说明,以提升回答的准确性和帮助性。</think>以下是关于 **树上差分、树链剖分、树上分治、树上DUS** 的详细介绍,结合它们的核心思想和应用场景: --- ## **1. 树上差分** ### **基本思想** - 树上差分是 **处理树上的区间/路径修改** 的高效方法,类似于数组的差分思想。通过标记路径的起点和终点,最后通过一次遍历(如DFS)累加标记,得到最终结果。 - **典型场景**:多次对树上的某条路径进行增减操作(如边权或节点权值的修改),最后统一查询每个节点的最终值。 ### **实现步骤** 1. **路径标记**:对于路径 `u → v`,在差分数组中将 `u` 和 `v` 的权值增加,同时将它们的最近公共祖先(LCA)的权值减少两次(抵消多余贡献)。 2. **后序遍历累加**:通过DFS从叶子到根累加差分值,得到每个节点的最终值。 ### **示例问题** - **题目**:给一棵树,多次操作在路径 `u→v` 上所有节点权值 +k,最后查询每个节点的值。 - **代码片段**: ```python def tree_diff(u, v, lca, k, diff): diff[u] += k diff[v] += k diff[lca] -= k if parent[lca] exists: diff[parent[lca]] -= k ``` --- ## **2. 树链剖分(重链剖分)** ### **基本思想** - 将树分割为若干条 **重链**(Heavy Path),使得树上任意路径的查询/修改可转化为对 `O(log n)` 条链的操作,从而结合线段树等数据结构高效处理。 - **核心概念**: - **重儿子**:子树大小最大的子节点。 - **轻边**:连接非重儿子的边。 - **DFS序**:按遍历顺序将节点映射到连续区间,便于线段树维护。 ### **应用场景** - 路径查询:求路径上的最大值、和、或修改路径上的权值。 - 子树查询:子树权值统计。 ### **代码实现(简化步骤)** ```python def dfs(u, parent): size[u] = 1 for v in children[u]: if v != parent: dfs(v, u) size[u] += size[v] if size[v] > size[heavy[u]]: heavy[u] = v # 标记重儿子 def decompose(u, head): top[u] = head # 当前链的顶端 if heavy[u] exists: decompose(heavy[u], head) # 优先处理重儿子(形成重链) for v in light_children[u]: decompose(v, v) # 轻边开启新链 ``` --- ## **3. 树上分治(点分治/边分治)** ### **基本思想** - **点分治**:通过选择树的重心(删除后最大子树最小的节点)将树分解为多个子树,递归处理每个子树的路径问题,合并时统计跨重心的路径。 - **边分治**:类似点分治,但选择一条边分割树(较少用,因树可能需重构为二叉树)。 ### **应用场景** - 统计满足条件的路径数量(如路径长度 ≤ k)。 - 经典问题:树的重心分解后处理所有路径的组合。 ### **点分治步骤** 1. 找到当前树的重心,删除重心后分裂为多个子树。 2. 计算经过重心的所有路径贡献。 3. 递归处理每个子树。 ### **示例问题** - **题目**:求树上路径长度等于 k 的路径数(LeetCode [437. 路径总和 III](https://leetcode.cn/problems/path-sum-iii/) 的扩展)。 --- ## **4. 树上DUS(Disjoint Set Union,并查集)** ### **基本思想** - 在树上应用并查集(DSU),通常用于 **离线处理连通性问题** 或 **路径压缩查询**。例如: - **Tarjan离线LCA算法**:通过DFS和并查集,预处理所有查询的最近公共祖先。 - **动态连通性**:处理树的边删除或动态连接。 ### **实现示例(Tarjan求LCA)** ```python def tarjan(u): visited[u] = True for v in children[u]: tarjan(v) union(u, v) # 将子节点合并到当前节点 for query_v in queries[u]: if visited[query_v]: lca = find(query_v) # 通过并查集找到LCA ``` --- ## **对比与应用场景** | 方法 | 核心用途 | 时间复杂度 | 典型问题 | |--|----------------------------| | 树上差分 | 路径批量修改 + 单次查询 | O(n + m) | 多次路径修改后统计节点值 | | 树链剖分 | 路径/子树频繁查询或修改 | O(log n) 单次 | 路径最大值、和 | | 树上分治 | 统计所有满足条件的路径 | O(n log n) | 路径长度等于k的路径数 | | 树上DUS | 离线LCA、连通性问题 | O(n α(n)) | Tarjan算法求LCA | -- 如果需要具体问题的代码实现或进一步解释,可以告诉我场景哦!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值