def buscar_solucion_DFS_rec(nodo_inicial, solucion, visitados):
visitados.append(nodo_inicial.get_datos())
if nodo_inicial.get_datos() == solucion:
# Solucion encontrada
return nodo_inicial
else:
#Expandir nodos hijos
dato_nodo = nodo_inicial.get_datos()
#Operador izquierdo
hijo = [dato_nodo[1], dato_nodo[0], dato_nodo[2], dato_nodo[3]]
hijo_izquierdo = Nodo(hijo)
#Operador central
hijo = [dato_nodo[0], dato_nodo[2], dato_nodo[1], dato_nodo[3]]
hijo_central = Nodo(hijo)
#Operador derecha
hijo = [dato_nodo[0], dato_nodo[1], dato_nodo[3], dato_nodo[2]]
hijo_derecho = Nodo(hijo)
nodo_inicial.set_hijos([hijo_izquierdo, hijo_central, hijo_derecho])
for nodo_hijo in nodo_inicial.get_hijos():
if not nodo_hijo.get_datos() in visitados:
# Llamada recursiva
sol = buscar_solucion_DFS_rec(nodo_hijo, solucion, visitados)
if sol != None:
return sol
return None
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_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_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_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_heuristica(nodo_inicial, solucion, visitados):
visitados.append(nodo_inicial.get_datos())
if nodo_inicial.get_datos() == solucion:
return nodo_inicial
else:
#expandir nodos sucesores (hijos)
dato_nodo = nodo_inicial.get_datos()
hijo = [dato_nodo[1], dato_nodo[0], dato_nodo[2], dato_nodo[3]]
hijo_izquierdo = Nodo(hijo)
hijo = [dato_nodo[0], dato_nodo[2], dato_nodo[1], dato_nodo[3]]
hijo_central = Nodo(hijo)
hijo = [dato_nodo[0], dato_nodo[1], dato_nodo[3], dato_nodo[2]]
hijo_derecho = Nodo(hijo)
nodo_inicial.set_hijos([hijo_izquierdo, hijo_central, hijo_derecho])
for nodo_hijo in nodo_inicial.get_hijos():
if not nodo_hijo.get_datos() in visitados \
and mejora(nodo_inicial, nodo_hijo):
#llamada recursiva
sol = buscar_solucion_heuristica(nodo_hijo, solucion,
visitados)
if sol != None:
return sol
return None
def busqueda_recursiva(nodo, solucion, visitados, limite):
nodo_visitado = nodo.get_datos()
visitados.append(nodo_visitado)
if nodo.get_datos() == solucion:
return nodo
else:
# Expandir nodos hijo
dato_nodo = nodo.get_datos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
if not hijo.get_datos() in 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 = busqueda_recursiva(nodo_hijo, solucion, visitados,
limite)
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_DFS_Rec(nodo_inicial, solucion, visitados, limite):
if limite > 0:
visitados.append(nodo_inicial.getDatos())
if nodo_inicial.getDatos() == solucion:
#Solcuion encontrada
return nodo_inicial
else:
#expandir nodos hijos
dato_nodo = nodo_inicial.getDatos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
lista_hijos.append(hijo)
if (not hijo.getDatos() in visitados):
lista_hijos.append(hijo)
nodo_inicial.setHijos(lista_hijos)
for nodo_hijo in nodo_inicial.getHijos():
if (not nodo_hijo.getDatos() in visitados):
# llamada recursiva
sol = buscar_solucion_DFS_Rec(nodo_hijo, solucion,
visitados, limite - 1)
if sol != None:
return sol
return None
def crear_hijo_por_derecha(nodo):
return Nodo([
nodo.get_datos()[0],
nodo.get_datos()[1],
nodo.get_datos()[3],
nodo.get_datos()[2]
])
def crear_hijo_por_centro(nodo):
return Nodo([
nodo.get_datos()[0],
nodo.get_datos()[2],
nodo.get_datos()[1],
nodo.get_datos()[3]
])
def crear_hijo_por_izquierda(nodo):
return Nodo([
nodo.get_datos()[1],
nodo.get_datos()[0],
nodo.get_datos()[2],
nodo.get_datos()[3]
])
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_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_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_UCS(conexiones, estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodo_inicial = Nodo(estado_inicial)
nodo_inicial.setCoste(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,
key=lambda Nodo: Nodo.calcularTotalCost(coord, solucion))
#extraer nodo y añadirlo a visitados
nodo = nodos_frontera.pop(0)
nodos_visitados.append(nodo)
if nodo.getDatos() == solucion:
#Solcuion encontrada
solucionado = True
return nodo
else:
#expandir nodos hijos (ciudades con conexion)
dato_nodo = nodo.getDatos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
#añadir el coste al nodo
coste = conexiones[dato_nodo][un_hijo]
hijo.setCoste(nodo.getCoste() + coste)
lista_hijos.append(hijo)
if (not hijo.enLista(nodos_visitados)):
#si no ha sido visitado y esta en la lista de frontera
# lo sustituimos con el nuevo valor de coste si es menor
if (hijo.enLista(nodos_frontera)):
for n in nodos_frontera:
if n.igual(
hijo) and n.getCoste() > hijo.getCoste():
nodos_frontera.remove(n)
nodos_frontera.append(hijo)
else:
nodos_frontera.append(hijo)
nodo.setHijos(lista_hijos)
def buscar_solucion(nodo_inicial, solucion, visitados):
visitados.append(nodo_inicial.get_datos())
if nodo_inicial.get_datos() == solucion:
return nodo_inicial
else:
# expandir nodos sucesores (hijos)
dato_nodo = nodo_inicial.get_datos()
hijo_izquierdo = Nodo([dato_nodo[1], dato_nodo[0], dato_nodo[2], dato_nodo[3]])
hijo_central = Nodo([dato_nodo[0], dato_nodo[2], dato_nodo[1], dato_nodo[3]])
hijo_derecho = Nodo([dato_nodo[0], dato_nodo[1], dato_nodo[3], dato_nodo[2]])
nodo_inicial.set_hijos([hijo_izquierdo, hijo_central, hijo_derecho])
for nodo_hijo in nodo_inicial.get_hijos():
if not nodo_hijo.get_datos() in visitados:
sol = buscar_solucion(nodo_hijo, solucion, visitados)
if sol != None:
return sol
return None
def crear_hijo_por_par_de_indices(nodo, pos_i, pos_f):
arreglo = []
for i in range(0, len(nodo.get_datos())):
if i == pos_i:
arreglo.append(nodo.get_datos()[pos_f])
elif i == pos_f:
arreglo.append(nodo.get_datos()[pos_i])
else:
arreglo.append(nodo.get_datos()[i])
return Nodo(arreglo)
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_DFS_Rec(nodo_inicial, solucion, visitados):
visitados.append(nodo_inicial.get_datos())
if nodo_inicial.get_datos() == solucion:
return nodo_inicial
else:
# Expandir nodos sucesores (hijos)
dato_nodo = nodo_inicial.get_datos()
hijo = [dato_nodo[1], dato_nodo[0], dato_nodo[2], dato_nodo[3]]
hijo_izquierdo = Nodo(hijo)
hijo = [dato_nodo[0], dato_nodo[2], dato_nodo[1], dato_nodo[3]]
hijo_central = Nodo(hijo)
hijo = [dato_nodo[0], dato_nodo[1], dato_nodo[3], dato_nodo[2]]
hijo_derecho = Nodo(hijo)
nodo_inicial.set_hijos([hijo_izquierdo, hijo_central, hijo_derecho])
for nodo_hijo in nodo_inicial.get_hijos():
if not nodo_hijo.get_datos() in visitados:
# Llamada Recursiva
sol = buscar_solucion_DFS_Rec(nodo_hijo, solucion, visitados)
if sol is not None:
return sol
return None
def buscar_solucion_DFS(nodo_inicial, solucion,visitados):
visitados.append(nodo_inicial.getDatos())
if nodo_inicial.getDatos()== solucion:
#Solcuion encontrada
return nodo_inicial
else:
#expandir nodos hijos
dato_nodo= nodo_inicial.getDatos()
hijo = [dato_nodo[1],dato_nodo[0],dato_nodo[2],dato_nodo[3]]
hijo_izquierdo = Nodo(hijo)
hijo=[dato_nodo[0],dato_nodo[2],dato_nodo[1],dato_nodo[3]]
hijo_central = Nodo(hijo)
hijo=[dato_nodo[0],dato_nodo[1],dato_nodo[3],dato_nodo[2]]
hijo_derecho = Nodo(hijo)
nodo_inicial.setHijos([hijo_izquierdo,hijo_central,hijo_derecho])
for nodo_hijo in nodo_inicial.getHijos():
if (not nodo_hijo.getDatos() in visitados):
# llamada recursiva
sol=buscar_solucion_DFS(nodo_hijo,solucion,visitados)
if sol!=None:
return sol
return None
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_UCS(informacion, estado_inicial):
depth = 0
nodos_visitados = []
nodos_frontera = []
nodo_inicial = Nodo(estado_inicial)
nodo_inicial.setCoste(0)
nodos_frontera.append(nodo_inicial)
while (depth != 3) and len(nodos_frontera) != 0:
#Ordenar la lista de nodos frontera
nodos_frontera = sorted(
nodos_frontera,
key=lambda Nodo: Nodo.calcularTotalCost(informacion))
#extraer nodo y añadirlo a visitados
nodo = nodos_frontera.pop(0)
nodos_visitados.append(nodo)
#expandir nodos hijos (empresas restantes)
dato_nodo = nodo.getDatos()
lista_hijos = []
if dato_nodo == "inicio":
for i in range(4):
hijo = Nodo("Empresa" + (i + 1))
#añadir el coste al nodo
coste = informacion[i][depth]
hijo.setCoste(nodo.getCoste() + coste)
lista_hijos.append(hijo)
if (not hijo.enLista(nodos_visitados)):
#si no ha sido visitado y esta en la lista de frontera
# lo sustituimos con el nuevo valor de coste si es menor
if (hijo.enLista(nodos_frontera)):
for n in nodos_frontera:
if n.igual(hijo) and n.getCoste() > hijo.getCoste():
nodos_frontera.remove(n)
nodos_frontera.append(hijo)
else:
nodos_frontera.append(hijo)
nodo.setHijos(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 main():
estado_inicial = [4, 2, 3, 1]
solucion = [1, 2, 3, 4]
nodo_solucion = None
visitados = []
nodo_inicial = Nodo(estado_inicial)
nodo_solucion = buscar_solucion_DFS_rec(nodo_inicial, solucion, visitados)
#Mostrar resultado
resultado = []
nodo = nodo_solucion
while nodo.get_padre() != None:
resultado.append(nodo.get_datos())
nodo = nodo.get_padre()
resultado.append(estado_inicial)
resultado.reverse()
print(resultado)
def insertar(arbol, valor):
if arbol == None:
return Nodo(valor)
if comparar(arbol) and comparar(arbol.der):
if (arbol.der == None):
return Nodo(arbol.valor, arbol.izq, insertar(arbol.der, valor))
else:
if (not (comparar(arbol.der.izq))) and (not (comparar(
arbol.der.der))):
tempVal = evaluar(arbol.der)
temp = Nodo(arbol.valor, arbol.izq, Nodo(tempVal))
return insertar(temp, valor)
else:
return Nodo(arbol.valor, arbol.izq, insertar(arbol.der, valor))
else:
temp = Nodo(arbol.valor, insertar(arbol.izq, valor), arbol.der)
if (comparar(Nodo(valor)) or (buscar(temp, valor))):
return temp
else:
tempVal = evaluar(temp)
return Nodo(tempVal)
hijo = [dato_nodo[0], dato_nodo[2], dato_nodo[1], dato_nodo[3]]
hijo_central = Nodo(hijo)
hijo = [dato_nodo[0], dato_nodo[1], dato_nodo[3], dato_nodo[2]]
hijo_derecho = Nodo(hijo)
nodo_inicial.set_hijos([hijo_izquierdo, hijo_central, hijo_derecho])
for nodo_hijo in nodo_inicial.get_hijos():
if not nodo_hijo.get_datos() in visitados:
# Llamada Recursiva
sol = buscar_solucion_DFS_Rec(nodo_hijo, solucion, visitados)
if sol is not None:
return sol
return None
if __name__ == "__main__":
estado_inicial = [4, 2, 3, 1]
solucion = [1, 2, 3, 4]
node_solucion = None
visitados = []
nodo_inicial = Nodo(estado_inicial)
nodo = buscar_solucion_DFS_Rec(nodo_inicial, solucion, visitados)
# Mostrar Resultado
resultado = []
while nodo.get_padre() is not None:
resultado.append(nodo.get_datos())
nodo = nodo.get_padre()
resultado.append(estado_inicial)
resultado.reverse()
print(resultado)
def armar_arbol(conjunto_entrenamiento, filas_padre):
tipo_nodo = 0
# caso 1, se pregunta si quedan ejemplos disponibles para este camino
if conjunto_entrenamiento == []:
target = obtener_pluralidad(filas_padre)
hoja = Hoja(target)
return hoja
else:
# caso 2, todos los target son iguales para el conjunto de
# entrenamiento
if (son_todos_target_iguales(conjunto_entrenamiento)):
target = retornar_target(conjunto_entrenamiento)
hoja = Hoja(target)
return hoja
else:
# hacer split
# 1.obtener las ganancias para cada columna
ganancias_por_columna = recorrer_columnas_datos_entrenamiento(
conjunto_entrenamiento)
ganancias_permitidas, encabezados_permitidos = reducir_ganancias_por_atributos_utilizados(
ganancias_por_columna)
# 2.ver si quedan atributos disponibles para hacer split
if ganancias_permitidas == []:
#print("ya no hay atributos, pluralidad ejemplos")
target = obtener_pluralidad(conjunto_entrenamiento)
hoja = Hoja(target)
return hoja
# crear una hoja aquí
elif es_ganancia_cero(ganancias_permitidas):
target = obtener_pluralidad(conjunto_entrenamiento)
hoja = Hoja(target)
return hoja
else:
hijos = []
indice_maximo = obtener_indice_maximo(ganancias_permitidas)
encabezado_nodo = encabezados_permitidos[indice_maximo]
ganancia_nodo = ganancias_permitidas[indice_maximo]
atributo = Atributo(ganancia_nodo, encabezado_nodo)
indice_nodo = obtener_indice_encabezado(encabezado_nodo)
atributos_utilizados.append(atributo)
conjunto_fila_valores_diferentes = valores_unicos_por_columna(
conjunto_entrenamiento, indice_nodo)
# si se aporta gran cantidad de valores para un atributo, se
# evaluará si es mayor o menor a 0
if indice_nodo in columnas_mayor_ocho:
mayores, menores = obtener_filas_mayores_menores_cero(
conjunto_entrenamiento, indice_nodo)
nodo_mayores = armar_arbol(mayores, conjunto_entrenamiento)
nodo_menores = armar_arbol(menores, conjunto_entrenamiento)
hijos.append(nodo_mayores)
hijos.append(nodo_menores)
else:
tipo_nodo = 1
for i in conjunto_fila_valores_diferentes:
# para cada valor, se obtienen las filas que cumplen
# con esta característica en la columna especificada
filas_elemento = obtener_filas_por_valor_columna(
conjunto_entrenamiento, i, indice_nodo)
# se llama de nuevo a la función, con los elementos del
# nuevo camino y los elementos del padre
nodo = armar_arbol(filas_elemento,
conjunto_entrenamiento)
hijos.append(nodo)
nodo = Nodo(hijos, indice_nodo,
conjunto_fila_valores_diferentes,
ganancias_permitidas[indice_maximo], tipo_nodo,
conjunto_entrenamiento)
return nodo
def crearArbol(pilita):
arbol = Nodo(pilita.desapilar())
while not (pilita.es_vacia()):
arbol = insertar(arbol, pilita.desapilar())
#print preorden(arbol)
return arbol
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)
