最短路算法模板合集（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 = 0;

    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=0; 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 -1;
}

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

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

        for(int i=0; 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(1,n);

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

下面是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=1; k<=n; k++)
    {
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
            }
        }
    }
}
void Init()
{
    for(int i=0; i<=n; i++)
    {
        G[i][i] = 0;
        for(int j=0; j<i; j++)
            G[i][j] = G[j][i] = INF;
    }
}

int main()
{
    while(cin >> n >> m, m+n)
    {
        Init();
        for(int i=0; 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[1][n] << endl;
    }
    return 0;
}