Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) from beginWord toendWord, 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"]
Return
[ ["hit","hot","dot","dog","cog"], ["hit","hot","lot","log","cog"] ]
Note:
- All words have the same length.
- All words contain only lowercase alphabetic characters.
必须要遍历整棵搜索树,记录所有可能的解路径,然后比较最短的输出,重复节点很多,时间复杂度相当大。有人问可以剪枝么,答案是这里没法剪。如果把已经访问过的剪掉,那么就会出现搜索不完全的情况。
看来直接上来爆搜是不行的。效率低的不能忍。
这样看,如果将相邻的两个单词(即只差一个字母的单词)相互连在一起,这就是一个图嘛。经典的图算法,dijiska算法不就是求解最短路径的算法么。
那么就说直接邻接表建图,然后dijkstra算法求解咯,当然是可以的,边缘权值设为1就行。而且这种思路工程化,模块化思路很明显,比较不容易出错。但此种情况下时间需建图,然后再调用dijkstra,光是后者复杂度就为o(n^2),所以仍有可能超时,或者说,至少还不是最优方法。
建图后进行DFS呢。很可惜,对于一个无向有环图,DFS只能遍历节点,求最短路径什么的还是别想了。(注意,这里对图进行DFS搜索也会生成一颗搜索树,但是与上文提到的递归爆搜得到的搜索树完全不一样哦,主要是因为对图进行DFS得不到严谨的前后关系,而这是最短路径必须具备的)
好了,我们来看看一个例子
如何对这个图进行数据结构上的优化,算法上的优化是解决问题的关键。
通过观察,容易发现这个图没有边权值,也就是所用dijkstra算法显得没必要了,简单的BFS就行,呵呵,BFS是可以求这类图的最短路径的,
正如wiki所言:若所有边的长度相等,广度优先搜索算法是最佳解——亦即它找到的第一个解,距离根节点的边数目一定最少。
所以,从出发点开始,第一次"遍历"到终点时过的那条路径就是最短的路径。而且是时间复杂度为O(|V|+|E|)。时间复杂度较dijkstra小,尤其是在边没那么多的时候。
到此为止了么。当然不是,还可以优化。
回到最原始的问题,这个图够好么?它能反映问题的本质么。所谓问题的本质,有这么两点,一是具有严格的前后关系(因为要输出所有变换序列),二是图中的边数量是否过大,能够减小一些呢?
其实,一个相对完美的图应该是这样的
这个图有两个很明显的特点,一是有向图,具有鲜明的层次特性,二是边没有冗余。此图完美的描述了解的结构。
所以,我们建图也要有一定策略,也许你们会问,我是怎么想出来的。
其实,可以这样想,我们对一个单词w进行单个字母的变换,得到w1 w2 w3...,本轮的这些替换结果直接作为当前单词w的后继节点,借助BFS的思想,将这些节点保存起来,下一轮开始的时候提取将这些后继节点作为新的父节点,然后重复这样的步骤。
这里,我们需要对节点“分层”。上图很明显分为了三层。这里没有用到队列,但是思想和队列一致的。因为队列无法体现层次关系,所以建图的时候,必须设立两个数据结构,用来保存当前层和下层,交替使用这两个数据结构保存父节点和后继节点。
同时,还需要保证,当前层的所有节点必须不同于所有高层的节点。试想,如果tot下面又接了一个pot,那么由此构造的路径只会比tot的同层pot构造出的路径长。如何完成这样的任务呢?可以这样,我们把所有高层节点从字典集合中删除,然后供给当前层选取单词。这样,当前层选取的单词就不会与上层的重复了。注意,每次更新字典的时候是在当前层处理完毕之后在更新,切不可得到一个单词就更新字典。例如我们得到了dog,不能马上把dog从待字典集合中删除,否则,下次hog生成dog时在字典中找不到dog,从而导致结果不完整。简单的说,同层的节点可以重复。上图也可以把dog化成两个节点,由dot和hog分别指向。我这里为了简单就没这么画了。
最后生成的数据结构应该这样,类似邻接表
hot---> hop, tot, dot, pot, hog
dot--->dog
hog--->dog, cog
ok。至此,问题算是基本解决了,剩下的就是如何生成路径。其实很简单,对于这种“特殊”的图,我们可以直接DFS搜索,节点碰到目标单词就返回。
这就完了,不能优化了?不,还可以优化。
可以看到,在生成路径的时候,如果能够从下至上搜索的话,就可以避免那些无用的节点,比如hop pot tot这类的,大大提升效率。其实也简单,构造数据结构时,交换一下节点,如下图
dog--->dot, hog
cog--->hog
hop--->hot
tot--->hot
dot--->hot
pot--->hot
hog--->hot
说白了,构造一个反向邻接表即可。
对了,还没说整个程序的终止条件。如果找到了,把当前层搜完就退出。如果没找到,字典迟早会被清空,这时候退出就行。
说了这么多,上代码吧
/**用来存储最终结果*/
List<List<String>> result;
/**用来存储某一条结果*/
List<String> tmp;
public List<List<String>> findLadders(String beginWord, String endWord, Set<String> wordList) {
/**用来存储一个单词的相邻单词*/
Map<String,Set<String>> map=new HashMap<String,Set<String>>();
/**初始化结果集*/
result=new ArrayList<List<String>>();
tmp=new ArrayList<String>();
/**存储当前层的结果*/
Set<String> current=new HashSet<String>();
/**存储没有的遍历到的单词*/
Set<String> unvisited=wordList;
/**首先遍历到的便是开始的单词*/
if(unvisited.contains(beginWord))
{
unvisited.remove(beginWord);
}
/**未遍历的节点中包含结束节点*/
unvisited.add(endWord);
/**初始化当前层位开始节点*/
current.add(beginWord);
while((!current.contains(endWord))&&unvisited.size()>0)
{
/**初始化下一层节点*/
Set<String> nextstep=new HashSet<String>();
/**遍历当前层节点*/
for(String word:current)
{
/**暴力搜索当前节点相近单词*/
for(int i=0;i<word.length();i++)
{
char ch=word.charAt(i);
for(int j=0;j<26;j++)
{
if(ch=='a'+j)
continue;
else
{
char c=(char) ('a'+j);
String tmpword="";
if(i==0)
{
tmpword=c+word.substring(i+1);
}
else
{
tmpword=word.substring(0,i)+c+word.substring(i+1);
}
if(unvisited.contains(tmpword))
{
nextstep.add(tmpword);
if(map.containsKey(tmpword))
{
Set<String> set=map.get(tmpword) ;
set.add(word);
/**为了优化搜索,构建的是反向图*/
map.put(tmpword, set);
}
else
{
Set<String> set=new HashSet<String>();
set.add(word);
map.put(tmpword, set);
}
}
}
}
}
}
/**如果没有下一层节点,直接返回*/
if(nextstep.size()==0) return result;
/**找完一层,去掉该层节点。而不是每找到一个节点就去掉,避免漏掉可能的路径*/
for(String news:nextstep)
{
unvisited.remove(news);
}
/**继续下一层的遍历*/
current=nextstep;
}
findPath(map,endWord,beginWord);
return result;
}
/**根据反向邻接表寻找遍历路径*/
public void findPath(Map<String,Set<String>> map,String start,String end)
{
tmp.add(start);
if(start.equals(end))
{
List<String> ret=new ArrayList<String>(tmp);
Collections.reverse(ret);
result.add(ret);
return;
}
Set<String> set=map.get(start);
for(String s:set)
{
findPath(map,s,end);
/**递归的后续处理*/
tmp.remove(tmp.size()-1);
}
}