hdu 4784 Dinner Coming Soon | dp

发现自己好久没写过解题报告了= =， 变懒了？！

——————————————————————————————————————

挂的比赛中没做出来。还以为会稳稳过的。。

吾以为这题就是开好状态然后跑个SPFA，没想到调了很久，调出来还TLE了。

赛后看了下别人的题解。自己的代码改来改去，WA+TLE不下10发，Orz。推倒重写，直接过了。。。

看来以后写代码还是分类分清楚的好，为了简洁很有可能会发生一些意料不到的问题。。

DAG ——> dp（状态放得下）/ 网络流（dp状态放不下）

题意：

一个人从1 到 N，必须要在T单位时间内到达N点。通过每条边需要一定的时间t和金钱m，一开始此人有R元。在这过程中这个人想进行商品买卖，背包大小B，使得到达N时所得的金钱最多。在一个点中，可以进行3种操作（买一个商品，卖一个商品，什么都不做）。这个世界存在平行世界，每次可以转移到同一个位置，平行世界（i+1）%k，耗时1个单位时间。

注意：

1.金钱不能为负；

2.不能在1和N两点进行商品买卖；

3.除了平行世界0，其它的世界不能进入1和N两点；

3.到达N点表示journey已经结束，不能对其它点更新。

思路：

开状态dp[n][k][b][t]：处于n点，在平行世界为k，身上有b个商品，时间花费为t 的情况下，所得的最大金钱数。

转移1：3种操作*转移到其它的点。

转移2：3种操作*转移到其它世界。

以下个人理解思路过程↓

————————————————————————————————————————————————————

咋看之下，SPFA好像能搞。SPFA理论上是能过的，不过状态数太凶残。队列进进出出就要TLE了。（才发现SPFA其实是很暴力的算法）

后来用优先队列优化，但用上优先队列就不是SPFA，而更像Dijkstra了。

但Dijkstra求最短路所定义的优先队列，一个状态是可以多次进入队列，并且一个状态只能对周边状态更新一次。其它同节点但无法用于更新的弹出队列即可。

而像这题每个状态只能进入一次队列，此后即使该状态再被更新也不会进入队列。

后来问了杰神和铭神，这题本质是个DP，优先队列（根据状态时间排序）最多是用来优化的工具。

因为这题时间t无论如何都是增加的，我取出时间t最小的状态，其它状态不可能对此状态进行更新。这里就有一点Dijstran最短路的影子了。

对于本题，时间不同就不是同一个状态！

对比平时的Dijstra求最短路，优先队列里存放的是<节点，dis>，优先队列根据dis进行排序，而dis并不作为状态的一部分。因此同一个节点，但更新后的dis不一样。那么就有必要放入队列中去。

而本题的优先队列存放的是<节点，平行世界，商品个数，t>。优先队列根据t进行排序，并且t作为所开状态的一部分，即使再更新到时候，也没必要再放进去。因为这两个状态是完全一样的！

————————————————————————————————————————————

AC代码：（写的不是递推的dp，递推的速度更快些）

/* **********************************************
Author    : vitasoy
Question    : tmp.cpp
Created Time: 2014-10-3 14:53:48
*********************************************** */
#include <iostream>
#include <fstream>
#include <cstring>
#include <climits>
#include <deque>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <string>
#include <vector>
#include <cstdio>
#include <bitset>
#include <functional>
#include <algorithm>
using namespace std;
typedef long long LL;
const int MAXN = 105;
const int MAXEDGE = 205;
const int MAXB = 8;
const int MAXK = 8;
const int MAXT = 205;
int dp[MAXN][MAXK][MAXB][MAXT];
bool inq[MAXN][MAXK][MAXB][MAXT];
int head[MAXN], pp;
int n, m, b, k, r, t;
int p[MAXK][MAXN];
struct Edge
{
        int v, t, m, next;
}edge[MAXEDGE];
void addEdge(int u, int v, int t, int m)
{
        edge[pp] = (Edge){v, t, m, head[u]};
        head[u] = pp++;
}
void init()
{
        memset(dp, -1, sizeof(dp));
        memset(head, -1, sizeof(head));
        memset(inq, false, sizeof(inq));
        pp = 0;
}
struct PP
{
        int n, k, b, t;
        bool operator < (const PP &a) const
        {
                return t > a.t;
        }
};
int sta[3] = {0, -1, 1};
void solve()
{
        priority_queue <PP> q;
        q.push((PP){1, 0, 0, 0});
        dp[1][0][0][0] = r;
        PP e, tmp;
        while(!q.empty())
        {
                e = q.top(), q.pop();
                int &ddp = dp[e.n][e.k][e.b][e.t];
                if(e.n == n || e.t > t || ddp < 0) continue;
                //to others house
                int next = head[e.n];
                int money = 0;
                while(next != -1)
                {
                        Edge &h = edge[next];
                        tmp.n = h.v, tmp.k = e.k, tmp.t = e.t+h.t;
                        for(int i = 0;i < 3; i++)
                        {
                                if(e.n == 1)
                                {
                                        money = -h.m;
                                        tmp.b = e.b;
                                }
                                else 
                                {
                                        money = (-sta[i]) * p[e.k][e.n] - h.m;
                                        tmp.b = e.b + sta[i];
                                }
                                if(tmp.b < 0 || tmp. b > b) continue;
                                int &tdp = dp[tmp.n][tmp.k][tmp.b][tmp.t];
                                if(money + ddp > tdp)
                                {
                                        tdp = money + ddp;
                                        if(!inq[tmp.n][tmp.k][tmp.b][tmp.t])
                                        {
                                                inq[tmp.n][tmp.k][tmp.b][tmp.t] = true;
                                                q.push(tmp);
                                        }
                                }
                        }
                        next = h.next;
                }
                //to other univeses
                if(e.n == 1)
                        continue;
                for(int i = 0;i < 3; i++)
                {
                        tmp.n = e.n, tmp.k = (e.k+1)%k, tmp.t = e.t+1;
                        money = (-sta[i])*p[e.k][e.n];
                        tmp.b = e.b+sta[i];
                        if(tmp.b < 0 || tmp.b > b) continue;
                        int &tdp = dp[tmp.n][tmp.k][tmp.b][tmp.t];
                        if(money + ddp > tdp)
                        {
                                tdp = money + ddp;
                                if(!inq[tmp.n][tmp.k][tmp.b][tmp.t])
                                {
                                        inq[tmp.n][tmp.k][tmp.b][tmp.t] = true;
                                        q.push(tmp);
                                }
                        }
                }
        }
}              
                        
                        
int main()
{
        int T, cas = 0;
        scanf("%d", &T);
        while(T--)
        {
                init();
                scanf("%d%d%d%d%d%d", &n, &m, &b, &k, &r, &t);
                for(int i = 0;i < k; i++)
                        for(int j = 1;j <= n; j++)
                                scanf("%d", &p[i][j]);
                //
                int tt, mm, u, v;
                for(int i = 0;i < m; i++)
                {
                        scanf("%d%d%d%d" ,&u, &v, &tt, &mm);
                        addEdge(u, v, tt, mm);
                }
                solve();
                int res = -1;
                for(int i = 0;i <= t; i++)
                {
                        res = max(res, dp[n][0][0][i]);
                }
                if(res == -1)
                        printf("Case #%d: Forever Alone\n", ++cas);
                else
                        printf("Case #%d: %d\n", ++cas, res);
        }
        return 0;
}