单源最短路径

smyoking

已于 2023-10-02 17:27:57 修改

阅读量60

点赞数

文章标签：笔记

于 2023-06-29 17:34:27 首次发布

本文链接：https://blog.csdn.net/yzx200708240628/article/details/131460743

版权

1.dijkstra 算法

dijkstra 算法是基于贪心思想的一种算法，只能处理没有负边权的图的单源最短路径。

大概思路

设源点为 s ，一共有 n 个节点，m 个询问。

首先，利用链式前向星将每条边进行保存。然后维护一个数组dist[]，用来记录目前所有节点到源点的最短路径，同时维护一个bool数组d[]，用来记录这条边是否被遍历过了。然后，遍历从源点发出的边，找出除了被d[]标记之后离源点最近的一个点，再从这个点开始更新dist[]，标记这个点，然后再循环同样的操作。时间复杂度O(n*n)；

可以发现，dijkstra 算法的复杂度主要来自点的遍历。所以，就有了进阶版的 dijkstra 算法：用堆优化。

堆优化的一大好处就是排除了大量的重复查询，堆中只会出现已经遍历到了的点。我们设点的个数为 n，边数为 m ，则堆优化的时间复杂度 O(n+mlogm)，这个复杂度在较为稀疏图中很适合。当然，在选择用堆优化还是朴素 dijkstra 时，应该考虑图的特性，仔细判断，谨慎选择。

Code （由1到n的单源最短路径）

#include<bits/stdc++.h>
#define maxn 1000005
#define maxm 5000000
#define INF (1<<31)-1
#define ll long long int
using namespace std;
ll n,m,s,u,v,w,dist[maxn];
struct edge{
	ll to,w,next;
}edges[maxm];
ll first[maxn],cnt;
bool yy[maxn];
priority_queue<pair<int,int> >q;
void Dijkstra()
{
	dist[s]=0;
	q.push(make_pair(0,1));
	while (!q.empty())
	{
		ll p=q.top().second;q.pop();
		ll t=first[p];
		if (yy[p]) continue;
		yy[p]=true;
		while (t)
		{
			ll h=edges[t].to,w2=edges[t].w;
			if (dist[h]>dist[p]+w2) {dist[h]=dist[p]+w2;q.push(make_pair(-dist[h],h));}
			t=edges[t].next;
		}
	}
}
void add(ll u,ll v,ll w)
{
	edges[++cnt].to=v;
	edges[cnt].w=w;
	edges[cnt].next=first[u];
	first[u]=cnt;
}
int main()
{
	scanf("%lld %lld",&n,&m);
	s=1;
	for (ll i=1;i<=m;++i)
	{
		scanf("%lld %lld %lld",&u,&v,&w);
		add(u,v,w);
	}
	for (ll i=1;i<=n;++i) dist[i]=INF;
	Dijkstra();
	for (ll i=1;i<=n;++i) 
	if (yy[i]==false) printf("-1 ");
	else printf("%lld ",dist[i]);
	return 0;
}

SPFA

bellman：对边进行松弛

SPFA：队列优化之后的bellman 算法

大概思路：假设当前节点为u，有一条边(u,v)，使得两个点满足三角形不等式dist[v]>dist[u]+(u,v)，就更新dist[v]，并判断v是否在队列中，如果不在将v压入队列，进行边的松弛。

不过SPFA尽管经过了无数人的优化，还是能够找到方法卡死SPFA。所以，在做题中，题目明确指出没有负边，还是建议使用dijkstra算法。

#include<bits/stdc++.h>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>

#define int long long

using namespace std;

inline int read(){
	   int x=0,f=1;char s=getchar();
	   while (s>'9'||s<'0'){
			 if (s=='-') f=-f;
			 s=getchar();
	   }
	   while (s>='0'&&s<='9'){
			 x=x*10+s-'0';
			 s=getchar();
	   }
	   return x*f;
}

const int N = 1e5+10;
const int M = 5e5+10;
const int INF = (1<<31)-1;

int n,m,s,first[N],cnt,u,v,w,dist[N];
queue<int>sx;
bool d[N];

struct node{
	int to,nxt,w;
}edges[M*2];

void add(int u,int v,int w) {
	edges[++cnt].to=v;
	edges[cnt].w=w;
	edges[cnt].nxt=first[u];
	first[u]=cnt;
}

void spfa() {
	for (int i=1;i<=n;++i) dist[i]=INF;
	dist[s]=0;sx.push(s);d[s]=true;
	while (!sx.empty()) {
		int root=sx.front();sx.pop();
		d[root]=false;
		for (int t=first[root];t;t=edges[t].nxt) {
			int h=edges[t].to;
			if (dist[h]>dist[root]+edges[t].w) {
				dist[h]=dist[root]+edges[t].w;
				if (!d[h]) d[h]=true,sx.push(h);
			}
		}
	} 
}

signed main(){
	n=read();m=read();
	s=1;
	for (int i=1;i<=m;++i) {
		u=read();v=read();w=read();
		add(u,v,w);
		//如果是无向边则再加一条 add(v,u,w); 
	}
	spfa();
	for (int i=1;i<=n;++i) if (dist[i]==INF) printf("-1 ");
	else printf("%lld ",dist[i]);
	return 0;
}

分层图

有一种类型的题目，一共 n 个点， m 条边，而一共可以使路上的 k 条边的权值变为 0，让你求单源最短路径。暴力思想，自然是枚举这 k 条边，然后求每次的最短路，那么久一共有 C(n,k) 种图，并且每次都要进行一次 O(nlogn) 的最短路求解，这个是十分不可取的。

分层图，是我在偶然之中发现的一种神奇算法，虽然它的提出已经好久了，但是对于蒟蒻的我来说，这个思想很值得记录下来。

例如有一张图，对于每条边 (u,v) , 每次加边时，add(u+i*n,v+(i+1)*n,0),add(u+(i+1)*n,v+(i+1)*n)(i>=0&&i<=k); 而这个add 则是用链式前向星时的那个 add。这个加边很好理解，就是将原本的图复制一下下，变成 (k+1) 个原本的图。然后再用边权为 0 的边将相邻两张图中原本连着的边连起来，就想当与这条边的权值变为0。而最后的答案，自然就是 min(dist[n+i*n] (i>=0&&i<=k) );

例题：luogu P4568 飞行路线

Code

#include<bits/stdc++.h>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>

#define mk make_pair

using namespace std;

inline int read(){
	   int x=0,f=1;char s=getchar();
	   while (s>'9'||s<'0'){
			 if (s=='-') f=-f;
			 s=getchar();
	   }
	   while (s>='0'&&s<='9'){
			 x=x*10+s-'0';
			 s=getchar();
	   }
	   return x*f;
}

const int N = 1e6+10;
const int M = 5e6+10;

int n,m,k,dist[N],st,ed,u,v,w,first[N],cnt;
struct edge{
	int to,nxt,w;
}edges[M];
priority_queue< pair<int,int> >q;
bool d[N];

void add(int u,int v,int w) {
	edges[++cnt].to=v;
	edges[cnt].nxt=first[u];
	first[u]=cnt;
	edges[cnt].w=w;
}

void D() {
	memset(dist,20,sizeof(dist));
	dist[st]=0;
	q.push(mk(0,st));
	while (!q.empty()) {
		int root=q.top().second;q.pop();
		if (d[root]) continue;
		d[root]=true;
		for (int t=first[root];t;t=edges[t].nxt) {
			int h=edges[t].to;
			if (dist[h]>dist[root]+edges[t].w) {
				dist[h]=dist[root]+edges[t].w;
				q.push(mk(-dist[h],h));
			}
		}
	}
}

int main(){
	n=read();m=read();k=read();
	st=read();ed=read();
	for (int i=1;i<=m;++i) {
		scanf("%d%d%d",&u,&v,&w);
		add(u,v,w);add(v,u,w);
		for (int j=1;j<=k;++j) {
			add(u+(j-1)*n,v+j*n,0);
			add(v+(j-1)*n,u+j*n,0);
			add(u+j*n,v+j*n,w);
			add(v+j*n,u+j*n,w);
		}
	}
	if (k>=m) {
		printf("0\n");
		return 0;
	}
	D();
	printf("%d\n",dist[ed+n*k]);
	return 0;
}