最大独立设定重量

Question

I'm trying to solve the problem outlined in this previously asked question:

Finding size of max independent set in binary tree - why faulty "solution" doesn't work?

Given an array A with n integers, its indexes start with 0 (ie, A[0], A[1], …, A[n-1]). We can interpret A as a binary tree in which the two children of A[i] are A[2i+1] and A[2i+2], and the value of each element is the node weight of the tree. In this tree, we say that a set of vertices is "independent" if it does not contain any parent-child pair. The weight of an independent set is just the summation of all weights of its elements. Develop an algorithm to calculate the maximum weight of any independent set.

However, I'm trying to solve this in Java. I have looked at the python solution in the linked question, but this line doesn't make sense to me:

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

Is there a Java equivalent of this solution?

Answer 1

Of course there is a Java equivalent. Though might depend on what you mean with "equivalent". I'm not fluent in current Java, so I'll just make sense of that line for you.

The part sum(map(find_max_independent, grandkids)) means:

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

And max(true_root[root_i], 0) is just the weight of the current node if it's not negative, and zero otherwise (note the weights are just known to be "integers", so they could be negative). Although, that's really not necessary to check, as using the zero means not including the node, which is already covered by without_root .

That algorithm is btw not O(n) as claimed, I wrote a comment there already. Here's one that actually is, and which is also simpler:

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

As Stefan was right that my solution did not work. So I translated his into Java. I made static methods but feel free to do whatever you want with that.

  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) };
  }