面试题39：词语阶梯

　　Leetcode中出现了两道词语阶梯的题目，大意是将一个词语将通过字典里面的词语，最终转换到目标词语，每次只能更改一个字符。两道题分别是求最少的转换次数和寻找最短的转换路径。词语阶梯是典型的BFS的题目，但是寻找转换路径的时候单纯的BFS会出现超时的问题，需要增加优化策略。优化策略是删除字典中BFS中上一层访问过的词语，因为它们如果出现在之后的BFS中，将不会是最短路径了。编程中通过unordered_set<string> visited，保存上一层BFS中访问过的词语。

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the dictionary

For example,

Given:
start ="hit"
end ="cog"
dict =["hot","dot","dog","lot","log"]

As one shortest transformation is"hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length5.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        
        queue<string> q;
        q.push(start);
        unordered_set<string> visited;
        visited.insert(start);
        int depth = 1;
        
        while (!q.empty()) {
            for(string word : visited){
                dict.erase(word);
            }
            visited.clear();
            depth++;
            int q_size = q.size();
            for (int i = 0; i < q_size; i++) {
                string word = q.front();
                q.pop();

                for (int i = 0; i < word.size(); i++) {
                    string newWord = word;
                    for (char ch = 'a'; ch <= 'z'; ch++) {
                        newWord[i] = ch;
                        if(dict.count(newWord) == 0) continue;
                        if(newWord == end) return depth;
                        else{
                            visited.insert(newWord);
                            q.push(newWord);
                        }
                    }
                }
            }
            
            
        }
        return 0;
    }
};

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from startto end, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the dictionary

For example,

Given:
start ="hit"
end ="cog"
dict =["hot","dot","dog","lot","log"]

Return

  [
    ["hit","hot","dot","dog","cog"],
    ["hit","hot","lot","log","cog"]
  ]

Note:

• All words have the same length.
• All words contain only lowercase alphabetic characters.

class Solution {
public:
    vector<vector<string>> findLadders(string start, string end,
            unordered_set<string> &dict) {
        queue<vector<string>> q;
        vector<string> path { start };
        q.push(path);
        vector<vector<string>> res;
        unordered_set<string> visited;
        int level = 1, minLevel = INT_MAX;
        while (!q.empty()) {
            vector<string> path = q.front();
            q.pop();
            if (path.size() > level) {
                for (string w : visited)
                    dict.erase(w);
                visited.clear();
                level = path.size();
                if(level >= minLevel) break;
            }
            string word = path.back();
            for (size_t i = 0; i < word.size(); i++) {
                string newWord = word;
                for (char ch = 'a'; ch <= 'z'; ch++) {
                    newWord[i] = ch;
                    if (!dict.count(newWord)) continue;
                    if (newWord == end){
                        path.push_back(newWord);
                        minLevel = path.size();
                        res.push_back(path);
                        path.pop_back();
                        break;
                    } else if (dict.count(newWord)
                            && find(path.begin(), path.end(), newWord)
                                    == path.end()) {
                        visited.insert(newWord);
                        path.push_back(newWord);
                        q.push(path);
                        path.pop_back();
                    }
                }
            }
        }
        return res;
    }
};