def cout_mouvement(etat_actuel, nouvel_etat):
    # Chaque mouvement a un coût constant de 1
    return 1

etat_jeu1 = [3, 4, 5]  # État initial
etat_jeu2 = [3, 3, 5]  # Après avoir retiré 1 objet du deuxième tas

# Le coût de passer de l'état [3, 4, 5] à l'état [3, 3, 5]
print("Coût du mouvement :", cout_mouvement(etat_jeu1, etat_jeu2))  # 1

import heapq

def algorithme_a_star(etat_initial):
    # File de priorité (tas) pour les nœuds à explorer
    file_priorite = []
    
    # Ajouter l'état initial dans la file de priorité (f(n), g(n), état)
    heapq.heappush(file_priorite, (0 + heuristique(etat_initial), 0, etat_initial))
    
    # Dictionnaire pour stocker le coût minimal pour atteindre chaque état
    cout_minimal = {tuple(etat_initial): 0}
    
    # Dictionnaire pour reconstruire le chemin
    predecesseurs = {tuple(etat_initial): None}
    
    while file_priorite:
        # Extraire l'état avec le plus faible coût estimé f(n)
        _, cout_actuel, etat_actuel = heapq.heappop(file_priorite)
        
        # Vérifier si l'état actuel est l'état final
        if est_etat_final(etat_actuel):
            # Reconstruire le chemin optimal
            chemin = []
            while etat_actuel is not None:
                chemin.append(etat_actuel)
                etat_actuel = predecesseurs[tuple(etat_actuel)]
            chemin.reverse()  # On inverse le chemin pour l'avoir dans l'ordre
            return chemin
        
        # Générer tous les mouvements possibles à partir de l'état actuel
        mouvements_possibles = generer_mouvements(etat_actuel)
        
        for nouvel_etat in mouvements_possibles:
            # Calculer le coût du mouvement (toujours 1 dans notre cas)
            cout_mouvement_actuel = cout_actuel + cout_mouvement(etat_actuel, nouvel_etat)
            
            # Si le nouvel état est rencontré avec un coût inférieur à celui déjà connu
            if tuple(nouvel_etat) not in cout_minimal or cout_mouvement_actuel < cout_minimal[tuple(nouvel_etat)]:
                cout_minimal[tuple(nouvel_etat)] = cout_mouvement_actuel
                predecesseurs[tuple(nouvel_etat)] = etat_actuel
                # Calculer f(n) = g(n) + h(n)
                f_n = cout_mouvement_actuel + heuristique(nouvel_etat)
                # Ajouter le nouvel état dans la file de priorité
                heapq.heappush(file_priorite, (f_n, cout_mouvement_actuel, nouvel_etat))
    
    # Si aucun chemin n'a été trouvé (ce qui ne devrait pas arriver dans le jeu de Nim)
    return None

etat_initial = [3, 4, 5]  # Exemple d'état initial

# Appel de l'algorithme A* pour trouver le chemin optimal
chemin_optimal = algorithme_a_star(etat_initial)

# Affichage du chemin
for etat in chemin_optimal:
    print(etat)