最短路径问题

Dijkstra算法：有权图的单源最短路

1.最短路必定只经过S中的顶点

　　如果还存在一个w在S之外，v0>w必定小于v0>v,但路径是按照递增顺序生成的，那么w一定已经收录了，与前提矛盾。    

2.新收录一个v,会影响v的邻接点的dist值

　　如果收录v使得s>w的路径变短，则s>w的路径一定经过v,并且v>w有一条边。如果v>w中间还存在顶点的话，该顶点一定在S之外（S是按递增顺序生成的，v刚被收录）而w的dist值为只经过S中的顶点。 dist[w] = min{dist[w], dist[v]+ <v, w>的权重}                                                                                                                             

3.过程

　　1.从V-S中找到dist[i]最小的下标i,收录到S中

　　2.更新与i的邻接点的dist值　

　　3.V==S时停止

4.代码

//邻接矩阵存储
#define MaxVertexNum 1100
struct GraphNode
{
    int Nv;
    int Ne;
    int G[MaxVertexNum][MaxVertexNum];
};
typedef struct GraphNode *MGraph;

Vertex FindMinDist(MGraph Graph, int dist[], int collected[])
{
    Vertex MinV, V;
    int MinDist = INFINITY;
    
    for (V = 0; V < Graph->Nv; V++) {
        if (collected[V] == false && dist[V]<MinDist) //在未收录中找且dist[V]更小
        {
            MinDist = dist[V];
            MinV = V;
        }
    }
    if (MinDist < INFINITY)
        return MinV;
    else
        return ERROR;
}

bool Dijkstra(MGraph Graph, int dist[], int path[], Vertex s)
{
    int collected[MaxVertexNum];
    Vertex v, w;
    
    for (v = 0; v < Graph->Nv; v++) {
        dist[v] = Graph->G[s][v];
        if (dist[v] < INFINITY)
            path[v] = s;
        else
            path[v] = -1;
        collected[v] = false;
    }
    dist[v] = 0;
    collected[s] = true;
    
    while (1) {
        v = FindMinDist(Graph, dist, collected);
        if (v == ERROR)
            break;  //全收录完
        collected[v] = true;
        for (w = 0; w < Graph->Nv; w++) {
            if (collected[w] == false && Graph->G[v][w]<INFINITY) {
                if (Graph->G[v][w] < 0)  //负值圈
                    return false;
                if (dist[v]+Graph->G[v][w] < dist[w]) {
                    dist[w] = dist[v] + Graph->G[v][w];
                    path[w] = v;
                }
            }
        }
    }
    return true;
}

5.时间复杂度

　　直接扫描所有未收录的顶点 T = O(|V|^2 + |E|)   稠密图效果好

　　若用最小堆存取dist 读取最小的并更新堆O(log|V|), 但更新dist[w]的值需要插入最小堆O(log|V|)  T = O(|V|log|V| + |E|log|V|) = O(|E|log|V|)  稀疏图较好 （E和V同一个数量级，|V|log|V|比|V|^2要好）

若将单源最短路算法调用|V|遍，对于稠密图T = O(|V|^3 + |E||V|) 对于稀疏图较好

对于稠密图有Floyd算法　

Floyd算法：多源最短路算法

采用DP思想

设为从到的只以集合中的节点为中间节点的最短路径的长度。

1. 若最短路径经过点k，则；
2. 若最短路径不经过点k，则。

因此，。

//邻接矩阵存储

bool Floyd(MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[])
{
    Vertex i, j, k;
    
    for (i = 0; i < Graph->Nv; i++)
    for (j = 0; j < Graph->Nv; j++) {
        D[i][j] = Graph->G[i][j];
        path[i][j] = -1;
    }
    
    for (k = 0; k < Graph->Nv; k++)
        for (i = 0; i < Graph->Nv; i++)
            for (j = 0; j < Graph->Nv; j++)
                if (D[i][k] + D[k][j] < D[i][j]) 
                {
                    D[i][j] = D[i][k] + D[k][j];
                    if (i == j && D[i][j] < 0)
                        return false;
                    path[i][j] = k;
                }
    return true;
}

输出路径：

　　递归输出, 先输出i到k，再输出k，再输出k到j路线。

时间复杂度

　　T = O(|V|^3)