Arrays 数组n个连续元素的最大和

如何找到数组中

n

连续数的最大和？例如，如果我们的数组是

{2,5,3,4,6}

和

n==2

，那么输出应该是

10

（即

6+4

）

对于数组大小的小值和

n

的小值，我能够获得正确的逻辑。但是当数组大小和n太大时，比如105左右，我的代码会花费很多时间。请建议一种优化的方法

我的代码被截断了：

for(int i = 0; i <= n - h; i++) {
  int count = 0;
  for(int k = i; k < i + h; k++) {
    count = count + arr[k];
  }
  if(i == 0) {
    ans[z] = count;
  } else if(i != 0) {
    if(count < ans[z]) {
      ans[z] = count;
    }
  }
  count = 0;
}

---

for（int i=0；i我建议您的第一件事是使用mergesort对数组进行排序，它的复杂度为O（n log（n））然后，您只需找到前n个连续数字，将数组从较高的数字迭代到较低的数字，以保持当前连续数字的总和，这将需要O（n）的复杂度时间。问候语
我建议您的第一件事是使用mergesort对数组进行排序，其复杂度时间为O（n log（n））然后，您只需找到前n个连续数字，将数组从较高的数字迭代到较低的数字，以保持当前连续数字的总和，这将需要O（n）的复杂度。问候语我的想法是：从0到（数组长度-n）遍历数组，并使用以下表达式确定下一个N项的总和：

下一个N项之和=上一个和-上一个子数组中的第一项+下一个子数组中的最后一项

示例：

数组={2,5,3,4,6}

当i=0时，总和=（2+5）=7，最大总和=7

当i=1时，sum=7-2+3=8，因为8>7，所以最大sum=8

当i=2时，和=8-5+4=7，因为7
当i=3时，sum=7-3+6=10，因为10>8，所以最大sum=10

下面是c语言中的示例代码#

static int GetLargestSum（int[]数组，int n）
{
int largestSum=0；
int-previousSum=0；
对于（int i=0；i最大值）
{
最大总和=当前总和；
}
前一个总和=当前总和；
}
}
回报最大；
}
我的想法是：从0到（数组长度-N）遍历数组，并使用以下表达式确定下一个N项的总和：

下一个N项之和=上一个和-上一个子数组中的第一项+下一个子数组中的最后一项

示例：

数组={2,5,3,4,6}

当i=0时，总和=（2+5）=7，最大总和=7

当i=1时，sum=7-2+3=8，因为8>7，所以最大sum=8

当i=2时，和=8-5+4=7，因为7
当i=3时，sum=7-3+6=10，因为10>8，所以最大sum=10

下面是c语言中的示例代码#

static int GetLargestSum（int[]数组，int n）
{
int largestSum=0；
int-previousSum=0；
对于（int i=0；i最大值）
{
最大总和=当前总和；
}
前一个总和=当前总和；
}
}
回报最大；
}
您的技术可能的主要改进是滑动窗口。整数加法有一个倒数，即减法。这使得从和中删除元素并添加新元素成为可能，而不是从头开始重新计算。（）

正如Terryfkjc在他的回答中所评论的那样，需要线程级并行。你可以让不同的线程检查数组的不同部分。如果滑动窗口的大小超过数组大小的一半，那么对第一个
n
求和应该是线程化的。当
n
大约是阵列大小的一半。大得多，它不能滑动那么远。小得多，大部分工作只是滑动

如果您针对的是带有向量指令的CPU，我们可以使用SIMD轻松地对第一个
w
（窗口大小/宽度）元素的初始和进行向量化。例如，使用x86 SSE（C/C++内部函数）：

#包括
常量m128i*数组向量=（u m128i*）数组；
__m128i sums=_mm_loadu_si128（array_vec）；//或以_mm_setzero_si128（）开头
//小心使循环开始/结束和增量正确，
//无论是按向量（i++）还是按元素（i++=4）计数
//如果窗口宽度不是向量宽度的倍数，则可能需要在末尾进行标量清理
对于（int i=1；i

我认为不可能对滑动窗口部分进行矢量化。我们不能有效地滑动4个单独的窗口，因为每个窗口（矢量元素）都需要看到每个数组元素

但是，如果我们对4/8/16不同的窗口大小（最好是连续的）感兴趣，那么我们可以使用向量来实现。因此，在每个循环迭代中，我们都有一个带有当前滑动窗口和的向量。对于SSE4.1
pmaxsd
（对于有符号的32位整数），我们可以这样做

window_max=_mm_max_epi32（window_max，window_sums）；

滑动窗口操作变为：添加
{a[i]，a[i+1]，a[i+2]，a[i+3]}
，同时从所有4个向量元素中删除相同的数组元素。（或者，广播要添加的元素，然后减去不同元素的向量。）

\uuum128i添加元素=\umm\uloadu\usi128（（\uuum128i*）和数组[i]）//加载i、i+1等。
__m128i子元素=_mm_cvtsi32_si128（数组[i-width-1]）；
sub_元素=_mm_shuffle_epi32（sub_元素，0）；//广播th
arr = [2,5,3,4,6];

sum = 0;
temp_sum = 0;

const add = (a,b) => a+b;

for(let i=0;i<arr.length-1;i++){
  console.log(i, i+2,arr.slice(i,i+2));
  temp_sum = add.apply(null, arr.slice(i,i+2));
  if(sum < temp_sum){
    sum = temp_sum;
  }
}

console.log(sum);

    s = 0
    arrayMaxConsecutiveSum = (a, k) =>
    Math.max(...
        a.map(x => s += x - ~~a[~--k])
    )

function maxSubelementsSum(inputArray, count) {
  let maxSum = 0;
  for (let i = 0; i < count; i++) {
    maxSum += inputArray[i];
  }
  let tempSum = maxSum;
  for (let i = count; i < inputArray.length; i++) {
    tempSum = tempSum + inputArray[i] - inputArray[i - count];
    maxSum = Math.max(tempSum, maxSum);

  }
  return maxSum;
}

int[] numArr = {1,3,5,6,7,12,14,2,3,4}; 
List<Integer> intList = Arrays.stream(numArr).boxed().collect(Collectors.toList());         
List<Integer> intSumList = new ArrayList<>();
for(int i=0; i<=numArr.length-3; i++)
{
    int intSum = intList.stream().skip(i).limit(3).mapToInt(Integer::intValue).sum();       
    intSumList.add(Integer.valueOf(intSum));
}       
int maxConsecutiveSum = intSumList.stream().reduce(Integer::max).get(); 
System.out.println("Max sum using 3 consecutive integers :"+maxConsecutiveSum);

A=list(map(int,input().split(" ")))
n=len(A)
max=0
for i in range(n-1):
    if(A[i]+A[i+1]>max):
        max=A[i]+A[i+1]
print(max)

let array = [2,5,3,4,6];
let sum=0;
let maxNumber = 0;
for(let i=0; i<array.length;i++){
    sum = array[i] + array[i+1];
    if(sum >= maxNumber){
        maxNumber = sum;
    }
    
}
console.log("max of two digit :", maxNumber);