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..NM (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, FF farm descriptions follow.  Line 1 of each farm: Three space-separated integers respectively: NM, and W  Lines 2.. M+1 of each farm: Three space-separated numbers ( SET) that describe, respectively: a bidirectional path between S and E that requires T seconds to traverse. Two fields might be connected by more than one path.  Lines M+2.. MW+1 of each farm: Three space-separated numbers ( SET) that describe, respectively: A one way path from S to E that also moves the traveler back T seconds.

Output

Lines 1.. F: 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

Hint

For farm 1, FJ cannot travel back in time.  For farm 2, FJ could travel back in time by the cycle 1->2->3->1, arriving back at his starting location 1 second before he leaves. He could start from anywhere on the cycle to accomplish this.
题目意思:对于t组输入输出,有N个点,M条双向通路,K个虫洞。虫洞是一个单向的通路。问能否从某一个点出发,通过一些路径和虫洞,返回到出发点,并且时间还要早于出发时间,这样他就能够遇到他自己了。
解题思路:又是John,想都不用想又是USACO的题,美国果然是农业立国啊。在第二组样例中,John沿着1->2->3->1,从第一个点出发回到第一个点,所需时间为-1,这样他就能够遇到自己了。这该怎么思考?遇到虫洞会回到过去,时间回溯。实际上就是要求判断一个带有负权的有向网中是否存在负权值回路,
我们知道可以使用Bellman-Ford可以判断是否存在负环,因为出现了负值回路后会不断的松弛。这里我们用优化后的SPFA来实现。
原理:如果存在负权值回路,那么从源点到某一个点的最短路径可以无限缩短,某些顶点入队列将会超过N次(N为顶点个数)。
ps:代码有给出了另外一种判断是否有负环的方法,时间会更快。从任意一点出发求最短路,必定会求出到其他所有点的最短路,若其中某个点在一个负权回路中,那么它肯定会不断地走这个回路以使到这个点的花费越小越好,这时候该点到出发点的距离就会为负值,所以只需从一个点开始便能找到是否存在负回路,这里我们就只看从源点到源点的dis就可以了。
 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #include<algorithm>
  5 #define INF 0x3f3f3f3f
  6 #define maxs 10010
  7 using namespace std;
  8 struct node
  9 {
 10     int to;
 11     int w;
 12 } t;
 13 vector<node>Map[maxs];
 14 int dis[maxs];
 15 int vis[maxs];
 16 int n,m,k;
 17 void add(int s,int e,int w)
 18 {
 19     t.to=e;
 20     t.w=w;
 21     Map[s].push_back(t);
 22 }
 23 void init()
 24 {
 25     int i;
 26     memset(dis,INF,sizeof(dis));
 27     memset(vis,0,sizeof(vis));
 28     for(i=0; i<=n; i++)
 29     {
 30         Map[i].clear();
 31     }
 32 }
 33 int SPFA(int s)
 34 {
 35     int cnt[maxs]= {0};///记录每个点入队次数
 36     int i;
 37     dis[s]=0;
 38     vis[s]=1;
 39     queue<int>q;
 40     q.push(s);
 41     cnt[s]++;
 42     while(!q.empty())
 43     {
 44         int u=q.front();
 45         /*if(cnt[u]>=n)
 46         {
 47             return 0;///这里用来判断入队列是否超过N次
 48         }*/
 49         q.pop();
 50         vis[u]=0;
 51         for(i=0; i<Map[u].size(); i++)
 52         {
 53             int to=Map[u][i].to;
 54             if(dis[to]>dis[u]+Map[u][i].w)
 55             {
 56                 dis[to]=dis[u]+Map[u][i].w;///松弛操作
 57                 if(dis[1]<0)///这种判断是否有负环的更快。如果起始点的dis[s]<0说明存在负环
 58                 {
 59                     return 0;
 60                 }
 61                 if(!vis[to])
 62                 {
 63                     vis[to]=1;
 64                     q.push(to);
 65                     cnt[to]++;
 66                 }
 67             }
 68         }
 69     }
 70     return 1;
 71 }
 72 int main()
 73 {
 74     int t,i,j,u,v,w;
 75     scanf("%d",&t);
 76     for(i=1; i<=t; i++)
 77     {
 78         scanf("%d%d%d",&n,&m,&k);
 79         init();
 80         while(m--)
 81         {
 82             scanf("%d%d%d",&u,&v,&w);
 83             add(u,v,w);
 84             add(v,u,w);
 85         }
 86         while(k--)
 87         {
 88             scanf("%d%d%d",&u,&v,&w);
 89             add(u,v,-w);///虫洞时间取负值
 90         }
 91         if(SPFA(1))
 92         {
 93             printf("NO\n");
 94         }
 95         else
 96         {
 97             printf("YES\n");
 98         }
 99     }
100     return 0;
101 }

 


这里再附上使用邻接矩阵和Bellman-Ford算法的代码。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f
struct Edge
{
    int f;///起点
    int t;///终点
    int c;///距离
} edge[6000];
int dist[505];
int n,m,h,cnt;
int bellman_ford()
{
    memset(dist,inf,sizeof(dist));
    dist[1]=0;///起点
    int i,j;
    for(j=1; j<=n; j++)
    {
        for(i=1; i<=cnt; i++)
        {
            if(dist[edge[i].t]>dist[edge[i].f]+edge[i].c)///松弛操作
            {
                dist[edge[i].t]=dist[edge[i].f]+edge[i].c;
            }
        }
    }
    int flag=1;
    for(i=1; i<=cnt; i++)///遍历所有的边
    {
        if(dist[edge[i].t]>dist[edge[i].f]+edge[i].c)
        {
            flag=0;///存在从源点可达的负权回路
            break;
        }
    }
    return flag;
}
int main()
{
    int i,t;
    scanf("%d",&t);
    while(t--)
    {
        cnt=0;
        scanf("%d %d %d",&n,&m,&h);
        int u,v,w;
        for(i=1; i<=m; i++)
        {
            cnt++;
            scanf("%d %d %d",&u,&v,&w);
            edge[cnt].f=u;
            edge[cnt].t=v;
            edge[cnt].c=w;
            cnt++;
            edge[cnt].f=v;
            edge[cnt].t=u;
            edge[cnt].c=w;
        }
        for(i=1; i<=h; i++)
        {
            cnt++;
            scanf("%d %d %d",&u,&v,&w);
            edge[cnt].f=u;
            edge[cnt].t=v;
            edge[cnt].c=-w;
        }
        if(bellman_ford())
            printf("NO\n");
        else
            printf("YES\n");
    }
    return 0;
}

 

 
作者:王陸
 

-------------------------------------------

个性签名:罔谈彼短,靡持己长。做一个谦逊爱学的人!