HDU 1811 Rank of Tetris

传送门

给定点之间的关系，让你判断序列是否唯一或者非法。
注意的是 点之间相等的话总是可以根据另一种关系排序，所以如果某些点相等的话就不用考虑他们之间的关系了（他们之间的排序是唯一且固定的），而且他们在总排序上是连续的。
所以相等的一些点可以看成一个连通分量，采取“缩点”的思想，他们可以由其中的一个点代表。
所以问题就是，怎么判断有环（也是非法的一种），怎么判断不唯一，怎么判断“绝对非法”（就是A=B A>B或者A>A这种，可以归结为连通分量内不能再有大小关系）。
需要注意的是，这里判环是有向图，所以可以用拓扑排序，可以判断各种环（有环连通图、有环不连通图），入队列的都是每个连通分量的代表，判断出队的个数与连通分量的个数即可。至于怎样判断不唯一，当某次队列中存在的点个数大于1时，实际上这时候已经造成排序不唯一了，因为这几个点的次序无法确定！而且这个方法也顺便把不连通给判断了（想象一下，若不连通且没环，则一开始队列就会入至少两个点吧）。
当然，有一种情况：A=B B>C A>C 这种情况是正确的（若A，B合为A，A的边表里有两个C，在A出队列时会遍历它的每一条边（两个C），相当于替B遍历了一个，实际上相当于这时候B也出去了，所以C的入度会降为0，没有问题）。

#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;

const int MAXN = 1e4 + 10;
int N, M;
int pre[MAXN];

struct Edge
{
    int from, to;
};
vector<Edge> ve;
vector<int> v[MAXN];
int indegree[MAXN];
int flag;

int f(int x)
{
    int f0 = x, f1 = x;
    for (; pre[f0] >= 0;)
        f0 = pre[f0];
    for (; pre[f1] >= 0;)
    {
        int t = f1;
        f1 = pre[f1];
        pre[t] = f0;
    }
    return f0;
}

void u(int n1, int n2)
{
    int f1 = f(n1);
    int f2 = f(n2);
    if (f1 != f2)
    {
        if (pre[f1] <= pre[f2])
        {
            pre[f1] += pre[f2];
            pre[f2] = f1;
        }
        else
        {
            pre[f2] += pre[f1];
            pre[f1] = f2;
        }
    }
}

void topological()
{
    int points = 0;
    int q_times = 0;
    queue<int> q;
    for (int i = 0; i < N; i++)
    {
        if (pre[i] < 0)             ////////
        {
            points++;
            if (!indegree[i])
                q.push(i);
        }
    }
    if (q.empty())          // 全图就是一个大环，这里只是提前判断一下
    {
        flag = 1;
        return;
    }
    for (; !q.empty();)
    {
        if (q.size() > 1) flag = 2;         // 若不连通这里一定会揪出来
        int t = q.front(); q.pop();
        q_times++;
        for (int i = 0; i < v[t].size(); i++)
        {
            indegree[v[t][i]]--;
            if (!indegree[v[t][i]]) q.push(v[t][i]);
        }
    }
    if (points != q_times) flag = 1;
}

int main()
{
    int a, b;
    char c;
    for (; ~scanf("%d%d", &N, &M);)
    {
        memset(pre, -1, sizeof pre);
        ve.clear();
        flag = 0;
        for (int i = 0; i < N; i++)
        {
            v[i].clear();
            indegree[i] = 0;
        }
        for (int i = 0; i < M; i++)
        {
            scanf("%d %c %d", &a, &c, &b);
            if (c == '=') u(a, b);
            else if (c == '>') ve.push_back({ a,b });
            else if (c == '<') ve.push_back({ b,a });
        }
        for (int i = 0; i < ve.size(); i++)
        {
            int n1 = f(ve[i].from);
            int n2 = f(ve[i].to);
            if (n1 == n2)
            {
                printf("CONFLICT\n");
                flag = 1;
                break;
            }
            v[n1].push_back(n2);
            indegree[n2]++;
        }
        if (flag) continue;
        topological();
        if (flag == 1) printf("CONFLICT\n");
        else if (flag == 2) printf("UNCERTAIN\n");
        else printf("OK\n");
    }

    return 0;
}