NOIP 道路游戏

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

游戏中有一条环形马路，马路上有 nn 个机器人工厂，两个相邻机器人工厂之间由一小段马路连接。

小新以某个机器人工厂为起点，按顺时针顺序依次将这 nn 个机器人工厂编号为 1∼n1∼n，因为马路是环形的，所以第 nn 个机器人工厂和第 11 个机器人工厂是由一段马路连接在一起的。

小新将连接机器人工厂的这 nn 段马路也编号为 1∼n1∼n，并规定第 ii 段马路连接第 ii 个机器人工厂和第 i+1i+1 个机器人工厂（1≤i≤n−11≤i≤n−1），第 nn 段马路连接第 nn 个机器人工厂和第 11 个机器人工厂。

游戏过程中，每个单位时间内，每段马路上都会出现一些金币，金币的数量会随着时间发生变化，即不同单位时间内同一段马路上出现的金币数量可能是不同的。

小新需要机器人的帮助才能收集到马路上的金币。

所需的机器人必须在机器人工厂用一些金币来购买，机器人一旦被购买，便会沿着环形马路按顺时针方向一直行走，在每个单位时间内行走一次，即从当前所在的机器人工厂到达相邻的下一个机器人工厂，并将经过的马路上的所有金币收集给小新，例如，小新在 ii（1≤i≤n1≤i≤n）号机器人工厂购买了一个机器人，这个机器人会从 ii 号机器人工厂开始，顺时针在马路上行走，第一次行走会经过 ii 号马路，到达 i+1i+1 号机器人工厂（如果 i=ni=n，机器人会到达第 11 个机器人工厂），并将 ii 号马路上的所有金币收集给小新。

游戏中，环形马路上不能同时存在 22 个或者 22 个以上的机器人，并且每个机器人最多能够在环形马路上行走 pp 次。

小新购买机器人的同时，需要给这个机器人设定行走次数，行走次数可以为 1∼p1∼p 之间的任意整数。

当马路上的机器人行走完规定的次数之后会自动消失，小新必须立刻在任意一个机器人工厂中购买一个新的机器人，并给新的机器人设定新的行走次数。 

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

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

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

输入格式

第一行 33 个正整数，n，m，pn，m，p，意义如题目所述。

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

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

输出格式

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

数据范围

2≤n≤10002≤n≤1000,
1≤m≤10001≤m≤1000,
1≤p≤m1≤p≤m

输入样例：

2 3 2
1 2 3
2 3 4
1 2

输出样例：

5

算法
(DP,斜线型DP,堆) O(n2logn)O(n2logn)
状态表示：

f[i]表示前i单位时间内可获取的最多金币数；
s[i, j]表示从[i, j]开始向左上角走的路径上的金币数量之和，注意如果走到第一行，则跳至最后一行继续走；
cost[i]表示从第i个点购买机器需要花费的金币数；
状态转移：

f[i] = max{f[i - k] + s[j, i] - s[j - k, i - k] - cost[j - k + 1]}，其中1 <= k <= i, k <= p, 1 <= j <= n；
整理一下可得：

f[i] = max{f[i - k] - s[j - k, i - k] - cost[j - k + 1]} + s[j, i]
我们令g[i, j] = f[i] - s[j, i] - cost[j + 1]，则：

f[i] = max{g[i - k][j - k]} + s[j, i]，其中1 <= k <= i, k <= p, 1 <= j <= n；
其中有三个变量，需要 O(n3)O(n3) 的计算量，因此需要优化。

我们发现状态转移方程是对长度为 pp 的滑动窗口求最大值，因此可以用单调队列或者堆可以去掉一重循环。

这里为了思路简单，我们选择堆来优化。

时间复杂度
总共两重循环，以及一重堆的操作，因此总时间复杂度是 O(n2logn)O(n2logn)。

C++ 代码
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 1010;

int n, m, p;
int s[N][N], cost[N];
int f[N], g[N][N];

struct Node
{
    int v, i, j;
    bool operator< (const Node& W) const
    {
        return v < W.v;
    }
};

priority_queue<Node> heap[N];

int get(int x)
{
    x %= n;
    if (x <= 0) x += n;
    return x;
}

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", &s[i][j]);

    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= n; j++)
            if (j == 1) s[j][i] += s[n][i - 1];
            else s[j][i] += s[j - 1][i - 1];

    memset(f, -0x3f, sizeof f);
    memset(g, -0x3f, sizeof g);
    f[0] = 0;

    for (int i = 1; i <= n; i++) scanf("%d", &cost[i]);
    for (int i = 1; i <= n; i++)
    {
        g[0][i] = -cost[get(i + 1)];
        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& h = heap[get(i - j)];
            while (h.size())
            {
                auto t = h.top();
                if (i - p > t.i) h.pop();
                else
                {
                    f[i] = max(f[i], s[j][i] + t.v);
                    break;
                }
            }
        }
        for (int j = 1; j <= n; j++)
        {
            g[i][j] = f[i] - s[j][i] - cost[get(j + 1)];
            heap[get(i - j)].push({ g[i][j], i, j });
        }
    }

    int res = 0;
    for (int i = 0; i <= m; i++) res = max(res, f[i]);
    cout << res << endl;
    return 0;
}