最短路算法模板合集（Dijkstar，Dijkstar（优先队列优化）， 多源最短路Floyd）

再开始前我们先普及一下简单的图论知识

图的保存：

1.邻接矩阵。 G[maxn][maxn];

2.邻接表

邻接表我们有两种方式

（1）vector< Node > G[maxn];

这个是之前就定义了图的大小了，再下面使用的时候就不用对图的大小进行申请了， 但是因为是直接申请了大小

要对图进行初始化，因此可能在某些题目中这样使用的话会超时

（2）vector< vector<Node> > G;

这个是未定义大小，但是在使用之前要对其的大小内存进行申请。

G.resize(n+1);

Dijkstra's Algorithm

算法思想：

1.从源点出发源点所有能一步到达的点的距离更新，然后从除源点外的所有点之中找出距离源点最近的点。

2.然后更新我们之前所找到的最短路点所有连接的点，但是要求这个点未曾被当做最短点处理过

3.重复上述操作n次。

单源最短路 我们还可以对他进行优先队列优化下面是以HDU2544为模板的用Dijkstra's Algorithm

邻接矩阵版，不用优先队列优化

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define INF 0xfffffff
#define maxn 1002

int G[maxn][maxn];//保存图
int dist[maxn];//表示从起点到第i点的距离
bool vis[maxn];//判断这个点是否被参观过
int m, n;//边数 m   顶点数 n

void Init()
{
    for(int i=0; i<=n; i++)
    {
        vis[i] = false;
        dist[i] = INF;
        for(int j=0; j<=i; j++)
            G[i][j] = G[j][i] =  INF;
    }
}
int Dij(int Star,int End)//起点 --- 终点
{
    dist[Star] = 0;
    for(int i=1; i<=n; i++)
    {
        int index = 0, Min = INF;
        for(int j=1; j<=n; j++)
        {
            if( !vis[j] && Min > dist[j] )//找出没有被参观过，并且距离起点最近的点
                Min = dist[j], index = j;
        }

        vis[index] = true;

        for(int j=1; j<=n; j++)//更新所有未曾到达的点距离，使之成为最近的点
        {
            if( !vis[j] && dist[j] >  dist[index] + G[index][j] )
                dist[j] = dist[index] + G[index][j];
        }
    }

    return dist[End];

}

int main()
{
    while(cin >> n >> m, m + n)
    {
        Init();

        int a, b , c;

        for(int i=0; i<m; i++)
        {
            cin >> a >> b >> c;
            G[a][b] = min(G[a][b], c);
            G[b][a] = G[a][b];
        }

        int ans = Dij(1,n);

        cout << ans << endl;
    }
    return 0;
}

　　接下来是邻接表版，用到了优先队列优化

 #include <iostream>
 #include <cmath>
 #include <cstring>
 #include <cstdlib>
 #include <cstdio>
 #include <algorithm>
 #include <vector>
 #include <queue>
 using namespace std;
 #define INF 0xfffffff
 #define maxn 1002

 struct Node
 {
     int e;
     int w;
     friend bool operator < (Node A, Node B)
     {
         return  A.w > B.w;
     }
 };

 bool vis[maxn];

 int m, n;
 vector< vector<Node> > G;

 int Dij(int Star,int End)
 {
     Node P, Pn;
     P.e = Star;
     P.w = ;

     priority_queue<Node> Q;

     Q.push(P);

     while( !Q.empty() )
     {
         P = Q.top();
         Q.pop();

         if( vis[P.e] )
             continue;

         vis[P.e] = true;

         if( P.e == End )
             return P.w;

         int len = G[P.e].size();

         for(int i=; i< len; i++)
         {
             Pn.e = G[P.e][i].e;
             Pn.w = G[P.e][i].w + P.w;

             if( !vis[Pn.e] )
                 Q.push(Pn);
         }
     }
     return -;
 }

 int main()
 {
     Node P;
     while(cin >> n >> m, m+n)
     {
         G.clear();
         G.resize(n+);

         memset(vis,false,sizeof(vis));

         for(int i=; i<m; i++)
         {
             int a, b, c;
             cin >> a >> b >> c;
             P.e = b;
             P.w = c;
             G[a].push_back(P);
             P.e = a;
             G[b].push_back(P);
         }

         int ans = Dij(,n);

         cout << ans << endl;
     }
     return ;
 }

下面是Floyd算法

Floyd是求多源最短路， 即可以求出所有点对之间的最短路

这个算法就只要注意两点就行了，初始化的时候 G[i][i] = 0, 其他的初始化为INF

#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define INF 0xfffffff
#define maxn 1002

int G[maxn][maxn];
int dist[maxn][maxn];
int m, n;

void Floyd()
{
    for(int k=; k<=n; k++)
    {
        for(int i=; i<=n; i++)
        {
            for(int j=; j<=n; j++)
            {
                G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
            }
        }
    }
}
void Init()
{
    for(int i=; i<=n; i++)
    {
        G[i][i] = ;
        for(int j=; j<i; j++)
            G[i][j] = G[j][i] = INF;
    }
}

int main()
{
    while(cin >> n >> m, m+n)
    {
        Init();
        for(int i=; i<m; i++)
        {
            int a, b, c;
            cin >> a >> b >> c;
            G[a][b] = min(G[a][b],c);
            G[b][a] = G[a][b];
        }

        Floyd();

        cout << G[][n] << endl;
    }
    return ;
}