可爱精灵宝贝 动态规划讲解

Description
Branimirko是一个对可爱精灵宝贝十分痴迷的玩家。最近，他闲得没事组织了一场捉精灵的游戏。游戏在一条街道上举行，街道上一侧有一排房子，从左到右房子标号由1到n。
刚开始玩家在k号房子前。有m个精灵，第i只精灵在第A[i]栋房子前，分值是B[i]，以及它在T[i]秒内（含）存在，之后消失。Branimirko可以选择移动至相邻的房子，耗时1秒。抓住精灵不需要时间，精灵被抓住后消失。时间从第1秒开始。Branimirko能最多获得多少分值和。
Input
输入的第1行为三个正整数n，k，m。
接下来m行描述精灵的信息，分别为A[i]，B[i]，T[i]。
Output
输出Branimirko能最多获得多少分值和。
Sample Input
10 5 4
1 30 4
3 5 7
7 10 12
9 100 23
Sample Output
115
Data Constraint
20%的数据：m≤10
40%的数据：m≤20
k≤n≤1000,m≤100,A[i] ≤N,B[i] ≤100,T[i] ≤2000，所有数为正整数。
Hint
很遗憾，它恰好不能抓住在一号房子前的精灵。
如果T[1]改成5，答案就是145

观察题目，我们发现，题目的意思是，有n个排成一排的房子，告诉你你初始所在房子的编号k，要求你抓小精灵，每次可以向比自己所在房子编号小1或者大1的房子移动，消耗1s，抓小精灵不用时间。换句话说，我们只需要分析要往左移动还是往右移动即可，无需探讨是否要抓这个小精灵。
由于在同一个房子面前可能有存活时间不同、分值不同的小精灵，所以到达一个房子后，要钻研这个房子能拿多少分。
观察题目，我们会发现，我们的抓捕方案，要么是从一个方向开始不断前进，要么是走了一个方向，突然调头…
那么，我们究竟要不要调头，什么时候调头，所以，其实这道题也未必不能尝试dfs，不过这里不多探讨。
我们可以知道，为了最大利益化，我们不可能向左走，一个小精灵都抓不到就调头，这样跟没走其实毫无区别，所以，我们可以保证，我们每次调头后，都会向一个方向进行超过上一次运动距离的运动，并且一定会抓到小精灵。
那么，我们发现，如果我们使用f[i][j]记录下当前所在位置i，时间j，并不合适。因为我们无法确定这样一个状态究竟有没有调过头，回头过几次。
所以，我们需要一个能够明确告诉我们我们曾经活动范围的状态f[i][l][r][t]，记录的是当前位置i，向左最大距离为l，向右最大距离为r，所用时间为t的一个状态。
但是，因为我们知道，我们每次调头都必须要抓小精灵， 所以，我们没有必要不断的重复我们走过的区间，所以，我们可以用一个更简洁明了、稍稍有点生涩的状态 f[i][j][t]表示，当前位置为i，距离当前最远走过的位置为j，所花时间为t的状态。
而这个状态，同样能够告诉我们哪些小精灵已经 被抓/消失，所以，我们就能够确定状态转移方程了。
当然，这个状态转移方程并不好写，但是，我们可以很容易理解，一个状态f[i][j][t]只能由两个状态转移过来，首先是f[k][j][t] （k为i向初始点方向相邻的一个房子）。当然，我们要明确的是，我们可以提前预处理出哪些房子有小精灵，然后提前删掉没有小精灵的房子。
其次是f[j][k][t]，这里的k可以是位置i向初始点方向的第一个点，这样保证转移的过程中，一次只抓一个房子里的小精灵，处理起来更安全，更方便。
所以，我们就存在一个状态转移方程（当前位置为i，当前位置向初始点方向的相邻点k，区间另一边端点j）f[i][j][t]=max(f[k][j][t],f[j][k][t])，当然，它们各自的时间t要根据具体情况分析。
那么，我们就可以做出这道题了。
代码如下，代码中因为时间比较时运用的是大于，而不包括等于，所以将开始时间作为0。

#include <cstdio>
#include <iostream>
#include <algorithm>

using namespace std;

int n,k,m;
int f[110][110][2010];
int a[1010],b[1010],t[1010];
int point[110];
int timax;
int h[1010];
struct node{
    int next,to;
}v[110];
int tot,num,times,ans;
int mid;

void add(int ,int );
int dis(int ,int );
int getpoint(int ,int );

int main()
{
    scanf("%d%d%d",&n,&k,&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&a[i],&b[i],&t[i]);
        timax=max(timax,t[i]);
        add(a[i],i);
    }
    for (int i=1;i<=n;i++)
        if (h[i]||i==k)
        {
            point[++num]=i;
            if (i==k)
                mid=num;
        }
    f[mid][mid][0]=getpoint(0,mid);
    for (times=1;times<=timax;times++)
        for (int x=1;x<=num;x++)
            if (dis(x,mid)<=times)
            {
                if (x<mid)
                    for (int y=mid;y<=num&&(dis(x,y)+dis(y,mid)<=times);y++)
                    {
                        f[x][y][times]=max(f[x+1][y][times-dis(x,x+1)],f[y][x+1][times-dis(x,y)])+getpoint(times,x);
                        if (f[x][y][times]>ans)
                            ans=f[x][y][times];
                    }
                else
                    if (x>mid)
                        for (int y=mid;y&&(dis(x,y)+dis(y,mid)<=times);y--)
                        {
                            f[x][y][times]=max(f[x-1][y][times-dis(x,x-1)],f[y][x-1][times-dis(x,y)])+getpoint(times,x);
                            if (f[x][y][times]>ans)
                                ans=f[x][y][times];
                        }
            }
    printf("%d",ans);
    return 0;
}

void add(int f,int i)
{
    v[++tot].next=h[f];
    v[tot].to=i;
    h[f]=tot;
    return ;
}

int dis(int pl,int pl2)
{
    return abs(point[pl]-point[pl2]);
}

int getpoint(int ti,int pl)
{
    int an=0;
    for (int jump=h[point[pl]];jump;jump=v[jump].next)
    {
        if (t[v[jump].to]>ti)
            an+=b[v[jump].to];
    }
    return an;
}