LeetCode 127. 单词接龙

127. 单词接龙

 

【BFS】借助队列实现BFS，具体思路为先把begin放入队列，同时设置一个visit的哈希表来记录当前字符串是否被访问过，再设置一个bk的哈希表用来记录合法的序列也就是wordList。由于需要得到最短的转换路径，因此需要带层次信息的BFS实现方式，对于每一层的每个word，从头到尾分别用26个字母来替换原来的值，如果替换后的字符串没有出现在visit并且存在bk中时判断是否和end相同，相同直接返回当前层数即可，否则将它加入下一层的队列中继续迭代。

class Solution {

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        Set<String> bk = new HashSet();
        for(var st: wordList) bk.add(st);
        Set<String> visit = new HashSet();
        int ans = 0;
        Deque<String> queue = new LinkedList();
        queue.offer(beginWord);
        visit.add(beginWord);
        while(!queue.isEmpty()){
            int k = queue.size();
            ans++;
            while(k-- > 0){
                char[] s = queue.poll().toCharArray();
                for(int i = 0, n = s.length; i < n; i++){
                    for(int j = 0; j < 26; j++){
                        char[] clone = s.clone();
                        clone[i] = (char)('a' + j);
                        String tmp = String.valueOf(clone);
                        if(!visit.contains(tmp) && bk.contains(tmp)){
                            if(tmp.equals(endWord)) return ++ans;
                            queue.offer(tmp);
                            visit.add(tmp);
                        }
                    }
                }
            }
        }
        return 0;   
    }
}

【双向BFS】

双向BFS的思路为一个从start开始BFS，一个从end开始BFS，每次更新较短的队列。当两个的搜索集合出现交集的时候就说明找到了最短路径。

class Solution {
    Set<String> set = new HashSet();
    int ans = -1;

    public void bfs(Deque<String> queue, int d, Map<String, Integer> map, Map<String, Integer> mp){
        int k = queue.size();
        while(k-- > 0){
            char[] c = queue.poll().toCharArray();
            for(int i = 0, n = c.length; i < n; i++){
                for(int j = 0; j < 26; j++){
                    char[] clone = c.clone();
                    clone[i] = (char)(j + 'a');
                    String str = String.valueOf(clone);
                    if(set.contains(str) && !map.containsKey(str)){
                        if(mp.containsKey(str)){
                            // System.out.println(str);
                            ans = d + mp.get(str);
                            return;
                        }
                        map.put(str, d);
                        queue.offer(str);
                    }
                }
            }
        }
    }

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        for(var str: wordList) set.add(str);
        if(!set.contains(endWord)) return 0;
        set.add(beginWord);
        Deque<String> st = new LinkedList();
        Deque<String> ed = new LinkedList();
        Map<String, Integer> m1 = new HashMap();
        Map<String, Integer> m2 = new HashMap();
        int d1 = 0, d2 = 0;
        st.offer(beginWord);
        m1.put(beginWord, 0);
        ed.offer(endWord);
        m2.put(endWord, 0);
        while(!st.isEmpty() && !ed.isEmpty()){
            if(st.size() < ed.size()) bfs(st, ++d1, m1, m2);
            else bfs(ed, ++d2, m2, m1);
            if(ans != -1) return ans + 1;
        }
        return 0;
    }
}