ACM/ICPC 之 拓扑排序-反向(POJ3687)

难点依旧是题意。。。。需要反向构图+去重+看题

---

POJ3687-Labeling Balls

　　题意：1-N编号的球，输出满足给定约束的按原编号排列的重量序列，如果有多组答案，则输出编号最小的Ball重量最轻，若依旧多组则输出编号次小的Ball重量最轻的方案。

　　题解：在看懂题意后，再开始做会省很多时间。。。曲解题意还真是人类的本能啊。

　　　　　为了完成单向关系排序，需要用到拓扑排序；

　　　　　为了符合编号最小的重量最轻...的题意，需要用到反向拓扑排序；

　　　　　输入可能会有重复的关系，因此需要判重；

　　　　　输出需要按原编号输出其重量，因此需要在每个编号上标记其重量。

//给球编号
//1-N编号的球，输出满足给定约束的按原编号排列的重量序列，如果有多组答案，则输出编号越小重量越轻的方案
//反向拓扑+去重+看题...(题意最后需要将Ball的重量按原编号输出)
//迭代器判重：Time:125Ms    Memory:524K
//数组判重：  Time:63Ms    Memory:564K
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
using namespace std;

#define MAX 205

struct Number {
    vector<int>    light;
    int in;        //in_degree
    int weight;    //该编号球的重量
}num[MAX];

int n, m;
bool v[MAX][MAX];

bool TopSort()
{
    for (int t = n; t > 0; t--)    //最重到最轻
    {
        int cur = n + 1;
        while (--cur && num[cur].in);    //将最大的label先取出放在最后
        if (cur == 0) return false;    //有环

        num[cur].weight = t;    //记录重量
        num[cur].in--;
        for (unsigned j = 0; j < num[cur].light.size(); j++)
            num[num[cur].light[j]].in--;
    }
    return true;
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        memset(num, 0, sizeof(num));
        memset(v, false, sizeof(v));
        scanf("%d%d", &n, &m);
        for (int i = 0; i < m; i++)
        {
            int light, heavy;
            scanf("%d%d", &light, &heavy);
            //反向构图
            //迭代器判重
            //vector<int> lg = num[heavy].light;
            //if (find(lg.begin(), lg.end(), light) != lg.end())    continue;
            //数组判重
            if (v[heavy][light]) continue;
            v[heavy][light] = true;
            num[heavy].light.push_back(light);
            num[light].in++;
        }

        if (TopSort())
        {
            for (int i = 1; i < n; i++)
                printf("%d ", num[i].weight);
            printf("%d
", num[n].weight);
        }
        else printf("-1
");

    }
    
    return 0;
}