Comprender Dijkstra (algoritmo de Dijkstra) y la implementación del código JS del algoritmo de ruta más corta

1. Ilustración de ejemplo

ejemplo uno

Hay cuatro puntos ABCD en la siguiente figura, encuentre el camino más corto de A a cada punto:

Primero prepare un registro (registro finalmente), que es el camino más corto desde el final A hasta cada punto, inicialmente vacío
A es el punto de partida y puede llegar directamente a B, C y D desde A. La ruta de A a B es 2, la ruta a C es 5 y la ruta a D es 3. "Registro 1" es como sigue:

A → B: 2
A → C: 5
A → D: 3

Mueva la ruta más corta A→B: 2 a "grabar finalmente", luego "grabar finalmente" es A→B: 2

El punto B puede ir a C: B→C: 4, de A a C puede optar por transferir desde B: En este momento A→C: 2+4=6, 6>5, por lo que el "registro 1" no se actualiza ( suponiendo B→ C: 2, en este momento A→C: 2+2=4, 4<5, luego actualice el "registro 1": A→C: 4 )
El punto D puede ir a C: D→C: 3, de A a C, puede elegir transferir desde D: En este momento, A→C: 3+3=6, 6>5, por lo que "registro 1" es no actualizado
No hay ningún punto alcanzable en el punto C, finalice el cálculo
Combinar "Registro 1" en "Registro finalmente"
Finalmente, se obtiene el camino más corto de A a cada punto: A→B: 2, A→C: 5, A→D: 3 ( si la suposición es cierta, el "registro final" es A→B: 2, A →C: 4. A → D: 3)

ejemplo dos

Como se muestra en la siguiente figura, encuentre el camino más corto desde A hasta cada punto:

Los registros de la instancia uno finalmente se registran como un conjunto S, y el S inicial solo contiene el punto de partida. Registre otros puntos excepto el punto de inicio en el conjunto U, los nodos adyacentes pueden registrar el valor de la ruta y los nodos no adyacentes se registran como ∞. Entonces la siguiente figura se representa como:

S={ A(0) }，U={ B(4), C(2), D(3), E(∞), F(∞), G(∞), H(∞), I(∞ ) }

primer paso:

S={ A(0) }
U={ segundo(4), C(2) , re(3), mi(∞), F(∞), sol(∞), H(∞), yo(∞) }

Paso 2: La ruta C es la más corta en el paso anterior, que es 2

S={ A(0), C(2) }
U={ segundo(4), re(3) , mi(2+3=5), F(2+2=4), sol(∞), H(∞), yo(∞) }

El tercer paso: el camino D es el más corto en el paso anterior, que es 3

S={UN(0), C(2), D(3) }
U={ B(4) , E(5), F(4) , G(∞), H(∞), I(3+5=8) }

Paso 4: En el paso anterior, los caminos B y F son los más cortos, que es 4

S={ A(0), C(2), D(3), B(4) }
U={ E(5), F(4) , G(4+5=9), H(∞), I(8) }

Paso 5: La ruta F en el paso anterior es la más corta, que es 4

S={ A(0), C(2), D(3), B(4), F(4) }
U={ E(5) , G(9), H(4+2=6), I(8) }

Paso 6: El camino E en el paso anterior es el más corto, que es 5

S={ A(0), C(2), D(3), B(4), F(4), E(5) }
U={G(5+3=8), H(6) , I(8) }

Paso 7: La ruta H en el paso anterior es la más corta, que es 6

S={ A(0), C(2), D(3), B(4), F(4), E(5), H(6 ) }
U={ G(6+1=7) , I(8) }

Paso 8: El camino G en el paso anterior es el más corto, que es 7

S={ A(0), C(2), D(3), B(4), F(4), E(5), H(6), G(7 ) }
U={ yo(8) }

Paso 9: El camino I en el paso anterior es el más corto, que es 8

S={ A(0), C(2), D(3), B(4), F(4), E(5), H(6), G(7), I(8 ) }
U = { }

Hasta ahora se ha obtenido el camino más corto desde A hasta cada punto.

Dos, implementación de código JS

Tome la instancia dos como ejemplo:

Primero defina una matriz gráfica, que registre la distancia a cada punto, por ejemplo:

La distancia A→A es 0, la distancia A→B es 4, la distancia A→C es 2, la distancia A→D es 3, A→E no es adyacente, por lo que la distancia es cero...
B→A es irreversible, por lo que la distancia es cero, B→B la distancia es 0, B→C la distancia es 1, B→D no es adyacente, por lo que la distancia es cero...

etcétera

let graph = [
    [0,4,2,3,0,0,0,0,0],
    [0,0,1,0,0,0,5,0,0],
    [0,0,0,0,3,2,0,0,0],
    [0,0,1,0,0,1,0,0,5],
    [0,0,0,0,0,0,3,2,0],
    [0,0,0,0,1,0,0,2,0],
    [0,0,0,0,0,0,0,0,0],
    [0,0,0,0,0,0,1,0,0],
    [0,0,0,0,0,0,0,1,0]
]

Defina una matriz currentMinPth, que registra la ruta más corta conocida actualmente, y el valor inicial es infinito; defina una matriz visitada, registra si ha sido visitada y el siguiente ciclo que se ha visitado no visitará

    let currentMinPth = [];
    let visited = [];
    for(let i = 0; i < graph.length;i++){
        currentMinPth.push(INF);
        visited.push(false);
    }

El punto de partida es A, A→A es 0, entonces currentMinPth[0] es 0
Encuentre el nodo más cercano de los nodos actualmente conocidos y devuelva el valor de índice minIndex (comenzando desde la ruta más corta cada vez)

function getMinIndex(currentMinPth,visited){
    let min = INF;
    let minIndex = -1;
    for(let i = 0; i < currentMinPth.length;i++){
        if(!visited[i]&&currentMinPth[i]<min){
            min = currentMinPth[i];
            minIndex = i;
        }
    }
    return minIndex
}

Establecer el nodo más cercano que se ha obtenido como visitado:

visited[minIndex] = true;

Encuentre el nodo adyacente, es decir, el nodo donde graph[minIndex][i] !== 0, y actualice el valor de la ruta al nodo adyacente a currentMinPth, pero solo si este valor es menor que el valor actual:

if(!visited[i]&&
   graph[minIndex][i] !== 0 && 
   currentMinPth[minIndex] + graph[minIndex][i] < currentMinPth[i]){
   currentMinPth[i] = currentMinPth[minIndex] + graph[minIndex][i];
}

Repita el proceso anterior para cada elemento de currentMinPth, longitud: 1 es suficiente, no es necesario verificar cuando solo queda el último, el código completo es el siguiente:

let graph = [
    [0,4,2,3,0,0,0,0,0],
    [0,0,1,0,0,0,5,0,0],
    [0,0,0,0,3,2,0,0,0],
    [0,0,1,0,0,1,0,0,5],
    [0,0,0,0,0,0,3,2,0],
    [0,0,0,0,1,0,0,2,0],
    [0,0,0,0,0,0,0,0,0],
    [0,0,0,0,0,0,1,0,0],
    [0,0,0,0,0,0,0,1,0]
]
let INF = Number.MAX_SAFE_INTEGER;
function handlePath(){
    let currentMinPth = [];
    let visited = [];
    for(let i = 0; i < graph.length;i++){
        currentMinPth.push(INF);
        visited.push(false);
    }
    currentMinPth[0] = 0
    for(let j = 0; j < currentMinPth.length - 1;j++){
        let minIndex = getMinIndex(currentMinPth,visited);
        visited[minIndex] = true;
        for(let i = 0; i < currentMinPth.length;i++){
            if(!visited[i]&&
               graph[minIndex][i] !== 0 && 
               currentMinPth[minIndex] + graph[minIndex][i] < currentMinPth[i]){
               currentMinPth[i] = currentMinPth[minIndex] + graph[minIndex][i];
            }
        }
    }
    
    return currentMinPth
}
function getMinIndex(currentMinPth,visited){
    let min = INF;
    let minIndex = -1;
    for(let i = 0; i < currentMinPth.length;i++){
        if(!visited[i]&&currentMinPth[i]<min){
            min = currentMinPth[i];
            minIndex = i;
        }
    }
    return minIndex
}
console.log(handlePath())

Resumir

Este artículo registra la comprensión simple del principio de la ruta más corta de Dijkstra y la implementación del código de js. Si hay algún error, corríjame.