图论及其应用——图的最短路径问题

  基于前文对图和树的简单讨论,我们在这篇文章中将介绍有关图的最短路径的问题。
  最短路径的原始模型非常简单,给出一个图G(V、E),其中边元素e都带有权值,寻找vi和vj之间的一条路径,是的该路径上边的权值之和最小。
  基于这个最简单的模型,最短路径问题细分还会有好多种类,比如图G是否有向?权值是否有负值?比如是单源头最短路还是多源头?
  在这里,我们先讨论利用Dijkstra算法实现的单源无负权值无向图的最短路问题。
  考察无向图G,点集的元素个数是n,我们利用二维数组map[i][j]记录无向图中边vivj的权值,如果vi与vj不连通,那么map[i][j]无限大。单源是s,并设置dis[j]记录单源s到j的最短路径(也就是最小的权值之和)。
  我们考察s点到vj的最短路径,假设是是s到vj的最短路径,那么用反证法很容易证明,是s到vj-1的最短路径,那么对于s到vj的最短路径的求解,我们可以看成这样一个过程,在与vj直接相连的点vm、vn、vp中(这里假设与vj直接相连的只有这三个点),那么我们只需比较dis[m] + map[m][j] 、 dis[n] + map[n][j]、dis[p] + map[p][j]中的最小值,即是s到vj的最短路径。如果我们用动态规划的思想去解读这个过程,会得到这样一个状态转移方程:
  dis[j] = min(dis[m] + map[m][j] , dis[n] + map[n][j],dis[p] + map[p][j] , ……),其中vm、vn、vp……表示点集V中和vj直接相连的点。
  那么基于这种递推关系,我们就很容易考虑如何用程序化的算法来实现最小路径的求解了,可以看到,s到vj的最短路径是要基于较短的最短路径,因此我们需要从较短的最短路径开始构造。
  首先我们从与源头s直接相连的点集v1开始,找到一条边,并标记顶点v1下次不再访问,使得的权值最小,这便是s到v1所有边数为1的路径中的最短路径,那么基于这最短路径,便可以逐层的往上构造边数更长的最短路径。
  Dijkstra算法基于无负权的图,因此从源头s到与其直接相连的点的最短路径是不会存在中转点的。
  由于我们我每次从源头s开始构造最短路径,至少会完成一个点的最短路径的构造,那么对于含有n个元素的点集,显然我们需要构造n-1次,才可以确保找到源头s到G中每一个点的最短路径都记录在dis[]当中,那么如果想访问s到vj的最短路径的最小权值,只需输出dis[j]即可。
  我们通过一个题目来进一步体会一下Dijkstra算法的实现。(Problem source : hdu 2066)
  

Problem Description
虽然草儿是个路痴(就是在杭电待了一年多,居然还会在校园里迷路的人,汗~),但是草儿仍然很喜欢旅行,因为在旅途中 会遇见很多人(白马王子,^0^),很多事,还能丰富自己的阅历,还可以看美丽的风景……草儿想去很多地方,她想要去东京铁塔看夜景,去威尼斯看电影,去阳明山上看海芋,去纽约纯粹看雪景,去巴黎喝咖啡写信,去北京探望孟姜女……眼看寒假就快到了,这么一大段时间,可不能浪费啊,一定要给自己好好的放个假,可是也不能荒废了训练啊,所以草儿决定在要在最短的时间去一个自己想去的地方!因为草儿的家在一个小镇上,没有火车经过,所以她只能去邻近的城市坐火车(好可怜啊~)。
 
Input
输入数据有多组,每组的第一行是三个整数T,S和D,表示有T条路,和草儿家相邻的城市的有S个,草儿想去的地方有D个; 接着有T行,每行有三个整数a,b,time,表示a,b城市之间的车程是time小时;(1=<(a,b)<=1000;a,b 之间可能有多条路) 接着的第T+1行有S个数,表示和草儿家相连的城市; 接着的第T+2行有D个数,表示草儿想去地方。
 
Output
输出草儿能去某个喜欢的城市的最短时间。


  数理分析:基于单源最短路径问题的模型,这里其实是给出了多个单源(和小草相连的城市,由于题目没给相关数据,显然这里认为小草的家到源头是不花时间的),也就是需要进行多次Dijkstra算法,然后维护一个最小值即可。
  基于对Dijkstra算法思想的理解,不难进行编程实现。
  参考代码如下。

 

#include
#include
#include<string.h>
#include
using namespace std;
#define MAX 0x3f3f3f3f

int road , link  ,want , total;
int Map[1010][1010] , linkarr[1010] , wantarr[1010] , dis[1010];
bool visit[1010];

void Dijkstra(int start)
{
     int temp , k;
     memset(visit , 0 , sizeof(visit));
     for(int i = 1;i <= total;++i)
          dis[i] = Map[start][i];
     dis[start] = 0;
     visit[start] = 1;
     for(int i = 1;i <= total;++i)
     {
         temp = MAX;
         for(int j = 1;j <= total;++j)
               if(!visit[j] && temp > dis[j])
                   temp = dis[k = j];
         visit[k] = 1;
         for(int j = 1;j <= total;++j)
               if(!visit[j] && dis[j] > dis[k] + Map[k][j])
                   dis[j] = dis[k] + Map[k][j];
     }
}

int main()
{
    int x , y , cost , minn , answer;
    while(scanf("%d%d%d",&road,&link,&want) != EOF)
    {
         total = 0;
         memset(Map , MAX ,sizeof(Map));
           for(int i = 1;i <= road;++i)
           {
                scanf("%d%d%d",&x,&y,&cost);
                if(cost < Map[x][y])  //这里是个小坑,在记录图的信息的时候,会出现平行边,直接记录较小的边即可
                      Map[x][y] = Map[y][x] = cost;
                total = max(total , max(x , y));
           }

           for(int i = 1;i <= link;++i)
               scanf("%d",&linkarr[i]);
           for(int i = 1;i <= want;++i)
               scanf("%d",&wantarr[i]);

           answer = MAX;
           for(int i = 1;i <= link;++i) //遍历与小草家相连的城市并以其为起点进行Dijkstra算法
           {
               Dijkstra(linkarr[i]);
               minn = MAX;
               for(int j = 1;j <= want;++j)
                   if(dis[wantarr[j]] < minn)
                        minn = dis[wantarr[j]];
               if(answer > minn)
                  answer = minn;
           }
           printf("%d\n",answer);
    }
}

 

 

    我们曾提到,解决图中最短路径的几个经典算法Dijkstra、SPFA等算法,适用于解决单源最短路径的问题,那么对于一个图G,我们想知道任意两点vi到vj的最短路径,该如何求解呢?
  下面我们就来介绍求解每对顶点间的最短距离的Floyd算法。
  我们容易看到,对着求解任意两点之间的最短距离,我们肯定是要基于穷举算法来遍历到所有的情况。显然我们需要两层循环来遍历起始点i和终止点j,我们再设置一个中间点k,表示vi到vj的路径中会经过vk。
  我们反身来看待这个问题,需要得到所有情况,需要找到最优解,容易看到,这正是动态规划能够解决的问题,因此我们很自然的联想到利用动态规划的思想来解决这一模型。
  我们设置二维数组dp[i][j]来表示vi到vj的最短路径,我们容易得到如下的状态转移方程:
      dp[i][j] = min(dp[i][j],dp[i][k] + dp[k][j]),其中k要遍历vi、vj路径上的所有点。
  通过这样一个状态转移方程,我们就能够遍历出所有的情况并且找到每种情况的最优解了。
  我们根据一个具体的题目来编程实现一下Floyd算法。(Problem source : hdu 1596)
  

Problem Description
XX星球有很多城市,每个城市之间有一条或多条飞行通道,但是并不是所有的路都是很安全的,每一条路有一个安全系数s,s是在 0 和 1 间的实数(包括0,1),一条从u 到 v 的通道P 的安全度为Safe(P) = s(e1)*s(e2)…*s(ek) e1,e2,ek是P 上的边 ,现在8600 想出去旅游,面对这这么多的路,他想找一条最安全的路。但是8600 的数学不好,想请你帮忙 ^_^
 
Input
输入包括多个测试实例,每个实例包括: 第一行:n。n表示城市的个数n<=1000; 接着是一个n*n的矩阵表示两个城市之间的安全系数,(0可以理解为那两个城市之间没有直接的通道) 接着是Q个8600要旅游的路线,每行有两个数字,表示8600所在的城市和要去的城市
 
Output
如果86无法达到他的目的地,输出"What a pity!", 其他的输出这两个城市之间的最安全道路的安全系数,保留三位小数。


  数理分析:其实这个题目是在上文我们引入Floyd算法的模型的基础上稍作了改动,比如说在这个问题中并不是求解最短路径而是最长路径,而且这个这个“长”代表路径中边的权值的乘积,可以看到,思路是完全一样的,只不过是在状态转移方程上稍作修饰即可。
  即dp[i][j] = max(dp[i][j] , dp[i][k]*dp[k][j]).
  参考代码如下。

 

#include
#include
#include
using namespace std;

const int maxn = 1005;

int n;
double Map[maxn][maxn];
double s[maxn][maxn];

void F_W()
{

      for(int k = 1 ;k <= n;k++)
          for(int i = 1;i <= n;i++)
               for(int j = 1;j <= n ;j++)
                    s[i][j] = max(s[i][j] , s[i][k]*s[k][j]);
}

int main()
{
        while(scanf("%d",&n) != EOF)
        {
               int i , j;
               for(i = 1;i <= n;i++)
                   for(j = 1;j <= n;j++)
               {
                     scanf("%lf",&Map[i][j]);
                     s[i][j] = Map[i][j];
               }
               F_W();
               int num;
               scanf("%d",&num);
               int S , E;
               while(num--)
               {
                    scanf("%d%d",&S,&E);
                if(s[S][E] > 0)
                    printf("%.3lf\n",s[S][E]);
                else
                     printf("What a pity!\n");
               }
        }
}

 


 
   


 
 
 

转载于:https://www.cnblogs.com/rhythmic/p/5340403.html

你可能感兴趣的:(图论及其应用——图的最短路径问题)