最大化输入中不超过 k 个连续元素的列表总和

Question

我有一个 N 个数字的数组，我只想从列表中删除那些元素，这些元素在删除后将创建一个新列表，其中没有更多相邻的 K 个数字对彼此。可以使用此限制创建多个列表。所以我只想要那个列表，其中剩余数字的总和是最大的，并且只作为输出打印那个总和。

到目前为止，我提出的算法的时间复杂度为 O(n^2)。是否有可能为这个问题获得更好的算法？

Link to the question.

这是我的尝试：

int main()
{
    //Total Number of elements in the list
    int count = 6;
    //Maximum number of elements that can be together
    int maxTogether = 1;

    //The list of numbers
    int billboards[] = {4, 7, 2, 0, 8, 9};

    int maxSum = 0;
    for(int k = 0; k<=maxTogether ; k++){
        int sum=0;
        int size= k;

        for (int i = 0; i< count; i++) {
            if(size != maxTogether){
                sum += billboards[i];
                size++;
            }else{
                size = 0;
            }
        }
        printf("%i\n", sum);
        if(sum > maxSum)
        {
            maxSum = sum;
        }
    }
    return 0;
}

Answer 1

O(NK)dynamic programming 解决方案相当简单：

让 A[i] 成为左侧元素的最佳总和，受 not-k-连续约束（假设我们也删除了 i-th 元素）。

然后我们可以通过回顾K元素来计算A[i]：

A[i] = 0;
for j = 1 to k
  A[i] = max(A[i], A[i-j])
A[i] += input[i]

最后，只需查看 A 中的最后一个 k 元素，将元素添加到每个元素的右侧并选择最佳元素。

但这太慢了。

让我们做得更好。

所以A[i] 从A[i-1]、A[i-2]、...、A[i-K+1]、A[i-K] 中找到最好的。
所以A[i+1] 从A[i]、A[i-1]、A[i-2]、...、A[i-K+1] 中找到最好的。

那里有很多冗余 - 由于A[i] 的计算，我们已经从索引i-1 到i-K 中知道了最好的，但后来我们找到了除i-K 之外的所有这些中最好的（@ 987654347@) 再次进入A[i+1]。

所以我们可以将它们全部存储在一个有序的数据结构中，然后删除A[i-K] 并插入A[i]。我的选择 - 一个 binary search tree 来找到最小值，以及一个大小为 K+1 的树节点的 circular array，这样我们就可以轻松找到我们需要删除的那个。

我交换了问题以使其稍微简单一些 - 我没有找到剩余元素的最大值，而是找到已删除元素的最小值，然后返回 total sum - removed sum。

高级伪代码：

for each i in input
  add (i + the smallest value in the BST) to the BST
  add the above node to the circular array
    if it wrapper around, remove the overridden element from the BST

// now the remaining nodes in the BST are the last k elements

return (the total sum - the smallest value in the BST)

运行时间：

O(n log k)

Java 代码：

int getBestSum(int[] input, int K)
{
   Node[] array = new Node[K+1];
   TreeSet<Node> nodes = new TreeSet<Node>();
   Node n = new Node(0);
   nodes.add(n);
   array[0] = n;
   int arrPos = 0;
   int sum = 0;
   for (int i: input)
   {
      sum += i;
      Node oldNode = nodes.first();
      Node newNode = new Node(oldNode.value + i);
      arrPos = (arrPos + 1) % array.length;
      if (array[arrPos] != null)
         nodes.remove(array[arrPos]);
      array[arrPos] = newNode;
      nodes.add(newNode);
   }
   return sum - nodes.first().value;
}

getBestSum(new int[]{1,2,3,1,6,10}, 2) 根据需要打印21。

Answer 2

让f[i] 成为您可以使用前 i 个数字获得的最大总值，而您不要选择最后一个（即第 i 个）。然后我们有

f[i] = max{
           f[i-1],
           max{f[j] + sum(j + 1, i - 1) | (i - j) <= k}
          }

您可以使用类似heap 的数据结构来维护选项并在log(n) 时间内获得最大值，保留全局delta 或其他任何内容，并注意i - j <= k 的范围。

Answer 3

以下算法的复杂度为 O(N*K)。

检查数组的第一个 K 元素（0 到 K-1）。该区域最多可以有 1 个间隙。
原因：如果有两个差距，那么就没有任何理由有更低的（早期差距）。

For each index i of these K gap options, following holds true:  
 1. Sum upto i-1 is the present score of each option.  
 2. If the next gap is after a distance of d, then the options for d are (K - i) to K  

For every possible position of gap, calculate the best sum upto that position among the options.  
The latter part of the array can be traversed similarly independently from the past gap history.

进一步遍历数组直到结束。