单源最短路径

一、Dijkstra算法

Dijkstra算法是解决带权重的有向图最短路径问题，要求所有边权重为非负值。

以下是算法导论上给出的伪码，采用了是贪心策略实现的，总是寻找集合V-S（S集合是加入）中最近的节点加入到S集合中，算法时间复杂度依赖于最小优先队列的实现方式。

Dijkstra(G,w,s)
    for each vertex v in G.V
        v.d=FIN;   //最短路径估计
        v.π=NIL； //前驱节点        
    s.d=0;   //到源节点距离为0
    S=NULL;
    Q=G.V;
    while !Q.empty
        u=EXTRACT-MIN(Q)   //最小优先队列
        S=SU{u}
        for each vertex v in G.Adj[u]
           RELAX(u,v,w)


RELAX(u,v,w)     //松弛操作
    if v.d>u.d+w(u,v)    
        v.d=u.d+w(u,v)    
        v.π=u

下面是C++的实现，时间复杂度是O(N^2),N为节点数。

/***prev数组保存已加入集合节点的前驱，dist数组保存每个节点到源节点的距离，vex边数，v源节点***/
const int INF=0xffff;
const int MAX=100;
void Dijkstra(vector<vector<int>>G,int *prev,int *dist,int vex,int v)
{
    bool s[MAX];   //记录节点是否加入集合
    for(int i=0;i<vex;i++)
    {
        dist[i]=G[v][i];  //源节点到每个节点的距离
        s[i]=0;           //初始化未使用节点
        if(dist[i]=INF)
            prev[i]=0;    //设置前驱节点
        else
            prev[i]=v;
    }
    dist[v]=0;
    s[v]=1;               //将源节点加入集合

    for(int i=1;i<vex;i++)
    {
        int temp=MAX;
        int u=v;
        for(int j=0;j<vex;j++)    //找出dist中最小值
        {
            if((!s[j])&&dist[j]<temp)
            {
                u=j;
                temp=dist[j];
            }
        }
        s[u]=1;           //加入集合

        for(int j=0;j<=vex;j++)       //松弛操作
        {
            if((!s[j])&&G[u][j]<MAX)
            {
                if(dist[u]+G[u][j]<dist[j])
                {
                    dist[j]=dist[u]+G[u][j];
                    prev[j]=u;
                }
            }
        }
    }
}

取终点将前驱数组逆序就可以得到最短路径的路线图了。

二、Bellman-Ford算法

该算法解决的是一般的单源最短路径问题，可以允许边的权重为负值，算法返回一个布尔值，表明是否存在一个从源节点可以到达的权重为负值的环路。

算法导论给出的伪码,时间复杂度为O（V*E）

Bellman-Ford(G,w,s)
    for each vertex v in G.V
        v.d=FIN;   //最短路径估计
        v.π=NIL； //前驱节点        
    s.d=0;   //到源节点距离为0
    for i=1 to |G.V|-1
        for each edge(u,v) in G.E
            RELAX(u,v,w)      //与dijstra算法一样的松弛操作
    for each edge(u,v) in G.E  //判断是否有存在权重为负值的环路
        if(v.d>v.d+w(u.v))
            return FALSE
    return TRUE

理解Bellman-Ford算法,首先我们要理解松弛操作，下面给出算法导论给出的路径松弛性质：

图G从源节点s到节点uk的任意一条最短路径p=<v0,v1,v2,…，vk>，图G在初始化后，在进行一系列松弛操作，其中包括<v0,v1><v1,v2><v2,v3>…<vk-1,vk>的次序进行松弛操作后，我们可以得到源节点到vk的最短路径（权重），并且所得的值会一直保持成立。该性质的成立与其他边的松弛操作及顺序无关。

路径松弛性质的证明可以用归纳法证明：

第一步，源节点s到s的最短路径权重就是0，初始化后将不会改变；

归纳步，假定s到vi-1的最短路径权重为k，我们经过（vi-1，vi）松弛操作后，必然有s到vi的最短路径（权重）就可以得到了（收敛性质），并且其他操作不会改变这个结果。

因为经过|G.V|-1的循环的松弛操作，必定包括<v0,v1><v1,v2><v2,v3>…<vk-1,vk>的次序的松弛操作，因而Bellman-Ford算法合理的。

下面给出的C++实现：

typedef struct Edge {
    int u,v;
    int weight;
}Edge;        //边集来描述图


bool Bellman_Ford(Edge *edge,int *dist,int *prev,int vex,int v,int edgenum)
{
    bool flag=1;
    for(int i=0;i<vex;i++)
    {
        dist[i]=MAX;  //源节点到每个节点的距离
    }
    dist[v]=0;
    for(int i=0;i<edgenum;i++)
    {
        if(edge[i].u==v)
         {
            dist[edge[i].v]=edge[i].weight;   //初始化dist数组
            prev[edge[i].v]=v;                //设置前驱节点
         }
    }
    
    for(int i=1;i<vex;i++)                   //松弛操作
    {
        for(int j=0;j<edgenum;j++)
        {
            if(dist[edge[j].v]>dist[edge[j].u]+edge[j].weight)
            {
                dist[edge[j].v]=dist[edge[j].u]+edge[j].weight;
                prev[edge[j].v]=edge[j].u;
            }    
        }
    }
    for(int j=0;j<edgenum;j++)   //检验是否含有权重为负的环路
    {
        if(dist[edge[j].v]>dist[edge[j].u]+edge[j].weight)
            flag=0;
    }
    return flag;
}