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