实用算法实现-第 20 篇单源最短路径

20.1 Dijktra算法

Dijktra算法适用于有向图上带权的单源最短路径，但是要求所有边的权值非负。所以它一方面比Ford性能好，一方面又没有Ford算法的通用性。

对比Dijktra算法和Prim算法，可以发现两者的相似之处。

20.1.1 实例

PKU JudgeOnline, 3268, Silver Cow Party.

20.1.2 问题描述

一只母牛从N块田中的任一块(1≤N≤1000)去参加盛大的母牛聚会，这个聚会被安排在X号田(1≤X ≤N)。一共有M(1 ≤ M ≤ 100,000)条单行道分别连接着两块田，且通过路i需要花Ti(1≤Ti≤100)的时间。

每头母牛必需参加宴会并且在宴会结束时回到自己的领地，但是每头牛都很懒而喜欢选择化是最少的一个方案。来时的路和去时的可能不一样。

求每头牛要来回的最短时间。

20.1.3 输入

第一行：三个用空格分开的整数:N,M和X

第2到第M+1行:第i+1描述路i，通过三个用空格分开的整数: Ai, Bi和Ti. 是对于从Ai号田到 Bi号田的描述,需要Ti的时间.

20.1.4 输出

第一行:一个整数:对于每头牛所必须花费的时间.（在这段时间内，每头牛可以来回）

20.1.5 分析

母牛要到X农场去，可以看做从N农场回来的逆过程，不过这个逆过程要考虑好路径的方向问题，因为这里的路径是有方向的。而从X农场回来只要再次执行Dijktra算法就能完成了。

20.1.6 程序

#include <stdio.h>

#include <iostream.h>

#include <string.h>

#define MAX_NUM        1002

int route[MAX_NUM][MAX_NUM];

int N, M, X;

int d[MAX_NUM];

int d1[MAX_NUM];

bool visited[MAX_NUM];

#define MAX   0x7F7F7F7F

void Dijktra(int s, bool back)

{

     int i, j;

     int minU;

     int U;

     memset(d, 0x7F, sizeof(d));

     memset(visited, 0, sizeof(visited));

     d[s] = 0;

     while(1){

         minU= MAX;

         for(i = 1; i <= N; i++){

              if(visited[i] == false && minU > d[i]){

                   minU = d[i];

                   U = i;

              }

         }

         if(minU == MAX)

              break;

         visited[U] = true;

         for(j = 1; j <= N; j++){

              int distance;

              if(back == true){

                   distance = route[U][j];

              }else{

                   distance = route[j][U];

              }

              if(distance == MAX){

                   continue;

              }

              if(d[j] > distance + d[U]){

                   d[j] = distance + d[U];

              }

         }

     }

}

int main()

{

 

     int i;

     int from, to;

     int dis;

     int max;

     memset(route, 0x7F, sizeof(route));

     cin >> N >> M >> X;

     for(i = 0; i < M; i++){

         cin >> from >> to >> dis;

         if(route[from][to] > dis)

         {

              route[from][to] = dis;

         }

     }

     Dijktra(X, false);

     memcpy(d1, d, sizeof(d));

     Dijktra(X, true);

     max = 0;

     for(i = 1; i <= N; i++){

         if(max < d[i] + d1[i]){

              max = d[i] + d1[i];

         }

     }

     cout << max << endl;

     return 1;

}