迪杰斯特拉Dijkstra算法，单源最短路径

算法思想：贪心策略，从源点出发不停合并路径最短的顶点，并更新顶点的最短路径信息。
步骤简单概括：查找->合并->更新（类似prime最小生成树）
辅助数组：
dist[]: dist[i]表示源点到顶点i的最短路径长度，初始dist[i]等于源点到顶点i的边长（不直接相连则为无穷）.
path[]:path[i]表示源点到点i的最短路径中顶点i的前驱顶点

例：求下图从0点出发的单源最短路径![在这里插入图片描述](https://img-blog.csdnimg.cn/20200406124636511.png?x-
算法过程模拟：

辅助数组的变化过程：

黄色表示选中的路径最短的顶点，红色表示结果集
代码：

#include <iostream>
#include <limits>
#define MAX 100

using namespace std;

typedef struct Graph{
    int vexnum, edgnum;
    int Matrix[MAX][MAX];
    Graph(int v, int e):vexnum(v), edgnum(e){
        for(int i = 0; i < vexnum; i ++){
            for(int j = 0; j < vexnum; j ++){
                Matrix[i][j] = INT_MAX;
            }
        }
    }
}Graph;

//初始化图
void initGraph(Graph &G){
    cout << "分别输入G的每条边的起点、终点、权值（用空格隔开）：" << endl;
    int i, j, info;
    for(int k = 0; k < G.edgnum; k ++){
        cin >> i >> j >> info;
        if(i >= G.vexnum || i < 0 || j >= G.vexnum || j < 0){
            cout << "输入的顶点越界！" << endl;
            continue;
        }
        G.Matrix[i][j] = info;
    }
}

//打印图的边
void printEdge(Graph G){
    for(int i = 0; i < G.vexnum; i ++){
        for(int j = 0; j < G.vexnum; j ++){
            if(G.Matrix[i][j] < INT_MAX){
                cout << i << "->" << j << ":" << G.Matrix[i][j] << endl;
            }
        }
    }
}

int dist[MAX];  //表示i到源点的最近距离（不停更新）
int path[MAX];  //表示i到源点最近距离路径的前驱（不停更新）
bool flag[MAX] = {false}; //定义结果标记，true表示改顶点已经并入结果

/**
寻找未并入结果的顶点集中与源点距离最近的顶点并返回该点下标
如果所有顶点都已并入结果或者剩余的顶点不连通则返回-1
*/
int findMinDist(Graph G){
    int result = -1;
    int maximum = INT_MAX;
    for(int i = 0; i < G.vexnum; i ++){
        if(dist[i] < maximum && !flag[i]){
            maximum = dist[i];
            result = i;
        }
    }
    return result;
}
int main()
{
    int v, e, start;
    cout << "输入图的顶点数和边数（用空格隔开）：";
    cin >> v >> e;
    Graph G(v, e);
    initGraph(G);
    cout << "输入Dijkstra算法的起点：";
    cin >> start;
    for(int i = 0; i < G.vexnum; i ++){
        dist[i] = G.Matrix[start][i];
        if(G.Matrix[start][i] < INT_MAX){
            path[i] = start;
        }else{
            path[i] = -1;
        }
    }

    //定义一个G的子图来存储结果
    Graph gg(G.vexnum, 0);

    //源点并入结果
    flag[start] = true;

    while(true){
        //查找
        int current = findMinDist(G);
        if(current == -1){
            break;
        }
        //合并
        gg.Matrix[path[current]][current] = G.Matrix[path[current]][current];
        gg.vexnum ++;
        flag[current] = true;
        //更新
        for(int i = 0; i < G.vexnum; i ++){
            if(dist[i] > dist[current] + G.Matrix[current][i] && G.Matrix[current][i] < INT_MAX){
                dist[i] = dist[current] + G.Matrix[current][i];
                path[i] = current;
            }
        }
    }
    printEdge(gg);
    return 0;
}

运行结果：