Wormholes//spfa 负环判断 链式向前星

题目：

 

 

Wormholes

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 60744		Accepted: 22692

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: A single integer, F. F farm descriptions follow.
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

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.

 

思路：

　　第一次用链式向前星来存图（其实就是用两个一维数组来实现邻接表），这题就是判断负环，spfa时有点入队列次数超过总点数则存在可达负环（注意是可达！），所以对于不可达的部分还要判断(但别人博客里都是随便找个点1入队然后就spfa了，貌似也能过，可能是题目数据太水)。

不方便画图，就给一组以点1进行spfa无可达负环但是图中却有负环的数据（不复杂，你自己画下图）：

1

6 2 4

4 6 3

6 5 4

4 5 8

1 2 3

2 3 3

4 1 3

其中4 5 6 三点明显构成负环，但是点1却不可达该负环，然而我复制别人的代码跑出来是NO，也就是检测不到该负环，解决办法就是我加了个循环和marked[]数组来判断是否可达，对于不可达的部分再进行spfa。(这些只是我个人的看法，也可能是我想多了QAQ)

代码：

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int size1 = 500 + 5;
const int size2 = 5200 + 5;

struct Edge
{
    int to;
    int len;
    int next;
};
//链式向前星
Edge edge[size2];
int head[size1];
int cnt = 0;

queue<int> que;
bool onque[size1];//是否在队列上
int intoque[size1];//>N则说明有可达负环(可达！！！)
int dis[size1];
bool marked[size1];//标记可达边

void init(int N)//初始化
{
    cnt = 0;
    memset(head, -1, sizeof(head));
    for(int i = 1; i <= N; i++)
    {
        dis[i] = 0x3f3f3f3f;
        marked[i] = false;
        onque[i] = false;
        intoque[i] = 0;
    }
}

void addEdge(int u, int v, int w)//加边
{
    edge[cnt].to = v;
    edge[cnt].len = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

bool spfa(int x, int N)
{
    dis[x] = 0;
    //marked[x] = true;
    que.push(x);
    onque[x] = true;
    marked[x] = true;
    while(!que.empty())
    {
        int c = que.front();
        onque[c] = false;
        que.pop();
        for(int h = head[c]; h != -1; h=edge[h].next)
        {
            if(dis[c] + edge[h].len < dis[edge[h].to])//边松弛
            {
                marked[edge[h].to] = true;//该边可达
                dis[edge[h].to] = dis[c] + edge[h].len;
                if(!onque[edge[h].to])//入队列
                {
                    que.push(edge[h].to);
                    onque[edge[h].to] = true;
                    intoque[edge[h].to]++;
                    if(intoque[edge[h].to] > N)//检测负环
                        return true;
                }
            }
        }
    }
    return false;//无负环
}

int main()
{
    int F;
    int N, M, W;
    int S, E, T;
    cin >> F;
    while(F--)
    {
        scanf("%d%d%d", &N, &M, &W);
        init(N);
        for(int i = 0; i < M; i++)
        {
            scanf("%d%d%d", &S, &E, &T);
            //双向边
            addEdge(S,E,T);
            addEdge(E,S,T);
        }
        for(int i = 0; i < W; i++)
        {
            scanf("%d%d%d", &S, &E, &T);
            addEdge(S,E,-T);//负权
        }
        int flag = 0;
        for(int i = 1; i <= N; i++)//对每一个不可达的地方进行检测
        {
            if(!marked[i])
            {
                if(spfa(i,N))
                    {
                        flag = 1;
                        break;
                    }
            }
        }
        if(flag)
            printf("YES\n");
        else 
            printf("NO\n");
    }
    return 0;
}