迪杰斯特拉算法（Dijkstra）

模板一：

时间复杂度O（n²）

int dijkstra(int s,int m)  //s为起点,m为终点
{
    memset(dist,0,sizeof(dist));   //初始化，dist数组用来储存s到各个点的距离
    memset(v,0,sizeof(v));         //初始化v数组，是否已标记
    for(int i=1;i<=n;++i)          //++i返回的是引用，稍微快一点
    {
        dist[i]=e[s][i];           //初始化，e[s][i]数组表示是点s到点i的权值，数组e用来存有向图或无向图的权值，用INF初始化
    }
    for(int i=1;i<=n;++i)
    {
        k=INF,u=0;
        for(int j=1;j<=n;++j)      //找出当前dist最小的点
        {
            if(!v[j]&&dist[j]<k)
            {
                k=dist[j];
                u=j;
            }
        }
        v[u]=1;                    //标记
        for(int j=1;j<=n;++j)      //更新与点u相连的点的权值和
        {
            if(!v[j]&&e[u][j]<INF&&dist[u]+e[u][j]<dist[j])    //比较从点s到点u载到点j的权值和点s直接到点j的权值
            {
                dist[j]=dist[u]+e[u][j];
            }
        }
    }
    return dist[m];  
}

模板二：

时间复杂度 O（mlogn）m为边数，n为顶点数。

对于稀疏图的效果显著，对稠密图慎用。

const int INF = 0x3f3f3f3f;
const int maxn = 150;
struct Edge
{
    int from, to, dist;
    Edge(int u, int v, int d) :from(u), to(v), dist(d) {}
};
struct HeapNode
{
    int d, u;
    HeapNode(int D,int U):d(D),u(U){}
    bool operator < (const HeapNode& rhs) const {
        return d > rhs.d;
    }
};
struct Dijkstra
{
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];    //maxn要大于顶点数
    bool done[maxn];
    int d[maxn];
    int p[maxn];

    void init(int n)
    {
        this->n = n;
        for (int i = 0; i < n; ++i)
            G[i].clear();
        edges.clear();
    }

    void addEdge(int from, int to, int dist)
    {
        edges.push_back(Edge(from, to, dist));
        m = edges.size();
        G[from].push_back(m - 1);
    }

    void dijkstra(int s, int kk)          //s为起点 kk为终点
    {
        priority_queue<HeapNode> Q;
        for (int i = 0; i < n; ++i)
            d[i] = INF;
        d[s] = 0;
        memset(done, 0, sizeof(done));
        Q.push(HeapNode( 0, s ));
        while (!Q.empty())
        {
            HeapNode x = Q.top();
            Q.pop();
            int u = x.u;
            if (u == kk)                  //到终点就退出
            {
                printf("%d
", x.d);
                break;
            }
            if (done[u])
            {
                continue;
            }
            done[u] = true;
            for (int i = 0; i < G[u].size(); ++i)
            {
                Edge& e = edges[G[u][i]];
                if (d[u] + e.dist < d[e.to])
                {
                    d[e.to] = d[u] + e.dist;
                    p[e.to] = G[u][i];
                    Q.push(HeapNode(d[e.to], e.to ));
                }
            }
        }
    }

};

放一道模板题

http://acm.hdu.edu.cn/showproblem.php?pid=2544

AC代码

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 150;
struct Edge
{
    int from, to, dist;
    Edge(int u, int v, int d) :from(u), to(v), dist(d) {}
};
struct HeapNode
{
    int d, u;
    HeapNode(int D,int U):d(D),u(U){}
    bool operator < (const HeapNode& rhs) const {
        return d > rhs.d;
    }
};
struct Dijkstra
{
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];    //maxn要大于顶点数
    bool done[maxn];
    int d[maxn];
    int p[maxn];

    void init(int n)
    {
        this->n = n;
        for (int i = 0; i < n; ++i)
            G[i].clear();
        edges.clear();
    }

    void addEdge(int from, int to, int dist)
    {
        edges.push_back(Edge(from, to, dist));
        m = edges.size();
        G[from].push_back(m - 1);
    }

    void dijkstra(int s, int kk)          //s为起点 kk为终点
    {
        priority_queue<HeapNode> Q;
        for (int i = 0; i < n; ++i)
            d[i] = INF;
        d[s] = 0;
        memset(done, 0, sizeof(done));
        Q.push(HeapNode( 0, s ));
        while (!Q.empty())
        {
            HeapNode x = Q.top();
            Q.pop();
            int u = x.u;
            if (u == kk)
            {
                printf("%d
", x.d);
                break;
            }
            if (done[u])
            {
                continue;
            }
            done[u] = true;
            for (int i = 0; i < G[u].size(); ++i)
            {
                Edge& e = edges[G[u][i]];
                if (d[u] + e.dist < d[e.to])
                {
                    d[e.to] = d[u] + e.dist;
                    p[e.to] = G[u][i];
                    Q.push(HeapNode(d[e.to], e.to ));
                }
            }
        }
    }

};
int n, m, x, y, k;
Dijkstra d;
int main()
{
    while (cin>>n>>m)
    {
        d.init(n);
        if (n == 0 && m == 0)
            break;
        while (m--)
        {
            cin >> x >> y >> k;
            d.addEdge(x - 1, y - 1, k);
            d.addEdge(y - 1, x - 1, k);
        }
        d.dijkstra(0, n - 1);
    }
    return 0;
}

 持续更新……