关于最短源路径问题

    在计算最短源路径中，涉及到了两个比较重要的算法，即Bellman-Ford算法和Dijkstra算法。Bellman-Ford算法是判断一个有向图里面是否存在负权回路，此算法是运用松弛技术，对每个顶点v,逐步减小从源s到v的最短路径的权的估计值d[v]直至达到实际最短路径的权为止。算法返回TRUE,当且仅当图中不包含从源点可达的负权回路。
源代码如下：

1. bool fellman(int n)
2. {
3.        memset(D,0,sizeof(D));
4.        Node *link;
5.        for(int i=0;i<n-1;++i)
6.        {
7.              bool f = false;
8.               for(int j=0;j<n;++j)
9.               {
10.                    link = Edg[j];
11.                    while(link)
12.                    {
13.                           if(D[link->to]>D[j]+link->value)
14.                           {
15.                                   D[link->to] = D[j] + link->value;
16.                                   f = true;
17.                           }
18.                           link = link->next;
19.                    }
20.               }
21.               if(f == false) return true;
22.        }
23.        for(int i=0;i<n;++i)
24.        {
25.              link = Edg[i];
26.              while(link)
27.              {
28.                     if(D[link->to] > D[i] + link->value) return false;
29.                     link = link->next;
30.              }
31.        }
32.        return true;
33. }

Dijkstra算法是用来计算从源点s出发，到其它顶点的最终最短路径的权值。
算法反复的选择具有最短路径估计的顶点，并将其加入到已经选择了的顶点
的集合中，直到所有的顶点都选择完为止。
代码如下：

1. void Dijkstra(int n)
2. {
3.       D[1] = 0;
4.       int r=0;
5.       memset(visit,false,sizeof(visit));
6.       for(int k=1;k<=n;++k)
7.       {
8.              double min = 0xfffffff;
9.              for(int i=1;i<=n;++i)
10.              {
11.                     if(!visit[i] && min>D[i])
12.                     {   
13.                           min = D[i];
14.                           r = i;
15.                     }
16.              }
17.              Node *link = Edg[r];
18.              visit[r] = true;
19.              while(link)
20.              {
21.                     if(!visit[link->to] && D[link->to]>link->value)
22.                     D[link->to] = link->value;
23.                     link = link->next;
24.              }
25.       }
26. }

数组D[]中，最终就存储了从顶点出发，到其它n-1个顶点的最小的权值。