迪杰斯特拉算法——PAT 1003

本文主要是将我对于我对于迪杰斯特拉算法的理解写出来，同时通过例题来希望能够加深对于算法的理解，其中有错误的地方希望大家指正。

迪杰斯特拉算法

我将这个算法理解成一个局部到整体的算法，这个方法确实越研究就会发现越经典。

首先可以将整个图的节点看成两个集合：一个是S,一个是U-S.如果是求v0到图中各点的最短距离的话，那么S就是已经确认到v0距离最短的点，U-S则是对于整体的点集合U，还没有加入S集合的点.

这里提出一个算法总体的思想，将所有的点按照一定的原则加入到S集就是解集。而这个解法就是重点了：如果我们能通过图邻接矩阵或者已经已知了图中点与点直连的距离，那么我们可以确定S集合的点就是到v0的最短路径（注意这个路径不是两点之间的距离而是图中可联通的任意两点的距离）。

好了问题缩小为求到v0路径最短的点，但是还需要注意的是：如果图中一点v加入到S集合中，图中其他点由于联通性就可能会减小到v0的最短路径。

如果不太清楚就依照图然后比对，最后再对照算法整理一下思路，如下是示例图（参考）：

　　　　　　　　　　　　　　　　 

算法步骤：

a.初始时，S只包含源点，即S＝{v}，v的距离为0。U包含除v外的其他顶点，即:U={其余顶点}，若v与U中顶点u有边，则<u,v>正常有权值，若u不是v的出边邻接点，则<u,v>权值为∞。

b.从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。

c.以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。

d.重复步骤b和c直到所有顶点都包含在S中。

根据以上的思想整理一下，可以包括两部分：

1.找到一个未加入到S集合的节点同时到v0的距离还是最小的节点u，将其加入到S集合中。

2.通过v0节点来更新该点到v0的距离.比如没有加入集合S的点v,如果v到v0的距离大于v到u和v0到u的最短距离就将v到v0的距离更新为新的最短距离。

具体的算法示例为（实例仅是为了说明思想，所以请结合实际情况修改使用）：

 #include<iostream>
 using namespace std;

 int edgs[][];     //边
 int dist[MAXNUM];        //v0到各边的值
 int prev[MAXNUM];       //前驱数组 

 void Dijkstra(int v0,int n)
 {
     bool S[MAXNUM];        //确定顶点是否在S集合中 

      for(int i=;i<n;i++)
      {
          dist[i]=edgs[v0][i];    //vo到个点的初值
          S[i]=false;         //所有节点未加入S
          if(dist[i] ==MAXINT)
          {
              prev[i]=-;     //没有前驱节点
          }
          else
              prev[i]=v0;
      } 

      dist[v0] =;
      S[v0]=true;
      /*
      求v到v0的最短距离，将v加到S集中
      */
      for(int i=;i<n;i++)
      {
          int min    =MAXINT;
          int u=v0;

          //找到当前未使用点的DISJ[i]最小值
          for(int j=;j<n;j++)
          {
              if((!S[j]) && dist[j]<min)
              {
                  u=j;
                  min=dist[j];
              } 

             S[u]=true;   //找到最短路径  加入顶点

              //以新加入的节点    更新从 v0触发到集合V-S的顶点路径长度
              for(int j=;j<n;j++)
                  if((!S[j]) && dist[u]+edgs[u][j]<dist[j])    //通过新加入节点找到更短路径
                  {
                      dist[j]=dist[u]+edgs[u][j];
                      prev[j]=u;     //更新前驱节点
                  }
          }
      }
 }
 int main()
 {
     int n;     //图的顶点数
     cin>>n;
      for(int i=;i<n;i++)
          for(int j=;j<n;j++)
              cin>>edgs[i][j];     //边的权值

     return ;
 } 

　　好了这是我见到的最传统的写法（书上基本都这么写），我上面提到了算法实现其实分为两部分，聪明的你可否想到：能否调换两个部分的顺序：先通过比较路径的大小再来更新S集合中的点，之前我确实没有考虑过类似的问题，但是这次通过看了一些代码和思索发现这样是可以的而且不失为一种好的方法。下面通过一道算法题（选自https://www.patest.cn/contests/pat-a-practise/1003）来将两种思想通过代码的方式列举一下。

1003. Emergency (25)

As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pair of cities are marked on the map. When there is an emergency call to you from some other city, your job is to lead your men to the place as quickly as possible, and at the mean time, call up as many hands on the way as possible.

Input

Each input file contains one test case. For each test case, the first line contains 4 positive integers: N (<= 500) - the number of cities (and the cities are numbered from 0 to N-1), M - the number of roads, C1 and C2 - the cities that you are currently in and that you must save, respectively. The next line contains N integers, where the i-th integer is the number of rescue teams in the i-th city. Then M lines follow, each describes a road with three integers c1, c2 and L, which are the pair of cities connected by a road and the length of that road, respectively. It is guaranteed that there exists at least one path from C1 to C2.

Output

For each test case, print in one line two numbers: the number of different shortest paths between C1 and C2, and the maximum amount of rescue teams you can possibly gather.
All the numbers in a line must be separated by exactly one space, and there is no extra space allowed at the end of a line.

Sample Input

5 6 0 2

1 2 1 5 3

0 1 1

0 2 2

0 3 1

1 2 1

2 4 1

3 4 1

Sample Output

2 4

对照本题，其实可以根据题意可以很快的转化到以图为模型的点与点之间的求解。对于我来说基本就确定用迪杰斯特拉算法来AC.将本体的元素抽象一下可以把每一个城市看成一个点，同时城市与城市之间的路可以看成边，边有对应的权值大小。有一些细节上的改动，比如：需要我们确定最短边的个数以及相应的一些点的权值的计算。好我们同样依照上面的算法来解决。下面是我的算法（已经通过测试），主要上面提到的两个主要部分：

 /*
 author :LY   2016.5.31
 */
 #include<iostream>
 using namespace std;
 #define INF 9999999

 int N;     //number of city
 int M;     //number of road
 int start,en;
 const int MAXNUM=;     //最大的顶点数 

 int city[MAXNUM];
 int path[MAXNUM][MAXNUM];    //边
 int dist[MAXNUM];        //v0到各边的最小值
 int pathcount[MAXNUM];    //最短边的数量
 int amount[MAXNUM];      //可获取的最大资源数
 bool S[MAXNUM];       //确定顶点是否在S集合中 

 void Dijs(int v0)     //根据dij来确定两点之间最短
 {
          //将v0加入S
     dist[v0]=;
     S[v0]=true;
     amount[v0]=city[v0];
      int u=v0;

     for(int i=;i<N;i++)
     {
         dist[i]=path[v0][i];    //optial
         if(dist[i]!=INF && i!=v0)
         amount[i]=amount[v0]+city[i]; 

        }

     /*
      求v到v0的最短距离，将v加到S集中
      */
     for(int i=;i<N;i++)
     { 

               //求出v0到v的最短路径，将此点加入到S中
          int min=INF;

          for(int j=;j<N;j++)  //找到最小值
          {
              if(!S[j]&&dist[j]<min)
              {
                  u=j;
                  min=dist[j];
              }
          } 

          S[u]=true;    //将v点加入S 

         //更新v0到各点的路径长度
          for(int j= ;j<N; j++)
          {
              if(!S[j]&&dist[j]>dist[u]+path[u][j])
              {
                  dist[j]= dist[u]+path[u][j];   //    更新路径
                 amount[j]=amount[u]+city[j];
                 pathcount[j]=pathcount[u];
              }
              else if(!S[j]&&dist[j]==dist[u]+path[u][j])
              {
                  pathcount[j]+=pathcount[u];

                  if(amount[j]<city[j]+amount[u])
                  {
                      amount[j]=city[j]+amount[u];
                  }
              }
          }     

     }
 }
 int main()
 {

     scanf("%d",&N);
     scanf("%d",&M);
     scanf("%d",&start);
     scanf("%d",&en);

     for(int i=;i<N;i++)
     {
         scanf("%d",&city[i]);
     } 

     int i=,j=;
     //初始化dij数组
     for(i=;i<N;i++)
     {
         dist[i]=INF;
         pathcount[i]=;
         S[i]=false;
         amount[i]=city[i];
         for(j=;j<N;j++)
         {
             path[i][j]=INF;
         }
     }

     int k1=,k2=,k3=;
     for(int j=;j<M;j++)
     {
         scanf("%d",&k1);
         scanf("%d",&k2);
         scanf("%d",&k3);
         path[k1][k2]=k3;     //the  length  of road between C1 and C2
         path[k2][k1]=k3;
     }
     Dijs(start); 

     printf("%d %d\n",pathcount[en],amount[en]);
     return ;
 } 

　　我提到了可以调换顺序来实现，首先通过先比较的路径，再将点加入到S集合中，不过思路需要很清晰，以下是代码，对照一下可以加深对于程序的理解：

 #include<iostream>
 #include <cstdio>
 #define MAX 500
 #define INF 999999999
 int dist[MAX];
 bool mark[MAX];
 int mp[MAX][MAX];
 int teams[MAX];
 int amount[MAX];
 int pathcount[MAX];
 int n, m, start, en;

 void dijkstra(int s){
     dist[s] = ;
     amount[s] = teams[s];
     mark[s] = true;
     int newP = s;
     while (newP != en){
         for (int i = ; i < n; i++){
             if (mark[i] == false){
                 if (dist[i] > dist[newP] + mp[newP][i]){
                     dist[i] = dist[newP] + mp[newP][i];
                     amount[i] = amount[newP] + teams[i];
                     pathcount[i] = pathcount[newP];
                 }
                 else if (dist[i] == dist[newP] + mp[newP][i]){
                     pathcount[i] += pathcount[newP];
                     if (amount[i] < amount[newP] + teams[i])
                         amount[i] = amount[newP] + teams[i];
                 }
             }
         }
         int dmin = INF;
         for (int i = ; i < n; i++){
             if (mark[i] == false && dist[i] < dmin){
                 dmin = dist[i];
                 newP = i;
             }
         }
         mark[newP] = true;
     }
 }

 int main(){
     scanf("%d%d%d%d", &n, &m, &start, &en);
     for (int i = ; i < n; i++){
         scanf("%d", &teams[i]);
     }
     for (int i = ; i < n; i++){
         dist[i] = INF;
         pathcount[i] = ;
         mark[i] = false;
         for (int j = ; j < n; j++)
             mp[i][j] = INF;
     }
     for (int i = ; i < m; i++){
         int c1, c2, L;
         scanf("%d%d%d", &c1, &c2, &L);
         mp[c1][c2] = mp[c2][c1] = L;
     }
     dijkstra(start);
     printf("%d %d\n", pathcount[en], amount[en]);
     return ;
 }

由于本人水平有限，参考了一些大神的博文：

http://blog.csdn.net/xtzmm1215/article/details/39006079

http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html

　　希望大家批评指正！

　　日进一小步，月过一大步~~加油！！！