题目：
现有一种使用英语字母的外星文语言，这门语言的字母顺序与英语顺序不同。
给定一个字符串列表 words ，作为这门语言的词典，words 中的字符串已经 按这门新语言的字母顺序进行了排序 。
请你根据该词典还原出此语言中已知的字母顺序，并 按字母递增顺序 排列。若不存在合法字母顺序，返回 “” 。若存在多种可能的合法字母顺序，返回其中 任意一种 顺序即可。
字符串 s 字典顺序小于 字符串 t 有两种情况：
在第一个不同字母处，如果 s 中的字母在这门外星语言的字母顺序中位于 t 中字母之前，那么 s 的字典顺序小于 t 。
如果前面 min(s.length, t.length) 字母都相同，那么 s.length < t.length 时，s 的字典顺序也小于 t 。

题解：
首先是建图，每个字母是一个顶点
如果字母 a 在 字母 b 前面，则生成一条 a 指向 b 的有向边

拓扑排序是在一个有向图中，对所有的节点进行排序，要求没有一个节点指向它前面的节点
这不刚好和题目意思相同

拓扑排序的思路就是
每次删除一个入度为 0 的点（没有其他点指向它）

如果最后入度都不为 0，则说明存在环，输出 “”

还有一种情况需要考虑
就是字符串 a 包含 字符串 b，且比字符串 b 长，但在字符串 b 前，例 “abc”，“ab”
这样也是输出 “”

代码如下：

class Solution {
    
    
public:
    string res = "";
    bool edge[26][26] = {
    
     false };
    bool flag[26] = {
    
     false };
    int point[26] = {
    
     0 };
    bool solve() {
    
    
        while(1) {
    
    
            int p = -1;
            for(int i = 0; i < 26; i++) {
    
    
                if(flag[i] == true && point[i] == 0) {
    
    
                    p = i;
                }
            }
            if(p == -1) break;
            flag[p] = false;
            res = res + char('a' + p);
            for(int i = 0; i < 26; i++) {
    
    
                if(edge[p][i] == true) {
    
    
                    point[i]--;
                }
            }
        }
        for(int i = 0; i < 26; i++) {
    
    
            if(flag[i] == true) {
    
    
                return false;
            }
        }
        return true;
    }
    string alienOrder(vector<string>& words) {
    
    
        for(int i = 0; i < words.size(); i++) {
    
    
            for(int j = 0; j < words[i].size(); j++) {
    
    
                flag[words[i][j] - 'a'] = true;
            }
            for(int j = i + 1; j < words.size(); j++) {
    
    
                for(int k = 0; k < words[i].size() && k < words[j].size(); k++) {
    
    
                    if(words[i][k] != words[j][k]) {
    
    
                        edge[words[i][k] - 'a'][words[j][k] - 'a'] = true;
                        break;
                    }
                    else if(k < words[i].size() - 1 && k == words[j].size() - 1) {
    
    
                        return "";
                    }
                }
            }
        }
        for(int i = 0; i < 26; i++) {
    
    
            for(int j = 0; j < 26; j++) {
    
    
                if(edge[i][j] == true) {
    
    
                    point[j]++;
                }
            }
        }
        if(solve()) return res;
        else return "";
    }
};