introduction - pages persos chez.comsophiasapiens.chez.com/informatique/techniques... · web...
TRANSCRIPT
Techniques d’OptimisationMaster 1 en Informatique
Table des matières
1) Introduction.......................................................................................................
2) Méthodologie de résolution d’un problème d’OC.............................................
2.1 Analyse du système.........................................................................................
2.2 Formulation du problème...............................................................................
2.3 Modélisation d’un problème...........................................................................
2.4 Recherche de solutions...................................................................................
2.5 Implémentation des solutions........................................................................
3) Définition d’un problème d’O.C...........................................................................
4) Exemples de problèmes d’OC.............................................................................
5) Classification naïve des POC (Facile/Difficile).......................................................
5.1 Problèmes faciles............................................................................................
5.2 Problèmes difficiles......................................................................................
6) Complexité algorithmique...................................................................................
6.1) Définition :.....................................................................................................
6.2) Définition......................................................................................................
6.3) Définition de la classe P.................................................................................
6.4) Définition de la classe NP...............................................................................
6.5) CLASSE NP COMPLET....................................................................................
1) Introduction
Les organisations font face de nos jours à des problématiques de plus en plus complexes. Ceci
est dû à la multiplicité des objectifs à atteindre et aux contraintes difficiles à prendre en
considération et très souvent liée à la nature combinatoire des problématiques qu’elles traitent.
Les approches existantes répondent partiellement et souvent pas du tout aux attentes des
décideurs. Nous tenterons dans ce chapitre d’attirer le lecteur sur la difficulté de résolution de
ces problèmes et de lui faire prendre conscience sur la nécessité d’aborder ces problématiques
sous un angle qui lui permettra d’intégrer la dimension combinatoire afin de développer une
approche raisonnable pour chercher une solution acceptable dans un temps raisonnable. Nous
couvrirons aussi bien des applications modélisables par les graphes que celles par les modèles
mathématiques d’une manière générale. Nous donnerons une classification des problèmes par
rapport à la complexité de leur résolution.
L'optimisation combinatoire (OC) occupe une place très importante dans la résolution de
problèmes en Informatique ou dans les autres disciplines de l’ingénierie aux technologies de
pointes. Les problèmes d'optimisation combinatoire sont souvent faciles à définir mais, en
général, ils sont difficiles à résoudre. En effet, la plupart de ces problèmes appartiennent à la
classe des problèmes NP-difficiles et ne possèdent donc pas à ce jour de solution algorithmique
efficace valable pour toutes les instances de ces problèmes. De nombreuses méthodes de
résolution ont été développées en recherche opérationnelle (RO) et en intelligence artificielle
(IA). Ces méthodes peuvent être classées sommairement en deux grandes catégories : les
méthodes exactes (complètes) qui garantissent la complétude de la résolution et les méthodes
approchées (incomplètes) qui perdent la complétude pour gagner en efficacité.
Les méthodes exactes tentent généralement d’énumérer, souvent de manière exhaustive,
l'ensemble des solutions de l'espace de recherche auxquelles elles rajoutent des techniques pour
détecter le plus tôt possible les échecs (calculs de bornes) et d'heuristiques spécifiques pour
guider les différents choix. Parmi les méthodes exactes, on trouve la plupart des méthodes
traditionnelles (développées depuis une trentaine d'années) telles les techniques de séparation et
évaluation progressive (SEP) ou les algorithmes avec retour arrière. Les méthodes exactes ont
permis de trouver des solutions optimales pour des problèmes de taille raisonnable. Malgré les
progrès réalisés (notamment en matière de la programmation linéaire en nombres entiers),
comme le temps de calcul nécessaire pour trouver une solution risque d'augmenter
exponentiellement avec la taille du problème, les méthodes exactes rencontrent généralement
des difficultés face aux applications de taille importante.
Les méthodes approchées constituent une alternative très intéressante pour la résolution de
problèmes combinatoires de grande taille lorsque l'optimalité n'est pas une priorité. Parmi ces
méthodes, nous citons les méthodes gloutonnes dites d’insertion comme, par exemple, la
méthode de Lin et Kernighan qui est restée longtemps l’approche préférée des praticiens pour
la résolution du problème du voyageur de commerce. Des progrès importants ont été réalisés
depuis ces dernières décennies où l’on constate l’apparition d’une nouvelle génération de
méthodes approchées appelées méta heuristiques pour améliorer les heuristiques locales. Elles
sont adaptables et applicables à une large classe de problèmes et offrent un processus de
raffinement par l’hybridation des différentes approches. Grâce à ces méta heuristiques dont
l’intérêt est certain en Informatique et dans d’autres disciplines comme la génétique, on peut
proposer aujourd'hui des solutions approchées pour des problèmes d'optimisation classiques de
plus grande taille et pour de très nombreuses applications qu'il était impossible de traiter
auparavant.
2) Méthodologie de résolution d’un problème d’OC
Pour traiter un problème de décision et plus particulièrement d’OC, nous devons adopter une
méthodologie d’approche de façon à être guidé tout au long du processus de résolution. La
figure 1.1 suivante illustre une méthodologie d’approche d’un problème d’OC.
Figure 1.1 : Méthodologie d’approche d’un problème
Analyse du système dans lequel le problème est posé (environnement, acteurs impliqués etc.)
Identification des facteurs contrôlables (Variables) et des facteurs non contrôlables (contraintes etc.) ainsi que les objectifs
Choix d’un modèle (Graphe, Programme linéaire, non linéaire, simulation etc.)
qui décrit au mieux les éléments de la formulation
Elaboration d’une approche de résolution (exacte ou approchée) pour le modèle
Retour arrière Développement d’application informatique qui intègre l’approche de résolution du modèle Implémentation
de(s) solution(s)
Résolution
Modèle
Formulation
Systèmes
2.1 Analyse du système
Une attention particulière doit être accordée à la phase d’analyse du système. Des réunions de
« brain storming » doivent être organisées avec les décideurs pour bien cerner la problématique
à traiter. Des approches d’analyse systématique comme CATWOE développée par Peter
Checkland en 1981 permettent de guider dans le processus d’identification du problème, de
réfléchir sur ce que l’on doit atteindre et de considérer l’impact de la solution sur les personnes
impliquées. Cette approche simple est utilisée pour stimuler la réflexion sur le problème et
l’implémentation de solution. consiste à dresser un tableau où les lignes sont les lettres de la
méthode formulées sous forme de questions auxquelles il faut tenter de répondre
objectivement. La tables CATWOE est présentée somme suit :
Code Designation Explication
C Customers
Les clients ou les bénéficiaires finaux, les problèmes qu’ils
rencontrent, comment vont-ils réagir aux propositions qui leurs
seront soumises et qui sont les gagnants et les perdants.
A Actors Identifier les acteurs qui font le travail, l’impact sur eux et
comment vont-ils réagir ?
T Transformation
process
Décrire le processus du système qui permet de transformer des
entrées en sorties, quelles sont les entrées et d’où proviennent-
elles? Quelles sont les sorties et où vont-elles? Quelles sont les
étapes intermédiaires ?
W Worldview Quelle est la vue globale dans laquelle la situation s’adapte le
mieux? Quelle est le problème réel sur lequel l’étude est faite?
Quelle est le plus large impact de n’importe quelle solution?
O Owners Quels sont les propriétaires réels ou les propriétaires du système ou
processus que vous souhaitez changer? Peuvent ils vous aider ou
vous stopper ? Quels sont les conséquences si vont dans le même
sens que vous? Pourquoi vont-ils suivre votre démarche?
E Environmental
constraints
Quelles sont les contraintes qui agissent sur la situation et vos
idées ? Quelles sont les limites éthiquement, réglementairement,
financièrement et ressources ? Les régulations en vigueur etc. ?
Comment cela puisse contraindre vos solutions ? Comment les
contourner ?
Table 1.1: L’approche CATWOE
Prenons à titre d’exemple le système ouvert comme Internet en considérant les points de vues des fournisseurs d’accès, des utilisateurs, des fournisseurs de services, des gouvernements (exécutifs) etc.
Code Désignation Explication
C Customers Les utilisateurs d’Internet et les problèmes de connexion et de débit qu’ils rencontrent quotidiennement.
A Actors Les fournisseurs d’accès, les utilisateurs, les fournisseurs de services et l’état qui fixe les régulations (ARTP) et qui contrôle le système
T
Transformation
process
Prestation de service pour le Provideur et les fournisseurs de services sur Internet
Outil incontournable pour le développement technologique et scientifique
Publicité pour les entreprises
Information et
Moyens de lutte comme les réseaux sociaux (crise dans les pays arabes, etc.)
W Worldview Internet est un outil qui réduit les distances culturelles, ethniques, sociales et permet de promouvoir les valeurs universelles comme la tolérances, la lutte contre xénophobies, islamophobie et abolit les frontières
O Owners Algérie Télecom,
E Environmental
constraints
Les virus, les hackers etc.
Nécessité de protéger les enfants
Nécessité de protéger les libertés individuelles
Lutte contre les nouveaux fléaux en cybercriminalité
Table1 : Exemple d’analyse d’un système par CATWOE
2.2 Formulation du problème
Dans cette phase, nous cherchons à identifier le(s) objectif(s) du problème et ses différentes
contraintes. Pour cela, nous devons connaître les différents facteurs intervenants dans le
système à savoir : Les facteurs contrôlables et les facteurs non contrôlables.
Les facteurs contrôlables sont ceux sur lesquels le(s) décideur (s) peu(ven)t directement agir.
Généralement, ils représentent les variables de décisions.
Les facteurs non contrôlables représentent ceux qui sont imposés par l’environnement. Les
contraintes sont un exemple de facteurs non contrôlables mais il en existe d’autres comme les
coûts dans la fonction Objectif etc.
A titre d’exemple, considérons le problème du voyageur de commerce qui doit partir d’une
ville donnée et visiter les (n-1) autres villes du réseau R=(X, U, l) une et une seule fois puis de
revenir à sa ville de départ tout en minimisant la longueur totale parcourue.
2.3 Modélisation d’un problème
Un modèle est une représentation d’une réalité. Il peut prendre plusieurs formes :
Mathématiques (Linéaire, non linéaire, entier, convexe etc.), graphe et ses différentes et ses
topologies (arbre, arborescence, biparti etc.) incluant les réseaux sous toutes ses formes
(Transport, Pétri, Automate à états finis etc.) et la simulation. Le processus de modélisation est
long et fastidieux auquel nous devons accorder beaucoup d’attention. Cela est dû au fait que les
parties impliqués dans ce processus ne parle souvent pas le même langage et des problèmes
sémantiques peuvent surgir. De même, le modèle à construire doit être supporté par des
données qui sont imprécises et comportent des aléas qui sont parfois liés au fait que les acteurs
ne fournissent pas suffisamment d’effort à leur collecte. En général, la résolution du modèle
permet de détecter ses insuffisances et de les corriger.
2.4 Recherche de solutions
Dans la littérature, les méthodes de résolution suivent quatre approches différentes pour la
recherche d'une solution : l'approche de construction, l'approche de relaxation, l'approche de
voisinage et l'approche d'évolution. La première classe regroupe les méthodes de résolution
dites exactes et permettent de résoudre des problèmes faciles de la classe P et certaines
instances de petites tailles des problèmes de la classe NP. Pour les méthodes exactes, il s’agit
de rechercher le ou les solutions optimales. Par contre, pour les solutions approchées nous
recherchons des solutions réalisables proches de l’optimum.
Les méthodes exactes fournissent une solution optimale exacte mais leur application pour
certain problème n’est pas de tout rentable ( en temps et espace mémoire ) . Parmi les
importantes méthodes, nous citerons les méthodes de séparation et d’évaluation SEP, A* et
CSP. Le temps de calcul nécessaire d'une telle méthode augmente en général exponentiellement
avec la taille du problème à résoudre (dans le pire des cas). Pour améliorer l'efficacité de la
recherche, on utilise des techniques variées pour calculer des bornes permettant d'élaguer le
plus tôt possible des branches conduisant à un échec. Parmi ces techniques, on peut citer les
différentes relaxations : la relaxation de base en programmation linéaire, la relaxation
lagrangienne, la relaxation agrégée (surragote relaxation) et la décomposition lagrangienne.
De plus, on emploie des heuristiques pour guider les choix de variables et de valeurs durant
l'exploration de l'arborescence. En programmation linéaire en nombres entiers, nous citons la
méthode des coupes de Gomory ou l’algorithme de Branch and Bound pour des petites
instances. Dans la première classe de méthode, nous cherchons à couper le polyèdre convexe de
façon à rendre les points extrêmes des solutions entières. Par contre, dans la seconde approche
l’approche tente de faire une exploration intelligente de l’espace des solutions en le divisant, à
chaque itération, en deux sous espaces de façon à restreindre une des variables non entière à
prendre des valeurs entières.
Les méthodes approchées tentent de rechercher de bonnes solutions réalisables. On dit qu’un
algorithme est approximatif (heuristique) s’il conduit à une solution réalisable mais pas
nécessairement optimal en temps raisonnable. Les méta heuristiques constituent une autre
partie importante des méthodes approchées et ouvrent des voies très intéressantes en matière de
conception de méthodes heuristiques pour l’optimisation combinatoire. On peut les classer en
deux catégories: les méthodes de voisinage et les algorithmes évolutifs. Nous pouvons
également combiner les différentes méthodes pour créer des méthodes hybrides.
2.5 Implémentation des solutions
Cette étape consiste à implémenter les solutions obtenues à l’étape précédente. Il s’agit de
choisir les structures de données adéquates pour la modélisation des données du problème afin
de développer une application permettant de répondre aux attentes du (des) décideur (s). La
maitrise des méthodes de conception, de langage de programmation, des systèmes de gestion de
base de données s’avère nécessaire.
Une fois les solutions implémentées, la validation opérationnelle avec les acteurs concernés est
nécessaire. Un retour arrière aux étapes antérieures peut être nécessaire pour régler les conflits
qui pourraient surgir de la validation du modèle.
3) Définition d’un problème d’O.C
Un Problème d’Optimisation Combinatoire (POC) consiste à chercher le minimum s* d’une
application le plus souvent à valeurs entières ou réelles sur un ensemble fini S
f ( s¿)=mins∈ S
f (s ){ Trouver s¿∈Sf ( s¿ )=min
s∈ Sf (s)
❑
Cette définition reste valable pour le cas d’une maximisation car il suffit de remarquer que :
Max (s) = - Min (-(s))
Un problème d'optimisation combinatoire est défini par un ensemble d'instances. A chaque
instance du problème est associé un ensemble discret de solutions S. Un sous ensemble X de S
représentant les solutions admissibles (réalisables) et une fonction de coût f (ou fonction
objectif) qui assigne à chaque solution s X le nombre réel (ou entier) f(s). Résoudre un tel
problème (plus précisément une telle instance du problème) consiste à trouver une solution
s*X optimisant la valeur de la fonction de coût f. Une telle solution s* s'appelle une solution
optimale ou un optimum global.
Une instance I d'un problème de minimisation est un couple (X, f) où X S est un ensemble fini
de solutions admissibles, et f une fonction.
Le Problème d’Existence (PE) consiste à chercher dans un ensemble fini S s’il existe un
élément s vérifiant une propriété P.
On peut formuler un (E) comme un (OC) particulier. En effet, un problème d’existence peut
être formulé par l’énoncé d’une question à réponses Oui / Non. On définit la fonction
Objectif
: S [0, 1]
s f(s) = 0 si et seulement si s vérifie la propriété P
Inversement, on peut ramener un POC à un E car il existe aussi un problème d’existence
associé à tout problème d’optimisation combinatoire où il suffit de rajouter à la donnée de S et
un entier K une propriété tel que ( s ) ≤ K. Autrement dit, on ne cherche pas une solution
optimale mais une solution de coût inférieur ou plus égale à K.
La résolution d’un POC peut se faire d’une manière intuitive par énumération complète de
toutes les solutions vérifiant le système des contraintes et de prendre ensuite celle qui optimise
f mais cette approche est impossible car lorsque S la recherche devient obsolète.
4) Exemples de problèmes d’OC
Cette section présente quelques exemples de problèmes d’Optimisation Combinatoire POC
dans les graphes, en programmation linéaire et autre.
Soient R=(X, U, c) un réseaux et s et p deux sommets particuliers de ce réseaux tel que
l’ensemble des prédécesseurs de s est vide noté -(s) = et l’ensemble des successeurs de p est
vide +(p) = , le problème de la recherche d’un chemin de s à p dans R est un problème
d’existence ( P E )
Problème de la recherche d’un plus court chemin de s à p dans R est un problème
d’optimisation combinatoire. En effet, soit S l’ensemble fini de tous les chemins de s à p dans
R, à tout chemin µ S lui correspond un coût ( ) = ∑u∈
f (u¿)¿. Il s’agit de trouver parmi
tous les chemins de S celui de longueur minimale f( *), c'est-à-dire,
( * ) = Minµ € S
( )=Minµ € S
∑u∈
f (u¿)¿
En programmation linéaire, le problème de la recherche d’une solution de base réalisable
(sommet) dans le polyèdre convexe délimitant l’espace de contraintes est un PE. Par contre,
celui qui consiste à trouver parmi toutes les solutions de base réalisation, celui qui optimise une
fonction Objectif est un POC. En effet, considérons le programme linéaire mis sous sa forme
standard :
{Max F=cxA x=bx≥ 0
Soit S = {x/ A x = b, x 0}. Ce problème est équivalent au problème suivant:
{ Trouver x¿∈SF ( x¿)=Max x∈S F(x )
5) Classification naïve des POC (Facile/Difficile)
Les problèmes d’optimisation combinatoires POC peuvent être classés d’une manière simple en
problèmes faciles et problèmes difficiles. La première catégorie regroupe tous les problèmes
dont on connait des algorithmes polynomiaux pour leurs résolutions. La seconde catégorie
regroupe tous ceux dont on ne connait pas d’algorithmes pour leurs résolutions et que la seule
façon de le faire est de trouver une solution approchée.
5.1 Problèmes faciles
Le problème de tri d’un tableau à n valeurs, les problèmes d’insertion et les problèmes de la
résolution d’un programme linéaire dans le cas de modèle non dégénéré sont des exemples de
problèmes faciles hors graphes.
Il existe beaucoup de problèmes faciles dans les graphes. On rappelle qu’un graphe G=(X, U)
est la donnée d’un ensemble de sommets et U d’un ensemble d’arcs (cas orienté) ou arêtes (cas
non orienté). Un arbre est un graphe connexe et sans cycle.
Le problème de la recherche d’un arbre recouvrant de poids minimum est un problème facile
car l’algorithme de Kruskal permet de le résoudre d’une façon optimale en O(n2) où n=|X|.
Les problèmes de cheminement qui consiste à trouver un plus court chemin d’un sommet
particulier de départ s et un sommet particulier d’arrivé p et celui de la recherche d’une
arborescence des plus courts chemins issus d’une racine s se résolvent d’une façon polynomiale
par les algorithmes de Belleman, Djikstra et Ford.
Le problème de la recherche d’un flot maximun dans un réseau (X, U, c) où c est la capacité
d’un arc. Un flot f est un vecteur de Rm avec m=| U| qui assure la conservation de la matière en
chaque sommet du graphe et où chacune de ses composantes ne dépasse pas la capacité de l’arc
correspondant. Il s’agit dans ce cas de trouver parmi tous les flots existants celui qui maximise
la valeur de l’arc retour ur de capacité infini. Ce problème est résolu d’une façon polynomiale
par l’algorithme de Ford et Fuklkerson en O(n.m2).
Un couplage C de G est un sous ensemble d’arrêtes tel que deux arrêtes u et v quelconque de C
n’aient aucun sommet en commun. Le problème de la recherche d’un couplage C* dans un
graphe biparti G=(X, Y, U) se résout d’une façon polynomiale par la méthode Hongroise.
Le problème du parcours Eulerien: Une condition nécessaire et suffisante d’existence d’un tel
parcours est que le graphe soit connexe et que les ses sommets sont de degrés pairs. Le
problème d’existence est résolu en O(m).
5.2 Problèmes difficiles
Il existe dans la vie courante des problèmes de nature difficile car on ne connait pas
d’algorithmes exactes pour leurs résolutions pour des instances de grandes tailles. Dans ce cas,
nous recherchons des approches approchées (heuristiques, méta heuristiques etc.).
Dans les graphes, le problème de stable maximal est un POC. Un sous ensemble de sommets S
X est un stable s’il n’existe pas d’arêtes entre chaque couple de sommets de S. En d’autres
termes, le sous graphe GS=(S, U) où U=. Un stable S* est dit maximal si son cardinal est
maximal.
Le problème de la recherche d’un transversal minimal est un POC. Un sous ensemble de
sommets T est dit transversal si toute arête de G a au moins une extrémité dans T. En d’autres
termes, T recouvre les arêtes de G. Il sera dit minimal si sa cardinalité est minimale.
Le problème de la recherche d’une clique maximale est un POC. Un sous ensemble de sommets
C est dit clique de G si toute paire de sommets de C est reliée par une arête. Le problème est de
trouver dans un graphe une clique de cardinalité maximale.
Un graphe G est dit k-coloriable si on peut colorier ses sommet avec k couleurs distincts sans
que 2 sommets adjacents quelconques de G n’aient la même couleur. Le plus petit k tel que G
est k-coloriable est appelé le nombre chromatique d’un graphe.
Le problème de la recherche d’un parcours Hamiltonien de moindre coût est un POC. Il s’agit
de parcourir tous les sommets d’un graphe une et une seule fois et en revenant au point de
départ tout en parcourant un minimum de distance.
Les problèmes difficiles hors des graphes sont nombreux. En voici quelque uns :
Le problème de sac-à-dos à valeurs entières. Il s’agit de déterminer le nombre d’exemplaire de
n objets à prendre dans le sac à dos de façon à maximiser la valeur totale nutritive et ne pas
dépasser son poids total p. Chaque objet i a un poids pi et une valeur ci et est disponible en
quantité bi
Le problème du Bin packing où il s’agit d’empaqueter n objets de poids pi dans un nombre
limité de boite de capacité b. Le but est de répartir ces objets en un nombre minimal de boîtes.
Le problème de la sauvegarde de fichiers sur plusieurs disques en utilisant la commande COPY du MSDos. Cette commande, contrairement à BACKUP ne peut fragmenter un fichier sur deux supports différents. On connait la capacité de chaque support de stockage ainsi que les tailles des fichiers à sauvegarder, le problème consiste à sauvegarder les fichiers en un nombre minimal de supports. Parmi les problèmes difficiles connus est celui du problème de satisfiabilité de n variables
booléennes xi, (i=1, …, n) et d’un ensemble de m clauses c j (j=1,…, m) où il s’agit de
déterminer les valeurs de chaque variable xi qui rendent les m clauses vraies. On rappelle d’une
clause est un littéral ou une disjonction de littéraux. Un littéral est une variable booléenne ou sa
négation.
Exemple : Considérons la formule suivante composée d’une conjonction d’une 3-clause, 2-
clause et 4-clause: F= (x1 x2x3 ) (y1y2 ) (z1z2z3z4)
Un 2-SAT est une formule à conjonction de 2-clauses, un 3-SAT à conjonction de 3-clauses
etc. Cook a démontré que le problème SAT est un problème difficile.
6) Complexité algorithmique
Un problème est dit polynomial s'il existe un algorithme permettant de trouver une solution
optimale pour toutes ses instances en un temps polynomial par rapport à la taille de l'instance.
Un tel algorithme est dit efficace pour le problème en question. C'est notamment le cas de
certains problèmes de plus court chemin dans un graphe pondéré, du recouvrement d'un graphe
valué par un arbre de poids minimum, des problèmes classiques de flots, ainsi que pour les
problèmes Horn-SAT et 2-SAT (notons cependant que MAX-2-SAT reste NP-difficile).
Cependant, pour la majorité des problèmes d'optimisation combinatoire, aucun algorithme
polynomial n'est connu actuellement.
La complexité a été développée en 1970 pour répondre à la question d’existence d’algorithme
polynomiale pour une classe de problème dit difficile. Le principal résultat est la conjecture
que PNp, c'est-à-dire que si on arrive à résoudre d’une façon polynomiale un de ces
problèmes difficiles on arriverait alors tous les autres.
Le temps d’exécution d’un algorithme (complexité temporelle) dépend de la machine, du
langage de programmation du compilateur (constructeur, version, option etc.) et des données.
De même la complexité spatiale (espace mémoire nécessaire) dépend de la machine. Ces deux
mesures dont insuffisantes pour tester l’efficacité d’un algorithme.
En pratique, la complexité d’un algorithme A est une fonction CA(n) donnant le nombre
d’opérations caractéristiques exécutées par A dans le pire des cas en fonction de la taille n. On
utilise la O notation pour donner une majoration de l’ordre de grandeur du nombre d’opérations
qui est déterminée en fonction de la taille n des données en entrées du problème et du nombre
d’opérations élémentaires qui interviennent dans l’algorithme dans le pire des cas.
Dans le cas des graphes, il est d’usage d’exprimer la taille des données en termes de nombre de
sommets n et/ou du nombre d’ares m. En générale, la taille d’une donnée est la quantité
mémoire nécessaire pour la stocker (mesurée en bits). On compte le nombre de mots mémoires
qui peuvent être des entiers, réels etc.
La difficulté intrinsèque de ces problèmes est bien caractérisée par la théorie de la NP-
complétude. De nombreux problèmes d'optimisation combinatoire (la plupart de ceux qui sont
vraiment intéressants dans les applications !) ont été prouvés NP-difficiles. Cette difficulté
n’est pas seulement théorique et se confirme hélas dans la pratique. Il arrive que des
algorithmes exacts de complexité exponentielle se comportent efficacement face à de très
grosses instances - pour certains problèmes et certaines classes d'instances. Mais c'est très
souvent l'inverse qui se produit ; pour de nombreux problèmes, les meilleures méthodes exactes
peuvent être mises en échec par des instances de taille modeste, parfois à partir de quelques
dizaines de variables seulement. Par exemple, on ne connaît aucune méthode exacte qui soit
capable de colorier de façon optimale un graphe aléatoire de densité 1/2 lorsque le nombre de
sommets dépasse 90. Or, pour le problème d'affectation de fréquences dans le domaine des
réseaux radio-mobiles qui est une extension du problème de coloration, il faut traiter des
instances comportant plus d'un millier de variables et on se contente de solutions approchées
obtenues avec une méthode approchée.
Un problème est dit décidable si et seulement s’il existe un algorithme qui permet de le
résoudre. A l’inverse, tout problème n’admettant pas d’algorithme pour sa résolution est
qualifié d’indécidable. Par exemple,
Voici quelques exemples de complexités
Complexité constante : CA(n) = O(1); le nombre d’opérations est indépendant de la taille des
données à traiter.
Complexité logarithmique : CA(n)= O (log(n)); on rencontre généralement une telle complexité
lorsque l’algorithme morcèle un problème complexe en plusieurs sous problèmes de sorte que
la résolution d’un seul de ces sous problèmes conduit à la solution du problème initial.
Complexité linéaire : CA(n) = O(n.log(n)) ; l’algorithme divise le problème en sous problèmes
plus petits qui sont résolus de manières indépendantes. Dans ce cas, la résolution des sous
problèmes mène à la solution du problème global.
Complexité quadratique : CA(n)= O(n2) ; l’algorithme envisage toutes les paires de données
parmi les n entrées (exemple, deux boucles imbriquées).
Complexité cubique : CA(n)= O(n3) etc.
Complexité exponentielle : CA(n)= O(2n). Dans ce cas, il n’existe aucune garanti que la solution
s’obtienne en un temps raisonnable.
6.1) Définition :
Soient et g deux fonctions de R R, on dit que est d’ordre inferieure ou égale à g ou
d’ordre au plus g, si on peut trouver un réel xO et un réel positif c tel que x ≥ xO ( x ) ≤ ( g
(xO)). On écrit = O ( g ) que l’on prononce Grand O de g .
Considérons deux algorithmes A1 et A2 pour un même problème de taille n avec : CA1 ( n ) =
0,5 n2 et CA2 ( n ) = 5n
A2 fait plus d’opération et va moins vite que A1 lorsque n = 5 , par contre pour n≥10, A2 fait
moins d’opérations que A1 et donc il va plus vite car : n ≥ 10 on a: 5n ≤ 0,5 n2
6.2) Définition
Soient deux fonctions et g deux fonctions de R R. Si la limn →+∞
fg=c, avec c> 0 alors et g
sont de même ordre (on note =O(g) et g=O(f) f= (g)). Si limn→+∞
fg=0 alors f=O(g). Si
limn →+∞
fg=+∞ alors g=O(f).
Voici quelques exemples : 0 (n2 ) = ( 0,75 n2 ), O(n2 + 2n + 7 = 0 (n2), on néglige des termes
d’ordre inférieur
Parfois, nous n’avons pas besoin d’être précis sur la notion d’opération caractéristique d’un
algorithme. En effet, Il n’est pas besoin d’être très précis dans la notion d’opération
caractéristique. En effet, soient f(n) = 3 n2 – 4n + 2 et g ( n ) = 12 n2. Nous avons lim
n →+∞
f (n)g(n)
=6
donc f= (g).
Soient f (n) = log2 ( n ) et g( n) = n. En utilisant la règle de l’hôpital, nous trouvons
limn →+∞
f (n)g(n)
=0 alors f = 0 (g)
Soient f( n ) = xn et g(n)= nk où x et k sont arbitraires mais des constantes fixes supérieure à 1,
nous avons limn →+∞
f (n)g(n)
=+∞ alors g = 0 ( ), en d’autres termes g est plus vite que f.
On notera que l’exponentielle est d’ordre supérieur à n’importe quel polynôme en n.
6.3) Définition de la classe P
La classe P est constituée de tous les problèmes d’existence P E résolus par des algorithmes
dont la complexité est polynomiale O(p(n)) où p(n) est un polynôme de degré n (n1). Elle
inclut tous les problèmes faciles cités précédemment.
6.4) Définition de la classe NP :
La classe NP est constituée de problèmes PE dont on ne connait pas d’algorithme de
complexité polynomiale et pour lequel une instance de ce problème est vérifiable
polynomialement. Autrement dit, cette classe regroupe tous les problèmes d’existence dont une
proposition de solution est « oui » est vérifiable polynomialement. En utilisant le principe du
superviseur qui stipule qu’ayant trouvé la solution à un PE par un algorithme polynomiale ou
pas, peut on en convaincre facilement (polynomialement) une tierce personne (superviseur) qui
n’a pas cherché la solution.
Pour montrer qu’un problème appartient à la classe NP complet il faut d’abord proposer un
codage à la solution et de trouver un algorithme qui vérifie la solution par des données
(certificat) puis de montrer que cet algorithme se résout d’une façon polynomiale
Remarque : Tous les problèmes d’existence PE sont des problèmes de type NP.
Exemple: Etant donné un ensemble S de n nombres entiers et un nombre entier b, existe-il un
ensemble T S tel que : ∑i
x i Xi = b ≤ O, on ne connaît pas d’algorithme polynomiale pour
résoudre ce problème alors il n’est pas de classe NP.
- Un codage de la solution (certificat) peut être une liste de celles trouvées dans T.
- L’algorithme de vérification consiste à vérifier que les entiers de cette liste correspondent
effectivement à des entiers de S et que leur somme vaut b.
- Cette vérification est possible.
6.5) CLASSE NP COMPLET
Il s’agit des problèmes les plus difficiles de NP et représentent le noyau de cette classe car si on
trouvait un algorithme polynomiale pour un des problèmes alors on résoudrait de façon
polynomiale tous ceux appartenant à cette classe.
La technique utilisée pour prouver qu’un problème appartient à la classe NP complet est de
montrer qu’il est transformable polynomialement en un des problèmes déjà connu de cette
classe.
Théorème de Cook : Le problème de satisfiabilité SAT est NP complet
Ce théorème est très important car il permet d’établir des équivalences pour certains problèmes
de la classe NP complet.
Les étudiants sont priés de consulter les ouvrages et les pointeurs sur les sites recommandés en
cours pour plus de détail sur cette partie.
Chapitre 2
Table des matières
1) Introduction............................................................................................................................
2) Quelques exemples de modélisation en PLNE........................................................................
2.1) Le problème du sac-à-dos................................................................................................
2.2) Planification de la production...........................................................................................
2.3) Problème de dichotomie..................................................................................................
3) Lemme....................................................................................................................................
4) Résolution de P par l’approche Branch-And-Bound...............................................................
4.1) Principe de séparation......................................................................................................
4.2) Principe d’évaluation........................................................................................................
4.3) Stratégies d’exploration...................................................................................................
4.4) Algorithme de Branch and Bound....................................................................................
4.5) Exemple illustratif.............................................................................................................
4.6) Amélioration de l’approche..............................................................................................
5) Méthode des coupes de Gomory (troncatures)......................................................................
5.1. Notion de coupe de Gomory............................................................................................
5.2) Algorithme de coupes......................................................................................................
5.3 Exemple illustratif..............................................................................................................
5.4) Amélioration de la méthode............................................................................................
1) Introduction
La programmation en nombres entiers regroupe l’ensemble des techniques permettant de
résoudre des programmes linéaires dont les solutions doivent être entières. Formellement, le
programme linéaire en nombres entiers s’exprime comme suit:
La matrice A d’ordre m x n, le vecteur colonne b d’ordre m et le vecteur ligne c d’ordre n sont
supposés être des entiers. Le vecteur colonne x d’ordre n est entier, c'est-à-dire, les variables du
système A x ≤ b sont soumises à être entières. La relaxation de cette contrainte d’intégrité
donne le programme linéaire (Q) associé comme suit :
La résolution de (P) ne peut pas se faire par la résolution de (Q) puis d’arrondir ensuite les
solutions non entières. En effet, le simple arrondi des variables non entières à des valeurs
entières peut rendre la solution non réalisable ou simplement non optimale. Considérons
l’exemple suivant :
Max Z = 3 x1 + 4 x2
2 x1 + x2 ≤ 6
2 x1 + 3 x2 ≤ 9
x1, x2 N
La résolution graphique du programme linéaire associé (Q) donne :
Soit D le polyèdre délimité par l’ensemble des contraintes de (P) illustré par la figure suivante :
Les points extrêmes sont O, A, B et C et la solution optimale est atteinte au point B qui n’est
pas entier. L’arrondi de cette solution donne (2, 2) qui n’est pas réalisable, (2, 1) qui est
réalisable mais n’est pas optimale.
(0, 6) 1
Figure 1 : Polyèdre D délimitant l’espace des solutions de (P)
Dans ce chapitre nous allons présenter deux approches différentes pour résoudre (P) à savoir :
La méthode de séparation et d’évaluation (Brand and Bound) et la méthode des coupes.
2) Quelques exemples de modélisation en PLNE
Beaucoup de problèmes pratiques se modélisent comme des programmes linéaires en nombres
entiers. En voici quelque un :
2.1) Le problème du sac-à-dos
Le problème du sac à dos où on doit remplir un sac à dos avec unités de n éléments où chaque
élément j possède un poids pj et une valeur nutritive cj de telle façon à ne pas dépasser son
poids total p et en maximisant la valeur nutritive.
En notant xj le nombre d’unités de l’élément j à prendre dans le sac à dos, ce problème se
modélise comme suit :
Il existe une variante où les variables de décision sont binaires. Dans ce cas, il s’agit de prendre
ou de ne pas prendre l’élément j dans le sac à dos.
(0, 6) 1
2.2) Planification de la production
Dans un problème de planning de production de n produits, le coût de production d’un produit
j est constitué d’un coût fixe Kj, indépendant du volume de production de ce produit et d’un
coût variable cj par unité du produit.
Si on désigne par xj le niveau de production du produit j, le coût total de production du produit
j est :
La fonction objectif est : Min Z ═
On notera que la fonction objectif Z n’est pas continue au point origine. Pour palier ce
problème, nous introduisons une variable auxiliaire yj définie comme suit :
Ces deux conditions peuvent être exprimées comme une contrainte linéaire suivante :
xj ≤ M yj où M est un nombre très grand. Le problème peut être formulé comme suit :
Remarques :
Le problème d’origine n’était pas un problème de programmation en nombres entiers, il a été
transformé pour régler le problème de la discontinuité au point origine et est devenu un
problème de linéaire mixte.
Un programme linéaire est dit mixte si une partie des variables est entière et une autre ne l’est pas.
2.3) Problème de dichotomie
Supposons que dans une situation donnée, il est requit qu’uniquement k contraintes parmi les
m contraintes du problème soient actives. Supposer que les m contraintes sont sous forme la
forme suivante: gi(x1, …, x n) ≤ bi avec i=1,2, …, m.
On définit la variable yi associée à la ième contrainte comme suit :
Pour assurer qu’uniquement k parmi m contraintes soient actives, il suffira de considérer
Avec M un nombre très grand.
En effet, pour les i (i=1, …, k) contraintes actives, nous avons yi = 0 et par conséquent on aura:
gi(x1, …, x n) ≤ bi. Pour les (m-k) autres contraintes nous avons gi(x1, …, x n) ≤ bi + M qui
deviennent redondantes.
Ce type de situation se produit souvent lorsque le second membre d’une contrainte prend une
ou plusieurs valeurs, c’est-à-dire,
g(x1, …, x n) ≤ b1, b2, …, br (*)
On introduit une variable Booléenne yk, définie comme suit :
La contrainte (*) est transformée comme suit :
g(x1…, x n) ≤
3) Lemme
Soient x e, x r les solutions optimales respectivement des programmes (P) et (Q) et Z e, Zr les
valeurs de leurs fonctions objectifs respectivement, alors nous avons : Z e ≤ Zr, c'est-à-dire,
que la valeur de la solution optimale du programme (Q) dont les variables ne sont pas astreintes
est une borne supérieure à la valeur de la solution optimale entière.
En effet, supposons le contraire, c'est-à-dire, pour un problème donné, nous avons Z e > Zr.
Puisque xe est aussi solution du programme Q car il vérifie A xe ≤ b, il s’ensuit que xr n’est pas
optimale car c x e > c xr . D’où la contradiction avec le fait que x r est optimale.
Remarque : Même si le domaine de solution de (Q) est convexe et borné, le nombre de solution
du programme (P) peut être tellement grand qu’il serait couteux de choisir la meilleure solution
par l’énumération explicite de toutes les solutions
4) Résolution de (P) par Branch-And-Bound
Cette approche a été proposée par Little et Al. pour résoudre le problème de voyageur de
commerce puis repris par d’autres auteurs pour résoudre d’autres problèmes en introduisant
plusieurs variantes. Le principe de cette approche est « diviser pour mieux régner ». En d’autres
termes, il s’agit de partitionner, à chaque itération, le polyèdre convexe représentant l’ensemble
des solutions réalisables du problème en trois sous ensembles et à éliminer celui qui ne peut
pas contenir de solutions entières (principe de séparation). Chaque sommet généré dans
l’arborescence des solutions est évalué par la résolution du programme linéaire associé
(principe d’évaluation). Le choix du sommet sur lequel la séparation doit se faire est fait en
utilisant une stratégie de sélection. Dès qu’une solution réalisable entière est atteinte alors le
sommet correspondant sera élagué et un retour arrière est nécessaire et la valeur de la fonction
objectif trouvée sera une borne inférieure à toutes les solutions réalisables à rechercher.
4.1) Principe de séparation
Soit x m la solution optimale du programme (Q) et xi une variable non entière. Pour se fixer les
idées, supposons que <xi < +1 où est nombre entier. La séparation de (P) consiste à
scinder ce programme en deux sous programmes :
(P1) (P2)
Si nous désignons par R0 le domaine ne contenant pas de solution entière, R1 le domaine (P1) et
R2 celui de (P2), la séparation consiste à éliminer R0 et à chercher des solutions entières dans R1
et R2.
y
R1
+1 Ro
R2 x
Figure 2 : Principe de séparation
Dans ce qui suit, nous allons adopter les notations suivantes :
P(0, 0) et Q(0, 0) le programme P et Q respectivement,
P(k, m) le programme linéaire en nombres entiers numéro m du niveau k (relativement à l’arborescences des solutions) et Q(k , m) le programme linéaire qui lui est associé,
x(k, m) la solution optimale de Q(k, m),
La séparation de P(k, m) donne lieu à deux sommets P(k+1, 2m) et P(k+1, 2m+1)
4.2) Principe d’évaluation
Chaque nœud généré par la séparation à l’étape k, à savoir, (Pk) est évalué en résolvant le
programme linéaire associé. Deux cas se présentent:
1 er cas : La solution obtenue est entière, elle est une borne inférieure au programme linéaire (P)
et en même temps un majorant à toutes les solutions de la branche issue de ce sommet (Pk). On
élague (coupe) ce nœud et on fait un backtraking (retour arrière) aux sommets non encore
explorés.
2 eme cas : La solution obtenue n’est pas entière et le sommet (Pk) correspondant est candidat à la
séparation.
4.3) Stratégies d’exploration
L’exploration des sommets de l’arborescence des solutions obéit à une stratégie donnée. Dans
la littérature, nous distinguons plusieurs stratégies dont voici quelque unes :
Stratégie ‘Profondeur d’abord’
Cette stratégie fait la séparation d’un sommet tant que celui-ci peut se faire. En d’autre termes,
le nœud est séparé en profondeur jusqu’à atteindre la feuille de l’arborescence des solutions.
Un retour-arrière est nécessaire dans le cas où il existe des sommets non élagués (coupés). A
partir d’un nœud Q(k, m) on explore Q(k+1, m), Q(k+2, m), etc.
Stratégie ‘Largeur d’abord’
Cette stratégie résout d’abord tous les problèmes d’un même niveau puis sépare les sommets
séparables pour ensuite résoudre les problèmes du niveau suivant. A partir d’un nœud Q (k, m)
on explore Q(k, m+1) , Q( k, m +2), etc.
Stratégie ‘Meilleur d’abord’
Dans le cas des deux stratégies précédentes, l’ordre d’exploration des sommets est prédéfini au
départ, par contre dans cette stratégie, il ne l’est pas. On explore le sommet ayant la meilleure
valeur de la fonction objectif.
A partir du sommet Q(k, m) on explore Q(i,j ) tel que Z(i j) > Z(u, v) pour tout sommet (u, v) non
encore exploré.
Il existe d’autres stratégies telles que celle basée sur la notion de pénalité.
4.4) Algorithme de Branch and Bound
(0) Choisir une stratégie d’exploration. Poser k=0, m=0 et Ze = -µ
(1) Résoudre Q(k, m) et soit x(k,m) sa solution optimale.
Si x(k,m) est entière. On coupe le nœud et si Z(k, m)> Ze on pose Ze = Z(k, m) (
Si x(k, m) n’est entière
Si Z(k, m)£ Ze. On coupe le nœud
Sinon Z(k, m) > Ze Aller en 2)
2) Soit xi une variable non entière de x(k,m) et a est nombre entier tel que a <xi < a+1.
Séparer P(k,m) en P(k+1, 2m) et P(k+1, 2m+1) où :
P(k+1, 2m) = { P(k,m), xi≤ a}, P(k+1, 2m+1) = {P(k,m), xi≥ a +1}.
Résoudre Q(k+1, 2m) et Q(k+1, 2m+1) .
3) Tester si tous les nœuds sont coupés.
Si oui. Terminer.
Sinon, choisir le nœud à explorer mettre à jour les paramètres m et k et aller en 1)
4.5) Exemple illustratif
Reprenons le programme linéaire en nombres entiers P(0, 0) précédent:
Max Z = 3 x1 + 4 x2
2 x1 + x2 ≤ 6
2 x1 + 3 x2 ≤ 9
x1, x2 N
Son programme linéaire associé Q(0, 0) est :
Max Z = 3 x1 + 4 x2
2 x1 + x2 ≤ 6
2 x1 + 3 x2 ≤ 9
x1, x2 ≥ 0
La solution optimale de Q(0, 0) est atteinte au point B=(9/4, 3/2) qui n’est pas entière. On pose Ze
= - M (M très grand positif).
Dans cet exemple, le lecteur est prié de se référer à la figure 3.1 pour la construction des
différents polyèdres obtenus après introduction de contraintes supplémentaires. Il est bien
évident que cet exemple est à titre illustratif et que dans la réalité nous devons résoudre des
programmes linéaires en utilisant des tableurs appropriés comme le Cplex ou autre.
1) Résolution de (P) par la stratégie « Profondeur d’abord »
On pose k=0 et m=0 et Ze=-M (M un nombre positif grand). On choisit de séparer sur la
variable x2= 3/2 (choix arbitraire, on raffinera ce choix plus tard). On a 1< x2< 2
On sépare P (0,0) en P (1,0) et P (1,1) avec P(1, 0) = { P(0,0), x2 ≥ 2} et P(1, 1) = {P(0,0), x2≤1}
On résout Q (1,0), on obtient le domaine délimité par DAE où D=(0, 2) A=(0,3) et E=(3/2, 2). La
solution optimale est atteinte en E avec x1= 3/2, x2=2 et ZE = 12.5. Cette solution n’est pas
entière. On explore alors P (1,0) en séparant sur la variable non entière x1 car 1 < x1 < 2. Le nœud
P (1,0) est séparé en P (2,0) et P (2,1) avec P(2, 0)={P(1,0), x1≤ 1} et P(2, 1) = {P(1,0), x1 ≥ 2}. On résout Q(2,
0) qui donne le polytope DAFG où D=(0, 2) A=(0, 3) F=(1, 2) et G=(1, 7/3). La solution
optimale est atteinte en G avec x1=1 et x2=7/3 et ZG=12.33 qui n’est pas entière. On explore le
nœud P(2, 0) en séparant sur la variable x2 avec 2< x2< 3. On définit deux sommets P (3,0) et P (3,1)
où P(3, 0)={P(2,0), x2≤ 2} et P(3, 1) = {P(2,0), x2 ≥ 3}. On résout Q (3,0), le polytope est réduit à un
segment [D, F]. La solution optimale est atteinte au point F avec x1=1 et x2=2 et ZF= 11 > Ze.
Cette solution est entière, on coupe le nœud P (3,0) et on pose Ze= 11, nouvelle borne inférieure
au programme (P).
Nous faisons un retour arrière au niveau 2 et on explore P (2,0) et on résout Q(3, 1) qui est réduit au
point (0, 2). Cette solution étant entière et on coupe le nœud P(3, 0). Comme Z(3, 1) =12 > Ze = 11,
elle constitue une nouvelle borne inférieure et on pose Ze=12 au programme (P).
Nous faisons un retour arrière au niveau 1. On résout Q (2, 1) dont le polyèdre correspondant est
vide. On coupe ce sommet car il ne peut pas mener vers une solution de base réalisable entière.
Nous remontons au niveau 0 et nous résolvons Q(1, 1) où le polyèdre correspondant est OMNC
avec O=(0, 0) M=(0, 1) N=(5/2, 1) et C=(3, 0). La solution optimale est atteinte au point N avec
x1=5/2, x2=1 et ZN= 11.5 < Ze=12. On coupe ce sommet car on ne peut pas espérer obtenir une
meilleur solution que celle déjà trouvée avec une valeur de la fonction objectif égale à 12. Par
conséquent, x1*=0, x2
*=3 et Z*=12.
En résumé, la stratégie « profondeur d’abord » a donné l’exploration des nœuds suivants (voir
Figure 3.2) :
Branche 0 : Résolution des programmes Q(0, 0), Q(1, 0), Q(2, 0) et Q(3, 0).
Branche 1 : Q(3, 1)
Branche 2 : Q(2, 1)
Branche 3 : Q(1, 1)
2) Résolution de (P) par la stratégie « Largeur d’abord »
En adoptant la même démarche, cette stratégie conduit à l‘exploration des nœuds suivants (voir
Figure 3.2) :
Niveau 0 : Résolution de Q(0, 0) qui donne x1=9/4 et x2=3/2
Niveau 1 : Résolution de Q(1, 0) qui donne x1=3/2, x2=2, Z=12.5 et Q(1, 1) qui donne x1=5/2, x2=1
et Z=11.5.
Niveau 2 : Résolution de Q(2, 0), Q(2, 1), Q(2, 2) et Q(2, 3). Seul le nœud P(2, 2) est retenu.
En effet, on sépare le nœud P(1, 0) en P(2, 0) et P(2, 1) puis on sépare P(1, 1) en P(2, 2) et P(2, 3) avec :
P(2, 2)={P(1, 1), x1 ≤ 2} et P(2, 3)={P(1, 1), x2≥3}. La résolution Q(2, 2) donne le domaine OMUV avec
M=(0, 1) U=(2, 1) et V=(2, 0). La solution optimale est atteinte en U avec x1=2, y1=1 et Z=10.
On coupe cette branche et on définit une nouvelle borne inférieure Ze=10.
La résolution de Q(2, 3) se résume au point (3, 0) et la solution trouvée est x1=3, x2=0 et Z=9 <Ze.
On coupe cette branche et on conserve l’ancienne borne inférieure.
Niveau 3 : Résolution de Q(3, 0) et Q(3, 1)
La résolution de Q(3, 0) et Q(3, 1) conduisent à des solutions entières. Le nœud P(3, 0) offre
une meilleure borne inférieure que celle trouvée en P(2, 2). Le sommet P(3, 1) est optimale car
il conduit à une solution entière de meilleure valeur de la fonction objectif. x1= 2.25, x2=1.5 Z=12.75
x2 ≥ 2 x2 ≤ 1
x1=3/2, x2=2, Z=12.5 x1= 5/2, x2=1, Z=11.5
x1 ≤ 1 x1 ≥ 2 x1 ≤ 2 x1 ≥ 3
x2 ≤ 2 x2 ≥ 3 Irréalisable x1= 2, x2=1, Z=10 x1= 3, x2=0, Z=9
x1= 1, x2=2, Z=11 x1= 0, x2=3, Z=12
Figure 3.2 : Arborescence des solutions de (P)
3) Résolution par la stratégie « meilleure d’abord » :
Au niveau O, nous résolvons Q(0,0) et nous séparons P(0,0) puis nous résolvons Q(1,0) et Q(11).
Nous séparons P(1, 0) car Q(1, 0) possède une meilleure valeur de la fonction objectif. Nous
résolvons ensuite Q(2,0). Nous séparons P(2,0) en P(3,0) et P(3, 1). Nous gardons la solution offerte par
P(3, 1) . Nous arrêtons la résolution.
P(0,0
P(1,0
P(0,0
P(3,1P(3,0
P(2,0 P(2, P(2,2) P(2,
P(1,
En résumé, cette stratégie explore les nœuds de l’arborescence représentée dans la figure 3.2
comme suit :
Niveau 0 : Q(0, 0)
Niveau1: Q(1, 0) et Q(1, 1)
Branche 2: Q(2, 0) et Q(2, 1)
Branche 3: Q(3, 0) et Q(3, 1)
4.6) Amélioration de l’approche
L’orque le programme à résoudre est de grande dimension, il est très important de chercher des
bornes inférieure et supérieure permettant de réduire rapidement l’arborescence des solutions et
le temps d’exécution des programmes car non seulement ce dernier devient exorbitant,
l’espace mémoire devient insuffisante pour terminer la résolution. Si nous n’avons pas trouvé
une solution réalisable entière, tous les efforts consentis pour la résolution sont vaines.
Dans l’exemple précèdent la résolution des programme Q(3,0) avant Q(1,1) a permis d’éviter la
résolution de Q(2,2) et Q(2,3). Il apparait donc évident que l’ordre d’exécution des programmes est
capitale pour la résolution d’un problème de programmation linéaire en nombres entiers.
Si plusieurs variables sont candidates à la séparation, une façon de gérer cette situation est de
choisir celle qui intervient dans le plus grand nombre de contraintes. Cependant, la démarche
suivante est plus solide qui consiste à chercher la meilleure borne inférieure avant d’entamer le
processus de résolution.
La bonne inferieure qui constitue un minorant pour la solution optimale d’un problème de
programmation linéaire en nombres entiers sert à élaguer des nœuds de l’arborescence assez
rapidement et d’éviter ainsi l’exploration d’un nombre important de branches.
Une manière d’opérer consiste à prospecter le voisinage de la solution optimale initiale du
programme linéaire associé et de considérer n’importe qu’elle solution entière réalisable. La
meilleure solution voisine peut être retenue comme une borne inferieure.
Dans l’exemple précèdent, la solution optimale (2.25, 1.5), les solutions voisines sont (2,1)
(2,2), (3,1), (3,2). La solution réalisable entière est (2, 1) avec Z=10. On peut démarrer
l’approche avec Ze=10. La meilleure solution de départ est celle qui est obtenue après
résolution d’un programme linéaire à variables bivalents.
Nous réécrivons le programme (Q) comme suit :
Soit x*=(x1*, …, xn
*) la solution optimale de (Q). Posons xj = [xj*] + yj où [ . ] désigne la partie
entière de la solution non entière et y j est une variable booléenne. Le vecteur x est entier. Si de
plus, il est réalisable alors la valeur de sa fonction objectif constituera une borne inférieure au
problème initial. La meilleure borne est celle qui optimise le programme suivant :
(Pb)
En effet, en remplaçant xj* dans le programme (P) et en utilisant le fait que les quantités c j
[xj*] et aij [xj*] sont des constantes, on retrouve (Pb).
La recherche de borne supérieure est utile pour améliorer les stratégies d’exploration décrites
précédemment. En effet, si le sommet (P) est séparé en (P1) et (P2), on cherche une borne
supérieure à P1 et une autre à P2. La priorité sera accordée au nœud qui possède la plus grande
borne. Comme cette borne est un majorant à toutes les solutions sur sa branche et si elle est
inférieure à la meilleure borne inférieure Ze, elle sera alors supprimée.
Soit (P) le nœud à séparer selon la variable de base xk non entière. Posons xk=[xk] + fk où 0 < fk
< 1 et considérons P1 ={P, xk ≤ [xk] }. Soit B l’ensemble des indices des variables de base et HB
ceux des variables hors base. La kième ligne du tableau optimal du programme linéaire (Q)
correspondant à (P) s’exprime comme suit: .
D’où : ≤ [xk ] (d’après la construction de P1).
Il s’ensuit : ≤ .
En introduisant une variable d’écart S, on obtient : +S =
On ajoute cette contrainte au tableau final du simplexe, on obtient une solution de base non
réalisable mais optimale (fk <0). Le changement de base par l’algorithme dual du simplexe
rapproche la faisabilité de la solution tout en la gardant optimale. La solution optimale obtenue
après une seule itération sera prise comme une borne supérieure à la solution optimale
réalisable du nœud (P1).
On procédera de la même manière pour le nœud P2 ={P, xk ≥ [xk] + 1 } et on obtiendra :
+S =
On définit la pénalité inférieure que l’on désignera Px-inf la diminution sur la valeur optimale de
la fonction objectif P occasionnée par une seule itération de l’algorithme dual du simplexe
après ajout de la contrainte xk ≤ [xk].
De même, on définit la pénalité supérieure que l’on désignera Px-sup la diminution sur la valeur
optimale de la fonction objectif P occasionnée par une seule itération de l’algorithme dual du
simplexe après ajout de la contrainte xk ≥ [xk] + 1.
Une fois ces deux pénalités calculées, la règle consiste à se brancher en priorité sur le nœud qui
génère une pénalité la plus faible car elle occasionne une plus faible diminution de la fonction
objectif (dans le cas d’une maximisation).
En utilisant l’algorithme dual du simplexe en appliquant le principe de la variable sortante xs
puis entrante xe, on obtient :
Px-inf =
Px-sup =
Où se est le coefficient marginal de la fonction objectif après ajout de la contrainte supplémentaire et ase est l’élément du tableau du simplexe situé à l’intersection entre la variable sortante et la variable entrante.
Reprenons l’exemple précédent et après ajout des variables d’écarts on obtient le programme linéaire (Q) associé à (P):
Max Z = 3 x1 + 4 x2
2 x1 + x2 + e1 = 6
2 x1 + 3 x2 + e2 = 9
x1, x2 ≥ 0
Après résolution par l’algorithme du simplexe, on obtient le dernier tableau du simplexe de (Q) :
Base b x1 x2 e1 e2
x1
x2
2,251,5
10
01
0,750,5
-0,250,5
Z -12 ,75 0 0 0,25 -1,25Les variables d’origine sont non entières. Supposons que l’on sépare sur la variable
x2= 1,5=1+0,5, d’où [x2]=1 et f2 = 0,5.
Pour le calcul de , on ajoute la contrainte supplémentaire
+ S = -0,5 et obtient le tableau suivant :
Base b x1 x2 e1 e2 S x1
x2
S
2,251,5-0,5
100
010
0,75-0,50,5
-0,250,5
- 0,5
001
Z -12 ,75 0 0 - 0,25 -1,25 0La variable sortante étant S et la variable entrante est e2. D’où :
Px-inf = = 0,5 * =1,25
Après une itération, on obtient :
Base b x1 x2 e1 e2 S x1
x2
e2
2,5011
100
010
0,50-1
001
-0,51-2
Z -11 ,5 0 0 -1,5 0 -2.5Pour le calcul de , on ajoute la contrainte supplémentaire
+ S = -0,5 et on obtient le tableau suivant :
Base b x1 x2 e1 e2 S x1
x2
S
2,251,5-0,5
100
010
0,75-0,5-0,5
-0,250,50,5
001
Z -12 ,75 0 0 - 0,25 -1,25 0La variable sortante est S et la variable sortante est e1. D’où :
Px2-sup = = 0.5 ( = 0.25
On se branche en priorité sur le nœud ayant la plus faible pénalité, à savoir, (P2) dans cet
exemple.
5) Méthode des coupes de Gomory (troncatures)
5.1. Notion de coupe de Gomory
Dans l’approche Branch-And-Bound que nous avons développé dans la section précédente, la
recherche des solutions est faite en éclatant le polyèdre convexe délimité par les contraintes en
trois parties distinctes et à éliminer celle qui ne contient pas de solutions entières et à explorer
les deux autres. L’approche par les coupes de Gomory est complémentent différente dans le
sens où elle coupe le polyèdre et se rapproche de la solution optimale entière d’itération en
itération.
Considérons le tableau optimal du simplexe associé au programme linéaire (Q) et soit x k une
variable base non entière de valeur xk*. La ligne associée à cette variable dans le tableau du
simplexe est : xk + = xk* (1)
Or, xk*= [xk*] + fk où 0< fk < 1
akj*= [akj*] + fkj où 0< fkj < 1
(1) peut être ré exprimé comme suit :
x k + +
Où encore : x k - + +
La partie de gauche est entière, il sera de même pour celle de droite et comme fk >0 et fkj >0 il
s’ensuit que
Par conséquent, . En introduisant une variable d’écart on obtient :
On définit ainsi une nouvelle contrainte, appelée, coupe de Gomory que l’on rajoute au tableau
optimal précédent. On résout le nouveau programme linéaire par l’algorithme du simplexe.
5.2) Algorithme de coupes
Une fois le principe de cette approche introduit, nous présentons le détail de l’algorithme :
1) Résoudre le programme linéaire associé et choisir une variable de xk non entière du
dernier tableau de simplexe.
2) On réécrit chaque coefficient de la ligne correspondante comme la somme d’un entier et
d’un nombre fractionnel positif inférieur à 1.
3) On forme la coupe constituée des parties fractionnelles
4) On résout le nouveau programme par l’algorithme dual du simplexe. Si la solution est
entière, terminer sinon nous reprenons (1).
Remarque :
A chaque itération la dimension du tableau du simplexe devient grande et par conséquent nous augmentons la complexité du problème. L’autre inconvénient est que la solution du problème reste irréalisable jusqu’à l’arrêt de l’algorithme.
5.3 Exemple illustratif
Soit le programme linéaire en nombres entiers (P)Max z = 7x1 + 9x2
-x1 + 3 x2 ≤ 6
7x1 +x2 ≤ 35
x1, x2 N
Soit le polytope délimitant l’espace des solutions du programmes linéaire associé (Q)
représenté par la Figure 3.3 ci-dessous. Le dernier tableau du simplexe associé au programme
linéaire (Q) est
Base b x1 x2 e1 e2
x2 7/2 0 1 7/22 1/22x1 9/2 1 0 -1/22 3/22 Z -63 0 0 -28/11 -15/11
Nous remarquons que : x*2 = 3 + 1/2 et x*1= 4 + 1/2 Les parties fractionnelles sont égales f1=f2= ½. On choisit au hasard la variable x2 et on a :
x2 + (0+7/22) e1 + (0+1/22)e2=(3+1/2)
La coupe de Gomory est :
e3 - 7/22 e1 -1/22 e2= - 1/2, où encore :
Nous l’introduisons dans le dernier tableau du simplexe et on obtient:
La variable e3 sort de la base et e1 entre en base. Après changement de la nouvelle base, on
obtient le nouveau tableau suivant :
La variable x1 n’est pas entière. On construit une coupe sur cette variable :
x1 + (0+1/7) e2 + (0-1/7)e3=(4+4/7). On doit transformer le coefficient de e3 pour rendre la
partie fractionnelle positive. Nous avons :
x1 + (0+1/7) e2 + (-1+6/7)e3=(4+4/7). La coupe de Gomory est :
e4 - 1/7 e2 - 6/7e3= - 4/7
En ajoutant cette coupe au tableau suivant, on obtient :
Base bi x1 x2 e1 e2 e3
x2 7/2 0 1 7/22 1/22 0x1 1/2 1 0 -1/22 3/22 0e3 -1/2 0 0 -7/22 -1/22 1Z -63 0 0 -28/11 -15/11 0
Base bi x1 x2 e1 e2 e3
x2 3 0 1 0 0 1x1 4+ 4/7 1 0 0 1/7 -1/7e1 1 +4/7 0 0 1 1/7 -22/7Z -59 0 0 0 -1 -8
Base bi x1 x2 e1 e2 e3 e4
x2 3 0 1 0 0 1 0x1 4+ 4/7 1 0 0 1/7 -1/7 0e1 1 +4/7 0 0 1 1/7 -22/7 0e4 -4/7 0 0 0 -1/7 -6/7 1Z -59 0 0 0 -1 -8 0
La variable e2 entre en base en remplacement de la variable e4. On obtient le nouveau tableau
suivant :
Cette solution est entière et optimale à savoir x1*=4, x2*=3 et Z*=55
Nous pouvons interpréter géométrique l’introduction de ces coupes dans le polyèdre convexe
délimitant le domaine convexe des contraintes de ce problème en les ré exprimant en termes de
variables d’origines x1 et x2.
e3 - 7/22 e1 -1/22 e2= e3 – 7/22 ( 6 + x1- 3 x2) - 1/22(35-7 x1-x2)=-1/2
Où encore : e3+ x2= 3, ce qui est équivalent à x2 ≤ 3 ……. (1).
De la même manière, on peut ré exprimer la seconde coupe sous la forme :
e4 - 1/7 e2 - 6/7e3= e4 – 1/7 ( 35 – 7 x1- x2) – 6/7(3- x2)= - 4/7
ce qui entraine e4 + x1 + x2 = 7, où encore x1 + x2 ≤ 7 ……(2)
Examinons ce qui se passe lorsque nous introduisons ces deux contraintes dans le domaine
délimitant l’ensemble des contraintes du programme (P)
7x1 +x2 = 35
1 : -x1 + 3 x2 = 6
2ième Coupe : x1 + x2 ≤ 7 X*=(9/2, 7/2) Z*=63
(0, 3) (4, 3) 1ière coupe : x2 ≤ 3
Base bi x1 x2 e1 e2 e3 e4
x2 3 0 1 0 0 1 0x1 4 1 0 0 0 -1 1e1 1 0 0 1 0 -4 1e2 4 0 0 0 1 6 -7Z -55 0 0 0 0 -2 -7
(5, 0)
Figure 3.3 : Résolution du programme (P) par la méthode des coupes de Gomory
5.4) Amélioration de la méthode
Une variable non entière peut générée plusieurs coupes différentes et il est intéressant de
choisir la meilleure. Pour cela, un critère de choix doit être fixé au préalable pour renforcer le
processus de résolution par cette approche.
Une coupe C est dite meilleure qu’une autre coupe C' si elle coupe profondément le polyèdre
convexe représentant l'espace des solutions.
En d'autres termes, une coupe C est dite meilleure qu'une autre coupe si et seulement si:
{ f kj ≤ f ' kj ∀ j ∈HB sauf pour un j '∈HB cette inégalité est stricte ¿ ¿¿¿
Où encore :
f k
∑j∈HB
f kj
>f ' k
∑j∈HB
f 'kj
La génération des différentes coupes de Gomory peut être généralisée en -coupes où est un
entier. En effet, reprenons l’égalité (1) précédente et multiplions ses deux membres par un
entier quelconque :
xk + ∑
j∈HBλ ([ akj ] + f kj) . x j
= [xk*] + fk (2)
Posons : fkj = [fkj ]+ f fkj
fk = [fk ]+ f fk
En remplaçant fkj et fk per leurs expressions respectives, nous obtenons :
xk + ∑
j∈HBλ [ akj ] x j+ ∑
j∈HB[ λ f kj ] . x j− λ[ x∗k ] −[ λ f k ]
= − ∑
j∈HBf λ f kj
x j + f λ f k
La partie de gauche doit être entière et il sera de même pour la partie de droite et on obtient :
− ∑j∈HB
f λ f kjx j + f λ f k ≤ f λ f k < 1
D’où : − ∑
j∈HBf λ f kj
x j + f λ f k ≤ 0
Où encore : − ∑
j∈HBf λ f kj
x j+ S = − f λ f k
Le nombre de coupes de Gomory que l’on peut générer sur une ligne est égal à (D-1) où D est
le déterminant de la partie de base B de la matrice (Ax ≤ b) associée à la solution optimale de
(Q). (Résultat à démontrer à titre d’exercice). En d’autres termes, on a : 0 ≤ ≤ (D-1).
La meilleure coupe est celle qui vérifie : Maxi r i où
ri =f λi f k
∑j∈HB
f λ i f kj
Un autre critère pour le choix de la meilleure coupe est celle qui possède la plus faible des
pénalités (même sens que celle que nous avons introduite dans la section précédente).
Dans l’exemple précédent D=22. Il s’agira donc de construire 21 coupes de Gomory
différentes.
=1 on aura la coupe: e3 - 7/22 e1 -1/22 e2= - ½ (1ière coupe trouvée) r1= 11/8
=2 on aura la coupe : e3 - 14/22 e1 - 2/22 e2= 0 et r2= 0
=3 on aura la coupe : e3 - 21/22 e1 - 3/22 e2= -1/2 et r3= 11/16
=4 on aura la coupe : e3 - 6/22 e1 - 4/22 e2= 0 et r4= 0
=5 on aura la coupe : e3 - 13/22 e1 - 5/22 e2= -1/2 et r5= 11/18
=6 on aura la coupe : e3 - 20/22 e1 - 6/22 e2= 0 et r6= 0
=7 on aura la coupe : e3 - 5/22 e1 – 7/22 e2= -1/2 et r7= 11/12
=8 on aura la coupe : e3 - 12/22 e1 - 8/22 e2= 0 et r8= 0
=9 on aura la coupe : e3 - 19/22 e1 – 9/22 e2= -1/2 et r9= 11/28
On notera qu’il est inutile de construire les coupes dont est paire car son ri correspondant est
forcément nul.
=11 on aura la coupe : e3 - 11/22 e1 – 11/22 e2= -1/2 et r9= ½
=13 on aura la coupe : e3 - 3/22 e1 – 13/22 e2= -1/2 et r9=11/16
=15 on aura la coupe : e3 - 17/22 e1 – 15/22 e2= -1/2 et r9= 11/52
=17 on aura la coupe : e3 - 9/22 e1 – 17/22 e2= -1/2 et r9= 11/26
=19 on aura la coupe : e3 - 10/22 e1 – 19/22 e2= -1/2 et r9= 11/29
=21 on aura la coupe : e3 - 15/22 e1 – 21/22 e2= -1/2 et r9= 11/36
La meilleure coupe de Gomory correspond à la valeur de = 1.
Remarque : Il existe d’autres approches de résolution d’un PLNE comme le Branch and Cut
qui est une méthode d'optimisation combinatoire pour résoudre des problèmes d'optimisation
linéaire en nombres entiers. Cette méthode est une hydridation entre l’approche de Branch and
Bound et la méthode des coupes de Gomory.
Le principe est de résoudre le programme linéaire associé (Q) à l'aide de l'algorithme du
simplexe. Lorsqu'une solution optimale est trouvée, et que l'une des variables n’est pas entière,
on utilise la méthode des coupes de Gomory pour trouver une contrainte linéaire satisfaite par
toutes les valeurs entières de la solution mais violée par la valeur fractionnaire. Si une telle
contrainte est trouvée, alors elle est ajoutée au programme linéaire de sorte que la résolution de
ce programme donne une solution avec moins de valeurs non entières. On répète ce procédé
jusqu'à ce qu'une solution entière soit trouvée (qui est alors optimale) ou jusqu'à ce qu'aucune
coupe ne puisse être trouvée.
À ce moment, la partie séparation et évaluation de l'algorithme commence. Le problème est
scindé en deux sous-problèmes, l'un en rajoutant la contrainte que la variable est supérieure ou
égale à la partie entière par excès de la solution intermédiaire, et l'autre en rajoutant la
contrainte que la variable est inférieure ou égale à sa partie entière usuelle (par défaut). Ces
deux nouveaux programmes linéaires sont résolus avec l'algorithme du simplexe et on itère la
procédure présentée précédemment.
Problème de flot
1)Position du problème
Soit G = (X, U) un graphe fini, orienté, connexe et sans boucles. Soient deux sommets
particuliers source s et puits p, c'est-à-dire, -(s)= +(p)= où - (s) représente l’ensemble des
prédécesseurs de s et +(p) l’ensemble des successeurs de p. Considérons l’application c définie
comme suit c : U R
u c ( u ) = cu où cu est la capacité de l’arc u.
Le problème du flot maximum dans le réseau R = ( X, U, c ) consiste à envoyer un flot (une
matière) d’un source s et de récupérer le maximum de ce flot au sommet puits p tout en
imposant une conservation de la matière au niveau de chaque sommet intermédiaire de ce
réseau (loi de KIRCHOFF) . Ce flot doit être réalisable, c'est-à-dire, sa valeur au niveau de
chaque arc ne peut pas dépasser sa capacité.
En d’autres termes, un flot est un vecteur de R m vérifiant.
∑u∈w+¿(x) f (u)= ∑
u∈w−¿ (x ) f (u)∀x ∈X¿
¿¿
¿ ……….(1)
Où w+(x) est le cocycle engendré par les arcs sortants du sommet x et w -(x) est le cocycle
engendré par les arcs entrants vers le sommet x. La relation (*) signifie que :
< f, w(x) > = 0 x X.
Pour une conservation totale, on crée un arc fictif ur = (p, s) de capacité infini.
Un flot f est dit réalisable sur R (X, U, c) s’il vérifie :
u U { ur } on 0 ≤ f(u) ≤c(u) ……………(2)
Un flot f est dit compatible sur R (X, U, a, b) s’il vérifie :
u U { ur } on a (u) ≤ f(u) ≤b (u).
Le problème du flot maximum sur R (X, U, c) consiste à :
{ Trouver f ∈ Rm
∑u∈w+¿( x) f (u )= ∑
u∈w−¿( x )f ( u)∀ x∈X ¿
0 ≤f (u) ≤ c (u ) ¿
f (ur )=Z (Max)
Si on dénote par x ij la quantité du flot sur l’arc (i, j), la contrainte de conservation de flot peut
s’exprimer sur la forme suivante :
∑j
x ji−∑i
xij=¿{ v sii= s
0 si i≠ p ,s− v sii= p
¿
Les contraintes d’intégrités s’expriment de la manière suivante : 0 ≤ xij ≤ cij
Le modèle mathématique associé au problème du flot maximum est :
(P) {∑jx ji−∑
ix ij={ v si i=s
0 si i≠ p , s−v sii=p
0 ≤ x ij≤ c ij
f (ur )=v (Max)
Il est facile de reconnaitre que ce modèle est un programme linéaire à variables bornées.
2) Notions de coupe et de chaîne améliorante
2.1) Notion de coupe
On appelle coupe séparant p de s et engendré par A X, un co circuit w+(A) tel que sA et
p A. La capacité d’une coupe est la capacité des arcs qui la constitue. En d’autres termes :
c()= ∑u∈
c (u)
Une coupe * est dite minimale si sa capacité est minimale. En d’autres termes, le problème de
la coupe minimale se formule comme suit :
(D) { Trouver une coupe❑¿
c (❑¿ )≤ c ( )∀ coupe séparant pde s
Ce problème (D) est un problème dual au problème primal (P). Considérons le réseau suivant :
Les différentes coupes associées à ce réseau sont :
1 = +{1}= {(1,2), (1,3)} de capacité c(1)=7+3= 10
2 = +{1, 2}= {(1,3) ; (2,3) ; (2,4)} de capacité c(2) = 7+1+2=10
3= +{1, 3}= { (1,2) ; (3,2) ; (3,4)} de capacité c(3) = 3+1+4=8
4= +{1, 2, 3}= { (2,4) ; (3,4)} de capacité c(4) = 3+1+4=6
La coupe de capacité minimale est 4.
2.2) Chaîne améliorante
Une chaine est dite améliorante par rapport à un flot si elle vérifie :
u + (u) < c (u).
u - (u) > 0
Où + représente l’ensemble des arcs allant de s vers p et - représente l’ensemble des arcs
dans le sens inverse.
Dans l’exemple précédent la chaine suivante = { (1,2) ; (1,3) ; (3,2) : (2,3) ; (2,4) ; (3,4)} est
améliorante par rapport au flot suivant : f = (2, 3, 0, 0, 2, 3)} de valeur 5.
2
3 2
1 4
7 1 1 4
On remarquera que nous avons que des arcs allant de s vers p dans cet exemple.
3)Aspects théoriques
3.1) Lemme
Soit (A, T) une partition de l’ensemble X tel que s A et p T. Pour toute coupe = + (A)
de capacité c () et pour tout flot réalisable alors (ur) ≤ c ().
En effet, considérons un flot f réalisable et A une partie de X vérifiant s A et p A, alors :
est un flot ∑
u∈w+¿(A) f (u)= ∑u∈w−¿ ( A) f (u)= ∑
u∈w−¿ ( A)⋱ {ur }f (u) ¿
¿ ¿
¿¿
¿ + f(ur)
f (ur )= ∑
u∈ w+¿ ( A ) f (u )− ∑u∈w
−¿ ( A)⋱ {ur} f ( u)¿
¿¿
¿ ≤ ∑
u∈w+¿ ( A ) f (u) ¿
¿
Comme est réalisable f (u )≤ c (u )u U {ur}
Il s’ensuivra que f (ur )≤ ∑u∈w+¿ ( A ) f (u) ≤ ∑
u∈w+¿ ( A )c ( u)=c() avec¿¿¿
¿= + (A)
3.2) Théorème :
Un flot est maximum si et seulement s’il n’admet pas de chaine améliorante entre s et p dans le
réseau R (X, U, c).
La condition nécessaire est évidente car si une telle chaîne n’existe pas alors on ne peut pas
améliorer la valeur du flot courant.
En revanche, considérons un flot réalisable f * n’ayant pas de chaîne améliorante alors il
existerait un cocycle = (A) vérifiant :
u + f * (u)= c(u)
u - f * (u)= 0
Nous avons :
f∗(ur )= ∑u∈w+¿ ( A ) f∗( u)− ∑
u∈w−¿ ( A)⋱ {ur }f ∗( u)= ∑
u∈w+ ¿ (A) f ∗(u )= ∑u∈w +¿ (A) c (u )=c ( ¿) ¿
¿ ¿
¿¿
¿ ¿
¿
¿ = +(A) est une coupe séparant p de s. Par conséquent, f *(ur ¿est maximum en vertu du
Lemme précédent.
Remarque : Si toutes les capacités des arcs sont entières alors il existe un flot entier maximum (
à démontrer ).
4) Algorithme de Ford et Fulkerson
On démarre avec une solution réalisable (flot réalisable de départ, par exemple, un flot
nul) et on l’améliore d’itération en itération. A chaque itération, on détermine par une
procédure de marquage une chaine améliorante. Si une telle chaine existe alors le flot courant
peut être amélioré si non on exhibe une coupe séparant p de s qui est minimale et dans un tel
cas le flot devient maximum.
La procédure de marquage :
On marque le sommet s d’un signe ( + ) et on pose (s) = + ( la quantité disponible au
sommet s). On pose : C+ = C- = øet Y= {s} .
S’il existe un arc u= (x, y) U, avec x marqué et y non marqué vérifiant (u ) < c(u) alors on
marque le sommet y par ( +x ) et on pose (y) = min{(x), c(u)-(u)}.
- C+=C+{u} et Y=Y{y}
- S’il existe un arc u=(y, x) U x marqué et y non marqué vérifiant (u )> 0 alors on
marque y d’un signe ( - x ) et on pose :
(y) = min{(x), (u)}, C-=C- {u} et Y=Y{y}
On applique cette procédure jusqu'à sa fin. Deux cas se présentent :
On a marqué le sommet p dans ce cas on a déterminé une chaine améliorante C= C+ C- et le
flot est amélioré de la manière suivantes :
f k+1(u)= {f k (u )+ε∀ u∈C+¿¿ f k (u )−ε∀ u∈C−¿ ¿ f k (u )∀ u∉C
Où k(u ) est la valeur du flot sur l’arc u à l’itération k et ε = (p) = min{(x)/ x Y}.
L’algorithme de Ford-Fulkerson se résume comme suit :
(0) Démarrer d’un flot réalisable (par exemple, un flot nul, un flot au jugé ou un flot
complet).
(1) On marque le sommet s d’un signe ( + ) et on pose (s) = + ( la quantité disponible au
sommet s). On pose : C+ = C- = øet Y= {s}.
2) Utiliser la procédure de marquage décrite plus haut jusqu’à sa fin.
Tester si p Y
Si oui, aller en 4)
Si non, aller en 3)
3) On a déterminé une chaîne améliorante C= C+ C- et le flot courant est amélioré. Aller en
1).
4) Le flot courant est maximum et on a déterminé une coupe minimale *= + (Y) où Y est
l’ensemble des sommets marqués à l’aide de la procédure décrite ci-haut.
Pour accélérer le processus de résolution par l’algorithme de Ford-Fulkerson, il est
recommandé de faire passer un flot " au jugé " puis de chercher un flot complet qui sera ensuite
utilisé comme solution de départ dans l’algorithme de Ford et Fulkerson. Un flot au juge est
obtenu en envoyant un flot à partir de la source s et on la distribue de sommet en sommet tout
respectant la propriété de conservation de flot en chaque sommet. Un flot est dit complet si
pour tout chemin de s à p contient au moins un arc saturé u, c'est-à-dire, f(u)=c(u).
Considérons le réseau suivant:
Supposons l’ordre des arcs de ce réseau sont comme suit : u1=(1,2), u2=(1,4), u3=(2,3), u4=(2,4),
u5=(4,5), u6=(5,3), u7=(3,6) et u8=(5,6).
En démarrant du flot au jugé f 0= (2, 1, 1, 1, 2, 0, 1, 2) R8 de valeur v(f 0)= f 0 (ur)=3. Les
différents chemins de ce réseau sont : C1={ u1, u3, u7 }, C2={ u1, u4, u5, u8 }, C3={ u2, u5, u6, u7 } et
C4={ u2, u5, u8 }
Nous constatons que les chemins C2 et C4 possèdent au moins un arc saturé qui est u8. Pour le
rendre complet, il faudrait saturer l’arc u1 en augmentant la valeur de son flot d’une unité et de
distribuer cette valeur sur les arcs u3 et u7 pour assurer la conservation du flot sur les sommets 2
et 3. Il faudrait également saturé l’arc u6 en l’augmentant d’une unité. Le flot complet obtenu
est : f 1= (3, 2, 2, 1, 3, 1, 3, 2) R8 de valeur v(f 1)= f 1 (ur)=5.
On applique l’algorithme de Ford-Fulkerson en prenant comme flot de départ f 1 (étape (0)).
1ière Itération : On marque 1 d’un (+) et on pose : (1) = + , C+ = C- = øet Y= {1}.
[3]
[3] [3]
[1] [1] [.] représente la capacité de l’arc
[3] [4] [2]
1
2 3
6
4 5
L’arc u2 =(1, 4) est tel que 1 est marqué, 4 ne l’est pas et f 1 (u2)= 2 < c(u2)=3. Nous marquons
le sommet 4 d’un (+1), (4)= Min {+, c(u2)- f 1 (u2) = 1}=1, C+ ={u2} Y={1, 4}.
L’arc u4=(2,4) est tel que 4 est marqué et 2 non marqué et f 1 (u4)=1>0. Nous marquons le
sommet 2 d’un (-4), (2)= Min {1, f 1 (u4) = 1}=1, C- ={u4}et Y={1, 2, 4}.
L’arc u3=(2,3) est tel que 2 est marqué, 3 ne l’est pas et f 1 (u3)=2 < c(u3)=3. Nous marquons le
sommet 3 d’un (+2), (3)= Min {1, c(u3)- f 1 (u3) = 3-2= 1}=1, C+ ={u2, u3} Y={1, 2, 3, 4}.
L’arc u5=(4,5) est tel que 4 est marqué, 5 ne l’est pas et f 1 (u5)=3 < c(u5)=4. Nous marquons le
sommet 5 d’un (+4), (6)= Min {1, c(u5)- f 1 (u5) = 1}=1, C+ ={u2, u3, u7} Y={1, 2, 3, 4, 5}.
On ne peut plus marquer de nouveaux sommets. Terminer le flot f 1 est maximum en ur. Nous
avons exhiber une coupe *= + (Y)={u7, u8} avec Y={1,2,3, 4, 5} de capacité minimale c(*)
= c(u7)+ c(u8)= 3+2= 5 = f 1 (ur).
5)Théorème de la coupe minimale
Soit R = (X, U, C) un réseau ou G = ( X, U, ) est un graphe fini connexe et sans boucles, la
valeur de flot maximum entre s et p est égale la capacité d’une coupe minimale séparant p de s.
En effet d’après lemme (2, 4) on a : , flot réalisable de s à p de valeur v() et coupe
séparant p de s alors v () ≤ c(). Il s’ensuit que le problème du flot maximum possède une
solution optimale; soit * cette solution.
En appliquant algorithme de Ford-Fulkerson à ce flot *, la procédure de marquage s’arrête à la
première itération sans marquer le sommet p. Soit Y l’ensemble des sommets marqués on aura :
s Y et p Y.
u w+(Y) on a : * (u) =c (u).
u w- (Y) on a : * (u) = 0.
Or,
f∗(ur )= ∑u∈ w+¿ ( Y ) f∗(u )− ∑
u∈w−¿(Y )⋱ {ur } f∗(u )¿
¿¿
¿
¿ ∑u∈w+¿ (Y ) f∗( u)= ∑
u∈w+ ¿ (Y )c (u)=c ¿¿
¿ ¿
¿
= c(*) avec *= w+(Y)
6. Problème de flot maximum de cout minimal
Soient R = (X, U, c, k) un réseau où G = ( X , U ) est un graphe fini, connexe sans
boucles et s , p deux sommets particuliers. L’application c est représente la fonction sur la
capacité des arcs et k est l’application coût unitaire définie comme suit :
k : U R
u k(u) coût unitaire sur l’arc u
Trouver f ∈Rm
∑u∈w+¿(x) f (u)= ∑
u∈w−¿(x ) f (u) ∀x ∈X¿
0≤ f (u )≤ c (u) ¿
f (ur )=Z ( Max )
k (u ) f (u ) minimum
Nous constatons que ce problème est multi objectif. L’algorithme de Roy permet de le résoudre
en utilisant le graphe des écarts. Son principe est comme suit :
On démarre d’un flot nul, puis on construit un flot de valeur v1 (v1 ≤ v*) de coût minimum
parmi tous les flot de valeur v1, puis un flot de valeur de v2 (v2 ≤ v1) de coût minimum parmi
tous les flots de valeurs v2 et ainsi de suite jusqu’à obtenir un flot de valeur v*.
A chaque itération, on construit le graphe des écarts associé au flot courant et on recherche le
plus court chemin (au sens coût minimum) de s à p et en modifiant, dans le réseau R, le flot
passant sur les arcs de ce chemin.
Soit f un flot sur R. Au couple (G, f) on lui associe le graphe des écarts Ge(f) =(X, Ue(f))
comme suit :
A tout arc u=(x, y) on lui associe dans Ge(f) :
- Un arc u=(x, y) de capacité cexy= cxy – fxy de coût unitaire ke
xy=kxy si f(u) < c(u)
- Un arc (y, x) de capacité ceyx=fxy de coût unitaire ke
yx= - kxy si f(u) > 0
L’algorithme s’énonce comme suit :
1) Soit 0 le flot nul initial de valeur v(0) =0 le graphe d’écart Ge(0) = G (identique au
graphe G) poser i = 0.
2) Rechercher un chemin de coût minimum allant de s à p dans Ge(i)
Si un tel chemin n’existe pas alors le flot obtenu est le flot recherché
Si non aller en (3).
3) Au chemin trouver dans Ge(i) lui correspond à une chaine améliorante dans G.
Améliorer le flot dans G d’une quantité maximal i permise par cette chaine. D’où le
nouveau flot (i+1) de valeur v(i+1 ) = v ( i ) + i
4) Tracer le graphe des écarts Ge(i+1) associé à ce nouveau flot. Poser i =i+1 et aller en
(2)
Remarque : La complexité de cet algorithme est 0 (n2 v) où v est le nombre d’améliorations du
flot.
La valeur du flot dans le pire des cas est en v améliorations (si les capacités sont entières)
et n2 est la complexité du problème du plus court chemin (Djikstra, Bellman etc.) dans Ge.
Exemple : Soit le réseau suivant :
:
1 ière itération : On a : G0e = G , f o≡ 0 , v ( f 0 )=0 .
Le plus dans chemin dans G0e
est {(1, 2) ; (2, 3) ; (3, 4) ; (4, 5)} de longueur 11. On améliore
la valeur du flot d’une quantité égale à 200 et on obtient le flot 1=(200, 0, 200, 0, 200, 0, 200)
de valeur v(1)= 200
Le graphe des écarts G1e
correspondant à 1 est :
2
(200, 0) (200, 13)
(200, 2)
(200, 9) (300, 0)
(400,2) (200,16)
Les valeurs sur les arcs représentent respectivement la capacité et le coût de l’arc. La numérotation
des arcs est comme suit : u1=(1,2), u2=(1,3), u3=(2,3), u4=(2,4), u5=(3,4), u6=(3,5) et u7=(4,5).
2
1
4
35
2
0 (200) 13 (0)
1 - 2 (200) 4
2 (0) - 9 (200) 0 (200) 0 (100)
3 16 (0) 5
2ième itération : f2= (200, 100, 100, 100, 200, 0, 300). Le graphe des écarts associé à f2 est :
2
0 (200) 13 (0)
1 - 2 (200) 4
2 (0) - 9 (200) 0 (200) 0 (100)
3 16 (0) 5
2
0 (200) +2(100)
-13 (100) 4
3 5
4. Problème du flot compatible (canalisé) :
Soit R = (X, U, b, C) un réseau ou
U R U {- µ } b (Ur) = -µ
U R U {+ µ } c (Ur ) = +µ
Avec u U b (u) ≤ c (u)
On flot est dit compatible sur le réseau Sissi u U ; b ( u ) ( u ) ≤ c ( u ) .
Peut modifiant l’algorithme de Ford et fulkerson on déterminer un flot compatible
maximum et cela en modifions la procédure de marquage inverse à ϶ ( y , x ) ≥ 0 on marquage y
d’un ( - K ).
……………….18.
T écrème d’Hoffman :
Une C, N, S pour qu’il existe un flot compatible réalisable sur R = (X, U, b, C) et que
A C X : ∑ b(u) ≤ ∑C (u)
wEw (A) ¿ ¿
C N :
Soit un flot compatible
A C X: ∑(u) ¿ ∑(u)
uw (A ) ¿ ¿
De plus il vérifie : u U u {Ur}
B (u) ≤ (u) ≤ C (u) il soit que :
∑ b ( u ) ≤ ∑ ( u ) = ∑ ( u ) ≤ ∑ C ( u ).
Uw-(A) Uw-(A) Uw+(A) Uw+(A).
C.S : Algorithme de construction d’un flot compatible :
Etant donné un flot , nom nécessitent réalisable , le principe consiste à associé à un
réseau R en modifiant les valeurs des b ( u ) et C ( u ) de manier à ce que soit réalisable sur R
puis modifier le flot sur R en utilisant l’algorithme de Ford et Fulkerson pour se rapproche
d’un flot réalisable sur R .
Soit un flot sur R = (X, U, b, C) on leu I ( ) = ∑ e (u ) ouU U
( u ) = { 0 pour tous les arcs vérifient b ( u ) ( u ) ≤ ( u )
{b ( u ) - ( u ) si ( u ) ≤ b ( u )
{ ( u ) – C ( u ) si ( u) ≥ C( u ) .
Principe de cette algorithme est de réduire cette quantité I ( ) jus ‘qua la rendre nulle
5.Principe de l’algorithme :
Soit on flot q q de R.
S’il existe un arc u = (x, y) U T q (u) ≥ c(u), Alors en (2).
S’il existe un arcs V = ( x , y ) U T q ( v ) ≤ b ( w ) , Alors aller en ( 3 ) .
Si non terminer , le flot est compatible poser = x , p = y , = ( w ) – C ( v ) µ = +1 ax aller
en ( 4 ) .
Poser = y , p = x = b (v) - (v) µ = -1 aller en (5).
Poser = (p, ) on consiste R = (x, w) {Ur}.
Avec b (u) {b (u ) si(u)≥ b(u)(u)si(u)≤ b(u)
C(u) {C (u) si (u) ≤ C (u).
{ (u) si non
On définit { (u) = { (u) u u est un flot réalisable.
{0 v = u r sur R allé en (5).
6. Application la variante de l’algorithme
Fet Fulkerson à partir de et R (on poser a ( ) = ).
Si on termine sans manquer p.
Terminer le problème ne possède pas de flot compatible.
si un termine avec p y on pas changer de flot, soit le nouveau flot sur R .
Si ( u ) - µ ( u R ) ≤ b ( v ) ou ( v ) - µ ( u R ) ≥ c ( v ) aller en ( 5 ).
Si non on définit le nouveau flot sur R.
(u) ={ K (u )U U−{v }K (v )−∝ K siU=valler en (1)
Ex Outrer la finitude est la convergence e cet algorithme.
Exemple :
Soit le réseau.
Soit on flot nul poser v = (3, 4).
(v) = 0 ≤ (v) = 2 on poser = 4 et p = 3.
= 2 / ∝ = - 1 on construit R.
(o
,2)
…………….
Applique l’algorithme de Fet Folksong (4) = 8 = 2.
Calcul (v) = ∝ (Ur) = 0 + ( 1 ) = 1 ≤ 2 alors on utiliser encoure l’algorithme Fet Fléron.
……………22
(v) - ∝ (Ur) = 0 + 2 = 2 = b (v). Le nouveau flot associe à R le flot est compatible.
Terminer : …………………23
7. Problème compatible de cout minimum :
Soit R= (x, u, K, b, c) un réseau ou
R = U R.
U R(u) l’application cout unitaire.
1
4 3
2
B(u) c(u)(o,1)B(u) c(u)
(O, 1)
B : U R U { -∝}.
C : U R U {+∝} v u U b (u) ≤ C (u).
Le problème de flot compatible de cout minimum se formule :
Trouver R m flot
B(u) ≤ (u) ≤ C (u) U U u {UR}
∑ K (u). (u) = K (à minimum) u U
On a (K) ∝ ≥ 0 B ≥ 0
0 T + ∝ b - B C = w (max)
Exemple :
Le problème se ramenant à un problème de flot compatible de cout minimum.
Problème de plus conte chemin de à p dans = (x, u, b) on lui associe Uu réseau R
= (x, v, K, b, c).
U = U w {Ur} Ur = (p, )
(u) = K (u) U U
0 si U = Ur b (u) = 0 U U
1 U Ur
C (u) = +µ u U w { x } .
b de flot maximum de à p dans R = ( x , u , c )
Ur = (p, ) on lui associe un réseau.
C = (X, U u {Ur}, K, b, c)
( w ) = 0 w U b ( u ) = 0 u Uu { Ur }
11 w = Ur c (u) = c (u4) u Uu {Ur }
8. Le problème de transport :
Soient n origine et n destinations , le problème n existe à cheminer la marchandise de n
origine ( x , u , x m) aux n destinations ( y , x , y1 ) tout en maximum le cout de transport , le
cout d’ache mini ment d’un origine à une destination j et K j une offre ai est disponible au
niveau de la source xi et une demande bj est formulée au niveau de la destination y j .
La formulation mathématique est : soit tj la qualité à transporter de la source xi vers la
destination.
∑n j=1 x I j ≤ ai I T, n
∑mi=1 x i j ≥ bj j = T, n
Z = ∑ ∑ Kij x j
Ex :
formule on terme de flot compatible de cout min le problème de transport se ramène ou
problème de flot compatible cout minimum sur le réseau R = ( x , u , K , b , c ) poser X1 =
{ X1, …………X m }origine.
…………. Yn} distinctives
X = X1 U X2 U { , p } on ajute un sommet source « » et un sommet puis p
U1 = {(xi, yj) / i = T, 1}.
U2 = {( , xi) / i = T, n }.
U3 = {(yj, p) / j = T, n}.
U = U1 u U2 u U3 u = (b, c, K)
C (u) = Kij u = (xi, y J) U1.
Si non
0
(u)= bj u = (yj, p) U3
0 si non.
Ci u = (i , xi).
(u) = µ si non.
……………..26.
9. L’algorithme des arcs non confirmés out of kitter algorithme :
Soit le problème de flot à cout min sur le réseau R = ( x, U { 01 } , K , b , c )
Min Ƶ = ∑ Kij x ij I i
Xij ≥ b i j ≥ 0 xi
Xij ≥ - c ij ij ij
Le pro dual est:
Max = ∑ bij, dij -∑ eij i.j
j - I + dij - ȣij ≤ Kij.
Dij, ȣij ≥ 0 iqq.
En utilisant les thermes des écarts complémentaires
On aura xij ≥ 0 j - i + dij - ij = Kij.
Dij ≥ 0 xij = bij.
ȣij ≥ 0 xij = cij.
Ces conditions sont équivalentes (à montrer).
xij = bij j - i ≤ Kij
Bij ≤ xij ≤ cij j - i = Kij
Xij = cij - i ≥ Kij.
On encore :
Kj + I - j ≥ 0
Kij + I - ≥ j = 0
Kij + I - j ≤ 0.
Cette condition sont appelé Condition de conformité (Kittery condition).
Les représente sous forme d’un diagramme appels diagramme de conformité pour
chaque arc.
….
…………28
Point représentée sent (xij, Kij, + i - j) il est accessoire que les valeur du flot sur
chaque arc soit être conforme et aller rendre conforme on opérant un changement adéquat dont
la valeur du flot sur cette arc à traverse la constriction d’une chaine augmentant si ne telle
chaine n’existe pas en modifier les valeurs des multiplication sur les sommets choisis .
Algorithme : (T p)
Choisir des valeurs arbitraires aux i (i = T, n) pour chaque sommet i du graphe (par
exemple 0).
Démarrer d’un flot réalisable de déport (flot nul).
choisi un arc non-conforme reliant le sommet et le sommet t si cet arc est non-
conforme car la valeur de son flot se situe à gouache de la droit de conformité alors
l’autre cas, il restera ( , t) dans les 2 cas, il arc en question sera ramené proche de la
ligne de conformité en augmentant la valeur du flot dans le réseau de à t .
S’il n’existe pas un tel arc, terminer tous les arcs sont conformes, la solution courante est
optimale sont si non aller en (2).
Déterminer une chaine augmentant de à p, cette chaine contiendra des arcs direct non
formes dent le flot est à gauche de la ligne de conformité (aux points d’intersection avec xij =
cij) puis des arcs inverses non-conformes.
Des arcs conformes qui se situent sur la ration horizontal de la ligne de conformité ce
point d’intersection avec xij = cij puis des inverses non conformé et dans le flot situe à droit
de la ligne de conformité enfin des arcs confirmes sur la Portici horizontal de la ligne de
conformité au point intersection xij = bij cette chaine sera construite on procédure de marquage
qui affecte marques à un sommet i ( a i , si ) ou ai est en sommet prédécesseur de i dans la
chaine sur de , si est la quantité maximal au flot que l’apport envoyer il est alleu pour un arc
direct ( ai , i ).
Si K ( ai ,i ) + ai - i ≤ 0 alors si C( ai , i ) – x ( ai , i ).
Si K( ai , i ) + ai - i ≥ 0 alors si b ( ai , i ) – x ( ai , i ) .
Pour un arc incorrect (i, ai)
a). Si K( I , ai ) + i - a ≥ 0 si = x(i , ai ) – b( i , ai )
B). Si si = x (i, ai) – ≤ 0 si = x (i, ai) –c (I, ai)
Si one chine augment ante put être trouvère on change la valeur de flot le m changement
se fait pour les arcs Nen confirme et on répète ( étape ( 1) jusqu'à à ne plus avien de chaine
augmentant si aller en ( 3 ) .
Examiner les arcs qui relient les sommets non marqué.
Pour les arcs directs et pour lequel K( i , j ) + i - j ≥ 0 et bij ≤ xij ≤ cij on calcul
comme la plus petite valeur des K( i , j ) + i - j .
Pour les arcs indirects et pour lequel K (i, j) + i - j ≤ 0 et bij ≤ xij ≤ cij on calcul comme
la plus petite valeur des K (i, j) + i - j.
Poser b = min { 1 , 2 } ajouter cette quantité à tous les multiplication i de chaque
sommet si ne peut pas ôter établi par cette règle , on utilise puron ce déterminer ,pour on x ( t
, ) = b ( t , ) alors 2 = { K ( t , ) + ( t ) - ( s ) }.
On arc (s, t) non-conforme et x ( , t) = c ( , t) .
Alors = { K ( , t ) + ( ) - ( t ) } Aller en ( 1 )
…………………………..32
Itération 1 :
1 = 2 = 3 = 0
X12 = X23 = X32 = X31 = 0 .
Arc (1, 2) K (1, 2) + 2 - 2 = - 420.
Est pas confirmé poser t = 1, = 2
………………………32
On détermine une chaine mentant de à t marque le sommet 2(1, 5).
On détermine une chaine mentant de à t marque 3(2, 1).
On marque le sommet 1(3, min {1, 4} = 1) augmente la valeur de flot sur le règle 3
2.
Le nouveau flot …………………….33
Itération 2 :
L’arc (1, 2) est un nom conforme car b12 ≤ x12 ≤ c12 ≤ c13 et K12 + 1 - 2 = -4 ≠ 0
La valeur du flot situé à gauche de la ligne de conformité. On pose t = 1, = 2.
On marque le sommet 3
.
S3 = 0 le sommet marqué et 2.
Les sommet non marqué sont 1, 3 l’ore ( 2,3 ) est le seul arc direct vérifiant X23 = b23 et
b23 + 2 - 2 = 3 ≥ 0 .
1 = 3.
Le seul arc indirect vérifient les conditions est ( 1,2 ) b12≤ X12 ≤ C12 K12 + -
= -4.20 .
2 = 4. = mim {3,4} = 3
.on poser 1 = 0 + 3 = 3, 2 = 0 = 0 + 33 = 3.
Itération 3 :
1 = 3 , 2 = 0 , 3 = 3.
Arc (1,2) K(1,2) + 1 - 2 = -4+3 = 1≠ 0.
Non confirme Ƶ = 1 , = 2, marque la sommet 2(1,4 ) est on marque le sommet 3( 2,4 )
enfin on marque le sommet 4( 3,3 ) augmente la valeur du flot sur la chaine de 3 unité
Xij
Itérations 4 :
1 = 3, 2 = 0, 3 = 3.
2 = 4, X23 = 4 , X32 = 0, X31 = 4.
Arc (1,2), K(1,2) + 1 - 2 = -1 ≠ 0.
Marque le sommet 2(1,1).
Marque le sommet 3(2,1).
À prendre s’arrête.
(Les 2 sommets marqués et un non marqué).
N examine arcs reliant les sommets marqué et les sommets non marqués l’arc (3,1) est
arc direct.
L’arc (1,2), = min {+µ , 1} = 1 vérifier bc x cc K(1,2) + 1 - 2 = -4 + = -1≤ 0
1 = 4, 2 = 0, 3 = 3
Itérations 5 :
= 4, = 0, = 3.
L’arc (1,2) K(1,2) + 1 - 2 = -4 + 4.0=0.
Est conforme l’arc (2,3) est l’arc (3,2) non = K(3,2) +1-2=1+3=4≥0
t=3, = 2
On marque le sommet 2(3,1) puis on marque le sommet 3(2,1)
232 une chaine augmentant.
On augmentant la valeur du flot d’une unité
L’arc (3,2)
X(3,2)
Itération 6 :
1 = 4, 2 = 0, = 3
L’arc (3,2) K(3,2) +3 - 2 = 1+3-0=4≥ 0 est conforme X32 = 1 / b32.
Arc C(3,1) conforme
Dans les arcs sont conformes :
X12 = 4
X23 = 5 xij
X32 = 1
X31 = 4
10. Formulation « Arc – chemin » du problème du lot maximum :
Rappel :
Soit A = (a, u) i=t , nv=t , m la matrice d’incidence sommet –arc de G
U e ( i ) = { u V / aiu = + 1} .
U- ( i ) = { u U / aiu= -1 }.
Les Lois de conservation aux somme s’erveut
A - = 0
Problème de flot maximum à cout min se formule
Trouver ℮HR
A℮ + 0
℮ ≥ b
-℮ ≥ -c
K℮ - Ƶ ( 1, )
La matrice A( UR HR ) l’ensemble des flot sur G constitue le noyau de , c’est un
arc dons un sous espace vectoriel de VR et sa dimension d’in ( ) + Vg ( A) = m .
Si G possède p. composantes connexes on q rg (A) = n-pet par suit d’in ( ) = m-n + p = V (G)
nombre cyclomatique de G.
Exercice :
Monter que tous flot ℮ = (℮1, …………… ℮n) peut se dé composer en une somme de
D (G) cycles élémentaires indépendants des scalaires ℮ = j, ¿ , + …….. + …………… + d
D (n , v (G ) ) .
Ou di sont des scalaires et ¿ sont de cycles élémentaires.
EXERCICES
Série n°1
Rappels PL, TG et Modélisation
Exercice 1 : Soit le programme linéaire P suivant
Max z = 4 x1 + x2
x1+ x2 ≤ 10
2 x1+ 6 x2 ≤ 48
3x1+ x2 ≤ 24
x1, x2 ≥ 0
1) Résoudre graphiquement P8
2) Résoudre P . Discuter selon l’existence de solution au programme linéaire P
3) Ecrire le programme dual D de P
Exercice 2 : On considère le graphe ci-contre:
1 2
4
5 3
Donnez les successeurs, les prédécesseurs et les degrés de chaque sommet
Donnez sa matrice d’adjacence.
Donnez sa matrice d’incidence.
Ce graphe comporte-t-il des circuits? Si oui, déterminez-les.
Donnez les composantes fortement connexes de ce graphe.
Exercice 3
Montrer que le problème de la recherche du nombre chromatique d’un graphe G=(X, U) peut se
modéliser comme un programme linéaire.
Indication : Numéroter les couleurs de 0 à k où k= Max dG(x), x X. Considérer les variables
xi comme étant le numéro de la couleur associée au sommet i
Exercice 4
Une entreprise fabrique et vend un produit. Supposer que n sites ont formulé un besoin pour ce
produit. Sur un horizon de planification, une demande di est estimée au site i, i=1, …, n et doit
être satisfaite. La construction de l’usine sur le site i coûte fi unités monétaires. L’implantation
de l’usine sur le site i permet la planification de ki unités sur cet horizon. La charge fixe pour
l’installation allant du site i au site j est de fij unités monétaires. Le coût de transport d’une
unité du site i au site j est cij unités monétaires.
Le problème est de déterminer un sous ensemble de site pour implanter les usines et de
proposer un plan de transport du produit sur l’horizon de planification qui minimise le coût
total constitué des coûts de construction des sites, d’installation des routes et les coûts de
transport du produit permettant la satisfaction de la demande.
Formuler et modéliser ce problème.
Exercice 5 : Dans une station de service bien équipé, plusieurs employés peuvent agir
simultanément pour servir le même client. Les opérations nécessaires sont :
Code Désignation de l’opération Durée Contraintes de précédences
A Arrivée du client 30 -
B Choix de la catégorie des produits 10 A
C Remplissage du réservoir d’essence 120 B
D Ouverture du capot 15 A
E Contrôle de la pression des pneus 80 A
F Nettoyage du pare-brise 20 A
G Préparation de la facture 45 C, I
H Payement de la facture 25 G
I Contrôle du niveau d’huile 60 D
J Ajout d’huile 25 B , I
K Remplissage radiateur 50 D
L Ajout d’eau distillée dans la batterie 30 D
M Fermeture du capot 5 J, K, L
N Gonflage des pneus 100 E
O Essuyage du pare brise 15 F
P Départ du client 10 C, H, M, N, O
1) Modéliser ce problème comme un graphe où les sommets sont des événements et on
dira qu’il existe un arc entre l’évènement i et l’évènement j si et seulement si (i, j) est
une opération du projet.
2) Quelle est la durée minimale pour terminer ce projet ? (Utiliser un algorithme que vous
aviez étudié en théorie des graphes) ?
Exercice 6 : On souhaite créer un réseau d’interconnexions électriques dans un pays en voie de
développement entre 6 villes, notées {1, 2, ..., 6}. Une étude a été menée sur les différents coûts
de constructions entre ces villes; on le donne sous forme de la matrice suivante (le coefficient
ai,j représentant le coût de construction entre les villes i et j):
0 10 20 30 ∞ ∞10 0 20 30 ∞ 5020 20 0 10 50 7030 30 10 0 55 30
∞ ∞ 50 55 0 60∞ 50 70 30 60 0
1 Construisez le graphe représentant ces villes, leurs liens et le coût de la construction de ce lien.2. A quel problème classique de théorie des graphes ce problème se ramène-t-il?3. Résoudre ce problème par un algorithme classique. Donnez sa complexité
Exercice 7 : Déterminer la complexité algorithmique des algorithmes suivants:
1. Algorithme de multiplication matricielle de matrices carrées n × n.
2. Algorithme de détection du plus grand élément dans une liste de n ´éléments.
3. Algorithmes de répartition des sujets d’examens dans une classe de n étudiants:
a- La première façon est de transmettre une unique pile de sujets, avec pour consigne de donner
la pile à un voisin qui ne possède pas de sujet.
b- La seconde est de donner une pile en précisant aux étudiant de transmettre deux piles,
chacune d’elles à un voisin n’ayant pas de sujet.
Dans les deux cas, on considérera une notion de ”voisins” suffisamment large pour que cela ne
pose aucun problème.
Série n°2
Programmation en nombres entiers et Programmation en 0-1
Exercice 1 : Résoudre graphiquement les programmes linéaires en nombres entiers suivants :
a) Max z = x1 + x2
2 x1+ 5 x2 ≤ 11
x1, x2 N
b) Max Z = 10 x1 + x2
2 x1+ 5 x2 ≤ 11
x1 ≤ 5
x1, x2 N
c) Max Z = 10 x1 + x2
2 x1+ 5 x2 ≤ 11
x1 ≤ 5
x2 1
x1, x2 N
Exercice 2 : Montrer graphiquement que le programme suivant n’a pas de solution
Max Z = 2 x1 + x2
10 x1+ 10 x2 ≤ 9
10 x1 + 5x2 1
x1, x2 N
Faire les vérifications par
a) Branch and Bound (donner l’arborescence des solutions)
b) Méthode des coupes
Exercice 3 : Soit le programme linéaire (P) en nombres entiers suivants :
Min Z = x1 - 2 x2
2 x1+ x2 ≤ 5
-4 x1 + 4 x2 ≤ 5
x1, x2 N
1) Résoudre (P) par l’algorithme de Branch and Bound par :
- La stratégie ‘profondeur d’abord’
- La stratégie de la règle de branchement au sommet ayant la plus faible
pénalité
2) a) Résoudre (P) par la méthode des coupes de Gomory. Faites une interprétation
graphique
b) Vérifier qu’il existe 11 coupes différentes que l’on déterminera. Donner la meilleure
coupe (ne pas résoudre le problème).
Exercice 4 : Résoudre par BALLAS les programmes en 0-1 suivants :
a) Max Z = x + 2y – 3 z
20 x + 15 y – z £ 10
12 x - 3 y + 4 z £ 20
x, y, z {0, 1}
b) Min Z= -3 x – y + z + 4t + 5 u + 2 v
6 x – 4y -2 z - 3t - 8 u + 2 v 1
- 8x +7y +3 z + 3t - 4 u - 4 v £ 1
5x - y +2 z + 2t + u - v £ 2
2x +2y + z + 7t + 3 u +2 v £ 6
x, y, z, t, u, v {0, 1}
Exercice 5 : Considérer le problème du sac à dos en 0-1 suivant :
Obj pi vi
1
2
3
4
5
8
6
2
3
2
80
48
14
18
10
11 Max
a) Formuler comme un programme linéaire en 0-1
b) Résoudre par Ballas
Exercice 6 : Un agent immobilier dispose de 4 acheteurs pour 4 sites. L’acheteur i est prêt à
payer pij pour le site j. Il désire connaître l’affectation des acheteurs aux sites de manière à
maximiser ses recettes. La table suivante résume les différents prix proposés par les acheteurs
pour chacun des sites :
s1 s2 s3 s4a1 6 7 6 2a2 0 5 8 1a3 5 10 6 5a4 2 7 12 4
Modéliser ce problème comme un programme linéaire en 0-1. Résoudre par Ballas
Exercice 7 : Résoudre le programme suivant :
Max Z= x +2 y + 5 z
|- x + 10 y -3 z | 15
2 x + y + z £ 10
x, y, z 0