51nod 1326 奇妙的spfa+dp

http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1326

1326 遥远的旅途

题目来源： TopCoder

基准时间限制：2 秒 空间限制：131072 KB 分值: 320 难度：7级算法题

收藏

关注

一个国家有N个城市，这些城市被标为0,1,2,...N-1。这些城市间连有M条道路，每条道路连接两个不同的城市，且道路都是双向的。一个小鹿喜欢在城市间沿着道路自由的穿梭，初始时小鹿在城市0处，它最终的目的地是城市N-1处。小鹿每在一个城市，它会选择一条道路，并沿着这条路一直走到另一个城市，然后再重复上述过程。每条道路会花费小鹿不同的时间走完，在城市中小鹿不花时间逗留。路程中，小鹿可以经过一条路多次也可以经过一个城市多次。给定城市间道路的信息，问小鹿是否有一种走法，从城市0出发到达城市N-1时，恰好一共花费T个单位的时间。如果存在输出“Possible”，否则输出“Impossible”。

注意，小鹿在整个过程中可以多次经过城市N-1，只要最终小鹿停在城市N-1即可。

 

例如样例中小鹿的行程可以是0->1->2->0->2.

Input

多组测试数据，输入的第一行含一个整数caseT，表示测试数据个数，1<=caseT<=3.
之后有caseT组相同结构的测试数据，每组测试数据构成如下：
第一行三个整数，N，M，T，且2<=N<=50,1<=M<=50，1<=T<=1,000,000,000,000,000,000(即
10^18).
之后M行，每行三个整数Ai,Bi,Di,表示城市Ai与Bi间有一条双向道路，且小鹿穿越这条路要花费Di的时间。其中，0<=Ai,Bi<N,1<=Di<=10000。

Output

每组测试数据一行输出，如果存在题目所述路径输出“Possible”，否则“Impossible”，不含引号。

Input示例

1
3 3 25
0 2 7
0 1 6
1 2 5

Output示例

Possible

 T很大，如果直接bfs暴力的话肯定是不行的。

题解看得也很玄学感觉还是有点不明白这样做的可行性，就是对于T很大的情况肯定要走环才能抵消这么大的路程，

我们不妨以N为结束点，N的入边作为环来延长总路径，假设有一条连接N点的边权值为w，有一条长度为k从1-N的路径，

如果(T-k)%(2*w)==0&&k<=T,我们就可以认定这是有可能的，我一直想要是这个环不在末尾而是处于中间会不会出现很多节点导致T，不过并没有出现，具体的证明我也不会。只能先码上了。

dis[i][j]表示(1->i点的距离%mod)=j的最小距离,mod=2*w,直接跑spfa更新就好了，如果dis[N][T%(2*w)]<=T,说明可能，否则不可能。

下面的转自  http://www.cnblogs.com/y142857/p/6833044.html

用dp表示的话似乎好理解了那么一点，因为边权最大1w，所有的路径长度模完之后最多也就两万种情况。

基本思想：能否在T时刻刚好到达n号点，可选n点的任一入边(q-->n)，记录边长ds，看能否在S时刻到达q，且   (T-S)%(2*ds)==0(S<=T)。

然后可以设dp[x][y] 表示到达x点，并且使dp[i][j]%(2*ds)==j 成立的最小时刻。初始化dp[1][0]=0；然后跑SPFA；DP方程dp[k][ (j+dis[i][k])%(2*ds) ] = min { dp[i][j] + dis[i][k] }。

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
struct Edge{int to,w,next;}e[115];
int cnt,first[55];
long long d[55][20005];
void add(int u,int v,int w)
{
    e[cnt].w=w;
    e[cnt].to=v;
    e[cnt].next=first[u];
    first[u]=cnt++;
}
struct node{int u,w;};

bool vis[55][20005];
long long spfa(int N,int  mod,long long  T)
{
   memset(vis,0,sizeof(vis));
   memset(d,inf,sizeof(d));
   queue<node>Q;
   Q.push(node{1,0});
   vis[1][0]=1;
   d[1][0]=0;
   while(!Q.empty()){
    node t1=Q.front(); Q.pop();
    vis[t1.u][t1.w]=0;
    for(int i=first[t1.u];i+1;i=e[i].next){
        Edge x=e[i];
        if(d[x.to][(t1.w+x.w)%mod]>d[t1.u][t1.w]+x.w){
            d[x.to][(t1.w+x.w)%mod]=d[t1.u][t1.w]+x.w;
            if(!vis[x.to][(t1.w+x.w)%mod]){
                Q.push(node{x.to,(t1.w+x.w)%mod});
                vis[x.to][(t1.w+x.w)%mod]=1;
            }
        }
    }
   }
   return d[N][T%mod];
}
int main()
{
    int C,N,M,i,j,k;
    long long T;
    while(cin>>C){
        while(C--){
            int a,b,c;
            cin>>N>>M>>T;
            cnt=0;
            memset(first,-1,sizeof(first));
        while(M--){
            cin>>a>>b>>c;
            a++;b++;
            add(a,b,c);
            add(b,a,c);
        }
        bool ok=0;
        for(i=0;i<cnt;i+=2)
        {
            if(e[i].to==N||e[i+1].to==N)
            {
              int w=2*e[i].w;
              if(spfa(N,w,T)<=T){ok=1;break;}
            }
        }
        ok?puts("Possible"):puts("Impossible");
    }
    }
    //system("pause");
    return 0;
}