2013成都站D題||hdu4784 bfs+DP+priority_queue（思路從spfa得到啟示）

http://acm.hdu.edu.cn/showproblem.php?pid=4784

題意：

        有n個點，m條有向邊，有一個人要在T時間內從1走到n，並在途中進行交易，獲得儘量多的錢。這個人能帶B包鹽，除了1和n，每個點都有不同的鹽價，所以可以根據差價賺錢。每條邊有相應的時間和花費，到達一個點時有三個選擇：買一包鹽、賣一包鹽、什麼也不做，進行交易不需要時間。另外，還有K個平行世界（編號從0~K-1），每個是平行世界相應的鹽價不同，但是相應道路的花費相同，這個人每次可以從第i個平行世界跳轉到第(i+1)%K的平行世界(跳轉前後位置相同)，這個過程需要花費1分鐘，但是他不能在1和n跳轉，也就是說在1和n時必須是在第0個平行世界。當他到n的時候立即停止旅行，最後問能獲得的最多的錢。 

思路：和spfa求最短路的思路很像

         用一個四維的陣列記錄在第i個城市，第t秒，在第k維空間中，有b包鹽時的最大價值。可以看出，每次行動時間都是增加的,接下來可以考慮用bfs的思想，把每個節點按時間去處理，先處理時間早的，再處理時間晚的，每次行動分為到下一個城市或者進行穿越，這兩個行動都可以選擇是否在當地進行交易，然後去更新新的狀態的值，然後插入佇列。由於要按時間的順序進行搜尋，所以這裡我用了優先佇列去搞，時間小的先出隊。需要注意的是，到達n點後是不能再進行擴充套件的，因此到這裡要跳過

幾個值得注意的點：1.到達n後不能進行擴充套件

                               2.在1和n點不能進行買和賣

                               3.n必須是第0宇宙內的n才是目的地

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;

int N,M,B,K,R,T;
int head[205],ip;
struct note
{
    int v,t,m,next;
} edge[205];
void init()
{
    memset(head,-1,sizeof(head));
    ip=0;
}
void addedge(int u,int v,int t,int m)
{
    edge[ip].v=v;
    edge[ip].t=t;
    edge[ip].m=m;
    edge[ip].next=head[u];
    head[u]=ip++;
}
int p[205][205],dp[205][205][8][8],flag[202][205][8][8];

struct node
{
    int u,tm,b,k;
    node() {}
    node(int _u,int _tm,int _k,int _b)
    {
        u=_u;
        tm=_tm;
        k=_k;
        b=_b;
    }
    bool operator < (const node &a) const
    {
        return tm>a.tm;
    }
};
int bfs()
{
    int fla=0;
    memset(dp,0,sizeof(dp));
    memset(flag,0,sizeof(flag));
    dp[1][0][0][0]=R;
    flag[1][0][0][0]=true;
    priority_queue<node>q;
    q.push(node(1,0,0,0));
    while(!q.empty())
    {
        node point=q.top();
        q.pop();
        int u=point.u;
        int k=point.k;
        int b=point.b;
        int tm=point.tm;
      //  printf("(%d %d %d %d)\n",u,k,b,tm);
        if(u==N) continue;
        if(tm>T) break;
     //穿越
        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].v;
            int t=edge[i].t;
            int cost=dp[u][tm][k][b]-edge[i].m;
            if(cost<0||tm+t>T)continue;
            if(v==N&&k!=0) continue;
            if(v==N) fla=1;
            if(u!=1&&u!=N)
            {
              //  printf("**\n");
                //buy
                if(b+1<=B&&(dp[v][tm+t][k][b+1]<cost-p[k][u]))
                {
                    dp[v][tm+t][k][b+1]=cost-p[k][u];
                    if(flag[v][tm+t][k][b+1]==0)
                    {
                        flag[v][tm+t][k][b+1]=1;
                        q.push(node(v,tm+t,k,b+1));
                    }
                }
                //sell
                if(b>0&&dp[v][tm+t][k][b-1]<cost+p[k][u])
                {
                    dp[v][tm+t][k][b-1]=cost+p[k][u];
                    if(flag[v][tm+t][k][b-1]==0)
                    {
                        flag[v][tm+t][k][b-1]=1;
                        q.push(node(v,tm+t,k,b-1));
                    }
                }
            }
            //no sell,no buy
            if(dp[v][tm+t][k][b]<cost)
            {
                dp[v][tm+t][k][b]=cost;
                if(flag[v][tm+t][k][b]==0)
                {
                    flag[v][tm+t][k][b]=1;
                    q.push(node(v,tm+t,k,b));
                }
            }
        }
        //不穿越
        int k1=(k+1)%K;
        int cost=dp[u][tm][k][b];
        if(u!=1&&u!=N)
        {
            if(cost<0)continue;
            if(tm+1>T)continue;
            //buy
            if(b+1<=B&&dp[u][tm+1][k1][b+1]<cost-p[k][u])
            {
                dp[u][tm+1][k1][b+1]=cost-p[k][u];
                if(flag[u][tm+1][k1][b+1]==0)
                {
                    flag[u][tm+1][k1][b+1]=1;
                    q.push(node(u,tm+1,k1,b+1));
                }
            }
            //sell
            if(b>0&&dp[u][tm+1][k1][b-1]<cost+p[k][u])
            {
                dp[u][tm+1][k1][b-1]=cost+p[k][u];
                if(flag[u][tm+1][k1][b-1]==0)
                {
                    flag[u][tm+1][k1][b-1]=1;
                    q.push(node(u,tm+1,k1,b-1));
                }
            }
        }
        //no buy,no sell
        if(dp[u][tm+1][k1][b]<cost)
        {
            dp[u][tm+1][k1][b]=cost;
            if(flag[u][tm+1][k1][b]==0)
            {
                flag[u][tm+1][k1][b]=1;
                q.push(node(u,tm+1,k1,b));
            }
        }
    }
    if(fla==0)
        return -1;
    int ans=0;
    for(int i=0; i<=T; i++)
    {
        for(int j=0; j<=B; j++)
        {
            ans=max(ans,dp[N][i][0][j]);
        }
    }
    return ans;
}
int main()
{
    int case1,tt=0;
    scanf("%d",&case1);
    while(case1--)
    {
        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]);
        }
        init();
        for(int i=0; i<M; i++)
        {
            int a,b,c,d;
            scanf("%d%d%d%d",&a,&b,&c,&d);
            addedge(a,b,c,d);
        }
        printf("Case #%d: ",++tt);
        int ans=bfs();
        if(ans==-1)
            printf("Forever Alone\n");
        else
            printf("%d\n",ans);
    }
    return 0;
}