Question

这个问题来自一个很棒的YouTube频道，提出了可以在采访中提出的问题。

它基本上与在数组中找到平衡点有关。这是一个最好地解释它的例子; {1,2,9,4，-1}。在这里，因为sum（1 + 2）= sum（4 +（ - 1））使得9 平衡点。在没有检查答案的情况下，我决定在想要询问是否可以采用更有效的方法之前实施算法;

汇总数组 O（n）
获得一半的总和 O（1）
从左侧开始扫描阵列，并在 sumleft 大于一般总和的一半时停止。 O（n）的
在右边做同样的事情，以获得总和权。 O（n）。
如果 sumleft 等于 sumright 则返回 arr [size / 2] 否则返回 -1

我问，因为这个解决方案毫不费力地突然出现在我脑海中，提供了O（n）运行时间。这个解决方案，如果是真的，可以开发，或者如果不是真的任何替代方法？

Answer 1

你的算法不好（反例：1 -1 1 0 1 -1 1），好的解决方案是计算数组的部分和（这样你就可以计算sumleft和sumright in O（1）对于数组的每个单元格然后（或者在同一时间，如果你已经知道全局和）在你的数组中搜索一个单元格，使sumleft = sumright为O（n）。

数组A的部分和是

[A[0], A[0]+A[1], A[0]+A[1]+A[2], …, A[0]+A[1]+A[2]+…+A[n-1]]

示例：

A=[5,2,3,1,4,6]
partial sum = [5,7,10,11,15,21]

使用此数组，您可以计算sumleft[i]=partial_sum[i-1]和sumright[i]=partial_sum[n-1]-partial_sum[i]

改进：

首先计算全局和，然后只计算当前索引的部分和，这样，如果存储所有partial_sum数组，则只能使用O（1）额外空间而不是O（n）额外空间。

Answer 2

我实际上有2个起点，一个在最左边的点（leftLoc），一个在最右边的点（rightLoc）。保持sumLeft和sumRight数字。

leftLoc  = 0;
rightLoc = (n - 1);
sumRight = array[rightLoc];
sumLeft  = array[leftLoc];

while(leftLoc < rightLoc){
    if(sumRight > sumLeft){
        leftLoc++;
        sumLeft += array[leftLoc];
    }else{
        rightLoc--;
        sumRight += array[rightLoc];
    } 
}

if( (sumRight + array[rightLoc - 1]) == sumLeft ){
    return rightLoc--;
}else if( (sumLeft + array[leftLoc + 1]) == sumRight){
    return leftLoc++;
}else{
    // return floating point number location in the middle of the 2 locations
}

一直跟踪已经移动了多少总位置O（n）

您可能会发现您的平衡点是最终点中间的浮点数（一旦它们位于彼此相邻的整数位置）。

应该甚至可以使用负数示例。也许我错过了一些细粒度的细节，但是这个主题的一些变化应该会导致你的O（n）运行时算法。

Answer 3

您正在寻找质心或质心。在纯Python中：

def centroid(input_list):
    idx_val_sum = 0.0
    val_sum = 0.0
    for idx,val in enumerate(input_list):
        idx_val_sum += idx*val
        val_sum += val
    return idx_val_sum/float(val_sum)

O（n），如果非整数结果格式不正确，您可以使用模数检查拒绝它们：

def integer_centroid(input_list):
    idx_val_sum = 0.0
    val_sum = 0.0
    for idx,val in enumerate(input_list):
        idx_val_sum += idx*val
        val_sum += val
    out = idx_val_sum/float(val_sum)
    if out%1.0==0.0:
        return out
    else:
        raise ValueError("Input list has non-integer centorid.")

本帖应该是对2012年6月14日评论的回响，但我没有足够的声誉。 “订单”在idx_val_sum中隐式跟踪，这是按值加权的累计位置总和。

修改

马特，谢谢你的观察。我认为这是一个伪代码问题，但现在我看到了C ++标签。这是一些（未经测试的）C ++，带有注释。

一个直观的例子是一个简单的杠杆臂问题：如果你有一个杠杆，有两个力 f1 ， f2 在 x1 和 x2 ，您可以通过在位置（f1 * x1 + f2 * x2）/（f1 + f2）处施加力来阻止系统旋转。连续系统需要集成在 x 和 f 的产品上，但具有离散位置和力的杠杆是这个问题的一个很好的类比。

// untested code: float centroid(float * vec, int vec_length){ float idx_val_sum = 0.0; float val_sum = 0.0; for (idx = 0; idx < vec_length; idx++){ // keep a running sum of the product of the index and the value idx_val_sum += float(idx)*vec[idx]; // similarly, keep a running sum of the index val_sum += vec[idx]; } // return the quotient of the product-sum and the index sum: return idx_val_sum/val_sum; }

Answer 4

首先将所有数字加起来。这将是O（n）操作。然后从数组的开头一直减去数组中的一个元素，直到upper == lower。因此，总订单将为O（n）。

int BalancePoint(int a[], int begin, int end) // find index of an array (balance point) such that sum of all elements before the index = sum of all elements after it; else return -1
{
    if(!a) return -1;
    else if(begin == end) return begin;

        long long upper = 0;
        long long lower = 0;

    for(int i = begin; i <= end; ++i)
    {
        upper += *(a+i);
    }

    for(int j = begin; j <= end; ++j)
    {
        upper -= *(a+j);
        if(upper == lower) return j;
        lower += *(a+j);
    }
    return -1;
}

使用STL

int BalancePointSTL( const vector<int> &A ) // find index of an array (balance point) such that sum of all elements before the index = sum of all elements after it; else return -1
{
    if(A.empty()) return -1;

        long long upper = 0;
        long long lower = 0;

    for(unsigned int i = 0; i <= A.size(); ++i)
    {
        upper += A[i];
    }

    for(unsigned int j = 0; j < A.size(); ++j)
    {
        upper -= A[j];
        if(upper == lower) return j;
        lower += A[j];
    }
    return -1;
    }

以下情况会有更好的最差情况，但会有更多if-else次比较

int BalancePoint2(int a[], int begin, int end) // Better worst case senario by factor of 2
{
    if(!a) return -1;
    else if(begin == end) return begin;

        long long upper = 0;
        long long lower = 0;

        int mid = (end-begin)/2;

        for(int i = begin; i < mid; ++i)
        {
            lower += *(a+i);
        }
        for(int i = mid+1; i <= end; ++i)
        {
            upper += *(a+i);
        } 

        if(upper == lower) return mid;
        else if(lower < upper)
        {
            lower += *(a+mid);
            for(int i= mid + 1 ; i <= end ; ++i)
            {
                upper -= *(a + i);
                if(upper == lower) return i;
                lower += *(a + i);
            }
        }
        else {
            upper += *(a + mid);
            for(int i = mid - 1; i >=begin; --i)
            {
                lower -= *(a + i);
                if(upper == lower) return i;
                upper += *(a + i);
            }
        }
        return -1;
}

Answer 5

O（n）且不需要更多空间的解决方案

def balance_array(arr):
    if len(arr) < 3:
        return False

    for i in range(1, len(arr)+1):
        lsum = sum(arr[:i])
        rsum = sum(arr[(i+1):])
        if lsum == rsum:
            return True
    return False

测试

test_arrays = [[5, 3, 7, 0, 9], [5,2,3,1,4,6], [1,0,1], [1,6,5,1,2,3,1], [1,1], [], [1], [1,2,9,4,-1], [5, 4, 7, 0, 9], [1, -1, 1, 0, 1, -1, 1]]

for i in test_arrays:
    print(f'{i}\t{balance_array(i)}')

[5, 3, 7, 0, 9]         False
[5, 2, 3, 1, 4, 6]      True
[1, 0, 1]               True
[1, 6, 5, 1, 2, 3, 1]   True
[1, 1]                  False
[]                      False
[1]                     False
[1, 2, 9, 4, -1]        True
[5, 4, 7, 0, 9]         True
[1, -1, 1, 0, 1, -1, 1] True

Answer 6

我相信您正在寻找Center of Mass，这是一个用Go编写的解决方案：

func centerOfGravity(a []int) float64 {
  tot := 0.0
  mass := 0.0
  for i := range a {
    tot += float64(i) * float64(a[i])
    mass += float64(a[i])
  }
  return tot / mass
}

这假设基于0的数组给出了数组中质心的索引。它可以返回非整数结果，因为质心可以在数组范围内的任何位置。

在数组中查找平衡点

6 个答案: