最短路的四种算法

求最短路一般有四种方法：

1.floyd       dp思想dis[i][j]=min(dis[i][j]+dis[i][k]+dis[k][j])                                 时间复杂度O(N^3)

2.dijkstra    邻接矩阵。                                                                                  时间复杂度O(N^2)

3.dijkstra    邻接表+优先级队列优化。                                                           时间复杂度O(M*lgN)

4.bellman-Ford 用于解决含有负权值得最小路问题                                        时间复杂度O(M*N)    
5.SPFA是bellman-ford的改进算法(队列实现），效率也更高                         复杂度为：O(kE)E为边数，k一般为2或3
1.floyd算法：可以求任意两点之间的最短距离。解决传递背包和最小环问题~，不能解决负权回路。

for(int k=0;k<a;k++)//经过k点{    for(int i=0;i<a;i++)//起点    {        for(int j=0;j<a;j++)//终点        {            If(w[i][j]>w[i][k]+w[k][i];            w[i][j]=w[i][k]+w[k][i];        }     }}//如果经过k点距离变短，那么w[i][j]不变，否则更新。
可以理解为对于1点而言，经过或者不经过1点求个最短，然后在1点的基础上对于2点，求个最短路...。
2.dijkstra    邻接矩阵：没办法解决负边权的最短路径。

采用的是邻接矩阵来存的，第一点浪费的空间比较多，第二点我们知道算法的时间复杂度在O（n*n）

（1）确定数组—邻接矩阵（赋值0或者inf）

（2）输入数组-邻接矩阵

（3）确定距离dis数组//用1号顶点到其余各边的距离初始化；

（4）判断某一点是否当过起始点bool数组

（5）最关键！！循环n-1次，

          先找一行中的最小值确保该行没有遍历过。

         找到之后通过最小值所在行更新dis数组。

      //初始化    for(i=1;i<=n;i++)        for(j=1;j<=n;j++)            if(i==j) e[i][j]=0;                else e[i][j]=inf;                  //读入边和权值    for(i=1;i<=m;i++)    {        scanf("%d %d %d",&t1,&t2,&t3);        e[t1][t2]=t3;    }    //初始化dis数组，这里是1号顶点到其余各个顶点的初始路程    for(i=1;i<=n;i++)        dis[i]=e[1][i];    //book数组初始化    for(i=1;i<=n;i++)        book[i]=0;    book[1]=1;        //Dijkstra算法核心语句    for(i=1;i<=n-1;i++)//循环n-1次，每次都找到一行中的最小值，也就是对应的最小的点。    {        min=inf;        for(j=1;j<=n;j++)//找离某一点最近的点        {            if(book[j]==0 && dis[j]<min)            {                min=dis[j];                u=j;            }        }        book[u]=1;        for(v=1;v<=n;v++)//找到最小点的最小距离的点，有的话就更新。        {            if(e[u][v]<inf)            {                if(dis[v]>dis[u]+e[u][v])                     dis[v]=dis[u]+e[u][v];            }        }    }

3.dijkstra    邻接表+优先级队列优化。

重载一个比较函数

struct node{      int x,d;      node(){}      node(int a,int b){x=a;d=b;}      bool operator < (const node & a) const      {          if(d==a.d) return x<a.x;          else return d > a.d;      }  };  //定义一个结构体，重载比较函数
vector<node> eg[Ni];  
int dis[Ni],n;  
void Dijkstra(int s)  {      int i;      for(i=0;i<=n;i++) dis[i]=INF;      dis[s]=0;      //用优先队列优化      priority_queue<node> q;      q.push(node(s,dis[s]));      while(!q.empty())      {          node x=q.top();q.pop();          for(i=0;i<eg[x.x].size();i++)          {              node y=eg[x.x][i];              if(dis[y.x]>x.d+y.d)              {                  dis[y.x]=x.d+y.d;                  q.push(node(y.x,dis[y.x]));              }          }      }  }  

4.bellman-Ford
一：初始化所有点。每一个点保存一个值，表示从原点到达这个点的距离，将原点的值设为0，其它的点的值设为无穷大（表示不可达）。二：进行循环，循环下标为从1到n－1（n等于图中点的个数）。在循环内部，遍历所有的边，进行松弛计算。三：遍历途中所有的边（edge（u，v）），判断是否存在这样情况：         d（v） > d (u) + w(u,v)        则返回false，表示途中存在从源点可达的权为负的回路。

struct node{    int from,to,w;};node edge[100];bool Ford(){    for(i = 1; i <= n; i ++)        dis[i] = inf;    dis[1] = 0;    for(i = 1; i <= n; i ++)    {        flag = false;        for(j = 1; j <= m; j ++)        {            x = edge[i].from ;            y = edge[i].to ;            z = edge[i].w ;            if(dis[y] > dis[x] + z)            {                dis[y] = dis[x] + z;                flag = true;            }        }        if(!flag)            break;        //如果更新到n遍，还能够继续更新dis数组，说明存在负权环         if(flag&&i == n)             return false;//返回false表示这个图存在负权环     }    return true;//返回true表示求最短路成功 }

5.SPFA