127. Word Ladder

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

1. Only one letter can be changed at a time.
2. Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.
• You may assume no duplicates in the word list.
• You may assume beginWord and endWord are non-empty and are not the same.

Example 1:

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Example 2:

Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

void getNeighbors(string word, vector<string>& neighbors,
                  unordered_set<string>& dictionary){
    neighbors.clear();
    int len = word.size();
    for(int i = 0; i < len; ++i){
        char t = word[i];
        for(char c = 'a'; c <= 'z'; ++c){
            if(c != t){
                word[i] = c;
                if(dictionary.count(word)){
                    neighbors.emplace_back(word);
                }
            }
        }
        word[i] = t;
    }
}

int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
    if(find(wordList.begin(), wordList.end(), endWord) == wordList.end())   return 0;
    unordered_set<string> preList, tailList, blockList, nextList;
    unordered_set<string> *smallList, *largeList;
    unordered_set<string> dictionary(wordList.begin(), wordList.end());
    dictionary.emplace(beginWord);
    preList.emplace(beginWord);
    tailList.emplace(endWord);
    int step = 1;
    while(preList.size() && tailList.size()){
        if(preList.size() < tailList.size()){
            smallList = &preList;
            largeList = &tailList;
        }
        else {
            smallList = &tailList;
            largeList = &preList;
        }
        step++;
        for(auto word : *smallList){
            vector<string> neighbors;
            getNeighbors(word, neighbors, dictionary);
            for(auto it : neighbors){
                if(largeList->count(it))  return step;
                if(blockList.count(it)) continue;
                nextList.emplace(it);
                blockList.emplace(it);
            }
        }
        smallList->clear();
        swap(*smallList, nextList);
        nextList.clear();
    }
    return 0;
}