广度优先搜索BFS优化，双向BFS

双向BFS通过从起点和终点同时搜索来优化传统单向BFS。

优化原理

1. 搜索空间减少

        单向BFS从起点开始逐层向外扩展，假设每层的平均分支因子为b，目标与起点之间的最短路径长度是d，那么单向BFS的时间复杂度为O()。因此，随着层数增加，时间消耗会大大增加。

        双向BFS从起点和终点同时出发，每次各扩展一层。由于两个搜索分别进行，搜索深度变为,那么时间复杂度变为，大大减少。

2. 搜索路径相遇

        双向BFS的核心思想是尽早使两个搜索相遇，两端搜索都只需要遍历路径的一半。

具体优化的细节

1. 两端同时搜索

使用两个队列，分别用于从起点搜索和从终点搜索。

2. 减少冗余搜索

使用两个哈希表，分别用于存储起点搜索已经访问过的节点和终点搜索已经访问过的节点。

3. 每次扩展一层 

每次从两个队列中分别取出一层节点遍历，并将新的为访问过的节点加入队列中。

如果在扩展过程中两个哈希表元素重合，即代表两个搜索相遇，返回结果。

如果此次扩展没有相遇，则两个队列都分别要将搜索长度加一。

例题(leetcode 752)

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转：例如把 '9' 变为 '0'，'0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。

锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。

列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。

字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1 。

示例 1:

输入：deadends = ["0201","0101","0102","1212","2002"], target = "0202"
输出：6
解释：
可能的移动序列为 "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202"。
注意 "0000" -> "0001" -> "0002" -> "0102" -> "0202" 这样的序列是不能解锁的，
因为当拨动到 "0102" 时这个锁就会被锁定。

示例 2:

输入: deadends = ["8888"], target = "0009"
输出：1
解释：把最后一位反向旋转一次即可 "0000" -> "0009"。

示例 3:

输入: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"
输出：-1
解释：无法旋转到目标数字且不被锁定。

提示：

• 1 <= deadends.length <= 500
• deadends[i].length == 4
• target.length == 4
• target 不在 deadends 之中
• target 和 deadends[i] 仅由若干位数字组成

import java.util.Set;
import java.util.Vector;

class Solution{
    public int openLock(String[] deadends, String target){
        if(target.equals("0000"))
            return 0;
        Set<String> deadendsSet = new HashSet<>(Arrays.asList(deadends));
        if(deadendsSet.contains("0000"))
            return -1;
        Queue<String> queueStart = new LinkedList<>();
        Queue<String> queueEnd = new LinkedList<>();
        Set<String> visitedStart = new HashSet<>();
        Set<String> visitedEnd = new HashSet<>();
        queueStart.offer("0000");
        queueEnd.offer(target);
        visitedStart.add("0000");
        visitedEnd.add(target);
        int step = 0;
        while(!queueStart.isEmpty() && !queueEnd.isEmpty()){
            ++step;
            if(bfs(queueStart, visitedStart, visitedEnd, deadendsSet, target))
                return step;
            ++step;
            if(bfs(queueEnd, visitedEnd, visitedStart, deadendsSet, target))
                return step;
        }
        return -1;   
    }
    public boolean bfs(Queue<String> queue, Set<String> visited, Set<String> otherVisited, Set<String> deadendsSet, String target){
        int size = queue.size();
        for(int i=0; i<size; ++i){
            String cur = queue.poll();
            for(String nextNum: getNextNum(cur)){
                if(otherVisited.contains(nextNum))
                    return true;
                if(!deadendsSet.contains(nextNum) && !visited.contains(nextNum)){
                    queue.offer(nextNum);
                    visited.add(nextNum);
                }
            }
        }
        return false;
    }
    public Vector<String> getNextNum(String cur){
        Vector<String> nextNumList = new Vector<>();
        for(int i=0; i<4; ++i){
            StringBuilder sb = new StringBuilder(cur);
            char c = sb.charAt(i);
            sb.setCharAt(i, c=='0'?'9':(char)(c-1));
            nextNumList.add(sb.toString());
        }
        for(int i=0; i<4; ++i){
            StringBuilder sb = new StringBuilder(cur);
            char c = sb.charAt(i);
            sb.setCharAt(i, c=='9'?'0':(char)(c+1));
            nextNumList.add(sb.toString());
        }
        return nextNumList;
    }
}