洛谷 P2850 [USACO06DEC]虫洞Wormholes 判负环

虫洞（wormhole）

FJ 在农场上闲逛时，发现他的农场里有很多虫洞。虫洞是一条特殊的有向路径，当

FJ 从它的一头走到另一头后，他将被传送到过去的某个时刻。FJ 的每个农场包括

N(1<=N<=500)块按1..N 编号的草地、M(1<=M<=2500)条草地间的道路以及W(1<=W<=200)

个虫洞。

FJ 一直以来就渴望进行时间旅行，于是他开始做如下的打算：从某块草地出发，穿

过一些道路以及一些虫洞，最终回到他出发的草地。这样，他说不定能碰见过去的自

己:) 。

请你帮FJ 算一下，他是否可能找到这样的一条路。当然，FJ 会给你他的所有

F(1<=F<=5)个农场的完整的地图。没有哪条道路上需要花的时间超过10,000 秒，同时，

也没有哪个虫洞能把FJ 带回10,000 秒以前。

程序名: wormhole

输入格式:

• 第1 行: 一个正整数F，即农场总数。以下依次描述各个农场的地图

• 每个农场描述的第1 行：三个用空格隔开的整数，N、M 和W

• 每个农场描述的第2..M+1 行：每行包含三个用空格隔开的整数S、E、T，表示

编号为S 的草地和编号为E 的草地边有一条双向道路，通过它所花费的时间为T 秒。两

块草地间可能有多条道路

• 每个农场描述的第M+2..M+W+1 行：每行包含三个用空格隔开的整数S、E、T，

描述了一个起点编号为S、终点编号为E 的虫洞。穿过这个虫洞后，FJ 可以回到T 秒之

前 输入样例(wormhole.in):

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

输入说明:

FJ 交给你两个农场的地图。第一个农场里有三条道路以及一个虫洞，第二个农场里

有两条道路和一个虫洞。

输出格式:

• 第1..F 行: 对于每个农场，如果FJ 可以实现他回到过去的愿望，输出"YES"，

否则输出"NO"（不含引号）。

输出样例(wormhole.out):

NO
YES

输出说明:

在农场1 中，FJ 无法完成他期望的时间旅行。

在农场2 中，FJ 可以沿路线1->2->3->1 旅行，这样他能在离开1 号草地前一秒回

到1 号草地。当然，从这条路线上的其他草地出发，也能达到目的。

这道题简单来说就是判断图内是否存在负环；

判断负环方法：拓扑排序或spfa

spfa判断负环：如果任意一条边被修改大于n次，就代表这个图内一定存在至少一个负环。

 #include<bits/stdc++.h>
 using namespace std;
 #define man 1000010
 #define ll int
 struct edge
 {
     int next,dis,to;
     }e[man<<];
 ll head[man<<],num=,cnt[man<<];
 bool vis[man];
 ll dis[man<<],t,n,m,w;
 inline void add(ll from,ll to,ll dis)
 {
     e[++num].next=head[from];
     e[num].to=to;
     e[num].dis=dis;
     head[from]=num;
     }
 inline void clear()
 {
     memset(head,,sizeof(head));
     memset(e,,sizeof(e));
     memset(cnt,,sizeof(cnt));
     num=;
     }
 inline bool spfa(ll s)
 {
     memset(vis,,sizeof(vis));
     memset(dis,0x7f,sizeof(dis));
     queue<int >q;
     q.push(s);dis[s]=;vis[s]=;
     do
     {
         int u=q.front();q.pop();
         vis[u]=;
         for(int i=head[u];i;i=e[i].next)
         {
             ll to=e[i].to;
             if(dis[to]>dis[u]+e[i].dis)
             {    dis[to]=dis[u]+e[i].dis;
                 if(!vis[to])
                 {
                     q.push(to);
                     vis[to]=;
                     cnt[to]++;
                     }
                 if(cnt[to]>n) return ;
                 }
             }
         }while(q.size());
     return ;
     }
 int main()
 {
     ios::sync_with_stdio(false);
     cin>>t;
     while(t--)
     {
         clear();
         cin>>n>>m>>w;
         for(int i=,x,y,z;i<=m;i++)
         {    cin>>x>>y>>z;
             add(x,y,z);add(y,x,z);
             }
         for(int i=,x,y,z;i<=w;i++)
         {    cin>>x>>y>>z;
             add(x,y,-z);
             }
         if(spfa()==) cout<<"YES"<<endl;
         else cout<<"NO"<<endl;
         }
     return ;
     }

拓扑排序：

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 int t,n,m,w,x,y,z,num=,dis[];
 bool flag;
 struct star{
     int from,to,dis;
 }e[];
 void add(int from, int to, int dis){
     e[++num].from=from;
     e[num].to=to;
     e[num].dis=dis;
 }
 bool topsort(){
     memset(dis,0x7f,sizeof(dis));
     dis[]=;
     for(int i=;i<=n;i++){
         flag=;
         for(int j=;j<=num;j++)
             if(dis[e[j].to]>dis[e[j].from]+e[j].dis){
                 flag=;
                 dis[e[j].to]=dis[e[j].from]+e[j].dis;
             }
         if(!flag)return ;
     }
     return ;
 }
 int main(){
     scanf("%d",&t);
     for(int i=;i<=t;i++){
         num=;
         scanf("%d%d%d",&n,&m,&w);
         for(int j=;j<=m;j++){
             scanf("%d%d%d",&x,&y,&z);
             add(x,y,z);add(y,x,z);
         }
         for(int j=;j<=w;j++){
             scanf("%d%d%d",&x,&y,&z);
             add(x,y,-z);
         }
         if(topsort())printf("YES\n");
         else printf("NO\n");
     }
     return ;
 }