poj 2367 Genealogical tree（DAG的拓扑排序）

Description

The system of Martians’ blood relations is confusing enough. Actually,
Martians bud when they want and where they want. They gather together
in different groups, so that a Martian can have one parent as well as
ten. Nobody will be surprised by a hundred of children. Martians have
got used to this and their style of life seems to them natural. And
in the Planetary Council the confusing genealogical system leads to
some embarrassment. There meet the worthiest of Martians, and
therefore in order to offend nobody in all of the discussions it is
used first to give the floor to the old Martians, than to the younger
ones and only than to the most young childless assessors. However, the
maintenance of this order really is not a trivial task. Not always
Martian knows all of his parents (and there’s nothing to tell about
his grandparents!). But if by a mistake first speak a grandson and
only than his young appearing great-grandfather, this is a real
scandal. Your task is to write a program, which would define once and
for all, an order that would guarantee that every member of the
Council takes the floor earlier than each of his descendants.
Input

The first line of the standard input contains an only number N, 1 <= N
<= 100 — a number of members of the Martian Planetary Council.
According to the centuries-old tradition members of the Council are
enumerated with the natural numbers from 1 up to N. Further, there are
exactly N lines, moreover, the I-th line contains a list of I-th
member’s children. The list of children is a sequence of serial
numbers of children in a arbitrary order separated by spaces. The list
of children may be empty. The list (even if it is empty) ends with 0.
Output

The standard output should contain in its only line a sequence of
speakers’ numbers, separated by spaces. If several sequences satisfy
the conditions of the problem, you are to write to the standard output
Sample Input

5
0
4 5 1 0
1 0
5 3 0
3 0
Sample Output

2 4 5 3 1

这题题意就是给出一个数n， 然后n行，编号1到n, 每行输入几个数，该行的编号排在这几个数前面，输出一种符合要求的编号名次排序。
显然就是一个裸的DAG拓扑排序

我们可以用链表存图，记录一下每个点的入度，先找入度为零的点，然后再把这个点连向的点的入度减减，再去找剩下的点中入度为零的点，以此类推，直到所有的点都被找过。

代码如下：

#include<iostream>#include<cstdio>#include<cstdlib>using namespace std;const int maxn=50005;struct dqs{    int f,t;}hh[maxn];int ru[maxn];int first[maxn],next[maxn],d[maxn];bool vis[maxn];int tot=0;void build(int f,int t){    hh[++tot]=(dqs){f,t};    next[tot]=first[f];    first[f]=tot;}   int n;void zhaoshu(){    for(int i=1;i<=n;i++)    {        if(ru[i]==0&&vis[i]==0)        {            printf("%d ",i);            vis[i]=1;            for(int j=first[i];j;j=next[j])            {                int u=hh[j].t;                if(!vis[u])                {                    ru[u]--;                    if(ru[u]==0)                    zhaoshu();                                  }            }        }    }}int main(){    scanf("%d",&n);    for(int i=1;i<=n;i++)    {        int x;        while(true)        {            scanf("%d",&x);            if(x==0) break;            build(i,x);            ru[x]++;            }    }    zhaoshu();    return 0;}