搜索与图论

已于 2023-12-15 16:59:51 修改
阅读量619 收藏 14
点赞数 11
分类专栏： 算法基础 文章标签： 图论
于 2023-12-05 23:14:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/houhuan521/article/details/134818480
版权

目录

搜索

 拓扑排序

最短路 

 Dijkstra 算法（稠密图 边 >= 点的平方 O(n^2)）

 ⭐堆优化版 Dijkstra 算法（稀疏图 边 < 点的平方 O(mlogn)）

Bellman-Ford O(nm)

 ⭐SPFA（一般O(m), 最坏O(nm)）

 Floyd O(n^3)

 最小生成树 

 ⭐Prim O(n^2)

堆优化版Prim O(mlogn)

⭐克鲁斯卡尔算法 O(mlogm)

 二分图

染色法 O(m + n) （注：此算法用于判断图是否为二分图）

匈牙利算法 （O(mn)，实际运行时间一般远小于O(mn)）（注：用于判断最大匹配数）

搜索

dfs(深度优先搜索)：一条路走到黑。沿着一条路一直搜索，直到走不通时，再进行回溯。

bfs(广度优先搜索)：像波纹一样层层向外扩展。每层搜索完全后，在进行下一层的搜索。

 拓扑排序

 一个序列，包含图中所有的点；在这个序列中，排在后面的点，不会有指向排在前面节点的出边。且这个序列不是唯一的。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 100010;

int h[N], e[N], ne[N], idx;
int q[N], d[N];
int n, m;

void add(int a, int b)
{
	e[idx] = b , ne[idx] = h[a], h[a] = idx ++;
}

bool topsort()
{
	int hh = 0, tt = -1;
	
	for (int i = 1; i <= n; i ++ )
		if (!d[i])	q[ ++ tt] = i;
	
	while (hh <= tt)
	{
		int t = q[hh ++];
		
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			d[j] --;
			if (d[j] == 0) q[ ++ tt] = j;
		}
	}
	
	return tt == n - 1;
}

int main()
{
	cin >> n >> m;
	
	memset(h, -1, sizeof h);
	
	for (int i = 0; i < m; i ++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b);
		 d[b] ++;
	}
	
	if (topsort())
	{
		for (int i = 0; i < n; i ++) cout << q[i];
		puts("");
	}
	else puts("-1");
	
	return 0;
}

最短路 

 Dijkstra 算法（稠密图 边 >= 点的平方 O(n^2)）
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N = 10010;

int n, m;
int g[N][N];
int dist[N];
bool st[N];

int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	
	for (int i = 0; i  < n; i ++)
	{
		int t = -1;
		for (int j = 1; j <= n; j ++)
			if (!st[j] && (t == -1 || dist[t] > dist[j]))
				t = j;
				
		st[t] = true;
		
		for (int j = 1; j <= n; j ++)
			dist[j] = min (dist[j], dist[t] + g[t][j]);
	}
	
	if (dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main()
{
	cin >> n >> m;
	
	memset (g, 0x3f, sizeof g);
	
	while (m --)
	{
		int a, b, c;
		cin >> a >> b >> c;
		g[a][b] = min (g[a][b], c);
	} 
	
	int t = dijkstra();
	
	cout << t;
	
	return 0;
}
 ⭐堆优化版 Dijkstra 算法（稀疏图 边 < 点的平方 O(mlogn)）
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 100010;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	
	priority_queue<PII, vector<PII>, greater<PII> > heap;
	heap.push({0, 1});
	
	while (heap.size())
	{
		PII t = heap.top();
		heap.pop();
		
		int ver = t.second, distance = t.first;
		if (st[ver]) continue;
		
		for (int i = h[ver]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > distance + w[i])
			{
				dist[j] = distance + w[i];
				heap.push ({dist[j], j});
			}
		}
	}
	
	if (dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main()
{
	cin >> n >> m;
	
	memset (h, -1, sizeof h);
	
	while (m --)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add (a, b, c);
	} 
	
	int t = dijkstra();
	
	cout << t;
	
	return 0;
}
Bellman-Ford O(nm)
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N = 510, M = 10010;

int n, m, k;
int dist[N], backup[N];

struct Edge
{
	int a, b, w;
}edges[M];

int bellman_ford()
{
	for (int i = 0; i < k; i ++)  // 只经过 K 条边， 能到的点的最短距离
	{
		memcpy(backup, dist, sizeof dist);
		for (int j = 0; j < m; j ++)
		{
			int a = edges[j].a, b = edges[j].b, w = edges[j].w;
			dist[b] = min(dist[b], backup[a] + w);
		}
	}
	
	if (dist[n] > 0x3f3f3f3f / 2) return -1;
	return dist[n];
}

int main()
{
	cin >> n >> m >> k;
	
	for (int i = 0; i < m; i ++)
	{
		int a, b, w;
		cin >> a >> b >> w;
		edges[i] = {a, b, w};
	}
	
	int t = bellman_ford();
	
	if (t == -1) puts("impossible");
	else cout << t << endl;
	
	return 0;
}
 ⭐SPFA（一般O(m), 最坏O(nm)）
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 100010;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N], cnt[N];
bool st[N];

void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

int spfa()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	
	queue<int> q;
	q.push(1);
	st[1] = true;
	
	while (q.size())
	{
		int t = q.front();
		q.pop();
		
		st[t] = false;
		
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				if (!st[j])
				{
					q.push(j);
					st[j] = true;
				}
			}
		}
	}
	
	if (dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main()
{
	cin >> n >> m;
	memset(h, -1, sizeof h);
	
	for (int i = 0; i < m; i ++)
	{
		int a, b, w;
		cin >> a >> b >> w;
		add(a, b, w);
	}
	
	int t = spfa();
	
	if (t == -1) puts("impossible");
	else cout << t << endl;
	
	return 0;
}
 Floyd O(n^3)
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 210, INF = 1e9;

int n, m, Q;
int d[N][N];

void floyd()
{
	for (int k = 1; k <= n; k ++)
		for (int i = 1; i <= n; i ++)
			for (int j = 1; j <= n; j ++)
				d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

int main()
{
	cin >> n >> m >> Q;
	
	for (int i = 1; i <= n; i ++)
		for (int j = 1; j <= n; j ++)
			if (i == j) d[i][j] = 0;
			else d[i][j] = INF;
			
	while (m --)
	{
		int a, b, w;
		cin >> a >> b >> w;
		d[a][b] = min(d[a][b], w);
	}
	
	floyd();
	
	while (Q --)
	{
		int a, b;
		cin >> a >> b;
		
		if (d[a][b] > INF / 2) puts("impossible");
		else cout << d[a][b] << endl;
	}
	
	return 0;
}

 最小生成树 

 

 ⭐Prim O(n^2)
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int g[N][N];
int dist[N];
bool st[N];

int prim()
{
	memset(dist, 0x3f, sizeof dist);
	
	int res = 0;
	
	for (int i = 0; i < n; i ++)
	{
		int t = -1;
		for (int j = 1; j <= n; j ++)
			if (!st[j] && (t == -1 || dist[t] > dist[j]))
				t = j;
		
		if (i && dist[t] == INF) return INF;
		if (i) res += dist[t];
		
		for (int j = 1; j <= n; j ++) dist[j] = min(dist[j], g[t][j]);
		
		st[t] = true;
	}
	
	return res;
}

int main()
{
	cin >> n >> m;
	
	memset(g, 0x3f, sizeof g);
	
	while (m --)
	{
		int a, b, c;
		cin >> a >> b >> c;
		
		g[a][b] = min (g[a][b], c);
	}
	
	int t = prim();
	
	if (t == INF) puts("impossible");
	else printf("%d\n", t);
	
	return 0;
}
堆优化版Prim O(mlogn)

 略（参照 Dijkstra 与 堆优化版Dijkstra 算法）

⭐克鲁斯卡尔算法 O(mlogm)
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int n, m;
int p[N];

struct Edge
{
	int a, b, w;
	
	bool operator< (const Edge &W)const
	{
		return w < W.w;
	}
}edges[N];

int find(int x)
{
	if (p[x] != x) p[x] = find(p[x]);
	return p[x];
	
}

int main()
{
	cin >> n >> m;
	
	for (int i = 0; i < m; i ++)
	{
		int a, b, w;
		cin >> a >> b >> w;
		edges[i] = {a, b, w};
	}
	
	sort(edges, edges + m);
	
	for (int i = 1; i <= n; i ++) p[i] = i;
	
	int res = 0, cnt = 0;
	for (int i = 0; i < m; i ++)
	{
		int a = edges[i].a, b = edges[i].b, w = edges[i].w;
		
		a = find(a), b = find(b);
		if (a != b)
		{
			p[a] = b;
			res += w;
			cnt ++;
		}
	}
	
	if (cnt < n - 1) puts("impossible");
	else printf("%d\n", res);
	
	return 0;
}

 二分图

染色法 O(m + n) （注：此算法用于判断图是否为二分图）
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010, M = 200010;

int n, m;
int h[N], e[M], ne[M], idx;
int color[N];

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

bool dfs(int u, int c)
{
	color[u] = c;
	
	for (int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		if (!color[j])
		{
			if (!dfs(j, 3 - c)) return false;
		}
		else if (color[j] == c) return false;
	}
	
	return true;
}

int main()
{
	cin >> n >> m;
	
	memset(h, -1, sizeof h);
	
	while (m --)
	{
		int a, b;
		cin >> a >> b;
		
		add(a, b), add(b, a);
	}
	
	bool flag = true;
	for (int i = 1; i <= n; i ++)
		if (!color[i])
		{
			if (!dfs(i, 1))
			{
				flag = false;
				break;
			}
		}
		
	if (flag) puts("Yes");
	else puts("No");
	
	return 0;
}
匈牙利算法 （O(mn)，实际运行时间一般远小于O(mn)）（注：用于判断最大匹配数）
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510, M = 100010;

int n1, n2, m;
int h[N], e[N], ne[N], idx;
int match[N];
bool st[N];

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

bool find(int x)
{
	for (int i = h[x]; i != -1; i = ne[i])
	{
		int j = e[i];
		if (!st[j])
		{
			st[j] = true;
			if (match[j] == 0 || find(match[j]))
			{
				match[j] = x;
				return true;
			}
		}
	}
	
	return false;
}

int main()
{
	cin >> n1 >> n2 >> m;
	
	memset(h, -1, sizeof h);
	
	while (m --)
	{
		int a, b;
		cin >> a >> b;
		add(a, b);
	}
	
	int res = 0;
	for (int i = 1; i <= n1; i ++)
	{
		memset(st, false, sizeof st);
		if (find(i)) res ++;
	}
	
	cout << res << endl;
	
	return 0;
}
hh_joker
关注
  • 11
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
常用代码模板3——搜索与图论.html
06-13
常用代码模板3——搜索与图论.html
图论与图学习
06-26
总的来说，“图论与图学习”涵盖了理论基础与实际应用，是理解和解决复杂关系数据问题的关键。通过学习这些内容，我们可以更好地理解并利用图的结构优势，为实际问题提供有效的解决方案。无论是计算机科学家、数据...
搜索与图论总结
m0_73569492的博客
10-06 581
搜索与图论总结（dfs+bfs+有向图与无向图+拓扑排序+最短路+二分图+匈牙利算法）
算法之搜索与图论
wat1r的博客
02-01 705
1.FloodFill
搜索与图论：Floyd
java领域博主
01-04 61
搜索与图论： Floyd
搜索与图论：Prim
java领域博主
10-28 713
搜索与图论：Prim
搜索与图论：Kruskal
java领域博主
10-28 314
搜索与图论：Kruskal
搜索与图论-DFS
每天进步一点点！
12-02 1004
DFS
搜索与图论-拓扑序列
amnesia_mint的博客
08-29 1084
虽然记了也不一定会看。
搜索与图论 - DFS
zhouth94的博客
06-24 197
1、题目描述 给定一个整数n，将数字1~n排成一排，将会有很多种排列方法。 现在，请你按照字典序将所有的排列方法输出。 输入格式 共一行，包含一个整数n。 输出格式 按字典序输出所有排列方案，每个方案占一行。 数据范围 1≤n≤71≤n≤7 输入样例： 3 输出样例： 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 2、分析 3、代码 idx 代表深搜的层数 import java.util.*; import java.io.*; .
搜索与图论之FloodFill
wat1r的博客
02-05 4305
FloodFill 泛洪填充算法(Flood Fill Algorithm)泛洪填充算法又称洪水填充算法是在很多图形绘制软件中常用的填充算法，最熟悉不过就是 windows paint的油漆桶功能。算法的原理很简单，就是从一个点开始附近像素点，填充成新的颜色，直到封闭区域内的所有像素点都被填充新颜色为止。泛红填充实现最常见有四邻域像素填充法，八邻域像素填充法，基于扫描线的像素填充方法。根据实现又可以分为递归与非递归（基于栈）。 733. 图像渲染 方法1：DFS 当当前的位置的颜色和开始位置(sr,s
集合论与图论2010s1
08-04
集合论与图论知识点总览 本资源摘要信息涵盖了集合论与图论两个重要的数学分支，涵盖了集合论的基本概念、图论的基本概念、图的定义、图的类型、图的操作等知识点。 集合论 集合论是数学的一个分支，研究集合的...
图论与网络流资料.zip
04-06
图论与网络流是计算机科学中的重要分支，广泛应用于算法设计和优化问题中。华为的CodeCraft活动常常涉及这些主题，以培养和测试参赛者的算法思维和编程能力。以下是关于图论与网络流的一些核心概念和应用的详细阐述...
代码 基于深度优先搜索算法图论代码
06-04
代码 基于深度优先搜索算法图论代码代码 基于深度优先搜索算法图论代码代码 基于深度优先搜索算法图论代码代码 基于深度优先搜索算法图论代码代码 基于深度优先搜索算法图论代码代码 基于深度优先搜索算法图论代码...
图论·Day01
2301_80132162的博客
07-06 328
【代码】图论·题解1。
代码随想录Day74（图论Part10）
Allen_7_kklt的博客
07-04 552
思路：出现负权回路，按照之前的思路，会一直循环回路，使得成本不断减小，因此核心思路是，在。Bellman_ford 算法 每次都是对所有边进行松弛，其实是多做了一些无用功。更新用的是minDist，判断用的是minDistCopy。使用LinkedList实现Queue，不断从中。思路：关键是在于，每次松弛要基于上一次松弛的结果。因此，关键在于记录上次松弛更新过的节点，用。出节点node，操作。邻接表存储，方便找到。
048N06L-VB TO252一款N-Channel沟道TO252的MOSFET晶体管参数介绍与应用说明
07-08
048N06L-VB TO252；Package：TO252；Configuration：Single-N-Channel；VDS：60V；VGS：20（±V）；Vth：3V；RDS(ON)=12mΩ@VGS=4.5V；RDS(ON)=4.5mΩ@VGS=10V；ID：97A；Technology：Trench；
基于阵列响应向量估计的宽容体积阵波束形成-洪常委.pdf
最新发布
07-08
基于阵列响应向量估计的宽容体积阵波束形成-洪常委.pdf
图与图论算法(1).pptx
02-12
"该资源是关于图与图论算法的PPT讲解，涵盖了图的基本概念、存储方式以及遍历、欧拉路径、最短路径算法等内容。" 在图论中，图是由点集（顶点）和边集组成的数学结构，用于表示对象之间的关系。图可以是有向的或...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值