假设你是一个想环游世界的穷孩子，现在好不容易攒了些钱，想要去很多城市。但是由于资金有限，你得尽量找便宜的交通方式。但有的城市从你家根本不能直达，有些城市你从家坐高铁就能直达，有些城市从你家到那里只有飞机。现在你知道了许多城市之间的交通费，想要到目的地去，除了直达还能转车。转车比飞机便宜啊！所以你精打细算想看看从你家到各城市的最便宜的交通方式，这时候有一个叫Dijkstra的人告诉你一个方法，在知道你想去的各个城市之间费用的情况下，计算出从你家到这些城市的最便宜的交通费。这就是Dijkstra算法。

假设一共有n个城市。
1.先用一张纸把这些城市的名字记录下来。再把这些城市里已经相互能直达的两个城市的费用记在账单上。再在黑板上写下到各个城市的最少费用，不能直达的城市之间就记成无穷大。准备好黑板擦，黑板只是个草稿，最少费用会在求解过程中实时改变。

  1. int **Graph=new int*[n];      //账单，在这里我用二维数组来存这些城市之间的交通费
  2. int *dist=new int[n];    //黑板，用来记录当前两个城市之间的最便宜费用
  3. int *path=new int[n];    //记录是从哪个城市到这个城市的
  4. bool *collected=new int[n];    //记录城市的名字的纸，用过之后就划掉

 

2.先从家出发，从黑板上挑出能最便宜直达另一个城市的路径，我们假设这个城市为A，一个小时公交车就能到。把家到A的交通费记在黑板上，因为A已经是从家到其他城市交通费里最低的了，所以这就是家到A的最便宜的交通方式。现在已经找过家了，就在纸上把家划掉。

3.现在从A出发，把从A能到达的城市找出来。依次比较家直达这些城市的费用，与从A转站到这些城市的费用。如果从A转站到达这些城市比直达还便宜的话，就把便宜的哪一种费用记在黑板上，把先导路径也记上，也就是到达此城市的前一站。如到B城市最偏宜的路径是从A转车，就记先导路径为A，反之记成家。

  1.     while (1) 
  2.     {
  3.         int V = FindMinDist(collected, dist, n);
  4.         if(V==-1)
  5.         {
  6.             break;      /* 算法结束 */
  7.         }
  8.         collected[V] = true;  /* 收录V */
  9.         for(int j=0; j<n; j++ ) /* 对图中的每个顶点j */
  10.             if ( j!=V&& Graph[V][j]<INFINITY ) 
  11.             {
  12.                 //if ( Graph[V][j]<0 ) /* 若有负边 */
  13.                 //return false; /* 不能正确解决，返回错误标记 */
  14.                 /* 若收录V使得dist[j]变小 */
  15.                 if ( dist[V]+Graph[V][j] < dist[j] ) 
  16.                 {
  17.                     dist[j] = dist[V]+Graph[V][j]; /* 更新dist[j] */
  18.                     path[j]=V;/*更新路径*/
  19.                 }
  20.             }
  21.     } /* while结束*/
  22. }

 

4.把A能到达的所有城市全布遍历，经过3中的比较之后，就在纸上把A划去。然后从黑板上挑出除A外下一个最便宜的路径，重复3中的操作。一直到纸上所有的城市都被划去。

5.现在黑板上所记录的就是家到各城市的最便宜交通费了。但是由于每个城市只记录了到达自己的前一站，所以如果想知道整条路的话，需要通过自己的前一站去找这个站的前面的站，一直遍历到家，才能知道全部路径。

在有向有权中，找到由一个顶点 V0 到其余各点的最短路径长度

在带权有向图G中，给定一个源点v，求从v到G中的其余各顶点的最短路径问题，叫做单源点的最短路径问题。

在常用的单源点最短路径算法中，迪杰斯特拉算法是最为常用的一种，是一种按照路径长度递增的次序产生最短路径的算法。

在本题中，读入一个有向图的带权邻接矩阵（即数组表示），建立有向图并按照以上描述中的算法求出源点至每一个其它顶点的最短路径长度。

输入的第一行包含2个正整数n和s，表示图中共有n个顶点，且源点为s。其中n不超过50，s小于n。

以后的n行中每行有n个用空格隔开的整数。对于第i行的第j个整数，如果大于0，则表示第i个顶点有指向第j个顶点的有向边，且权值为对应的整数值；如果这个整数为0，则表示没有i指向j的有向边。当i和j相等的时候，保证对应的整数为0。

只有一行，共有n-1个整数，表示源点至其它每一个顶点的最短路径长度。如果不存在从源点至相应顶点的路径，输出-1。

请注意行尾输出换行。

4 1
0 3 0 1
0 0 4 0
2 0 0 0
0 0 1 0

6 4 7

  1. #include<iostream>
  2. #include<limits.h>
  3. #define INFINITY INT_MAX
  4. using namespace std;
  6. int FindMinDist(bool *collected,int *dist,int n)
  7. {
  8.     /* 返回未被收录顶点中dist最小者 */
  9.     int MinV;
  10.     int MinDist = INFINITY;
  11.  
  12.     for (int i=0; i<n; i++) {
  13.         if ( collected[i]==false && dist[i]<MinDist) 
  14.         {
  15.             /* 若i未被收录，且dist[i]更小 */
  16.             MinDist = dist[i]; /* 更新最小距离 */
  17.             MinV = i; /* 更新对应顶点 */
  18.         }
  19.     }
  20.     if (MinDist < INFINITY) /* 若找到最小dist */
  21.         return MinV; /* 返回对应的顶点下标 */
  22.     else return -1;  /* 若这样的顶点不存在，返回错误标记 */
  23. }
  25. void Dijkstra(int **Graph,int start,int *dist,bool *collected,int n,int *path)
  26. {
  27.     
  28.     for (int i=0; i<n; i++ ) 
  29.         {
  30.             dist[i] = Graph[start][i];
  31.             if(dist<INFINITY)
  32.                 path[i]=start;
  33.             else
  34.                 path[i]=-1;
  35.         }
  36.     
  37.     /* 先将起点收入集合 */
  38.     collected[start]= true;     //收录设为0
  39.  
  40.     while (1) 
  41.     {
  42.         int V = FindMinDist(collected, dist, n);
  43.         if(V==-1)
  44.         {
  45.             break;      /* 算法结束 */
  46.         }
  47.         collected[V] = true;  /* 收录V */
  48.         for(int j=0; j<n; j++ ) /* 对图中的每个顶点j */
  49.             if ( j!=V&& Graph[V][j]<INFINITY ) 
  50.             {
  51.                // if ( Graph[V][j]<0 ) /* 若有负边(但本题不涉及负边,所以不用) */
  52.                 //return ; /* 不能正确解决，返回 */
  53.                 /* 若收录V使得dist[j]变小 */
  54.                 if ( dist[V]+Graph[V][j] < dist[j] ) 
  55.                 {
  56.                     dist[j] = dist[V]+Graph[V][j]; /* 更新dist[j] */
  57.                     path[j]=V;/*更新路径*/
  58.                 }
  59.             }
  60.     } /* while结束*/
  61. }
  63. int main()
  64. {
  65.     int n,s;
  66.     cin >> n >> s;
  67.     int **Graph=new int*[n];
  68.     int *dist=new int[n];       //原点到v的最短路径
  69.     int *path=new int[n];
  70.     bool *collected=new bool[n];
  71.     for(int i=0;i<n;i++)
  72.     {
  73.         Graph[i]=new int[n];    //初始化图
  74.         for(int j=0;j<n;j++)
  75.         {
  76.             cin>>Graph[i][j];
  77.             if(Graph[i][j]==0)
  78.                 Graph[i][j]=INFINITY;    //不能到达或者是自己到自己就设为无线大
  79.         }
  80.         
  81.         collected[i]=false;    
  82.     }
  83.     Dijkstra(Graph,s,dist,collected,n,path);
  84.     for(int i=0;i<n;i++)    //输出源点至其它每一个顶点的最短路径长度
  85.     {
  86.         if(i==s)
  87.             continue;
  88.         if(dist[i]==INFINITY)
  89.             cout<<-1<<" ";
  90.         else
  91.             cout<<dist[i]<<" ";
  92.     }
  93.     cout<<endl;
  94.     return 0;
  95. }

 

 

 

版权声明：本文为buxingzhiwu原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/buxingzhiwu/p/11031364.html