【POJ - 3259 】Wormholes（Bellman_Ford或spfa算法，判断有向图中是否存在负环）

题干：

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

Input

第1行：一个整数F表示接下来会有F个农场说明。每个农场第一行：分别是三个空格隔开的整数：N，M和W 第2行到M+1行：三个空格分开的数字（S，E，T）描述，分别为：需要T秒走过S和E之间的双向路径。两个区域可能由一个以上的路径来连接。第M +2到M+ W+1行：三个空格分开的数字（S，E，T）描述虫洞，描述单向路径，S到E且回溯T秒。

Output

F行，每行代表一个农场每个农场单独的一行，” YES”表示能满足要求，”NO”表示不能满足要求。

Sample Input

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.

AC代码：（spfa，邻接矩阵存图）（1079ms）

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int n;
const int MAX = 505;
const int INF = 0x3f3f3f3f;
int dis[MAX],maze[MAX][MAX],cnt[MAX];
bool vis[MAX];
bool spfa(int s){
//  for(int i=0; i<=n; i++) dis[i]=99999999; //初始化每点i到s的距离dis[s]=0; vis[s]=1;  //队列初始化,s为起点int i, v;queue<int > q;q.push(s);while (!q.empty()){   //队列非空v=q.front();  //取队首元素q.pop();vis[v]=0;   //释放队首结点，因为这节点可能下次用来松弛其它节点，重新入队for(i=1; i<=n; i++)  //对所有顶点if (maze[v][i]!=INF && dis[i]>dis[v]+maze[v][i]){  dis[i] = dis[v]+maze[v][i];   //修改最短路if (vis[i]==0){  //如果扩展结点i不在队列中，入队cnt[i]++;vis[i]=1;q.push(i);if(cnt[i] >=n) return true;}}}return false;
}void init() {memset(vis,0,sizeof(vis));memset(maze,INF,sizeof(maze));memset(dis,INF,sizeof(dis));memset(cnt,0,sizeof(cnt));
}
int main()
{int t;int M,W,u,v,w;cin>>t;  while(t--) {init();scanf("%d%d%d",&n,&M,&W);for(int i = 1; i<=M; i++) {scanf("%d%d%d",&u,&v,&w);if(w<maze[u][v])maze[u][v] = maze[v][u] = w;}for(int i = 1; i<=W; i++) {scanf("%d%d%d",&u,&v,&w);maze[u][v] = -w;}cnt[1] =1;if(spfa(1)) printf("YES\n");else printf("NO\n");}return 0 ;
}

AC代码2：（Bellman_Ford算法）（125ms）

//Bellman_Ford算法试试
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
#define MAXN 3000*2
#define INF 0xFFFFFFFint t , n , m, w;
int dis[MAXN];
struct Edge{int x;int y;int value;
}e[MAXN];bool judge(){for(int i = 0 ; i < m*2+w ; i++){if(dis[e[i].y] > dis[e[i].x] + e[i].value)return false;}return true;
}void Bellman_Ford(){dis[1] = 0;for(int i = 2 ; i <= n ; i++)dis[i] = INF;for(int i = 1 ; i <= n ; i++){for(int j = 0 ; j < m*2+w; j++){if(dis[e[j].y] > dis[e[j].x] + e[j].value)dis[e[j].y] = dis[e[j].x] + e[j].value;}}if(judge())printf("NO\n");elseprintf("YES\n");
}int main()
{int uu,vv,ww,i;scanf("%d",&t);while(t--){scanf("%d%d%d",&n,&m,&w);for(i=0;i<m*2;){scanf("%d%d%d",&uu,&vv,&ww);e[i].x=uu;e[i].y=vv;e[i++].value=ww;e[i].x=vv;e[i].y=uu;e[i++].value=ww;}for(;i<m*2+w;i++){scanf("%d%d%d",&uu,&vv,&ww);e[i].x=uu;e[i].y=vv;e[i].value=-ww;}Bellman_Ford();}return 0;
}

AC代码3：（spfa，邻接表储存图）（266ms）

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int n,cnt;
const int MAX = 505;
const int INF = 0x3f3f3f3f;
int dis[MAX],maze[MAX][MAX],cntt[MAX],head[MAX];
bool vis[MAX];
struct Edge {int to,w,ne;Edge(){}//没有此构造函数不能写  node t  这样Edge(int to,int w,int ne):to(to),w(w),ne(ne){}//可以写node(pos,cost)这样} e[200000 + 5];//数组别开小了
void add(int u,int v,int w) {e[cnt].to = v;e[cnt].w = w;e[cnt].ne = head[u];head[u] = cnt++;
}bool spfa(int s){dis[s]=0; vis[s]=1;  //队列初始化,s为起点int v;queue<int > q;q.push(s);while (!q.empty()){   //队列非空v=q.front();  //取队首元素q.pop();vis[v]=0;   //释放队首结点，因为这节点可能下次用来松弛其它节点，重新入队for(int i=head[v]; i!=-1; i=e[i].ne)  //对所有顶点{if (dis[e[i].to]>dis[v]+e[i].w) {  dis[e[i].to] = dis[v]+e[i].w;   //修改最短路if (vis[e[i].to]==0) {  //如果扩展结点i不在队列中，入队cntt[e[i].to]++;vis[e[i].to]=1;q.push(e[i].to);if(cntt[e[i].to] >=n) return true;}}}}return false;
}void init() {cnt = 0;memset(vis,0,sizeof(vis));memset(maze,0,sizeof(maze));memset(e,0,sizeof(e));memset(dis,INF,sizeof(dis));memset(cntt,0,sizeof(cntt));memset(head,-1,sizeof(head));
}
int main()
{int t;int M,W,u,v,w;cin>>t;  while(t--) {init();scanf("%d%d%d",&n,&M,&W);for(int i = 1; i<=M; i++) {scanf("%d%d%d",&u,&v,&w);add(u,v,w);add(v,u,w);}for(int i = 1; i<=W; i++) {scanf("%d%d%d",&u,&v,&w);add(u,v,-w);}cntt[1] =1;if(spfa(1)) printf("YES\n");else printf("NO\n");}return 0 ;
}

AC代码4：（Bellmanford，加优化）（47ms）

//bellman算法：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 20100using namespace std;
const int INF = 0x3f3f3f3f;
int n,m,mm;
int tot;
int dis[6005];
struct Edge {int u,v,w;
} e[6005];
void add(int u,int v,int w) {e[++tot].u = u;e[tot].v = v;e[tot].w = w;
}
bool bell() {memset(dis,INF,sizeof(dis));dis[1]=0;int all = n;int flag = 0;while(all--) {flag = 0;for(int i = 1; i<=tot; i++) {if(dis[e[i].v] > dis[e[i].u] + e[i].w) {flag = 1;dis[e[i].v] = dis[e[i].u] + e[i].w;}}if(flag == 0) return false;}flag = 0;for(int i = 1; i<=tot; i++) {if(dis[e[i].v] > dis[e[i].u] + e[i].w) return 1;}return 0;
}int main()
{int f,a,b,c;cin>>f;while(f--) {tot = 0;scanf("%d%d%d",&n,&m,&mm);for(int i = 1; i<=m; i++) {scanf("%d%d%d",&a,&b,&c) ;add(a,b,c);add(b,a,c);}for(int i = 1; i<=mm; i++) {scanf("%d%d%d",&a,&b,&c);add(a,b,-c);}if(bell()) puts("YES");else puts("NO");}return 0 ;
}
//2
//3 3 1
//1 2 2
//1 3 4
//2 3 1
//3 1 3

【POJ - 3259 】Wormholes（Bellman_Ford或spfa算法，判断有向图中是否存在负环）相关推荐

~~spfa判断图中是否存在负环
时间复杂度是 O(nm), n 表示点数,m 表示边数 int n; // 总点数 int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N], ...
SPFA算法判断负权环（bfs_spfa,dfs_spfa）
判断给定的有向图中是否存在负环. 利用 spfa 算法判断负环有两种方法: 1) spfa 的 dfs 形式,判断条件是存在一点在一条路径上出现多次. 2) spfa 的 bfs 形式,判断条件是存在 ...
图8——判断有向图中是否有根
在有向图G中,如果r到G中每个结点都有路径可达,则称结点r为G的跟结点.编写一个算法判断有向图G中是否有根,如果有则打印出所有根节点的值. [分析] 这是东北大学和浙江大学的考研试题.主要考查对图的深 ...
POJ 3259 Wormholes（bellman_ford，判断有没有负环回路）
题意:John的农场里field块地,path条路连接两块地,hole个虫洞,虫洞是一条单向路,不但会把你传送到目的地,而且时间会倒退Ts.我们的任务是知道会不会在从某块地出发后又回来,看到了离开之前 ...
POJ 3259 Wormholes【最短路/SPFA判断负环模板】
农夫约翰在探索他的许多农场,发现了一些惊人的虫洞.虫洞是很奇特的,因为它是一个单向通道,可让你进入虫洞的前达到目的地!他的N(1≤N≤500)个农场被编号为1..N,之间有M(1≤M≤2500)条路径 ...
POJ - 3259 Wormholes(判断负环)
题目链接:点击查看题意:最短路判断负环这里介绍三种方法判断负环,分别是spfa,bellman-ford和flyod算法,不过spfa的速度能比bellman-ford的速度慢了接近20倍是出乎 ...
POJ 3259 Wormholes SPFA判负环
思路:SPFA判负环数组不要开太小-- (后面附一组测试数组) // by SiriusRen #include <queue> #include <cstdio> #inc ...
POJ 3259 Wormholes
题目链接题意问是否存在负环 AC 因为Dijkstra不能处理带有负边权的图,可以用spfa 和 BellmenFord spfa using namespace std; int inf = 0 ...
POJ - 3169 SPFA解差分约束除了有解,负环还有另一种情况
题意就是有N头牛排成一个直线..有些牛之间互相讨厌..距离必须大于等于某个...有些牛之间相互暧昧..距离必须小于等于某个...牛的前后顺序和编号是一样的...问这些牛最多能排多长.. 比较传统的SP ...

【POJ - 3259 】Wormholes（Bellman_Ford或spfa算法，判断有向图中是否存在负环）

【POJ - 3259 】Wormholes（Bellman_Ford或spfa算法，判断有向图中是否存在负环）相关推荐

最新文章

热门文章