LeetCode

Word Ladder II

2014.2.13 01:23

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) 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"]

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.

Solution:

　　The solution for this problem is similar to Word Ladder, but you have to record the full paths.

　　I tried my own methods, but all got timed-out. At last I referred to others' code and saw the key difference from my code: when a word is visited, you have to remove it from the dictionary, because you never visit it again. This strategy makes the code run much faster.

　　Besides, the idea of solving this problem is still with BFS, but not in the form of queue-in or queue-out. You can do it with O(n) space and without a <queue>.

　　Total time complexity is O(n^2). Space complexity is O(n).

Accepted code:

// 9CE, 1TLE, 1WA, 1AC, O(n^2) will get you TLE, no matter time or space.
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;

class Solution {
public:
    vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict) {
        unordered_map<string, vector<string> > back_trace;
        vector<unordered_set<string> > level(2);
        
        dict.insert(start);
        dict.insert(end);
        
        int flag, nflag;
        flag = 0;
        nflag = !flag;
        level[flag].insert(start);
        
        unordered_set<string>::iterator usit;
        char ch, old_ch;
        string word;
        while (true) {
            flag = !flag;
            nflag = !nflag;
            level[flag].clear();
            for (usit = level[nflag].begin(); usit != level[nflag].end(); ++usit) {
                dict.erase(*usit);
            }
            for (usit = level[nflag].begin(); usit != level[nflag].end(); ++usit) {
                word = *usit;
                for (size_t i = 0; i < word.size(); ++i) {
                    old_ch = word[i];
                    for (ch = 'a'; ch <= 'z'; ++ch) {
                        if (ch == old_ch) {
                            continue;
                        }
                        word[i] = ch;
                        if (dict.find(word) != dict.end()) {
                            back_trace[word].push_back(*usit);
                            level[flag].insert(word);
                        }
                    }
                    word[i] = old_ch;
                }
            }
            if (level[flag].empty() || level[flag].count(end) > 0) {
                // found or not found
                break;
            }
        }
        
        single_result.clear();
        for (size_t i = 0; i < result.size(); ++i) {
            result[i].clear();
        }
        result.clear();
        
        if (!back_trace.empty()) {
            recorverPath(back_trace, end);
        }
        
        return result;
    }
private:
    vector<vector<string> > result;
    vector<string> single_result;
    
    void recorverPath(unordered_map<string, vector<string> > &back_trace, string cur) {
        if (back_trace.count(cur) == 0) {
            // this word has no back trace, it is unreachable.
            vector<string> single_path(single_result);
            
            single_path.push_back(cur);
            reverse(single_path.begin(), single_path.end());
            result.push_back(single_path);
            return;
        }
        
        const vector<string> &v = back_trace[cur];
        vector<string>::const_iterator usit;
        
        single_result.push_back(cur);
        for (usit = v.begin(); usit != v.end(); ++usit) {
            recorverPath(back_trace, *usit);
        }
        single_result.pop_back();
    }
};