专题 | 存图&最短路&负环

最新推荐文章于 2024-07-20 09:51:47 发布

entiesci

最新推荐文章于 2024-07-20 09:51:47 发布

阅读量889

点赞数 18

分类专栏：算法竞赛文章标签：开发语言算法 c++

本文链接：https://blog.csdn.net/hzx616599/article/details/136534580

版权

图的存储方式

结构体邻接表（链式前向星）

请强记！

struct edge{
	int v,c,nxt;
}e[N];
int h[N],idx;
void add(int a,int b,int w){
	e[++idx]={b,w,h[a]};
	h[a]=idx;
}

邻接表（链式前向星）

由以下3个数组组成

int h[],nxt[],to[]; //头,节点i(i为实际编号)的相邻节点在数组里的编号,节点i的相邻节点的实际编号
int cnt;    //记录节点个数

存储

模拟一下（不一定准确）

插入前	插入9后(连接1,9)
h[1]=3	h[1]=4
nxt={0,0,2}	nxt={0,0,2,3}
cnt=3	cnt=4

当访问1的临边时,让i=h[1],然后不断v=to[i] ( v 是相邻的点的真实编号), i=nxt[i] ,直到nxt[i]为空停止.

void add(int a, int b) {
    to[++cnt] = b;        //新建节点的目标
    nxt[cnt] = h[a];    //头插法
    h[a] = cnt;        //接上
}

遍历

当我们要访问一个点的出边时,从i=h[i]开始向下i=nxt[i],直到nxt[i]==0

int u=1;    //u是目前节点的编号
for(int i=h[u],i;i=nxt[i]){}

邻接矩阵

建立矩阵web[a][b],如果web[a][b]==1,则表示存在 $ a\to b$ 的路径

可按具体环境改变web[a][b]存的内容

Vector存图

连边（无向图）

void add(int a,int b){
	e[a].push_back(b);
	e[b].push_back(a);
}

访问u的邻点

for(int i=0;i<e[u].size();i++){
	int v=e[u][i];
}
//或者
for(int v:e[u]){
	
}

可以去学习一下:的使用方法。同时了解一下auto类型的使用方法。

对于有边权的情况，我们要么把vector定义为struct或者pair，要么开第二个vector来同步存其边权。

最短路（题面）

题目描述

如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。

输入格式

第一行包含三个整数 $n, m, s$ ，分别表示点的个数、有向边的个数、出发点的编号。

接下来 $m$ 行每行包含三个整数 $u, v, w$ ，表示一条 $\to v$ 的，长度为 $w$ 的边。

输出格式

输出一行 $n$ 个整数，第 $i$ 个表示 $s$ 到第 $i$ 个点的最短路径，若不能到达则输出 $2^{31}-1$ 。

对于 $100\%$ 的数据： $\le n \le 10^4$ ， $1\le m \le 5\times 10^5$ ， $1\le u,v\le n$ ， $w\ge 0$ ， $\sum w< 2^{31}$ ，保证数据随机。

两个点之间可能有多条边，敬请注意。

样例说明：

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?

图片1到3和1到4的文字位置调换

Dijkstra

·通过已得到最短路径的的点去扩展其他的点，设起点为 s

·设定 dist[s]=0;dist[v]=inf(v!=s)

找到最小的 dist [ u ]（且 u 没有被访问过）此时的 dist [ u ]就是起点到该点的最短路（为什么？→之后的dis值一定大于dis_u，不会更新dis_u）
更新与 u 相连的点

vector 版本

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e6+5;
int vis[N],h[N];
int dis[N],cnt,u,w,n,m,v,s;
struct node {
	int nxt,dis;
};

vector<node> e[N];
priority_queue<pair<int,int>> pq;
void add(int a,int b,int dis) {
	e[a].push_back((node){b,dis});
}

void djstr(int rt) {
	pq.push(make_pair(0,rt));
	int u=rt;	//先从起点开始查
	for(int i=1; i<=n; i++)dis[i]=2147483647;	//初始化边权

	dis[rt]=0;
//	vis[rt]=1;//别写错！！
	
	while(pq.size()) {	//搜完全图
		
		u=pq.top().second;
		
		pq.pop();
		if(vis[u])continue;//记得continue
		vis[u]=1;
		for(int i=0;i<e[u].size();i++){
			int v=e[u][i].nxt,w=e[u][i].dis;
			if(!vis[v]&&dis[u]+w<dis[v]){
				dis[v]=dis[u]+w;	//更新
				pq.push(make_pair(-dis[v],v));
			}
		}
	}
}
signed main() {

	cin>>n>>m>>s;

	for(int i=1; i<=m; i++) {
		cin>>u>>v>>w;
		if(u!=v)add(u,v,w);
	}
	djstr(s);
	for(int i=1; i<=n; i++) {
		cout<<dis[i]<<' ';
	}
	return 0;
}

邻接表版本

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int MAXN=1e6+5;
int vis[MAXN],h[MAXN];
int dis[MAXN],cnt,u,w,n,m,v,s;
struct Edge {
	int next,to,dis;
} edge[MAXN];
priority_queue<pair<int,int>> pq;
void add(int from,int to,int dis) {
	edge[++cnt].next=h[from];
	edge[cnt].to=to;
	edge[cnt].dis=dis;
	h[from]=cnt;
}

void djstr(int rt) {
	pq.push(make_pair(0,rt));
	int u=rt;	//先从起点开始查
	for(int i=1; i<=n; i++)dis[i]=2147483647;	//初始化边权

	dis[rt]=0;
	//for(int i=1; i<=n; i++)
	while(pq.size()) {	//搜完全图
		
		u=pq.top().second;

		pq.pop();
        if(vis[u])continue;
        vis[u]=1;
		for(int j=h[u]; j; j=edge[j].next) {
			if(!vis[edge[j].to]&&dis[u]+edge[j].dis<dis[edge[j].to]){
				dis[edge[j].to]=dis[u]+edge[j].dis;	//更新
				pq.push(make_pair(-dis[edge[j].to],edge[j].to));
			}
				
		}
		
		/*int min=2147483647;
		for(int j=1; j<=n; j++) {	//重新查找到i距离最小的点
			if(!vis[j]&&dis[j]<min) {
				min=dis[j];
				u=j;
			}
		}*/
	}
}
signed main() {

	cin>>n>>m>>s;

	for(int i=1; i<=m; i++) {
		cin>>u>>v>>w;
		if(u!=v)add(u,v,w);
	}
	djstr(s);
	for(int i=1; i<=n; i++) {
		cout<<dis[i]<<' ';
	}
	return 0;
}

其他问题

最短路计数·求 1 号点到其他点的最短路有几条？

每次更新的时候如果dis不变，则该点最短路cnt+1，否则cnt变为1

Bellman-Ford

求总路径条数不多于K条的最短路径

#include<bits/stdc++.h>
using namespace std;
int n,m,ans;
int dis[5005],road[5005][5005];

void bellman(){
	
	for(int i=2;i<=n;i++)dis[i]=0x3f3f3f3f;
	dis[1]=0;
	for(int i=1;i<=n;i++){
		int flag=0;
		for(int j=1;j<=m;j++){
			if(dis[j]>dis[i]+road[i][j])dis[j]=dis[i]+road[i][j],flag=1;//如果1->j比1->i->j远，则更新它 
		}
		if(!flag)break;	//如果没有更新则break 
	}
}
int main(){
	memset(road,0x3f3f3f3f,sizeof road);
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int u,v,w;
		cin>>u>>v>>w;
		road[u][v]=w;
	
	}
	bellman();
	
	for(int i=1;i<=n;i++)cout<<dis[i]<<' ';

    return 0;
}

另外一种写法

#include<bits/stdc++.h>
using namespace std;
int n,m,ans;
int d[5005];
struct node{
	int u,v,w;
}e[5050];
int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int c,c2,y;
		cin>>c>>c2>>y;
		e[i].u=c2;e[i].v=c;e[i].w=y;
	
	}
	for(int i=2;i<=n;i++)d[i]=0x3f3f3f3f;
	for(int i=1;i<=n-1;i++){
		for(int j=1;j<=m;j++){
			d[e[j].v]=min(d[e[j].u]+e[j].w,d[e[j].v]);
		}
	}
	for(int i=1;i<=m;i++){
		if(d[e[i].v]>d[e[i].u]+e[i].w){
			printf("NO");return 0;  //有负环
		}
	}
	for(int i=1;i<=n;i++)cout<<d[i]<<' ';

    return 0;
}

因为图的最短路径不包含负环或正环，故显然最多只能包含 n−1 条边，于是进行 n−1 次松弛操作。

若经过 n−1 轮松弛操作后仍能松弛，说明图存在负权回路。

SPFA

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int MAXN=1e4+5;
int vis[MAXN],h[50*MAXN];
int dis[MAXN],cnt,u,w,n,m,v,s;
struct Edge {
	int next,to,dis;
} edge[MAXN*50];
void add(int from,int to,int dis) {
	edge[++cnt].next=h[from];
	edge[cnt].to=to;
	edge[cnt].dis=dis;
	h[from]=cnt;
}

queue <int> q;

void spfa(int rt) {
	dis[rt]=0;
	vis[rt]=1;
	q.push(rt);
	while(q.size()) {   //类似广搜
		int u=q.front();
		q.pop();
		vis[u]=0;
		for(int i=h[u]; i; i=edge[i].next) {
			int nxt=edge[i].to;
			if(dis[nxt]<=dis[u]+edge[i].dis)continue;
			dis[nxt]=dis[u]+edge[i].dis;
			if(!vis[nxt]) {
				vis[nxt]=1;
				q.push(nxt);
			}
		}
	}

}
signed main() {
//	freopen("P3371_2.in","r",stdin);
//	freopen("test.txt","w",stdout);
	cin>>n>>m>>s;

	for(int i=1; i<=n; i++)dis[i]=2147483647;
//	memset(dis,0x3f,sizeof(dis));
	//cout<<dis[1]<<endl;
	for(int i=1; i<=m; i++) {
		cin>>u>>v>>w;
		add(u,v,w);
	}
	spfa(s);
	for(int i=1; i<=n; i++) {
		cout<<dis[i]<<' ';
	}
	return 0;
}

堆优化Dijkstra和SPFA的区别和优缺点：待补充

SPFA判负环

题目描述

给定一个 $n$ 个点的有向图，请求出图中是否存在从顶点 $1$ 出发能到达的负环。

负环的定义是：一条边权之和为负数的回路。

输入格式

本题单测试点有多组测试数据。

输入的第一行是一个整数 $T$ ，表示测试数据的组数。对于每组数据的格式如下：

第一行有两个整数，分别表示图的点数 $n$ 和接下来给出边信息的条数 $m$ 。

接下来 $m$ 行，每行三个整数 $u, v, w$ 。

若 $\geq 0$ ，则表示存在一条从 $u$ 至 $v$ 边权为 $w$ 的边，还存在一条从 $v$ 至 $u$ 边权为 $w$ 的边。
若 $w < 0$ ，则只表示存在一条从 $u$ 至 $v$ 边权为 $w$ 的边。

输出格式

对于每组数据，输出一行一个字符串，若所求负环存在，则输出 YES，否则输出 NO。

样例 #1

样例输入 #1

样例输出 #1

NO
YES

提示

数据规模与约定

对于全部的测试点，保证：

$\leq n \leq 2 \times 10^3$ ，

最低0.47元/天解锁文章

entiesci

关注

18
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
专题 | 存图&最短路&负环

图的存储方式Dijkstra堆优化Dijkstra求总路径条数不多于K条的最短路径SPFA堆优化Dijkstra和SPFA的区别和优缺点SPFA判负环Floyd弗洛伊德Johnson 全源最短路次短路算法/K短路算法其他算法。
复制链接

扫一扫