学习笔记：最短路[模版总结]

最短路算法分为两大类：

1、单源最短路，常用算法有：
(1) dijkstra，只适用于正边权图。在稠密图上的时间复杂度是 O(n^2)，稀疏图上的时间复杂度是 O(mlogn)。
(2) spfa，不论边权是正的还是负的，都可以做。算法平均时间复杂度是 O(km),k是常数
2、多源最短路，一般用floyd算法。时间复杂度是 O(n^3)。

算法一：dijkstra算法

模板题：
给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出-1。

输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出格式
输出一个整数，表示1号点到n号点的最短距离。如果路径不存在，则输出-1。

1、朴素版dijstra算法 O(n^2)
适用于稠密图，n比较小，存图方式用邻接矩阵
1≤n≤500 ,1≤m≤1e5

//朴素版dijsktra算法

const int N = 510;
int n,m;
int dis[N],g[N][N];
bool vis[N];

void dijkstra(int s)
{
    
    
	memset(dis,0x3f,sizeof dis);
	dis[s]=0;
	
	for(int i=1;i<n;i++) //起始点s已经确定，循环n-1次 
	{
    
    
		int t=-1; //找到不在集合里 离起点最近的点
		for(int j=1;j<=n;j++)
			if(!vis[j]&&(t==-1||dis[t]>dis[j]))	t=j;
		
		vis[t]=1; //将该点加入集合 
		for(int j=1;j<=n;j++)	
			dis[j]=min(dis[j],dis[t]+g[t][j]); //用该点更新其他点到起点额距离 
	}
}

int main()
{
    
    
	cin>>n>>m;
	
	//初始化邻接矩阵
	memset(g,0x3f,sizeof g);
	for(int i=0;i<=n;i++)	g[i][i]=0;
	
	while(m--)
	{
    
    
		int u,v,w;
		cin>>u>>v>>w;
		g[u][v]=min(g[u][v],w); //因为有重边，要取最小 
	}
	dijkstra(1);
	if(dis[n]==inf)	puts("-1");
	else	cout<<dis[n]<<endl;
	return 0;
}

2、堆优化版dijkstra算法O(mlogn)
适用与稀疏图，n与m都比较大，存图方式用邻接表
1≤n,m≤1.5×1e5

//堆优化版dijkstra算法

const int N = 1.5e+5, M = 1.5e+5;


int n,m,dis[N];
bool vis[N];
struct node{
    
    int v,w,next;}edge[M];
int head[N],idx;

void add(int u,int v,int w)
{
    
    
	edge[idx]=(node){
    
    v,w,head[u]};
	head[u]=idx++;
}

typedef pair<int,int> pii;

void dijkstra(int s)
{
    
    
	memset(dis,0x3f,sizeof dis);
	dis[s]=0;
	
	priority_queue<pii> q;
	q.push(pii(0,s));
	while(!q.empty())
	{
    
    
		int u=q.top().second;
		q.pop();
		if(vis[u])	continue;
		vis[u]=1;
		for(int i=head[u];~i;i=edge[i].next)
		{
    
    
			int v=edge[i].v, w=edge[i].w;
			if(!vis[v]&&dis[v]>dis[u]+w)
			{
    
    
				dis[v]=dis[u]+w;
				q.push(pii(-dis[v],v)); //因为优先队列默认是大根堆，若想实现 小根堆的操作，第一维都放入相反数 
			}
		}
	}
}

int main()
{
    
    
	memset(head,-1,sizeof head); //链表初始化
	 
	cin>>n>>m;
	while(m--)
	{
    
    
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w);
	}
	dijkstra(1);
	if(dis[n]==inf)	puts("-1");
	else	cout<<dis[n]<<endl;
	return 0;
}

算法二：spfa算法[平均复杂度O(m),最坏O(nm)]

模版题：
给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。
请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出impossible。数据保证不存在负权回路
输入格式
第一行包含整数n和m。(1≤n,m≤1e5)
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出格式
输出一个整数，表示1号点到n号点的最短距离。如果路径不存在，则输出”impossible”。

//spfa算法

const int N = 1e5+5, M = 1e5+5;

int n,m,dis[N];
bool vis[N];
struct node{
    
    int v,w,next;}edge[M];
int head[N],idx;

void add(int u,int v,int w)
{
    
    
	edge[idx]=(node){
    
    v,w,head[u]};
	head[u]=idx++;
}

void spfa(int s)
{
    
    
	memset(dis,0x3f,sizeof dis);
	dis[s]=0;
	
	queue<int> q;
	q.push(s); vis[s]=1;
	while(!q.empty())
	{
    
    
		int u=q.front();
		q.pop(); vis[u]=0;
		for(int i=head[u];~i;i=edge[i].next)
		{
    
    
			int v=edge[i].v, w=edge[i].w;
			if(dis[v]>dis[u]+w)
			{
    
    
				dis[v]=dis[u]+w;
				if(!vis[v])	q.push(v),vis[v]=1;
			}
		}
	}
}

int main()
{
    
    
	memset(head,-1,sizeof head); //链表初始化
	 
	cin>>n>>m;
	while(m--)
	{
    
    
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w);
	}
	spfa(1);
	if(dis[n]==inf)	puts("impossible");
	else	cout<<dis[n]<<endl;
	return 0;
}

spfa应用：spfa判负环
给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。
请你判断图中是否存在负权回路。

const int N = 1e5+5, M = 1e5+5;

int n,m,dis[N];
bool vis[N];
struct node{
    
    int v,w,next;}edge[M];
int head[N],idx;

void add(int u,int v,int w)
{
    
    
	edge[idx]=(node){
    
    v,w,head[u]};
	head[u]=idx++;
}

int cnt[N]; //根据每个点的入队次数判断是否出现负环 
bool spfa(int s)
{
    
    
	memset(dis,0x3f,sizeof dis);
	dis[s]=0;
	
	queue<int> q;
	q.push(s); vis[s]=1;
	while(!q.empty())
	{
    
    
		int u=q.front();
		q.pop(); vis[u]=0;
		for(int i=head[u];~i;i=edge[i].next)
		{
    
    
			int v=edge[i].v, w=edge[i].w;
			if(dis[v]>dis[u]+w)
			{
    
    
				dis[v]=dis[u]+w;
				if(!vis[v])
				{
    
    
					q.push(v),vis[v]=1;
					cnt[v]++;
					if(cnt[v]>n)	return true; //入队次数大于n说明出现了负环 
				}
			}
		}
	}
	return false;
}

int main()
{
    
    
	memset(head,-1,sizeof head); //链表初始化
	 
	cin>>n>>m;
	while(m--)
	{
    
    
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w);
	}
	//建立虚拟点0，让0向每一个点连接一条边权为0的边
	for(int i=1;i<=n;i++)	add(0,i,0);
	 
	//从0点出发判断
	if(spfa(0))	puts("Yes");
	else	puts("No");
	 
	return 0;
}

算法三：bellman-ford算法O(nm)

该算法不常用，不过该算法可以解决一种特殊问题：有边数限制的最短路

模版题：
给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。
请你求出从1号点到n号点的最多经过k条边的最短距离，如果无法从1号点走到n号点，输出impossible。
注意：图中可能存在负权回路。

// bellman-ford算法

const int N = 510, M = 1e4+5;

int n,m,k;
int dis[N],backup[N];
struct node{
    
    int u,v,w;}edge[M]; //直接用结构体存边

void bellman_ford(int s)
{
    
    
	memset(dis,0x3f,sizeof dis);
	dis[s]=0;
	for(int i=0;i<k;i++) 这里循环k次后得到的所有结果都是最多经过k条边的最短路 
	{
    
    
		memcpy(backup,dis,sizeof dis); //备份dis数组
		for(int j=0;j<m;j++)
		{
    
    
			int u=edge[j].u, v=edge[j].v, w=edge[j].w;
			dis[v]=min(dis[v],backup[u]+w); //每次更新dis只用上一次的结果，防止用已经更新的结果来更新dis，类似与01背包的倒序更新问题	
		}
	}
}

int main()
{
    
    
	cin>>n>>m>>k;
	for(int i=1;i<=m;i++)
	{
    
    
		int u,v,w;
		cin>>u>>v>>w;
		edge[i]=(node){
    
    u,v,w};
	}
	bellman_ford(1);
	if(dis[n]>inf/2)	puts("impossible"); //尽管无法到达，但是该inf可能被更新过
	else	cout<<dis[n]<<endl;
	return 0;
}

算法四：folyd算法O(n^3)

模版题：
给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。
再给定k个询问，每个询问包含两个整数x和y，表示查询从点x到点y的最短距离，如果路径不存在，则输出“impossible”。
数据保证图中不存在负权回路。

输入格式
第一行包含三个整数n，m，k(1≤n≤200, 1≤k≤n^2, 1≤m≤20000)
接下来m行，每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
接下来k行，每行包含两个整数x，y，表示询问点x到点y的最短距离。

输出格式
共k行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出“impossible”。

//folyd算法

const int N = 210;

int n,m;
int f[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++)
				f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
}

int main()
{
    
    
	int k;
	cin>>n>>m>>k;
	
	//初始化 
	memset(f,0x3f,sizeof f);
	for(int i=0;i<=n;i++)	f[i][i]=0;
	
	while(m--)
	{
    
    
		int u,v,w;
		cin>>u>>v>>w;
		f[u][v]=min(f[u][v],w); //有重边 
	}
	
	floyd();
	
	while(k--)
	{
    
    
		int u,v;
		cin>>u>>v;
		if(f[u][v]>inf/2)	puts("impossible"); //因为有负权，可能将inf更新 
		else	cout<<f[u][v]<<endl;
	}
	return 0;
}