图论最短路模板

最新推荐文章于 2022-12-29 08:30:00 发布

wan-ying

最新推荐文章于 2022-12-29 08:30:00 发布

阅读量64

点赞数 1

文章标签：图论算法

本文链接：https://blog.csdn.net/jsxhnzl/article/details/125952693

版权

1.Floyd

Floyed算法：

原理：O（n^3）的for循环，对每一个中间节点k做松弛（寻找更短路径）；

但它适合算多源最短路径，即任意两点间的距离。

但spfa，迪杰斯特拉就只能算一个点到其他任一点的最短路径。

代码

for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
	if(i!=j&&j!=k&&i!=k&&dis[i][j]>dis[i][k]+dis[k][j])
	dis[i][j]=dis[i][k]+dis[k][j];
	//或者
	//dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}

2.Dijkstra

算法特点：

迪科斯彻算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。

算法的思路:

Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。
然后，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点，
然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。
然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。
代码

int n,m;
int a[2001][2001],dis[2001];
bool vis[2001];
int main(){
	scanf("%d%d",&n,&m);
	memset(a,0x3f,sizeof(a));//初始化 
	memset(vis,true,sizeof(vis));
	for(int i=1;i<=n;i++)
	a[i][i]=0;
	int x,y,z;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&x,&y,&z);
		a[x][y]=a[y][x]=min(a[x][y],z);
	}
	vis[1]=false;
	for(int i=1;i<=n;i++)
	dis[i]=a[1][i];
	int minn=0x3f3f3f3f,k;
	for(int i=1;i<=n;i++)
	{
		minn=0x3f3f3f3f;
		for(int j=1;j<=n;j++)
		{
			if(vis[j]==true&&minn>dis[j])
			{
				minn=dis[j];
				k=j;
			}
		}
		vis[k]=false;
		for(int j=1;j<=n;j++)
		{
			if(vis[j]==true)
			{
				if(dis[k]+a[k][j]<dis[j])
				dis[j]=dis[k]+a[k][j];
			}
		}
	}
	cout<<dis[n]<<endl;
}

3.SPFA

SPFA(Shortest Path Faster Algorithm)算法是求单源最短路径的一种算法，它是Bellman-ford的队列优化，它是一种十分高效的最短路算法。

很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。SPFA的复杂度大约是O(kE),k是每个点的平均进队次数(一般的，k是一个常数，在稀疏图中小于2)。

但是，SPFA算法稳定性较差，在稠密图中SPFA算法时间复杂度会退化。

实现方法：建立一个队列，初始时队列里只有起始点，在建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。

此外，SPFA算法还可以判断图中是否有负权环，即一个点入队次数超过N。

代码

struct edge
{
	int /*from,*/to,w;
} ;
vector<edge>e[500002];
int dis[100002];
bool vis[100002];//点是否再队列中
int neg[100002] ;//判断负环
int n,m;
int spfa(int s)
{
	memset(neg,0,sizeof(neg)) ;
	neg[s]=0;
	for(int i=1;i<=n;i++)
	{
		dis[i]=0x3f3f3f3f;
		vis[i]=false;
	}
	dis[s]=0;
	queue<int>q;
	q.push(s);
	vis[s]=true; 
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		vis[u]=false;
		for(int i=0;i<e[u].size();i++)
		{
			int v=e[u][i].to;
			int w=e[u][i].w;
			if(dis[u]+w<dis[v])
			{
				dis[v]=dis[u]+w;
				if(!vis[v])
				{
					vis[v]=true;
					q.push(v);
					neg[v]++;
					if(neg[v]>n)
					return -1;
				}
				
			}
		}
	}
	return dis[n];
}

int main()
{
	scanf("%d%d",&n,&m);
	int a,b,c;
	for(int i=1; i<=m; i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		edge h;
		//h.from=a;
		h.to=b;
		h.w=c;
		e[a].push_back(h);
		//h.from=b;
		h.to=a;
		e[b].push_back(h);
	}
    cout<<spfa(1); 
	return 0;
}

好辣~撒花撒花~~~~~（真的不点个赞再走嘛）~~