HDU2544 最短路dij

纯最短路。

 ///HDU 2544堆优化的最短路
 #include <cstdio>
 #include <iostream>
 #include <sstream>
 #include <cmath>
 #include <cstring>
 #include <cstdlib>
 #include <string>
 #include <vector>
 #include <map>
 #include <set>
 #include <queue>
 #include <stack>
 #include <algorithm>
 using namespace std;
 #define ll long long
 #define _cle(m, a) memset(m, a, sizeof(m))
 #define repu(i, a, b) for(int i = a; i < b; i++)
 #define repd(i, a, b) for(int i = b; i >= a; i--)
 #define sfi(n) scanf("%d", &n)
 #define pfi(n) printf("%d\n", n)
 const int MAXN = ;
 const int MAXM = ;
 const int INF=0x3f3f3f3f;
 struct Node
 {
     int to,next,w;
 } edge[MAXM];
 struct HeapNode
 {
     int d, u;
     bool operator < (const HeapNode& rhs) const
     {
         return d > rhs.d;
     }
 };
 struct Dijkstra
 {
     int head[MAXN],d[MAXN];
     bool done[MAXN];
     int cnt;
     void init()
     {
         memset(head,-,sizeof(head));
         cnt = ;
     }
     void AddEdge(int u, int v, int w)
     {
         edge[cnt].to=v,edge[cnt].next=head[u];
         edge[cnt].w=w,head[u]=cnt++;
         edge[cnt].to=u,edge[cnt].next=head[v];
         edge[cnt].w=w,head[v]=cnt++;
     }
     void dijkstra(int s,int n)
     {
         priority_queue<HeapNode> Q;
         for(int i = s; 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(done[u]) continue;
             done[u] = true;
             for(int i=head[u]; i!=-; i=edge[i].next)
             {
                 int v=edge[i].to;
                 if(d[v] > d[u] + edge[i].w)
                 {
                     d[v] = d[u] + edge[i].w;
                     Q.push((HeapNode)
                     {
                         d[v], v
                     });
                 }
             }
         }
     }
 } dij;
 int main()
 {
     int n,m,a,b,c;
     while(scanf("%d%d",&n,&m),n+m)
     {
         dij.init();
         repu(i,,m)
         {
             scanf("%d%d%d",&a,&b,&c);
             dij.AddEdge(a,b,c);
             dij.AddEdge(b,a,c);
         }
         dij.dijkstra(,n);
         printf("%d\n",dij.d[n]);
     }
     return ;
 }

堆优化的Dij

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <algorithm>
 #include <cstring>
 #include <cmath>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <set>
 #include <map>
 using namespace std;
 const int maxn=;
 const int INF=0x3f3f3f3f;
 struct Edge
 {
     int u, v, d;
     Edge(int u, int v, int d):u(u), v(v), d(d) {}
 };
 struct qnode
 {
     int u,d;
     qnode(int u, int d):u(u), d(d) {}
     bool operator < (const qnode a)const
     {
         return d>a.d;
     }
 };
 struct Dijkstra
 {
     int n;
     vector<int> G[maxn];
     vector<Edge> edge;
     int d[maxn];
     bool vis[maxn];
     void init(int n)
     {
         this->n = n;
         for(int i=; i<=n; i++)
         {
             G[i].clear();
             vis[i]=;
             d[i]=INF;
         }
         edge.clear();
     }
     void AddEdge(int u, int v, int d)
     {
         G[u].push_back(edge.size());
         edge.push_back(Edge(u, v, d));
     }
     void dijkstra(int s)
     {
         priority_queue<qnode> q;
         d[s]=;
         q.push(qnode(s, ));
         while(!q.empty())
         {
             qnode x=q.top();
             q.pop();
             if(vis[x.u])
                 continue ;
             vis[x.u]=true;
             for(int i=; i<G[x.u].size(); i++)
             {
                 Edge& e=edge[G[x.u][i]];
                 if(d[e.v]>d[x.u]+e.d)
                 {
                     d[e.v]=d[x.u]+e.d;
                     q.push(qnode(e.v, d[e.v]));
                 }
             }
         }
     }
 } dij;

 int main()
 {
     int n, m;
     while(scanf("%d%d", &n, &m),n+m)
     {
         dij.init(n);
         while(m--)
         {
             int u, v, w;
             scanf("%d%d%d", &u, &v, &w);
             dij.AddEdge(u, v, w);
             dij.AddEdge(v, u, w);
         }
         dij.dijkstra();
         printf("%d\n",dij.d[n]);
     }
     return ;
 }

邻接矩阵Dij

本来以为这两个时间效率相差会很大，看来只在稠密图中奏效。

当图稠密起来后一般需要用堆优化的dijkstra。。。