[Swift]LeetCode437. 路径总和 III | Path Sum III

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9783465.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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

---

给定一个二叉树，它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。

示例：

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

      10
     /  
    5   -3
   /     
  3   2   11
 /    
3  -2   1

返回 3。和等于 8 的路径有:

1.  5 -> 3
2.  5 -> 2 -> 1
3.  -3 -> 11

---

40ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    
    func pathSum(_ root: TreeNode?, _ sum: Int) -> Int {
        var dict = [Int: Int]()
        dict[0] = 1
        return getNum(root, 0, sum, &dict)
    }
    
    func getNum(_ rootNode: TreeNode?, _ curSum: Int, _ target: Int, _ dict: inout [Int: Int]) -> Int {
        guard let root = rootNode else {
            return 0
        }
        var tempSum = curSum
        tempSum += root.val
        var res = dict[tempSum-target] ?? 0
        dict[tempSum] = (dict[tempSum] ?? 0) + 1
        print(tempSum)
 
        res += getNum(root.left, tempSum, target, &dict) + getNum(root.right, tempSum, target, &dict)
        dict[curSum+root.val] = (dict[curSum+root.val] ?? 0) - 1
        return res
    }
}

---

44ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    
    func pathSum(_ root: TreeNode?, _ sum: Int) -> Int {
        var dict = [Int: Int]()
        dict[0] = 1
        return getNum(root, 0, sum, &dict)
    }
    
    func getNum(_ rootNode: TreeNode?, _ curSum: Int, _ target: Int, _ dict: inout [Int: Int]) -> Int {
        guard let root = rootNode else {
            return 0
        }
        var tempSum = curSum
        tempSum += root.val
        var res = dict[tempSum-target] ?? 0
        dict[tempSum] = (dict[tempSum] ?? 0) + 1
    
        res += getNum(root.left, tempSum, target, &dict) + getNum(root.right, tempSum, target, &dict)
        dict[curSum+root.val] = (dict[curSum+root.val] ?? 0) - 1
        return res
    }
}

---

52ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    
    func pathSum(_ root: TreeNode?, _ sum: Int) -> Int {
        guard let root = root else { return 0 }
        
        var result = 0
        var dict = [Int : Int]()
        dfs(root, sum, 0, [0 : 1], &result)
        
        return result
    }
    
    func dfs(_ root: TreeNode?, _ target: Int, _ prev: Int, _ dict: [Int : Int], _ result: inout Int) {
        guard let root = root else { return }
        
        let sum = root.val + prev
        if let freq = dict[sum - target] {
            result += freq
        }
        
        var newDict = dict
        newDict[sum] = (dict[sum] ?? 0) + 1
        
        dfs(root.left, target, sum, newDict, &result)
        dfs(root.right, target, sum, newDict, &result)
    }
}

---

84ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    
    func pathSum(_ root: TreeNode?, _ sum: Int) -> Int {
        guard let root = root else { return 0 }
        
        var result = 0
        var dict = [Int : Int]()
        dfs(root, sum, 0, [0 : 1], &result)
        
        return result
    }
    
    func dfs(_ root: TreeNode?, _ target: Int, _ prev: Int, _ dict: [Int : Int], _ result: inout Int) {
        guard let root = root else { return }
        
        let sum = root.val + prev
        if let freq = dict[sum - target] {
            print("sum:(sum), cur:(root.val), prev:(prev)")
            result += freq
        }
        
        var newDict = dict
        newDict[sum] = (dict[sum] ?? 0) + 1
        
        dfs(root.left, target, sum, newDict, &result)
        dfs(root.right, target, sum, newDict, &result)
    }
}

---

172ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func pathSum(_ root: TreeNode?, _ sum: Int) -> Int {
        
        guard let root = root else { return 0 }
        
        return numberOfPaths(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum)
    }
    
    func numberOfPaths(_ root: TreeNode?, _ sum: Int) -> Int {
        
        guard let root = root else { return 0 }
        
        let diff = sum - root.val
        let left = numberOfPaths(root.left, diff)
        let right = numberOfPaths(root.right, diff) 
        return  diff == 0 ? 1 + left + right : left + right
    }
}