Wormholes

Wormholes

Time Limit : 4000/2000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)

Total Submission(s) : 75   Accepted Submission(s) : 25

Problem Description

While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar because it is a one-way path that delivers you to its destination at a time that is BEFORE you entered the wormhole! Each of FJ's farms comprises N (1 ≤ N ≤ 500) fields conveniently numbered 1..N, M (1 ≤ M ≤ 2500) paths, and W (1 ≤ W ≤ 200) wormholes.

As FJ is an avid time-traveling fan, he wants to do the following: start at some field, travel through some paths and wormholes, and return to the starting field a time before his initial departure. Perhaps he will be able to meet himself :) .

To help FJ find out whether this is possible or not, he will supply you with complete maps to F (1 ≤ F ≤ 5) of his farms. No paths will take longer than 10,000 seconds to travel and no wormhole can bring FJ back in time by more than 10,000 seconds.

 

Input

Line 1: A single integer, <i>F</i>. <i>F</i> farm descriptions follow. <br>Line 1 of each farm: Three space-separated integers respectively: <i>N</i>, <i>M</i>, and <i>W</i> <br>Lines 2..<i>M</i>+1 of each farm: Three space-separated numbers (<i>S</i>, <i>E</i>, <i>T</i>) that describe, respectively: a bidirectional path between <i>S</i> and <i>E</i> that requires <i>T</i> seconds to traverse. Two fields might be connected by more than one path. <br>Lines <i>M</i>+2..<i>M</i>+<i>W</i>+1 of each farm: Three space-separated numbers (<i>S</i>, <i>E</i>, <i>T</i>) that describe, respectively: A one way path from <i>S</i> to <i>E</i> that also moves the traveler back <i>T</i> seconds.

 

Output

Lines 1..<i>F</i>: For each farm, output "YES" if FJ can achieve his goal, otherwise output "NO" (do not include the quotes).

 

Sample Input

  
  

   
   2
3 3 1
1 2 2
1 3 4
2 3 1
3 1 3
3 2 1
1 2 3
2 3 4
3 1 8
  
  

 

Sample Output

  
  

   
   NO
YES
  
  

 

      题意是有n个地，m条路，w个黑洞。m条路是双向，耗时为t；w个黑洞也连接两块地但是单向，而且可以时光逆转t；问有没有可能通过穿梭之后遇见自己。很有情怀的一个题啊。这个简直就是让你默写一遍Ford算法，判断负环。但是由于我的个人水平问题，我依次用了Floyed、Ford、SPFA，为了熟练嘛，也为了对比找差别。结果Floyed不对，另外两个都对了。

代码如下：

//Ford      AC

#include<cstring>
#include<iostream>
using namespace std;
struct Edge
{
    int s,e,t;
};
Edge edge[20000];
int dis[510];
int k,n;
int ioan()
{
    memset(dis,0x7f,sizeof(dis));
    dis[1]=0;
    int s,e,t;
    for(int i=1;i<=n-1;i++)
    {
        int f=0;
        for(int j=1;j<=k;j++)
        {
            s=edge[j].s;
            e=edge[j].e;
            t=edge[j].t;
            if(dis[e]>(dis[s]+t))
            {
                dis[e]=dis[s]+t;
                f=1;
            }
        }
        if(f==0)
            break;
    }
    for(int j=1;j<=k;j++)
    {
        s=edge[j].s;
        e=edge[j].e;
        t=edge[j].t;
        if(dis[e]>(dis[s]+t))
        {
            return 1;
        }
    }
    return 0;
}

int main()
{
    int t,m,w;
    cin>>t;
    while(t--)
    {
        cin>>n>>m>>w;
        k=0;
        memset(edge,0,sizeof(edge));
        int s,e,t;
        for(int i=1;i<=m;i++)
        {
            cin>>s>>e>>t;
            k++;
            edge[k].s=s;
            edge[k].e=e;
            edge[k].t=t;
            k++;
            edge[k].s=e;
            edge[k].e=s;
            edge[k].t=t;
        }
        for(int i=1;i<=w;i++)
        {
            cin>>s>>e>>t;
            k++;
            edge[k].s=s;
            edge[k].e=e;
            edge[k].t=-t;
        }
        //cout<<"k=  "<<k<<endl;
        int f=ioan();
        if(f==1)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}

//SPFA     AC

#include<iostream>
#include<cstring>
using namespace std;
struct Edge
{
    int s,e,t;
};
Edge edge[20000];
int dis[510];
int vis[510];
int k,n;
int ioan()
{
    memset(dis,0x7f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dis[1]=0;
    vis[1]=1;;
    int q[500000]={0};
    int head=0;
    int tail=1;
    q[1]=1;
    do
    {
        head++;
        int a=q[head];
        vis[a]=0;
        for(int j=1;j<=k;j++)
        {
            if(edge[j].s==a)
            {
                int s=edge[j].s;
                int e=edge[j].e;
                int t=edge[j].t;
                if(dis[e]>(dis[s]+t))
                {
                    dis[e]=dis[s]+t;
                    if(vis[e]==0)
                    {
                        vis[e]=1;
                        tail++;
                        q[tail]=e;
                    }
                }
                if(dis[1]<0)
                {
                    return 1;
                }
            }
        }
    }while(head<tail);
    return 0;

}

int main()
{
    int t,m,w;
    cin>>t;
    while(t--)
    {
        cin>>n>>m>>w;
        k=0;
        memset(edge,0,sizeof(edge));
        int s,e,t;
        for(int i=1;i<=m;i++)
        {
            cin>>s>>e>>t;
            k++;
            edge[k].s=s;
            edge[k].e=e;
            edge[k].t=t;
            k++;
            edge[k].s=e;
            edge[k].e=s;
            edge[k].t=t;
        }
        for(int i=1;i<=w;i++)
        {
            cin>>s>>e>>t;
            k++;
            edge[k].s=s;
            edge[k].e=e;
            edge[k].t=-t;
        }
        //cout<<"k=  "<<k<<endl;
        int f=ioan();
        if(f==1)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}

//Floyed   未AC

#include<cstring>
#include<iostream>
using namespace std;
struct wormholes
{
    int x,y,t;
};
int main()
{
    int t,n,m,w;
    int p[510][510];
    wormholes worm[5100];
    cin>>t;
    while(t--)
    {
        cin>>n>>m>>w;
        memset(p,0,sizeof(p));
        //for(int i=1;i<=n;i++)
            //p[i][i]=0;
        int x,y,t;
        for(int i=1;i<=m;i++)
        {
            cin>>x>>y>>t;
            p[x][y]=t;
            p[y][x]=t;
        }
        for(int i=1;i<=w;i++)
        {
            cin>>x>>y>>t;
            worm[i].x=x;
            worm[i].y=y;
            worm[i].t=t;
        }
        for(int k=1;k<=n;k++)
        {
            for(int i=1;i<=n;i++)
            {
                for(int j=1;j<=n;j++)
                {
                    if(p[i][j]>p[i][k]+p[k][j])
                        p[i][j]=p[i][k]+p[k][j];
                }
            }
        }
        int flag=0;
        for(int i=1;i<=w;i++)
        {
            x=worm[i].x;
            y=worm[i].y;
            t=worm[i].t;
            if(p[x][y]<t)
            {
                flag=1;
                break;
            }
        }
        if(flag==0)
        {
            cout<<"NO"<<endl;
        }
        else
        {
            cout<<"YES"<<endl;
        }
    }

    return 0;
}