algorithme de rÉsolution d’un labyrinthe · notre choix s’est donc porté sur celui-ci....

Mathématiques S3

Modélisations mathématiques M3202C-S3

Département Informatique

Romain SEMLER, Cédric VIGNE, Manon SAILLARD Groupe 4, 2nd année Date de rendu : 23 octobre 2014 Enseignante responsable : Patricia GAITAN

ALGORITHME DE RÉSOLUTION

D’UN LABYRINTHE

MODÉLISATIONS MATHÉMATIQUES

Mathématiques S3




2

SOMMAIRE

PRÉSENTATION DU PROJET ..................................................................................................................................... 3

LE LABYRINTHE ..................................................................................................................................................... 3

LABYRINTHES ET MATHÉMATIQUES ..................................................................................................................... 4

AVANCEMENT DU PROJET ....................................................................................................................................... 5

PRÉPARATION ....................................................................................................................................................... 5

CRÉATION DU LABYRINTHE .................................................................................................................................. 6

RÉSOLUTION DU LABYRINTHE ............................................................................................................................ 10

ANNEXES ................................................................................................................................................................ 17

D’AUTRES ALGORITHMES DE RÉSOLUTION ........................................................................................................ 17

SOURCES WEB .................................................................................................................................................... 17

TÉLÉCHARGEMENT DU CODE SOURCE COMPLET .............................................................................................. 17

Mathématiques S3




3

PRÉSENTATION DU PROJET

Comme dans tout projet, des définitions s’imposent. Les bases de notre projet reposent avant tout

sur le principe d’un labyrinthe et les liens qu’il possède avec les mathématiques.

LE LABYRINTHE

Il s’agit d’un tracé sinueux contenant des impasses ou des fausses pistes dans le but de ralentir ou

de perdre celui qui cherche à s’y déplacer.

Les origines du labyrinthe remontent à la préhistoire. Beaucoup de civilisations, notamment les

grecs et les égyptiens, dessinaient et créaient des labyrinthes. Dans le temps, cette structure était

très utile pour distraire ou faire perdre du temps à l’ennemi, mais aujourd’hui beaucoup de

méthodes existent pour en sortir en un minimum de temps (et même si l’on est plongé dans

l’obscurité). En informatique, le défi de sortir du labyrinthe est un bon moyen de tester la

puissance d’un ordinateur. Beaucoup d’algorithmes de résolution existent à ce jour.

Ci-dessus, un labyrinthe généré et résolu par un algorithme

Mathématiques S3




4

LABYRINTHES ET MATHÉMATIQUES

En mathématiques un labyrinthe est une surface connexe1, qui peut être modélisé dans un espace

multi-dimensionnel. On trouvera plus couramment, des labyrinthes en deux dimensions.

Il existe deux types de labyrinthes : les labyrinthes parfaits et imparfaits.

On peut imaginer en informatique et en mathématique que le labyrinthe est une matrice

constitué de cellules, contenant des murs ou des cases vides. Un labyrinthe est parfait lorsqu’il

possède un chemin unique qui passe par toutes les cellules. Il est considéré comme imparfait, s’il

contient un chemin qui se recoupe, formant ainsi des cloisons, appelées « ilots ».

Exemple de labyrinthe parfait Exemple de labyrinthe imparfait avec « îlot »

Pour créer ou résoudre un labyrinthe, on va généralement se servir de différentes variables qui le

constituent.

En effet dans ce projet, un labyrinthe est tout simplement un rectangle ou un carré de x colonnes

et de y lignes contenant xy cellules.

1 Un objet est dit connexe s’il est fait d’un seul morceau (Ex : Un archipel n’est pas connexe)

Mathématiques S3




5

AVANCEMENT DU PROJET

Avant d’arriver à l’étape de résolution du labyrinthe par un algorithme, plusieurs choses étaient à

mettre en place.

PRÉPARATION

Il fallait avant toute réalisation, choisir l’interface visuelle qu’allait utiliser notre algorithme. Nous

avions le choix entre une interface console2 ou une interface graphique3. Étant donné la difficulté

de lecture d’un labyrinthe dans une interface console, c’est l’interface graphique que nous avons

choisi.

Deux langages de programmation orientés objet4 (destinés aux interfaces graphiques) que nous

avons appris à l’IUT s’offraient à nous : le C++ et le Java. Parmi ces derniers, seul le langage Java

avait été manipulé avec des interfaces graphiques.

Notre choix s’est donc porté sur celui-ci. Différents logiciels existent pour coder en Java, mais

nous avons pris le plus connu et le plus présent en entreprise : Eclipse5.

Une fois tous ces préparatifs effectués, nous pouvions commencer à imaginer la fenêtre qui allait

accueillir notre labyrinthe ainsi, qu’à la manière de représenter les murs et les espaces vides du

labyrinthe.

Nous avons divisé notre code Java en trois classes6 : une classe contenant le labyrinthe, une classe

contenant la fenêtre principale et une classe contenant la fenêtre qui affiche le labyrinthe résolu.

Le sujet du projet étant le labyrinthe et son algorithme de résolution, le code Java de la fenêtre

principale n’apparaîtra pas dans ce dossier.

Toutefois, il est possible de télécharger le code complet du projet (voir Annexes page 17).

2 Appelé aussi « interface en ligne de commande », il s’agit d’une interface où l’homme et la machine communiquent en

mode texte. 3 Une interface graphique (GUI en anglais) est un dispositif de dialogue homme-machine à travers des objets graphiques tels

que des boutons, des cases à cocher, des zones de texte... 4 Style de programmation qui consiste en l’interaction d’entités du monde physique, de concepts ou d’idées appelés « objet »

(Ex : une voiture, une personne, une page d’un livre...). 5 https://www.eclipse.org/

6 En programmation, une classe représente une catégorie d’objet, déclarée par un constructeur et divers propriétés.

Mathématiques S3




6

CRÉATION DU LABYRINTHE

Pour résoudre un labyrinthe, il nous faut d’abord le créer. Nous voulions au départ écrire un

algorithme qui génère des labyrinthes selon une taille, en longueur et en largeur, définie par

l’utilisateur, mais les méthodes pour y arriver étaient trop compliquées à mettre en œuvre (peut-

être que cet algorithme verra le jour dans une version ultérieure).

Nous avons donc décidé de créer le labyrinthe manuellement, c'est-à-dire en écrivant cellule par

cellule la matrice. Trois labyrinthes de différentes tailles ont été créés au total, plus un labyrinthe

sans issue, pour tester le résultat inverse de l’algorithme de résolution.

Pour créer les labyrinthes, nous avons défini un constructeur7 qui prend en paramètre la taille du

labyrinthe selon un numéro entre 1 et 4 inclus. Le numéro 1 représente la première taille de

labyrinthe, le numéro 2 la deuxième, etc.

Extrait de code de la classe « Labyrinthe.java »

// Déclaration du constructeur publique du labyrinthe

public Labyrinthe(int taille){

//Affectation de la taille passée en paramètre

this.taille = taille;

//Appel de la fonction qui va créer le labyrinthe selon la taille

creerLab();

}

Le paramètre « taille » du constructeur est de type « int », ce qui veut dire que la taille est un

nombre entier.

« this.taille » permet de ne pas confondre la variable « taille » passée en paramètre du

constructeur avec la variable du même nom « taille » appartenant à la classe (d’où le « this »).

«creerLab()» signifie que l’on passe la main à la fonction qui porte le nom de « creerLab ». Elle est

en charge de créer le labyrinthe selon la taille demandée.

C’est d’ailleurs cette fonction que nous allons maintenant étudier.

7 En programmation orientée objet, un constructeur est une fonction particulière qui permet d’instancier un objet en

mémoire vive.

Mathématiques S3




7


// Déclaration de la fonction « creerLab »

public void creerLab(){

// Si la taille est égale au chiffre 1

if (taille == 1){

// Alors on crée une matrice de type int de 100 cellules définies

grille = new int[][]{

{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },

{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1 },

{ 1, 1, 0, 1, 0, 1, 0, 1, 0, 1 },

{ 1, 0, 0, 1, 0, 1, 1, 1, 0, 1 },

{ 1, 0, 1, 1, 0, 0, 0, 0, 0, 1 },

{ 1, 0, 1, 1, 0, 1, 1, 1, 0, 1 },

{ 1, 0, 1, 1, 0, 1, 0, 0, 0, 1 },

{ 1, 0, 0, 1, 0, 1, 1, 1, 1, 1 },

{ 1, 0, 1, 1, 0, 0, 0, 0, 0, 1 },

{ 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 }

}; //Fin de la déclaration de la matrice

} //Fin du if

Pour les labyrinthes de ce projet, le chiffre « 1 » représente un mur et le chiffre « 0 » un espace

vide (où l’on peut marcher). Lors de la résolution d’un labyrinthe on va parcourir la matrice à

partir de sa première cellule jusqu’à sa dernière. Ainsi le départ d’un labyrinthe se trouvera

toujours en haut à gauche (1ère cellule) et la sortie en bas à droite (dernière cellule).

Le code ci-dessus n’est pas complet, il est suivi d’un code identique mais pour des tailles et des

configurations de matrice différentes (si la taille est égale à 2 alors créer le deuxième labyrinthe, si

la taille est égale à 3 alors créer le 3ème labyrinthe, etc.).

La fonction ne se contente pas seulement de générer et d’écrire le labyrinthe, elle permet aussi de

créer les éléments graphiques qui permettent la visualisation du labyrinthe à l’écran.

Mathématiques S3




8

En effet un autre tableau est crée en parallèle : une matrice de boutons. Celle-ci est « calquée » à

la matrice du labyrinthe. Ainsi un bouton portant la valeur « 1 » a une image de fond noir (pour le

mur) et un bouton portant la valeur « 0 » a une image de fond blanc (pour l’espace vide).


//Déclaration de la matrice de boutons (de même taille que le labyrinthe)

button = new JButton[grille.length][grille[0].length];

//Début de parcours de la matrice du labyrinthe

for (int i = 0; i < grille.length; ++i)

for (int j = 0; j < grille[0].length; ++j) {

//Si la cellule parcourue vaut 0

if (grille[i][j] == 0)

//Alors lui associer le bouton « caseVide »

button[i][j] = new JButton(caseVide);

//Si la cellule parcourue vaut autre chose que 0

else

//Alors lui associer le bouton « caseMur »

button[i][j] = new JButton(caseMur);

//Redimensionner la cellule parcourue selon la variable « dim »

button[i][j].setPreferredSize(dim);

//Enlever à la cellule parcourue les bordures des boutons

button[i][j].setBorder(null);

//Ajouter au panel la cellule parcourue

panel.add(button[i][j]);

} //Fin de parcours de la matrice du labyrinthe

this.add(panel); // Ajouter le panel à la classe labyrinthe

} //Fin de la fonction creerLab()

Mathématiques S3




9

La variable « dim » ainsi que le panel sont déclarés plus haut dans le code.


//Déclaration de la variable dim

private Dimension dim = new Dimension(caseVide.getIconWidth(),

caseVide.getIconHeight());

//Déclaration du panneau JPanel et de son type (ici une grille)

JPanel panel = new JPanel();

panel.setLayout(new GridLayout(grille.length, grille[0].length));

« Dimension » permet de définir une taille d’objet personnalisée. Ici la variable « dim » possède

une taille, de largeur et de hauteur, égale à l’image de fond du bouton.

Le « panel » est l’élément qui va contenir toute la matrice de boutons pour ensuite l’afficher sous

forme de grille (de même taille que le labyrinthe) grâce au « GridLayout ».

Le résultat obtenu est le suivant (ici sous Windows) :

Ci-contre, il s’agit de la fenêtre principale construite par la

classe « FenetreLab.java » contenant au centre le fameux

« panel » du labyrinthe construit par la classe

« Labyrinthe.java ».

On remarquera l’entrée du labyrinthe en haut à gauche et la

sortie en bas à droite, ainsi que le menu « Labyrinthe » en

haut de la fenêtre, permettant de changer de taille à tout

moment (en fait il s’agit de la variable « taille » qui change de

valeur entre 1 et 4 inclus).

Lorsqu’on clique sur le bouton « Afficher le chemin », le

programme va appeler la fonction qui va résoudre le

labyrinthe. Cette fonction se trouve dans la classe

« Labyrinthe.java » mais la fonction qui la déclenche se trouve

dans « FenetreLab.java ».

Mathématiques S3




10

RÉSOLUTION DU LABYRINTHE

Dans notre programme, la fonction de résolution du labyrinthe s’appelle « resolutionLab ». Son

appel est déclenché lors du clic sur le bouton « Afficher le chemin » de la fenêtre principale. On va

donc s’intéresser à la classe « FenetreLab.java » car c’est là que se situe le bouton et son action de

clic.

Extrait de code de la classe « FenetreLab.java »

//Déclaration du bouton nommé « showSoluce »

public JButton showSoluce;

//Création du bouton « showSoluce » avec ajout du texte

showSoluce = new JButton("Afficher le chemin");

//Ajout de l’action lors du clic sur le bouton « showSoluce »

showSoluce.addActionListener(this);

//Ajout du bouton « showSoluce » au bas de la fenêtre principale

this.add(showSoluce, BorderLayout.SOUTH);

L’avant dernière ligne de cet extrait de code, signifie que l’action effectuée lors du clic sur le

bouton « showSoluce » se situe dans la même classe que son ajout (d’où le « this » entre

parenthèses) soit la classe « FenetreLab.java ».

La fonction de résolution « resolutionLab » est une fonction de type8 « boolean ». C'est-à-dire que

cette fonction renvoie une réponse de type « true » (vrai) ou « false » (faux).

Dans notre cas, si cette fonction renvoie « true » cela voudra dire qu’un chemin a été trouvé. La

fonction affichera alors à l’écran la solution. Si elle renvoie « false» cela voudra dire qu’aucune

solution n’a été trouvée pour le labyrinthe. Elle affichera dans ce cas un message l’indiquant.

8 En programmation, les fonctions peuvent avoir plusieurs types : int (renvoi un nombre entier), string (renvoie un texte),

boolean (renvoie vrai ou faux)... Précédemment dans la création du labyrinthe, les fonctions étaient de type « void » c'est-à-dire qu’elles ne renvoyaient rien.

Mathématiques S3




11

Donc lors du clic sur le bouton, l’action va être de tester si la fonction « resolutionLab »

appartenant à la classe « Labyrinthe.java » renvoie « true » ou « false».

Extrait de code de la classe « FenetreLab.java »

//Déclaration de l’action lors du clic sur le bouton « showSoluce »

public void actionPerformed(ActionEvent e) {

//Si la source du clic vient du bouton « showSoluce »

if (e.getSource() == showSoluce) {

//Et si la fonction « resolutionLab » renvoie « true »

if (labyrinthe.resolutionLab(0, 0)) {

//Alors on crée une fenêtre de la classe « GridSol.java »

grilleSol = new GridSol(labyrinthe.grille);

//Puis on la centre sur l’écran

grilleSol.setLocationRelativeTo(null);

//Puis on la rend visible

grilleSol.setVisible(true);

//Puis on rend le bouton « showSoluce » non cliquable

showSoluce.setEnabled(false);

} //Fin du deuxième if

//Autrement (donc si elle renvoie « false »)

else {

//Alors afficher un message l’indiquant

JOptionPane.showMessageDialog(this, "Aucune sortie n'a été

trouvée ");

} //Fin du else

} //Fin du premier if

} //Fin de l’action lors du clic

Mathématiques S3




12

La classe « GridSol.java » se charge de créer la fenêtre affichant la solution.

La fonction « resolutionLab » prend en paramètre les positions x et y de la case par laquelle elle

doit commencer. Ainsi nous avons écrit « resolutionLab(0, 0) » car notre position de départ est la

première case du tableau, soit l’indice 0 en ligne et 0 en colonne.

« labyrinthe.resolutionLab(0, 0) » veut dire que la fonction à appeler se trouve dans la classe

« Labyrinthe.java ». De même pour l’instruction « labyrinthe.grille » qui reprend la matrice du

labyrinthe pour afficher la solution.

La particularité de la fonction « resolutionLab » est le fait qu’elle utilise le principe de la

récursivité. En informatique et en logique, une fonction qui contient un appel à elle-même est

dite récursive.

En effet pour se déplacer dans la matrice et tester les différentes cases du labyrinthe, nous ne

devons pas seulement nous contenter de la position de la première case (« resolutionLab(0, 0) »),

il nous faut aussi tester la position de la case à côté et la position de la case en dessous. Pour ce

faire, il faut appeler encore une fois la fonction « resolutionLab » en changeant la valeur des

variables de position x et y, puis l’appeler autant de fois que nécessaire.

La fonction « resolutionLab » va donc s’appeler elle-même au sein de sa propre implémentation.

Dans notre cas il faudra l’appeler 4 fois pour tester le contenu de toutes les positions dans toutes

les directions possibles. Ci-dessous un tableau montrant les changements de positions effectués

lors de chaque appel de la fonction :

Appels de la fonction Variation de pos_x (en ligne) Variation de pos_y (en colonne)

Appel 1 pos_x + 1 pos_y

Appel 2 pos_x pos_y + 1

Appel 3 pos_x – 1 pos_y

Appel 4 pos_x pos_y - 1

C’est en effectuant des opérations basiques sur les coordonnées (pos_x, pos_y) des cases de la

matrice, qu’on parcourt ainsi le labyrinthe sans manquer une case.

Il ne faut pas oublier que chaque nouvel appel de fonction, signifie qu’une nouvelle réponse

« true » ou « false » est renvoyé à chaque fois. Nous avons donc déclaré une variable du nom de

« done » (pour ce qui est « fait ») qui prend pour valeur la réponse de chaque appel de fonction.

Mathématiques S3




13

Au début de l’algorithme, la variable « done » est initialisée à « false » car à ce moment là aucun

chemin n’a été trouvé. Ensuite, elle prend pour valeur la réponse du premier appel de la fonction,

soit « resolutionLab(pos_x + 1, pos_y) ». C’est ici que la récursivité commence.

Puis, si la variable « done » vaut « false » alors on teste le deuxième appel de la fonction :

« resolutionLab(pos_x, pos_y + 1) » en affectant à « done » la réponse de celle-ci.

Si la variable « done » vaut encore « false » alors on teste le troisième appel de la fonction :

« resolutionLab(pos_x - 1, pos_y) » en affectant à « done » la réponse de celle-ci.

Et ainsi de suite.

Le plus surprenant dans tout cela, est que pour chaque appel de fonction, les tests précédents

sont effectués de nouveau ! C’est comme si la même fonction était imbriqué en plusieurs fois.

Si la variable « done » vaut à un moment ou à un autre « true », alors on affecte à la position

connue la valeur 7.

Toutes les cases qui porteront ce chiffre feront parties du chemin de solution du labyrinthe.

Avant toute cette partie de code, deux vérifications sont réalisées. On vérifie d’abord que la case

testée est bien égale à 0 (espace vide), car si elle est égale à 1 (mur), ça ne sert à rien de continuer,

étant donné qu’il s’agit d’un obstacle. Puis on vérifie ensuite si l’on se situe oui ou non à la

dernière case de la matrice, car si c’est le cas alors « done » prend la valeur « true » (en effet la

dernière case représentant la sortie, on en déduit que le labyrinthe est résolu).

La première vérification est réalisée par une autre fonction se trouvant elle aussi dans la classe

« Labyrinthe.java ». Il s’agit de la fonction booléenne « estValide() » prenant en paramètre les

positions d’une case de la matrice. Son rôle est de vérifier si la case passée en paramètre est un

mur ou un espace vide. De plus, elle vérifie également si la case se situe toujours dans les

dimensions de la matrice (pour éviter tout dépassement des limites de la matrice).

La réponse de cette fonction (« true » ou « false ») est renvoyée par la variable « result ».

Mathématiques S3




14


//Déclaration de la fonction de type « boolean » estValide()

private boolean estValide(int pos_x, int pos_y) {

//Déclaration et initialisation de la variable « result » à « false »

boolean result = false;

//Si la case se situe dans les dimensions de la grille

if (pos_x >= 0 && pos_x < grille.length && pos_y >= 0 && pos_y <

grille[0].length)

//Et si la case est un espace vide

if (grille[pos_x][pos_y] == 0)

//Alors on affecte à « result » la valeur « true »

result = true;

//Enfin on retourne la valeur de « result »

return result;

} //Fin de la fonction estValide()

L’instruction « grille.length » permet de récupérer la taille totale de la matrice en ligne ou en

colonne.

Dans la fonction « resolutionLab() » la première chose à faire sera de vérifier si la fonction

« estValide() » a renvoyée vrai.

Comme on teste en premier la case de départ (0, 0) de la matrice, logiquement, elle est contenue

dans la matrice et c’est un espace vide. Ainsi lors de la première exécution de l’algorithme, la

fonction « estValide() » renverra forcément « true ».

Lorsqu’elle renvoie « false » cela veut dire que la case en question est soit un mur, soit dépasse les

limites de la matrice. Dans ce dernier cas, on passe directement à l’appel récursif suivant.

Voici maintenant le code complet et commenté de l’algorithme de résolution du labyrinthe.

Mathématiques S3




15


//Déclaration de la fonction « resolutionLab »

public boolean resolutionLab (int pos_x, int pos_y) {

//On déclare une variable « done » que l’on met à « false »

boolean done = false;

//Si la fonction « estValide » renvoie « true » pour « pos_x et pos_y »

if (estValide (pos_x, pos_y)) {

//Alors on affecte à la case (pos_x et pos_y) la valeur 3

//La valeur 3 veut dire qu’il s’agit d’une case valide

grille[pos_x][pos_y] = 3;

//Si on se trouve à la dernière case du tableau c’est gagné !

if (pos_x == grille.length-1 && pos_y == grille[0].length-1)

//Alors on retourne « true »

return true;

//Si non

else {

/* La variable « done » prend la valeur d’un nouvel appel de

la fonction « resolutionLab » (Récursivité) */

done = resolutionLab(pos_x + 1, pos_y);

//Si ensuite « done » renvoie « false »

if (!done)

//Alors on refait un nouvel appel (Récursivité)

done = resolutionLab(pos_x, pos_y + 1);


if (!done)


done = resolutionLab(pos_x - 1, pos_y);

Mathématiques S3




16


if (!done)


done = resolutionLab(pos_x, pos_y - 1);

} //Fin du else

//Si enfin « done » renvoie true

if (done)

//Alors la position ayant renvoyé « true » prend la valeur 7

grille[pos_x][pos_y] = 7;

} //Fin du if

//On renvoie la valeur de la variable « done » (true ou false)

return done;

} //Fin de la fonction « resolutionLab »

Il ne reste plus qu’à afficher la solution.

Cela se passe dans la classe « GridSol.java ». On va tout simplement ajouter aux boutons de la

matrice ayant la valeur 7, une image de fond orange pour bien faire ressortir le chemin menant à

la sortie.

Extrait de code de la classe « GridSol.java »

//… Après quelques conditions, si la case vaut 7

else if (soluceGrille[i][j] == 7)

//Alors le bouton a une image de fond orange (caseDepArr)

button[i][j] = new JButton(caseDepArr);

Au final nous avons bel et bien un algorithme qui résout un labyrinthe, se basant sur un principe

présent dans les mathématiques et d’autres sciences, la récursivité, et en modifiant les différentes

variables constituants le labyrinthe (longueur, hauteur, coordonnées...).

Mathématiques S3




17

ANNEXES

D’AUTRES ALGORITHMES DE RÉSOLUTION

Notre algorithme est un programme récursif parmi beaucoup d’autres. Ces algorithmes se classent

selon leur consommation en temps, en mémoire et selon leur fonctionnement.

Deux algorithmes de résolution en particulier se distinguent en informatique : le backtracking

(ou retour sur trace) qui permet de revenir en arrière au cas où une erreur est rencontrée (mais

sans combler le chemin qui mène à cette erreur) puis le dead-end filling qui à chaque fois que

celui-ci rencontre une impasse revient à l’intersection précédente en comblant le chemin qui

mène à cette impasse.

Dans un labyrinthe réel et non virtuel, il existe une méthode pour y sortir (même dans le noir).

C’est l’algorithme de Pledge, qui consiste à longer les murs avec sa main et à se guider en retenant

des chiffres selon le tracé du labyrinthe.

Plus d’informations ici : https://interstices.info/jcms/c_46065/l-algorithme-de-pledge

SOURCES WEB

http://www.liafa.jussieu.fr/~yunes/cours/concepts/fiches/2013/Labyrinthe.java.html

http://www.di.ens.fr/~mauborgn/td-99/programmation/tp8.html

http://fr.openclassrooms.com/informatique/cours/la-recursivite-1

http://fr.openclassrooms.com/informatique/cours/le-backtracking-par-l-exemple-resoudre-un-

sudoku

TÉLÉCHARGEMENT DU CODE SOURCE COMPLET

Vous pouvez téléchargez le code source complet du projet ici :

https://github.com/Semrom/Resolution-labyrinthe-Java/archive/LabJava.zip

http://www.liafa.jussieu.fr/~yunes/cours/concepts/fiches/2013/Labyrinthe.java.html

http://www.di.ens.fr/~mauborgn/td-99/programmation/tp8.html

http://fr.openclassrooms.com/informatique/cours/la-recursivite-1

http://fr.openclassrooms.com/informatique/cours/le-backtracking-par-l-exemple-resoudre-un-sudoku

http://fr.openclassrooms.com/informatique/cours/le-backtracking-par-l-exemple-resoudre-un-sudoku

algorithme de rÉsolution d’un labyrinthe · notre choix s’est donc porté sur celui-ci....

Documents