Bellman-Ford算法,Bellman-Ford队列优化（SPFA）

Bellman-Ford算法能解决负权的问题但不能解决负权回路的问题

但是Bellman-Ford可以判断是否可以存在负环，同样的SPFA也可以判断负环的存在。

Bellman-Ford主要是将每个点每一次都松弛

while(b)
{
    b=false;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(d[j]+map[j][i]<d[i])
            {
                d[i]=d[j]+map[j][i];
                b=true;
            }
        }
    }
}

但是如果有负权回路的话每次更新的时候边都会变小因此bellman-ford算法无法求解具有负权回路的问题，但是bellman-ford可以判断是否存在负权回路。

spfa算法是对bellman-ford算法进行的队列优化

queue<int>q;
int spfa(int s,int t)
{
	memset(vis,0,sizeof(vis));
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0;
	vis[s]=1;
	q.push(s);
	while(!q.empty())
	{
		int x=q.front();
		q.pop();
		vis[x]=0;
		for(int i=head[x];i!=-1;i=edge[i].next)
		{
			int y=edge[i].t;
			if(dis[y]>dis[x]+edge[i].l)
			{
				dis[y]=dis[x]+edge[i].l;
				if(!vis[y])
				{
					q.push(y);
					vis[y]=1;
				}
			}
		}
	}
	if(dis[t]==0x3f3f3f3f) return -1;
	else
	{
		return dis[t];
	}	
}

就是对前面更新过的点进行入队处理

然后让入队的点在下面去更新后面的点，如果一个点已经在队列中则不需要进行二次入队

floyd算法

floyd算法使用的是动态规划的思想

主要代码为

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)&&(k!=i))
{
    if((i!=j)&&(j!=k)&&(k!=i))
    {
        if(f[i][k]+f[k][j]<=f[i][j])
        f[i][j]=f[i][k]+f[k][j];
    }
}

k放到外层可以枚举出通过所有点松弛的情况