[leetcode] word ladder

对于之前没有接触过该类型题目的人来说，此题无疑是个难题，本人提交了10次才正确通过，期间遇到了非常多的问题，感觉几乎把OJ的所有错误遍历了一遍，下面详细说说自己做该题的经验。

首先承认，我一开始并没有想到什么图模型，或者说是一点思路都没有。然后我就冥思苦想，首先想到了可以先构造一个二维矩阵，判断给定的词之间是否能两两一步到达，这一步可以通过两层循环加字符串的遍历完成，应该不难。获得这个矩阵之后，我居然还是没有想到图，只是在纸上写写画画感觉问题可以转化成在矩阵中搜索一条路径可以到达最后一行。路径搜索应该可以通过深搜完成，之后就开始按照这个思路写代码，结果越写越乱，遇到多次MLE。

多次尝试无果后，我感觉之前的思路不对，需要重整思路。然后又是写写画画，突然灵光一闪：搜索路径貌似可以用图表示！然后按照这个思路很快就想明白了整个流程：首先构造一个无向图用来表示单词之间的可达性，然后从表示起点的节点开始对整个图进行BFS遍历，直到找到表示end的节点。按照这个思路也很快写出代码，但是提交后又遇到新问题：不停地超时。此时说明算法已经正确，但是复杂度还是太高。不妨先看一下这时的代码：

[java]  view plain copy print ?

1. public int ladderLength2(String start, String end, HashSet<String> dict) {  
2.         if (start == null || end == null || start.equals(end)  
3.                 || start.length() != end.length())  
4.             return 0;  
5.   
6.         if (isOneWordDiff(start, end))  
7.             return 2;  
8.   
9.         dict.add(start);  
10.         dict.add(end);  
11.   
12.         String[] dicts = (String[]) dict.toArray(new String[0]);  
13.   
14.         int size = dicts.length;  
15.   
16. 　　// 表示图的列表数组  
17.         ArrayList<ArrayList<Integer>> lists = new ArrayList<ArrayList<Integer>>();  
18.   
19.         int s = 0, e = 0;  
20.         // 判断一个单词一步可以到达哪些单词  
21.         for (int i = 0; i < size; i++) {  
22.             if (start.equals(dicts[i]))  
23.                 s = i;  
24.             if (end.equals(dicts[i]))  
25.                 e = i;  
26.   
27.             ArrayList<Integer> list = new ArrayList<Integer>();  
28.             for (int j = 0; j < size; j++) {  
29.                 if (isOneWordDiff(dicts[i], dicts[j]))  
30.                     list.add(j);  
31.             }  
32.   
33.             lists.add(list);  
34.         }  
35.   
36.         HashMap<Integer,Integer> dist = new HashMap<Integer, Integer>();  
37.   
38.         Queue<Integer> queue = new LinkedList<Integer>();  
39.         queue.add(s);  
40.         dist.put(s, 1);  
41.   
42.         while (!queue.isEmpty()) {  
43.             int index = queue.poll();  
44.             ArrayList<Integer> list = lists.get(index);  
45.   
46.             for (int i = 0; i < list.size(); i++) {  
47.                 if (list.get(i) == e) {  
48.                     return dist.get(index) + 1;  
49.                 }  
50.   
51.                 if (!dist.containsKey(list.get(i))) {  
52.                     queue.add(list.get(i));  
53.                     dist.put(list.get(i), dist.get(index) + 1);  
54.                 }  
55.             }  
56.         }  
57.   
58.         return 0;  
59.     }  
60. private boolean isOneWordDiff(String a, String b) {  
61.         int diff = 0;  
62.         for (int i = 0; i < a.length(); i++) {  
63.             if (a.charAt(i) != b.charAt(i)) {  
64.                 diff++;  
65.                 if (diff >= 2)  
66.                     return false;  
67.             }  
68.         }  
69.   
70.         return diff == 1;  
71.     }  

分析一下上面代码的思路：

1．首先将start和end添加到词典中，并将词典转化成数组；

2．创建一个二维数组，二维数组的每一维表示某个单词可以通过一步转化到达的单词，也即利用邻接表的方式存储图结构。在这个过程中也获得了start和end代表的数字；

3．利用构造的图进行BFS遍历，直到遇到end节点或者返回0。在遍历的过程中，由于图的边长是1，所以我们在遍历的时候总是得到从start到某个节点的最短路径，所以我们只需要考虑尚未遍历过的顶点即可。

上述代码是正确的，但是一直超时真是让人搞不清状况。后来，只能上网搜索别人的解答才明白其中的原因。超时的地方不在BFS遍历，而是在我们构造图的地方。我们采用了两层遍历构造一个图，此时复杂度是O(n2)，数据量很小时可能体现不出它的劣势，但是当n上千时（给定的测试集中有这样的例子），上面的方法构造图就显得太慢。

这里我们可以不用实际构造图，而在BFS遍历的时候去寻找当前单词可达的下一个单词。如果还是通过遍历所有的单词判断是否可达，则复杂度和上面一样，但实际上在上千个单词中，只有少数几个可以由当前单词一步到达，我们之前的比较浪费了很多时间在不可能的单词上。网上对该问题的解决无一例外都是按照下面的思路：将当前单词每一个字符替换成a~z的任意一个字符，然后判断是否在词典中出现。此时的复杂度是O(26*word_length)，当单词比较短时，这种方法的优势就体现出来了。按照这种思路修改后的代码如下：

[java]  view plain copy print ?

1. public int ladderLength(String start, String end, HashSet<String> dict) {  
2.         if (start == null || end == null || start.equals(end)  
3.                 || start.length() != end.length())  
4.             return 0;  
5.   
6.         if (isOneWordDiff(start, end))  
7.             return 2;  
8.   
9.         Queue<String> queue=new LinkedList<String>();  
10.         HashMap<String,Integer> dist=new HashMap<String,Integer>();  
11.           
12.         queue.add(start);  
13.         dist.put(start, 1);  
14.           
15.         while(!queue.isEmpty())  
16.         {  
17.             String head=queue.poll();  
18.               
19.             int headDist=dist.get(head);  
20.             //从每一个位置开始替换成a~z  
21.             for(int i=0;i<head.length();i++)  
22.             {  
23.                 for(char j='a';j<'z';j++)  
24.                 {  
25.                     if(head.charAt(i)==j) continue;  
26.                       
27.                     StringBuilder sb=new StringBuilder(head);  
28.                     sb.setCharAt(i, j);  
29.                       
30.                     if(sb.toString().equals(end)) return headDist+1;  
31.                       
32.                     if(dict.contains(sb.toString())&&!dist.containsKey(sb.toString()))  
33.                     {  
34.                         queue.add(sb.toString());  
35.                         dist.put(sb.toString(), headDist+1);  
36.                     }  
37.                 }  
38.             }  
39.         }  
40.           
41.         return 0;  
42. 　　  }  

我们可以看出，代码更加简洁，而且效率也更高，提交上述代码就可以AC了。

 ---------------------------------------------------------------------------------------------------------

附上自己AC的C++代码：

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        unordered_map<string, int> dictMap;
        queue<string> q;
        q.push(start);
        dictMap[start] = 1;
        while (!q.empty())
        {
            string temp = q.front(); 
            int dist = dictMap[temp];
            for (int i = 0; i < temp.size(); ++i)
            {
                for (char ch = 'a'; ch <= 'z'; ++ch)
                {
                    if (temp[i] == ch)
                        continue;
                    string nTemp = temp;
                    nTemp[i] = ch;
                    if (nTemp == end)
                        return dist + 1;
                    if (dictMap.find(nTemp) == dictMap.end() && dict.find(nTemp) != dict.end())
                    {
                        dictMap[nTemp] = dist + 1;
                        q.push(nTemp);
                    }
                }
            }
            q.pop();
        }
        return 0;
    }
};