Fox And Names CodeForces

题意：新定义题，重新定义了字典序的概念（ 即 a不一定小于b），已的n个单词是按 新字典序 从小到大排序的，求重新定义字典序的字母顺序。如果先后有矛盾输出  “Impossible”。

思路：先把前缀一致的过滤，剩下将路径存入数组，并记录每个字母的入度；

最后拓扑排序：若是不按照26原始字母顺序来，可以直接先将入度为0的全部放入队列并记录答案p[t++]，再对队列里的字母开始出队且删除与之有关的边，若删除后，那个字母的入度为0，则可进入队列，答案p[t++]，若入度不为0，则不操作。最后若答案长度小于26，说明有环，否则成功输出p数组。

#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
#include <bitset>
#include<set>
#include<map>
#include<unordered_map>
#include<vector>
#include<cmath>
#include<string>
#include<string.h>
using namespace std;
typedef long long ll;
typedef pair<ll, int> pa;
typedef unsigned long long ull;
char s[105][105];
int f[50], mapp[50][50], len[105];
char p[1001];//存储拓扑排序结果；
void tp() {
    int i, j, t = 0;
    queue<int>q;
    for (i = 0; i < 26; i++){//从小到大找出全部入度为0的字母
        if (!f[i]){
            q.push(i);
            p[t++] = i + 'a';
        }
    }
    while (!q.empty()){//进行拓扑排序
        int k = q.front();
        q.pop();
        for (i = 0; i < 26; i++){
            if (mapp[k][i] == 1){
                f[i]--;
                if (f[i] == 0){//直到入度为0才可以进去队列
                    q.push(i);
                    p[t++] = i + 'a';
                }
            }
        }
    }
    if (t < 26){
        printf("Impossible
");
    }
    else{
        p[t] = '';
        printf("%s
", p);
    }
    return;
}

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> s[i];
        len[i] = strlen(s[i]);
    }
    int flag = 0;
    for (int i = 0; i < n - 1; i++) {
        int len1 = len[i];
        int len2 = len[i + 1];
        int lenm = min(len1, len2);
        int k, a = 0;
        //最多比较到较短的单词结束
        for (k = 0; k < lenm; k++) {
            if (s[i][k] != s[i+1][k]) {
                a = 1;
                if (!mapp[s[i][k] - 'a'][s[i+1][k] - 'a']) {//没有出现过这两个字母的连接
                    mapp[s[i][k] - 'a'][s[i + 1][k] - 'a'] = 1;
                    f[s[i + 1][k] - 'a']++; //入度+1，相当于在它前面还有一个字母
                }
                break;
            }
        }
        if (!a) {//若是两个单词中某个是前缀必须是len1
            if (k != len1) {
                flag = 1;
                break;
            }
        }
        if (flag) {
            break;
        }
    }
    if (flag) {
        printf("Impossible
");
    }
    else {
        tp();
    }
    return 0;
}

若是按照26字母原始顺序，则遍历每次取出第一个入度为0的字母，依次删除与之有关的边，入度为负记录答案num[cns++],再取出第一个入读为0的边，直到在26次循环中某一次没有找到入度为0的边，说明有环。代码参考：https://blog.csdn.net/qq_41890797/article/details/81742221

void tp()  //拓扑排序的核心代码
{
    int p,flag,cns=0;
    for(int i=0; i<26; i++)
    {
        int flag=0;
        for(int j=0; j<26; j++)
        {
            if(!f[j])  //此时这个字母是最小的
            {
                p=j;
                flag=1;
                break;
            }
        }
        if(!flag) //没有可确定的字母，矛盾了
        {
            printf("Impossible
");
            return;
        }
        f[p]--;
        num[cns++]=p+'a';
        for(int j=0; j<26; j++)
            if(map[p][j])
                f[j]--;    //与p为前端的入度-1
    }
    num[cns]=0;//加 ‘/0’
    puts(num);
}