| Time Limit: 2000MS | Memory Limit: 65536K | |
| Total Submissions: 27163 | Accepted: 9777 |
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..N, M (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 of each farm: Three space-separated integers respectively: N, M, and W
Lines 2.. M+1 of each farm: Three space-separated numbers ( S, E, T) 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 ( S, E, T) that describe, respectively: A one way path from S to E that also moves the traveler back T seconds.
Output
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 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.
题意：
给出 T（1 ~ 5） 个 case，每个 case 首先给出 3 个数，n（1 ~ 500），m（1 ~ 2500），w（1 ~ 200）。代表有 n 个地方，m 条路，w 个虫洞。虫洞的能让时间倒退回 k ，后给出这 m 条路和 w 个虫洞，每一条路都给出 S,E,T，代表 S 和 E 路之间需要花费 T （不超过10000）的时间。结束后给每一个虫洞的S,E,T，代表S 到 E 可以倒退 T （不超过10000）的时间。问能否找到能回到自己的路径，就是找一条能够比刚开始出发的时间还要少的路径。
思路：
最短路。SPFA即可。读老半天没意味出来是什么意思，能返回自己就是存在负环，因为负环每循环一圈这圈内的每个节点都会减少。要注意 M 是双向边，W 是单向边，添加完M后再添加W即可，所以可能会出现重边的情况，但是也不影响，因为每次松弛都会算出最短的那条。最后判断节点是否入队 超过 n 次即可，如果是的话说明存在负环。还需注意一点就是，因为是双向边，所以边的总数是 2500 * 2 + 200，故有关于边的数组范围要 >= 5200。
AC：
#include <cstdio>
#include <algorithm>
#include <queue>
#include <string.h>
#define MAXN 5500
#define INF 99999999
using namespace std;
int v[MAXN],w[MAXN],fir[505],next[MAXN];
int d[505],vis[505],time[505];
int ind,n;
void add_edge(int a,int b,int val) {
v[ind] = b;
w[ind] = val;
next[ind] = fir[a];
fir[a] = ind;
ind++;
}
int SPFA() {
memset(vis,0,sizeof(vis));
memset(time,0,sizeof(time));
for(int i = 1;i <= n;i++) d[i] = INF;
queue<int> q;
d[1] = 0;
q.push(1);
time[1]++;
while(!q.empty()) {
int x = q.front();q.pop();
vis[x] = 0;
for(int e = fir[x];e != -1;e = next[e]) {
if(d[v[e]] > d[x] + w[e]) {
d[v[e]] = d[x] + w[e];
if(!vis[v[e]]){ //这里一开始写!vis[x],纯粹手抽
q.push(v[e]);
vis[v[e]] = 1;
time[v[e]]++;
if(time[v[e]] >= n) return 0;
}
}
}
}
return 1;
}
int main() {
int t;
scanf("%d",&t);
while(t--) {
int m,w;
ind = 0;
memset(fir,-1,sizeof(fir));
scanf("%d%d%d",&n,&m,&w);
while(m--) {
int a,b,val;
scanf("%d%d%d",&a,&b,&val);
add_edge(a,b,val);
add_edge(b,a,val);
}
while(w--) {
int a,b,val;
scanf("%d%d%d",&a,&b,&val);
add_edge(a,b,-val);
}
if(SPFA()) puts("NO");
else puts("YES");
}
return 0;
}