Graphe et Algorithmes A*

Graphe et
Algorithmes
A*
PR-3602
COURIVAUD Raphaël et LY Diane

Graphe et Algorithmes A*
2015
1
Dans le cadre du projet PR-3602, nous avons dû résoudre le problème de l’affectation.
Notre but est d’affecter un employé à un poste particulier ou une machine à une tâche en
connaissant le coût ou la performance de ces derniers pour chaque tâches/postes.
Préparation
Pour comprendre au mieux le problème, les notions suivantes sont importantes :
Qu'est-ce qu'un Graphe de Résolution de Problème (GRP), relativement à un problème
donné ?
Afin de résoudre le problème donné qui est assez complexe, nous avons mis en place un
graphe de résolution de problème (GRP). Ce graphe permet de modéliser chaque état d’un
problème. En effet, à chaque nœud de notre graphe, on y associe un état de notre
problème. Chaque nœud possède un prédécesseur qui représente l’état précédant. Et
autant de successeur que d’état possible au “coup suivant”.
Le problème de l’affectation peut se modéliser lui-même par un graphe, plus précisément un
graphe biparti. (Un graphe est dit biparti s'il existe une partition de son ensemble de
sommets en deux sous-ensembles U et V telle que chaque arête ait une extrémité dans U et
l'autre dans V, cf. http://fr.wikipedia.org). Dans notre cas l’ensemble U représente les
différents employés que l’on doit affecter aux différents postes de l’ensemble V. Pour cela
nous avons à notre disposition une matrice représentant le coût de l’affectation de
l’employé i au poste j :
0 1 2 3 4
𝑎
𝑏
𝑐
𝑑
𝑒
|
|
23 17 13 234
16 28 37 11 7
12 21 11 26 12
21 23 15 28 31
14 936 29 18
|
|
(0,1,2,3,4) représente l’ensemble V
(a,b,c,d,e) représente l’ensemble U

Graphe et Algorithmes A*
2015
2
Quel GRP proposeriez-vous pour le problème de l'affectation ?
Nous nous basons donc sur un GRP composé de nœuds représentant des graphes biparti. A
chaque profondeur du graphe, nous avons une nouvelle affectation. On a donc une source qui
est le graphe biparti vide. Et des feuilles qui représentent un graphe biparti complet.
Quel est, schématiquement, le fonctionnement d'un algorithme A* ?
Tout d’abord l’algorithme A* est un algorithme qui permet de résoudre un problème
modélisé par un GRP en évitant d’explorer tous les nœuds. En effet le nombre de nœud d’un
GRP peut s’avérer très rapidement énorme. Et compte tenu de la rapidité de calcul des
ordinateurs nous pouvons très rapidement arriver à des programmes de durée extrêmement
longues si l’on doit explorer tous les nœuds.
L’algorithme A* repose un peu sur la base d’un algorithme glouton sans pour autant écarté les
autres possibilités. En effet, A* va toujours se diriger vers la solution optimale en développant
les nœuds correspondants aux nœuds les plus aptes à donner une solution optimale. Cependant
si “il s'aperçoit” qu’il existe un autre chemin plus optimal, il peut revenir en arrière afin de
développer un nouveau nœud. Cela est possible car l’algorithme garde en mémoire tous les
nœuds possibles dans une liste (OUVERT) et peut également, garder dans une liste (FERMÉE)
tous les nœuds déjà parcourus.
Que représentent les symboles g, h et f dans l'algorithme ?
f représente la fonction d’évaluation qui est indispensable pour obtenir un tri optimal de la
liste OUVERT. f(n), fonction qui estime le coût d’un chemin optimal du nœud de départ au
dernier nœud, peut s’écrire sous la forme :
f(n) = g(n) + h(n)
avec :
 g(n) fonction qui estime le coût d’un chemin du nœud de départ et le nœud n à
développer.
 h(n) fonction qui estime le coût d’un chemin optimal du nœud sélectionné n au
nœud choisi.
H représente la fonction heuristique.
Quelle est la condition sur h pour que l'on parle d'algorithme A* ?
Pour qu’on puisse parler d’algorithme A*, il faut que f(n) estime au mieux f*(n), ce qui revient à
estimer au mieux l’heuristique. Pour que l'algorithme garantisse un résultat optimal quand il

Graphe et Algorithmes A*
2015
3
s'arrête, il faut que l'estimation de h, h* soit strictement inférieur au chemin optimal" Ainsi, nous
avons travaillé sur trois heuristiques différentes, décrites ci-dessous : l’heuristique « line »,
l’heuristique « column » et la plus optimale, l’heuristique « maximum ».
Description détaillée de notre programme
Nous avons, dans un premier temps, adapté la structure C qui nous était
fournie pour utiliser les fonctionnalités d’un langage objet tel que Python et créé un classe Node.
Cette classe contient comme attribut : son score g et h, le nombre d’affectation déjà réalisées
avec une liste de couple (i,j) (avec i, le i-ème employé et j, le j-ème poste,), ainsi que le nombre
totale d’affectation. Nous avons aussi définis quelques fonctions de base pour modifier les
attributs d’un nœud et redéfinis des fonctions systèmes comme __eq__(self, other) qui permet
de définir lorsqu’un nœud est ou non équivalent à un autre. Cela nous permet ainsi de
déterminer si un nœud est déjà ou non dans une liste (ici la liste OUVERT)
Nous avons ensuite mis en place le calcul des scores de chaque
nœud en fonction des différentes heuristiques que nous avions préalablement trouvées. Il était
très facile de trouver la valeur de g. Il suffit de récupérer toutes les affectations qui ont été
réalisées au nœud correspondant et de récupérer la valeur de ces dernières dans la matrice des
coûts. Dans un même temps nous créons deux listes qui contiennent tous les i et j (employés et
poste) qui ont été affectés, elles nous servirons pour le calcul de l’estimation de h.
En fonction de l’heuristique choisie nous devons maintenant définir la valeur de h*. On rappelle
que nos heuristiques, pour garantir l’optimalité du résultat, doivent donner un h* inférieur au
chemin optimal. Pour cela nous avons donné trois heuristiques différentes.
Tout d’abord l’heuristique ‘Line’ qui prend le minimum de chaque ligne sur la sous matrice des
employés et des postes qui n’ont pas encore été affectés. C’est dans cette partie que nos deux
listes des i et j nous servent. Nous parcourons toute la matrice en prenant en compte que les i et
j non affectés. Nous créons une liste pour chaque ligne et prenons le score minimum de chaque
ligne. Nous incrémentons alors l’estimation de h et passons à la ligne suivante. Nous observons
bien évidemment le même déroulement pour l’heuristique ‘Column’.
L’heuristique la plus optimale est de prendre le maximum des scores pour l’heuristique
‘Column’’ et ‘Line’. Nous devons calculer le score de h* pour les deux heuristiques et à chaque
noeud prendre celui qui est le plus élevé des deux.
Nous devons pour chaque état du GRP donner tous les
successeurs de ce nœud node, ainsi que tous les états suivants possibles.
Dans un premier temps nous avions mis en place un GRP qui prenait en compte tous les états
possibles à chaque profondeur : Au premier état du graphe, nous pouvions affecter tous les
Class Node() :
Méthode computeH() :
Méthode developNode() :

Graphe et Algorithmes A*
2015
4
employés à tous les postes. Au deuxième état, nous éliminions l’employé et le poste déjà affecté,
et nous observions encore tous les cas possibles pour tous les employés et tous les postes.
Au nœud initial, nous avions alors NxN successeur, au deuxième (N-1)x(N-1), troisième (N-2)(N-
2) etc… Ce GRP était possible mais développait beaucoup trop de nœuds et n’était donc pas du
tout optimal pour notre cas. Notre programme marchait pour des petites matrices mais était
très vite dépassé lorsqu’on augmentait la taille de ces dernières.
Dans un deuxième temps, Mr Couprie nous a indiqué un graphe de résolution de problèmes plus
optimal qui consistait à développer seulement un employé à la fois à chaque profondeur. Si le
nœud de départ est le graphe biparti vide, on développe tous les états possibles pour l’employé
1 : on ne développe que N successeurs puis N-1, N-2 etc… On voit bien évidemment que la
quantité de nœuds développés à chaque coup est bien moindre que notre premier GRP.
Pour développer le nœud courant, on récupère tous les postes déjà affectés dans une liste qui
nous permet de ne pas parcourir ces derniers lors du balayage de la matrice. De plus, le i est fixé
puisque c’est l’affectation du i-ème employé pour la profondeur i. Il nous suffit donc de balayer
les colonnes pour une ligne définie. Cela nous permet de créer un nœud par colonne avec un
nombre d’affectation incrémenté par rapport à son “parent” et une nouvelle liste d’affectation.
Nous ajoutons un pointeur vers son parent grâce à un attribut de la class Node qui est une
instance de la même classe. Chaque nœud est ajouté dans une liste qui est retourné par la
fonction. On appelle ensuite Node.ComputeH() sur cette liste qui permet de calculer à chaque
fois le score g et h de chaque nœud.