Résolution d`un puzzle

Optimisation 2 : projet Eternity II
Dimitri Watel
Semestre 5, 2016
D´eroulement du projet
Ce projet consiste en l’´etude d’un probl`eme via toutes les techniques de recherche op´erationnelle que l’on vous
a enseign´e jusqu’`a pr´esent ou que vous connaissez. Il propose des ´etapes d’´etude de l’aspect th´eorique ou appliqu´e.
Il s’effectue en binˆome. Vous devez rendre un code, un rapport et effectuer une soutenance. Le code et le
rapport doivent ˆetre rendus en temps et la soutenance doit ˆetre effectu´ee sans quoi la note que le binˆome se verra
attribu´ee sera 0. En cas d’absence d’un des deux membres `a la soutenance, la personne pr´esente se verra le droit de
soutenir seule. Si l’absence est justifi´ee, votre charg´e de projet peut s’arranger pour faire soutenir l’autre personne
un autre jour. Sinon elle se verra seule attribu´ee la note de 0.
Le rapport
Vous devez rendre le rapport dans une archive rapport.tar.gz. Le rapport en lui mˆeme doit ˆetre r´edig´e dans
un fichier rapport.pdf. Si vous le souhaitez, vous pouvez ajouter des documents annexes dans un dossier Annexe,
mais ces documents ne seront pas n´ecessairement relus par votre charg´e de projet.
Le fichier rapport.pdf doit avoir une vingtaine de pages maximum (images comprises). Il n’y a pas de minimum
de page autre que celui que votre conscience vous impose. Bref, le rapport ne doit ˆetre ni insuffisant ni du remplissage
inutile. Petit rappel : un rapport comporte une introduction rappelant rapidement le sujet et pr´esentant rapidement
la contribution, une conclusion, une page de garde, un sommaire, ...
Les annexes servent `a mettre les preuves trop longues, les tableaux trop grands, ... Dans tous les cas, le rapport
doit se suffire `a lui mˆeme. Par exemple, si vous d´ecidez de placer une preuve en annexe, il peut ˆetre bon de laisser
une id´ee de la preuve dans le rapport.
Le rapport sera not´e sur le fond et la forme. Le fond regroupe la justesse des preuves, la validit´e/pertinence des
mod`eles de programmation lin´eaire et des algorithmes (pourquoi pensez vous que ce sont de bons mod`eles/algorithmes)
et, enfin, la pertinence des ´evaluations num´eriques que vous effectuerez. La forme regroupe votre qualit´e `a synth´etiser,
la qualit´e des images et des exemples, la clart´e des propos, les fautes d’orthographe, ...
Le code
Vous devez rendre le code dans une archive nomm´ee code.tar.gz. Ce code doit ˆetre comment´e et il doit
pouvoir se compiler sans erreur ni warning `a l’aide d’un Makefile qui vous est donn´e. Il devra pouvoir fonctionner
uniquement avec les fichiers pr´esent dans l’archive `a l’exception de possibles fichiers d’entr´ee et de sortie. Si une de
ces conditions n’est pas respect´ee, la moyenne ne peut ˆetre attribu´ee `a ce projet : il vaut mieux ne rien rendre que
rendre un code qui ne compile pas ! Testez votre compilation r´eguli`erement, et faites des sauvegardes au fur et `a
mesure. Vous utiliserez le langage C.
Vous ne devez pas cr´eer l’archive code.tar.gz vous-mˆeme. Une commande vous est fournie pour ce faire.
Tout est expliqu´e dans la partie suivante.
Organisation du code ; l’archive opti2.tar.gz
Vous devez t´el´echarger et d´ecompresser l’archive opti2.tar.gz cr´eant ainsi normalement un dossier opti2 qui
contient tous les fichiers n´ecessaires au d´emarrage du projet.
Cette archive contient de nombreux fichiers. Ceux qui vous int´eressent sont :
— Le fichier algorithm 0.c contient un mod`ele de code d’algorithmes.
— Les fichiers algorithm exemple.c et algorithm lpexemple.c contiennent des exemples d’algorithmes.
— Un fichier Makefile, d´ej`a r´edig´e, pour compiler votre code.
1

— Un dossier Benchmark contenant des fichiers .input, chacun repr´esentant une instance du probl`eme (voir la
section Fichier d’entr´ee et de sortie des codes, page 4 ).
— Une biblioth`eque proglin helper(.c,.h) pour cr´eer et ex´ecuter facilement un programme lin´eaire.
— Un dossier customlibs o`u vous pourrez mettre des fichiers .c et .h indirectement li´es au projet
— Un dossier others o`u vous pourrez mettre tout autre fichier (par exemple, des fichiers pour g´en´erer des
tests).
Deux exemples vous sont donn´es dans les fichiers algorithm exemple.c et algorithm lpexemple.c. Le second
vous montre comment utiliser un programme lin´eaire. Vous pouvez tester l’archive avec les commandes suivantes
$ make −j 4
$ . / algo r i thm exe m p le exemple . i npu t exemple . output
$ . / a l g o r i t h m lpe x e m p l e exemple . inp ut exemple . output
Ce premier make est long. C’est normal, il ne devrait plus l’ˆetre par la suite.
Tous les algorithmes que vous coderez seront plac´es dans le dossier racine opti2, sous le nom algorithm S.c
et le fichier compil´e se nommera algorithm S o`u S est le nom de votre algorithme. Votre fichier algorithm S.c
doit respecter quelques contraintes afin de faciliter votre travail et la correction du charg´e de projet. Pour cr´eer un
nouvel algorithme, vous ˆetes invit´es `a suivre la proc´edure indiqu´ee dans la partie Coder un nouvel algorithme,
page 4. Votre code doit poss´eder au moins 2 algorithmes :
algorithm exact1.c et algorithm pl1.c correspondant `a la partie 2 de ce sujet.
Pour compiler et ex´ecuter votre algorithme, vous devez effectuer les commandes suivantes o`u S est le nom de
votre algorithme et fichier.input fichier.output sont deux noms de fichiers.
$ make
$ . / a l g o r i t h m S f i c h i e r . i npu t f i c h i e r . output
Vous aurez peut-ˆetre besoin de fichiers .c et .h pour factoriser votre code, par exemple une biblioth`eque d´ecrivant
les dictionnaires ou les listes chain´ees. Vous devez placer tous ces fichiers dans le dossier customlibs. En utilisant
la commande make, ils seront automatiquement compris dans la chaˆıne de compilation, quelque soit l’algorithme
qui en a besoin. Il est donc, normalement inutile de toucher au fichier Makefile. Vous pouvez le constater avec la
biblioth`eque example d´ej`a pr´esente dans le dossier. Si toutefois vous ˆetes contraint de modifier le makefile, pr´evenez
votre charg´e de projet.
Tout autre fichier que vous cr´eez et que vous jugez utile de mettre dans l’archive code.tar.gz que vous rendrez
peut ˆetre plac´e dans le dossier others. Par exemple, si vous g´en´erez des tests, si vous cr´eez un fichier contenant le
r´esultat des tests, ...
Certains de vos algorithmes utiliseront une biblioth`eque de programmation lin´eaire : deux biblioth`eques de
programmation lin´eaire vous sont propos´ees. Par d´efaut, en tapant la commande make pour compiler, vous utilisez
la biblioth`eque SCIP. Vous pouvez, si vous le souhaitez utiliser la biblioth`eqe LPSOLVE si SCIP ne fonctionne pas
sur votre machine avec la commande make LPS=TRUE. Une interface proglin helper.h est pr´evue pour que vous
n’ayez pas `a changer votre code si vous souhaitez tester la premi`ere ou la seconde biblioth`eque.
Vous ne devez pas cr´eer l’archive code.tar.gz vous-mˆeme. Une commande vous est fournie pour ce faire.
$ make a r c h i v e
Cette commande ajoute l’archive code.tar.gz `a la racine de opti2. Cette archive contient tous vos algorithmes
et le contenu de vos dossiers customlibs et others. V´erifiez l`a avant d’envoyer votre code.
Notation du code
Votre code sera not´e en deux parties.
En premier lieu, chacun de vos fichiers algorithmes sera relu puis test´e et ´evalu´e sur un ensemble d’instances. Ces
instances ne sont pas exactement celles dont vous disposez dans l’archive opti2.tar.gz, mais seront g´en´er´ees de
la mˆeme fa¸con. Ces tests permettront uniquement de v´erifier si les algorithmes r´epondent correctement aux entr´ees
par rapport `a ce qui est indiqu´e dans le rapport.
Ensuite, vos deux algorithmes algorithm exact1.c et algorithm pl1.c seront compar´es `a ceux des autres
binˆomes sur 10 instances de tailles au plus 15x15. Pour chaque instance, chaque algorithme sera ex´ecut´e 100 fois,
puis le temps de calcul moyen est mesur´e. Deux classements sont effectu´es pour chaque instance, un par algorithme.
Un algorithme qui ne renverrait pas une solution en 2 minutes sur une des instances est retir´e du classement de
cette instance. Une premi`ere place rapporte 0.125 point, la seconde place 0.10, la troisi`eme place 0.075, la quatri`eme
0.05, et la cinqui`eme 0.025. Les autres places ne rapportent pas. Vous pouvez donc gagner jusqu’`a 2.5 points en
´etant premier partout. La somme des points est arrondie au demi-point sup´erieur. Ces points sont bonus.
2

La soutenance
Vous devez enfin effectuer une soutenance lors de la derni`ere s´eance. Sa dur´ee est de 15 minutes + 5 minutes
de questions. La soutenance n’a pas vocation `a r´ep´eter oralement la totalit´e du rapport mais `a ´evaluer vos qualit´es
de pr´esentation. Lors des 15 minutes de pr´esentation, vous devez : pr´esenter le sujet et vos r´esultats de la partie
D´eveloppement. Vous pouvez ´egalement, `a vos risques et p´erils, faire une d´emonstration de votre code pendant ces
15 minutes. Sachez toutefois que, pr´esentation termin´ee ou non, `a l’issue des 15 minutes, vous serez interrompus.
Remarque : vous ˆetes deux sur le travail, cependant, un d´ecoupage artificiel de la pr´esentation est inutile. Il vaut
mieux qu’une seule personne pr´esente le travail si vous avez travaill´e ensemble du d´ebut `a la fin. Les deux pourront
r´epondre aux questions.
L’archive `a renvoyer
Les archives rapport.tar.gz et code.tar.gz doivent ˆetre toutes les deux ins´er´ees dans une archive nomm´ee
opti2 binome N.tar.gz o`u N est votre num´ero de binˆome attribu´e `a la premi`ere s´eance. Cette archive sera rendue
seule sur exam.ensiie.fr.
Dates importantes
— Soutenance : vendredi 13 janvier, de 14h `a 17h45. Toute absence `a votre soutenance entraˆınera la note de 0.
— Rapport et code `a rendre au plus tard le dimanche 15 janvier `a 23h59. Tout rapport/code non rendu entraˆınera
la note de 0.
3

1 Probl`eme ´etudi´e
On ´etudie dans ce projet le probl`eme de r´esoudre un puzzle.
On dispose d’un ensemble de n×mpi`eces carr´ees de mˆeme taille. On souhaite les placer dans un rectangle
ayant npi`eces par ligne et mpar colonne. Les pi`eces ont des bords droits, si bien qu’il est physiquement possible
de placer chaque pi`ece `a cˆot´e de n’importe quelle autre.
Sur les bords de chaque pi`eces sont peintes des couleurs, distinctes ou non. On ne peut placer une pi`ece `a cˆot´e
d’une autre que si les couleurs des bords qui se touchent sont les mˆemes.
Dans cette version, il n’est pas possible de tourner les pi`eces.
Un exemple de puzzle est donn´e en Figure 1.
1 2
1
3
2 2
1
3
2 3
1
1
3 2
3
1
2 3
1
1
3 2
3
1
1 2
1
3
2 2
1
3
Figure 1
1.1 Coder un nouvel algorithme
Pour cr´eer un nouvel algorithme dont le nom est S, vous devez copier le fichier algorithm 0.c en algorithm S.c.
Vous pouvez ensuite remplir deux fonctions :
—void run(int width, int height, int** pieces, int** puzzle) : le coeur de votre algorithme, qui
remet les pi`eces du puzzle dans le bon sens. width et height indiquent la largeur et hauteur du puzzle.
pieces contient l’ensemble des pi`eces m´elang´ees, il s’agit d’un tableau de height ·width lignes et 5 colonnes.
Chaque ligne d´ecrit l’identifiant et les 4 couleurs d’une pi`ece par un entier dans cet ordre : haut, gauche, bas
et droite. La premi`ere pi`ece a pour identifiant 0, la suivante 1, ... la derni`ere (height ·width - 1). Enfin,
puzzle est un tableau de height lignes et width colonnes et est charg´e de recueillir la sortie. Vous devez,
avant la fin de la fonction, mettre dans puzzle[i][j] l’identifiant de la pi`ece que vous placeriez sur la ligne
i et la colonne j du puzzle. Dans l’exemple de la Figure 1, width et height vaudraient 2. pieces serait un
tableau contenant dans cet ordre la pi`ece en haut `a gauche, celle en haut `a droite, celle en bas `a gauche puis
la derni`ere en bas `a droite. Il faudrait mettre dans puzzle[0][0] la valeur 1, dans puzzle[0][1] la valeur 2, dans
puzzle[1][0] la valeur 3 et dans puzzle[1][1] la valeur 0.
—int post process(double cpu time, int width, int height, int** pieces, int** puzzle) o`u vous
pouvez afficher des informations dans une fichier ou dans la console. Cette fonction est appel´ee apr`es run.
Le param`etre cpu time est le temps de calcul de cette derni`ere fonction. La valeur des autres est celle des
mˆemes param`etres `a la sortie de la fonction run.
Attention ! Il ne faut pas lib´erer la m´emoire des pointeurs pieces et puzzle dans ces fonctions.
1.2 Fichiers d’entr´ee et de sortie des codes
Votre algorithme prendra en entr´ee le nom d’un fichier d’entr´ee .input (variable input file) et le nom d’un
fichier de sortie .output (variable output file). Vous n’aurez pas `a manipuler ces fichiers directement, le fichier
main.c s’en charge pour vous. Toutefois savoir comment sont organis´es ces fichiers peut vous int´eresser, entre autres
si vous voulez g´en´erer vos propres entr´ees.
Ces deux types de fichiers commencent pas une ligne ### Commentaire, suivie par une ligne vide. Le commentaire
permet d’expliquer par exemple comment le fichier est g´en´er´e. Il n’est pas possible de le faire sur plus d’une ligne.
Dans les fichiers d’entr´ee (fichiers .input) vous sont donn´ees 3 informations : les tailles net mdu puzzle et
une liste de n×mpi`eces dans un ordre arbitraire, chacune d´ecrite par ses 4 couleurs, s´epar´ees d’une virgule. Les
4

couleurs sont dans cet ordre : haut, gauche, bas, droite. Un identifiant est implicitement donn´e `a chaque pi`ece : leur
num´ero dans l’ordre dans lequel elles vous sont donn´ees. La premi`ere pi`ece a pour identifiant 0, la suivante 1, ... la
derni`ere le nombre de pi`eces moins 1.
Dans le fichier de sortie (fichiers .output) sont ´ecrites sur n×mlignes les pi`eces du puzzle. Elles sont ´ecrites
dans cet ordre : de gauche `a droite les pi`eces de la ligne la plus haute du puzzle, puis la seconde ligne de gauche
`a droite, puis la troisi`eme . . . jusqu’`a la ligne du bas. Une pi`ece est d´ecrite par son identifiant et ses 4 couleurs,
s´epar´es d’une virgule. Les couleurs sont dans cet ordre : haut, gauche, bas, droite.
Dans l’exemple de la Figure 1, le fichier example.input et le fichier example.output correspondant seraient
Listing 1 – .input
### Exemple d ’ e n t r e e
2 ,2
1 , 3 , 3 , 2
3 , 1 , 1 , 2
3 , 2 , 1 , 2
1 , 2 , 1 , 3
Listing 2 – .output
### Exemple de s o r t i e
1 , 3 , 1 , 1 , 2
2 , 3 , 2 , 1 , 2
3 , 1 , 2 , 1 , 3
0 , 1 , 3 , 3 , 2
2´ Etude commune
2.1 Mod´elisation
D´ecrivez ce probl`eme de mani`ere formelle. On attend de vous que vous l’´ecriviez sous forme d’un probl`eme de
d´ecision en d´etaillant l’instance et la sortie. On rappelle qu’il n’est pas possible de tourner les pi`eces. On
nommera ce probl`eme (PZL).
Votre mod`ele doit ˆetre valid´e par votre charg´e de TD avant de continuer.
2.2 ´ Etude de la complexit´e
On souhaite prouver que (PZL) est NP-Complet.
1. Expliquez pourquoi ce probl`eme est dans la classe NP.
2. Pour prouver la NP-Compl´etude, on va effectuer une r´eduction de puis le probl`eme de 3-partition. Vous
pouvez d´ecider de l’effectuer depuis un autre probl`eme si vous le souhaitez, mais vous ne serez pas guid´es.
Le probl`eme de 3 partitions consiste `a savoir si un ensemble Xde 3pentiers positifs peut ˆetre partitionn´e
en ptriplets de mˆemes sommes. Soit p·Bla somme totale des ´el´ements de X. On suppose tous les entiers
de Xstrictement compris entre B/2 et B/4. Ce probl`eme est NP-Complet au sens fort.
Voici des questions qui peuvent vous guider vers la r´eduction
(a) Montrer que la somme de chaque triplet dans une solution de 3 partition est B. Montrer qu’il n’est pas
possible de trouver 2 ´el´ements ou moins de Xdont la somme fait B. De mˆeme pour 4 ´el´ements ou plus.
(b) Comment forcer certaines pi`eces du puzzle `a ˆetre pos´ees sur un bord du puzzle ?
`
A l’aide de cette technique, on va fabriquer un puzzle avec p+ 2 lignes et B+ 2 colonnes tel que, quelque
soit la solution propos´ee, les 2p+ 2B+ 4 pi`eces de bords sont toujours les mˆemes.
(c) Soit iun entier. Comment forcer ipi`eces du puzzle `a ˆetre cˆote `a cˆote en ligne ? Pour chaque entier ide X,
on va cr´eer ipi`eces de la sorte. Soient pices pi`eces. On consid`ere maintenant que piest une super-pi`ece
de hauteur 1 et de largeur i.
(d) Faire en sorte qu’on puisse placer la super-pi`ece pi`a cˆot´e d’une pi`ece de bord (gauche, droite, bas et
haut), pour tout i∈X. Faire en sorte qu’on puisse placer pi`a cˆot´e de pj, pour tout i, j ∈X.
(e) Montrer qu’on ne peut placer plus de 3 super-pi`eces cˆotes `a cˆotes. Montrer ensuite que si, sur une ligne,
on ne place que 2 pi`eces piet pjcˆotes `a cˆotes, il sera impossible de remplir le puzzle.
(f) Montrer enfin que le puzzle ne peut ˆetre termin´e si et seulement si on peut d´ecouper Xen ptriplets de
mˆeme somme.
Votre preuve n’est pas oblig´ee de suivre ces indications. Dans tous les cas, votre preuve doit figurer dans le rapport
sous une forme agr´eable `a lire (dessins, d´ecoupage en lemme, th´eor`eme, ...). Vous avez le droit de demander de
l’aide pour la comprendre et la terminer.
5