LeetCode127. 单词接龙

 

为什么要用BFS?

  无向图求最短路,广搜最为合适,广搜只要搜到了终点,那么一定是最短的路径。因为广搜就是以起点中心向四周扩散的搜索。

  本题是一个无向图,需要用标记位,标记着节点是否走过,否则就会死循环!

 

☆☆☆方法1:BFS

☆☆☆☆方法2:双向BFS,减少搜索空间大小。

  BFS的搜索空间大小依赖于每层节点的分支数量。每次都从中间结果少的那一端出发,这样就能剪枝掉很多不必要的搜索过程。

  注意:如果遇到了另一个visited里有过的结点,那么说明可以连接。

关于单词转换判断

  思路1:遍历所有候选单词,判断当前单词是否可以转换成这个候选单词。

  思路2:因为单词是由 a~z 这有限数量的字符组成的,可以遍历当前单词能转换成的所有单词,判断其是否包含在候选单词中。候选单词用 HashSet 保存,可以大大提高判断包含关系的性能。

 

代码1.1:BFS(耗时523ms)

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (!wordList.contains(endWord)) {
            return 0;
        }

        Queue<String> queue = new LinkedList<>();
        boolean[] visited = new boolean[wordList.size()];
        queue.offer(beginWord);
        int idx = wordList.indexOf(beginWord);
        if (idx != -1) {
            visited[idx] = true;
        }

        int level = 1; // 初始单词也算一次
        while (!queue.isEmpty()) {
            int size = queue.size();
            level ++;
            for (int i = 0; i < size; i++) {
                String cur = queue.poll();
                for (int j = 0; j < wordList.size(); j++) {
                    if (visited[j]) continue;
                    String s = wordList.get(j);
                    if (canConvert(cur,s)) {
                        if (s.equals(endWord)) {
                            return level;
                        }
                        queue.offer(s);
                        visited[j] = true;
                    }
                }

            }
        }
        return 0;
    }
    private boolean canConvert(String cur, String s) {
        int diff = 0;
        for (int i = 0; i < cur.length(); i++) {
            if (cur.charAt(i) != s.charAt(i)) {
                diff ++;
                if (diff > 1) break;
            }
        }
        return diff == 1;
    }
}

 

代码1.2:BFS + 优化单词转换判断(耗时76ms)

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        // 把字典中的单词放入到set中,主要是为了方便查询
        HashSet<String> dictSet = new HashSet<>(wordList);
        if (dictSet.size() == 0 || !dictSet.contains(endWord)) {
            return 0;
        }
        dictSet.remove(beginWord);

        Queue<String> queue = new LinkedList<>();
        HashSet<String> visited = new HashSet<>();
        queue.offer(beginWord);
        visited.add(beginWord);

        int level = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            level ++;
            for (int i = 0; i < size; i++) {
                String cur = queue.poll();
                char[] chars = cur.toCharArray();
                //修改单词的每一个字符,成为新的单词
                for (int j = 0; j < cur.length(); j++) {
                    // 先保存再恢复
                    char temp = chars[j];
                    for (char k = 'a'; k <= 'z'; k++) {
                        if (k == temp) continue;
                        chars[j] = k;
                        String newWord = String.valueOf(chars);
                        if (dictSet.contains(newWord) && !visited.contains(newWord)) {
                            if (newWord.equals(endWord)) {
                                return level;
                            }
                            queue.offer(newWord);
                            visited.add(newWord);
                        }
                    }
                    chars[j] = temp;
                }

            }
        }
        return 0;
    }
}

 

代码2.1:双向BFS(耗时128ms)

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        int end = wordList.indexOf(endWord);
        if (end == -1) {
            return 0;
        }
        wordList.add(beginWord);
        int start = wordList.size() - 1;

        Queue<Integer> queue1 = new LinkedList<>();
        Queue<Integer> queue2 = new LinkedList<>();
        Set<Integer> visited1 = new HashSet<>();
        Set<Integer> visited2 = new HashSet<>();
        queue1.offer(start);
        queue2.offer(end);
        visited1.add(start);
        visited2.add(end);

        int level = 1;
        while (!queue1.isEmpty() && !queue2.isEmpty()) {
            if (queue1.size() > queue2.size()) {
                Queue<Integer> tempQueue = queue1;
                queue1 = queue2;
                queue2 = tempQueue;
                Set<Integer> tempSet = visited1;
                visited1 = visited2;
                visited2 = tempSet;
            }
            int size1 = queue1.size();
            level ++;
            for (int i = 0; i < size1; i++) {
                String cur = wordList.get(queue1.poll());
                for (int j = 0; j < wordList.size(); j++) {
                    if (visited1.contains(j)) continue;
                    String s = wordList.get(j);
                    if (canConvert(cur, s)) {
                        if (visited2.contains(j)) { // 相遇,说明可以连接
                            return level;
                        }
                        queue1.offer(j);
                        visited1.add(j);
                    }
                }
            }

        }
        return 0;
    }
    private boolean canConvert(String cur, String s) {
        int diff = 0;
        for (int i = 0; i < cur.length(); i++) {
            if (cur.charAt(i) != s.charAt(i)) {
                diff ++;
                if (diff > 1) break;
            }
        }
        return diff == 1;
    }
}

 

代码2.2:双向BFS + 优化单词转换判断(耗时14ms)

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        Set<String> dictSet = new HashSet<>(wordList);
        if (dictSet.size() == 0 || !dictSet.contains(endWord)) return 0;

        Queue<String> queue1 = new LinkedList<>();
        Queue<String> queue2 = new LinkedList<>();
        Set<String> visited1 = new HashSet<>();
        Set<String> visited2 = new HashSet<>();
        queue1.offer(beginWord);
        visited1.add(beginWord);
        queue2.offer(endWord);
        visited2.add(endWord);

        int level = 1;
        while (!queue1.isEmpty() && !queue2.isEmpty()) {
            if (queue1.size() > queue2.size()) {
                Queue<String> tempQueue = queue1;
                queue1 = queue2;
                queue2 = tempQueue;
                Set<String> tempSet = visited1;
                visited1 = visited2;
                visited2 = tempSet;
            }
            int size1 = queue1.size();
            level ++;
            for (int i = 0; i < size1; i++) {
                String cur = queue1.poll();
                char[] chars = cur.toCharArray();
                for (int j = 0; j < cur.length(); j++) {
                    char temp = chars[j];
                    for (char k = 'a'; k <= 'z'; k++) {
                        if (k == temp) continue;
                        chars[j] = k;
                        String newWord = String.valueOf(chars);
                        if (dictSet.contains(newWord) && !visited1.contains(newWord)) {
                            if (visited2.contains(newWord)) {  // 两端遍历相遇
                                return level;
                            }
                            queue1.offer(newWord);
                            visited1.add(newWord);
                        }
                    }
                    chars[j] = temp; // 恢复第j位的原始字符
                }

            }
        }
        return 0;
    }
}

 

 

 

 

优化过程参考:

  算法实现和优化(Java 双向 BFS,23ms)

 

posted @ 2020-12-20 14:33  不学无墅_NKer  阅读(105)  评论(0编辑  收藏  举报