Modlisation de CSPs

rappels
- Un "problme de satisfaction de
contraintes" (ou CSP), est un problme
modlis sous la forme d'un ensemble de
contraintes poses sur des variables,
chacune de ces variables prenant ses
valeurs dans un domaine. De faon plus
formelle, un CSP est dfini par un triplet
(X,D,C) tel que
X = { X1, X2, ..., Xn} est l'en. des
variables (les inconnues) du problme ;
D est la fonction qui associe chaque
variable Xi son domaine D(Xi) ;
C = {C1, C2, ..., Ck} est l'ensemble des
contraintes. Chaque contrainte Cj est
une relation entre certaines variables de
X, restreignant les valeurs que peuvent
prendre simultanment ces variables.

Problme 1 : Retour de monnaie

On s'intresse un distributeur
automatique de boissons. L'utilisateur
insre des pices de monnaie pour un total
de T centimes d'Euros, puis il slectionne
une boisson, dont le prix est de P centimes
d'Euros (T et P tant des multiples de 10).
Il s'agit alors de calculer la monnaie
rendre, sachant que le distributeur a en
rserve E2 pices de 2 , E1 pices de 1 ,
C50 pices de 50 centimes, C20 pices de
20 centimes et C10 pices de 10 centimes.
1.Modlisez ce problme sous la forme
d'un CSP.
2. Comment pourrait-on exprimer le fait
que l'on souhaite que le distributeur
rende le moins de pices possibles ?

Solution :
On dfinit le CSP (X,D,C) tel que
X = {XE2, XE1, XC50, XC20, XC10}
o XE2 dsigne le nombre de
pices de 2 Euros retourner, XE1
dsigne le nombre de pices de 1
Euro retourner, ...
Les domaines spcifient que la quantit
de pices retournes, pour un type de
pice donn, est comprise entre 0 et le
nombre de pices de ce type que l'on a
en rserve :
D(XE2) = {0,1,...,E2}
D(XE1) = {0,1,...,E1}
D(XC50) = {0,1,...,C50}
D(XC20) = {0,1,...,C20}
D(XC10) = {0,1,...,C10}
Les contraintes spcifient que la
somme retourner doit tre gale la
somme insre moins le prix payer :

C = { 200*XE2 + 100*XE1 +
50*XC50 + 20*XC20 + 10*XC10
= T-P }
Dans cette modlisation, nous avons
utilis une contrainte arithmtique linaire
sur les entiers. Cette contrainte est globale
dans le sens o elle fait intervenir toutes
les variables du problme.
Pour exprimer le fait que l'on souhaite que
le distributeur rende le moins de pices
possibles, on pourrait ajouter ce CSP une
fonction "objectif" minimiser
f(X) = XE2 + XE1 + XC50 + XC20 +
XC10
Dans ce cas, rsoudre le CSP revient
chercher une affectation de X complte et
consistante qui minimise f(X).

Problme 2 : Coloriage d'une carte

Il s'agit de colorier les 14 rgions de la
carte ci-dessous, de sorte que deux rgions
ayant une frontire en commun soient
colories avec des couleurs diffrentes. On
dispose pour cela des 4 couleurs
suivantes : bleu, rouge, jaune et vert.

Modlisez ce problme sous la forme d'un

CSP.

Solution :
On dfinit le CSP (X,D,C) tel que
X = {X1, X2, ..., X14}
(On associe une variable Xi
diffrente par rgion i colorier.)
pour tout Xi lment de X,
D(Xi) = { bleu, rouge, vert, jaune }
(Chaque rgion peut tre colorie
avec une des 4 couleurs.)
C = { Xi Xj / Xi et Xj sont 2 variables
de X correspondant des rgions
voisines }
(2 rgions voisines doivent tre de
couleurs diffrentes.)
Pour tre plus prcis, on
explicitement les relations
entre rgions, par exemple
prdicat voisines/2, tel que

peut dfinir
de voisinage
l'aide d'un
voisines(X,Y)

soit vrai si X et Y sont deux rgions

voisines. Ce prdicat peut tre dfini en
extension, en listant l'ensemble des
couples de rgions ayant une frontire en
commun :
voisines(X,Y) <=> (X,Y) lment-de
{(1,7), (1,9), (1,10), (1,11), (1,12),
(1,13), (2,8), (2,12), (2,14), (3,7),
(3,10), (3,14), (4,9), (4,11), (4,14),
(5,8), (5,11), (5,12), (6,7), (6,13),
(6,14), (7,1), (7,3), (7,6), (7,10),
(7,13), (7,14), (8,2), (8,5), (8,12),
(9,1), (9,4), (9,10), (9,11), (10,1),
(10,3), (10,7), (10,9), (10,14), (11,1),
(11,4), (11,5), (11,9), (11,12), (12,1),
(12,2), (12,5), (12,8), (12,11),
(12,13), (12,14), (13,1), (13,6),
(13,7), (13,12), (13,14), (14,2),
(14,3), (14,4), (14,6), (14,7), (14,10),
(14,12), (14,13)}

on peut alors dfinir l'ensemble des

contraintes C de la faon suivante :
C = { Xi Xj / Xi et Xj sont 2
variables diffrentes de X et
voisines(Xi,Xj) = vrai }
Ce problme de coloriage d'une carte est
un cas particulier du problme du
coloriage des sommets d'un graphe (deux
sommets adjacents du graphe doivent
toujours tre de couleurs diffrentes). De
nombreux problmes "rels" se ramnent
ce problme de coloriage d'un graphe :
problme des examens, d'emploi du temps,
de classification, ...

Problme 3 : Send more money

On considre l'addition suivante :
SEND
+ MORE
------= MONEY
o chaque lettre reprsente un chiffre
diffrent (compris entre 0 et 9). On
souhaite connatre la valeur de chaque
lettre, sachant que la premire lettre de
chaque mot reprsente un chiffre diffrent
de 0.
Modlisez ce problme sous la forme d'un
CSP.

Solution :
Premire modlisation
Variables : on associe une variable
chaque lettre
X = {S,E,N,D,M,O,R,Y}
Domaines : les variables correspondant
au premier chiffre d'un mot (S et M)
doivent prendre une valeur diffrente
de 0 ; les autres peuvent prendre
n'importe quelle valeur entre 0 et 9.
D(S) = D(M) = {1,2,3,4,5,6,7,8,9}
D(E) = D(N) = D(D) = D(O) =
D(R) = D(Y) =
{0,1,2,3,4,5,6,7,8,9}
Contraintes :
Une premire contrainte exprime le
fait que SEND+MORE=MONEY :

C1 = 1000*S + 100*E + 10*N

+D
+1000*M + 100*O + 10*R +
E
= 10000*M + 1000*O +
100*N + 10*E + Y
Une seconde contrainte exprime le
fait que toutes les variables doivent
prendre des valeurs diffrentes. On
peut utiliser pour cela la contrainte
globale "toutes-diffrentes" :
C2 = toutesdiffrentes({S,E,N,D,M,O,R,Y})
Deuxime modlisation
La premire modlisation exprime en une
seule contrainte (C1) le fait que
SEND+MORE=MONEY. Une deuxime
modlisation consiste poser les
contraintes "verticalement", comme quand
on fait une addition la main. Pour cela,

on rajoute 3 variables R1, R2 et R3

correspondant aux retenues successives.
On obtient le CSP suivant :
Variables :
X = {S,E,N,D,M,O,R,Y,R1,R2,R3}
Domaines :
D(S) = D(M) = {1,2,3,4,5,6,7,8,9}
D(E) = D(N) = D(D) = D(O) =
D(R) = D(Y) =
{0,1,2,3,4,5,6,7,8,9}
D(R1) = D(R2) = D(R3) = {0,1}
Contraintes :
Un premier ensemble de contraintes
exprime le fait que
SEND+MORE=MONEY :
C1 = { D + E = Y + 10*R1,
R1 + N + R = E + 10*R2,
R2 + E + O = N + 10*R3,
R3 + S + M = O + 10*M }

 Une dernire contrainte exprime le

fait que toutes les variables doivent
prendre des valeurs diffrentes. On
peut utiliser pour cela la contrainte
globale "toutes-diffrentes" :
C2 = toutesdiffrentes({S,E,N,D,M,O,R,Y})

Rsolution de CSPs
On va maintenant tudier quelques
algorithmes permettant de rsoudre, de
faon gnrique, certains de ces CSPs.
On se restreindra aux CSPs sur les
domaines finis, c'est--dire, les CSPs
dont les domaines des variables sont
des ensembles finis de valeurs. Le
principe commun tous les
algorithmes que nous allons tudier est
d'explorer mthodiquement l'ensemble
des affectations possibles jusqu', soit
trouver une solution (quand le CSP est
consistant), soit dmontrer qu'il n'existe
pas de solution (quand le CSP est
inconsistant).

1 - L'algorithme "gnre et teste"

1.1 - Principe de l'algorithme "gnre et
teste"
La faon la plus simple (et trs nave !) de
rsoudre un CSP sur les domaines finis
consiste numrer toutes les affectations
totales possibles jusqu' en trouver une qui
satisfasse toutes les contraintes.
Ce principe est repris dans la fonction
rcursive
"genereEtTeste(A,(X,D,C))"
dcrite ci-dessous. Dans cette fonction, A
contient une affectation partielle et
(X,D,C) dcrit le CSP rsoudre (au
premier appel de cette fonction,
l'affectation partielle A sera vide).
La fonction retourne vrai si on peut
tendre l'affectation partielle A en une
affectation
totale
consistante
(une
solution), et faux sinon.

fonction genereEtTeste(A,(X,D,C)) retourne un

boolen
Prcondition :
(X,D,C) = un CSP sur les domaines finis
A = une affectation partielle pour (X,D,C)
Postrelation :
retourne vrai si l'affectation partielle A peut tre
tendue en une solution pour (X,D,C), faux
sinon
dbut
si toutes les variables de X sont affectes
une valeur dans A alors
/* A est une affectation totale */
si A est consistante alors
/* A est une solution */
retourner vrai
sinon
retourner faux
finsi
sinon /* A est une affectation partielle */
choisir une variable Xi de X qui n'est pas
encore affecte une valeur dans A

pour toute valeur Vi appartenant D(Xi)

faire
si genereEtTeste(A U {(Xi,Vi)}, (X,D,C)) =
vrai alors retourner vrai
finpour
retourner faux
finsi
fin

1.2 - Exemple de trace d'excution de

"gnre et teste"
Considrons par exemple le CSP (X,D,C)
suivant :
X = {a,b,c,d}
D(a) = D(b) = D(c) = D(d) = {0,1}
C = { a b, c d, a+c < b }
Lenchanement des appels successifs la
fonction genereEtTeste (abrge par GET)
est reprsent ci-dessous

(chaque rectangle correspond un appel

de la fonction, et prcise la valeur de
l'affectation partielle en cours de
construction A).

2 - Critique de "gnre et teste" et

notion d'espace de recherche d'un CSP
- L'algorithme "gnre et teste" que nous
venons de voir numre l'ensemble des
affectations compltes possibles, jusqu'
en trouver une qui soit consistante.
- L'ensemble des affectations compltes
est appel l'espace de recherche du CSP.
Si le domaine de certaines variables
contient une infinit de valeurs, alors cet
espace de recherche est infini et on ne
pourra pas numrer ses lments en un
temps fini. Nanmoins, mme en se
limitant des domaines comportant un
nombre fini de valeurs, l'espace de
recherche est souvent de taille tellement
importante que l'algorithme "gnre et
teste" ne pourra se terminer en un temps
"raisonnable". En effet, l'espace de

recherche d'un CSP (X,D,C) comportant n

variables ( X = {X1, X2, ..., Xn}) est dfini
par
E = { {(X1,v1), (X2,v2), ..., (Xn,vn)} /
quelquesoit i compris entre 1 et n, vi
est un lment de D(Xi) }
et le nombre d'lments de cet espace de
recherche est dfini par
| E | = | D(X1) | * | D(X2) | * ... * |
D(Xn) |
de sorte que, si tous les domaines des
variables sont de la mme taille k
(autrement dit, | D(Xi) |=k), alors la taille
de l'espace de recherche est
| E | = kn
Ainsi, le nombre d'affectations gnrer
croit de faon exponentielle en fonction du
nombre de variables du problme.
Considrons plus prcisment un CSP
ayant n variables, chaque variable pouvant

prendre 2 valeurs (k=2 ). Dans ce cas, le

nombre d'affectations totales possibles
pour ce CSP est 2n. En supposant qu'un
ordinateur puisse gnrer et tester un
milliard d'affectations par seconde (ce qui
est une estimation vraiment trs
optimiste !), le tableau suivant donne une
ide du temps qu'il faudrait pour numrer
et tester toutes les affectations en fonction
du nombre de variables n.
Nombre
de
variables
n
10

Nombre
d'affectations
totales 2^n

Temps (si on traitait

10^9 affectations par
seconde)

environ 10^3

20

environ 10^6

30
40
50
60
70

environ 10^9
environ 10^12
environ 10^15
environ 10^18
environ 10^21

environ 1 millionime
de seconde
environ 1 millime de
seconde
environ 1 seconde
environ 16 minutes
environ 11 jours
environ 32 ans
environ 317 sicles

Les amliorations de "gnre et teste"

que nous allons tudier dans la suite...
La conclusion de ce petit exercice de
dnombrement est que, ds lors que le
CSP a plus d'une trentaine de variables, on
ne peut pas appliquer "btement"
l'algorithme "gnre et teste". Il faut donc
chercher rduire l'espace de recherche.
Pour cela, on peut notamment :
ne
dvelopper que les affectations
partielles consistantes : ds lors qu'une
affectation partielle est inconsistante, il
est inutile de chercher l'tendre en
une affectation totale puisque celle-ci
sera ncessairement inconsistante ;
rduire les tailles des domaines des
variables en leur enlevant les valeurs
"incompatibles" : pendant la gnration
d'affectations, on filtre le domaine des
variables pour ne garder que les valeurs

"localement
consistantes"
avec
l'affectation en cours de construction, et
ds lors que le domaine d'une variable
devient vide, on arrte l'numration
pour cette affectation partielle ;

introduire des "heuristiques" pour

"guider" la recherche : lorsqu'on
numre les affectations possibles, on
peut essayer d'numrer en premier
celles qui sont les plus "prometteuses",
en esprant ainsi tomber rapidement
sur une solution.

... et celles que nous n'tudierons pas

(entre autres...)
Il existe encore bien d'autres faons de
(tenter de) rduire la combinatoire, afin de
rendre l'exploration exhaustive de l'espace
de recherche possible, que nous ne verrons
pas dans ce cours.

- Par exemple, lors d'un chec, on peut

essayer d'identifier la cause de l'chec
(quelle est la variable qui viole une
contrainte) pour ensuite "retourner en
arrire" directement l o cette variable a
t instancie afin de remettre en cause
plus rapidement la variable l'origine de
l'chec. C'est ce que l'on appelle le "retour
arrire
intelligent"
("intelligent
backtracking").
- Une autre approche particulirement
sduisante consiste exploiter des
connaissances sur les types de contraintes
utilises pour rduire l'espace de
recherche.
considrons par exemple le CSP
(X,D,C) suivant :
X={a,b,c},
D(a)=D(b)=D(c)={0,1,2,3,4, ...,
1000},

C={4*a - 2*b = 6*c + 3}

L'espace de recherche de ce CSP
comporte 1 milliard d'affectations ;
pour rsoudre ce CSP, on peut
numrer toutes ces combinaisons,
en esprant en trouver une qui
satisfasse la contrainte 4*a - 2*b =
6*c + 3... c'est long et si on remplace
la borne suprieure 1000 par l'infini,
a devient carrment impossible.
En revanche un simple raisonnement
permet de conclure trs rapidement
que ce CSP n'a pas de solution : la
partie gauche de l'quation "4*a 2*b" donnera toujours un nombre
pair, quelles que soient les valeurs
affectes a et b, tandis que la partie
droite "6*c + 3" donnera toujours un
nombre impair, quelle que soit la

valeur affecte c ; par consquent,

on ne peut trouver d'affectation qui
satisfasse la contrainte, et il est
inutile
d'numrer
toutes
les
affectations possibles pour s'en
convaincre !
Ce genre de raisonnement demande de
l'intelligence, ou pour le moins des
connaissances.
De fait, l'homme est capable de rsoudre
des problmes trs combinatoires en
raisonnant (en utilisant son "exprience" et
des connaissances plus ou moins
explicites). Un exemple typique est le jeu
d'chec : les grands joueurs d'checs
n'envisagent pour chaque coup jouer que
trs peu de combinaisons (les meilleures
videmment !), liminant par des
raisonnements souvent difficiles
expliciter un trs grand nombre de

combinaisons moins intressantes. Cela

explique le fait que, malgr leur capacit
envisager un trs grand nombre de
combinaisons, les ordinateurs sont encore
(bien souvent) moins forts que ces grands
joueurs.
3 - L'algorithme "simple retourarrire"
3.1 - Principe de l'algorithme "simple
retour-arrire"
- Une premire faon d'amliorer
l'algorithme "gnre et teste" consiste
tester au fur et mesure de la construction
de l'affectation partielle sa consistance :
ds lors qu'une affectation partielle est
inconsistante, il est inutile de chercher la
complter. Dans ce cas, on "retourne en
arrire" ("backtrack" en anglais) jusqu' la

plus rcente instanciation partielle

consistante que l'on peut tendre en
affectant une autre valeur la dernire
variable affecte.
Par exemple, sur la trace d'excution
dcrite en 1.2, on remarque que
l'algorithme
gnre
tous
les
prolongements
de
l'affectation
partielle
A={(a,0),(b,0)},
en
numrant toutes les possibilits
d'affectation pour les variables c et
d, alors qu'elle viole la contrainte a
b. L'algorithme "simple retourarrire" ne va donc pas chercher
tendre cette affectation, mais va
"retourner en arrire" l'affectation
partielle prcdente A={(a,0)}, et va
l'tendre en affectant 1 b , ...
Ce principe est repris dans la fonction
rcursive
"simpleRetourArrire(A,(X,D,C))" dcrite

ci-dessous.
Dans cette fonction, A contient une
affectation partielle et (X,D,C) dcrit le
CSP rsoudre (au premier appel de cette
fonction, l'affectation partielle A sera
vide). La fonction retourne vrai si on peut
tendre l'affectation partielle A en une
affectation
totale
consistante
(une
solution), et faux sinon.
fonction simpleRetourArrire(A,(X,D,C))
retourne un boolen
Prcondition :
A = affectation partielle
(X,D,C) = un CSP sur les domaines
finis
Postrelation :
retourne vrai si A peut tre tendue en
une solution pour (X,D,C), faux sinon
dbut

si A n'est pas consistante alors

retourner faux finsi
si toutes les variables de X sont
affectes une valeur dans A alors
/* A est une affectation totale et
consistante = une solution */
retourner vrai
sinon /* A est une affectation partielle
consistante */
choisir une variable Xi de X qui
n'est pas encore affecte une
valeur dans A
pour toute valeur Vi appartenant
D(Xi) faire
si simpleRetourArrire(A U
{(Xi,Vi)}, (X,D,C)) = vrai alors
retourner vrai
finpour
retourner faux
finsi
fin

3.2 - Exemple de "trace d'excution" de

SimpleRetourArrire
Considrons le problme du placement de
4 reines sur un chiquier 4x4, et sa
deuxime modlisation propose :
Variables : X = {X1,X2,X3,X4}
Domaines : D(X1) = D(X2) = D(X3) =
D(X4) = {1,2,3,4}
Contraintes :
C = {Xi Xj / i lment_de {1,2,3,4}, j
lment_de {1,2,3,4} et i j}
U {Xi+i Xj+j / i lment_de
{1,2,3,4}, j lment_de {1,2,3,4} et i
j}
U {Xi-i Xj-j / i lment_de
{1,2,3,4}, j lment_de {1,2,3,4} et i
j}
Lenchanement des appels successifs la
fonction SimpleRetourArrire peut tre
reprsent par l'arbre suivant (chaque
nud correspond un appel de la fonction

; l'chiquier dessin chaque noeud dcrit

l'affectation partielle en cours) :

4 - L'algorithme "anticipation"
4.1 - Notions de filtrage et de
consistance locale
Pour amliorer l'algorithme "simple
retour-arrire", on peut tenter d'anticiper
("look
ahead"
en
anglais)
les
consquences de l'affectation partielle en

cours de construction sur les domaines des

variables qui ne sont pas encore affectes :
si on se rend compte qu'une variable non
affecte Xi n'a plus de valeur dans son
domaine D(Xi) qui soit "localement
consistante" avec l'affectation partielle en
cours de construction, alors il n'est pas
ncessaire de continuer dvelopper cette
branche, et on peut tout de suite retourner
en arrire pour explorer d'autres
possibilits.
Pour mettre ce principe en uvre, on va,
chaque tape de la recherche, filtrer les
domaines des variables non affectes en
enlevant
les
valeurs
"localement
inconsistantes", c'est--dire celles dont on
peut infrer qu'elles n'appartiendront
aucune solution.

On peut effectuer diffrents filtrages,

correspondant diffrents niveaux de
consistances locales, qui vont rduire plus
ou moins les domaines des variables, mais
qui prendront aussi plus ou moins de
temps s'excuter : considrons un CSP
(X,D,C), et une affectation partielle
consistante A,
le filtrage le plus simple consiste
anticiper d'une tape l'numration :
pour chaque variable Xi non affecte
dans A, on enlve de D(Xi) toute valeur
v telle que l'affectation A U {(Xi,v)} soit
inconsistante.
Par exemple pour le problme des
4 reines, aprs avoir instanci X1
1, on peut enlever du domaine
de X2 la valeur 1 (qui viole la
contrainte X1 X2).
Un tel filtrage permet d'tablir ce qu'on
appelle la consistance de nud, aussi

appele 1-consistance.
un filtrage plus fort, mais aussi plus
long effectuer, consiste anticiper de
deux tapes l'numration : pour
chaque variable Xi non affecte dans A,
on enlve de D(Xi) toute valeur v telle
qu'il existe une variable Xj non affecte
pour laquelle, pour toute valeur w de
D(Xj), l'affectation A U {(Xi,v),(Xj,w)}
soit inconsistante.
Par exemple pour le problme des
4 reines, aprs avoir instanci X1
1, on peut enlever la valeur 3 du
domaine de X2 car si X1=1 et
X2=3, alors la variable X3 ne
peut plus prendre de valeurs :
- si X3=1, on viole la contrainte
X3 X1 ;
- si X3=2, on viole la contrainte
X3+3 X2+2 ;

- si X3=3, on viole la contrainte

X3 X2 ;
- et si X3=4, on viole la
contrainte X3-3 X2-2.
Notons que ce filtrage doit tre rpt
jusqu' ce plus aucun domaine ne
puisse tre rduit.
Ce filtrage permet d'tablir ce qu'on
appelle la consistance d'arc, aussi
appele 2-consistance.
un filtrage encore plus fort, mais aussi
encore plus long effectuer, consiste
anticiper de trois tapes l'numration.
Ce filtrage permet d'tablir ce qu'on
appelle la consistance de chemin, aussi
appele 3-consistance.
... et ainsi de suite... notons que s'il
reste k variables affecter, et si l'on
anticipe de k tapes l'numration pour
tablir la k-consistance, l'opration de

filtrage revient rsoudre le CSP, c'est-dire que toutes les valeurs restant
dans les domaines des variables aprs
un tel filtrage appartiennent une
solution.
4.2 - Principe de l'algorithme
"anticipation"
Le principe gnral de l'algorithme
"anticipation"
reprend
celui
de
l'algorithme "simple retour-arrire", en
ajoutant simplement une tape de filtrage
chaque fois qu'une valeur est affecte
une variable. Comme on vient de le voir
au point 4.1, on peut effectuer diffrents
filtrages plus ou moins forts, permettant
d'tablir diffrents niveaux de consistance
locale (nud, arc, chemin, ...).
Par exemple, la fonction rcursive
"anticipation/nud(A,(X,D,C))"
dcrite
ci-dessous effectue un filtrage simple qui

tablit chaque tape la consistance de

noeud.
Dans cette fonction, A contient une
affectation partielle consistante et (X,D,C)
dcrit le CSP rsoudre (au premier appel
de cette fonction, l'affectation partielle A
sera vide).
La fonction retourne vrai si on peut
tendre l'affectation partielle A en une
affectation
totale
consistante
(une
solution), et faux sinon.
fonction anticipation/noeud(A,(X,D,C))
retourne un boolen
Prcondition :
A = affectation partielle consistante
(X,D,C) = un CSP sur les domaines
finis

Postrelation :
retourne vrai si A peut tre tendue en
une solution pour (X,D,C), faux sinon
dbut
si toutes les variables de X sont
affectes une valeur dans A alors
/* A est une affectation totale et
consistante = une solution */
retourner vrai
sinon /* A est une affectation partielle
consistante */
choisir une variable Xi de X qui n'est
pas encore affecte une valeur dans
A
pour toute valeur Vi appartenant
D(Xi) faire
/* filtrage des domaines par
rapport A U {(Xi,Vi)} */
pour toute variable Xj de X qui
n'est pas encore affecte faire
Dfiltr(Xj) <- { Vj lment de
D(Xj) / A U {(Xi,Vi),(Xj,Vj)}

est consistante }
si Dfiltr(Xj) est vide alors
retourner faux
finpour
si anticipation(A U {(Xi,Vi)},
(X,Dfiltr,C))=vrai alors retourner vrai
finpour
retourner faux
finsi
fin
4.3 - Exemple de "trace d'excution" de
"anticipation"
Considrons de nouveau le problme du
placement de 4 reines sur un chiquier
4x4. Lenchanement des appels successifs
la fonction "Anticipation/nud" peut
tre reprsent par l'arbre suivant (les
valeurs supprimes par le filtrage sont
marques d'une croix) :

Si on appliquait un filtrage plus fort, qui

rtablirait chaque tape la consistance
d'arc, lenchanement des appels successifs

la
fonction
"Anticipation/arc"
correspondante serait le suivant (les
valeurs supprimes par le filtrage sont
marques d'une croix) :

Ainsi, on constate sur le problme des 4

reines que le filtrage des domaines permet
de rduire le nombre d'appels rcursifs :
on passe de 27 appels pour "simple retourarrire" 8 appels pour l'algorithme
d'anticipation avec filtrage simple
tablissant une consistance de noeud. En
utilisant des filtrages plus forts, comme
celui qui tablit la consistance d'arc, on
peut encore rduire la combinatoire de 8
3 appels rcursifs. Cependant, il faut noter
que plus le filtrage utilis est fort, plus
cela prendra de temps pour l'excuter...
De faon gnrale, on constate que, quel
que soit le problme considr,
l'algorithme
"anticipation/nud"
est
gnralement plus rapide que l'algorithme
"simple retour-arrire" car le filtrage
utilis est vraiment peu coteux. En
revanche, si l'algorithme "anticipation/arc"
envisage toujours moins de combinaisons

que l'algorithme "anticipation/nud", il

peut parfois prendre plus de temps
l'excution car le filtrage pour tablir une
consistance d'arc est plus long que celui
pour tablir la consistance de nud.