将数组分成更小的连续部分，使 NEO 值最大

Posted 2023-02-16

【中文标题】将数组分成更小的连续部分，使 NEO 值最大

【英文标题】：Divide array into smaller consecutive parts such that NEO value is maximal

【发布时间】：2018-06-06 18:25:25

【问题描述】：

这几年Bubble Cup（完结）有问题NEO（我解决不了），问

给定具有 n 个整数元素的数组。我们把它分成几个部分（可能是1个），每个部分是一个连续的元素。在这种情况下，NEO 值通过以下方式计算： 每个部分的值之和。一个部分的值是这个部分中所有元素的总和乘以它的长度。

示例：我们有数组：[ 2 3 -2 1 ]。如果我们将其划分为：[2 3] [-2 1]。那么NEO = (2 + 3) * 2 + (-2 + 1) * 2 = 10 - 2 = 8。

数组中的元素个数小于10^5，并且是-10^6和10^6之间的整数

我尝试过类似分而治之的方法，如果它增加了最大 NEO 数量，则不断地将数组分成两部分，否则返回整个数组的 NEO。但不幸的是，该算法具有最坏情况 O(N^2) 复杂度（我的实现如下）所以我想知道是否有更好的解决方案

编辑：我的算法（贪婪）不起作用，例如 [1,2,-6,2,1] 我的算法返回整个数组，而要获得最大的 NEO 值是参加 [1,2],[-6],[2,1] 的部分，它给出的 NEO 值为 (1+2)*2+(-6)+(1+2)*2=6

#include <iostream>
int maxInterval(long long int suma[],int first,int N)

    long long int max = -1000000000000000000LL; 
    long long int curr;
    if(first==N) return 0;
    int k;
    for(int i=first;i<N;i++)
    
        if(first>0) curr = (suma[i]-suma[first-1])*(i-first+1)+(suma[N-1]-suma[i])*(N-1-i); // Split the array into elements from [first..i] and [i+1..N-1] store the corresponding NEO value
        else curr = suma[i]*(i-first+1)+(suma[N-1]-suma[i])*(N-1-i); // Same excpet that here first = 0 so suma[first-1] doesn't exist
        if(curr > max) max = curr,k=i; // find the maximal NEO value for splitting into two parts
    
    if(k==N-1) return max; // If the max when we take the whole array then return the NEO value of the whole array
    else
    
        return maxInterval(suma,first,k+1)+maxInterval(suma,k+1,N); // Split the 2 parts further if needed and return it's sum
    

int main() 
    int T;
    std::cin >> T;
    for(int j=0;j<T;j++) // Iterate over all the test cases
    
        int N;
        long long int NEO[100010]; // Values, could be long int but just to be safe
        long long int suma[100010]; // sum[i] = sum of NEO values from NEO[0] to NEO[i]
        long long int sum=0;
        int k;
        std::cin >> N;
        for(int i=0;i<N;i++)
        
            std::cin >> NEO[i];
            sum+=NEO[i];
            suma[i] = sum;
        
        std::cout << maxInterval(suma,0,N) << std::endl;
    
    return 0;

【问题讨论】：

only 在这里得到 O(n^2) 会很不错：蛮力是 O(n 2^n)，来自 compositions 的数量>n.

你的时间复杂度不是 O(n^2)，很遗憾

是数组的所有部分长度相同还是长度任意？

@Yola 我刚刚找到了一个反例，如果我采用 1 2 -6 2 1 我的算法会选择给出 0*6 = 0 的整个数组，而最佳值是 [1,2],[ -6],[2,1] = (1+2)*2+(-6)+(2+1)*2=6。回到绘图板我猜：P

感谢您的更新。我尝试了动态编程方法，但它需要大量内存和失败的时间限制。

【参考方案1】：

这不是一个完整的解决方案，但应该提供一些有用的方向。

将两个总和为正（或其中一个总和为非负）的组组合起来总是会产生比分开的更大的 NEO：

m * a + n * b < (m + n) * (a + b) where a, b > 0 (or a > 0, b >= 0); m and n are subarray lengths

将具有负和的组与整个非负数组组合总是比仅将其与非负组的一部分组合产生更大的 NEO。但是排除总和为负的组可能会产生更大的NEO：

[1, 1, 1, 1] [-2] => m * a + 1 * (-b)

现在，假设我们逐渐将分界线向左移动，增加 b 与的总和。虽然右边的表达式是否定的，但左边组的 NEO 一直在下降。但是如果右边的表达式是肯定的，依赖于我们的第一个断言（参见 1.），将两个组结合起来总是大于不。

按顺序单独组合负数总是会产生比分开的更小的 NEO：

-a - b - c ... = -1 * (a + b + c ...)

l * (-a - b - c ...) = -l * (a + b + c ...)

-l * (a + b + c ...) < -1 * (a + b + c ...) where l > 1; a, b, c ... > 0

O(n^2) 时间，O(n) 空间 javascript 代码：

function f(A)
  A.unshift(0);

  let negatives = [];
  let prefixes = new Array(A.length).fill(0);
  let m = new Array(A.length).fill(0);

  for (let i=1; i<A.length; i++)
    if (A[i] < 0)
      negatives.push(i);

    prefixes[i] = A[i] + prefixes[i - 1];
    m[i] = i * (A[i] + prefixes[i - 1]);

    for (let j=negatives.length-1; j>=0; j--)
      let negative = prefixes[negatives[j]] - prefixes[negatives[j] - 1];
      let prefix = (i - negatives[j]) * (prefixes[i] - prefixes[negatives[j]]);

      m[i] = Math.max(m[i], prefix + negative + m[negatives[j] - 1]);
    
  

  return m[m.length - 1];


console.log(f([1, 2, -5, 2, 1, 3, -4, 1, 2]));
console.log(f([1, 2, -4, 1]));
console.log(f([2, 3, -2, 1]));
console.log(f([-2, -3, -2, -1]));

更新

This blog 提供我们可以将 dp 查询从

dp_i = sum_i*i + max(for j < i) of ((dp_j + sum_j*j) + (-j*sum_i) + (-i*sumj))

到

dp_i = sum_i*i + max(for j < i) of (dp_j + sum_j*j, -j, -sum_j) ⋅ (1, sum_i, i)

这意味着我们可以在每次迭代中查看已经看到的向量，该向量将使用我们当前的信息生成最大的点积。提到的数学涉及凸包和最远点查询，目前我无法实现，但会进行研究。

【讨论】：

感谢您提供的链接，它非常有帮助，如果成功，我将尝试实施自己的解决方案，我将在此处发布答案。

@kingW3 是的，计算几何与这些数字查询的关系非常有趣。我试图自己想象它。 （顺便说一句，如果您遇到困难，请注意用户 dacin21 在该博客中发布了完整代码：）