算法模板（二）（相关话题：广度优先搜索BFS）

目录

模板介绍

题目描述

思路分析

参考文章

相关习题

---

模板介绍

BFS 的核心思想应该不难理解的，就是把一些问题抽象成图，从一个点开始，向四周开始扩散。一般来说，我们写 BFS 算法都是用「队列」这种数据结构，每次将一个节点周围的所有节点加入队列。

BFS 相对 DFS 的最主要的区别是：BFS 找到的路径一定是最短的，但代价就是空间复杂度比 DFS 大很多 

1、为什么 BFS 可以找到最短距离，DFS 不行吗？

首先，你看 BFS 的逻辑，depth每增加一次，队列中的所有节点都向前迈一步，这保证了第一次到达终点的时候，走的步数是最少的。

DFS 不能找最短路径吗？其实也是可以的，但是时间复杂度相对高很多。

你想啊，DFS 实际上是靠递归的堆栈记录走过的路径，你要找到最短路径，肯定得把二叉树中所有树杈都探索完才能对比出最短的路径有多长对不对？

而 BFS 借助队列做到一次一步「齐头并进」，是可以在不遍历完整棵树的条件下找到最短距离的。

形象点说，DFS 是线，BFS 是面；DFS 是单打独斗，BFS 是集体行动。这个应该比较容易理解吧。

2、既然 BFS 那么好，为啥 DFS 还要存在？

BFS 可以找到最短距离，但是空间复杂度高，而 DFS 的空间复杂度较低。

还是拿刚才我们处理二叉树问题的例子，假设给你的这个二叉树是满二叉树，节点总数为N，对于 DFS 算法来说，空间复杂度无非就是递归堆栈，最坏情况下顶多就是树的高度，也就是O(logN)。

但是你想想 BFS 算法，队列中每次都会储存着二叉树一层的节点，这样的话最坏情况下空间复杂度应该是树的最底层节点的数量，也就是N/2，用 Big O 表示的话也就是O(N)。

由此观之，BFS 还是有代价的，一般来说在找最短路径的时候使用 BFS，其他时候还是 DFS 使用得多一些（主要是递归代码好写）。

下面是DFS的通用模板

// 计算从起点 start 到终点 target 的最近距离
int BFS(Node start, Node target) {
    Queue<Node> q; // 核心数据结构
    Set<Node> visited; // 避免走回头路

    q.offer(start); // 将起点加入队列
    visited.add(start);
    int step = 0; // 记录扩散的步数

    while (q not empty) {
        int sz = q.size();
        /* 将当前队列中的所有节点向四周扩散 */
        for (int i = 0; i < sz; i++) {
            Node cur = 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++;
    }
}

题目描述

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有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
解释：
无法旋转到目标数字且不被锁定。
示例 4:

输入: deadends = ["0000"], target = "8888"
输出：-1

思路分析

由于密码锁有四位数字，每个数字可以向上向下移动。所以每个节点的相邻节点共用4*2=8种组合

	private Set deads = new HashSet();
	private Set visits = new HashSet();
	private LinkedList<String> queue = new LinkedList();

	public int openLock(String[] deadends, String target) {

		for (int i = 0; i < deadends.length; i++) {
			deads.add(deadends[i]);
		}

		int step = 0;
		queue.offer("0000");
		visits.add("0000");
		while (!queue.isEmpty()) {

			int sz = queue.size();
			/* 将当前队列中的所有节点向周围扩散 */
			for (int i = 0; i < sz; i++) {
				String curr = queue.poll();
				if (deads.contains(curr)) {
					continue;

				}
				if (curr.equals(target)) {
					return step;
				}

				for (int j = 0; j < 4; j++) {

					String upStr = upMove(curr, j);
					if (!visits.contains(upStr)) {
						queue.offer(upStr);
						visits.add(upStr);
					}
					String downStr = downMove(curr, j);
					if (!visits.contains(downStr)) {
						queue.offer(downStr);
						visits.add(downStr);
					}
				}
			}
			step++;

		}
		return -1;

	}

	public String upMove(String curr, int index) {
		char[] arr = curr.toCharArray();
		if (arr[index] == '9') {
			arr[index] = '0';
		} else {
			arr[index] += 1;
		}

		return new String(arr);
	}

	public String downMove(String curr, int index) {
		char[] arr = curr.toCharArray();
		if (arr[index] == '0') {
			arr[index] = '9';
		} else {
			arr[index] += -1;
		}

		return new String(arr);
	}

参考文章

BFS 算法框架套路详解

相关习题

LCR 175. 计算二叉树的深度