这道题思路不难，本质就是BFS嘛，从一个单词开始，他的下一层是所有可以一步变到，且从来没变到过得那些string。问题是怎样确定这些可以变到的string呢？有两个条件，一，只能通过上一层的string变化一个数字得到，二，变化之后单词必须在字典中。注意是变化一个字母得到，而不是编辑距离是1，要么就复杂了，情况多了好多好多。

我最开始的思路是建个map，保存所有从开始单词能变化到得单词及这些单词一步能变化到的那些单词。too young too simple, 在一个字典非常大的测试用例上超时了。为什么会超时呢，因为字典很大的时候，大家都能互相变来变去，生成我这个映射后的字典代价很大，因为每次都要验证这个单词跟它后面的所有单词是不是只相差了一个字符，建成了这个映射字典，以后每次还是要在map中查找。

那怎么办？还有一个看似不起眼，其实很关键的条件没有使用，那就是所有的单词的长度都一样！还好英文字母一共26个，而且在set的和map中查找的速度都很快，而且，单词长度都还相同，那么我们就从头开始尝试，每次变换一位，看看变化之后的是不是要求的？如果不是，看看在不在字典中，在字典中且没访问过加入到下一层中。尝试完这一波后，把刚变化的位置恢复，这样保证了每次只有一位不一样。有那么点暴力却行得通。

ac代码：

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        if(start == end)
            return 2;
        if(dict.size()<=0)
            return 0;
        queue<string> que;
        set<string> visited;
        int res = 2, len = start.length();
        que.push(start);
        que.push("");
        bool flag = false;
        string tps(start);
        char tp;
        while(!que.empty()){
            tps = que.front();
            que.pop();
            if(tps == ""){
                if(que.empty()){
                    return 0;
                }else{
                    res++;
                    que.push("");
                    continue;
                }
            }
            for(int i=0;i<len;i++){
                char p = tps[i];
                for(tp=‘a‘;tp<=‘z‘;tp++){
                    tps[i] = tp;
                    if(tps == end)  return res;
                    if(dict.find(tps)!=dict.end()){
                        if(visited.find(tps)==visited.end()){
                            visited.insert(tps);
                            que.push(tps);
                        }
                    }
                }
                tps[i] = p;
            }
            
        }
        return 0;
    }
};