DFS && BFS

最新推荐文章于 2024-07-12 16:15:47 发布
最新推荐文章于 2024-07-12 16:15:47 发布
阅读量814 收藏 18
点赞数 24
文章标签： 深度优先 宽度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80489323/article/details/135309962
版权

用DFS和BFS分别实现

//这边给出DFS的模版
void dfs(int x,int y)
{
	//判断是否到达终点（只有给出结束点的时候需要） 
	if (x == ex && y == ey) {
        if (min_steps > step) {
            min_steps = step;
        }
        return;
    }
	//给出移动方向
	int move[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
	//以当前的点为基础，开始搜索，搜索的路线为右遇到障碍物或者边界变成向下...... 
	for (int i = 0; i < 4; ++i) {
        int tx = x + move[i][0], ty = y + move[i][1];
        if (tx < 0 || tx >= m || ty < 0 || ty >= n) continue;
        if (a[tx][ty] == 0 && v[tx][ty] == 0) {
            v[tx][ty] = 1;//走过的点打上标记，防止再走一遍 
            dfs(tx, ty, step + 1);
            v[tx][ty] = 0;//由于回溯的需要，需要接触标记，找下一条路径 
        }
    }
    return;	
}

以下是完整的DFS代码

#include<bits/stdc++.h>
#define itn int
using namespace std;
int sx, sy, ex, ey;
int min_steps = 1000000;
int a[100][100];
int v[100][100];
int m, n;
void dfs(int x, int y, int step) {
    int move[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    if (x == ex && y == ey) {
        if (min_steps > step) {
            min_steps = step;
        }
        return;
    }
    for (int i = 0; i < 4; ++i) {
        int tx = x + move[i][0], ty = y + move[i][1];
        if (tx < 0 || tx >= m || ty < 0 || ty >= n) continue;
        if (a[tx][ty] == 0 && v[tx][ty] == 0) {
            v[tx][ty] = 1;
            dfs(tx, ty, step + 1);
            v[tx][ty] = 0;
        }
    }
    return;
}
int main() {
    cin >> sx >> sy >> ex >> ey;
    cin >> m >> n;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> a[i][j];
        }
    }
    v[sx][sy] = 1; 
    dfs(sx, sy, 0);  
    cout << "Minimum steps needed: " << min_steps << endl;
    return 0;
}

  BFS部分：

#include<bits/stdc++.h>
#define itn int
using namespace std;
struct Queue{
	int x;
	int y;
	int s;
};
int a[50][50];
int vis[50][50];
int main()
{
	struct Queue queue[2501];
	int sx,sy,ex,ey,n;
	int flag=0;
	cin>>sx>>sy>>ex>>ey>>n;
	for (int i=0;i<n;++i)
	{
		for (int j=0;j<n;++j)
		{
			cin>>a[i][j];
		}
	}
	int tail=0,head=0;
	queue[tail].x=sx,queue[tail].y=sy,queue[tail].s=0;
	int move[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
	while (head!=tail)
	{
		int x=queue[head].x,y=queue[head].y;
		for (int i=0;i<=3;++i)
		{
			int tx=x+move[i][0],ty=y+move[i][1];
			if (tx==ex && ty==ey)
			{
				flag=1;
				break;
			}
			if (tx<0 || tx>=n || ty<0 || ty<=n) continue;
			if (a[tx][ty]==0 && vis[tx][ty]==0)
			{
				vis[tx][ty]=1;
				queue[tail].x=tx;
				queue[tail].y=ty;
				queue[tail].s=queue[head].s+1;
				tail++;
			}
		}
		if (flag)break;
		head++;
	}
	cout<<queue[tail-1].s;
}

最大岛屿面积https://leetcode.cn/problems/max-area-of-island/description/

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：

输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。

示例 2：

输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

提示：

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 50
  • grid[i][j] 为 0 或 1

思路：套用搜索模版，找最大的岛屿的面积，只需要便利每一个岛的面积，然后定义一个最大值变量记录最大值就可以。


//BFS
struct Queue{
    int x;
    int y;
};
int vis[55][55];
int maxAreaOfIsland(int** grid, int gridSize, int* gridColSize) {
    struct Queue queue[1000000];
    int line=gridSize;
    int col=*gridColSize;
    int head=0,tail=0;
    int max=0;
    for (int i=0;i<line;++i)
    {
        for (int j=0;j<col;++j)
        {
            if (grid[i][j]==1)
            {
                queue[tail].x=i;
                queue[tail].y=j;
                tail++;
                vis[i][j]=1;
                int sum=1;
                int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
                while (head!=tail)
                {
                    int x=queue[head].x,y=queue[head].y;
                    for (int k=0;k<=3;++k)
                    {
                        int tx=x+move[k][0],ty=y+move[k][1];
                        if (tx<0 || tx>=line || ty<0 || ty>=col)continue;
                        if (grid[tx][ty]==1 && vis[tx][ty]==0)
                        {
                            vis[tx][ty]=1;
                            sum++;
                            queue[tail].x=tx;
                            queue[tail].y=ty;
                            tail++;
                        }
                    }
                    head++;
                }
                if (max<sum)max=sum;
            }   
        }
    }
    memset(vis, 0, sizeof(vis));
    return max;
}
//DFS
int line ,col;
int  dfs(int ** grid,int i,int j)
{
    if (i<0 || j>=col || i>=line || j<0 || grid[i][j]==0) return 0 ;
    grid[i][j]=0;
    return 1+dfs(grid,i+1,j)+dfs(grid,i-1,j)+dfs(grid,i,j+1)+dfs(grid,i,j-1);
}
int maxAreaOfIsland(int** grid, int gridSize, int* gridColSize) {
    line=gridSize;
    col=*gridColSize;
    int max=0;
    for (int i=0;i<line;++i)
    {
        for (int j=0;j<col;++j)
        {
            if (grid[i][j]==1)
            {
                int sum=dfs(grid,i,j);
                if (sum>max)max=sum;
            }
        }
    }
    return max;
}

填涂颜色https://www.luogu.com.cn/problem/P1162

题目描述

由数字 00 组成的方阵中，有一任意形状的由数字 11 构成的闭合圈。现要求把闭合圈内的所有空间都填写成 22。例如：6×66×6 的方阵（�=6n=6），涂色前和涂色后的方阵如下：

如果从某个 00 出发，只向上下左右 44 个方向移动且仅经过其他 00 的情况下，无法到达方阵的边界，就认为这个 00 在闭合圈内。闭合圈不一定是环形的，可以是任意形状，但保证闭合圈内的 00 是连通的（两两之间可以相互到达）。

0 0 0 0 0 0
0 0 0 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 0 1 0 1
1 1 1 1 1 1

0 0 0 0 0 0
0 0 0 1 1 1
0 1 1 2 2 1
1 1 2 2 2 1
1 2 2 1 2 1
1 1 1 1 1 1

输入格式

每组测试数据第一行一个整数 �(1≤�≤30)n(1≤n≤30)。

接下来 �n 行，由 00 和 11 组成的 �×�n×n 的方阵。

方阵内只有一个闭合圈，圈内至少有一个 00。

输出格式

已经填好数字 22 的完整方阵。

输入输出样例

输入 #1复制

6
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 0 0 0 1
1 1 1 1 1 1

输出 #1复制

0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 2 2 1
1 1 2 2 2 1
1 2 2 2 2 1
1 1 1 1 1 1

说明/提示

对于 100%100% 的数据，1≤�≤301≤n≤30。

思路：把1看作墙，遇到就停止搜索下去，但是要注意边界的情况，从边界开始搜索，那么剩下的0的是要变成2的。

#include<bits/stdc++.h>
using namespace std;
int a[35][35],b[35][35];
int n;
void dfs(int x, int y)
{
	int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
	for (int i=0;i<=3;++i)
	{
		int tx=x+move[i][0],ty=y+move[i][1];
		if (tx<0 || tx>=n || ty<0 ||ty>=n)continue;
		if (a[tx][ty]==0 && b[tx][ty]==0)
		{
			b[tx][ty]=1;
			dfs(tx,ty);
		}
	}
	return ;
}
int main()
{
	cin>>n;
	for (int i=0;i<n;++i)
	{
		for (int j=0;j<n;++j)
		{
			cin>>a[i][j];
		}
	}
	for (int i=0;i<n;++i)
	{
		if (a[i][0]==0)dfs(i,0);
		if (a[0][i]==0)dfs(0,i);
		if (a[i][n-1]==0)dfs(i,n-1);
		if (a[n-1][i]==0)dfs(n-1,i);
	}
	for (int i=0;i<n;++i)
	{
		for (int j=0;j<n;++j)
		{
			if (b[i][j]==0 && a[i][j]==0)
			{
				a[i][j]=2;
			}
		}
	}
	for (int i=0;i<n;++i)
	{
		for (int j=0;j<n;++j)
		{
			cout<<a[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}

自然数的拆分问题https://www.luogu.com.cn/problem/P2404

题目描述

任何一个大于 11 的自然数 �n，总可以拆分成若干个小于 �n 的自然数之和。现在给你一个自然数 �n，要求你求出 �n 的拆分成一些数字的和。每个拆分后的序列中的数字从小到大排序。然后你需要输出这些序列，其中字典序小的序列需要优先输出。

输入格式

输入：待拆分的自然数 �n。

输出格式

输出：若干数的加法式子。

输入输出样例

输入 #1复制

7

输出 #1复制

1+1+1+1+1+1+1
1+1+1+1+1+2
1+1+1+1+3
1+1+1+2+2
1+1+1+4
1+1+2+3
1+1+5
1+2+2+2
1+2+4
1+3+3
1+6
2+2+3
2+5
3+4

说明/提示

数据保证，2≤�≤82≤n≤8。

思路：主要掌握回溯的用法

#include<bits/stdc++.h>
using namespace std;
int a[35];
int n;
void dfs(int sum, int len, int last) {
    if (sum == n &&len!=1) {
        for (int j = 0; j < len - 1; ++j) {
            cout << a[j] << "+";
        }
        cout << a[len - 1] << endl;
        return;
    }
    for (int i = last; i <= n - sum; ++i) {
        a[len] = i;
        dfs(sum + i, len + 1, i); 
    }
}

int main() {
    cin >> n;
    dfs(0, 0, 1);
    return 0;
}

啊这泪目了
关注
  • 24
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构|图论DFS&&BFS_JavaScript
weixin_49179577的博客
02-19 196
首先需要明确深度优先遍历（BFS）和广度优先遍历（DFS）是怎么进行遍历的？ 可以参考一下这篇文章：漫画：深度优先遍历 和 广度优先遍历 知道了DFS和BFS后，我们可以用通俗的语言解释如何实现DFS和BFS DFS：从根节点开始，找子节点，再找子节点的子节点，…，直到没有子节点，那就返回上一层查找子节点 BFS：从根节点开始，找左右子节点，再按照先左后右的顺序【队列：先进先出】查找左右子节点的子节点 代码实现 BFS （广度优先搜索） 在这里插入代码片 ...
DFS&&BFS&&图.pptx
07-26
技术文档分享，免费获取请私信博主。
DFS&&BFS模板
Usher_Ou的博客
04-02 593
DFS模板 #include<cstdio> #include<cstring> #include<cstdlib> using namespace std; const int maxn=100; bool vst[maxn][maxn]; // 访问标记 int map[maxn][maxn]; // 坐标范围 int dir[4][2]= {0,1,0,-1,1,0,-1,0}; // 方向向
yp集之DFS&&BFS
MoRan0_0的博客
01-22 118
目录：DFS：BFS：BFS 中 起点到其点的最小距离拓展知识： DFS： #include<bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<int ,int> pii; typedef double db; vector<int> a[10]; int n,m; bool vis[12]; void dfs(int now){ vis[now]=1; for(
DFS&BFS
wqs12345612的博客
02-26 345
DFS&BFS 1.深度优先搜索 DFS解决什么问题 DFS解决的是连通性问题，即给定一个起始点（或某种起始状态）和一个终点（或某种最终状态），判断是否有一条路径能从起点连接到终点 很多情况下，连通的路径有很多条，只需要找出一条即可，DFS只关心路径存在与否，不在乎其长短 算法的思想 从起点出发，选择一个可选方向不断向前，直到无法继续为止 然后尝试另外一种方向，直到最后走到终点 深度优先搜索借助地数据结构是栈 DFS的递归实现 利用递归去实现DFS可以让代码看上去很简洁 递归的时候需要将当前程序种
DFS&&BFS总结
qq_46300524的博客
04-03 493
在dfs(int i)方法中，我们首先标记当前节点为已访问，并输出它的编号，然后遍历与它相连的所有节点，如果这些节点还没有被访问过，则递归访问它们。接着，我们循环处理队列中的节点，对于每个节点，我们输出它的编号，并把与它相连的所有未访问过的节点加入到队列中。3. 双向BFS问题：s到t的最短路。在main方法中，我们创建了一个BFS对象，并定义了一个5个节点的图，其中每个元素表示节点之间的连接关系。在main方法中，我们创建了一个DFS对象，并定义了一个5个节点的图，其中每个元素表示节点之间的连接关系。
javaScripts数据结构：dfs&&bfs
前端学习博客
02-27 72
javaScripts数据结构：dfs&&bfs dfs const graph = { 0: [1, 2], 1: [2], 2: [0, 3], 3: [3] }; const visited = new Set(); const dfs = (n) => { console.log(n); visited.add(n); graph[n].forEach(c => { if(!visited.has(c)){ dfs(c);
浅谈dfs&bfs
sjs_caomei的博客
08-06 804
dfs（深度优先搜索） bfs（广度优先搜索） 前言 作为初学者，可能会想，搜索吗，就是作用在图上啊，树上什么的算法。其实，搜索（这里主要说dfs和bfs），就是以一种特定方式，在大多数场景寻找真正想要结果的方式。而dfs就是以一种现已一种单一方式走到黑，然后通过回溯等得到答案的过程。而bfs则是先看有多少种方式可以走，然后先记录每一种方式，在一一按这种方式一层一层遍历，直到得到最后结果。这...
DFS & BFS 算法思想及例题
Alkali!的博客
01-29 1004
DFS 尽可能往深了搜，在一个结点处，只有搜不到了（当前所有路径都遍历完了）才有可能回溯。 回溯工作的重点在于恢复现场。 每个DFS都对应了一颗搜索树 BFS 每次只会扩展一层，只有周围这一层全部扩展完以后，才回去扩展下一层。 DFS 对比 BFS 数据结构 DFS： 栈 BFS：队列 空间 h为搜索树的高度 DFS： O（h） BFS：O（2h） DFS的空间更节省 BFS的“最短路”性质：每次扩展到的点和根的距离一定所有路径中距离最短的，DFS没有最短性（边的权重为1的情况下） 使用
dfs & bfs
xkayla
03-29 58
dfs 数据范围 5e4 代码 递归出口 剪枝 可以走的条件{ vis = 1; dfs(); vis = 0; } 优化 1 调整搜索顺序 2 剪枝 bfs 数据范围 1e6 代码 入队列 while(!que.empty()){ 队头元素 出队列 for(){ int dx,dy 是否越界,是否被访问过 } } ...
DFS&BFS&UCS&Astar.py
06-05
python实现八数码问题，代码可读性较好
数独DFS&BFS.cpp
08-13
在校初学者
搜索入门——BFS和DFS
12-18
从最基础的迷宫问题看深搜和宽搜的内涵，理解最基础的穷举搜索。
第二讲：复习专题之链表,指针,dfs&bfs.pptx
10-05
在C++编程语言中，链表、指针、深度优先搜索(DFS)和广度优先搜索(BFS)是重要的概念，这些概念在处理数据结构和算法时尤其关键。本讲将详细阐述这些主题。 首先，我们来看结构体，它是C++中定义自定义数据类型的一种...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5125
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 865
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
函数模板与类模板
程序员_小兵
07-12 1274
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
最新发布
熟悉python,matlab,C,C++,JAVA等
07-12 254
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
c语言bfs dfs
11-02
C语言中的BFS和DFS是图遍历算法，用于遍历图中的所有节点。其中BFS是广度优先搜索，DFS是深度优先搜索。 BFS算法从起始节点开始，先遍历所有与起始节点相邻的节点，再遍历与这些节点相邻的节点，以此类推，直到遍历...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值