采用了算是BFS的方法，维护一个队列，其中维护某一次循环中所有需要进行处理的字符串。每当一次循环开始时，首先记录当前队列中元素个数，作为大循环中小循环个数。每一个小循环中，都会对队列中的元素寻找数组中是否有只差一位的字符串，如果有，则将该字符串从数组中删除，并且加入队列。每次大循环开始时将length++，如果遇到目标字符串，则返回当前length，如果某一次大循环结束时，队列为空，则代表无法转换到目标字符串，返回0。贴代码

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) 
    {
        queue<string> tempQue;
        int length = 1;
        tempQue.push(beginWord);
        int sizeTemp;
        while(!tempQue.empty())
        {
            length++;
            //cout<<length<<endl;
            sizeTemp = tempQue.size();
            //cout<<sizeTemp<<endl;
            for(int i = 0 ; i < sizeTemp ; i++)
            {
                string strTemp = tempQue.front();
                tempQue.pop();
                vector<string>::iterator Iter;
                for(Iter = wordList.begin() ; Iter != wordList.end() ; )
                {
                    //cout<<*Iter<<endl;
                    //string temp = *Iter;
                    if(ifDifferOne(strTemp,*Iter))
                    {
                        //cout<<"1"<<endl;
                        if(*Iter == endWord)
                        return length;
                        tempQue.push(*Iter);
                        wordList.erase(Iter);
                    }
                    else
                    Iter++;
                }
            }
        }
        return 0;
    }
    bool ifDifferOne(string& a,string &b)
    {
        int j = 0;
        for(int i = 0 ; i < a.length() ; i++)
        {
            if(a[i]!=b[i])
            j++;
        }
        if(j == 1)
        return true;
        else 
        return false;
    }
};

有向图的做法，感觉是和自己的方法类似的。使用有向图的方式，对每一个字符串，建立修改其中某个字符为*的虚拟节点，并建立一个双向的边。这样以来，只差一个字符的字符串就能通过一个虚拟节点连接起来。之后都是类似的。还有就是通过string到ID的映射减少存储量。贴代码

 1 class Solution {
 2 public:
 3     unordered_map<string,int> wordId;
 4     vector<vector<int>> edge;
 5     int nodeNum = 0;
 6     void addWord(string& word)
 7     {
 8         if(!wordId.count(word))
 9         {
10             wordId[word] = nodeNum++;
11             edge.emplace_back();
12         }
13     }
14     void addEdge(string& word)
15     {
16         addWord(word);
17         int id1 = wordId[word];
18         for(char& it:word)
19         {
20             char temp = it;
21             it = '*';
22             addWord(word);
23             int id2 = wordId[word];
24             edge[id1].push_back(id2);
25             edge[id2].push_back(id1);
26             it = temp;
27         }
28     }
29     int ladderLength(string beginWord, string endWord, vector<string>& wordList) 
30     {
31         for(string& word:wordList)
32         addEdge(word);
33         addEdge(beginWord);
34         if(!wordId.count(endWord))
35         return 0;
36         vector<int> dis(nodeNum,INT_MAX);
37         int beginId = wordId[beginWord];
38         int endId = wordId[endWord];
39         dis[beginId] = 0;
40         queue<int> que;
41         que.push(beginId);
42         while(!que.empty())
43         {
44             int x = que.front();
45             que.pop();
46             if(x == endId)
47             return dis[endId]/2+1;
48             for(int& tempId:edge[x])
49             {
50                 if(dis[tempId] == INT_MAX)
51                 {
52                     dis[tempId] = dis[x]+1;
53                     que.push(tempId);
54                 }
55             }
56         }
57         return 0;
58     }
59 };