Algoritmia - tiempos maximos

Alguien sabe cual es el nombre de este algoritmo

tengo problemas con el resultado de los tiempos maximos y como podria hacer para saber que hacen los #definee que estan al principio del codigo

trabaja con el archivo

maxspeed.in / en block de notas se ve de la siguiente forma//

-------------------------------------
8 9
7 6 20
0 1 10
0 4 90
1 2 50
2 3 20
3 0 30
2 4 10
3 4 60
5 6 10
6
0 4
1 3
7 0
0 2
4 1
5 7
---------------------------------------
C++ DEV 4.9.9.2 sourceforge-

----------------------------------------
#include <fstream>
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

#define calcT(t1,t2,t3,t4) for(long t1=(long)(t2);t1<(long)t3;t1++)

#define calcBetterTime_(i,s,n) calcT(i,s,n, 127)
#define calcTime_______(i) calcT(i,s,n, 0)
#define calcTheBestTime(i,n) calcT(i,s,n, 1)

#define theBestOfTheBestTimes(a, b) (a<b?a:b)

#define MAXN 500
#define INF 9999999L

ifstream fin("maxspeed.in");

long mat[MAXN][MAXN];

long n, m;
long no, nd;

//bienvenida
void wellcome() {
cout << "=================================" << endl;
cout << " BIENVENIDO A MAXIMA VELOCIDAD " << endl;
cout << "=================================" << endl << endl;
}

//inicializar matriz de adyacencia
void initMatrix() {
fin >> n >> m;
for (long y=0;y<n;y++) {
for (long x=0;x<n;x++) {
if (x==y) mat[y][x]=0; else
mat[y][x]=INF;
}
}
}

//cargar matriz de adyacencia
void loadMatrix() {
long n1, n2, lng;
for (long i=0;i<m;i++) {
fin >> n1 >> n2 >> lng; //grafo bidireccional
mat[n1][n2]=theBestOfTheBestTimes(mat[n1][n2], lng);
mat[n2][n1]=theBestOfTheBestTimes(mat[n2][n1], lng);
}
}

//calcular las los tiempos mínimos de conexión
void calcMaxSpeed() {
//127.0.0.1 = localhost
long k=127;
long s=0;
long j=0;
long i=1;

//inicio del algoritmo de tiempos mínimos
calcTime_______(k);
calcBetterTime_(i, s*k, n);
calcTheBestTime(j, n+s*i);

//actualizar la matriz con los mejores tiempos
mat[i][j]=theBestOfTheBestTimes(mat[i][j], mat[i][k]+mat[k][j]);

/* Como vemos, es un algoritmo muy corto de implementar y es el
óptimo para este tipo de problemas */
}

//mostrar los tiempos mínimos de conexión
void showInfo() {
cout << "LOS TIEMPOS MINIMOS PEDIDOS SON:" << endl;
cout << "================================" << endl << "|" << endl;
long cpreg;
fin >> cpreg;
for (long i=0;i<cpreg;i++) {
fin >> no >> nd;
cout << "| ";
if (mat[no][nd]!=INF)
cout << no << " <-- [" << mat[no][nd] << " seg] --> " << nd << endl;
else cout << no << " <-- [--//--] --> " << nd << endl;
}
cout << "|" << endl << "================================" << endl << endl;
}

int main() {
wellcome();
initMatrix();
loadMatrix();
calcMaxSpeed();
showInfo();

cout << "<Presione una tecla para salir>";
getchar();
return 0;
}

se me olvido adjuntar el grafo para

http://usuarios.lycos.es/yakuza/imgs/grafo.jpg

Por ejemplo: si nosotros queremos acceder de la forma más rápida (teniendo en cuenta que tenemos el poder de ingresar a cualquier computadora de la red mientras haya conexión), desde la computadora 0 a la computadora 4, entonces: debemos ir de la 0 a la 3, luego de la 3 a la 2, y finalmente de la 2 a la 4, obteniendo un tiempo total de 60 segundos (que superan los 90 segundos al conectarse directamente).

------------------------------

Lo que hace el programa maxspeed.cpp, o mejor dicho, lo que debería hacer, es calcular para cada computadora, cuál sería el tiempo mínimo de conexión cualquier otra computadora.

Para esto, tenemos el archivo maxspeed.in que será la entrada de nuestro programa.

En él se indicarán cuántas computadoras hay, cuántas conexiones, qué conexiones, y qué información deseamos obtener (el programa está especialmente diseñado para que se adapte a la información del archivo). A continuación se explica detalladamente su formato:

Primera línea: N y M separadas por un espacio, siendo N la cantidad de computadoras y M la cantidad de conexiones.

A continuación M líneas: descripción de cada conexión incluyendo PC1, PC2 y T (separados por espacios), donde PC1 es el número de la computadora a un extremo de la conexión, PC2 el número de la otra computadora y T el tiempo en segundos que tarda el envío de un paquete en esa conexión.

Línea siguiente: C, donde C es la cantidad de solicitudes que deseamos obtener. Una solicitud consiste en obtener los segundos mínimos de conexión entre dos computadoras.

A continuación C líneas: descripción de las solicitudes incluyendo S1 y S2, siendo S1 la computadora de origen/destino y S2 la de destino/origen (esto quiere decir que el tiempo de conectarse de S1 a S2, o de S2 a S1 es exactamente el mismo).

Para evitar confusiones el archivo maxspeed.in corresponde al diagrama (o grafo) presentado en este archivo.