1108

1108 - Instant View of Big Bang

PDF (English)

Statistics

Forum

Time Limit: 2 second(s)

Memory Limit: 32 MB

Have you forgotten about wormholes? Oh my god! Ok, let me explain again.

A wormhole is a subspace tunnel through space and time connecting two star systems. Wormholes have a few peculiar properties:

1. Wormholes are one-way only.
2. The time it takes to travel through a wormhole is negligible.
3. A wormhole has two end points, each situated in a star system.
4. A star system may have more than one wormhole end point within its boundaries.
5. Between any pair of star systems, there is at most one wormhole in each direction.
6. There are no wormholes with both end points in the same star system.

All wormholes have a constant time difference between their end points. For example, a specific wormhole may cause the person traveling through it to end up 15 years in the future. Another wormhole may cause the person to end up 42 years in the past.

A brilliant physicist wants to use wormholes to study the Big Bang. Since warp drive has not been invented yet, it is not possible for her to travel from one star system to another one directly. Thiscan be done using wormholes, of course.

The scientist can start her journey from any star system. Then she wants to reach a cycle of wormholes somewhere in the universe that causes her to end up in the past. By traveling along this cycle a lot of times, the scientist is able to go back as far in time as necessary to reach the beginning of the universe and see the Big Bang with her own eyes. Write a program to help her to find such star systems where she can start her journey.

Input

Input starts with an integer T (≤ 125), denoting the number of test cases.

Each case starts with a blank line. The next line contains two numbers n and m . These indicate the number of star systems (1 ≤ n ≤ 1000) and the number of wormholes (0 ≤ m ≤ 2000). The star systems are numbered from 0 to n-1. For each wormhole a line containing three integer numbers x, y and t is given. These numbers indicate that this wormhole allows someone to travel from the star system numbered x to the star system numbered y, thereby ending up t (-1000 ≤ t ≤ 1000) years in the future or past, a negative integer denotes past, positive integer denotes future.

Output

For each case, print the case number first. Then print the star systems (in ascending order) where she can start her journey. If no such star system is found, print 'impossible'.

Sample Input	Output for Sample Input
2 3 3 0 1 1000 1 2 15 2 1 -42 4 4 0 1 10 1 2 20 2 3 30 3 0 -60	Case 1: 0 1 2 Case 2: impossible

---

Problem Setter: Jane Alam Jan

题意：让你找所有的可以走入负环的点；

思路：spfa找负环；

这题的关键不是去判断负环，而是咋样去找那些点，我们可以知道，假如是负环的话用spfa去更新会无限循环。如果某个点能到达到达负环，并且它不在负环的内部，我们咋判断这个点，由于负环的内部即使边的方向改变了，这个负环还是不会变的，那么原来指向这个负环的边就会变成，负环指向那个点，那么当你找到负环然后dfs找点就能将所有符合要求的点求出。其实关键就是反向建图；

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<queue>
#include<math.h>
using namespace std;
typedef struct pp
{
        int from;
        int to;
        int pre;
        int cost;
} ss;
const int N=1e8;
ss node[6000];
ss nn[6000];
int id[6000];
int id1[6000];
int ask[6000];
bool flag[6000];
int cnt[6000];
int sum[6000];
int d[6000];
int yy[6000];
void add(int from,int to,int cost,int cc);
void add1(int from,int to,int cost,int cc);
void dfs(int n);
void spfa(int n);
int main(void)
{
        int i,j,k;
        scanf("%d",&k);
        int s;
        int n,m;
        for(s=1; s<=k; s++)
        {
                memset(ask,0,sizeof(ask));
                scanf("%d %d",&n,&m);
                memset(id,-1,sizeof(id));
                memset(id1,-1,sizeof(id1));
                int ans=0;
                for(i=0; i<m; i++)
                {
                        int x,y,z;
                        scanf("%d %d %d",&x,&y,&z);
                        add(y,x,z,ans);
                        ans++;
                }
                spfa(n);
                int xx=0;
                for(i=0; i<n; i++)
                {
                        if(ask[i])
                        {
                                sum[xx++]=i;
                        }
                }
                printf("Case %d: ",s);
                if(xx==0)
                        printf("impossible
");
                else
                {
                        printf("%d",sum[0]);
                        for(i=1; i<xx; i++)
                                printf(" %d",sum[i]);
                        printf("
");
                }
        }
        return 0;
}
void add(int from,int to,int cost,int cc)
{
        node[cc].from=from;
        node[cc].to=to;
        node[cc].cost=cost;
        node[cc].pre=id[from];
        id[from]=cc;
}
void spfa(int n)
{
        int i,j,k;
        memset(yy,0,sizeof(yy));
        for(i=0; i<n; i++)
        {
                if(!ask[i]&&!yy[i])
                {
                        memset(flag,0,sizeof(flag));
                        memset(cnt,0,sizeof(cnt)) ;
                        fill(d,d+n,N);
                        yy[i]=1;
                        queue<int>que;
                        que.push(i);
                        flag[i]=true;
                        cnt[i]++;
                        que.push(i);
                        while(!que.empty())
                        {
                                int vv=que.front();
                                que.pop();
                                flag[vv]=false;
                                int kk=id[vv];
                                while(kk!=-1)
                                {
                                        int gg=node[kk].to;
                                        if(!ask[gg])
                                        {
                                                if(d[gg]>d[vv]+node[kk].cost)
                                                {
                                                        d[gg]=d[vv]+node[kk].cost;
                                                        if(flag[gg]==false)
                                                        {
                                                                que.push(gg);
                                                                cnt[gg]++;
                                                                flag[gg]=true;
                                                                if(cnt[gg]>n)
                                                                {
                                                                    dfs(gg);
                                                                    while(!que.empty())
                                                                    {
                                                                        que.pop();
                                                                    }
                                                                    break;
                                                                }
                                                        }
                                                }
                                        }
                                        kk=node[kk].pre;
                                }
                        }
                }
        }
}
void dfs(int n)
{
        ask[n]=1;
        int xx=id[n];
        while(xx!=-1)
        {
                int kk=node[xx].to;
                if(!ask[kk])
                {
                        dfs(kk);
                }
                xx=node[xx].pre;
        }
}