Group: 4SIQ3

Assem Chelli

Walid Benchaita

Réalisé Par:

1I. Index

I. IndexII. IntroductionIII. Travaille à faire

A. LE LABYRINTHE:B. LE TAQUIN

C. LA GRANDE TRAVERSEE

IV. Algorithme General de A*

V. Implémentation des jeux

A. LE LABYRINTHE:B. LE TAQUIN

C. LA GRANDE TRAVERSEE

VI. Classes et Structures

VII. Programme de A* en C++

VIII. Programmes de jeux

A. LE LABYRINTHE:B. LE TAQUIN

C. LA GRANDE TRAVERSEE

IX. ExemplesX. ConclusionXI. Bibliographie

2II. Introduction :Pour ce premier TP de MCCP, nous devions concevoir la solution d’une série de

jeu on utilisant la méthode heuristique de résolution. Avant d’aller plus loin, nous allons rappeler qu’elle est cette méthode heuristique. L’heuristique est définie par Larousse, par «heuristique (du grec ancien εὑρίσκω, eurisko, « je trouve » 1) est un terme de didactiquequi signifie l'art d'inventer, de faire des découvertes (Littré). En sociologie, il s'agit d'une discipline qui se propose de dégager les règles de la recherche scientifique

En général une heuristique est un algorithme qui fournit rapidement (en temps polynomial) une solution réalisable, pas nécessairement optimale, pour un problème d'optimisation NP-difficile. Une heuristique, ou méthode approximative, est donc le contraire d'un algorithme exact qui trouve une solution optimale pour un problème donné.

Pour ce TP nous devions réaliser la solution qui s’appliquerait à des jeux. Nous avons décidé de traiter les jeux TAQUIN LABYRINTHE et LA GRAND TRAVERSER,.

Nous avons donc réalisé un algorithme heuristique général puis nous l’avons adaptée pour chacun des jeux . Nous avons implémenté cette fonction dans une interface séduisante pour rendre les jeux plus agréables à jouer.

3III. Travail à faire :

LE LABYRINTHE:

Le terme labyrinthe vient du grec λαβύρινθος, (en latin labyrinthus), mot dont l'étymologie est douteuse. Il désigne dans la mythologie grecque une série complexe de galeries construites par Dédale pour enfermer le Minotaure.

Par extension, un labyrinthe est un tracé sinueux, muni ou non d'embranchements, d'impasses et de fausses pistes, destiné à perdre ou à ralentir celui qui cherche à s'y déplacer.

Ce motif, apparu dès la préhistoire, se retrouve dans de très nombreuses civilisations sous des formes diverses.

De nos jours, le terme de labyrinthe désigne une organisation complexe, tortueuse, concrète (architecture, urbanisme, jardins, paysages...) ou abstraite (structures, façons de penser...), où l'homme peut se perdre. Le cheminement du labyrinthe est difficile à suivre et à saisir dans sa globalité.

On va s’intéresser aux labyrinthes mathématiques de la forme rectangulaire

Un labyrinthe rectangulaire parfait de m colonnes par n lignes est un ensemble de mn cellules reliées les unes aux autres par un chemin unique avec une seul sortie et un ensembles d’obstacles

4LE TAQUIN

Le taquin est un jeu solitaire en forme de damier créé vers 1870 aux Etats-Unis. Sa théorie mathématique a été publiée par l'American Journal of mathématiques pure and applet en 1879. En 1891, son invention fut revendiquée par Sam Loyd, au moment où le jeu connaissait un engouement considérable, tant aux Etats-Unis qu'en Europe. Il est composé de 15 petits carreaux numérotés de 1 à 15 qui glissent dans un cadre prévu pour 16. Il consiste à remettre dans l'ordre les 15 carreaux à partir d'une configuration initiale quelconque.

Méthode générale de résolution

Dans l'hypothèse où la case vide se trouve en bas à droite :

remettre le jeu dans l'ordre ligne par ligne en commençant par la ligne du haut ; quand il ne reste plus que deux lignes mélangées, les réordonner colonne par colonne en

commençant par celle de gauche.

Cette méthode ne garantit pas qu'un nombre minimal de mouvements sera effectué, mais est simple à mémoriser et aboutit dans tous les cas où une solution est possible.

5LA GRANDE TRAVERSEE

On a un nombre N (donne par l’utilisateur) de personnes qui veulent traverser un pont de nuit et disposent d’une seul lampe chaque personne effectuent la traverser dans un temps qui lui est propre (définit par l’utilisateur) Sachant qu'elles doivent traverser au maximum à 2 personnes et ils ne peuvent traverser qu’avec la lampe (un des deux personne retraverse le pont) le but est de trouver le temps minimal nécessaire pour que les N personnes effectuent la traversée.

Choisi un exemple

Exemple 1

4 personnes doivent traverser un pont de nuit et ne disposent que d'une seule lampe.L'une effectue la traversée en 10min, la 2ème en 5min, la 3ème en 2min et la dernière en 1mn.Sachant qu'elles doivent traverser au maximum à 2 personnes ET avec la lampe, trouver le temps minimal nécessaire pour que les 4 personnes effectuent la traversée.10min5min 2min1min

NOTE 1 : Par exemple si 1min et 5min traversent ensemble, ils effectuent la traversée en 5min (temps du plus lent), et l'un d'eux doit revenir avec la lampe pour aller chercher les 2 autres.

NOTE 2 : La réponse est 17min !!!

6IV. Algorithme General de A*

CreerFile( F ); /* une file de priorité ordonnée par f */

Z := {Racine}; /* un chemin formé par un seul sommet */

Enfiler( F , <Z,f(Racine)> );

Trouv := FAUX;

TantQue Non FileVide(F) et Non Trouv

Defiler( F , Z );

Soit x le dernier sommet du chemin Z;

Si x <> BUT

Soient y1,...yk les succ de x qui n’appartiennent pas à Z;

Pour i:=1,k

T := Z + {yi} /* former de nouveaux chemins */

Enfiler(F,<T,f(yi)>); /* et les enfiler */

FP

etiq: /* pour le moment rien à faire ici */

Sinon

Trouv := VRAI

Fsi

FTQ

7V. Implémentation des jeux

A. LE LABYRINTHE:

Configuration :Joueur et But :

X Y

Board :

0 0 0 0

-1 0 0 0

0 0 -1 -1

-1 0 0 0

0 : case vide

-1 : un bloc

Fonction de coût :La fonction g(x) = le nb de cases parcourus dans ce chemin depuis la racine jusqu’à x

Fonction d’estimation :La fonction h*(x) = la distance euclidienne entre la case de joueur et la case de but.

Comment calculer le successeur ?Le joueur peut déplacer à droite, à gauche, haut et bas

8B. LE TAQUIN

La configuration :1 2 3

4 5 6

7 8 0

0 : la case videX : le nombre de case

La fonction de cout :Le nombre des étapes

La fonction d’estimation :La somme des distances « en pâté de maison » entre actuel places et But places

Comment calculer les successeursRecherche la case vide et permute avec les adjacents dans tous les 4 vois

9

C. LA GRANDE TRAVERSEE

Configuration :1 2 3 4 5 6 7 8 9 10R R R R L l R L L L

R : Person i dans la côte droite

L: Person i dans la côté Gauche

r : le Person i va à la côte droite

l : le Person i va à la côte gauche

La Fonction de cout :La somme de temps estime depuis le début

La fonction d’estimation :C’est la somme de durée de passage des pensons dans la cote droite +le minimum de durée des personnes dans la cote gauche si la lampe est a cette cote

Comment calculer le successeur ?1. si la lampe a la cote droite alors choisir deux personnes pour passer a la cote gauche

Sinon choisir un seul Person pour retourner avec la lampe

10VI. Classes et Structuresstruct config{char val[tab_max_x][tab_max_y];

};struct list { config X; list *suiv; };struct data { list *Z; float f; float g; }; struct file { data D; file *suiv; };

/*class general d'entree BBA*/class system { public: system()

{cpt=0;trouv=false;solution=NULL;n=tab_min_x;m=tab_min_y;}

bool trouv; char n,m; config init; bool (*but)(config A,int n,int m); float (*p)(config A,int n,int m); float (*h)(config A,int n,int m); list *(*SUCC)(config A,int n,int m); list *solution; int cpt;

};

11VII. Programme de A* en C++/*declaration du fonctions*/bool eqiv(config A,config B,char n,char m);bool copylist(list *A,list **B);list *inverser(list *A);bool detruire(list **A);bool inserer(list **Z,config X0);bool search(list *Z,config X0,char n,char m);void exporter(list *s,char mode,char n,char m);bi SchConf(config A,char n,char m,char val);bool enfiler(file **F,data D);data defiler(file **F);

/*Fonction de A* */bool BBA(class system *system){file *F=NULL;data D;config X; char n=system->n; char m=system->m;

list *T=NULL,*Z=new list,*Ferm=new list,*last=NULL; Z->X=system->init; Z->suiv=NULL; Ferm->X=system->init; Ferm->suiv=NULL; int cpt=0; D.Z=Z; D.f=system->h(Z->X,n,m)+system->p(Z->X,n,m); enfiler(&F,D);

bool trouv=false;while (F!=NULL && !trouv) {D=defiler(&F);printf("%d\t",cpt++); Z=D.Z; X=Z->X; float g=D.g; if (!(system->but(X,system->n,system->m))) {for(list *l=system->SUCC(X,n,m);l!=NULL;l=l->suiv) {config Y=l->X if (!search(Z,Y,system->n,system->m)) {copylist(Z,&T); inserer(&T,Y); D.Z=T; D.f=system->h(Y,n,m)+system->p(Y,n,m)+g; D.g=system->p(Y,n,m)+g; enfiler(&F,D); } } detruire(&last);last=Z; } else trouv=true;

} system->solution=inverser(Z); system->trouv=trouv; return trouv;};

12VIII. Programmes de jeux

A. LE LABYRINTHE:

#define max_lab 80 int x_but_Lab=0;int y_but_Lab=0;

char board[max_lab][max_lab];

char X_lab=2;char Y_lab=2;

float h_Lab(config A,int n,int m){ return sqrt((x_but_Lab-A.val[0][0])*(x_but_Lab-A.val[0][0])+

(y_but_Lab-A.val[0][1])*(y_but_Lab-A.val[0][1]));}

float p_Lab(config A,int n,int m){

return 1;};

list *SUCC_Lab(config A,int n,int m){ list *l=NULL; config B;

char x=A.val[0][0];char y=A.val[0][1];

B=A; if (x!=0) if (board[x-1][y]!=-1) {B.val[0][0]--;}; inserer(&l,B,n,m); B=A; if (x!=X_lab-1) if (board[x+1][y]!=-1) {B.val[0][0]++;}; inserer(&l,B,n,m); B=A; if (y!=0) if (board[x][y-1]!=-1) {B.val[0][1]--;}; inserer(&l,B,n,m); B=A; if (y!=Y_lab-1) if (board[x][y+1]!=-1) {B.val[0][1]++;}; inserer(&l,B,n,m); return l;}

bool but_Lab(config A,int n,int m){

return (A.val[0][0]==x_but_Lab && A.val[0][1]==y_but_Lab);};

//initialize classclass system init_class_Lab(){ class system sys;

sys.h=(&h_Lab);sys.p=(&p_Lab);sys.SUCC=(&SUCC_Lab);sys.but=(&but_Lab);

return sys;}

13B. LE TAQUIN

config mx_but_Taq;

float h_Taq(config A,int n,int m){ float t2=0; for(char i=1;i<n*m-1;i++)

{ bi p=SchConf(A,n,m,i); bi g=SchConf(mx_but_Taq,n,m,i); t2+=sqrt((g.x-p.x)*(g.x-p.x)+(g.y-p.y)*(g.y-p.y)); } return t2;}

float p_Taq(config A,int n,int m) {return 1;};

list *SUCC_Taq(config A,int n,int m){ list *l; config B; bi v=SchConf(A,n,m,0); char x=v.x; char y=v.y;

B=A; if (x!=0) {B.val[x][y]=B.val[x-1][y];B.val[x-1][y]=0;}; inserer(&l,B); B=A; if (x!=n-1) {B.val[x][y]=B.val[x+1][y];B.val[x+1][y]=0;}; inserer(&l,B); B=A; if (y!=0) {B.val[x][y]=B.val[x][y-1];B.val[x][y-1]=0;}; inserer(&l,B); B=A; if (y!=n-1) {B.val[x][y]=B.val[x][y+1];B.val[x][y+1]=0;}; inserer(&l,B); return l;}

bool but_Taq(config A,int n,int m){ char i;

for(i=0;i<n;i++) for(char j=0;j<m;j++) {if (A.val[i][j]!=mx_but_Taq.val[i][j]) goto fin_eqiv;}

fin_eqiv:if (i==n) return true; else return false;};

//initialize classclass system init_class_Taq(){ class system sys; sys.h=(&h_Taq); sys.p=(&p_Taq);

sys.SUCC=(&SUCC_Taq);sys.but=(&but_Taq);

return sys;}

14C. LE PROBLEME DE PONT

#define NbMax 30int TIME[NbMax];

//functionsfloat h_Pont(config A,int n,int m){

float t2=0; float minLeft=1000000; char Lamp='r';

for(int j=0;j<m;j++) switch(A.val[0][j])

{case 'R':t2+=TIME[j];break;

case 'L':if (minLeft>TIME[j]) minLeft=TIME[j];break; case 'r':Lamp='r';t2+=TIME[j];break;

case 'l':if (minLeft>TIME[j]) minLeft=TIME[j]; Lamp='l';break; default :Lamp='e';//erreur }; if (Lamp=='l') t2+=minLeft;

return t2;}

float p_Pont(config A,int n,int m){

float t1=0; float Left=0,Right=0; char Lamp='r'; for(int j=0;j<m;j++)

switch(A.val[0][j]){case 'R':break;case 'L':break;

case 'r':Right=TIME[j];Lamp='r';break; case 'l':Left=TIME[j];Lamp='l';break; default :Lamp='e';//erreur }; if (Lamp=='l') t1=Left; if (Lamp=='r') t1=Right;

return t1;};

bool but_Pont(config A,int n,int m){

bool but=true;for(int j=0;j<m;j++)

{if (A.val[0][j]=='R' || A.val[0][j]=='r') but=false;}; return but;};

15list *SUCC_Pont(config A,int n,int m){

list *l=NULL;char Lamp='r';

config B=A;for(int j=0;j<m;j++)

switch(B.val[0][j]) { case 'R':break; case 'L':break; case 'r':B.val[0][j]='R';Lamp='r';break; case 'l':B.val[0][j]='L';Lamp='l';break; default :;//erreur }; for(int j=0;j<m;j++) switch(B.val[0][j]) { case 'R':if (Lamp=='r' && j!=m-1)

{//2 go to left side for(int k=j+1;k<m;k++){if (B.val[0][k]=='R') {

if (TIME[j]<TIME[k]) {B.val[0][j]='L';B.val[0][k]='l';}

else {B.val[0][j]='l';B.val[0][k]='L';};

inserer(&l,B,n,m);B.val[0][k]='R';

B.val[0][j]='R'; };}};break;

case 'L':if (Lamp=='l') {B.val[0][j]='r';inserer(&l,B,n,m);B.val[0][j]='L';};break;

default :Lamp='e';//erreur };

return l;}

//initialize classclass system init_class_Pont(){ class system sys; sys.h=(&h_Pont); sys.p=(&p_Pont); sys.SUCC=(&SUCC_Pont); sys.but=(&but_Pont);

return sys;}

16IX. Exemples

Labyrinthe-ex1 (66 moves):

Labyrinthe-ex2 (21 moves):

17Taquin-ex1(28 moves)

step 0:

8 7

6 5 4

3 2 1

step 1:

6 8 7

5 4

3 2 1

step 2:

6 8 7

3 5 4

2 1

step 3:

6 8 7

3 5 4

2 1

step 4:

6 8 7

3 5 4

2 1

step 5:

6 8 7

3 5

2 1 4

step 6:

6 8

3 5 7

2 1 4

step 7:

6 8

3 5 7

2 1 4

step 8:

6 8

3 5 7

2 1 4

step 9:

3 6 8

5 7

2 1 4

step 10:

3 6 8

2 5 7

1 4

step 11:

3 6 8

2 5 7

1 4

step 12:

3 6 8

2 5 7

1 4

step 13:

3 6 8

2 5

1 4 7

step 14:

3 6

2 5 8

1 4 7

step 15:

3 6

2 5 8

1 4 7

step 16:

3 6

2 5 8

1 4 7

step 17:

2 3 6

5 8

1 4 7

step 18:

2 3 6

1 5 8

4 7

step 19:

2 3 6

1 5 8

4 7

step 20:

2 3 6

1 5 8

4 7

step 21:

2 3 6

1 5

4 7 8

step 22:

2 3

1 5 6

4 7 8

step 23:

2 3

1 5 6

4 7 8

step 24:

2 3

1 5 6

4 7 8

step 25:

1 2 3

5 6

4 7 8

step 26:

1 2 3

4 5 6

7 8

step 27:

1 2 3

4 5 6

7 8

step 28:

1 2 3

4 5 6

7 8

18Grand Traversi-ex1(7 steps)

step 0:

left side:() >>>>>>>>>> (1(1) , 2(3) , 3(6) , 4(8) , 5(12) , ):right side

step 1:

left side:(1(1) , 2(3) , ) <<<<<<<<<<<<(3(6) , 4(8) , 5(12) , ):right side

step 2:

left side:(2(3) , ) >>>>>>>>>> (1(1) , 3(6) , 4(8) , 5(12) , ):right side

step 3:

left side:(2(3) , 3(6) , 5(12) , ) <<<<<<<<<<<<(1(1) , 4(8) , ):right side

step 4:

left side:(3(6) , 5(12) , ) >>>>>>>>>> (1(1) , 2(3) , 4(8) , ):right side

step 5:

left side:(1(1) , 2(3) , 3(6) , 5(12) , ) <<<<<<<<<<<<(4(8) , ):right side

step 6:

left side:(2(3) , 3(6) , 5(12) , ) >>>>>>>>>> (1(1) , 4(8) , ):right side

step 7:

left side:(1(1) , 2(3) , 3(6) , 4(8) , 5(12) , ) <<<<<<<<<<<<():right side

19X. Conclusion

Cette solution est une parmi plusieurs autres qu’on puisse proposer mais qui se base tous sur le même principe de backtracking ou précisément A*.

La réalisation de ce TP est passé par plusieurs étapes, au départ la compréhension et l’analyse des différents concepts demandés suivi de la conception des structures de données nécessaires puis le développement graphique de l’interface homme-machine.

Il fallait quelques petites recherches pour enfin s’en sortir et se rendre compte que s’était plus facile qu’on le voyait avant.

Nul n’est parfait, et sûrement qu’il y aura quelques manques que nous souhaitons corriger après votre vérification.

20XI. Bibliographié

Support de cours – MCP4 Fr.wikipedia.org