Leetcode 126.单词接龙II

单词接龙II

给定两个单词（beginWord 和 endWord）和一个字典 wordList，找出所有从 beginWord 到 endWord 的最短转换序列。转换需遵循如下规则：

1. 每次转换只能改变一个字母。
2. 转换过程中的中间单词必须是字典中的单词。

说明:

• 如果不存在这样的转换序列，返回一个空列表。
• 所有单词具有相同的长度。
• 所有单词只由小写字母组成。
• 字典中不存在重复的单词。
• 你可以假设 beginWord 和 endWord 是非空的，且二者不相同。

示例 1:

输入:

beginWord = "hit",

endWord = "cog",

wordList = ["hot","dot","dog","lot","log","cog"]

输出:

[

["hit","hot","dot","dog","cog"],

  ["hit","hot","lot","log","cog"]

]

示例 2:

输入:

beginWord = "hit"

endWord = "cog"

wordList = ["hot","dot","dog","lot","log"]

输出: []

解释: endWord "cog" 不在字典中，所以不存在符合要求的转换序列。

先BFS遍历图,找到所有到达结尾单词的最短路径，同时记录图。最后再DFS遍历图。

BFS遍历图：queue用来BFS遍历图。队列按结点的深度依次存放待处理的结点。首先存放第一层结点，弹出，根据第一层结点找到所有第二层结点放入队列；弹出第二层某个结点，根据此结点找到所有第三层结点放入队列，以此类推。

记录图：记录图中每个结点的父节点们。记录图中结点的层数（深度）。

DFS遍历记录的图得出结果。

class Solution{
    public boolean isDiffOneWord(String a,String b){
        int diffnum=0;
        for(int i=0;i<a.length();i++){
            if(a.charAt(i)!=b.charAt(i)){
                diffnum++;
            }
            if(diffnum==2){
                return false;
            }
        }
        if(diffnum==1){
            return true;
        }
        return false;
    }

    public List<List<String>> findLadders(String beginWord,String endWord,List<String> wordList){
        List<List<String>> res=new ArrayList<List<String>>();
        int endIndex=wordList.indexOf(endWord);
        if(endIndex==-1){
            return res;
        }
        int beginIndex=wordList.indexOf(beginWord);
        //若beginWord不在wordList中，则添加至wordList末尾
        if(beginIndex==-1){
            wordList.add(beginWord);
            beginIndex=wordList.size()-1;
        }
        //queue用来BFS遍历图。队列按节点的深度依次存放待处理的节点。首先存放第一层结点，弹出
        //根据第一层结点找到所有第二层结点放入队列；以此类推
        Queue<Integer> queue=new LinkedList<Integer>();
        queue.offer(beginIndex);
        //fatherNodes、height用来记录图
        //记录图中每个节点的父亲节点们
        Map<Integer,List<Integer>> fatherNodes=new HashMap<Integer,List<Integer>>();
        for(int i=0;i<wordList.size();i++){
            fatherNodes.put(i,new ArrayList<Integer>());
        }
        //记录图中节点的层数（深度）
        int[] height=new int[wordList.size()];
        height[beginIndex]=1;
        while(!queue.isEmpty()){
            int nowIndex=queue.poll();
            //若最短深度的路径已经记录完毕，退出循环
            //height[nowIndex]>=height[endIndex]针对多个父亲点的情况
            if(height[endIndex]!=0 && height[nowIndex]>=height[endIndex]){
                break;
            }
            for(int i=0;i<wordList.size();i++){
                //height[i]==0未访问过的节点，height[i]=height[nowIndex]+1多个父亲节点的情况，且一个父亲节点已经访问过该结点
                if((height[i]==0 || height[i]==height[nowIndex]+1) && isDiffOneWord(wordList.get(nowIndex),wordList.get(i))){
                    if(height[i]==0){
                        queue.offer(i);
                        height[i]=height[nowIndex]+1;
                        fatherNodes.get(i).add(nowIndex);
                    }else{
                        //height[i]=height[nowIndex]+1多个父亲节点的情况，且一个父亲节点已经访问过该结点
                        fatherNodes.get(i).add(nowIndex);
                    }
                }
            }
        }

        if(height[endIndex]==0){
            return res;
        }else{
            List<String> list=new ArrayList<String>();
            list.add(wordList.get(endIndex));
            dfs(endIndex,list,res,wordList,fatherNodes,beginIndex);
        }
        return res;
    }

    public void dfs(int lastIndex,List<String> list,List<List<String>> res,List<String> wordList,Map<Integer,List<Integer>> fatherNodes,int beginIndex){
        if(lastIndex==beginIndex){
            List<String> newList=new ArrayList<String>(list);
            Collections.reverse(newList);
            res.add(newList);
            return;
        }
        for(int i=0;i<fatherNodes.get(lastIndex).size();i++){
            int fatherIndex=fatherNodes.get(lastIndex).get(i);
            list.add(wordList.get(fatherIndex));
            dfs(fatherIndex,list,res,wordList,fatherNodes,beginIndex);
            list.remove(list.size()-1);
        }
    }
}