P1070 道路游戏（单调队列+动态规划）

题干在这里：https://www.luogu.org/problemnew/show/P1070

这道题分了三类，
对于 40%的数据, 2≤n≤40,1≤m≤40
对于 90%的数据,2≤n≤200,1≤m≤200
对于 100%的数据2≤n≤1000,1≤m≤1000,1≤p≤m

先说状态转移方程：f[i][j]表示在i时刻在j工厂买了一个机器人
f[i][j]=max{f[i+k][y]+sum-need[j]}（其中sum表示从第i时刻开始，机器人从第j个工厂开始收集金币，经过k步所能收集的金币数，money表示从j工厂买机器人需要的金币数，0<=y<=n-1）

如果不采用任何优化的话，只能得40%的分，我们先采取第一步优化：在状态转移的过程中，我们枚举了i，j，k，y。数据范围是200的时候就爆了。其实我们完全可以不需要枚举y。我们可以用opt数组来存储第i行f[i][j]的最大值，要用的时候直接调用就行了（不需要再枚举一遍j）。

程序如下：

#include<iostream>
#include<cstring>
using namespace std;
const int maxans=100*1000+10;
int n,m,p,a[1100][1100],f[1100][1100],need[1100],opt[1100];

int add(int fac,int step,int tim)
{
    int num=0;
    for(int i=0;i<step;++i){
        num+=a[(fac+i)%n][tim+i];
    }
    return num;
}

void prepare()
{
    opt[m]=0;
    for(int i=0;i<n;++i)
        f[m][i]=0;
    for(int i=m-1;i>=0;--i){
        for(int j=0;j<n;++j){
            int sum=0;
            for(int k=1;k<=min(p,m-i);++k){
                sum+=a[(j+k-1)%n][i+k-1];
                f[i][j]=max(f[i][j],opt[i+k]+sum-need[j]);
            }
            opt[i]=max(opt[i],f[i][j]);
        }
    }
}

void readin()
{
    cin>>n>>m>>p;
    for(int i=0;i<n;++i){
        for(int j=0;j<m;++j){
            cin>>a[i][j];
        }
    }
    for(int i=0;i<n;++i)
        cin>>need[i];
}

int main()
{
    readin();
    for(int i=0;i<=1010;++i){
        for(int j=0;j<=1010;++j){
            f[i][j]=-maxans;
        }
    }
    for(int i=0;i<=1010;++i)
        opt[i]=-maxans;
    prepare();
    cout<<opt[0]<<endl;
    return 0;
}

当数据范围是200的时候，在一秒内计算200^3完全可以。但是如果是1000的范围内的话，就会超时，所以我们要请出最后的王牌——

单调队列！！！

首先，让我们了解一下神马是单调队列：这里写图片描述
但是——这道题不是直线上的单调队列，而是斜线上的。
s[i][j]表示i，j所在的这一条斜线到第一行的和，递推关系式为：
s[i+1][(j+1)%n]=s[i][j]+a[i+1][(j+1)%n]；
其中，所有（j-i+n）%n得到的数相同的都为一条斜线
opt[i+k]和s[i][j]都和j有关，所以我们可以将二者的和存储在queue数组中，在求f[i][j]的时候再调用。
先将所有的s数组求出来，以便调用，状态转移方程如上~；
有了s数组，先将opt数组附一个很小的值（但是要注意opt[m]=0）之后我们就可以求queue（了！opt[i]在求完f[i][j]的时候再更新，转移方程为：opt[i]=max(opt[i],f[i][j])）
其中，head表示投指针。tail表示尾指针，当且仅当
tail[k]>=head[k]&&x>=queue[k][tail[k]][1]时才需要做，因为是求最大值，这个数列是一个单调递减的数列如果后面加进来的数大于queue数组尾的数，这个数组尾的数就没有用了，tail–，同理，如果这个数组头太遥远，超过了可执行步数，head++;

最后献上代码~~~

#include<iostream>
using namespace std;
const int maxans=100*1000+10;
int n,m,p,a[1100][1100],f[1100][1100],need[1100],opt[1100];
int s[1100][1100],queue[1100][1100][2],head[1100],tail[1100];

void readin()
{
    cin>>n>>m>>p;
    for(int i=0;i<n;++i){
        for(int j=0;j<m;++j){
            cin>>a[j][i];
        }
    }
    for(int i=0;i<n;++i)
        cin>>need[i];
    for(int i=0;i<n;++i)
        s[0][i]=a[0][i];
    for(int i=0;i<=m-1;i++){
        for(int j=0;j<n;++j){
            s[i+1][(j+1)%n]=s[i][j]+a[i+1][(j+1)%n];
        }
    }
}

void work()
{
    for(int i=0;i<n;++i)
        head[i]=1;
    for(int i=m-1;i>=0;--i)
        opt[i]=-maxans;
    for(int i=m-1;i>=0;--i){
        for(int j=0;j<n;++j){
            int k=(j-i+n)%n;
            int x=opt[i+1]+s[i][j];
            int maxstep=min(m-i,p);
            while(tail[k]>=head[k]&&x>=queue[k][tail[k]][1])
                tail[k]--;
            queue[k][++tail[k]][0]=i+1;
            queue[k][tail[k]][1]=x;
            if(queue[k][head[k]][0]>i+maxstep)
                head[k]++;
            f[i][j]=queue[k][head[k]][1]-need[j];
            if(i>0)
                f[i][j]-=s[i-1][(j+n-1)%n];
            opt[i]=max(opt[i],f[i][j]);
        }
    }
}

int main()
{
    readin();
    work();

    cout<<opt[0]<<endl;
    return 0;
}

其实写完这篇博客，我个人是蒙蒙懵逼的。。。

P1070 道路游戏（单调队列+动态规划）

单调队列！！！

猜你喜欢