P1070 道路游戏

P1070 道路游戏

题目描述

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

游戏中有一条环形马路，马路上有 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，意义如题目所述。

接下来的 n 行，每行有 m 个正整数，每两个整数之间用一个空格隔开，其中第 i 行描

述了 i 号马路上每个单位时间内出现的金币数量（1≤金币数量≤100），即第 i 行的第 j（1≤j≤m）个数表示第 j 个单位时间内 i 号马路上出现的金币数量。

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

 

输出格式：

 

共一行，包含 1 个整数，表示在 m 个单位时间内，扣除购买机器人

花费的金币之后，小新最多能收集到多少金币。

 

输入输出样例

输入样例#1：

2 3 2 
1 2 3 
2 3 4 
1 2

输出样例#1：

5

说明

【数据范围】

对于 40%的数据，2≤n≤40，1≤m≤40。

对于 90%的数据，2≤n≤200，1≤m≤200。

对于 100%的数据，2≤n≤1000，1≤m≤1000，1≤p≤m。

NOIP 2009 普及组 第四题

 

分析：

记忆化搜索和dp差不多，dp思路可以通过记忆化搜索来启发

f[i]到第时间i时的最大值。

枚举时间

枚举买机器人的位置

枚举买机器人运动时间

 

80分

#include<cstdio>
#include<cstring>
#include<algorithm>
#define MAXN 1010
int c[MAXN],mo[MAXN][MAXN],f[MAXN];
int n,m,p;
void init()
{
    scanf("%d%d%d",&n,&m,&p);
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j)
            scanf("%d",&mo[i][j]);
    for (int i=1; i<=n; ++i)
        scanf("%d",&c[i]);
}
void dp()
{
    for (int i=1; i<=m; ++i)        //枚举时间 
    {
        for (int j=1; j<=n; ++j)    //枚举位置 
        {
            int r = j==1?n:j-1, sum = 0;    //r是j的前一个点 
            sum += mo[r][i];        //sum加上捡到的金币
            for (int k=1; k<=p; ++k)//枚举买机器人的时间 
            {
                if (i-k<0) break ;
                f[i] = std::max(f[i],f[i-k]-c[r]+sum);
                //枚举，f[i-k]就是第（i-k）时间时的最优解
                //r就是买机器人的工厂位置
                //sum是这个机器人捡的金币，即从r走来时捡到的金币 
                r = r==1?n:r-1;     //倒回前一个工厂
                sum += mo[r][i-k];    //从r走过来的路上捡到的金币
            }
        }
    }
    printf("%d",f[m]);
}
int main()
{
    init();
    dp();
    return 0;
}

100分

#include<iostream>
#include<cstdio>
#include<cstring>

#define maxn 1010

using namespace std;
int n,m,p,g[maxn][maxn],w[maxn],f[maxn];

int main()
{
    scanf("%d%d%d",&n,&m,&p);
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++)
      scanf("%d",&g[i][j]);
    for(int i=1;i<=n;i++)  scanf("%d",&w[i]);
    memset(f,128,sizeof(f));f[0]=0;
    for(int i=1;i<=m;i++)
      for(int j=1;j<=n;j++)//这次的出发点 
        {  
          int r=j-1,vi=0;//vi 表示累计的收益 
          if(r==0)r=n;vi+=g[r][i];//当前道路花费 
          for(int k=1;k<=p;k++)//枚举买机器人的时间 
            {
                if(i-k<0)continue;
                f[i]=max(f[i],f[i-k]-w[r]+vi);
                if(r==1)r=n;else r--;//前一个工厂
                vi+=g[r][i-k];//O(1)计算 
            }
        }
    printf("%d\n",f[m]);
    return 0;
}

 

f[i]表示在时间i所有位置的最大收益

状态转移方程

r表示j的前一个点

f[i]=max(f[i],f[i-k]-w[r]+vi);

 

心得

1、通过计算机输出中间变量的方式比较容易能看懂代码和方法

2、可以弄个pre[i]记录前驱节点，也可以这样

3、状态转移方程，应该可以自己想的会的

4、一定要把这些代码弄懂能够敲出来

5、不会做先跟着它敲一遍，然后再自己敲

6、子结构，子问题，我都没意识到么

7、线性DP

 

8、因为dp的值可能有负的，又是求最大值，所以memset(128)

9、DP过程，前i分钟走到j位置的最后一个机器人走了k步的方程。

10、ijk合起来不懂的时候我们就看ij

 

 

空间换时间

1、这里我能优化是因为我那g[i][j]这个数组换了时间

O（mn）

dp[i][j]表示时间i在j点的最大收益，pre[j]表示j点的上一个，

mx[i]表示在时间i所有位置的最大收益（因为买机器人是任意位置可买，转移时直接用即可）,

g[i][j]表示状态(i,j)取最优解时走的最少步数（显然越少越好）

 

如果已经有机器人并且它还可以走的情况：

dp[i][j]=max(dp[i][j]+dp[i-1][pre[j]]+mon[pre[j]][i]);

如果走了

mx[i]=max(mx[i],dp[i][j]);

g[i][j]=g[i-1][pre[j]]+1;

 

如果机器人不能走了或者我们想换机器人了

dp[i][j]=max(dp[i][j], mx[i-1]+mon[pre[j]][i]-c[pre[j]]);

如果我们换了机器人

mx[i]=max(mx[i],dp[i][j]);

g[i][j]=g[i-1][pre[j]]+1;

 

O(MN)

#include<iostream>
#include<cstdio>
#include<cstring>
#define maxn 1005
#define inf 0x3f3f3f
using namespace std;
inline void read(int &num){
    char c;bool flag=0;num=0;
    while((c=getchar())>57||c<48);
    if(c=='-')flag=1;
    else num+=c-48;
    while((c=getchar())>=48&&c<=57)num=num*10+c-48;
    if(flag)num*=-1;
    return;
}
 
/*
空间换时间 
O（mn） 
dp[i][j]表示时间i在j点的最大收益，pre[j]表示j点的上一个，
mx[i]表示在时间i所有位置的最大收益（因为买机器人是任意位置可买，转移时直接用即可）,
g[i][j]表示状态(i,j)取最优解时走的最少步数（显然越少越好）
*/ 
int n,m,p,mon[maxn][maxn],c[maxn],dp[maxn][maxn],mx[maxn],g[maxn][maxn],pre[maxn];
int main(){
    memset(dp,-0x3f,sizeof(dp));
    memset(mx,-0x3f,sizeof(mx));
    mx[0]=0;
    read(n),read(m),read(p);
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
            read(mon[i][j]);
    for(int i=1;i<=n;++i) read(c[i]),pre[i]=(i-1?i-1:n),dp[0][i]=0;
    for(int i=1;i<=m;++i){
        for(int j=1;j<=n;++j){
            //机器人如果还可以走。我们就让机器人走 
            //第一次你肯定不能不买机器人，
            if(g[i-1][pre[j]]<p&&i>1){
                //让之前那个机器人从j的前一步开始走，如果这个值优于dp[i][j]，我们就更新它 
                if(dp[i][j]<dp[i-1][pre[j]]+mon[pre[j]][i]){
                    dp[i][j]=dp[i-1][pre[j]]+mon[pre[j]][i];
                    //更新mx[i] 
                    mx[i]=max(mx[i],dp[i][j]);
                    //机器人的步数加上走的这一步 
                    g[i][j]=g[i-1][pre[j]]+1;
                }
            }
            //在j的前面一步买机器人，如果我们买机器人的收益大，我们就买机器人 
            if(dp[i][j]<mx[i-1]+mon[pre[j]][i]-c[pre[j]]){
                //更新dp[i][j] 
                dp[i][j]=mx[i-1]+mon[pre[j]][i]-c[pre[j]];
                //更新mx[i] 
                mx[i]=max(mx[i],dp[i][j]);
                //更新步数 
                g[i][j]=1;
            }
        }
    }
    int ans=-inf;
    for(int i=1;i<=n;++i) ans=max(ans,dp[m][i]);
    printf("%d",ans); 
    return 0;
}

 

 

这里也是一个易错点：

第18行：num[j][i]=num[pre[j]][i-1]+1;//写成了 num[j][i]++

#include <bits/stdc++.h>
const int N=1e3+10;
using namespace std;
int dp[N][N],f[N],pre[N],g[N][N],num[N][N],a[N],n,m,p;

int main(){
    //freopen("in.txt","r",stdin);
    cin>>n>>m>>p;
    memset(dp,128,sizeof(dp)); memset(f,128,sizeof(f));
    f[0]=0;
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) cin>>g[i][j];
    for(int i=1;i<=n;i++) cin>>a[i],pre[i]=(i-1?i-1:n),dp[i][0]=0;
    for(int i=1;i<=m;i++) for(int j=1;j<=n;j++){
        if(num[pre[j]][i-1]<p&&i>1)
            if(dp[j][i]<dp[pre[j]][i-1]+g[pre[j]][i]){
                dp[j][i]=dp[pre[j]][i-1]+g[pre[j]][i];
                f[i]=max(f[i],dp[j][i]);
                num[j][i]=num[pre[j]][i-1]+1;//写成了 num[j][i]++
            }
        if(dp[j][i]<dp[pre[j]][i-1]+g[pre[j]][i]-a[pre[j]]){
            dp[j][i]=dp[pre[j]][i-1]+g[pre[j]][i]-a[pre[j]];
            f[i]=max(f[i],dp[j][i]);
            num[j][i]=1;
        }
    }
    int ans=-1<<30;
    for(int i=i;i<=m;i++) ans=max(ans,f[i]);
    cout<<f[m]<<endl;
    return 0;
} 

 

单调队列+DP优化

用 f[i] 表示到时间 i 可以得到的最多金钱

转移很显然，枚举到达的点 j 以及走的步数 k：

f[i]=max(f[i−k]+(g[j−1][i]−g[j−k−1][i-k])−a[j−k])(0<j<n,0<k≤min(i,p))

（其中 g 数组表示斜着的部分和）注意上面没有考虑环的情况

然而这样子做是 O(N​3​​) 的，理论上是过不了的

我们考虑进行简化，（即省掉 k 循环）先把只有关 i 和 j 的独立出来

f[i]=max(f[i−k]−g[j−k−1][i-k]−a[j−k])+g[j−1][i]

然后我们设一个 h[i][j]：

h[i][j]=f[i]−g[j−1][i]−a[j]

则转移方程变成了：

f[i][j]=max(h[i−k][j−k])+g[j−1][i](0<k≤min(i,p))

而每个对于每个 f[i][j]，它都是相当于在斜线上转移：

 

（相同颜色的格子代表斜线）对于每个 f[i][j]，相当于要求斜线上最多 p 个元素的最大值

然后注意到这是个连续的滑动区间，并且是二维的，于是用 n 个单调队列维护一下就好了

 

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <utility>
#define N 1020
#define INFINITE 999999999
using namespace std;

class Queue
{
private:
    pair<int, int> f[N];
    int l, r;

public:
    Queue() : l(0), r(0)
    {
        return;
    }

    bool Empty(void)
    {
        return l == r;
    }

    pair<int, int> Back (void)
    {
        return f[r - 1];
    }

    pair<int, int> Front(void)
    {
        return f[l    ];
    }

    void Push_Back(pair<int, int> x)
    {
        f[r ++] = x;

        return;
    }

    void Pop_Back (void)
    {
        r --;

        return;
    }

    void Pop_Front(void)
    {
        l ++;

        return;
    }
};

int n, a[N];
int f[N], g[N][N];
Queue q[N];

void PushOrder(Queue &q, int x, int p)
{
    while(!q.Empty() && q.Back().first <= x)
        q.Pop_Back();
    q.Push_Back(make_pair(x, p));

    return;
}

void PopOrder(Queue &q, int p)
{
    if(q.Front().second <= p)
        q.Pop_Front();

    return;
}

int MaxOrder(Queue &q)
{
    return q.Front().first;
}

int Reload(int x, int k)//解决环和往之前走 
{
    return ((x - k) % n + n) % n;
}

int main()
{
    int m, p;
    int i, j;

    scanf("%d %d %d", &n, &m, &p);
    for(i = 0;i < n;i ++)//i是工厂编号 
        for(j = 1;j <= m;j ++)//j是时间 
            scanf("%d", &g[i][j]);
    for(i = 0;i < n;i ++)
        scanf("%d", &a[i]);
    //有点像前缀和，这样操作之后保证g[i][j]里面存的是超过i号工厂的前j分钟路上的所有金币，用的时候i-1 
    for(j = 2;j <= m;j ++)//j是时间 
        for(i = 0;i < n;i ++)//i是工厂编号 
            g[i][j] += g[(i - 1 + n) % n][j - 1];

    for(i = 0;i < n;i ++)
        PushOrder(q[Reload(i, -1)], -a[i], 0);

    for(i = 1;i <= m;i ++)
    {
        for(j = 0, f[i] = -INFINITE;j < n;j ++)
            f[i] = max(f[i], MaxOrder(q[Reload(j, i - 1)]) + g[Reload(j, 1)][i]);

        for(j = 0;j < n;j ++)
        {
            PopOrder (q[Reload(j, i - 1)], i - p);
            PushOrder(q[Reload(j, i - 1)], f[i] - g[Reload(j, 1)][i] - a[j], i);
        }
    }
    cout << f[m] << endl;

    return 0;
}