Nombre: Raúl Alejandro Chávez Hernández

Registro: 17110057
Grado y Grupo: 5°E
Nombre y Número de tarea: #4 Codigo Dijkstra
Materia: INTELIGENCIA ARTIFICIAL
Fecha de entrega: 19/Septiembre /2019
 “CÓDIGO DIJKSTRA”

Introducción:

En este reporte se trata sobre el algoritmo Dijkstra, como realizaron está el algoritmo, tratar
de interpretarlo para poder llevarlo a la práctica, además de realizarlo en pseudocódigo,
para después llevarlo a programar el código en un lenguaje de programación que en este
caso seria java.

Objetivo:

El alumno implementará el algoritmo Dijkstra, interpretar como funciona este algoritmo

para llevarlo a un pseudocódigo y así poderlo pasarlo a un código de algún lenguaje de
programación, y pueda funcionar para encontrar el camino mas corto en el grafo.

Marco Teórico:

Grafos
Los grafos son un conjunto de puntos, de los cuales algún par de ellos está conectado por
unas líneas. Si estas líneas son flechas, hablaremos de grafo dirigido (dígrafo), mientras que
si son simples líneas estamos ante un grafo no dirigido.

Más formalmente se pueden definir como un conjunto de vértices y un conjunto de aristas.

Cada arista es un par (u,v), donde u y v pertenecen al conjunto de vértices. Si este par es
ordenado el grafo es dirigido.

Grafo No Dirigido
Un grafo no dirigido es aquel en el que todas sus aristas son bidireccionales.
La relación sobre V es simétrica. Las aristas se representan como pares no ordenados
{u,v}, u,v Є V y u ≠ v.

Grafo Dirigido
Un grafo dirigido o digrafo es un tipo de grafo en el cual las aristas tienen un sentido
definido, a diferencia del grafo no dirigido, en el cual las aristas son relaciones
simétricas y no apuntan en ningún sentido.

Grafo Etiquetado
Grafos en los cuales se ha añadido un peso a las aristas (número entero
generalmente) o un etiquetado a los vértices.
DESARROLLO

pseudocodigo

Codigo en Python
import sys

class Vertex:
def __init__(self, node):
self.id = node
self.adjacent = {}

self.distance = sys.maxint #...constructor

 self.visited = False

self.previous = None

def add_neighbor(self, neighbor, weight=0): #compara nodo y pone peso"

self.adjacent[neighbor] = weight

def get_connections(self):
return self.adjacent.keys() #une nodos

def get_id(self):
return self.id

def get_weight(self, neighbor):

return self.adjacent[neighbor]

def set_distance(self, dist):

self.distance = dist

def get_distance(self):
return self.distance

def set_previous(self, prev):

self.previous = prev

def set_visited(self):
 self.visited = True #cambia el estado de visitado a no visitado

def __str__(self):
return str(self.id) + ' adjacent: ' + str([x.id for x in self.adjacent])

class Graph:
def __init__(self):
self.vert_dict = {}
self.num_vertices = 0

def __iter__(self):
return iter(self.vert_dict.values())

def add_vertex(self, node):

self.num_vertices = self.num_vertices + 1
new_vertex = Vertex(node)#crea objeto con esos valores
self.vert_dict[node] = new_vertex
return new_vertex

def get_vertex(self, n):

if n in self.vert_dict:
return self.vert_dict[n]
else:
return None

def add_edge(self, frm, to, cost = 0):#añade aristas

if frm not in self.vert_dict:
 self.add_vertex(frm)
if to not in self.vert_dict:
self.add_vertex(to)

self.vert_dict[frm].add_neighbor(self.vert_dict[to], cost)
self.vert_dict[to].add_neighbor(self.vert_dict[frm], cost)#bidireccionar

def get_vertices(self):
return self.vert_dict.keys() #obtiene el identificador

def set_previous(self, current):

self.previous = current

def get_previous(self, current):

return self.previous

def shortest(v, path):

''' make shortest path from v.previous'''
if v.previous:
path.append(v.previous.get_id())
shortest(v.previous, path)
return

import heapq #libreria para añadir prioridad a la cola

def dijkstra(aGraph, start):

dis=0
 start.set_distance(0)#contador del peso
unvisited_queue = [(v.get_distance(),v) for v in aGraph]
heapq.heapify(unvisited_queue)

while len(unvisited_queue):#hasta que termine todos los elementos de lista

uv = heapq.heappop(unvisited_queue)
current = uv[1]
current.set_visited()#Elimina el vertice del conjunto T(t es conjunto de vertices)

for next in current.adjacent:#crea un nodo igual a otro

if next.visited:#siguiente nodo a comparar

continue
new_dist = current.get_distance() + current.get_weight(next)#suma la distancia del
nodo copiado con el nodo actual

if new_dist < next.get_distance():#si la distancia nueva es menor al acumulado

next.set_distance(new_dist)#suma la nueva distancia con la distancia acumulada
next.set_previous(current)
if (next.get_id()==fin) :#compara el segmento para saber si llego al fin
dis=next.get_distance()
while len(unvisited_queue):
heapq.heappop(unvisited_queue)
unvisited_queue = [(v.get_distance(),v) for v in aGraph if not v.visited]#como no
heapq.heapify(unvisited_queue)#
print 'Distancia total: %s' %(dis) #imprime peso total
if __name__ == '__main__':

g = Graph()

g.add_vertex('a')
g.add_vertex('b')
g.add_vertex('c')
g.add_vertex('d')
g.add_vertex('e')
g.add_vertex('f')
g.add_vertex('g')
g.add_vertex('z')

g.add_edge('a', 'b', 3)
g.add_edge('a', 'c', 1)
g.add_edge('b', 'c', 7)
g.add_edge('b', 'd', 5)
g.add_edge('b', 'e', 1)
g.add_edge('c', 'd', 2)
#g.add_edge('c', 'z', 1)
g.add_edge('d', 'e', 7)
#g.add_edge('d', 'f', 3)
# g.add_edge('e', 'g', 7)
## g.add_edge('f', 'g', 5)
# g.add_edge('g', 'z', 6)

print 'GRAFO:'
for v in g:
for w in v.get_connections():
vid = v.get_id()
wid = w.get_id()
print '( %s , %s, %3d)' % ( vid, wid, v.get_weight(w))
print "Write the first Vertex "
ini= raw_input()
print "Write the last Vertex "
fin= raw_input()
dijkstra(g, g.get_vertex(ini))

target = g.get_vertex(fin)
path = [target.get_id()]
shortest(target, path)

print 'Camino mas corto: %s' %(path[::-1])

Grafo Utilizado
 Resultados

CONCLUSIONES:
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.
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.
Se tuvieron varias complicaciones al realizarlo, tales como el realizar una cola que
defina prioridades para ir descartando caminos que no son de menor peso.