Dijkstra(迪杰斯特拉)模板

Dijkstra(迪杰斯特拉)

算法思想

本质来说是一种贪心。每次选择一条最短路径，这样最后得到的就是一条最短路径。
举个例子：

代码模板（邻接表与邻接矩阵）

邻接矩阵版

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int MAXV = 1000;

const int INF = 1e9;

int n, G[MAXV][MAXV];//n是图顶点的个数，MAXV是最大顶点个数

int d[MAXV];//起点到各个点最短距离的长度]

bool vis[MAXV] = {false};

//s是起点
void Dijkstra(int s){
    fill(d, d + MAXV, INF);
    d[s] = 0;
    for(int i = 0; i < n; i++){//循环n次，遍历结点
        int u = -1, MIN = INF;//u使得的d[u]最小，MIN来记录最小的d[u]
        for(int j = 0; j < n; j++){
            if(vis[j] == false && d[j] < MIN){//找出没有访问地顶点里面的d[]最小的
                u = j;
                MIN = d[j];
            }
        }
        if(u == -1) return;//如果没有找到，说明剩下的点和起点s不连通
        vis[u] == true;//已经找到，设置访问过
        for(int v = 0; v < n; v++){
            //如果结点v未访问 and u可以到达v and 以u为中介点可以有更短的d[v] 
            if(vis[v] == false && G[u][v] != INF && d[u] + G[u][v] < d[v]){
                d[v] = d[u] + G[u][v];
            }
        }
    }
}

int main(){
    return 0;
}

邻接表版

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

using namespace std;

const int MAXV = 1000;//最大顶点个数

const int INF = 1e9;//设为一个很大的数字

struct Node{
    int v;//目标边的顶点
    int dis;//边的权值
};

vector<Node> Adj[MAXV];//图G,Adj[u]存放从顶点u可以到达的所有顶点

int n;//顶点个数

int d[MAXV];//起点到各个点的最短路径长度

bool vis[MAXV] = {false};//标记数组

void Dijkstra(int s){
    fill(d, d + MAXV, INF);
    d[s] = 0;//起点到自身的距离为0
    for(int i = 0; i < n; i++){
        int u = -1, MIN = INF;
        for(int j = 0; j < n; j++){
            if(vis[i] == 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;//通过邻接表直接获得u能到达的顶点v
            if(vis[v] == false && d[u] + Adj[u][j].dis <d[v]){
                //更优情况
                d[v] = d[u] + Adj[u][j].dis;
            }
        }
    }
}

int main(){
    return 0;
}