免费馅饼（动态规划）

免费馅饼（动态规划）

Time limit1000 ms
Memory limit32768 kB
OSWindows
judge:VJudge

Description

都说天上不会掉馅饼，但有一天gameboy正走在回家的小径上，忽然天上掉下大把大把的馅饼。说来gameboy的人品实在是太好了，这馅饼别处都不掉，就掉落在他身旁的10米范围内。馅饼如果掉在了地上当然就不能吃了，所以gameboy马上卸下身上的背包去接。但由于小径两侧都不能站人，所以他只能在小径上接。由于gameboy平时老呆在房间里玩游戏，虽然在游戏中是个身手敏捷的高手，但在现实中运动神经特别迟钝，每秒种只有在移动不超过一米的范围内接住坠落的馅饼。现在给这条小径如图标上坐标：

为了使问题简化，假设在接下来的一段时间里，馅饼都掉落在0-10这11个位置。开始时gameboy站在5这个位置，因此在第一秒，他只能接到4,5,6这三个位置中其中一个位置上的馅饼。问gameboy最多可能接到多少个馅饼？（假设他的背包可以容纳无穷多个馅饼）

Input

输入数据有多组。每组数据的第一行为以正整数n(0

Output

每一组输入数据对应一行输出。输出一个整数m，表示gameboy最多可能接到m个馅饼。
提示：本题的输入数据量比较大，建议用scanf读入，用cin可能会超时。

Sample Input

6
5 1
4 1
6 1
7 2
7 2
8 3
0

Sample Output

4

题解

网上的题解几乎都是从下往上进行分析的，这样做的确可以让代码更好写，不用考虑复杂的有效范围的问题。

不过我从拿到题就一直在考虑从上往下的做法，故在此记录下我的想法。

---

定义$dp[i][j]$：$i$秒之后在$j$位置能拿到的最多馅饼数量。
状态转移方程：$dp[i][j]=max(dp[i-1][j-1],dp[i-1][j],dp[i-1][j+1])+v[i][j]$

不过由于主人公的活动范围有限，所以要时刻判断当前位置在当前时间能否走到。

此外，由于此题是多组数据，我并没有在原矩阵里进行递推，而是另外开了个两行的数组进行滚动压缩空间。这样虽然牺牲了一点点空间，但是初始化时我们就不必每个位置都重置，只需要枚举出现过的位置进行重置即可，可以节约一些时间。

代码

#pragma GCC optimize(2)
#include 
#define _for(i, a) for(register int i = 0, lennn = (a); i < lennn; ++i)
#define _rep(i, a, b) for(register int i = (a), lennn = (b); i <= lennn; ++i)
#define mem0(a) memset(a, 0, sizeof(a))
#define max(a, b) ((a) > (b) ? (a) : (b))
using namespace std;
const int maxn = 100005;

inline int read() {
     
    int x(0), f(1); char ch(getchar());
    while (ch<'0' || ch>'9') {
      if (ch == '-') f = -1; ch = getchar(); }
    while (ch >= '0'&&ch <= '9') {
      x = x * 10 + ch - '0'; ch = getchar(); }
    return x * f;
}

int n;
int v[maxn][13];
int dp[2][13];
pair<int, int> a[maxn];

bool che(int p, int i) {
     //判断当前位置在当前时间能否走到
    return abs(p - 5) <= i;
}

int main() {
     
    while(n = read(), n) {
     
        int f = 1;
        _for(i, n) a[i].second = read(), a[i].first = read();
        _for(i, n) ++v[a[i].first][a[i].second];
        int end = 0, ans = 0;
        _for(i, n) end = max(end, a[i].first);
        _rep(i, 1, end) {
     
            _for(j, 11) {
     
                if(che(j, i)) dp[f][j] += v[i][j];
                if(che(j, i + 1)) dp[f ^ 1][j] = max(dp[f ^ 1][j], dp[f][j]);
                if(che(j - 1, i + 1) && j - 1 >= 0) dp[f ^ 1][j - 1] = max(dp[f ^ 1][j - 1], dp[f][j]);
                if(che(j + 1, i + 1) && j + 1 <= 10) dp[f ^ 1][j + 1] = max(dp[f ^ 1][j + 1], dp[f][j]);
            }
            if(i == end) _for(j, 11) ans = max(ans, dp[f][j]);
            mem0(dp[f]);
            f ^= 1;
        }
        printf("%d\n", ans);
        mem0(dp);
        _for(i, n) v[a[i].first][a[i].second] = 0;
    }
    return 0;
}