迪杰斯特拉算法（Dijkstra）

模板一：

时间复杂度O（n²）

 int dijkstra(int s,int m)  //s为起点,m为终点
 {
     memset(dist,,sizeof(dist));   //初始化，dist数组用来储存s到各个点的距离
     memset(v,,sizeof(v));         //初始化v数组，是否已标记
     for(int i=;i<=n;++i)          //++i返回的是引用，稍微快一点
     {
         dist[i]=e[s][i];           //初始化，e[s][i]数组表示是点s到点i的权值，数组e用来存有向图或无向图的权值，用INF初始化
     }
     for(int i=;i<=n;++i)
     {
         k=INF,u=;
         for(int j=;j<=n;++j)      //找出当前dist最小的点
         {
             if(!v[j]&&dist[j]<k)
             {
                 k=dist[j];
                 u=j;
             }
         }
         v[u]=;                    //标记
         for(int j=;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 = ;
 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 = ; 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 - );
     }

     void dijkstra(int s, int kk)          //s为起点 kk为终点
     {
         priority_queue<HeapNode> Q;
         for (int i = ; i < n; ++i)
             d[i] = INF;
         d[s] = ;
         memset(done, , sizeof(done));
         Q.push(HeapNode( , s ));
         while (!Q.empty())
         {
             HeapNode x = Q.top();
             Q.pop();
             int u = x.u;
             if (u == kk)                  //到终点就退出
             {
                 printf("%d\n", x.d);
                 break;
             }
             if (done[u])
             {
                 continue;
             }
             done[u] = true;
             for (int i = ; 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 = ;
 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 = ; 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 - );
     }

     void dijkstra(int s, int kk)          //s为起点 kk为终点
     {
         priority_queue<HeapNode> Q;
         for (int i = ; i < n; ++i)
             d[i] = INF;
         d[s] = ;
         memset(done, , sizeof(done));
         Q.push(HeapNode( , s ));
         while (!Q.empty())
         {
             HeapNode x = Q.top();
             Q.pop();
             int u = x.u;
             if (u == kk)
             {
                 printf("%d\n", x.d);
                 break;
             }
             if (done[u])
             {
                 continue;
             }
             done[u] = true;
             for (int i = ; 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 ==  && m == )
             break;
         while (m--)
         {
             cin >> x >> y >> k;
             d.addEdge(x - , y - , k);
             d.addEdge(y - , x - , k);
         }
         d.dijkstra(, n - );
     }
     return ;
 }

持续更新……