NOIP2009普及组T4：道路游戏

题目链接

[NOIP 2009 普及组] 道路游戏

题目描述

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

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

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

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

1. 游戏从小新第一次购买机器人开始计时。
2. 购买机器人和设定机器人的行走次数是瞬间完成的，不需要花费时间。
3. 购买机器人和机器人行走是两个独立的过程，机器人行走时不能购买机器人，购买完机器人并且设定机器人行走次数之后机器人才能行走。
4. 在同一个机器人工厂购买机器人的花费是相同的，但是在不同机器人工厂购买机器人的花费不一定相同。
5. 购买机器人花费的金币，在游戏结束时再从小新收集的金币中扣除，所以在游戏过程中小新不用担心因金币不足，无法购买机器人而导致游戏无法进行。也因为如此，游戏结束后，收集的金币数量可能为负。

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

输入格式

第一行 $3$ 个正整数 $n,m,p$，意义如题目所述。

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

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

输出格式

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

输入输出样例 #1

输入 #1

2 3 2 
1 2 3 
2 3 4 
1 2

输出 #1

5

说明/提示

对于 $40\%$ 的数据，$2\le n\le 40$，$1\le m\le 40$。

对于 $90\%$ 的数据，$2\le n\le 200$，$1\le m\le 200$。

对于 $100\%$ 的数据，$2\le n\le 1000$，$1\le m\le 1000$，$1\le p\le m$。

样例分析

小新在$1$ 号机器人工厂花费$1$金币购买机器人，设定机器人的行走$2$次数，开始计时：

• 行走$1$次，在第$1$个单位时间经过$1$号马路，得到$1$个金币，到达2号工厂。
• 行走$2$次，在第$2$个单位时间经过$2$号马路，得到$3$个金币，到达1号工厂，重新花费$1$金币购买机器人。
• 行走$3$次，在第$3$个单位时间经过$1$号马路，得到$3$个金币

小新在$3$个单位时间内花费了$2$个金币购买机器人，一共获得$7$个金币，最后的收益是$5$个金币。

算法思想（动态规划）

状态表示

要计算机器人经过$m$个单位时间，走到某个工厂时能获取的最大收益，不妨设：

• 状态f[i]表示前i个单位时间的最大收益

状态计算

考虑到每个机器人最多能够在环形马路上行走 $p$ 次，那么要计算f[i]，可以分成下面若干种情况：

• 在第i - 1个单位时间出发，行走$1$次，通过第j号马路获得的金币数量 - 在j号工厂购买机器人花费的金币数量
• 在第i - 2个单位时间出发，行走$2$次，通过第j-1、j号马路获得的金币数量 - 在j-1号工厂购买机器人花费的金币数量
• …
• 在第i - k个单位时间出发，行走$k$次，通过第j-k+1、j-k+2、...、j号马路获得的金币数量 - 在j-k+1号工厂购买机器人花费的金币数量
• …

显然，f[i]要取以上情况的最大值，即

• f[i] = max{f[i - k] + 该情况下获得的金币数 - w[j - k + 1]}

其中

• 1 <= k <= i， k <= p, 1 <= j <= n
• w[j]表示从第j个工厂购买机器人需要花费的金币数

可以用前缀和的思想，计算每种情况下获得的金币数：

• s[j][i]表示在第1单位时间从第1个工厂出发，在第i个单位时间到经过第j号马路获得的金币数量之和，如下图所示：
  

• s[j][i] - s[j - k][i - k]表示从i - k + 1到i这段时间，通过第j-k+1、j-k+2、...、j号马路得到的金币数量之和

那么

• f[i] = max{f[i - k] + s[j][i] - s[j - k][i - k] - w[j - k + 1]}

注意，进行状态计算时，由于是一条环形马路，第$n$段马路连接第$1$段马路，当j - k、j - k + 1小于等于$0$时，要获取正确的马路编号：

int get(int x) //确定x在1~n中的编号
{
    x %= n;
    if(x <= 0) x += n;
    return x;
}

时间复杂度

计算状态时有i,j,k三个变量，时间复杂度为$O(n^3)$，尚需优化…不过题目中数据比较水，是可以AC的O(∩_∩)O哈哈~

代码实现

#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, m, p;
int s[N][N], w[N];
int f[N];
int get(int x) //确定x在1~n中的编号
{
    x = x % n;
    if(x <= 0) x += n;
    return x;
}
int main()
{
    cin >> n >> m >> p;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            cin >> s[i][j];
    for(int i = 1; i <= n; i ++) cin >> w[i];
    
    //计算矩阵从[1, 1]开始向右下角走到[j, i]得到的金币数量之和
    for(int i = 1; i <= m; i ++)
        for(int j = 1; j <= n; j ++)
            if(j == 1) s[j][i] += s[n][i - 1]; //在环形马路上，第n段马路连接第1段马路
            else s[j][i] += s[j - 1][i - 1];
    
    memset(f, -0x3f, sizeof f); //可能存在负值，将初始状态设为负无穷
    f[0] = 0;

    for(int i = 1; i <= m; i ++)
        for(int j = 1; j <= n; j ++)
            for(int k = 1; k <= min(i, p); k ++) 
                f[i] = max(f[i], f[i - k] + s[j][i] - s[get(j - k)][i - k] - w[get(j - k + 1)]);
            
    int ans = 0;
    for(int i = 0; i <= m; i ++) ans = max(ans, f[i]);
    cout << ans << endl;
    return 0;
}

算法优化

在分析状态计算时，得到状态转移方程：

• f[i] = max{f[i - k] + s[j][i] - s[j - k][i - k] - w[j - k + 1]}

在状态转移方程中，可以将s[j][i]提取出来，得到：

• f[i] = max{f[i - k] - s[j - k][i - k] - w[j - k + 1]} + s[j][i]

不妨令g[i][j] = f[i] - s[j][i] - w[j + 1]，那么方程可以变为：

• f[i] = max{g[j - k][i - k]} + s[j][i]

可以发现状态转移方程是对一系列长度为 p 的滑动窗口求最大值，如下图所示：

每一条斜线用一个优先队列（堆）来维护，可以在$O(logn)$取得最大值。斜线的下标可以用i - j来表示。

时间复杂度变为$O(n^{2}logn)$

代码实现

#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
struct Node{
    int v, i, j; //优先队列中的节点g[j][i]
    bool operator < (const Node &t) const
    {
        return v < t.v;
    }
};
int n, m, p;
int s[N][N], w[N];
int f[N], g[N][N];
priority_queue<Node> heap[N]; //大顶堆，取最大值
int get(int x) //确定x在1~n中的编号
{
    x = x % n;
    if(x <= 0) x += n;
    return x;
}
int main()
{
    cin >> n >> m >> p;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            cin >> s[i][j];
    for(int i = 1; i <= n; i ++) cin >> w[i];
    
    //计算矩阵从[j, i]开始向左上角走的路径上的金币数量之和
    for(int i = 1; i <= m; i ++)
        for(int j = 1; j <= n; j ++)
            if(j == 1) s[j][i] += s[n][i - 1]; //在环形马路上，第n段马路连接第1段马路
            else s[j][i] += s[j - 1][i - 1];
    
    memset(f, -0x3f, sizeof f);
    f[0] = 0;
    memset(g, -0x3f, sizeof g);
    for(int i = 1; i <= n; i ++)
    {
        g[0][i] = -w[get(i + 1)]; //在第0个单位时间，在第i个工厂的代价（购买机器人的花费）
        heap[get(0 - i)].push({g[0][i], 0, i}); //将初始值压入对应的优先队列
    }

    for(int i = 1; i <= m; i ++)
    {
        for(int j = 1; j <= n; j ++)
        {
            auto &q = heap[get(i - j)]; //获取斜线对应的优先队列
            while(q.size()){
                auto t = q.top();
                if(i - p > t.i) q.pop(); //不在p时间内，弹出
                else
                {
                    f[i] = max(f[i], t.v + s[j][i]); //取斜线的最大值
                    break;
                }
            }
        }
        for(int j = 1; j <= n; j ++)
        {
            g[i][j] = f[i] - s[j][i] - w[get(j + 1)];
            heap[get(i - j)].push({g[i][j], i, j});
        }
    }
            
    int ans = 0;
    for(int i = 0; i <= m; i ++) ans = max(ans, f[i]);
    cout << ans << endl;
    return 0;
}