The Bottom of a Graph

　　　　　　　　　　　　　                                　poj——The Bottom of a Graph

Time Limit: 3000MS		Memory Limit: 65536K
Total Submissions: 11044		Accepted: 4542

Description

We will use the following (standard) definitions from graph theory. Let V be a nonempty and finite set, its elements being called vertices (or nodes). Let E be a subset of the Cartesian product V×V, its elements being called edges. ThenG=(V,E) is called a directed graph. 
Let n be a positive integer, and let p=(e₁,...,e_n) be a sequence of length n of edges e_i∈E such that e_i=(v_i,v_i+1) for a sequence of vertices (v₁,...,v_n+1). Then p is called a path from vertex v₁ to vertex v_n+1 in G and we say that v_n+1is reachable from v₁, writing (v₁→v_n+1). 
Here are some new definitions. A node v in a graph G=(V,E) is called a sink, if for every node w in G that is reachable from v, v is also reachable from w. The bottom of a graph is the subset of all nodes that are sinks, i.e.,bottom(G)={v∈V|∀w∈V:(v→w)⇒(w→v)}. You have to calculate the bottom of certain graphs.

Input

The input contains several test cases, each of which corresponds to a directed graph G. Each test case starts with an integer number v, denoting the number of vertices of G=(V,E), where the vertices will be identified by the integer numbers in the set V={1,...,v}. You may assume that 1<=v<=5000. That is followed by a non-negative integer e and, thereafter, e pairs of vertex identifiers v₁,w₁,...,v_e,w_e with the meaning that (v_i,w_i)∈E. There are no edges other than specified by these pairs. The last test case is followed by a zero.

Output

For each test case output the bottom of the specified graph on a single line. To this end, print the numbers of all nodes that are sinks in sorted order separated by a single space character. If the bottom is empty, print an empty line.

Sample Input

3 3
1 3 2 3 3 1
2 1
1 2
0

Sample Output

1 3
2

Source

Ulm Local 2003

定义：点v是汇点须满足 --- 对图中任意点u，若v可以到达u则必有u到v的路径；若v不可以到达u，则u到v的路径可有可无。

题目大意：

如果v点能够到的点，反过来能够到达v点，则称这个点为sink点，输出所有的sink点

思路：

我们这样想：对于一对点如果他们能够相互到达，那么他们在缩点是一定能缩成一个点，这样我们剩下的就是不能缩点的情况了。

也就是说我们缩完点后就剩下两种情况：1.这个点连向其它的点但是那个点不连向他   2.这个点不连向任意点

在这两种情况中第二种情况对于sink点的要求是显然成立的。而第一种情况是不成立的，因为这种情况一定是另一个点不连向这个点的，也就是说她是单向的。

（最开始没明白的地方。。。）

我们为何要在判断一个点的出度为0时循环到n？？

因为我们把这些点缩成一个点，这样我们在进行判断每一个点的时候有两种选择：

1.我们先将出度为零的强连通分量记录在一个数组中。然后再用一个双重循环来判断一下那个点在这个数组中

2.我们用一个一重循环，循环到n，判断这个点所属的强连通分量缩点后对应的点的出度是否为0，若是0，用一个数组将其储存下来。

排序

输出这个数组内的元素

代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 10000
using namespace std;
bool vis[N];
int n,m,x,y,sum,tim,tot,top;
int out[N],dfn[N],low[N],ans[N],head[N],stack[N],belong[N],point[N];
inline int read()
{
    ,f=;char ch=getchar();
    ;ch=getchar();}
    +ch-';ch=getchar();}
    return f*x;
}
struct Edge
{
    int from,to,next;
 }edge[500010];
void add(int x,int y)
{
    tot++;
    edge[tot].to=y;
    edge[tot].next=head[x];
    head[x]=tot;
}
void begin()
{
    tot=;top=;sum=,tim=;
    memset(edge,,sizeof(edge));
    memset(stack,,sizeof(stack));
    memset(head,,sizeof(head));
    memset(,sizeof(out));
    memset(dfn,,sizeof(dfn));
    memset(low,,sizeof(low));
    memset(belong,,sizeof(belong));
    memset(ans,,sizeof(ans));
}
int tarjan(int now)
{
    dfn[now]=low[now]=++tim;
    stack[++top]=now;vis[now]=true;
    for(int i=head[now];i;i=edge[i].next)
    {
        int t=edge[i].to;
        if(vis[t]) low[now]=min(low[now],dfn[t]);
        else if(!dfn[t]) tarjan(t),low[now]=min(low[now],low[t]);
    }
    if(dfn[now]==low[now])
    {
        sum++;belong[now]=sum;
        for(;stack[top]!=now;top--)
        {
            vis[stack[top]]=false;
            belong[stack[top]]=sum;
            }
        vis[now]=false;top--;
    }
 }
void shrink_point()
{
    ;i<=n;i++)
     for(int j=head[i];j;j=edge[j].next)
      if(belong[i]!=belong[edge[j].to])
        out[belong[i]]++;
}
int main()
{
    while(~scanf("%d",&n)&&n)
    {
        m=read();begin();
        ;i<=m;i++)
            x=read(),y=read(),add(x,y);
        ;i<=n;i++)
          if(!dfn[i]) tarjan(i);
        shrink_point();
        x=;
        ;i<=n;i++)
          if(!out[belong[i]]) ans[++x]=i;
        sort(ans+,ans++x);
        if(x)
        {
            ;i<x;i++)
              printf("%d ",ans[i]);
            printf("%d\n",ans[x]);
        }
        else printf("\n");
    }
    ;
}

注意：注意数组的大小！！