如何在 O(n) 中获得数组的平衡索引？

Question

我在 C++ 中做了一个测试，要求一个函数返回一个索引，该索引将输入向量分成具有相同元素总和的两部分，例如：对于vec = {1, 2, 3, 5, 4, -1, 1, 1, 2, -1}，它可能返回 3，因为 1+2+3 = 6 = 4-1+1+1+2-1。所以我已经完成了返回正确答案的函数：

int func(const std::vector< int >& vecIn)
{
   for (std::size_t p = 0; p < vecin.size(); p++)
   {
      if (std::accumulator(vecIn.begin(), vecIn.begin() + p, 0) == 
          std::accumulator(vecIn.begin() + p + 1, vecIn.end(), 0))
             return p;
   }
   return -1;
}

我的问题是当输入是一个很长的向量时，它只包含 1（或 -1），函数的返回很慢。所以我想到了从中间开始搜索想要的索引，然后左右走。但我认为最好的方法是索引在合并排序算法顺序中，这意味着：n/2、n/4、3n/4、n/8、3n/8、5n/8、7n/ 8... 其中 n 是向量的大小。有没有办法在公式中写下这个顺序，以便我可以在我的函数中应用它？

谢谢

---

编辑 在一些 cmets 之后，我不得不提到我几天前已经完成了测试，所以我忘了放并提到没有解决方案的部分：它应该返回 -1...我也更新了问题标题。

Answer 1

专门针对这个问题，我会使用以下算法：

1. 计算向量的总和。这给出了两个和（空向量和全向量）
2. 对于每个元素，将一个元素从满移动到空，这意味着将下一个元素的值从 sum(full) 添加到 sum(empty)。当两个总和相等时，您就找到了索引。

这给出了一个 o(n) 算法而不是 o(n2)

Answer 2

您可以更快地解决问题，而无需在每个步骤中调用std::accumulator：

int func(const std::vector< int >& vecIn)
{
   int s1 = 0;
   int s2 = std::accumulator(vecIn.begin(), vecIn.end(), 0);
   for (std::size_t p = 0; p < vecin.size(); p++)
   {
       if (s1 == s2)
           return p;
       s1 += vecIn[p];
       s2 -= vecIn[p];
   }
}

这是O(n)。在每一步，s1 将包含第一个 p 元素的总和，s2 将包含其余元素的总和。移动到下一个元素时，您可以使用加法和减法更新它们。

由于std::accumulator 需要迭代你给它的范围，你的算法是O(n^2)，这就是为什么它对许多元素来说这么慢。

Answer 3

回答实际问题：您的序列 n/2, n/4, 3n/5, n/8, 3n/8 可以重写为

1*n/2
1*n/4 3*n/4
1*n/8 3*n/8 5*n/8 7*n/8
...

也就是说，分母从 i=2 以 2 的幂为单位，而提名者从 j=1 到 i-1 以 2 为步长。但是，这不是您实际问题所需要的，因为你给出的例子有 n=10。显然你不希望 n/4 在那里 - 你的索引必须是整数。

这里最好的解决方案是递归。给定一个范围 [b,e]，选择一个中间值 (b+e/2) 并将新范围设置为 [b, (b+e/2)-1] 和 [(b+e/2)=1 , e]。当然，专门化长度为 1 或 2 的范围。

Answer 4

考虑到 MSalters cmets，恐怕另一种解决方案会更好。如果您想使用更少的内存，也许选择的答案就足够了，但是要找到可能的多个解决方案，您可以使用以下代码：

static const int arr[] = {5,-10,10,-10,10,1,1,1,1,1};
std::vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

// compute cumulative sum
std::vector<int> cumulative_sum( vec.size() );
cumulative_sum[0] = vec[0];
for ( size_t i = 1; i < vec.size(); i++ )
{ cumulative_sum[i] = cumulative_sum[i-1] + vec[i]; }

const int complete_sum = cumulative_sum.back();

// find multiple solutions, if there are any
const int complete_sum_half = complete_sum / 2; // suggesting this is valid...
std::vector<int>::iterator it = cumulative_sum.begin();
std::vector<int> mid_indices;
do {
  it = std::find( it, cumulative_sum.end(), complete_sum_half );

  if ( it != cumulative_sum.end() )
  { mid_indices.push_back( it - cumulative_sum.begin() ); ++it; }

} while( it != cumulative_sum.end() );

for ( size_t i = 0; i < mid_indices.size(); i++ )
{ std::cout << mid_indices[i] << std::endl; }

std::cout << "Split behind these indices to obtain two equal halfs." << std::endl;

这样，您可以获得所有可能的解决方案。如果没有解决方案将向量一分为二，则 mid_indices 将留空。 同样，您只需对每个值求和一次。

我的建议是这样的：

static const int arr[] = {1,2,3,5,4,-1,1,1,2,-1};
std::vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

int idx1(0), idx2(vec.size()-1);
int sum1(0), sum2(0);
int idxMid = -1;
do {
  // fast access without using the index each time.
  const int& val1 = vec[idx1];
  const int& val2 = vec[idx2];

  // Precompute the next (possible) sum values. 
  const int nSum1 = sum1 + val1;
  const int nSum2 = sum2 + val2;

  // move the index considering the balanace between the 
  // left and right sum.
  if ( sum1 - nSum2 < sum2 - nSum1 )
  { sum1 = nSum1; idx1++; }
  else
  { sum2 = nSum2; idx2--; }

  if ( idx1 >= idx2 ){ idxMid = idx2; }

} while( idxMid < 0 && idx2 >= 0 && idx1 < vec.size() );

std::cout << idxMid << std::endl;

不管有多少值，它只会将每个值添加一次。这样它的复杂性只有 O(n) 而不是 O(n^2)。

代码只是从左右同时运行，如果它的一侧低于另一侧，则将索引移动得更远。

Answer 5

你想要你提到的系列的第 n^th 个词。那么它会是：

numerator:   (n - 2^((int)(log2 n)) ) *2 + 1
denominator:  2^((int)(log2 n) + 1) 

Answer 6

我在 Codility 测试中遇到了同样的问题。上面有一个类似的答案（没有通过一些单元测试），但下面的代码段在测试中是成功的。

#include <vector>
#include <numeric>
#include <iostream>

using namespace std;

// Returns -1 if equilibrium point is not found
// use long long to support bigger ranges
int FindEquilibriumPoint(vector<long> &values) {
    long long lower = 0;
    long long upper = std::accumulate(values.begin(), values.end(), 0);

    for (std::size_t i = 0; i < values.size(); i++) {

        upper -= values[i];

        if (lower == upper) {
            return i;
        }

        lower += values[i];
    }

    return -1;
}


int main() {
        vector<long> v = {-1, 3, -4, 5, 1, -6, 2, 1};

        cout << "Equilibrium Point:" << FindEquilibriumPoint(v) << endl;

        return 0;
}

输出 平衡点：1

Answer 7

这是Javascript中的算法：

function equi(arr){

var N = arr.length;
if (N == 0){ return -1};

var suma = 0;
for (var i=0; i<N; i++){
    suma += arr[i];
}

var suma_iz = 0;
for(i=0; i<N; i++){
    var suma_de = suma - suma_iz - arr[i];
    if (suma_iz == suma_de){
        return i};
    suma_iz += arr[i];
}

return -1;

}

如你所见，这段代码满足 O(n) 的条件