Algorithmes pour calculer la valeur exacte

SoitC une configuration respectant les trois règles énoncées précédemment.

D’après le Théorème 4.4, pour calculer toutes les configurations équivalentes àC qui respectent les trois Règles, il suffit de calculer les configurations créées par les permutations transformant chaque ordre deC en 1 <i 2 <i · · · <i r puis en r <i r − 1 <i · · · <i 1 et d’appliquer à ces confi-

gurations les Règles 4.2 et 4.3. Ainsi pour chaque configuration linéaire respectant les trois règles, il existe au plus 2r − 1 autres configurations linéaires équivalentes respectant ces règles. L’Algo- rithme 4.1 applique ce principe et utilise le calcul la positon d’une configuration linéaire pour re- chercher si une configuration donnée possède une équivalente déjà générée.

Algorithme 4.1 : Recherche d’une configuration équivalente déjà générée

Entrée : Une configuration linéaireC sous forme d’un tableau respectant les trois règles. Sortie : Vrai si la configurationC est équivalente à une configuration linéaire déjà générée,

Faux sinon.

Créer un tableau O tel que O1soit égal à 1, 2, ··· ,r et O2soit égal à r, r − 1,··· ,1; Créer un tableauCeq;

Calculer la position deC et la stocker dans un entier min;

t r ouve ← FAUX; i ← 1;

tant que non(t r ouve) ET i ≤ r − 1 faire

j ← 1;

tant que non(t r ouve) ET j ≤ 2 faire CopierC dans Ceq;

Calculer la permutation qui transformeC [i] en Oj;

Appliquer cette permutation àCeq;

Inverser les ordres deCeqqui ne respectent pas la Règle 4.3;

Permuter les ordres deCeqpour qu’ils respectent la Règle 4.2;

Calculer la position deCeqet la stocker dans poseq;

si poseq< mi n alors

t r ouve ←VRAI; j ← j + 1;

Génération de l’ensemble des configurations deSr

Maintenant que nous savons comment déterminer si une configuration possède une configu- ration équivalente déjà générée, il ne nous reste plus qu’à voir comment générer les configurations deSr. Afin de générer l’ensemble de ces configurations (i.e. l’ensemble des configurations linéaires

respectant les Règles 4.1, 4.2 et 4.3), nous allons commencer par créer un tableau contenant les ordres utilisés dans ces configurations. Nous pourrons alors utiliser ce tableau pour générer les configurations linéaires respectant ces règles.

Algorithme 4.2 : Création du tableau des ordres à utiliser

Entrée : Un entier r correspondant au nombre d’éléments des ordres d’une configuration. Sortie : Le tableau des ordres à utiliser dans la création des configurations.

Créer le tableau or d r es de tailler !₂× r ; Créer un tableau per mut égal à {2, 3, ··· ,r };

k ←¥r 2¦; j ← −1; for pos1= 1 à k do répéter j ← j + 1; for i = 1 to pos1− 1 do or d r ej ,i ← per muti; or d r ej ,pos1← 1; for i = pos1+ 1 to r do or d r ej ,i ← per muti −1;

jusqu’à next_permutation(per mut2, per mut2+ (r − 2)) =FAUX ;

Création du tableau des ordres à utiliser. L’Algorithme 4.2 indique comment créer ce tableau. Dans cet algorithme, on crée dans un premier temps un tableau à deux dimensions de taille r !₂ × r où chaque ligne du tableau correspond à un ordre respectant la Règle 4.3. Notons pos1la position de 1 et pos2la position de 2 dans l’ordre que nous allons créer. Il faut donc traiter différemment le cas où r est pair et le cas où r impair. Le cas le plus simple est le cas où r est pair. On doit alors faire varier pos1 de 1 à r /2. Le reste de l’ordre correspond à une permutation de (2, ··· ,r ). En C++, pour créer facilement toutes les permutations de (2, ··· ,r ), il suffit d’utiliser la fonction

next_permutation(t ab, t ab + (r − 1)) qui prend les r − 1 premiers éléments d’un tableau unidimen-

sionnel t ab, qui remplit le tableau t ab avec la permutation suivante dans l’ordre lexicographique (si elle existe) et qui renvoie vrai (ou faux si elle n’existe pas). Si r est impair alors il faut créer en plus les ordres où pos1= (r + 1)/2 et pos2< (r + 1)/2. Pour les créer il suffit de faire varier pos2de 1 à (r − 1)/2 et le reste de l’ordre correspond à une permutation de (3,··· ,r ).

Génération des configurations linéaires respectant les trois règles. Cette partie du programme est la plus simple. Comme nous l’avons vu lors du calcul de la borne supérieur, il suffit en effet de générer toutes les combinaisons avec répétition de r − 2 ordres parmi les r !₂ ordres du tableau précédent. L’Algorithme 4.3 permet de générer toutes ces combinaisons. On commence par créer

4.3. MÉTHODE DE CALCUL DE LA VALEUR EXACTE 75

un tableau comb de taille r − 2 dont toutes les valeurs sont initialisées à 0 et on initialise un entier

i à 1 qui servira à se déplacer dans le tableau comb. A chaque étape on augmente de 1 la valeur de combi puis la valeur de i . Ensuite si on a i = (r − 1) alors on a rempli tout le tableau et ce tableau

correspond à une combinaison avec répétition. On peut alors ce servir de comb pour créer une configuration linéaire. On diminue i de 1 pour continuer à travailler sur la dernière case du tableau. Puis si la valeur de combivautr !₂, cela signifie que l’on a fini de travailler avec cette case et qu’il faut

revenir à une case précédente du tableau. On cherche alors la dernière case du tableau ne valant pas (r +1)!

2 . S’il n’y en a pas, on a alors terminé de lister toutes les combinaisons avec répétition. Sinon on donne à i l’indice de cette case, et pour toutes les cases dont l’indice est plus grand que i on donne comme valeur la valeur de combi. Ainsi aux étapes suivantes on va augmenter de 1 la valeur

de toutes les cases d’indice i à r − 2 ce qui nous donnera la combinaison avec répétition suivante. Algorithme 4.3 : Génération de toutes les configurations respectant les trois règles

Entrée : Le nombre d’ordres r d’une configuration linéaire et le tableau or d r es créé par l’Algorithme 4.2.

Sortie : L’ensemble S des configurations linéaires à équivalence près (en utilisant l’Algorithme 4.1.

Créer le tableau comb de taille r − 2 dont toutes les valeurs sont initialisées à 0;

S ← ;; i ← 0;

ar r et ← FAUX;

tant que ar r et =FAUX faire

combi← combi+ 1;

i ← i + 1;

si i=n alors

k := combi;

Créer la configurationC dont le i-ème ordre correspond à ordrek;

Utiliser l’Algorithme 4.1 pour ajouterC à S s’il n’existe pas dans S une configuration équivalente àC ;

i ← i − 1;

si combi=r !₂ alors

tant que combi=r !₂ ET i ≥ 1 faire

i ← i − 1; si i = 0 alors ar r et ←VRAI; sinon pour j = i to r − 1 faire combj← combi;