如果在普通连续子序列问题的基础上加以限制,条件为 长度=K
方法一的动态规划仍然有效,之前得出的结论也依然有效,
算法步骤:
1、求出a[0......k-1]的和sum,max=sum
2、j从k.....n-1,sum=sum+a[j]-a[k-j],max=MAX(max,sum)
3、结果为max
int maxsub(int* arr,int len,int k)
{
int i,maxsum=0,sum=0;
for(i=0;i<k;++i)
maxsum+=arr[i];
sum=maxsum;
for(i=1;i<len-k;++i)
{
sum=sum+arr[i+k-1]-arr[i-1];
if(sum>maxsum)
maxsum=sum;
}
return maxsum;
}
(二)限制条件为长度<=K
对于数组a[0,n-1]
考虑最大和连续子序列的限制条件为长度<=K。显然,朴素的动态规划:令f[i]表示为以第i个元素结束的连续子序列(显然开始位置s不能小于i-K+1)的最大值。定义sum[i,j]表示a[i]+a[i+1]+....+a[j],则f[i]=MAX(sum[k,i]) ------> i-K+1 <=k <=i,对于这个状态转移方程,若每一次决策都枚举的话,复杂度为O(N^3),简单优化,sm[i]表示a[0]+...a[i],这样可以在O(1)时间内求出sum[i,j],但是复杂度O(N^2)仍然不容乐观。继续优化,仍然用sm[i]表示a[0]+...+a[i],考虑对于每一个f[i]要找出MAX(sum[k,i])------> i-K+1 <=k <=i,其实只要找出MAX(sum[k,i]-a[i]) ,结果再加上a[i],同样是正确的,但这么做则让我们省了很大的事, 因为MAX(sum[k,i]-a[i]) 其实和 MAX(sum[k,i-1])没差多少,再仔细想一下,这两个k的取值范围错了一位,既然这样,如果我们用一个单调队列(用数组模拟的话,在这里意味着 ,随着下标的增加,值不断减少),保存sum[k,i-1] (i-1-k<=K),队首元素就是f[i-1],求f[i]的时候,我们将a[i]-a[i]加入队列,并维护单调性,之后取出的队首元素值+a[i]就是f[i]。这样每个元素只进出队列一次,算法时间复杂度为O(N),问题得到完美解决,聪明的读者应该可以看出来这也是一个在线算法,因为求当前f[i]根本不需要a[i+1]及以后的元素。其实这个思想主要还是因为这个dp方程中的决策是凸性的,这使得我们可以充分利用决策的单调性来优化程序。
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
#define maxn 10000
int sm[maxn],a[maxn];
int f[maxn],n,k,head,tail;
typedef struct node
{
int v;
int dex;
}node;
node q[maxn+1];
void solve()
{
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
if(!i) sm[i]=a[i];
else sm[i]=a[i]+sm[i-1];
while(head<tail && q[head].dex+k<=i) head++;
while(head<tail && q[tail-1].v<a[i]-sm[i]) tail--;
q[tail].v=a[i]-sm[i];//所有的都减去sm[i],这样都具有可比性
q[tail].dex=i;
tail++;
f[i]=q[head].v+sm[i];
}
}
void init()
{
memset(sm,0,sizeof(sm));
memset(a,0,sizeof(a));
memset(f,0,sizeof(f));
head=tail=0;
}
void printans()
{
int max=-99999999;
for(int i=0;i<n;i++)
{
printf("%d ",f[i]);
max=max>f[i]?max:f[i];
}
printf("\n%d\n",max);
}
int main()
{
freopen("in.txt","r",stdin);
while(scanf("%d %d",&n,&k)!=EOF)
{
init();
solve();
printans();
}
return 0;
}