Leetcode之 剑指 Offer II 114. 外星文字典

题目：

现有一种使用英语字母的外星文语言，这门语言的字母顺序与英语顺序不同。

给定一个字符串列表 words ，作为这门语言的词典，words 中的字符串已经 按这门新语言的字母顺序进行了排序 。

请你根据该词典还原出此语言中已知的字母顺序，并 按字母递增顺序 排列。若不存在合法字母顺序，返回 "" 。若存在多种可能的合法字母顺序，返回其中 任意一种 顺序即可。

字符串 s 字典顺序小于 字符串 t 有两种情况：

在第一个不同字母处，如果 s 中的字母在这门外星语言的字母顺序中位于 t 中字母之前，那么 s 的字典顺序小于 t 。
如果前面 min(s.length, t.length) 字母都相同，那么 s.length < t.length 时，s 的字典顺序也小于 t 。

示例 1：

输入：words = ["wrt","wrf","er","ett","rftt"]
输出："wertf"
示例 2：

输入：words = ["z","x"]
输出："zx"
示例 3：

输入：words = ["z","x","z"]
输出：""
解释：不存在合法字母顺序，因此返回 "" 。

提示：

1 <= words.length <= 100
1 <= words[i].length <= 100
words[i] 仅由小写英文字母组成

代码：

class Solution {
public:
    string alienOrder(vector<string>& words) {

    
    int wn=(int) words.size();
    int gID=0;

    //给字母编号
    unordered_map<char,int> char_ID;
    unordered_map<int,char> ID_char;

    for(string& word:words){
        for( char &c: word){
            if(char_ID.find(c)==char_ID.end()){
                char_ID[c]=gID;
                ID_char[gID]=c;
                gID++;
            }
        }
    }

    int N=gID;

    unordered_map<int,unordered_set<int>> adjvex;
    for(int i=0;i<wn;i++){
        string wi=words[i];
        for(int j=i+1;j<wn;j++){
            string wj=words[j];
            for(int k=0;k<min((int)wi.size(),(int)wj.size());k++){
                if(wi[k]!=wj[k]){
                    int IDi=char_ID[wi[k]];
                    int IDj=char_ID[wj[k]];
                    adjvex[IDi].insert(IDj);
                    break;
                }
            }
        }

    }

    //统计入度
    int indegree[N];
    memset(indegree,0, sizeof(indegree));
    for(auto & [x,ys] :adjvex){
        for(int y:ys){
            indegree[y]++;
        }
    }

    //--topsort()-bfs
    vector<int> path;
    queue<int> q;
    for(int x=0;x<N;x++){
        if(indegree[x]==0)q.push(x);
    }
    while(!q.empty()){
        int x=q.front();q.pop();
        path.push_back(x);
        for(int y:adjvex[x]){
            indegree[y]--;
            if(indegree[y]==0){
                q.push(y);
            }
        }
    }

    //看是否输出了所有的点，有没有环
    if((int)path.size()!=N){
        return "";
    }

    bool has_reverse= false;
    for(int i=0;i<wn;i++){
        if(has_reverse== true)break;
        string wi=words[i];
        for(int j=i+1;j<wn;j++){
            string wj=words[j];
            int win=(int)wi.size();
            int wjn=(int)wj.size();
            if(win>wjn and wi.substr(0,wjn)==wj){
                has_reverse= true;
                break;
            }
        }
    }

    if(has_reverse== true){
        return "";
    }

    string res="";
    for(int ID:path){
        res.push_back(ID_char[ID]);
    }
    return res;
}
};

思路：

统计出现过的每个字母，给他们一个编号；按照字母的顺序，遍历邻接的字母，插入建立邻接图；统计入度；进行拓扑排序，得出结果；如果最后的结果长度不等于N，那么返回""；最后需要检查原来给的列表是否是字典序，如果不是，返回""；否则，返回统计的结果；