单源最短路径（Dijkstra算法）

• 算法思想：
  Dijkstra算法和Prim算法思想相似，通过定义两个集合，走过的结点位于集合S，未走过的结点位于集合U中，在集合S中寻找是否有更短的路径能够到达未走过的结点，比如A–>B权值为2，B–>C权值5，A–C权值为10，以A为起始点，把A加入集合S中，以A为起点的最短边为A–>B，于是我们把B加入集合S中，未走过的结合U中还剩下C，当要去判断是否有更短的权值能够到达C,由于一开始A是起点，我们已经记录了A–>C的路径，要判断是否能更短的路径，只需在B点的基础上，判断能否有更短的路径到C，即判断A–>B + B–>C 是否小于A–>C，如果存在更短的路径，那么则更新能够到达的最小权值和更新能够到达C更短路径的上一个顶点。
• 用计算机语言去描述两个互斥的集合关系，我们只需将集合中所有结点初始为0，定义为均未走过，如果结点已经走过，那么重新赋值为1即可。dist数组存储当前已找到的从V0到每个终点Vi的最短路径的长度，path保存从V0到Vi最短路径上的前一个顶点。
• 下面我们用下图作为测试用例寻找从0开始到其他顶点的最短路径。
  
  测试结果如下：
  
  
  源代码如下：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

#define MaxSize 20
#define INF 99999

typedef struct{
    int edges[MaxSize][MaxSize];
    int VNode[MaxSize];
    int n;
    int e;
}MGraph;

void InitMGraph(MGraph* G){
    G->e = 12;
    G->n = 7;
    for (int i = 0; i < G->n; i++) {
        for (int j = 0; j < G->n; j++) {
            G->edges[i][j] = INF;
        }
    }
    G->edges[0][1] = 4;
    G->edges[0][3] = 6;
    G->edges[0][2] = 6;
    G->edges[1][2] = 1;
    G->edges[1][4] = 7;
    G->edges[2][5] = 4;
    G->edges[2][4] = 6;
    G->edges[3][2] = 2;
    G->edges[3][5] = 5;
    G->edges[4][6] = 6;
    G->edges[5][4] = 1;
    G->edges[5][6] = 8;
}

void Dijkstra(MGraph* G,int cur){
    int S[MaxSize];
    int dist[MaxSize];
    int path[MaxSize];
    for (int i = 0; i < G->n; i++) {
        S[i] = 0;
        dist[i] = G->edges[cur][i];
        if (dist[i]!=INF) {
            path[i] = cur;
        }else{
            path[i] = -1;
        }
    }
    
    int minIndex;
    S[cur] = 1;
    for (int j = 0; j < G->n; j++) {
        int min = INF;
        for (int k = 0; k < G->n; k++) {
            if (S[k] != 1 && dist[k] < min) {
                min = dist[k];
                minIndex = k;
            }
        }
        
        S[minIndex] = 1;
        for (int i = 0; i < G->n; i++) {
            if (S[i] != 1 && dist[i] > G->edges[minIndex][i] + dist[minIndex]) {
                dist[i] = G->edges[minIndex][i] + dist[minIndex];
                path[i] = minIndex;
            }
        }
    }
}

int main(int argc, const char * argv[]) {
    MGraph* G = new MGraph();
    InitMGraph(G);
    Dijkstra(G, 0);
    return 0;
}