最短路径算法：dijkstra与Floyd算法

1、无权图的单源最短路径算法

本质为广度优先搜索算法BFS，在BFS中，原来需要一个布尔变量visited[w]来标记节点是否已经被搜索过了，这里替换为dist[w]，不仅可以标记是否被搜索过，还可以记录最短距离。

/*  无权图的单源最短路径算法
    dist[w] 源点S到w的最短距离, dist[w]初始化为-1，表示还没有搜索过
    path[w] S到w的路径上需要经过的某点
    需要提前将进入该函数之前，需要提前将dist[s]初始化为0
*/

void UnWeighted(Vertex S) {
    Enqueue(S, Q);
    while (!IsEmpty(Q)) {
        v = Dequeue(Q);
        for (v的每个领节点w) {
            if (dist[w] == -1) {
                dist[w] = dist[v] + 1;
                path[w] = v;
                Enqueue(w, Q);
            }
        }
    }
}

2、有权图的单源最短路径算法 – dijkstra算法

算法说明：

• 不能解决负边的情况
• 初始化 dist[w] = edge[s][w]
• 求未收录顶点中dist最小值可以使用小顶堆算法

/*  有权图的单源最短路径算法 -- dijkstra算法
*/

void dijkstra(vertex s) {
    while (1) {
        v = 未收录顶点中dist中的最小者;
        if (这样的v不存在) {
            break;
        }
        collected[v] = true;  // 将v标记为收录
        for (v的每个邻接点w) {
            if (collected[w] == false) {
                if (dist[v] + edge[v][w] < dist[w]) {
                    dist[w] = dist[v] + edge[v][w];
                    path[w] = v;
                }
            }
        }
    }
}

3、 多源最短路径算法 – Floyd算法

关于算法的几点说明：
（1）初始化问题， D[i][i] = 0
（2）关于求解i – j之间最短路径上经过的所有的点

• 若path[i][j] = -1, 说明i与j直接相连的路径就是最短路径，不需要经过任何点
• 否则，若path[i][j] = k, 那么 路径可以表示为 i --> k --> j， 递归求解path[i][k]以及path[k][j]

/*
    Floyd 算法 -- 多源最短路径算法
    N -- 邻接矩阵顶点的个数
    D[i][j] -- 顶点i与j之间的最短距离 
*/
void Floyd() {
    for (int i = 0; i < N; ++i) {
        for (int j =  0; j < N; ++j) {
            D[i][j] = G[i][j];
            path[i][j] = -1;
        }
    }
    for (int k = 0; k < N; ++k) {
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                if (D[i][k] + D[k][j] < D[i][j]) {
                    D[i][j] = D[i][k] + D[k][j];
                    path[i][j] = k;
                }
            }
        }
    }
}