BFS

最新推荐文章于 2022-04-06 09:21:53 发布

ryontang

最新推荐文章于 2022-04-06 09:21:53 发布

阅读量188

点赞数

分类专栏： leecode刷题

本文链接：https://blog.csdn.net/ryontang/article/details/107670273

版权

leecode刷题专栏收录该内容

13 篇文章 0 订阅

订阅专栏

算法框架

参考来源：
作者：labladong
网址

问题的本质就是让你在一幅「图」中找到从起点 start 到终点 target 的最近距离，这个例子听起来很枯燥，
但是 BFS 算法问题其实都是在干这个事儿
* 本质上就是一幅「图」，让你从一个起点，走到终点，
* 问最短路径。这就是 BFS 的本质，框架搞清楚了直接默写就好。

记住下面这个框架就ok了：

# 计算起点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++;
	}
}

队列 q 就不说了，BFS 的核心数据结构；cur.adj() 泛指 cur 相邻的节点，比如说二维数组中，cur 上下左右四面的位置就是相邻节点；visited 的主要作用是防止走回头路，大部分时候都是必须的，但是像一般的二叉树结构，没有子节点到父节点的指针，不会走回头路就不需要 visited

二叉树的最小高度Leetcode111

在这里插入图片描述

怎么套到 BFS 的框架里呢？
首先明确一下起点 start 和终点 target 是什么，怎么判断到达了终点？
显然起点就是 root 根节点，终点就是最靠近根节点的那个「叶子节点」
if (cur.left == null && cur.right == null) 
    // 到达叶子节点

那么，按照我们上述的框架稍加改造来写解法即可：

int minDepth(TreeNode* root){
	if(root == null) return 0;
	Queue<TreeNode*> q = new TreeNode();
	q->offer(root);
	# root 本身就是一层，depth 初始化为 1
	int depth = 1;
	
	while(!q->empty()){
		int sz = q->size();
		/* 将当前队列中的所有节点向四周扩散 */
		for(int i = 0; i<sz; i++){
			TreeNode* cur = q->poll();
			/* 判断是否到达终点 */
			if(cur->left == null &&cur->right==null){
				return depth;
			}
			/* 将 cur 的相邻节点加入队列 */
			if(cur->left!=null){
				q->offer(cur->left);
			}
			if(cur->right!=null){
				q->offer(cur->right);
			}
		}
		/* 这里增加步数 */
		depth++;
	}
	return depth;
}

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

首先，你看 BFS 的逻辑，depth 每增加一次，队列中的所有节点
都向前迈一步，这保证了第一次到达终点的时候，走的步数是最少的。
DFS 不能找最短路径吗？其实也是可以的，但是时间复杂度相对高很多。你想啊，DFS 实际上是靠递归的堆栈记录走过的路径，
你要找到最短路径，肯定得把二叉树中所有树杈都探索完才能对
比出最短的路径有多长对不对？而 BFS 借助队列做到一次一步「齐头并进」，是可以在不遍历完整棵树的条件下找到最短距离
的。
形象点说，DFS 是线，BFS 是面；DFS 是单打独斗，BFS 是集
体行动。这个应该比较容易理解吧

解开密码锁的最少次数LeetCode 题目是第 752 题

1. 第一步，我们不管所有的限制条件，不管 deadends 和 target 
的限制，就思考一个问题：如果让你设计一个算法，穷举所有可能的密码组合，你怎么做？
穷举呗，再简单一点，如果你只转一下锁，有几种可能？总共有 
4 个位置，每个位置可以向上转，也可以向下转，也就是有 8 种可能对吧

比如说从 "0000" 开始，转一次，可以穷举出 "1000", "9000", 
"0100", "0900"... 共 8 种密码。然后，再以这 8 种密码作为基础，对每个密码再转一下，穷举出所有可能...

仔细想想，这就可以抽象成一幅图，每个节点有 8 个相邻的节
点，又让你求最短距离，这不就是典型的 BFS 嘛，框架就可以
派上用场了，先写出一个「简陋」的 BFS 框架代码再说别的：

```cpp
// 将s[j]向上拨动一次
string plusOne(string s, int j){
	int n = s.length(); 
	char ch[n + 1];
	// copying the contents of the 
    // string to char array 
    strcpy(ch, s.c_str());
    if(ch[j]=='9')
    	ch[j]=='0';
   	else
   		ch[j]+=1;
	return new string(ch);
}

// 将s[j]向下拨动一次
string minusOne(string s, int j){
	int n = s.length(); 
	char ch[n + 1];
	// copying the contents of the 
    // string to char array 
    strcpy(ch, s.c_str());
    if(ch[j]=='0')
    	ch[j]=='9';
   	else
   		ch[j]-=1;
	return new string(ch);
}

// BFS 框架，打印出所有可能的密码
void BFS(string target){
	Queue<string> q = new string();
	q.offer("0000");
	
	while(!q->isEmpty()){
		int sz = q->size();
		/* 将当前队列中的所有节点向周围扩散 */
		for(int i =0; i<sz; i++){
			string cur = q.poll();
			/* 判断是否到达终点 */
			system.out.println(cur);
			
			/* 将一个节点的相邻节点加入队列 */
			for(int j = 0; j<4; j++){
				string up = plusOne(cur, j);
				string down = minusOne(cur, j);
				q.offer(up);
				q.offer(down);
			}
		}
		/* 在这里增加步数 */
	}
	return;
}

这段 BFS 代码已经能够穷举所有可能的密码组合了，但是显然不能完成题目，有如下问题需要解决：

会走回头路。比如说我们从 “0000” 拨到 “1000”，但是等从队列拿出 “1000” 时，还会拨出一个 “0000”，这样的话会产生死循环
没有终止条件，按照题目要求，我们找到 target 就应该结束并返回拨动的次数
没有对 deadends 的处理，按道理这些「死亡密码」是不能出现的，也就是说你遇到这些密码的时候需要跳过

int openLock(string deadends, string target){
	set<string> deads = new HashSet<>();
	for(string s:deadends) deads.add(s);
	// 记录已经穷举过的密码，防止走回头路
	set<string> visited = new HashSet<>();
	Queue<string> q = new LinkedList<>();
	// 从起点开始启动广度优先搜索
	int step = 0;
	q.offer("0000");
	visited.add("0000");
	
	while(!q.isEmpty()){
		int sz=q.size();
		/* 将当前队列中的所有节点向周围扩散 */
		for(int i =o; i<sz; i++){
			string cur = q.poll();
			/* 判断是否到达终点 */
			if(deads.contains(cur)){
				continue; // 遇到deads跳过去不能加入队列
			}
			if(cur.equals(target)){
				return step;
			}
			
			/* 将一个节点的未遍历相邻节点加入队列 */
			for(int j = 0; j<4; j++){
				string up = plusOne(cur, j);
				if(!visited.contains(up)){
					// 没访问过才访问
					q.offer(up);
					visited.add(up);
				}
				string down = minusOne(cur, j);
				if(!visited.contains(down)){
					q.offer(down);
					visited.add(down);
				}
			}
		}
		/* 在这里增加步数 */
		step++;
	}
	// 如果穷举完都没找到目标密码，那就是找不到了
	return -1;
}

剑指13 机器人的运动范围

矩阵BFS总结几点：
1. 队列queue, 二维vector<<vector<bool>>>visited创建, 队首元素入队
2. 出队就是要访问了，访问是否满足题目条件：visited?格子没有限制？，既然已经入队肯定没有超过边界，访问过后记得打上标签
3. 出队元素邻居点的添加：在边界的范围内(邻居点的添加可以这样按照队首元素的访问一个个队首元素的添加，也可以目前队内一圈元素整个往外扩添加，后者可能更符合BFS的动画形象，但是前者不容易乱有条理)
4. 直到队列为空，或到达终点

// 方法一：
// 这个题跟BFS搜索有不同的地方在于，BFS的扩展是对队内所有元素扩展的
// 而本题有限制，即有些格子不能扩展，所以这就是不同
// 方法一，是先对队内元素单个遍历单个扩展，队内元素肯定是符合要求的
// 统一在出队且这个元素能访问之后，才进行step的更新和visited的更新
class Solution{
  public:
  int get_single_number(int x){
    int s = 0;
    while(x){
      s+=x%10;
      x/=10;
    }
    return s;
  }

  int get_sum(pair<int, int> p){
    return get_single_number(p.first)+get_single_number(p.second);
  }

  // BFS
  int movingCount(int m, int n, int k){
    queue<pair<int,int>> q;
    vector<vector<bool>> visited(m, vector<bool>(n));
    // 步数
    int step = 0;
    // start 入队
    q.push({0, 0});

    int dx[4]={-1,1,0,0}, dy[4]={0,0,-1,1};

    while(!q.empty()){
      // 1.栈顶元素出队
      auto t = q.front();
      q.pop();

      // 该出队元素是否能走呢？
      // 决定是否能走后再添加其邻居点
      if(get_sum(t) > k || visited[t.first][t.second]) continue; // 即使符合范围也不能走，不访问，下一个点入队

      // 能走
      step++;
      // 标记已访问
      visited[t.first][t.second]=true;

      // 2.处理完栈顶元素，再添加其邻居点
      for(int i = 0; i<4 ;i++){
        int x = t.first + dx[i], y = t.second+dy[i];
        
        // 是否在这个范围
        if(x>=0 && x<m && y>=0 && y<n){ // 
          q.push({x,y});
        }
      }
    }

    return step;
  }
};