Comprender el algoritmo de Dijkstra

    El algoritmo de Dijkstra nos permite encontrar el camino más corto entre dos vértices del gráfico.
    Es diferente del árbol de expansión mínimo porque la distancia más corta entre dos vértices puede no incluir todos los vértices del gráfico.

Cómo funciona el algoritmo de Dijkstra

    El principio de funcionamiento del algoritmo de Dijkstra es que una cierta subruta B -> D de la ruta más corta A -> D entre los vértices A y D es también la ruta más corta entre los vértices B y D.

    Djikstra usa esta propiedad a la inversa, es decir, sobrestimamos la distancia desde cada vértice al vértice inicial. Luego visitamos cada nodo y sus vecinos y buscamos la ruta secundaria más corta a estos vecinos.
    El algoritmo utiliza un método codicioso, es decir, buscamos la mejor solución, esperando que el resultado final sea la mejor solución para todo el problema.

Ejemplo del algoritmo de Dijkstra

    Es más fácil comenzar con un ejemplo y luego considerar el algoritmo.

    Comience con un gráfico ponderado.

    Elija un vértice inicial y asigne el valor de la ruta infinita a todos los demás nodos.

    Actualiza la longitud de la ruta de cada vértice.

    Si la longitud de la ruta del vértice adyacente es menor que la longitud de la nueva ruta, no se actualiza.

    Evite actualizar la longitud de la ruta de los vértices visitados.

    Después de cada iteración, seleccionamos el vértice no visitado con la menor longitud de ruta. Entonces elegimos 5 antes que 7.

    Observe cómo la longitud de la ruta del vértice más a la derecha se actualiza dos veces.

    Repita hasta que se hayan visitado todos los vértices.

Pseudocódigo del algoritmo Djikstra

    Necesitamos mantener la distancia del camino de cada vértice. Podemos almacenarlo en una matriz de tamaño v, donde v es el número de vértices.
    También esperamos conseguir el camino más corto, no solo conocer la longitud del camino más corto. Para hacer esto, asignamos cada vértice al vértice cuya longitud de ruta se actualizó por última vez.
    Una vez finalizado el algoritmo, podemos retroceder desde el vértice de destino al vértice de origen para encontrar la ruta.
    La cola de prioridad más pequeña puede recibir eficazmente el vértice con la distancia de ruta más pequeña.

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 del algoritmo de 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;
}

La complejidad del algoritmo de Dijkstra

    Complejidad de tiempo: O (E Log V)
    donde E es el número de aristas y V es el número de vértices.
    Complejidad espacial: O (V)

Aplicación del algoritmo de Dijkstra

• Encuentra el camino más corto
• Aplicación en redes sociales
• En la red telefónica
• Encontrar ubicación en el mapa

Documentos de referencia

[1] Parewa Labs Pvt. Ltd. Algoritmo de Dijkstra [EB / OL] .https: //www.programiz.com/dsa/dijkstra-algorithm,2020-01-01.