POJ2553——The Bottom of a Graph

The Bottom of a Graph

Time Limit: 3000MS		Memory Limit: 65536K
Total Submissions: 8902		Accepted: 3688

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. Then G=(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+1 is 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


看图就能理解，其实就是找缩点后，出度为0的点，所以就是tarjan+缩点了

#include<map>
#include<set>
#include<list>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N  = 100010;
const int M  = 200010;
const int inf = 0x3f3f3f3f;
int DFN[N];
int low[N];
int block[N];
int Stack[N];
int out[N];
bool instack[N];
int head[N];
int ans[N];
int tot, sccnum, index, top, n, m;

struct node
{
    int next;
    int to;
}edge[M];

void addedge(int from, int to)
{
    edge[tot].to = to;
    edge[tot].next = head[from];
    head[from] = tot++;
}

void init()
{
    memset( instack, 0, sizeof(instack) );
    memset( DFN, 0, sizeof(DFN) );
    memset( low, 0, sizeof(low) );
    memset( out, 0, sizeof(out) );
    sccnum = index = top = 0;
}

void tarjan(int u)
{
    DFN[u] = low[u] = ++index;
    Stack[top++] = u;
    instack[u] = 1;
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if (DFN[v] == 0)
        {
            tarjan(v);
            if (low[u] > low[v])
            {
                low[u] = low[v];
            }
        }
        else if (instack[v])
        {
            if (low[u] > DFN[v])
            {
                low[u] = DFN[v];
            }
        }
    }
    if (DFN[u] == low[u])
    {
        sccnum++;
        do
        {
            top--;
            block[Stack[top]] = sccnum;
            instack[Stack[top]] = 0;
        }while (Stack[top] != u);
    }
}

void solve()
{
    init();
    for (int i = 1; i <= n; i++)
    {
        if (DFN[i] == 0)
        {
            tarjan(i);
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = head[i]; j != -1; j = edge[j].next)
        {
            if (block[i] != block[edge[j].to])
            {
                out[block[i]]++;
            }
        }
    }
    int cnt = 0;
    for (int i = 1; i <= n; i++)
    {
        if (out[block[i]] == 0)
        {
            ans[cnt++] = i;
        }
    }
    sort(ans, ans + cnt);
    printf("%d", ans[0]);
    for (int i = 1; i < cnt; i++)
    {
        printf(" %d", ans[i]);
    }
    printf("\n");
}

int main()
{
    while (~scanf("%d", &n), n)
    {
        scanf("%d", &m);
        memset( head, -1, sizeof(head) );
        tot = 0;
        int u, v;
        for (int i = 0; i < m; i++)
        {
            scanf("%d%d", &u, &v);
            addedge(u, v);
        }
        solve();
    }
    return 0;
}