leetcode-113

题目描述：具体描述见原题。简单来说就是找到所有二叉树根节点到叶子节点路径值之和等于给定值的路径。

解题思路：DFS，还是递归解题，最简单暴力的递归就是记录所有根节点到叶子节点路径，遍历求和。具体过程见代码。

具体代码：

// 方法一
func pathSum(root *TreeNode, targetSum int) [][]int {
   temp, res := getSum(root), make([][]int, 0)
   for _, t := range temp{
      count := 0
      for _, v := range t{
         count += v
      }
      if count == targetSum {
         res = append(res, t)
      }
   }
   return res
}

func getSum(root *TreeNode) [][]int {
   res := make([][]int, 0)
   if root == nil {
      return res
   }
   if root.Left == nil && root.Right == nil {
      temp := make([]int, 0)
      temp = append(temp, root.Val)
      res = append(res, temp)
   }
   resL := getSum(root.Left)
   for _, l := range resL{
      l = append(l, root.Val)
      res = append(res, l)
   }
   resR := getSum(root.Right)
   for _, r := range resR{
      r = append(r, root.Val)
      res = append(res, r)
   }
   return res
}


// 方法二
func pathSum(root *TreeNode, sum int) [][]int {
   var slice [][]int
   slice = findPath(root, sum, slice, []int(nil))
   return slice
}

func findPath(n *TreeNode, sum int, slice [][]int, stack []int) [][]int {
   if n == nil {
      return slice
   }
   sum -= n.Val
   stack = append(stack, n.Val)
   if sum == 0 && n.Left == nil && n.Right == nil {
      slice = append(slice, append([]int{}, stack...))
   }
   slice = findPath(n.Left, sum, slice, stack)
   slice = findPath(n.Right, sum, slice, stack)
   return slice
}

补充说明：方法一和方法二思路是一样的，都是暴力递归解题，方法二要比方法一少1M左右空间开销。神奇的是都没有爆栈，也没有超时。优化思路应该是在递归过程中剪枝，但是我没想明白怎么剪。