单源加权图最短路径问题(权值非负)-Dijkstra算法

解决单源最短路径的一个常用算法叫做：Dijkstra算法，这是一个非常经典的贪心算法例子。

注意：这个算法只对权值非负情况有效。

在每个阶段，Dijkstra算法选择一个顶点v，它在所有unknown顶点中具有最小的distance，同时算法将起点s到v的最短路径声明为known。

这个算法的本质就是 给定起点，然后假设你有一个点集（known点集），对这个点集中的点，我们已经求出起点到其的最短距离。然后慢慢扩张这个集合。直到某一时刻它包括目标点。

具体概念详细介绍见书吧，下面结合一个例子，阐述一下该算法遍历顶点的过程。

  

  

假设开始顶点s为v1。

则，第一个选择的顶点是v1，路径长是0，该顶点标记为known，

            

    1： known(v1)    unknown(v2,v3,v4,v5,v6,v7);    这时由known点集扩充，v4 为下一个最短路径顶点，路径长为1，标记v4为known

            

            

    2： known(v1,v4) unknown(v2,v3,v5,v6,v7);       这时由known点集扩充，v2 为下一个最短路径顶点，路径长为2，标记v2为known

            

    3： known(v1,v4,v2) unknown(v3,v5,v6,v7);       这时由known点集扩充，v3，v5 为下一个最短路径顶点，路径长为3, 标记v3，v5为known

               

    4:  known(v1,v4,v2,v3,v5) unknown(v6,v7);       这时由known点集扩充，v7 为下一个最短路径顶点，路径长为5, 标记v7为known

            

    5:  known(v1,v4,v2,v3,v5,v7) unknown(v6);       这时由known点集扩充，v6 为下一个最短路径顶点，路径长为6, 标记v6为known

           

伪代码：

        struct VertexNode

        {

            char data[2];

            int distance;

            bool known;

            VertexNode* path;

            adjVertexNode* list;

        };

 

         void Dijkstra(Graph& g, VertexNode& s)

        {

            for each vertex v in g
            {

                v.distance = INFINITY;

                v.known = false;

                v.path = NULL;

            }

            s.distance = 0;

            for (int i=0; i<g.vertexnum; i++)

            {

                vertex v = smallest unknown distance vertex;

                if (v==NULL)

                    break;

                else

                    v.known = true;

                for each w adjacent to v

                {

                    if (!w.known)                    

                    {

                        if (v.distance + weight(v,w) < w.distance)

                        { 

                            w.distance = v.distance + weight(v,w);

                            w.path = v;

                        }

                    }

                }

            }

        }

        void PrintPath( Graph& g, VertexNode* target)

        {// print the shortest path from s to target

            if(target.path!=NULL)

            {

                PrintPath(g, target.path);

                cout << " " ;

            }

            cout << target ;

        }

代码实现：

 

#include <iostream>
using namespace std;

#define MAX_VERTEX_NUM    20
#define INFINITY    2147483647
struct adjVertexNode
{
    int adjVertexPosition;
    int weight;
    adjVertexNode * next;
};
struct VertexNode
{
    char data [ 2 ];
    int distance;
    bool known;
    VertexNode * path;
    adjVertexNode * list;
};
struct Graph
{
    VertexNode VertexNode [ MAX_VERTEX_NUM ];
    int vertexNum;
    int edgeNum;
};

void CreateGraph ( Graph & g)
{
     int i , j , edgeStart , edgeEnd , edgeWeight;
     adjVertexNode * adjNode;
     cout << "Please input vertex and edge num (vnum enum):" << endl;
     cin >> g . vertexNum >> g . edgeNum;
     cout << "Please input vertex information (v1) /n note: every vertex info end with Enter" << endl;
     for ( i = 0; i < g . vertexNum; i ++)
     {
         cin >> g . VertexNode [ i ]. data; // vertex data info.
         g . VertexNode [ i ]. list = NULL;
     }
     cout << "input edge information(start end weight):" << endl;
     for ( j = 0; j < g . edgeNum; j ++)
     {
         cin >> edgeStart >> edgeEnd >> edgeWeight;
         adjNode = new adjVertexNode;
         adjNode -> weight = edgeWeight;
         adjNode -> adjVertexPosition = edgeEnd - 1; // because array begin from 0, so it is j-1
         // 将邻接点信息插入到顶点Vi的边表头部,注意是头部！！！不是尾部。
         adjNode -> next = g . VertexNode [ edgeStart - 1 ]. list;
         g . VertexNode [ edgeStart - 1 ]. list = adjNode;
     }
}

void PrintAdjList( const Graph & g)
{
    for ( int i = 0; i < g . vertexNum; i ++)
    {
        cout << g . VertexNode [ i ]. data << "->";
        adjVertexNode * head = g . VertexNode [ i ]. list;
        if ( head == NULL)
            cout << "NULL";
        while ( head != NULL)
        {
            cout << head -> adjVertexPosition + 1 << " ";
            head = head -> next;
        }
        cout << endl;
    }
}
void DeleteGraph( Graph & g)
{
    for ( int i = 0; i < g . vertexNum; i ++)
    {
        adjVertexNode * tmp = NULL;
        while( g . VertexNode [ i ]. list != NULL)
        {
            tmp = g . VertexNode [ i ]. list;
            g . VertexNode [ i ]. list = g . VertexNode [ i ]. list -> next;
            delete tmp;
            tmp = NULL;
        }
    }
}
VertexNode * FindSmallestVertex( Graph & g)
{
    int smallest = INFINITY;
    VertexNode * sp = NULL;

   
    for ( int i = 0; i < g . vertexNum; i ++)
    {
        if ( ! g . VertexNode [ i ]. known && g . VertexNode [ i ]. distance < smallest)
        {
            smallest = g . VertexNode [ i ]. distance;
            sp = &( g . VertexNode [ i ]);
        }
    }
    return sp;
}

void Dijkstra( Graph & g , VertexNode & s)
{
    int i;
    for ( i = 0; i < g . vertexNum; i ++)
    {
        g . VertexNode [ i ]. known = false;
        g . VertexNode [ i ]. distance = INFINITY;
        g . VertexNode [ i ]. path = NULL;
    }
    s . distance = 0;
    for( i = 0; i < g . vertexNum; i ++)
    {
        VertexNode * v = FindSmallestVertex( g);
        if( v == NULL)
            break;
        v -> known = true;
        adjVertexNode * head = v -> list;
        while ( head != NULL)
        {
            VertexNode * w = & g . VertexNode [ head -> adjVertexPosition ];
            if( !( w -> known) )
            {
                if( v -> distance + head -> weight < w -> distance)
                {
                    w -> distance = v -> distance + head -> weight;
                    w -> path = v;
            }
        }
        head = head -> next;
    }
}
void PrintPath( Graph & g , VertexNode * source , VertexNode * target)
{
    if ( source != target && target -> path == NULL)
    {
        cout << "There is no shortest path from " << source -> data << " to " << target -> data << endl;
    }
    else
    {
        if ( target -> path != NULL)
        {
            PrintPath( g , source , target -> path);
            cout << " ";
        }
        cout << target -> data ;
    }
}

int main( int argc , const char ** argv)
{
    Graph g;
    CreateGraph( g);
    PrintAdjList( g);
    VertexNode & start = g . VertexNode [ 0 ];
    VertexNode & end = g . VertexNode [ 6 ];
    Dijkstra( g , start);
    cout << "print the shortest path from v1 to v7" << endl;
    PrintPath( g , & start , & end);

    cout << endl;
    DeleteGraph( g);
    return 0;
}

运行结果：

对于这个算法，vertex v = smallest unknown distance vertex;如果用最简单的扫描数组方式实现，则该部操作时间复杂度为O(|V|), 所以该算法将花费O(|V|2)查找最小距离顶点,同时，注意到最内层循环，最终对每条边会执行一次，所以该算法时间复杂度为O(|V|2+|E|)

对于无向图，可以认为是双向的有向图，所以只要更改边的输入信息即可。

仍以上例看，有向图输入的边信息为12条边：

1 2 2
3 1 4
1 4 1
2 4 3
2 5 10
4 3 2
4 5 2
3 6 5
4 6 8
4 7 4
5 7 6
7 6 1

如果是无相图，即双向的有向图，则应该输入24条边信息，12组对称的边信息即可：

1 2 2   

2 1 2
3 1 4   

1 3 4
1 4 1   

4 1 1
2 4 3   

4 2 3
2 5 10  

5 2 10
4 3 2   

3 4 2
4 5 2   

5 4 2
3 6 5   

6 3 5
4 6 8   

6 4 8
4 7 4   

7 4 4
5 7 6   

7 5 6
7 6 1   

6 7 1

运行结果：

即：Dijkstra算法既可以求无向图也可以求有向图最短路径。