图论算法->最短路

求最短路算法，有Floyd，dijkstra，Bellmanford，spfa等诸多高级算法。优化方法也是层出不穷。

我们不妨分析一下各算法的使用特点（可能不准确

1.Floyd算法 复杂度O（n³）可计算任意两点间最短路径 可处理负边权情况

2.Dijkstra算法 复杂度O（n²）只能计算单源最短路径 不可处理负边权情况（多源可再加一重循环）

3.Bellman-Ford算法 复杂度O（边数*点数） 计算单源最短路径 能处理负边权情况但无法处理存在负权回路情况

4.spfa算法 复杂度O（边数*玄学常数） 单源最短路径 可处理负边权情况

另外，这种算法在稀疏图上是好，而在稠密图有不乐观的一面。

另外，还有输出最短路径方案，记录前驱。参见玛丽卡一题。

我们不妨先来讨论两种图的存储方式

第一种是邻接矩阵，开了一个二维数组。如f[i][j]记录了i到j有一条边，且权值为f[i][j]

第二种是邻接表。用一个结构体+head数组记录这条边的信息

 struct node{
     int val,to,next;
     //node存储第i条边的信息，val为第i条边的权值，to为第i条边的终
     //点,next为同一起点的下一条边的第几条边数
 }edge[];
 int head[];//head[x]表示以x节点为起点的第一条边的边数
 int tot;//tot记录已经读到第几条边 

 /*建边*/
 void build(int x,int y,int z)
 {
     tot++;
     edge[tot].val=z;
     edge[tot].to=y;
     edge[tot].next=head[x];//这里好像链表一样
     head[x]=tot;
 } 

我们可以用这张图帮助理解。

、

长得有点像链表 是不是耶...

一、最暴力的弗洛伊德Floyd

 //floyd
 #include<bits/stdc++.h>
 using namespace std;
 const int inf=0x7f7f7f7f;
 int n,m;
 int w[][];
 int dis[][];
 int main()
 {
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=n;j++)
          dis[i][j]=inf;
     }
     for(int i=;i<=m;i++)
     {
         int u,v;
         scanf("%d%d%d",&u,&v,&w[u][v]);
         dis[u][v]=w[u][v];
     }
     //floyd
     for(int k=;k<=n;k++)
      for(int i=;i<=n;i++)
       for(int j=;j<=n;j++)
        if(dis[i][j]>dis)
         dis[i][j]=dis[i][k]+dis[k][j];
     //输出 dis[i][j]为i到j的最短路
     return ;
 }

二、Dijkstra+堆优化+邻接表

 // Dijkstra
 #include<bits/stdc++.h>
 using namespace std;
 int n,m,s;
 const int inf=0x3f3f3f3f;
 int tot;
 bool visit[];
 int head[],dis[];
 struct node{
     int val,to,next;
 }edge[];
 priority_queue<  pair<int,int>  > q;
 //大根堆 pair第一维为dis相反数以达到小根堆效果，第二维为节点编号
 void add(int x,int y,int z)
 {
     tot++;
     edge[tot].to=y;
     edge[tot].val=z;
     edge[tot].next=head[x];
     head[x]=tot;
 }
 void dijkstra()
 {
     for(int i=;i<=n;i++)
      dis[i]=inf;
     dis[s]=;//这里默认把1作为起点，求多源时可另加调整
     q.push(make_pair(,s));
     while(!q.empty())
     {
         int x=q.top().second;
         q.pop();//pop会把二元组中两个元素一并弹出
         if(visit[x]) continue;
         visit[x]=;
         for(int i=head[x];i;i=edge[i].next)
         {
             int y=edge[i].to;
             int z=edge[i].val;
             if(dis[y]>dis[x]+z&&visit[y]==)
             {
                 dis[y]=dis[x]+z;
                 q.push(make_pair(-dis[y],y));
             }
          }
     }
 }
 int main()
 {
     scanf("%d%d%d",&n,&m,&s);
     for(int i=;i<=m;i++)
     {
         int x=,y=,z=;
         scanf("%d%d%d",&x,&y,&z);
         add(x,y,z);
     }
     dijkstra();
     for(int i=;i<=n;i++)
      printf("%d ",dis[i]);
     return ;
 }

三、SPFA算法（大力拒绝bellmanford

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 using namespace std;
 const int inf=;
 int n,m,s;
 int num;
 int pre[];
 struct node{
     int to,val,next;
 }edge[];
 int dis[];
 bool visit[];
 void add(int x,int y,int z)
 {
     num++;
     edge[num].val=z;
     edge[num].to=y;
     edge[num].next=pre[x];
     pre[x]=num;
 }
 void spfa()
 {
     queue<int>q;
     for(int i=;i<=n;i++)
     {
         dis[i]=inf;
     }
     q.push(s);
     dis[s]=;
     visit[s]=;
     while(!q.empty())
     {
         int u=q.front();
         q.pop();
         visit[u]=;
         for(int i=pre[u];i>;i=edge[i].next)
         {
             int v=edge[i].to;
             if(dis[v]>dis[u]+edge[i].val)
             {
                 dis[v]=dis[u]+edge[i].val;
                 if(visit[v]==)
                 {
                     visit[v]=;
                     q.push(v);
                 }
             }

         }
     }
 }
 int main()
 {
     scanf("%d%d%d",&n,&m,&s);
     for(int i=;i<=m;i++)
     {
         int x=,y=,z=;
         scanf("%d%d%d",&x,&y,&z);
         add(x,y,z);
     }
     spfa();
     for(int i=;i<=n;i++)
     {
         if(s==i) cout<<""<<" ";
         else cout<<dis[i]<<" ";
     }

     return ;
 }

最后我们再来讨论一下防止溢出的问题。

建邻接表的时候，edge开到边数，无向图开二倍边；

head dis visit均存到点数即可。