ALGORITMO DE RUTA MÁS CORTA DE DIJKSTRA CON EJEMPLOS

El siguiente tutorial nos enseñará sobre el algoritmo de ruta más corta de Dijkstra. Entenderemos el funcionamiento del Algoritmo de Dijkstra con una explicación gráfica paso a paso.

Cubriremos lo siguiente:

Una breve descripción de los conceptos fundamentales de Graph
Comprender el uso del algoritmo de Dijkstra
Comprenda el funcionamiento del algoritmo con un ejemplo paso a paso

Entonces empecemos.

Una breve introducción a los gráficos

Graficos son estructuras de datos no lineales que representan las 'conexiones' entre los elementos. Estos elementos se conocen como Vértices , y las líneas o arcos que conectan dos vértices cualesquiera en el gráfico se conocen como Bordes . Más formalmente, un gráfico comprende un conjunto de vértices (V) y un conjunto de bordes (E) . El gráfico se denota por GRAMO(V, mi) .

Componentes de un gráfico

Vértices:Los vértices son las unidades básicas del gráfico que se utilizan para representar objetos, personas o entidades de la vida real. A veces, los vértices también se conocen como nodos.Bordes:Los bordes se dibujan o se utilizan para conectar dos vértices del gráfico. A veces, los bordes también se conocen como arcos.

La siguiente figura muestra una representación gráfica de un Graph:

Figura 1: Representación gráfica de un gráfico

En la figura anterior, los vértices/nodos se indican con círculos de colores y los bordes se indican con las líneas que conectan los nodos.

Aplicaciones de los gráficos

Los gráficos se utilizan para resolver muchos problemas de la vida real. Se utilizan gráficos para representar las redes. Estas redes pueden incluir redes telefónicas o de circuitos o rutas en una ciudad.

Por ejemplo, podríamos usar gráficos para diseñar un modelo de red de transporte donde los vértices muestren las instalaciones que envían o reciben los productos, y los bordes representen carreteras o caminos que las conectan. La siguiente es una representación pictórica del mismo:

Figura 2: Representación pictórica de la red de transporte

Los gráficos también se utilizan en diferentes plataformas de redes sociales como LinkedIn, Facebook, Twitter y más. Por ejemplo, plataformas como Facebook utilizan gráficos para almacenar los datos de sus usuarios, donde cada persona se indica con un vértice, y cada uno de ellos es una estructura que contiene información como ID de persona, nombre, sexo, dirección, etc.

Tipos de gráficos

Los Gráficos se pueden clasificar en dos tipos:

Gráfico no dirigido
Gráfico dirigido

Gráfico no dirigido: Un gráfico con aristas que no tienen dirección se denomina gráfico no dirigido. Los bordes de este gráfico implican una relación bidireccional en la que cada borde se puede atravesar en ambas direcciones. La siguiente figura muestra un gráfico no dirigido simple con cuatro nodos y cinco aristas.

Figura 3: Un gráfico simple no dirigido

Gráfico dirigido: Un gráfico con aristas con dirección se denomina gráfico dirigido. Los bordes de este gráfico implican una relación unidireccional en la que cada borde solo se puede atravesar en una única dirección. La siguiente figura muestra un gráfico dirigido simple con cuatro nodos y cinco aristas.

Figura 4: Un gráfico dirigido simple

La longitud, posición u orientación absolutas de los bordes en una ilustración gráfica característicamente no tienen significado. En otras palabras, podemos visualizar el mismo gráfico de diferentes maneras reorganizando los vértices o distorsionando los bordes si la estructura subyacente del gráfico no se altera.

¿Qué son los gráficos ponderados?

Se dice que un gráfico está ponderado si a cada borde se le asigna un 'peso'. El peso de una arista puede denotar distancia, tiempo o cualquier cosa que modele la 'conexión' entre el par de vértices que conecta.

Por ejemplo, podemos observar un número azul al lado de cada borde en la siguiente figura del gráfico ponderado. Este número se utiliza para indicar el peso del borde correspondiente.

Figura 5: Un ejemplo de gráfico ponderado

Una introducción al algoritmo de Dijkstra

Ahora que conocemos algunos conceptos básicos de gráficos, profundicemos en la comprensión del concepto del algoritmo de Dijkstra.

¿Alguna vez te has preguntado cómo encuentra Google Maps la ruta más corta y rápida entre dos lugares?

Bueno, la respuesta es Algoritmo de Dijkstra . Algoritmo de Dijkstra es un algoritmo gráfico que encuentra el camino más corto desde un vértice de origen a todos los demás vértices del gráfico (ruta más corta de origen único). Es un tipo de algoritmo codicioso que solo funciona en gráficos ponderados que tienen pesos positivos. La complejidad temporal del algoritmo de Dijkstra es O(V²) con la ayuda de la representación matricial de adyacencia del gráfico. Esta vez la complejidad se puede reducir a O((V + E) Iniciar sesión V) con la ayuda de una representación de lista de adyacencia del gráfico, donde EN es el número de vértices y Y es el número de aristas en el gráfico.

Historia del algoritmo de Dijkstra

El algoritmo de Dijkstra fue diseñado y publicado por Dr. Edsger W. Dijkstra , un informático, ingeniero de software, programador, ensayista científico y científico de sistemas holandés.

Durante una entrevista con Philip L. Frana para Comunicaciones de la revista ACM en el año 2001, el Dr. Edsger W. Dijkstra reveló:

'¿Cuál es el camino más corto para viajar de Rotterdam a Groningen, en general: de una ciudad determinada a otra ciudad determinada? Es el algoritmo del camino más corto, que diseñé en unos veinte minutos. Una mañana estaba de compras en Ámsterdam con mi joven prometida y, cansados, nos sentamos en la terraza del café a tomar una taza de café y yo estaba pensando si podía hacer esto, y entonces diseñé el algoritmo para el camino más corto. . Como dije, fue un invento de veinte minutos. De hecho, se publicó en el 59, tres años después. La publicación aún se puede leer y, de hecho, es bastante bonita. Una de las razones por las que es tan bonito es que lo diseñé sin lápiz ni papel. Más tarde supe que una de las ventajas de diseñar sin lápiz ni papel es que casi estás obligado a evitar todas las complejidades evitables. Con el tiempo, para mi gran asombro, ese algoritmo se convirtió en una de las piedras angulares de mi fama.'

Dijkstra pensó en el problema del camino más corto mientras trabajaba como programador en el Centro de Matemáticas de Ámsterdam en 1956 para ilustrar las capacidades de una nueva computadora conocida como ARMAC. Su objetivo era seleccionar tanto un problema como una solución (producida por la computadora) que las personas sin experiencia en informática pudieran comprender. Desarrolló el algoritmo de ruta más corta y luego lo ejecutó para ARMAC para un mapa de transporte vagamente acortado de 64 ciudades en los Países Bajos (64 ciudades, por lo que 6 bits serían suficientes para codificar el número de la ciudad). Un año más tarde, se encontró con otro problema por parte de los ingenieros de hardware que operaban la siguiente computadora del instituto: minimizar la cantidad de cables necesarios para conectar los pines en el panel posterior de la máquina. Como solución, redescubrió el algoritmo llamado algoritmo de árbol de expansión mínimo de Prim y lo publicó en el año 1959.

Fundamentos del algoritmo de Dijkstra

Los siguientes son los conceptos básicos del algoritmo de Dijkstra:

El algoritmo de Dijkstra comienza en el nodo que seleccionamos (el nodo de origen) y examina el gráfico para encontrar el camino más corto entre ese nodo y todos los demás nodos del gráfico.
El algoritmo mantiene registros de la distancia más corta actualmente reconocida desde cada nodo al nodo de origen y actualiza estos valores si encuentra una ruta más corta.
Una vez que el algoritmo ha recuperado la ruta más corta entre la fuente y otro nodo, ese nodo se marca como 'visitado' y se incluye en la ruta.
El procedimiento continúa hasta que todos los nodos del gráfico se hayan incluido en la ruta. De esta manera, tenemos una ruta que conecta el nodo de origen con todos los demás nodos, siguiendo el camino más corto posible para llegar a cada nodo.

Comprender el funcionamiento del algoritmo de Dijkstra

A grafico y vértice fuente son requisitos para el algoritmo de Dijkstra. Este algoritmo se establece en el enfoque codicioso y, por lo tanto, encuentra la elección local óptima (mínimos locales en este caso) en cada paso del algoritmo.

Cada Vértice en este Algoritmo tendrá dos propiedades definidas para él:

Propiedad visitada
Propiedad de ruta

Entendamos estas propiedades brevemente.

Propiedad visitada:

La propiedad 'visitada' indica si el nodo ha sido visitado o no.
Estamos utilizando esta propiedad para no volver a visitar ningún nodo.
Un nodo se marca como visitado sólo cuando se ha encontrado el camino más corto.

Propiedad de ruta:

La propiedad 'ruta' almacena el valor de la ruta mínima actual al nodo.
La ruta mínima actual implica el camino más corto por el que hemos llegado a este nodo hasta ahora.
Esta propiedad se revisa cuando se visita cualquier vecino del nodo.
Esta propiedad es importante porque almacenará la respuesta final para cada nodo.

Inicialmente, marcamos todos los vértices o nodos como no visitados porque aún no lo han sido. La ruta a todos los nodos también se establece en infinito aparte del nodo de origen. Además, la ruta al nodo de origen se establece en cero (0).

Luego seleccionamos el nodo de origen y lo marcamos como visitado. Después de eso, accedemos a todos los nodos vecinos del nodo de origen y realizamos relajación en cada nodo. La relajación es el proceso de reducir el costo de llegar a un nodo con la ayuda de otro nodo.

En el proceso de relajación, la ruta de cada nodo se revisa al valor mínimo entre la ruta actual del nodo, la suma de la ruta al nodo anterior y la ruta desde el nodo anterior al nodo actual.

Supongamos que p[n] es el valor de la ruta actual para el nodo n, p[m] es el valor de la ruta hasta el nodo m visitado previamente y w es el peso del borde entre el nodo actual y uno visitado previamente (peso de borde entre n y m).

En el sentido matemático, la relajación se puede ejemplificar como:

p[n] = mínimo(p[n], p[m] + w)

Luego marcamos un nodo no visitado con la menor ruta visitada en cada paso posterior y actualizamos las rutas de sus vecinos.

Repetimos este procedimiento hasta que todos los nodos del gráfico estén marcados como visitados.

Cada vez que agregamos un nodo al conjunto visitado, la ruta a todos sus nodos vecinos también cambia en consecuencia.

Si algún nodo queda inalcanzable (componente desconectado), su ruta sigue siendo 'infinita'. En caso de que la fuente en sí sea un componente separado, la ruta a todos los demás nodos sigue siendo 'infinita'.

Comprender el algoritmo de Dijkstra con un ejemplo

El siguiente es el paso que seguiremos para implementar el Algoritmo de Dijkstra:

Paso 1: Primero, marcaremos el nodo de origen con una distancia actual de 0 y estableceremos el resto de los nodos en INFINITO.

Paso 2: Luego configuraremos el nodo no visitado con la distancia actual más pequeña como el nodo actual, supongamos X.

Paso 3: Para cada vecino N del nodo actual X: Luego sumaremos la distancia actual de X con el peso del borde que une X-N. Si es menor que la distancia actual de N, configúrelo como la nueva distancia actual de N.

Etapa 4: Luego marcaremos el nodo actual X como visitado.

Paso 5: Repetiremos el proceso desde 'Paso 2' si queda algún nodo no visitado en el gráfico.

Ahora comprendamos la implementación del algoritmo con la ayuda de un ejemplo:

Figura 6: El gráfico dado

Usaremos el gráfico anterior como entrada, con el nodo A como fuente.
Primero, marcaremos todos los nodos como no visitados.
Marcaremos el camino hacia 0 en el nodo A y INFINIDAD para todos los demás nodos.
Ahora marcaremos el nodo fuente. A como visitado y acceder a sus nodos vecinos.
Nota: Solo hemos accedido a los nodos vecinos, no los hemos visitado.
Ahora actualizaremos la ruta al nodo. B por 4 con la ayuda de la relajación porque el camino al nodo A es 0 y el camino desde el nodo A a B es 4 , y el mínimo((0 + 4), INFINITO) es 4 .
También actualizaremos la ruta al nodo. C por 5 con la ayuda de la relajación porque el camino al nodo A es 0 y el camino desde el nodo A a C es 5 , y el mínimo((0 + 5), INFINITO) es 5 . Tanto los vecinos del nodo A ahora están relajados; por lo tanto, podemos seguir adelante.
Ahora seleccionaremos el siguiente nodo no visitado con la menor ruta y lo visitaremos. Por lo tanto, visitaremos el nodo B y relajar a sus vecinos no visitados. Después de realizar la relajación, el camino hacia el nodo C permanecerá 5 , mientras que la ruta al nodo Y se convertirá 11 , y el camino al nodo D se convertirá 13 .
Ahora visitaremos el nodo. Y y realizar relajación en sus nodos vecinos. B, D , y F . Dado que solo nodo F Si no es visitado, estará relajado. Por lo tanto, el camino al nodo B permanecerá como está, es decir, 4 , el camino al nodo D también permanecerá 13 , y el camino al nodo F se convertirá 14 (8 + 6) .
Ahora visitaremos el nodo. D , y único nodo F Estará relajado. Sin embargo, el camino al nodo F permanecerá sin cambios, es decir, 14 .
Dado que solo nodo F queda, lo visitaremos pero no realizaremos ninguna relajación ya que todos sus nodos vecinos ya están visitados.
Una vez visitados todos los nodos de los gráficos, el programa finalizará.

Por lo tanto, los caminos finales que concluimos son:

 A = 0 B = 4 (A -&gt; B) C = 5 (A -&gt; C) D = 4 + 9 = 13 (A -&gt; B -&gt; D) E = 5 + 3 = 8 (A -&gt; C -&gt; E) F = 5 + 3 + 6 = 14 (A -&gt; C -&gt; E -&gt; F)

Pseudocódigo para el algoritmo de Dijkstra

Ahora entenderemos un pseudocódigo para el algoritmo de Dijkstra.

cadenas a números enteros

Tenemos que mantener un registro de la distancia del camino de cada nodo. Por lo tanto, podemos almacenar la distancia de la ruta de cada nodo en una matriz de tamaño n, donde n es el número total de nodos.
Además, queremos recuperar el camino más corto junto con la longitud de ese camino. Para superar este problema, asignaremos cada nodo al nodo que actualizó por última vez la longitud de su ruta.
Una vez que se completa el algoritmo, podemos retroceder el nodo de destino hasta el nodo de origen para recuperar la ruta.
Podemos usar una cola de prioridad mínima para recuperar el nodo con la menor distancia de ruta de manera eficiente.

Implementemos ahora un pseudocódigo de la ilustración anterior:

Pseudocódigo:

 function Dijkstra_Algorithm(Graph, source_node) // iterating through the nodes in Graph and set their distances to INFINITY for each node N in Graph: distance[N] = INFINITY previous[N] = NULL If N != source_node, add N to Priority Queue G // setting the distance of the source node of the Graph to 0 distance[source_node] = 0 // iterating until the Priority Queue G is not empty while G is NOT empty: // selecting a node Q having the least distance and marking it as visited Q = node in G with the least distance[] mark Q visited // iterating through the unvisited neighboring nodes of the node Q and performing relaxation accordingly for each unvisited neighbor node N of Q: temporary_distance = distance[Q] + distance_between(Q, N) // if the temporary distance is less than the given distance of the path to the Node, updating the resultant distance with the minimum value if temporary_distance <distance[n] distance[n] :="temporary_distance" previous[n] returning the final list of distance return distance[], previous[] < pre> <p> <strong>Explanation:</strong> </p> <p>In the above pseudocode, we have defined a function that accepts multiple parameters - the Graph consisting of the nodes and the source node. Inside this function, we have iterated through each node in the Graph, set their initial distance to <strong>INFINITY</strong> , and set the previous node value to <strong>NULL</strong> . We have also checked whether any selected node is not a source node and added the same into the Priority Queue. Moreover, we have set the distance of the source node to <strong>0</strong> . We then iterated through the nodes in the priority queue, selected the node with the least distance, and marked it as visited. We then iterated through the unvisited neighboring nodes of the selected node and performed relaxation accordingly. At last, we have compared both the distances (original and temporary distance) between the source node and the destination node, updated the resultant distance with the minimum value and previous node information, and returned the final list of distances with their previous node information.</p> <h2>Implementation of Dijkstra&apos;s Algorithm in Different Programming Languages</h2> <p>Now that we have successfully understood the pseudocode of Dijkstra&apos;s Algorithm, it is time to see its implementation in different programming languages like C, C++, Java, and Python.</p> <h3>Code for Dijkstra&apos;s Algorithm in C</h3> <p>The following is the implementation of Dijkstra&apos;s Algorithm in the C Programming Language:</p> <p> <strong>File: DijkstraAlgorithm.c</strong> </p> <pre> // Implementation of Dijkstra&apos;s Algorithm in C // importing the standard I/O header file #include // defining some constants #define INF 9999 #define MAX 10 // prototyping of the function void DijkstraAlgorithm(int Graph[MAX][MAX], int size, int start); // defining the function for Dijkstra&apos;s Algorithm void DijkstraAlgorithm(int Graph[MAX][MAX], int size, int start) { int cost[MAX][MAX], distance[MAX], previous[MAX]; int visited_nodes[MAX], counter, minimum_distance, next_node, i, j; // creating cost matrix for (i = 0; i <size; i++) for (j="0;" j < size; j++) if (graph[i][j]="=" 0) cost[i][j]="INF;" else (i="0;" i { distance[i]="cost[start][i];" previous[i]="start;" visited_nodes[i]="0;" } distance[start]="0;" visited_nodes[start]="1;" counter="1;" while (counter size - 1) minimum_distance="INF;" (distance[i] && !visited_nodes[i]) next_node="i;" visited_nodes[next_node]="1;" (!visited_nodes[i]) (minimum_distance + cost[next_node][i] distance[i]) cost[next_node][i]; counter++; printing the distance !="start)" printf('
distance from source node to %d: %d', i, distance[i]); main function int main() defining variables graph[max][max], j, size, source; declaring of matrix nodes graph graph[0][0]="0;" graph[0][1]="4;" graph[0][2]="0;" graph[0][3]="0;" graph[0][4]="0;" graph[0][5]="8;" graph[0][6]="0;" graph[1][0]="4;" graph[1][1]="0;" graph[1][2]="8;" graph[1][3]="0;" graph[1][4]="0;" graph[1][5]="11;" graph[1][6]="0;" graph[2][0]="0;" graph[2][1]="8;" graph[2][2]="0;" graph[2][3]="7;" graph[2][4]="0;" graph[2][5]="4;" graph[2][6]="0;" graph[3][0]="0;" graph[3][1]="0;" graph[3][2]="7;" graph[3][3]="0;" graph[3][4]="9;" graph[3][5]="14;" graph[3][6]="0;" graph[4][0]="0;" graph[4][1]="0;" graph[4][2]="0;" graph[4][3]="9;" graph[4][4]="0;" graph[4][5]="10;" graph[4][6]="2;" graph[5][0]="0;" graph[5][1]="0;" graph[5][2]="4;" graph[5][3]="14;" graph[5][4]="10;" graph[5][5]="0;" graph[5][6]="2;" graph[6][0]="0;" graph[6][1]="0;" graph[6][2]="0;" graph[6][3]="0;" graph[6][4]="2;" graph[6][5]="0;" graph[6][6]="1;" calling dijkstraalgorithm() by passing graph, number and dijkstraalgorithm(graph, source); return 0; pre> <p> <strong>Output</strong> </p> <pre> Distance from the Source Node to 1: 4 Distance from the Source Node to 2: 12 Distance from the Source Node to 3: 19 Distance from the Source Node to 4: 12 Distance from the Source Node to 5: 8 Distance from the Source Node to 6: 10 </pre> <p> <strong>Explanation:</strong> </p> <p>In the above snippet of code, we have included the <strong>stdio.h</strong> header file defined two constant values: <strong>INF = 9999</strong> and <strong>MAX = 10</strong> . We have declared the prototyping of the function and then defined the function for Dijkstra&apos;s Algorithm as <strong>DijkstraAlgorithm</strong> that accepts three arguments - the Graph consisting of the nodes, the number of nodes in the Graph, and the source node. Inside this function, we have defined some data structures such as a 2D matrix that will work as the Priority Queue for the algorithm, an array to main the distance between the nodes, an array to maintain the record of previous nodes, an array to store the visited nodes information, and some integer variables to store minimum distance value, counter, next node value and more. We then used a <strong>nested for-loop</strong> to iterate through the nodes of the Graph and add them to the priority queue accordingly. We have again used the <strong>for-loop</strong> to iterate through the elements in the priority queue starting from the source node and update their distances. Outside the loop, we have set the distance of the source node as <strong>0</strong> and marked it as visited in the <strong>visited_nodes[]</strong> array. We then set the counter value as one and used the <strong>while</strong> loop iterating through the number of nodes. Inside this loop, we have set the value of <strong>minimum_distance</strong> as <strong>INF</strong> and used the <strong>for-loop</strong> to update the value of the <strong>minimum_distance</strong> variable with the minimum value from a <strong>distance[]</strong> array. We then iterated through the unvisited neighboring nodes of the selected node using the <strong>for-loop</strong> and performed relaxation. We then printed the resulting data of the distances calculated using Dijkstra&apos;s Algorithm.</p> <p>In the <strong>main</strong> function, we have defined and declared the variables representing the Graph, the number of nodes, and the source node. At last, we have called the <strong>DijkstraAlgorithm()</strong> function by passing the required parameters.</p> <p>As a result, the required shortest possible paths for every node from the source node are printed for the users.</p> <h3>Code for Dijkstra&apos;s Algorithm in C++</h3> <p>The following is the implementation of Dijkstra&apos;s Algorithm in the C++ Programming Language:</p> <p> <strong>File: DijkstraAlgorithm.cpp</strong> </p> <pre> // Implementation of Dijkstra&apos;s Algorithm in C++ // importing the required header files #include #include // defining constant #define MAX_INT 10000000 // using the standard namespace using namespace std; // prototyping of the DijkstraAlgorithm() function void DijkstraAlgorithm(); // main function int main() { DijkstraAlgorithm(); return 0; } // declaring the classes class Vertex; class Edge; // prototyping the functions void Dijkstra(); vector* Adjacent_Remaining_Nodes(Vertex* vertex); Vertex* Extract_Smallest(vector&amp; vertices); int Distance(Vertex* vertexOne, Vertex* vertexTwo); bool Contains(vector&amp; vertices, Vertex* vertex); void Print_Shortest_Route_To(Vertex* des); // instantiating the classes vector vertices; vector edges; // defining the class for the vertices of the graph class Vertex { public: Vertex(char id) : id(id), prev(NULL), distance_from_start(MAX_INT) { vertices.push_back(this); } public: char id; Vertex* prev; int distance_from_start; }; // defining the class for the edges of the graph class Edge { public: Edge(Vertex* vertexOne, Vertex* vertexTwo, int distance) : vertexOne(vertexOne), vertexTwo(vertexTwo), distance(distance) { edges.push_back(this); } bool Connects(Vertex* vertexOne, Vertex* vertexTwo) public: Vertex* vertexOne; Vertex* vertexTwo; int distance; }; // defining the function to collect the details of the graph void DijkstraAlgorithm() { // declaring some vertices Vertex* vertex_a = new Vertex(&apos;A&apos;); Vertex* vertex_b = new Vertex(&apos;B&apos;); Vertex* vertex_c = new Vertex(&apos;C&apos;); Vertex* vertex_d = new Vertex(&apos;D&apos;); Vertex* vertex_e = new Vertex(&apos;E&apos;); Vertex* vertex_f = new Vertex(&apos;F&apos;); Vertex* vertex_g = new Vertex(&apos;G&apos;); // declaring some edges Edge* edge_1 = new Edge(vertex_a, vertex_c, 1); Edge* edge_2 = new Edge(vertex_a, vertex_d, 2); Edge* edge_3 = new Edge(vertex_b, vertex_c, 2); Edge* edge_4 = new Edge(vertex_c, vertex_d, 1); Edge* edge_5 = new Edge(vertex_b, vertex_f, 3); Edge* edge_6 = new Edge(vertex_c, vertex_e, 3); Edge* edge_7 = new Edge(vertex_e, vertex_f, 2); Edge* edge_8 = new Edge(vertex_d, vertex_g, 1); Edge* edge_9 = new Edge(vertex_g, vertex_f, 1); vertex_a -&gt; distance_from_start = 0; // setting a start vertex // calling the Dijkstra() function to find the shortest route possible Dijkstra(); // calling the Print_Shortest_Route_To() function to print the shortest route from the source vertex to the destination vertex Print_Shortest_Route_To(vertex_f); } // defining the function for Dijkstra&apos;s Algorithm void Dijkstra() { while (vertices.size() &gt; 0) { Vertex* smallest = Extract_Smallest(vertices); vector* adjacent_nodes = Adjacent_Remaining_Nodes(smallest); const int size = adjacent_nodes -&gt; size(); for (int i = 0; i at(i); int distance = Distance(smallest, adjacent) + smallest -&gt; distance_from_start; if (distance distance_from_start) { adjacent -&gt; distance_from_start = distance; adjacent -&gt; prev = smallest; } } delete adjacent_nodes; } } // defining the function to find the vertex with the shortest distance, removing it, and returning it Vertex* Extract_Smallest(vector&amp; vertices) { int size = vertices.size(); if (size == 0) return NULL; int smallest_position = 0; Vertex* smallest = vertices.at(0); for (int i = 1; i distance_from_start distance_from_start) { smallest = current; smallest_position = i; } } vertices.erase(vertices.begin() + smallest_position); return smallest; } // defining the function to return all vertices adjacent to &apos;vertex&apos; which are still in the &apos;vertices&apos; collection. vector* Adjacent_Remaining_Nodes(Vertex* vertex) { vector* adjacent_nodes = new vector(); const int size = edges.size(); for (int i = 0; i vertexOne == vertex) { adjacent = edge -&gt; vertexTwo; } else if (edge -&gt; vertexTwo == vertex) { adjacent = edge -&gt; vertexOne; } if (adjacent &amp;&amp; Contains(vertices, adjacent)) { adjacent_nodes -&gt; push_back(adjacent); } } return adjacent_nodes; } // defining the function to return distance between two connected vertices int Distance(Vertex* vertexOne, Vertex* vertexTwo) { const int size = edges.size(); for (int i = 0; i Connects(vertexOne, vertexTwo)) { return edge -&gt; distance; } } return -1; // should never happen } // defining the function to check if the &apos;vertices&apos; vector contains &apos;vertex&apos; bool Contains(vector&amp; vertices, Vertex* vertex) { const int size = vertices.size(); for (int i = 0; i <size; ++i) { if (vertex="=" vertices.at(i)) return true; } false; defining the function to print shortest route destination void print_shortest_route_to(vertex* des) vertex* prev="des;" cout << 'distance from start: ' < distance_from_start endl; while (prev) id prev; pre> <p> <strong>Output</strong> </p> <pre> Distance from start: 4 F G D A </pre> <p> <strong>Explanation:</strong> </p> <p>In the above code snippet, we included the <strong>&apos;iostream&apos;</strong> and <strong>&apos;vector&apos;</strong> header files and defined a constant value as <strong>MAX_INT = 10000000</strong> . We then used the standard namespace and prototyped the <strong>DijkstraAlgorithm()</strong> function. We then defined the main function of the program within, which we have called the <strong>DijkstraAlgorithm()</strong> function. After that, we declared some classes to create vertices and edges. We have also prototyped more functions to find the shortest possible path from the source vertex to the destination vertex and instantiated the Vertex and Edge classes. We then defined both classes to create the vertices and edges of the graph. We have then defined the <strong>DijkstraAlgorithm()</strong> function to create a graph and perform different operations. Inside this function, we have declared some vertices and edges. We then set the source vertex of the graph and called the <strong>Dijkstra()</strong> function to find the shortest possible distance and <strong>Print_Shortest_Route_To()</strong> function to print the shortest distance from the source vertex to vertex <strong>&apos;F&apos;</strong> . We have then defined the <strong>Dijkstra()</strong> function to calculate the shortest possible distances of the all the vertices from the source vertex. We have also defined some more functions to find the vertex with the shortest distance to return all the vertices adjacent to the remaining vertex, to return the distance between two connected vertices, to check if the selected vertex exists in the graph, and to print the shortest possible path from the source vertex to the destination vertex.</p> <p>As a result, the required shortest path for the vertex <strong>&apos;F&apos;</strong> from the source node is printed for the users.</p> <h3>Code for Dijkstra&apos;s Algorithm in Java</h3> <p>The following is the implementation of Dijkstra&apos;s Algorithm in the Java Programming Language:</p> <p> <strong>File: DijkstraAlgorithm.java</strong> </p> <pre> // Implementation of Dijkstra&apos;s Algorithm in Java // defining the public class for Dijkstra&apos;s Algorithm public class DijkstraAlgorithm { // defining the method to implement Dijkstra&apos;s Algorithm public void dijkstraAlgorithm(int[][] graph, int source) { // number of nodes int nodes = graph.length; boolean[] visited_vertex = new boolean[nodes]; int[] dist = new int[nodes]; for (int i = 0; i <nodes; 0 1 i++) { visited_vertex[i]="false;" dist[i]="Integer.MAX_VALUE;" } distance of self loop is zero dist[source]="0;" for (int i="0;" < nodes; updating the between neighboring vertex and source int u="find_min_distance(dist," visited_vertex); visited_vertex[u]="true;" distances all vertices v="0;" v++) if (!visited_vertex[v] && graph[u][v] !="0" (dist[u] + dist[v])) dist[v]="dist[u]" graph[u][v]; dist.length; system.out.println(string.format('distance from %s to %s', source, i, dist[i])); defining method find minimum private static find_min_distance(int[] dist, boolean[] visited_vertex) minimum_distance="Integer.MAX_VALUE;" minimum_distance_vertex="-1;" (!visited_vertex[i] minimum_distance) return minimum_distance_vertex; main function public void main(string[] args) declaring nodes graphs graph[][]="new" int[][] 0, 1, 2, }, 3, }; instantiating dijkstraalgorithm() class dijkstraalgorithm test="new" dijkstraalgorithm(); calling shortest node destination test.dijkstraalgorithm(graph, 0); pre> <p> <strong>Output</strong> </p> <pre> Distance from Vertex 0 to Vertex 0 is 0 Distance from Vertex 0 to Vertex 1 is 1 Distance from Vertex 0 to Vertex 2 is 1 Distance from Vertex 0 to Vertex 3 is 2 Distance from Vertex 0 to Vertex 4 is 4 Distance from Vertex 0 to Vertex 5 is 4 Distance from Vertex 0 to Vertex 6 is 3 </pre> <p> <strong>Explanation:</strong> </p> <p>In the above snippet of code, we have defined a public class as <strong>DijkstraAlgorithm()</strong> . Inside this class, we have defined a public method as <strong>dijkstraAlgorithm()</strong> to find the shortest distance from the source vertex to the destination vertex. Inside this method, we have defined a variable to store the number of nodes. We have then defined a Boolean array to store the information regarding the visited vertices and an integer array to store their respective distances. Initially, we declared the values in both the arrays as <strong>False</strong> and <strong>MAX_VALUE</strong> , respectively. We have also set the distance of the source vertex as zero and used the <strong>for-loop</strong> to update the distance between the source vertex and destination vertices with the minimum distance. We have then updated the distances of the neighboring vertices of the selected vertex by performing relaxation and printed the shortest distances for every vertex. We have then defined a method to find the minimum distance from the source vertex to the destination vertex. We then defined the main function where we declared the vertices of the graph and instantiated the <strong>DijkstraAlgorithm()</strong> class. Finally, we have called the <strong>dijkstraAlgorithm()</strong> method to find the shortest distance between the source vertex and the destination vertices.</p> <p>As a result, the required shortest possible paths for every node from the source node are printed for the users.</p> <h3>Code for Dijkstra&apos;s Algorithm in Python</h3> <p>The following is the implementation of Dijkstra&apos;s Algorithm in the Python Programming Language:</p> <p> <strong>File: DikstraAlgorithm.py</strong> </p> <pre> # Implementation of Dijkstra&apos;s Algorithm in Python # importing the sys module import sys # declaring the list of nodes for the graph nodes = [ [0, 0, 1, 0, 1, 0, 0], [0, 0, 1, 0, 0, 1, 0], [1, 1, 0, 1, 1, 0, 0], [1, 0, 1, 0, 0, 0, 1], [0, 0, 1, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 1], [0, 0, 0, 1, 0, 1, 0] ] # declaring the list of edges for the graph edges = [ [0, 0, 1, 0, 2, 0, 0], [0, 0, 2, 0, 0, 3, 0], [1, 2, 0, 1, 3, 0, 0], [2, 0, 1, 0, 0, 0, 1], [0, 0, 3, 0, 0, 2, 0], [0, 3, 0, 0, 2, 0, 1], [0, 0, 0, 1, 0, 1, 0] ] # defining the function to find which node is to be visited next def toBeVisited(): global visitedAndDistance v = -10 for index in range(numberOfNodes): if visitedAndDistance[index][0] == 0 and (v <0 1 or visitedanddistance[index][1] <="visitedAndDistance[v][1]):" v="index" return # finding the number of nodes in graph numberofnodes="len(nodes[0])" visitedanddistance="[[0," 0]] for i range(numberofnodes - 1): visitedanddistance.append([0, sys.maxsize]) node range(numberofnodes): next to be visited tovisit="toBeVisited()" neighborindex updating new distances if nodes[tovisit][neighborindex]="=" and visitedanddistance[neighborindex][0]="=" 0: newdistance="visitedAndDistance[toVisit][1]" + edges[tovisit][neighborindex] visitedanddistance[neighborindex][1]> newDistance: visitedAndDistance[neighborIndex][1] = newDistance visitedAndDistance[toVisit][0] = 1 i = 0 # printing the distance for distance in visitedAndDistance: print(&apos;Distance of&apos;, chr(ord(&apos;A&apos;) + i), &apos;from source node:&apos;, distance[1]) i = i + 1 </0></pre> <p> <strong>Output</strong> </p> <pre> Distance of A from source node: 0 Distance of B from source node: 3 Distance of C from source node: 1 Distance of D from source node: 2 Distance of E from source node: 2 Distance of F from source node: 4 Distance of G from source node: 3 </pre> <p> <strong>Explanation:</strong> </p> <p>In the above snippet of code, we have imported the <strong>sys</strong> module and declared the lists consisting of the values for the nodes and edges. We have then defined a function as <strong>toBeVisited()</strong> to find which node will be visited next. We then found the total number of nodes in the graph and set the initial distances for every node. We have then calculated the minimum distance from the source node to the destination node, performed relaxation on neighboring nodes, and updated the distances in the list. We then printed those distances from the list for the users.</p> <p>As a result, the required shortest possible paths for every node from the source node are printed for the users.</p> <h2>Time and Space Complexity of Dijkstra&apos;s Algorithm</h2> <ul> <li>The Time Complexity of Dijkstra&apos;s Algorithm is <strong>O(E log V)</strong> , where E is the number of edges and V is the number of vertices.</li> <li>The Space Complexity of Dijkstra&apos;s Algorithm is O(V), where V is the number of vertices.</li> </ul> <h2>Advantages and Disadvantages of Dijkstra&apos;s Algorithm</h2> <p> <strong>Let us discuss some advantages of Dijkstra&apos;s Algorithm:</strong> </p> <ol class="points"> <li>One primary advantage of using Dijkstra&apos;s Algorithm is that it has an almost linear time and space complexity.</li> <li>We can use this algorithm to calculate the shortest path from a single vertex to all other vertices and a single source vertex to a single destination vertex by stopping the algorithm once we get the shortest distance for the destination vertex.</li> <li>This algorithm only works for directed weighted graphs, and all the edges of this graph should be non-negative.</li> </ol> <p> <strong>Despite having multiple advantages, Dijkstra&apos;s algorithm has some disadvantages also, such as:</strong> </p> <ol class="points"> <li>Dijkstra&apos;s Algorithm performs a concealed exploration that utilizes a lot of time during the process.</li> <li>This algorithm is impotent to handle negative edges.</li> <li>Since this algorithm heads to the acyclic graph, it cannot calculate the exact shortest path.</li> <li>It also requires maintenance to keep a record of vertices that have been visited.</li> </ol> <h2>Some Applications of Dijkstra&apos;s Algorithm</h2> <p> <strong>Dijkstra&apos;s Algorithm has various real-world applications, some of which are stated below:</strong> </p> <ol class="points"> <tr><td>Digital Mapping Services in Google Maps:</td> There are various times when we have tried to find the distance in Google Maps either from our location to the nearest preferred location or from one city to another, which comprises multiple routes/paths connecting them; however, the application must display the minimum distance. This is only possible because Dijkstra&apos;s algorithm helps the application find the shortest between two given locations along the path. Let us consider the USA as a graph wherein the cities/places are represented as vertices, and the routes between two cities/places are represented as edges. Then with the help of Dijkstra&apos;s Algorithm, we can calculate the shortest routes between any two cities/places. </tr><tr><td>Social Networking Applications:</td> In many applications like Facebook, Twitter, Instagram, and more, many of us might have observed that these apps suggest the list of friends that a specific user may know. How do many social media companies implement this type of feature in an efficient and effective way, specifically when the system has over a billion users? The answer to this question is Dijkstra&apos;s Algorithm. The standard Dijkstra&apos;s Algorithm is generally used to estimate the shortest distance between the users measured through the connections or mutuality among them. When social networking is very small, it uses the standard Dijkstra&apos;s Algorithm in addition to some other features in order to determine the shortest paths. However, when the graph is much bigger, the standard algorithm takes several seconds to count, and thus, some advanced algorithms are used as the alternative. </tr><tr><td>Telephone Network:</td> As some of us might know, in a telephone network, each transmission line has a bandwidth, &apos;b&apos;. The bandwidth is the highest frequency that the transmission line can support. In general, if the frequency of the signal is higher in a specific line, the signal is reduced by that line. Bandwidth represents the amount of information that can be transmitted by the line. Let us consider a city a graph wherein the switching stations are represented using the vertices, the transmission lines are represented as the edges, and the bandwidth, &apos;b&apos;, is represented using the weight of the edges. Thus, as we can observe, the telephone network can also fall into the category of the shortest distance problem and can be solved using Dijkstra&apos;s Algorithm. </tr><tr><td>Flight Program:</td> Suppose that a person requires software to prepare an agenda of flights for customers. The agent has access to a database with all flights and airports. In addition to the flight number, origin airport, and destination, the flights also have departure and arrival times. So, in order to determine the earliest arrival time for the selected destination from the original airport and given start time, the agents make use of Dijkstra&apos;s Algorithm. </tr><tr><td>IP routing to find Open Shortest Path First:</td> Open Shortest Path First (abbreviated as OSPF) is a link-state routing protocol used to find the best path between the source and destination router with the help of its own Shortest Path First. Dijkstra&apos;s Algorithm is extensively utilized in the routing protocols required by the routers in order to update their forwarding table. The algorithm gives the shortest cost path from the source router to the other routers present in the network. </tr><tr><td>Robotic Path:</td> These days, drones and robots have come into existence, some operated manually and some automatically. The drones and robots which are operated automatically and used to deliver the packages to a given location or used for any certain task are configured with Dijkstra&apos;s Algorithm module so that whenever the source and destination are known, the drone and robot will move in the ordered direction by following the shortest path keeping the time taken to a minimum in order to deliver the packages. </tr><tr><td>Designate the File Server:</td> Dijkstra&apos;s Algorithm is also used to designate a file server in a Local Area Network (LAN). Suppose that an infinite period of time is needed for the transmission of the files from one computer to another. So, to minimize the number of &apos;hops&apos; from the file server to every other computer on the network, we will use Dijkstra&apos;s Algorithm. This algorithm will return the shortest path between the networks resulting in the minimum number of hops. </tr></ol> <h2>The Conclusion</h2> <ul> <li>In the above tutorial, firstly, we have understood the basic concepts of Graph along with its types and applications.</li> <li>We then learned about Dijkstra&apos;s Algorithm and its history.</li> <li>We have also understood the fundamental working of Dijkstra&apos;s Algorithm with the help of an example.</li> <li>After that, we studied how to write code for Dijkstra&apos;s Algorithm with the help of Pseudocode.</li> <li>We observed its implementation in programming languages like C, C++, Java, and Python with proper outputs and explanations.</li> <li>We have also understood the Time and Space Complexity of Dijkstra&apos;s Algorithm.</li> <li>Finally, we have discussed the advantages and disadvantages of Dijkstra&apos;s algorithm and some of its real-life applications.</li> </ul> <hr></nodes;></pre></size;></pre></size;></pre></distance[n]>

Explicación:

En el fragmento de código anterior, hemos incluido el stdio.h El archivo de encabezado definió dos valores constantes: INF = 9999 y MÁXIMO = 10 . Hemos declarado el prototipo de la función y luego definimos la función para el algoritmo de Dijkstra como Algoritmo de Dijkstra que acepta tres argumentos: el gráfico que consta de los nodos, el número de nodos en el gráfico y el nodo de origen. Dentro de esta función, hemos definido algunas estructuras de datos, como una matriz 2D que funcionará como cola de prioridad para el algoritmo, una matriz para mantener la distancia entre los nodos, una matriz para mantener el registro de nodos anteriores, una matriz para almacenar la información de los nodos visitados y algunas variables enteras para almacenar el valor de distancia mínima, el contador, el valor del siguiente nodo y más. Luego usamos un bucle for anidado para iterar a través de los nodos del gráfico y agregarlos a la cola de prioridad en consecuencia. Hemos vuelto a utilizar el en bucle para iterar a través de los elementos en la cola de prioridad comenzando desde el nodo de origen y actualizar sus distancias. Fuera del bucle, hemos establecido la distancia del nodo fuente como 0 y lo marcó como visitado en el nodos_visitados[] formación. Luego configuramos el valor del contador como uno y usamos el mientras bucle que itera a través del número de nodos. Dentro de este bucle, hemos establecido el valor de distancia minima como INF y usé el en bucle para actualizar el valor del distancia minima variable con el valor mínimo de una distancia[] formación. Luego iteramos a través de los nodos vecinos no visitados del nodo seleccionado usando el en bucle y realizó relajación. Luego imprimimos los datos resultantes de las distancias calculadas utilizando el algoritmo de Dijkstra.

En el principal función, hemos definido y declarado las variables que representan el gráfico, el número de nodos y el nodo de origen. Por fin hemos llamado a Algoritmo de Dijkstra() función pasando los parámetros requeridos.

Como resultado, se imprimen para los usuarios las rutas más cortas posibles requeridas para cada nodo desde el nodo de origen.

Código para el algoritmo de Dijkstra en C++

La siguiente es la implementación del algoritmo de Dijkstra en el lenguaje de programación C++:

Archivo: DijkstraAlgorithm.cpp

 // Implementation of Dijkstra&apos;s Algorithm in C++ // importing the required header files #include #include // defining constant #define MAX_INT 10000000 // using the standard namespace using namespace std; // prototyping of the DijkstraAlgorithm() function void DijkstraAlgorithm(); // main function int main() { DijkstraAlgorithm(); return 0; } // declaring the classes class Vertex; class Edge; // prototyping the functions void Dijkstra(); vector* Adjacent_Remaining_Nodes(Vertex* vertex); Vertex* Extract_Smallest(vector&amp; vertices); int Distance(Vertex* vertexOne, Vertex* vertexTwo); bool Contains(vector&amp; vertices, Vertex* vertex); void Print_Shortest_Route_To(Vertex* des); // instantiating the classes vector vertices; vector edges; // defining the class for the vertices of the graph class Vertex { public: Vertex(char id) : id(id), prev(NULL), distance_from_start(MAX_INT) { vertices.push_back(this); } public: char id; Vertex* prev; int distance_from_start; }; // defining the class for the edges of the graph class Edge { public: Edge(Vertex* vertexOne, Vertex* vertexTwo, int distance) : vertexOne(vertexOne), vertexTwo(vertexTwo), distance(distance) { edges.push_back(this); } bool Connects(Vertex* vertexOne, Vertex* vertexTwo) public: Vertex* vertexOne; Vertex* vertexTwo; int distance; }; // defining the function to collect the details of the graph void DijkstraAlgorithm() { // declaring some vertices Vertex* vertex_a = new Vertex(&apos;A&apos;); Vertex* vertex_b = new Vertex(&apos;B&apos;); Vertex* vertex_c = new Vertex(&apos;C&apos;); Vertex* vertex_d = new Vertex(&apos;D&apos;); Vertex* vertex_e = new Vertex(&apos;E&apos;); Vertex* vertex_f = new Vertex(&apos;F&apos;); Vertex* vertex_g = new Vertex(&apos;G&apos;); // declaring some edges Edge* edge_1 = new Edge(vertex_a, vertex_c, 1); Edge* edge_2 = new Edge(vertex_a, vertex_d, 2); Edge* edge_3 = new Edge(vertex_b, vertex_c, 2); Edge* edge_4 = new Edge(vertex_c, vertex_d, 1); Edge* edge_5 = new Edge(vertex_b, vertex_f, 3); Edge* edge_6 = new Edge(vertex_c, vertex_e, 3); Edge* edge_7 = new Edge(vertex_e, vertex_f, 2); Edge* edge_8 = new Edge(vertex_d, vertex_g, 1); Edge* edge_9 = new Edge(vertex_g, vertex_f, 1); vertex_a -&gt; distance_from_start = 0; // setting a start vertex // calling the Dijkstra() function to find the shortest route possible Dijkstra(); // calling the Print_Shortest_Route_To() function to print the shortest route from the source vertex to the destination vertex Print_Shortest_Route_To(vertex_f); } // defining the function for Dijkstra&apos;s Algorithm void Dijkstra() { while (vertices.size() &gt; 0) { Vertex* smallest = Extract_Smallest(vertices); vector* adjacent_nodes = Adjacent_Remaining_Nodes(smallest); const int size = adjacent_nodes -&gt; size(); for (int i = 0; i at(i); int distance = Distance(smallest, adjacent) + smallest -&gt; distance_from_start; if (distance distance_from_start) { adjacent -&gt; distance_from_start = distance; adjacent -&gt; prev = smallest; } } delete adjacent_nodes; } } // defining the function to find the vertex with the shortest distance, removing it, and returning it Vertex* Extract_Smallest(vector&amp; vertices) { int size = vertices.size(); if (size == 0) return NULL; int smallest_position = 0; Vertex* smallest = vertices.at(0); for (int i = 1; i distance_from_start distance_from_start) { smallest = current; smallest_position = i; } } vertices.erase(vertices.begin() + smallest_position); return smallest; } // defining the function to return all vertices adjacent to &apos;vertex&apos; which are still in the &apos;vertices&apos; collection. vector* Adjacent_Remaining_Nodes(Vertex* vertex) { vector* adjacent_nodes = new vector(); const int size = edges.size(); for (int i = 0; i vertexOne == vertex) { adjacent = edge -&gt; vertexTwo; } else if (edge -&gt; vertexTwo == vertex) { adjacent = edge -&gt; vertexOne; } if (adjacent &amp;&amp; Contains(vertices, adjacent)) { adjacent_nodes -&gt; push_back(adjacent); } } return adjacent_nodes; } // defining the function to return distance between two connected vertices int Distance(Vertex* vertexOne, Vertex* vertexTwo) { const int size = edges.size(); for (int i = 0; i Connects(vertexOne, vertexTwo)) { return edge -&gt; distance; } } return -1; // should never happen } // defining the function to check if the &apos;vertices&apos; vector contains &apos;vertex&apos; bool Contains(vector&amp; vertices, Vertex* vertex) { const int size = vertices.size(); for (int i = 0; i <size; ++i) { if (vertex="=" vertices.at(i)) return true; } false; defining the function to print shortest route destination void print_shortest_route_to(vertex* des) vertex* prev="des;" cout << \'distance from start: \' < distance_from_start endl; while (prev) id prev; pre> <p> <strong>Output</strong> </p> <pre> Distance from start: 4 F G D A </pre> <p> <strong>Explanation:</strong> </p> <p>In the above code snippet, we included the <strong>&apos;iostream&apos;</strong> and <strong>&apos;vector&apos;</strong> header files and defined a constant value as <strong>MAX_INT = 10000000</strong> . We then used the standard namespace and prototyped the <strong>DijkstraAlgorithm()</strong> function. We then defined the main function of the program within, which we have called the <strong>DijkstraAlgorithm()</strong> function. After that, we declared some classes to create vertices and edges. We have also prototyped more functions to find the shortest possible path from the source vertex to the destination vertex and instantiated the Vertex and Edge classes. We then defined both classes to create the vertices and edges of the graph. We have then defined the <strong>DijkstraAlgorithm()</strong> function to create a graph and perform different operations. Inside this function, we have declared some vertices and edges. We then set the source vertex of the graph and called the <strong>Dijkstra()</strong> function to find the shortest possible distance and <strong>Print_Shortest_Route_To()</strong> function to print the shortest distance from the source vertex to vertex <strong>&apos;F&apos;</strong> . We have then defined the <strong>Dijkstra()</strong> function to calculate the shortest possible distances of the all the vertices from the source vertex. We have also defined some more functions to find the vertex with the shortest distance to return all the vertices adjacent to the remaining vertex, to return the distance between two connected vertices, to check if the selected vertex exists in the graph, and to print the shortest possible path from the source vertex to the destination vertex.</p> <p>As a result, the required shortest path for the vertex <strong>&apos;F&apos;</strong> from the source node is printed for the users.</p> <h3>Code for Dijkstra&apos;s Algorithm in Java</h3> <p>The following is the implementation of Dijkstra&apos;s Algorithm in the Java Programming Language:</p> <p> <strong>File: DijkstraAlgorithm.java</strong> </p> <pre> // Implementation of Dijkstra&apos;s Algorithm in Java // defining the public class for Dijkstra&apos;s Algorithm public class DijkstraAlgorithm { // defining the method to implement Dijkstra&apos;s Algorithm public void dijkstraAlgorithm(int[][] graph, int source) { // number of nodes int nodes = graph.length; boolean[] visited_vertex = new boolean[nodes]; int[] dist = new int[nodes]; for (int i = 0; i <nodes; 0 1 i++) { visited_vertex[i]="false;" dist[i]="Integer.MAX_VALUE;" } distance of self loop is zero dist[source]="0;" for (int i="0;" < nodes; updating the between neighboring vertex and source int u="find_min_distance(dist," visited_vertex); visited_vertex[u]="true;" distances all vertices v="0;" v++) if (!visited_vertex[v] && graph[u][v] !="0" (dist[u] + dist[v])) dist[v]="dist[u]" graph[u][v]; dist.length; system.out.println(string.format(\'distance from %s to %s\', source, i, dist[i])); defining method find minimum private static find_min_distance(int[] dist, boolean[] visited_vertex) minimum_distance="Integer.MAX_VALUE;" minimum_distance_vertex="-1;" (!visited_vertex[i] minimum_distance) return minimum_distance_vertex; main function public void main(string[] args) declaring nodes graphs graph[][]="new" int[][] 0, 1, 2, }, 3, }; instantiating dijkstraalgorithm() class dijkstraalgorithm test="new" dijkstraalgorithm(); calling shortest node destination test.dijkstraalgorithm(graph, 0); pre> <p> <strong>Output</strong> </p> <pre> Distance from Vertex 0 to Vertex 0 is 0 Distance from Vertex 0 to Vertex 1 is 1 Distance from Vertex 0 to Vertex 2 is 1 Distance from Vertex 0 to Vertex 3 is 2 Distance from Vertex 0 to Vertex 4 is 4 Distance from Vertex 0 to Vertex 5 is 4 Distance from Vertex 0 to Vertex 6 is 3 </pre> <p> <strong>Explanation:</strong> </p> <p>In the above snippet of code, we have defined a public class as <strong>DijkstraAlgorithm()</strong> . Inside this class, we have defined a public method as <strong>dijkstraAlgorithm()</strong> to find the shortest distance from the source vertex to the destination vertex. Inside this method, we have defined a variable to store the number of nodes. We have then defined a Boolean array to store the information regarding the visited vertices and an integer array to store their respective distances. Initially, we declared the values in both the arrays as <strong>False</strong> and <strong>MAX_VALUE</strong> , respectively. We have also set the distance of the source vertex as zero and used the <strong>for-loop</strong> to update the distance between the source vertex and destination vertices with the minimum distance. We have then updated the distances of the neighboring vertices of the selected vertex by performing relaxation and printed the shortest distances for every vertex. We have then defined a method to find the minimum distance from the source vertex to the destination vertex. We then defined the main function where we declared the vertices of the graph and instantiated the <strong>DijkstraAlgorithm()</strong> class. Finally, we have called the <strong>dijkstraAlgorithm()</strong> method to find the shortest distance between the source vertex and the destination vertices.</p> <p>As a result, the required shortest possible paths for every node from the source node are printed for the users.</p> <h3>Code for Dijkstra&apos;s Algorithm in Python</h3> <p>The following is the implementation of Dijkstra&apos;s Algorithm in the Python Programming Language:</p> <p> <strong>File: DikstraAlgorithm.py</strong> </p> <pre> # Implementation of Dijkstra&apos;s Algorithm in Python # importing the sys module import sys # declaring the list of nodes for the graph nodes = [ [0, 0, 1, 0, 1, 0, 0], [0, 0, 1, 0, 0, 1, 0], [1, 1, 0, 1, 1, 0, 0], [1, 0, 1, 0, 0, 0, 1], [0, 0, 1, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 1], [0, 0, 0, 1, 0, 1, 0] ] # declaring the list of edges for the graph edges = [ [0, 0, 1, 0, 2, 0, 0], [0, 0, 2, 0, 0, 3, 0], [1, 2, 0, 1, 3, 0, 0], [2, 0, 1, 0, 0, 0, 1], [0, 0, 3, 0, 0, 2, 0], [0, 3, 0, 0, 2, 0, 1], [0, 0, 0, 1, 0, 1, 0] ] # defining the function to find which node is to be visited next def toBeVisited(): global visitedAndDistance v = -10 for index in range(numberOfNodes): if visitedAndDistance[index][0] == 0 and (v <0 1 or visitedanddistance[index][1] <="visitedAndDistance[v][1]):" v="index" return # finding the number of nodes in graph numberofnodes="len(nodes[0])" visitedanddistance="[[0," 0]] for i range(numberofnodes - 1): visitedanddistance.append([0, sys.maxsize]) node range(numberofnodes): next to be visited tovisit="toBeVisited()" neighborindex updating new distances if nodes[tovisit][neighborindex]="=" and visitedanddistance[neighborindex][0]="=" 0: newdistance="visitedAndDistance[toVisit][1]" + edges[tovisit][neighborindex] visitedanddistance[neighborindex][1]> newDistance: visitedAndDistance[neighborIndex][1] = newDistance visitedAndDistance[toVisit][0] = 1 i = 0 # printing the distance for distance in visitedAndDistance: print(&apos;Distance of&apos;, chr(ord(&apos;A&apos;) + i), &apos;from source node:&apos;, distance[1]) i = i + 1 </0></pre> <p> <strong>Output</strong> </p> <pre> Distance of A from source node: 0 Distance of B from source node: 3 Distance of C from source node: 1 Distance of D from source node: 2 Distance of E from source node: 2 Distance of F from source node: 4 Distance of G from source node: 3 </pre> <p> <strong>Explanation:</strong> </p> <p>In the above snippet of code, we have imported the <strong>sys</strong> module and declared the lists consisting of the values for the nodes and edges. We have then defined a function as <strong>toBeVisited()</strong> to find which node will be visited next. We then found the total number of nodes in the graph and set the initial distances for every node. We have then calculated the minimum distance from the source node to the destination node, performed relaxation on neighboring nodes, and updated the distances in the list. We then printed those distances from the list for the users.</p> <p>As a result, the required shortest possible paths for every node from the source node are printed for the users.</p> <h2>Time and Space Complexity of Dijkstra&apos;s Algorithm</h2> <ul> <li>The Time Complexity of Dijkstra&apos;s Algorithm is <strong>O(E log V)</strong> , where E is the number of edges and V is the number of vertices.</li> <li>The Space Complexity of Dijkstra&apos;s Algorithm is O(V), where V is the number of vertices.</li> </ul> <h2>Advantages and Disadvantages of Dijkstra&apos;s Algorithm</h2> <p> <strong>Let us discuss some advantages of Dijkstra&apos;s Algorithm:</strong> </p> <ol class="points"> <li>One primary advantage of using Dijkstra&apos;s Algorithm is that it has an almost linear time and space complexity.</li> <li>We can use this algorithm to calculate the shortest path from a single vertex to all other vertices and a single source vertex to a single destination vertex by stopping the algorithm once we get the shortest distance for the destination vertex.</li> <li>This algorithm only works for directed weighted graphs, and all the edges of this graph should be non-negative.</li> </ol> <p> <strong>Despite having multiple advantages, Dijkstra&apos;s algorithm has some disadvantages also, such as:</strong> </p> <ol class="points"> <li>Dijkstra&apos;s Algorithm performs a concealed exploration that utilizes a lot of time during the process.</li> <li>This algorithm is impotent to handle negative edges.</li> <li>Since this algorithm heads to the acyclic graph, it cannot calculate the exact shortest path.</li> <li>It also requires maintenance to keep a record of vertices that have been visited.</li> </ol> <h2>Some Applications of Dijkstra&apos;s Algorithm</h2> <p> <strong>Dijkstra&apos;s Algorithm has various real-world applications, some of which are stated below:</strong> </p> <ol class="points"> <tr><td>Digital Mapping Services in Google Maps:</td> There are various times when we have tried to find the distance in Google Maps either from our location to the nearest preferred location or from one city to another, which comprises multiple routes/paths connecting them; however, the application must display the minimum distance. This is only possible because Dijkstra&apos;s algorithm helps the application find the shortest between two given locations along the path. Let us consider the USA as a graph wherein the cities/places are represented as vertices, and the routes between two cities/places are represented as edges. Then with the help of Dijkstra&apos;s Algorithm, we can calculate the shortest routes between any two cities/places. </tr><tr><td>Social Networking Applications:</td> In many applications like Facebook, Twitter, Instagram, and more, many of us might have observed that these apps suggest the list of friends that a specific user may know. How do many social media companies implement this type of feature in an efficient and effective way, specifically when the system has over a billion users? The answer to this question is Dijkstra&apos;s Algorithm. The standard Dijkstra&apos;s Algorithm is generally used to estimate the shortest distance between the users measured through the connections or mutuality among them. When social networking is very small, it uses the standard Dijkstra&apos;s Algorithm in addition to some other features in order to determine the shortest paths. However, when the graph is much bigger, the standard algorithm takes several seconds to count, and thus, some advanced algorithms are used as the alternative. </tr><tr><td>Telephone Network:</td> As some of us might know, in a telephone network, each transmission line has a bandwidth, &apos;b&apos;. The bandwidth is the highest frequency that the transmission line can support. In general, if the frequency of the signal is higher in a specific line, the signal is reduced by that line. Bandwidth represents the amount of information that can be transmitted by the line. Let us consider a city a graph wherein the switching stations are represented using the vertices, the transmission lines are represented as the edges, and the bandwidth, &apos;b&apos;, is represented using the weight of the edges. Thus, as we can observe, the telephone network can also fall into the category of the shortest distance problem and can be solved using Dijkstra&apos;s Algorithm. </tr><tr><td>Flight Program:</td> Suppose that a person requires software to prepare an agenda of flights for customers. The agent has access to a database with all flights and airports. In addition to the flight number, origin airport, and destination, the flights also have departure and arrival times. So, in order to determine the earliest arrival time for the selected destination from the original airport and given start time, the agents make use of Dijkstra&apos;s Algorithm. </tr><tr><td>IP routing to find Open Shortest Path First:</td> Open Shortest Path First (abbreviated as OSPF) is a link-state routing protocol used to find the best path between the source and destination router with the help of its own Shortest Path First. Dijkstra&apos;s Algorithm is extensively utilized in the routing protocols required by the routers in order to update their forwarding table. The algorithm gives the shortest cost path from the source router to the other routers present in the network. </tr><tr><td>Robotic Path:</td> These days, drones and robots have come into existence, some operated manually and some automatically. The drones and robots which are operated automatically and used to deliver the packages to a given location or used for any certain task are configured with Dijkstra&apos;s Algorithm module so that whenever the source and destination are known, the drone and robot will move in the ordered direction by following the shortest path keeping the time taken to a minimum in order to deliver the packages. </tr><tr><td>Designate the File Server:</td> Dijkstra&apos;s Algorithm is also used to designate a file server in a Local Area Network (LAN). Suppose that an infinite period of time is needed for the transmission of the files from one computer to another. So, to minimize the number of &apos;hops&apos; from the file server to every other computer on the network, we will use Dijkstra&apos;s Algorithm. This algorithm will return the shortest path between the networks resulting in the minimum number of hops. </tr></ol> <h2>The Conclusion</h2> <ul> <li>In the above tutorial, firstly, we have understood the basic concepts of Graph along with its types and applications.</li> <li>We then learned about Dijkstra&apos;s Algorithm and its history.</li> <li>We have also understood the fundamental working of Dijkstra&apos;s Algorithm with the help of an example.</li> <li>After that, we studied how to write code for Dijkstra&apos;s Algorithm with the help of Pseudocode.</li> <li>We observed its implementation in programming languages like C, C++, Java, and Python with proper outputs and explanations.</li> <li>We have also understood the Time and Space Complexity of Dijkstra&apos;s Algorithm.</li> <li>Finally, we have discussed the advantages and disadvantages of Dijkstra&apos;s algorithm and some of its real-life applications.</li> </ul> <hr></nodes;></pre></size;>

Explicación:

En el fragmento de código anterior, incluimos el 'iostream' y 'vector' archivos de encabezado y definió un valor constante como MAX_INT = 10000000 . Luego utilizamos el espacio de nombres estándar y creamos el prototipo del Algoritmo de Dijkstra() función. Luego definimos la función principal del programa, a la que hemos llamado Algoritmo de Dijkstra() función. Después de eso, declaramos algunas clases para crear vértices y aristas. También creamos prototipos de más funciones para encontrar la ruta más corta posible desde el vértice de origen al vértice de destino y creamos instancias de las clases Vertex y Edge. Luego definimos ambas clases para crear los vértices y aristas del gráfico. Luego hemos definido el Algoritmo de Dijkstra() función para crear un gráfico y realizar diferentes operaciones. Dentro de esta función, hemos declarado algunos vértices y aristas. Luego configuramos el vértice fuente del gráfico y llamamos al Dijkstra() función para encontrar la distancia más corta posible y Imprimir_ruta_más_corta_a() función para imprimir la distancia más corta desde el vértice de origen al vértice 'F' . Luego hemos definido el Dijkstra() función para calcular las distancias más cortas posibles de todos los vértices desde el vértice de origen. También hemos definido algunas funciones más para encontrar el vértice con la distancia más corta para devolver todos los vértices adyacentes al vértice restante, para devolver la distancia entre dos vértices conectados, para verificar si el vértice seleccionado existe en el gráfico e imprimir el camino más corto posible desde el vértice de origen al vértice de destino.

Como resultado, el camino más corto requerido para el vértice 'F' del nodo de origen se imprime para los usuarios.

Código para el algoritmo de Dijkstra en Java

La siguiente es la implementación del algoritmo de Dijkstra en el lenguaje de programación Java:

Archivo: DijkstraAlgorithm.java

 // Implementation of Dijkstra&apos;s Algorithm in Java // defining the public class for Dijkstra&apos;s Algorithm public class DijkstraAlgorithm { // defining the method to implement Dijkstra&apos;s Algorithm public void dijkstraAlgorithm(int[][] graph, int source) { // number of nodes int nodes = graph.length; boolean[] visited_vertex = new boolean[nodes]; int[] dist = new int[nodes]; for (int i = 0; i <nodes; 0 1 i++) { visited_vertex[i]="false;" dist[i]="Integer.MAX_VALUE;" } distance of self loop is zero dist[source]="0;" for (int i="0;" < nodes; updating the between neighboring vertex and source int u="find_min_distance(dist," visited_vertex); visited_vertex[u]="true;" distances all vertices v="0;" v++) if (!visited_vertex[v] && graph[u][v] !="0" (dist[u] + dist[v])) dist[v]="dist[u]" graph[u][v]; dist.length; system.out.println(string.format(\'distance from %s to %s\', source, i, dist[i])); defining method find minimum private static find_min_distance(int[] dist, boolean[] visited_vertex) minimum_distance="Integer.MAX_VALUE;" minimum_distance_vertex="-1;" (!visited_vertex[i] minimum_distance) return minimum_distance_vertex; main function public void main(string[] args) declaring nodes graphs graph[][]="new" int[][] 0, 1, 2, }, 3, }; instantiating dijkstraalgorithm() class dijkstraalgorithm test="new" dijkstraalgorithm(); calling shortest node destination test.dijkstraalgorithm(graph, 0); pre> <p> <strong>Output</strong> </p> <pre> Distance from Vertex 0 to Vertex 0 is 0 Distance from Vertex 0 to Vertex 1 is 1 Distance from Vertex 0 to Vertex 2 is 1 Distance from Vertex 0 to Vertex 3 is 2 Distance from Vertex 0 to Vertex 4 is 4 Distance from Vertex 0 to Vertex 5 is 4 Distance from Vertex 0 to Vertex 6 is 3 </pre> <p> <strong>Explanation:</strong> </p> <p>In the above snippet of code, we have defined a public class as <strong>DijkstraAlgorithm()</strong> . Inside this class, we have defined a public method as <strong>dijkstraAlgorithm()</strong> to find the shortest distance from the source vertex to the destination vertex. Inside this method, we have defined a variable to store the number of nodes. We have then defined a Boolean array to store the information regarding the visited vertices and an integer array to store their respective distances. Initially, we declared the values in both the arrays as <strong>False</strong> and <strong>MAX_VALUE</strong> , respectively. We have also set the distance of the source vertex as zero and used the <strong>for-loop</strong> to update the distance between the source vertex and destination vertices with the minimum distance. We have then updated the distances of the neighboring vertices of the selected vertex by performing relaxation and printed the shortest distances for every vertex. We have then defined a method to find the minimum distance from the source vertex to the destination vertex. We then defined the main function where we declared the vertices of the graph and instantiated the <strong>DijkstraAlgorithm()</strong> class. Finally, we have called the <strong>dijkstraAlgorithm()</strong> method to find the shortest distance between the source vertex and the destination vertices.</p> <p>As a result, the required shortest possible paths for every node from the source node are printed for the users.</p> <h3>Code for Dijkstra&apos;s Algorithm in Python</h3> <p>The following is the implementation of Dijkstra&apos;s Algorithm in the Python Programming Language:</p> <p> <strong>File: DikstraAlgorithm.py</strong> </p> <pre> # Implementation of Dijkstra&apos;s Algorithm in Python # importing the sys module import sys # declaring the list of nodes for the graph nodes = [ [0, 0, 1, 0, 1, 0, 0], [0, 0, 1, 0, 0, 1, 0], [1, 1, 0, 1, 1, 0, 0], [1, 0, 1, 0, 0, 0, 1], [0, 0, 1, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 1], [0, 0, 0, 1, 0, 1, 0] ] # declaring the list of edges for the graph edges = [ [0, 0, 1, 0, 2, 0, 0], [0, 0, 2, 0, 0, 3, 0], [1, 2, 0, 1, 3, 0, 0], [2, 0, 1, 0, 0, 0, 1], [0, 0, 3, 0, 0, 2, 0], [0, 3, 0, 0, 2, 0, 1], [0, 0, 0, 1, 0, 1, 0] ] # defining the function to find which node is to be visited next def toBeVisited(): global visitedAndDistance v = -10 for index in range(numberOfNodes): if visitedAndDistance[index][0] == 0 and (v <0 1 or visitedanddistance[index][1] <="visitedAndDistance[v][1]):" v="index" return # finding the number of nodes in graph numberofnodes="len(nodes[0])" visitedanddistance="[[0," 0]] for i range(numberofnodes - 1): visitedanddistance.append([0, sys.maxsize]) node range(numberofnodes): next to be visited tovisit="toBeVisited()" neighborindex updating new distances if nodes[tovisit][neighborindex]="=" and visitedanddistance[neighborindex][0]="=" 0: newdistance="visitedAndDistance[toVisit][1]" + edges[tovisit][neighborindex] visitedanddistance[neighborindex][1]> newDistance: visitedAndDistance[neighborIndex][1] = newDistance visitedAndDistance[toVisit][0] = 1 i = 0 # printing the distance for distance in visitedAndDistance: print(&apos;Distance of&apos;, chr(ord(&apos;A&apos;) + i), &apos;from source node:&apos;, distance[1]) i = i + 1 </0></pre> <p> <strong>Output</strong> </p> <pre> Distance of A from source node: 0 Distance of B from source node: 3 Distance of C from source node: 1 Distance of D from source node: 2 Distance of E from source node: 2 Distance of F from source node: 4 Distance of G from source node: 3 </pre> <p> <strong>Explanation:</strong> </p> <p>In the above snippet of code, we have imported the <strong>sys</strong> module and declared the lists consisting of the values for the nodes and edges. We have then defined a function as <strong>toBeVisited()</strong> to find which node will be visited next. We then found the total number of nodes in the graph and set the initial distances for every node. We have then calculated the minimum distance from the source node to the destination node, performed relaxation on neighboring nodes, and updated the distances in the list. We then printed those distances from the list for the users.</p> <p>As a result, the required shortest possible paths for every node from the source node are printed for the users.</p> <h2>Time and Space Complexity of Dijkstra&apos;s Algorithm</h2> <ul> <li>The Time Complexity of Dijkstra&apos;s Algorithm is <strong>O(E log V)</strong> , where E is the number of edges and V is the number of vertices.</li> <li>The Space Complexity of Dijkstra&apos;s Algorithm is O(V), where V is the number of vertices.</li> </ul> <h2>Advantages and Disadvantages of Dijkstra&apos;s Algorithm</h2> <p> <strong>Let us discuss some advantages of Dijkstra&apos;s Algorithm:</strong> </p> <ol class="points"> <li>One primary advantage of using Dijkstra&apos;s Algorithm is that it has an almost linear time and space complexity.</li> <li>We can use this algorithm to calculate the shortest path from a single vertex to all other vertices and a single source vertex to a single destination vertex by stopping the algorithm once we get the shortest distance for the destination vertex.</li> <li>This algorithm only works for directed weighted graphs, and all the edges of this graph should be non-negative.</li> </ol> <p> <strong>Despite having multiple advantages, Dijkstra&apos;s algorithm has some disadvantages also, such as:</strong> </p> <ol class="points"> <li>Dijkstra&apos;s Algorithm performs a concealed exploration that utilizes a lot of time during the process.</li> <li>This algorithm is impotent to handle negative edges.</li> <li>Since this algorithm heads to the acyclic graph, it cannot calculate the exact shortest path.</li> <li>It also requires maintenance to keep a record of vertices that have been visited.</li> </ol> <h2>Some Applications of Dijkstra&apos;s Algorithm</h2> <p> <strong>Dijkstra&apos;s Algorithm has various real-world applications, some of which are stated below:</strong> </p> <ol class="points"> <tr><td>Digital Mapping Services in Google Maps:</td> There are various times when we have tried to find the distance in Google Maps either from our location to the nearest preferred location or from one city to another, which comprises multiple routes/paths connecting them; however, the application must display the minimum distance. This is only possible because Dijkstra&apos;s algorithm helps the application find the shortest between two given locations along the path. Let us consider the USA as a graph wherein the cities/places are represented as vertices, and the routes between two cities/places are represented as edges. Then with the help of Dijkstra&apos;s Algorithm, we can calculate the shortest routes between any two cities/places. </tr><tr><td>Social Networking Applications:</td> In many applications like Facebook, Twitter, Instagram, and more, many of us might have observed that these apps suggest the list of friends that a specific user may know. How do many social media companies implement this type of feature in an efficient and effective way, specifically when the system has over a billion users? The answer to this question is Dijkstra&apos;s Algorithm. The standard Dijkstra&apos;s Algorithm is generally used to estimate the shortest distance between the users measured through the connections or mutuality among them. When social networking is very small, it uses the standard Dijkstra&apos;s Algorithm in addition to some other features in order to determine the shortest paths. However, when the graph is much bigger, the standard algorithm takes several seconds to count, and thus, some advanced algorithms are used as the alternative. </tr><tr><td>Telephone Network:</td> As some of us might know, in a telephone network, each transmission line has a bandwidth, &apos;b&apos;. The bandwidth is the highest frequency that the transmission line can support. In general, if the frequency of the signal is higher in a specific line, the signal is reduced by that line. Bandwidth represents the amount of information that can be transmitted by the line. Let us consider a city a graph wherein the switching stations are represented using the vertices, the transmission lines are represented as the edges, and the bandwidth, &apos;b&apos;, is represented using the weight of the edges. Thus, as we can observe, the telephone network can also fall into the category of the shortest distance problem and can be solved using Dijkstra&apos;s Algorithm. </tr><tr><td>Flight Program:</td> Suppose that a person requires software to prepare an agenda of flights for customers. The agent has access to a database with all flights and airports. In addition to the flight number, origin airport, and destination, the flights also have departure and arrival times. So, in order to determine the earliest arrival time for the selected destination from the original airport and given start time, the agents make use of Dijkstra&apos;s Algorithm. </tr><tr><td>IP routing to find Open Shortest Path First:</td> Open Shortest Path First (abbreviated as OSPF) is a link-state routing protocol used to find the best path between the source and destination router with the help of its own Shortest Path First. Dijkstra&apos;s Algorithm is extensively utilized in the routing protocols required by the routers in order to update their forwarding table. The algorithm gives the shortest cost path from the source router to the other routers present in the network. </tr><tr><td>Robotic Path:</td> These days, drones and robots have come into existence, some operated manually and some automatically. The drones and robots which are operated automatically and used to deliver the packages to a given location or used for any certain task are configured with Dijkstra&apos;s Algorithm module so that whenever the source and destination are known, the drone and robot will move in the ordered direction by following the shortest path keeping the time taken to a minimum in order to deliver the packages. </tr><tr><td>Designate the File Server:</td> Dijkstra&apos;s Algorithm is also used to designate a file server in a Local Area Network (LAN). Suppose that an infinite period of time is needed for the transmission of the files from one computer to another. So, to minimize the number of &apos;hops&apos; from the file server to every other computer on the network, we will use Dijkstra&apos;s Algorithm. This algorithm will return the shortest path between the networks resulting in the minimum number of hops. </tr></ol> <h2>The Conclusion</h2> <ul> <li>In the above tutorial, firstly, we have understood the basic concepts of Graph along with its types and applications.</li> <li>We then learned about Dijkstra&apos;s Algorithm and its history.</li> <li>We have also understood the fundamental working of Dijkstra&apos;s Algorithm with the help of an example.</li> <li>After that, we studied how to write code for Dijkstra&apos;s Algorithm with the help of Pseudocode.</li> <li>We observed its implementation in programming languages like C, C++, Java, and Python with proper outputs and explanations.</li> <li>We have also understood the Time and Space Complexity of Dijkstra&apos;s Algorithm.</li> <li>Finally, we have discussed the advantages and disadvantages of Dijkstra&apos;s algorithm and some of its real-life applications.</li> </ul> <hr></nodes;>

Explicación:

En el fragmento de código anterior, hemos definido una clase pública como Algoritmo de Dijkstra() . Dentro de esta clase, hemos definido un método público como algoritmo dijkstra() para encontrar la distancia más corta desde el vértice de origen al vértice de destino. Dentro de este método, hemos definido una variable para almacenar el número de nodos. Luego hemos definido una matriz booleana para almacenar la información sobre los vértices visitados y una matriz de números enteros para almacenar sus respectivas distancias. Inicialmente, declaramos los valores en ambas matrices como FALSO y VALOR MÁXIMO , respectivamente. También establecimos la distancia del vértice de origen como cero y utilizamos el en bucle para actualizar la distancia entre el vértice de origen y los vértices de destino con la distancia mínima. Luego actualizamos las distancias de los vértices vecinos del vértice seleccionado realizando relajación e imprimimos las distancias más cortas para cada vértice. Luego hemos definido un método para encontrar la distancia mínima desde el vértice de origen hasta el vértice de destino. Luego definimos la función principal donde declaramos los vértices del gráfico y creamos una instancia del Algoritmo de Dijkstra() clase. Finalmente, hemos llamado a la algoritmo dijkstra() Método para encontrar la distancia más corta entre el vértice de origen y los vértices de destino.

Como resultado, se imprimen para los usuarios las rutas más cortas posibles requeridas para cada nodo desde el nodo de origen.

Código para el algoritmo de Dijkstra en Python

La siguiente es la implementación del algoritmo de Dijkstra en el lenguaje de programación Python:

Archivo: DikstraAlgorithm.py

 # Implementation of Dijkstra&apos;s Algorithm in Python # importing the sys module import sys # declaring the list of nodes for the graph nodes = [ [0, 0, 1, 0, 1, 0, 0], [0, 0, 1, 0, 0, 1, 0], [1, 1, 0, 1, 1, 0, 0], [1, 0, 1, 0, 0, 0, 1], [0, 0, 1, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 1], [0, 0, 0, 1, 0, 1, 0] ] # declaring the list of edges for the graph edges = [ [0, 0, 1, 0, 2, 0, 0], [0, 0, 2, 0, 0, 3, 0], [1, 2, 0, 1, 3, 0, 0], [2, 0, 1, 0, 0, 0, 1], [0, 0, 3, 0, 0, 2, 0], [0, 3, 0, 0, 2, 0, 1], [0, 0, 0, 1, 0, 1, 0] ] # defining the function to find which node is to be visited next def toBeVisited(): global visitedAndDistance v = -10 for index in range(numberOfNodes): if visitedAndDistance[index][0] == 0 and (v <0 1 or visitedanddistance[index][1] <="visitedAndDistance[v][1]):" v="index" return # finding the number of nodes in graph numberofnodes="len(nodes[0])" visitedanddistance="[[0," 0]] for i range(numberofnodes - 1): visitedanddistance.append([0, sys.maxsize]) node range(numberofnodes): next to be visited tovisit="toBeVisited()" neighborindex updating new distances if nodes[tovisit][neighborindex]="=" and visitedanddistance[neighborindex][0]="=" 0: newdistance="visitedAndDistance[toVisit][1]" + edges[tovisit][neighborindex] visitedanddistance[neighborindex][1]> newDistance: visitedAndDistance[neighborIndex][1] = newDistance visitedAndDistance[toVisit][0] = 1 i = 0 # printing the distance for distance in visitedAndDistance: print(&apos;Distance of&apos;, chr(ord(&apos;A&apos;) + i), &apos;from source node:&apos;, distance[1]) i = i + 1 </0>

Producción

 Distance of A from source node: 0 Distance of B from source node: 3 Distance of C from source node: 1 Distance of D from source node: 2 Distance of E from source node: 2 Distance of F from source node: 4 Distance of G from source node: 3

Explicación:

En el fragmento de código anterior, hemos importado el sistema módulo y declaró las listas que consisten en los valores de los nodos y bordes. Luego hemos definido una función como para ser visitado() para encontrar qué nodo se visitará a continuación. Luego encontramos el número total de nodos en el gráfico y establecimos las distancias iniciales para cada nodo. Luego calculamos la distancia mínima desde el nodo de origen al nodo de destino, realizamos relajación en los nodos vecinos y actualizamos las distancias en la lista. Luego imprimimos esas distancias de la lista para los usuarios.

Como resultado, se imprimen para los usuarios las rutas más cortas posibles requeridas para cada nodo desde el nodo de origen.

Complejidad temporal y espacial del algoritmo de Dijkstra

La complejidad temporal del algoritmo de Dijkstra es O(E Iniciar sesión V) , donde E es el número de aristas y V es el número de vértices.
La complejidad espacial del algoritmo de Dijkstra es O(V), donde V es el número de vértices.

Ventajas y desventajas del algoritmo de Dijkstra

Analicemos algunas ventajas del algoritmo de Dijkstra:

Una ventaja principal de utilizar el algoritmo de Dijkstra es que tiene una complejidad temporal y espacial casi lineal.
Podemos usar este algoritmo para calcular la ruta más corta desde un único vértice a todos los demás vértices y desde un único vértice de origen a un único vértice de destino deteniendo el algoritmo una vez que obtengamos la distancia más corta para el vértice de destino.
Este algoritmo solo funciona para gráficos ponderados dirigidos y todos los bordes de este gráfico deben ser no negativos.

A pesar de tener múltiples ventajas, el algoritmo de Dijkstra también tiene algunas desventajas, como por ejemplo:

El algoritmo de Dijkstra realiza una exploración oculta que utiliza mucho tiempo durante el proceso.
Este algoritmo es impotente para manejar bordes negativos.
Dado que este algoritmo se dirige al gráfico acíclico, no puede calcular exactamente el camino más corto.
También requiere mantenimiento para llevar un registro de los vértices que se han visitado.

Algunas aplicaciones del algoritmo de Dijkstra

El algoritmo de Dijkstra tiene varias aplicaciones en el mundo real, algunas de las cuales se detallan a continuación:

Servicios de mapas digitales en Google Maps:Son varias las ocasiones en las que hemos intentado encontrar la distancia en Google Maps ya sea desde nuestra ubicación hasta la ubicación preferida más cercana o de una ciudad a otra, que comprende múltiples rutas/caminos que las conectan; sin embargo, la aplicación debe mostrar la distancia mínima. Esto sólo es posible porque el algoritmo de Dijkstra ayuda a la aplicación a encontrar el camino más corto entre dos ubicaciones determinadas a lo largo del camino. Consideremos Estados Unidos como un gráfico en el que las ciudades/lugares se representan como vértices y las rutas entre dos ciudades/lugares se representan como aristas. Luego, con la ayuda del algoritmo de Dijkstra, podemos calcular las rutas más cortas entre dos ciudades/lugares.Aplicaciones de redes sociales:En muchas aplicaciones como Facebook, Twitter, Instagram y más, muchos de nosotros podríamos haber observado que estas aplicaciones sugieren la lista de amigos que un usuario específico puede conocer. ¿Cómo implementan muchas empresas de redes sociales este tipo de función de manera eficiente y efectiva, específicamente cuando el sistema tiene más de mil millones de usuarios? La respuesta a esta pregunta es el algoritmo de Dijkstra. El algoritmo estándar de Dijkstra se utiliza generalmente para estimar la distancia más corta entre los usuarios medida a través de las conexiones o la mutualidad entre ellos. Cuando las redes sociales son muy pequeñas, utilizan el algoritmo estándar de Dijkstra, además de algunas otras funciones, para determinar los caminos más cortos. Sin embargo, cuando el gráfico es mucho más grande, el algoritmo estándar tarda varios segundos en contar y, por lo tanto, se utilizan algunos algoritmos avanzados como alternativa.Red Telefónica:Como algunos de nosotros sabemos, en una red telefónica, cada línea de transmisión tiene un ancho de banda, 'b'. El ancho de banda es la frecuencia más alta que puede soportar la línea de transmisión. En general, si la frecuencia de la señal es mayor en una línea específica, la señal se reduce en esa línea. El ancho de banda representa la cantidad de información que puede transmitir la línea. Consideremos una ciudad como un gráfico en el que las estaciones de conmutación se representan mediante los vértices, las líneas de transmisión se representan como los bordes y el ancho de banda, 'b', se representa mediante el peso de los bordes. Así, como podemos observar, la red telefónica también puede entrar en la categoría del problema de distancia más corta y puede resolverse utilizando el Algoritmo de Dijkstra.Programa de vuelo:Supongamos que una persona requiere un software para preparar una agenda de vuelos para los clientes. El agente tiene acceso a una base de datos con todos los vuelos y aeropuertos. Además del número de vuelo, el aeropuerto de origen y el destino, los vuelos también tienen horarios de salida y llegada. Entonces, para determinar la hora de llegada más temprana al destino seleccionado desde el aeropuerto original y la hora de inicio dada, los agentes utilizan el algoritmo de Dijkstra.Enrutamiento IP para encontrar la ruta más corta abierta primero:Open Shortest Path First (abreviado como OSPF) es un protocolo de enrutamiento de estado de enlace que se utiliza para encontrar la mejor ruta entre el enrutador de origen y destino con la ayuda de su propio Shortest Path First. El algoritmo de Dijkstra se utiliza ampliamente en los protocolos de enrutamiento requeridos por los enrutadores para actualizar su tabla de reenvío. El algoritmo proporciona la ruta de menor costo desde el enrutador de origen a los otros enrutadores presentes en la red.Camino robótico:Hoy en día, han surgido drones y robots, algunos operados manualmente y otros automáticamente. Los drones y robots que se operan automáticamente y se utilizan para entregar los paquetes en un lugar determinado o se utilizan para una tarea determinada están configurados con el módulo de algoritmo de Dijkstra de modo que siempre que se conozca el origen y el destino, el dron y el robot se moverán en la dirección ordenada. siguiendo el camino más corto manteniendo el tiempo necesario para entregar los paquetes al mínimo.Designe el servidor de archivos:El algoritmo de Dijkstra también se utiliza para designar un servidor de archivos en una red de área local (LAN). Supongamos que se necesita un período de tiempo infinito para la transmisión de archivos de una computadora a otra. Entonces, para minimizar la cantidad de 'saltos' desde el servidor de archivos a cualquier otra computadora en la red, usaremos el algoritmo de Dijkstra. Este algoritmo devolverá la ruta más corta entre las redes, lo que dará como resultado el número mínimo de saltos.

La conclusión

En el tutorial anterior, en primer lugar, hemos comprendido los conceptos básicos de Graph junto con sus tipos y aplicaciones.
Luego aprendimos sobre el algoritmo de Dijkstra y su historia.
También hemos comprendido el funcionamiento fundamental del algoritmo de Dijkstra con la ayuda de un ejemplo.
Después de eso, estudiamos cómo escribir código para el algoritmo de Dijkstra con la ayuda de Pseudocódigo.
Observamos su implementación en lenguajes de programación como C, C++, Java y Python con resultados y explicaciones adecuadas.
También hemos comprendido la Complejidad Temporal y Espacial del Algoritmo de Dijkstra.
Finalmente, hemos discutido las ventajas y desventajas del algoritmo de Dijkstra y algunas de sus aplicaciones en la vida real.