HDU 6444 Neko's loop (单调队列+带限制的最大子段和)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6444

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define read(x,y) scanf("%d%d",&x,&y)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
const int  maxn =1e4+5;
const int mod=1e9+7;
const int ub=1e6;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*
题目大意：给定一个数字序列，
和跳跃的间距，在这个序列可以选择任意起点开始跳跃，
循环，每次跳跃可以获得当前位置的权重值，
有个目标权重值，问初始权重值要多少才能使得其获得的不小于目标。
最多可以跳k次切跳跃方向单一。

首先我们可以通过列式子，发现任意位置跳跃的周期，
即n/gcd(n,k)，然后通过O(n)的复杂度把每个循环数列存储到vector中，
下面开始分析一波即可，已知m1=m/loop,m2=m%loop,
如果一整圈的大小小于零，那么肯定不额外跑圈，
大于零则肯定额外跑圈，然后容易想到，把额外跑圈算完后，
剩余的m2个就是在序列数中求带限制的最大字段和，
还有一个情况就是，m1如果大于1，则可能牺牲多余的数，
使得额外的圈数减一，然后求最大长度为序列本身的最大字段和。

最关键的还是如何求带限制的最大字段和，
朴素算法是暴力平方，用数据结构优化则是O(nlogn)，
用单调队列优化则是O(n)。
先把数的序列累加（做积分），
然后把前缀和的下标丢到单调队列中去维护，
因为我们可以看到最优答案肯定是个单调队列中的两端，
就是说用单调队列肯定能扫描到答案就行。

*/
int a[maxn],vis[maxn];
vector<ll> duan;
ll n,s,m,k;

ll MaxSum(vector<ll> vt,int len)///容器和最大长度
{
    int tmp=vt.size();for(int i=0;i<tmp;i++) vt.push_back(vt[i]);///复制一遍
    ///for(int i=0;i<tmp;i++) cout<<vt[i]<<" ";cout<<len<<endl;
    tmp<<=1;for(int i=1;i<tmp;i++) vt[i]+=vt[i-1];
    ll Sk[maxn<<1],l=0,r=-1;///单调栈
    ll ans=0,sum=0;
    for(int i=0;i<tmp;i++)
    {
        if(i<len) ans=max(ans,vt[i]);///在没有铺满的时候的额外判定
        while(r>=l&&i-Sk[l]>len) l++;///i位置是最新状态，把i当成刷新答案和更新状态的指标
        if(r>=l)  ans=max(ans,vt[i]-vt[Sk[l]]);
        while(r>=l&&vt[Sk[r]]>=vt[i]) r--;
        Sk[++r]=i;///必须存储下标，存储数值不行,数值不能检测是否超过最大长度.
    }
    ///cout<<ans<<endl;
    return ans;
}

ll F(vector<ll> vt,int m)
{
    ll sz=vt.size(),sm=0;
    for(int i=0;i<sz;i++) sm+=vt[i];
    ll len1=m/sz,len2=m%sz;
    ll m1=MaxSum(vt,len2),m2=MaxSum(vt,sz);
    m1+=max(0LL,sm)*len1;
    m2+=max(0LL,sm)*(len1>=1?(len1-1):0);
    return max(m1,m2);
}


int main()
{
    int t;scanf("%d",&t);
    for(int ca=1;ca<=t;ca++)
    {
        memset(vis,0,sizeof(vis));
        scanf("%lld%lld%lld%lld",&n,&s,&m,&k);
        for(int i=0;i<n;i++) scanf("%d",&a[i]);
        int loop=n/gcd(n,k);
        ll ans=0;
        for(int i=0;i<n;i++)
        {
            if(vis[i]) continue;
            vis[i]=1,duan.push_back(a[i]);
            for(int j=(i+k)%n;j!=i&&!vis[j];j=(j+k)%n)
            {
                vis[j]=1;
                duan.push_back(a[j]);
            }
            ans=max(ans,F(duan,m));
            duan.clear();
        }

        printf("Case #%d: ",ca);
        if(ans>=s) ans=0;
        else ans=s-ans;
        printf("%lld\n",ans);
    }
    return 0;
}