Arrays 循环缓冲区中的最大连续和

我有一个程序来确定数组中最大的连续和，但我想扩展它以处理循环数组。有没有比将单个数组加倍并调用我的函数来查找2n长度数组中所有n长度数组的最大和更简单的方法呢？

嗯，实际上不必将数组加倍。您可以通过索引现有的数组模

n

，或者在其上迭代两次来模拟它。根据数组的大小和缓存行为，这最多应该比非圆形数组的算法慢两倍。

我假设您使用的是O（n）算法，该算法将继续向和中添加，跟踪最大值，只有当和为负数时才重新启动。要捕获循环数组的情况，您需要做的唯一一件事就是将相同的原理应用于循环方面。当您在原始算法中到达数组的末尾时，继续循环到开始处，直到低于最大值或到达当前范围的开始处（我认为这是不可能的，因为如果解决方案是完整数组，我们应该在第一次通过时看到），在这种情况下，您就完成了

max_start=0; max_end =0; maxv = 0; sum 0;
for i in range(arr):
    sum+= arr[i];
    if sum<0:
       sum=0; max_start =i;
    if maxv<sum:
       maxv=sum; max_end = i;

#seocnd pass
for i in range(max_start):
    sum+= arr[i];
    if sum<0:
       break;
    if maxv<sum:
       maxv=sum;max_end = i;

max\u start=0；max_end=0；maxv=0；总和0；
对于范围内的i（arr）：
总和+=arr[i]；
如果sum我认为@spinning_plate的解决方案是错误的。你能为给定的情况测试一下吗

int arr[]={-3,6,2,1,7,8,13,0}

你的方法返回21

实际解决方案可以从第6个索引（即13个值）开始。。和第四个索引的末尾（即7值）。由于数组是圆形的，我们可以从第6个索引到第7个索引，从第0个索引到第4个索引取连续序列

上述情况的实际答案是：26参见以下链接：

它使用Kadane算法解决了一个问题

基于以下内容更正代码：最小和子数组的元素不能出现在最终换行中，或者不是最大和子数组

public int maxSum(int[] arr) {
    if (arr.length == 0) return 0;

    int sum = 0;
    int min = Integer.MAX_VALUE;
    int eix = 0;
    for (int i = 0; i < arr.length; i++) {
        sum = sum + arr[i] < arr[i] ? sum + arr[i] : arr[i];
        if (sum < min) {
            min = sum;
            eix = i;
        }
    }
    int max = 0;
    sum = 0;
    for (int i = eix; i < arr.length + eix; i++) {
        int ix = i < arr.length ? i : i - arr.length;
        sum = sum + arr[ix] > arr[ix] ? sum + arr[ix] : arr[ix];
        max = max > sum ? max : sum;
    }

    return max;
}

public int maxSum（int[]arr）{
如果（arr.length==0）返回0；
整数和=0；
int min=整数最大值；
int-eix=0；
对于（int i=0；iarr[ix]？sum+arr[ix]：arr[ix]；
max=max>sum？max:sum；
}
返回最大值；
}
对于给定的问题，
我们将应用kadane算法，我们还将找到具有最大负值的子集。如果移除最大负值，将以循环顺序给出剩余数组的和。如果该和大于最大和，则最大和将以循环顺序求和。
该算法的复杂度为O（n）

Eg:-arr[i]={10，-3，-4,7,6,5，-4，-1}
答案：最大和=7+6+5+-4+-1+10
移除的_集={-3，-4}
int find_maxsum（int arr[]，int n）
{
int i=0；
int-total=0；
int maxa=0；
int mini=0；
int min_sum=0；
int max_sum=0；
while（imax_sum）
max_sum=maxa；
if（极小极大和）
最大和=总最小和；
返回最大和；

}
即使所有数字都是负数，例如，{-1，-2，-3}，此代码也会返回正确答案。
将返回-1

 public static int maxSubarraySumCircular(int[] A) {

    int maxSum = Arrays.stream(A).max().getAsInt();
    if (maxSum < 0)
        return maxSum;

    int maxKadane = KadaneAlgorithm(A);
    int maxWrap = 0;
    for (int i = 0; i < A.length; i++) {
        maxWrap += A[i];
        A[i] = -A[i];
    }
    maxWrap = maxWrap + KadaneAlgorithm(A);

    return maxWrap > maxKadane ? maxWrap : maxKadane;
}

private static int KadaneAlgorithm(int[] A) {
    int maxSoFar = 0;
    int maxEndingHere = 0;
    for (int i = 0; i < A.length ; i++) {

        maxEndingHere = maxEndingHere + A[i];

        if (maxEndingHere < 0 )
            maxEndingHere = 0;

        if(maxSoFar < maxEndingHere)
            maxSoFar = maxEndingHere;
    }

    return maxSoFar;
}

public static int maxSubraySumCircular（int[]A）{
int maxSum=Arrays.stream（A）.max（）.getAsInt（）；
如果（最大和<0）
返回最大和；
int maxKadane=KadaneAlgorithm（A）；
int-maxWrap=0；
for（int i=0；imaxKadane？maxWrap:maxKadane；
}
私有静态int-KadaneAlgorithm（int[]A）{
int maxSoFar=0；
int maxEndingHere=0；
for（int i=0；i
您的要求是什么？数组可以包含的整数范围（？）是多少？它能包含负面因素吗？数组最多包含多少个元素？对我来说，这是动态编程，可能有一个DP算法，它的运行时间围绕着其他任何东西运行…@SyntaxT3rr0r，这是一个著名的问题，如果没有所有项的负数和就是答案（我的答案可能还有其他一些答案），所以我认为没有具体的歧义，@rach，加倍列表有什么错？顺序是O（n）（空间和时间），没有任何变化，我认为这不是一个很大的开销。@Saeed:我总是做的第一件事就是询问需求。。。如果数组可以包含从-263到263-1的数亿个元素，那么我可以向您保证，“常规”答案对它来说并不那么容易。因为您需要将总和存储在多个“long”上。如果没有足够的内存来存储中间结果呢？这几乎总是一种时间/内存的权衡。0-1背包也很有名。但也存在一些制约因素。要求要求是101。计算中的“整数”在数学中很难是“整数”。。。等等，刚才在careercup中看到一条关于同一个问题的评论，我认为这对像{7，-6，5}这样的数组不起作用。
 public static int maxSubarraySumCircular(int[] A) {

    int maxSum = Arrays.stream(A).max().getAsInt();
    if (maxSum < 0)
        return maxSum;

    int maxKadane = KadaneAlgorithm(A);
    int maxWrap = 0;
    for (int i = 0; i < A.length; i++) {
        maxWrap += A[i];
        A[i] = -A[i];
    }
    maxWrap = maxWrap + KadaneAlgorithm(A);

    return maxWrap > maxKadane ? maxWrap : maxKadane;
}

private static int KadaneAlgorithm(int[] A) {
    int maxSoFar = 0;
    int maxEndingHere = 0;
    for (int i = 0; i < A.length ; i++) {

        maxEndingHere = maxEndingHere + A[i];

        if (maxEndingHere < 0 )
            maxEndingHere = 0;

        if(maxSoFar < maxEndingHere)
            maxSoFar = maxEndingHere;
    }

    return maxSoFar;
}