noip2009 道路游戏 （单调队列优化动态规划）

1815道路游戏
Accepted

标签：NOIP普及组2009

描述

小新正在玩一个简单的电脑游戏。

游戏中有一条环形马路，马路上有n 个机器人工厂，两个相邻机器人工厂之间由一小段马路连接。小新以某个机器人工厂为起点，按顺时针顺序依次将这n 个机器人工厂编号为1~n，因为马路是环形的，所以第n 个机器人工厂和第1 个机器人工厂是由一段马路连接在一起的。小新将连接机器人工厂的这n 段马路也编号为1~n，并规定第i 段马路连接第i 个机器人工厂和第i+1 个机器人工厂（1 ≤ i ≤ n-1），第n 段马路连接第n 个机器人工厂和第1个机器人工厂。 

游戏过程中，每个单位时间内，每段马路上都会出现一些金币，金币的数量会随着时间发生变化，即不同单位时间内同一段马路上出现的金币数量可能是不同的。小新需要机器人的帮助才能收集到马路上的金币。所需的机器人必须在机器人工厂用一些金币来购买，机器人一旦被购买，便会沿着环形马路按顺时针方向一直行走，在每个单位时间内行走一次，即从当前所在的机器人工厂到达相邻的下一个机器人工厂，并将经过的马路上的所有金币收集给小新，例如，小新在i（1 ≤ i ≤ n）号机器人工厂购买了一个机器人，这个机器人会从i 号机器人工厂开始，顺时针在马路上行走，第一次行走会经过i
号马路，到达i+1 号机器人工厂（如果i=n，机器人会到达第1 个机器人工厂），并将i 号马路上的所有金币收集给小新。 游戏中，环形马路上不能同时存在2 个或者2 个以上的机器人，并且每个机器人最多能够在环形马路上行走p 次。小新购买机器人的同时，需要给这个机器人设定行走次数，行走次数可以为1~p 之间的任意整数。当马路上的机器人行走完规定的次数之后会自动消失，小新必须立刻在任意一个机器人工厂中购买一个新的机器人，并给新的机器人设定新的行走次数。 

以下是游戏的一些补充说明：

1. 游戏从小新第一次购买机器人开始计时。

2. 购买机器人和设定机器人的行走次数是瞬间完成的，不需要花费时间。

3. 购买机器人和机器人行走是两个独立的过程，机器人行走时不能购买机器人，购买完机器人并且设定机器人行走次数之后机器人才能行走。

4. 在同一个机器人工厂购买机器人的花费是相同的，但是在不同机器人工厂购买机器人的花费不一定相同。

5. 购买机器人花费的金币，在游戏结束时再从小新收集的金币中扣除，所以在游戏过程中小新不用担心因金币不足，无法购买机器人而导致游戏无法进行。也因为如此，游戏结束后，收集的金币数量可能为负。 

现在已知每段马路上每个单位时间内出现的金币数量和在每个机器人工厂购买机器人需要的花费，请你告诉小新，经过m 个单位时间后，扣除购买机器人的花费，小新最多能收集到多少金币。

格式

输入格式

第一行 3 个正整数，n，m，p(2 ≤ n ≤ 1000，1 ≤m≤ 1000，1 ≤ p ≤m)，意义如题目所述。

接下来的 n 行，每行有m 个正整数，每两个整数之间用一个空格隔开，其中第i 行描述了i 号马路上每个单位时间内出现的金币数量（1 ≤ 金币数量≤ 100），即第i 行的第j（1 ≤ j ≤m）个数表示第j 个单位时间内i 号马路上出现的金币数量。

最后一行，有 n 个整数，每两个整数之间用一个空格隔开，其中第i 个数表示在i 号机器人工厂购买机器人需要花费的金币数量（1 ≤ 金币数量≤ 100）。

输出格式

共一行，包含1 个整数，表示在m 个单位时间内，扣除购买机器人花费的金币之后，小新最多能收集到多少金币。

样例1

样例输入1[复制]

2 3 2
1 2 3
2 3 4
1 2

样例输出1[复制]

5

限制

每个测试点1s。

来源

NOIP2009普及组

解析：摘自sentimental_man 

          原文链接：http://blog.163.com/sentimental_man/blog/static/73001618201110193442301/

          /*

       这题乍一看是DP
f(i,j)代表第i个时间走到第j个位置得到的最大金币数，有n^2个状态（因为n和m的上界相等，所以后边都用n代替），对每个状态枚举p，这样复杂度是O(n^3)，能得90分
f(i,j)=max{ fm[i-k-1]+val[i-k][j-k][k]-cost[j-k] | 0<k<p}
fm[i]表示走到第i秒可以得到的最大金币数，即fm[i]=max( fm[i-1] , max{ f(i,j) | 0<j<n } ) （因为这一步也可能不选机器人），跟着f一起求出来即可
cost[i]表示第i个位置生产机器人的代价
val[i][j][k]就是第i秒开始在第j个位置走k步能捡到的金币数，可以预处理一个数组a[i][j]表示从第0秒走到第i秒第j个位置能捡到的金币数，a[i][j]=a[i-1][j-1]+第i秒第j个位置的金币数，那么val[i-k][j-k][k]=a[i][j]-a[i-k-1][j-k-1]，方程变为：
f(i,j)=max{ fm[i-k-1]+a[i][j]-a[i-k-1][j-k-1]-cost[j-k] | 0<k<p}
这样就可以很容易地写出程序了，要注意边界条件（路是环形的）

要想得满分的话，我们需要O(n^2)的算法，在原来的基础上降一维即可。
注意到这是一个2D/1D的动态规划，可不可以降到2D/0D，即对每一个状态，不用枚举p呢？
答案是可以的。
观察方程：f(i,j)=max{ fm[i-k-1]+a[i][j]-a[i-k-1][j-k-1]-cost[j-k] | 0<k<p}
由于a[i][j]和k是没关系的，可以提出来
f(i,j)=a[i][j]+max{ fm[i-k-1]-a[i-k-1][j-k-1]-cost[j-k] | 0<k<p}
设g[i][j]=fm[i-1]-a[i-1][j-1]-cost[j]
f(i,j)=a[i][j]+max{ g[i-k][j-k] | 0<k<p}
我们只需要令g[i-k][j-k]最大就可以了。
对任意0<k1<k2<p，若g[i-k1][j-k1]<g[i-k2][j-k2]，那么k1就永远不会被取到了
所以，可用的决策点g值一定是单调递减的，我们把它们维护到一个队列里，最大值即为队头元素。维护的方法是：如果队头元素大于p步则出队，每次在队尾加入新的决策点使队列保持单调递减。由于每个位置可取的决策点是不一样的，需要维护n个单调队列。这样，每个状态就可以用O(1)的时间求出来。
至此，问题圆满解决。

         */

代码：

#include<cstdio>
#include<algorithm>
#define maxn 1000
#define inf 1000000000
using namespace std;

struct tnode{int x,y;}q[maxn+20][maxn+10];
int n,m,p;
int a[maxn+10][maxn+10],b[maxn+10][maxn+10];
int fm[maxn+10],cost[maxn+10];

void readdata()
{
int i,j,k;
scanf("%d%d%d",&n,&m,&p);
for(i=0;i<n;i++)
for(j=1;j<=m;j++)
scanf("%d",&b[i][j]);
for(i=0;i<n;i++)scanf("%d",&cost[i]);

for(i=0;i<n;i++)a[1][i]=b[i][1];
for(i=2;i<=m;i++)
for(j=0;j<n;j++)
a[i][j]=a[i-1][(j-1+n)%n]+b[j][i];
}

void del(int t,int yy)
{
int i,j,k=q[t][0].x;
for(i=k;q[t][i].y>0;i++)
if(yy-q[t][i].y<p)break;
q[t][0].x=i;
}

void add(int t,int yy,int xx)
{
int i,j,k=q[t][0].x;
if(k==0)
{
q[t][0].x=1;
q[t][1].x=xx,q[t][1].y=yy;
return;
}
for(i=k;q[t][i].y>0;i++)
if(q[t][i].x<=xx)break;
q[t][i].x=xx,q[t][i].y=yy;
}

void work()
{
int i,j,k,x;
for(i=1;i<=m;i++)
for(fm[i]=-inf,j=0;j<n;j++)
{
k=(i-j+n)%n,del(k,i);
add(k,i,fm[i-1]-a[i-1][(j-1+n)%n]-cost[j]);
x=a[i][j]+q[k][q[k][0].x].x;
fm[i]=max(fm[i],x);
}
printf("%d\n",fm[m]);
}

int main()
{
readdata();
work();
return 0;
}