O algoritmo de Floyd, também conhecido como método de interpolação, é um algoritmo que usa a idéia de programação dinâmica para encontrar o caminho mais curto entre vários pontos de origem em um determinado gráfico ponderado .
Este artigo apresenta uma implementação em C ++ do algoritmo Floyd. Este algoritmo suporta entrada dinâmica de pontos e arestas e fornece descrições de interface
1 estrutura de dados
- A estrutura de armazenamento de um gráfico não direcionado usa uma matriz de adjacência.
- O peso de cada aresta é a distância entre dois pontos nessa aresta.
int ** d = NULL; // Matriz bidimensional, armazenando a soma dos pesos do caminho mais curto de dois pontos
int ** path = NULL; // array bidimensional, armazena o caminho mais curto entre dois pontos
int matrixSize = 0; // O número de vértices na figura
int arcSize = 0; // O número de arestas na figura
int isDigraph = 0; // O tipo de gráfico, seja um gráfico direcionado ou um gráfico não direcionado
2 Definição da interface
Defina a seguinte interface:
/ * Inicialize a estrutura de armazenamento
vertexNum: o número de vértices
arcNum: número de arestas * /
bool init (int vertexNum, int arcNum)
/ * Adicione uma aresta
start: o ponto inicial da aresta
fim: o fim da borda
peso: peso da aresta * /
bool addArc (int início, int final, peso int, bool isDigraph = false)
/ * Calcule o caminho mais curto entre todos os vértices * /
bool CalculatePath ()
/ * Retorne ao caminho mais curto entre dois pontos
start: o ponto de partida do caminho
end: o fim do caminho * /
bool getShortestPath (int start, int end)
Implementação de código-fonte 3
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#define MAX 10000000
int ** d = NULL;
int ** caminho = 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 *));
for (int i = 0; i <vertexNum; i ++)
{
d [i] = (int *) malloc (vertexNum * sizeof (int));
memset (d [i], 0, vertexNum * sizeof (int));
for (int j = 0; j <vertexNum; j ++)
{
d [i] [j] = MAX;
}
}
caminho = (int **) malloc (vertexNum * sizeof (int *));
memset (caminho, 0, vertexNum * sizeof (int *));
for (int i = 0; i <vertexNum; i ++)
{
caminho [i] = (int *) malloc (vertexNum * sizeof (int));
memset (caminho [i], 0, vertexNum * sizeof (int));
for (int j = 0; j <vertexNum; j ++)
{
caminho [i] [j] = -1;
}
}
return true;
}
bool addArc (int início, int final, int peso, bool isDigraph = false)
{
if (! isDigraph)
{
d [start] [end] = weight;
d [fim] [início] = peso;
caminho [início] [fim] = fim;
caminho [final] [início] = início;
}
else
{
d [início] [final] = peso;
caminho [início] [fim] = fim;
}
}
bool CalculatePath ()
{
para (int k = 0; k <tamanho da matriz; k ++)
para (int i = 0; i <tamanho da matriz; i ++)
para (int j = 0; j <tamanho da matriz; j ++) {
if (d [i ] [k] + d [k] [j] <d [i] [j]) {
d [i] [j] = d [i] [k] + d [k] [j];
caminho [i] [j] = caminho [i] [k];
}
}
return true;
}
bool getShortestPath (int início, int final)
{
if ((início! = final) && (d [início] [final] <MAX))
{
printf ("% d ->% d:% d", início, fim , d [início] [fim]);
printf ("caminho:");
int f = início;
int en = fim;
while (f! = pt)
{
printf ("% d ->", f);
f = caminho [f] [en];
}
printf ("% d \ n", en);
return true;
}
else if ((início! = final) && (d [início] [final]> = MAX))
{
printf ("% d ->% d: SEM CAMINHO \ n", início, fim);
retorna falso;
}
retorna falso;
}
int main ()
{
int i, j, m, n;
int x, y, z;
printf ("entrada vertexNum arcNum isDigraph: \ n");
scanf ("% d% d% d", & n, & m, & isDigraph);
init (n, m);
for (i = 0; i <m; i ++) {
printf ("arco de entrada com o startPoint endPoint weitht: \ n");
scanf ("% d% d% d", & x, & y, & z);
addArc (x, y, z, isDigraph);
}
CalculePath ();
printf ("Liste todas as distâncias e caminhos mais curtos: \ n");
for (i = 0; i <n; i ++)
{
for (j = 0; j <n; j ++)
{
getShortestPath (i, j);
}
}
retornar 0;
}
