队列与栈复习IV-127. 单词接龙

127. 单词接龙

字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列：

序列中第一个单词是 beginWord 。
序列中最后一个单词是 endWord 。
每次转换只能改变一个字母。
转换过程中的中间单词必须是字典 wordList 中的单词。
给你两个单词 beginWord 和 endWord 和一个字典 wordList ，找到从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0

---

1.暴力BFS

队列用来BFS，还要有两个集合储存信息，一个set储存字典，一个visited来记录访问过的字符串，每个字符串如果和当前字符串只差一个字母且未访问过，就将其加入队列之中，直到找到endword为止。

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        int cnt=0;
        Set<String>visited=new HashSet<>();
        Set<String>set=new HashSet<>();
        //如果答案不在字典中
        for(String s:wordList){
            set.add(s);
        }
        if(!set.contains(endWord))
            return 0;
        Deque<String>queue=new LinkedList<>();
        queue.offer(beginWord);
        visited.add(beginWord);
        while(!queue.isEmpty()){
            cnt++;
            int size=queue.size();
            for(int i=0;i<size;i++){
                String s1=queue.poll();
                if(s1.equals(endWord))
                    return cnt;
                for(String s2:set){
                    if(visited.contains(s2))continue;
                    if(change(s1, s2)){
                        queue.offer(s2);
                        visited.add(s2);
                    }
                }
            }
        }
        return 0;
    }
    boolean change(String s1,String s2){
        if(s1.length()!=s2.length()){
            return false;
        }
        int x=0;
        for(int i=0;i<s1.length();i++){
            if(s1.charAt(i)!=s2.charAt(i))
                x++;
        }
        return x==1;
    }
}

结果还是很震撼的，因为每一个字符串可产生多达26*length个接龙字符串，即使考虑剪枝，遍历到底部的时候仍然会有巨大的解空间，所以时间复杂度超高，因此我们要考虑如何降低时间复杂度

优化1：首先想到的,visited这个集合可以用布尔数组替代，查找字典完全可以通过下标法，如此可以降低时间复杂度

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        int cnt=0;
        //Set<String>visited=new HashSet<>();
        int len=wordList.size();
        boolean[]visited=new boolean[len];
        //如果答案不在字典中
        for(String s:wordList){
            if(s.equals(endWord))cnt=-1;
        }
        if(cnt!=-1)
            return 0;
        cnt=0;
        Deque<String>queue=new LinkedList<>();
        queue.offer(beginWord);
        while(!queue.isEmpty()){
            cnt++;
            int size=queue.size();
            for(int i=0;i<size;i++){
                String s1=queue.poll();
                if(s1.equals(endWord))
                    return cnt;
                for(int j=0;j<len;j++){
                    String s2=wordList.get(j);
                    if(visited[j]==true)continue;
                    if(change(s1, s2)){
                        queue.offer(s2);
                        visited[j]=true;
                    }
                }
            }
        }
        return 0;
    }
    boolean change(String s1,String s2){
        if(s1.length()!=s2.length()){
            return false;
        }
        int x=0;
        for(int i=0;i<s1.length();i++){
            if(s1.charAt(i)!=s2.charAt(i))
                x++;
        }
        return x==1;
    }
}

 优化2：还是用集合，但是我们找接龙词的时候，可以逐个字母尝试改变，而不是遍历整个字典，这样可以有效降低时间复杂度

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        int cnt=1;
        Set<String>visited=new HashSet<>();
        Set<String>wordSet=new HashSet<>();
        //如果答案不在字典中
        for(String s:wordList){
            wordSet.add(s);
        }
        if(!wordSet.contains(endWord))
            return 0;
        Deque<String>queue=new LinkedList<>();
        queue.offer(beginWord);
        visited.add(beginWord);
        while(!queue.isEmpty()){
            int size=queue.size();
            for(int i=0;i<size;i++){
                //处理本层队列
                String s1=queue.poll();
                char[] charArray = s1.toCharArray();
                //逐字母替换,生成新单词,要考虑如下这些
                //1.是否在字典中
                //2.若等于答案直接返回
                //3.是否访问过
                for(int j=0;j<charArray.length;j++){
                    char origin=charArray[j];
                    for(char c='a';c<='z';c++){
                        if(c==origin)continue;
                        charArray[j]=c;
                        String newStr=new String(charArray);
                        if(wordSet.contains(newStr)){
                            if(newStr.equals(endWord)){
                                return cnt+1;
                            }
                            if(!visited.contains(newStr)){
                                queue.offer(newStr);
                                visited.add(newStr);
                            }
                        }
                    }
                    charArray[j]=origin;
                }                
            }
            cnt++;
        }
        return 0;
    }
}

 方法2：双向BFS+字典集合+逐字母修改

双向BFS也太绝绝子了吧，像个战神，直接把时间拉到10ms了

public class Solution {

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        // 第 1 步：先将 wordList 放到哈希表里，便于判断某个单词是否在 wordList 里
        Set<String> wordSet = new HashSet<>(wordList);
        if (wordSet.size() == 0 || !wordSet.contains(endWord)) {
            return 0;
        }

        // 第 2 步：已经访问过的 word 添加到 visited 哈希表里
        Set<String> visited = new HashSet<>();
        // 分别用左边和右边扩散的哈希表代替单向 BFS 里的队列，它们在双向 BFS 的过程中交替使用
        Set<String> beginVisited = new HashSet<>();
        beginVisited.add(beginWord);
        Set<String> endVisited = new HashSet<>();
        endVisited.add(endWord);

        // 第 3 步：执行双向 BFS，左右交替扩散的步数之和为所求
        int step = 1;
        while (!beginVisited.isEmpty() && !endVisited.isEmpty()) {
            // 优先选择小的哈希表进行扩散，考虑到的情况更少
            if (beginVisited.size() > endVisited.size()) {
                Set<String> temp = beginVisited;
                beginVisited = endVisited;
                endVisited = temp;
            }

            // 逻辑到这里，保证 beginVisited 是相对较小的集合，nextLevelVisited 在扩散完成以后，会成为新的 beginVisited
            Set<String> nextLevelVisited = new HashSet<>();
            for (String word : beginVisited) {
                if (changeWordEveryOneLetter(word, endVisited, visited, wordSet, nextLevelVisited)) {
                    return step + 1;
                }
            }

            // 原来的 beginVisited 废弃，从 nextLevelVisited 开始新的双向 BFS
            beginVisited = nextLevelVisited;
            step++;
        }
        return 0;
    }


    /**
     * 尝试对 word 修改每一个字符，看看是不是能落在 endVisited 中，扩展得到的新的 word 添加到 nextLevelVisited 里
     */
    private boolean changeWordEveryOneLetter(String word, Set<String> endVisited,
                                             Set<String> visited,
                                             Set<String> wordSet,
                                             Set<String> nextLevelVisited) {
        char[] charArray = word.toCharArray();
        for (int i = 0; i < word.length(); i++) {
            char originChar = charArray[i];
            for (char c = 'a'; c <= 'z'; c++) {
                if (originChar == c) {
                    continue;
                }
                charArray[i] = c;
                String nextWord = String.valueOf(charArray);
                if (wordSet.contains(nextWord)) {
                    if (endVisited.contains(nextWord)) {
                        return true;
                    }
                    if (!visited.contains(nextWord)) {
                        nextLevelVisited.add(nextWord);
                        visited.add(nextWord);
                    }
                }
            }
            // 恢复，下次再用
            charArray[i] = originChar;
        }
        return false;
    }
}