Leetcode 269. Alien Dictionary

Problem:

There is a new alien language which uses the latin alphabet. However, the order among letters are unknown to you. You receive a list of non-empty words from the dictionary, where words are sorted lexicographically by the rules of this new language. Derive the order of letters in this language.

Example 1:

Input:
[
  "wrt",
  "wrf",
  "er",
  "ett",
  "rftt"
]

Output: "wertf"

Example 2:

Input:
[
  "z",
  "x"
]

Output: "zx"

Example 3:

Input:
[
  "z",
  "x",
  "z"
] 

Output: "" 

Explanation: The order is invalid, so return "".

Note:

1. You may assume all letters are in lowercase.
2. You may assume that if a is a prefix of b, then a must appear before b in the given dictionary.
3. If the order is invalid, return an empty string.
4. There may be multiple valid order of letters, return any one of them is fine.

Solution:

这道题可以分为两部分。

1. 根据单词之间的关系构建拓扑图

　　以第一个例子为例，对每对相邻的两个字符串提取拓扑关系，如“wrt"和"wrf"，找到两个字符串第一个不相同的字符，将t->f插入哈希表，以此类推。注意如果第一个字符串是第二个字符串添加后缀组成的话，则可以直接返回空，如”wrt“和”wr“，因为它不存在拓扑排序的可能性。

2. 利用BFS得到结果

　　这一步是算法核心，难点在于我们不知道哪个字符才是起始点。所以先用一个indegree数组计算每个出现过的字符的入度，如果为0则可以断定它必为起始点，则将它插入队列中，注意可能存在多个起始点。然后利用BFS和第一步得到的拓扑关系，每推出一个字符就将这个字符的所有出度推入队列，如果发现推入的字符已经访问过，则必然存在环，输出空。注意可能存在这种情况，a->b,c->b，如果简单的将出度推入队列则b会推入两次，所以我们只有在indegree['b']为0时才推入队列，否则自减1。

Code:

class Solution {
public:
    string alienOrder(vector<string>& words) {
        if(words.size() == 0) return "";
        if(words.size() == 1) return words[0];
        unordered_map<char,vector<char>> graph;
        vector<bool> allchar(128,false);
        for(int i = 1;i != words.size();++i){
            string str1 = words[i-1];
            string str2 = words[i];
            int p1 = 0;
            int p2 = 0;
            for(char c:str1) allchar[c] = true;
            for(char c:str2) allchar[c] = true;
            while(p1 != str1.size() && p2 != str2.size() && str1[p1] == str2[p2]){
                p1++;
                p2++;
            }
            if(p1 != str1.size() && p2 != str2.size())
                graph[str1[p1]].push_back(str2[p2]);
            else{
                if(p2 == str2.size() && str1.size() > str2.size())
                    return "";
            }
        }
        
        vector<int> indegree(128,0);
        for(auto iter:graph){
            vector<char> v = iter.second;
            for(char c:v)
                indegree[c]++;
        }
        
        string result = "";
        queue<char> q;
        vector<bool> visited(128,false);
        for(int i = 0;i != 128;++i){
            if(allchar[i] && indegree[i] == 0){
                q.push(i);
            }
        }
        while(!q.empty()){
            char front = q.front();
            q.pop();
            result = result+front;
            visited[front] = true;
            if(graph.find(front) != graph.end()){
                for(int i = 0;i != graph[front].size();++i){
                    if(visited[graph[front][i]]) return "";
                    indegree[graph[front][i]]--;
                    if(indegree[graph[front][i]] == 0)
                        q.push(graph[front][i]);
                }
            }
        }
        for(int i = 0;i != 128;++i){
            if(indegree[i] != 0)
                return "";
        }
        return result;
    }
};