LeetCode-Word Ladder

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:

Code:

<span style="font-size:14px;">class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        if (start == end) return 1;
        const int lengthDict = dict.size();
        if (lengthDict == 0) return 0;
        const int lengthStr = start.size();
        vector<queue<string> > v(2, queue<string>());
        int index = 0, count = 0;
        v[index].push(start);
        while (!v[index].empty() && !dict.empty()) {
            count++;
            while (!v[index].empty() && !dict.empty()) {
                start = v[index].front();
                v[index].pop();
                if (start == end) return count;
                for (int i = 0; i < lengthStr; ++i)
                    for (char c = 'a'; c <= 'z'; ++c)
                        if (start[i] != c) {
                            char copy = start[i];
                            start[i] = c;
                            if (start == end) return count+1;
                            if (dict.find(start) != dict.end()) {
                                dict.erase(start);
                                v[(index+1)%2].push(start);
                            }
                            start[i] = copy;
                        }
            }
            index = (index+1)%2;
        }
        return 0;
    }
};</span>