Labeling Balls（poj3687）

Labeling Balls

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 13109		Accepted: 3782

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
思路：拓扑排序，优先队列。
开始时我是正向建边，然后拓扑排序，贪心去当前度为0的最小的点WA

后来想想，因为要保证1,2，。。。要最优，也就是要先找到1，那么在1前面度为0的点肯定在1之前。那么用上面这种贪心，我们会先选1，然后
4然后5，然后才是3，由于我们要先贪心找到2，所以这种策略就不对了，那么我们还是从正向模拟一下，1,5,3,4,2，这时正向走就是按每次最小所以我们的先找到2然后这时
这时2前面的数已经取出，但我们不知道在2出来前咋对前面的数进行选取。我们思考这么一种策略，我们建反向边，我们可以知道如果这时有入度为0的点，那么我们选取最大的
入度为0的点，这时这个点肯定是最后一个，那些在它下一层的那些点肯定排在它的前面，同时比它小和他同一层的点也要排在它的前面，所以每次都这样，选最大的可以保证最优。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<queue>
#include<vector>
using namespace std;
typedef struct pp {
    int x;
    bool operator<(const pp &n)const {
        return n.x>x;
    }
} ss;
vector<int>vec[300];
priority_queue<ss>que;
int ans[300];
int bb[300];
int aa[300];
int ma[300][300];
int main(void) {
    int i,j,k;
    int p,q;
    scanf("%d",&k);
    while(k--) {
        for(i=0; i<300; i++) {
            vec[i].clear();
        }
        while(!que.empty())que.pop();
        memset(ma,0,sizeof(ma));
        memset(ans,0,sizeof(ans));
        scanf("%d %d",&p,&q);
        int ff=0;
        while(q--) {
            int x,y;
            scanf("%d %d",&x,&y);
            if(x==y)ff=1;
            {
                vec[y].push_back(x);
                ans[x]++;
                ma[y][x]=1;
            }
        }
        if(ff)printf("-1
");
        else {
            int flag=0;
            for(i=1; i<=p; i++) {
                if(ans[i]==0) {
                    ss g;
                    g.x=i;
                    que.push(g);
                }
            }
            while(!que.empty()) {
                ss fg=que.top();
                int c=fg.x;
                bb[flag++]=c;
                que.pop();
                for(i=0; i<vec[c].size(); i++) {
                    int uu=vec[c][i];
                    ans[uu]--;
                    fg.x=uu;
                    if(ans[uu]==0) {
                        que.push(fg);
                    }
                }
            }
            if(flag==p) {
                for(i=0; i<p; i++) {
                    aa[bb[i]]=p-i;
                }
                printf("%d",aa[1]);
                for(i=2; i<=p; i++) {
                    printf(" %d",aa[i]);
                }
                printf("
");
            } else printf("-1
");
        }
    }
    return 0;
}