图论算法——最短路问题

无权最短路

简单介绍

对于无权图G（边没有权值或认为权值为1），如果G是连通的，则每个顶点之间都存在路径。最短路径算法就是要找到一条连接不同顶点的最短路径。
例如：V2到V5可以是V2->V5，也可以是V2->V0->V3->V5，很明显最短路是前者

算法

主要思路： 广度优先搜索（bfs） ：对于每个顶点，我们将跟踪三个信息
，known标记此顶点是否被访问过，dist标记此顶点到起始点的深度，path标记前面的顶点，用于标记路径

步骤：我们以求V2到其他顶点的最短路为例）

• (1) 标记v2v2的Known为1，找与v2v2最近的点即遍历v2v2的邻接表，更新邻接表中的顶点v0、v5v0、v5的Known=1，dist=0+1=1，Path= v2v2。
• (2) 接着找离v0v0和v5v5的最近的点，对于v0v0，遍历其邻接表，更新v1v1和v3v3的相关状态。
• (3) 最终得到一个状态表，从改状态表中可以提取v2v2到其他所有顶点的最短路径。
• (4) 该方法的时间复杂度为 O(|V|^2)

伪代码：

void unweighted(table T)
{
    int currdist;
    vertex V, W;

    for (currdist = 0; currdist < numvertex; currdist++)
    {
        for each vertex V
        {
            if (!T[V].know && T[V].dist == currdist)
            {
                T[V].known = true;
                for each W adjacent to v;
                if (T[W].dist == infinity)
                {
                    T[W].path = V;
                    T[W].dist = currdist + 1;
                }
            }
        }
    }
}

优化(借助队列）

伪代码：

void unweighted(Table T)
{
    queue Q;
    vertex V, W;

    Q = createQueue(numvertex);
    enqueue(S, Q);

    while (!isempty(Q))
    {
        V = Dequeue(Q);
        T[V].known = true;

        for each W adjacent to V
            if (T[W].dist == Infinity)
            {
                T[W].dist = T[V].dist + 1;
                T[W].path = V;
                enqueue(W, Q);
            }
    }
    Disposequeue(Q);
}

Dijkstra算法

伪代码讲解：

typedef int Vertex;
struct TableEntry
{
    List Header;//邻接表
    int Known;//标记是否走过
    DistType Dist;//标记权值
    Vertex Path;//来到此顶点的路径，指前一个顶点
};
#define NotAvertex -1
typedef struct TableEntry Table[NumVertex];//一个包含所有顶点信息的数组

void InitTable(Vertex Start,Vertex Graph G,Table T)//Start顶点为要所求的最短路径的起点
{
    int i;
    ReadGraph(G,T);//读图,将图里的顶点复制到Table表里
    for(i=0;i<NumVertex;i++)
    {
        T[i].Known=False;
        T[i].Dist=Infinity;
        T[i].Path=NotAvertex;
    }
    T[Start].Dist=0;
}

void PrintPath(Vertex V,Table T)
{
    if(T[V].Path!=NotAvertex)
    {
        PrintPath(T[V].Path,T);
        printf(" to");
    }
    printf("%v",V);
}

void Dijkstra(Table T)//算法主体
{
    Vertex V,W;
    for(;;)
    {
        V=smallest unknown distance vertex;//初始即为Start点，因为此时只有这个点是0
        if(V==NotAvertex)break;//当所有顶点都被遍历过后跳出循环
        T[V].Known=True;
        for each W adjacent to V//对于每一个V的邻接点
        {
            if(!T[W].Known)//如果W没有被遍历过
            {
                if(T[V].Dist+Cvw<T[W].Dist)//如果V的累计权值小于W的权值，更新W的权值
                {
                    T[W].Dist=T[V].Dist+Cvw
                    T[W].Path=V;
                }
                
            }
        }

    }
}

具有负边值的图的最短路算法

void weightedNegative(Table T)
{
    queue Q;
    vertex V, W;

    Q = createQueue(numvertex);
    MakeEmpty(Q);
    enqueue(S, Q);

    while (!isempty(Q))
    {
        V = Dequeue(Q);
        for each W adjacent to V
            if (T[W].Dist +Cvw<T[W].Dist)
            {
                T[W].dist = T[V].dist + Cvw;
                T[W].path = V;
                if(W is not already in Q)//W完全没有在Q过
                enqueue(W, Q);
            }
    }
    Disposequeue(Q);
}

此算法和无权的最短路算法很像，而且权值不是负的时候也同样可用