每日总结 12.30

接上昨天学习的两种最短路径算法

今天学习第三种最短路径算法“Bellman-Ford”及其优化

以及顺带学习的邻接表储存

注：该文章为本人经过对《啊哈！算法》的阅读后归纳总结

Bellman-Ford

相比于Floyd算法它时间复杂度于空间复杂度更低

相比于Dijkstra算法它可以解决负权（即一顶点到另外一个顶点的距离为负数）问题

很明显Bellman-Ford解决负权问题即使面对优秀简便的Floyd算法也稍微占上风

个人认为Bellman-Ford算法更适合稀疏图（顶点与边关系为1：1）而其他两种更适合稠密图（顶点与边关系为n:n平方）

其核心代码为

for(k=1;k<=n-1;k++)//核心语句
{
	for(i=1;i<=m;i++)
	{
		if(dis[v[i]]>dis[u[i]]+w[i])
		{
			dis[v[i]]=dis[u[i]]+w[i];
		}
	}
}

核心思想即在总共n-1轮中，从一个顶点到另一个顶点由只经过一条边到经过n-1条边进行不断筛选选出到达各个顶点的最短路径，而整个逻辑最多执行n-1轮，所以该算法可以简单优化，即加入一个数组在每一次更新中cheak是否dis数组有更新，即没有更新即没有更优方案（可以仔细想一想该算法的核心）

优化后的代码如下

for(k=1;k<=n-1;k++)//核心语句
	{
		for(i=1;i<=n;i++)
		{
			bak[i]=dis[i];
		}
		for(i=1;i<=m;i++)
		{
			if(dis[v[i]]>dis[u[i]]+w[i])
			{
				dis[v[i]]=dis[u[i]]+w[i];
			}
		}
		//小优化，也许不需要完整循环n-1次
		check=0;
		for(i=1;i<=n;i++)
		{
			if(bak[i]!=dis[i])
			{
				check=1;
				break;
			}
		}
    }

甚至Bellman-Ford算法可以通过他的特性判断一个图是否含有负权回路（自行百度）

即在n-1轮的筛选后仍然存在

 if(dis[v[i]]>dis[u[i]]+w[i])
     {
         dis[v[i]]=dis[u[i]]+w[i];
     }

这种情况就代表该图有负权回路

简简单单加入一个flag看看是否有再次执行该循环即可

代码

flag=0;
	  for(i=1;i<=m;i++)
	  if(dis[v[i]]>dis[u[i]]+w[i])
	  flag=1;
	  if(flag==1)
	  printf("此图含有负权回路");

Bellman-Ford基础思想已经解决

接下来是对Bellman-Ford算法进行用队列优化一下下喽

这边顺便学习了邻接表（队列优化需要用）

邻接表

简单来说是用数组以类似链表的方式储存数据

用两个数组first与next来实现

first数组来储存顶点的出现编号即出现顺序，next[i]即储存“序号为i的边”他的“下一条边”的序号

很明显有点绕，这里本蒟蒻自己也理解一半一半，还是看看代码吧

#include<stdio.h>
int main()
{
	int n,m,i,k;
	int u[6],v[6],w[6];
	int first[5],next[5];
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++)
	{
		first[i]=-1;
	}
	for(i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
		next[i]=first[u[i]];
		first[u[i]]=i;
	}
	for(i=1;i<=n;i++)
	{
		k=first[i];
		while(k!=-1)
		{
			printf("%d %d %d\n",u[k],v[k],w[k]);
			k=next[k];
		}
	}
	getchar();
	getchar();
	return 0;
}

很明显核心即为

for(i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
		next[i]=first[u[i]];
		first[u[i]]=i;
	}
	for(i=1;i<=n;i++)
	{
		k=first[i];
		while(k!=-1)
		{
			printf("%d %d %d\n",u[k],v[k],w[k]);
			k=next[k];
		}
	}

ps：这里不多解释能力有限，应该画个图就能出来

Bellman-Ford队列优化

值得注意的是 用队列的方法达成该算法，代表队列中的值不能同时出现相同的顶点

队列优化就是结合了Bellman-Ford的基础和队列表达还有邻接表储存

这里直接上代码

#include<stdio.h>
int main()
{
	int n,m,i,k;
	int u[8],v[8],w[8];
	int first[6],next[8];
	int dis[6]={0},book[6]={0};
	int que[101]={0},head=1,tail=1;
	int inf=99999999;
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++)
	{
		dis[i]=inf;
	}
	dis[1]=0;
	//邻接表储存
	for(i=1;i<=n;i++)
	{
		book[i]=0;
		first[i]=-1;
	}
	for(i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
		next[i]=first[u[i]];
		first[u[i]]=i;
	}
	que[tail]=1;
	tail++;
	book[1]=1;
	while(head<tail)
	{
		k=first[que[head]];
		while(k!=-1)
		{
			if(dis[v[k]]>dis[u[k]]+w[k])
			{
				dis[v[k]]=dis[u[k]]+w[k];
				if(book[v[k]]==0)
				{
					que[tail]=v[k];
					tail++;
					book[v[k]]=1;
				}
			}
			k=next[k];
		}
		book[que[head]]=0;
		head++;
	}
	for(i=1;i<=n;i++)
	{
		printf("%d ",dis[i]);
	}
	getchar();
	getchar();
	return 0;
}

把这些与昨天的两种最短路径算法列出一张表格

	Floyd	Dijkstra	Bellman-Ford	队列优化的Bellman-Ford
空间复杂度	O（N^2）	O(M)	O(M)	O(M)
时间复杂度	O(N^3)	O((M+N)logN)	O(NM)	最坏O(NM)
适用情况	稠密图	稠密图	稀疏图	稀疏图
负权	YES	NO	YES	YES

各个算法各有所长吧，Dijkstra很明显还有优化，这里蒟蒻我也还没有学，根据实际需求和每一种算法的特性，选择适合的算法才是最关键的。

2022年的最后一篇每日总结（明天放假）awa

2023也要加油哦各位！！！