El algoritmo de Floyd, también conocido como método de interpolación, es un algoritmo que utiliza la idea de la programación dinámica para encontrar la ruta más corta entre múltiples puntos de origen en un gráfico ponderado dado .
Este artículo presenta una implementación en C ++ del algoritmo Floyd. Este algoritmo admite la entrada dinámica de puntos y bordes y proporciona descripciones de la interfaz.
1 estructura de datos
- La estructura de almacenamiento de un gráfico no dirigido utiliza una matriz de adyacencia.
- El peso de cada borde es la distancia entre dos puntos en este borde.
int ** d = NULL; // Matriz bidimensional, que almacena la suma de los pesos de la ruta más corta de cualquiera de los dos puntos
int ** path = NULL; // Matriz bidimensional, almacena la ruta más corta entre dos puntos
int matrixSize = 0; // El número de vértices en la figura
int arcSize = 0; // El número de aristas en la figura
int isDigraph = 0; // El tipo de gráfico, ya sea un gráfico dirigido o un gráfico no dirigido
2 Definición de interfaz
Defina la siguiente interfaz:
/ * Inicializar la estructura de almacenamiento
vertexNum: el número de vértices
arcNum: número de aristas * /
bool init (int vertexNum, int arcNum)
/ * Agregar un borde
inicio: el punto de partida del borde
final: el final del borde
peso: peso del borde * /
bool addArc (int start, int end, int weight, bool isDigraph = false)
/ * Calcular la ruta más corta entre todos los vértices * /
bool CalculatePath ()
/ * Volver al camino más corto entre dos puntos
inicio: el punto de partida de la ruta
final: el final del camino * /
bool getShortestPath (int inicio, int final)
3 implementación del código fuente
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#define MAX 10000000
int ** d = NULL;
int ** ruta = NULL;
int matrixSize = 0;
int arcSize = 0;
int isDigraph = 0;
bool init (int vertexNum, int arcNum)
{
matrixSize = vertexNum;
arcSize = arcNum;
d = (int **) malloc (vertexNum * sizeof (int *));
memset (d, 0, vertexNum * sizeof (int *));
para (int i = 0; i <vertexNum; i ++)
{
d [i] = (int *) malloc (vertexNum * sizeof (int));
memset (d [i], 0, vertexNum * sizeof (int));
para (int j = 0; j <vertexNum; j ++)
{
d [i] [j] = MAX;
}
}
ruta = (int **) malloc (vertexNum * sizeof (int *));
memset (ruta, 0, vertexNum * sizeof (int *));
para (int i = 0; i <vertexNum; i ++)
{
ruta [i] = (int *) malloc (vertexNum * sizeof (int));
memset (ruta [i], 0, vertexNum * sizeof (int));
para (int j = 0; j <vertexNum; j ++)
{
ruta [i] [j] = -1;
}
}
volver verdadero;
}
bool addArc (int start, int end, int weight, bool isDigraph = false)
{
if (! isDigraph)
{
d [start] [end] = weight;
d [fin] [inicio] = peso;
ruta [inicio] [fin] = fin;
ruta [final] [inicio] = inicio;
}
else
{
d [inicio] [fin] = peso;
ruta [inicio] [fin] = fin;
}
}
bool CalculatePath ()
{
for (int k = 0; k <matrixSize; k ++)
for (int i = 0; i <matrixSize; i ++)
for (int j = 0; j <matrixSize; j ++) {
if (d [i ] [k] + d [k] [j] <d [i] [j]) {
d [i] [j] = d [i] [k] + d [k] [j];
ruta [i] [j] = ruta [i] [k];
}
}
volver verdadero;
}
bool getShortestPath (int start, int end)
{
if ((start! = end) && (d [start] [end] <MAX))
{
printf ("% d ->% d:% d", start, end , d [inicio] [fin]);
printf ("ruta:");
int f = inicio;
int en = fin;
while (f! = en)
{
printf ("% d ->", f);
f = ruta [f] [en];
}
printf ("% d \ n", en);
volver verdadero;
}
else if ((start! = end) && (d [start] [end]> = MAX))
{
printf ("% d ->% d: NO PATH \ n", start, end);
falso retorno;
}
falso retorno;
}
int main ()
{
int i, j, m, n;
int x, y, z;
printf ("input vertexNum arcNum isDigraph: \ n");
scanf ("% d% d% d", & n, & m, & isDigraph);
init (n, m);
for (i = 0; i <m; i ++) {
printf ("arco de entrada con startPoint endPoint weitht: \ n");
scanf ("% d% d% d", & x, & y, & z);
addArc (x, y, z, isDigraph);
}
CalculatePath ();
printf ("Listar todas las distancias y rutas más cortas: \ n");
for (i = 0; i <n; i ++)
{
for (j = 0; j <n; j ++)
{
getShortestPath (i, j);
}
}
devuelve 0;
}
