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_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): 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_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 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_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_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 buscarSolucionBfs(estadoInicial, solucion): solucionado = False nodosVisitados = [] nodosFrontera = [] nodoInicial = Nodo(estadoInicial) nodosFrontera.append(nodoInicial) while (not solucionado) and len(nodosFrontera) != 0: # extraer nodo y a;adirlo a vistado nodo = nodosFrontera.pop(0) nodosVisitados.append(nodo) if nodo.getDatos() == solucion: # solucion encontrada solucionado = True return nodo else: # expandir nodos hijo datoNodo = nodo.getDatos() # operador izquierdo hijo = [datoNodo[1], datoNodo[0], datoNodo[2], datoNodo[3]] hijoIzquierdo = Nodo(hijo) if not hijoIzquierdo.enLista(nodosVisitados) and not hijoIzquierdo.enLista(nodosFrontera): nodosFrontera.append(hijoIzquierdo) # operados central hijo = [datoNodo[0], datoNodo[2], datoNodo[1], datoNodo[3]] hijoCentral = Nodo(hijo) if not hijoCentral.enLista(nodosVisitados) and not hijoCentral.enLista(nodosFrontera): nodosFrontera.append(hijoCentral) #operador derecho hijo = [datoNodo[0], datoNodo[1], datoNodo[3], datoNodo[2]] hijoDerecho = Nodo(hijo) if not hijoDerecho.enLista(nodosVisitados) and not hijoDerecho.enLista(nodosFrontera): nodosFrontera.append(hijoDerecho) nodo.setHijos([hijoIzquierdo, hijoCentral, hijoDerecho])
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 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 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 buscarSolucionDfs_recursive(conexiones, nodo, solucion, visitados, limite): if limite > 0: visitados.append(nodo) if nodo.getDatos() == solucion: return nodo else: datoNodo = nodo.getDatos() listaHijos = [] for unHijo in conexiones[datoNodo]: hijo = Nodo(unHijo) if not hijo.enLista(visitados): listaHijos.append(hijo) nodo.setHijos(listaHijos) for nodoHijo in nodo.getHijos(): if not nodoHijo.getDatos() in visitados: sol = buscarSolucionDfs_recursive(conexiones, nodoHijo, solucion, visitados, limite-1) if sol != 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_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_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 buscarSolucionBfs(conexiones, estadoInicial, solucion): solucionado = False nodosVisitados = [] nodosFrontera = [] nodoInicial = Nodo(estadoInicial) nodosFrontera.append(nodoInicial) while (not solucionado) and len(nodosFrontera) != 0: nodo = nodosFrontera.pop(0) nodosVisitados.append(nodo) if nodo.getDatos() == solucion: solucionado = True return nodo else: # expandir nodos hijo (ciudades con conexion) datoNodo = nodo.getDatos() listaHijos = [] for unHijo in conexiones[datoNodo]: hijo = Nodo(unHijo) listaHijos.append(hijo) if not hijo.enLista(nodosVisitados) and not hijo.enLista(nodosFrontera): nodosFrontera.append(hijo) nodo.setHijos(listaHijos)
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 buscarSolucionUcs(conexiones, estadoInicial, solucion): solucionado = False nodosVisitados = [] nodosFrontera = [] nodoInicial = Nodo(estadoInicial) nodoInicial.setCoste(0) nodosFrontera.append(nodoInicial) while (not solucionado) and len(nodosFrontera) != 0: # ordenar la lista de nodos frontera nodosFrontera = sorted(nodosFrontera, key=lambda n: n.getCoste()) nodo = nodosFrontera.pop(0) # extraer nodo y a;adirlo a visitados nodosVisitados.append(nodo) if nodo.getDatos() == solucion: solucionado = True return nodo else: datoNodo = nodo.getDatos() listaHijos = [] for unHijo in conexiones[datoNodo]: hijo = Nodo(unHijo) coste = conexiones[datoNodo][unHijo] hijo.setCoste(nodo.getCoste() + coste) listaHijos.append(hijo) if not hijo.enLista(nodosVisitados): # si esta el hijo en nodosFrontera if hijo.enLista(nodosFrontera): for n in nodosFrontera: if n.igual(hijo) and n.getCoste() > hijo.getCoste(): nodosFrontera.remove(n) nodosFrontera.append(hijo) else: nodosFrontera.append(hijo) nodo.setHijos(listaHijos)
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)
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 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 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 = [] nodoInicial = Nodo(estado_inicial) nodos_frontera.append(nodoInicial) while (not solucionado) and len(nodos_frontera) != 0: #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 dato_nodo = nodo.getDatos() #operador izquierdo hijo = [dato_nodo[1], dato_nodo[0], dato_nodo[2], dato_nodo[3]] hijo_izquierdo = Nodo(hijo) if (not hijo_izquierdo.enLista(nodos_visitados)) and ( not hijo_izquierdo.enLista(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.enLista(nodos_visitados)) and ( not hijo_central.enLista(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.enLista(nodos_visitados)) and ( not hijo_derecho.enLista(nodos_frontera)): nodos_frontera.append(hijo_derecho) nodo.setHijos([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 crearArbol(pilita): arbol = Nodo(pilita.desapilar()) while not (pilita.es_vacia()): arbol = insertar(arbol, pilita.desapilar()) #print preorden(arbol) return arbol
def buscar_solucion(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: # Extraer nodo y agregarlo a visitados nodo = nodos_frontera.pop(0) nodos_visitados.append(nodo) if nodo.get_datos() == solucion: solucionado = True return nodo else: # Expandir nodo 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])
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 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)
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_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 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_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)