图的应用之最短路径：Dijkstra、Floyd、Bellman-Ford、SPFA算法

Dijkstra算法（O（n^2））

对于有向带权图，边权非负，求解某一个节点到所有节点的最短路

void dijkstra(int u)
{
	for(int i=1;i<=n;i++)
	{
		dist[i]=a[u][i];//初始化源点u到其他各个节点的最短路径长度 
		flag[i]=false;
		if(dist[i]==INF)
			p[i]=-1;//节点i与源点u不相邻 
		else
			p[i]=u;//节点i与源点u相邻,设置节点i的前驱p[i]=u 
		
	}
	dist[u]=0;
	for(int i=1;i<=n;i++)
	{
		int temp=INF,t=u;
		for(int j=1;j<=n;j++)//在集合V-S中寻找距离源点u最近的节点t 
			if(!flag[j] && dist[j]<temp)
			{
				t=j;
				temp=dist[j];
			}
		
		flag[t]=true;//否则，将t加入集合S 
		for(int j=1;j<=n;j++)//更新与t相邻接的节点到源点u的距离 
		{
			if(a[t][j]<INF)
				if(!flag[j] && dist[t]+a[t][j]<dist[j])
				{
					dist[j]=dist[t]+a[t][j];
					p[j]=t;
				}
		}
	}
}

因为我们使用了p数组记录了从u到任一节点最短路径上每个点的前驱值，所以可以还原出最短路

void sc(int x)
{
	if(x!=u)
	{
		sc(p[x]);
		cout<<x<<" ";
	}
	else
		cout<<x<<" ";
}

算法优化

1. 优先队列优化
2. 邻接表优化 

Floyd算法（O（n^3））

又叫点插法，用来求有向图任意两个节点之间的最短路径

void floyd()
{
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		{
			if(i!=j)
				if(a[i][j]<INF)
					p[i][j]=i;
				else
					p[i][j]=-1;
		}
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
			{
				if(a[i][k]+a[k][j]<a[i][j])
				{
					a[i][j]=a[i][k]+a[k][j];
					p[i][j]=p[k][j];
				}
			}
}

Bellman-Ford算法（O（nm））

如果遇到负权边，但没有负环时，求单源最短路径问题

bool bellman_ford(int u)//求从源点u到其他节点的最短路长度，并判断是否有负环 
{
	memset(dis,0x3f,sizeof(dis));
	dis[u]=0;
	for(int i=1;i<n;i++)//执行n-1次 
	{
		bool flag=0;
		for(int j=0;j<m;j++)//边数m 
			if(dis[e[j].b]>dis[e[j].a]+e[j].w)
			{
				dis[e[j].b]=dis[e[j].a]+e[j].w;
				flag=true;
			}
		if(!flag)
			return false;
	}
	for(int j=0;j<m;j++)//再执行一次，还能松弛，说明有负环 
		if(dis[e[j].b]>dis[e[j].a]+e[j].w)
			return true;
	return false;
}

算法优化

1. 提前退出循环。在实际操作中，可能不需要n-1次就求解完毕，利用if(!flag)就可以提前退出循环
2. 队列优化。松弛操作必定只会发生在最短路径松驰过前驱节点上，用一个队列记录松驰过的节点。这就是SPFA算法

SPFA算法 

SPFA是Bellman-Ford算法的队列优化算法，通常用于求解含负权边的单源最短路径，以及判负环。最坏情况下，时间复杂度为O(nm)，但在稀疏图上运行效率较高，为O(km)，其中k是一个较小的常数。

bool spfa(int u)
{
	queue<int>q;
	memset(vis,0,sizeof(vis));
	memset(sum,0,sizeof(sum));
	memset(dis,0x3f,sizeof(dis));
	vis[u]=1;
	dis[u]=0;
	sum[u]++;
	q.push(u);
	while(!q.empty())
	{
		int x=q.front();
		q.pop();
		vis[x]=0;
		for(int i=head[x];~i;i=e[i].next)
		{
			int v=e[i].to;
			if(dis[v]>dis[x]+e[i].w)
			{
				dis[v]=dis[x]+e[i].w;
				if(!vis[v])
				{
					if(++sum[v]>=n)
						return true;
					vis[v]=1;
					q.push(v);
				}
			}
		}
		
	}
	return false;
}