def extraireSousGraphe(self, point, typeVehicule, etatPatient):
# On utilise la classe Arbre pour créer l'arbre de chemins simples possibles
# variable point étant la racine de l'arbre
arbre = Arbre(point)
arbre.remplirArbre(self.listeSommets, self.matriceArete, typeVehicule,
etatPatient)
# Créer liste contenant les feuilles de l'arbres uniquement
liste = []
arbre.creerListeChemins(liste)
maxDist = 0
indexMax = -1
# Trouver feuille ayant la plus grande distance (en min)
for i in range(len(liste)):
if liste[i].distance > maxDist:
maxDist = liste[i].distance
indexMax = i
# Affichage du chemin et la longueur de celui-ci en minutes
print("\nChemin le plus long sur une charge :\n")
if not indexMax == -1:
strChemin = []
liste[indexMax].afficheChemin(strChemin)
strChemin[len(strChemin) - 1] = strChemin[len(strChemin) - 1][:-3]
for string in strChemin:
print(string, end="")
print("\nLongueur : " + str(maxDist) + " minutes\n")
def constructionArbreLong(l):
A = Arbre()
if len(l) == 1:
A = Feuille(l[0])
return A
else:
A.droit = Feuille(l[0])
A.gauche = Feuille(l[1])
for i in range(2, len(l)):
tmp = Arbre()
tmp.gauche = Feuille(l[i])
tmp.droit = A
A = tmp
A.equilibre()
return A
def arbre_feuille(self):
#pour chaque tuple(freq,char) de notre liste de l'alpha freq:
for (freq,char) in self.listeAlpha_freq:
#ajouter à la liste Arbre:
# - la frequence correspondant à la "valeur" de l'arbre/feuille;
# - le caractere correspondant au "label" de l'arbre/feuille;
self.listeArbre.append(Arbre(freq,char))
#puis retourner la liste Arbre
return self.listeArbre
class Main: #classe ou o fait les test
a = Freqlettre('extraitalice.txt') #on crée un objet Freqlettre
print(a.liste_freq_et_lettre) #on affiche la liste de tuple
b = a.creation_fichier() #on crée le fichier avec les tuples
arbre = Arbre('', a.liste_freq_et_lettre) #création d'un arbre
liste = arbre.tant_que(
) #on applique la methode tant_que a notre objet arbre pour parcourir ttes les feuilles, enlever
#les 2 premiers elem et construire l'arbre
liste[0].affiche_arbre() #affichage du dernier arbre restant dans la liste
a.ecrire_octet(liste[0]) #crée le fichier avec les caractères spéciaux
def creation_feuille(self):
#on parcourt les tuples (frequences,caractere) present dans la liste
#(frequence,alphabet)
#print("les feuilles",liste_afreq,"\n")
for (freq,alpha) in self.liste_afreq:
#on ajoute a la liste des arbres chaque tuple en creant un arbre
#a partir de chaque tuple
self.listeArbre.append(Arbre(freq,alpha))
return self.listeArbre
def __init__(self, game, playerTurn=0, valFirstPlayerIsValJ2=False):
# generation de l'arbre des differents etats possibles
debutchrono = time.time()
self.arbre = Arbre(game)
finchrono = time.time()
self.maximise = playerTurn == 1
self.invertGame = valFirstPlayerIsValJ2 # invertion is needed because the first player of the tree is J1
print('valFirstPlayerIsValJ2: ', valFirstPlayerIsValJ2)
print("Travail termine ! temps ecoule: ",
str(round(finchrono - debutchrono, 3)))
self.game = game
self.node = self.arbre.node
def constructionArbre(l):
A = Arbre()
if len(l) == 0:
showinfo("Erreur", "Le fichier est vide")
return A
elif len(l) == 1:
A = Feuille(l[0])
return A
A.gauche = Feuille(l[0])
A.droit = Feuille(l[1])
for i in range(2, len(l)):
A = A.constructionArbre(l[i])
A.equilibre()
return A
def constructionMobile(l):
A = Arbre()
if type(l[0]) is int:
A.gauche = Feuille(l[0])
elif type(l[0]) is list:
A.gauche = constructionMobile(l[0])
if len(l) <= 1:
return A.gauche
if type(l[1]) is int:
A.droit = Feuille(l[1])
elif type(l[1]) is list:
A.droit = constructionMobile(l[1])
A.equilibre()
return A
def creationArbre(self):
# On prend les 2 plus petit elements de listeArbre
abr1 = self.listeArbre[0]
abr2 = self.listeArbre[1]
# On cree un nouvel arbre qui va avoir 2 enfants (abr1 et abr2)
arbre = Arbre("", abr1.valeur + abr2.valeur, abr2, abr1)
# On enleve les 2 plus petit elements de listeArbre
self.listeArbre.pop(1)
self.listeArbre.pop(0)
# On recupère l'index de la place ou doit etre placer arbre
index = self.indexNouvelArbre(arbre)
# On ajoute arbre au bon endroit dans listeArbre
self.listeArbre[index:index] = [arbre]
def creationArbre(self):
#on recupere les deux arbres les plus petits de la liste, ce qui correspond
#aux arbres a la premiere et deuxieme places dans la liste
ab1=self.listeArbre[0]
ab2=self.listeArbre[1]
#on cree un nouvel arbre qui prend en frequence la somme des deux arbres
#en label une chaine vide et en fils gauche le plus petit des 2 et en fils
#droit le plus grand
arbre=Arbre(ab1.valeur+ab2.valeur,'',ab1,ab2)
#on enleve de la liste des arbres le plus grand des 2 puis le plus petit
self.listeArbre.pop(1)
self.listeArbre.pop(0)
#on recherche l'index correspond au nouvel arbre precedemment cree
index=self.indexNewArbre(arbre)
#on ajoute dans la liste arbre a sa place le nouvel arbre
self.listeArbre[index:index]=[arbre]
def arbre(self):
#le 1er arbre :
arbre1=self.listeArbre[0]#le plus petit
#le 2eme arbre :
arbre2=self.listeArbre[1]#le deuxième plus petit
#on crée un arbre qui va additionner la fréq des deux arbres/feuilles
#et qui va mettre en fils droit l'arbre2 et en fils gauche l'arbre3
arbre=Arbre(valeur=arbre1.valeur+arbre2.valeur,
label='',fils_droit=arbre2,fils_gauche=arbre1)
#on supprime ensuite les deux arbres de gauche de la listeArbre
self.listeArbre.pop(1)
self.listeArbre.pop(0)
#on appelle la méthode index() qui retourne l'index de l'arbre présent dans la liste en fct de sa valeur et label
index=self.RecupIndexNewArbre(arbre)
#que l'on va utiliser pour ajouter l'arbre à
#la bonne place dans la liste Arbre:
self.listeArbre[index:index]=[arbre]
def branch_bound(self, V):
# Affichage au début de l'algo
if self.timed == 0:
self.send_to_Trace("Debut du Branch & Bound :\n", "in")
self.timed = time.time()
# Initialisation de l'algo
arbre = Arbre(V, self)
# Initialisation de la liste des feuilles
sol = arbre.update()
# Tant qu'on a pas de solution, on met à jour la liste des feuilles
while not sol:
sol = arbre.update()
if isinstance(sol, str):
print sol
return
# Construction de la solution entière à partir de la feuille
solution = []
while sol:
solution += [(sol.motObj, sol.mot, sol.value)]
sol = sol.pere
# Affichage de la solution et du temps de calcul
self.timed = time.time() - self.timed
self.send_to_Trace("Fin du Branch & Bound ", "out")
self.send_to_Trace(" Temps :" + str(self.timed) + "\n", "time")
self.res = solution
self.sendResult(self.res)
self.pause()
with self.pause_cond:
while self.paused:
self.pause_cond.wait()
self.timed = time.time()
def assert_arbre_prob(input):
arbre = Arbre()
root = arbre.root
add_children(root, 10)
assert_answer(input, arbre)
def creationFeuille(self):
for (u, v) in self.elem:
self.listeArbre.append(Arbre(v, u))
def testArbre(self):
graphe = Graphe("centresLocaux.txt")
arbre = Arbre(2)
arbre.fillArbre(graphe.listeSommets, graphe.matriceArete, 0, 1)
