给定总和的二叉树中的路径数

Question

我正在解决问题https://leetcode.com/problems/path-sum-iii/ 在这里我也简单提一下： 在二叉树中求总和 = 总和的路径数。路径不一定必须从根（叶）开始（结束）。只要路径向下，就应该被视为有效路径。

这是我的解决方案：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

public class Solution {
    public int pathSum(TreeNode root, int sum) {
        int path = 0;
        if(root.val == sum)
            return 1;
        else if(root.left == null && root.right == null)
            return 0;
        if(root.left != null){
            path += pathSum(root.left, sum - root.val);
            path += pathSum(root.left, sum);
        }
        if(root.right != null){
            path += pathSum(root.right, sum - root.val);
            path += pathSum(root.right, sum);
        }
        return path;
    }
}

根据他们的系统，答案是 3，但对于以下输入，我得到的答案是 4：

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

我花了好几个小时试图解释为什么我的代码不起作用，但我无法找出问题所在。

抱歉问了一个幼稚的问题 :( 但这让我很生气！

Answer 1

我不确定您的解决方案有什么问题，但我认为它不正确。一方面，如果您的根为 8，您将立即返回并仅将根计为解决方案。我会这样做：

import java.util.ArrayList;

public class Solution {
    public static int pathSum(TreeNode root, int sum) {
      return pathSum(root, sum, 0, new ArrayList<Integer>());
    }

    public static int pathSum(TreeNode root, int sum, int count, ArrayList<Integer> arr) {
        arr.add(root.val);
        int acc = 0;
        for (int i=arr.size()-1; i>=0; i--) {
          acc += arr.get(i);
          if (acc == sum)
            count++;
        }
        if(root.left != null)
            count = pathSum(root.left, sum, count, arr);
        if(root.right != null)
            count = pathSum(root.right, sum, count, arr);
        arr.remove(arr.size()-1);
        return count;
    }

  static class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int v) {
      this.val = v;
    }
  }

  public static void main(String[] args) {
    TreeNode root = new TreeNode(10);
    root.left = new TreeNode(5);
    root.right = new TreeNode(-3);
    root.left.left = new TreeNode(3);
    root.left.right = new TreeNode(2);
    root.right.right = new TreeNode(11);
    root.left.left.left = new TreeNode(3);
    root.left.left.right = new TreeNode(-2);
    root.left.right.right = new TreeNode(1);
    System.out.println(pathSum(root, 8));
  }
}

我们的想法是在递归遍历树时使用沿路径的值填充 aarray，确保在返回时删除元素。当您访问一个节点时，您必须考虑从该节点到根路径上的任何节点的所有总和。它们中的任何一个都可以增加您的参考价值。这个实现是 O(nlogn)，当你遍历 n 个节点时，你遍历一个 len 数组直到 log(n)。

Answer 2

你的代码不能满足这个约束：

these nodes should be continuous.

例如这棵树的根（值10）和这棵树的叶（值-2），它们之和等于8。但它不满足连续，所以它不能计数。

很遗憾，您的代码无法过滤这种情况。

另一种解决方案：

public class Solution {
public int pathSum(TreeNode root, int sum) {
    int path = traverse(root,sum);
    return path;
}

public int traverse(TreeNode root, int sum){
    int path = 0;
    if(root==null){
        return 0;
    }
    else{
        path += calcu(root,sum);
        path += traverse(root.left,sum);
        path += traverse(root.right,sum);
        return path;
    }
}

private int calcu(TreeNode root, int sum) {
    if(root==null){
        return 0;
    }
    else if(root.val==sum){
        return 1 + calcu(root.left,sum-root.val)+calcu(root.right,sum-root.val);
    }
    else{
        return calcu(root.left,sum-root.val)+calcu(root.right,sum-root.val);
    }
}
}

解释：traverse这棵树并把每一个treeNode作为根节点，在连续的前提下找到目标路径。

Answer 3

您的解决方案的问题在于，如果您处于新的内部路径中，您不会从初始总和开始。

因此，当您移动内部路径时，您应该同时跟踪累计总和和原始总和。

在下面找到您的算法的修改副本。

public static class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    boolean visitedAsRoot = false;

    TreeNode(int x) {
        val = x;
    }
}

public static int pathSum(TreeNode root, int accomulate, int sum) {
    int path = 0;
    if (root.val == accomulate)
        return 1;
    else if (root.left == null && root.right == null)
        return 0;
    if (root.left != null) {
        path += pathSum(root.left, accomulate - root.val, sum);
        if (!root.left.visitedAsRoot) {
            root.left.visitedAsRoot = true;
            path += pathSum(root.left, sum, sum);
        }
    }
    if (root.right != null) {
        path += pathSum(root.right, accomulate - root.val, sum);
        if (!root.right.visitedAsRoot) {
            root.right.visitedAsRoot = true;
            path += pathSum(root.right, sum, sum);
        }
    }
    return path;
}

public static void main(String args[]) {
    TreeNode t1 = new TreeNode(3);
    TreeNode t2 = new TreeNode(-2);
    TreeNode t3 = new TreeNode(1);
    TreeNode t4 = new TreeNode(3);
    TreeNode t5 = new TreeNode(2);
    TreeNode t6 = new TreeNode(11);
    TreeNode t7 = new TreeNode(5);
    TreeNode t8 = new TreeNode(-3);
    TreeNode t9 = new TreeNode(10);

    t4.left = t1;
    t4.right = t2;

    t5.right = t3;

    t7.left = t4;
    t7.right = t5;

    t8.right = t6;

    t9.left = t7;
    t9.right = t8;

    System.out.println(pathSum(t9, 8, 8));
}

Answer 4

您的解决方案的问题在于它还计算 10 - 2 = 8。其中10 是最顶部的根节点，-2 是底部叶子。它忽略了中间的所有路径。

我设法用 tamperedSum 布尔值解决了这个问题。

public static int pathSum(TreeNode root, int sum, boolean tamperedSum)  
{
    int path = 0;
    if(root.val == sum)
        path = 1;

    if(root.left == null && root.right == null)
        return path;

    if(root.left != null){
        path += pathSum(root.left, sum - root.val, true);
        if (!tamperedSum)
            path += pathSum(root.left, sum, false);
    }   
    if(root.right != null){
        path += pathSum(root.right, sum - root.val, true);
        if (!tamperedSum)
            path += pathSum(root.right, sum, false);
    }   
    return path;
}   

tamperedSum 布尔值设置为 true，当我们从原始总和中减去（节点的）值时，在本例中为 8。

我们会这样调用它：

pathSum(root, sum, false)

想法是，如果总和已被篡改，即路径上的节点值已被扣除，我们不再允许将其按原样传递到节点下方的分支。

因此，每当我们从总和中减去节点值时，我们将tamperedSum 设置为true：sum - root.value。之后，它下面的所有节点都不允许通过sum而不从中扣除它们的节点值。