Vous êtes sur la page 1sur 40

République Tunisienne A. U.

: 2015-2016

Ministère de l’Enseignement Supérieur et N° Ordre : 35 /2016


de la Recherche Scientifique

Université de Gabès
Faculté des Sciences de Gabès

Projet de Fin d’Études


Présenté à :

La Faculté des Sciences de Gabès

Département Informatique

en vue de l’obtention du diplôme de

Licence Fondamentale En Sciences de L’informatique

Implémentation de l'algorithme solve and decompose pour la résolution des


problèmes d'optimisation

Réalisé Par :

SAYOUTI SOULEYMANE Abdoulaye


Soutenu le 01./06./2016.

Devant le jury composé de :

Mr Khaled Hassine Président


Mme Wafa Gabsi Examinateur
Mr Amine Lamine Encadreur
Implémentation de l'algorithme solve and decompose pour la résolution des
problèmes d'optimisation

SAYOUTI SOULEYMANE Abdoulaye

Résumé :
L’algorithme Solve and Decompose est un algorithme qui est combiné à des
méthodes de résolution exactes pour résoudre des problèmes d’optimisation.
L’objectif de notre travail est d’implémenter la version basique de
l’algorithme Solve and Decompose et ensuite d’apporter des améliorations à cet
algorithme afin de le rendre plus efficace pour résoudre les problèmes
d’optimisations.

Mots clés:

S&D : Solve and Decompose, COP : Combinatorial Optimization problem


CSP : Constraint Satisfaction Problem, PL : Programmation Linéaire
PPC : Programmation par contraintes; BTC : BACKTRACKING
AC : Arc Consistency, FC : Forward Checking, MAC : Maintaining Arc
Consistency, DFS : Depth-First Search, TSP : Traveling Salesman Problem

Abstract:

The Solve and Decompose algorithm is an algorithm that is combined with


exact resolution methods for solving optimization problems.
The objective of this work is to implement the basic version of Solve and
Decompose algorithm and then to make improvements to this algorithm to make
it more effective for solving optimization problems.

Key-words:

S&D : Solve and Decompose, COP : Combinatorial Optimization problem


CSP : Constraint Satisfaction Problem, PL : Programmation Linéaire
PPC : Programmation par contraintes, BTC : BACKTRACKING
AC : Arc Consistency, FC : Forward Checking, MAC : Maintaining Arc
Consistency, DFS : Depth-First Search, TSP : Traveling Salesman Problem
DÉDICACE

A mes parents qui m’ont toujours soutenu durant mes études


A mes frères et sœurs
A mes ami(e)s
je dédie ce mémoire

SAYOUTI S. Abdoulaye
REMERCIEMENT

Tous mes remerciements à mes enseignants de la Faculté des


Sciences de Gabès qui m’ont dispensé des cours durant mon
premier cycle d’études universitaires, ainsi que le personnel
administratif qui m’a apporté son aide.

Très sincèrement, je remercie mon encadrant Mr. Amine


LAMINE sans qui ce travail n’aurait pas vu le jour et qui m’a
toujours encouragé à aller de l’avant et a toujours été à mon
écoute. Un grand merci pour votre soutien, votre encadrement,
votre présence et surtout pour votre patience.

J’adresse également mes remerciements aux membres du jury


pour l’évaluation de ce travail.
TABLE DES MATIÈRES

TABLE DES MATIÈRES

Introduction Générale 6

1 Programmation par contraintes et optimisation combinatoire sous contraintes 7


1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Problème de Satisfaction de Contraintes (CSP) . . . . . . . . . . . . . . . . 7
1.2.1 Définition d’un problème de satisfaction de contraintes . . . . . . . . 8
1.2.2 Solution d’un problème de satisfaction de contraintes . . . . . . . . . 9
1.2.3 Exemple d’un problème de satisfaction de contraintes . . . . . . . . . 10
1.3 Problème d’Optimisation Combinatoire sous Contraintes (COP) . . . . . . . 11
1.3.1 Définition d’un problème d’optimisation combinatoire sous contraintes 11
1.3.2 Exemple d’un problème d’optimisation combinatoire sous contraintes 11
1.4 Méthodes de résolution exactes . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4.1 Algorithme Retour-Arrière Chronologique( BACKTRACKING) . . . 13
1.4.2 Cohérences locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4.3 Algorithme Branch&Propagate . . . . . . . . . . . . . . . . . . . . . 13
1.4.4 Algorithme Branch&Propagate&Bound . . . . . . . . . . . . . . . . . 14
1.4.5 Heuristiques d’ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2 L’algorithme Solve and Decompose 16


2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2 Description de l’algorithme Solve and Decompose . . . . . . . . . . . . . . . 16
2.2.1 Méthode de décomposition et de génération des sous-problèmes . . . 17
2.2.2 Identification des sous-problèmes prometteurs . . . . . . . . . . . . . 18
2.2.3 Renforcement du filtrage . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2.4 Processus de parcourt . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2.5 Code source de la version basique de l’algorithme S&D en C++ . . . 21
2.3 Critique de l’algorithme S &D et améliorations apportées . . . . . . . . . . . 23
2.3.1 Critiques de l’algorithme S &D . . . . . . . . . . . . . . . . . . . . . . 23

SAYOUTI S. Abdoulaye Page 2/37


TABLE DES MATIÈRES

2.3.2 Améliorations apportées . . . . . . . . . . . . . . . . . . . . . . . . . 24


2.3.3 Description de l’ensemble des contraintes levelConstraint . . . . . . . 26
2.4 Implémentations et résultats expérimentaux . . . . . . . . . . . . . . . . . . 27
2.4.1 Environnements de travail . . . . . . . . . . . . . . . . . . . . . . . . 27
2.4.2 Implémentation de la contrainte de cycle pour le TSP . . . . . . . . . 29
2.4.3 Implémentation du S&D en bas niveau et en haut niveau . . . . . . . 30
2.4.4 Résultats expérimentaux . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Conclusion et Perspectives 36

BIBLIOGRAPHIE 37

SAYOUTI S. Abdoulaye Page 3/37


TABLE DES FIGURES

TABLE DES FIGURES

1.1 Echiquier 4 x 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Formulation du problème des quatre reines. . . . . . . . . . . . . . . . . . . 10
1.3 Deux solutions possibles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4 Formulation du Problème du Voyageur de Commerce. . . . . . . . . . . . . 12

2.1 Partie lef ti et righti de chaque variable. . . . . . . . . . . . . . . . . . . . . 17


2.2 Génération des sous-problèmes. [1] . . . . . . . . . . . . . . . . . . . . . . . 18
2.3 Arbre de génération des sous-problèmes. [1] . . . . . . . . . . . . . . . . . . . 20
2.4 Unité de temps de décomposition Td. . . . . . . . . . . . . . . . . . . . . . . 24
2.5 Regroupement des sous-problèmes. . . . . . . . . . . . . . . . . . . . . . . . 26
2.6 Courbes des solutions obtenus par le DFS, le Basic S&D et le Grouped S&D
en fonction du temps pour l’instance f tv70 du TSP. . . . . . . . . . . . . . . 32

SAYOUTI S. Abdoulaye Page 4/37


LISTE DES TABLEAUX

LISTE DES TABLEAUX

2.1 Test sur quatre niveau de l’instance f tv33 du TSP . . . . . . . . . . . . . . . 31


2.2 Temps d’exécution en seconde pour huit instances du TSP en utilisant le DFS,
le Basic S&D et le Grouped S&D . . . . . . . . . . . . . . . . . . . . . . . . 34

SAYOUTI S. Abdoulaye Page 5/37


INTRODUCTION GENERALE

INTRODUCTION GÉNÉRALE

Dans notre vie quotidienne, la notion de contrainte est naturellement très présent. Il s’agit
aussi bien de ranger des objets de formes différentes dans une boîte, d’établir des emplois du
temps ou même de planifier le trafic aérien pour limiter les retards ou pour éviter les colli-
sions. La notion de "Problème de Satisfaction de Contrainte" ou CSP( "Constraint Satisfac-
tion Problem" en anglais) désigne l’ensemble de ces problèmes, définis par des contraintes, et
consistant à chercher une solution les respectants. Dans le même sens la notion de "Problème
d’Optimisation Combinatoire sous Contraintes" ou COP(" Combinatorial Optimization Pro-
blem" en anglais) désigne l’ensemble des problèmes, définis par des contraintes, et consiste à
chercher la solution optimale. Généralement la résolution de ces problèmes variés est com-
binatoire dans le sens où il faut envisager un très grand nombre de combinaisons avant d’en
trouver une qui satisfasse toutes les contraintes. Intégrée à un langage de programmation, la
programmation par contraintes (PPC) est un nouveau paradigme de programmation pour
formuler et résoudre ces problèmes combinatoires.
Dans un cas idéal, l’utilisateur définit le problème à résoudre, le donne ensuite à l’ordina-
teur, l’ordinateur le résout et donne une solution. En raison de l’aspect fortement combina-
toire des problèmes à traiter, la puissance de calcul des ordinateurs ne suffit pas pour exami-
ner toutes les combinaisons possibles en un temps acceptable. Pour cela, des raisonnements
et des heuristiques issues traditionnellement de « l’intéligence artificielle » sont introduits
pour réduire la combinatoire et de guider la recherche vers les bonnes combinaisons.
Ce mémoire est structuré en deux chapitres. Dans le premier chapitre, nous présentons les
notions de base sur la programmation par contraintes et sur l’optimisation combinatoire sous
contraintes. Dans le deuxième chapitre, nous présentons l’algorithme Solve and Decompose
qui est une heuristique permettant de résoudre les problèmes d’optimisation de façon plus
efficace.

SAYOUTI S. Abdoulaye Page 6/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

CHAPITRE 1
PROGRAMMATION PAR CONTRAINTES ET
OPTIMISATION COMBINATOIRE SOUS CONTRAINTES

1.1 Introduction
La programmation par contraintes est une technique de résolution des problèmes com-
binatoires complexes issue de la programmation logique et de l’intelligence artificielle. Elle
consiste à modéliser un problème par un ensemble de variables et de contraintes, imposant
des conditions sur l’instanciation possible d’un sous-ensemble de ces variables définissant une
solution du problème. Ainsi, dans ce chapitre, nous donnons quelques définitions et notations
qui vont constituer le socle de la suite de ce mémoire.
La suite de ce chapitre est composé de quatre sections. Dans la section 1.2 et la section 1.3
nous donnons une définition sur les problèmes de satisfaction de contraintes et les problèmes
d’optimisation combinatoire sous contraintes. Ensuite, dans la section 1.4 nous donnons
quelques méthodes de résolution exactes et une définition des heuristiques d’ordre de choix
de variables et de valeurs. Enfin dans la section 1.5 nous concluons le chapitre.

1.2 Problème de Satisfaction de Contraintes (CSP)


Un problème de satisfaction de contraintes (en anglais : Constraint Satisfaction Problem
(CSP)) est un problème modélisé sous la forme d’un ensemble de contraintes posées sur
des variables, chacune de ces variables prenant ses valeurs dans un domaine. Ainsi, résoudre
ce problème consiste à affecter à ces variables des valeurs appartenant à leurs domaines
respectifs tout en satisfaisant l’ensemble des contraintes.

SAYOUTI S. Abdoulaye Page 7/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

1.2.1 Définition d’un problème de satisfaction de contraintes


Plus formellement, un CSP peut être défini par un triplet (X,D,C) où :
– X : est un ensemble fini de n variables {x1 , x2 , .., xn }.
– D : associe à chaque variable xi ∈ X un ensemble fini D(xi ) de valeurs possibles pour
xi .
– C : est un ensemble fini de contraintes {c1 , c2 , ..., cm }. Chaque contrainte cj définit une
relation sur un sous-ensemble de variables dénoté var(cj ). Chacune de ces contraintes
Q
définit un sous-ensemble du produit cartésien xi ∈Var(cj ) D(xi ) qui donne les valeurs
que les variables de var(cj ) peuvent prendre simultanément.
Par exemple, on peut définir un simple CSP (X,D,C) avec X = { x1 , x2 , x3 } , D = {
D(x1 ) = {1,2,3}, D(x2 ) = {1,2}, D(x3 ) = {2,3}} et C = { c1 ≡ ( x1 + x2 = x3 ) , c2 ≡ (
| x1 − x3 | 6= 1 )}. Cependant, une contrainte peut être défini en extension, en intension ou
peut être défini de façon globale.

– Contrainte en extension :
Q
Définir une contrainte cj en extension revient à donner tous les tuples xi ∈Var(cj ) D(xi )
autorisés par cette contrainte. L’ensemble de ces tuples peut être nommé par support(cj ).
Cependant, la contrainte cj peut être définie par l’ensemble des tuples qui ne sont
pas autorisées par la contrainte cj . Dans ce cas l’ensemble de ces tuples, peut être
nommé par conflicts(cj ). L’exemple du CSP ci-dessus contient deux contraintes, à sa-
voir c1 ≡ (x1 + x2 = x3 ) et c2 ≡ (| x1 − x3 | = 6 1). Nous avons donc : supports(c1 ) ≡
{(1,1,2),(1,2,3),(2,1,3)} et supports(c2 ) ≡ {(1,3),(2,2),(3,3)}.

– Contrainte en intention :
Définir une contrainte cj en intention revient à exprimer avec des propriétés mathé-
matiques ou logiques les tuples autorisés par la contrainte cj . Chacune des contraintes
de l’exemple est donnée en formule mathématique c1 ≡ (x1 + x2 = x3 ) et c2 ≡ (| x1 − x3
| 6= 1). Ces deux contraintes c1 et c2 sont défini en intention.

– Contrainte globale :
Une contrainte globale peut aider à résoudre un problème plus efficacement qu’un
ensemble de contraintes binaires dans la mesure où elle véhicule des informations sur
ce problème. Dans l’exemple ci-dessous, le fait d’utiliser la contrainte globale All-
Diff permet d’affirmer immédiatement que le problème n’admet pas de solution, car |
xi ∈X D(xi ) | <| x |. Cette propriété est exploitable lorsque nous utilisons la contrainte
S

AllDiff, mais elle ne peut pas être exploitée en utilisant chacune des trois contraintes
binaires séparément {6= (x1 , x2 ), 6= (x1 , x3 ), 6= (x2 , x3 )}.

SAYOUTI S. Abdoulaye Page 8/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

Exemple 1 :

Considérons le CSP (X, D, C) tel que :


– X = {x1 , x2 , x3 }
– D(x1 ) = D(x2 ) = D(x3 ) = {1, 2} et
– C = {x1 6= x2 , x1 6= x3 , x2 6= x3 }.
Dans cet exemple, les trois contraintes de différence sont binaires. Cependant, elles peuvent
être remplacées par une seule contrainte globale AllDiff spécifiant que les trois variables
x1 , x2 et x3 doivent prendre simultanément des valeurs différentes.

1.2.2 Solution d’un problème de satisfaction de contraintes


La résolution d’un CSP consiste à affecter des valeurs aux variables, de telle sorte que
toutes les contraintes soient satisfaites. Ainsi, pour un CSP P = (X , D, C), on définit les
notions suivantes :
– Une instanciation d’une variable xi par une valeur vi ∈ D(xi ) est définie par le couple
<xi , vi >.
– Une affectation A = {<x1 , v1 >, < x2 , v2 >, ..., < xk , vk >} est un ensemble d’instan-
ciations (de couples) correspondant à l’instanciation de la variable x1 par la valeur v1 ,
la variable x2 par la valeur v2 ,..., et la variable xk par la valeur vk . On dénote par
var(A) l’ensemble des variables instanciées dans A.
– Une affectation A est partielle si |A | < | X |, sinon, elle est totale.
– Une affectation A satisfait (resp. viole) une contrainte cj ∈ C telle que var(cj ) ⊆
var(A) si le tuple des valeurs associées aux variables var(cj ) dans A est autorisé (resp.
non autorisé) par la contrainte cj .
– Une affectation A est incohérente si elle viole au moins une des contraintes de C, sinon
elle est cohérente.
– Une solution d’un CSP est une affectation totale et cohérente.

L’espace de recherche :

L’espace de recherche d’un CSP P = (X , D, C ) est défini par un ensemble fini Ω qui
est constitué de toutes les affectations totales. L’ensemble des contraintes C divise Ω en une
partition de deux ensembles Ω+ et Ω− . L’ensemble Ω+ contient toutes les solutions de P
et l’ensemble Ω− contient toutes les affectations totales et incohérentes de P. Résoudre P
revient à trouver un élément de Ω+ .

Remarque :

Un CSP est dit binaire s’il ne contient que des contraintes binaires.

SAYOUTI S. Abdoulaye Page 9/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

1.2.3 Exemple d’un problème de satisfaction de contraintes


Problème des n reines

Le but du problème des n reines est de placer n reines d’un jeu d’échecs sur un échiquier
de n x n cases sans que les reines ne puissent se menacer mutuellement, conformément aux
règles du jeu d’échecs. Par conséquent, deux reines ne devraient jamais partager la même
ligne, colonne, ou diagonale. La figure 1.1 ci-dessous illustre l’échiquier d’une instance du
problème des n reines avec quatre reines.

4
0Z0Z
3
Z0Z0
2
0Z0Z
1
Z0Z0
1 2 3 4

Figure 1.1 – Echiquier 4 x 4 .

Le modèle CSP du problème des quatres reines est :

Variables de décision et Domaines :


(1) X = {x1 , x2 , x3 , x4 }
(2) xi ∈ {1, 2, 3, 4}, ∀i ∈ {1, 2, 3, 4}
Contraintes :
(3) AllDiff (x1 , x2 , x3 , x4 )
(4) xi − xj 6= i − j
(5) xi − xj 6= j − i

Figure 1.2 – Formulation du problème des quatre reines.

Dans le modèle ci-dessus, (1) représente un ensemble de quatre variables, où chaque va-
riable xi représente une reine ; (2) représente le domaine de chaque variable de sorte que
xi = j si la reine i se trouve sur la colonne j ; (3) contraint deux reines à ne pas êtres sur la
même colonne ; enfin (4) et (5) représentent les contraintes de diagonale. La contrainte de
ligne est implicitement formulée par les quatre variables xi distinctes. La figure 1.3 présente
les deux solutions possibles de ce problème :

SAYOUTI S. Abdoulaye Page 10/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

4
0L0Z 4
0ZQZ
3
Z0ZQ 3
L0Z0
2
QZ0Z 2
0Z0L
1
Z0L0 1
ZQZ0
1 2 3 4 1 2 3 4

Figure 1.3 – Deux solutions possibles.

1.3 Problème d’Optimisation Combinatoire sous Contraintes


(COP)

1.3.1 Définition d’un problème d’optimisation combinatoire sous


contraintes
Un problème d’optimisation combinatoire sous contraintes (en anglais : Combinatorial
Optimization Problem (COP)) est un problème de satisfaction de contraintes CSP augmenté
d’une fonction à optimiser qu’on appelle généralement la fonction objectif.
Un COP donc, est défini par un quadruplet (X, D, C, f ) tel que :
– (X , D, C ) est un problème de satisfaction de contraintes.
– f : D(x1 ) ×...×D(xn ) −→ R est la fonction objectif à optimiser.
Résoudre un COP P = (X, D, C, f ) à l’optimalité, implique de trouver une solution S *
∈ Ω+ telle que ∀S ’ ∈ Ω+ , f (S *) > f (S ’) si f est une fonction à maximiser ou une solution
S * ∈ Ω+ telle que ∀S ’∈ Ω+ , f (S *) ≤ f (S ’) si f est une fonction à minimiser.

1.3.2 Exemple d’un problème d’optimisation combinatoire sous


contraintes
Problème du voyageur de commerce

Le Problème du Voyageur de Commerce (en anglais :Traveling Salesman Problem (TSP))


consiste à visiter un ensemble de villes en passant une et une seule fois par chacune d’elles
et de revenir à la ville de départ tout en minimisant le coût de la distance totale parcourue.
Le coût de la distance parcourue d’une ville i vers une ville j (dij ) peut être différent
du coût de la ville j vers la ville i (dji ). Dans ce cas le problème est dit asymétrique. Ce
problème peut être modélisé en programmation par contraintes avec la contrainte de cycle.
Pour n villes à visiter, n variables xi sont introduites avec i ∈ {1, 2, 3, ... , n}. Chaque
variable xi a pour domaine D(xi ) = {1, 2, 3, ..., n} avec xi = j si le voyageur visite la ville j
après la ville i. Un ensemble de n variables zi sont également introduites où chaque variable
zi déterminent le coût de la distance parcourue après le départ de la ville i. Chaque variable

SAYOUTI S. Abdoulaye Page 11/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

zi a pour domaine D(zi ) = {di1 , di2 , ..., din }. La formulation en programmation par contrainte
du problème du voyageur de commerce utilise la contrainte Element pour associer à chaque
variable zi le coût de la distance parcourue après le départ de la ville i.
Un modèle COP d’un TSP à n villes est :

Variables de décision et Domaines :


(1) X = {x1 , x2 , ..., xn }
(2) xi ∈ {1, 2, ..., n}, ∀i ∈ {1, 2, ..., n}
(3) Z = {z1 , z2 , ..., zn }
(4) zi ∈ {di1 , di2 , ..., din }, ∀i ∈ {1, 2, ..., n}
Contraintes :
(5) Element(xi , [di1 , ..., din ], zi ), ∀i ∈ {1, 2, ..., n}
(6) Cycle(x1 , x2 , ..., xn )
Fonction Objectif :
n
P
minimiser ( zi )
i=1

Figure 1.4 – Formulation du Problème du Voyageur de Commerce.

Remarque :

On parle de programmation linéaire (PL) lorsque les contraintes et la fonction objectif


sont linéaires. Ainsi, une contrainte linéaire peut être formuler comme suit : c(x1 , x2 , ..., xn ) ≡
a1 x1 + a2 x2 + ... + an xn + b = 0 avec les ai des constantes. Par contre, une contrainte non
linéaire peut être formulée ainsi : c(x, y) ≡ x2 + 2xy 2 = 0 .

1.4 Méthodes de résolution exactes


De manière générale, pour résoudre un COP, deux types d’approches peuvent être utili-
sées, à savoir, les approches complètes et les approches heuristiques (ou métaheuristiques).
Un algorithme basé sur une approche complète explore l’espace de recherche de façon ex-
haustive et trouve la solution optimale en une limite de temps finie. Les approches complètes
garantissent l’optimalité des solutions trouvées. Cependant, leur utilisation est souvent li-
mitée à des problèmes de taille raisonnable, car, trouver la solution optimale a un coût
exponentiel dans le pire des cas. Les métaheuristiques sont une alternative aux algorithmes
exacts. Les métaheuristiques ont toutes des objectifs et des caractéristiques communes à
savoir : contourner l’explosion combinatoire en s’autorisant à ne pas parcourir tout l’espace
de recherche et combiner des mécanismes d’intensification (visant à augmenter l’effort de re-
cherche aux alentours des meilleures solutions trouvées) et des mécanismes de diversification
(visant à échantillonner le plus largement possible l’espace de recherche).
Ainsi, dans cette section, nous présentons des algorithmes basés sur une approche com-
plète utilisés pour résoudre les CSP et les COP. Ensuite, nous parlons des heuristiques
d’ordres de choix de variables et de valeurs.

SAYOUTI S. Abdoulaye Page 12/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

1.4.1 Algorithme Retour-Arrière Chronologique( BACKTRACKING)


L’algorithme retour-arrière Chronologique (BTC ) construit l’arbre de recherche en pro-
fondeur d’abord. A chaque fois qu’une affectation partielle Ap est étendue par un couple <
x, v >, BTC vérifie la cohérence de Ap < x, v > par rapport à chaque contrainte c ∈ C
S

pour laquelle var(c) ⊆ (var(Ap) {< x, v >}). Si toutes les contraintes sont satisfaites,
S

il continue l’exploration en profondeur à partir de ce nœud, sinon, il fait un retour arrière


jusqu’au premier nœud ancêtre pour lequel certains fils n’ont pas encore été explorés. Ainsi,
une solution est trouvée lorsque nous obtenons une affectation totale et cohérente, sinon le
problème est dit infaisable.

1.4.2 Cohérences locales


Pour réduire la taille de l’arbre de recherche développé par BTC, des techniques de véri-
fication de cohérences locales d’un CSP (ou d’un COP) ont été développées. Ces techniques
permettent de réduire la taille des domaines des variables en enlevant certaines valeurs qui
ne peuvent pas figurer dans une solution. Ainsi, la recherche de solutions est accélérée, car les
sous-arbres de recherche qui ont comme racine les valeurs supprimées ne sont pas développés.
Le processus de réduction des domaines des variables est appelé le processus de filtrage.

La cohérence d’arc :

La cohérence d’arc (en anglais : Arc Consistency (AC)) est basée sur la notion de support
et a été initialement définie pour les CSP binaires.

Définition de la relation de support :

Soit un CSP binaire (X, D, C). La valeur b de la variable y ∈ X est un support de la


valeur a de la variable x ∈ X si l’affectation {< x, a >, < y, b >} est cohérente.

Définition de la cohérence d’arc (AC) :

Un CSP (X, D, C) vérifie la propriété de la cohérence d’arc si :


∀(x, y) ∈ X 2 , ∀a ∈ D(x), ∃b ∈ D(y), tel que b est un support de a.
Autrement dit, si un CSP binaire vérifie la propriété AC, alors toute paire de variables
peuvent être affectées simultanément sans violer aucune contrainte.

1.4.3 Algorithme Branch&Propagate


Pour réduire l’espace de recherche, la construction de l’arbre de recherche peut être
combiné à des algorithmes de filtrages. A chaque fois qu’une valeur est affectée à une variable,
les contraintes portant sur cette variable sont propagées. Cependant, le choix de l’algorithme
de filtrage à utiliser (ou le choix de la propriété de cohérence locale à maintenir) n’est pas
évident.

SAYOUTI S. Abdoulaye Page 13/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

Un utilisateur novice de ces algorithmes peut penser qu’un algorithme qui maintient
à chaque point de décision une cohérence locale forte est toujours meilleur que le même
algorithme maintenant une propriété de cohérence locale plus faible. En pratique, ceci n’est
pas toujours vrai, car en général, plus la propriété de cohérence maintenue est forte plus
grande est la complexité de l’algorithme de filtrage.

Forward Checking

L’algorithme Forward Checking (FC ) est l’un des algorithmes de propagation. Sur un
CSP binaire, après chaque affectation d’une variable xi par une valeur vi , l’algorithme FC
filtre le domaine de chaque variable xj non encore affectée et liée par une contrainte avec xi ,
n’enlevant du domaine de xj toute valeur vj telle que l’affectation {< xi , vi >, < xj , vj >}
est incohérente .

Algorithme MAC

L’algorithme MAC (Maintaining Arc Consistency) est l’un des algorithmes les plus
connus. Après chaque affectation d’une variable, il maintient la propriété de cohérence d’arc.
Cet algorithme filtre plus de domaines que FC, mais ça ne lui garantit pas d’être le meilleur
des deux. En effet, en fonction de l’instance de problème traitée, l’effort de filtrage supplé-
mentaire introduit par le maintien de la cohérence d’arc après chaque affectation peut ne
pas compenser la réduction de l’espace de recherche.

1.4.4 Algorithme Branch&Propagate&Bound


Dans la section précédente, nous avons parlé des algorithmes qui utilisent la propagation
de contraintes au cours de la recherche des solutions. Pour les problèmes où il y a, en
plus des contraintes, une fonction objectif f à optimiser, des contraintes sur les bornes de f
peuvent être rajoutées à l’ensemble des contraintes du problème au fur et à mesure que des
solutions sont trouvées. Ces contraintes sur les bornes de f sont utilisées dans le processus
de propagation des contraintes pour filtrer les domaines des variables. Si S est la meilleure
solution trouvée jusqu’à présent pour un COP où l’objectif est de minimiser une fonction f et
que f (S ) = fs , alors, la contrainte f (X ) < fs sera rajoutée à l’ensemble des contraintes C du
problème. La propagation de cette contrainte permet de ne pas développer les sous-arbres où
f (var(Ap )) >= fs . On peut raffiner ce principe en ajoutant une étape d’évaluation à chaque
nœud de recherche, ce que l’on peut résumer par Branch&Propagate&Bound.
L’idée principale de l’étape d’évaluation est de détecter qu’un ensemble de solutions ne
contient pas de solutions meilleures que la meilleure solution trouvée jusqu’à présent sans
pour autant calculer séparément chacune des solutions de cet ensemble. En effet, à partir
d’une affectation partielle et en se positionnant sur un nœud de l’arbre de recherche, on
calcule une borne inférieure (resp. supérieure) de f. Cette borne correspond à la qualité de
la meilleure solution que nous pouvons espérer trouver dans ce sous-arbre de recherche. Par

SAYOUTI S. Abdoulaye Page 14/37


CHAPITRE 1. PROGRAMMATION PAR CONTRAINTES ET OPTIMISATION
COMBINATOIRE SOUS CONTRAINTES

conséquent, si cette borne est moins bonne que la qualité de la meilleure solution trouvée
jusqu’à présent, l’algorithme peut ne pas développer ce sous-arbre.

1.4.5 Heuristiques d’ordre


A chaque étape de la construction d’un arbre de recherche, l’algorithme doit choisir une
variable non encore affectée et lui choisir une valeur de son domaine. L’ordre dans lequel ces
variables et ces valeurs sont choisies a un impact crucial sur les performances. C’est pour
cette raison que plusieurs heuristiques d’ordre de choix de variables et de valeurs ont été
développées.

Heuristique d’ordre de choix de variables

Une heuristique de choix de variables très populaire est l’heuristique minDom qui sé-
lectionne en premier la variable qui a le plus petit domaine. Les ex-aequo peuvent être dé-
partagés en utilisant le degré dynamique des variables (le nombre de contraintes auxquelles
cette variables appartient et qui ne sont pas encore satisfaites). Une autre heuristique est
d’utiliser le ratio entre la taille des domaines et le degré des variables.

Heuristique d’ordre de choix de valeurs

Une fois que la prochaine variable à affecter est sélectionnée, il faut lui choisir une valeur.
Si le problème à résoudre consiste à trouver uniquement une solution et que cette solution
existe, alors l’ordre de choix des valeurs influence beaucoup le temps de calcul nécessaire pour
trouver cette solution. En effet, pour trouver rapidement une solution, il serait intéressant
de choisir d’abord les valeurs qui restreignent le moins possible le reste des variables non
encore affectées. En revanche, si le problème consiste à trouver toutes les solutions possibles
ou si le problème n’admet pas de solution, alors, toutes les valeurs de chaque variable vont
être considérées et donc, l’ordre de choix des valeurs n’a plus d’importance.

1.5 Conclusion
Dans ce chapitre, nous avons passé en revue les principaux techniques et algorithmes de
résolution de problèmes de satisfaction de contraintes et de problèmes d’optimisation com-
binatoire basées sur la recherche complète. Nous avons également donné quelques exemples
de problème de satisfaction de contrainte et d’optimisation combinatoire sous contraintes.
Cependant, des stratégies peuvent être combinées à ces méthodes de résolution exacte afin
d’obtenir rapidement la solution optimale ou une solution proche de la solution optimale.
Ainsi, dans le prochain chapitre, nous présentons l’ algorithme Solve and Decompose qui
combine méthodes de résolution exactes et heuristiques de recherche afin de résoudre les
problèmes d’optimisation de façon plus efficace .

SAYOUTI S. Abdoulaye Page 15/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

CHAPITRE 2
L’ALGORITHME SOLVE AND DECOMPOSE

2.1 Introduction
Dans la pratique, de nombreux problèmes ont des espaces de recherche trop grands pour
une recherche exhaustive. On peut souvent trouver une solution tout en recherchant seule-
ment dans une petite fraction de l’espace de recherche reposant sur des heuristiques soigneu-
sement réglées pour guider la recherche vers les régions de l’espace de recherche qui sont
susceptibles de contenir de meilleurs solutions. Dans cette optique, A. Lamine, M. Khema-
khem, B. Hnich et H. ChabChoub ont ainsi proposé [1] l’algorithme Solve and Decompose
dont la principale caractéristique est d’identifier et d’explorer les parties les plus prometteuses
de l’espace de recherche pour atteindre la solution optimale dans un temps acceptable. Ainsi
notre principal objectif sera d’apporter des améliorations à cet algorithme et ensuite de le
comparer à l’algorithme de recherche en profondeur (en anglais : Depth-First Search (DFS)).
La suite de ce chapitre est organisée comme suit : Nous présentons l’algorithme Solve
and Decompose et son principe de fonctionnement dans la section 2.2. Dans la section 2.3
nous faisons quelques critiques de l’algorithme Solve and Decompose et nous présentons les
améliorations que nous apportons. Dans la section 2.4 nous présentons les implémentations
effectuées pour la nouvelle version de l’algorithme Solve and Decompose. Et dans la section
2.5 nous concluons le chapitre.

2.2 Description de l’algorithme Solve and Decompose


L’algorithme Solve and Decompose (S&D) est une stratégie de parcours de l’arbre de
recherche à travers un mécanisme de décomposition à base de solution. Pour résoudre un
COP(X, D, C, f), S&D part d’une solution réalisable de ce COP. La solution réalisable est
obtenue en résolvant le CSP(X, D, C) de ce COP. La solution réalisable est alors exploitée
afin de décomposer le problème d’origine en de sous-problèmes qui sont beaucoup plus pe-
tits en taille que le problème initial. Les sous-problèmes les plus prometteurs sont ensuite

SAYOUTI S. Abdoulaye Page 16/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

identifiés et résolus en premier pour atteindre la solution optimale dans un temps acceptable.
Dans la suite de ce chapitre on supposera que l’ensemble des variables X est composé de
deux types de variables Y et Z tel que X = Y∪Z. Les variables contenues dans Y sont des
variables qui appartiennent à la fonction objectif, tandis que les variables contenues dans Z
appartiennent aux contraintes mais pas à la fonction objectif.

2.2.1 Méthode de décomposition et de génération des sous-problèmes


Le principe de l’algorithme Solve and Decompose est d’utiliser une solution réalisable
afin de décomposé le problème initial en de sous-problèmes de plus petite taille. Pour un
problème de minimisation P = COP(X, D, C, f) où X = Y∪Z et S une solution réalisable de
P’ = CSP (X, D, C) avec P’ le CSP de P, les valeurs affectées aux variables xi ∈ X, yi ∈ Y et
zi ∈ Z dans la solution S sont respectivement dénotés par x̄i , ȳi et z¯i . La décomposition est
basée sur l’ensemble des variables Y qui appartiennent à la fonction objectif. Le domaine de
chaque variable yi ∈ Y est subdivisé en deux sous-domaines. Le domaine lef ti qui contient
toutes les valeurs du domaine de la variable yi et qui sont inférieur ou égale ȳi , puis righti
qui contient toutes les valeurs strictement supérieur à ȳi . Ainsi, lef ti et righti forment une
partition du domaine de la variable yi .
En utilisant lef ti et righti , 2|Y | sous-problèmes (X, D, C) sont générés, avec | Y | le
nombre de variables contenues dans Y. Chaque sous-problème est créé en modifiant le do-
maine de chaque variable yi . Pour chaque sous-problème, le domaine de chaque variable yi
est soit lef ti ou righti . L’exemple suivant illustre le processus de décomposition.

Exemple 1 :

Soit un problème de minimisation P = COP(X, D, C, f) où la fonction objectif est linéaire


et est de la forme i wi yi avec wi ≥ 0 et X = Y∪Z. L’ensemble de variables Y est composé
P

de trois variables y1 , y2 , y3 ∈ {1, 2, 3, 4, 5} et tous les wi sont égales à 1. Considérons ensuite


une solution réalisable S du CSP du problème P dans la quelle (y1 , y2 , y3 )=(2,3,3). Ainsi,
le domaine de chaque variable yi sera subdivisé en deux parties lef ti et righti . La figure
2.1 illustre la partie lef ti colorée en bleu et righti colorée en orange du domaine de chaque
variable yi . [1]

Figure 2.1 – Partie lef ti et righti de chaque variable.

SAYOUTI S. Abdoulaye Page 17/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

Ainsi, d’après le procédé de décomposition décrit, huit sous-problèmes basés sur cette
solution réalisable seront générés comme l’illustre la figure suivante :

Figure 2.2 – Génération des sous-problèmes. [1]

2.2.2 Identification des sous-problèmes prometteurs


En fonction de la forme de la fonction objectif et en raisonnant sur la solution réalisable
utilisée pour décomposer le problème d’origine, certains sous-problèmes qui constituent les
parties les plus prometteuses de l’espace de recherche peuvent être identifiés. Si ces sous-
problèmes sont explorés en premier, alors les chances de trouver de meilleures solutions
réalisables sont plus élevées. Cela peut accélérer le processus d’obtention de la solution
optimale.
Étant donné que la fonction objectif est linéaire dans ce cas, les heuristiques minmin
et minmax sont utilisées afin de comparer les sous-problèmes pour déterminer lesquelles
ont plus de chances d’améliorer la fonction objectif f(S). L’heuristique minmin est utilisées
pour les problèmes de minimisation et consiste pour chaque sous-problème, à additionner le
minimum de chaque variable de décision yi et à trier ces sous-problèmes par ordre croissant
de cette somme. Ainsi, si une solution est trouvée dans le sous-problème qui a la plus petite
somme, alors cette solution serait un peu plus proche de la solution optimale. A l’inverse,
pour un problème de maximisation, l’heuristique minmax additionne le maximum de chaque
variable yi au lieu du minimum. La dernière étape consiste à compter le nombre de variable
yi dans chaque sous-problème dont les valeurs de domaine sont inférieures ou égales à la
valeur ȳi dans S. Ainsi, plus le nombre de ces variables est grand dans le sous-problème,
meilleures sont les chances d’améliorer la valeur de la fonction objectif. Cette heuristique est
appelée maxleft.

SAYOUTI S. Abdoulaye Page 18/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

2.2.3 Renforcement du filtrage


La décomposition du problème original génère des sous-problèmes de plus petites tailles.
En outre, certains de ces sous-problèmes peuvent être plus prometteurs que d’autres en
termes de trouver une meilleure solution. Ces sous-problèmes peuvent être exploités dans le
but de renforcer le processus de filtrage lors du parcours des sous-problèmes.
Tout d’abord, la valeur de la première solution réalisable obtenue en résolvant le CSP
du problème d’origine est utilisée en tant que facteur d’élimination, afin d’éliminer les sous-
problèmes qui n’apportent aucune amélioration à cette solution. En d’autres termes, tout
sous-problème dont la borne inférieure (lowerBound) est pire que la valeur de la solution
réalisable f (S) (upperB, l’actuelle meilleure borne supérieure) ne sera pas visité.
Pour l’exemple 1 ci-dessus, f(S) = 2 + 3 + 3 = 8 et puisque la fonction objectif est
linéaire, une borne inférieure peut être simplement calculée en additionnant les minimums
des yi dans chaque sous-problème. Maintenant, il est facile de voir que la limite inférieure des
sous-problèmes (d), (f), (g) et (h) sont supérieures ou égales à la borne supérieure connue
(upperB). Par conséquent, ces sous-problèmes ne seront pas visités.
Ensuite, si les sous-problèmes les plus prometteurs sont explorés en premier, les chances
d’améliorer la meilleure borne supérieure sont plus élevées. Ceci resserre la meilleure borne
supérieure pour les prochains sous-problèmes à visiter. Par exemple, si la résolution du sous-
problème (a) donne une meilleure solution réalisable où chaque yi est égale à 2. La valeur
de la meilleure borne supérieure est maintenant 6 au lieu de 8. Puis, les sous-problèmes (b)
et (c) ne seront pas visités étant donné que leur borne inférieure est égale à 6. Ainsi, il ne
reste plus que le sous-problème (e) dont la borne inférieure est 5.
Enfin, lorsqu’un sous-problème est visité, une contrainte est ajoutée au sous-problème,
stipulant que la valeur d’une solution réalisable du sous-problème doit être meilleure que la
valeur de la meilleure borne supérieure connue. Par exemple, si le sous-problème (e) n’a pas
de solution réalisable de valeur 5, la contrainte ajoutée va accélérer le processus pour prouver
l’infaisabilité de (e).

2.2.4 Processus de parcourt


La caractéristique finale du S&D est de décomposer récursivement les sous-problèmes
d’une manière de recherche en profondeur en visitant les sous-problèmes les plus prometteurs
en premier. Le nœud racine d’un tel arbre est le problème initial. Chaque nœud interne
est l’un des sous-problèmes du nœud parent. A chaque nœud interne, soit une solution
réalisable S est trouvée, soit un échec se produit. Si une solution réalisable S est trouvée, la
meilleure borne supérieure (upperB) est mise à jour et la solution S est utilisée pour générer
séquentiellement des sous-problèmes. Ces sous-problèmes sont générés dans l’ordre croissant
des sous-problèmes les plus prometteurs (en utilisant une des heuristiques citées). Si aucune
solution réalisable n’est trouvée, alors un retour en arrière est effectué au nœud parent
et le prochain sous-problème le plus prometteur est visité. Il y a deux façons d’échouer

SAYOUTI S. Abdoulaye Page 19/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

à un nœud interne. Avant d’essayer de résoudre le sous-problème, un échec se produit si


le upperB actuelle est inférieure à la borne inférieure (lowerBound) du sous-problème. Si,
toutefois, la borne inférieure du sous-problème est plus petite que le upperB actuelle, une
contrainte est ajoutée au sous-problème stipulant que toutes les solutions doivent avoir une
valeur objective inférieure à upperB. Si le sous-problème est infaisable, un échec se produit.
Lorsqu’un retour en arrière est effectué jusqu’au nœud racine et que tous les sous-problèmes
ont été visités, la valeur de upperB constitue alors la valeur de la solution optimale. Une limite
est imposée sur la profondeur de décomposition. A cette profondeur, les sous-problèmes ne
sont plus décomposés mais résolus à l’optimalité. La figure ci-dessous illustre le processus de
décomposition et de génération des sous-problèmes pour l’exemple ci-dessus.

Figure 2.3 – Arbre de génération des sous-problèmes. [1]

Sur cette figure, nous observons un arbre de recherche dont le nœud racine est le problème
à minimiser. Les nœuds de la profondeur depth = 1 sont les sous-problèmes générés après
la décomposition du problème initial. Les nœuds de la profondeur depth = 2 sont les sous-
problèmes générés après la décomposition du sous-problème (a). Les sous-problèmes sous
lesquelles une croix (X) entourée d’un carré est représentée, sont des sous-problèmes qui
ne peuvent pas améliorer le upperB connue. Ainsi, ils ne seront pas visités. Par contre, les
sous-problèmes sous lesquelles une croix (X) entourée d’un cercle est représentée, sont ceux
qui sont susceptibles d’améliorer le upperB.
Il convient de noter que l’arbre de recherche n’est conçue d’avance. Les sous-problèmes
sont générés et résolus de façons récursive. Après la génération d’un sous problème, il est
résolu avant la génération du sous-problème suivant. Ainsi, pour notre exemple, les deux

SAYOUTI S. Abdoulaye Page 20/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

premiers sous-problèmes générés sont les sous-problèmes (a) et (i). Il convient de noter
également que les sous-problèmes sont classés par niveaux en fonction du nombre de sous-
domaines lef ti dans le sous-problème. Chaque niveau est désigné par Lp où p représente le
nombre de sous-domaines lef ti dans le sous-problème.

2.2.5 Code source de la version basique de l’algorithme S&D en


C++
Nous présentons ci-dessous le code source la version basique " Basic S&D " en C++. Le
Basic S&D génère les sous-problèmes de façon récursive et résout un sous problème avant
de généré un autre sous-problème. La fonction " basic_sand " est une fonction récursive qui
génère et résout tous les sous-problèmes du niveau p passé en paramètre. La fonction prend
en paramètre, un tableau binaire t qui permet de représenter le domaine lef ti ou righti de
chaque variable yi . Les parties colorées en vert sont les parties les plus importante de ce
code source. A cet effet, la partie /*(6)*/ tout en bas de la fonction, est la partie qui permet
de faire appel à la fonction elle même pour généré tous les sous problèmes du niveau p .
Les parties /*(1)*/ permettent de déterminer le domaine de chaque variable de yi ; la partie
/*(2)*/ permet de vérifier si la borne inférieur du sous-problèmes est supérieur ou égale au
upperB ; les parties /*(3)*/ et /*(4)*/ permettent de généré un sous-problème et la partie
/*(5)*/ permet de résoudre ce sous-problème et de mettre à jour le upperB si une solution
a été trouvée.

1 v o i d basic_sandd ( I l o I n t A r r a y t , I l o I n t n , I l o I n t p , I l o I n t V a r A r r a y y , IloNumArray s o l u t i o n ,
I l o M o d e l model , IloNumExpr f ) {
2
3 /∗ ( 1 ) ∗/ i f ( n == p ) {
4 f o r ( i n t i = 0 ; i <n ; i ++)
5 /∗ ( 1 ) ∗/ t [ i ] = 0;
6
7 /∗ ( 2 ) ∗/ i f ( lower_Bound ( t ) >= upperB ) {
8 c o u t << " Lower ␣ bound ␣ s u p p e r i e u r "<< e n d l ;
9 /∗ ( 2 ) ∗/ }
10 else {
11 /∗ ( 3 ) ∗/ I l o C o n s t r a i n t A r r a y decompose_Constraint ( env ) ;
12 f o r ( I l o I n t i = 0 ; i <t . g e t S i z e ( ) ; i ++){
13 i f ( t [ i ] == 0 )
14 decompose_Constraint . add ( y [ i ] <= s o l u t i o n [ i ] ) ;
15 else
16 decompose_Constraint . add ( y [ i ] > s o l u t i o n [ i ] ) ;
17 }
18 /∗ ( 3 ) ∗/ decompose_Constraint . add ( f < upperB ) ;
19 /∗ ( 4 ) ∗/ model . add ( decompose_Constraint ) ;
20
21 IloCP cp ( model ) ;
22 /∗ ( 5 ) ∗/ cp . s e t P a r a m e t e r ( IloCP : : SearchType , IloCP : : D e p t h F i r s t ) ;
23 i f ( cp . s o l v e ( ) ) {
24 upperB = cp . getObjValue ( ) ;
25 c o u t << " o b j e c t i v e S p=" << cp . getObjValue ( ) <<e n d l ;
26 }
27 else {

SAYOUTI S. Abdoulaye Page 21/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

28 c o u t << " Pas ␣ de ␣ s o l u t i o n ␣SP " << e n d l ;


29 }
30 model . remove ( decompose_Constraint ) ;
31 cp . end ( ) ;
32 /∗ ( 5 ) ∗/ decompose_Constraint . end ( ) ;
33 }
34 }
35
36 else
37
38 /∗ ( 1 ) ∗/ i f ( p == 0 ) {
39 f o r ( i n t i = 0 ; i <n ; i ++)
40 /∗ ( 1 ) ∗/ t [ i ] = 1;
41
42 i f ( lower_Bound ( t ) >= upperB ) {
43 c o u t << " Lower ␣ bound ␣ s u p p e r i e u r "<<e n d l ;
44 }
45 else {
46 I l o C o n s t r a i n t A r r a y decompose_Constraint ( env ) ;
47 f o r ( I l o I n t i = 0 ; i <t . g e t S i z e ( ) ; i ++){
48 i f ( t [ i ] == 0 )
49 decompose_Constraint . add ( y [ i ] <= s o l u t i o n [ i ] ) ;
50 else
51 decompose_Constraint . add ( y [ i ] > s o l u t i o n [ i ] ) ;
52
53 }
54 decompose_Constraint . add ( f < b e s t _ S o l ) ;
55 model . add ( decompose_Constraint ) ;
56
57 IloCP cp ( model ) ;
58 cp . s e t P a r a m e t e r ( IloCP : : SearchType , IloCP : : D e p t h F i r s t ) ;
59 i f ( cp . s o l v e ( ) ) {
60 upperB = cp . getObjValue ( ) ;
61 c o u t << " o b j e c t i v e S p=" << cp . getObjValue ( ) << e n d l ;
62 }
63 else {
64 c o u t << " Pas ␣ de ␣ s o l u t i o n ␣SP " << e n d l ;
65 }
66 cp . end ( ) ;
67 model . remove ( decompose_Constraint ) ;
68 decompose_Constraint . end ( ) ;
69 }
70 }
71 else {
72 /∗ ( 6 ) ∗/ t [ n − 1 ] = 1 ;
73 basic_sandd ( t , n − 1 , p , y , s o l u t i o n , model , f ) ;
74 t [ n − 1] = 0;
75 /∗ ( 6 ) ∗/ basic_sandd ( t , n − 1 , p − 1 , y , s o l u t i o n , model , f ) ;
76
77 }
78 }

Listing 2.1 – Code source en C++ du Basic S&D

SAYOUTI S. Abdoulaye Page 22/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

2.3 Critique de l’algorithme S&D et améliorations ap-


portées
Malgré l’efficacité de l’approche de l’algorithme S &D, il fait face à plusieurs critiques.
Ces critiques sont entre autres le nombre exponentiel de sous-problèmes générés ; le temps
de décomposition du problème d’origine et des sous-problèmes ; le problème lié au filtrage
lors de la résolution des sous-problèmes et enfin la difficulté à prouver l’optimalité de la
solution trouvée. L’algorithme Solve and Decompose peut être amélioré pour résoudre les
problèmes d’optimisation de façon plus efficace. Pour cela, nous commençons par limiter
la profondeur de décomposition à depth=1. Ce qui signifie que seul le problème d’origine
est décomposé et que les sous-problèmes générés au niveau de la profondeur depth=1 sont
résolus à l’optimalité.
Dans cette section nous présentons les insuffisances de l’ancienne version de l’algorithme
S&D, ensuite les améliorations que nous apportons à l’algorithme S&D pour le rendre plus
efficace et enfin le nouvel algorithme du S&D.

2.3.1 Critiques de l’algorithme S&D


Dans la section précédente (2.2.4), nous avions énoncé que l’algorithme S &D générait les
sous-problèmes d’une manière de recherche en profondeur. Ces sous-problèmes sont à leur
tour décomposés en de sous-problèmes jusqu’à une profondeur donnée. Pour un COP dont
la fonction objectif contient un ensemble de variables Y, 2|Y | sous-problèmes sont générés
après la décomposition du problème d’origine. Ce nombre étant trop grand, nous proposons
dans la section 2.3.2 une stratégie permettant de regrouper l’ensemble des sous-problèmes
d’un niveau Lp en un seul sous-problème.
Par ailleurs, nous dénotons par Td l’unité de temps de décomposition. Cette unité de
temps comme illustré à la figure 2.4, correspond au temps mis entre la génération de deux
sous-problèmes consécutifs. Hormis le temps de résolution des sous-problème, ce temps de
décomposition joue un rôle capital sur la complexité en temps de résolution du problème
en entier. Pour un niveau Lp donné, le temps de décomposition est exprimé par la formule
(Cnp - 1)*Td, avec n=| Y | et Cnp la combinaison de p parmi n qui correspond au nombre
de sous-problèmes générés au niveau Lp. Ainsi, le temps de décomposition total mis pour
générer tous les sous-problèmes est (2|Y | -1)*Td.
Après la résolution d’un sous-problème, un problème de filtrage survient lors de la ré-
solution du prochain sous-problème. Le nouveau sous-problème à résoudre étant considéré
comme un problème indépendant du précédent sous-problème, certaines parties de l’espace
de recherche du précédent sous-problème pourraient être reparcourut une autre fois dans le
nouveau sous-problème. Par conséquent, cela augmenterait le temps de résolution du nou-
veau sous-problème. Ainsi, on pourrait imaginer le temps perdu si l’espace de recherche
de certains sous-problèmes étaient entièrement composés de parties déjà explorées dans de

SAYOUTI S. Abdoulaye Page 23/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

précédant sous-problèmes.
Une autre faiblesse de l’ancienne version de l’algorithme S&D est de prouver que le upperB
connue est la solution optimale en raison du nombre exponentiel de sous-problèmes générés
qui est dû au nombre de variables apparaissant dans la fonction objectif. Pour palier à ces
faiblesses de l’ancienne version de l’algorithme S&D, nous proposons dans la section 2.3.2
une stratégie de regroupement de l’ensemble des sous-problèmes générés pour un niveau Lp
en un seul sous-problème.

Figure 2.4 – Unité de temps de décomposition Td.

2.3.2 Améliorations apportées


Le principe de l’algorithme S&D est de décomposer le problème d’origine en de sous-
problèmes de plus petites tailles et de parcourir ces sous-problèmes en commençant par
les sous-problèmes les plus prometteurs. Cependant, en pratique, cette stratégie fait face à
quatre problèmes. Le premier est le nombre exponentiel de sous-problèmes générés après la
décomposition du problème d’origine. Le second, est le temps de décomposition du problème.
Le troisième est lié au filtrage lors de la résolution des sous-problèmes. Et le quatrième est
sa difficulté à prouver l’optimalité de la meilleur borne supérieur actuelle (upperB).
Pour ce fait, nous proposons dans un premier temps de limiter le nombre de sous-
problèmes visités à un niveau Lp donnée où on espère que la solution optimale ou qu’une
bonne solution proche de la solution optimale peut être trouvée. Ensuite, nous revenons au
problème d’origine pour le résoudre à l’optimalité dans le but de prouver rapidement que
le upperB est la solution optimale si elle a été trouvé. Dans un second temps nous pro-
posons de regrouper l’ensemble des sous-problèmes générés pour un niveau Lp en un seul
sous-problème, pour à la fois réduire le nombre de sous-problèmes générés ; réduire le temps
de décompositions et augmenter l’effort de filtrage.

SAYOUTI S. Abdoulaye Page 24/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

Limitation du nombre de sous-problèmes visités :

La version basique du S&D possède de nombreux avantages en termes de réduction d’une


grande partie de l’arbre de recherche ; générant des sous-problèmes de plus petites tailles ;
identifiant les sous-problèmes prometteurs et par conséquent trouve rapidement la solution
optimale.
Mais il a un principal inconvénient qui constitue à prouver que le upperB connu est la
solution optimale en raison du nombre exponentiel de sous-problèmes générés qui est dû
au nombre de variables apparaissant dans la fonction objectif. Cela signifie que la taille de
l’arbre de recherche générée est très grande. Pour y remédier, nous-proposons de limiter le
nombre de sous-problème visité à un certain niveau où on espère que la solution optimale (ou
une bonne solution) se trouve. Ensuite, nous revenons sur le nœud racine qui est le problème
d’origine, et nous le résolvons à l’optimalité.
Le choix de la limite étant important, nous proposons deux critères pour la limite. Le
premier, consiste à définir une limite Lp telle que tous les sous-problèmes se trouvant avant
le niveau Lp serons tous résolus. Ensuite, après la résolution des sous-problèmes du niveau
Lp, nous devons remonté au nœud racine pour le résoudre à l’optimalité. Le second, consiste
également à définir une limite Lp. Mais, cette fois, si une solution a été trouvée dans un
niveau Lq se situant avant Lp, nous remontons au nœud racine sans atteindre le niveau Lp.

Regroupement des sous-problèmes par niveau :

L’autre approche que nous proposons est de regrouper l’ensemble des sous-problèmes
générés pour un niveau Lp donné en un seul sous-problème. Une fois qu’une solution réalisable
S est obtenue en résolvant le CSP du problème d’origine, nous passons à l’étape de la
décomposition de ce problème. Dans la version précédente de l’algorithme S&D, pour un
niveau Lp, Cnp sous-problèmes sont générés avec n =| Y | le nombre de variable contenue
dans la fonction objectif. Pour remplacer cet ensemble de sous-problèmes en un seul sous-
problème, nous formulons un ensemble de contraintes levelConstraint que nous rajoutons au
problème d’origine. Cet ensemble de contraintes stipule que le nombre de variables yi ∈ Y
dont leur domaine est lef ti doit être égale à p. Ceci permet de prendre en considération tous
les sous-problèmes du niveau Lp. Nous donnons plus de détail sur cet ensemble de contraintes
levelConstraint dans la section 2.3.3.
Ainsi, comme illustré à la figure 2.5, on peut remarquer que le nombre exponentiel de
sous-problèmes qui devrait être générés a été réduit à un nombre fini de sous-problèmes.
Nous somme donc passé de 2|Y | sous-problèmes à | Y | +1 sous-problèmes. On peut aussi
remarquer que le filtrage est beaucoup plus efficace avec cette stratégie, car considérer comme
un seul sous-problème une partie de l’espace de recherche ne sera pas parcourue plus d’une
fois. Il convient de remarquer également que le temps de décomposition pour un niveau Lp,
qui était égale à (Cnp - 1)*Td a été éliminé. Ainsi, pour tous les niveaux allant de p=0 à
Pp=|Y |
p=| Y |, le temps de décomposition éliminé est égale à : ( p=0 Cnp - | Y | - 1)*Td ou (2|Y | -
| Y | - 1)*Td.

SAYOUTI S. Abdoulaye Page 25/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

Par exemple, considérons un problème de minimisation ou de maximisation dont le


nombre de variables contenues dans la fonction objectif est égale à quinze (| Y |=15) et
supposons que l’unité de temps de décomposition est Td=0.001 seconds. Le temps total
de décomposition éliminé est de 32.7 seconds. On peut ainsi donc remarquer l’efficacité de
cette stratégie pour un problème avec uniquement quinze variables dans la fonction objectif.

Figure 2.5 – Regroupement des sous-problèmes.

2.3.3 Description de l’ensemble des contraintes levelConstraint


Nous appelons par " Grouped S&D " la version amélioré de l’algorithme S&D. Pour
l’implémentation du nouvel algorithme, nous introduisons un tableau de variable binaire t et
un ensemble des n +1 contraintes levelConstraint. L’ensemble des contraintes levelConstraint
est composé de n contraintes logiques ajoutées au problème d’origine pour générer un sous-
problème pour un niveau p donné, avec n la taille du tableau t qui correspond au nombre de
variables contenues dans la fonction objectif. Chaque contrainte logique ci ∈ levelConstraint
stipule que si ti =0 alors la variable yi ∈ Y doit prendre une valeur dans son domaine inférieur
ou égale ȳi . Cela revient à dire que si ti =0 alors le domaine de yi est lef ti . Inversement
si ti =1 alors le domaine yi est righti . La dernière contrainte de levelConstraint est une
contrainte qui stipule que la somme des valeurs du tableau t doit être égale à p. Ainsi, le
sous-problème généré après l’ajout de l’ensemble des contraintes levelConstraint stipulant
P
que t =p regroupe tous les sous-problèmes du niveau p. Ci-dessous, nous présentons le
code source du Grouped S&D. La fonction " grouped_sandd " prend à peut près les mêmes
paramètre que le Basic S&D. Cependant, la principale différence est que le " grouped_sandd

SAYOUTI S. Abdoulaye Page 26/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

" n’est pas une fonction récursive. De plus, l’ensemble des contraintes levelConstraint et le
tableau de variable binaire permettent de regroupé tous les sous-problèmes du niveau p en
un seul sous-problème.

1 v o i d grouped_sandd ( I n t n , I l o I n t p , I l o I n t V a r A r r a y y , I l o I n t A r r a y s o l u t i o n , I l o M o d e l model ,
IloNumExpr f ) {
2
3 /∗ ∗/ I l o C o n s t r a i n t A r r a y l e v e l _ C o n s t r a i n t ( env ) ;
4 I l o I n t V a r A r r a y t ( env , n , 0 , 1 ) ;
5 f o r ( I l o I n t i = 0 ; i <n ; i ++){
6 l e v e l _ C o n s t r a i n t . add ( I l o I f T h e n ( env , t [ i ] == 1 , y [ i ] <= s o l u t i o n [ i ] ) ) ;
7 l e v e l _ C o n s t r a i n t . add ( I l o I f T h e n ( env , t [ i ] == 0 , y [ i ] > s o l u t i o n [ i ] ) ) ;
8 }
9
10 /∗ ∗/ l e v e l _ C o n s t r a i n t . add ( IloSum ( t ) == p ) ;
11 model . add ( l e v e l _ C o n s t r a i n t ) ;
12 model . add ( f < upperB ) ;
13 IloCP cp ( model ) ;
14 cp . s e t P a r a m e t e r ( IloCP : : SearchType , IloCP : : D e p t h F i r s t ) ;
15 i f ( cp . s o l v e ( ) ) {
16 upperB = cp . getObjValue ( ) ;
17 c o u t << " o b j e c t i v e S p=" << cp . getObjValue ( ) <<e n d l ;
18 }
19 else {
20
21 c o u t << " Pas ␣ de ␣ s o l u t i o n ␣ " << e n d l ;
22 }
23 cp . end ( ) ;
24 model . remove ( l e v e l _ C o n s t r a i n t ) ;
25 l e v e l _ C o n s t r a i n t . end ( ) ;
26 }

Listing 2.2 – Code source en C++ du Grouped S&D

2.4 Implémentations et résultats expérimentaux


Cette section a pour but d’exposer les différentes implémentations que avons eu à effectuer
et les résultats obtenues après des test effectués sur des instances du Problème du Voyageur
de Commerce. Ainsi, nous présentons tout d’abord les environnements matériels et logiciels
utilisés pour les implémentations. Ensuite, nous énumérons toutes les implémentations qui
ont été effectués. Enfin, nous présentons les résultats obtenues après des tests réalisés sur
des instances du Problème du Voyageur de Commerce.

2.4.1 Environnements de travail


Environnement matériel :

Pour la phase de développement, nous avons utilisé un ordinateur portable de marque Le-
novo G500 avec les caractéristiques suivantes :
– Procésseur : Intel(R) Pentium(R) CPU 2.40GHz 2.40GHz 64 bit
– Mémoire RAM : 4 GB

SAYOUTI S. Abdoulaye Page 27/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

– System d’exploitation : Windows 10 Integtral 64 bit


– Disque dur : 500 GO

Environnements logiciel :

Pour procéder à l’implémentation nous avons utilisé les logiciels suivants :


1. IBM ILOG CPLEX Optimization Studio version 12.6.3 : C’est un logiciel
conçu par la société multinationale américaine IBM (International Business Machines
Corporation) qui permet de modéliser et de résoudre des problèmes d’optimisations.
Ce logiciel contient un outil de modélisation et deux moteurs de résolutions :
– IBM ILOG Concert Technology : C’est un outil qui offre une bibliothèque
de classes et de fonctions permettant de définir des modèles pour les problèmes
d’optimisation.
– IBM ILOG CPLEX : C’est un outil de résolution de problèmes d’optimisation
linéaire, communément appelés "problèmes de programmation linéaire" (PL).
– CP Optimizer : C’est une bibliothèque logicielle qui fournit un moteur de program-
mation par contraintes ciblant à la fois les problèmes de satisfaction de contraintes
et les problèmes d’optimisation.
2. Microsoft Visual Studio version Ultimate 2012 : C’est un environnement de
développement intégré (IDE) conçu par la société américaine Microsoft.
IBM ILOG Concert Technology, CP Optimizer et IBM ILOG CPLEX pro-
posent des interfaces de programmation (API) pour les langages Microsoft .NET, C++
et Java. Cepandant, l’interface de programmation pour le C++ doit être utiliser sur l’
IDE Microsoft Visual Studio et il fournit beaucoup plus de fonctionnalités que les autres
API, comme implémenté ses propres stratégies de recherches. Pour cette raison, le langage
de programmation utilisé pour l’implémentation est le langage C++.
Le moteur de résolution utilisé pour effectué les implémentations et les tests, est le moteur
de programmation par contraintes CP Optimizer. L’algorithme de résolution exacte utilisé
pour tester les différentes versions du S&D est l’algorithme de recherche en profondeur (
en anglais : Depth-First Search (DFS)). Cette algorithme, est prédéfini dans CP Optimizer,
mais nous l’avons implémenté en utilisant les extension de ce moteur de résolution dans le but
d’avoir une bonne compréhension du fonctionnement du DFS et de maitriser les processus
d’implémentation d’algorithmes de recherche personnalisés sous CP Optimizer . Le problème
du voyageur de commerce (TSP) est le problème que nous avons utilisé pour effectué des
tests des versions du S&D. Ensuite, nous avons effectué une comparaisons avec l’algorithme
DFS afin d’évaluer l’efficacité des deux versions de l’algorithme S&D quand ils sont combinés
au DFS. Nous avions prévue effectués des tests sur le problème du voyageur de commerce
avec fenêtre de temps (TSPTW) qui est une variante du problème du voyageur de commerce.
Cependant, en raison d’un temps imparti, nous nous somme limités au problème du voyageur
de commerce.

SAYOUTI S. Abdoulaye Page 28/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

2.4.2 Implémentation de la contrainte de cycle pour le TSP


Dans la section 1.3.2 du chapitre précédent, nous avions présenté en exemple le problème
du voyageur de commerce comme un exemple de problème d’optimisation combinatoire sous
contraintes. En effet, dans le modèle du TSP , nous avions parlé de la contrainte globale Cycle
qui contraignait l’ensemble des villes visitées à former un seul cycle hamiltonien. Cependant,
cette contrainte globale n’est pas fournit par l’outil de modélisation IBM ILOG Concert
Technology. Pour cela, nous avons implémenté la contrainte globale Cycle en utilisant les
extensions du moteur de résolution CP Optimizer.
Une contrainte est un objet dans CP Optimizer. Plus précisément, une contrainte dans
CP Optimizer est une instance d’une classe avec deux fonctions virtuelles pures, propagate
et post. La fonction virtuelle propagate implémente l’invariant de la contrainte ; la fonction
post définit sur quels événements s’exécute propagate. Le terme invariant est utilisé dans le
sens usuel de l’ingénierie informatique.
Prenons l’exemple x ≤ y dans ce contexte. Son invariant est facile à déterminer et il peut
être exprimé comme suit :
– les valeurs du domaine de x doivent être inférieures ou égales au maximum des valeurs du
domaine de y ;
– les valeurs du domaine de y doivent être supérieures ou égales au minimum des valeurs du
domaine de x.
Ainsi, pour la contrainte de cycle, nous avons exprimé l’invariant comme suit : Sachant
qu’un ensemble de n villes doivent être visitées, si une ville i est visitée, cette ville est
considérée comme la ville de départ. De plus, les (n - 1) prochaines villes qui seront visitées
en partant de la ville i doivent être toutes différentes et doivent être aussi différentes de la
ville i. La fonction propagate est déclenché à chaque fois qu’une ville est visitée. Les codes
source des deux fonctions propagate et post sont présentés ci-dessous.
1 void I l c C y c l e I : : propagate ( ) {
2 IloCP cp = _x_var . getCP ( ) ;
3 f o r ( i n t i = 0 ; i < _x_var . g e t S i z e ( ) ; i ++){
4 i f ( _x_var [ i ] . i s F i x e d ( ) && _x_var [ i ] . i s I n P r o c e s s ( ) ) {
5 I l c I n t V a r A r r a y y ( cp , _x_var . g e t S i z e ( ) , 0 , _x_var . g e t S i z e ( ) − 1 ) ;
6 cp . add ( y [ 0 ] == i ) ;
7 f o r ( i n t j = 1 ; j < _x_var . g e t S i z e ( ) ; j ++){
8 cp . add ( y [ j ] == _x_var [ y [ j − 1 ] ] ) ;
9 }
10 cp . add ( I l c A l l D i f f ( y ) ) ;
11 }
12 }
13
14 }

1 void I l c C y c l e I : : post ( ) {
2 f o r ( i n t i = 0 ; i < _x_var . g e t S i z e ( ) ; i ++){
3 _x_var [ i ] . whenValue ( t h i s ) ;
4 }
5 }

Listing 2.3 – Codes sources des fonction propagate et post

SAYOUTI S. Abdoulaye Page 29/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

Dans la fonction propagate, au niveau de la ligne 2, " _x_var " est un tableau de variable
qui représente l’ensemble des villes à visitées. L’instruction " IloCP cp = _x_var " permet
d’extraire le tableau de variables dans le moteur de résolution CP Optimizer. La première
boucle commençant à la ligne 3 permet de parcourir le tableau de variable pour déterminer
la dernière ville en cours de visite. Cependant, la condition de vérification commençant à la
ligne 4 vérifie si la ville i est la dernière ville qui vient d’être visitée. Si cela est le cas, un
tableau de variables " y " est introduit. Le tableau de variables " y " permet d’enregistrer la
liste des villes visitées dans l’ordre en partant de la ville i. Ensuite, une contrainte globale
" IlcAllDiff " est appliqué à cette liste de villes. Cette contrainte " IlcAllDiff " contraint le
tableau de variable à contenir des valeurs différentes. Ainsi, si en partant de la ville i, parmi
les (n - 1) prochaines villes à visitées, une ville est visité plus d’une fois, alors la contrainte
" IlcAllDiff(y) " est violée. Dans la fonction post, la boucle permet de déclencher la fonction
propagate à chaque fois qu’une ville est visitée.

2.4.3 Implémentation du S&D en bas niveau et en haut niveau


L’implémentation du " Basic S&D " et " Grouped S&D ", est une étape importante car
elle permet de mettre en pratique toutes les idées développées dans les sections précédentes.
Cependant, les appellations " implémentation en bas niveau " et " implémentation en haut
niveau " déterminent si l’implémentation a été effectué en utilisant comme algorithme de
base, un algorithme prédéfini dans le solveur, ou si l’algorithme de base a été implémenté.
Dans notre cas, l’algorithme de base est l’algorithme de recherche en profondeur (DFS).
Dans le but de maitriser le procédé d’implémentation d’algorithme de recherche personna-
lisé sous CP Optimizer, nous avons implémenté l’algorithme DFS. L’implémentation d’al-
gorithmes de recherche sous CP Optimizer se fait à base de buts. Les buts implémentent
des algorithmes dans lesquels la séquence exacte d’opérations à suivre n’est pas connue à
l’avance. Ce type de programmation est souvent appelé non déterministe. Ci-dessous nous
montrons le code source d’un exemple de but dont la tâche est d’instancier une variable.
Cet algorithme est composé d’un but nommé " Instanciate ". Ce but prend en paramètre
une variable et ensuite vérifie si une valeur est déjà affecté à cette variable. Si c’est le cas
le but arrête son exécution. Sinon, il choisit la plus petite valeur du domaine de la variable
qu’il affect à la variable. Si cette affection n’est pas cohérente à cause d’une contrainte posée
sur cette variable alors la valeur sera supprimé du domaine de la variable et la prochaine
plus petite valeur sera essayé. Remarquer donc que l’instruction de la ligne 4 est celle qui
se charge d’attribuer une valeur à la variable et reprendre une autre fois la même tâche si
l’affection n’est pas cohérente.

SAYOUTI S. Abdoulaye Page 30/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

1 ILCGOAL1( I n s t a n c a t e , I l c I n t V a r , x_var ) {
2 i f ( x_var . i s F i x e d ( ) ) r e t u r n 0 ;
3 I l c I n t v a l = x_var . getMin ( ) ;
4 r e t u r n I l c O r ( x_var == v a l , I lc An d ( x_var != v a l , t h i s ) ) ;
5 }

Listing 2.4 – Exemple de but pour instancier une variable

Ainsi, ces buts ont été utilisé pour implémenté le DFS, le " Basic S&D " et le " Grouped
S&D " en bas niveau. Pour, l’implémentation du " Basic S&D " et du " Grouped S&D " en
haut niveau, nous avons utilisés comme algorithme de base, l’algorithme DFS prédéfini dans
le moteur de résolution CP Optimizeur.

2.4.4 Résultats expérimentaux


Dans cette section nous présentons les résultats obtenus des tests effectués sur huit
instances du problème du voyageur de commerce. Pour la limite Lp du nombre de sous
problèmes à parcourir au maximum, nous avons choisit d’imposer la limite p = 10. Le
tableau 2.1 ci-dessous montre une comparaison des temps d’exécutions en seconde entre le
Basic S&D et le Grouped S&D. La comparaison a été effectuée sur l’instance f tv33 du TSP
qui comporte 34 variables dans sa fonction objectif. Les tests ont été effectués sur les niveaux
L34 , L33 , L32 , L31 et L30 , et nous pouvons observés le temps nécessaire à chaque version du
S&D pour résoudre un niveau Lp . On peut ainsi remarquer l’efficacité de la stratégie de
regroupement des sous-problèmes d’un niveau en un seul sous-problème. Par exemple, pour
les niveau L32 ,L31 et L30 , on peut observer l’écart très grand entre les temps nécessaires au
deux version du S&D. Nous nous somme limité au niveau L30 car le " Basic S&D " nécessitait
plus que 2000 seconds pour parcourir tous les sous-problèmes du niveau L30 .

L34 L33 L32 L31 L30


Basic S&D 0.1 s 4.6 s 49.3 s 527.5 s > 2000 s
Grouped S&D 0.1 s 1.5 s 10.8 s 96.8 s 490.3 s

Tableau 2.1 – Test sur quatre niveau de l’instance f tv33 du TSP

La figure 2.6 ci-dessous montre les courbes des solutions obtenus par chaque algorithme en
fonction du temps pour l’instance f tv70 du TSP qui comporte 71 variables dans sa fonction
objectif. Sur cette figure on remarque que la valeur de la première solution obtenu par les
trois algorithmes est 3346. A partir de cette valeur, on remarque une chute des courbes du
Basic S&D et du Grouped S&D. On peut aussi remarquer qu’en 1000 secondes, les courbes
du Basic S&D et du Grouped S&D sont plus proche de la solution optimale qui est égale à
1950. Les courbes du Basic S&D et Grouped S&D sont confondus car la deuxième solution
a été trouvée en résolvant le premier sous-problème généré qui correspond au niveau L71 .

SAYOUTI S. Abdoulaye Page 31/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

Ce niveau, ne comportant qu’un seul sous-problème pour les deux algorithmes, alors le
temps nécessaire pour la résolution de ce sous-problème est sensiblement égale pour les deux
algorithmes S&D.

Figure 2.6 – Courbes des solutions obtenus par le DFS, le Basic S&D et le Grouped S&D
en fonction du temps pour l’instance f tv70 du TSP.

Le tableau 2.2 ci-dessous présente les résultats des temps d’exécution en seconde pour
le TSP en utilisant le DFS prédéfini dans CP Optimizer, le Basic S&D et le Grouped S&D
implémentés en haut niveau. La colonne " Nom " représente le nom des instances du TSP, la
colonne " n " représente le nombre variable contenue dans la fonction objective et la colonne
" opt " représente la valeur de la solution optimale pour chaque instance. Pour chaque algo-
rithme, la colonne " Sol1 " représente la valeur de la première solution trouver. Cette solution
est la même pour tous les trois algorithmes, car les algorithmes Basic S&D et Grouped S&D
utilise la première solution fournie par le DFS pour effectué la décomposition. Les colonnes
" Sol2 " et " Sold " représentent respectivement la deuxième solution trouver et la dernière
solution trouver. La dernière solution correspond en fait à la meilleur solution trouver en
1000 seconds. Pour chaque solution trouvée, les colonnes " val " et " ts " représentent la
valeur de la solution et le temps d’exécution en seconde nécessaire pour obtenir la solution.
Cependant, pour le Basic S&D et le Grouped S&D le niveau à la quel la deuxième solution
a été trouvé est représenté par " (Lp ) " avec p le nombre de sous-domaine lef ti dans le
sous-problème. Les " - " notifient qu’aucune solution n’a été trouvée en 1000 secondes.
Pour effectuer une comparaison entre les trois algorithmes, nous passerons par deux
étapes. En premier lieu, nous comparons pour chaque algorithme les valeurs val de la solution
Sol2 et les temps d’exécutions ts nécessaire pour trouver la solution Sol2 . Ainsi, on peut
remarqué l’écart entre la valeur de la deuxième solution trouvée par le DFS et celle trouvée
par les algorithmes Basic S&D et Grouped S&D par rapport au temps, pour la majorité des
instances. On remarque donc que les algorithmes S&D trouvent une solution plus proche de
la solution optimale. Le rapport de différence entre le S&D Basic et le Grouped S&D se situe

SAYOUTI S. Abdoulaye Page 32/37


CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

au niveau du temps ts où l’on remarque un léger avantage du Grouped S&D sur le Basic
S&D. En second lieu, nous comparons pour chaque algorithme le valeur val de la meilleur
solution trouvée en 1000 secondes. On peut toujours remarqué un écart entre ces valeurs.
Cela nous permet de conclure que le Grouped S&D est plus efficace que le DFS et le Basic
S&D.

SAYOUTI S. Abdoulaye Page 33/37


SAYOUTI S. Abdoulaye
DFS Basic S&D Grouped S&D
Sol1 Sol2 Sold Sol2 Sold Sol2 Sold
Nom n opt val ts val ts val ts val ts val ts val ts val ts
f tv33 34 1286 1911 0.7 s 1880 1.04 s 1562 642.8 s 1698(L34 ) 0.9 s 1396 327.8 s 1698 0.8 s 1396 326.4 s
f tv35 36 1473 1928 1.7 s 1927 4.2 s 1605 577.1 s 1825(L35 ) 3.7 s 1635 820.3 s 1825 2.4 s 1635 817.2 s
f tv38 39 1530 1892 2.4 s 1891 4.7 s 1812 291 s 1772(L38 ) 5.3 s - - 1772 3s - -
f tv44 45 1613 2370 4.1 s 2244 7.6 s 1995 994.1 s 2097(L45 ) 4.3 s 1970 574.6 s 2097 3.8 s 1970 569.2 s
f tv47 48 1776 2570 4.9 s 2554 10.1 s 2233 1018.48 s 2280(L47 ) 9.4 s 2080 335.7 s 2280 8.5 s 2080 320.3 s

Page 34/37
f tv55 56 1608 2551 7.5 s 2543 12.3 s 2351 914.5 s 2288(L56 ) 7.8 s 1938 317.8 s 2288 8.1 s 1938 309.5 s
f tv64 65 1839 2621 7.4 s 2574 8.3 s 2443 73.2 s 2408(L64 ) 13.2 s 2371 991.5 s 2408 12.9 s 2371 976.2 s
f tv70 71 1950 3346 11.2 s 3293 22.4 s 3039 804.3 s 2841(L71 ) 13.6 s 2554 194.3 s 2841 12.7 s 2554 197.9 s

Tableau 2.2 – Temps d’exécution en seconde pour huit instances du TSP en utilisant le DFS, le Basic S&D et le Grouped S&D
CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE
CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE

2.5 Conclusion
Dans ce chapitre, une description de l’algorithme S&D a été présentée et des améliorations
ont été apportées à cette algorithme. Des implémentations ont ensuite été effectuées pour les
deux versions du S&D ainsi que pour le DFS et la contrainte de cycle pour le TSP. Enfin des
tests effectués sur des instances du TSP ont permis d’évaluer l’efficacité de la stratégie de
décomposition et du regroupement des sous-problèmes. Nous avons ensuite remarqué d’après
les résultats obtenus que le regroupement des sous-problèmes d’un niveau est très efficace en
matière de résoudre les sous-problèmes plus rapidement et de trouver une solution beaucoup
plus proche de la solution optimale dans un temps rapide.

SAYOUTI S. Abdoulaye Page 35/37


CONCLUSION ET PERSPECTIVES

CONCLUSION ET PERSPECTIVES

Dans ce mémoire, nous avons donné les définitions de bases et quelques exemples des
problèmes de satisfaction de contraintes et des problèmes d’optimisation combinatoire sous
contraintes. Nous avons également présenté des méthodes de résolution exactes pour résoudre
les problèmes d’optimisation. Ensuite, nous avons présenté l’algorithme Solve and Decompose
qui est une stratégie de recherche combinée à des méthodes de résolution exactes pour trouver
la solution optimale ou un solution plus proche de de la solution optimale dans un temps
rapide. Notre but a été donc d’améliorer cette algorithme afin qu’il soit plus efficace.
Pour aboutir aux résultats escomptés, nous sommes passés par plusieurs phases. La
première phase a été, d’apprendre à maitriser l’outil de modélisation des problèmes d’opti-
misation IBM ILOG Concert Technology et le moteur de programmation par contarinte
CP Optimizer. Après cela, nous sommes passés à la phase d’implémentation et ensuite à la
phase des tests pour évaluer le nouvel l’algorithme. Les résultats que nous avons obtenus nous
ont permis de conclure que le nouvel algorithme est plus efficace que l’ancien algorithme. Ce-
pendant, le principe du nouvel algorithme étant de regroupé l’ensemble des sous-problèmes
d’un niveau en un seul sous-problème, nous pensons qu’il peut être possible de regroupé tous
les sous-problèmes en un seul sous-problème. Ainsi, le principe de décomposition sera géré
de façon interne et non de façon externe. Cela signifie qu’une fois que la première solution
est obtenue, la décomposition ne sera plus physique, mais plutôt logique.
Ce travail nous a été très instructif du point de vue des connaissances acquises, d’une prise
de conscience sur nos forces et nos faiblesses et des améliorations que nous pouvont apportés
à ce travail. Il nous a procuré une opportunité de découvrir le monde de la programmation
par contrainte et de l’optimisation. Nous sommes satisfaits du travail accompli malgré le
temps qui était insuffisant pour effectué des tests sur d’autre type de problème.

SAYOUTI S. Abdoulaye Page 36/37


BIBLIOGRAPHIE

BIBLIOGRAPHIE

[1] A. Lamine, M. Khemakhem, B. Hnich, H. Chabchoub, Solving Constrained Opti-


mization Problems by Solution-based Decomposition Search. Journal of Com-
binatorial Optimization, 23p.
[2] Hoeve, W.J.v., Milano, M. : Decomposition based search - a theoretical and expe-
rimental evaluation. CoRR cs.AI/0407040 (2004)
[3] Philippe Refalo, Linear Formulation of Constraint Programming Models and Hy-
brid Solvers. ISBN 978-3-540-41053-9, 15p.
[4] Madjid KHICHANE, Optimisation sous contraintes par Intelligence Collective
Auto-adaptative. Université Claude Bernard Lyon 1 Laboratoire d’Informatique
en Image et Système d’information (LIRIS), 151p.
[5] http ://www.ibm.com/support/knowledgecenter/SSSA5P_12.6.0/ilog.odms.cpo.help/
CP_Optimizer/topics/ cpoptimizer_splash.html ?lang=fr.
[6] https ://www.ibm.com/developerworks/community/forums/html/category ?id=33333333-
0000-0000-0000-000000000268
[7] http ://elib.zib.de/pub/mp-testdata/tsp/tsplib/atsp/index.html
[8] http ://www.cs.cornell.edu/w8/iisi/ilog/cp11/usrsolver/usrsolverpreface.html

SAYOUTI S. Abdoulaye Page 37/37