【算法】搜索练习

最新推荐文章于 2022-02-07 20:29:26 发布
最新推荐文章于 2022-02-07 20:29:26 发布
阅读量175 收藏 1
点赞数
分类专栏： 算法 文章标签： bfs dfs 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/karshey/article/details/118480086
版权

DFS

注意搜索的顺序，是以树的形式。

Lake Counting

原题
在这里插入图片描述
输入

10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.

输出

3

题意：有几个水池。
思路：DFS，遇到连接的水池就继续搜，断开之后就记录。用dis[8][2]代表8个方向。范围是从1–n（列），1–m（行）。（通常x是横坐标，但是其实只要x在代码里的含义从一而终，都是可以过的，在这里x代表列（纵坐标））

注意：由于输入是没有空格的，直接以字符数组%s的形式输入会快：

for(int i=1;i<=n;i++)//n是列，从1开始
	{
		scanf("%s",mp[i]+1);//从1开始 
	}

总：
模板题

//DFS
#include<bits/stdc++.h>
using namespace std;
const int N=105,M=105;
int n,m;
char mp[N][M];
int dis[8][2]={-1,0,1,0,0,-1,0,1,-1,-1,-1,1,1,-1,1,1};
int v[N][M];
void dfs(int x,int y)
{
	v[x][y]=1;
	for(int i=0;i<8;i++)
	{
		int dx=x+dis[i][0];
		int dy=y+dis[i][1];
		//范围x:1~n,y:1~m 
		if(dx>=1&&dx<=n&&dy>=1&&dy<=m&&!v[dx][dy]&&mp[dx][dy]=='W')
		{
			dfs(dx,dy);
		}
	}
}
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)//n是列 
	{
		scanf("%s",mp[i]+1);//从1开始 
	}
	
	int ans=0;
	for(int i=1;i<=n;i++)//列循环在外 
	{
		for(int j=1;j<=m;j++)
		{
			if(mp[i][j]=='W'&&!v[i][j])
			{
				ans++;
				dfs(i,j);
			}
		}
	}
	cout<<ans;
	return 0;
}

Oil Deposits

题目链接
在这里插入图片描述
输入：

1 1
*
3 5
*@*@*
**@**
*@*@*
1 8
@@****@*
5 5 
****@
*@@*@
*@**@
@@@*@
@@**@
0 0

输出：

0
1
2
2

跟上面的水池问题其实一样。DFS即可。
如果发现输出不对可能是方向错了，如果发现输出多很多可能是条件少了…

//#include<bits/stdc++.h>
#include<iostream>
#include<string.h>
using namespace std;
const int N=105;
//@有oil 可以斜着 diagonally

int dis[8][2]={1,0,-1,0,0,1,0,-1,1,1,1,-1,-1,1,-1,-1};
char mp[N][N];
int ans=0;
int v[N][N];
int n,m;
void dfs(int x,int y)
{
	v[x][y]=1;
	for(int i=0;i<8;i++)
	{
		int xx=x+dis[i][0];
		int yy=y+dis[i][1];
		
		if(xx>=1&&xx<=n&&yy>=1&&yy<=m&&!v[xx][yy]&&mp[xx][yy]=='@')
		{					
			dfs(xx,yy);
		}
	}
}
int main()
{	
	while(cin>>n>>m&&(n&&m))
	{
		
		for(int i=1;i<=n;i++)//列
		{
			for(int j=1;j<=m;j++)
			{
				cin>>mp[i][j];
			}
		}
		ans=0;
		memset(v,0,sizeof(v));
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				if(!v[i][j]&&mp[i][j]=='@')
				{
					ans++;
					dfs(i,j);
					//cout<<i<<" "<<j<<endl;
				}
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}

棋盘问题

原题
在这里插入图片描述
输入：

2 1
#.
.#
4 4
...#
..#.
.#..
#...
-1 -1

输出：

2
1

因为每列最多只能有一个棋子，因为v可以用来记录此列是否有过棋子。

判断方法1：从右到左搜到头了，方案数+1；

//DFS
#include<bits/stdc++.h>
using namespace std;
const int N=10;
int v[N];//记录此列是否有过
char mp[N][N];
int n,m; 
int ans=0;
void dfs(int x,int y)
{
	if(y==0) //从右向左搜到头了 
	{
		ans++;
		return;
	}
	if(x>n) return;//x超出范围了
	 
	for(int i=1;i<=n;i++)//每一列从左到右 
	{		
		if(mp[x][i]=='#'&&!v[i])//可以放棋子且没搜过
		{
			v[i]=1;
			dfs(x+1,y-1);//下一行的左一列
			v[i]=0;//搜完一轮后所有列清0； 
		 } 		 
	}
	dfs(x+1,y);
}
int main()
{
	while(cin>>n>>m&&n!=-1)
	{
		memset(v,0,sizeof(v));
		ans=0;
		for(int i=1;i<=n;i++)
		{
			scanf("%s",mp[i]+1);
		}
		
		dfs(1,m);//从右上角开始搜 
		
		cout<<ans<<endl;
	}
}

判断方法2：定义一个全局变量cheer来记录棋子数量，若cheer=要求的棋子数则方案数+1，记住cheer在搜索完之后要–（退回来后要取消标记，当作已经计算过这种情况，后重新计算别的情况 ）；
这里h代表行，v代表那一列有过棋子。一行行往下搜。

//DFS
#include<bits/stdc++.h>
using namespace std;
const int N=10;
char mp[N][N];
int n,k;
int cheer=0,ans=0;
int v[N];
void dfs(int h)
{
	if(cheer==k) 
	{
		ans++;
		return;
	}
	if(h>n) return;
	for(int i=1;i<=n;i++)
	{
		if(!v[i]&&mp[h][i]=='#')
		{
			v[i]=1;
			cheer++;
			dfs(h+1);
			v[i]=0;//退回来后要取消标记，当作已经计算过这种情况，后重新计算别的情况 
			cheer--;
		}
	}
	dfs(h+1);
}
int main()
{
	while(cin>>n>>k&&(n!=-1))
	{
		memset(v,0,sizeof(v));
		for(int i=1;i<=n;i++)
		{
			scanf("%s",mp[i]+1);
		}
		
		ans=0;
		cheer=0;
		dfs(1);
		cout<<ans<<endl; 
	}
}

BFS

Catch That Cow-HDU 2717

在这里插入图片描述

大意：多个样例，人抓牛，牛在K，人在N。人有两种走法，一步法的是向前一步或向后移，瞬移法是从n到2n，求抓到牛的最短时间。

此题是BFS，不是贪心
思路：从当前位置n开始，把所有可能到达的点搜索一遍。遇到k位置就输出时间。
注意：

  • 范围，由于可以到达两倍的距离，所以范围是0~3*k。（因为可以超过k）
  • 由于BFS是一圈一圈地搜索，每次记录的时间就已经是最短时间。（之后再记录就是下一圈，时间会边长，故第一次记录的是最短的）

模板题

//BFS
//#include<iostream>
//#include<queue>
//#include<string.h>
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+5;
struct node
{
	int pos,dis;
}a[N];
int vis[N];
int main()
{
	int n,k;
	while(cin>>n>>k)
	{
		memset(vis,0,sizeof(vis));
		queue<node>q;
		q.push({n,0});
		vis[n]=1;
		int ans=0;
		while(!q.empty())
		{
			node temp=q.front();
			if(temp.pos==k)
			{
				ans=temp.dis;
				break;
			}
			q.pop();
			if(vis[temp.pos+1]==0&&temp.pos+1<=3*k) {q.push({temp.pos+1,temp.dis+1});vis[temp.pos+1]=1;}
			if(vis[temp.pos-1]==0&&temp.pos-1>=0) {q.push({temp.pos-1,temp.dis+1});vis[temp.pos-1]=1;}
			if(vis[temp.pos*2]==0&&temp.pos*2<=3*k) {q.push({temp.pos*2,temp.dis+1});vis[temp.pos*2]=1;}
		}
		cout<<ans<<endl;
	}
	
	return 0;
}

Dungeon Master

原题
在这里插入图片描述
输入：

3 4 5
S....
.###.
.##..
###.#

#####
#####
##.##
##...

#####
#####
#.###
####E

1 3 3
S##
#E#
###

0 0 0

输出：

Escaped in 11 minute(s).
Trapped!

三维的。模板题。BFS。

//BFS 最短时间 
//L——lever;R---rows; C---colums
//每行C个字符 #不可走 .可走 
#include<bits/stdc++.h>
using namespace std;
const int N=35;
char mp[N][N][N];
//int v[N][N][N];
int l,r,c;

struct node
{
	int x,y,z;//坐标
	int min;//时间 
};

int dx[6]={-1,1,0,0,0,0};
int dy[6]={0,0,-1,1,0,0};
int dz[6]={0,0,0,0,-1,1};
int dis[N][N][N];
int sx,sy,sz,ex,ey,ez;
int bfs(int x,int y,int z)
{
	memset(dis,-1,sizeof(dis));
	dis[x][y][z]=0;
	queue<node>q;
	q.push({x,y,z,0});
	while(!q.empty())
	{
		node temp=q.front();
		q.pop();
		
		for(int i=0;i<6;i++)
		{
			int xx=temp.x+dx[i];
			int yy=temp.y+dy[i];
			int zz=temp.z+dz[i];
			
			if(dis[xx][yy][zz]==-1&&mp[xx][yy][zz]=='.'&&xx>0&&xx<=l&&yy>0&&yy<=r&&zz>0&&zz<=c)
			{				
				dis[xx][yy][zz]=temp.min+1;
				q.push({xx,yy,zz,temp.min+1});
			}
		}
	}
	
	return dis[ex][ey][ez];
}

int main() 
{
	while(cin>>l>>r>>c&&(l&&r&&c))
	{
		//memset(v,0,sizeof(v));	
		for(int i=1;i<=l;i++)
		{
			for(int j=1;j<=r;j++)
			{
				for(int k=1;k<=c;k++)
				{
					cin>>mp[i][j][k];
					if(mp[i][j][k]=='S') 
					{
						sx=i;sy=j;sz=k;
					}
					else if(mp[i][j][k]=='E')
					{
						ex=i;ey=j;ez=k;
						mp[i][j][k]='.';
					}
				}
			}
			getchar();
		}//三维输入 
		
		dis[sx][sy][sz]=0;
		int ans=bfs(sx,sy,sz);
		if(ans!=-1) cout<<"Escaped in "<<ans<<" minute(s)."<<endl;
		else cout<<"Trapped!"<<endl;
		
	}//while
}

迷宫问题

原题
在这里插入图片描述
在这里插入图片描述
最短路，BFS，要形成一条路就要存下每一个点的前一个点。
最后从右下角的点开始把每一个前结点存在一个vector里，后一起输出。
注意格式。

//BFS
#include<bits/stdc++.h>
//#include<iostream>
//#include<queue>
//#include<vector>
using namespace std;
const int N=7;
int mp[N][N];
int v[N][N];
int road[N][N][2];
struct node
{
	int x,y;
};

int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int main()
{
	for(int i=0;i<=4;i++)
	{
		for(int j=0;j<=4;j++)
		{
			cin>>mp[i][j];
		}
	}
	
	queue<node>q;
	q.push({0,0});
	v[0][0]=1;
	while(!q.empty())
	{
		int x=q.front().x,y=q.front().y;
		q.pop();
		
		if(x==4&&y==4)
		{
			int tx=x,ty=y;
			vector<node>vv;
			while(tx||ty)
			{
				vv.push_back({tx,ty});
				int t1=tx,t2=ty;
				tx=road[t1][t2][0];
				ty=road[t1][t2][1];//用t1t2存txty，因为到这一步tx会变 
			}
			vv.push_back({0,0});
			
			while(!vv.empty()) 
			{
				node temp=vv.back();
				vv.pop_back();
				printf("(%d, %d)\n",temp.x,temp.y);
			}
			return 0;
		}
		
		for(int i=0;i<4;i++)
		{
			int xx=x+dx[i],yy=y+dy[i];
			if(xx>=0&&xx<5&&yy>=0&&yy<5&&!v[xx][yy]&&!mp[xx][yy])
			{
				road[xx][yy][0]=x;
				road[xx][yy][1]=y;//存前
				q.push({xx,yy}); 
				v[xx][yy]=1;
			}
		}
	}
	return 0;
}
karshey
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
算法题目 搜索
coding
09-24 624
目录BFSDFS动态规划排列问题组合问题 BFS DFS 动态规划 Backtracking（回溯）属于 DFS。 普通 DFS 主要用在 可达性问题 ，这种问题只需要执行到特点的位置然后返回即可。 Backtracking 主要用于求解 排列组合 问题，例如有 { ‘a’,‘b’,‘c’ } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求...
【算法】搜索算法
weixin_44062380的博客
07-27 3712
文章目录搜索算法一、深度优先695 - 岛屿的最大面积题目思路题解547 - 省份数量（未完成）题目思路题解417 - 太平洋大西洋水流问题题目思路题解二、回溯46 - 全排列题目思路题解77 - 组合题目思路题解79 - 单词搜索题目思考题解51 - N皇后问题题目思考题解三、广度优先934 - 最短的桥题目思考题解126 - 单词接龙2题目小结深度优先(DFS)和广度优先(BFS)的区别 搜索算法 搜索算法分为深度优先和广度优先，常用在树和图的搜索上面 树的 DFS 和 BFS 比较容易，我这里不会介绍
Java编程题：搜索算法（汇总）
长不大的大灰狼
06-29 634
搜索算法（汇总） 搜索算法就是去搜索每一个解的可能。 搜索算法的分类： 枚举法：暴力搜索 深度优先搜索 广度优先搜索 回溯 目录搜索算法（汇总）Ⅰ 深度优先搜索（1）放牌（2）员工的重要性（3）图像渲染（4）被围绕的区域（5）岛屿数量Ⅱ 广度优先搜索（1）员工的重要性（2）N叉树的层序遍历（3）腐烂的橘子（4）单词接龙（5）打开转盘锁 Ⅰ 深度优先搜索 Dfs(当前这一步的处理逻辑) { 1.判断边界，是否已经到头了：向上回退 2.尝试当下的每一种可能 3.确定一种可能之后，继续下一步Dfs } （1
搜索算法dfs和bfs解析(附有例题）
秋名山码民的技术小屋
02-07 2103
文章目录前言dfsdfs全排列问题dfs N皇后问题最长快乐字符串二叉树的最近祖先bfs 前言 本文我们主要来介绍dfs和bfs的基础知识在加以几个必要的习题说明，搜索算法dfs和bfs dfs 深度优先搜索算法（简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。
【算法题归纳合集】搜索-最短路模型
一只快乐的小蒟蒻~
10-29 204
一、AcWing 1076. 迷宫问题 【题目描述】 给定一个由0,10,10,1组成的n×nn×nn×n的二维数组。 它表示一个迷宫，111表示墙壁，000表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 数据保证至少存在一条从左上角走到右下角的路径。 【输入格式】 第一行包含整数nnn。 接下来nnn行，每行包含nnn个整数000或111，表示迷宫。 【输出格式】 输出从左上角到右下角的最短路线，如果答案不唯一，输出任意一条路径均可。 按顺序，每行输出一个路径中
算法第四版练习题答案
热门推荐
山海經的博客
11-15 1万+
算法第4版练习题答案 Algorithms 4th edition exercise answers. 1 FUNDAMENTALS 1.2.13 Transaction.java transactiondatatype 1.2.16 Rational.java rationalnumb
算法练习
qq_38364448的博客
12-27 2117
算法 一、 选择题 1、 算法是若干指令的有穷序列，满足性质：（ ） A、输入、输出、确定性、不确定性 B、输入、输出、确定性、有限性 C、输入、计算、确定性、不确定性 D、输入、输出、无限性、有限性 2、 程序是算法用某种程序设计语言的具体实现,程序与算法的主要区别在于（ ） A、输入方式不同 B、输出方式不同 C、有无确定性 D、是否存在有限性 3、 程序是算法...
《算法设计》Kleinberg 练习 答案
03-31
通过解答《算法设计》中的练习，你可以加深对这些算法和概念的理解，提高解决问题的能力。实践中遇到的具体问题和解题思路将有助于你在实际编程和项目中灵活运用这些知识。同时，这也有助于准备各种编程竞赛和面试，...
算法设计练习源代码
04-12
这份名为"算法设计练习源代码"的压缩包显然包含了作者在学习算法设计过程中编写的源代码，这些代码可能涵盖了各种算法和数据结构，旨在帮助其他学习者理解和实践算法设计。下面，我们将深入探讨这些可能包含的知识点...
算法练习题
03-18
在算法的世界里，练习是提升技能的关键步骤。"算法练习题"这个压缩包提供了一系列的基础算法题目，旨在帮助我们磨炼编程思维，提高解决问题的能力。这些题目覆盖了各种常见的算法类型，包括排序、搜索、图论、动态...
java语言练习算法.zip
最新发布
06-26
Java中的算法练习通常涵盖排序、搜索、图论、动态规划等多个方面。例如，"algorithm-questions-master"可能是一个包含各种算法问题的代码库，可能包括经典的排序算法如冒泡排序、选择排序、插入排序、快速排序、归并...
java经典算法练习题
11-02
本压缩包包含了三个文档，分别是“JAVA经典算法40题.doc”、“最新JAVA编程题全集_50题及答案.doc”和“50道JAVA基础编程练习题.doc”，这些资源为初学者提供了大量的实践机会，有助于深入理解和运用Java。...
一些值得注意的算法题——搜索、查找
今天你学习了吗
03-07 155
240. 搜索二维矩阵Ⅱ // 从右上角开始搜索，保证不会错过元素 class Solution { public boolean searchMatrix(int[][] matrix, int target) { if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false; int i = 0, j = matrix[0].length - 1; while (i <
第九章　查找练习题
奋斗的PIG
04-25 9153
原文地址：第九章　查找练习题作者：tanzj 1、在对有二十个数据有序表作二分查找时有___________个结点的查找长度是4. 2、用折半查找法的查找速度比用顺序查找法的查找速度_________.       A  必然慢   B必然快     C速度相等      D   快慢不定 3、写出从循环单链表中查找出最大值的算法. 4、写出从循环单链表中查找出最小值的算法 . 5、适合折半
【算法】深度优先搜索DFS 入门：基本知识+经典例题
karshey的博客
11-21 2526
自学DFS看的视频： 小甲鱼：讲原理 青岛大学-王卓：讲的较为全面
【算法】动态规划DP自学笔记 入门：基本知识+经典例题
karshey的博客
08-17 2358
简述 动态规划，是利用历史记录来避免重复计算的一种算法，是求解决策过程最优化的过程。一般用一维数组/二维数组来保存历史记录。 一般动态规划有三个步骤： 定义数组元素的含义，一般求什么就定义成什么 找出数组元素之间的关系式，类似归纳法 找出初始值 例题 1 青蛙跳台阶 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法？ 由题意知：青蛙可以从n-1的位置到n，也可以从n-2的位置到n，因此，f(n)=f(n-1)+f(n-2); 初始化：由于变量最小为0,也易得：f(
【图论】最短路算法：Dijkstra、bellman-ford、spfa、Floyd 和拓扑排序
karshey的博客
01-09 979
是AcWing算法基础课关于基本图论算法的笔记。 AcWing YYDS！ 朴素版Dijkstra-849. Dijkstra求最短路 I（稠密图） 参考 步骤： 初始化，dis[1]=0,dis[n]=0x3f3f3f3f.——起点到起点的距离为0，到其他点的距离为正无穷（这里1是起点） 迭代：n次迭代确定每个点到起点的最小值 输出答案 其中： dist[n]表示起点到点n的距离 st[n]表示点n到起点的最短距离是否已经确定 每次找还没有确定最短距离的点中的最短的那个进行更新： 可以看这里的演示
7-1 旅行售货员 (10 分) TSP 回溯法
karshey的博客
11-24 855
输入： 3 0 2 1 1 0 2 2 1 0 输出： 3 参考 代码： 个人认为难点主要在于swap。 比如说，现在到了第u层，我们想知道从第u-1步到第u步的路径（在数组x里），假设u==2，那就是求第1步到第2步的路径。第1步为x[1]，第2步可以为x[2],x[3],x[4]…这就是TSP函数里else中的那个循环。把第2步的候选数swap换到u这个位置代表这是u这层选择的路径，然后往下走。 #include<bits/stdc++.h> using namespace std; .
【算法】排序（sort排序函数和冒泡、选择、插入、快速排序）
karshey的博客
11-21 515
记录目前学到的4种排序，sort函数排序，冒泡排序，选择排序，插入排序。 sort函数排序 1、对数组进行排序，要加函数头#include<algorithm>;或者可以直接万能头#include<bits/stdc++.h>; 2、sort函数的参数，第一个是要排序的开始的地方，第二个是要排序的结尾+1的地方； 如对一个a[10]全部排序，则函数为：sort(a,a+10);其中a即a[0],a+10即a[9]+1; 代码如下： #include<iostream> #
Java编程：经典算法练习题解析
"Java经典练习题，包括控制结构的运用，如循环、条件判断等，以及算法实现，如求兔子数问题、素数判断和水仙花数的查找。" 在Java编程学习中，掌握基本的控制结构是至关重要的。这里我们通过三个经典的Java练习题来...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

karshey

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值