[算法日志]图论: 广度优先搜索(BFS)

[算法日志]图论: 广度优先搜索(BFS)

广度优先概论

​ 广度优先遍历也是一种常用的遍历图的算法策略,其思想是将本节点相关联的节点都遍历一遍后才切换到相关联节点重复本操作。这种遍历方式类似于对二叉树节点的层序遍历,即先遍历完子节点后再去遍历子节点的各个子节点。

代码框架

c++ 复制代码
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 表示四个方向
// grid 是地图,也就是一个二维数组
// visited标记访问过的节点,不要重复访问
// x,y 表示开始搜索节点的下标
void bfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
    queue<pair<int, int>> que; // 定义队列
    que.push({x, y}); // 起始节点加入队列
    visited[x][y] = true; // 只要加入队列,立刻标记为访问过的节点
    while(!que.empty()) { // 开始遍历队列里的元素
        pair<int ,int> cur = que.front(); 
        que.pop(); // 从队列取元素
        int curx = cur.first;
        int cury = cur.second; // 当前节点坐标
        for (int i = 0; i < 4; i++) { // 开始想当前节点的四个方向左右上下去遍历
            int nextx = curx + dir[i][0];
            int nexty = cury + dir[i][1]; // 获取周边四个方向的坐标
            if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 坐标越界了,直接跳过
            if (!visited[nextx][nexty]) { // 如果节点没被访问过
                que.push({nextx, nexty});  // 队列添加该节点为下一轮要遍历的节点
                visited[nextx][nexty] = true; // 只要加入队列立刻标记,避免重复访问
            }
        }
    }
}

通过队列辅助进行迭代操作是BFS的常用遍历手段(当然也可以使用栈),而除了会额外使用一个visited数组辅助进行路径判断,其他的步骤都可以照搬二叉树的层序遍历。

BFS的简单应用

leetcode 200(岛屿数量)

BFS示例代码

c++ 复制代码
 	const int dir[4][2] = { {0, -1}, {1, 0}, {0, 1}, {-1, 0} };
	void BFS(const vector<vector<char>>& g, vector<vector<bool>>& v, queue<pair<int,int>>& h)
	{
		while (!h.empty())
		{
			int X = h.front().first;
			int Y = h.front().second;
			h.pop();
			for (int i = 0; i < 4; ++i)
			{
				int nextX = X + dir[i][0];
				int nextY = Y + dir[i][1];
				if (nextX < 0 || nextY < 0 || nextX >= g[0].size() || nextY >= g.size())
					continue;
				if (!v[nextY][nextX] && g[nextY][nextX] == '1')
				{
					v[nextY][nextX] = true;
					h.push(pair<int, int>(nextX, nextY));
				}
			}
		}
		return;
	}
	int numIslands(const vector<vector<char>>& gird)
	{
		if (gird.empty())
			return 0;
		vector<vector<bool>> visited(gird.size(), vector<bool>(gird[0].size(), false));
		queue<pair<int, int>> help;
		int count = 0;
		for (int i = 0; i < gird.size(); ++i)
			for (int j = 0; j < gird[0].size(); ++j)
			{
				if (!visited[i][j] && gird[i][j] == '1')
				{
					++count;
					help.push({j, i});
					visited[i][j] = true;
					BFS(gird, visited, help);					
				}
			}
		return count;
	}

当然,对于这种岛屿问题并没有对遍历方式做限制,因此自然有DFS解法。

c++ 复制代码
	const int dir[4][2] = { {0, -1}, {1, 0}, {0, 1}, {-1, 0} };
	void DFS2(vector<vector<bool>>& v, int& c,int depth ,int nextX, int nextY)
	{
		if (depth > 0 && (nextX < 0 || nextY < 0 || nextX >= v[0].size()
			|| nextY >= v.size() || v[nextY][nextX]))
			return;
		for(int i = nextY; i < v.size(); ++i)
			for (int j = nextX; j < v[0].size(); ++j)
			{
				if (v[i][j])
				{
					if (depth > 0)
						return;
					continue;
				}
				if (depth == 0)
					++c;
				v[i][j] = true;
				for (int k = 0; k < 4; ++k)
				{
					DFS2(v, c, depth + 1, j + dir[k][0], i + dir[k][1]);
				}
			}
		return;
	}
	int numIslands1(const vector<vector<char>>& grid)
	{
		if (grid.empty())
			return 0;
		vector<vector<bool>> visited(grid.size(), vector<bool>(grid[0].size()));
		int count = 0;
		for (int i = 0; i < grid.size(); ++i)
			for (int j = 0; j < grid[0].size(); ++j)
			{
				if (grid[i][j] == '1')
					visited[i][j] = false;
				else
					visited[i][j] = true;
			}
		DFS2(visited, count, 0, 0, 0);
		return count;
	}
相关推荐
CoovallyAIHub2 小时前
港大&字节重磅发布DanceGRPO:突破视觉生成RLHF瓶颈,多项任务性能提升超180%!
深度学习·算法·计算机视觉
CoovallyAIHub2 小时前
英伟达ViPE重磅发布!解决3D感知难题,SLAM+深度学习完美融合(附带数据集下载地址)
深度学习·算法·计算机视觉
聚客AI19 小时前
🙋‍♀️Transformer训练与推理全流程:从输入处理到输出生成
人工智能·算法·llm
大怪v1 天前
前端:人工智能?我也会啊!来个花活,😎😎😎“自动驾驶”整起!
前端·javascript·算法
惯导马工1 天前
【论文导读】ORB-SLAM3:An Accurate Open-Source Library for Visual, Visual-Inertial and
深度学习·算法
骑自行车的码农1 天前
【React用到的一些算法】游标和栈
算法·react.js
博笙困了1 天前
AcWing学习——双指针算法
c++·算法
moonlifesudo1 天前
322:零钱兑换(三种方法)
算法
NAGNIP2 天前
大模型框架性能优化策略:延迟、吞吐量与成本权衡
算法
美团技术团队2 天前
LongCat-Flash:如何使用 SGLang 部署美团 Agentic 模型
人工智能·算法