算法基础课第三章搜素与图论-CSDN博客

本文链接：https://blog.csdn.net/xnhdbb/article/details/134034418

本章介绍了搜索算法中的DFS和BFS，详细讲解了它们在树与图中的应用，包括拓扑序列的求解。接着讨论了最短路问题，如Dijkstra算法、Bellman-Ford算法和Floyd算法，并探讨了最小生成树的Prim算法和Kruskal算法。最后，简述了二分图的概念及其在最大匹配问题中的匈牙利算法。

摘要由CSDN通过智能技术生成

算法基础课第三章搜索与图论

DFS（深度优先遍历）

在这里插入图片描述

例题：排列数字

思路：

注意：每一次结束后需要恢复现场

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 10;
int n, path[N];
bool st[N];//状态数组

void dfs(int u)//第几个数字，一共几个数字
{
   
	if (u == n)//递归到最后一个数字
	{
   
		for (int i = 0;i < n;i++) cout << path[i] << ' ';//输出保存的结果
		puts(" ");
	}
	for (int i = 1;i <= n;i++)
	{
   
		if (!st[i])//该数没有被使用过
		{
   
			path[u] = i;
			st[i] = true;//i被使用过
			dfs(u + 1);//进入下一层
			st[i] = false;//恢复现场
		}
	}
}

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

例题：n-皇后问题
n-皇后问题题解

注意：剪枝（提前判断该条路不行直接剪去）
算法一：按每个元素枚举

#include<iostream>
using namespace std;
const int N = 10;
int n;
bool row[N], col[N], dg[N * 2], udg[N * 2];
char g[N][N];
void dfs(int x, int y, int s)
{
   
	if (s > n)return;//总共有n个皇后
	if (y == n)y = 0, x++;//当每一行结束后，从下一行第一个开始
	if (x == n)//遍历完后
	{
   
		if (s == n)//有n个皇后
		{
   
			for (int i = 0;i < n;i++)puts(g[i]);
			puts("");
		}
		return;
	}
	g[x][y] = '.';
	dfs(x, y + 1, s);
	if (!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n])
	{
   
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
		g[x][y] = 'Q';
		dfs(x, y + 1, s + 1);
		g[x][y] = '.';
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
	}
}

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

算法二：按行枚举

#include<iostream>
using namespace std;
const int N = 10;
int n;
char g[N][N];
bool  col[N], dg[N * 2], udg[N * 2];
//bool数组来判断搜索的下一个位置是否可行
//col——列 dg——对角线  udg——反对角线
//g[N[N]用来存路径
void dfs(int u)
{
   
	if (u == n)//表示已经搜索了n行，故输出这条路径
	{
   
		for (int i = 0;i < n;i++) puts(g[i]);
		puts("");//换行
		return;
	}

	//枚举u这一行，搜索合法的列
	for(int i=0;i<n;i++)//剪枝（对于不满足要求的点，不再继续往下搜索）
		if (col[i] = false && dg[u+i] == false && udg[n-u+i] == false)
		{
   
			g[u][i] = 'Q';
			col[i] = dg[u+i] = udg[n-u+i] = true;
			dfs(u + 1);
			//恢复现场
			col[i] = dg[u+i] = udg[n-u+i] = false;
			g[u][i] = '.';
		}
	
}

int main()
{
   
	cin >> n;
	for (int i = 0;i < n;i++)
		for (int j = 0;j < n;j++)
			g[i][j] = '.';
	dfs(0);
	return 0;
}

BFS（宽度优先搜索）

一层一层搜索（先把宽度为1的点全部搜到，再把宽度为2的点全部搜到…）
优点：最短路问题（只有当所有的权重都相同时，才能用宽搜来求最短路问题）
例题1：走迷宫

算法一：数组模拟队列

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110;
typedef pair<int, int>PII;
int n, m;
int g[N][N];//存放地图
int d[N][N];//存放每个点到起点的距离
PII q[N * N];//手写队列
int bfs()
{
   
	int hh = 0, tt = 0;
	q[0] = {
    0,0 };
	memset(d, -1, sizeof d);//距离初始化为-1，-1表示没有走过
	d[0][0] = 0;//表示起点已经走过了
	int dx[4] = {
    -1,0,1,0 }, dy[4] = {
    0,1,0,-1 };//x方向的向量和y方向的向量表示上下左右四个方向
	while (hh <= tt)//队列不为空
	{
   
		PII t = q[hh++];//去队头元素
		for (int i = 0;i < 4;i++)
		{
   
			int x = t.first + dx[i], y = t.second + dy[i];//往下走
			if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)//在地图内并且路是通的且之前没有走过
			{
   
				d[x][y] = d[t.first][t.second] + 1;//到起点的距离加一
				q[++tt] = {
    x,y };//新坐标入队
			}
		}
	}
	return d[n - 1][m - 1];//输出右下角的点到起点的距离
}

int main()
{
   
	cin >> n >> m;
	for (int i = 0;i < n;i++)
		for (int j = 0;j < m;j++)
			cin >> g[i][j];
	cout << bfs() << endl;
	return 0;
}

算法二 C++队列

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N = 110;
typedef pair<int, int>PII;
int n, m;
int g[N][N], d[N][N];
int bfs()
{
   
	queue<pair<int, int>>q;
	q.push({
    0,0 });
	memset(d, -1, sizeof(d));
	d[0][0] = 0;
	int dx[4] = {
    -1,0,1,0 }, dy[4] = {
    0,1,0,-1 };
	while (q.size())//队列不为空
	{
   
		PII t = q.front();//取队头元素
		q.pop();//出队 弹出
		for (int i = 0;i < 4;i++)
		{
   
			int x = t.first + dx[i], y = t.second + dy[i];
			if (x >= 0 && x < n && y >= 0 && y