我的深度搜索和广度搜索的学习------题目记录

最新推荐文章于 2024-04-10 14:29:25 发布
置顶 最新推荐文章于 2024-04-10 14:29:25 发布
阅读量304 收藏 1
点赞数 2
分类专栏： 小练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42261362/article/details/88385018
版权

一，深度搜索

1.数字的全排列

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int a[10];//这个数组中一个一个放排的 
int flag[10];//这个数组标记数字是否放入 
int n;
void dfs(int step){
	if(step==n+1){
		for(int i=1;i<=n;i++)
		cout<<a[i];
		cout<<endl;
	}
	for(int i=1;i<=n;i++){
		if(flag[i]==0){
			a[step]=i;
			flag[i]=1;
			dfs(step+1);
			flag[i]=0;
		}
	}
}
int  main(){
	cin>>n;
	dfs(1);
}

备注：一个数组进行标记，另一个数组进行放置的排列，一次排好以后输出排列结果；倒退回最近的一步进行选择再次进行排列。

2.二维数组寻找最少步数（走出迷宫最短步数）

（下标从1开始）

0 0 1 0

0 0 0 0

0 0 1 0

0 1 0 0

0 0 0 1

这样的一个5*4的矩阵，1代表路障，0可以走，从（1，1）出发，到（4，3）的位置

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int map[6][5];
int mins=999999;
bool flag[6][5]={false};
void dfs(int r,int c,int step){
	int tr=0,tc=0;
	int next[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
	if(r==4&&c==3){
		if(step<mins) mins=step;
		return;
	}
	for(int k=0;k<4;k++){
		tr=r+next[k][0];
		tc=c+next[k][1];
		if(tr>5||tr<1||tc>4||tc<1) continue;
		if(flag[tr][tc]==false&&map[tr][tc]==0){
			flag[tr][tc]=true;
			dfs(tr,tc,step+1);
			flag[tr][tc]=false;
		}
	}
	return;	
}
int main(){
	for(int i=1;i<6;i++){
		for(int j=1;j<5;j++){
			cin>>map[i][j];
		}
		cout<<endl;
	}
	flag[1][1]=true;
	dfs(1,1,0);
	cout<<mins;
}

备注：与第一题不同在于 1，变成二维数组，需要开设两个二维数组，一个进行标记，另一个进行排列；2，有步数的加入，每一次递归都加一次步数，到达终点时将步数与之前步数进行比较，输出最小步数；3，分方向，循环的条件变为现在所在位置的四个方向的选择。 

3.求岛屿的面积

在一张二维地图中，数字代表海拔，0代表大海，求某一个点（比如6，8）所在岛屿的面积

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int sum;
int x,y;
int map[11][11]={
	0,0,0,0,0,0,0,0,0,0,0,
	0,1,2,1,0,0,0,0,0,2,3,
	0,3,0,2,0,1,2,1,0,1,2,
	0,4,0,1,0,1,2,3,2,0,1,
	0,3,2,0,0,0,1,2,4,0,0,
	0,0,0,0,0,0,0,1,5,3,0,
	0,0,1,2,1,0,1,5,4,3,0,
	0,0,1,2,3,1,3,6,2,1,0,
	0,0,0,3,4,8,9,7,5,0,0,
	0,0,0,0,3,7,8,6,0,1,2,
	0,0,0,0,0,0,0,0,0,1,0
};
bool flag[11][11]={false};
void dfs(int r,int c){
	int next[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
	int tr=0,tc=0;
	for(int i=0;i<4;i++){
		tr=r+next[i][0];
		tc=c+next[i][1];
		if(tr>10||tr<1||tc>10||tc<1) continue;
		if(map[tr][tc]>0&&flag[tr][tc]==false){
			sum++;
			flag[tr][tc]=true;
			dfs(tr,tc);
		}
	}
	return;
}
int main(){
	cin>>x>>y;
	flag[x][y]=true;
	if(map[x][y]<=0){
		sum=0;cout<<sum;
		return 0;
	}
	else sum=1;
	dfs(x,y);
	cout<<sum;
}

备注：岛屿的面积，在dfs(tr,tc)之后，不需要将该点置于false，否则就变为路径的搜索。

 4.岛屿的数量

上题中有多少个岛屿

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int num=0;
int map[11][11]={
	0,0,0,0,0,0,0,0,0,0,0,
	0,1,2,1,0,0,0,0,0,2,3,
	0,3,0,2,0,1,2,1,0,1,2,
	0,4,0,1,0,1,2,3,2,0,1,
	0,3,2,0,0,0,1,2,4,0,0,
	0,0,0,0,0,0,0,1,5,3,0,
	0,0,1,2,1,0,1,5,4,3,0,
	0,0,1,2,3,1,3,6,2,1,0,
	0,0,0,3,4,8,9,7,5,0,0,
	0,0,0,0,3,7,8,6,0,1,2,
	0,0,0,0,0,0,0,0,0,1,0
};
bool flag[11][11]={false};
void dfs(int r,int c,int n){
	int next[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
	int tr=0,tc=0;
	map[r][c]=n;
	for(int i=0;i<4;i++){
		tr=r+next[i][0];
		tc=c+next[i][1];
		if(tr>10||tr<1||tc>10||tc<1) continue;
		if(map[tr][tc]>0&&flag[tr][tc]==false){
			flag[tr][tc]=true;
			dfs(tr,tc,n);
		}
	}
	return;
}
int main(){
	for(int i=0;i<11;i++){
		for(int j=0;j<11;j++){
			if(map[i][j]>0){
				num--;
				flag[i][j]=true;
				dfs(i,j,num);
			}
		}
	}
	cout<<-num;
}

备注： 从左上角开始遍历寻找，找到一个岛将它置于num--（并深度搜索与该岛屿相连的所有岛都置于该num--），相当于划分板块,-1,-2,-3...板块，最后一个板块的负即为岛屿的个数了。

5.方格填数

如下的10个格子

填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）

一共有多少种可能的填数方案？

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int sum=0;
int num[3][4];
bool isfilled[10];
bool islegal(int r, int c, int val)
//第一排检查左右，第一列检查上和右上，第三列检查上，上左，左，其余检查左，上左，上，上右；
{
    if( r == 0 )
        return abs(val-num[r][c-1]) > 1;
    else if( c == 0 )
        return abs(val-num[r-1][c]) > 1 && abs(val-num[r-1][c+1])>1;
    else if( c != 3 )
        return abs(val-num[r][c-1]) > 1 && abs(val-num[r-1][c]) > 1 && abs(val-num[r-1][c-1])>1 && abs(val-num[r-1][c+1])>1;
    else
        return abs(val-num[r][c-1]) > 1 && abs(val-num[r-1][c]) > 1 && abs(val-num[r-1][c-1])>1;
}
void DFS(int  r,int c){
	if(r==2&&c==3){
		sum++;
		return ;
	}
	for(int i=0;i<10;i++){
		if(!isfilled[i]&&islegal(r,c,i)){
			num[r][c]=i;
			isfilled[i]=true;
			DFS(r+(c+1)/4,(c+1)%4);
//	if(c==3) DFS(r+1,0);
//  else DFS(r,c+1);
			isfilled[i]=false;
		}
	}
} 
int main(){
	num[0][0]=-10;
	num[2][3]=-10;
	for(int i=0;i<10;i++){
		isfilled[i]=false;
	}
	DFS(0,1);
	cout<<sum;
	return 0;
}

 6.寒假作业

每个方块代表1~13中的某一个数字，但不能重复。
比如：
 6  + 7 = 13
 9  - 8 = 1
 3  * 4 = 12
 10 / 2 = 5

以及： 
 7  + 6 = 13
 9  - 8 = 1
 3  * 4 = 12
 10 / 2 = 5

就算两种解法。（加法，乘法交换律后算不同的方案）

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int a[4][3];
int flag[14]={false};
int sum=0;
bool islegal(int r,int i){
	if(r==0){
		return a[r][0]+a[r][1]==i;
	}
	else if(r==1){
		return a[r][0]-a[r][1]==i;
	}
	else if(r==2){
		return a[r][0]*a[r][1]==i;
	}
	else if(r==3){
		return a[r][1]*i==a[r][0];
	}
	else return false;
}
void dfs(int r,int c){
	if(r==4){
		sum++;
		return;
	}
	for(int i=1;i<14;i++){
		if(!flag[i]){
			flag[i]=true;
			if(c!=2||islegal(r,i)){
				a[r][c]=i;
				dfs(r+(c+1)/3,(c+1)%3);
			}
					flag[i]=false;
			}
		}
	}
int main(){
	dfs(0,0);
	cout<<sum;
}

7.方格分割

6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图：p1.png, p2.png, p3.png 就是可行的分割法

试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法

式例

//以线进行分割，0-6；

#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#include <cstring>
#define MAX 100000
using namespace  std;
int map[7][7];
bool flag[7][7]={false};
int ans=0;
int next[4][2]={0,1,0,-1,1,0,-1,0};
void dfs(int r,int c){
	if(r==0||c==0||r==6||c==6){
		ans++;
		return;
	}
	for(int i=0;i<4;i++){
		int tr=r+next[i][0];
		int tc=c+next[i][1];
	//	if(tr<0||tc<0||tr>6||tc>6) continue;
		if(flag[tr][tc]==false){
			flag[tr][tc]=true;//
			flag[6-tr][6-tc]=true;
			dfs(tr,tc);
			flag[tr][tc]=false;
			flag[6-tr][6-tc]=false;
		}
	}
}
int main(){
	flag[3][3]=true;
	dfs(3,3);
	cout<<ans/4;
}

8.全球变暖

//蓝桥 ，用深搜写 太累了  ，先贴上，后补写广搜

#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#include <cstring>
#define MAX 100
using namespace std;
int n;
int map[MAX][MAX];
bool flag[MAX][MAX]={false};
void dfs(int r,int c,int val){
	int next[4][2]={0,1,0,-1,1,0,-1,0};
	int tr=0,tc=0;
	map[tr][tc]=val;
	for(int i=0;i<4;i++){
		 tr=r+next[i][0];
		 tc=c+next[i][1];
		if(tr<0||tc<0||tr>=n||tc>=n) continue;
		if(map[tr][tc]>1&&flag[tr][tc]==false) dfs(tr,tc,val);
	}
}
int main(){
	cin>>n;
	char ch;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			cin>>ch;
			if(ch=='.') map[i][j]=0;
			else map[i][j]=1;
		}
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(map[i][j]==1){
				if(map[i-1][j]==1&&map[i+1][j]==1&&map[i][j+1]==1&&map[i][j-1]==1)
				map[i][j]=2;
			}
		}
	}
	int ans=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(map[i][j]>1){
				ans--;
				flag[i][j]=true;
				dfs(i,j,ans);
			}
		}
	}
	cout<<-ans;
//	for(int i=0;i<n;i++){
//		for(int j=0;j<n;j++){
//			cout<<map[i][j];
//		}
//		cout<<endl;
//	}
	
}

 

这两个博客写的很好，我看得第一个文章介绍，做的第二个题目。

算法入门

深度优先的八个简单小栗子

二、广度搜索

1.在一个n*m（n行, m列）的迷宫中，存在着一个入口、一些墙壁以及一个宝藏。由于迷宫是四连通的，即在迷宫中的一个位置，只能走到与它直接相邻的其他四个位置（上、下、左、右）。现洪尼玛在迷宫的入口处，问他最少需要走几步才能拿到宝藏？若永远无法拿到宝藏，则输出-1。

输入样例1：

3 3

S.#

.#.

.#E

输出 -1

输入样例2：

5 5

S.#..

#.#.#

#.#.#

#...E

#....

输出 7

#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#define MAX 101
using namespace  std;
char map[MAX][MAX];
bool vis[MAX][MAX]={false};//标记是否已经访问
struct point{//结构体存储该点的信息情况
	int r,c,num;
	point(int rr,int cc,int nn){
		r=rr;
		c=cc;
		num=nn;//搜索的范围（逐步扩大）
	}
};
int next[4][2]={1,0,-1,0,0,1,0,-1};
int flag,val,num=0;
int n,m;
queue<point> q;//用赌队列进行维护
void bfs(int sr,int sc){
	q.push(point(sr,sc,0));
	vis[sr][sc]=true;
	while(!q.empty()){
		point p=q.front();//p存储队列第一位的信息
		q.pop();
		if(map[p.r][p.c]=='E'){
			val=p.num;
			flag=1;
			break;
		}
		for(int i=0;i<4;i++){
		   	int tr=p.r+next[i][0];
			int tc=p.c+next[i][1];
			if(tr<0||tc<0||tr>=n||tc>=m) continue;//不可越界 
			if(map[tr][tc]!= '#'&&vis[tr][tc]==false){//判断条件
				q.push(point(tr,tc,p.num+1));
				vis[tr][tc]=true;
			}
		}
	}
}
int main(){
	flag=0;
	int r1,c1;
	cin>>n>>m;
	for(int i=0;i<n;i++){//赋值
		cin>>map[i];
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(map[i][j]=='S'){//标记起点
				r1=i;
				c1=j;
			}
		}
	}	
	bfs(r1,c1);
	if(flag==0) cout<<"-1";
	else cout<<val;
	return 0;
}

 

 

三鱼在熬汤
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
深度优先搜索 题集
Eason5108的博客
07-13 527
下面我将给大家带来几道深度优先搜索的题。
深度优先搜索和广度优先搜索
weixin_42269028的博客
08-17 698
明天要面试，这次我必须好好准备一下了，学习吧！今天凌晨记住尼采的一本书名，好长的，《查拉图斯特拉如是说》。我还看了一部分《三体：黑色森林（下部）》和《房思琪的初恋乐园》几章，说心里话看书真的可以让我放下好多没用的孤寂，无论怎么说，永远记住：我思故我在，努力地上进，努力地思考，努力地记忆，努力地努力。就这样吧，努力：奋斗！............
深度优先搜索题目（DFS）
2301_80841939的博客
01-26 677
DFS，是一种常用的图遍历算法，用于在图或树数据结构中遍历所有节点。沿着一条路径尽可能的深入，无法深入时便会返回。
深度搜索
qq_44238714的博客
04-08 1632
深度搜索： 深度搜索的方法： （1）访问顶点v； （2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问； （3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。　当然，当人们刚刚掌握深度优先搜索的时候常常用它来走迷宫. 例题：迷宫问题 有一天，傻子A一个人去迷宫玩，但是他的方向感并不是很好，所...
深搜(DFS) 之 一些简单例题
shiyansama的博客
07-17 497
深搜(DFS) 之 一些简单例题 深度优先搜索( DFS, Depth-First Search)是搜索的手段之-一 。它从某个状态开始，不断地转移 状态直到无法转移，然后回退到前一步的状态 ，继续转移到其他状态，如此不断重复，直至找到 最终的解。 例如求解数独，首先在某个格子内填人适当的数字，然后再继续在下一个格子内填入 数字，如此继续下去。如果发现某个格子无解了，就放弃前一个格子上选择的数字，改用其他可 行的数字。 根据深度优先搜索的特点，采用递归函数实现比较简单。 部分和问题 题目 给定整数a1、a2
算法基础 第8章 广度优先搜索-2021-02-17.pdf
02-17
3. **最优性**：如果目标节点的“成本”与其在图中的深度成正比，则广度优先搜索能够保证找到最小成本的解决方案。 4. **效率问题**：广度优先搜索的效率取决于目标节点的位置。如果目标节点位于较深的位置，则需要...
Online-Judge-Codes:我的ACM OI编码记录
05-01
这些代码可能包含了经典的排序算法（如快速排序、归并排序）、搜索算法（如深度优先搜索、广度优先搜索）、图论算法（如最短路径算法Dijkstra、最小生成树算法Kruskal或Prim）、动态规划（DP）、回溯法、分治策略等...
LeetCode-Challenges-2021：我针对leetcode挑战的解决方案集合
02-08
9. **算法与数据结构**：如排序算法（快速排序、归并排序）、搜索算法（二分查找、深度优先搜索、广度优先搜索）、动态规划、贪心策略等，这些都是解题的核心。 通过阅读和学习这个压缩包中的代码，你不仅可以加深...
数据结构实践环节考核指导精品-doc(常用版).doc
12-02
4. 图的遍历：考察对有向图和无向图的深度优先搜索（DFS）和广度优先搜索（BFS），可以使用邻接矩阵或邻接表作为存储结构。 5. 数据查找：实现顺序查找、折半查找和二叉排序查找，并比较它们的效率。 6. 排序：...
leetCode-day-pratice:每日练习，开发遇到的问题，技术笔记
03-19
3. **问题分类**：根据 LeetCode 的分类，可能涵盖了二分查找、回溯、动态规划、贪心算法、深度优先搜索、广度优先搜索等多种算法类别。 4. **编程技巧**：如何优化代码，减少时间复杂度，提高效率，可能还包括一些...
深度优先搜索练习1
axuhongbo的博客
02-20 427
深度优先搜索练习1
深度优先搜索的几道题目
weixin_44288817的博客
06-05 835
感觉还是比动规简单一些的……但是最近脑子有点糊。 首先是要注意邻接表是有两种的，在稀疏图中，最好用vector存每个顶点的边的信息，而不是稠密图中的G[x][y]。 第二是步数最少的路径……存path然后把path拷贝到bestpath……要不然会乱。我犯了很多次傻然后后面debug。这个错误很蠢但是我一开始也没想清楚。 下面是一些具体问题。 百练2815 城堡问题 基本上可以算一个连通图的模板题...
算法学习-深度优先搜索
qq_40079310的博客
07-12 183
算法学习-深度优先搜索 1：总览深度优先搜索 深度优先搜索（缩写DFS）有点类似广度优先搜索，也是对一个连通图进行遍历的算法。它的思想是从一个顶点V0开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底，这种尽量往深处走的概念即是深度优先的概念。 2：和广度优先搜索的对比 广度优先搜索(BFS)是按照一个树的层次来完成搜索的。 缺点：当树的层次较深...
深度优先搜索常见习题类型（一）
snowwolf_tal的博客
07-10 401
在上一篇文章中，我们了解了深搜及其相关概念，那么这篇文章就为大家带来几个关于深搜常考的题型（题型名称自己总结，见谅）这便是深搜中我个人觉得一类最常考的题和最有意思的题，如果有什么不足或错误地方欢迎指正，我会在日后根据你们的意见不断改正这篇文章。
深度搜索、广度搜索及经典例题(上)
qq_34603425的博客
07-17 874
搜索从初始状态，通过某种转化到中间状态，最终转化到终极状态的过程。深度搜索先不断从某一方向进行状态转化，直到无法转化，最后再回溯地向其他方向转化搜索。广度搜索先找到转化一步能遍历到哪些状态，然后找到转化两部能到达的状态，直到找到最终的状态。深搜和广搜的本质穷举遍历。深搜一般用递归实现，广搜一般用队列实现。...............
hdu 1312 DFS深度搜索典型例题
楼上小宇___home
03-18 1036
题目链接 Problem Description There is a rectangular room, covered with square tiles. Each tile is colored either red or black. A man is standing on a black tile. From a tile, he can move to one of f
第一部分 基础算法（第四章 深度优先搜索）例题
蒟蒻こんにゃく
01-07 633
例题一：拔河比赛 link 思路： 考虑条件（1）,显然只用构造一个大小为n/2的组 考虑条件（2），显然两个组的体重之和是固定的， 记所有人的体重和为S, 则我们只用考虑构造出来的每一个的体重和尽可能接近S/2即可。 通过dfs函数来完成以上操作， 有一个三元组（x,y,z）描述当前状态（第x位成员，已选y个人，体重和为z） #include <cstdio> #include <iostream> #include <cmath> using namespace
算法学习 深度优先搜索 DFS
weixin_62888410的博客
04-13 728
DFS学习
【数据结构与算法】搜索算法（深度优先搜索 DFS和广度优先搜索 BFS）以及典型算法例题
最新发布
ChenZHIHAO_y的博客
04-10 3604
深度优先搜索 和广度优先搜索！！！【数据结构与算法】搜索算法（深度优先搜索 DFS和广度优先搜索 BFS）以及典型算法例
2018年OCP-052考试新增题库解析与重点知识点
这次更新的特点在于在原有题库的基础上增加了新的考题，强调了对现有知识的深度理解和广度覆盖。以下是针对部分新增题目及概念的详细解析： 1. 题目19涉及数据库结构：哪三种结构可以跨越多个数据文件？答案是A) ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值