77 lines
2.7 KiB
Python
77 lines
2.7 KiB
Python
import heapq
|
|
|
|
# Fonction heuristique: Somme des objets restants (admissible)
|
|
def heuristique(etat_jeu):
|
|
return sum(etat_jeu)
|
|
|
|
# Fonction qui vérifie si l'état est final (tous les tas sont vides)
|
|
def est_etat_final(etat_jeu):
|
|
return all(tas == 0 for tas in etat_jeu)
|
|
|
|
# Fonction qui génère tous les mouvements possibles depuis un état donné
|
|
def generer_mouvements(etat_jeu):
|
|
mouvements_possibles = []
|
|
for i in range(len(etat_jeu)):
|
|
if etat_jeu[i] > 0:
|
|
for retirer in range(1, etat_jeu[i] + 1):
|
|
nouvel_etat = etat_jeu.copy()
|
|
nouvel_etat[i] -= retirer
|
|
mouvements_possibles.append(nouvel_etat)
|
|
return mouvements_possibles
|
|
|
|
# Classe Noeud utilisée pour l'algorithme A*
|
|
class Noeud:
|
|
def __init__(self, etat, parent=None, g=0, h=0):
|
|
self.etat = etat
|
|
self.parent = parent
|
|
self.g = g # Coût du chemin (g(n))
|
|
self.h = h # Heuristique (h(n))
|
|
|
|
# Priorité des nœuds basée sur la somme g + h
|
|
def __lt__(self, other):
|
|
return (self.g + self.h) < (other.g + other.h)
|
|
|
|
# Algorithme A* pour trouver le chemin optimal vers la victoire
|
|
def algorithme_a_star(etat_initial):
|
|
# Initialisation de la file de priorité
|
|
open_list = []
|
|
heapq.heappush(open_list, Noeud(etat_initial, g=0, h=heuristique(etat_initial)))
|
|
closed_list = set()
|
|
|
|
while open_list:
|
|
# Récupérer le nœud avec le plus faible f(n) = g(n) + h(n)
|
|
noeud_courant = heapq.heappop(open_list)
|
|
|
|
# Vérifier si c'est l'état final
|
|
if est_etat_final(noeud_courant.etat):
|
|
return reconstruire_chemin(noeud_courant)
|
|
|
|
# Ajouter l'état courant aux états visités
|
|
closed_list.add(tuple(noeud_courant.etat))
|
|
|
|
# Générer les mouvements légaux
|
|
for mouvement in generer_mouvements(noeud_courant.etat):
|
|
if tuple(mouvement) in closed_list:
|
|
continue
|
|
|
|
g_nouveau = noeud_courant.g + 1
|
|
h_nouveau = heuristique(mouvement)
|
|
nouveau_noeud = Noeud(mouvement, parent=noeud_courant, g=g_nouveau, h=h_nouveau)
|
|
heapq.heappush(open_list, nouveau_noeud)
|
|
|
|
return None # Si aucun chemin n'est trouvé
|
|
|
|
# Fonction pour reconstruire le chemin optimal
|
|
def reconstruire_chemin(noeud_final):
|
|
chemin = []
|
|
noeud_courant = noeud_final
|
|
while noeud_courant is not None:
|
|
chemin.append(noeud_courant.etat)
|
|
noeud_courant = noeud_courant.parent
|
|
return chemin[::-1] # Retourner le chemin dans l'ordre correct
|
|
|
|
# Test de l'algorithme A* avec l'état initial [3, 4, 5]
|
|
etat_initial = [3, 4, 5]
|
|
chemin_optimal = algorithme_a_star(etat_initial)
|
|
print("Chemin optimal:", chemin_optimal)
|