Dijkstra算法

Dijkstra算法的具体实现：

设置集合S存放以被访问的顶点，然后执行n次以下两个步骤(n为顶点数):

 1.每次从集合V-S(即没有访问过的城市)中选择与起点s的最短距离最小的一个顶点(记为u)，

访问并加入到集合S中(即访问过)。

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

解决1和2的方法。

集合S可以用一个bool类型的vis[]来实现，当vis[i]==true时表示顶点Vi已经被访问，

当vis[i]==false时表示没有被访问。

令一个int的数组d[]表示起点s到达顶点Vi的最短距离，初始时除了起始顶点的d[s]赋值为0，

其余每个顶点都赋值为INF，

然后动态维护d数组

伪代码如下:

Dijkstra(G,d[],s){
    初始化
    for(循环n次){
        u = 使d[u]最小的还末被访问的顶点的编号;
        记u已经被访问
        for(从u出发能到达所有的顶点v){
            if(v没有被访问&&以u为中介点使s到顶点v的最短距离更优){
                优化d[v]
            }
        }
    }
}

邻接矩阵版：

const int MAXV = 1e5+5;
const int INF = 0x3f3f3f3f;
int n,G[MAXV][MAXV],d[MAXV];
bool vis[MAXV];

void Dijkstra(int s){
    memset(d,INF,sizeof(d));
    memset(vis,false,sizeof(vis));
    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]==0&&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&&d[u]+G[u][v]<d[v]){
                d[v] = d[u]+G[u][v];
            }
        }
    }
}

邻接表版：

const int MAXV = 1e5+5;
const int INF = 0x3f3f3f3f;
int n,d[MAXV];
bool vis[MAXV];
struct ac{
    int v,dis;
};
vector<ac>Adj[MAXV];
void Dijkstra(int s){
    memset(d,INF,sizeof(d));
    memset(vis,false,sizeof(vis));
    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]==0&&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;
            }
        }
    }
}