C++ 如何找到具有最小k长度和最大和的子阵列？

子阵列包含正数和负数。必须找到一个最大和子数组，使子数组的长度大于或等于k

这里是C++中的代码，使用KADAN算法。< /P>

#include <iostream>

using namespace std;

int main(){

    int n,k;
    cin >> n >> k;
    int array[n];
    int sum = 0;
    int maxsum = 0;
    int beststarts[n];

    for(int i = 0;i < n; i++){
            cin >> array[i];
    }

    for(int i = 0;i < k-1;i ++){
            sum = sum+array[i];
            beststarts[i] = 0;
    }


    for(int i =  k-1;i < n; i++){ //best end search with min length;
            sum = sum+array[i];
            int testsum = sum;
            if(i > 0){
            beststarts[i] = beststarts[i-1];
            }
            for(int j = beststarts[i] ;i-j > k-1;j ++){
                    testsum = testsum - array[j];
                    if(testsum > sum){
                            beststarts[i] = j+1;
                            sum = testsum;
                    }
            }
            if(sum > maxsum){
                    maxsum = sum;
            }
    }

    cout << maxsum;

    return 0;
}

#包括
使用名称空间std；
int main（）{
int n，k；
cin>>n>>k；
整数数组[n]；
整数和=0；
int最大和=0；
int-beststart[n]；
对于（int i=0；i>阵列[i]；
}
对于（int i=0；i0）{
最佳启动[i]=最佳启动[i-1]；
}
对于（int j=beststart[i]；i-j>k-1；j++）{
testsum=testsum-数组[j]；
if（testsum>sum）{
最佳启动[i]=j+1；
总和=测试总和；
}
}
如果（总和>最大总和）{
最大和=和；
}
}
cout基于


intw（0）；
对于（inti=0；i< C++ >不允许C++声明C++，C++不允许声明具有非const值的数组。这是C99标准中的一些C++编译器选择支持的。（参见）@ pSTRJDS，我知道，但是它是由编译器（GCC）支持的。所以为什么不使用它呢！我不是说不使用它：）我只是想指出它，以防其他人看到它，并对他们的编译器感到失望，因为它无法编译。可能重复
#include <algorithm>
#include <iterator>
#include <iostream>
#include <numeric>
#include <ostream>
#include <utility>
#include <vector>

// __________________________________________________

template<typename RandomAccessIterator> typename std::iterator_traits<RandomAccessIterator>::value_type
max_subarr_k(RandomAccessIterator first,RandomAccessIterator last,int k)
{
    using namespace std;
    typedef typename iterator_traits<RandomAccessIterator>::value_type value_type;
    if(distance(first,last) < k)
        return value_type(0);
    RandomAccessIterator tail=first;
    first+=k;
    value_type window=accumulate(tail,first,value_type(0));
    value_type max_sum=window, current_sum=window;
    while(first!=last)
    {
        window += (*first)-(*tail) ;
        current_sum = max( current_sum+(*first), window );
        max_sum = max(max_sum,current_sum);
        ++first;
        ++tail;
    }
    return max_sum;
}

// __________________________________________________

template<typename E,int N>
E *end(E (&arr)[N])
{
    return arr+N;
}

int main()
{
    using namespace std;
    int arr[]={1,2,4,-5,-4,-3,2,1,5,6,-20,1,1,1,1,1};
    cout << max_subarr_k(arr,end(arr),4) << endl;
    cout << max_subarr_k(arr,end(arr),5) << endl;
}

14
11

  int w(0);
    for (int i=0; i < k; i++) w += a[i];
    int run_sum(w), max_sum(w);
    for (int i=k; i < n; i++) {
              w = a[i] + max(w, w-a[i-k]); //  window will such that it will include run_sum
              run_sum = max(run_sum + a[i], w);
              max_sum = max(run_sum, max_sum); 
    }
    return max_sum;