REPÚBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA DEFENSA

UNIVERSIDAD NACIONAL EXPERIMENTAL POLITÉCNICA DE LA FUERZA ARMADA NACIONAL

- UNEFA -

TEORIA DE GRAFOS

PROFESOR: ALUMNO:

FRANKLIN PERDOMO ROGER MIJARES

 ALGORITMO DE DIJKSTRA

El algoritmo de Dijkstra, también llamado algoritmo de caminos mínimos, es un algoritmo para la

determinación del camino más corto, dado un vértice origen, hacia el resto de los vértices en
un grafo que tiene pesos en cada arista. Su nombre alude a Edsger Dijkstra, científico de la
computación de los Países Bajos que lo describió por primera vez en 1959
La idea subyacente en este algoritmo consiste en ir explorando todos los caminos más cortos que
parten del vértice origen y que llevan a todos los demás vértices; cuando se obtiene el camino más
corto desde el vértice origen hasta el resto de los vértices que componen el grafo, el algoritmo se
detiene. Se trata de una especialización de la búsqueda de costo uniforme y, como tal, no funciona
en grafos con aristas de coste negativo (al elegir siempre el nodo con distancia menor, pueden
quedar excluidos de la búsqueda nodos que en próximas iteraciones bajarían el costo general del
camino al pasar por una arista con costo negativo).
Una de sus aplicaciones más importantes reside en el campo de la telemática. Gracias a él, es
posible resolver grafos con muchos nodos, lo que sería muy complicado resolver sin dicho
algoritmo, encontrando así las rutas más cortas entre un origen y todos los destinos en una red

ALGORITMO

Teniendo un grafo dirigido ponderado de N nodos no aislados, sea x el nodo inicial. Un vector D de
tamaño N guardará al final del algoritmo las distancias desde x hasta el resto de los nodos.

1. Inicializar todas las distancias en D con un valor infinito relativo, ya que son desconocidas
al principio, exceptuando la de x, que se debe colocar en 0, debido a que la distancia de x
a x sería 0.
2. Sea a = x (Se toma a como nodo actual.)
3. Se recorren todos los nodos adyacentes de a, excepto los nodos marcados. Se les
llamará nodos no marcados vi.
4. Para el nodo actual, se calcula la distancia tentativa desde dicho nodo hasta sus vecinos
con la siguiente fórmula: dt(vi) = Da + d(a,vi). Es decir, la distancia tentativa del nodo ‘vi’ es
la distancia que actualmente tiene el nodo en el vector D más la distancia desde dicho
nodo ‘a’ (el actual) hasta el nodo vi. Si la distancia tentativa es menor que la distancia
almacenada en el vector, se actualiza entonces el vector con esta distancia tentativa. Es
decir, si dt(vi) < Dvi→ Dvi = dt(vi)
5. Se marca como completo el nodo a.
6. Se toma como próximo nodo actual el de menor valor en D (puede hacerse almacenando
los valores en una cola de prioridad) y se regresa al paso 3, mientras existan nodos no
marcados.
Una vez terminado al algoritmo, D estará completamente lleno
 PSEUDOCODIGO

Estructura de datos auxiliar: Q = Estructura de datos cola de prioridad (se puede implementar con
un montículo)

DIJKSTRA (Grafo G, nodo_ fuente s)

para u ∈ V[G] hacer
distancia[u] = INFINITO
padre[u] = NULL
visto[u] = false
distancia[s] = 0
adicionar (cola, (s, distancia[s]))
mientras que cola no es vacía hacer
u = extraer_mínimo(cola)
visto[u] = true
para todos v ∈ adyacencia[u] hacer
si distancia[v] > distancia[u] + peso (u, v) hacer
distancia[v] = distancia[u] + peso (u, v)
padre[v] = u
adicionar(cola,(v, distancia[v]))

OTRA VERSION EN PSEUDOCODIGO SIN COLA DE PRIORIDAD

función Dijkstra (Grafo G, nodo_salida s)

//Usaremos un vector para guardar las distancias del nodo salida
al resto
entero distancia[n]
//Inicializamos el vector con distancias iniciales
booleano visto[n]
//vector de boleanos para controlar los vértices de los que ya
tenemos la distancia mínima
para cada w ∈ V[G] hacer
Si (no existe arista entre s y w) entonces
distancia[w] = Infinito //puedes marcar la casilla con un
-1 por ejemplo
Si_no
distancia[w] = peso (s, w)
fin si
fin para
distancia[s] = 0
visto[s] = cierto
//n es el número de vértices que tiene el Grafo
 mientras que (no_estén_vistos_todos) hacer
vértice = tomar_el_mínimo_del_vector distancia y que no esté
visto;
visto[vértice] = cierto;
para cada w ∈ sucesores (G, vértice) hacer
si distancia[w]>distancia[vértice]+peso (vértice, w)
entonces
distancia[w] = distancia[vértice]+peso (vértice, w)
fin si
fin para
fin mientras
fin función.

IMPLEMENTACION EN JAVA

/**
1 * Realizar el algoritmo de Dijkstra sobre el grafo
2 * @param origen nodo inicial
3 * @param destino nodo destino
4 * @return camino ArrayList con el camino a seguir.
5 */
6 public ArrayList<Integer> dijkstra(int origen, int
destino) {
7 ArrayList<Integer> camino= new
ArrayList<Integer>();
8 int distancia=Grafo.INFINITO;
9 int nodo=origen;
10 boolean fin=true;
11 camino.add(nodo);
12 while(fin) {
13 if(this.floydC[nodo][destino]<distancia) {
14 /*El metodo siguiente(nodo, destino),
nos devuelve
15 el siguiente nodo a visitar*/
16 nodo=this.siguiente(nodo, destino);
17 camino.add(nodo);
18 }
19
20 if(nodo==destino) {
21 fin=false;
22 }
23 }
24
25 return camino;
26 }

ALGORITMO DE PRIM
El algoritmo de Prim es un algoritmo perteneciente a la teoría de los grafos para encontrar
un árbol recubridor mínimo en un grafo conexo, no dirigido y cuyas aristas se están etiquetadas.
En otras palabras, el algoritmo encuentra un subconjunto de aristas que forman un árbol con todos
los vértices, donde el peso total de todas las aristas en el árbol es el mínimo posible. Si el grafo no
es conexo, entonces el algoritmo encontrará el árbol recubridor mínimo para uno de los
componentes conexos que forman dicho grafo no conexo.
El algoritmo fue diseñado en 1930 por el matemático Vojtech Jarnik y luego de manera
independiente por el científico computacional Robert C. Prim en 1957 y redescubierto
por Dijkstra en 1959. Por esta razón, el algoritmo es también conocido como algoritmo
DJP o algoritmo de Jarnik.
PSEUDOCODIGO DEL ALGORITMO

Prim (Grafo G)
/* Inicializamos todos los nodos del grafo.
La distancia la ponemos a infinito y el padre de cada nodo a
NULL
Encolamos, en una cola de prioridad
donde la prioridad es la distancia,
todas las parejas <nodo, distancia> del grafo*/
por cada u en V[G] hacer
distancia[u] = INFINITO
padre[u] = NULL
Añadir(cola,<u, distancia[u]>)
distancia[u]=0
mientras !esta_vacia(cola) hacer
// OJO: Se entiende por mayor prioridad aquel nodo cuya
distancia[u] es menor.
u = extraer_minimo(cola) //devuelve el mínimo y lo
elimina de la cola.
por cada v adyacente a 'u' hacer
si ((v ∈ cola) && (distancia[v] > peso(u, v))
entonces
padre[v] = u
distancia[v] = peso(u, v)
Actualizar(cola,<v, distancia[v]>)
 ALGORITMO DE KRUSKAL

El algoritmo de Kruskal es un algoritmo de la teoría de grafos para encontrar un árbol recubridor

mínimo en un grafo conexo y ponderado. Es decir, busca un subconjunto de aristas que, formando
un árbol, incluyen todos los vértices y donde el valor de la suma de todas las aristas del árbol es el
mínimo. Si el grafo no es conexo, entonces busca un bosque expandido mínimo (un árbol
expandido mínimo para cada componente conexa). Este algoritmo toma su nombre de Joseph
Kruskal, quien lo publicó por primera vez en 1956.1 2
Otros algoritmos que sirven para hallar el árbol de expansión mínima o árbol recubridor mínimo es
el algoritmo de Prim, el algoritmo del borrador inverso y el algoritmo de Boruvka.

PSEUDOCODIGO

función Kruskal(G)
Para cada v en V[G] hacer
Nuevo conjunto C(v) ← {v}.
Nuevo heap Q que contiene todas las aristas de G, ordenando por
su peso.
Defino un arbol T ← Ø
// n es el número total de vértices
Mientras T tenga menos de n-1 aristas y !Q.vacío() hacer
(u,v) ← Q.sacarMin()
// previene ciclos en T. agrega (u,v) si u y v están
diferentes componentes en el conjunto.
// Nótese que C(u) devuelve la componente a la que pertenece
u.
Si C(v) ≠ C(u) hacer
Agregar arista (v,u) a T.
Merge C(v) y C(u) en el conjunto
Responder arbol T
 ALGORITMO DE FLOYD-WARSHALL
En informática, el algoritmo de Floyd-Warshall, descrito en 1959 por Bernard Roy, es
un algoritmo de análisis sobre grafos para encontrar el camino mínimo en grafos dirigidos
ponderados. El algoritmo encuentra el camino entre todos los pares de vértices en una única
ejecución. El algoritmo de Floyd-Warshall es un ejemplo de programación dinámica.
Muchos problemas de la vida cotidiana se pueden expresar e incluso resolver en forma de grafo.
Existen algoritmos que encuentran distintos tipos de soluciones, tanto booleanas como de
eficiencia. El grafo se representa en una tabla (matriz) que se conoce como “matriz de adyacencia”
y representa si existe una unión entre dos nodos (boolean).

El algoritmo de Warshall es un ejemplo de algoritmo booleano. A partir de una tabla inicial

compuesta de 0`s (no hay correspondencia inicial en el grafo) y 1`s (hay una correspondencia,
llamase “flecha”, entre nodos), obtiene una nueva matriz denominada “Matriz de Clausura
Transitiva” en la que se muestran todas las posibles uniones entre nodos, directa o indirectamente.
Es decir, si de “A” a “B” no hay una “flecha”, es posible que si haya de “A” a “C” y luego de “C” a
“B”. Luego, este resultado se vera volcado en la matriz final.

PSEUDOCODIGO

1 /* Suponemos que la función pesoArista devuelve el coste del

camino que va de i a j
2 (infinito si no existe).

3 También suponemos que es el número de vértices y

pesoArista(i,i) = 0
4 */
5
6 int camino[][];
7 /* Una matriz bidimensional. En cada paso del algoritmo,
camino[i][j] es el camino mínimo
8 de i hasta j usando valores intermedios de (1..k-1). Cada
camino[i][j] es inicializado a
9
10 */
11
12 procedimiento FloydWarshall ()
13 para k: = 0 hasta n − 1
14
15 camino[i][j] = mín ( camino[i][j],
camino[i][k]+camino[k][j])
16
17 fin para
 INTRODUCCION

En el siguiente documento de carácter investigativo veremos varios algoritmos q nos

ayudan a la resolución de grafos a través de varios nodos, o también estos podrán
encontrar el árbol recubridor mínimo para uno de los componentes conexos que forman
un grafo no conexo también veremos que tienen cierta relación y que cada uno puede
ofrecer varias características
 ÍNDICE

INTRODUCCION………………………………………………………………………..................................................1

ALGORITMO DE DIJKSTRA………………………………………………………..…………………………………………………….2
PSEUDOCODIGO DE DIJKSTRA………………………………………………………………………………………………….…….3
OTRA VERSION EN PSEUDOCODIGO SIN COLA DE PRIORIDAD………………………………………4,5

IMPLEMENTACION EN JAVA……………………………………………………………………………………5,6

ALGORITMO DE PRIM……………………………………………………………………………………………………….…….6
PSEUDOCODIGO DE PRIM…………………………………………………………………………………………………..………….6

ALGORITMO DE KRUSKAL……………………………………………………………………………………………………….………7

PSEUDOCODIGO DE KRUSKAL…………………………………………………………………………………………………………7

ALGORITMO DE FLOYD-WARSHALL………………………………………………………………………………………………..8
PSEUDOCODIGO DE FLOYD-WARSHALL………………………………………………………………………………………….8
CONCLUSION……………………………………………………………….…………………………………………………………………9
BIBLIOGRAFIA………………………………………………………………………………………………………………….……………10
 BIBLIOGRAFIA

https://es.wikipedia.org/wiki/Algoritmo_de_Prim
https://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra
https://es.wikipedia.org/wiki/Algoritmo_de_Floyd-Warshall
https://es.wikipedia.org/wiki/Algoritmo_de_Kruskal