初学算法之dijkstra

　　dijkstra的代码思想网上各路高手所述备矣。这里只是存下用邻接矩阵和邻接表实现的dijkstra。（白书代码）

　　邻接矩阵

void dijkstra(int s){
    int dis[s]=0;
    while(1){
        int v=0;  //从尚未使用过的顶点中选择一个距离最小的顶点 
        for(int u=1;u<=n;u++){
            if(!used[u]&&dis[v]>dis[u])
            v=u;
        }
        if(!v) break;
        used[v]=1;
        for(int u=1;u<=n;u++){
            dis[u]=min(dis[u],dis[v]+dis[v][u]);
        }
    }
}

　　　　堆优化的dijkstra

struct edge{int to,cost;};
typedef pair<int ,int > P;

int V;
vector<int>G[Max];
int d[Max];

void dijkstra(int s){
    priority_queue<P>,vector<P>,greater<P> >que;//通过指定greater<P>参数 
    que.push(P(0,s));                             //堆按照first从小到大的顺序取出值 
    
    while(!que.empty()){
        P p=que.top();que.pop();
        int v=p.second;
        if(d[v]<p.first) continue;
        for(int i=0;i<G[v].size();i++){
            edge e=G[v][i];
            if(d[e.to]>d[v]+e.cost){
                d[e.to]=d[v]+e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
} 
    
    

例题：hdu-2544 最短路

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。
Output对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间Sample Input

2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

Sample Output

3
2

这题就是单纯的套模板
附本人堆优化dijkstra的ac代码

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
const int Max = 111111;
const int inf = 0x3f3f3f3f;
using namespace std;
struct edge{int to,cost;};
vector<edge>G[Max];
int d[Max];
typedef pair<int,int>P;
void dijkstra(){
    priority_queue<P,vector<P>,greater<P> >que;
    d[0]=0;
    que.push(P(0,0));
    while(!que.empty()){
        P p=que.top();que.pop();
//        printf("%d ",p.first);
        int v=p.second;
        if(d[v]<p.first) continue;
        for(int i=0;i<G[v].size();i++){
            edge e=G[v][i];
            if(d[e.to]>d[v]+e.cost){
//                printf("%d ",d[e.to]);
                d[e.to]=d[v]+e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
}        
int main(){
    int n,m;
    while(~scanf("%d %d",&n,&m),n+m){
        memset(d,inf,sizeof(d));
        int a,b,c;
        for(int i=0;i<m;i++){
            scanf("%d %d %d",&a,&b,&c);
            a-=1;
            b-=1;
            edge e;
            e.to=b;e.cost=c;
            G[a].push_back(e);
            e.to=a;
            G[b].push_back(e);
        }
        dijkstra();
        printf("%d
",d[n-1]);
        for(int i=0;i<m;i++)
        G[i].clear();
    }
    return 0;
}

附本人邻接矩阵的ac代码

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<iostream>
#include<queue>

using namespace std;

const int inf = 0x3f3f3f3f;

int mp[105][105],dis[105],used[105],n;

void dijkstra(){
    for(int i=1;i<=n;i++){
        dis[i]=mp[1][i];
    }
//    for(int i=1;i<=n;i++)
//            cout << mp[1][i] <<endl;
    dis[1]=0;
    used[1]=1;
    while(1){
        int minn=inf,u=-1;
        for(int i=1;i<=n;i++){
            if(minn>dis[i]&&used[i]==0){
                minn=dis[i];
                u=i;
            }
        }
        used[u]=1;
        if(u==-1)    break;
        for(int i=1;i<=n;i++){
            int temp=min(inf,dis[u]+mp[u][i]);
            if(dis[i]>temp){
                dis[i]=temp;
            }
        }
    }
}
int main(){
    ios::sync_with_stdio(false);
    int m,i,j,a,b,c;
    while(cin >> n >> m,n||m){
        memset(dis,0,sizeof(dis));
        memset(mp,inf,sizeof(mp));
        memset(used,0,sizeof(used));
        for(i=0;i<m;i++){
            cin >> a >> b >> c;
            mp[a][b] = c;
            mp[b][a] = c;
        }
        dijkstra();
        
        cout << dis[n] << endl;
    }
    return 0;
}