Question

我正在尝试解决此前提出的问题中列出的问题：

给定具有n个整数的数组A，其索引从0开始（即，A [0]，A [1]，...，A [n-1]）。我们可以将A解释为二叉树，其中A [i]的两个子节点是A [2i + 1]和A [2i + 2]，并且每个元素的值是树的节点权重。在这个树中，我们说如果一组顶点不包含任何父子对，则它们是“独立的”。独立集合的权重只是其元素的所有权重的总和。开发一种算法来计算任何独立集合的最大权重。

但是，我正在尝试用Java解决这个问题。我已经查看了链接问题中的python解决方案，但这一行对我来说没有意义：

with_root = sum(map(find_max_independent, grandkids))+ max(true_root[root_i],0)

这个解决方案是否有Java等价物？

Answer 1

当然有Java等价物。虽然可能取决于你对“等价物”的意思。我不熟悉当前的Java，所以我只会为你理解这一行。

部分sum(map(find_max_independent, grandkids))表示：

find_max_independent(grandkids[0]) + find_max_independent(grandkids[1]) + ...

max(true_root[root_i], 0)只是当前节点的权重，如果它不是负数，否则为零（注意权重只是已知为“整数”，因此它们可能为负数）。虽然，确实没有必要检查，因为使用零意味着不包括without_root已涵盖的节点。

那个算法是btw 而不是 O（n）声称，我已经在那里写了一个评论。这是实际上的一个，也更简单：

def max_independant_weight(weights):
    def with_and_without(i):
        if i >= len(weights):
            return 0, 0
        left  = with_and_without(2*i + 1)
        right = with_and_without(2*i + 2)
        return (weights[i] + left[1] + right[1],
                max(left) + max(right))
    return max(with_and_without(0))

Answer 2

Stefan说得对，我的解决方案不起作用。所以我把他翻译成了Java。我制作了静态方法，但随意做任何你想做的事。

  public static void main(String[] args)
  {
    int[] tree = new int[] { 3, 2, 2 };

    System.out.println(max_independant_weight(tree));
  }

  private static int max(int[] array)
  {
    int max = Integer.MIN_VALUE;

    for (int i : array)
    {
      if (i > max)
      {
        max = i;
      }
    }

    return max;
  }

  private static int max_independant_weight(int[] weights)
  {
    return max(with_and_without(weights, 0));
  }

  private static int[] with_and_without(int[] weights, int i)
  {
    if (i >= weights.length)
    {
      return new int[] { 0, 0 };
    }
    int[] left = with_and_without(weights, (2 * i) + 1);
    int[] right = with_and_without(weights, (2 * i) + 2);
    return new int[] { weights[i] + left[1] + right[1], max(left) + max(right) };
  }

最大独立设定重量

2 个答案: