437. Path Sum III(easy)-优快云博客

本文链接：https://blog.youkuaiyun.com/SourDumplings/article/details/103150416

本文探讨了在二叉树中寻找特定路径和的问题，介绍了两种算法：一种使用哈希表加深度优先搜索(DFS)，时间复杂度为O(n)；另一种采用暴力DFS，时间复杂度为O(n^2)。通过实例解析了算法的具体实现。

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

Easy

2197126FavoriteShare

You are given a binary tree in which each node contains an integer value.

Find the number of paths that sum to a given value.

The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).

The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.

Example:

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

/ \

5 -3

/ \ \

3 2 11

/ \ \

3 -2 1

Return 3. The paths that sum to 8 are:

1. 5 -> 3

2. 5 -> 2 -> 1

3. -3 -> 11

DFS加Hash表的作差算法：

C++：

/*
 * @Autor: SourDumplings
 * @Date: 2019-09-25 16:50:53
 * @Link: https://github.com/SourDumplings/
 * @Email: changzheng300@foxmail.com
 * @Description: https://leetcode.com/problems/path-sum-iii/
 */

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 * 
 * 利用哈希表加DFS算法，时间复杂度为O(n)
 * 既然不一定从root作为起点，那么我们可以利用作差的思想间接变换起点
 * 思路就是记录下从root走到当前结点时所累积的值的路径数，比如：
 *          10
           /  \
          5   -3
         / \    \
      ->3   2   11
       / \   \
      3  -2   1
 * 假设我们需要的sum是8，遍历到了箭头指向的结点3，此时当前值为18，
 * 那么我们只需要知道从根结点到当前结点的路径上，有没有路径值为18 - 8 = 10的路径，加上它的条数即可
 * 这样就间接的加上了以这个结点3为终点的路径值为8的所有路径
 */
class Solution
{
public:
    int pathSum(TreeNode *root, int sum)
    {
        unordered_map<int, int> path_num;
        int res = 0;
        path_num[0] = 1;
        dfs(root, 0, path_num, sum, res);
        return res;
    }

    void dfs(TreeNode *Node, int thisV, unordered_map<int, int> &path_num, int sum, int &res)
    {
        if (!Node)
        {
            return;
        }
        thisV += Node->val;
        res += path_num[thisV - sum];
        ++path_num[thisV];
        dfs(Node->left, thisV, path_num, sum, res);
        dfs(Node->right, thisV, path_num, sum, res);
        --path_num[thisV];
    }
};

DFS暴力算法：

Java：

/*
 * @Autor: SourDumplings
 * @Date: 2019-09-25 17:53:35
 * @Link: https://github.com/SourDumplings/
 * @Email: changzheng300@foxmail.com
 * @Description: https://leetcode.com/problems/path-sum-iii/
 * 
 * 暴力从每个点都作为起点来个DFS，时间复杂度为O(n^2)
 */

/**
* 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)
    {
        if (root == null)
        {
            return 0;
        }
        int res = 0;
        res += dfs(root, sum, 0);
        res += pathSum(root.left, sum);
        res += pathSum(root.right, sum);
        return res;
    }

    int dfs(TreeNode root, int sum, int thisV)
    {
        if (root == null)
        {
            return 0;
        }
        thisV += root.val;
        int res = 0;
        if (thisV == sum)
        {
            res++;
        }
        res += dfs(root.left, sum, thisV) + dfs(root.right, sum, thisV);
        return res;
    }
}