BFS模板 + 力扣例题

BFS模板 + 力扣例题

DFS和BFS的区别：

BFS的时间复杂度是O(logn)，DFS的时间复杂度是O(n)。BFS更节省时间，速度更快。

 

BFS模板：

int BFS(Node start, Node target)//计算从起点start到终点target的距离
{
    Queue<Node> q;//核心数据结构，队列
    Set<Node> visited;//访问过的不再访问，避免走回头路
    // 但是在二叉树结构里面不存在子节点访问父节点，所以不需要visited集合

    q.offer(start);//把起点加入队列
    visited.add(start);
    int step = 0;//step表示遍历的层数，也是步数

    while(q not empty())
    {
        int n = q.size();
        /*将目前队列里所有的结点往邻接结点遍历*/ 
        for(int i=0;i<n;i++)
        {
            Node curr = q.poll();
        /*判断是否到达终点，也就是是否到达目标点*/
            if(cur is target)
            {
                return step;
            }
        /*将cur的邻近结点加入到队列里面*/ 
            for(Node x : cur.adj()){
                if(x not in visited)
                {
                    q.offer(x);
                    visited.add(x);
                }
            }
        }
        //更新步数，也就是更新遍历的层数
        step++;
    }
}

双向 BFS：

双向 BFS还是遵循 BFS 算法框架的，只是不再使用队列，而是使用 HashSet 方便快速判断两个集合是否有交集。

int openLock(String[] deadends, String target) {
    Set<String> deads = new HashSet<>();
    for (String s : deadends) deads.add(s);
    // 用集合不用队列，可以快速判断元素是否存在
    Set<String> q1 = new HashSet<>();
    Set<String> q2 = new HashSet<>();
    Set<String> visited = new HashSet<>();

    int step = 0;
    q1.add("0000");
    q2.add(target);

    while (!q1.isEmpty() && !q2.isEmpty()) {
        // 哈希集合在遍历的过程中不能修改，用 temp 存储扩散结果
        Set<String> temp = new HashSet<>();

        /* 将 q1 中的所有节点向周围扩散 */
        for (String cur : q1) {
            /* 判断是否到达终点 */
            if (deads.contains(cur))
                continue;
            if (q2.contains(cur))
                return step;
            visited.add(cur);

            /* 将一个节点的未遍历相邻节点加入集合 */
            for (int j = 0; j < 4; j++) {
                String up = plusOne(cur, j);
                if (!visited.contains(up))
                    temp.add(up);
                String down = minusOne(cur, j);
                if (!visited.contains(down))
                    temp.add(down);
            }
        }
        /* 在这里增加步数 */
        step++;
        // temp 相当于 q1
        // 这里交换 q1 q2，下一轮 while 就是扩散 q2
        q1 = q2;
        q2 = temp;
    }
    return -1;
}

参考链接：https://mp.weixin.qq.com/s/WH_XGm1-w5882PnenymZ7g

力扣例题