我可以将数组分成总和相等的两部分多少次？

Question

我想找到可以将数组划分为 2 个非空部分的次数，以使左侧分区中的元素之和等于右侧分区中的元素之和。

每次成功分区后，我们丢弃左分区或右分区，并使用剩余的分区作为数组继续播放。

最初，有一个数组，a，包含 N 个整数。 N <= 2^14

static int Compute(int[] a, int arraySize)
{
     return ComputeNumberOfPartition(a.ToList(), arraySize,  0);
}

static int ComputeNumberOfPartition(List<int> a, int N, int points)
{
     List<int> left = new List<int>();
     List<int> right = new List<int>();

     for (int i = 0; i < N; ++i)
     {
         if (sum(left) <= sum(right)) { left.Add(a[i]);  }
         else                         { right.Add(a[i]); }
     }

     if (sum(left) == sum(right))
     {
         return left.Count >= right.Count ? 
                ComputeNumberOfPartition(left, left.Count, ++points) :
                ComputeNumberOfPartition(right, right.Count, ++points);
     }

     return points;
}

static int sum(List<int> a)
{
     int sum = 0;
     for (int i = 0; i < a.Count; ++i)
     {
         sum += a[i];
     }

     return sum;
}

例如：

input1 3 3 3

output1 0

我们不能分成两部分，总和相等。因此，她的最大可能得分为 0。

input2 4 1 0 1 1 0 1

output2 3

我的解决方案很慢。我们怎样才能更有效地解决它？ 这个问题来自hackerrank

Answer 1

public Tuple<int[], int[]> SplitIntArray(int[] array, int index) {
    return new Tuple<int[], int[]>(
        array.Take(index).ToArray(),
        array.Skip(index).ToArray()
    );
}
public string AggregateSumString(int[] array) {
    return array.Select(i => i.ToString()).Aggregate((sumString, next) => 
        String.IsNullOrEmpty(sumString) ? next : String.Format("{0} + {1}", sumString, next))
}

那么，

int[] array;
var results = new List<Tuple<int[], int[]>>();

for (int i = 0; i < array.Length; i++) {
    var tuple = SplitIntArray(array, i);

    if (tuple.Item1.Sum() == tuple.Item2.Sum()) {
        results.Add(tuple);
    }            
}

// results contains all pairs of arrays that sum to the same value.
foreach (var tuple in results) {
    Console.WriteLine(
        String.Format("{0} == {1}", AggregateSumString(tuple.Item1), AggregateSumString(tuple.Item2)));
}

Answer 2

这是一个相当有效的方法：

static int CalcScore(int[] a)
{
    return CalcScore(a, 0, a.Length - 1, a.Sum(n => (long)n));
}

static int CalcScore(int[] a, int startPos, int endPos, long totalSum)
{
    long leftSum = 0;
    long rightSum = totalSum;
    for (int splitPos = startPos; splitPos < endPos; splitPos++)
    {
        leftSum += a[splitPos];
        rightSum -= a[splitPos];
        if (leftSum > rightSum) break;
        if (leftSum == rightSum)
        {
            int leftScore = CalcScore(a, startPos, splitPos, leftSum);
            int rightScore = CalcScore(a, splitPos + 1, endPos, rightSum);
            return 1 + Math.Max(leftScore, rightScore);
        }
    }
    return 0;
}

主要算法在第二种递归方法中。首先，它使用预先计算的总和。其次，它使用由startPos 和endPos 定义的包含数组索引范围，这使我们可以避免内存分配。然后它简单地从头到尾迭代 - 1 将当前值添加到左总和并从右总和中减去它，直到左总和大于右总和，在这种情况下它提前退出（这是基于以下约束值不是负数），或者如果两个总和相等，则计算拆分并递归添加左右部分的最大拆分。

更新：考虑到只有当总和可被 2 整除时，数组范围才能以相等的总和分成两部分（因此目标左右和应该是总和的一半），递归部分可以进一步优化如下：

static int CalcScore(int[] a, int startPos, int endPos, long totalSum)
{
    long halfSum = totalSum / 2;
    if (halfSum + halfSum != totalSum) return 0;
    long leftSum = 0;
    for (int splitPos = startPos; splitPos < endPos; splitPos++)
    {
        leftSum += a[splitPos];
        if (leftSum > halfSum) break;
        if (leftSum == halfSum)
        {
            int leftScore = CalcScore(a, startPos, splitPos, halfSum);
            int rightScore = CalcScore(a, splitPos + 1, endPos, halfSum);
            return 1 + Math.Max(leftScore, rightScore);
        }
    }
    return 0;
}