洛谷 P1347 排序

Description

一个不同的值的升序排序数列指的是一个从左到右元素依次增大的序列，例如，一个有序的数列 $A,B,C,D$ 表示$A<B,B<C,C<D$。在这道题中，我们将给你一系列形如 $A<B$ 的关系，并要求你判断是否能够根据这些关系确定这个数列的顺序。

Input

第一行有两个正整数 $n,m$，$n$ 表示需要排序的元素数量，$2\le n\le 26$，第 $1$ 到 $n$ 个元素将用大写的 $A,B,C,D\dots$ 表示。$m$ 表示将给出的形如 $A<B$ 的关系的数量。

接下来有 $m$ 行，每行有 $3$ 个字符，分别为一个大写字母，一个 < 符号，一个大写字母，表示两个元素之间的关系。

Output

若根据前 $x$ 个关系即可确定这 $n$ 个元素的顺序 yyy..y（如 ABC），输出

Sorted sequence determined after xxx relations: yyy...y.

若根据前 $x$ 个关系即发现存在矛盾（如 $A<B,B<C,C<A$），输出

Inconsistency found after x relations.

若根据这 $m$ 个关系无法确定这 $n$ 个元素的顺序，输出

Sorted sequence cannot be determined.

（提示：确定 $n$ 个元素的顺序后即可结束程序，可以不用考虑确定顺序之后出现矛盾的情况）

Solution

1.明确判定条件

依题意得，

无法确定顺序的优先级最低（至少也要遍历完m个关系），最后才考虑；

对于存在矛盾关系，不难看出即为存在环，该情况下环内元素将无法得到遍历，此时拓扑排序的长度也不等于所给定的元素总个数，将拓扑排序结果存放于vector<int>ans中，判定存在矛盾即为ans.size() != n；

若ans.size() == n，即拓扑排序存在，还需要判断该拓扑排序是否唯一，

判定方法：判定是否存在某一时刻，用于拓扑排序的队列的长度不为1，若不为1，证明当前有多个入度为0的点可供选择遍历，故拓扑排序不唯一。

若唯一，直接输出答案即可。

2.整体思路

一边读入关系一边进行一次拓扑排序，方便找到遍历了前x个关系时，唯一拓扑排序或存在环的情况出现的x值。

3.复杂度估算

时间复杂度：

拓扑排序$O(n+m)$ ，共遍历m次，总时间复杂度$O(m(n+m))$

空间复杂度：

开了个邻接矩阵，$O(n^2)$

Code

#include <bits/stdc++.h>

#define MOD 1000000007
using namespace std;

int n, m;
string s;

vector<int> graph[105]; //邻接矩阵
int ind[30];            //入度表
vector<int> ans;        //拓扑后的结果

int topo()
{
    ans.clear();

    bool flag = false;
    // 复制入度表
    int rudu[30] = {0};
    for (int i = 1; i <= 26; i++)
        rudu[i] = ind[i];

    queue<int> q;
    //将起点压进队列
    for (int i = 1; i <= n; i++)
    {
        if (rudu[i] == 0)
            q.push(i);
    }
    while (!q.empty())
    {
        // 同一时间存在多个入度为0的点，造成拓扑排序的不唯一
        // 此处不可直接返回0，因为尚未判定是否存在拓扑排序
        if (q.size() > 1)
            flag = true;

        int u = q.front();
        q.pop();

        //将队列头元素压进答案
        ans.push_back(u);
        //找有向边的另一点，将其入度-1（删除掉该有向边），若该点入度为0则压进队列
        for (int v = 0; v < graph[u].size(); v++)
        {
            int point = graph[u][v];

            rudu[point]--;

            if (rudu[point] == 0)
                q.push(point);
        }
    }

    // 存在环，有部分点没有遍历到
    if (ans.size() != n)
        return -1;
    // 拓扑排序不唯一
    if (flag)
        return 0;
    // 拓扑排序唯一
    return 1;
}

void solve()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        cin >> s;

        int u = s[0] - 'A' + 1, v = s[2] - 'A' + 1;

        graph[u].push_back(v);
        ind[v]++;

        int judge = topo();

        // 存在环(包括自环)
        if (judge == -1)
        {
            cout << "Inconsistency found after " << i << " relations.";
            return;
        }
        // 能确定唯一顺序
        else if (judge == 1)
        {
            cout << "Sorted sequence determined after " << i << " relations: ";
            for (int i = 0; i < ans.size(); i++)
            {
                char tmp = ans[i] + 'A' - 1;
                cout << tmp;
            }
            cout << ".";
            return;
        }
    }

    // 无法决定唯一顺序
    cout << "Sorted sequence cannot be determined.";
}

int main(void)
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    solve();

    return 0;
}