搜索和简单图论 B - Sorting It All Out

B - Sorting It All Out

题解

不同值的升序排序序列是这样的序列，其中使用某种形式的小于运算符将元素从最小到最大排序。 例如，排序的序列A，B，C，D表示A <B，B <C和C <D。在此问题中，我们将为您提供一系列形式为A <B的关系，并请您确定 是否已指定排序顺序。
来自谷歌翻译

可知，我们需要判断所给的字符串是否可以构成拓扑排序。

1. 可以：输出顺序及确定顺序时的字符串的序号；
2. 不可以：
   1. 由于构成环导致不能， 输出构成环的字符串的序号；
   2. 无法判断导致不能， 输出。

第一遍的时候我以为是这样：

这里入度为0必有环的前提是入度数组初始化为-1。判断是否全部参与时使用了set集合。
对于多个的情况直接输出了待定， 导致错误。
比如，这个例子：

A<B
C<D
D<E
E<F

虽然有多个入度，但是是有环的。所以在这种情况下我们还是需要判断一下。
改正错误后如下：

不得不说，这个代码写的是……真的烂。
不过思路还是可以的吧hhhhh

AC代码

#include <iostream>
#include <queue>
#include <cstring>
#include <set>
#include <vector>
#include <string>
//#pragma GCC optimize(2)
#define IO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ull unsigned long long
#define ll long long
#define rep(i, x, y) for(int i=x;i<=y;i++)
#define mms(x, n) memset(x, n, sizeof(x))
#define mmc(a, b) memcpy(a, b, sizeof(b))
#define pre(i, x, y) for(int i = x; i >=y; i--)
#define INF (0x3f3f3f3f)
#define mod (ull)(1e9+7)

using namespace std;
const int N = 30;
vector<int> G[N];
int n, m;
int in[N], inn[N];
int ans;
int flag;
set<int> st;
vector<char> ch;

int tp(int t) {
    //init
    int cnt = 0;
    ch.clear();
    mmc(inn, in);
    //judge
    queue<int> q;
    rep(i, 0, n) {
        if (inn[i] == 0) {
            cnt++;
            q.push(i);
        }
    }
    if (cnt == 0) {
        ans = t;
        return -1;
    } else if (cnt > 1) {
        while (!q.empty()) {
            int x = q.front();
            ch.push_back(char('A' + x - 1));
            q.pop();
            bool f = true;
            for (int i = 0; i < G[x].size(); i++) {
                int y = G[x][i];
                inn[y]--;
                if (inn[y] == 0) {
                    if (!f) {
                        return 0;
                    } else {
                        cnt++;
                        q.push(y);
                        f = false;
                    }
                }
            }
        }
        if (cnt < st.size()) {
            ans = t;
            return -1;
        } else return 0;
    } else if (cnt == 1) {
        while (!q.empty()) {
            int x = q.front();
            ch.push_back(char('A' + x - 1));
            q.pop();
            bool f = true;
            for (int i = 0; i < G[x].size(); i++) {
                int y = G[x][i];
                inn[y]--;
                if (inn[y] == 0) {
                    if (!f) {
                        return 0;
                    } else {
                        cnt++;
                        q.push(y);
                        f = false;
                    }
                }
            }
        }
        if (cnt == st.size()) {
            if (st.size() == n) {
                ans = t;
                return 1;
            }
            return 0;
        } else if (cnt < st.size()) {
            ans = t;
            return -1;
        }
    }
}

int main() {
    IO;
    while (cin >> n >> m && (n || m)) {
        // init
        rep(i, 0, n) G[i].clear();
        set<string> ss;
        mms(in, -1);
        flag = 0;
        st.clear();
        ans = 0;
        // judge
        rep(i, 1, m) {
            string s;
            cin >> s;
            if (flag == 1 || flag == -1) continue;
            if (ss.find(s) != ss.end()) continue;
            ss.insert(s);
            int a = s[0] - 'A' + 1, b = s[2] - 'A' + 1;
            st.insert(a);
            st.insert(b);
            in[a] = in[a] == -1 ? 0 : in[a];
            in[b] = in[b] == -1 ? 0 : in[b];
            in[b]++;
            if (a == b) {
                flag = -1;
                ans = i;
            } else {
                G[a].push_back(b);
                flag = tp(i);
            }
        }
        if (flag == 1) {
            cout << "Sorted sequence determined after " << ans << " relations: ";
            rep(i, 0, ch.size() - 1) {
                cout << ch[i];
            }
            cout << "." << endl;
        } else if (flag == -1) {
            cout << "Inconsistency found after " << ans << " relations." << endl;
        } else if (flag == 0) {
            cout << "Sorted sequence cannot be determined." << endl;
        }
    }
    return 0;
}

Tips

一定要仔细读题啊!!!
错以为题目意思是以最后的结果为准,做了很久还wa了TAT.
wa的时候多考虑一下判断条件！