`` `Java
import java.util.*;
clase pública Dijkstra {
Public Static Map
Map
Priorityqueue
// Inicializar distancias al infinito excepto por la fuente
para (nodo nodo:gráfico.getNodes ()) {
distancias.put (nodo, integer.max_value);
}
distancias.put (fuente, 0);
minheap.add (fuente);
while (! minheap.isempty ()) {
Nodo corriente =minheap.poll ();
para (borde de borde:current.getedges ()) {
Nodo vecino =borde.getto ();
int Distance =Distances.get (actual) + borde.getWeight ();
if (distancia
distancias.put (vecino, distancia);
minheap.add (vecino);
}
}
}
Distancias de retorno;
}
// clases de ayuda para la representación de gráficos
Gráfico de clase estática {
set private
public void addNode (nodo nodo) {
nodos.add (nodo);
}
SET Public
nodos de retorno;
}
}
nodo de clase estática {
nombre de cadena privada;
Lista privada
nodo público (nombre de cadena) {
this.name =name;
}
Public String getName () {Return Name;}
public void adicional (borde borde) {
bordes.add (borde);
}
Lista pública
Bordes de retorno;
}
@Anular
Public Boolean iguales (object obj) {
if (this ==obj) return verdadero;
if (obj ==null || getClass ()! =obj.getClass ()) return false;
Nodo nodo =(nodo) obj;
return Objects.equals (name, node.name);
}
@Anular
public int hashcode () {
devolver objetos.hash (nombre);
}
}
Bordamiento de clase estática {
nodo privado a;
Peso privado int;
Public Edge (nodo a, int weight) {
this.to =a;
this.weight =peso;
}
Public Node getTo () {
volver a;
}
public int getweight () {
peso de regreso;
}
}
public static void main (string [] args) {
Gráfico gráfico =nuevo gráfico ();
Nodo a =nuevo nodo ("a");
Nodo b =nuevo nodo ("b");
Nodo c =nuevo nodo ("c");
Nodo d =nuevo nodo ("d");
A.Addedge (nuevo borde (b, 4));
A.Addedge (nuevo borde (c, 2));
B.Addedge (nuevo borde (c, 1));
B.Addedge (nuevo borde (d, 5));
C.Addedge (nuevo borde (d, 8));
Graph.addnode (a);
Graph.addnode (b);
Graph.addnode (c);
Graph.addnode (d);
Map
para (map.entry
System.out.println ("Distancia de A a" + Entry.getKey (). GetName () + ":" + Entry.getValue ());
}
}
}
`` `` ``
Explicación:
1. `Graph`,` Node`, `Edge` clases: Estos representan la estructura gráfica. La clase `nodo` incluye una lista de sus objetos` Edge` salientes.
2. `Dijkstra` Función: Esto implementa el algoritmo de Dijkstra.
- Inicializa un `Hashmap` (` Distances`) para almacenar las distancias más cortas del nodo fuente a todos los demás nodos. Inicialmente, todas las distancias se establecen en Infinity, excepto la fuente, que es 0.
- Un `priorityqueue` se usa como un mínimo de alta para seleccionar eficientemente el nodo con la distancia más pequeña. El comparador asegura que los nodos sean ordenados por sus distancias.
- El algoritmo elimina iterativamente el nodo con la distancia más pequeña del montón. Para cada uno de sus vecinos, verifica si se encuentra una ruta más corta y actualiza la distancia y el montón en consecuencia. Las operaciones `remove` y` add` en el `priorityqueue 'mantienen la propiedad del montón de manera eficiente (tiempo logarítmico).
3. `Main` Función: Esto crea un gráfico de muestra y llama a la función `Dijkstra`. El resultado muestra la distancia más corta desde el nodo "A" a todos los demás nodos.
Recuerde manejar problemas potenciales como los pesos de borde negativo (el algoritmo de Dijkstra no funciona correctamente con ellos; necesitaría el algoritmo de Bellman-Ford) y se desconectó gráficos. Este ejemplo mejorado maneja 'Equals` y' Hashcode` en la clase `nodo` para administrar adecuadamente el manejo clave de 'priorityqueue' y 'hashmap`.