def buscar_solucion_BFS(conexiones, estado_inicial, solucion):
# 1
solucionado = False
nodo_inicial = Nodo(estado_inicial) # nodo inicial = estado inicial
nodos_frontera = [] # Nodos frontera = cola FIFO
nodos_visitados = [] # Nodos visitados = Lista
# 2
nodos_frontera.append(nodo_inicial) # Almacena el nodo inicial en la lista de nodos frontera
print("Puntero:")
# Mientras haya elementos en la lista de nodos frontera o se haya alcanzado la solucion
while (not solucionado) and len(nodos_frontera) != 0: # Mientras no este solucionado el problema y el nodo frontera no es vacio
nodo = nodos_frontera.pop(0) # Nodo Actual = extraer un nodo de la lista de nodos frotera
nodos_visitados.append(nodo) # Almaceno en la lista de nodos visitados
print(nodo.get_datos())
if nodo.get_datos() == solucion: # Si el nodo actual es la solucion
solucionado = True
return nodo # Retorno el nodo solucion o nodo objetivo
else:
# Expandir nodos hijos, nodos con conexion
dato_nodo = nodo.get_datos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
lista_hijos.append(hijo)
if (not hijo.en_lista(nodos_visitados) and not hijo.en_lista(nodos_frontera)):
nodos_frontera.append(hijo)
nodo.set_hijos(lista_hijos)
def buscar_solucion_BFS(conexiones, estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodoInicial = Nodo(estado_inicial)
nodos_frontera.append(nodoInicial)
while (not solucionado) and len(nodos_frontera) != 0:
nodo = nodos_frontera[0]
#extraer nodo y anadirlo a visitados
nodos_visitados.append(nodos_frontera.pop(0))
if nodo.get_datos() == solucion:
#solucion encontrada
solucionado = True
return nodo
else:
#expandir nodos hijo (ciudades con conexion)
dato_nodo = nodo.get_datos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
lista_hijos.append(hijo)
if not hijo.en_lista(nodos_frontera) \
and not hijo.en_lista(nodos_visitados):
nodos_frontera.append(hijo)
nodo.set_hijos(lista_hijos)
def buscar_solucion_aes(conexiones, estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodo_inicial = Nodo(estado_inicial)
nodo_inicial.set_coste(0)
nodos_frontera.append(nodo_inicial)
while (not solucionado) and len(nodos_frontera) != 0:
nodos_frontera = sorted(nodos_frontera, key=cmp_to_key(compara))
nodo = nodos_frontera[0]
nodos_visitados.append(nodos_frontera.pop(0))
if nodo.get_datos() == solucion:
solucionado = True
return nodo
else:
dato_nodo = nodo.get_datos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
coste = conexiones[dato_nodo][un_hijo]
hijo.set_coste(nodo.get_coste() + coste)
lista_hijos.append(hijo)
if not hijo.en_lista(nodos_visitados):
if hijo.en_lista(nodos_frontera):
for n in nodos_frontera:
if n.igual(
hijo) and n.get_coste() > hijo.get_coste():
nodos_frontera.remove(n)
nodos_frontera.append(hijo)
else:
nodos_frontera.append(hijo)
nodo.set_hijos(lista_hijos)
def buscar_solucion_DFS_Rec(nodo, solucion, visitados, limite):
if limite > 0:
visitados.append(nodo)
if nodo.get_datos() == solucion:
return nodo
else:
# expandir nodos hijo (ciudades con conexión)
dato_nodo = nodo.get_datos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
if not hijo.en_lista(visitados):
lista_hijos.append(hijo)
nodo.set_hijos(lista_hijos)
for nodo_hijo in nodo.get_hijos():
if not nodo_hijo.get_datos() in visitados:
# llamada recursiva
sol = buscar_solucion_DFS_Rec(nodo_hijo, solucion, \
visitados, limite-1)
if sol != None:
return sol
return None
def buscar_solucion_DFS_Rec(nodo, solucion, visitados, limite):
if limite > 0:
visitados.append(nodo)
if nodo.get_datos() == solucion:
return nodo
else:
# expandir nodos hijo (ciudades con conexión)
dato_nodo = nodo.get_datos()
lista_hijos=[]
for un_hijo in conexiones[dato_nodo]:
hijo=Nodo(un_hijo)
if not hijo.en_lista(visitados):
lista_hijos.append(hijo)
nodo.set_hijos(lista_hijos)
for nodo_hijo in nodo.get_hijos():
if not nodo_hijo.get_datos() in visitados:
# llamada recursiva
sol = buscar_solucion_DFS_Rec(nodo_hijo, solucion, \
visitados, limite-1)
if sol != None:
return sol
return None
def buscar_solucion_UCS(conexiones, estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodoInicial = Nodo(estado_inicial)
nodoInicial.set_coste(0)
nodos_frontera.append(nodoInicial)
while (not solucionado) and len(nodos_frontera) != 0:
# Ordenar la lista de nodos frontera
nodos_frontera = sorted(nodos_frontera, key=cmp_to_key(compara))
nodo = nodos_frontera[0]
# Extraer nodo y añadirlo a visitados
nodos_visitados.append(nodos_frontera.pop(0))
if nodo.get_datos() == solucion:
# Solucion encontrada
solucionado = True
return nodo
else:
#Expandir nodos hijos (ciudades con conexión)
dato_nodo = nodo.get_datos()
lista_hijos = []
lista_posibles_hijos = procrear(nodoInicial, conexiones, solucion)
for un_hijo in lista_posibles_hijos[dato_nodo]:
hijo = Nodo(un_hijo)
#Cálculo g(n)
if celda_valida(hijo):
coste = 2
hijo.set_coste(nodo.get_coste() + coste)
lista_hijos.append(hijo)
if not hijo.en_lista(nodos_visitados):
# Si está en la lista lo sustituimos con el
# nuevo valor de coste si es menor
if hijo.en_lista(nodos_frontera):
for n in nodos_frontera:
if n.igual(hijo) and n.get_coste(
) > hijo.get_coste():
nodos_frontera.remove(n)
nodos_frontera.append(hijo)
else:
nodos_frontera.append(hijo)
nodo.set_hijos(lista_hijos)
def buscar_solucion_BFS(estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodo_inicial = Nodo(estado_inicial)
nodos_frontera.append(nodo_inicial)
while (not solucionado) and len(nodos_frontera) != 0:
nodo = nodos_frontera.pop(0)
# extraer nodo y añadirlo a visitados
nodos_visitados.append(nodo)
if nodo.get_datos() == solucion:
#solucion encontrada
solucion = True
return nodo
else:
#expandir nodos hijo
dato_nodo = nodo.get_datos()
#operador izquierdo
hijo = [dato_nodo[1],dato_nodo[0],dato_nodo[2],dato_nodo[3]]
hijo_izquierdo = Nodo(hijo)
if not hijo_izquierdo.en_lista(nodos_visitados) and not hijo_izquierdo.en_lista(nodos_frontera):
nodos_frontera.append(hijo_izquierdo)
#operador central
hijo = [dato_nodo[0],dato_nodo[2],dato_nodo[1],dato_nodo[3]]
hijo_central = Nodo(hijo)
if not hijo_central.en_lista(nodos_visitados) and not hijo_central.en_lista(nodos_frontera):
nodos_frontera.append(hijo_central)
#operador derecho
hijo = [dato_nodo[0],dato_nodo[1],dato_nodo[3],dato_nodo[2]]
hijo_derecho = Nodo(hijo)
if not hijo_derecho.en_lista(nodos_visitados) and not hijo_derecho.en_lista(nodos_frontera):
nodos_frontera.append(hijo_derecho)
nodo.set_hijos([hijo_izquierdo,hijo_central,hijo_derecho])
def buscar_solucion_UCS(conexiones, estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodo_inicial = Nodo(estado_inicial)
nodo_inicial.set_coste(0)
nodos_frontera.append(nodo_inicial)
while (not solucionado) and len(nodos_frontera) != 0:
# ordenar la lista de nodos frontera
nodos_frontera = sorted(nodos_frontera, cmp=compara)
nodo = nodos_frontera[0]
# extraer nodo y añadirlo a visitados
nodos_visitados.append(nodos_frontera.pop(0))
if nodo.get_datos() == solucion:
# solucion encontrada
solucionado = True
return nodo
else:
# expandir nodos hijo (ciudades con conexión)
dato_nodo = nodo.get_datos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
coste = conexiones[dato_nodo][un_hijo]
hijo.set_coste(nodo.get_coste() + coste)
lista_hijos.append(hijo)
if not hijo.en_lista(nodos_visitados):
# si está en la lista lo sustituimos con
# el nuevo valor de coste si es menor
if hijo.en_lista(nodos_frontera):
for n in nodos_frontera:
if n.igual(
hijo) and n.get_coste() > hijo.get_coste():
nodos_frontera.remove(n)
nodos_frontera.append(hijo)
else:
nodos_frontera.append(hijo)
nodo.set_hijos(lista_hijos)
def buscar_solucion_BFS(conexiones, estado_inicial, solucion):
sql = "select ability from tickets_ability where"
solucionado = False
nodos_visitados=[]
nodos_frontera=[]
nodoInicial = Nodo(estado_inicial)
nodos_frontera.append(nodoInicial)
while (not solucionado) and len(nodos_frontera) !=0 :
nodo=nodos_frontera[0]
#extraer nodo y añadirlo a visitados
nodos_visitados.append(nodos_frontera.pop(0))
if nodo.get_datos() == solucion:
# comprobar que cada uno de los nodos si tenga ticketes disponibles n
#solucion encontrada
solucionado = True
return nodo
else:
#expandir ciudades hijos (ciudades con coneccion)
dato_nodo = nodo.get_datos()
lista_hijos=[]
for un_hijo in conexiones[dato_nodo]:
#en alguna parte de este codigo tengo que hacer la comprobacion de si la ruta es valida
# de no ser valida no dejar que se reprodusca con la funcion
# and valid_route(nodo)
#aprovechano que es un bucle for hago la comprobacion y doy un continue si es negativa
if valid_ruta_ciudad(dato_nodo,un_hijo):
hijo=Nodo(un_hijo)
else:
continue
lista_hijos.append(hijo)
if not hijo.en_lista(nodos_visitados) and not hijo.en_lista(nodos_frontera) :
nodos_frontera.append(hijo)
nodo.set_hijos(lista_hijos)
#si llego aqui significa que no encontre ruta
print("ruta no encontrada")
return -1
def Busqueda_en_Amplitud(estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodoInicial = Nodo(estado_inicial)
#nodos_frontera.append(nodoInicial)
nodoTemporal = []
nodoTemporal.append(nodoInicial)
while (not solucionado) and len(nodoTemporal) != 0:
nodo = nodoTemporal.pop()
#Extrae nodo y añade a los visitados
nodos_visitados.append(nodo)
if nodo.get_datos() == solucion:
#solucion encontrada
solucionado = True
return nodo
else:
#expandir nodos hijo
dato_nodo = nodo.get_datos()
#operador izquierdo
hijo = [dato_nodo[1], dato_nodo[0], dato_nodo[2], dato_nodo[3]]
hijo_izquierdo = Nodo(hijo)
if not hijo_izquierdo.en_lista(
nodos_visitados) and not hijo_izquierdo.en_lista(
nodoTemporal):
nodos_frontera.append(hijo_izquierdo)
#operacdor central
hijo = [dato_nodo[0], dato_nodo[2], dato_nodo[1], dato_nodo[3]]
hijo_central = Nodo(hijo)
if not hijo_central.en_lista(
nodos_visitados) and not hijo_central.en_lista(
nodoTemporal):
nodos_frontera.append(hijo_central)
#operador derecho
hijo = [dato_nodo[0], dato_nodo[1], dato_nodo[3], dato_nodo[2]]
hijo_derecho = Nodo(hijo)
if not hijo_derecho.en_lista(
nodos_visitados) and not hijo_derecho.en_lista(
nodoTemporal):
nodos_frontera.append(hijo_derecho)
nodo.set_hijos([hijo_izquierdo, hijo_central, hijo_derecho])
for nodoAux in range(len(nodos_frontera)):
nodoTemporal.append(nodos_frontera.pop())
def buscar_solucion_DFS(estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodoInicial = Nodo(estado_inicial)
nodos_frontera.append(nodoInicial)
while (not solucionado) and len(nodos_frontera) != 0:
nodo = nodos_frontera.pop()
# pop node and add it to visited
nodos_visitados.append(nodo)
if nodo.get_datos() == solucion:
#found a solution
solucionado = True
return nodo
else:
# expand branches (child node)
dato_nodo = nodo.get_datos()
# left operator
hijo = [dato_nodo[1], dato_nodo[0], dato_nodo[2], dato_nodo[3]]
hijo_izquierdo = Nodo(hijo)
if not hijo_izquierdo.en_lista(nodos_visitados) \
and not hijo_izquierdo.en_lista(nodos_frontera):
nodos_frontera.append(hijo_izquierdo)
# central operator
hijo = [dato_nodo[0], dato_nodo[2], dato_nodo[1], dato_nodo[3]]
hijo_central = Nodo(hijo)
if not hijo_central.en_lista(nodos_visitados) \
and not hijo_central.en_lista(nodos_frontera):
nodos_frontera.append(hijo_central)
# right operator
hijo = [dato_nodo[0], dato_nodo[1], dato_nodo[3], dato_nodo[2]]
hijo_derecho = Nodo(hijo)
if not hijo_derecho.en_lista(nodos_visitados) \
and not hijo_derecho.en_lista(nodos_frontera):
nodos_frontera.append(hijo_derecho)
nodo.set_hijos([hijo_izquierdo, hijo_central, hijo_derecho])
def buscar_solucion_BFS(estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodo_inicial = Nodo(estado_inicial)
nodos_frontera.append(nodo_inicial)
while (not solucionado) and len(nodos_frontera) != 0:
nodo = nodos_frontera.pop(0)
#extraigo nodo y añado a visitado
nodos_visitados.append(nodo)
if nodo.get_datos() == solucion:
solucionado = True
return nodo
else:
dato_nodo = nodo.get_datos()
#izquierda
hijo = [dato_nodo[1], dato_nodo[0], dato_nodo[2], dato_nodo[3]]
hijo_izquierdo = Nodo(hijo)
if not hijo_izquierdo.en_lista(
nodos_visitados) and not hijo_izquierdo.en_lista(
nodos_frontera):
nodos_frontera.append(hijo_izquierdo)
#central
hijo = [dato_nodo[0], dato_nodo[2], dato_nodo[1], dato_nodo[3]]
hijo_central = Nodo(hijo)
if not hijo_central.en_lista(
nodos_visitados) and not hijo_central.en_lista(
nodos_frontera):
nodos_frontera.append(hijo_central)
#derecha
hijo = [dato_nodo[0], dato_nodo[1], dato_nodo[3], dato_nodo[2]]
hijo_derecho = Nodo(hijo)
if not hijo_derecho.en_lista(
nodos_visitados) and not hijo_derecho.en_lista(
nodos_frontera):
nodos_frontera.append(hijo_derecho)
nodo.set_hijos([hijo_izquierdo, hijo_central, hijo_derecho])
def buscar_solucion_bfs(estado_inicial, cantidad_piezas):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodoInicial = Nodo(estado_inicial)
nodos_frontera.append(nodoInicial)
while (not solucionado) and len(nodos_frontera) != 0:
nodo = nodos_frontera.pop(0)
# Extraer nodo y anadirlo a visitados
nodos_visitados.append(nodo)
# Validar que no haya ataque en filas
validacion_fila = [nodo.get_datos()[0]]
for reina in nodo.get_datos():
if reina not in validacion_fila:
validacion_fila.append(reina)
# Calcular y validar diagonales de reinas
lista_descendentes = []
lista_ascendentes = []
bandera_diagonales = True
for fila in nodo.get_datos():
columna = nodo.get_datos().index(fila)
if fila - columna in lista_descendentes:
bandera_diagonales = False
break
else:
lista_descendentes.append(fila - columna)
if fila + columna in lista_ascendentes:
bandera_diagonales = False
break
else:
lista_ascendentes.append(fila + columna)
# Validar si nodo es solucion
if len(validacion_fila
) == cantidad_piezas and bandera_diagonales is True:
# solucion encontrada
solucionado = True
return nodo
else:
# expandir nodos hijo
dato_nodo = nodo.get_datos()
# operador | Generar hijos
grupo_hijos = []
for reina in range(cantidad_piezas):
hijo = []
por_avanzar = reina
for indice in range(cantidad_piezas):
if indice != por_avanzar:
hijo.append(dato_nodo[indice])
else:
hijo.append(
avanzar_fila(dato_nodo[indice], cantidad_piezas))
hijo_reina = Nodo(hijo)
if not hijo_reina.en_lista(
nodos_visitados) and not hijo_reina.en_lista(
nodos_frontera):
nodos_frontera.append(hijo_reina)
grupo_hijos.append(hijo_reina)
nodo.set_hijos(grupo_hijos)
