J - Wormholes

Time Limit:3000MS     Memory Limit:0KB     64bit IO Format:%lld
& %llu

Description

In the year 2163, wormholes were discovered. A wormhole is a subspace tunnel through space and time connecting two star systems. Wormholes have a few peculiar properties:

  • Wormholes are one-way only.
  • The time it takes to travel through a wormhole is negligible.
  • A wormhole has two end points, each situated in a star system.
  • A star system may have more than one wormhole end point within its boundaries.
  • For some unknown reason, starting from our solar system, it is always possible to end up in any star system by following a sequence of wormholes (maybe Earth is the centre of the universe).
  • Between any pair of star systems, there is at most one wormhole in either direction.
  • There are no wormholes with both end points in the same star system.

All wormholes have a constant time difference between their end points. For example, a specific wormhole may cause the person travelling through it to end up 15 years in the future. Another wormhole may cause
the person to end up 42 years in the past.

A brilliant physicist, living on earth, wants to use wormholes to study the Big Bang. Since warp drive has not been invented yet, it is not possible for her to travel from one star system to another one directly. This can be done using wormholes, of
course.

The scientist wants to reach a cycle of wormholes somewhere in the universe that causes her to end up in the past. By travelling along this cycle a lot of times, the scientist is able to go back as far in time as necessary to reach the beginning of the universe
and see the Big Bang with her own eyes. Write a program to find out whether such a cycle exists.

Input

The input file starts with a line containing the number of cases c to be analysed. Each case starts with a line with two numbers n and m . These indicate the number of star systems ( )
and the number of wormholes ( ) . The star systems are numbered from 0 (our solar system) through n-1
. For each wormhole a line containing three integer numbers xy and t is given. These numbers indicate that this wormhole allows someone to travel from the star system numbered x to the star system numbered y,
thereby ending up t ( ) years in the future.

cid=84319" style="color:blue; text-decoration:none">Output

The output consists of c lines, one line for each case, containing the word possible if it is indeed possible to go back in time indefinitely, or not possible if this is not possible with the given set of star systems and wormholes.

cid=84319" style="color:blue; text-decoration:none">Sample Input

2
3 3
0 1 1000
1 2 15
2 1 -42
4 4
0 1 10
1 2 20
2 3 30
3 0 -60

Sample Output

possible
not possible

Miguel A. Revilla

1998-03-10

题意:问能否通过虫洞,回到过去,意思实际上就是求,最短路里面有不有负环。

思路:SPFA 或者Bellman-ford 推断下有不有负环就能够了,对于SPFA,假设有负环,表明进栈次数大于等于n次。

#include <iostream>
#include <stdio.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#define INF 9999999
using namespace std; int n,m;
int num[2222];
int dis[2222];
int vis[2222];
int f[2222];
int u[2222],v[2222],w[2222],next[2222]; int spfa()
{
queue<int>q;
memset(vis,0,sizeof vis);
memset(num,0,sizeof num); for(int i=0;i<=n;i++) dis[i]=INF;
dis[0]=0;
q.push(0);
num[0]++; while(!q.empty())
{
int x=q.front(); q.pop();
vis[x]=0;
for(int i=f[x];i!=-1;i=next[i])
if(dis[x]+w[i]<dis[v[i]])
{
dis[v[i]]=dis[x]+w[i];
if(vis[v[i]]==0)
{
vis[v[i]]=1;
q.push(v[i]);
num[v[i]]++;
if(num[v[i]]>=n)
return 1;
}
}
} return 0;
} int main()
{
int T;
scanf("%d",&T); while(T--)
{
scanf("%d%d",&n,&m);
memset(f,-1,sizeof f); for(int i=0;i<m;i++)
{
scanf("%d%d%d",&u[i],&v[i],&w[i]);
next[i]=f[u[i]];f[u[i]]=i;
} if(spfa()==0)
puts("not possible");
else
puts("possible"); }
return 0;
} /*
5 4
1 2 1
1 3 2
2 4 3
2 5 2
*/

uva558 Wormholes SPFA 求是否存在负环的更多相关文章

  1. POJ 1151 Wormholes spfa+反向建边+负环判断+链式前向星

    Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 49962   Accepted: 18421 Descr ...

  2. POJ3259 Wormholes —— spfa求负环

    题目链接:http://poj.org/problem?id=3259 Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submis ...

  3. vijos1053 用spfa判断是否存在负环

    MARK 用spfa判断是否存在负环 判断是否存在负环的方法有很多, 其中用spfa判断的方法是:如果存在一个点入栈两次,那么就存在负环. 细节想想确实是这样,按理来说是不存在入栈两次的如果边权值为正 ...

  4. poj 3259 Wormholes 【SPFA&amp;&amp;推断负环】

    Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 36852   Accepted: 13502 Descr ...

  5. spfa算法及判负环详解

    spfa     (Shortest Path Faster Algorithm) 是一种单源最短路径的算法,基于Bellman-Ford算法上由队列优化实现. 什么是Bellman_Ford,百度内 ...

  6. SPFA算法的判负环问题(BFS与DFS实现)

    经过笔者的多次实践(失败),在此温馨提示:用SPFA判负环时一定要特别小心! 首先SPFA有BFS和DFS两种实现方式,两者的判负环方式也是不同的.       BFS是用一个num数组,num[x] ...

  7. poj3259 Wormholes【Bellman-Ford或 SPFA判断是否有负环 】

    题目链接:poj3259 Wormholes 题意:虫洞问题,有n个点,m条边为双向,还有w个虫洞(虫洞为单向,并且通过时间为倒流,即为负数),问你从任意某点走,能否穿越到之前. 贴个SPFA代码: ...

  8. (简单) POJ 3259 Wormholes,SPFA判断负环。

    Description While exploring his many farms, Farmer John has discovered a number of amazing wormholes ...

  9. POJ3259:Wormholes(spfa判负环)

    Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 68097   Accepted: 25374 题目链接: ...

随机推荐

  1. Comparator.comparing比较排序

    使用外部比较器Comparator进行排序 当我们需要对集合的元素进行排序的时候,可以使用java.util.Comparator 创建一个比较器来进行排序.Comparator接口同样也是一个函数式 ...

  2. uva11491 Erasing and Winning

    边读入边处理 优化了速度一开始有想错了的地方.处理输入有点想用stringstream, 的问题在于他把字符串连续的数字作为一个整体,遇到空格才分开,所以不适用 #include<cstdio& ...

  3. docker 创建容器与管理容器

    创建容器的选项 [root@mast ~]# docker container run --help Usage: docker container run [OPTIONS] IMAGE [COMM ...

  4. 对faster rcnn代码讲解的很好的一个

    http://www.cnblogs.com/houkai/p/6824455.html http://blog.csdn.net/u014696921/article/details/6032142 ...

  5. java 定时任务-servlet

    在web.xml中配置监听类. <listener> <listener-class>com.skin.generate.action.TaskManager</list ...

  6. ajax 实现订单商品数量的增减及订单的删除进行异步更新界面

    [转载]https://blog.csdn.net/luliuying_01/article/details/78177617?locationNum=8&fps=1 由于在做答辩项目,做到购 ...

  7. 测试linux服务器带宽

    测试准备 1. 计划考量参数 TCP上传数据带宽 TCP下载数据带宽 UDP上传带宽 UDP下载带宽 多并发支持 稳定性 Tcp通讯网络延迟(小包:32.中包1k.大包1M) UDP通讯网络延迟(小包 ...

  8. 用AOP来让你的JS代码变得更有可维护性吧

    此文已由作者吴佳祥授权网易云社区发布. 欢迎访问网易云社区,了解更多网易技术产品运营经验. 好吧我承认这是篇任务. 最近看到个消息,ES2017已经定稿了,心想,我去,还完全没了解ES2016呢,ES ...

  9. 图的最小生成树——Kruskal算法

    Kruskal算法 图的最小生成树的算法之一,运用并查集思想来求出最小生成树. 基本思路就是把所有边从小到大排序,依次遍历这些边.如果这条边所连接的两个点在一个连通块里,遍历下一条边,如果不在,就把这 ...

  10. 谁才是最强战舰!-From 南京理工大学第八届程序设计大赛(校外镜像),博弈~~

    谁才是最强战舰! Time Limit: 1000MS Memory Limit: 65536KB Description 依阿华来到镇守府的第一件事情,就是找大和solo!然而这并不是什么好消息,说 ...