最大子序列和（dp+ rmq/队列）

http://exam.upc.edu.cn/problem.php?id=1552

题意：长度为n的数组，再加一限制条件m。求长度最大为m的连续子序列和是多少。m是个正整数

分析：我们都知道如果没有限制条件，求最大连续子序列的和只需用方程：dp[i] = max(0,dp[i - 1] + a[i])即可。复杂度O（n）

此题加上了限制，此时可将dp方程改为：dp[i] =sum[i] - min(sum[i - m + 1] , sum[i - m + 2] , ……，sump[i - 1]）求从当前点向前的不同长度的全部序列。此时复杂度为O（n * m）

我们对求一段区间的和进行优化，首先考虑rmq。明确rmq是可行的。rmq的复杂度为O（nlogn）的预处理，O（1）的查询。只需每次RMQ（i - m + 1,i -1）这时是有两点是需要判断的。首先是i - m + 1是大于等于1的，如果不是则RMQ(1,i - 1)。其次i - m + 1 <= i - 1如果不是则说明m <= 1及是m = 1,此时dp[i]的大小为每个点元素的大小。

rmq版本的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <string>
#include <algorithm>
#include <list>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdlib>
using namespace std;
int a[20005] = {0};
long long  dp[20005] = {0};
long long sum[20005] = {0};
long long d[20005][33] = {0};
int n,m;
void RMQ_init()
{
    for(int i=1; i<=n; i++) d[i][0]=sum[i];
    for(int j=1; (1<<j)<=n; j++)
        for(int i=1; i+(1<<j)-1<=n; i++)
            d[i][j]=min(d[i][j-1],d[i+(1<<(j-1))][j-1]);
}
int RMQ(int L,int R)
{
    int k=0;
    while((1<<(k+1))<=R-L+1) k++;
    return min(d[L][k],d[R-(1<<k)+1][k]);
}
int main()
{
    //freopen("in.txt","r",stdin);

    long long ans = 0;
    scanf("%d",&n);
    for(int i = 1; i <= n; i ++)
    {
        scanf("%d",&a[i]);
        sum[i] = sum[i - 1] + a[i];
    }
    scanf("%d",&m);

    RMQ_init();
    dp[1] = sum[1];//i == 1时，考虑几种可能，如果是满足了第一个条件，那么i - 1 = 0,i - m + 1 <= 0 且 i - m + 1 >= 1 矛盾，如果满足第二个条件i - m + 1 <= i - 1,及m >= 2,s时 1 < i - 1需要特判.只要i>1则不需要
    for(int i = 2; i <= n; i ++)
    {

        if(i - m + 1 <= i - 1 && i - m + 1 >= 1)
            dp[i] = sum[i]- RMQ(i  - m + 1,i - 1);
        else if(i - m + 1 <= i - 1)
            dp[i] = sum[i] - RMQ(1,i - 1);
        else
            dp[i] = a[i];

        //cout<<dp[i]<<endl;
        ans = max(ans,dp[i]);
    }
    printf("%lld\n",ans);
    return 0;
}

现在我们来分析另一种版本的，其实每次要查询的区间都只是变化一点儿，我们可以用一个队列来维护。在队尾插入新增加的元素，再队首删去已经不再区间范围的元素。

那么每次在队尾插入新的元素，都需与原有的元素进行对比，如果原有的元素更大，那么在以后的取min中，将不会再用到他们。则直接可以将队尾的指针--。如果队首的位置此时已经小于区间的范围，那么队尾的指针向前移动1

代码中用p[]记录队列中元素的位置。p数组的有效位置是从一开始的。分析可知每一个sum值只进队出队一次，时间复杂度为O（n）。略快于rmq

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <string>
#include <algorithm>
#include <list>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdlib>
using namespace std;
int a[20005] = {0};
int  p[20005] = {0};
long long sum[20005] = {0};
long long INF  = 1;
//如果当前点比队尾元素小，队尾元素删除
int main()
{
    for(int i = 0; i < 62; i ++)
    {
        INF = INF * 2;
    }
   // cout<<INF<<endl;
    //freopen("in.txt","r",stdin);
    int n,m ;
    scanf("%d",&n);
    for(int i = 1; i <= n; i ++)
    {
        scanf("%d",&a[i]);
        sum[i] = sum[i - 1] + a[i];
    }
    scanf("%d",&m);
    int bg =0,ed = 0;
    long long ans = -INF;
    //sum[i - m + 1] sum[i - 1]
    //模仿队列，向队尾加入元素时，若比队尾的元素小，此时去掉队尾的元素，因为在未来的求最小值中，是用不上它的了
    //而队首元素的维护是判断队首的位置是否大于等于i - m + 1
    for(int i = 1; i <= n; i ++)
    {
       while(p[bg] != 0 && p[bg] < i - m)
       {
            bg ++;
       }
       while(ed >= bg &&sum[p[ed]] >= sum[i])
       {
           ed --;
       }
        ed ++;
       p[ed] = i;

       ans = max(ans,sum[p[ed]] - sum[p[bg]]);
    }
    printf("%lld\n",ans);
    return 0;
}