LeetCode

Word Ladder

2014.2.27 02:14

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 length 5.

Note:

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

Solution:

　　At first I tried to use Dijkstra's Algorithm on this problem, as I saw a graph in the words. But it proved to be unnecessary and inefficient.

　　Use BFS and queue instead and you'll make it.

　　One thing is very important: don't check if two words differ only by one letter, you should change one letter and see if it is still in the dictionary. This saves a lot of time.

　　Total time complexity is O(n^2). Space complexity is O(n). The constant factor is relatively large, so the algorithm is still expensive.

Accepted code:

// 7CE, 4RE, 4TLE, 1AC, BFS...
#include <queue>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        queue<pair<string, int> > qq;
        string word, next_word;
        unordered_map<string, int> um;
        char ch, old_ch;
        int result = 0;
        bool suc = false;
        pair<string, int> this_pair;
        
        qq.push(make_pair(start, 1));
        um[start] = 1;
        while (!qq.empty()) {
            this_pair = qq.front();
            qq.pop();
            word = this_pair.first;
            for (size_t i = 0; i < word.length(); ++i) {
                old_ch = word[i];
                for (ch = 'a'; ch <= 'z'; ++ch) {
                    word[i] = ch;
                    if (word == end) {
                        suc = true;
                        result = this_pair.second + 1;
                    }
                    if (um.find(word) == um.end() && dict.find(word) != dict.end()) {
                        qq.push(make_pair(word, this_pair.second + 1));
                        um[word] = this_pair.second + 1;
                    }
                }
                if (suc) {
                    break;
                }
                word[i] = old_ch;
            }
            if (suc) {
                break;
            }
        }
        while(!qq.empty()) {
            qq.pop();
        }
        return result;
    }
};