codeforces 825E Minimum Label 拓扑排序+逆向思维贪心

题目描述：

给定n个点，m条边(2 <= n <= 1e5 , 1 <= m <= 1e5)的有向无环图，图中无自环、无重边，图不保证连通，现要求给1——n的每一个点编号，要求满足以下三个条件

（1）对1到n的编号是一个1到n的排列

（2）如果存在一条边由点u指向点v，那么要求给u的编号小于给v的编号

（3）将为1——n的编号写成一排，这个排列的字典序最小

现在要求输出这个编号的排列

思路：

很容易产生一种想法，就是对这张图进行拓扑排序，拓扑排序的时候每次从入度为0的点当中选出一个编号最小的，然后为他赋当前的最小编号，然后继续进行直至每个点都有编号。实际上，这个贪心的方法是错的，比如例子

4 2

4 1

2 3

如果按照上述思路，输出结果为4 1 2 3，但是实际上答案为2 3 4 1，那么为什么会出错呢？因为我们要求字典序最小，所以有可能为了把某一个编号最小的点“解锁”出来，在入度为0中的点必须要先选一个编号大的。就像例子中的，为了让1的编号尽量小，不是先选择2，而是先选择4。

那么正确思路是怎么样的呢？

在读入的时候，应当反向建图，也就是说如果u到v有一条边，那么我就建一条v到u的边，然后对图进行拓扑排序的过程，在当前入度为0的所有点中，选出编号最大的一个，然后为他赋当前最大的编号，然后不断重复这个过程直到所有点都被编号。

这样为什么是对的呢？

直观上来想确实和一开始错的思路好像没什么两样，但仔细一想会发现，正确的做法不存在需要“解锁”的问题，所以可以顺着编号：

在错误的做法当中，举个例子，我可能为了让2的编号尽量小，不惜先为比较大的点编上比较小的号，这样起码让2的编号小了；

在正确的做法当中，相类似的，我需不需要为了让8的编号（假设一共9个点）的编号尽量大，而不惜为一些比较小的点编上比较大的号呢？不会，为比较小的点编上比较大的号，显然字典序变大，这样就得不偿失了。

综上，后一种方案是正确的。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#define mem(a,x) memset(a,x,sizeof(a))
#define lson l,m,x<<1
#define rson m+1,r,x<<1|1
using namespace std;
const int maxn = 1e5 + 5;
vector<int>G[maxn];
int n , m , d[maxn] , label[maxn], vis[maxn];
void toposort()
{
    priority_queue<int>Q;
    for(int i= 1 ; i <= n ;i++){
        if(!d[i] && !vis[i]){
            vis[i] = 1;
            Q.push(i);
        }
    }
    int cnt = n;
    while(!Q.empty()){
        int f = Q.top();    Q.pop();
        label[f] = cnt--;
        for(int i = 0 ; i < G[f].size() ; i++){
            int to = G[f][i];--d[to];
            if(!d[to] && !vis[to]){
                vis[to] = 1;
                Q.push(to);
            }
        }
    }
}
int main()
{
    int u , v;
    scanf("%d %d" , &n , &m);
    mem(vis , 0);
    for(int i = 1 ; i <= m ; i++){
        scanf("%d %d" , &u , &v);
        G[v].push_back(u);
        ++d[u];
    }
    toposort();
    for(int i = 1 ; i <= n ;i++){
        printf("%d " , label[i]);
    }
    puts("");
    return 0;
}