[LeetCode] Word Ladder

Given two words (beginWord and endWord), and a dictionary, 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 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: BFS with QUEUE! 

class Solution {
public:
    struct WordNode{
        string word;
        int level;
        WordNode(string word, int level):word(word),level(level){}
    };
    
    int ladderLength(string beginWord, string endWord, unordered_set<string>& wordDict) {
        queue<WordNode> bfs;
        WordNode node(beginWord,1);
        bfs.push(node);
        unordered_set<string> used;
        
        while(!bfs.empty())
        {
            string word = bfs.front().word;
            int level = bfs.front().level;
            bfs.pop();
            //enqueue 1-length transformation from the queue header word
            for(int i=0;i<word.length();i++)
            {
                for(char sub = 'a'; sub <= 'z'; sub++)
                {
                    if(sub==word[i]) continue;
                    string subword=word;
                    subword[i]=sub;
                    if(subword == endWord) return level+1;
                    if( wordDict.find(subword)!=wordDict.end() && used.find(subword)==used.end())
                    {
                        used.insert(subword);
                        WordNode newnode(subword,level+1);
                        bfs.push(newnode);
                    }
                }
            }
        }
        return 0;
    }
};