Labeling Balls(逆向拓扑排序)

Labeling Balls

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 14093		Accepted: 4094

Description

Windy has N balls of distinct weights from 1 unit to N units. Now he tries to label them with 1 to N in such a way that:

1. No two balls share the same label.
2. The labeling satisfies several constrains like "The ball labeled with a is lighter than the one labeled with b".

Can you help windy to find a solution?

Input

The first line of input is the number of test case. The first line of each test case contains two integers, N (1 ≤ N ≤ 200) and M (0 ≤ M ≤ 40,000). The next M line each contain two integers a and b indicating the ball labeled with a must be lighter than the one labeled with b. (1 ≤ a, b ≤ N) There is a blank line before each test case.

Output

For each test case output on a single line the balls' weights from label 1 to label N. If several solutions exist, you should output the one with the smallest weight for label 1, then with the smallest weight for label 2, then with the smallest weight for label 3 and so on... If no solution exists, output -1 instead.

Sample Input

5

4 0

4 1
1 1

4 2
1 2
2 1

4 1
2 1

4 1
3 2

Sample Output

1 2 3 4
-1
-1
2 1 3 4
1 3 2 4

Source

解题思路：

每做一道题都可以学到新的思路。

由编号1—N的N个小球，重量也为1—N（容易混淆），给出一些限制条件，a  b，代表着编号为a的小球比编号为b的小球的重量小，根据限制条件，给小球分配重量，最后输出的是编号1—N的小球的重量。如果有多种方法，那么编号小的小球重量尽量小。

分析：拓扑排序，注意根据题的要求，要先保证1号球最轻，如果我们由轻的向重的连边，然后我们依次有小到大每次把重量分给一个入度为0的点，那么在拓扑时我们面对多个入度为0的点，我们不知道该把最轻的分给谁才能以最快的速度找到1号（使1号入度为0），并把当前最轻的分给1号。所以我们要由重的向轻的连边，然后从大到小每次把一个重量分给一个入度为0的点。这样我们就不用急于探求最小号。我们只需要一直给最大号附最大值，尽量不给小号赋值，这样自然而然就会把轻的重量留给小号。（转

在基本的拓扑排序的基础上又增加了一个要求：编号 最小 的节点要尽量排在前面；在满足上一个条件的基础上，编号 第二小 的节点要尽量排在前面；在满足前两个条件的基础上，编号 第三小 的节点要尽量排在前面……依此类推。（注意，这和 字典序 是两回事，不可以混淆。）

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int mp[250][250],in[250],vis[250],a[250];
int n,m,i,j;
int weight;
int toopsort()
{
    weight=n;
    for(i=1;i<=n;i++)
    {
        int ans=0;
        for(j=n;j>=1;j--)//倒着的目的是，让重量相同的，序号小的在前面
        {
            if(!vis[j]&&in[j]==0)//每次找出入度为0得点也就是最重的点
            {
               ans=j;
               break;
            }
        }
        if(!ans)//如果没有入度为0的点就已经结束了
        break;
        vis[ans]=1;
        a[ans]=weight--;//赋给该点它的重量次序
        for(j=1;j<=n;j++)
        {
            if(!vis[j]&&mp[j][ans]==1)
            {
               in[j]--;
            }
        }
    }
return weight;
}
int main()
{
    int T,u,v;
    scanf("%d",&T);
    while(T--)
    {
       scanf("%d%d",&n,&m);
       memset(mp,0,sizeof(mp));
       memset(vis,0,sizeof(vis));
       memset(in,0,sizeof(in));
       memset(a,0,sizeof(a));
       for(i=1;i<=m;i++)
       {
          scanf("%d%d",&u,&v);
          if(!mp[u][v])
          {
             mp[u][v]=1;
             in[u]++;
          }
       }
       if(toopsort()==0)
       {
          for(i=1;i<=n;i++)
          {
              if(i==n)
              printf("%d\n",a[i]);
              else printf("%d ",a[i]);
          }
       }
       else
       printf("-1\n");
    }
    return 0;
}