搜索与图论【中】

 目录

Dijkstra

Dijkstra求最短路I

Dijkstra求最短路Ⅱ

bellman-ford

有边数限制的最短路

🔺spfa

spfa求最短路

spfa判断负环

Floyd

Floyd求最短路


所谓松弛操作,就是看一看distv和distu+u到v的距离哪个大一点。 前者大说明当前不是最短路,否则赋值为后者。

Dijkstra

Dijkstra:进行n次迭代去确定每个点到起点的最小值,最后输出的终点即为最短路的距离。

Dijkstra求最短路I

迪杰斯特拉算法适用于求正权有向图中,源点到其余各个节点的最短路径。注意:图中可以有环,但不能有负权边。复杂度 O(n ^ 2)

给定一个n 个点 m 条边的有向图,图中可能存在重边和自环,所有边权均为正值。

请你求出 1 号点到 n 号点的最短距离,如果无法从 1 号点走到 n 号点,则输出 -1.
输入格式
第一行包含整数n和m。
接下来 m 行每行包含三个整数 x,y,z,表示存在一条从点x 到点y的有向边,边长为 z。
输出格式
输出一个整数,表示 1 号点到 n 号点的最短距离
如果路径不存在,则输出 -1。
数据范围
1 ≤ n ≤ 500.1 ≤ m ≤ 10^5
图中涉及边长均不超过10000
输入样例:

3 3
1 2 2
2 3 1
1 3 4

输出样例:

3

思路:1)初始化距离dis[];2)循环n次:将不在集合中的距离t最近的点加入S,更新t;如果存在距离dis[]数组存在初始化的,则没有最短路,否则dist[n]就是1~n的最短路

#include <bits/stdc++.h>
using namespace std;
const int N = 550;
int n, m;
int g[N][N], dist[N];//dist源点到其余各个节点的距离
bool st[N];

int dijkstra()
{
	dist[1] = 0;
	for(int i = 0; i < n; i++)//n次迭代
	{
		int t = -1;// 没有确定最短路径的节点中距离源点最近的点
		for(int j = 1; j <= n; j++)//从n个节点
			if(!st[j] && (t == -1 || dist[t] > dist[j])){//未访问过并且距离源点最近
				t = j;
			}
		st[t] = true;//访问
		for(int j = 1; j <= n; j++)//更新1-j的距离(当前距离,距离远点最近的t+t到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);
	memset(dist, 0x3f, sizeof dist);
	while(m--){
		int x, y, z;
		cin >> x >> y >> z;
		g[x][y] = min(g[x][y], z);//要最短的边
		
	}
	cout << dijkstra();
	return 0;
}

Dijkstra求最短路Ⅱ

给定一个n 个点 m 条边的有向图,图中可能存在重边和自环,所有边权均为正值。

请你求出 1 号点到 n 号点的最短距离,如果无法从 1 号点走到 n 号点,则输出 -1.
输入格式
第一行包含整数n和m。
接下来 m 行每行包含三个整数 x,y,z,表示存在一条从点x 到点y的有向边,边长为 z。
输出格式
输出一个整数,表示 1 号点到 n 号点的最短距离
如果路径不存在,则输出 -1。
数据范围
1≤n,m≤1.5×10^5
图中涉及边长均不超过10000
输入样例:

3 3
1 2 2
2 3 1
1 3 4

输出样例:

3

思路:与朴素版思路一样,但是由邻接矩阵转化为邻接表,从n次循环升级为优先队列

1)dist[1]=0,其余无穷大,入堆;2)弹出堆顶(距离最小的点),更新临界点的距离,成功则入堆,不断循环直到堆空

#include <bits/stdc++.h>
using namespace std;
#define PII pair<int,int> 
const int N = 2e5 + 10;
int n, m;
int e[N], ne[N], w[N], h[N], idx;
int dist[N];
bool st[N];
priority_queue<PII, vector<PII>, greater<PII> > q;//小顶堆

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

int dijkstra()
{
	dist[1] = 0;
	q.push({0, 1});//{距离, 节点}
	while(q.size())
	{
		int d = q.top().first, u = q.top().second; 
		q.pop();
		if(st[u])continue;//访问过
		st[u] = true;//标记
		for(int i = h[u]; ~i; i = ne[i]){
			int j = e[i];
			if(dist[j] > d + w[i]){//当前距离 大于 最近的+最近到当前点的距离
				dist[j] = d + w[i];//更新
				q.push({dist[j], j});
			}
		}
	}
	if(dist[n] == 0x3f3f3f3f){
		return -1;
	}
	return dist[n];
}

int main()
{
	cin >> n >> m;
	memset(dist, 0x3f, sizeof dist);
	memset(h, -1, sizeof h);
	while(m--){
		int x, y, z;
		cin >> x >> y >> z;
		add(x, y, z);
	}
	cout << dijkstra();
	return 0;
}

bellman-ford

有边数限制的最短路

给定一个n 个点 m 条边的有向图,图中可能存在重边和自环,边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离,如果无法从 1 号点走到n 号点,输出 impossible 。
注意: 图中可能 存在负权回路
输入格式
第一行包含三个整数n,m,k。
接下来 m 行,每行包含三个整数 x, y, z,表示存在一条从点 x 到点y的有向边,边
长为 z。
点的编号为 1~n
输出格式
输出一个整数,表示从 1 号点到 n 点的最多经过 k 条边的最短距离.

如果不存在满足条件的路径,则输出 impossible。

数据范围

1≤n,k≤500,
1≤m≤10000,
1≤x,y≤n,
任意边长的绝对值不超过 10000。

输入样例:

3 3 1
1 2 1
2 3 1
1 3 3

输出样例:

3

 

原理:连续进行松弛,在每次松弛时把每条边都更新一下,若在 n-1 次松弛后还能更新,则说明图中有负环,因此无法得出结果,否则就完成。 

思路:1)循环k次;2)每层循环每条边,使用三角不等式进行松弛操作;3)可以处理负权边,判断负环。

#include <bits/stdc++.h>
using namespace std;
int n, m, k;
const int N = 550, M = 10010;
const long long INF=0x3f3f3f3f  ;
int dist[N], backup[N];
struct Edge
{
	int a, b, w;
}edges[M];
int bellman_ford()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for(int i = 0; i < k; i++)
	{
		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);//加入每条边去松弛每个点到起点的距离
		}
	}
	/*5号节点距离起点的距离是无穷大,利用5号节点更新 n号节点距离起点的距离,将得到10^9-2,
	 虽然小于10^9,但并不存在最短路,(在边数限制在k条的条件下)。*/
	if(dist[n] > INF / 2) return -INF;
	return dist[n];
}
int main()
{
	cin >> n >> m >> k;
	for(int i = 0; i < m; i++){
		int x, y, z;
		cin >> x >> y >> z; 
		edges[i] = {x, y, z};
	}
	int t = bellman_ford();
	if(t == -INF)puts("impossible");
	else cout << t << "\n";
	return 0;
 } 

🔺spfa

spfa求最短路

给定一个 n 个点 m 条边的有向图,图中可能存在重边和自环,边权可能为负数。

请你求出 1 号点到 n 号点的最短距离,如果无法从 1 号点走到 n 号点,则输出impossible 。
数据保证不存在负权回路。
输入格式:
第一行包含整数n 和 m
接下来 m 行每行包含三个整数 x,y,z,表示存在一条从点 x 到点y的有向边,边长
为 z。
输出格式:
输出一个整数,表示 1 号点到 n 号点的最短距离。如果路径不存在,则输出 impossible 。
数据范围:

1≤n,m≤10^5,
图中涉及边长绝对值均不超过 10000。

输入样例:

3 3
1 2 5
2 3 -3
1 3 4

输出样例:

2

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, INF = 0x3f3f3f3f;
int n, m,  e[N], ne[N], h[N], w[N], idx;
int dist[N];
bool st[N];
queue<int> q;
void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++; 
}
void spfa()
{
	q.push(1);
	dist[1] = 0;
	st[1] = true;//在队内
	while(!q.empty())
	{
		int t = q.front(); q.pop();
		st[t] = false;//不在队内
		for(int i = h[t]; ~i; 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;//在队内
				}
			}
			
		}
	}
}
int main()
{
	cin >> n >> m;
	memset(h, -1, sizeof h);
	memset(dist, 0x3f, sizeof dist);
	while(m--){
		int x, y, w;
		cin >> x >> y >> w;
		add(x, y, w);
	}
	spfa();
	if(dist[n] == INF){
		puts("impossible");
	}else{
		cout << dist[n];
	}
	return 0;
}

spfa判断负环

给定一个n 个点 m 条边的有向图,图中可能存在重边和自环,边权可能为负数。

请你判断图中是否存在负权回路。
输入格式
第一行包含整数 n和m。
接下来 m 行每行包含三个整数 x,y,z,表示存在一条从点 x 到点 y的有向边,边长为z。
输出格式
如果图中存在负权回路,则输出 Yes,否则输出No
数据范围

1≤n≤2000,
1≤m≤10000,
图中涉及边长绝对值均不超过 10000

输入样例:

3 3
1 2 -1
2 3 4
3 1 -4

输出样例:

Yes

 思路:

#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
int n, m;
int e[N], ne[N], w[N], h[N], idx;
int dist[N], cnt[N];//cnt[]记录当前x点到虚拟源点最短路的边数
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()
{
	queue<int> q;
	for(int i = 1; i <= n; i++){//每个点都放进去
		st[i] = true;
		q.push(i);
	}
	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];
				cnt[j] = cnt[t] + 1;
				st[j] = true;
				q.push(j);
			}
			if(cnt[j] > n)return true;
		}
	}
	return false;
}

int main()
{
	cin >> n >> m;
	memset(h, -1, sizeof h);
	while(m--){
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
	}
	if(spfa()) puts("Yes");
	else puts("No");
	
	return 0;
}

Floyd

Floyd求最短路

给定一个n 个点 m 条边的有向图,图中可能存在重边和自环,边权可能为负数。

再给定 k 个询问,每个询问包含两个整数 x 和 y,表示查询从点 x 到点y的最短距离,如果路径不存在,则输出 impossible 。
数据保证图中不存在负权回路.
输入格式
第一行包含三个整数 n,m,k
接下来 m 行,每行包含三个整数 x,y,z,表示存在一条从点 x 到点y的有向边,长为 z。
接下来 k 行,每行包含两个整数 x,y,表示询问点 x 到点 y的最短距离
输出格式
共 k 行,每行输出一个整数,表示询问的结果,若询问两点间不存在路径,则输出
impossible 
数据范围

1≤n≤200,
1≤k≤n^2
1≤m≤20000,
图中涉及边长绝对值均不超过 10000。

输入样例:

3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3

输出样例:

impossible
1

 从任意顶点 i 到任意顶点 j 的最短路径:1)i -> j; 2) i 经过多个节点到 j
对于每个顶点 k ,检查 从i到k的路径+从k到j的路径是否 < 从 i 到 j 的路径 => dist[i][k] + dist[k][j] < dist[i][j]; 并更新

#include <bits/stdc++.h>
using namespace std;
const int N = 210, INF = 0x3f3f3f3f;
int n, m, k;
int d[N][N];

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


int main()
{
	cin >> n >> m >> k;
	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, c;
		cin >> a >> b >> c;
		d[a][b] = min(d[a][b], c);
	}
	floyd();
	while(k--){
		int a, b;
		cin >> a >> b;
		if(d[a][b] > INF / 2)puts("impossible");
		else
		cout << d[a][b] << "\n";
	}
	return 0;
}

本篇是关于求最短路的四种算法,分别为Dijkstra,bellman-ford,spfa,Floyd。

关于图论篇:

搜索与图论【上】

搜索与图论【中】

搜索与图论【下】


与理想平等交易,同喧嚣保持距离。

  • 6
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值