[leetcode: Python]437.Path Sum 3

Title:
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

      10
     /  \
    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

寻找路径和等于给定值的路径数量

方法一：1355ms(OMG……)
遍历+递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: int
        """
        def traverse(root, val):
            if not root:
                return 0
            res = (val == root.val)
            res += traverse(root.left, val - root.val)
            res += traverse(root.right, val - root.val)
            return res
        if not root:
            return 0
        ans = traverse(root, sum)
        ans += self.pathSum(root.left, sum)
        ans += self.pathSum(root.right, sum)
        return ans

方法二：122ms

class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: int
        """
        self.count=0
        self.helper(root,sum,0,{0:1})
        return self.count

    def helper(self,root,sum,currSum,cache):
        if root:
            if ((currSum+root.val-sum) in cache):
                self.count+=cache.get(currSum+root.val-sum)
            cache[currSum+root.val] = cache.get(currSum+root.val,0)+1

            self.helper(root.left,sum,currSum+root.val,cache)
            self.helper(root.right,sum,currSum+root.val,cache)
            cache[currSum+root.val]=cache.get(currSum+root.val)-1
        return

方法三：76ms(to be understood)

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
from collections import defaultdict
class Solution(object):
    def inorder(self, root, target, summ, di):
        if not root:
            return 0
        summ += root.val
        numWays = di[summ-target]
        di[summ] += 1
        numWays += self.inorder(root.left, target, summ, di) + self.inorder(root.right, target, summ, di)
        di[summ] -= 1
        return numWays

    def pathSum(self, root, target):
        di = defaultdict(int)
        di[0] = 1
        return self.inorder(root, target, 0, di)

        """
        :type root: TreeNode
        :type sum: int
        :rtype: int
        """

方法四：79ms（+1）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
import collections
class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: int
        """
        d = collections.defaultdict(int)
        d[0] = 1
        def pSum(root, cur, sum):
            if not root: return 0
            res = 0
            cur += root.val
            if cur - sum in d:
                res += d[cur - sum]
            d[cur] += 1
            res += pSum(root.left, cur, sum) + pSum(root.right, cur, sum)
            d[cur] -= 1
            return res
        return pSum(root, 0, sum)