Dijkstra算法

Dijkstra算法用来解决单源最短路径：

设置集合S存放已被访问的顶点，然后执行n次下面的步骤：

1.每次从集合V-S中选择与起点s的最短距离最小的一个顶点，访问并加入集合S；

2.之后，令顶点u为中介点，优化起点s与所有从u能到达的顶点v之间的最短距离。

邻接矩阵：

int vis[MAXN];
int G[MAXN][MAXN];
int d[MAXN];

void Dijkstra(int s)
{
    fill(d,d+MAXN,oo);
    d[s]=0;
    for(int i=0;i<n;i++)
    {
        int u=-1,MIN=oo;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<MIN){
                u=j;
                MIN=d[j];
            }
        }
        if(u==-1)return;
        vis[u]=true;
        for(int v=0;v<n;v++){
            if(vis[v]==false&&G[u][v]!=oo&&d[u]+G[u][v]<d[v]){
                d[v]=d[u]+G[u][v];
            }
        }
    }
}

邻接表：

struct Node{
    int v,dis;
};
vector<Node> Adj[MAXN];
int d[MAXN];
int vis[MAXN];
void Dijkstra(int s)
{
    fill(d,d+MAXN,oo);
    d[s]=0;
    for(int i=0;i<n;i++){
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<MIN){
                u=j;MIN=d[j];
            }
        }
        if(u==-1)return;
        vis[u]=true;
        for(int j=0;j<Adj[u].size();j++){
            int v=Adj[u][j].v;
            if(vis[v]==false&&d[u]+Adj[u][j].dis<d[v]){
                d[v]=d[u]+Adj[u][j].dis;
            }
        }
    }
}

如果要求最短路径，可以定义变量pre[MAXN];

void Dijkstra(int s)
{
    fill(d,d+MAXN,oo);
    for(int i=0;i<n;i++) pre[i]=i;
    d[s]=0;
    for(int i=0;i<n;i++){
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<MIN){
                u=j;MIN=d[j];
            }
        }
        if(u==-1)return;
        vis[u]=true;
        for(int j=0;j<Adj[u].size();j++){
            int v=Adj[u][j].v;
            if(vis[v]==false&&d[u]+Adj[u][j].dis<d[v]){
                d[v]=d[u]+Adj[u][j].dis;
                pre[v]=u;
            }
        }
    }
}
void DFS(int s,int v)
{
    if(v==s){
        printf("%d\n",s);
        return;
    }
    DFS(s,pre[v]);
    printf("%d\n",v);
}