HDU 2647 拓扑排序分层；

Problem Description

Dandelion's uncle is a boss of a factory. As the spring festival is coming , he wants to distribute rewards to his workers. Now he has a trouble about how to distribute the rewards.
The workers will compare their rewards ,and some one may have demands of the distributing of rewards ,just like a's reward should more than b's.Dandelion's unclue wants to fulfill all the demands, of course ,he wants to use the least money.Every work's reward will be at least 888 , because it's a lucky number.

Input

One line with two integers n and m ,stands for the number of works and the number of demands .(n<=10000,m<=20000)
then m lines ,each line contains two integers a and b ,stands for a's reward should be more than b's.

Output

For every case ,print the least money dandelion 's uncle needs to distribute .If it's impossible to fulfill all the works' demands ,print -1.

Sample Input

2 1

1 2

2 2

1 2

2 1

Sample Output

1777

-1

分析：

 其实就是将所有员工的奖金拓扑排序,然后从888开始安排.不过要注意对于任意奖金数(比如889或888)可能有多个员工获得同样的奖金.

        实现方法很多,这里我采用网上一位大牛的方法.将整个拓扑图分层,位于第0层的是那些可以获得888奖金的,位于第1层的是可以获得889奖金的,依次类推.最终的奖金总数就是888*N+(所有节点层数总和).

 

代码：

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int maxn=10000+10;
const int maxm=20000+10;
int n,m;
int ans;        //ans记录所有节点层数dep的总和
struct Node
{
    int in,dep; //入度与层号
    int head;   //指向第一条边号,head为0表示无边
}nodes[maxn];
struct Edge
{
    int to;     //尾节点  
    int next;   //下一条边  ，相当于邻接表里的next数组。
}edges[maxm];   //边从1开始计数
void add_edge(int i,int u,int v)//添加一条从u->v的边
{
    edges[i]=(Edge){v,nodes[u].head};
    nodes[u].head=i;
    nodes[v].in++;
}
bool topo()
{
    queue<int> Q;
    ans=0;
    int sum=0;
    for(int i=1;i<=n;i++)if(nodes[i].in==0)
        Q.push(i);
    while(!Q.empty())
    {
        int u=Q.front(); Q.pop();
        sum++;
        ans+= nodes[u].dep;
        for(int e=nodes[u].head;e;e=edges[e].next)
        {
            int v=edges[e].to;
            if(--nodes[v].in==0)//这里要注意:若u是正好能使得v入度归0的点,那么u一定是所有指向v点的点中深度最大的
            {
                Q.push(v);
                nodes[v].dep = nodes[u].dep+1;
            }
        }
    }
    return sum==n;
}
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        memset(nodes,0,sizeof(nodes));
        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(i,v,u);
        }
        printf("%d\n",topo()?888*n+ans:-1);
    }
    return 0;
}

邻接表详解----->这里