poj 3259 Wormholes【spfa判断负环】

Wormholes

Time Limit: 2000MS   Memory Limit: 65536K
Total Submissions: 36729   Accepted: 13444

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..M+W+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 Tseconds.

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.

题意:John的农场里有n块地和m条路双向路以及w个虫洞,虫洞是一条单向路,不但会把你传送到目的地,而且时间会倒退T秒。我们的任务是知道会不会在从某块地出发后又回来,看到了离开之前的自己。

说下输入:n块地,m条边,w个虫洞。下面依次是m条边的信息(双向),输入完后是w个虫洞的信息(单向)。

思路:看图中有没有负权环,有的话John可以无限次走这个环,使得时间一定能得到一个负值。所以存在负环话就是可以,没有的话就是不可以了。

#include<stdio.h>
#include<string.h>
#include<queue>
#define MAX 20000
#define INF 0x3f3f3f
using namespace std;
int n,m,ans,s;
int beg,en;
int dis[MAX],vis[MAX];
int head[MAX];
int used[MAX];
struct node
{
	int u,v,w;
	int next;
}edge[MAX];
void init()
{
	ans=0;
	memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)
{
	edge[ans].u=u;
	edge[ans].v=v;
	edge[ans].w=w;
	edge[ans].next=head[u];
	head[u]=ans++;
}
void getmap()
{
    int i,j;
    scanf("%d%d%d",&n,&m,&s);
    while(m--)
    {
    	int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        add(b,a,c);
	}
	while(s--)
	{
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,-c);
	}
}
void spfa(int sx)
{
	int i,j;
	bool flag=false;
	queue<int>q;
	memset(vis,0,sizeof(vis));
	memset(used,0,sizeof(used));
	for(i=1;i<=n;i++)
	    dis[i]=INF;
	vis[sx]=1;
	dis[sx]=0;
	used[sx]++;
	q.push(sx);
	while(!q.empty())
	{
		int u=q.front();
		    q.pop();
		vis[u]=0;
		for(i=head[u];i!=-1;i=edge[i].next)
		{
			int top=edge[i].v;
			if(dis[top]>dis[u]+edge[i].w)
			{
				dis[top]=dis[u]+edge[i].w;
				if(!vis[top])
				{
					vis[top]=1;
					q.push(top);
					used[top]++;
					if(used[top]>n)//当一个点进队列大于n次则证明存在负环
					{
						flag=true;
						break;
					}
				}
			}
		}
		if(flag)
		   break;
	}
	if(!flag)
	    printf("NO\n");
	else
	    printf("YES\n");
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		init();
		getmap();
		spfa(1);
	}
    return 0;
}

  

时间: 2024-10-31 06:56:18

poj 3259 Wormholes【spfa判断负环】的相关文章

POJ 3259 Wormholes(SPFA判负环)

题目链接:http://poj.org/problem?id=3259 题目大意是给你n个点,m条双向边,w条负权单向边.问你是否有负环(虫洞). 这个就是spfa判负环的模版题,中间的cnt数组就是记录这个点松弛进队的次数,次数超过点的个数的话,就说明存在负环使其不断松弛. 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <queue> 5 using na

POJ3259 Wormholes(SPFA判断负环)

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! Eac

POJ 3259 Wormholes (判负环)

Wormholes Time Limit: 2000MS Memory Limit: 65536K Total Submissions: 46123 Accepted: 17033 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

POJ 3259 Wormholes( bellmanFord判负环)

Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 36425   Accepted: 13320 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 p

poj 3259 Wormholes[ bellman_ford 判负环]

Wormholes 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 wor

POJ 3259 Wormholes【最短路/SPFA判断负环模板】

农夫约翰在探索他的许多农场,发现了一些惊人的虫洞.虫洞是很奇特的,因为它是一个单向通道,可让你进入虫洞的前达到目的地!他的N(1≤N≤500)个农场被编号为1..N,之间有M(1≤M≤2500)条路径,W(1≤W≤200)个虫洞.FJ作为一个狂热的时间旅行的爱好者,他要做到以下几点:开始在一个区域,通过一些路径和虫洞旅行,他要回到最开时出发的那个区域出发前的时间.也许他就能遇到自己了:).为了帮助FJ找出这是否是可以或不可以,他会为你提供F个农场的完整的映射到(1≤F≤5).所有的路径所花时间都

poj 3259 Wormholes spfa : 双端队列优化 判负环 O(k*E)

1 /** 2 problem: http://poj.org/problem?id=3259 3 spfa判负环: 4 当有个点被松弛了n次,则这个点必定为负环中的一个点(n为点的个数) 5 spfa双端队列优化: 6 维护队列使其dist小的点优先处理 7 **/ 8 #include<stdio.h> 9 #include<deque> 10 #include<algorithm> 11 using namespace std; 12 13 class Graph

POJ 3259 Wormholes SPFA算法题解

本题其实也可以使用SPFA算法来求解的,不过就一个关键点,就是当某个顶点入列的次数超过所有顶点的总数的时候,就可以判断是有负环出现了. SPFA原来也是可以处理负环的. 不过SPFA这种处理负环的方法自然比一般的Bellman Ford算法要慢点了. #include <stdio.h> #include <string.h> #include <limits.h> const int MAX_N = 501; const int MAX_M = 2501; const

poj3259 Wormholes --- spfa判负环

又写了个bellman模板一直RE求解啊... #include <iostream> #include <cstring> #include <string> #include <cstdio> #include <cmath> #include <algorithm> #include <vector> #include <queue> #include <map> #define inf 0x

spfa 判断负环 (转载)

判断给定的有向图中是否存在负环. 利用 spfa 算法判断负环有两种方法: 1) spfa 的 dfs 形式,判断条件是存在一点在一条路径上出现多次. 2) spfa 的 bfs 形式,判断条件是存在一点入队次数大于总顶点数. 代码如下: 法 1 (spfa 的 dfs 形式): #include <iostream> #include <cstdio> #include <cstring> using namespace std; const int oo = 1 &