链接:



Wormholes
Time Limit: 2000MS   Memory Limit: 65536K
Total Submissions: 25079   Accepted: 8946

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
comprisesN (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 Ethat requires T seconds to traverse. Two fields might be connected
by more than one path. 

Lines M+2..M+W+1 of each farm: Three space-separated numbers (SET) that describe, respectively: A one way path from S to Ethat 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.

Source

题意:


农夫 FJ 有 N 块田地【编号 1...n】 (1<=N<=500)

        田地间有 M 条路径 【双向】(1<= M <= 2500)

        同时有 W 个孔洞,可以回到以前的一个时间点【单向】(1<= W <=200)

        问:FJ 是否能在田地中遇到以前的自己

算法:bellman_ford 判断是否有负环

思路:


田地间的双向路径加边,权值为

        孔洞间的单向路径加边,权值为【可以回到以前】

        判断有向图是否存在负环

        因为如果存在了负数环,时间就会不停的减少,

        那么 FJ 就可以回到以前更远的地方,肯定能遇到以前的自己的

PS:第一次做这个的童鞋,如果实在无法理解,就按照上面的样例和思路画个图就好了,反正才三个点。
         两年了,居然如此经典的入门题目都没有遇到过,真不知道我干什么去了Orz



code:

3259 Accepted 180K 63MS C++ 1707B

/********************************************************************
Accepted 180 KB 47 ms C++ 2509 B
题意:农夫 FJ 有 N 块田地【编号 1...n】 (1<=N<=500)
田地间有 M 条路径 【双向】(1<= M <= 2500)
同时有 W 个孔洞,可以回到以前的一个时间点【单向】(1<= W <=200)
问:FJ 是否能在田地中遇到以前的自己
算法:bellman_ford 判断是否有负环
思路:田地间的双向路径加边,权值为正
孔洞间的单向路径加边,权值为负【可以回到以前】
判断有向图是否存在负环
因为如果存在了负数环,时间就会不停的减少,
那么 FJ 就可以回到以前更远的地方,肯定能遇到以前的自己的
*******************************************************************/
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std; const int maxn = 510;
const int maxw = 2500*2+200+10;
const int INF = 10000;
int d[maxn];
int n,m; struct Edge{
int u,v;
int t;
}edge[maxw]; bool bellman_ford()
{
for(int i = 1; i <= n; i++) d[i] = INF; //初始化从起点到 i 时间为最值
d[1] = 0; //起点为 0 for(int i = 1; i < n; i++)
{
bool flag = true; //判断这轮是否能够松弛
for(int j = 0; j < m; j++)
{
int u = edge[j].u;
int v = edge[j].v;
int t = edge[j].t; if(d[v] > d[u]+t) //松弛操作
{
d[v] = d[u]+t;
flag = false;
}
}
if(flag) return false; //如果当前轮不能松弛,直接判断没有负数环
} for(int i = 0; i < m; i++)
{
if(d[edge[i].v] > d[edge[i].u]+edge[i].t)
return true;//如果仍然能够松弛则存在负环
}
return false;
} int main()
{
int T;
int M,W;
scanf("%d", &T);
while(T--)
{
scanf("%d%d%d", &n,&M,&W);
m = 0; int u,v,t;
for(int i = 1; i <= M; i++) //田地间的大路,加双边
{
scanf("%d%d%d", &u,&v,&t);
edge[m].u = u;
edge[m].v = v;
edge[m++].t = t; edge[m].u = v;
edge[m].v = u;
edge[m++].t = t;
} for(int i = 1; i <= W; i++) //孔洞,加单边
{
scanf("%d%d%d", &u,&v,&t);
edge[m].u = u;
edge[m].v = v;
edge[m++].t = -t;
} if(bellman_ford()) printf("YES\n"); //存在负数环
else printf("NO\n");
}
}
















POJ 3259 Wormholes【bellman_ford判断负环——基础入门题】的更多相关文章

  1. POJ 3259 Wormholes ( SPFA判断负环 && 思维 )

    题意 : 给出 N 个点,以及 M 条双向路,每一条路的权值代表你在这条路上到达终点需要那么时间,接下来给出 W 个虫洞,虫洞给出的形式为 A B C 代表能将你从 A 送到 B 点,并且回到 C 个 ...

  2. POJ 3259 Wormholes(SPFA判负环)

    题目链接:http://poj.org/problem?id=3259 题目大意是给你n个点,m条双向边,w条负权单向边.问你是否有负环(虫洞). 这个就是spfa判负环的模版题,中间的cnt数组就是 ...

  3. POJ 3259 Wormholes 最短路+负环

    原题链接:http://poj.org/problem?id=3259 题意 有个很厉害的农民,它可以穿越虫洞去他的农场,当然他也可以通过道路,虫洞都是单向的,道路都是双向的,道路会花时间,虫洞会倒退 ...

  4. POJ 3259 Wormholes( bellmanFord判负环)

    Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 36425   Accepted: 13320 Descr ...

  5. POJ 3259 Wormholes (判负环)

    Wormholes Time Limit: 2000MS Memory Limit: 65536K Total Submissions: 46123 Accepted: 17033 Descripti ...

  6. POJ 3259 Wormholes【Bellman_ford判断负环】

    题意:给出n个点,m条正权的边,w条负权的边,问是否存在负环 因为Bellman_ford最多松弛n-1次, 因为从起点1终点n最多经过n-2个点,即最多松弛n-1次,如果第n次松弛还能成功的话,则说 ...

  7. POJ 3259:Wormholes bellman_ford判定负环

    Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 37906   Accepted: 13954 Descr ...

  8. poj 3259 (Bellman_Ford判断负环)

    题意:John的农场里n块地,m条路连接两块地,k个虫洞,虫洞是一条单向路,不但会把你传送到目的地,而且时间会倒退Ts.我们的任务是知道会不会在从某块地出发后又回来,看到了离开之前的自己. 思路:虫洞 ...

  9. Wormholes POJ 3259(SPFA判负环)

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

随机推荐

  1. python抓包截取http记录日志

    #!/usr/bin/python import pcap import dpkt import re   def main(): pc=pcap.pcap(name="eth1" ...

  2. poj 3696 The Luckiest number 欧拉函数在解a^x=1modm的应用

    题意: 给一个L,求长度最小的全8数满足该数是L的倍数. 分析: 转化为求方程a^x==1modm. 之后就是各种数学论证了. 代码: //poj 3696 //sep9 #include <i ...

  3. springMVC4(5)RestTemplate控制层单元測试

    在前面我们进行web測试,总要在游览器进行.数据组装.请求方法更给等都极为麻烦. RestTemplate是Spring提供的一个web层測试模板类,我们能够通过RestTemplate在client ...

  4. PHP多线程处理问题

    近日工作中涉及到项目同时处理多个线程问题时,在网上找到了PHP的pthreads扩展以及curl_multi_init函数,具体如下: 一 .windows下安装php真正的多线程扩展pthreads ...

  5. C# socket编程 使用fleck轻松实现对话 https://github.com/statianzo/Fleck

    class Program { static void Main(string[] args) { FleckLog.Level = LogLevel.Debug; var allSockets = ...

  6. Spark学习(一) 基本操作

    先来一个简单的spark小程序,这是官网上的小样例,目的就是统计spark以下的README文档中包括字母a和字母b的个数,然后 打印,代码例如以下: object BasicStandaloneAp ...

  7. POJ 3667 Hotel(线段树)

    POJ 3667 Hotel 题目链接 题意:有n个房间,如今有两个操作 1.找到连续长度a的空房间.入住,要尽量靠左边,假设有输出最左边的房间标号,假设没有输出0 2.清空[a, a + b - 1 ...

  8. python 在Windows中描述路径时出现的问题

    问题的根本:windows读取文件可以用\,但在字符串里面\被作为转义字符使用,   python在描述路径时有两种方式: 'd:\\a.txt',转义的方式 r'd:\a.txt',声明字符串不需要 ...

  9. TCP通过哪些措施,保证传输可靠

    TCP是通过什么方式来提供可靠传输的 (合理截断数据包,超时重发,校验,失序重新排序,能够丢弃重复数据,TCP可以进行流量控制) TCP提供一种面向连接的.可靠的字节流服务.  面向连接:意味着两个使 ...

  10. Android JNI和NDK学习(03)--动态方式实现JNI(转)

    本文转自:http://www.cnblogs.com/skywang12345/archive/2013/05/23/3092491.html 前面总结了静态实现JNI的方法,本文介绍如何动态实现J ...