Artigo Diretório
O algoritmo de Dijkstra nos permite encontrar o caminho mais curto entre quaisquer dois vértices do gráfico.
É diferente da árvore de abrangência mínima porque a distância mais curta entre dois vértices pode não incluir todos os vértices do gráfico.
Como funciona o algoritmo de Dijkstra
O princípio de funcionamento do algoritmo de Dijkstra é que um certo subcaminho B -> D do caminho mais curto A -> D entre os vértices A e D é também o caminho mais curto entre os vértices B e D.
Djikstra usa essa propriedade ao contrário, ou seja, superestimamos a distância de cada vértice ao vértice inicial. Em seguida, visitamos cada nó e seus vizinhos e encontramos o caminho secundário mais curto para esses vizinhos.
O algoritmo utiliza um método guloso, ou seja, buscamos a melhor solução, esperando que o resultado final seja a melhor solução para todo o problema.
Exemplo de algoritmo de Dijkstra
É mais fácil começar com um exemplo e depois considerar o algoritmo.
Comece com um gráfico ponderado.
Escolha um vértice inicial e atribua o valor do caminho infinito a todos os outros nós.
Atualize o comprimento do caminho de cada vértice.
Se o comprimento do caminho do vértice adjacente for menor que o comprimento do novo caminho, ele não será atualizado.
Evite atualizar o comprimento do caminho dos vértices visitados.
Após cada iteração, selecionamos o vértice não visitado com o menor comprimento de caminho. Portanto, escolhemos 5 antes de 7.
Observe como o comprimento do caminho do vértice mais à direita é atualizado duas vezes.
Repita até que todos os vértices tenham sido visitados.
Pseudocódigo do algoritmo Djikstra
Precisamos manter a distância do caminho de cada vértice. Podemos armazená-lo em um array de tamanho v, onde v é o número de vértices.
Também esperamos obter o caminho mais curto, não apenas saber a extensão do caminho mais curto. Para fazer isso, mapeamos cada vértice para o vértice cujo comprimento do caminho foi atualizado pela última vez.
Depois que o algoritmo terminar, podemos retroceder do vértice de destino ao vértice de origem para encontrar o caminho.
A menor fila de prioridade pode receber efetivamente o vértice com a menor distância de caminho.
function dijkstra(G, S)
for each vertex V in G
distance[V] <- infinite
previous[V] <- NULL
If V != S, add V to Priority Queue Q
distance[S] <- 0
while Q IS NOT EMPTY
U <- Extract MIN from Q
for each unvisited neighbour V of U
tempDistance <- distance[U] + edge_weight(U, V)
if tempDistance < distance[V]
distance[V] <- tempDistance
previous[V] <- U
return distance[], previous[]
Código do algoritmo Dijkstra
// Dijkstra's Algorithm in C
#include <stdio.h>
#define INFINITY 9999
#define MAX 10
void Dijkstra(int Graph[MAX][MAX], int n, int start);
void Dijkstra(int Graph[MAX][MAX], int n, int start) {
int cost[MAX][MAX], distance[MAX], pred[MAX];
int visited[MAX], count, mindistance, nextnode, i, j;
// Creating cost matrix
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (Graph[i][j] == 0)
cost[i][j] = INFINITY;
else
cost[i][j] = Graph[i][j];
for (i = 0; i < n; i++) {
distance[i] = cost[start][i];
pred[i] = start;
visited[i] = 0;
}
distance[start] = 0;
visited[start] = 1;
count = 1;
while (count < n - 1) {
mindistance = INFINITY;
for (i = 0; i < n; i++)
if (distance[i] < mindistance && !visited[i]) {
mindistance = distance[i];
nextnode = i;
}
visited[nextnode] = 1;
for (i = 0; i < n; i++)
if (!visited[i])
if (mindistance + cost[nextnode][i] < distance[i]) {
distance[i] = mindistance + cost[nextnode][i];
pred[i] = nextnode;
}
count++;
}
// Printing the distance
for (i = 0; i < n; i++)
if (i != start) {
printf("\nDistance from source to %d: %d", i, distance[i]);
}
}
int main() {
int Graph[MAX][MAX], i, j, n, u;
n = 7;
Graph[0][0] = 0;
Graph[0][1] = 0;
Graph[0][2] = 1;
Graph[0][3] = 2;
Graph[0][4] = 0;
Graph[0][5] = 0;
Graph[0][6] = 0;
Graph[1][0] = 0;
Graph[1][1] = 0;
Graph[1][2] = 2;
Graph[1][3] = 0;
Graph[1][4] = 0;
Graph[1][5] = 3;
Graph[1][6] = 0;
Graph[2][0] = 1;
Graph[2][1] = 2;
Graph[2][2] = 0;
Graph[2][3] = 1;
Graph[2][4] = 3;
Graph[2][5] = 0;
Graph[2][6] = 0;
Graph[3][0] = 2;
Graph[3][1] = 0;
Graph[3][2] = 1;
Graph[3][3] = 0;
Graph[3][4] = 0;
Graph[3][5] = 0;
Graph[3][6] = 1;
Graph[4][0] = 0;
Graph[4][1] = 0;
Graph[4][2] = 3;
Graph[4][3] = 0;
Graph[4][4] = 0;
Graph[4][5] = 2;
Graph[4][6] = 0;
Graph[5][0] = 0;
Graph[5][1] = 3;
Graph[5][2] = 0;
Graph[5][3] = 0;
Graph[5][4] = 2;
Graph[5][5] = 0;
Graph[5][6] = 1;
Graph[6][0] = 0;
Graph[6][1] = 0;
Graph[6][2] = 0;
Graph[6][3] = 1;
Graph[6][4] = 0;
Graph[6][5] = 1;
Graph[6][6] = 0;
u = 0;
Dijkstra(Graph, n, u);
return 0;
}
A complexidade do algoritmo de Dijkstra
Complexidade de tempo: O (E Log V)
onde E é o número de arestas e V é o número de vértices.
Complexidade do espaço: O (V)
Aplicação do algoritmo de Dijkstra
- Encontre o caminho mais curto
- Aplicação nas redes sociais
- Na rede telefônica
- Encontre a localização no mapa
Documentos de referência
[1] Parewa Labs Unip. Algoritmo de Ltd.Dijkstra [EB / OL] .https: //www.programiz.com/dsa/dijkstra-algorithm,2020-01-01.