// C++ program for Dijkstra's single source shortest path // algorithm. The program is for adjacency matrix // representation of the graph #include  using namespace std; #include  // Number of vertices in the graph #define V 9 // A utility function to find the vertex with minimum // distance value, from the set of vertices not yet included // in shortest path tree int minDistance(int dist[], bool sptSet[]) {  // Initialize min value  int min = INT_MAX, min_index;  for (int v = 0; v < V; v++)  if (sptSet[v] == false && dist[v] <= min)  min = dist[v], min_index = v;  return min_index; } // A utility function to print the constructed distance // array void printSolution(int dist[]) {  cout << 'Vertex 	 Distance from Source' << endl;  for (int i = 0; i < V; i++)  cout << i << ' 				' << dist[i] << endl; } // Function that implements Dijkstra's single source // shortest path algorithm for a graph represented using // adjacency matrix representation void dijkstra(int graph[V][V], int src) {  int dist[V]; // The output array. dist[i] will hold the  // shortest  // distance from src to i  bool sptSet[V]; // sptSet[i] will be true if vertex i is  // included in shortest  // path tree or shortest distance from src to i is  // finalized  // Initialize all distances as INFINITE and stpSet[] as  // false  for (int i = 0; i < V; i++)  dist[i] = INT_MAX, sptSet[i] = false;  // Distance of source vertex from itself is always 0  dist[src] = 0;  // Find shortest path for all vertices  for (int count = 0; count < V - 1; count++) {  // Pick the minimum distance vertex from the set of  // vertices not yet processed. u is always equal to  // src in the first iteration.  int u = minDistance(dist, sptSet);  // Mark the picked vertex as processed  sptSet[u] = true;  // Update dist value of the adjacent vertices of the  // picked vertex.  for (int v = 0; v < V; v++)  // Update dist[v] only if is not in sptSet,  // there is an edge from u to v, and total  // weight of path from src to v through u is  // smaller than current value of dist[v]  if (!sptSet[v] && graph[u][v]  && dist[u] != INT_MAX  && dist[u] + graph[u][v] < dist[v])  dist[v] = dist[u] + graph[u][v];  }  // print the constructed distance array  printSolution(dist); } // driver's code int main() {  /* Let us create the example graph discussed above */  int graph[V][V] = { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },  { 4, 0, 8, 0, 0, 0, 0, 11, 0 },  { 0, 8, 0, 7, 0, 4, 0, 0, 2 },  { 0, 0, 7, 0, 9, 14, 0, 0, 0 },  { 0, 0, 0, 9, 0, 10, 0, 0, 0 },  { 0, 0, 4, 14, 10, 0, 2, 0, 0 },  { 0, 0, 0, 0, 0, 2, 0, 1, 6 },  { 8, 11, 0, 0, 0, 0, 1, 0, 7 },  { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };  // Function call  dijkstra(graph, 0);  return 0; } // This code is contributed by shivanisinghss2110>

// C program for Dijkstra's single source shortest path // algorithm. The program is for adjacency matrix // representation of the graph #include  #include  #include  // Number of vertices in the graph #define V 9 // A utility function to find the vertex with minimum // distance value, from the set of vertices not yet included // in shortest path tree int minDistance(int dist[], bool sptSet[]) {  // Initialize min value  int min = INT_MAX, min_index;  for (int v = 0; v < V; v++)  if (sptSet[v] == false && dist[v] <= min)  min = dist[v], min_index = v;  return min_index; } // A utility function to print the constructed distance // array void printSolution(int dist[]) {  printf('Vertex 		 Distance from Source
');  for (int i = 0; i < V; i++)  printf('%d 				 %d
', i, dist[i]); } // Function that implements Dijkstra's single source // shortest path algorithm for a graph represented using // adjacency matrix representation void dijkstra(int graph[V][V], int src) {  int dist[V]; // The output array. dist[i] will hold the  // shortest  // distance from src to i  bool sptSet[V]; // sptSet[i] will be true if vertex i is  // included in shortest  // path tree or shortest distance from src to i is  // finalized  // Initialize all distances as INFINITE and stpSet[] as  // false  for (int i = 0; i < V; i++)  dist[i] = INT_MAX, sptSet[i] = false;  // Distance of source vertex from itself is always 0  dist[src] = 0;  // Find shortest path for all vertices  for (int count = 0; count < V - 1; count++) {  // Pick the minimum distance vertex from the set of  // vertices not yet processed. u is always equal to  // src in the first iteration.  int u = minDistance(dist, sptSet);  // Mark the picked vertex as processed  sptSet[u] = true;  // Update dist value of the adjacent vertices of the  // picked vertex.  for (int v = 0; v < V; v++)  // Update dist[v] only if is not in sptSet,  // there is an edge from u to v, and total  // weight of path from src to v through u is  // smaller than current value of dist[v]  if (!sptSet[v] && graph[u][v]  && dist[u] != INT_MAX  && dist[u] + graph[u][v] < dist[v])  dist[v] = dist[u] + graph[u][v];  }  // print the constructed distance array  printSolution(dist); } // driver's code int main() {  /* Let us create the example graph discussed above */  int graph[V][V] = { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },  { 4, 0, 8, 0, 0, 0, 0, 11, 0 },  { 0, 8, 0, 7, 0, 4, 0, 0, 2 },  { 0, 0, 7, 0, 9, 14, 0, 0, 0 },  { 0, 0, 0, 9, 0, 10, 0, 0, 0 },  { 0, 0, 4, 14, 10, 0, 2, 0, 0 },  { 0, 0, 0, 0, 0, 2, 0, 1, 6 },  { 8, 11, 0, 0, 0, 0, 1, 0, 7 },  { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };  // Function call  dijkstra(graph, 0);  return 0; }>

// A Java program for Dijkstra's single source shortest path // algorithm. The program is for adjacency matrix // representation of the graph import java.io.*; import java.lang.*; import java.util.*; class ShortestPath {  // A utility function to find the vertex with minimum  // distance value, from the set of vertices not yet  // included in shortest path tree  static final int V = 9;  int minDistance(int dist[], Boolean sptSet[])  {  // Initialize min value  int min = Integer.MAX_VALUE, min_index = -1;  for (int v = 0; v < V; v++)  if (sptSet[v] == false && dist[v] <= min) {  min = dist[v];  min_index = v;  }  return min_index;  }  // A utility function to print the constructed distance  // array  void printSolution(int dist[])  {  System.out.println(  'Vertex 		 Distance from Source');  for (int i = 0; i < V; i++)  System.out.println(i + ' 		 ' + dist[i]);  }  // Function that implements Dijkstra's single source  // shortest path algorithm for a graph represented using  // adjacency matrix representation  void dijkstra(int graph[][], int src)  {  int dist[] = new int[V]; // The output array.  // dist[i] will hold  // the shortest distance from src to i  // sptSet[i] will true if vertex i is included in  // shortest path tree or shortest distance from src  // to i is finalized  Boolean sptSet[] = new Boolean[V];  // Initialize all distances as INFINITE and stpSet[]  // as false  for (int i = 0; i < V; i++) {  dist[i] = Integer.MAX_VALUE;  sptSet[i] = false;  }  // Distance of source vertex from itself is always 0  dist[src] = 0;  // Find shortest path for all vertices  for (int count = 0; count < V - 1; count++) {  // Pick the minimum distance vertex from the set  // of vertices not yet processed. u is always  // equal to src in first iteration.  int u = minDistance(dist, sptSet);  // Mark the picked vertex as processed  sptSet[u] = true;  // Update dist value of the adjacent vertices of  // the picked vertex.  for (int v = 0; v < V; v++)  // Update dist[v] only if is not in sptSet,  // there is an edge from u to v, and total  // weight of path from src to v through u is  // smaller than current value of dist[v]  if (!sptSet[v] && graph[u][v] != 0  && dist[u] != Integer.MAX_VALUE  && dist[u] + graph[u][v] < dist[v])  dist[v] = dist[u] + graph[u][v];  }  // print the constructed distance array  printSolution(dist);  }  // Driver's code  public static void main(String[] args)  {  /* Let us create the example graph discussed above  */  int graph[][]  = new int[][] { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },  { 4, 0, 8, 0, 0, 0, 0, 11, 0 },  { 0, 8, 0, 7, 0, 4, 0, 0, 2 },  { 0, 0, 7, 0, 9, 14, 0, 0, 0 },  { 0, 0, 0, 9, 0, 10, 0, 0, 0 },  { 0, 0, 4, 14, 10, 0, 2, 0, 0 },  { 0, 0, 0, 0, 0, 2, 0, 1, 6 },  { 8, 11, 0, 0, 0, 0, 1, 0, 7 },  { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };  ShortestPath t = new ShortestPath();  // Function call  t.dijkstra(graph, 0);  } } // This code is contributed by Aakash Hasija>

# Python program for Dijkstra's single # source shortest path algorithm. The program is # for adjacency matrix representation of the graph # Library for INT_MAX import sys class Graph(): def __init__(self, vertices): self.V = vertices self.graph = [[0 for column in range(vertices)] for row in range(vertices)] def printSolution(self, dist): print('Vertex 	Distance from Source') for node in range(self.V): print(node, '	', dist[node]) # A utility function to find the vertex with # minimum distance value, from the set of vertices # not yet included in shortest path tree def minDistance(self, dist, sptSet): # Initialize minimum distance for next node min = sys.maxsize # Search not nearest vertex not in the # shortest path tree for u in range(self.V): if dist[u] < min and sptSet[u] == False: min = dist[u] min_index = u return min_index # Function that implements Dijkstra's single source # shortest path algorithm for a graph represented # using adjacency matrix representation def dijkstra(self, src): dist = [sys.maxsize] * self.V dist[src] = 0 sptSet = [False] * self.V for cout in range(self.V): # Pick the minimum distance vertex from # the set of vertices not yet processed. # x is always equal to src in first iteration x = self.minDistance(dist, sptSet) # Put the minimum distance vertex in the # shortest path tree sptSet[x] = True # Update dist value of the adjacent vertices # of the picked vertex only if the current # distance is greater than new distance and # the vertex in not in the shortest path tree for y in range(self.V): if self.graph[x][y]>0 y sptSet[y] == False y  dist[y]> dist[x] + self.graph[x][y]: dist[y] = dist[x] + self.graph[x][y] self.printSolution(dist) # Código del controlador if __name__ == '__main__': g = Graph(9) g.graph = [[0, 4, 0, 0, 0, 0, 0, 8, 0], [4, 0, 8, 0, 0, 0, 0, 11, 0], [0, 8, 0, 7, 0, 4, 0, 0, 2], [0, 0, 7, 0, 9, 14, 0, 0, 0], [0, 0, 0, 9, 0, 10, 0, 0, 0], [0, 0, 4, 14, 10, 0, 2, 0, 0], [0, 0, 0, 0, 0, 2, 0, 1, 6], [8, 11, 0, 0, 0, 0, 1, 0, 7], [0, 0, 2, 0, 0, 0, 6, 7, 0] ] g.dijkstra(0) # Este código fue aportado por Divyanshu Mehta y actualizado por Pranav Singh Sambyal>

// C# program for Dijkstra's single // source shortest path algorithm. // The program is for adjacency matrix // representation of the graph using System; class GFG {  // A utility function to find the  // vertex with minimum distance  // value, from the set of vertices  // not yet included in shortest  // path tree  static int V = 9;  int minDistance(int[] dist, bool[] sptSet)  {  // Initialize min value  int min = int.MaxValue, min_index = -1;  for (int v = 0; v < V; v++)  if (sptSet[v] == false && dist[v] <= min) {  min = dist[v];  min_index = v;  }  return min_index;  }  // A utility function to print  // the constructed distance array  void printSolution(int[] dist)  {  Console.Write('Vertex 		 Distance '  + 'from Source
');  for (int i = 0; i < V; i++)  Console.Write(i + ' 		 ' + dist[i] + '
');  }  // Function that implements Dijkstra's  // single source shortest path algorithm  // for a graph represented using adjacency  // matrix representation  void dijkstra(int[, ] graph, int src)  {  int[] dist  = new int[V]; // The output array. dist[i]  // will hold the shortest  // distance from src to i  // sptSet[i] will true if vertex  // i is included in shortest path  // tree or shortest distance from  // src to i is finalized  bool[] sptSet = new bool[V];  // Initialize all distances as  // INFINITE and stpSet[] as false  for (int i = 0; i < V; i++) {  dist[i] = int.MaxValue;  sptSet[i] = false;  }  // Distance of source vertex  // from itself is always 0  dist[src] = 0;  // Find shortest path for all vertices  for (int count = 0; count < V - 1; count++) {  // Pick the minimum distance vertex  // from the set of vertices not yet  // processed. u is always equal to  // src in first iteration.  int u = minDistance(dist, sptSet);  // Mark the picked vertex as processed  sptSet[u] = true;  // Update dist value of the adjacent  // vertices of the picked vertex.  for (int v = 0; v < V; v++)  // Update dist[v] only if is not in  // sptSet, there is an edge from u  // to v, and total weight of path  // from src to v through u is smaller  // than current value of dist[v]  if (!sptSet[v] && graph[u, v] != 0  && dist[u] != int.MaxValue  && dist[u] + graph[u, v] < dist[v])  dist[v] = dist[u] + graph[u, v];  }  // print the constructed distance array  printSolution(dist);  }  // Driver's Code  public static void Main()  {  /* Let us create the example graph discussed above */  int[, ] graph  = new int[, ] { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },  { 4, 0, 8, 0, 0, 0, 0, 11, 0 },  { 0, 8, 0, 7, 0, 4, 0, 0, 2 },  { 0, 0, 7, 0, 9, 14, 0, 0, 0 },  { 0, 0, 0, 9, 0, 10, 0, 0, 0 },  { 0, 0, 4, 14, 10, 0, 2, 0, 0 },  { 0, 0, 0, 0, 0, 2, 0, 1, 6 },  { 8, 11, 0, 0, 0, 0, 1, 0, 7 },  { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };  GFG t = new GFG();  // Function call  t.dijkstra(graph, 0);  } } // This code is contributed by ChitraNayal>

// A Javascript program for Dijkstra's single  // source shortest path algorithm.  // The program is for adjacency matrix  // representation of the graph  let V = 9; // A utility function to find the  // vertex with minimum distance  // value, from the set of vertices  // not yet included in shortest  // path tree  function minDistance(dist,sptSet) {    // Initialize min value   let min = Number.MAX_VALUE;  let min_index = -1;    for(let v = 0; v < V; v++)  {  if (sptSet[v] == false && dist[v] <= min)   {  min = dist[v];  min_index = v;  }  }  return min_index; } // A utility function to print  // the constructed distance array  function printSolution(dist) {  console.log('Vertex 		 Distance from Source ');  for(let i = 0; i < V; i++)  {  console.log(i + ' 		 ' +   dist[i] + ' ');  } } // Function that implements Dijkstra's  // single source shortest path algorithm  // for a graph represented using adjacency  // matrix representation  function dijkstra(graph, src) {  let dist = new Array(V);  let sptSet = new Array(V);    // Initialize all distances as   // INFINITE and stpSet[] as false   for(let i = 0; i < V; i++)  {  dist[i] = Number.MAX_VALUE;  sptSet[i] = false;  }    // Distance of source vertex   // from itself is always 0   dist[src] = 0;    // Find shortest path for all vertices   for(let count = 0; count < V - 1; count++)  {    // Pick the minimum distance vertex   // from the set of vertices not yet   // processed. u is always equal to   // src in first iteration.   let u = minDistance(dist, sptSet);    // Mark the picked vertex as processed   sptSet[u] = true;    // Update dist value of the adjacent   // vertices of the picked vertex.   for(let v = 0; v < V; v++)  {    // Update dist[v] only if is not in   // sptSet, there is an edge from u   // to v, and total weight of path   // from src to v through u is smaller   // than current value of dist[v]   if (!sptSet[v] && graph[u][v] != 0 &&   dist[u] != Number.MAX_VALUE &&  dist[u] + graph[u][v] < dist[v])  {  dist[v] = dist[u] + graph[u][v];  }  }  }    // Print the constructed distance array  printSolution(dist); } // Driver code let graph = [ [ 0, 4, 0, 0, 0, 0, 0, 8, 0 ],  [ 4, 0, 8, 0, 0, 0, 0, 11, 0 ],  [ 0, 8, 0, 7, 0, 4, 0, 0, 2 ],  [ 0, 0, 7, 0, 9, 14, 0, 0, 0],  [ 0, 0, 0, 9, 0, 10, 0, 0, 0 ],  [ 0, 0, 4, 14, 10, 0, 2, 0, 0],  [ 0, 0, 0, 0, 0, 2, 0, 1, 6 ],  [ 8, 11, 0, 0, 0, 0, 1, 0, 7 ],  [ 0, 0, 2, 0, 0, 0, 6, 7, 0 ] ] dijkstra(graph, 0); // This code is contributed by rag2127>

// C++ Program to find Dijkstra's shortest path using // priority_queue in STL #include  using namespace std; #define INF 0x3f3f3f3f // iPair ==>par entero typedef par par; // Esta clase representa un gráfico dirigido usando // representación de lista de adyacencia class Graph { int V; // Número de vértices // En un gráfico ponderado, necesitamos almacenar el vértice // y el par de pesos para cada lista de aristas>* adj; público: Gráfico (int V); // Constructor // función para agregar un borde al gráfico void addEdge(int u, int v, int w);  // imprime la ruta más corta desde s voidshortPath(int s); }; // Asigna memoria para la lista de adyacencia Graph::Graph(int V) { this->V = V;  adj = nueva lista [V]; } void Graph::addEdge(int u, int v, int w) { adj[u].push_back(make_pair(v, w));  adj[v].push_back(make_pair(u, w)); } // Imprime las rutas más cortas desde src a todos los demás vértices void Graph::shortestPath(int src) { // Crea una cola de prioridad para almacenar los vértices que // están siendo preprocesados. Esta es una sintaxis extraña en C++.  // Consulte el enlace a continuación para obtener detalles de esta sintaxis // https://www.techcodeview.com prioridad_queue , mayor que >pq;  // Crea un vector para distancias e inicializa todas // las distancias como un vector infinito (INF) dist(V,INF);  // Inserta la fuente en la cola de prioridad e inicializa // su distancia como 0. pq.push(make_pair(0, src));  dist[fuente] = 0;  /* Recorriendo hasta que la cola de prioridad se vacíe (o no se finalicen todas las distancias) */ while (!pq.empty()) { // El primer vértice del par es la distancia mínima // vértice, extráigalo de la cola de prioridad.  // la etiqueta del vértice se almacena en el segundo del par ( // debe hacerse de esta manera para mantener los vértices // distancia ordenada (la distancia debe ser el primer elemento // del par) int u = pq.top().segundo; pq.pop(); // 'i' se usa para obtener todos los vértices adyacentes de una // lista de vértices>::iterador i;  for (i = adj[u].begin(); i != adj[u].end(); ++i) { // Obtener la etiqueta del vértice y el peso del // actual adyacente de u.  int v = (*i).primero;  peso int = (*i).segundo;  // Si hay un camino corto de v a través de u.  if (dist[v]> dist[u] + peso) { // Actualizando la distancia de v dist[v] = dist[u] + peso;  pq.push(make_pair(dist[v], v));  } } } // Imprime las distancias más cortas almacenadas en dist[] printf('Distancia de vértice desde la fuente
');  para (int i = 0; i< V; ++i)  printf('%d 		 %d
', i, dist[i]); } // Driver's code int main() {  // create the graph given in above figure  int V = 9;  Graph g(V);  // making above shown graph  g.addEdge(0, 1, 4);  g.addEdge(0, 7, 8);  g.addEdge(1, 2, 8);  g.addEdge(1, 7, 11);  g.addEdge(2, 3, 7);  g.addEdge(2, 8, 2);  g.addEdge(2, 5, 4);  g.addEdge(3, 4, 9);  g.addEdge(3, 5, 14);  g.addEdge(4, 5, 10);  g.addEdge(5, 6, 2);  g.addEdge(6, 7, 1);  g.addEdge(6, 8, 6);  g.addEdge(7, 8, 7);  // Function call  g.shortestPath(0);  return 0; }>

import java.util.*; class Graph {  private int V;  private List> adj;  Gráfico(int V) { this.V = V;  adj = nueva ArrayList();  para (int i = 0; i< V; i++) {  adj.add(new ArrayList());  }  }  void addEdge(int u, int v, int w) {  adj.get(u).add(new iPair(v, w));  adj.get(v).add(new iPair(u, w));  }  void shortestPath(int src) {  PriorityQueue pq = new PriorityQueue(V, Comparator.comparingInt(o -> o.segundo));  int[] dist = nuevo int[V];  Arrays.fill(dist, Integer.MAX_VALUE);  pq.add(nuevo iPair(0, origen));  dist[fuente] = 0;  mientras (!pq.isEmpty()) { int u = pq.poll().segundo;  for (iPair v : adj.get(u)) { if (dist[v.primero]> dist[u] + v.segundo) { dist[v.primero] = dist[u] + v.segundo;  pq.add(new iPair(dist[v.first], v.first));  } } } System.out.println('Distancia del vértice desde la fuente');  para (int i = 0; i< V; i++) {  System.out.println(i + '		' + dist[i]);  }  }  static class iPair {  int first, second;  iPair(int first, int second) {  this.first = first;  this.second = second;  }  } } public class Main {  public static void main(String[] args) {  int V = 9;  Graph g = new Graph(V);  g.addEdge(0, 1, 4);  g.addEdge(0, 7, 8);  g.addEdge(1, 2, 8);  g.addEdge(1, 7, 11);  g.addEdge(2, 3, 7);  g.addEdge(2, 8, 2);  g.addEdge(2, 5, 4);  g.addEdge(3, 4, 9);  g.addEdge(3, 5, 14);  g.addEdge(4, 5, 10);  g.addEdge(5, 6, 2);  g.addEdge(6, 7, 1);  g.addEdge(6, 8, 6);  g.addEdge(7, 8, 7);  g.shortestPath(0);  } }>

import heapq # iPair ==>Par entero iPair = tupla # Esta clase representa un gráfico dirigido usando # la clase de representación de lista de adyacencia Gráfico: def __init__(self, V: int): # Constructor self.V = V self.adj = [[] for _ in range(V )] def addEdge(self, u: int, v: int, w: int): self.adj[u].append((v, w)) self.adj[v].append((u, w)) # Imprime las rutas más cortas desde src a todos los demás vértices defshortPath(self, src: int): # Crea una cola de prioridad para almacenar los vértices que # están siendo preprocesados ​​pq = [] heapq.heappush(pq, (0, src)) # Cree un vector para distancias e inicialice todas las # distancias como infinitas (INF) dist = [float('inf')] * self.V dist[src] = 0 mientras pq: # El primer vértice del par es la distancia mínima # vértice, extráigalo de la cola de prioridad. # la etiqueta de vértice se almacena en el segundo del par d, u = heapq.heappop(pq) # 'i' se usa para obtener todos los vértices adyacentes de un # vértice para v, peso en self.adj[u]: # Si hay un camino corto de v a través de u. if dist[v]> dist[u] + peso: # Actualizando distancia de v dist[v] = dist[u] + peso heapq.heappush(pq, (dist[v], v)) # Imprime las distancias más cortas almacenadas en dist[] for i in range(self.V): print(f'{i} 		 {dist[i]}') # Código del conductor si __name__ == '__main__': # crear el gráfico mostrado en la figura anterior V = 9 g = Graph(V) # hacer el gráfico mostrado arriba g.addEdge(0, 1, 4) g.addEdge(0, 7, 8) g.addEdge(1, 2, 8) g.addEdge(1, 7, 11) g.addEdge(2, 3, 7) g.addEdge(2, 8, 2) g.addEdge(2, 5, 4) g.addEdge(3, 4, 9) g.addEdge(3, 5, 14) g.addEdge(4, 5, 10) g.addEdge(5, 6, 2) g.addEdge(6, 7, 1) g.addEdge(6, 8, 6) g.addEdge(7, 8, 7) g.shortestPath(0)>

using System; using System.Collections.Generic; // This class represents a directed graph using // adjacency list representation public class Graph {  private const int INF = 2147483647;  private int V;  private List [] adj;  public Graph(int V) { // No. de vértices this.V = V;  // En un gráfico ponderado, necesitamos almacenar el vértice // y el par de pesos para cada arista this.adj = new List [V];  para (int i = 0; i< V; i++)  {  this.adj[i] = new List ();  } } public void AddEdge(int u, int v, int w) { this.adj[u].Add(new int[] { v, w });  this.adj[v].Add(new int[] { u, w });  } // Imprime las rutas más cortas desde src a todos los demás vértices public void ShortestPath(int src) { // Crea una cola de prioridad para almacenar los vértices que // se están preprocesando.  Conjunto ordenado pq = nuevo conjunto ordenado (nuevo Comparador de distancia());  // Crea una matriz para distancias e inicializa todas // las distancias como infinitas (INF) int[] dist = new int[V];  para (int i = 0; i< V; i++)  {  dist[i] = INF;  }  // Insert source itself in priority queue and initialize  // its distance as 0.  pq.Add(new int[] { 0, src });  dist[src] = 0;  /* Looping till priority queue becomes empty (or all  distances are not finalized) */  while (pq.Count>0) { // El primer vértice del par es la distancia mínima // vértice, extráigalo de la cola de prioridad.  // la etiqueta del vértice se almacena en el segundo del par ( // debe hacerse de esta manera para mantener los vértices // ordenados por distancia) int[] minDistVertex = pq.Min;  pq.Remove(minDistVertex);  int u = minDistVertex[1];  // 'i' se usa para obtener todos los vértices adyacentes de un // vértice foreach (int[] adjVertex in this.adj[u]) { // Obtener la etiqueta del vértice y el peso del // actual adyacente de u.  int v = adjVértice[0];  int peso = adjVertex[1];  // Si hay un camino más corto desde v hasta u.  if (dist[v]> dist[u] + peso) { // Actualizando la distancia de v dist[v] = dist[u] + peso;  pq.Add(new int[] { dist[v], v });  } } } // Imprime las distancias más cortas almacenadas en dist[] Console.WriteLine('Vertex Distance from Source');  para (int i = 0; i< V; ++i)  Console.WriteLine(i + '	' + dist[i]);  }  private class DistanceComparer : IComparer { público int Comparar(int[] x, int[] y) { if (x[0] == y[0]) { return x[1] - y[1];  } devolver x[0] - y[0];  } } } public class Program { // Código de controlador public static void Main() { // crea el gráfico mostrado en la figura anterior int V = 9;  Gráfico g = nuevo gráfico (V);  // haciendo el gráfico mostrado arriba g.AddEdge(0, 1, 4);  g.AddEdge(0, 7, 8);  g.AddEdge(1, 2, 8);  g.AddEdge(1, 7, 11);  g.AddEdge(2, 3, 7);  g.AddEdge(2, 8, 2);  g.AddEdge(2, 5, 4);  g.AddEdge(3, 4, 9);  g.AddEdge(3, 5, 14);  g.AddEdge(4, 5, 10);  g.AddEdge(5, 6, 2);  g.AddEdge(6, 7, 1);  g.AddEdge(6, 8, 6);  g.AddEdge(7, 8, 7);  g.ShortestPath(0);  } } // este código es aportado por bhardwajji>

// javascript Program to find Dijkstra's shortest path using // priority_queue in STL const INF = 2147483647; // This class represents a directed graph using // adjacency list representation class Graph {    constructor(V){    // No. of vertices  this.V = V;    // In a weighted graph, we need to store vertex  // and weight pair for every edge  this.adj = new Array(V);  for(let i = 0; i < V; i++){  this.adj[i] = new Array();  }  }  addEdge(u, v, w)  {  this.adj[u].push([v, w]);  this.adj[v].push([u, w]);  }  // Prints shortest paths from src to all other vertices  shortestPath(src)  {  // Create a priority queue to store vertices that  // are being preprocessed. This is weird syntax in C++.  // Refer below link for details of this syntax  // https://www.techcodeview.com  let pq = [];  // Create a vector for distances and initialize all  // distances as infinite (INF)  let dist = new Array(V).fill(INF);  // Insert source itself in priority queue and initialize  // its distance as 0.  pq.push([0, src]);  dist[src] = 0;  /* Looping till priority queue becomes empty (or all  distances are not finalized) */  while (pq.length>0) { // El primer vértice del par es la distancia mínima // vértice, extráigalo de la cola de prioridad.  // la etiqueta del vértice se almacena en el segundo del par ( // debe hacerse de esta manera para mantener los vértices // distancia ordenada (la distancia debe ser el primer elemento // en el par) let u = pq[0][1]; pq.shift(); // 'i' se usa para obtener todos los vértices adyacentes de un // vértice for(let i = 0; i< this.adj[u].length; i++){    // Get vertex label and weight of current  // adjacent of u.  let v = this.adj[u][i][0];  let weight = this.adj[u][i][1];  // If there is shorted path to v through u.  if (dist[v]>dist[u] + peso) { // Actualizando la distancia de v dist[v] = dist[u] + peso;  pq.push([dist[v], v]);  pq.sort((a, b) =>{ if(a[0] == b[0]) devolver a[1] - b[1]; devolver a[0] - b[0]; });  } } } // Imprime las distancias más cortas almacenadas en dist[] console.log('Vertex Distance from Source');  para (sea i = 0; i< V; ++i)  console.log(i, ' ', dist[i]);  } } // Driver's code // create the graph given in above figure let V = 9; let g = new Graph(V); // making above shown graph g.addEdge(0, 1, 4); g.addEdge(0, 7, 8); g.addEdge(1, 2, 8); g.addEdge(1, 7, 11); g.addEdge(2, 3, 7); g.addEdge(2, 8, 2); g.addEdge(2, 5, 4); g.addEdge(3, 4, 9); g.addEdge(3, 5, 14); g.addEdge(4, 5, 10); g.addEdge(5, 6, 2); g.addEdge(6, 7, 1); g.addEdge(6, 8, 6); g.addEdge(7, 8, 7); // Function call g.shortestPath(0); // The code is contributed by Nidhi goel.>