最短路算法-Floyd，dijkstra，bellman-Ford，SPFA

一 Floyd算法

  五行算法，遍历遍历遍历，用于所有点对的最短路径，若数据范围小可以使用，时间复杂度 O(N^3)，空间复杂度O(N^2);

代码：

for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(e[i][j]>e[i][k]+e[k][j])  //e记录始点到终点的距离
                e[i][j]=e[i][k]+e[k][j];

二，dijkstra算法——单源最短路

单源最短路，就是指某个定点到其余各个顶点的最短路 。

其实这种方法是一种基于贪心策略的算法。

1，每次扩展一个路程，选取最短路程的点,。（此时这个点的路程是最短路，因为其他的路程都比这条路长，从其他地方绕显然路径会更长，因此在之后的更新中，这个点的值不会改变。）

2，在用这个已经确定为最短路点对其他连通的边进行松弛。

3，重复以上两点，直到所有边都被确定。

提醒：这是一个不允许存在负边权的算法，因为扩展到负边权的时候会产生最短路，破坏了已经更新的点不改变的性质 

但是如果不优化的话，它的复杂度是O（n^2），比较低效，一般我们采用邻接表+优先队列的优化。

代码： 

 

//没有任何优化的dijkstra算法模板
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int k[n+1][n+1]; //记录路径；
int dis[n+1],biao[n+1],first[n+1],next[m+1];
int inf=0x3f3f3f3f;
void init(int n)
{
    for(int i=1; i<=n; i++)
    {
        biao[i]=0;
        dis[i]=k[1][i];
        first[i]=-1;
    }
    biao[1]=1; //假设这里求1到其余点的最短路
}
void dijstra(int n)
{
    int u;
    for(int i=1;i<=n-1;i++)
    {
        int minn=inf;
        for(int j=1;j<=n;j++)  //找到最小路径，保存这个点
        {
            if(biao[j]==0&&dis[j]<minn)
            {
                minn=dis[j];
                u=j;
            }
        }
        biao[u]=1;
        for(int j=1;j<=n;j++)  //用保存的那个点对其他连接点松弛
        {
            if(k[u][j]!=inf)
            {
                if(dis[j]>dis[u]+k[u][j])
                    dis[j]=dis[u]+k[u][j];
            }
        }
    }
    return ;
}
int main()
{
    int n,m,a,b,c;
    scanf("%d %d",&n,&m);
    memset(k,inf,sizeof(k));
    for(int i=1;i<=n;i++)
        k[i][i]=0;
    for(int i=1; i<=m; i++)
    {
        scanf("%d %d %d",&a,&b,&c);
        k[a][b]=c;   //存边
        k[b][a]=c;
    }
     init(n);//送去初始化；
    dijstra(n);
    for(int i=1;i<=n;i++)
        printf("%d\n",dis[i]);

}

三 bellman算法——解决负边权

核心代码只有四行

for(int k=1; k<=n-1; k++)
    for(int i=1; i<=m; i++)  //m为边的个数
        if(dis[v[i]]>dis[u[i]]+w[i])
            dis[v[i]]=dis[u[i]]+w[i];