搜索算法

最新推荐文章于 2022-11-02 13:29:58 发布
最新推荐文章于 2022-11-02 13:29:58 发布
阅读量166 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cloud_yan/article/details/102843445
版权

DFS

为对一组数进行 全排列
深度优先搜索

#include<stdio.h>
int a[10], book[10],n;

void dfs(int step)
{
	int i;
	if (step == n + 1)	//如果已经选择完毕
	{	//则打印，所选数据
		for (i = 1; i <= n; i++)
			printf("%d ", a[i]);
		printf("\n");
		return;	//一定要立即return，不然就会无限制地运行下去
	}
	
	for (i = 1; i <= n; i++)	//选择数
	{
		if (book[i] == 0)	//如果这个数是可选的
		{
			a[step] = i;	//第step个位置，选择的数i
			book[i] = 1;	//因为上面a[]已选，则把这个i标记为不可选

			dfs(step + 1);	//选择下一个数
			book[i] = 0;	//将上面选择的数标记为可选，为下一次选数做准备
		}
	}
	return;
}

int main()
{
	scanf("%d", &n);
	dfs(1);
	return 0;
}

深度优先搜索的关键在于解决 “当下该如何做” 。
至于下一步怎么做是和 “当下怎么做” 是一样的

深度优先搜索的基本模型：

void dfs(int step)
{
	判断边界，并进行一些操作
	
	尝试每一种可能 for (i = 1; i <= n; i++)
	{
		继续下一步 dfs(step + 1);
	}
	
	返回
}

每一种尝试就是一种扩展

题目1

[ ][ ][ ]+[ ][ ][ ]=[ ][ ][ ]
找九个互不相同的数，使上式成立

#include<stdio.h>
int a[10], book[10], total = 0;
void dfs(int step)
{
	int i;
	if (step == 10)	//如果选择完毕
	{
		if (a[1] * 100 + a[2] * 10 + a[3] + a[4] * 100 + a[5] * 10 + a[6] == a[7] * 100 + a[8] * 10 + a[9])
		{
			total++;
			printf("%d%d%d+%d%d%d+%d%d%d\n", a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]);
		}
		return;	//返回之前的一步，最近调用的地方
	}

	//此刻进行第step的选择
	for (i = 1; i <= 9; i++)	//按照1/2/3···牌的顺序选择
	{
		if (book[i] == 0)	//判断i这个数是否还可以被选
		{
			a[step] = i;	//选择i
			book[i] = 1;	//表示i已经被选了，不能再选了
			dfs(step + 1);	//进行下一选择
			book[i] = 0;	//把刚刚选的标记删除，进行下一次尝试
		}
	}
	return;
}

int main()
{
	dfs(1);		//对第一个数进行选择
	printf("total=%d", total / 2);	//因为会有相同的，比如A+B=C和B+A=C相同
	return 0;
}

这个代码中最为关键的还是dfs那一部分。
dfs的思想方法
简直牛逼的不行

走迷宫

主要思想
深度优先，先走一边，然后一直尝试，直到走不通了，就层层回溯，回到最初的位置，然后换方向走

就是先判断这个点是不是想要走到的点
如果不是，则进行走到下一个点
并递归调用dfs，以对下一个点进行分析，操作

//当前点的x，y坐标，以及已经走过的步数step
void dfs(int x, int y, int step)	
{
	//判断是否找到了
	if (x == p && y == q)	//如果找到了
	{
		if (step < min)	//看是不是比最小的还要小
			min = step;
		return;	//这里的返回很重要
	}
	//如果没有找到，则找出下一步可以走的地方
	int next[4][2] = { {0,1},	//向右走
						{1,0},	//向下走
						{0,-1},	//向左走
						{-1,0} };	//向上走
	for (k = 0; i < 4; k++)
	{
		tx = x + next[k][0];	//下一步的坐标
		ty = y + next[k][1];

		if (tx<1 || tx>n || ty<1 || ty>m)	//如果超界直接返回
			continue;

		//判断是否为障碍物，或者已经走过了
		if (a[tx][ty] == 0 && book[tx][ty] == 0)
		{
			book[tx][ty] = 1;	//标记这里已经走过了
			dfs(tx, ty, step + 1);	//进行下一步的走
			book[tx][ty] = 0;	//尝试结束，也就是退到了这个点的上一个位置
		}
	}
	return;
}

完整代码：

#include<stdio.h>

int n, m, p, q, min = 999999999;
int a[51][51], book[51][51];

//当前点的x，y坐标，以及已经走过的步数step
void dfs(int x, int y, int step)
{
	//判断是否找到了
	int tx, ty, k;
	if (x == p && y == q)	//如果找到了
	{
		if (step < min)	//看是不是比最小的还要小
			min = step;
		return;	//这里的返回很重要
	}
	//如果没有找到，则找出下一步可以走的地方
	int next[4][2] = { {0,1},	//向右走
						{1,0},	//向下走
						{0,-1},	//向左走
						{-1,0} };	//向上走
	for (k = 0; k < 4; k++)
	{
		tx = x + next[k][0];	//下一步的坐标
		ty = y + next[k][1];

		if (tx<1 || tx>n || ty<1 || ty>m)	//如果超界直接返回
			continue;

		//判断是否为障碍物，或者已经走过了
		if (a[tx][ty] == 0 && book[tx][ty] == 0)
		{
			book[tx][ty] = 1;	//标记这里已经走过了
			dfs(tx, ty, step + 1);	//进行下一步的走
			book[tx][ty] = 0;	//尝试结束，也就是退到了这个点的上一个位置
		}
	}
	return;
}

int main()
{
	int i, j, startx, starty;
	scanf("%d %d", &n, &m);
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= m; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}
	scanf("%d%d%d%d", &startx, &starty, &p, &q);

	book[startx][starty] = 1;
	dfs(startx, starty, 0);
	printf("%d", min);
	return 0;
}

BFS

广度优先搜索
宽度优先搜索

走迷宫

通过一层一层的扩展，来找到想要找到的出路
扩展时每发现一个点就把这个点加入到队列中，直到走到出路为止

核心思想：
利用队列，实现层层扩展

核心代码：

while (head < tail)	//当队列不为空的时候循环
	{
		//枚举四个方向
		for (k = 0; k < 4; k++)
		{
			tx = que[head].x + next[k][0];	//下一个点是从head扩展出来的
			ty = que[head].y + next[k][1];

			//判断是否越界
			if (tx<1 || tx>n || ty<1 || ty>m)
				continue;
			//判断是否是障碍物或者已经走过了
			if (a[tx][ty] == 0 && book[tx][ty] == 0)
			{
				//把这个点标记为已走
				//BFS中每个点只入队一次，因此，book一旦标记，就不再还原
				book[tx][ty] = 1;

				//将走到的点插入到队列中
				que[tail].x = tx;
				que[tail].y = ty;
				que[tail].f = head;	//因为这个点是从head扩展出来的，因此父亲就是head
				que[tail].s = que[head].s + 1;

				tail++;
			}
			if (tx == p && ty == q)//如果到达终点了，直接跳出
			{
				flag = 1;
				break;
			}
		}
		if (flag == 1)
			break;
		
		head++;		//当一个点的扩展结束了，head++才能对后面的点再扩展
	}

#include<stdio.h>

struct node
{
	int x;	//横坐标
	int y;	//纵坐标
	int f;	//父亲在队列中的编号，这个是为输出路径而准备的
	int s;	//步数
};
int main()
{
	int i, j, k, n, m;

	node que[2501];	//因为地图大小不超过50*50，因此队列扩展不会超过2500
	int head, tail;	//队首，队尾

	int a[51][51] = { 0 };	//地图
	int book[51][51] = { 0 };	//book的作用是记录哪些点已经在队列中，防止一个点被重复扩展，并全部初始化为0

	int next[4][2] = { {0,1},	//向右走
						{1,0},	//向下走
						{0,-1},	//向左走
						{-1,0} };	//向上走

	int startx, starty;	//开始的位置的横纵坐标
	int p, q;
	int tx, ty;	//下一个点的横纵坐标
	int flag;

	scanf("%d%d", &n, &m);	//输入地图
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= m; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}

	//输入开始的横纵坐标
	scanf("%d%d%d%d", &startx, &starty, &p, &q);

	//最开始的时候需要进行队列初始化，即将队列设置为空
	head = 1;
	tail = 1;

	//在队列中设置开始时位置坐标以及路径长度
	que[tail].x = startx;
	que[tail].y = starty;
	que[tail].s = 0;
	que[tail].f = 0;
	tail++;
	book[startx][starty] = 1;

	flag = 0;	//用来记录是否到达目标点，0表示未到，1表示到达
	while (head < tail)	//当队列不为空的时候循环
	{
		//枚举四个方向
		for (k = 0; k < 4; k++)
		{
			tx = que[head].x + next[k][0];	//下一个点是从head扩展出来的
			ty = que[head].y + next[k][1];

			//判断是否越界
			if (tx<1 || tx>n || ty<1 || ty>m)
				continue;
			//判断是否是障碍物或者已经走过了
			if (a[tx][ty] == 0 && book[tx][ty] == 0)
			{
				//把这个点标记为已走
				//BFS中每个点只入队一次，因此，book一旦标记，就不再还原
				book[tx][ty] = 1;

				//将走到的点插入到队列中
				que[tail].x = tx;
				que[tail].y = ty;
				que[tail].f = head;	//因为这个点是从head扩展出来的，因此父亲就是head
				que[tail].s = que[head].s + 1;

				tail++;
			}
			if (tx == p && ty == q)//如果到达终点了，直接跳出
			{
				flag = 1;
				break;
			}
		}
		if (flag == 1)
			break;
		
		head++;		//当一个点的扩展结束了，head++才能对后面的点再扩展
	}

	//打印队列中末尾最后一个点的步数(这时候就是到达终点的点)
	printf("%d", que[tail - 1].s);	//tail指向的队列中最后一个元素的下一个位置。因此需要减1
	return 0;
}

炸弹人

BFS大致的模板

while (head < tail)
{
	for (k = 0; k < 4; k++)
	{
		tx = que[head].x + next[k][0];
		ty = que[head].y + next[k][1];

		if (tx<1 || tx>n || ty<1 || ty>m)
			continue;

		if (a[tx][ty] == '.' && book[tx][ty] == 0)
		{
			book[tx][ty] = 1;
			que[tail].x = tx;
			que[tail].y = ty;

			//在这里进行你先要的操作

			tail++;
		}
	}
	head++;
}

DFS
这个与为了找到终点是不一样的
这个是为遍历图中的每一个点
因此，需要的将所有的点都做一个标记
而且不能清除这个标记，不然没有办法知道，是否遍历完所有的点

void dfs(int x, int y)
{
	//操作
	for (k = 0; k < 4; k++)
	{
		tx = x + next[k][0];
		ty = y + next[k][1];

		if (tx<0 || tx>n - 1 || ty<0 || ty>m - 1)
			continue;
		if (a[tx][ty] == '.' && book[tx][ty] == 0)
		{
			book[tx][ty] = 1;
			dfs(tx, ty);
			//book[tx][ty] = 0;	因为是遍历图中的每一个点，与找到终点不一样，所以这个步骤删除
		}
	}
	return;
}

上述代码就是着色法的实现：
着色法：以某个点为源点对其临近的点进行着色

求一个图中有多少个独立子图
对图中每一个点进行一次DFS，并对其进行不同的着色

Floodfill漫水填充法
Floodfill算法在计算机图形学中有着非常广泛的应用。比如图像切割，物体识别
例如：Windows下画图软件的油漆桶就是基于这个算法

水管工游戏

在这里插入图片描述
输出通路，需要一个栈
每次进行尝试的时候入栈
如果尝试不成功，则将这个不成功的出栈

最后栈中保留的，就是正确的路线
当成功的时候，就输出栈中路线就可以了

这个我觉得收获最大是
形成路线
至于水管的选择还是dfs
不过，在选择水管的时候，可以选择进行多个dfs，给我带来了启发

#include<stdio.h>
int a[51][51];
int book[51][51];
int n, m, flag = 0;

struct note
{
	int x;
	int y;
}s[100];	//形成一个栈
int top = 0;

void dfs(int x, int y, int front)//x,y代表位置,front代表进水口方向
{
	int i;
	//判断是否到达终点
	//判断终点一定要在判断越界前面
	if (x == n && y == m + 1)
	{
		flag = 1;
		for (i = 1; i <= top; i++)
			printf("(%d,%d)", s[i].x, s[i].y);
		return;
	}
	if (x < 1 || x>n || y<1 || y>m)
	{
		return;
	}
	if (book[x][y] == 1)	//判断这个管道是不是已经使用过
		return;
	book[x][y] = 1;//如果没有使用过，标记的当前管道

	//将当前尝试入栈
	top++;
	s[top].x = x;
	s[top].y = y;


	//枚举当前管道的每一种摆放方式。根据进水口的方向来决定管道方向
	
	//当前管道是直道
	if (a[x][y] >= 5 && a[x][y] <= 6)
	{	//front代表进水口方向
		if (front == 1)
		{
			dfs(x, y + 1, 1);
		}
		if (front == 2)
		{
			dfs(x + 1, y, 2);
		}
		if (front == 3)
		{
			dfs(x, y - 1, 3);
		}
		if (front == 4)
		{
			dfs(x - 1, y, 4);
		}
	}

	//当前是弯道的时候
	//每个弯道有两种状态，因此对应于需要两个dfs
	if (a[x][y] >= 1 && a[x][y] <= 4)
	{
		if (front == 1)		//如果进水口是左边
		{
			dfs(x + 1, y, 2);	//那么我下一个位置进水口只有上面和下面
			dfs(x - 1, y, 4);
		}
		if (front == 2)
		{
			dfs(x, y + 1, 1);
			dfs(x, y - 1, 3);
		}
		if (front == 3)
		{
			dfs(x - 1, y, 4);
			dfs(x + 1, y, 2);
		}
		if (front == 4)
		{
			dfs(x, y + 1, 1);
			dfs(x, y - 1, 3);
		}
	}
	book[x][y] = 0;	//取消标记	这是因为，这个尝试失败了，要换一种了

	top--;	//将当前尝试出栈
	return;
}

int main()
{
	int i, j, num = 0;
	scanf("%d%d", &n, &m);
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= m; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}
	dfs(1, 1, 1);
	if (flag == 0)
	{
		printf("impossible\n");
	}
	else
		printf("找到铺设方案\n");
}
isSiYua
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
盲目搜索算法
Junds0的博客
06-12 2367
本关任务：给定迷宫地图以及在迷宫中的起始位置，利用宽度优先搜索算法求解走出迷宫的最短路径长度，走出迷宫意味着达到迷宫地图的边界（所有位置下标0开始）。 第2关：盲目搜索之深度优先搜索算法 本关任务：利用深度优先搜索算法的核心思想，求解N皇后问题的方案总数，其中N∈[1,10]。...
智能优化算法-搜索组算法Search Group Algorithm (附Matlab代码)
weixin_44028734的博客
06-18 74
搜索组算法(Search Group Algorithm, SGA)是一种求解非线性、非凸、非光滑、多模态、有界优化问题的元启发式优化方法。于2015年发表在Computers & Structures。
广度优先搜索算法
流月的博客
04-25 12万+
一、简介 广度优先搜索算法（Breadth-First Search，BFS）是一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。BFS并不使用经验法则算法。 广度优先搜索让你能够找出两样东西之间的最短距离，不过最短距离的含义有很多！使用广度优先搜索可以： 编写国际跳棋AI，计算最少走多少步就可获胜； ...
DFS(深度优先搜索算法)
热门推荐
无限迭代中......
12-04 21万+
基本概念 深度优先搜索算法（Depth First Search，简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。 算法思想 回溯法（探索与回溯法...
麻雀搜索算法（Sparrow Search Algorithm，SSA）
weixin_46838605的博客
10-13 2万+
这是一篇麻雀搜索算法总结博客，包括算法思想，算法步骤，Python代码实现，算法改进等，会不断更新。
智能优化算法：麻雀搜索算法-附代码
Jack旭的博客
09-27 11万+
2020智能优化算法：麻雀搜索算法-附代码 文章目录2020智能优化算法：麻雀搜索算法-附代码1.算法原理2.算法结果3.参考文献4.Matlab代码 摘要：麻雀搜索算法(Sparrow Search Algorithm, SSA)是于2020年提出的。SSA 主要是受麻雀的觅食行为和 反捕食行为的启发而提出的。该算法比较新颖，具有寻优能力强，收敛速度快的优点 1.算法原理 建立麻雀搜索算法的数学模型，主要规则如下所述： 发现者通常拥有较高的能源储备并且在整个种群中负责搜索到具有丰富食物的区域，为所有的加
经典搜索算法总结
qq_21746331的博客
06-01 1万+
前言0x01 搜索问题的形式化0x02 树搜索和图搜索0x03 搜索算法的评估0x04 盲目搜索算法0x04.01 宽度优先搜索算法BFS0x04.02 一致代价搜索算法UCS0x04.03 深度优先搜索算法DFS 前言 搜索问题是在解决各类问题时不可避免的重点难点，很多问题的求解过程都可以转变为搜索问题。比如，对于以下罗马尼亚问题，希望找到一条路径使得从城市 Arad 到城市 Bucuresti 的路径最短，这就是一个经典的搜索问题，在数据结构课程中，我们都知道使用 Dijkstra 算法来求得最优解，.
禁忌搜索算法
talkAC的博客
11-20 3323
禁忌搜索算法(Tabu Search or Taboo Search,TS)是一种迭代搜索算法，靠记忆来引导算法的搜索过程。 1 算法原理 主要包含2个方面：局部领域搜索、禁忌搜索，在领域搜索的基础上，通过禁忌准则来避免重复搜索，通过藐视准则来赦免一些被禁忌的优良状态，以实现全局优化。 1.1 局部领域搜索 局部领域搜索是基于贪婪准则持续在当前的领域中进行搜索，找到局部最优解。大致方法是选定一个可行解，并产生领域解集,逐一比较和的目标值，选出最优解更新，直到找不到更优为止，记为。 1.2 禁忌搜索
麻雀搜索算法
m0_54176616的博客
11-02 2688
麻雀搜索算法
Grover搜索算法
浮生之居士
12-01 4476
目录一 简介二 问题描述三 算法描述3.1 量子门3.2 量子线路 一 简介 Grover算法和Shor算法是量子算法领域两个最重要的量子算法，而Grover算法相比于Shor因子分解算法，有着更广泛的应用。 二 问题描述 N=2nN=2^nN=2n，给定一个任意的x∈{0,1}nx\in\{0,1\}^nx∈{0,1}n； 目标：找到iii使得xi=1x_i=1xi​=1（如果没有这样的iii，输出“no solution”）。 注：经典随机算法需要Θ(n)\Theta(n)Θ(n)次查询才能解决该搜索问
麻雀搜索算法（SSA）可以很好对算法进行解读
06-23
可以运行的代码！麻雀搜索算法（SSA）可以很好对算法进行解读
搜索算法介绍
08-23
搜索算法是利用计算机的高性能来有目的的穷举一个问题的部分或所有的可能情况，从而求出问题的解的一种方法。 搜索过程实际上是根据初始条件和扩展规则构造一棵解答树并寻找符合目标状态的节点的过程。
最短路径(广度优先搜索)
Cloud_yan的博客
11-05 2583
广度优先搜索适用于所有边的权值相同的情况 当所有边的权值相同，采用BFS时，当找到终点，直接退出。 这时，得到的便是最短路径 一个案例： 各边权值均为1，找到1到5距离最小值 #include<stdio.h> struct note { int x; //城市编号 int s; //转机次数 }; int main() { struct note que[2501]; //...
最短路径(图的深度优先遍历)
Cloud_yan的博客
11-05 1231
图的基本概念： 图就是N个顶点，M条边组成的集合 图有有向图和无向图 如果给图中每条边规定一个方向，则得到的图是有向图，其边为有向边。在有向图中，与一个点相关联的边有出边和入边之分，而与一个有向边关联的两个点也有始点和终点之分 边没有方向的图称为无向图 我们采用图的邻接矩阵来存储图(当然还有其他方法) 在存储无向图时，需要注意的是： 存储的边，需要有两个，例如：存储(a，b)边时，需要在图的邻接矩...
最短路径(Dijkstra算法)
Cloud_yan的博客
11-07 683
Dijkstra算法 一个点到其余个点的算法 仍用邻接矩阵的方法存储图 使用dis[]初始化为：存储1号顶点到其余顶点的初始路径 此时dis数组的值被称为最短路径的估计值 松弛 算法的基本思想： 每次找到离源点最近的一个顶点，然后以该顶点为中心开始扩展，最终得到源点到其余所有点的最短路径。 基本步骤如下： 算法核心代码： for (i = 1; i <= n; i++) { dis[i...
多源最短路径问题(Floyd-Warshall)
Cloud_yan的博客
11-06 639
为了求任意两个点之间的最短路径 照旧，利用矩阵来存储图的信息 自身到自身，设置为0 无法到达设置为无穷 可以到达的 i 到 j ，就记为a[i][j]=路径长度 思路一： 对所有的两个点动用一次dfs或bfs，也就是n2次DFS或BFS 上述是个啥子方法，只是看看 思路二： 如果，要使得从 i 到 j，就必须经过中转点，i→k→j，那么我们从所有的点中，找到这个k，使得i→j的路径变短 或许，经...
枚举算法
Cloud_yan的博客
10-31 305
枚举算法的基本思想：有序地去尝试每一种可能 炸弹人 基本就是把每一个点都遍历一遍 然后判断 就是最简单的枚举 全部枚举 //炸弹人的策略 #include<stdio.h> int main() { char a[20][21]; int i, j, sum, map = 0, p, q, x, y, n, m; scanf("%d%d", &n, &m); ...
matlab搜索算法
最新发布
08-18
在MATLAB中，有许多搜索算法可供使用。以下是一些常见的搜索算法示例： 1. 线性搜索：通过逐个检查元素来查找特定值或条件的元素。MATLAB中，可以使用`find`函数来执行线性搜索。 2. 二分搜索：对于已排序的数组，可以使用二分搜索来快速查找特定值。MATLAB中的`binarySearch`函数可以帮助执行二分搜索。 3. 插值搜索：对于一维或多维数据集，可以使用插值方法进行搜索。MATLAB中的`interp1`和`interp2`函数可用于执行插值搜索。 4. 遗传算法：遗传算法是一种基于进化和遗传原理的优化算法。MATLAB提供了`ga`函数来实现遗传算法。 5. 粒子群优化算法：粒子群优化算法模拟鸟群或鱼群的行为，通过迭代找到最优解。在MATLAB中，可以使用`particleswarm`函数执行粒子群优化算法。 这只是一小部分可用的搜索算法示例，MATLAB还提供了许多其他搜索算法和优化工具，可以根据具体问题选择合适的算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值