最小切片位置 - 阶 N 算法

Question

给出了一个由 N 个整数组成的非空零索引数组 A。一对整数 (P, Q)，使得 0 ≤ P

写一个函数：

int 解(int A[], int N);

给定一个由 N 个整数组成的非空零索引数组 A，返回具有最小平均值的切片的起始位置。 如果有多个切片具有最小平均值，则应返回该切片的最小起始位置。

假设：

N 是 [2..100,000] 范围内的整数； 数组 A 的每个元素都是 [−10,000..10,000] 范围内的整数。 复杂性：

预期的最坏情况时间复杂度为 O(N)； 预期的最坏情况空间复杂度为 O(N)，超出输入存储（不计算输入参数所需的存储）。

你能只发布订单 N 的解决方案吗？

Answer 1

如果A 仅有正数，您可以不用这样：

pos = 0
min_avg = A[0] + A[1]
for (i=2; i<N; i++)
    m = A[i-1] + A[i]
    if (m < min_avg)
        min_avg = m
        pos = i-1
return pos

这只是取两个数字的切片的平均值，因为较大切片的平均值不能小于较小切片的最小值。

如果A有负数，你可以先向上调整所有值：

offset = min(A)
for (i=0; i<N; i++)
    A[i] -= offset

结合之前的算法：

offset = min(A) * 2              (because we're adding two numbers below)
pos = 0
min_avg = A[0] + A[1] - offset
for (i=2; i<N; i++)
    m = A[i-1] + A[i] - offset
    if (m < min_avg)
        min_avg = m
        pos = i-1
return pos

Answer 2

我认为你是对的，我能做的最好的就是 O(N²) 解决方案（这是在 Python 中）：

from random import randint

N = 1000
A = [randint(-10000, 10000) for _ in xrange(N)]

def solution(A, N):
    min_avg = 10001
    for p in xrange(N):
        s = A[p]
        for q in xrange(1,N-p):
            s += A[p+q]
            a = s / (q+1.)
            if a < min_avg:
                min_avg = a
                pos = (p, q+1)
    return pos

print solution(A, N)

但是，较大切片的平均值倾向于原始范围的平均值（中间）。在这种情况下，平均值为零，介于 -10000 和 10000 之间。大多数情况下，最小的平均值是两个值的切片，但有时它可以是三个值的切片，很少是更多值.所以我认为我之前的答案在大多数（> 90％）的情况下都有效。这真的取决于数据值。

Answer 3

    #include <assert.h>
    struct Slice { unsigned P, Q; };
    struct Slice MinSlice( int A[], unsigned N ) {
        assert( N>=2 );
        // find min slice of length 2
        unsigned P = 0;
        double min_sum = A[P] + A[P+1];
        for (unsigned i = 1; i < N-1; ++i)
            if ( min_sum > A[i] +A[i+1] ) {
                P = i;
                min_sum = A[P] + A[P+1];
            }
        unsigned Q = P+1;
        double min_avg = min_sum / 2;
        //extend the min slice if the avg can be reduced.
        //(in the direction that most reduces the avg)
        for (;;) {
            if ( P > 0 && ( Q >= N-1 || A[P-1] <= A[Q+1] ) ) {
                //reducing P might give the best reduction in avg
                double new_sum = A[P-1] + min_sum;
                double new_avg = new_sum / (Q - P + 2);
                if ( min_avg < new_avg )
                    break;
                min_sum = new_sum; 
                min_avg = new_avg; 
                --P;
             } else if ( Q < N-1 && ( P <= 0 || A[P-1] >= A[Q+1] ) ) {
                //increasing Q might give the best reduction in avg
                double new_sum = min_sum + A[Q+1];
                double new_avg = new_sum / (Q - P + 2);
                if ( min_avg < new_avg )
                    break;
                min_sum = new_sum; 
                min_avg = new_avg; 
                ++Q;
             } else
                 break;
        }
        struct Slice slice = { .P = P, .Q= Q };
        return slice;
    }