Leetcode -- 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 intermediate word must exist in the word list

For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["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.

分析：

1. 使用宽度优先搜索

2. 在扩展节点时对每个字母直接进行替换

3. 使用unordered_set进行查重

class Solution {
public:
    vector<string> extend_(string s,unordered_set<string>& wordList,unordered_set<string>& vis)
    {
        vector<string> res;
        for(int i=0;i<s.size();++i)
        {
            for(char c = 'a';c<='z';++c)
            {
                if(c==s[i]) continue;
                swap(s[i],c);
                if(wordList.count(s)>0&&vis.count(s)==0)
                {
                    res.push_back(s);
                    vis.insert(s);
                }
                swap(c,s[i]);
            }
        }
        return res;
    }
    int ladderLength(string beginWord, string endWord, unordered_set<string>& wordList) {
        queue<string> cur,next;
        unordered_set<string> vis;
        wordList.insert(beginWord);
        
        
        int level = 0;
        bool found = 0;
        cur.push(beginWord);
        while(!found&&!cur.empty())
        {
            level++;
            while(!found&&!cur.empty())
            {
                string str = cur.front();
                cur.pop();
                vector<string> states = extend_(str,wordList,vis);
                for(int i=0;i<states.size();++i)
                {
                    next.push(states[i]);
                    if(states[i]==endWord)
                    {
                        found = 1;
                        break;
                    }
                }
            }
            swap(next,cur);
        }
        if(found) return level+1;
        else return 0;
        
    }
};