這道題分了三類，
對於 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;
}

其實寫完這篇部落格，我個人是濛濛懵逼的。。。