POJ3687拓扑排序+贪心

题意：
      给你n个求，他们的重量是1-n（并不是说1号求的重量是1...），然后给你m组关系a,b，表示a的重量小于b的重量，然后让你输出满足要求的前提下每个球的重量，要求字典序最小。


思路：

      很容易想到这个可以用拓扑排序（其实如果没有字典序那个要求的话查分约束也行），还有就是这个里面的字典序最小不是说拓扑排序的字典序最小，这个要整清楚，如果是求拓扑排序的序列字典序最小直接在出队列的时候找一个编号最小的就行，但是这个不是，我们必须要逆向建边，然后逆向分配编号，因为正向的话会出问题，比如刚开始有好几个入度是0，但是我们无法找到该现则那个会最早碰到1号位置，这个自己画一下就清楚了，一开始我想的是差分约束+并查集之后二级排序，排序的依据是如果当前这两个点是同一个父亲，那么按照距离排序，否则按照id排序，其实这样逻辑没错，但是sort本身不可以这样用的，因为这两个限制条件并不是那种一个建立在另一个的基础上的那种，这个说不太清楚，自己好好和xy的那个二级排序对比下就明白了，还有这个题目数据并不是很大，做法不唯一，直接搜索理论上没啥大问题，如果是上面说的那种逆向的拓扑排序的话其实有点贪心的意思。

#include<queue>
#include<stdio.h>
#include<string.h>

#define N_node 200 + 10
#define N_edge 40000 + 400

using namespace std;

typedef struct
{
    int to ,next;
}STAR;

typedef struct NODE
{
    int x;
    friend bool operator < (NODE a, NODE b)
    {
        return a.x < b.x;
    }
}NODE;

STAR E[N_edge];
int s_x[N_node] ,in[N_node];
int list[N_node] ,tot;
NODE xin ,tou;


void add(int a ,int b)
{
    E[++tot].to = b;
    E[tot].next = list[a];
    list[a] = tot;
}

bool Sort_TP(int n)
{
    priority_queue<NODE>q;
    for(int i = 1 ;i <= n ;i ++)
    if(!in[i])
    {
        xin.x = i;
        q.push(xin);
    }
    int nowsort = n;
    while(!q.empty())
    {
        tou = q.top();
        q.pop();
        s_x[tou.x] = nowsort --;
        for(int k = list[tou.x] ;k ;k = E[k].next)
        {
            xin.x = E[k].to;
            if(!--in[xin.x]) q.push(xin);
        }
    }
    return nowsort == 0;
}

int main ()
{
    int t ,n ,m ,i ,a ,b;
    scanf("%d" ,&t);
    while(t--)
    {
        scanf("%d %d" ,&n ,&m);
        memset(list ,0 ,sizeof(list)) ,tot = 1;
        memset(in ,0 ,sizeof(in));
        for(i = 1 ;i <= m ;i ++)
        {
            scanf("%d %d" ,&a ,&b);
            add(b ,a);
            in[a] ++;
        }
        if(Sort_TP(n))
        {
            for(i = 1 ;i <= n ;i ++)
            if(i == n) printf("%d\n" ,s_x[i]);
            else printf("%d " ,s_x[i]);
        }
        else
        {
            printf("-1\n");
            continue;
        }
    }
    return 0;
}