LeetCode 127 Word Ladder java (看某位大神的解法做出来的)

问题重述：

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:
Only one letter can be changed at a time 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.
Subscribe to see which companies asked this question

代码如下：其实代码啦，思想啦都是那位大神的，他在LeetCode上给过源码啦，我只是说一下我对他算法的理解

import java.util.HashSet;import java.util.Set;import org.junit.Test;/** * 基本思想：模拟 */public class Solution {    public int ladderLength(String beginWord, String endWord, Set<String> wordList) {        Set<String> start = new HashSet<>();        Set<String> end = new HashSet<>();        start.add(beginWord);        end.add(endWord);        return solve(start, end, wordList, 1);    }    public int solve(Set<String> start,Set<String> end,Set<String> wordList,int step){        if(start.isEmpty()){            return 0;        }        if(start.size()>end.size()){            return solve(end,start,wordList,step);        }        wordList.removeAll(start);        Set<String> next = new HashSet<String>();        for(String s : start){            char[] chs = s.toCharArray();            for (int i = 0; i < chs.length; i++) {                for (int j = 'a'; j <='z'; j++) {                    char t = chs[i];                    chs[i]=(char) j;                    String temp = new String(chs);                    if(end.contains(temp)){                        return step+1;                    }                    if(wordList.contains(temp)){                        next.add(temp);                    }                    chs[i] = t;                }            }        }        return solve(next, end, wordList, step+1);    }    @Test    public void test(){        Set<String> set = new HashSet<>();        set.add("hot");        set.add("dog");        set.add("dot");        ladderLength("hot","dog",set);    }}

创建两个集合，一个开始集合、一个结束集合，由开始集合向结束集合靠近，或者由结束集合向开始集合靠近，这个想法有点像图论中求点到点最短路的算法，都是集合向集合逼近，只不过这个算法有点盲目基本是靠穷举举出来的。

for(String s : start){    char[] chs = s.toCharArray();    for (int i = 0; i < chs.length; i++) {        for (int j = 'a'; j <='z'; j++) {            char t = chs[i];            chs[i]=(char) j;            String temp = new String(chs);            if(end.contains(temp)){                return step+1;            }            if(wordList.contains(temp)){                next.add(temp);            }            chs[i] = t;        }    }}

这段代码就是穷举的代码，将开始字符集中的每一个字符串中的每一个字符都替换一次，然后判断结果集合或者字符集合里是否包含更改后的字符，如果包含，添加到next集合中，next集合是下一次要查询的开始集。
需要注意的是，更改字符后记得把更改后的字符改回来（就像搜索算法中的染色，有些染色必须再染回去，不然会发生错误，我算法敲得少，所以经常忘记这一点）

此外原作者进行了一个简化：

wordList.removeAll(start);

将查询过的字符串从字符表中删除，这一步确保算法不做重复的工作，极大得改进了算法性能

还有一个优化就是：

if(start.size()>end.size()){    return solve(end,start,wordList,step);}

这一步确保三重循环是循环的较小的那个集合，可以带来一定的优化