CoursROPonts PDF

Frédéric Meunier
Introduction à la recherche
opérationnelle
13 juillet 2017
ii
Table des matières
1 Généralités 1
I Fondements 7
2 Bases 9
2.1 Graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Retour sur les ponts et sur le voyageur . . . . . . . . . . . . . . . . . . . . . 14
2.3 Optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4 Problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5 Algorithme et complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3 Plus courts chemins et programmation dynamique 29

3.1 Cas du graphe orienté et programmation dynamique . . . . . . . . . . . . . . 29
3.2 Cas du graphe non-orienté . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4 Programmation linéaire 47
4.1 Définition et exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.2 Quelques éléments théoriques . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.3 Algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.4 Dualité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.5 Une application de la dualité : jeux matriciels à somme nulle . . . . . . . . . 61
4.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5 Flots et Coupes 65
5.1 Flots et coupes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.2 Flot de coût minimum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
TABLE DES MATIÈRES iv
6 Graphes bipartis : problème d’affectation, problème de transport, mariages

stables 81
6.1 L’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.2 Problème du couplage optimal . . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.3 Couplages généralisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.4 Problème de l’affectation optimale . . . . . . . . . . . . . . . . . . . . . . . . 84
6.5 Mariages stables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
7 Que faire face à un problème difficile ? 89

7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
7.2 Branch-and-bound . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
7.3 Métaheuristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
7.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
II Problématiques 103
8 Remplissage de conteneurs 105
8.1 Sac-à-dos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
8.2 Bin-packing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
8.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
9 Positionnement d’entrepôts 115

9.1 Formalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
9.2 Branch-and-bound . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
9.3 Recherche locale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
9.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
10 Ordonnancement industriel 125

10.1 Préliminaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
10.2 Management de projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
10.3 Ordonnancement d’atelier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
10.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
11 Tournées 143
11.1 Problème du voyageur de commerce . . . . . . . . . . . . . . . . . . . . . . . 143
11.2 Problème du postier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
11.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
12 Conception de réseaux 159

12.1 Quelques rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
12.2 Arbre couvrant de poids minimal . . . . . . . . . . . . . . . . . . . . . . . . 160
12.3 Arbre de Steiner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
v TABLE DES MATIÈRES
12.4 Quelques remarques pour finir . . . . . . . . . . . . . . . . . . . . . . . . . . 167

12.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
13 Ouverture 175
13.1 Quelques outils absents de ce livre . . . . . . . . . . . . . . . . . . . . . . . . 175
13.2 Trois domaines à la frontière de la recherche opérationnelle . . . . . . . . . . 177
TABLE DES MATIÈRES vi
CHAPITRE 1
Généralités
Présentation
La recherche opérationnelle (RO) est la discipline des mathématiques appliquées qui traite
des questions d’utilisation optimale des ressources dans l’industrie et dans le secteur public.
Depuis une dizaine d’années, le champ d’application de la RO s’est élargi à des domaines
comme l’économie, la finance, le marketing et la planification d’entreprise. Plus récemment,
la RO a été utilisée pour la gestion des systèmes de santé et d’éducation, pour la résolution
de problèmes environnementaux et dans d’autres domaines d’intérêt public.
Exemples d’application
Planifier la tournée d’un véhicule de livraison qui doit passer par des points fixés à
l’avance puis revenir à son point de départ en cherchant à minimiser la distance parcourue
est un problème typique de recherche opérationnelle. On appelle ce problème le problème du
voyageur de commerce (étudié plus en détail au Chapitre 11).
Remplir un conteneur avec des objets de tailles et de valeurs variables. Si le conteneur a
une capacité finie, on va chercher à maximiser la valeur placée dans le conteneur. On appelle
ce problème le problème du sac-à-dos (étudié plus en détail au Chapitre 8).
Ordonnancer les tâches sur un chantier. Pour chaque tâche T , on connaı̂t sa durée. De
plus, on connaı̂t les autres tâches dont T dépend directement et combien de temps avant ou
après le début de chacune d’elles T doit démarrer. On désire minimiser la durée totale du
chantier. On dit que ce problème est un problème d’ordonnancement (étudié plus en détail
au Chapitre 10).
Chacun de ces problèmes peut bien sûr être compliqué à l’envie. Dans ce cours, on restera
relativement simple – quelques contraintes de plus suffisent en effet à faire de ces problèmes
de véritables sujets de thèse (par exemple pour le remplissage de conteneur un sujet de
thèse peut consister en : plusieurs types de conteneurs, plusieurs produits à stocker, des
incompatibilités).
Histoire
La recherche opérationnelle est née pendant la Seconde Guerre mondiale des efforts
conjugués d’éminents mathématiciens (dont von Neumann, Dantzig, Blackett) à qui il avait
CHAPITRE 1. GÉNÉRALITÉS 2
été demandé de fournir des techniques d’optimisation des ressources militaires. Le premier
succès de cette approche a été obtenue en 1940 par le Prix Nobel de physique Patrick
Blackett qui résolut un problème d’implantation optimale de radars de surveillance. Le
qualificatif opérationnelle vient du fait que les premières applications de cette disci-
pline avait trait aux opérations militaires. La dénomination est restée par la suite, même si
le domaine militaire n’est plus le principal champ d’application de cette discipline, le mot
opérationnelle prenant alors plutôt le sens d’ effectif . Ce sont donc ces mathématiciens
qui ont créé une nouvelle méthodologie caractérisée par les mots-clés modélisation et opti-
misation.
A partir des années 50, la recherche opérationnelle fait son entrée dans les entreprises.
En France, des entreprises comme EDF, Air France, la SNCF créent à cette époque des
services de recherche opérationnelle (qui existent toujours). La discipline commence à être
enseignée dans les universités et les grandes écoles. Puis, au milieu des années 70, sans doute
à cause d’un excès d’enthousiasme au départ et à l’inadéquation des moyens informatiques à
l’application des méthodes de la RO, la discipline s’essouffle. A partir du milieu des années 90,
on assiste à un retour en force la RO, les outils informatiques étant maintenant à la hauteur
des méthodes proposées par la recherche opérationnelle. On assiste depuis à une explosion
du nombre de logiciels commerciaux et l’apparition de nombreuses boı̂tes de conseil. Pour la
France, notons Ilog (65 millions d’euros de CA), Eurodécision (2,8 millions d’euros de CA),
Artelys (1,6 millions d’euros de CA) à l’étranger Dash-Optimization (racheté début 2008
pour 32 millions de dollars par Fair Isaac), IBM Optimization et beaucoup d’autres (le site
de INFORMS Institute of Operations Research and Management Science en liste près de
240).
Les racines
Si l’on cherche à trouver des précurseurs à la Recherche Opérationnelle, on peut penser
à Alcuin ou à Euler qui se sont tous deux intéressés à des problèmes du type RO, bien
qu’aucune application n’ait motivé leur travail.
Alcuin est le moine irlandais chargé par Charlemagne de construire l’école palatine et qui
inventa le problème du loup, de la chèvre et du chou devant traverser une rivière dans une
barque où au plus un élément peut prendre place.
Un homme devait transporter de l’autre côté d’un fleuve un loup, une chèvre et un
panier de choux. Or le seul bateau qu’il put trouver ne permettait de transporter
que deux d’entre eux. Il lui a donc fallu trouver le moyen de tout transporter de
l’autre côté sans aucun dommage. Dise qui peut comment il a réussi à traverser
en conservant intacts le loup, la chèvre et les choux 1 .
Euler est le mathématicien allemand à qui les notables de Königsberg demandèrent s’il
était possible de parcourir les ponts de la ville en passant sur chacun des 7 ponts exactement
1. Homo quidam debebat ultra fluvium transferre lupum, capram, et fasciculum cauli. Et non potuit
aliam navem invenire nisi quae duos tantum ex ipsis ferre valebat. Praeceptum itaque ei fuerat ut omnia
haec ultra illaesa omnino transferret. Dicat, qui potest, quomodo eis illaesis transire potuit.
3 CHAPITRE 1. GÉNÉRALITÉS
Figure 1.1 – Königsberg et ses 7 ponts
une fois (voir Figure 1.1). Ce genre de problème se rencontre maintenant très souvent dans
les problèmes de tournées du type facteur ou ramassage de déchets ménagers, dans lesquels il
faut parcourir les rues d’une ville de façon optimale. Euler trouva la solution en 1736 – un tel
parcours est impossible – en procédant à une modélisation subtile par des mots. La solution
actuelle, beaucoup plus simple, utilise une modélisation par un graphe (voir Chapitre 2).
On voit sur cet exemple qu’une bonne modélisation peut simplifier de manière drastique la
résolution d’un problème.
Le premier problème de recherche opérationnelle à visée pratique a été étudié par Monge
en 1781 sous le nom du problème des déblais et remblais. Considérons n tas de sable, devant
servir à combler m trous. Notons ai la masse du ième tas de sable et bj la masse de sable
nécessaire pour combler le jème trou. Quel plan de transport minimise la distance totale
parcourue par le sable ?
La solution que proposa Monge est intéressante et procède par une modélisation dans
un espace continu dans lequel on cherche une géodésique – malheureusement, elle n’est pas
correcte. La solution correcte pour trouver l’optimum est connue depuis les années 40 et
utilise la programmation linéaire (que nous verrons au Chapitre 4), ou mieux, la théorie des
flots (que nous verrons au Chapitre 5).
Modélisation et optimisation
[Wikipedia] Un modèle mathématique est une traduction de la réalité pour pou-
voir lui appliquer les outils, les techniques et les théories mathématiques, puis
généralement, en sens inverse, la traduction des résultats mathématiques obte-
nus en prédictions ou opérations dans le monde réel.

Les problèmes d’organisation rencontrés dans une entreprise ne sont pas mathématiques
dans leur nature. Mais les mathématiques peuvent permettre de résoudre ces problèmes.
Pour cela, il faut traduire le problème dans un cadre mathématique, cadre dans lequel les
techniques de la recherche opérationnelle pourront s’appliquer. Cette traduction est le modèle
du problème.
Cette phase essentielle s’appelle la modélisation. La résolution d’un problème dépend
crucialement du modèle choisi. En effet, pour un même problème, différentes modélisations
sont possibles et il n’est pas rare que le problème semble insoluble dans une modélisation et
trivial dans une autre.
D’autre part, tous les éléments d’un problème ne doivent pas être modélisés. Par exemple,
lorsqu’on souhaite planifier une tournée, la couleur du véhicule n’a pas d’intérêt. Le statut du
conducteur, la nature du véhicule ou du produit transporté peuvent, eux, en avoir, et seule
une compréhension de l’objectif de l’optimisation de la tournée peut permettre de trancher.
Souvent, la phase de modélisation est accompagnée ou précédée de nombreuses discussions
avec le commanditaire (lequel n’a d’ailleurs pas toujours une idée claire de ce qu’il cherche
à obtenir – ces discussions lui permettent alors également de préciser ses objectifs).
Une des vrais difficultés de départ est de savoir quels éléments doivent être modélisés et
quels sont ceux qui n’ont pas besoin de l’être. Il faut parvenir à trouver le juste équilibre entre
un modèle simple, donc plus facilement soluble, et un modèle compliqué, plus réaliste, mais
plus difficile à résoudre. Cela dit, pour commencer, un modèle simple est toujours préférable
et permet souvent de capturer l’essence du problème 2 , de se construire une intuition et de
proposer des solutions faciles à implémenter.
Ce qui est demandé au chercheur opérationnel, c’est de proposer une meilleure utilisation
des ressources, voire une utilisation optimale. Les bonnes questions à se poser, face à un
problème du type recherche opérationnelle, sont les suivantes :
— Quelles sont les variables de décision ? C’est-à-dire quels sont les éléments de mon
modèle que j’ai le droit de faire varier pour proposer d’autres solutions ?
— Quelles sont les contraintes ? Une fois identifiées les variables de décision, quelles sont
les valeurs autorisées pour ces variables ?
— Quel est l’objectif ou le critère ? Quelle est la quantité que l’on veut maximiser ou
minimiser ?
Rappelons immédiatement que, en toute rigueur, on n’optimise qu’une seule quantité à la
fois. On ne peut pas demander d’optimiser à la fois la longueur d’un trajet et son temps de
parcours : le trajet le plus court peut très bien passer par un chemin vicinal et le trajet le
plus rapide être très long mais sur autoroute. L’optimum par rapport à un critère n’a pas
de raison de coı̈ncider avec l’optimum par rapport à l’autre critère. Il existe bien ce qu’on
appelle l’optimisation multi-objectif ou multi-critère, mais ce n’est jamais directement une
optimisation. C’est une méthode qui consiste à hiérarchiser les objectifs, ou leur donner une
2. En physique ou en économie, beaucoup de modèles simples, comme le modèle d’Ising ou le modèle de
concurrence parfaite, sont très fructueux pour expliquer le réel.
5 CHAPITRE 1. GÉNÉRALITÉS
certaine pondération, ce qui revient in fine à un vrai problème d’optimisation ; ou alors de

proposer toute une famille de solutions dites Pareto-optimales.
Une fois le modèle écrit, le chercheur opérationnel va proposer un algorithme de résolution
qui tiendra compte de l’objectif qui lui a été fixé. Comme nous le verrons à de nombreuses
reprises dans ce cours, pour un même modèle, un grand nombre d’algorithmes peut être
proposé. Ces algorithmes se différencient par la qualité de la solution qu’ils fournissent, le
temps d’exécution, la simplicité d’implémentation. Dans certains cas, il peut être crucial de
pouvoir fournir une solution en 1 ms, avec une certaine tolérance sur la qualité de la solution.
Dans d’autres cas, 1 semaine de calcul peut être acceptable mais en revanche on souhaite
trouver l’optimum. En général, on se situe entre ces deux extrêmes.
La recherche opérationnelle dispose d’outils théoriques qui permettent a priori d’apprécier
ces points (rapidité de l’algorithme, qualité de la solution,...) sans avoir à expérimenter. On
parle de validation théorique. Ensuite, il faut réaliser un prototype de l’algorithme (on peut
parle de code académique si ce prototype est développé en laboratoire) qui permet de
démontrer sa réalisabilité pratique – on parle de validation pratique. Enfin, si ces étapes sont
validées, on passe au déploiement de la solution, qui consiste à produire un code robuste, pro-
grammer une interface, discuter les formats des fichiers d’input, de discuter la question de la
maintenance du code, etc. mais là on s’éloigne du cœur du métier du chercheur opérationnel.
En résumé, la méthodologie de la recherche opérationnelle suit en général le schéma
suivant.
1. Objectifs, contraintes, variables de décision.
2. Modélisation.
3. Proposition d’un algorithme, validité théorique de l’algorithme (temps d’exécution pour
trouver la solution, qualité de la solution fournie).
4. Implémentation, validation pratique de la solution.
5. Déploiement de la solution.
Objectif de ce cours
La recherche opérationnelle occupe une place grandissante dans l’industrie, la logistique et
les transports. Pour un ingénieur souhaitant faire un travail technique dans ces disciplines,
elle est quasi-incontournable. L’objectif de ce cours est de donner les bases de recherche
opérationnelle : la méthodologie, les problèmes et les modèles typiques, les principales tech-
niques de résolution. Un étudiant maı̂trisant les exercices de ce cours est capable de proposer
une modélisation de nombreux problèmes de recherche opérationnelle rencontrés dans l’in-
dustrie, de proposer des approches de résolution et d’en discuter les qualités respectives. Le
cours se focalisera principalement sur les étapes 2. et 3. ci-dessus.
Première partie
Fondements
7
CHAPITRE 2
Bases
2.1 Graphes
Une brique de base dans la modélisation est le graphe. Les graphes apparaissent naturel-
lement lorsqu’on est confronté à un réseau (réseau de transport, réseau informatique, réseau
d’eau ou de gaz, etc.). Comment parcourir le réseau de manière optimale ? C’est la question
du voyageur de commerce par exemple. Comment concevoir un réseau informatique robuste,
tout en minimisant le nombre de connexions ? C’est le thème de la conception de réseau
(Network Design), abordé au Chapitre 12.
Mais les graphes apparaissent également de manière plus subtile dans certaines modélisations
de problèmes où la structure du graphe n’est pas physique. Un exemple classique est le
problème de l’affectation optimale d’employés à des tâches qui sera étudié aux Chapitres 5
et 6. Les sommets représentent des tâches et des employés, et les arêtes les appariements
possibles entre tâches et employés. Ils apparaissent également dans des problèmes d’ordon-
nancement, où les sommets représentent des tâches et les arcs les relations de précédence.
2.1.1 Graphe non-orienté

Un graphe G = (V, E) est la donnée d’un ensemble fini V de sommets et d’une famille
finie E d’arêtes, chacune associée à une paire de sommets, les extrémités de l’arête. On écrit
indifféremment e = uv ou e = vu, où e est une arête et où u et v sont les sommets auxquels
l’arête est associée. Si e = uv, on dit que u et v sont voisins à e, et que e est incidente à u
et à v. Un sommet auquel aucune arête n’est incidente est dit isolé.
On parle de famille d’arêtes pour souligner le fait que les répétitions sont autorisées. En cas
de répétition, on parle d’arêtes parallèles. La paire associée à une arête peut également être
la répétition d’un sommet, auquel cas on parle de boucle. Un graphe est souvent représenté
dans le plan par des points – ce sont les sommets – reliés par des lignes – ce sont les arêtes.
Voir la Figure 2.1.
L’ensemble des arêtes dont une extrémité exactement est un sommet u est noté δ(u). Une
boucle dont les extrémités sont u n’est donc pas dans δ(u). Le degré d’un sommet u et noté
deg(u) est la quantité |δ(u)|. On note δ(X) l’ensemble des arêtes de la forme uv avec u ∈ X
et v ∈ / X. Un tel ensemble d’arêtes est une coupe du graphe.
Un graphe est complet si toute paire de sommets est reliée par une arête. Voir exemple
Figure 2.2. Un graphe est biparti si l’ensemble des sommets peut être partitionné en deux
CHAPITRE 2. BASES 10
v3 v3 v 3
v5
v1 v 2 v2
v2 v 5
v1
v1 v 2 v5 v 6
v3 v 4
v4 v6
Figure 2.1 – Exemple de graphe. Ce graphe est non connexe, possède 6 sommets, 6 arêtes, dont deux arêtes
parallèles et une boucle.
parties n’induisant chacune aucune arête. Voir exemple Figure 2.3.

Un sous-graphe H d’un graphe G a pour ensemble de sommets un sous-ensemble X de
V et pour ensemble d’arêtes un sous-ensemble F de E. Ce sous-graphe H est induit si F est
formé de toutes les arêtes de E dont les deux extrémités sont dans X. Ces arêtes sont notées
E[X].
Chaı̂ne, cycle, connexité

Une chaı̂ne est une suite de la forme
v0 , e1 , v1 , e2 , . . . , vk−1 , ek , vk
où k est un entier ≥ 0, vi ∈ V pour i = 0, . . . , k et ej ∈ E pour j = 1, . . . , k avec ej = vj−1 vj .

L’entier k est la longueur de la chaı̂ne. En d’autres termes, une chaı̂ne est un trajet possible
dans la représentation d’un graphe lorsqu’on suit les arêtes sans rebrousser chemin sur une
arête. Si les ei sont distincts deux à deux, la chaı̂ne est simple. Si de plus la chaı̂ne ne passe
jamais plus d’une fois sur un sommet, elle est élémentaire. Une chaı̂ne simple passant par
toutes les arêtes d’un graphe est eulérienne. Une chaı̂ne élémentaire passant par tous les
sommets du graphe est hamiltonienne (voir un exemple Figure 2.4).
Un cycle est une chaı̂ne de longueur ≥ 1, simple et fermée. C’est donc une suite de la
forme
v0 , e1 , v1 , . . . , ek , v0
avec ej = vj−1 vj pour j < k, et ek = v0 vk−1 . Un cycle est élémentaire si les vi pour i =
11 CHAPITRE 2. BASES
Figure 2.2 – Exemple de graphe complet.
Figure 2.3 – Exemple de graphe biparti.

Figure 2.4 – Graphe possédant une chaı̂ne hamiltonienne. La chaı̂ne hamiltonienne est mise en gras.
0, . . . , k − 1 sont distincts deux à deux. Un cycle passant par toutes les arêtes d’un graphe
est eulérien. Un cycle élémentaire passant par tous les sommets du graphe est hamiltonien.
Un graphe est connexe si entre toute paire de sommets il existe une chaı̂ne.
Couplage
Un couplage dans un graphe G = (V, E) est un sous-ensemble d’arêtes M ⊆ E tel que
toute paire d’arêtes de M sont disjointes. Une couverture est un sous-ensemble de sommets
C ⊆ V tel que toute arête de E touche au moins un sommet de C. La cardinalité maximale
d’un couplage se note ν(G). La cardinalité minimale d’une couverture se note τ (G).
On a la propriété très utile suivante, car elle permet par exemple d’évaluer la qualité d’un
couplage.
Proposition 2.1. Soit M un couplage et C une couverture d’un graphe G. Alors
|M | ≤ |C|.
La preuve est laissée en exercice. Cette proposition peut également s’écrire
ν(G) ≤ τ (G).
Coloration
Une notion fructueuse en théorie des graphes et très utile en Recherche Opérationnelle
est la notion de coloration. Une coloration d’un graphe est une application c : V → N. Les
entiers N sont alors appelés couleurs. Une coloration propre est telle que pour toute paire
de voisins u, v on a c(u) 6= c(v) : deux sommets voisins ont des couleurs différentes. Une
question que l’on peut se poser, étant donné un graphe, est le nombre minimum de couleurs
possible pour une coloration propre. Ce nombre, noté χ(G), s’appelle le nombre chromatique
de G.
On a l’inégalité
cardinalité du plus grand sous-graphe complet ≤ χ(G),
dont on peut aisément se convaincre.
u1
u3
(u3 , u4 )
u4
(u4 , u3 )
(u5 , u3 )
u5
(u7 , u5 )
u7 (u2 , u1 )
(u6 , u3 ) u2
u6
Figure 2.5 – Exemple de graphe orienté. Ce graphe possède 7 sommets et 5 arcs.
2.1.2 Graphe orienté

Un graphe orienté D = (V, A) est la donnée d’un ensemble fini V de sommets et d’une
famille finie A d’arcs, chacun associé à un couple 1 de sommets, les extrémités de l’arc. On
écrit a = (u, v), où a est un arc et où (u, v) est le couple de sommets auquel l’arc est associé.
Si a = (u, v), on dit que u et v sont voisins à a, et que a est incidente à u et à v. Pour un
arc (u, v), le sommet u est appelé antécédent de v et v est le successeur de u. Si v 6= u, on
dit de plus que l’arc quitte u et entre en v.
Comme pour les graphes non orientés, les répétitions d’arcs sont autorisées et, en cas
de répétition, on parle d’arcs parallèles. Le couple définissant un arc peut également être
la répétition d’un sommet, auquel cas on parle de boucle. Lorsqu’on représente un graphe
orienté, les lignes deviennent des flèches (voir Figure 2.5).
L’ensemble des arcs quittant un sommet u est noté δ + (u) et l’ensemble des arcs entrant en
u est noté δ − (u). Le degré sortant (resp. degré entrant) d’un sommet u et noté deg+ (u) (resp.
deg− (u)) est la quantité |δ + (u)| (resp. |δ − (u)|). On note δ + (X) (resp. δ − (X)) l’ensemble des
arcs de la forme (u, v) avec u ∈ X et v ∈ / X (resp. u ∈ / X et v ∈ X).
Un chemin est une suite de la forme
v0 , a1 , v1 , a2 , . . . , vk−1 , ak , vk
où k est une entier ≥ 0, vi ∈ V pour i = 0, . . . , k et aj ∈ A pour j = 1, . . . , k avec

aj = (vj−1 , vj ). L’entier k est la longueur du chemin. En d’autres termes, un chemin est un
trajet possible dans la représentation d’un graphe lorsqu’on suit les arcs dans le sens des
1. Rappelons que les deux éléments d’un couple sont ordonnés, ceux d’une paire ne le sont pas.
5 6
1
3
7 4
8
Figure 2.6 – Graphe orienté possédant un circuit eulérien. L’ordre des arcs dans un tel circuit est indiqué.
flèches. Si les ai sont distincts deux à deux, le chemin est dite simple. Si de plus le chemin ne
passe jamais plus d’une fois sur un sommet, elle est élémentaire. Un chemin simple passant
par tous les arcs d’un graphe orienté est eulérien. Un chemin élémentaire passant par tous
les sommets du graphe est hamiltonien.
Un circuit est un chemin de longueur ≥ 1, simple et fermée. C’est donc une suite de la
forme
v0 , a1 , v1 , . . . , ak , v0
avec aj = (vj−1 , vj ) pour j < k, et ak = (vk−1 , v0 ). Un circuit est élémentaire si les vi pour
i = 0, . . . , k − 1 sont distincts deux à deux. Un circuit passant par tous les arcs d’un graphe
orienté est dit eulérien. Un circuit élémentaire passant par tous les sommets du graphe est
dit hamiltonien. Un exemple de circuit eulérien est donné Figure 2.6.
Un graphe orienté est dit faiblement connexe si le graphe non orienté obtenu en “oubliant”
les orientations des arcs est connexe. Il est fortement connexe si pour tout couple (u, v) de
sommets, il existe un chemin allant de u à v.
Une dernière remarque : Si rien n’est précisé par ailleurs, n représentera |V | le nombre
de sommets et m représentera |E| (ou |A|) le nombre d’arêtes (ou le nombre d’arcs).
2.2 Retour sur les ponts et sur le voyageur

Le problème des ponts de Königsberg auquel il a été fait allusion ci-dessus se modélise
de la manière suivante : chacune des ı̂les et chacune des berges sont représentées par des
Figure 2.7 – Modélisation du problème des ponts de Königsberg. Ce graphe possède-t-il une chaı̂ne
eulérienne ?
sommets. Il y a donc 4 sommets. Chaque pont est représenté par une arête – voir Figure 2.7.
On cherche donc à savoir s’il y a une chaı̂ne eulérienne dans ce graphe.
La condition nécessaire et suffisante d’existence d’une chaı̂ne eulérienne dans un graphe
est simple. La preuve est laissée en exercice.
Théorème 2.1. Un graphe connexe admet une chaı̂ne eulérienne si et seulement si il possède
au plus deux sommets de degré impair.
Un graphe connexe admet un cycle eulérien si et seulement si il n’a pas de sommet de
degré impair.
Avec ce théorème, on voit donc qu’il n’existe pas de parcours passant exactement une
fois et une seule sur chaque ponts de la ville de Königsberg.
On appelle graphe eulérien un graphe possédant un cycle eulérien.
On peut également tenter une modélisation du problème du voyageur de com-
merce, qui a déjà été évoqué. Un camion doit quitter son entreprôt, livrer différents points
d’un réseau puis revenir à son point de départ, et ce, en parcourant la distance minimale.
Le point à livrer est représenté par un sommet du graphe, la route la plus courte entre deux
points est représentée par une arête. On note ce graphe Kn = (V, E), où n est le nombre de
sommets. Ce graphe – simple – est un graphe complet puisque toute paire de sommets cor-
respond à une arête. On ajoute encore une fonction d : E → R+ qui indique la longueur des
routes représentées par les arêtes. Il est à noter que la fonction d satisfait par construction
l’inégalité triangulaire
d(uv) + d(vw) ≥ d(uw) pour tous sommets u, v, w.
On cherche le cycle hamiltonien de Kn le plus court pour la fonction de poids d.

Le Chapitre 11 donne plus de détail sur cette transformation et traitera des méthodes pour
résoudre le problème.
Dans le cas orienté, la condition nécessaire et suffisante d’existence de chemin ou circuit

eulérien est semblable à celle du Théorème 2.1.
Théorème 2.2. Un graphe faiblement connexe admet un chemin eulérien si et seulement si

il existe deux sommets v et w tels que deg+ (v) = deg− (v) + 1, deg+ (w) + 1 = deg− (w) et
deg+ (u) = deg− (u) pour tout sommet u 6= v, w.
Un graphe faiblement connexe admet un circuit eulérien si et seulement si deg+ (u) =
deg− (u) pour tout sommet u.
Notons qu’un graphe admettant un circuit eulérien est automatiquement fortement connexe.
2.3 Optimisation
2.3.1 Définition
Un problème d’optmisation s’écrit sous la forme suivante (on supposera que l’on cherche
à minimiser une certaine quantité).
Min f (x)
s.c. x ∈ X.
f est le critère. s.c. signifie sous contraintes . X est l’ensemble des solutions
possibles ou réalisables et x ∈ X est la ou les contraintes du programme. On cherche
parmi ces solutions réalisables une solution optimale x∗ , i.e. ici une solution réalisable qui
minimise le critère. La quantité inf{f (x) : x ∈ X} est appelée valeur du problème. Si X = ∅,
cette valeur est définie comme étant égale à +∞.
En plus de fournir un cadre compact pour formuler un problème, cette notation à l’avan-
tage de rappeler les questions essentielles à se poser lorsqu’on résout un problème. Veut-
on minimiser ou maximiser ? Que veut-on optimiser ? Quelles sont les contraintes de notre
système ? Quelles sont les variables sur lesquelles on peut jouer ?
Une remarque fondamentale et très utile est que tout problème de minimisation peut se
réécrire comme un problème de maximisation : il suffit de prendre comme critère −f (x). Et
réciproquement.
2.3.2 Borne et solution approchée

Si l’on est capable de trouver une borne inférieure à un problème d’optimisation, c’est-à-
dire (en reprenant les notations du paragraphe précédent) une fonction g telle que pour tout
x ∈ X, on ait g(x) ≤ f (x), on peut majorer l’écart d’une solution x proposée à la solution
optimale x∗ : on est à moins de
f (x) − g(x∗ )
%
g(x∗ )
de l’optimum. Il est toujours utile de vérifier si l’on n’a pas une borne inférieure de qualité,
facile à calculer. On peut alors éviter de chercher à améliorer une solution en faisant tourner
Graphe coloré avec 5 couleurs
Figure 2.8 – Peut-on colorer proprement ce graphe avec moins de 5 couleurs ?
longuement un programme informatique, alors qu’une borne inférieure nous fournit la preuve
que l’on est à moins de 0,1% de l’optimum par exemple.
En particulier, un bon minorant peut permettre de montrer l’optimalité d’une solution.
Voir Figures 2.8 et 2.9.
2.3.3 Optimisation continue vs optimisation discrète

Si X est une partie d’un espace vectoriel et si f satisfait certaines conditions de régularité,
la résolution de ce programme relève de l’optimisation continue. Un outil fréquent est alors la
dérivation. Dans les problèmes industriels, l’ensemble X est souvent de nature discrète, i.e.
qu’il peut être mis en bijection avec une partie de N. Par exemple, le problème du voyageur
de commerce qui consiste à trouver le cycle le plus court passant par des villes fixées à
l’avance est de nature discrète. X est ici l’ensemble des cycles hamiltoniens. Tout cycle de ce
type est une solution réalisable. Le critère est la distance parcourue. Il y a un nombre fini de
cycles. On est bien dans le cadre de l’optimisation discrète (et l’on voit bien qu’ici la plupart
des notions de l’optimisation continue sont sans intérêt : que dériver ici ?). En recherche
opérationnelle, ce sont plutôt des problèmes d’optimisation discrète qui sont rencontrés.
2.3.4 Programmation linéaire, programmation convexe

Considérons le problème d’optimisation
Min f (x)
s.c. g(x) = 0, (P)
h(x) ≤ 0
x ∈ X,
Figure 2.9 – Peut-on trouver un couplage de plus de 3 arêtes ?
avec X 6= ∅, f : X → R, g : X → Rp et h : X → Rq . Comme l’ensemble des so-

lutions réalisables est décrit par des équations et des inéquations, on appelle programme
mathématique ce type de problème et son étude relève de la programmation mathématique.
On dit que (P ) est un programme linéaire si f est une fonction linéaire, et si g et h sont
toutes deux affines (cf. Chapitre 4). On dit que (P ) est un programme convexe si f , et h
sont toutes deux convexes, et si g est affine. La programmation linéaire est bien entendu un
cas particulier de la programmation convexe. Les techniques pour aborder cette dernières ne
seront que très sommairement évoquées dans ce cours.
2.3.5 Lagrangien et dualité faible

On définit le lagrangien associé au problème (P)
L(x, λ, µ) := f (x) + λT g(x) + µT h(x),
où λ ∈ Rp et µ ∈ Rq+ . On vérifie facilement que

f (x) si g(x) = 0 et h(x) ≤ 0,
sup L(x, λ, µ) =
λ∈Rp ,µ∈Rq +∞ sinon.
+
On peut donc réécrire l’équation (P ) de la manière suivante

Minx∈X sup L(x, λ, µ).
λ∈Rp ,µ∈Rq+
On a toujours
inf sup L(x, λ, µ) ≥ sup min L(x, λ, µ). (2.1)

x∈X λ∈Rp ,µ∈Rq λ∈Rp ,µ∈Rq+ x∈X
+
En définissant
d(λ, µ) := inf L(x, λ, µ),
x∈X
on peut regarder le programme mathématique appelé dual de (P )
Max d(λ, µ)
s.c. λ ∈ Rp (D)
µ ∈ Rq+ .
(P) est alors appelé programme primal.

Notant vP (resp. vD ) la valeur de (P ) (resp. (D)), l’inégalité (2.1) fournit l’inégalité
suivante, appelée inégalité de dualité faible
vP ≥ vD .
Cette inégalité est extrêmement utile et constitue un moyen “automatique” de générer des
bornes inférieures à un problème. Ces notions seront en particulier approfondies dans le
Chapitre 4 sur le programmation linéaire et dans le Chapitre 7. En programmation linéaire,
nous verrons qu’on dispose d’une relation plus forte, appelée dualité forte.
Remarque
d est une fonction concave car infimum de fonctions affines.
2.4 Problème
Une autre notion commode dans la modélisation est la notion de problème. Un problème
se décompose en deux parties : une partie Donnée et une partie Tâche ou Question.
Une telle formalisation permet d’écrire clairement quels sont les éléments dont on dispose
au départ et quelle est précisément la tâche que l’on veut résoudre. L’objectif à atteindre
devient donc clair et dans un tel contexte, il est plus facile de discuter des performances de
telle ou telle méthode.
Par exemple, le problème de l’existence d’une chaı̂ne eulérienne peut s’écrire :
Problème de la chaı̂ne eulérienne

Donnée : Un graphe G = (V, E).
Question : G a-t-il une chaı̂ne eulérienne ?
Celui du voyageur de commerce :

Problème du voyageur de commerce
Donnée : Un graphe complet Kn = (V, E) et une fonction de distance d : E → R+ (qui

satisfait l’inégalité triangulaire)
Tâche : Trouver le cycle hamiltonien C = v0 , e1 , . . . , en , v0 minimisant nj=1 d(ej ).

P
Le premier problème est un type particulier de problème, qui joue un rôle important en
informatique théorique, et s’appelle un problème de décision, puisque la tâche à réaliser est
de répondre à une question fermée, i.e. dont la réponse est soit oui , soit non . Le
second problème est un problème d’optimisation.
2.5 Algorithme et complexité
2.5.1 Algorithme, algorithme exact, algorithme approché
Une fois que l’on a modélisé notre problème concret en un problème formalisé ou en un
programme mathématique, on doit se demander comment le résoudre. Dans ce cours, nous
verrons différents problèmes, différents programmes mathématiques, et quelles méthodes
pour les résoudre. De nouveaux problèmes sont proposés tout le temps par les chercheurs
travaillant en recherche opérationnelle ; dans ce cours, nous nous limiterons bien entendu aux
plus classiques.
On se fixe un ensemble d’opérations que l’on considère facile à faire . Par exemple,
comparaison d’entiers, lire une adresse mémoire, etc. Une suite d’opérations élémentaires
permettant de résoudre un problème s’appelle un algorithme. La résolution d’un problème
de recherche opérationnelle passe toujours par l’application d’un algorithme, qui est ensuite
implémenté. Lorsque le problème que l’on tente de résoudre est un programme d’optimisa-
tion, on parlera d’algorithme exact si l’algorithme est sûr de se terminer avec l’optimum du
programme, et d’algorithme approché sinon.
La question qui se pose également est celle de l’efficacité de l’algorithme, i.e. du temps
qu’il va mettre pour résoudre le problème (une fois admis que l’algorithme est correct et
résout bien le problème).
2.5.2 Question de l’efficacité
Une méthode peut être de tester l’algorithme sur de grandes quantités de données. Mais
ces tests-là peuvent être très, très longs, et de toute façon, à chaque fois que l’on va penser
à un algorithme possible, on ne va pas systématiquement procéder à son implémentation
et à des tests. La théorie de la complexité, un des fondement théorique de la recherche
opérationnelle, a pour but de mesurer a priori l’efficacité d’un algorithme. La petite histoire
qui va suivre va montrer l’intérêt de cette théorie, et est librement adapté du livre de Garey
et Johnson [10].
2.5.3 De l’intérêt de la théorie pour sauver son boulot

Supposez qu’un jour votre patron vous appelle dans son bureau et vous annonce que
l’entreprise est sur le point d’entrer sur le marché compétitif du schmilblick. Il faut donc
trouver une bonne méthode qui permette de dire si une collection de spécifications peut être
satisfaite ou non, et si oui, qui donne la façon de construire ce schmilblick. On peut imaginer
qu’un schmilblick est décrit par des variables booléennes Ci qui indiquent si le composant i
est présent ou non. De plus, on a des règles du type si C1 et C5 sont vraies et C3 est faux,
alors C7 doit être faux. Etc.
Comme vous travaillez au département de Recherche Opérationnelle, c’est à vous de
trouver un algorithme efficace qui fasse cela.
Après avoir discuté avec le département de production des schmilblicks afin de déterminer
quel est exactement le problème à résoudre, vous retournez dans votre bureau et commencez
avec enthousiasme à travailler d’arrache-pied. Malheureusement, quelques semaines plus tard,
vous êtes obligé de l’admettre : vous n’avez pas réussi à trouver un algorithme qui fasse
substantiellement mieux que d’essayer toutes les possibilités – ce qui ne réjouira certainement
pas votre patron puisque cela demandera des années et des années pour tester juste un
ensemble de spécifications. Vous ne souhaitez certainement pas retourner dans le bureau de
votre patron et lui dire : Je ne parviens pas à trouver d’algorithme efficace. Je pense que
je suis trop bête.
Ce qui serait bien, c’est que vous soyez capable de démontrer que le problème du schmil-
blick est intrinsèquement intractable 2 . Dans ce cas, vous pourriez sereinement aller voir votre
patron et lui dire : Je ne parviens pas à trouver d’algorithme efficace car un tel algorithme
ne peut exister.
Malheureusement, personne à ce jour n’a été capable de montrer qu’il existe un problème
intrinsèquement intractable. En revanche, les théoriciens de l’informatique ont développé
un concept qui est presqu’aussi bon, celui de problème NP-complet. La théorie de la NP-
complétude fournit des techniques variées pour prouver qu’un problème est aussi difficile
qu’une grande quantité d’autres problèmes, pour lesquels aucune méthode efficace n’a été
trouvée à ce jour, malgré les efforts répétés des plus grands experts de la planète. Avec
ces techniques, vous pourrez peut-être prouver que votre problème est NP-complet et donc
équivalent à tous ces problèmes difficiles. Vous pourriez alors entrer dans le bureau de votre
patron et annoncer : Je ne parviens pas à trouver d’algorithme efficace, mais aucune star
de la RO, aucune star de l’informatique théorique, aucune star de l’optimisation discrète ne
peut le faire. Au pire, cela l’informera qu’il ne sert à rien de vous virer pour embaucher un
autre expert à votre place.
Prouver qu’un problème est NP-complet ne signifie pas la fin de l’histoire ; au contraire,
c’est le début du vrai travail. Le fait de savoir qu’un problème est NP-complet fournit une
information sur l’approche la plus productive. Cela montre qu’il ne faut pas se focaliser
sur la recherche d’un algorithme exact et efficace et qu’il faut avoir des approches moins
ambitieuses. Par exemple, on peut chercher des algorithmes efficaces résolvant divers cas
2. anglicisme signifiant dans ce contexte qu’il n’existe pas d’algorithme efficace résolvant le problème
considéré.
Taille n
Fonction de complexité 10 20 30 40 50 60
n 0, 01 µs 0, 02 µs 0, 03 µs 0, 04 µs 0, 05 µs 0, 06 µs
n2 0, 1 µs 0, 4 µs 0, 9 µs 1, 6 µs 2, 5 µs 3, 6 µs
n3 1 µs 8 µs 27 µs 64 µs 125 µs 216 µs
n5 0, 1 ms 3, 2 ms 24, 3 ms 102, 4 ms 312, 5 ms 777, 6 ms
2n ∼ 1 µs ∼ 1 ms ∼1s ∼ 18 min20 s ∼ 13 jours ∼ 36 années et 6 mois
Table 2.1 – Comparaison de diverses fonctions de complexité pour un ordinateur effectuant

1 milliard d’opérations par seconde.
particuliers. On peut chercher des algorithmes sans garantie sur le temps d’exécution, mais
qui en général semblent être rapides. Ou alors, on peut relaxer le problème et chercher un
algorithme rapide qui trouve des schmilblicks satisfaisant presque toutes les spécifications.
Dans les chapitres suivants, nous verrons des exemples concrets illustrant de telles approches.
2.5.4 Notions de base en théorie de la complexité ou comment gagner 1 million de $

Pour évaluer théoriquement l’efficacité d’un algorithme résolvant un problème P, on
compte le nombre d’opérations élémentaires que cet algorithme effectue pour le résoudre.
Comme la taille des données de P peut varier, on va avoir une fonction de complexité f qui à
n, la taille des données, va associer le nombre f (n) d’opérations élémentaires que l’algorithme
va effectuer pour trouver une solution. La taille des données, c’est le nombre de bits qu’il
faut pour coder les données.
Rappelons qu’en mathématiques, dire qu’une fonction f est O(g(n)) (lire grand ‘o’ de
g(n) ), c’est dire qu’il existe une constante B et un n0 tels que f (n) ≤ Bg(n) pour n ≥ n0 .
Si la fonction de complexité d’un algorithme est un O(p(n)), où p est un polynôme, alors
l’algorithme est polynomial. Sinon, il est exponentiel. Un algorithme polynomial est en général
perçu comme efficace, un algorithme exponentiel est en général mauvais. Le Tableau 2.1
montre le temps qu’il faut à des algorithmes de fonction de complexité variable pour résoudre
un problème pour différentes tailles de données.
On entend souvent dire : Ces problèmes ne se poseront plus lorsque la puissance des
ordinateurs aura augmenté . C’est faux, comme le montre le Tableau 2.2. Supposons par
exemple que l’on ait un algorithme résolvant le problème du schmilblick en B2n opérations
élémentaires, où B est une constante et où n est le nombre de spécifications (avec donc un
ordinateur effectuant bien plus d’1 milliard d’opérations par seconde). Et supposons que
l’on soit capable de résoudre des problèmes de schmilblick en 1 heure jusqu’à n = 438.
L’utilisation d’une machine 1000 fois plus rapide ne permettra que d’aller jusqu’à n = 448
en 1 heure !
Un problème P est polynomial ou dans P s’il existe un algorithme polynomial qui le
résout.
Un problème de décision P est dans NP si, lorsque la réponse est oui , il existe
un certificat (c’est-à-dire une information supplémentaire) et un algorithme polynomial qui
Taille de l’instance la plus large que l’on peut résoudre en 1 heure

Fonction de complexité Avec un ordinateur actuel Avec un ordinateur Avec un ordinateur
100 fois plus rapide 1000 fois plus rapide
n N1 100N1 1000N1
2
n N2 10N2 31.6N2
3
n N3 4.64N3 10N3
5
n N4 2.5N4 3.98N4
2n N5 N5 + 6.64 N5 + 9.97
3n N6 N6 + 4.19 N6 + 6.29
Table 2.2 – Comparaison de diverses fonctions de complexité.
permet de vérifier que la réponse est oui , sans pour autant être nécessairement capable
de trouver cette réponse (voir des exemples ci-dessous). Le sigle NP ne signifie pas non
polynomial mais non déterministiquement polynomial . Le non-déterminisme ici fait
référence aux machines de Turing non-déterministes, et dépasse largement le cadre de ce
cours.
Un problème de décision NP est NP-complet si l’existence d’un algorithme polynomial
le résolvant implique l’existence d’un algorithme polynomial pour tout problème NP. A ce
jour, on ne connaı̂t pas d’algorithme polynomial résolvant un problème NP-complet. En
revanche, on connaı̂t beaucoup de problèmes NP-complets. Le premier a été trouvé en 1970,
par un informaticien appelé Cook.
Considérons le problème suivant.
Problème du cycle eulérien

Question : G a-t-il un cycle eulérien ?
Ce problème de décision est dans P. En effet, le Théorème 2.1 ci-dessus permet facilement
de répondre à la question en temps polynomial : si m est le nombre d’arêtes de G et n son
nombre de sommets, tester le fait que tous les sommets sont de degré pair prend O(m) et
que le graphe est connexe prend O(n + m), au total O(n + m). Il est donc également dans
NP : le certificat est le graphe lui-même.
De même, le problème suivant est dans P.
Problème de la chaı̂ne eulérienne

Donnée : Un graphe G = (V, E) et deux sommets s, t ∈ V .
Question : G a-t-il une s–t chaı̂ne eulérienne ?
Considérons maintenant le problème suivant.

Problème du cycle hamiltonien

Question : G a-t-il un cycle hamiltonien ?
A ce jour, nul n’a pu démontrer que ce problème est dans P, ni qu’il n’y était pas. En
revanche, il est facile de voir que ce problème est dans NP car si la réponse est positive, alors
l’algorithme qui consiste à suivre le cycle hamiltonien permet de prouver que la réponse est
bien positive. Ici, le cycle hamiltonien joue le rôle de certificat. Il a été également démontré
que ce problème est NP-complet. Cela signifie que si vous rencontrez quelqu’un vous disant
qu’il connaı̂t un algorithme efficace pour répondre à cette question, il est très probable qu’il se
trompe car tous les problèmes NP-complets pourraient alors être résolus par un algorithme
polynomial. Or personne à ce jour n’a pu en trouver, et quantité de gens très brillants ont
cherché un tel algorithme. S’il ne se trompe pas, c’est une découverte fondamentale, qui au-
rait un impact énorme tant dans le monde de l’informatique théorique, que dans la recherche
opérationnelle appliquée. De plus, cette personne percevrait le prix d’1 millions de dollars
?
offert par la Fondation Clay pour la résolution de la question ouverte P = NP.
De même le problème suivant est NP-complet.
Problème de la chaı̂ne hamiltonienne

Donnée : Un graphe G = (V, E), deux sommets s, t ∈ V .
Question : G a-t-il une s–t chaı̂ne hamiltonienne ?
On peut définir également les mêmes problèmes pour les graphes orientés, les résultats
seront semblables. En résumé, on a
Résultats de complexité pour des parcours.
Problèmes Complexité
Graphe non-orienté : Cycle eulérien P
Graphe non-orienté : Chaı̂ne eulérienne P
Graphe non-orienté : Cycle hamiltonien NP-complet
Graphe non-orienté : Chaı̂ne hamiltonienne NP-complet
Graphe orienté : Circuit eulérien P
Graphe orienté : Chemin eulérien P
Graphe orienté : Circuit hamiltonien NP-complet
Graphe orienté : Chemin hamiltonien NP-complet
La Figure 2.10 illustre les relations entre problèmes P, NP, NP-complets, si P 6= NP

(ce qui est le plus probable).
La notion de problème NP et a fortiori de problème NP-complet est définie pour les
problèmes de décision, dont la réponse est oui ou non . Mais les problèmes que l’on
NP-difficiles
NP-complets
NP
Figure 2.10 – Les problèmes NP
rencontre en RO sont rarement de ce type. Il existe une notion qui permet de caractériser
des problèmes difficiles qui ne sont pas des problèmes de décision : c’est celle de problème
NP-difficile.
Un problème est NP-difficile si savoir le résoudre en temps polynomial impliquerait que
l’on sait résoudre un problème (de décision) NP-complet en temps polynomial.
Théorème 2.3. Le problème du voyageur de commerce est NP-difficile.
La preuve de ce résultat découle de la NP-complétude du problème de cycle hamiltonien.
2.6 Exercices
2.6.1 Dessiner sans lever le crayon
Indiquez pour les Figures 2.11 et 2.12 quand il est possible de dessiner la figure sans lever
le crayon (et sans repasser sur un trait déjà dessiné) et quand il ne l’est pas.
2.6.2 Parcours hamiltonien

Pour chacun des trois graphes de la Figure 2.13, indiquez pour chacun d’eux s’il possède
une chaı̂ne hamiltonienne. Même question avec pour le cycle hamiltonien.
Justifiez votre réponse.
2.6.3 Le jeu Icosian

La Figure 2.14 représente le jeu Icosian inventé en 1859 par le mathématicien Hamilton.
Peut-on mettre les chiffres de 1 à 20 dans les cercles de manière à ce que toute paire de
Figure 2.11 – Peut-on tracer cette figure sans lever le crayon ?
Figure 2.12 – Et celle-là ?
nombres consécutifs soit adjacente, 1 et 20 étant aussi considérés comme adjacents ?
2.6.4 Affectation de fréquences
Considérons des relais de téléphonie mobile. Chaque relais reçoit et émet des signaux
à une certaine fréquence. Pour éviter les interférences, on veut que deux relais à moins de
200 m fonctionnent avec des fréquences différentes. Le coût de gestion du parc de relais est
une fonction croissante du nombre de fréquences utilisées. On souhaite minimiser ce coût.
Modéliser ce problème avec les outils du cours.
2.6.5 Organisation de formations
Considérons maintenant un DRH qui doit assurer un certain nombre de formation à ses
employés. Les formations sont F1 , . . . , Fn . Et les employés sont E1 , . . . , Em . Le DRH sait
pour chaque employé Ei quelles sont les formations qu’il doit suivre. Il veut organiser une
session de formations – chacune des formation ne peut être dispensée qu’une fois au total
dans l’entreprise et un employé peut suivre au plus une formation par jour. En revanche,
plusieurs formations peuvent être dispensées le même jour. Le DRH souhaite organiser la
session la plus courte possible.
Modéliser ce problème avec les outils du cours.
G1
G2
G3
Figure 2.13 – Lequel de ces graphes contient une chaı̂ne hamiltonienne ? Lequel contient un cycle hamilto-
nien ?
Figure 2.14 – Le jeu Icosian.

2.6.6 Borne inférieure du nombre chromatique

Montrer l’optimalité de la coloration de la Figure 2.8, et proposer une borne inférieure
générale pour les nombre chromatique.
2.6.7 Borne supérieure pour les couplages maximum

Montrer l’optimalité du couplage de la Figure 2.9, et proposer une borne supérieure
générale pour les couplages maximum.
2.6.8 NP-complétude de la chaı̂ne hamiltonienne

Montrer que le problème de l’existence de la chaı̂ne hamiltonnienne est NP-complet,
sachant que celui du cycle hamiltonien l’est. Réciproquement, montrer que le problème de
l’existence du cycle hamiltonnien est NP-complet, sachant que celui de la chaı̂ne hamilto-
nienne l’est.
2.6.9 Problème de transport

Le premier problème de recherche opérationnelle à visée pratique a été étudié par Monge
en 1781 sous le nom du problème des déblais et remblais. Considérons n tas de sable, devant
servir à combler m trous. Notons ai la masse du ième tas de sable et bj la masse de sable
nécessaire pour combler le jème trou. Pour chaque couple (i, j) on connaı̂t la distance dij
du ième tas au jème trou. Si une masse xij est déplacée du tas i au trou j, le coût du
déplacement est égal à dij xij . On souhaite savoir quel est le plan de transport qui permet de
boucher les trous au coût minimum.
Modéliser ce problème sous la forme d’un programme mathématiques. Quelle est sa na-
ture ?
CHAPITRE 3
Plus courts chemins et programmation

dynamique
Les problèmes de plus courts chemins apparaissent naturellement dans des contextes
variés. Ils peuvent apparaı̂tre comme modélisation de problèmes opérationnels (trajet le plus
rapide, ou le moins cher, gestion optimal d’un stock, plan d’investissement optimal, etc.),
ils sont aussi fréquemment des sous-problèmes d’autres problèmes d’optimisation (flot de
coût minimum – Chapitre 5 – ou en théorie de l’ordonnancement – Chapitre 10). Sous cette
appellation anodine de plus court chemin, nous verrons qu’il se cache une réalité extrêmement
variée, tant du point de vue de la complexité que des types d’algorithmes mis en œuvre. Le
graphe peut être orienté ou non, les arêtes ou les arcs avoir des poids positifs ou quelconque,...
Un cas particulier important est la programmation dynamique qui traite des situations où des
décisions doivent être prises de manière séquentielle, chaque décision faisant passer le système
d’un état à un autre. Ce passage d’un état à un autre s’appelle une transition. On suppose
qu’un coût est associé à chaque transition. L’objectif de la programmation dynamique est
de minimiser le coût de la suite des transitions, suite qu’on appelle trajectoire.
3.1 Cas du graphe orienté et programmation dynamique
3.1.1 Les poids sont positifs : algorithme de Dijkstra

Le cas le plus naturel est le cas du graphe orienté avec des poids strictement positifs sur
les arcs. En effet, le problème du trajet le plus court dans un réseau (routier, de transport,
informatique, etc.) rentre dans ce cadre. Le temps de parcours d’un arc, ou sa longueur, sont
dans ces contextes strictement positifs.
En 1959, Dijkstra proposa le premier algorithme efficace. On suppose que l’on a un graphe
orienté D = (V, A), avec une fonction de poids w : A → R+ . On se fixe un sommet s de
départ et un sommet t d’arrivée. On veut le chemin de plus petit poids (le poids d’un chemin
étant la somme des poids de ses arcs), ou autrement dit le plus court chemin allant de s
à t. Noter que dans un graphe dont tous les poids sont positifs, il existe toujours un plus
court chemin qui est un chemin élémentaire (avec répétition de sommets interdite) car si
le plus court chemin passe par un circuit, on peut supprimer ce circuit sans détériorer le
poids du chemin. Si tous les poids sont strictement positifs, les notions de plus court chemin,
plus court chemin simple (avec répétition d’arcs interdite) et plus court chemin élémentaire
CHAPITRE 3. PLUS COURTS CHEMINS ET PROGRAMMATION DYNAMIQUE 30
(avec répétition de sommets interdite) coı̈ncident puisqu’alors suivre un circuit détériore

strictement le poids du chemin.
L’algorithme de Dijkstra va calculer les plus courts chemins démarrant en s pour tous
les sommets d’arrivée possibles, donc en particulier pour t.
Au cours de l’algorithme, on maintient un ensemble U ⊆ V et une fonction λ : V → R+ .
On dit que λ(v) est le label courant de v. Ce label est la meilleure évaluation courante du
poids du plus court chemin de s à v. On commence avec U := V et λ(s) := 0 et λ(v) := +∞
pour v 6= s. Ensuite, on répète la chose suivante de manière itérative :
Choisir u minimisant λ(u) pour u ∈ U . Pour chaque (u, v) ∈ δ + (u) tel

que λ(v) > λ(u) + w(u, v), redéfinir λ(v) := λ(u) + w(u, v). Redéfinir
U := U \ {u}.
On s’arrête lorsque λ(u) = +∞ pour tout u ∈ U . La fonction λ donne alors les distances de
s à tout sommet que l’on peut atteindre en partant de s. Les sommets dans U à la fin de
l’algorithme sont ceux qui ne peuvent être atteints depuis s.
De plus, si pour chaque v 6= s, on garde en mémoire le dernier arc a = (u, v) pour lequel
on a redéfini λ(v) := λ(u) + w(a), on peut reconstruire l’ensemble des plus courts chemins
partant de s.
Il est clair que le nombre d’itérations est au plus |V |, et chaque itération prend un temps
O(n). L’algorithme a donc une fonction de complexité qui est en O(n2 ). D’où le théorème :
Théorème 3.1. Etant donnés un graphe orienté D = (V, A), un sommet s ∈ V et une
fonction de poids w : A → R+ , un ensemble de plus courts chemins de s à tout sommet
v ∈ V peut être calculé en O(n2 ).
Eléments de preuve. Pour démontrer le théorème, il faut simplement voir que lorsque u est retiré de U
dans l’itération au-dessus, λ(u) est la vraie distance de s à u (la preuve de cette assertion est laissée en
exercice).
Remarque
En utilisant de bonnes structures de données, il est possible d’obtenir une complexité de

O(m + n log n).
Exemple
En appliquant l’algorithme de Dijkstra sur la Figure 3.1, on obtient le tableau suivant

indiquant les valeurs successives de λ pour chaque sommet.
31 CHAPITRE 3. PLUS COURTS CHEMINS ET PROGRAMMATION DYNAMIQUE
a
2
b
3
1 1
s 3 d
c
1
5 3 3 6
2 e
2
t
f
7
Figure 3.1 – Exemple de graphe orienté avec poids positifs sur les arcs.
s a b c d e f t
(0) (∞) (∞) (∞) (∞) (∞) (∞) (∞)
0 (3) (∞) (∞) (3) (∞) (5) (∞)
0 3 (5) (∞) (3) (∞) (5) (∞)
0 3 (4) (∞) 3 (∞) (5) (∞)
0 3 4 (5) 3 (∞) (5) (∞)
0 3 4 5 3 (8) (5) (∞)
0 3 4 5 3 (7) 5 (12)
0 3 4 5 3 7 5 (9)
0 3 4 5 3 7 5 9
3.1.2 Les poids sont quelconques mais le graphe est sans circuit
On considère maintenant le cas où les poids peuvent prendre des valeurs négatives, mais
où le graphe est sans circuit, ou acircuitique. Lorsqu’on voit le problème du plus court chemin
comme la modélisation d’un plus court chemin dans un réseau physique, cela peut paraı̂tre
surprenant puisque les temps de parcours ou les distances de portion de réseau sont toujours
positifs. Mais dans de nombreux cas le graphe dont on cherche un plus court chemin est
issu d’une modélisation et les poids ne correspondent pas à des distances ou des temps qui
s’écoulent. Noter que dans ce cas, les notions de plus court chemin, plus court chemin simple
et plus court chemin élémentaire coı̈ncident, puisqu’il n’y a pas de circuit. Donc de même
que dans le cas où tous les w(a) sont positifs, il existe toujours un plus court chemin qui est
élémentaire.
Considérons donc maintenant le cas du graphe orienté D = (V, A) acircuitique, avec une
fonction de poids w : A → R.
L’algorithme de Dijkstra ne fonctionne plus lorsque les poids peuvent être négatifs. En
effet, l’invariant de boucle qui fait fonctionner l’algorithme de Dijkstra est le fait que le
minimum de λ(u) pour u dans le U courant est la vraie distance de s à u. Ce qui justifie que
l’on retire u de U . Or si les poids peuvent être négatifs, il facile de voir que cette propriété
n’est plus vraie.
A la fin des années 50, des mathématiciens comme Ford, Bellman, Moore, et d’autres,
remarquèrent que dans ce contexte, un algorithme très simple permet de trouver le plus
court chemin.
Pour décrire cet algorithme, définissons pour v ∈ V :
λ(v) := poids minimum d’un s–v chemin,
posant λ(v) := ∞ si un tel chemin n’existe pas.

L’algorithme est une traduction de l’équation de Bellman qui dit
λ(v) = min (λ(u) + w(u, v)) (3.1)

(u,v)∈A
pour tout v ∈ V . Cette équation peut être lue de la manière suivante :

Le plus court chemin de s à v est le plus court chemin de s à u, où u est un
antécédent de v, auquel on a ajouté le dernier arc (u, v).
En fait, de façon un peu plus compacte, on a le principe suivant qui implique ce qui
précède
[Principe d’optimalité de Bellman] La sous-trajectoire d’une trajectoire optimale
est encore optimale.
L’équation (3.1) se traduit facilement en un algorithme. On commence par poser λ(s) := 0
et λ(u) := ∞ pour tout u tel qu’il n’existe pas de s–u chemin. Ensuite, on repète la boucle
suivante
Chercher un sommet v dont on connaı̂t λ pour tous les prédécesseurs

(on peut démontrer que, puisque le graphe est acircuitique, un tel
sommet existe toujours). L’équation (3.1) permet de calculer λ(v).
On s’arrête lorsque λ aura été calculé pour tous les sommets.

Remarquons qu’il n’est pas difficile de reconstruire le plus court chemin : en même temps
que λ(v), on peut stocker p(v) qui est le sommet u antécédent de v qui a permis d’obtenir
le poids λ(v). Comme pour l’algorithme de Dijkstra, on récupère ainsi un plus court chemin
de s à v, pour tout v ∈ V .
Théorème 3.2. Etant donnés un graphe acircuitique D = (V, A) et une fonction de poids
w : A → R, un ensemble de plus courts chemins de s à tout sommet v ∈ V peut être calculé
en O(m).
L’outil central de l’algorithme qui sous-tend ce théorème est l’ordre topologique. Un ordre
topologique des sommets d’un graphe orienté D = (V, A) est une indexation v1 , v2 , . . . , vn des
sommets de D telle que pour tout i, j tels que (vi , vj ) ∈ A on ait i < j. Un graphe orienté
admet un ordre topologique si et seulement si il est acircuitique. On peut alors trouver un
ordre topologique en O(m) avec l’algorithme suivant.
Scanner un sommet consiste à ouvrir le sommet, scanner ses successeurs puis fer-
mer le sommet (définition récursive, consistante puisque le graphe est sans circuit). On
choisit un sommet s sans prédécesseur. On scanne s. L’ordre opposé à celui dans lequel on
ferme les sommets est un ordre topologique.
En effet, s’il y a un arc de u à v, alors v sera fermé avant u et son indice sera plus
grand que celui de u.
Preuve du Théorème 3.2. Pour prouver ce théorème, il faut montrer que l’on peut trouver en O(m) un ordre
v1 , v2 , . . . , vn sur les sommets de D tel que tous les antécédents de vi ont un indice < i, ce qui assure que l’on
peut toujours calculer λ(vi ) une fois calculés les λ(vj ) pour j < i. Or, c’est ordre n’est rien d’autre qu’un
ordre topologique.
Remarque
Dans le cas acircuitique, on sait en particulier trouver un plus long chemin d’une origine
s à une destination t : en effet, en définissant des poids w0 (a) := −w(a), on voit que le même
algorithme fonctionne (en gardant les mêmes poids, il suffit de changer les min en max).
3.1.3 Programmation dynamique

Un cas particulier important est celui de la programmation dynamique qui traite de
situations où les décisions peuvent ou doivent être prises de manière séquentielle. Ce qui
caractérise la programmation dynamique 1 est la présence
1. un système dynamique à temps discret caractérisé par un ensemble Xk d’états possibles
à l’instant k et
2. une fonction de coût additive dans le temps.
Le système dynamique décrit l’évolution de l’état du processus au fil de N périodes et a
la forme
xk+1 = fk (xk , uk ), k = 1, 2, . . . , N
où k numérote les périodes et où xk ∈ Xk est l’état du système au début de la période k.
Passer de xk à xk+1 s’appelle une transition. On a de plus un coût c(xk , xk+1 ) pour toute
transition de l’état xk à l’état xk+1 . Ces coûts s’additionnent au fil des périodes et pour la
trajectoire complète x1 , . . . , xN , on a un coût total de
N
X
c(xk , xk+1 ).
k=1
1. On se limite au cas déterministe discret.

xk
..
.
s := x0 t
.. ...
.
..
.
k=1 k=2 k=3 k =N −1 k=N k

trajectoire optimale = plus court s–t chemin dans un graphe acircuitique
coûts := 0
Figure 3.2 – La programmation comme problème de plus court chemin.
Le problème de la programmation dynamique consiste à trouver la trajectoire optimale, i.e.

minimisant le coût total.
Ce problème de la programmation dynamique se modélise très bien comme celui du plus
court chemin dans un graphe orienté, pondéré et sans circuit. En effet, pour chaque période
k, on représente les états possibles par des sommets. Les transitions possibles sont des arcs.
Le coût de la transition xk → xk+1 est le poids de l’arc (xk , xk+1 ). Noter que ce graphe est
sans circuit (ou acircuitique) : en effet, un arc va toujours d’un état de période k à un état
de période k + 1. En ajoutant des états de départ s et d’arrivée t, on va chercher le chemin
de s à t qui a le plus petit poids. Voir Figure 3.2.
Si on définit
λ(k, x) := coût minimum de la trajectoire allant de l’état de départ s à l’état x en k étapes,
posant λ(k, x) := +∞ s’il n’est pas possible d’amener le système dans l’état x en k étapes,
l’équation de Bellman (3.1) se réécrit
λ(k, x) = min (λ(k − 1, y) + c(y, x)). (3.2)

y∈Xk−1
Cette équation permet de calculer de proche en proche les valeurs de λ(k, x) : à l’itération
k, on calcule tous les λ(k, x) pour x ∈ Xk , en utilisant les valeurs λ(k − 1, x) calculées à
l’itération k − 1. En voyant ce calcul comme un calcul de plus court chemin dans un graphe
acircuitique (Section 3.1.2), cela revient à dire qu’un ordre topologique est donné facilement
par le découpage temporel.
Remarquons enfin que tout graphe orienté acircuitique n’est pas issu d’une modélisation
d’un système dynamique. En effet, un graphe modélisant un processus de programmation
dynamique a tous ses chemins de s à t ayant le même nombre d’arcs, à savoir N .
Venons-en maintenant à quelques exemples de modélisation par la programmation dyna-
mique.
Exemple : Gestion de stock

Considérons le problème de la gestion d’un stock pour N périodes consécutives.
Un stock suit une dynamique de la forme xk+1 = xk − dk + uk , où dk désigne la demande
pour la période k, supposée connue, xk désigne le nombre d’unités disponibles en début de
kième période et uk désigne le nombre d’unités commandées (et reçues immédiatement) en
début de kième période. On prendra xk ∈ Z, une quantité négative signifiant une pénurie.
De plus, on a en général l’existence d’une capacité maximale de stockage K qui implique que
xk ≤ K. On supposera x0 fixé.
Les coûts de gestion de stock se décomposent pour chaque période k en
— un coût de réapprovisionnement c(uk ), c’est-à-dire le coût d’achat des uk unités, et
— un coût de gestion g(xk+1 ), qui comprend le coût de stockage des unités en excès en fin
de période et le coût de pénurie si la demande ne peut être totalement satisfaite sur la
période.
Typiquement, on a c(u) = b + au, où a est un coût unitaire d’achat et b un coût fixe et

sx si x ≥ 0
g(x) =
px si x ≤ 0,
où s est le coût unitaire de stockage et p le coût unitaire de défaillance. Si on veut interdire
les stocks négatifs, on pose p = +∞.
On veut minimiser
N
X −1
c(uk ) + g(xk+1 ).
k=0
Dans le vocabulaire de la programmation dynamique, les états sont les valeurs possibles de
niveau de stock, les transitions possibles sont tous les xk → xk+1 tels que xk+1 satisfasse
simultanément xk+1 ∈ Z, xk+1 ≤ K et xk+1 ≥ xk − dk . Le coût de la transition xk → xk+1
est c(xk+1 − xk + dk ) + g(xk+1 ). On souhaite donc trouver la trajectoire optimale pour ce
modèle de programmation dynamique.
On applique l’algorithme de plus court chemin dans le graphe acircuitique suivant. Pour
chaque période k, on aura un sommet pour chaque niveau de stock possible (inférieur à K et
supérieur à x0 − d0 − d1 − . . . − dk−1 ) en début de période. On notera un tel sommet (x, k),
où x est le niveau de stock, et k la période. Entre un sommet de période k et un sommet
de période k + 1, on a un arc ((x, k), (x0 , k + 1)) seulement si x0 ≥ x − dk . Le poids de l’arc
((x, k), (x0 , k + 1)) est égal à c(x0 − x + dk ) + g(x0 ). On cherche un plus court chemin de (x0 , 0)
à un sommet de la forme (x, N ). Le poids de ce plus court chemin sera le coût optimal de la
gestion du stock.
Exemple : Remplissage d’un conteneur ou problème du sac-à-dos

Considérons un assortiment de N objets k = 1, . . . , N , l’objet k ayant une valeur ck ≥ 0
et un volume ak >P 0, et supposons que l’on ait à stocker ces objets dans un conteneur de
volume fini W . Si N k=1 ak > W , on va devoir sélectionner des objets afin de maximiser la
valeur des objets stockés. Ce problème est connu sous le nom du problème du sac-à-dos, car
le conteneur est vu comme un sac-à-dos avec lequel on veut transporter des objets de plus
grand valeur totale, sous des contraintes de capacité. On note x(j, W 0 ) la valeur maximale
qui peut être transportée dans un sac de capacité W 0 , en ne se servant que des j premiers
objets.
On a l’équation (programmation dynamique)
x(j, W 0 ) = max(x(j − 1, W 0 ), x(j − 1, W 0 − wj ) + cj )
qui se lit : le remplissage optimal x(j, W 0 ) d’un sac de capacité W 0 , avec les objets de 1 à j,
— soit n’utilise pas le jème objet, et dans ce cas x(j, W 0 ) = x(j − 1, W 0 )
— soit utilise le jème objet, et dans ce cas x(j, W 0 ) = x(j − 1, W 0 − wj ) + cj .
La complexité de l’algorithme est : O(nW ). En effet, il faut calculer tous les x(j, W 0 ) qui
sont au nombre de nW , et une fois calculés x(j − 1, W 0 ) et x(j − 1, W 0 − wj ), la quantité
x(j, W 0 ) se calcule en temps constant. Ce n’est pas polynomial car W nécessite log2 (W ) bits
pour être codé. On dit que c’est un algorithme pseudo-polynomial.
3.1.4 Les poids sont quelconques, mais le graphe est sans circuit absorbant : encore la
programmation dynamique
Supposons maintenant que l’on se demande comment calculer un plus court chemin dans
un graphe orienté pondéré, non nécessairement acircuitique. C’est encore possible si le graphe
ne possède pas de circuit absorbant, i.e. de circuit dont la somme des poids est < 0. Ce cas
contient les deux cas précédents (graphe avec poids ≥ 0 et graphe acircuitique). Noter qu’une
fois encore, il existe toujours un plus court chemin qui soit un chemin élémentaire car si le
plus court chemin passe par un circuit, on peut supprimer ce circuit sans détériorer le poids
du chemin.
En fait, pour calculer un plus court chemin dans un graphe sans circuit absorbant, on
peut appliquer la méthode de la programmation dynamique vue ci-dessus.
On considère que les états sont les sommets (Xk = V ) et qu’à chaque instant on traverse
un arc. Le coût de la transition u → v, c’est w(u, v) si (u, v) ∈ A, et +∞ sinon. Avec les
notations de la programmation dynamique, λ(k, v), c’est donc le poids minimal d’un s-v
chemin comportant exactement k arcs.
L’algorithme sera une traduction de l’équation de la programmation dynamique ou équation

de Bellman
λ(k, v) = min (λ(k − 1, u) + w(u, v)) (3.3)
(u,v)∈A
pour tout v ∈ V . Cette équation peut être lue de la manière suivante :

Le plus court chemin de s à v utilisant k arcs est le plus court chemin de s à
un certain antécédent u de v, utilisant k − 1 arcs, chemin auquel on a ajoute le
dernier arc (u, v).
En utilisant l’algorithme de la programmation dynamique, on calcule donc les λ(k, v)
de proche en proche, en augmentant progressivement k. Il est inutile de considérer le cas
k > n, où n est le nombre de sommets, car l’absence de circuit absorbant garantie l’existence
d’un chemin de poids minimal qui soit sans circuit. En effet, supprimer un circuit dans un
chemin fait diminuer son poids total. Puisqu’un chemin sans circuit a moins d’arcs qu’il y a
de sommets dans le graphe, on peut dérouler l’algorithme de programmation dynamique en
s’arrêtant au calcul des λ(n − 1, v), pour v ∈ V .
Une fois tous les λ(k, v) calculés pour k = 0, . . . , n − 1 et pour v ∈ V , le poids minimal
d’un s-t chemin pour un sommet t donné est obtenu en cherchant le k minimisant λ(k, t).
Remarquons qu’il n’est pas difficile de reconstruire le plus court chemin : en même temps
que λ(k, v), on peut stocker pk (v) qui est le sommet qui a permis d’obtenir le poids λ(k, v).
Comme ci-dessus, on récupère ainsi un plus court chemin de s à v pour tout v ∈ V .
Théorème 3.3. Etant donnés un graphe D = (V, A) et une fonction de poids w : A → R

telle qu’il n’y ait pas circuit absorbant, un ensemble de plus courts chemins de s à tout
sommet v ∈ V peut être calculé en O(nm).
Remarque : En utilisant des techniques totalement différentes [11], on peut obtenir une
complexité de O(n1/2 m log C) où C est la valeur abolue du plus petit poids négatif (en
supposant que C ≥ 2).
3.1.5 Les poids sont quelconques

Dans le cas général, il n’y a pas d’algorithme polynomial qui trouve un plus court chemin
élémentaire. Rappelons qu’un chemin élémentaire est un chemin dans lequel chaque sommet
apparaı̂t au plus une fois. Si l’on ne se restreint pas au chemin élémentaire, le problème peut
ne pas avoir de solution : en effet, en faisant passer un chemin par un circuit absorbant, on
peut répéter un nombre arbitraire de fois le passage sur le circuit absorbant et décroı̂tre le
coût autant qu’on le souhaite.
Considérons le problème
Problème du plus court chemin élémentaire

Donnée : Un graphe orienté D = (V, A), une fonction de poids w : A → R, deux sommets
s ∈ V et t ∈ V .
we
we
we
Figure 3.3 – Une transformation qui fait apparaı̂tre des circuits.
Tâche : Trouver un plus court chemin élémentaire de s à t.
On a le théorème suivant dont la preuve est laissée en exercice.

Théorème 3.4. Le problème du plus court chemin élémentaire avec des poids quelconques,
dans un graphe orienté quelconque, est NP-difficile.
3.2 Cas du graphe non-orienté

3.2.1 Les poids sont positifs : toujours l’algorithme de Dijkstra
Considérons un graphe (non-orienté) G = (V, E), avec une fonction de poids w : E →
R+ . Supposons fixés deux sommets s et t. On veut trouver la plus courte chaı̂ne de s à t.
Remarquons que le raisonnement fait précédemment s’applique encore : on sait qu’il existe
une chaı̂ne élémentaire de même poids que la chaı̂ne de plus petit poids puisqu’on peut
supprimer les cycles d’une chaı̂ne de plus petit poids (ces cycles sont alors forcéments de
poids nul).
L’algorithme de Dijkstra permet encore de résoudre le problème : en effet, il suffit de
remplacer chaque arête uv du graphe par deux arcs (u, v) et (v, u) et de mettre sur chacun
d’eux le poids de l’arête uv. Voir Figure 3.3. Un plus court chemin dans ce graphe orienté
induit alors une plus courte chaı̂ne dans le graphe de départ et réciproquement.
3.2.2 Les poids sont quelconques, mais sans cycle absorbant

Il peut être tentant de vouloir refaire la même transformation que dans la sous-section
précédente, à savoir de remplacer chaque arête par deux arcs de sens opposés, chacun recevant
le poids de l’arête dont ils sont issus. Le problème, c’est que dans cette transformation, on
fait apparaı̂tre quantité de circuits absorbants : toute arête de poids < 0 induit un circuit
absorbant à deux arcs. Les algorithmes de style programmation dynamique ne peuvent pas
appliquer. Il n’y a pas de raison particulière de penser que ce problème soit NP-difficile
car le problème qui est NP-difficile est celui où l’on accepte des circuits absorbants avec un
nombre d’arcs non borné. Ici nos circuits absorbants ont deux arcs seulement.
En fait, il y a bien un algorithme polynomial mais curieusement il provient d’un tout autre
domaine de l’optimisation discrète que nous évoquerons dans le chapitre sur les tournées
(Chapitre 11), le T -joint, qui apparaı̂t naturellement dans les problèmes de tournée du style
facteur . Avec cet outil, on peut trouver une plus courte chaı̂ne élémentaire en O(n ).
3
3.2.3 Les poids sont quelconques
Dans le cas général, le problème est à nouveau NP-difficile.
Problème de la plus courte chaı̂ne élémentaire
Donnée : Un graphe G = (V, E), une fonction de poids w : E → R, deux sommets s ∈ V et

t∈V.
Tâche : Trouver une plus courte chaı̂ne élémentaire de s à t.
On a le théorème suivant.
Théorème 3.5. Le problème de la plus courte chaı̂ne élémentaire avec des poids quelconques,
dans un graphe quelconque, est NP-difficile.
3.3 Résumé
Complexité
Graphe orienté, poids positifs O(n2 ) (Dijkstra) 1
Graphe orienté, poids quelconques, O(m)
acircuitique (Programmation dynamique)
Graphe orienté, poids quelconques, O(nm)
sans circuit absorbant (Programmation dynamique, algorithme de Ford-Bellman) 2
Graphe orienté, poids quelconques NP-difficile
Graphe non-orienté, poids positifs O(n2 ) (Dijkstra) 1
Graphe non-orienté, poids quelconques, O(n3 )
pas de cycle absorbant (voir Chapitre 11)
Graphe non-orienté, poids quelconques NP-difficile
3.4 Exercices
3.4.1 Plus court chemin
Trouver la plus courte chaı̂ne de s à t dans le graphe de la Figure 3.4 et le plus court
chemin de s à t dans le graphe de la Figure 3.5.
1. On peut atteindre, avec les bonnes structures de données, O(m + n log n).
2. On peut atteindre avec des techniques différentes O(n1/2 m log C).
a 1 b
3 2
5 2 10
c
s
6 1 9
d
g 3
h
4
f 2 1
3
t
2
3
e 5
6
i
Figure 3.4 – On cherche la plus courte chaı̂ne de s à t.
3.4.2 Problème du goulot

Soit N un réseau (de gaz par exemple) modélisé par un graphe orienté. Une origine o et
une destination d sont données. Pour chaque arc, on dispose d’une capacité c : A → R+ .
La capacité d’un chemin est le minimum des capacités de ses arcs. Proposer un algorithme
efficace qui trouve la capacité maximale d’un chemin de o à d.
3.4.3 Gestion de stock

k 1 2 3
Un stock suit une dynamique xk+1 = xk − dk + uk , avec x1 = 2 et
dk 3 2 4
La quantité dk est la demande pour la période k (supposée connue). xk ∈ N est nombre
d’unités disponibles en début de période k. uk est le nombre d’unités commandées (et reçues
immédiatement) en début de période k . On a une capacité maximale de stockage de 6, i.e
que l’on doit toujours avoir xk + uk ≤ 6 (ou de manière équivalente xk+1 + dk ≤ 6).
Le coût de gestion de stock pour la période k se décompose en un coût d’approvisionne-
ment et un coût de stockage et s’écrit 4uk + 3 + xk+1 si uk 6= 0 et xk+1 sinon.
Trouver la stratégie qui minimise le coût total de la gestion du stock.
3.4.4 Problème du sac-à-dos

Un bâteau peut transporter une cargaison formée à partir de N conteneurs. Le poids
total ne doit pas dépasser W . Le kième conteneur pèse wk et son transport rapporte ck . On
2
a
10
3
−2
s
b c
4
2
6
3 3
t
5
d
Figure 3.5 – On cherche le plus court chemin de s à t.
veut déterminer un chargement qui maximise le bénéfice. Montrer que ce problème est un
problème de sac-à-dos. Le résoudre sur les données W = 6 et
Conteneurs
1 2 3
Bénéfice ck 9 2 8
Poids wk 5 3 2
Même question avec le tableau suivant, W = 13 et avec la possibilité de prendre autant

de conteneurs de type k que l’on veut.
Conteneurs
1 2 3
Bénéfice ck 12 25 50
Poids wk 4 5,5 6,5
3.4.5 Remplacement de machine

Une entreprise vient de faire l’acquisition d’une machine neuve, dont elle a besoin pour
assurer son bon fonctionnement pour les cinq années à venir. Une telle machine a une durée
de vie de trois ans. A la fin de chaque année, l’entreprise peut décider de vendre sa machine
et d’en racheter une neuve pour 100 000¤. Le bénéfice annuel assuré par la machine est noté
bk , son coût de maintenance ck et son prix de revente pk . Ces quantités dépendent de l’âge
k de la machine et sont indiquées dans le tableau ci-dessous.
Age k de la machine en début d’année

k 0 1 2
bk 80 000¤ 60 000¤ 30 000¤
ck 10 000¤ 14 000¤ 22 000¤
pk 50 000¤ 24 000¤ 10 000¤
Proposer la stratégie de remplacement de la machine maximisant le profit de l’entreprise,

sachant qu’à la fin de ces cinq années elle n’aura plus besoin de la machine.
3.4.6 Problème d’investissement - d’après Hêche, Liebling et de Werra [6]

Une entreprise dispose d’un budget de 500 000¤ pour l’amélioration de ses usines pendant
l’année à venir. L’entreprise possède trois sites de production dont les bénéfices annuels
espérés, en fonction de la somme investie pour leur amélioration, sont données dans le tableau
suivant.
Montants investis
(en centaines de milliers d’euros)
Sites 0 1 2 3 4 5
Bénéfices annuels
1 1 3 4 5 5,5 6
2 0,5 2,5 4 5 6 6,5
3 2 4 5,5 6,5 7 7,5
3.4.7 Un problème d’intérimaires

Une entreprise a une tâche à réaliser, qui va prendre 5 mois. Pour chaque mois, elle a
besoin des nombres suivants d’intérimaires en plus de ses salariés.
Mois Nombre d’intérimaires

1 10
2 7
3 9
4 8
5 11
Embaucher un intérimaire coûte 800¤ (embauche + formation). La fin d’une embauche

coûte 1200¤. Enfin, le coût mensuel d’un des ces intérimaires est de 1600¤ (salaire +
charges). Trouver la stratégie de recrutement qui minimise les coûts.
3.4.8 Livraisons avec fenêtres de temps : cas linéaire

Supposons qu’un camion ait à livrer des points x1 , x2 , . . . , xn , tous situés sur une droite.
Pour chaque point xi , on connaı̂t l’instant le plus tard di où la livraison peut se faire. Le
camion se situe au départ en un point x0 , et veut terminer sa tournée au plus tôt. Le camion
n’a pas à retourner à son point de départ. De plus, on suppose que la livraison en chaque
point se fait de manière instantanée, et que le temps pour aller de xi à xj est proportionnel
à la distance les séparant. Montrer que l’on peut trouver la tournée optimale en O(n2 ) par
un algorithme de type programmation dynamique (c’est un résultat de Tsitsiklis).
3.4.9 Biologie : plus long sous-mot commun

Un mot w sur un alphabet Σ est une suite finie w1 w2 . . . wn d’élément de Σ. La quantité
n est appelé longueur du mot w. On dit qu’un mot w0 = w10 , . . . wn0 0 de longueur n0 est
un sous-mot de w s’il existe une application f strictement croissante de {1, 2, . . . , n0 } dans
{1, 2, . . . , n} telle que wi0 = wf (i) pour tout i ∈ {1, 2, . . . , n0 }. En d’autres termes, en effaçant
des lettres de w, on peut obtenir w0 . Par exemple : ABC est un sous-mot de AEBBAC,
mais n’est pas un sous-mot de AECAB.
On se donne deux mots w1 et w2 sur un alphabet Σ. On cherche leur sous-mot commun
0
w le plus long. Montrer que c’est un problème de type programmation dynamique, et qu’il
peut se résoudre en O(n1 n2 ), où n1 et n2 sont les longueurs de w1 et de w2 .
Ce problème a des applications en biologie, lorsque on veut évaluer la “distance” séparant
deux brins d’ADN.
3.4.10 Déplacement de wagonnet dans un mine souterraine avec contrainte d’orientation

Les mines souterraines sont souvent dotées d’un réseau ferré souterrain sur lequel circulent
des wagonnets. Ces derniers servent essentiellement à évacuer la roche sans valeur extraite
lors des forages. Un wagonnet récupère la roche dans sa benne en un point d’extraction et
se déplace le long du réseau, jusqu’à atteindre un point d’évacuation. Un wagonnet peut se
déplacer en avant ou en arrière, mais la benne se trouve à l’avant. Cela signifie que lorsque le
wagonnet arrive en un point d’extraction ou un point d’évacuation, il faut impérativement
qu’il arrive en marche avant, les demi-tours étant impossibles. L’objectif de ce problème est
de proposer une méthode qui trouve les trajets les plus courts satisfaisant cette contrainte
additionnelle. On se limite au cas à un seul wagonnet (dans le problème réel, la question de
la congestion induite par les autres wagonnets se pose également).
La Figure 3.6 représente un tel réseau souterrain. Un wagonnet ne peut suivre que des
trajectoires C 1 (pas de changement d’orientation discontinu) ou faire des marches arrière. La
Figure 3.7 reprend ce réseau et met en exergue quelques points. L’enchaı̂nement
A→B→G
est impossible car l’orientation du wagonnet changerait brusquement en B. En revanche,

l’enchaı̂nement
A→B→C→D→E→F →G
est possible.
Concernant l’orientation du wagonnet, l’enchaı̂nement
H → I → J,
Figure 3.6 – Un exemple de réseau souterrain
également possible, fait changer l’orientation du wagonnet : s’il se déplaçait en marche avant
en H, il se déplace en marche arrière en J.
1. Est-il possible pour le réseau de la Figure 3.6 de passer de n’importe quel point de
réseau à n’importe quel autre ? Peut-on de plus le faire avec les orientations du wagonnet au
départ et à l’arrivée imposées ? Justifier brièvement vos réponses.
2. Considérons le graphe dont les sommets sont les tronçons, et les arêtes les enchaı̂nements
possibles entre les tronçons. La construction est explicitée sur la Figure 3.8. Oublions mo-
mentanément l’orientation. Quitte à modifier un peu le graphe, expliquer comment utiliser
ce graphe pour trouver le plus court trajet entre deux points particuliers du réseau.
3. Montrer que, en introduisant une copie de ce graphe et au prix de quelques transfor-

mations, on peut de plus trouver le plus court trajet entre deux points avec les orientations
du wagonnets au départ et à l’arrivée imposées.
3.4.11 Intervalles disjoints et locations rentables

On suppose donnée une collection finie C d’intervalles fermés bornés de la droite réelle.
On dispose d’une application poids w : C → R+ .
1. Montrer que l’on sait trouver le sous-ensemble d’intervalles de C deux à deux disjoints
de poids maximal en temps polynomial (indication : construire un graphe orienté acircuitique
pondéré).
2. Application : Vous êtes chargé de la location d’un appartement. Vous connaissez un

ensemble de demandes, chacune d’entre elles étant caractérisée par un instant de début, un
E
F
A C
Figure 3.7 – Quelques points explicités dans le réseau de la Figure 3.6
c
e d e d c
b b
a
a
f
Figure 3.8 – Illustration de la construction du graphe de la question 2.

instant de fin et le gain qu’apporterait la satisfaction de cette demande. Montrez que grâce
à la question 1., on sait proposer une stratégie rapide maximisant le gain total de la location
de l’appartement.
CHAPITRE 4
Programmation linéaire
4.1 Définition et exemples

Un programme linéaire est un programme qui peut s’écrire sous la forme (forme inéquationnelle)
Min cT x
(4.1)
s.c. Ax ≤ b,
où x, c ∈ Rn , b ∈ Rm et où A est une m × n matrice réelle.

La programmation linéaire est peut-être le cas particulier de programmation mathématique,
i.e. d’optimisation d’une fonction sous contrainte, le plus fréquemment rencontré dans l’in-
dustrie. Beaucoup de problèmes se modélisent comme des programmes linéaires, bien plus de
problèmes encore font appel à la programmation linéaire pour résoudre des sous-problèmes
qui mis bout-à-bout permettent la résolution du problème de départ.
Exemple
Commençons par un exemple de problème de production dans l’agro-alimentaire 1 . Sup-
posons que l’on dispose d’une grande surface cultivable sur laquelle il est possible de faire
pousser des navets ou des courgettes. Le coût des semences est considéré comme négligeable.
On dispose de deux types d’engrais X et Y, ainsi que d’un anti-parasite AP. Le besoin en
engrais et en anti-parasite pour les courgettes et pour les navets est synthétisé dans le tableau
suivant.
Engrais X Engrais Y Anti-parasite AP

Courgettes 2 l.m−2 1 l.m−2 0 l.m−2
Navets 1 l.m−2 2 l.m−2 1 l.m−2
On dispose comme ressource de 8 l d’engrais X, de 7 l d’engrais Y et de 3 l d’anti-parasite

AP.
On peut s’attendre à une productivité de 4 kg.m−2 pour les courgettes et de 5 kg.m−2
pour les navets, et à un gain de 1¤.kg−1 tant pour les courgettes que pour les navets.
Quel est le gain maximum qui peut être fait compte tenu des ressources disponibles ?
1. Source : N. Brauner.
CHAPITRE 4. PROGRAMMATION LINÉAIRE 48
On modélise ce problème comme un programme linéaire.

Variables de décision : x : surface de courgettes.
y : surface de navets.
Fonction objectif : Max 4x + 5y
Contraintes 2x + y ≤ 8 (ressources d’engrais A)
x + 2y ≤ 7 (ressources d’engrais B)
y≤3 (ressources d’anti-parasite AB)
x ≥ 0 et y ≥ 0.
On veut donc résoudre le programme suivant.
Max 4x + 5y
s.c. 2x + y ≤ 8
x + 2y ≤ 7
y≤3
x ≥ 0, y ≥ 0
Ce programme est bien un programme linéaire comme défini par l’équation (4.1), avec
   
8 2 1
 7   1 2 
4    
c= , b= 3  A= 0
   1 .
5  0   −1 0 
0 0 −1
Comme nous l’avons déjà noté lors du premier cours, le fait qu’il y ait Max dans notre
problème au lieu d’un Min comme dans l’équation (4.1) ne pose pas de problème : maximiser
une quantité revient à minimiser son opposé.
Comme on n’a que deux variables, on peut procéder à une représentation graphique (voir
Figure 4.1).
Problème de production
On considère une entreprise qui produit des biens de n types différents. Pour cela, elle
dispose de m types de ressources. Elle possède bi unités de la ressource i pour i = 1, . . . , m.
La production d’une unité du bien j entraı̂ne un bénéfice égal à cj , pour j = 1, . . . , n. Pour
produire une unité du bien j, elle a besoin de aij unités de chaque ressource i. Maximiser le
profit revient alors à résoudre le programme linéaire suivant.
Pn
Max cj x j
Pj=1
n
s.c. j=1 aij xj ≤ bi i = 1, . . . , m (4.2)
xj ≥ 0, j = 1, . . . , n.
La variable xj représente le nombre d’unités du bien j produites.
C’est un exemple classique et très fréquent de la programmation linéaire. L’aspect allo-
cation optimale des ressources de la RO est particulièrement bien illustré par le problème
de production.
49 CHAPITRE 4. PROGRAMMATION LINÉAIRE
P = {(x, y) : 2x + y ≤ 8, x + 2y ≤ 7, y ≤ 3, x ≥ 0, y ≥ 0}
y=3
x
x + 2y = 7
2x + y = 8
Figure 4.1 – Représentation graphique des contraintes du problème des navets et des courgettes.
Dans l’exemple des navets et des courgettes, nous avons pu résoudre le problème assez
facilement car il n’y avait que 2 variables, et donc une représentation graphique était possible.
Mais la plupart des problèmes réels le nombre de variables et le nombre de contraintes
peuvent dépasser le millier, et ni l’intuition, ni le dessin peuvent alors nous tirer d’affaire.
Heureusement, depuis la fin des années 40, de nombreux chercheurs ont travaillé sur la
programmation linéaire, et c’est maintenant un problème qui est bien résolu tant sur le plan
pratique que sur le plan théorique.
Plan pratique De nombreux logiciels (libres et commerciaux) résolvent des programmes
linéaires de grande taille. Voir la liste en annexe du polycopié. Il y a principalement deux
algorithmes qui sont utilisés dans ces codes : l’algorithme du simplexe et l’algorithme
des points intérieurs. On devrait plutôt parler de familles d’algorithmes car tant l’algo-
rithme du simplexe que l’algorithme des points intérieurs existent sous de nombreuses
variantes.
Plan théorique La programmation linéaire est dans P. Cela signifie qu’il existe des algo-
rithmes polynomiaux qui résolvent la programmation linéaire. L’algorithme des points
intérieurs est un de ceux-là. L’algorithme du simplexe, bien que très rapide en pratique,
ne possède pas pour le moment de version polynomiale : pour chacune de ses versions,
on connaı̂t des instances qui nécessitent un nombre exponentiel d’étapes.
Dans ce chapitre, nous donnons quelques propriétés théoriques de la programmation
linéaire (PL), qui ont un grand intérêt pratique (polyèdres, dualité,...). Les différents algo-
rithmes qui résolvent la programmation linéaire sont également présentés.
4.2 Quelques éléments théoriques
4.2.1 Forme standard

L’algorithme du simplexe et l’algorithme des points intérieurs utilisent une écriture du
programme linéaire différente de celle de l’équation (4.1). Ils utilisent la forme standard qui
consiste à écrire le programme linéaire de la façon suivante :
Min cT x
s.c. Ax = b (4.3)
x ≥ 0.
Comme d’habitude, x est le vecteur des variables, A est une matrice m × n donnée, c ∈ Rn ,
b ∈ Rm sont deux vecteurs donnés et 0 est le vecteur 0, avec n composantes.
En plus de la forme standard et de la forme inéquationnelle, il existe la forme canonique
qui consiste à écrire le programme linéaire de la façon suivante :
Min cT x
s.c. Ax ≤ b (4.4)
x ≥ 0.
Ces trois formes sont équivalentes : à partir d’une solution réalisable d’un programme
sous l’une des formes, on peut aisément construire une solution réalisable pour les deux
autres formes, donnant une même valeur pour la fonction objectif.
Passage de la forme standard à la forme canonique et réciproquement

A
Pour passer de la forme standard à la forme canonique, on pose A := 0
, b0 :=
−A
b
, c0 := c. Le programme
−b
0
Min c T x
s.c. A0 x ≤ b0
x≥0
est alors clairement équivalent au programme (4.3).
La transformation réciproque consiste à poser A0 := A Im , b0 = b et c0 := (c, 0).

Concrètement, cela revient à ajouter des variables d’écart y et à considérer le programme
Min cT x
s.c. Ax + y = b
x, y ≥ 0.
Passage de la forme standard à la forme inéquationnelle et réciproquement

 
A
Pour passer de la forme standard à la forme inéquationnelle, on pose A0 :=  −A ,
  −In
b
b0 :=  −b , c0 := c. Le programme
0
0
Min c T x
s.c. A0 x ≤ b0 ,
est alors clairement équivalent au programme (4.3).

La transformation réciproque est un peu plus subtile. On a alors le programme linéaire
sous forme standard suivant :
Min c0T x0
s.c. A0 x0 = b0 (4.5)
0
x ≥ 0,
avec A0 := A −A Im , b0 := b et c0 := (c, −c, 0). Il faut montrer que toute solution

optimale de l’équation (4.1) donne une solution optimale de ce programme et réciproquement.

Pour ce faire, nous allons montrer que toute solution réalisable de l’équation (4.1) donne une
solution réalisable de même coût pour ce programme.
Prenons une solution réalisable x du programme (4.1). On construit les variables u, v ∈
R et y ∈ Rm de la manière suivante
n
yi := bi − (Ax)i pour j = 1, . . . , m
et
xj si xj ≥ 0 −xj si xj ≤ 0
uj := et vj := pour j = 1, . . . , n.
0 sinon, 0 sinon,
Il est alors aisé de vérifier que x0 := (u, v, y) est une solution réalisable du programme (4.5),
et que l’on a bien cT x = cT u − cT v.
Réciproquement, soient x0 = (u, v, y) une solution réalisable du programme (4.5). Posons
x := u − v. Le vecteur x est alors une solution réalisable du programme (4.3), et l’on a bien
cT x = cT u − cT v.
4.2.2 Préliminaires
Dans la suite, on supposera sans perte de généralité, que la matrice A de la forme standard
(4.3) est de plein rang, c’est-à-dire que les m lignes sont linéairement indépendantes. En effet,
on peut tester l’existence d’une solution réalisable en résolvant l’équation Ax = b (par des
pivots de Gauss par exemple). S’il y a une solution réalisable et si les lignes de A ne sont pas
linéairement indépendantes, alors forcément l’équation correspondante est redondante et on
peut la supprimer. D’où
Hypothèse : Nos programmes linéaires sous forme standard seront tels que A est de plein
rang.
4.2.3 Solutions basiques réalisables

On suppose toujours que A est une matrice m × n, de plein rang. Pour introduire la
notion de solution basique, nous introduisons la notation suivante : pour une partie B ⊆
{1, 2, . . . , n}, on note AB la sous-matrice de A réduite aux colonnes indicées par les éléments
de B.
Par exemple, si  
1 2 0 3 3 1
A =  0 8 9 3 4 4 ,
5 6 0 7 1 1
et si B = {1, 4, 5} alors  
1 3 3
AB =  0 3 4  .
5 7 1
Une notation semblable sera utilisée pour les vecteurs : si x = (5, 4, 5, 1, 1, 2) et B =
{1, 4, 5}, alors xB = (5, 1, 1).
Remarquons que pour une partie B fixée, on peut réécrire l’égalité Ax = b sous la forme
AB xB + AN xN = b, (4.6)
où N est le complémentaire de B dans {1, . . . , n}.

Une partie B ∈ {1, 2, . . . , n} à m éléments est appelée base si la matrice AB est inver-
sible. Dans ce cas, on peut réécrire le système Ax = b dans la base B en transformant
l’écriture (4.6) en
xB + A−1 −1
B AN xN = AB b.
La solution x̃ du système Ax = b obtenue en posant x̃B := A−1 B b et x̃N := 0 est une solution
basique. Si cette solution basique est réalisable (par rapport au programme linéaire (4.3)),
i.e. si A−1
B b ≥ 0, alors on dit que x̃ est une solution basique réalisable, et que B est une base
réalisable.
On a alors le théorème important suivant qui constitue la base de l’algorithme du sim-
plexe.
Théorème 4.1. Considérons un programme linéaire sous forme standard (forme (4.3)).
Alors
— si l’ensemble des solutions réalisables est non-vide et si la fonction objectif est bornée
inférieurement sur cet ensemble, alors il existe une solution optimale.
— s’il existe une solution optimale, alors il existe une solution optimale qui soit basique
réalisable.
Ce théorème conduit à un algorithme naı̈f pour résoudre un programme linéaire : comme

n

il n’y a qu’un nombre fini de bases (au plus m ), on essaye chaque base l’une après l’autre et
on garde celle réalisable qui fournit la plus petite valeur pour cT x. Il faudrait encore vérifier
que le fonction objectif est bornée inférieurement, mais dans tous les cas, un tel algorithme
n’a aucun intérêt pratique. En effet, le nombre d’étapes est exponentiel 2 .
L’algorithme du simplexe va également énumérer des bases réalisables, mais dans un ordre
intelligent, ce qui va réduire considérablement (en général) le nombre de bases réalisables à
évaluer. Pour décrire cet ordre (voir Section 4.3.1), on a besoin de la notion de base voisine.
B 0 est une base voisine de la base B si c’est une base telle que B 0 \ B ne contient qu’un
élément (et puisque les bases ont toute même cardinalité, elle est également telle que B \ B 0
ne contient qu’un élément).
Il se peut aussi que l’ensemble des solutions réalisables soit non-vide, mais que la fonction
objectif ne soit pas bornée inférieurement sur cet ensemble. Dans ce cas, on a un rayon infini.
Théorème 4.2. Considérons un programme linéaire sous forme standard (forme (4.3)). Si
l’ensemble des solutions réalisables est non-vide et si la fonction objectif n’est pas bornée
inférieurement sur cet ensemble, alors il existe x0 et q tels que les points x(t) = x0 − tq
soient tous réalisables pour t ≥ 0, et tels que limt→+∞ cT x(t) = −∞.
L’ensemble des points x(t) = x0 − tq pour t ≥ 0 est appelé rayon infini. La variable t
est le paramètre de ce rayon, x0 son origine et q sa direction.
4.2.4 Polyèdres
On peut également essayer de voir ce que signifie le programme (4.3), un peu comme
on l’a fait dans la résolution de l’exemple introductif des navets et des courgettes. Les
contraintes Ax = b et x ≥ 0 délimitent ce qu’on appelle un polyèdre, c’est-à-dire une
partie de Rn obtenue comme intersection d’un nombre fini de demi-espaces fermés délimités
par des hyperplans.
On vérifie facilement qu’un polyèdre est convexe, c’est-à-dire que pour toute paire de
points x et y d’un polyèdre P , l’ensemble des points du segment [x, y] est inclus dans P .
Un polyèdre possède en général des points extrêmes ou sommets, qui sont les “pointes”,
ou les “piques” du polyèdre (voir Figure 4.2). Pour éviter la confusion avec les sommets des
graphes, nous utiliserons plutôt l’appellation “points extrêmes” dans ce cours. On définit
n
' 4m .

2. Par exemple, pour n = 2m, on a m
Figure 4.2 – Un polyèdre.
mathématiquement un point extrême de la manière suivante. v ∈ P est un point extrême de

P si pour tout x, y ∈ P , on a l’implication
(le segment [x, y] contient v) ⇒ (v = x ou v = y).
Autrement dit, on ne peut avoir un segment inclus dans P et non réduit à un point qui
contienne v.
En réalité, comme le montre le théorème suivant, les points extrêmes et les solutions
basiques réalisables recouvrent le même concept.
Théorème 4.3. Soit P l’ensemble des solutions réalisables du programme linéaire (4.3) (P
est donc un polyèdre). Soit v ∈ P . Les deux assertions sont équivalentes :
— v est une solution basique réalisable de (4.3).
— v est un point extrême de P .
On peut voir une illustration sur la Figure 4.3, qui montre la solution optimale au
problème des navets et des courgettes du début du chapitre.
4.3 Algorithmes
Il y a trois (familles d’) algorithmes résolvant les programmes linéaires : le simplexe, les
ellipsoı̈des et les points intérieurs.
Nous allons décrire dans ces grandes lignes l’algorithme du simplexe et très brièvement
l’algorithme des points intérieurs. Notre objectif est de permettre d’en comprendre les prin-
cipes et certaines de leurs propriétés. Rappelons que lorsqu’un problème est décrit comme
un programme linéaire, il est inutile de programmer un algorithme pour le résoudre : de
nombreux logiciels, dont certains libres, le font déjà avec d’excellentes performances. Même
EXCEL dispose d’une implémentation de l’algorithme du simplexe.
Pour la description exacte de ces algorithmes, il existe de nombreux ouvrages. Un excellent
ouvrage qui couvre l’ensemble de la programmation linéaire et de ces algorithmes est celui
4x + 5y = 22 x
l’optimum est atteint en (x∗ , y ∗ ) = (3, 2)
Figure 4.3 – La solution optimale au problème des navets et des courgettes est un sommet du polyèdre.
de Matoušek et Gärtner [21]. Sur l’algorithme du simplexe, le meilleur livre est certainement
celui de Chvátal [4]. Sur l’algorithme des ellipsoı̈des, le livre de Grötchel, Lovász et Schrijver
est une excellente référence et un grand classique [13]. Enfin, sur les points intérieurs, l’article
de Terlaky est une bonne introduction aux points intérieurs [22].
Sur le plan pratique, l’algorithme des ellipsoı̈des n’a pas encore fait ses preuves, ce qui
explique qu’il ne soit pas décrit dans ce cours. Son intérêt est (pour le moment ?) théorique
et historique puisqu’il constitue le premier algorithme polynomial proposé pour la program-
mation linéaire (en 1979, par Khachyan). Avant 1979, la question, alors ouverte, de savoir
s’il était possible de résoudre la programmation linéaire en temps polynomial passionnait
beaucoup de chercheurs.
4.3.1 Le simplexe
L’idée de l’algorithme du simplexe est de passer de base réalisable en base réalisable en
améliorant à chaque fois la valeur du critère. Comme le nombre de bases est fini, on obtient
l’optimum ou la preuve que le programme est non borné en un nombre fini d’étapes.
On suppose que l’on connaı̂t au départ une base réalisable B. L’algorithme du simplexe
commence par réécrire le programme (4.3) sous la forme équivalente
Min cTB A−1 T −1

B b + cN − cB AB AN xN
s.c. xB + A−1 −1
B AN xN = AB b (4.7)
x ≥ 0.
Il faut bien noter que ce programme et le programme (4.3) sont complètement équivalents.
L’avantage de cette forme, c’est qu’on peut directement lire la valeur de la solution basique
réalisable associée à B : c’est le terme constant cTB A−1
B b de la fonction objectif. En effet, la
−1
solution basique réalisable associée à B est x̃B = AB b et x̃N = 0.
Ensuite, l’algorithme cherche une base réalisable voisine B 0 qui améliore le critère (c’est
l’opération de pivot). Il est en effet assez simple de construire une telle base B 0 à partir de B,
simplement à la lecture des entrées de cN − cTB A−1 −1
B AN et de AB AN . On sélectionne d’abord
0
l’élément j ∈ / B qui va entrer dans B (la variable entrante xj ), à la lecture des coefficients
de cN − cTB A−1 B AN . Ensuite, à la lecture des coefficients de la colonne correspondante de
−1
AB AN , on trouve l’élément i qui va quitter B (la variable sortante xi ).
Variable entrante : Tout coefficient négatif de cTN − cTB A−1

B AN peut faire office de variable
entrante.
Variable sortante : Soit q la colonne de A−1 B AN correspondant à la variable entrante et
−1
soit p := AB b. On regarde les coefficients strictement positifs de q et parmi ceux-là, on
choisit la variable sortante xi telle que pi /qi soit le plus petit possible.
On réécrit ensuite le programme sous la forme équivalente

Min cTB 0 A−1 −1
T T

B 0 b + cN 0 − cB 0 AB 0 AN 0 xN 0
s.c. xB 0 + A−1 −1
B 0 AN 0 xN 0 = AB 0 b (4.8)
x ≥ 0.
pour laquelle on est à nouveau capable de lire la valeur du critère pour la solution basique
réalisable associée à B 0 (c’est cTB 0 A−1
B 0 b) et la solution basique réalisable elle-même (x̃B 0 =
−1
AB 0 b et x̃N 0 = 0).
Et on recommence.
L’optimalité est atteinte quand tous les coefficients de cTN 0 − cTB 0 A−1 B 0 AN 0 sont ≥ 0. En
effet, quelque soit alors le choix de xN 0 , qui est à coefficients positifs ou nuls, le critère verra
sa valeur augmenter.
De deux choses l’une, soit on termine sur une base optimale, soit à la lecture des coeffi-
cients, on voit que le programme est non bornée (i.e −∞ est la valeur optimale) : cela arrive
lorsque toutes les composantes de la colonne q correspondante à la variable entrante sont
négatives ou nulles, on a alors un rayon infini d’origine x̃B 0 et de direction q.
On a supposé que l’on disposait d’une base réalisable de départ. C’est en effet souvent le
cas. Par exemple, si le programme est sous forme canonique et si b ≥ 0, l’ajout des variables
d’écart fait apparaı̂tre une sous-matrice identité, voir Section 4.2.1, dont les colonnes sont
une base réalisable naturelle de départ. Sinon, on dispose de techniques standard pour tester
la réalisabilité du programme et trouver une base réalisable, voir Exercice 4.6.5.
Interprétation géométrique : L’algorithme du simplexe s’interprète facilement géométriquement.
En effet, deux bases réalisables voisines fournissent des solutions basiques réalisables qui sont
des points extrêmes confondus ou voisins (au sens des arêtes du polyèdre) du polyèdre des so-
lutions réalisables. L’opération de pivot consiste à “glisser” le long d’une arête du polyèdre 3
pour aller vers un point extrême voisin, de meilleur valeur par la fonction objectif.
Par conséquent, la suite des solutions basiques réalisables et des pivots générés par l’al-
gorithme du simplexe fournit une trajectoire qui passe par des points extrêmes et des arêtes
du polyèdre et qui cherche à se diriger dans le sens de c.
Efficacité de l’algorithme du simplexe : On considère qu’en général, pour un programme à
m contraintes, l’algorithme du simplexe va faire entre 2m et 3m opérations de pivots avant
d’arriver à l’optimum. La réécriture du système lors d’un pivot nécéssite O(m2 ) opérations.
On a donc en général O(m3 ) opérations pour résoudre un programme linéaire par l’algorithme
du simplexe, ce qui est tout à fait raisonnable. Sur des instance réelles, le simplexe fonctionne
bien.
Cela dit, il existe des instances pour lesquelles le nombre de pivots est exponentiel. La
question de savoir s’il existe une règle de pivot – c’est-à-dire une façon de choisir la variable
entrante lorsque le choix est possible – conduisant à un comportement polynomial est une
(importante) question ouverte.
4.3.2 Les points intérieurs

A l’opposé de l’algorithme du simplexe, l’algorithme des points intérieurs cherche à éviter
le bord du polyèdre et à rester le plus possible à l’intérieur. C’est seulement à la dernière
étape que l’algorithme atteint le bord, précisément sur une solution optimale.
3. ou à rester sur le même points extrême ; un pivot ne parvient pas toujours à améliorer directement la
valeur du critère.
Concrètement, cela consiste à considérer le coût pénalisé

n
X
T
fµ (x) := c x − µ · log xi
i=1
et à remplacer le programme (4.3) par le programme suivant
Min fµ (x)
s.c. Ax = b (4.9)
x > 0,
où x > 0 signifie que xi > 0 pour i = 1, . . . , n.

L’idée de l’algorithme est de faire tendre progressivement µ vers 0, et de chercher la
solution optimale x∗ (µ) du programme (4.9) pour chaque valeur de µ successive. La suite
des x∗ (µ) tend alors vers l’optimum du programme (4.3) (à quelques conditions techniques
près). La recherche de la solution optimale x∗ (µ) du programme (4.9) se fait en fait approxi-
mativement et utilise la solution optimale approximative du programme pour la valeur de µ
précédente – cette étape revient alors à une simple résolution d’un système linéaire.
Efficacité de l’algorithme des points intérieurs : La complexité de l’algorithme est O(n3 L)
où L est le nombre maximum de bits nécessaires pour coder un coefficient du programme,
ce qui en fait bien un algorithme polynomial. Le nombre √ d’itérations (nombre de µ distincts
pour lequel x∗ (µ) est approximativement calculé) est O( nL) mais en pratique cela semble
plutôt être un O(log n), ce qui en fait un algorithme réellement efficace.
4.4 Dualité
4.4.1 Dualité faible, dualité forte
Nous abordons maintenant la propriété théorique fondamentale de la programmation
linéaire, dont les applications sont innombrables. Il s’agit de la propriété de dualité.
En suivant la méthode présentée en Section 2.3.5, à tout programme linéaire, on peut
associer un autre programme linéaire, son dual. Le premier programme est le programme
primal. Lors de la transformation, les variables du primal deviennent les contraintes du dual
et les contraintes du primal deviennent les variables du dual.
Considérons par exemple, le programme linéaire suivant, sous forme standard :
Min cT x
s.c. Ax = b (4.10)
x ≥ 0.
Son dual se définit alors
Max bT y
(4.11)
s.c. AT y ≤ c.
Cela se vérifie aisément en suivant la méthode présentée à la Section 2.3.5.
Noter que chaque yi multiplie la ième ligne (la contrainte) de A, pour i = 1, . . . , m, et que
chaque colonne de A, associée chacune à une des n variables du programme (4.10), devient
une contrainte pour le programme (4.11).
Nous expliquons maintenant une preuve de l’inégalité de dualité faible, alternative à celle
présentée en Section 2.3.5.
Prenons une solution réalisable x du primal et une solution réalisable y du dual. Multi-
plions à gauche les contraintes du primal par y. On obtient
y T Ax = y T b.
En utilisant les contraintes du dual et le fait que les composantes de x sont positives, on
obtient cT x ≥ y T b ou plus lisiblement
cT x ≥ bT y.
On retrouve bien la dualité faible. En particulier, la valeur optimale du dual minore la valeur
optimale du primal (si optimum il y a).
En réalité, on a beaucoup plus : en général, pour la programmation linéaire, les valeurs

optimales des programmes primal et dual coı̈ncident. Plus précisément :
Théorème 4.4 (Théorème fort de la dualité pour la programmation linéaire). Pour les deux
programmes linéaires suivants
Min cT x
s.c. Ax = b (P)
x≥0
et
Max bT y
s.c. AT y ≤ c, (D)
une et une seule des possibilités suivantes se réalise
1. Ni (P), ni (D) n’ont de solution réalisable.
2. (P) est non borné et (D) n’a pas de solution réalisable.
3. (D) est non borné et (P) n’a pas de solution réalisable.
4. (P) et (D) sont tous deux réalisables. Ils ont alors tous deux des solutions optimales,
respectivement x∗ et y ∗ , et l’on a
cT x∗ = bT y ∗ .
Autrement dit, le minimum de (P) est égal au maximum de (D).
La preuve est omise, mais ce théorème peut se prouver soit en utilisant un lemme classique
en géométrie – le lemme de Farkas – soit en utilisant l’écriture de la base optimale dans
l’algorithme du simplexe (voir Exercice 4.6.4).
4.4.2 Dualité sous toutes ses formes
Dans le tableau suivant, on donne toutes les situations possibles. Un bon exercice consiste
à redémontrer ces programmes en utilisant la méthode de la Section 2.3.5.
Programme linéaire primal Programme linéaire dual
Variables x1 , x2 , . . . , xn y1 , y2 , . . . , ym
Matrice A AT
Membre de droite b c
Fonction objectif Min cT x Max bT y
ième contrainte a ≤ yi ≤ 0
Contraintes ≥ yi ≥ 0
= yi ∈ R
xj ≤ 0 jème contrainte a ≥
xj ≥ 0 ≤
xj ∈ R =
Une propriété importante de la dualité en programmation linéaire, qui se vérifie direc-
tement sur le tableau ci-dessus mais aussi à partir de la définition de la Section 2.3.5, est
que
Proposition 4.1. Le dual du dual est équivalent au primal.
4.4.3 Interprétation économique de la dualité
Soit le problème de production pour une entreprise E :

Pn
Max cj x j
Pj=1
n
s.c. j=1 aij xj ≤ bi i = 1, . . . , m
xj ≥ 0 j = 1, . . . , n.
Soit une firme F qui veut racheter les ressources de l’entreprise E. A quels prix doit-elle
le faire pour tout racheter au coût minimum ?
On note yi le prix de la ressource i. F doit fixer les yi de manière à ce que m
P
i=1 aij yi ≥
cj pour tout j = 1, . . . , n. En effet, pour tout j, cela garantit que E a intérêt à vendre
les ressources nécessaire pour produire une unité de j plutôt que de la produire. D’où le
programme mathématique suivant auquel se trouve confronté F.
Min Pm
P
i=1 bi yi
m
s.c. i=1 aij yi ≥ cj j = 1, . . . , n
yi ≥ 0 i = 1, . . . , m.
C’est précisément le dual du problème de production.

4.5 Une application de la dualité : jeux matriciels à somme nulle

Soit A = ((aji )) une matrice réelle à m lignes et n colonnes. Une telle matrice définit
ce qu’on appelle un jeu matriciel à somme nulle de la manière suivante. On se donne deux
joueurs, C pour colonne et L pour ligne . Le joueur C choisit une colonne i, et,
simultanément, le joueur L choisit une ligne j. Chacun reçoit aji . Le joueur C cherche à
minimiser, L cherche à maximiser.
Ce qu’on cherche en théorie des jeux, ce sont les équilibres de Nash, i.e. des situations
où aucun des joueurs n’a intérêt à changer de choix. Ici, lorsque le choix est restreint au
choix d’une ligne et d’une colonne, on parle d’un équilibre en stratégies pures. Un équilibre
de Nash en stratégies pures est un couple (j, i) tel que
aj 0 i ≤ aji0 , pour toute ligne j 0 et toute colonne i0 .
On ne peut pas toujours assurer l’existence d’un équilibre en stratégies pures.

En revanche, comme l’avait remarqué von Neumann, si les joueurs choisissent des dis-
tributions de probabilité, il y a un équilibre en stratégies mixtes, le gain des joueurs
Pk étant
k k
alors l’espérance de gain. Notons 4 l’ensemble des vecteurs z de R+ tels que i=1 zi = 1.
Un élément de 4k s’interprète comme une distribution de probabilité sur un ensemble à k
éléments. Si C choisit la distribution x ∈ 4n et L choisit la distribution y ∈ 4m , alors le gain
espéré est y T Ax. Un équilibre de Nash en stratégies mixtes est un couple (x̃, ỹ) ∈ 4n × 4m
tels que
y 0T Ax̃ ≤ ỹ T Ax0 pour tout x0 ∈ 4n et y 0 ∈ 4m .
Le théorème suivant, dû à von Neumann, assure l’existence d’un équilibre en stratégies
mixtes pour les jeux matriciels à somme nulle.
Théorème 4.5. Dans tout jeu matriciel à somme nulle, il existe un équilibre de Nash en
stratégies mixtes.
Démonstration. On peut supposer que toutes les entrées de A sont strictement positives. En effet, ajouter
une même constante sur chaque entrée de la matrice ne change rien au jeu.
Considérons le programme linéaire
Pn
Max i=1 xi
s.c. Ax ≤ 1 (4.12)
x ≥ 0.
Son dual est Pm
Min j=1 yj
s.c. y T A ≥ 1T (4.13)
y ≥ 0.
Le programme (4.12) est réalisable, car x = 0 est une solution réalisable. Le programme (4.13) est également
réalisable : A a toutes ses entrées strictement positives ce qui implique que tout y suffisament grand est
∗
solution réalisable.P
D’après le P
théorème 4.4, il existe
Pmx solution
Pn optimale du primal et y ∗ solution optimale
m n
du dual, telle que i=1 xi = j=1 yj . Soit w = i=1 xi = j=1 yj . Les solutions x̃ := w1 x∗ et ỹ := w1 y ∗
∗ ∗ ∗ ∗
satisfont les relations demandées.

On peut par ailleurs démontrer facilement que, même s’il y a plusieurs équilibres de Nash
en stratégies mixtes, la quantité y T Ax – i.e. w1 dans la preuve ci-dessus – ne change pas. On
l’appelle valeur du jeu.
4.6 Exercices
4.6.1 Production de boissons
Une entreprise fabrique trois types de boissons : XXX, YYY et ZZZ qui rapportent
respectivement 1, 55, 3, 05 et 4, 80 le litre. Chaque boisson a un niveau minimal de production
hebdomadaire qui sont respectivement de 1020, 1450 et 750 litres. 20 litres de chaque boisson
requiert un temps en heures de fabrication, un temps de mélange et un temps d’embouteillage.
XXX YYY ZZZ
fabrication 2 3 6
mélange 4 5,5 7,5
embouteillage 2 1 3,5
Pendant la semaine à venir, l’entreprise aura 708 heures disponibles en fabrication, 932
en mélange et 342 en embouteillage. Formuler un modèle donnant un plan de production qui
maximise le profit.
4.6.2 Un problème de raffinerie - d’après Hêche, Liebling et de Werra [6]

Une raffinerie doit fournir chaque jour deux qualités A et B d’essence à partir de consti-
tuants 1, 2 et 3. On note Qmax la quantité maximale disponible quotidiennement :
constituant Qmax coût unitaire
1 3000 3
2 2000 6
3 4000 4
essence spécification prix de vente unitaire
A ≤ 30% de 1 5,5
≥ 40% de 2
≤ 50% de 3
B ≤ 50% de 1 4,5
≥ 10% de 2
Donner un modèle qui permet de maximiser la recette, sachant que toute la production
pourra être écoulée.
4.6.3 Dual du dual

En utilisant les recettes de dualisation du cours, montrer que le dual du dual est équivalent
au primal.
4.6.4 Théorème fort de la dualité

En s’appuyant sur la caractérisation de l’optimalité de la solution retournée par l’algo-
rithme du simplexe, prouver le théorème fort de la dualité (Théorème 4.4). Plus précisément,
montrer que le programme (4.8) écrit dans la base optimale permet de construire des so-
lutions réalisables au dual (4.11) donnant le même coût à la fonction objectif. Expliquer
pourquoi cela permet de conclure.
4.6.5 Trouver une solution réalisable

Considérons le système suivant
Ax = b
(4.14)
x≥0
où b ∈ Rm et A est une m × n matrice réelle. L’objectif de l’exercice est de proposer une
méthode pour tester si un tel système a une solution réalisable, et s’il en existe, en trouver
une.
1. Montrer qu’on peut supposer que b ≥ 0.
Considérons maintenant le programme
Pm
Min i=1 yi
s.c. Ax + y = b
(4.15)
x≥0
y≥0
2. Montrer que le système (4.14) a une solution réalisable si et seulement si le programme (4.15)
a une valeur optimale = 0.
Par conséquent, l’algorithme du simplexe est une méthode pour résoudre un système de
la forme du système (4.14). En effet, le programme (4.15) a une solution basique réalisable
facile à identifier : y = b et x = 0. On peut alors dérouler l’algorithme du simplexe aisément
sur le programme (4.15) à partir de cette base initiale. Noter que s’il y a une solution au
système (4.14), cette méthode lui trouve une solution basique réalisable. C’est donc également
une méthode pour trouver une première solution réalisable à un programme linéaire pour
lequel il n’y en a pas d’évidente.
3. Réciproquement, montrer avec la théorie de la dualité que si on a une méthode pour trouver
une solution réalisable de n’importe quel système d’équations et d’inéquations linéaires, alors
on peut utiliser cette méthode pour résoudre les programmes linéaires.
4.6.6 Meilleure droite approximante

Soit (x1 , y1 ), (x2 , y2 ), . . . , (xn , yn ) des points dans le plan. On cherche la meilleure droite
approximante pour la norme sup, i.e. la droite du plan d’équation ax + b = y telle que
supi=1,...,n |axi + b − yi | soit le plus petit possible. Montrer que Pcela revient à résoudre un
programme linéaire. Même question en cherchant à minimiser ni=1 |axi + b − yi |.
4.6.7 Interprétation économique de la dualité

Un diététitien utilise six produits comme source de vitamines A et C. Il a une certaine
demande en vitamine A et en vitamine C. Il veut la satisfaire au moindre coût.
Produits (unités/kg) Demande

vitamine A 1 0 2 2 1 2 9
vitamine C 0 1 3 1 3 2 19
Prix par kg 35 30 60 50 27 22
1. Modéliser ce problème comme un programme linéaire.

2. Ecrire le programme dual. Proposer une interprétation.
4.6.8 Programmation linéaire en nombres entiers

Un programme linéaire du type
Min cT x
s.c. Ax = b (4.16)
xj ∈ N j = 1, . . . , n
est appelé programme linéaire en nombres entiers.

Ecrire le problème du sac-à-dos comme un programme liénaire en nombre entiers.
Comme le problème du sac-à-dos est NP-difficile, cela prouve que la résolution des pro-
grammes linéaires en nombre entiers est également NP-difficile.
CHAPITRE 5
Flots et Coupes
La notion de flot dans un graphe est naturelle : étant donné un réseau de transport (train,
tuyau, cables électriques), avec des capacités sur les arcs, quelle quantité de biens peut-on
faire transiter au maximum ? Ou alors, en supposant qu’à chaque arc est attaché un coût
unitaire, à quel coût minimum peut-on faire transiter un volume de biens donné ?
Une notion duale est celle de coupe dans un graphe. Une coupe est un ensemble d’arcs
intersectant tout chemin entre deux sommets fixés. Les applications des coupes sont nom-
breuses : positionnement de postes d’enquêtes, robustesse de réseaux, imagerie, etc.
5.1 Flots et coupes
5.1.1 Généralités
Soit un réseau modélisé par un graphe orienté D = (V, A), muni d’une capacité u → R+
et de deux sommets particuliers s (la source) et t (le puits). Une fonction f : A → R+ est
un s-t flot si f (a) ≤ u(a) pour tout arc a ∈ A et si pour tout sommet v ∈ / {s, t}, la loi de
conservation X X
f (a) = f (a)
a∈δ − (v) a∈δ + (v)
est respectée. Un s-t flot f est tel que f (a) ∈ Z pour tout a ∈ A, alors il est entier.
Une s-t coupe est une coupe δ(X) telle que s ∈ X et t ∈ / X. Etant donnée une s-t coupe,
il est intuitivement clair qu’un flot aura
P une valeur inférieure à sa capacité, où la capacité
+
d’une s-t coupe δ (X) est définie par a∈δ+ (X) u(a). Le lemme suivant formalise entre autres
cette propriété.
Lemme 5.1. Soit δ + (X) une s-t coupe et soit f un s-t flot quelconque. Alors
X X
value(f ) = f (a) − f (a).
a∈δ + (X) a∈δ − (X)
En particulier,
X
value(f ) ≤ u(a). (5.1)
a∈δ + (X)
CHAPITRE 5. FLOTS ET COUPES 66
La preuve de ce lemme est laissée en exercice.

On a également une propriété fondamentale qui est conforme à l’intuition qu’on peut
se faire d’un flot : tout flot peut se décomposer en combinaison conique de s-t chemins
élémentaires et circuits élémentaires.
Pour tout B ⊆ A, on note χB la fonction qui à a ∈ A renvoie 1 si a ∈ B et 0 sinon.
Proposition 5.1. Soit f un s-t flot. Notons P l’ensemble des s-t chemins élémentaires et
C l’ensemble des circuits élémentaires. Il existe alors des coefficients réels positifs (λP )P ∈P
et (µC )C∈C tels que X X
f= λP χP + µC χC .
P ∈P C∈C
De plus, si f est entier, alors ces coefficients peuvent être choisis entiers.
Il peut alors être facilement vérifié que
X
value(f ) = λP .
P ∈P
La preuve de la Proposition 5.1 n’est pas triviale, mais constitue tout de même un exercice
raisonnable.
5.1.2 Flot maximum et coupe minimum

Les problèmes
Une question naturelle est celle de la valeur maximum d’un flot étant donné un réseau
avec des capacités. Informellement, étant donné un réseau avec des capacités sur des arcs, la
question est de savoir quelle quantité maximum de matière on peut faire passer de la source
s à la destination t. Cette question se modélise de la façon suivante.
Problème du flot maximum

Donnée : Un graphe orienté D = (V, A), deux sommets particuliers s et t et des capacités
u : A → R+ .
Tâche : Trouver un s-t flot de valeur maximum.
Ce problème est polynomial car il peut se modéliser comme un programme linéaire, voir
Exercice 5.3.2. La nature particulière du problème a poussé les chercheurs à concevoir des al-
gorithmes ad hoc plus performants. L’un de ces algorithmes est celui d’Edmonds et Karp [8],
qui est également polynomial. Il est décrit dans le paragraphe suivant.
Un problème associé est celui de la s-t coupe minimum. C’est en réalité le problème dual
du problème du s-t flot maximum, au sens de la dualité de la programmation linéaire, voir
Exercice 5.3.2.
Problème de la s-t coupe minimum

67 CHAPITRE 5. FLOTS ET COUPES
Donnée : Un graphe orienté D = (V, A), deux sommets particuliers s et t, et des capacités
u : A → R+ .
Tâche : Trouver une s-t coupe de capacité minimum.
Graphe résiduel et chemins f -augmentants

Les algorithmes ad hoc pour les flots utilisent souvent les graphes résiduels et les che-
mins augmentants, que nous définissons maintenant. Informellement, le graphe résiduel est
le graphe qui indique les arcs où l’on peut augmenter ou diminuer la quantité de flot sans
violer la loi de conservation et les bornes de capacités (voir exemple Figure 5.1).
Pour un arc a = (u, v), on note a−1 := (v, u). On définit A−1 := {a−1 : a ∈ A}. Soit f
un s-t flot. On définit
Af := {a : a ∈ A et f (a) < u(a)} ∪ {a−1 : a ∈ A et f (a) > 0}.
Le graphe résiduel est le graphe Df := (V, Af ). Pour a ∈ Af , on associe une capacité

résiduelle uf (a) := u(a) − f (a) si a ∈ A et uf (a) := f (a) si a−1 ∈ A. Tout s-t chemin dans
Df est appelé chemin f -augmentant.
Proposition 5.2. Un s-t flot f est optimal si et seulement si il n’y a pas de chemin f
augmentant.
Démonstration. Supposons qu’il y ait un chemin f -augmentant P . Alors µ := mina∈P uf (a) est strictement
positif. Si a ∈ P est dans le même sens dans A (i.e. a ∈ A), alors on définit f 0 (a) := f (a) + µ ; sinon (i.e.
a−1 ∈ A), alors on définit f 0 (a) := f (a) − µ. On vérifie alors que value(f 0 ) = value(f ) + µ. On voit que f
n’est pas optimal.
Réciproquement, supposons qu’il n’y a pas de chemin f -augmentant. Posant X l’ensemble des sommets
que l’on peut atteindre depuis s dans Df , cela signifie que pour les arcs a quittant X (formellement a ∈
+ −
δP (X)), on a f (a)P= u(a) et que pour P ceux entrant dans X (formellement a ∈ δ (X)), on a f (a) = 0. Donc
a∈δ + (X) f (a) − a∈δ − (X) f (a) = a∈δ + (X) u(a), ce qui signifie
X
value(f ) = u(a).
a∈δ + (X)
Comme le terme de droite est une borne supérieure sur la valeur optimale d’un s-t flot (Lemme 5.1), le flot
f est optimal.
Algorithme d’Edmonds et Karp

On commence par poser f (a) := 0 pour tout a ∈ A. Ensuite on répète
Trouver un chemin f -augmentant P dans le graphe résiduel Df . S’il n’y

en a pas, alors f est optimal. Sinon, on calcule le plus grand µ possible
qui permette d’ augmenter f le long de P et on augmente f de
la quantité µ.
Le calcul de µ se formalise par µ := mina∈P uf (a). Augmenter f le long de P se fait de

la manière suivante : si a ∈ P est dans le même sens dans A (i.e. a ∈ A), alors on pose
f (a) := f (a) + µ ; sinon (i.e. a−1 ∈ A), alors on pose f (a) := f (a) − µ.
L’algorithme décrit ci-dessus n’est polynomial que si on choisit toujours le chemin f -
augmentant ayant le moins d’arcs possible, ce qui se fait par un algorithme de plus court
chemin avec des coûts unitaires sur les arcs 1 .
D’où
Théorème 5.1. L’algorithme d’Edmonds et Karp trouve un s-t flot maximum en O(nm2 ).
Remarque
Il existe maintenant de nombreux algorithmes polynomiaux. Le plus rapide de tous est
celui de Goldberg et Tarjan : ils ont montré qu’il était possible de trouver un flot maximum
en O(nm log n2 /m).
Théorème max flot–min coupe

Une application de l’algorithme et du théorème ci-dessus est la célèbre propriété de max
flot–min coupe. En effet, lorsque l’algorithme se termine, on a obtenu un flot maximum. En
notant f ce flot maximum, le critère qui a permis de s’arrêter est l’absence de chemin f -
augmentant dans le graphe résiduel, i.e. qu’on ne peut atteindre t depuis s dans Df . Posant
X l’ensemble des sommets que l’on peut atteindre depuis s dans Df , cela signifie que pour
les arcs a quittant X (formellement a ∈ δ + (X)), on a f (a)P= u(a) et que pour P ceux entrant
−
dans X (formellement a ∈ δ (X)), on a f (a) = 0. Donc a∈δ+ (X) f (a) − a∈δ− (X) f (a) =
P
a∈δ + (X) u(a). Ce qui signifie d’après le Lemme 5.1
X
value(f ) = u(a).
a∈δ + (X)
On obtient donc
Théorème 5.2. La valeur d’un s-t flot maximum est égale à la capacité d’une s-t coupe
minimum.
De plus, la discussion précédente implique que l’on peut trouver une s-t coupe minimum
en O(nm2 ). En effet, après avoir appliqué l’algorithme d’Edmonds et Karp, l’ensemble X
des sommets que l’on peut atteindre dans Df depuis s est tel que δ + (X) est une coupe de
capacité minimale.
Théorème 5.3. L’algorithme d’Edmonds et Karp trouve une s-t coupe minimum en O(nm2 ).
Une autre conséquence importante de l’algorithme est la suivante.

1. Dans ce cas particulier, coût = 1, il n’est pas nécessaire d’appliquer l’algorithme de Dijkstra du Cha-
pitre 3. Une simple recherche en largeur d’abord donne la solution.
Théorème 5.4. Si toutes les capacités sont entières, alors il existe un s-t flot maximum
entier, et l’algorithme d’Edmonds et Karp le trouve.
Démonstration. La preuve est immédiate : si f est entier à une itération de l’algorithme, µ l’est aussi, et f
le sera encore à l’itération suivante.
Remarque
On peut définir les S-T coupes où S et T sont des ensembles disjoints de sommets. Une
S-T coupe est un ensemble d’arcs de la forme δ + (X), avec S ⊆ X et T ∩ X = ∅. Une S-T
coupe de capacité minimum se trouve en ajoutant une source fictive s, un puits fictif t, des
arcs (s, u) pour tout u ∈ S et des arcs (v, t) pour tout v ∈ T . Ces nouveaux arcs sont alors
munis de capacité infinis.
Cette astuce consistant à ajouter une source et un puits fictifs est utile dans de nombreuses
situations.
Remarque
Dans le cas non-orienté, on appelle s-t coupe un ensemble d’arêtes de la forme δ(X),
avec s ∈ X et t ∈
/ X. Trouver une s-t coupe de capacité minimum se ramène simplement à
remplacer chaque arête par deux arcs opposés.
Remarque
Considérons le problème suivant.
Problème de l’ensemble d’arcs déconnectant minimum

Donnée : Un graphe orienté D = (V, A), deux sommets particuliers s et t, et des capacités
u : A → R+ .
Tâche : Trouver un sous-ensemble B d’arcs de capacité minimum tel que pour tout s-t
chemin P , on a P ∩ B =
6 ∅.
Ce problème coı̈ncide avec celui de la s-t coupe de capacité minimum. En effet, une s-t
coupe est une solution réalisable pour le problème de l’ensemble d’arcs déconnectant mi-
nimum. Inversement, s’il existe une solution réalisable B pour le problème de l’ensemble
d’arcs déconnectant minimum, alors l’ensemble X des sommets que l’on peut atteindre dans
D depuis s sans utiliser d’arcs de B est tel que δ + (X) ⊆ B.
Exemple : Contrôle routier

Pour améliorer l’utilisation des flottes de camions (pour diminuer les émissions de CO2
par exemple), on souhaite effectuer des contrôles de poids lourds partant d’une région P
et allant vers une autre région Q par le biais d’un réseau autoroutier R. Les contrôles sont
effectués sur des tronçons d’autoroute. Faire un contrôle sur le tronçon t coûte ct . Le problème
consiste à trouver le sous-ensemble de tronçons sur lesquels les contrôles vont être effectués
tel que tout camion allant de P à Q passe par un contrôle, et ce, à coût minimum.
Avec les remarques ci-dessus, on peut voir que ce problème se modélise comme un
problème de s-t coupe minimum.
Exemple : Problème de l’affectation de tâches

On suppose que l’on a différentes tâches à accomplir dont on connaı̂t les durées d’exécution,
et que l’on dispose d’une ressource de main d’œuvre dont on connaı̂t les compétences. Les
tâches sont supposées telles que les employés peuvent y travailler en parallèle. On souhaite
minimiser le temps nécessaire pour réaliser l’ensemble des tâches.
Problèmes de l’affectation des tâches

Données : n tâches et leurs durées t1 , . . . , tn ∈ R+ ; m employés et des sous-ensembles
Si ⊆ {1, . . . , m} qui correspondent aux employés compétents pour la tâche i.
Tâche : Trouver des réels xij ∈ R+ pour tous i ∈ {1, . . . , n} et j ∈ {1, . . . , m} (signifiant le
tempsPconsacré par l’employé j à la tâche i) tels que toutes les tâches soient finies, i.e. tels
que j∈Si xij = ti pour i = 1, . . . , n. MinimiserP le temps qu’il faut pour terminer toutes les
tâches, i.e. la quantité T (x) := maxj∈{1,...,m} i: j∈Si xij .
Ce problème se modélise comme un problème de flot de la manière suivante. On construit

un graphe biparti avec d’un côté des sommets vi représentant les tâches et de l’autre des
sommets wj représentant des employés. On met un arc (vi , wj ) si l’employé j est compétent
pour effectuer la tâche i, en d’autres termes, si j ∈ Si . On ajoute deux autres sommets s
et t, et on construit tous les arcs (s, vi ) et tous les arcs (wj , t). On dénomme ce graphe D.
Fixons un temps T et on va se demander s’il est possible d’effectuer toutes les tâches en un
temps plus petit que T .
On munit D de capacités u(s, vi ) := ti , et u(a) := T .
Prenons maintenant un jeu de réels xij satisfaisant les contraintes du problème, et
réalisant les tâches en un temps total ≤ T . Associons P à chaque arc (vi , wj ) la quantité
x
Pij . A chaque arc (s, vi ) on associe la quantité j∈Si xijP et à chaque arc (wj , t) la quantité
n
x
i: j∈Si ij . On obtient ainsi un flot réalisable de valeur i=1 ti .
Réciproquement, supposons que l’on trouve un flot réalisable f de valeur ni=1 ti . Alors,
P
les réels xij := f (vi , wj ) constituent une solution réalisable du problème de l’affectation de
tâches, avec un temps de réalisation total ≤ T .
Par conséquent pour résoudre le problème de l’affectation de tâches (trouver une solution
optimale), on cherche un flot maximum sur D. On sait Pnqu’il y a un flot maximum de valeur
i=1 ti
Pn Pn
et T 0 := ni=1 ti . On répète
P
i=1 ti si on pose T := i=1 ti . On pose alors T :=
2
Pn
Si on trouve un flot de valeur i=1 ti , on sait qu’on peut réaliser les
tâches en un temps ≤ T . On recommence alors avec T := T /2 et
T + T0
T 0 := T . Sinon, c’est que T était trop petit, et on pose T :=
2
et on laisse T 0 := T 0 .
La solution optimale x∗ est telle T ≤ T (x∗ ) ≤ T 0 . On peut s’arrêter dès que T 0 − T est
plus petit qu’une quantité fixée au préalable.
On a résolu un problème d’optimisation par une recherche binaire, chaque étape étant
un problème de décision.
Cette façon de procéder est très efficace en pratique, plus que l’autre solution consistant
à voir le problème de l’affectation de tâches comme un programme linéaire.
On peut se demander si, dans le cas où les ti sont entiers, on a nécessairement alors une
solution optimale entière. L’auteur de ce polycopié ne sait pas. L’intérêt pourrait être de
montrer que la recherche binaire termine en un nombre fini d’étapes.
5.2 Flot de coût minimum
Soit un graphe orienté D = (V, A), muni de capacités
P `, u : A → R+ tels que `(a) ≤ u(a)
pour tout a ∈ A, et des nombres b : V → R tels que v∈V b(v) = 0. Une fonction f : A → R+
est un b-flot si pour tout arc a ∈ A, on a `(a) ≤ f (a) ≤ u(a) et si pour tout sommet v ∈ V ,
la loi de conservation X X
f (a) − f (a) = b(v)
a∈δ + (v) a∈δ − (v)
est respectée.
Les sommets v tels que b(v) > 0 sont appelés sources et les sommets v tels que b(v) < 0
sont appelés puits. Pour une source, b(v) est l’offre ; pour un puits, b(v) est la demande.
Dans le cas particulier où tous les b(v) sont nuls, on parle de circulation.
Proposition 5.3. Soit f un b-flot. Notons P l’ensemble des chemins élémentaires reliant
les sources aux puits et C l’ensemble des circuits élémentaires. Il existe alors des coefficients
réels positifs (λP )P ∈P et (µC )C∈C tels que
X X
f= λP χP + µC χC .
P ∈P C∈C
De plus, si f est entier, alors ces coefficients peuvent être choisis entiers.
Il peut alors être facilement vérifié que pour tout v ∈ V

X X
b(v) = λP − λP .
P ∈P : P quitte v P ∈P : P arrive en v
5.2.2 Le problème
On suppose que l’on a une fonction de coût c : A → R.
On peut alors se demander, parmi tous les b-flots, lequel est de plus petit coût, où le coût
d’un b-flot f est défini par X
c(a)f (a).
a∈A
Les applications des flots de coût minimum sont innombrables. Nous verrons ce que
cela peut apporter au problème d’affectation de tâches vu précédemment. Tout comme le
problème de flot maximum, le problème du b-flot de coût minimum se formule comme un
programme linéaire et peut donc être résolu avec ma méthode des points intérieurs (en temps
polynomial donc) ou par l’algorithme du simplexe.
En 1985, Goldberg et Tarjan [12] ont montré qu’il existait un algorithme particulièrement
efficace pour résoudre le problème flot de coût minimum. L’algorithme travaille encore sur
le graphe résiduel, en définissant c(a−1 ) := −c(a) pour a ∈ D et
Af := {a : a ∈ A et f (a) < u(a)} ∪ {a−1 : a ∈ A et f (a) > `(a)}.
Le graphe résiduel Df est donc maintenant muni de coûts.
5.2.3 Algorithme de Goldberg et Tarjan

On commence par fixer un b-flot (voir ci-dessous : comment trouver un b-flot réalisable).
Le coût moyen d’un circuit C est défini par
P
a∈C c(a)
,
|C|
somme des coûts des arcs du circuit C divisée par le nombre d’arcs du circuit C.
On repète
Repérer un circuit C de coût moyen minimum dans Df . S’il n’y en a

pas, alors f est optimal. Sinon, on calcule µ le plus grand possible qui
permette d’ augmenter f le long de C et on augmente f de la
quantité µ.
Le calcul de µ se formalise par µ := mina∈C uf (a). Augmenter f le long de C se fait de

la manière suivante : si a ∈ C est dans le même sens dans A (i.e. a ∈ A), alors on pose
f (a) := f (a) + µ ; sinon (i.e. a−1 ∈ A), alors on pose f (a) := f (a) − µ.
La difficulté de cet algorithme est de trouver un circuit de coût moyen minimum dans le
graphe résiduel Df . En fait, pour cela, on peut faire appel à un algorithme de Karp [18] qui
trouve un tel circuit en O(nm).
Théorème 5.5. On peut trouver un b-flot de coût minimum en O(n2 m3 log n).
Comme pour le problème du flot maximum, si les capacités sont entières, il existe une
solution optimale entière, que l’on trouve sans plus de difficulté.
Théorème 5.6. Supposons toutes les capacités entières et tous les b(v) entiers. S’il existe un
b-flot de coût minimum, il en existe un entier de coût minimum, et l’algorithme de Goldberg
et Tarjan le trouve.
Un corollaire immédiat mais important de ce théorème est que dans le cas où les capacités
sont entières et tous les b(v) entiers, alors s’il existe un b-flot, alors il en existe un entier.
Cela peut se voir en prenant un coût nul sur chaque arc.
Si l’on accepte d’avoir une complexité qui dépend de la taille des nombres de l’input (on
parle alors d’algorithme faiblement polynomial), on peut avoir d’autres bonnes complexités.
Par exemple, l’algorithme classique d’Edmonds et Karp [8] tourne en O(m(m + n log n)L),
où L est le nombre maximum de bits pour coder un coefficient du problème.
5.2.4 Comment trouver un b-flot réalisable

Remarquons d’abord que le cas où `(a) = 0 pour tout a ∈ A est facile. En effet, en
ajoutant une source fictive s, un puits fictif t, les arcs (s, v) avec capacité b(v) pour les v tels
que b(v) > 0 et les arcs (v, t) avec capacité −b(v) pour les v tels que b(v) < 0, l’existence
d’un b-flot se resout par un algorithme de s-t flot maximum, par exemple avec l’algorithme
d’Edmonds et Karp ci-dessus.
Nous allons voir maintenant comment l’on peut toujours se ramener au cas `(a) = 0 pour
tout arc a.
Considérons un b-flot f , satisfaisant donc
X X
f (a) − f (a) = b(v) pour tout v ∈ V,
a∈δ + (v) a∈δ − (v)
`(a) ≤ f (a) ≤ u(a) pour tout a ∈ A.

Posons f 0 (a) = f (a) − `(a). On voit que le problème de l’existence du b-flot f revient à
celui de l’existence d’une fonction f 0 : A → R satisfaisant
X X X X
`(a) + f 0 (a) = `(a) + f 0 (a) + b(v) pour tout v ∈ V,
a∈δ + (v) a∈δ + (v) a∈δ − (v) a∈δ − (v)
0 ≤ f 0 (a) ≤ u(a) − `(a) pour tout a ∈ A.

Ce dernier est un problème d’existence de b0 -flot avec borne inférieure = 0 et borne supérieure
= u − `, et où X X
b0 (v) := `(a) − `(a),
a∈δ − (v) a∈δ + (v)
lequel est résolu par un problème de flot maximum, comme indiqué au début de cette dis-
cussion.
Exemple : Conception d’un réseau de transport à moindre coût, d’après [6]

Supposons que l’on souhaite calibrer un réseau de transport de façon à pouvoir assurer des
livraisons depuis des sources jusqu’à des destinations. Pour chaque tronçon direct (u, v), on
connaı̂t le coût c(u, v) d’établissement d’une liaison de capacité unitaire. Comment construire
le réseau dont l’établissement soit de coût minimum ? On suppose que l’on connaı̂t pour les
sources, l’offre et pour les destinations, la demande.
Ce problème se modélise comme la recherche d’un b-flot de coût minimum. En effet, on
cherche le b-flot de coût minimum, où les coûts sont donnés par les c(u, v) et b(v) est égal
à l’offre si v est une source, et est égal à l’opposé de la demande si v est une destination.
Noter que d’après le Théorème 5.6, on peut trouver une solution entière à ce problème, ce
qui est commode si chaque tronçon ne peut avoir que des capacités unitaires.
Exemple : Problème de l’affectation de tâches avec considération salariale

Dans le cas du problème de l’affectation des tâches, mettre de coûts sur les arcs dans la
modélisation par les flots permet de prendre en compte des considérations salariale.
Soit le problème
Problème de l’affectation de tâche avec salaires

Donnée : n tâches et leurs durées t1 , . . . , tn ∈ R+ ; m employés et des sous-ensembles
Si ⊆ {1, . . . , m} qui correspondent aux employés compétents pour la tâche i ; un salaire
horaire cij pour l’employé j lorsqu’il effectue la tâche i ; une durée limite T pour la réalisation
de l’ensemble des tâches.
Tâche : Trouver des réels xij ∈ R+ pour tous i ∈ {1, . . . , n} et j ∈ P {1, . . . , m} tels que
toutes les tâches soient finies enPun temps inférieur à T , i.e. tels que j∈Si xij = ti pour
i = 1, . . . , n et tels maxj∈{1,...,m} i: j∈Si xijP≤ T . Minimiser le coût qu’il faut pour terminer
toutes les tâches, i.e. la quantité C(x) := j∈{1,...,m},i∈{1,...,n} cij xij .
On peut répéter la construction du graphe D comme dans la sous-section précédente,

avec les mêmes capacités. Les coûts sont c(vi , wj ) := cij , c(s, vi ) := 0 et c(wj , t) := 0. Une
simple application d’un algorithme de flot de coût minimum donne la solution.
5.3 Exercices
5.3.1 Valeur d’un s-t flot
Prouver le Lemme 5.1.
5.3.2 Formulation des problèmes de flots maximum sous forme de programme linéaire
Montrer que le problème de flot maximum s’écrit comme un programme linéaire. Ecrire
son dual. Quelle remarque pouvez-vous faire ?
5.3.3 Coupe minimum

On se donne un graphe orienté D = (V, A) avec une capacité u : A →PR+ . Montrer que
l’on peut trouver en temps polynomial l’ensemble X non vide tel que a∈δ+ (X) u(a) soit
minimal. (Attention : il n’y a pas de s et de t spécifiés).
5.3.4 Combat sur un réseau

Un centre de commandement est situé en un sommet p d’un réseau non-orienté. On
connaı̂t la position des subordonnés modélisée par un sous-ensemble S des sommets du
réseau. On souhaite détruire un nombre minimum de liens afin d’empêcher toute communi-
cation entre le centre de commandement et les subordonnés. Comment résoudre ce problème
en temps polynomial ?
5.3.5 Le problème des représentants – d’après Ahula, Magnanti et Orlin [1]

Une ville à n citoyens, c clubs et p partis politiques. Chaque citoyen appartient à au
moins un club, et à au plus un parti.
Le jour du renouvellement du conseil de la ville approche... Le nombre de conseillers du
parti Pk ne doit pas excéder uk . Or, chaque club doit nommer un représentant au conseil de la
ville, et certains de ces représentants sont membre d’un parti politique... Un citoyen siégeant
au conseil ne peut que représenter qu’un seul club. Proposer un algorithme polynomial
permettant de décider si ces contraintes peuvent être satisfaites.
5.3.6 Théorème de Menger

Démontrer le théorème suivant.
Soit D = (V, A) une graphe orienté, et s et t deux sommets particuliers. Le nombre
maximum de s-t chemins arc-disjoints est égale à la cardinalité minimale d’un sous-ensemble
d’arcs intersectant tout s-t chemin.
5.3.7 Problème de transport de Monge bis

Montrer que le problème de transport de Monge (Exercice 2.6.9) se modélise comme un
problème de flot de coût minimum.
5.3.8 Flotte d’avions

Une compagnie aérienne a p vols à satisfaire. Pour chacun de ces vols i = 1, . . . , p, elle
connaı̂t son lieu oi et son heure de départ hi , la durée du vol ti et le lieu d’arrivée di . De
plus, le temps pour se rendre de dj à oi est connu pour chaque couple (i, j). La compagnie
souhaite minimiser le nombre d’avions tout en satisfaisant la demande en vols. Modéliser ce
problème comme un problème de flot.
5.3.9 Flotte d’avions bis

Une compagnie aérienne a la possibilité de satisfaire p vols. Pour chacun de ces vols
i = 1, . . . , p, elle connaı̂t son lieu oi et son heure de départ hi , la durée du vol ti , le lieu
d’arrivée di et le produit de la vente des billets. De plus, le temps pour se rendre de dj à oi
est connu pour chaque couple (i, j). Enfin, pour chaque vol (u, v), le coût c(u, v) du vol est
connu (frais, salaire, carburant). La compagnie souhaite maximiser son gain, sachant qu’elle
dispose de K avions.
Modéliser ce problème comme un problème de flot.
5.3.10 Remplissage d’un avion

Un avion capable d’embarquer au plus B passagers doit partir de l’aéroport 1 à desti-
nation des aéroports 2, 3, . . . , n successivement. Le nombre de passagers voulant voyager de
l’aéroport i à l’aéroport j (avec i < j) est d(i, j) et le prix de ce trajet est p(i, j). Combien de
passagers faut-il prendre à chaque aéroport pour maximiser les recettes totales ? Modéliser
ce problème comme un problème de flot.
5.3.11 Gestion dynamique de stock, cas à 1 seul bien

On souhaite satisfaire une demande prescrite dt pour chacune des T périodes t = 1, 2, . . . , T .
Pour satisfaire la demande dt sur la période t, on peut produire une quantité xt ∈ R+ sur
la période t et/ou retirer une certaine quantité du stock yt−1 ∈ R+ de la période t − 1 (on
suppose y0 = 0). On suppose de plus que la production sur la période t ne peut pas excéder
Pt .
1. Justifier la dynamique du stock
yt = yt−1 + xt − dt , (5.2)
pour t = 1, 2, . . . , T .
Sur la période t, le coût unitaire de stockage est st ≥ 0 et le coût unitaire de production
est pt ≥ 0. On veut gérer le stock au coût minimum.
2. Montrer que ce problème se modélise comme un programme linéaire.
3. Application numérique : On considère les données du tableau suivant
t= 1 2 3 4
dt 5 4 1 3
st 1 1 1 xxx
pt 2 3 3 4
Pt 9 5 5 5
Indiquer le coût minimal de gestion de stock, ainsi que les niveaux de productions (en
p.4 , des programmes linéaires sont donnés).
4. Montrer que ce problème peut également se modéliser comme un problème P de b-flot
de coût minimum. (Indication : introduire un sommet “source” v avec b(v) = Tt=1 dt et des
sommets “puits” wt avec b(wt ) = −dt ; à vous d’indiquer les arcs, les coûts sur les arcs, les
capacités sur les arcs, etc.) Justifier la modélisation.
5. Quel peut être l’intérêt d’une telle modélisation alors qu’on sait résoudre le problème
avec un solveur de programmation linéaire ?
5.3.12 Extraction de mine à ciel ouvert

Un domaine d’application de la recherche opérationnelle est l’exploitation des mines à
ciel ouvert. Un problème important consiste à déterminer les blocs à extraire. Dans toute la
suite, la mine sera assimilée à une collection de n blocs numérotés de 1 à n. L’extraction du
bloc i rapporte la quantité ci ; cette quantité peut être positive ou négative (en fonction de
la quantité de minerai présent dans le bloc).
Les blocs ne peuvent pas être extraits dans n’importe quel ordre : pour chaque bloc i,
on connaı̂t l’ensemble Yi des blocs qu’il faut avoir extraits pour pouvoir extraire le bloc i.
L’objectif est de proposer un sous-ensemble de blocs à extraire de manière à maximiser le
profit total.
Dans un graphe orienté, on dit qu’un ensemble S de sommets est fermé si tout successeur
d’un sommet de S est encore dans S. Considérons le problème suivant.
Le problème du fermé maximum.
P tout v ∈ V .
Donnée : Un graphe D = (V, A) orienté, des réels cv pour
Tâche : Trouver un sous-ensemble fermé S ⊆ V tel que v∈S cv soit maximal.
1. Expliquez pourquoi le problème peut se modéliser sous la forme d’un problème de
fermé maximum.
L’objectif va maintenant être de modéliser le problème du fermé maximum comme un
problème de s-t coupe de capacité minimale.
On construit un nouveau graphe D̃ = (Ṽ , Ã) en ajoutant un sommet source s et un
sommet puits t à V . On note V + = {v ∈ V : cv ≥ 0} et V − = {v ∈ V : cv < 0}. L’ensemble
Ã est alors A auquel on ajoute les arcs {(s, v) : v ∈ V + } et les arcs {(v, t) : v ∈ V − }. On
met une capacité u(s,v) = cv pour v ∈ V + et u(v,t) = −cv pour v ∈ V − .
2. Quelles capacités ua mettre sur les arcs a ∈ A de manière à ce que tout X ⊆ V tel que
+
δD̃ (X ∪ {s}) soit une s-t coupe de D̃ de capacité minimale soit un ensemble fermé de D ?
3. Soit X ⊆ V un ensemble fermé de D. Montrez que
X X X
ua = cv − cv .
a∈δ + (X∪{s}) v∈V + v∈X
D̃
4. En déduire que le problème du fermé maximum se modélise comme un problème de

coupe minimale. Conclure sur la résolution pratique de problème.
Les nombres non-entourés sont les capacités; les nombres entourés forment le flot.
Graphe résiduel:
v1 6 6 v2
v1 6 v2
10 6 5
5 1 6
3 6
0
s 5 3 3
1 3
4 s t
t 1
3 5
2 3 7 2
3
2
3 3 2
5
5 8 v4 v4
v3 v3
5
Figure 5.1 – Le graphe résiduel.

CHAPITRE 6
Graphes bipartis : problème d’affectation,

problème de transport, mariages stables
L’objectif de ce cours est d’étudier un objet central de l’optimisation discrète et d’en voir
quelques applications parmi les plus importantes. Il s’agit des graphes bipartis.
6.1 L’objet
Un graphe biparti est un graphe dont l’ensemble des sommets peut être partitionné en
deux parties X et Y telles que toute arête à l’une de ces extrémités dans X et l’autre dans Y .
Voir la Figure 6.1. On a la proposition suivante, très utile, dont la démonstration est laissée
en exercice.
Proposition 6.1. Un graphe est biparti si et seulement si il ne contient pas de circuit de
taille impaire.
6.2 Problème du couplage optimal

Rappelons qu’un couplage dans un graphe G = (V, E) est un sous-ensemble d’arêtes
M ⊆ E disjointes : quelles que soient e et f dans M , les arêtes e et f n’ont pas de sommet
en commun. On note ν(G) la cardinalité maximale d’un couplage d’un graphe G.
Problème du couplage de poids maximum

Donnée : Un graphe G = (V, E) biparti avec des poids w : E → R sur les arêtes.
Tâche : Trouver un couplage de poids maximal.
Ce problème modélise typiquement des situations où l’on veut affecter des personnes à
des tâches ou à des services. Le poids d’une arête uv représente alors le bénéfice obtenu en
affectant u à v.
Le problème du couplage de poids maximum se résout en temps polynomial. En effet,
ce problème peut se modéliser comme un problème de flot de coût maximum (qui est un
problème de flot de coût minimum avec des coûts opposés) : on oriente toutes les arêtes de
X vers Y , on ajoute un sommet s et un sommet t, on ajoute des arcs (s, v) pour v ∈ X et
(v, t) pour v ∈ Y ; enfin, on ajoute un arc (s, t), et on pose b(s) = |X| = −b(t) et b(v) = 0
CHAPITRE 6. GRAPHES BIPARTIS : PROBLÈME D’AFFECTATION, PROBLÈME DE TRANSPORT, MARIAGES STABLES 82
Figure 6.1 – Un exemple de graphe biparti.
ailleurs. Enfin, les capacités des arcs sont partout = +∞ sauf sur les arcs (s, v) et (v, t) où
elles sont égales à 1, et les coûts sont partout nuls sauf sur les arcs de X à Y où ils sont
égaux aux poids w. C’est un problème de flot de coût maximum : en effet, tout flot entier
induit un couplage de même poids ; et tout couplage induit un flot entier de même coût.
Tout algorithme trouvant des flots entiers de coût optimal trouve donc la solution (en
particulier celui vu au chapitre précédent). En fait, il existe un algorithme plus efficace,
appelé algorithme hongrois, découvert par Kühn en 1955 [19].
Soit G = (V, E) notre graphe biparti, avec les ensembles X et Y partitionnant V et
n’induisant chacun aucune arête. On a de plus une fonction w de poids sur E. L’algorithme
hongrois commence avec un couplage M = ∅. Ensuite, on répète
Créer le graphe orienté DM de la façon suivante :

— Orienter chaque arête e de M de Y vers X, et définir l(e) := w(e).
— Orienter chaque arête e de E \ M de X vers Y et définir l(e) :=
−w(e).
Soit XM (resp. YM ) les sommets de X (resp. Y ) qui ne sont pas cou-
verts par une arête de M . S’il y a un chemin de XM à YM , en chercher
un plus court (pour la fonction l), que l’on note P . Remplacer le M
courant par M 4E(P ) (où E(P ) est l’ensemble des arêtes de P , et
où B4C représente les éléments présents dans exactement l’un des
ensembles B ou C 1 ).
1. On a donc B4C = (B ∪ C) \ (B ∩ C) ; on appelle cette opération la différence symétrique de B et de

C.
83 CHAPITRE 6. GRAPHES BIPARTIS : PROBLÈME D’AFFECTATION, PROBLÈME DE TRANSPORT, MARIAGES STABLES
L’algorithme s’arête lorsqu’on ne peut pas trouver de chemin de XM à YM dans DM . On

peut démontrer que M est alors un couplage de poids maximum.
Un lecteur attentif remarquera qu’il faut calculer un plus court chemin dans DM qui
est un graphe orienté avec des poids quelconques. Ce problème est NP-difficile en général.
Heureusement ici, on peut montrer que l’algorithme est tel que DM ne contient jamais de
circuit absorbant et que l’on peut donc calculer un tel plus court chemin avec la méthode
Bellman-Ford vue au Chapitre 3.
Avec quelque subtilité d’implémentation, l’algorithme hongrois peut tourner en O(n(m +
n log n)). On a donc le théorème suivant (donné ici sans preuve).
Théorème 6.1. Le problème du couplage de poids maximal peut être résolu en O(n(m +
n log n)).
Avec un algorithme de flot, on est en O(n2 m3 log n).
Si on veut simplement trouver le couplage le plus grand (en nombre d’arêtes), on peut
aller encore plus vite.
Théorème√6.2. Dans un graphe biparti, on peut construire un couplage de cardinalité maxi-
male en O( nm).
Dans ce cas, on gardant la même modélisation par un graphe orienté (et en oubliant les
coûts), on cherche le s-t flot de valeur maximale, ce qui donne une complexité de O(nm2 ).
Par une série d’astuces, non détaillées ici, et sans utiliser la modélisation par les flots, on
arrive à la complexité donnée dans le théorème ci-dessus.
Le théorème max flot–min coupe permet également de montrer le théorème suivant, dû
à König (la preuve est laissée en exercice). On rappelle qu’une couverture par les sommets
dans un graphe G = (V, E) est un sous-ensemble de sommets C ⊆ V tel que toute arête e
de G soit incident à au moins un sommet de C et qu’on note τ (G) la cardinalité minimale
d’une couverture par les sommets.
Théorème 6.3. Dans un graphe biparti, on a
ν(G) = τ (G).
Rappelons que l’inégalité ν(G) ≤ τ (G) est facile à montrer, voir Proposition 2.1. L’algo-
rithme de Ford-Fulkerson permet par la même construction que celle utilisée dans la preuve
de calculer une telle couverture optimale. Cela dit, il existe des algorithmes plus rapides.
6.3 Couplages généralisés

Soit G = (V, E) un graphe biparti. Soient a, b : V → N, avec a(v) ≤ b(v) pour tout v. On
appelle couplage généralisé un ensemble d’arêtes F ⊆ E tel que a(v) ≤ degF (v) ≤ b(v) pour
tout v ∈ V , où degF (v) = |δ(v) ∩ F | (on compte les arêtes de F incidentes à v). On peut
alors considérer le problème suivant.
Problème du couplage généralisé de poids maximum

Donnée : Un graphe G = (V, E) biparti, deux fonctions a, b : V → N, des poids w : E → R.
Tâche : Trouver un couplage généralisé de poids maximal.
Il se résout en temps polynomial par un algorithme de flot de coût minimum, avec une
construction similaire à celle de la section précédente. Noter que si on ne veut que maximiser
la cardinalité, on peut utiliser un algorithme de flot maximum (plus rapide), toujours avec
la même construction.
Exemple
On se place dans un centre de tri de palettes (plateforme logistique, aéroport, etc.). En
début de journée, on a n palettes 1, . . . , n à trier. La palette i contient des marchandises
mi,j . Chaque marchandise est caractérisée par une heure limite de tri tij . Si la palette où
se trouve la marchandise mij est triée avant l’heure tij , on gagne ci , sinon, on perd di . On
suppose que
• on dispose de k personnes pour trier,
• chaque personne met une heure pour trier une palette,
• on dispose de T créneaux d’une heure, sans contrainte sur le nombre de personnes
pouvant travailler sur un créneau.
Trouver la stratégie qui minimise l’amende totale.
C’est un problème de couplage généralisé. En effet, on considère le graphe biparti suivant.
D’un côté, on a les palettes 1, 2, . . ., de l’autre les horaires 1, 2, . . . , T . L’arête ih modélise
le fait qu’on trie la palette i ∈ {1, . . . , n} sur le créneau h ∈ {1, . . . , T }. Si h ≤ tij , on
met un poids ci sur l’arête it ; sinon, on met −di . On définit a(i) = b(i) = 1 pour les
palettes i = 1, . . . , n, signifiant qu’il faut trier chaque palette exactement une fois. On définit
également a(h) = 0 et b(h) = k pour le créneau h, signifiant qu’on ne peut pas trier plus de
k palettes sur un créneau horaire.
6.4 Problème de l’affectation optimale

Une situation classique où apparaı̂t un graphe biparti est le problème de l’affectation. On
dit qu’un couplage M est parfait lorsque tout sommet de G est incident à une arête de M .
Problème de l’affectation
Donnée : Un graphe G = (V, E) biparti avec des poids w : E → R sur les arêtes.
Tâche : Trouver un couplage parfait de poids maximal.
Ce problème apparaı̂t dans quantité de situations. Comme précédemment, les sommets

du graphe biparti peuvent être des employés d’une part et des tâches à effectuer de l’autre
(on suppose qu’il y a autant d’employés que de tâches). Les poids peuvent modéliser le coût
de réalisation de la tâche par un employé donné. On veut réaliser toutes les tâches avec un
coût minimal, en supposant que tout employé peut réaliser n’importe quelle tâche.
C’est un cas particulier des couplages généralisés : pour s’y ramener, il suffit de poser
a(v) = b(v) = 1 pour tout v.
Théorème 6.4. On sait résoudre le problème de l’affectation en O(n(m + n log n)).
Il y a de nombreux algorithmes qui résolvent ce problème avec cette complexité. On peut
également appliquer l’algorithme hongrois auquel il a été fait mention ci-dessus. En effet,
l’algorithme hongrois fait en fait mieux que trouver un couplage de poids maximum : il
trouve, pour un k fixé, le couplage de cardinalité k de plus grand poids. Il suffit alors de
multiplier par −1 les poids et de chercher le couplage de cardinalité n/2.
6.5 Mariages stables

Nous avons vu ci-dessus des problèmes d’affectation ou de couplage où l’on maximise une
quantité globale. Dans de nombreuses situations, par exemple la création de binômes, on
veut maximiser dans un certain sens une quantité locale (la satisfaction de chaque binôme).
On sent bien qu’en général, on ne peut jamais satisfaire de manière optimale tout le monde,
mais on a des notions qui s’en approchent, issues de l’économie ou de la théorie des jeux.
Nous présentons le plus célèbre des résultats de cette famille. Bien des généralisations
sont possibles, à l’origine d’une littérature spécialisée abondante, mais elles ne seront pas
évoquées ici.
Imaginons la situation suivante. On a m filles et n garçons et l’on veut former des ma-
riages. Chaque fille accepterait éventuellement de se marier avec certains garçons, et elle a un
ordre total de préférence sur ces garçons. De même, chaque garçon accepterait éventuellement
de se marier avec certaines filles et a un ordre de préférence total sur ces filles. On modélise
cela de la manière suivante. Les filles et les garçons forment les sommets d’un graphe biparti
G = (V, E). Il y a une arête entre un sommet fille et un sommet garçon si l’un et l’autre ac-
cepteraient éventuellement de se marier ensemble. L’existence de l’ordre de préférence pour
chaque fille et chaque garçon se traduit par l’existence d’un ordre total ≺v sur δ(v) pour
tout v ∈ V .
Un ensemble de mariages est représenté par un couplage dans G. Un couplage M est
dit stable si la condition suivante est satisfaite pour toute arête uv de G : si uv n’est pas
dans M , alors il existe e ∈ δ(u) ∩ M avec uv ≺u e ou il existe e ∈ δ(v) ∩ M avec uv ≺v e.
En d’autres termes, si une fille u et un garçon v ne sont pas mariés ensemble alors que
l’un et l’autre seraient prêts éventuellement à l’être, c’est que l’un des deux est marié avec
quelqu’un qu’il préfère. C’est une notion tout à fait naturelle de stabilité : un tel coulage
stable ne conduira pas à des réarrangements locaux. Ce sont Gale et Shapley [9] qui ont
imaginé ce concept en 1962 et ont prouvé le théorème suivant. Shapley a d’ailleurs obtenu
le prix Nobel d’économie en 2012 pour ses travaux sur ce sujet. De nombreux domaines
en ont en effet bénéficié : ces mariages stables ont été appliqués aux affectations d’internes
dans des services hospitaliers, aux attributions de bourses, aux acceptations d’élèves dans
les écoles préparatoires, etc.
Théorème 6.5. Il existe toujours un couplage stable dans un graphe biparti. De plus, un tel
couplage se trouve en O(nm).
Ce qui est remarquable, c’est que la preuve est simple, algorithmique et peut se raconter
sous la forme d’une histoire.
Démonstration. Tous les matins, chaque garçon invite à dı̂ner la fille qu’il préfère parmi celles qui ne lui ont
pas déjà refusé une invitation. Chaque fille qui a été invitée dı̂ne le soir avec le garçon qu’elle préfère parmi
ceux qui l’ont invitée ce jour là, à condition bien sûr qu’elle accepterait éventuellement de se marier avec lui.
Tout garçon qui a vu son invitation refusée par une fille décide de ne plus jamais l’inviter.
L’algorithme se poursuit tant qu’au moins une invitation change. Les couples qui ont dı̂né entre eux le
dernier soir sont mariés.
Pour se convaincre que cet algorithme fournit un couplage stable, il faut d’abord remarquer que
toute fille qui est invitée un soir à dı̂ner est sûre de dı̂ner le lendemain avec un garçon qui lui plaise au
moins autant.
En effet, si une fille, disons Alice, est invitée à dı̂ner par un garçon, disons Bob, c’est que Bob préfère
Alice à toutes celles qui ne l’ont pas déja refusé. Alice est donc sûre d’être réinvitée le lendemain par Bob,
mais elle sera peut-être aussi invitée par de nouveaux garçons qui viennent d’essuyer des refus et pour qui
elle est désormais le meilleur choix restant. Peut-être que Charlie, l’un de ces nouveaux garçons, lui plait plus
que Bob, dans ce cas elle dı̂nera avec Charlie, en congédiant Bob. Dans tous les cas, Alice dı̂ne le lendemain
avec un garçon au moins aussi plaisant.
Ensuite, on remarque que
l’algorithme se termine.
En effet, une invitation qui a été refusée ne sera jamais répétée. À chaque étape précédant la fin de
l’algorithme, au moins une invitation est refusée. Le nombre d’étapes avant que la liste des invitations ne se
stabilise est donc borné par le nombre d’invitations possibles, i.e. par le nombre de filles fois le nombre de
garçons.
Enfin, lorsque l’algorithme se termine,
les mariages fournissent un couplage stable.
En effet, considérons le mariage obtenu à l’issue de l’algorithme.
Supposons qu’Alice et Bob ne sont pas mariés ensemble et qu’Alice préfère Bob à son mari actuel. Cela
implique que Bob ne l’a jamais invitée car sinon, en vertu de la remarque ci-dessus, son mari serait forcément
mieux que Bob. Si Bob ne l’a jamais invitée, c’est qu’il est marié à une fille qu’il préfère à Alice.
Supposons qu’Alice et Bob ne sont pas mariés ensemble et que Bob préfère Alice à sa femme actuelle.
Comme Bob fait ses invitations dans l’ordre décroissant de ses préférences, c’est qu’Alice a refusé une
invitation de sa part, et donc qu’Alice, ce matin-là et les suivants, a reçu des invitations plus intéressantes
de son point de vue.
Dans tous les cas, si Alice et Bob ne sont pas mariés ensemble, c’est que l’un des deux est mariés à
quelqu’un qu’il préfère. L’ensemble des mariages est donc stable.
6.6 Exercices
6.6.1 Une caractérisation des graphes bipartis
Prouver la Proposition 6.1.
O E
Figure 6.2 – Des postes d’observation possibles.
6.6.2 Théorème de König

Prouver le Théorème 6.3.
6.6.3 Positionnement de postes d’observation

Considérer le domaine de la Figure 6.2. Chaque point indique une position possible pour
un poste d’observation. On veut que chaque poste d’observation ait la vue complètement
dégagée dans les 4 directions cardinales (nord, sud, est, ouest) – deux postes d’observation
ouverts ne peuvent donc ni se trouver sur la même ligne, ni se trouver sur la même colonne. On
veut en ouvrir un nombre maximum. Proposer un nombre maximum dans le cas particulier
de la Figure 6.2. Prouver la qualité de votre solution. Proposer la méthode générale (est-ce
polynomial ?).
CHAPITRE 7
Que faire face à un problème difficile ?
7.1 Introduction
Jusqu’à présent nous avons vu un certain nombre de problèmes, certains NP-difficiles,
d’autres polynomiaux. Pour les problèmes polynomiaux, nous avons discuté les algorithmes
possibles pour les résoudre ; pour les autres, rien n’a été indiqué, ce qui pourrait laisser penser
qu’on ne sait pas les résoudre. Bien entendu, c’est faux, et heureusement, car de nombreux
(la plupart ?) problèmes industriels sont NP-difficiles.
L’objet de ce chapitre est de présenter quelques méthodes générales, indépendantes du
problème, que l’on peut employer lorsqu’on est confronté à un problème d’optimisation NP-
difficile, que l’on écrit sous la forme
Min f (x)
(7.1)
s.c. x ∈ X,
où X est supposé fini mais très grand.
Un problème NP-difficile est tel qu’il n’est pas possible (sauf si finalement il s’avèrait
que P = NP) de trouver en temps polynomial, i.e. raisonnable, la solution exacte pour
toute instance. On peut donc soit relâcher la condition solution exacte et vouloir garder
un temps raisonnable d’exécution, soit relâcher la condition sur le temps et garder le désir
d’avoir une solution exacte.
La première option conduit aux algorithmes approchés, qui calculent en temps raisonnable
des solutions qui sont proches de l’optimum. Ces algorithmes approchés sont des heuristiques
ou des métaheuristiques. Une heuristique n’a de sens que pour un problème donné, c’est un
algorithme ad hoc pour lequel le bon sens assure son fonctionnement en général. Il n’est pas
toujours possible de garantir la qualité de la solution fournie par une heuristique et l’on est
parfois obligé de les valider par des batteries de tests prouvant leurs efficacités de manière
expérimentale. Nous verrons quelques exemples dans les chapitres suivants, mais il n’existe
pas de schéma général qui permettent de dériver de tels algorithmes. Une métaheuristique
est une méthodologie très générale pour concevoir un algorithme d’optimisation. Sa vocation
est de pouvoir s’adapter à un grand nombre de problèmes d’optimisation, plus ou moins
indépendamment de leur structure. Ce sera l’objet de la Section 7.3. Il est en général très
difficile de garantir a priori leurs performances et l’on ne peut alors échapper à des validations
CHAPITRE 7. QUE FAIRE FACE À UN PROBLÈME DIFFICILE ? 90
expérimentales.
La seconde option conduit aux algorithmes exacts, comme ceux de séparation et évaluation,
ou branch-and-bound, dont nous allons présenter le principe dans la Section 7.2. Plusieurs
exemples seront donnés aux cours des séances suivantes. Un branch-and-bound suppose l’exis-
tence de bonnes bornes sur la solution (borne inférieure si on minimise, borne supérieure si
on maximise).
Dans un contexte industriel, un algorithme exact, dont le temps d’exécution peut être
long, sera plutôt utilisé pour des questions stratégiques. Une heuristique ou une métaheuristique
peut avoir des temps d’exécution très courts et sera donc plutôt utilisée pour des questions
tactiques ou opérationnelles.
7.2 Branch-and-bound
7.2.1 Description
On suppose que l’on dispose d’une fonction λ : P(X) → R qui a toute partie Y de X,
associe λ(Y ) ≤ Min x∈Y f (x). La quantité λ(Y ) est donc une borne inférieure de f sur Y .
On supposera de plus que λ se calcule “facilement” (par exemple, en temps polynomial).
Conceptuellement, l’algorithme de branch-ad-bound maintient
S
— une collection Y de parties de X telle que Y contient un minimum de f sur X
— la meilleure solution courante x̃.
Une itération est alors
Choisir une partie Y de Y.

• Si Y est réduit à un singleton {y} : supprimer Y de Y ; si f (y) <
f (x̃), poser x̃ := y.
• Sinon : partitionner Y en parties Y1 , Y2 , . . . , Ys ; supprimer Y de
Y ; faire : pour i = 1, . . . , s, si λ(Yi ) < f (x̃), poser Y := Y ∪ {Yi }.
L’idée principale du branch-and-bound réside dans cette dernière étape : il ne sert à rien
de conserver la partie Yi si λ(Yi ) ≥ f (x̃). En effet, comme λ(Yi ) ≤ Min x∈Yi f (x), on n’est
sûr que sur Yi on ne parviendra pas à améliorer strictement la valeur de la fonction objectif.
Il ne sert donc à rien d’explorer cette partie.
On représente souvent l’exploration de l’espace des solutions par une arborescence, dont
les nœuds sont les Y , et les arêtes codent la partition (voir exemple ci-dessous).
On comprend qu’un algorithme de branch-and-bound marchera d’autant mieux que la
borne λ sera bonne. La branchement, i.e. l’opération de partition de Y est également impor-
tante. Souvent, la structure du problème impose assez naturellement les façons de brancher.
Enfin, le choix de la partie Y dans Y peut également influencer la qualité de l’algorithme.
Deux solutions classiques sont les suivantes :
91 CHAPITRE 7. QUE FAIRE FACE À UN PROBLÈME DIFFICILE ?
— En profondeur d’abord : brancher toujours sur la dernière partie Yi ajoutée à Y. On va

descendre très vite dans l’arborescence. Cela peut être utile par exemple si on n’a pas
de bonne solution réalisable.
— En largeur d’abord : brancher toujours sur la partie Y telle que Y = argminY ∈Y λ(Y ).
C’est intéressant si λ est une bonne évaluation par défaut de f .
Nous allons maintenant voir deux exemples très classiques de calcul de borne, et nous
appliquerons ensuite l’algorithme sur un exemple très simple, en guise d’illustration.
7.2.2 Programmation linéaire en nombres entiers

Un grand champ d’application du branch-and-bound est la programmation linéaire en
nombres entiers. Comme il va être vu ci-dessous, la programmation linéaire en nombres
entiers est NP-difficile.
Programmation linéaire en nombres entiers

Contrairement à la programmation linéaire où les variables prennent leurs valeurs dans
R, la programmation linéaire en nombres entiers, où les variables prennent leurs valeurs dans
Z, n’est pas polynomiale. De façon générale, la programmation linéaire en nombre entiers se
modélise, avec A une matrice m × n à coefficients rationnels, et b ∈ Qm et c ∈ Qn
Min cT x
s.c. Ax ≤ b (7.2)
x ∈ Zn .
Même le cas suivant, où il n’y a qu’une seule contrainte, est NP-difficile.
Max Pni=1 ci xi
P
n
s.c. i=1 wi xi ≤ W
xi ∈ {0, 1} pour i = 1, . . . , n,
avec les wi et W entiers. Il s’agit en effet du problème du sac-à-dos, vu au Chapitre 3.
Noter que les algorithmes du simplexe, des points intérieurs ou des ellipsoı̈des ne peuvent
absolument pas résoudre les programmes linéaires en nombres entiers, ils sont conçus uni-
quement pour les variables continues.
Relaxation continue
Une borne inférieure à la valeur optimale vplne de (7.2) s’obtient en relâchant la contrainte
d’intégrité, i.e. en ne demandant plus à ce que x soit à coordonnées entières. En effet,
considérons
Min c · x
s.c. Ax ≤ b (7.3)
n
x∈R ,
et notons vpl sa valeur optimale. Toute solution réalisable du programme (7.2) étant solution
réalisable de (7.3), on a vplne ≥ vpl .
Exemple
On considère le programme
Max x1 + 5 2
s.c. −4x1 + 2x2 ≤ 3
(7.4)
2x1 + 8x2 ≤ 39
x1 , x2 ∈ Z.
L’arborescence est donnée Figure 7.1. Remarquer que par deux fois, on évite l’exploration
d’une sous-arborescence en utilisant la borne : une fois sur le noeud x1 ≤ 1, et l’autre fois
sur le noeud x1 ≥ 4, x2 ≤ 3.
Utilisation de solveurs
Il a déjà été noté que si un problème s’écrit sous la forme d’un programme linéaire
avec des variables continues, il est inutile de procéder à l’implémentation d’un algorithme
pour résoudre ce problème : il existe déjà de nombreux solveurs – libres ou commerciaux –
utilisant l’algorithme de simplexe ou l’algorithme des points intérieurs. La même remarque
vaut également en grande partie pour les programmes linéaires en nombres entiers : la plupart
des solveurs comportent des branch-and-bound intégrés et très performants, voir l’annexe du
polycopié. La partie informatique de la résolution du problème consiste alors principalement
à écrire le problème dans un langage de modélisation simple d’utilisation (comme OPL,
AMPL, GPL,...) que peut comprendre le solveur et à appuyer sur le bouton pour obtenir
la solution. Implémenter son propre branch-and-bound pour un problème linéaire en nombres
entiers peut cependant être justifié dans certains cas : par exemple, si le problème a une
structure particulière qui n’est pas exploitée par ces solveurs, ou si le nombre de contraintes
est exponentiel comme pour le problème du voyageur de commerce, voir Chapitre 11.
7.2.3 Relaxation lagrangienne

Min f (x)
s.c. x ∈ X
(7.5)
gi (x) = 0 i = 1, . . . , p
gi (x) ≤ 0 i = p + 1, . . . , p + q
où f, g1 , . . . , gp+q sont des fonctions de Rn dans R, et X un sous-ensemble non vide de Rn . On

suppose que si les fonctions gi n’étaient pas présentes, le problème serait facile à résoudre.
L’idée consiste à dualiser les contraintes gi en écrivant le lagrangien (voir Section 2.3.5)
p+q
X
L(x, λ) := f (x) + λi gi (x),
i=1
avec λ ∈ Λ := Rp × (R+ )q .
Si on note v la valeur optimale de (7.5), on a toujours
v = inf sup L(x, λ) ≥ sup inf L(x, λ) = sup G(λ), (7.6)

x∈X λ∈Λ λ∈Λ x∈X λ∈Λ
où
G: Λ → R ∪ {−∞}
G(λ) 7→ inf x∈X L(x, λ),
est la fonction duale. Elle est concave et affine par morceaux (car infimum de fonctions af-
fines). L’idée de la relaxation lagrangienne est d’utiliser supλ∈Λ G(λ) comme borne inférieure,
laquelle peut ensuite être utilisée au sein d’un branch-and-bound. La question est donc de
savoir calculer cette quantité. Pour cela on peut utiliser des techniques de l’optimisation
non-différentiable, une méthode de sur-gradient par exemple 1 , qui nécessite principalement
de savoir calculer un sur-gradient en tout point λ. Cette méthode est décrite à la fin de cette
section.
Rappelons qu’un sur-gradient p de G au point λ est tel que
G(µ) − G(λ) ≤ pT (µ − λ) pour tout µ ∈ Λ.
En particulier, si G est dérivable, le sur-gradient coı̈ncide avec son gradient.

Heureusement, cela se fait facilement, grâce à la proposition suivante.
Proposition 7.1. Si X est fini, alors (gi (x))i=1,...,p+q est un sur-gradient de G au point λ
dès que x réalise inf x∈X L(x, λ).
Pp+q
Démonstration. Soit un tel x. Pour tout µ, on a G(µ)−G(λ) ≤ L(x, µ)−L(x, λ) = i=1 gi (x)(µi −λi ).
Un des intérêts de la relaxation lagrangienne est contenu dans le théorème suivant (preuve
omise).
Théorème 7.1. Pour un programme linéaire en nombres entiers, la borne obtenue par re-
laxation lagrangienne est toujours au moins aussi bonne que celle obtenue par relaxation
linéaire.
Cela dit, il existe beaucoup de cas où ces deux bornes coı̈ncident. Cela n’empêche pas la
relaxation lagrangienne d’être intéressante (comme dans l’exemple ci-dessous), car le calcul
de supλ∈Λ G(λ) peut-être plus rapide que la résolution du programme linéaire.
1. ou alors par la méthode des faisceaux, plus efficace mais qui dépasse le cadre de ce cours, voir [5].
Exemple
Un exemple très classique est celui du plus court chemin avec contrainte de temps.
Soit D = (V, A) un graphe orienté, avec deux sommets s et t. A chaque arc a est associé un
coût ca ≥ 0 et un temps ta ≥ 0. On veut trouver le s–t chemin le moins coûteux qui mette
un temps inférieur à T . Ce problème se résout bien avec un branch-and-bound, utilisant
des bornes
P fournies par la relaxation lagrangienne. X est alors l’ensembleP des s–t chemins,
f (x) = a∈A ca xa et l’on a une seule contrainte du type gi , c’est g(x) := a∈A ta xa ≤ T .
Ecrivons G(λ), défini pour λ ≥ 0.
!
X X
L(x, λ) = ca xa + λ −T + ta xa .
a∈A a∈A
Donc X
G(λ) = −T λ + min (ca + ta λ)xa .
x∈X
a∈A
Le calcul de G(λ) se fait donc par un calcul de plus court chemin où les coûts des arcs sont
non plus les ca mais les ca + λta . Ce calcul peut se faire par l’algorithme de Dijkstra
P car les
poids sont positifs ou nuls, et la solution x, injectée dans g donne la valeur −T + a∈A ta xa ,
cette dernière quantité étant alors le sur-gradient de G en λ (d’après la Proposition 7.1).
On sait donc calculer les sur-gradients de G, donc on sait maximiser G sur Λ = R+ , donc
on sait calculer de bonnes bornes inférieures pour notre problème, et on peut donc faire un
branch-and-bound.
Méthode de sur-gradient
Posons Λ = {(λ1 , . . . , λp , λp+1 , . . . , λp+q ) ∈ Rp+q : λi ≥ 0 pour i ≥ p + 1}. Soit PΛ la
projection dans Λ définie par PΛ (λ) = (λ1 , . . . , λp , λ+ +
p+1 , . . . , λp+q ), avec la notation t
+
=
max(0, t). Supposons que l’on veuille maximiser G(λ) sur Λ, avec G concave. L’algorithme
de sur-gradient consiste à construire la suite

ρk
λk+1 = PΛ λk + p ,
||pk || k
où λ0 est choisi arbitrairement dans Λ, où pk est un sur-gradient de G au point λk , et où
(ρk ) est une suite prédéterminée de réels strictement positifs telle que
+∞
X
lim ρk = 0 et ρk = +∞.
k→+∞
k=0
Lorsque pk vaut 0, l’algorithme s’arrête, λk est alors le maximum de G.

On peut montrer que l’algorithme converge vers le maximum de G, mais la convergence
est lente (le pas de convergence devant nécessairement tendre vers 0).
7.3 Métaheuristiques
Nous allons décrire quelques métaheuristiques, qui sont des méthodes générales d’explo-
ration de l’espace des solutions réalisables, qui peuvent être décrites indépendamment du
problème. Les métaheuristiques peuvent parfois donner de très bons résultats ou constituer
la seule arme pour attaquer un problème ; il est donc nécessaire de les connaı̂tre lorsqu’on
fait de la recherche opérationnelle. De plus, il est facile de contrôler leur temps d’exécution.
Cela dit, leur implémentation dépend d’un certain nombre de paramètres dont les valeurs
nécessitent beaucoup d’expérimentations. De plus, ces algorithmes n’ont généralement pas
de garantie sur la qualité de la solution trouvée.
7.3.1 Recherche locale

Le principe
On cherche toujours à résoudre (7.1).
L’idée de la recherche locale est la suivante. On suppose connue une bonne solution
réalisable de départ, trouvée par une heuristique quelconque. Ensuite, on essaie d’améliorer
la solution courante en procédant à des “modifications” locales.
Plus précisément,
1. il faut définir sur X un graphe implicite (ce graphe ne sera jamais explicitement codé
en machine), une solutions réalisable étant connectée à une autre solution réalisable si
on passe de la première à la seconde par une modification autorisée. Pour une solu-
tion réalisable x, on note Γ(x) l’ensemble de ses voisins dans le graphe implicite, i.e.
l’ensemble des solutions réalisables que l’on peut atteindre de x par une modification
locale. Une condition nécessaire pour pouvoir trouver l’optimum global est que la so-
lution réalisable de départ est dans la même composante connexe du graphe implicite
que l’optimum cherché.
2. il faut aussi définir à quelle condition on modifie la solution courante. La solution
consistant à modifier la solution courante si la modification a amélioré la valeur de f
est naı̈ve : en effet, un tel algorithme va “plonger” vers un optimum local, qu’il ne va
plus quitter.
L’implémentation de la version naı̈ve est donc : On part d’une solution réalisable x.
Ensuite on répète
Si {y ∈ Γ(x) : f (y) < f (x)} est non vide, choisir y ∈ Γ(x) tel que
f (y) < f (x) et poser x := y.
Puisqu’on a supposé X fini, l’algorithme se termine sur un x ∈ X, qui sera un minimum

local de f .
Pour éviter de se retrouver bloqué sur n’importe quel minimum local, deux stratégies
classiques sont employées, la méthode tabou et le recuit simulé, détaillées plus bas.
Un exemple : la coloration de graphe
Considérons le problème de la coloration de graphe (voir Section 2.1.1). On veut colorer

les sommets d’un graphe G = (V, E) de manière à ce que deux sommets voisins ont des
couleurs distinctes, et en utilisant un nombre minimum de couleurs. C’est un problème NP-
difficile.
Une recherche locale pour ce problème consiste à définir l’ensemble X des solutions
réalisables comme l’ensemble des colorations propres et à considérer deux colorations propres
comme voisines si elles diffèrent uniquement par la couleur d’un sommet. La fonction objectif
est le nombre de couleurs utilisées. Cette approche a un inconvénient : la plupart des modifi-
cations n’implique pas un changement de la valeur de la fonction objectif. Avec la définition
stricte de l’algorithme naı̈f ci-dessus, on se retrouve très vite bloqué sur des minima locaux.
Même en acceptant des modifications à valeur constante de la fonction objectif, ou des mo-
difications détériorant cette valeur (comme dans les métaheuristiques décrites ci-dessous),
cela reste problématique car la fonction objectif donne peut d’information sur la direction à
prendre.
Une façon plus efficace de résoudre le problème de
Pla coloration [15] est de fixer un entier k
et de résoudre le problème consistant à minimiser ki=1 |E[Vi ]| sur l’ensemble des partitions
V1 ∪ · · · ∪ Vk de V . Rappelons que E[Vi ] est l’ensemble des arêtes de G ayant leurs deux
extrémités dans Vi . Si l’on parvient à atteindre 0, on aura trouvé une coloration en au plus k
couleurs : chaque partie Vi peut être vue comme l’ensemble des sommets de couleur i ; comme
alors E[Vi ] = ∅, on est sûr de ne pas avoir deux sommets de même couleur adjacents. La
recherche locale résout extrêmement bien cette tâche : l’ensemble X des solutions Pkréalisables
est alors l’ensemble des partitions V1 ∪ · · · ∪ Vk de V . La fonction objectif est i=1 |E[Vi ]|.
On accepte de passer de passer d’une solution à une autre si le changement consiste modifier
la couleur (l’appartenance à l’un des Vi ) d’un sommet appartenant à une arête dont les deux
extrémités sont de couleur identique. Une dichotomie sur k permet de trouver in fine le
nombre chromatique de G, ou en tout cas, une bonne approximation de ce dernier.
Méthode tabou
La méthode tabou consiste à maintenir une liste L de solutions réalisables tabous ,

dont la taille, constante, est un paramètre de l’algorithme. Si l est cette taille 2 , on commence
par une solution réalisable x tabou. On choisit une liste L qui contient l autres solutions
réalisables et on pose x∗ := x (x∗ est la meilleure solution courante). Ensuite, on répète
— choisir y minimisant f (y) sur Γ(x) \ L

— enlever le premier élément de L, et ajouter x à la fin de L,
— poser x := y,
— si f (x) < f (x∗ ), poser x∗ := x.
2. par exemple l = 7.
On arrête l’algorithme lorsqu’on ne parvient pas à trouver de x améliorant x∗ , ou après un

nombre prédéterminé d’itérations.
La solution x∗ retournée à la fin est en général meilleure que celle retournée par la version
naı̈ve de la recherche locale. En effet, la liste tabou permet de sortir de certains minima
locaux puisqu’elle autorise de choisir des solutions qui ne sont pas strictement meilleures que
la solution courante, et force à explorer des solutions qui n’ont pas été visitées dans les l
dernières itérations.
Recuit simulé
Le recuit simulé imite la pratique du recuit en métallurgie qui consiste à alterner de
lents refroidissements et de réchauffages (recuits) pour minimiser l’énergie d’un matériau.
L’algorithme maintient une température T qui va tendre vers 0, et les transitions d’une
solution réalisable à une solution réalisable voisine auront lieu avec une probabilité dépendant
de la différence de la valeur prise par f et de la température. Plus précisément, si on a choisi
y voisin de x, la probabilité de passer effecivement de x à y ∈ Γ(x) sera, par analogie avec
la physique 3
f (y)−f (x)
min 1, e− T .
Une fois fixée au préalable la suite Tk des températures (telle que Tk → 0 quand k → ∞),
on peut écrire l’algorithme. On part d’une solution réalisable x. Ensuite, on répète
Tirer un voisin
y uniformément dans Γ(x). Faire x := y avec la pro-
f (y)−f (x)
−
babilité min 1, e Tk
. Poser k := k + 1.
Plusieurs auteurs ont donné des conditions suffisantes pour que x tende en probabilité
vers l’optimum global. Par exemple, Hajek [14] a donné une condition nécessaire et suffisante
assez légère pour cette convergence en probabilité avec Tk de la forme log κ2+k .Cette condition
met en jeu les notions d’irréductibilité et de faible réversibilité des chaı̂nes de Markov.
En pratique, on aime bien avoir Tk de la forme 4
Tk := T0 β k
ou de la forme
1
Tk :=
α + sk
avec α et s des paramètres bien choisis. La plupart du temps, ces derniers sont déterminés
expérimentalement. Comme la méthode tabou, le recuit simulé autorise des détériorations
de la qualité de la solution courante. Elle permet donc de sortir des minima locaux, si ces
derniers ne sont pas trop petits par rapport à leurs voisins, et d’explorer une plus grande
partie de l’espace des solutions.
3. Pour un système fermé, à la température T , la probabilité d’être dans un état d’énergie E est de la
E
k T
forme e ZB où Z est la fonction de partition, kB la constante de Boltzmann.
4. avec par exemple β = 0, 93.
7.3.2 Algorithmes évolutionnaires, colonie de fourmi, etc.

Il y a bien d’autres exemples de métaheuristiques. L’idée des algorithmes évolutionnaires
est d’identifier les solutions réalisables à des individus et de coder ces solutions réalisables
sur les chromosomes des individus. On autorise les individus à se croiser avec une probabilité
d’autant plus grande que les individus sont de qualité. De plus ces individus peuvent muter.
On part alors d’une population de taille fixée d’individus, et on laisse évoluer le tout. Ce qui
est crucial ici, c’est le codage d’une solution réalisable sur les chromosomes et la nature du
croisement, qui doit maintenir les avantages compétitifs de ses parents.
L’algorithme de colonie de fourmis, tout comme le recuit simulé ou les algorithmes
évolutionnaires, cherche à imiter la nature dans la façon dont elle résout ses problèmes
d’optimisation. Les fourmis pour trouver leur nourriture explorent au hasard l’espace des
solutions, en ayant une toute petite vue locale, mais grâce à des échanges d’information
(phéromones), elles parviennent à trouver la source de nourriture et à trouver le trajet le
plus court. Une fourmi qui a trouvé de la nourriture revient à la fourmilière en déposant au
sol des phéromones, qui s’évaporent au bout d’un certain temps. D’autre part, une fourmi
qui part à la recherche de nourriture va suivre préférentiellement ces phéromones au sol.
Etant donnés deux chemins conduisant de la fourmilière à la nourriture, le plus court sera
donc plus attractif que le long car les fourmis qui l’empruntent déposent des phéromones
plus fréquemment. L’algorithme va donc simuler l’exploration de l’espace des solutions par
des fourmis, qui marqueront leur passage.
7.4 Exercices
7.4.1 Borne inférieure par la relaxation lagrangienne

Prouver l’inégalité (7.6).
7.4.2 Gestion dynamique de stock, cas à plusieurs biens

Cet exercice fait suite à l’exercice 5.3.11.
Supposons maintenant qu’il n’y ait pas un seul bien, mais K biens, indicés par k =
1, 2, . . . , K. Pour chaque bien k, on a une demande dkt sur chaque période t. On satisfait
la demande en produisant xkt de bien k sur la période t et/ou en prélevant une certaine
quantité sur le srock yk(t−1) de la période t − 1. On suppose que la production en période t
pour le bien k ne peut pas excéder Pkt . De plus, on ne possède qu’une machine, et donc sur
une période on ne peut produire qu’un seul type de bien. Le coût de production unitaire du
bien k en période t est noté pkt , et celui de stockage unitaire skt .
1. Ecrire la dynamique du stock dans ce cas-là.
2. En introduisant une variable zkt qui indique si le bien k est produit sur la période t,
proposer une contrainte linéaire (indicée par t) qui empêche la production de plusieurs biens
sur la période t.
3. Ecrire une contrainte (indicée par k et t) qui limite la production du bien k en période
t, en tenant compte du fait que si un autre bien k 0 6= k est produit, alors la production du
bien k doit être nulle.
4. Montrer que ce problème peut se modéliser comme un programme linéaire mixte en
nombres entiers (mixte signifie que toutes les variables ne sont pas contraintes à être entières).
Dans une approche par branch-and-bound, on va chercher des bornes inférieures. Une
solution est de procéder par relaxation lagrangienne.
5. Montrer qu’en relaxant les bonnes contraintes, le calcul des bornes inférieures par
la relaxation lagrangienne se ramène à des calculs de gestion de stock à un seul bien, et
expliquer comment calculer ces bornes dans le cas où les Pkt sont suffisament grands.
6. Si les Pkt ne sont pas suffisament grands, le problème à un seul bien est NP-difficile.
Proposer une solution pour le calcul de la borne inférieure par la programmation dynamique
qui garde une complexité raisonnable.
7.4.3 Extraction de mine à ciel ouvert – cas dynamique

On se remet dans le contexte de l’Exercice 5.3.12. On essaie cette fois de prendre en
compte l’aspect dynamique. On cherche à déterminer la séquence d’extraction des blocs dans
les mines à ciel ouvert. La mine est assimilée à une collection de n blocs numérotés de 1 à n,
le bloc i ayant une masse mi . On se place dans un contexte à horizon de temps fini. Le temps
est discrétisé est assimilé à des années τ = 1, . . . , T . Un bloc i extrait l’année τ entraı̂ne un
profit de ci,τ dollars. Cette quantité ci,τ peut éventuellement être négative si l’extraction du
bloc i coûte plus qu’il ne rapporte. La dépendance en temps permet de tenir compte du taux
d’actualisation, des tendances des cours boursiers, etc.
A l’année τ donnée, on peut extraire plusieurs blocs, mais pas plus d’une masse totale
Mτ .
Les blocs ne peuvent pas être extraits dans n’importe quel ordre : pour chaque bloc i,
on connaı̂t l’ensemble Yi des blocs qu’il faut avoir extraits pour pouvoir extraire le bloc i.
Si le bloc i est extrait au cours de l’année τ , tout bloc de Yi doit être extrait au cours de
l’année τ ou avant. L’objectif est de proposer un sous-ensemble de blocs à extraire et les
années auxquelles extraire ces blocs de manière à maximiser le profit total (on appelle cela
un plan d’extraction).
On suppose maintenant que les ci,τ dépendent bien du temps. On parle alors du cas
dynamique. Etant donné un plan d’extraction, on note xi,τ = 0 si le bloc i est extrait
strictement après l’année τ et xi,τ = 1 sinon. On tient à nouveau compte de la contrainte de
masse.
1. Proposez un programme linéaire en nombres entiers qui modélise le cas dynamique, en
utilisant les variables xi,τ . On posera de plus xi,0 = 0 pour tout i. Justifiez votre réponse.
En pratique, ces programmes linéaires peuvent avoir un grand nombre de variables (le
produit N T peut être grand). On va chercher dans la suite des méthodes pour améliorer les
temps de calculs lorsqu’on donne un tel programme linéaire à un solveur.
P∗
2. Soit i∗ et τ ∗ tels que mi∗ + k∈Yi∗ mk > ττ 0 =1 Mτ 0 . On dit alors que (i∗ , τ ∗ ) est une
P
bonne paire. Expliquez pourquoi toute solution réalisable du programme linéaire en nombres
entiers de 1. satisfait xi∗ ,τ ∗ = 0 lorsque (i∗ , τ ∗ ) est une bonne paire.
3. Considérons deux blocs i∗ et j ∗ et une année τ ∗ tels que k∈Yi∗ ∪Yj∗ ∪{i∗ }∪{j ∗ } mk >
P
Pτ ∗ ∗ ∗ ∗
τ 0 =1 Mτ 0 . On dit alors que (i , j , τ ) est un bon triplet. Expliquez pourquoi toute solution
réalisable du programme linéaire en nombres entiers de 1. satisfait xi∗ ,τ ∗ + xj ∗ ,τ ∗ ≤ 1 lorsque
(i∗ , j ∗ , τ ∗ ) est un bon triplet (on dira que cette contrainte est induite par le bon triplet).
4. Supposons que le solveur fonctionne par un branch-and-bound qui utilise les bornes de
la relaxation continue (ou linéaire). On fixe à 0 les variables indicées par une bonne paire.
On ajoute au programme linéaire en nombres entiers de 1. plusieurs contraintes induites par
des bons triplets. Expliquez pourquoi cela ne change pas la solution optimale du programme
linéaire en nombres entiers, et en quoi cela va améliorer les temps de calculs (au moins pour
les grandes instances).
x1 = 1, 5
x2 = 4, 5
v = 24
x1 ≤ 1 x1 ≥ 2
x1 = 1 x1 = 2
x2 = 3, 5
x2 = 4, 375
v = 18, 5
v = 23, 875
x2 ≤ 4
x2 ≥ 5
on abandonne l’exploration car v est moins bon x1 = 3, 5
que le meilleur résultat entier courant.
x2 = 4
irréalisable
v = 23, 5
x1 ≤ 3
x1 ≥ 4
x1 = 3 x1 = 4
x2 = 4 x2 = 3, 875
v = 23
v = 23, 375
x2 ≤ 3 x2 ≥ 4
x1 = 7, 5
x2 = 3
v = 22, 5 irréalisable
on abandonne l’exploration car v est moins bon

que le meilleur résultat entier courant.
Figure 7.1 – Un arbre de branch-and-bound.

Deuxième partie
Problématiques
103
CHAPITRE 8
Remplissage de conteneurs
Le thème de ce chapitre est le suivant : on a des objets et des conteneurs, comment remplir
au mieux ? Ecrit comme cela, le problème est assez imprécis. Nous allons nous focaliser sur
deux problèmes particuliers qui rentrent dans la catégorie des problèmes de remplissage, le
problème du sac-à-dos et celui du bin-packing. Le problème du sac-à-dos a déjà été vu au
Chapitre 3, mais allons discuter d’autres aspects de ce problème.
Le problème du sac-à-dos dans sa version la plus simple peut se décrire informellement
de la manière suivante : on a des objets de poids et de valeur variable ; on dispose d’un
seul conteneur (le sac-à-dos) qui est muni d’une contrainte de poids ; remplir le conteneur de
manière à maximiser la valeur des objets stockés.
Le problème du bin-packing dans sa version la plus simple peut se décrire informellement
de la manière suivante : on a des objets de taille variée et un seul type de conteneur ; trouver
le nombre minimum de conteneur permettant de tout stocker.
Ces problèmes ont des applications directes dans le domaine de la logistique : stocker des
produits, remplir des camions, etc.
8.1 Sac-à-dos
8.1.1 Le problème
De façon formelle, le problème du sac-à-dos s’écrit
Problème du sac-à-dos
Donnée : des entiers positifs n, w1 , . . . , wn et W , et des réels c1 , . . . , cn .
P P
Tâche : trouver un sous-ensemble S ⊆ {1, . . . , n} tel que j∈S wj ≤ W et j∈S cj est
maximum.
Cela peut s’interpréter de la manière suivante : W est la charge maximale du conteneur,

wi est le poids de l’objet i, et ci sa valeur. On a n objets, mettre dans le conteneur un
sous-ensemble S d’objets de valeur maximale, tout en respectant la contrainte de poids.
Les applications en logistique sont évidentes. Mais il existe bien d’autres domaines où ce
problème se retrouve. Par exemple, en finance : on a un budget fini W , on a des produits
financiers i coûtant chacun wi et rapportant ci sur l’année à venir ; maximiser le profit.
Comme d’habitude, commençons par cerner la complexité du problème.
CHAPITRE 8. REMPLISSAGE DE CONTENEURS 106
Théorème 8.1. Le problème du sac-à-dos est NP-difficile.
Nous avons déjà vu au Chapitre 3 qu’une façon commode de résoudre ce problème, si les
wi sont entiers (ce à quoi on peut toujours se ramener en changeant l’unité de mesure) et
si W n’est pas trop grand, passe par l’utilisation de la programmation dynamique, laquelle
fournit un algorithme pseudo-polynomial en O(nW ). Nous allons présenter d’autres façons
de résoudre ce problème.
8.1.2 Formulation sous forme d’un programme linéaire et branch-and-bound

On peut modéliser le problème du sac-à-dos sous forme d’un programme linéaire en
nombres entiers.
Pn
Max cx
Pnj=1 j j
s.c. j=1 wj xj ≤ W
xj ∈ {0, 1} j ∈ {1, . . . , n}.
Remarquons que dans un sens ce programme linéaire en nombres entiers est le plus
simple possible : chaque variable ne peut prendre que deux valeurs, et il n’y a qu’une seule
contrainte.
La relaxation continue fournit une borne supérieure naturelle à la solution du programme
précédent Pn
Max cx
Pnj=1 j j
s.c. j=1 wj xj ≤ W
0 ≤ xj ≤ 1 j ∈ {1, . . . , n}.
Pour la calculer (pour faire du branch-and-bound par exemple – voir ci-dessous), on
pourrait bien sûr faire appel à l’algorithme du simplexe ou à l’algorithme des points intérieurs.
Mais il existe un algorithme très simple, glouton, qui calcule la solution optimale du relâché
continu.
On suppose que nj=1 wj > W , sinon, le problème du asc-à-dos est trivial. Ensuite on
P
fait
Classer les objets de façon à ce que

c1 c2 cn
≥ ≥ ... ≥ .
w1 w2 wn
Poser x1 = x2 = · · · = xj̄ := 1 avec j̄ le plus grand entier tel que

Pj̄
j=1 wj ≤ W .
W − j̄j=1 wj
P
Poser xj̄+1 := wj̄+1
.
Poser xj̄+2 = · · · = xn := 0.
Lemme 8.1. Un tel x est solution optimale du relâché continu.

107 CHAPITRE 8. REMPLISSAGE DE CONTENEURS
Eléments de preuve. On prouve d’abord que si x est optimal avec xi < 1, xk > 0 et i < k, alors ci /wi =
ck /wk . Par conséquent, il existe une solution optimale avec un indice j̄ tel que xi = 1 pour tout i < j̄ (si
j̄ ≥ 2) et tel que xi = 0 pour tout i > j̄ (si j̄ ≤ n − 1).
On sait donc calculer une borne d’assez bonne qualité (relâché continu) en O(n log(n)).
Cette borne permet de mettre en place un branch-and-bound. Pour le branchement, c’est la
technique usuelle pour les programmes linéaires en {0, 1} : fixer certaines variables à 0 et
d’autres à 1.
8.1.3 Une heuristique naturelle

La discussion précédente sur la relaxation linéaire permet de construire une heuristique
très simple. Reprenons le j̄ calculé par l’algorithme qui résout le relâché continu. Chacun
des ensembles {1, . . . , j̄} et {j̄ + 1} est une solution réalisable. On prend celui de plus grande
valeur.
Une solution construite ainsi a toujours une valeur ≥ 12 OP T , où OP T est la valeur
optimale. En effet, j̄+1
P
j=1 cj est par définition de j̄ une borne supérieure de OP T .
8.2 Bin-packing
8.2.1 Le problème
Le problème du bin-packing traite du cas où l’on a des objets de tailles variables et un
seul type de conteneurs, et où l’on se demande comment utiliser un nombre minimum de
conteneurs pour ranger tous les objets. Dans les formes les plus générales de ce problème,
on peut aussi prendre en compte la forme des objets (on parle alors de bin-packing 2D ou
de bin-packing 3D), des incompatibilités, etc.
Ce problème peut être parfois appelé aussi cutting-stock. En effet, les problèmes de
découpes (de pièces de textile, métal, etc.), où l’on cherche à minimiser les pertes, se
modélisent de façon similaire.
Ici, on se limite au cas le plus simple, 1D. C’est un cas déjà très utile en pratique, puisqu’il
peut fournir des bornes, être utilisé en sous-routines, ou être appliqué tel quel (nombre min
de CD-rom pour stocker le contenu d’un disque dur, découper des planches de longueurs
variables dans des grandes planches de longueur fixée, découpe dans des bandes de tissu,
etc.).
Le problème s’écrit alors formellement
Problème du bin-packing
Donnée : Des entiers positifs ou nuls a1 , . . . , an , W .
P: Trouver un entier naturel k minimum et une affectation f : {1, . . . , n} → {1, . . . , k}

Tâche
avec i: f (i)=j ai ≤ 1 pour tout j ∈ {1, . . . , k}.
Théorème 8.2. Le problème du bin-packing est NP-difficile.

Non seulement il est NP-difficile, mais il existe encore de nombreuses instances de pe-
tite taille non résolue, ce qui justifie et motive largement des travaux de recherche dans
ces domaines. Par exemple, considérons l’instance suivante, dont on ne connaı̂t pas à ce jour
la solution optimale 1 .
taille de la boı̂te : 150

nombre d’objets : 120
taille des objets : 100 22 25 51 95 58 97 30 79 23 53 80 20 65 64 21 26 100 81 98 70 85 92
97 86 71 91 29 63 34 67 23 33 89 94 47 100 37 40 58 73 39 49 79 54 57 98 69 67 49 38 34 96
27 92 82 69 45 69 20 75 97 51 70 29 91 98 77 48 45 43 61 36 82 89 94 26 35 58 58 57 46 44
91 49 52 65 42 33 60 37 57 91 52 95 84 72 75 89 81 67 74 87 60 32 76 85 59 62 39 64 52 88
45 29 88 85 54 40 57
meilleure solution connue : 51 boı̂tes.
Le défi est de trouver une solution en moins de 51 boı̂tes, ou alors de parvenir à montrer
que 51 boı̂tes est la solution optimale. Nous allons décrire maintenant quelques heuristiques
classiques (NEXT-FIT, FIRST-FIT, FIRST-FIT DECREASING), puis nous verrons les ap-
proches branch-and-bound.
8.2.2 Quelques heuristiques classiques

NEXT-FIT
Je prends les objets les uns après les autres. Dès que l’objet i ne peut pas entrer dans la
boı̂te courante, je passe à une nouvelle boı̂te.
De façon plus formelle :
Commencer par k := 1, i := 1 et S := 0. Répéter
Si S + ai > 1, faire k := k + 1 et S := 0. Sinon, faire f (i) := k,

S := S + ai et i := i + 1.
On a
Théorème 8.3. NEXT-FIT fournit une solution SOL telle que
SOL ≤ 2OP T − 1,
où OP T est la valeur d’une solution optimale.

Démonstration. On prouve d’abord la borne suivante.
Pn
i=1 ai
≤ OP T. (8.1)
W
1. source : la page web du professeur Eric Taillard http ://mistic.heig-vd.ch/taillard/

Cette équation se montre en numérotant les boı̂tes de 1 à OP T dans la solution optimale. Ensuite, on
note o(j) l’ensemble des indices i d’objet tels que l’objet i soit dans la boı̂te j. Les o(j) forment une partition
de {1, . . . , n}. On a donc
OP
XT OP
XT X Xn
W ≥ ai = ai .
j=1 j=1 i∈o(j) i=1
Le fait que OP T soit entier permet de conclure (ajout des parties entières).
On Pveut prouver que le k fournit par NEXT-FIT est tel que k ≤ 2OP T − 1. On va montrer que
n
k ≤ 2 d( i=1 ai )/W e − 1 et utiliser la borne (8.1) pour conclure.
Pour j = 1, . . . , k2 on a
X
ai > W,
i: f (i)∈{2j−1,2j}
par définition de l’algorithme NEXT-FIT.

En sommant :
X n
k
W < ai ,
2 i=1
qui peut se réécrire

Pn
k−1

i=1 ai
≤ − 1,
2 W
ce qu’on voulait montrer.
FIRST-FIT
Je prends les objets les uns après les autres. Je mets l’objet i dans la boı̂te de plus petit
rang où il peut entrer.
De façon plus formelle,
poser i := 1. Répéter :
n P o
poser f (i) := min j ∈ N : ai + h<i: f (h)=j ah ≤ W ; poser i := i+1.
Poser k := maxi∈{1,...,n} f (i).
Théorème 8.4. FIRST-FIT fournit une solution SOL telle que

17
SOL ≤ OP T ,
10
où OP T est la valeur d’une solution optimale.
La preuve de ce résultat, difficile, est omise. Ce que ce résultat indique et qui est vérifié
en pratique, c’est que l’heuristique FIRST-FIT marche en général mieux que l’heuristique
NEXT-FIT
FIRST-FIT DECREASING
Je trie d’abord les objets par ai décroissant. Puis j’applique FIRST-FIT.
Théorème 8.5. FIRST-FIT DECREASING fournit une solution SOL telle que
3
SOL ≤ OP T.
2
Tout comme pour le Théorème 8.4, la preuve de ce résultat est omise. C’est cette heuris-
tique qui a en général les meilleurs résultats. L’avantage des deux premiers algorithmes sur
ce dernier est qu’ils peuvent fonctionner on-line, ce qui signifie qu’on peut les faire tourner
lorsque les objets arrivent les uns après les autres et qu’on ne connaı̂t pas la taille des objets
futurs.
8.2.3 Branch-and-bound
Formulation PLNE
Pour l’approche branch-and-bound, la formulation sous forme d’un programme linéaire

va s’avérer utile.
On suppose que l’on a K boı̂tes disponibles. Le problème du bin-packing peut alors
s’écrire
PK
Min j=1 zj
PK
s.c. yji = 1 i = 1, . . . , n
Pj=1
n (8.2)
i=1 ai yji ≤ W zj j = 1, . . . , K
yji , zi ∈ {0, 1} i = 1, . . . , n ; j = 1, . . . , K
où zj = 1 si la boı̂te j est utilisée et yji = 1 si l’objet i est mis dans la boı̂te j.
Relaxation continue
Comme d’habitude, la borne la plus naturelle s’obtient par relaxation continue :

PK
Min j=1 zj
PK
s.c. yji = 1 i = 1, . . . , n
Pj=1
n
i=1 ai yji ≤ W zj j = 1, . . . , K
yji , zi ≥ 0 i = 1, . . . , n ; j = 1, . . . , K
yji , zi ≤ 1 i = 1, . . . , n ; j = 1, . . . , K
C’est un programme linéaire avec un nombre linéaire de contraintes, il n’y a donc pas de
problème pour calculer la borne obtenue par relaxation continue.
Relaxation lagrangienne
PK
On peut faire de la relaxation lagrangienne en “oubliant” les contraintes j=1 yji = 1.
On écrit le lagrangien
K
X n
X XK
L(y, z, λ) := zj + λi ( yji − 1).
j=1 i=1 j=1
Si on note v la valeur optimale du programme (8.2), c’est-à-dire la solution optimale de

notre problème de bin-packing, on a toujours
v = inf sup L(x, λ) ≥ sup inf L(x, λ) = sup G(λ),

x∈X λ∈Λ λ∈Λ x∈X λ∈Λ
où
G: Λ → R ∪ {−∞}
G(λ) 7→ inf x∈X L(x, λ),
est la fonction duale.

Rappelons que cette dernière est concave et affine par morceaux et que l’idée de la re-
laxation lagrangienne est d’utiliser supλ∈Λ G(λ) comme borne inférieure (ou même n’importe
quel G(λ) proche de l’optimum).
Ici,
PK
zj + ni=1 λi ( K
P P
G(λ) := min j=1 j=1 yji − 1)
Pn
s.c. i=1 ai yji ≤ W zj j = 1, . . . , K
yji , zi ∈ {0, 1} i = 1, . . . , n ; j = 1, . . . , K
se réécrit
n
X K
X
G(λ) := λi + Sj
i=1 j=1
avec Sj := miny,z∈{0,1} {z + ni=1 λi yi : ni=1 ai yi ≤ W z}.

P P
On doit donc résoudre K problèmes de sac-à-dos

( n n
)
X X
Sj := min z+ λi yi : ai y i ≤ W z .
y,z∈{0,1}
i=1 i=1
On sait donc calculer G(λ) (assez) facilement et trouver les y, z le réalisant. Et par
conséquent, on sait calculer les sur-gradients de la fonction concave G(λ), et donc la maxi-
miser.
8.3 Exercices
8.3.1 Inégalités valides pour le sac-à-dos
On considère un problème de sac-à-dos avec a1 , . . . , an , b des réels positifs. On note S
l’ensemble des solutions réalisables
( n
)
X
n
S := x ∈ {0, 1} : ai x i ≤ b .
i=1
P
On appelle ensemble dépendant tout ensemble C ⊆ {1, . . . , n} tel que i∈C ai > b.
1. Montrer que tout x ∈ S satisfait l’inégalité
X
xi ≤ |C| − 1,
i∈E(C)
où E(C) = C ∪ {j : aj ≥ maxi∈C ai }.

2. Expliquer l’intérêt de ce type d’inégalités dans une résolution d’un problème de sac-à-
dos dans une approche branch-and-bound.
8.3.2 Inégalités valides pour le bin-packing

On rappelle la modélisation PLNE du problème du bin-packing. On suppose que l’on
dispose d’un stock de K boı̂tes de taille 1.
PK
Min j=1 zj
PK
s.c. yji = 1 i = 1, . . . , n
Pj=1n
i=1 ai yji ≤ zj j = 1, . . . , K
yji , zi ∈ {0, 1} i = 1, . . . , n ; j = 1, . . . , K
où zj = 1 si la boı̂te j est utilisée et yji = 1 si l’objet i est mis dans la boı̂te j.
1. Montrer qu’en ajoutant les contraintes zj ≥ zj+1 , pour j = 1, . . . , K − 1, on continue
à modéliser le problème du bin-packing.
2. Même question avec la contrainte K
P Pn
j=1 zj ≥ d i=1 ai e.
3. Expliquer l’intérêt de ce type d’inégalité dans une résolution d’un problème de bin-
packing dans une approche branch-and-bound.
8.3.3 Gros objets

1
Supposons qu’une instance a1 , . . . , an du bin-packing soit telle que ai > 3
pour tout
i = 1, . . . , n. On suppose toujours que les conteneurs sont de taille 1.
1. Montrer comment modéliser ce problème de bin-packing comme un problème de cou-
plage de cardinalité maximale dans un graphe.
2. Montrer comment en réalité on peut résoudre ce problème en O(n log(n)).
8.3.4 Calcul glouton de relâché continu de problème de sac-à-dos

Compléter la preuve du Lemme 8.1.
CHAPITRE 9
Positionnement d’entrepôts
De nombreuses décisions économiques mettent en jeu la sélection ou le positionnement

de dépôts, d’usines, de relais, d’hôpitaux, etc. afin de répondre de manière optimale à la
demande.
9.1 Formalisation
La version la plus simple du problème de positionnement d’entrepôts est la suivante.
Problème du positionnement d’entrepôts
Donnée : Un ensemble fini de clients D, un ensemble fini d’entrepôts potentiels F, un coût
fixe fi ∈ R+ d’ouverture pour chaque entrepôt i ∈ F et un coût de service cij ∈ R+ pour
chaque i ∈ F et j ∈ D.
Tâche : Trouver un sous-ensemble X ⊆ F (dits entrepôts ouverts) et une affectation σ :
D → X des clients aux entrepôts ouverts, de façon à ce que la quantité
X X
fi + cσ(j)j
i∈X j∈D
soit minimale.
Un exemple d’input et d’output pour ce problème est donné Figures 9.1 et 9.2.
On dit qu’on est dans le le cas métrique si
cij + ci0 j + ci0 j 0 ≥ cij 0 pour tout i, i0 ∈ F et j, j 0 ∈ D.
C’est en particulier le cas lorsque les coûts de services cij sont proportionnels à la distance
géométrique. Cette inégalité contient plus de termes que l’inégalité triangulaire classique, à
laquelle elle ressemble. C’est dû au fait que les coûts ne sont pas nécessairement définis entre
entrepôts ou entre clients.
Commençons par la question de la complexité.
Proposition 9.1. Le problème du positionnement d’entrepôts est NP-difficile, même dans
le cas métrique.
Nous allons un peu discuter des formulations sous forme de programmes linéaires en
nombres entiers et parler rapidement de recherche locale.
CHAPITRE 9. POSITIONNEMENT D’ENTREPÔTS 116
Emplacement potentiel d’un entrepôt
Client
Figure 9.1 – Les données d’un problème de positionnement d’entrepôts.
9.2 Branch-and-bound
9.2.1 Programme linéaire en nombres entiers
Une bonne façon de rechercher un schéma de branch-and-bound est de commencer par la

modélisation sous forme d’un programme linéaire en nombres entiers. Ici, le problème s’écrit
facilement sous cette forme.
P P P
Min i∈F fi yi + i∈F j∈D cij xij
Pij ≤ yi
s.c. x i ∈ F, j ∈ D (1)
i∈F xij = 1 j∈D (2)
xij ∈ {0, 1} i ∈ F, j ∈ D (3)
yi ∈ {0, 1} i ∈ F. (4)
9.2.2 Relaxation linéaire
On peut appliquer la technique du branch-and-bound dans sa version la plus classique.

Le branchement se fait sur les choix de fixer à 0 ou à 1 certaines variables xij et yi . Les
117 CHAPITRE 9. POSITIONNEMENT D’ENTREPÔTS
Figure 9.2 – Une solution au problème du positionnement d’entrepôts.
bornes sont obtenues par le relâché continu :

P P P
Min i∈F f i y i + i∈F j∈D cij xij
s.c. xPij ≤ y i i ∈ F, j ∈ D (1)
i∈F ij = 1
x j∈D (2) (9.1)
0 ≤ xij i ∈ F, j ∈ D (3)
0 ≤ yi i ∈ F. (4)

On peut également obtenir une borne inférieure par relaxation lagrangienne. Relâchons
la contrainte (2)
P
i∈F xij = 1 pour j ∈ F.
On écrit le lagrangien
!
X XX X X
L(x, y, λ) = fi y i + cij xij + λj 1− xij .
i∈F i∈F j∈D j∈D i∈F
Notre problème consiste à résoudre

min max L(x, y, λ).
x∈{0,1}F ×D ,y∈{0,1}F : xij ≤yi λj ∈R
Une borne inférieure à notre problème est donc fournie par
max min L(x, y, λ),

λj ∈R x∈{0,1}F ×D ,y∈{0,1}F : xij ≤yi
c’est-à-dire, en posant
G(λ) := min L(x, y, λ),

x∈{0,1}F ×D ,y∈{0,1}F : xij ≤yi
on a G(λ) borne inférieure pour tout λ ∈ RF , la meilleure borne étant
max G(λ)
λ∈RF
On veut donc être capable de calculer G(λ), i.e. de résoudre à λ fixé
min L(x, y, λ).

x∈{0,1}F ×D ,y∈{0,1}F : xij ≤yi
Il est facile de résoudre le programme : G(λ) := minx∈{0,1}F ×D ,y∈{0,1}F : xij ≤yi L(x, y, λ).
En effet on peut écrire X X
G(λ) = λj + di (λ)
j∈D i∈F
avec X
di (λ) = min fi y i + (cij − λj )xij .
xi · ∈{0,1}D ,yi ∈{0,1},xij ≤yi
j∈D
Chacun des di se calcule facilement. Il suffit de comparer la valeur obtenue en posant

yi = 0 qui impose di = 0 et celle obtenue en posant yi = 1 qui impose xij = 0 si et seulement
si cij ≥ λj .
9.3 Recherche locale

Rappelons que la recherche locale consiste à mettre une notion de voisinage sur l’espace
des solutions réalisables. Une fois ce voisinage défini, on peut facilement implémenter des
métaheuristiques du type tabou, récuit simulé, etc. Dans le cas du positionnement d’en-
trepôts, il est très facile de définir un voisinage sur l’espace des solutions et les méthodes de
recherche locale sont en général très efficaces.
Remarquons d’abord que l’espace des solutions peut être identifié à l’ensemble des parties
X de F. En effet, une fois X fixé, on a toujours intérêt à affecter le client j à l’entrepôt
ouvert i ∈ X minimisant cij .
Ensuite, on dit que X 0 est voisin de X si l’on est dans une des ces situations
1. X 0 := X \ {x} pour un x ∈ X, (drop)
2. X 0 := X ∪ {x0 } pour un x0 ∈ F \ X (add) ou
3. X 0 := X \ {x} ∪ {x0 } (swap).
Dans le cas du problème de positionnement d’entrepôts, on a réalisé dans les années 2000
que la recherche locale était extrêmement efficace (plus que pour les autres problèmes de
RO).
On a par exemple le théorème suivant [2]
Théorème 9.1. On se place dans le cas métrique. Si X est un minimum local pour le
voisinage défini précédemment, alors X vaut au plus 3 fois l’optimum.
En revanche, on n’a pas a priori d’évaluation du temps de calcul d’un optimum local.
9.4 Exercices
9.4.1 Positionnement d’entrepôts avec capacité
On reprend le problème de positionnement d’entrepôts vu en cours, mais avec cette fois

une contrainte supplémentaire : chaque entrepôt ne peut desservir qu’un nombre limité de
clients. Modéliser le problème suivant comme un problème linéaire en nombres entiers.
Donnée : Un ensemble fini de clients D, un ensemble fini d’entrepôts potentiels F, un coût
fixe fi ∈ R+ d’ouverture et une capacité Ki pour chaque entrepôt i ∈ F, et un coût de
service cij ∈ R+ pour chaque i ∈ F et j ∈ D.
Tâche : Trouver un sous-ensemble X ⊆ F (dits entrepôts ouverts) et une affectation σ :
D → X des clients aux entrepôts ouverts, tel que pour tout i, l’entrepôt i ne desserve pas
plus de Ki clients, de façon à ce que la quantité
X X
fi + cσ(j)j
i∈X j∈D
soit minimale.
9.4.2 Relaxation lagrangienne du problème de localisation d’entrepôt
On reprend la modélisation PLNE du problème de la localisation d’entrepôt.

P P P
Min i∈F f i yi + i∈F j∈D cij xij
s.c. x
Pij ≤ yi i ∈ F, j ∈ D (1)
i∈F ij = 1
x j∈F (2)
xij ∈ {0, 1} i ∈ F, j ∈ D (3)
yi ∈ {0, 1} i ∈ F. (4)
Dans le cours, on a relâché la contrainte (2). Relâcher maintenant la contrainte (1) à la

place de la contrainte (2) et montrer que la fonction duale se calcule encore très simplement.
9.4.3 Positionnement d’entrepôts, forward logistique et reverse logistique

La logistique traditionnellement prise en compte est la logistique forward, qui concerne
l’approvisionnement de clients à partir d’entrepôts, que nous appellerons dans cet exercice
entrepôts forward. La logistique reverse concerne les retours (biens non consommés par le
client) vers des entrepôts reverse chargés de traiter ces retours.
Pour de nombreuses raisons (environnementales, durée de vie plus courte des produits,
vente à distance), la reverse logistique prend de l’importance dans le management de la
supply-chain. L’objectif de cet exercice est d’étudier l’implication que cela peut avoir dans
la modélisation des problèmes de positionnement d’entrepôts.
On suppose donc que l’on dispose d’un ensemble I de positions potentielles d’entrepôts,
et d’un ensemble J de clients. Les clients souhaitent s’approvisionner en un certain bien,
dont la quantité est mesurée par un nombre réel.
Le coût d’ouverture d’un entrepôt forward en la position i est noté fi ∈ R+ et celui d’un
entrepôt reverse ri ∈ R+ . La capacité d’un entrepôt forward en position i (ie la demande
totale qu’il peut satisfaire) est notée bi et la capacité d’un entrepôt reverse en position i (ie
le retour total qu’il peut accepter) est notée ei . Chaque client j a une demande hj ∈ R. De
plus, chaque client j a un taux de retour αj ∈ [0, 1], ce qui signifie qu’il renvoie une quantité
αj hj du bien. Le coût de tranport d’une unité de bien d’un entrepôt i à un client j, ou d’un
client j à l’entrepôt i, est cij ∈ R+ .
Le bien étant supposé parfaitement fractionnable, un client peut être approvisionné par
plusieurs entrepôts forward ; et de même, plusieurs entrepôts reverse peuvent être destination
des retours d’un client. De plus, il est possible d’ouvrir au même endroit i en entrepôt forward
et un entrepôt reverse.
1. Proposer une modélisation par la programmation linéaire mixte (avec des variables
entières et des variables réelles) du problème de minimisation des coûts de conception d’un
tel système, pouvant traiter toute la demande et tous les retours. Noter que ce problème
se décompose en deux sous-problèmes indépendants : un pour le forward et l’autre pour le
reverse.
On suppose maintenant que si on parvient à ouvrir un entrepôt forward et un entrepôt
reverse au même endroit i, cela diminue le coût total d’ouverture des deux entrepôts d’une
quantité si .
2. Modifier la modélisation précédente pour tenir compte de cette nouvelle possibilité,
tout en restant dans la programmation linéaire mixte. Noter que les deux sous-problèmes ne
sont plus indépendants.
3. Proposer une définition de l’espace des solutions et d’un voisinage et expliquer com-
ment pourrait être construite une métaheuristique de type recherche locale à partir de cette
définition.
4. Toujours dans le cas d’une métaheuristique de type recherche locale, comment adapter
la méthode au cas où le bien n’est pas parfaitement fractionnable (les quantités seront donc
des entiers) et que les αj hj , les hj , les bi et les ei sont entiers pour tout i et j ?
9.4.4 Réduction du nombre d’entrepôts

Un grand groupe industriel dispose dans un pays de n entrepôts abritant des pièces de
rechange. La direction souhaite fermer k entrepôts et transférer le contenu des entrepôts
fermés dans les entrepôts restés ouverts qui disposent encore de place. Tous les entrepôts
sont considérés comme identiques et possèdent une capacité de 1. On note la quantité de
pièces de rechange stockés dans l’entrepôt i par qi . Cette quantité est assimilée à un réel
dans [0, 1]. Le coût unitaire de transfert de l’entrepôt i à l’entrepôt j est noté cij : si l’on
transfert x ∈ [0, 1] de l’entrepôt i à l’entrepôt j, cela coûte cij x. On suppose de plus que les
coûts cij satisfont l’inégalité triangulaire
cij + cjk ≥ cik
pour tout triplet (i, j, k). On posera cii = 0 pour tout i. Noter que le contenu d’un entrepôt
fermé peut très bien être réparti entre plusieurs entrepôts restés ouverts.
1. Ecrire sous forme d’un programme linaire en variables mixtes (entières et continues)
le problème consistant à choisir les k entrepôts à fermer et le plan de transfert des pièces de
rechange des entrepôts fermés vers ceux restés ouverts, tout en minimisant le coût total du
transfert. Justifier en particulier les contraintes utilisées.
2. Expliquer pourquoi il est facile de voir si ce problème a une solution réalisable.
Il est maintenant demandé d’admettre que l’on peut assez facilement montrer que ce
problème est NP-difficile (il contient le problème du dominant d’un graphe).
3. Ce problème étant NP-difficile, proposer une méthode raisonnable permettant de

trouver l’optimum exact de ce problème (quelques lignes donnant le nom de la méthode
et son principe sont suffisantes). Est-on certain de pouvoir obtenir l’optimum en quelques
minutes ?
4. Y a-t-il des logiciels libres permettant de résoudre un tel problème avec cette méthode ?
Si oui, en citer un.
On souhaite maintenant proposer une méthode du type “recherche locale” pour ce problème.
5. Quel peut être l’intérêt d’une telle méthode ?
6. Expliquer pourquoi une recherche locale pour ce problème peut limiter le codage des
solutions au choix des k entrepôts fermés, sans précision sur les transferts. Donner le nom
d’un problème traditionnel de recherche opérationnelle dont la résolution rapide permet un
tel codage.
7. Proposer une définition du voisinage pour cette recherche locale.

9.4.5 Positionnement d’ambulances

Pour diminuer le temps mis par les ambulances pour atteindre les victimes d’accidents,
certains hôpitaux envisagent de les positionner de manière optimisée sur le département dont
ils ont la charge. Considérons donc un certain hôpital ayant K ambulances. L’ensemble des
communes est noté C. On dispose d’un ensemble S de points de stationnement potentiel
et on suppose que |S| ≥ K. Pour c ∈ C et s ∈ S, on note ts,c le temps nécessaire à une
ambulance positionné en s pour atteindre c. Si S 0 ⊆ S est l’ensemble des points où sont
positionnées les ambulances (avec bien sûr |S 0 | ≤ K), dans le pire des cas, une ambulance
atteindra la commune où a eu lieu l’appel en un temps égal à maxc∈C mins∈S 0 ts,c . C’est ce
temps maximum que l’hôpital souhaite rendre le plus petit possible.
1. Montrer que ce problème est NP-difficile. Indication : soit G = (V, E) un graphe non-
orienté ; on appelle dominant un sous-ensemble Y ⊆ V tel que tout v ∈ V est soit dans Y ,
soit a un voisin dans Y ; décider s’il existe un dominant de taille ≤ K est NP-complet.
2. Démontrer que le programme linéaire suivant modélise le problème. Pour cela, procédez
en deux temps : montrez que toute solution optimale du problème donne une solution de
même valeur au programme linéaire ; puis montrez que toute solution optimale du programme
linéaire donne une solution de même valeur au problème.
Min h
X
s.c. ys ≤ K (i)
s∈S
X
xs,c ≤ |C|ys s∈S (ii)
c∈C
X
xs,c = 1 c∈C (iii)
s∈S
ts,c xs,c ≤ h s ∈ S ; c ∈ C (iv)
xs,c ∈ {0, 1} s ∈ S ; c ∈ C (v)
ys ∈ {0, 1} s ∈ S (vi)
h ∈ R+ (vii)
Un tel programme linéaire se résout par branch-and-bound. La borne dont on se sert alors
peut être celle obtenue en relâchant les contraintes d’intégrité de x et de y. On se propose
de voir si l’on peut également obtenir des bornes par relaxation lagrangienne.
3. Ecrire le programme d’optimisation obtenu lorsqu’on procède à la relaxation lagran-
gienne de la contrainte (ii).
4. Montrer que ce programme se ramène à deux programmes distincts et indépendants,

l’un ne mettant en jeu que les variables y, l’autre ne mettant en jeu que les variables x et h.
5. Montrer que chacun de ces deux programmes se résout en temps polynomial.
6. Expliquer pourquoi la polynomialité de ces deux programmes permet d’espérer un
calcul efficace d’une borne inférieure au programme linéaire de la question 2.
CHAPITRE 10
Ordonnancement industriel
Dans un contexte de tâches ou d’opérations à effectuer sous des contraintes de temps et de

ressource, un problème d’ordonnancement consiste à donner les instants auxquels commencer
les tâches, en vue d’optimiser un certain critère. Dans l’industrie, dans le bâtiment, sur les
gros chantiers, les problèmes d’ordonnancement sont souvent très présents, et de leur solution
peut dépendre la réussite du projet. Nous verrons que pour une certaine famille de problèmes
d’ordonnancement (les problèmes d’atelier), les problèmes sont non seulement NP-difficiles,
mais même mal résolus en pratique.
10.1 Préliminaires
De manière un peu générique, un problème d’ordonnancement se formule avec des tâches,
qui elles-mêmes se découpent éventuellement en opérations. Etant données des contraintes,
on appellera ordonnancement la donnée des instants auxquels commencent les différentes
tâches ou opérations.
Les contraintes de temps peuvent être de deux natures :
— Durées des tâches
— Précédences
Les contraintes de ressource peuvent également être de deux natures :
— Disjonctive : si les tâches i et j sont effectuées sur la machine k, elles doivent être
faites dans tel ordre
— Cumulative : la tâche i consomme aik de la ressource k. La ressource k a une capacité
Ak . A tout instant, la somme des consommations sur la machine k doit être inférieure
à sa capacité.
Les critères à optimiser peuvent être variés. Exemples :
— Coût : Coût total de l’ordonnancement. Cela suppose défini le coût d’affectation d’une
tâche i sur une machine k.
— Makespan : Temps pour effectuer l’ensemble des tâches.
— Temps moyen : Temps moyen mis par une tâche pour être traitée. Son intérêt peut
être varié. Par exemple si le problème d’ordonnancement s’insère dans un processus
plus grand, ce genre de critère peut être intéressant.
CHAPITRE 10. ORDONNANCEMENT INDUSTRIEL 126
20 40 60 80 100 120 140 jours
Figure 10.1 – Le diagramme de Gantt qui correspond à l’exemple de la section qui suit.
Une façon commode de représenter un ordonnancement est le diagramme de Gantt : en

abscisse, on met le temps, et on ordonnée, les différentes tâches. Sur chaque ligne repérée
par une tâche, on met des intervalles qui occupent les instants pendant lesquels la tâche est
traitée. Un exemple est donné Figure 10.1.
10.2 Management de projet

Lorsqu’on a un projet à conduire et différentes tâches à effectuer, connaissant la durée des
tâches et les relations de précédence, une question naturelle est celle de la durée minimale du
projet. Différentes méthodes peuvent être utilisées, certaines informelles, en jouant avec le
diagramme de Gantt, d’autres exactes, comme la méthode PERT ou la méthode potentiel-
tâches. C’est cette dernière que nous allons maintenant présenter.
On se donne une collection I de tâches, pour chaque tâche i, on se donne sa durée di , et
des contraintes par rapport aux autres tâches de cette forme : la tâche i ne peut commencer
que lorsque r% de la tâche j au moins a été effectué .
On veut trouver
— la durée minimale du projet.
— les tâches critiques : les tâches pour lesquelles une modification de l’instant de début
rallonge la durée du projet.
— les marges : la marge d’une tâche est l’intervalle de temps sur lequel on peut faire
démarrer la tâche sans rallonger la durée du projet. En particulier, une marge nulle
signifie une tâche critique.
On modélise ce problème sous la forme d’un graphe dont les sommets sont les débuts des
tâches et les arcs sont les relations de précédence. On ajoute deux tâches fictives : Début et
127 CHAPITRE 10. ORDONNANCEMENT INDUSTRIEL
Fin. De plus, chaque arc (u, v) est muni d’une longueur égale à la durée minimale séparant
le début de u de celui de v.
La première remarque que l’on peut faire est la suivante
Si ce projet a un sens, le graphe est acircuitique.
En effet, un circuit traduirait l’obligation de remonter dans le temps.
Considérons l’exemple suivant.
Tâches Description Durée (j) Contraintes

A Construction voie ferrée 80 Début
B Forage des puits 70 Début
C Construction logements provisoires 30 Début
D Pompage de l’eau (Fonds de mine) 30 B
E Aménagement fonds + ascenseurs 50 A, D
F Construction logements définitifs 40 A, C
On fait la modélisation décrite ci-dessus : voir Figure 10.2.

A
D
80 70
0 30
30
Début E Fin
B
0
50
80
0 40
F
C
30
Figure 10.2 – Le graphe de la méthode potentiel tâche.
Notons tI et t0I les instants au plus tôt et au plus tard auxquels commencer la tâche I.
Proposition 10.1. tI est la longueur du plus long chemin de Début à I. t0I , c’est tFin moins
la longueur du plus long chemin de I à Fin.
Démonstration. En effet,
— pour chaque tâche I, on ne peut pas commencer avant la somme des longueurs des arcs du plus long
chemin de Début à I.
— on faisant débuter chaque tâche I précisément à la somme des longueurs des arcs du plus long chemin
de Début à I, on peut commencer chaque tâche à l’instant tI .
De même pour t0I .
Pour trouver la durée minimale du projet, les tâches critiques, etc. il faut donc savoir
calculer les plus longs chemins dans un graphe acircuitique D = (V, A), muni d’une longueur
l : A → R+ . Cela se fait par la programmation dynamique, comme nous l’avons vu au
Chapitre 3. Si on note ηI la longueur du plus long chemin de Début à I, on peut écrire
(équation de Bellman)
ηI = max (ηJ + l(J, I)).
(J,I)∈A
On peut calculer tous les ηI en O(m) où m est le nombre d’arcs. On peut calculer de
même les πI , plus longs chemins de I à Fin. On pose alors tI := ηI , t0I := tFin − πI et la
marge mI := t0I − tI . Les chemins critiques sont les plus longs chemins de Début à Fin ;
toutes les tâches d’un chemin critique sont caractérisées par une marge nulle.
10.3 Ordonnancement d’atelier
10.3.1 Introduction
Un problème d’ordonnancement d’atelier se décrit sous la forme d’un ensemble de tâches
J1 , . . . , Jn et d’un ensemble de machines M1 , . . . , Mm . Une tâche j, pour être réalisée,
nécessite son exécution sur différentes machines successivement. Le temps d’exécution de
la tâche j sur la machine k est une donnée du problème et se note pjk . L’exécution d’une
tâche j sur une machine k s’appelle une opération, on parle également de passage de la tâche
j sur la machine k.
Dans ce cours, on fait de plus les suppositions suivantes.

— Chaque tâche passe exactement une fois sur chaque machine. (Quitte à accepter des
temps d’exécution nuls, cela est sans perte de généralité.)
— Deux tâches ne peuvent passer simultanément sur une machine.
— A l’exception du cas traité dans la Section 10.3.3, le passage d’une tâche sur une ma-
chine doit se faire d’une traite. En d’autres termes, une opération, une fois commencée,
ne peut être interrompue. On dit qu’on est dans le cas non-préemptif.
Il y a trois modèles de base pour les problèmes d’ordonnancement d’atelier.
— flow-shop : Toutes les tâches doivent passer sur les machines dans le même ordre.
— job-shop : L’ordre dans lequel dans passer chaque tâche sur les machines est fixé, mais
peut différer d’une tâche à l’autre.
— open-shop : L’ordre dans lequel dans passer chaque tâche sur les machines n’est pas
fixé.
Remarque
Le flow-shop est un cas particulier du job-shop.
Trouver l’ordonnancement, c’est fixer les instants tjk de début du passage de toute tâche
j sur toute machine k. On note Cj l’instant d’achèvement de la tâche j.
Comme indiqué au début de ce chapitre, deux objectifs classiques sont
P
— minimiser “la durée moyenne”, lequel s’écrit donc j Cj , et
— minimiser le makespan, lequel s’écrit Cmax = maxj Cj .
L’essentiel du cours se focalisera sur la minimisation du makespan. L’objectif de minimisation
des coûts n’est pas abordé dans ce cours.
10.3.2 Difficulté
Les problèmes d’ordonnancement sont difficiles, dans tous les sens du terme.
Théorème 10.1. — Le problème du flow-shop non-préemptif à trois machines et mini-

misation du makespan Cmax est NP-difficile.
P
— Le problème du flow-shop non-préemptif à deux machines et minimisation du j Cj
est NP-difficile.
— Le problème de l’open-shop non-préemptif à trois machines et minimisation du makes-
pan Cmax est NP-difficile.
P
— Le problème de l’open-shop non-préemptif à deux machines et minimisation du j Cj
est NP-difficile.
Mais en plus d’être NP-difficile, on a du mal en pratique à résoudre de manière optimale

ces problèmes, contrairement au problème du voyageur de commerce par exemple, que l’on
étudiera au Chapitre 11. Même avec des métaheuristiques ou des techniques de branch-and-
bound, des instances job-shop à 15 machines et 15 tâches sont encore non résolues à ce
jour !
Par exemple, on ne connaı̂t pas l’ordonnancement optimal pour l’instance suivante de
flow-shop à 20 tâches et 5 machines 1
54 83 15 71 77 36 53 38 27 87 76 91 14 29 12 77 32 87 68 94
79 3 11 99 56 70 99 60 5 56 3 61 73 75 47 14 21 86 5 77
16 89 49 15 89 45 60 23 57 64 7 1 63 41 63 47 26 75 77 40
66 58 31 68 78 91 13 59 49 85 85 9 39 41 56 40 54 77 51 31
58 56 20 85 53 35 53 41 69 13 86 72 8 49 47 87 58 18 68 28
1. Source : la page web du professeur Eric Taillard http ://mistic.heig-vd.ch/taillard/

Ce tableau se lit de la manière suivante : il faut effectuer 20 tâches. Chaque tâche se

décompose en 5 opérations 1, 2, 3, 4 et 5, identifiées avec 5 machines. Les opérations doivent
être faites dans cet ordre (flow-shop), le temps pour faire la kème opération de la tâche j se
lit sur l’entrée qui est à l’intersection de la kème ligne et de la jème colonne.
Nous allons voir maintenant
— des cas particuliers polynomiaux.
— un cas préemptif : l’open-shop avec un nombre quelconque de machines, qui est encore
un problème polynomial.
— un schéma de branch-and-bound pour le job-shop.
— un schéma de recherche locale pour le job-shop.
10.3.3 Quelques cas particuliers polynomiaux

Les cas particuliers polynomiaux les plus célèbres sont les suivants.
1. Le problème du flow-shop non-préemptif à deux machines et minimisation du makespan
Cmax : algorithme de Johnson.
2. Le problème du job-shop non-préemptif à deux machines et minimisation du makespan
Cmax : algorithme de Jackson.
3. Le problème du job-shop non-préemptif à deux tâches et minimisation du makespan
Cmax : algorithme de Brucker.
4. Le problème de l’open-shop non-préemptif à deux machines et minimisation du ma-
kespan Cmax : algorithme de Gonzalez et Sahni
Flow-shop non-préemptif à deux machines et minimisation du makespan Cmax

C’est résolu par l’algorithme de Johnson [17]. On a n tâches J1 , J2 , . . . , Jn . Chaque tâche
Jj a une durée pj1 sur la machine 1 et pj2 sur la machine 2. On doit d’abord passer par la
machine 1, puis par la machine 2.
L’algorithme produit une séquence j1 , j2 , . . . , jn : ce sera l’ordre dans lequel effectuer les
tâches sur les deux machines. En effet, comme nous le verrons ci-dessous, il y a toujours
une solution optimale pour laquelle les tâches sont réalisées dans le même ordre sur les deux
machines.
On définit pour chaque tâche j la durée qj = min(pj1 , pj2 ). Classer les tâches par qj
croissant. Quitte à renuméroter, on a q1 ≤ q2 ≤ . . . ≤ qn . Commencer à j = 1. Fixer r, s = 0.
Répéter jusqu’à j = n :
si qj est atteint sur la première machine, définir jr+1 := j et r := r +1 ;
0
si qj est atteint sur la seconde machine, définir js+1 := j et s := s + 1.
Faire j := j + 1.
Retourner l’ordre j1 , . . . , jr , js0 , . . . , j10 .
Il y a deux autres formulations alternatives de cet algorithme.
1. Faire deux paquets : un paquet A avec les j tels que pj1 ≤ pj2 , un paquet B avec les
j tels que pj1 > pj2 . Ordonner A selon les pj1 croissants, B selon les pj2 décroissants.
Concaténer la suite des j de A à celle de B dans cet ordre.
2. Choisir la tâche Jj ayant le plus petit pj1 ou pj2 parmi tous les pji .
Appliquer récursivement l’algorithme sur les tâches 6= j : cela donne une séquence
j1 , j2 , . . . , jr , js0 , . . . , j10 , avec r + s = n − 1.
Les tâches j1 , . . . , jr sont choisies de façon à ce que le temps sur la machine 1 soit plus
court que sur la machine 2. Les tâches js0 , . . . , j10 sont choisies de façon à ce que le temps
sur la machine 2 soit strictement plus court que sur la machine 1.
Si pj1 ≤ pj2 , retourner j, j1 , j2 , . . . , jr , js0 , . . . , j10 .
Si pj1 > pj2 , retourner j1 , j2 , . . . , jr , js0 , . . . , j10 , j.
Considérons l’exemple suivant.
Tâches temps sur la machine 1 temps sur la machine 2

A 12 3
B 14 11
C 25 13
D 9 17
E 6 15
L’algorithme va successivement fixer :
...,A
E, . . . , A
E, D, . . . , A
E, D, . . . , B, A
E, D, C, B, A.
Théorème 10.2. L’algorithme de Johnson résout correctement le problème du flow-shop à
deux machines et minimisation du makespan Cmax .
Démonstration. Déroulons maintenant l’algorithme et plaçons nous à l’itération j. On peut supposer sans
perte de généralité que qj est atteint sur la première machine. j − 1 tâches ont déjà été fixées : pour
fixer les notations, supposons que les tâches fixées sont celles d’indices j1 , . . . , jr et j10 , . . . , js0 . On suppose
donc que j = r + s + 1. On peut mettre les autres dans un ordre quelconque, pas forcément le même
sur la première et la seconde machine. On suppose que l’on a les instants de démarrage de chacune des
opérations et que cet ordonnancement est réalisable. On a donc un ordre de tâches sur la première machine
(1) (1) (2) (2)
j1 , . . . , jr , i1 , . . . , in−r−s , js0 , . . . , j10 et sur la seconde j1 , . . . , jr , i1 , . . . , in−r−s , js0 , . . . , j10 .
(1)
On fait maintenant commencer j sur la machine 1 à l’instant auquel commençait i1 , et sur la machine 2
(2)
à l’instant auquel commençait i1 . On décale vers la droite les tâches qui était à gauche de j sur la machine
1 et sur la machine 2 en conséquence. Cette opération est illustrée sur le Figure 10.3.
i j20
j1 j2 j3 ` j10
M1
M2
j1 j2 j3 i0
`0 j20 j10
j1 j2 j3 i ` j20 j10
M1
M2
j1 j2 j3
i0 `0 j20 j10
Figure 10.3 – Illustration d’une itération de l’algorithme de Johnson : changer la position relative de la
tâche en pointillés par rapport à i et ` ne détériore pas la durée de l’ordonnancement
Montrons que ce nouvel ordonnancement est encore réalisable et garde le même makespan. Une fois
l’itération j finie, les tâches décalées ont vu leur temps de démarrage augmenter de pj1 sur la machine 1, et
de pj2 sur la machine 2. Comme pj1 < pj2 , on reste réalisable, en tout cas pour les tâches différentes de j.
Il faut encore vérifier que la tâche j démarre sur la machine 2 lorsqu’elle a été terminée sur la machine 1.
(2)
Mais c’est évident car j commence sur la machine 1 au plus tard à l’instant auquel commençait i1 sur la
machine 1 et pi(2) 1 ≥ pj1 .
1
En conclusion, partant d’un ordonnancement quelconque, on peut toujours obtenir un ordonnancement

de même makespan tel que les tâches soient classées de la même façon que par l’algorithme de Johsonn.
Job-shop non-préemptif à deux machines et minimisation du makespan Cmax

C’est résolu par l’algorithme de Jackson [16], qui est une simple adaptation de l’algorithme
de Johnson. On a n tâches J1 , J2 , . . . , Jn . Chaque tâche Jj a une durée pj1 sur la machine 1
et pj2 sur la machine 2. Pour chaque tâche j, l’ordre de passage sur les machines 1 et 2 est
fixé.
L’algorithme consiste à définir
J12 := {Jj : Jj doit d’abord être effectué sur 1 puis sur 2}

J21 := {Jj : Jj doit d’abord être effectué sur 2 puis sur 1}
et à faire les opérations suivantes :
— sur la machine 1 : J12 J21 ,
— sur la machine 2 : J21 J12 ,
où J12 et J21 sont ordonnés selon l’algorithme de Johnson.
Théorème 10.3. L’algorithme de Jackson résout correctement le problème du job-shop à

deux machines, au plus deux opérations par tâche, et minimisation du makespan Cmax .
Démonstration. Similaire à celle du Théorème 10.2.
Job-shop non-préemptif à deux tâches et minimisation du makespan Cmax

On a deux tâches et des machines numérotées de 1 à m. Chaque tâche j = 1, 2 est décrite
par l’ordre (mji )i=1,...,m des machines dans lequel elle doit passer.
On note qji le temps pour effectuer la ième opération de la tâche j, i.e. qji := pjmji .
Pour résoudre ce problème, on peut appliquer l’algorithme de Brucker [3], qui est en fait
un algorithme de plus court chemin dans un certain graphe.
On se place dans le quart de plan positif. Pour toute paire i, i0 telle que m1i = m2i0 (i.e. la
ième opération de la tâche 1 utilise la même machine que la i0 ème opération de la tâche 2),
on dessine un obstacle rectangulaire dont les côtés P sont parallèles aux axes de coordonnées,
i−1 Pj−1
dont le point inférieur gauche est de coordonnées k=1 p1k , k=1 p2k et dont les côtés sont
de longueurs q1i et q2j .
Un ordonnancement réalisable induit un chemin partant de (0, 0) et allant jusqu’à
m m
!
X X
q1i , q2i .
i=1 i=1
Ce chemin se déplace soit de gauche à droite, soit de haut en bas, soir vers le nord-est. On
cherche donc le plus court chemin : c’est un problème de plus court chemin dans un graphe
acircuitique – le poids d’un arc étant la durée correspondant à la transition représentée par
l’arc – qui conduit à un algorithme en O(m2 log(m)) (le plus court chemin lui-même met
O(m2 ), mais la construction du graphe est un peu plus coûteuse).
En toute rigueur, le nombre de chemins respectant ce genre de déplacement est infinis :
si la tâche 1 met en jeu la machine 1 sur une certaine plage de temps, et si la tâche 2 peut
pendant ce temps passer sur la machine 2, avec un temps de passage beaucoup plus court,
on peut faire débuter à un grand nombre de moment sur la plage horaire l’opération sur
la machine 2. La démonstration du Théorème 10.4 ci-dessous, omise ici, consiste dans un
premier temps à montrer qu’en se limitant à un nombre fini de mouvements possibles (voir
Figure 10.5), on ne diminue pas la longueur du plus court chemin.
D’après cette discussion, on a
Théorème 10.4. L’algorithme de Brucker résout correctement le problème du job-shop à
deux tâches et minimisation du makespan.
L’algorithme est illustré sur les Figures 10.4 et 10.5.
Remarque
Cet algorithme peut se généraliser au problème à n tâches, mais la complexité devient
alors O(nmn log(m)), ce qui n’est pas polynomial...
tâche 1: M1 → M2 → M3 → M4
tâche 2: M2 → M4 → M3 → M1
tâche 2
q24
M1
q23
M3
M4 q22
M2 q21
q14 tâche 1
q11 q12 q13
M4
M1 M2 M3
un ordonnancement possible
un autre ordonnancement possible
Figure 10.4 – Illustration de l’algorithme de Brucker qui résout le job-shop à deux tâches et minimisation
du makespan.
poids de cet arc: p24
tâche 2
q24
M1
poids de cet arc: p22

q23
M3
M4 q22
M2 q21
q14 tâche 1
q11 q12 q13
M4
M1 M2 M3
un ordonnancement possible
un autre ordonnancement possible
Figure 10.5 – Graphe acircuitique associé à l’algorithme de Brucker.

Open-shop non-préemptif à deux machines et minimisation du makespan Cmax
On a n tâches et deux machines. Chaque tâche est constituée de deux opérations, iden-
tifiées avec les machines. Comme on est en open-shop, il n’y a pas de contrainte sur l’ordre
dans lequel doivent être faites les opérations d’une tâche. On a alors le résultat suivant.
Théorème 10.5. Pour ce cas, on a à l’optimum

n n
!
X X
Cmax = max max(pj1 + pj2 ), pj1 , pj2 .
j
j=1 j=1
Un tel ordonnancement peut se trouver en temps polynomial.
Démonstration. Il est clair que l’on ne peut pas faire mieux que la valeur
Pn T ci-dessus.
Pn Montrons qu’on peut
l’atteindre. Quitte à ajouter des tâches fictives, on peut supposer que j=1 pj1 = j=1 pj2 = T .
On peut définir j1 le plus grand indice j tel que
(p11 + p12 ) + (p21 + p22 ) + . . . + (pj1 + pj2 ) ≤ T.

Pj1 Pj1
On considère que cela donne une seule grande tâche J1∗ , avec p∗11 := j=1 pj1 et p∗12 := j=1 pj2 .
De même, on peut définir j2 le plus grand indice j tel que
(p(j1 +1)1 + p(j1 +1)2 ) + (p(j1 +2)1 + p(j1 +2)2 ) + . . . + (pj1 + pj2 ) ≤ T.
Pj2 Pj2
On considère que cela donne une seule grande tâche J2∗ , avec p∗21 := j=j 1 +1
pj1 et p∗22 := j=j 1 +1
pj2 .
∗ ∗
Pn Enfin, on définit
∗
de
Pnmême j3 . On considère que cela donne une seule grande tâche J3 , avec p31 :=
j=j2 +1 pj1 et p32 := j=j2 +1 pj2 .
Après avoir défini J3∗ , toutes
Pn les tâches
∗
Pn sont soit dans J1 ,Psoit dans J2∗ , soit ∗ ∗ ∗
Pn dans J3 . En effet, p11 + p12 +
n
p(j1 +1)1 + p(j1 +1)2 > T et j=1 pj1 + j=1 pj2 = 2T , donc j=j1 +2 pj1 + j=j1 +2 pj2 < T .
On se retrouve donc avec l’open shop à trois tâches J1∗ , J2∗ , J3∗ , avec p∗11 +p∗21 +p∗31 = T et p∗12 +p∗22 +p∗32 =
T , et p∗j1 + p∗j2 ≤ T pour tout j = 1, 2, 3.
En renumérotant, on peut supposer que p∗11 ≥ p∗22 et p∗12 ≥ p∗31 . On vérifie ensuite que l’on peut
effectuer J1∗ , J2∗ , J3∗ sur la machine 1 dans cet ordre, et J2∗ , J3∗ , J1∗ sur la machine 2 dans cet ordre. C’est un
ordonnancement de durée T . Pour chaque Js∗ , on effectue les Jj dont il est composé, consécutivement selon
les indices.
Open-shop préemptif
On a n tâches et m machines, chaque tâche j est décrite par un vecteur pj = (pj1 , . . . , pjm ),
le nombre pjk indiquant le temps que la tâche j doit passer sur la machine k. Chaque
tâche peut passer dans un ordre quelconque sur les machines (open-shop). De plus, chaque
opération (passage sur une machine) peut être interrompue et reprise plus tard, et ce, autant
de fois que nécessaire (cas préemptif). L’important est qu’au total, chaque tâche j ait passé
un temps pjk sur la machine k, et ce pour tout k ∈ {1, . . . , m}.
On a le résultat suivant.
Théorème 10.6. A l’optimum, on a

m
! n
!!
X X
Cmax = max max pjk , max pjk .
j k
k=1 j=1
De plus, un tel ordonnancement se trouve en temps polynomial.
En fait, c’est une application directe du théorème de Birkhoff-von Neumann dont la

preuve est laissée en exercice.
Théorème 10.7 (Théorème Pde Birkhoff-von Neumann). PSoit A = ((aij )) une matrice carrée
bistochastique (ie aij ≥ 0 et i=1 aij = 1 pour tout j et nj=1 aij = 1 pour tout i).
n
Alors A est combinaison convexe de matrices de permutation (matrices 0 − 1 ayant

exactement un 1 par ligne et par colonne).
Preuve du Théorème 10.6. Considérons la matrice P := ((pjk )). Définissons
..
 
. P 
A :=  .
..
PT .
C’est une matrice (n + m) × (n + m). Quitte à ajouter des quantités positives sur la diagonale de A, on peut
supposer que A a toutes ses sommes par ligne et par colonne égale à
  
m n
!
X X
T := max max pjk , max  pjk  .
j k
k=1 j=1
P
On applique Birkhoff-von Neumann à A. On obtient que P peut s’écrire comme T P i λi Qi où les Qi
sont des matrices ayant au plus un 1 par ligne et par colonne, et où λi > 0 pour tout i et i λi = 1.
Cela donne un ordonnancement : sur les λ1 T premiers instants, on fait passer la tâche j sur la machine
k, pour tout (j, k) entrée non nulle de la matrice Q1 ; on fait passer la tâche j sur la machine k, pour tout
(j, k) entrée non nulle de la matrice Q2 , etc.
10.3.4 Cas non-polynomiaux

Comme il a été indiqué dans l’introduction de ce chapitre, les problèmes d’ordonnance-
ment sont mal résolus en pratique, contrairement au problème du voyageur de commerce où
l’on sait résoudre des instances à plusieurs dizaine de milliers de villes. Pour le job-shop par
exemple, il existe à ce jours un grand nombre d’instances à 15 tâches et 15 opérations par
tâches (soit des instances occupant l’équivalent mémoire de 225 nombres réels) dont on est
très loin de connaı̂tre l’optimum.
Les techniques employées en pratique pour résoudre les problèmes d’ordonnancement
sont donc en général très sophistiquées et dépassent largement le cadre d’un tel cours. Nous
n’allons donc qu’effleurer certaines notions utiles à la conception d’algorithmes branch-and-
bound pour le problème job-shop.
Graphe disjonctif
Un outil particulièrement commode pour les cas difficiles, et qui peut servir tant pour les
algorithmes de recherche locale que les méthodes exactes du type branch-and-bound est le
graphe disjonctif.
Le graphe disjonctif est un graphe mixte (à la fois des arcs et des arêtes) dont les sommets
sont les opérations, les arcs les relations conjonctives (un arc est mis entre deux opérations
consécutives d’une même tâche), les arêtes les relations disjonctives (une arête est mise entre
toute paire d’opérations utilisant la même machine). La longueur d’un arc est la durée de
l’opération dont il est issu.
Considérons par exemple le job-shop suivant, à trois tâches, et trois machines.
J1 M1 : 2 M2 : 5 M3 : 4
J2 M2 : 1 M1 : 6 M3 : 7
J3 M3 : 6 M2 : 8 M1 : 3
Le graphe disjonctif correspondant est donné sur la Figure 10.6.
: arc conjonctif
: arête disjonctive
2
5
J1
Début Fin
1 6 7
J2
3
J3
6 8
Figure 10.6 – Un exemple de graphe disjonctif.
La remarque fondamentale qui motive l’introduction du graphe disjonctif est la suivante

Trouver un ordonnancement, c’est orienter les arêtes du graphe disjonctif de manière
acircuitique.
En mettant sur chaque arc obtenu par orientation d’une arête la durée de l’opération dont
elle est issue, il est facile de calculer le makespan, c’est-à-dire la durée totale de l’ordonnan-
cement. On se retrouve en effet dans la même situation que dans la méthode potentiel-tâche
(Section 10.2) où les durées et les précédences sont entièrement fixées.
Branch-and-bound
On définit alors comme dans la Section 10.2, pour toute opération O, la quantité ηO qui
est la longueur du plus long chemin de Début à O, et de même πO (en ne gardant que les
arcs). Les calculs sont décrits Section 10.2.
P
On définit η(O) := minO∈O ηO , π(O) := minO∈O πO et p(O) := O∈O p(O).
Cela permet de définir un schéma de branch-and-bound. On a en effet alors la borne
suivante sur la durée des ordonnancements :

max max η(O) + π(O) + p(O) ,
k=1,...,m O⊆Ok
où Ok est l’ensemble des opérations devant être effectuées sur la machine k. Carlier a montré
qu’elle se calculait en temps polynomial. Le branchement le plus naturel consiste à fixer
progressivement les arcs depuis l’origine Début.
Recherche locale
Pour faire de la recherche locale (recuit simulé, tabou, etc.), il faut définir une notion de
voisinage sur les ordonnancements réalisables, ces derniers étant identifiés avec les orienta-
tions acicuitique du graphe disjonctif. Par exemple, on peut dire que deux ordonnancements
réalisables sont voisins si on passe de l’un à l’autre par
— retournement d’arc
— retournement des arcs disjonctifs d’un chemin critique.
10.4 Exercices
10.4.1 Management de projet
Considérons le projet de construction d’immeuble suivant, découpé en différentes tâches.

Pour la ligne d’une tâche T donnée, la colonne contraintes indique quelles tâches doivent
être terminées pour pouvoir commencer T . Trouver la durée minimale de ce projet. Justifier
la réponse.
Tâches Description Durée (j) Contraintes

A préparation, fondations 6 Début
B construction des murs 10 A
C plomberie extérieure 4 B
D plomberie intérieure 5 A
E électricité 7 A
F toit 6 B
G peinture et finitions extérieures 16 B,C,F
H lambris 8 D,E
I sol 4 D,E
J peinture et finitions intérieures 11 H,I
10.4.2 Ordonnancement de travaux sur un chantier, d’après de Werra, Liebling, Hêche

Trouver le temps minimum nécessaire pour réaliser les tâches suivantes. Trouver également
les chemins critiques.
Tâches Durées Contraintes

A 10 Début
Pose de cloisons
B 12 A, G
menuiserie
C 14 B
vitrerie
D 10 au plus tôt
construction 2 jours après Début
de l’ossature
E 9 D
plomberie
F 11 au plus tôt lorsque les 4/5
charpente
de D sont terminés
et au plus tard 30 jours
avant le début B
G 13 F
pose de
la couverture
H 15 E, I
installation
des radiateurs
I 16 C
revêtement des murs
et des cloisons
10.4.3 Cas à une seule machine

On considère les problèmes d’ordonnancement d’atelier dans le cas à une seule machine.
On se met dans le cas non préemptif, chaque tâche est faite d’une seule opérationP (flow-
shop, job-shop
P et open-shop identiques). Résoudre le minimum makespan, minimum j Cj ,
minimum j wj Cj (où chaque tâche j est munie d’un poids j).
10.4.4 Retour sur le problème de l’affectation de tâche (cours sur les flots)
On revient sur l’exercice d’affectation des tâches, mais cette fois on ne suppose plus que
les employés puissent travailler en parallèle.
On suppose que l’on a différentes tâches à accomplir dont on connaı̂t les durées d’exécution,
et que l’on dispose d’une ressource de main d’œuvre dont on connaı̂t les compétences. A un
instant donné, un employé ne peut se consacrer qu’à une seule tâche à la fois. Enfin, on se
met dans un cadre préemptif, c’est-à-dire qu’un employé peut interrompre son travail sur
une tâche, et le reprendre plus tard.
On veut trouver un ordonnancement, c’est-à-dire à tout instant la donnée pour chaque
employé i de la tâche j sur lequel il travaille. On souhaite minimiser le temps nécessaire pour
réaliser l’ensemble des tâches (makespan).
Problème de l’affectation de tâches

Donnée : n tâches et leurs durées t1 , . . . , tn ∈ R+ ; m employés et des sous-ensembles
Si ⊆ {1, . . . , m} qui correspondent aux employés compétents pour la tâche i.
Tâche : Trouver un ordonnancement, c’est-à-dire à tout instant la donnée pour chaque
employé i de la tâche j sur lequel il travaille, minimisant le temps nécessaire pour réaliser
l’ensemble des tâches (makespan).
Montrer que ce problème peut se résoudre en temps polynomial.
10.4.5 Preuve du théorème de Birkoff-von Neumann

Nous allons montrer le théorème de Birkhoff-von Neumann, qui dit que toute matrice
bistochastique A (matrice carrée à coefficients positifs, dont la somme des termes de chaque
ligne fait 1, et la somme des termes de chaque colonne fait 1) est combinaison convexe de
matrices de permutation (matrice carrée à coefficients dans {0, 1} ayant exactement un 1 par
ligne et par colonne).
1. Avec l’aide du théorème de König (qui dit que la cardinalité minimale d’une couverture
par les sommets est égale à la cardinalité maximale d’un couplage), montrer le théorème de
Hall suivant : Soit G un graphe biparti, de classes U et V . Supposons que pour tout X ⊆ U ,
on a |N (X)| ≥ |X|, où N (X) est le voisinage de X dans G. Alors il existe un couplage
couvrant U .
2. En déduire le théorème de Birkhoff-von Neumann (indication : le faire par récurrence

sur le nombre d’entrées non-nulles de A, et construire un graphe biparti G dont les classes
sont les lignes d’une part, et les colonnes d’autre part.)
10.4.6 Job-shop à deux machines

Considérons l’instance job-shop non-préemptif suivante, la flèche indique l’ordre des
tâches.
M1 M2
J1 6 → 3
J2 5 → 4
J3 7 ∅
J4 ∅ 3
J5 2 ← 6
J6 4 ← 3
Proposer un ordonnancement optimal.
10.4.7 Open-shop à deux machines

Considérons l’instance open-shop non-préemptif suivante.
M1 M2
J1 7 0
J2 3 7
J3 9 14
J4 7 3
J5 7 3
J6 7 0
Proposer un ordonnancement optimal.
10.4.8 Déchargement et chargement d’une flotte de camions

Un site d’une entreprise logistique est constitué de deux entrepôts : l’un de déchargement
(entrepôt D) et l’autre de chargement (entrepôt C). Le matin, à 6h, 15 camions se présentent,
chacun contenant un nombre de caisses connu, indiqué dans le tableau ci-dessous. Chacun
de ces camions doit être intégralement vidé dans l’entrepôt D avant d’accéder à l’entrepôt
C, où il sera à nouveau chargé avec un nombre de caisses connu, indiqué également dans
le tableau ci-dessous. Pour des raisons liées aux effectifs en personnel et aux contraintes de
manutention, un seul camion peut être traité à la fois par chaque entrepôt, et lorsqu’on
commence à traiter un camion, on ne peut interrompre cette opération. On souhaite finir au
plus tôt le traitement des 15 camions, sachant que le temps de chargement et de déchargement
est exactement proportionnel au nombre de caisses : 1 minute par caisse. On néglige le temps
pour se rendre d’un entrepôt à l’autre. A quelle heure peut-on avoir fini au plus tôt ? Justifier
votre réponse.
Camions Nbre de caisses à décharger Nbre de caisses à charger

1 2 6
2 1 2
3 20 11
4 2 3
5 7 6
6 6 6
7 2 3
8 1 4
9 8 7
10 6 4
11 12 11
12 5 8
13 7 3
14 6 9
15 5 1
CHAPITRE 11
Tournées
Les problèmes de tournées sont parmi les plus naturels en Recherche Opérationnelle et
en Logistique. Le thème général est le suivant : un réseau étant donné, il s’agit de le visiter
entièrement en minimisant le coût. Les variations sont alors infinies et peuvent concerner la
nature du réseau, la notion de visite, la définition du coût. Des contraintes peuvent également
être ajoutées à l’envie : fenêtre de temps, retour au point de départ, etc.
Dans cette séance, nous nous intéresserons aux deux problèmes les plus simples à formu-
ler dans cette famille, tous deux d’un grand intérêt pratique : le problème du voyageur de
commerce et le problème du postier. De plus, nous verrons qu’ils illustrent les deux aspects de
la recherche opérationnelle car, bien que très semblables dans leur formulation, ils diffèrent
radicalement quant à leur résolution puisque l’un d’eux peut être résolu en temps polynomial
par un algorithme simple à implémenter, et l’autre au contraire est NP-difficile et nécessite
pour être résolu un mélange de techniques avancées et d’heuristiques.
11.1 Problème du voyageur de commerce
11.1.1 Version non orientée

Formulation du problème
Le problème du voyageur de commerce (Traveling Salesman Problem ou TSP en anglais)
se formule de la manière suivante.
Problème du voyageur de commerce

Donnée : Un graphe G = (V, E) et une fonction de coût sur les arêtes c : E → R+ .
P
Tâche : Trouver une chaı̂ne fermée C passant par tous les sommets telle que e∈C c(e) soit
minimum.
Rappelons que c’est un problème difficile, comme il a été déjà signalé au Chapitre 2.
Théorème 11.1. Le problème du voyageur de commerce est NP-difficile.

CHAPITRE 11. TOURNÉES 144
Graphe complet des plus courtes

chaı̂nes
b
2 a
2
a 4 2
b
c
1 2
d 2
4
1 2
3
3
e
e c
1 3
1
2
a
2
b d
2 b
4
2 2
2
3
3 a 4
e
c c
1 3 1
d 2
1
2
1
d
e
Figure 11.1 – Le problème du voyageur de commerce peut se reformuler comme un problème de cycle
hamiltonien dans un graphe complet.
Il faut donc mettre en œuvre des stratégies de résolutions plus intelligentes, et donc
se tourner vers les techniques de la recherche opérationnelle. Nous allons présenter trois ap-
proches : heuristique, branch-and-bound, recherche locale. Les grands progrès de ces dernières
années dans la résolution du problème du voyageur de commerce résident principalement dans
les techniques de branch-and-bound, et plus précisément dans le calcul des bornes. On sait
de nos jours résoudre des instances à 1000 000 villes, alors qu’il y a une vingtaine d’années,
on ne dépassait pas quelques centaines de villes (la puissance de calcul joue un rôle très
secondaire dans ces performances – voir la discussion sur la complexité du Chapitre 2).
Les approches que nous allons décrire s’énoncent plus facilement sous la reformulation
suivante sur le graphe complet Kn . Elle s’obtient en prenant le même ensemble de sommets
et en mettant comme coût c(xy) le coût du plus court chemin dans G de x à y. En effet,
prenons une chaı̂ne fermée de G passant par tous les sommets. La succession des premiers
passages en chaque sommet plus le sommet de départ induit un cycle hamiltonien de coût
inférieur dans Kn . Réciproquement, un cycle hamiltonien de coût minimum dans Kn induit
une chaı̂ne fermée de même coût dans G. Cela permet de conclure que le cycle hamiltonien
de plus petit coût dans Kn induit une tournée de coût minimum dans G.
Voir l’illustration de cette reformulation sur la Figure 11.1.
145 CHAPITRE 11. TOURNÉES
Problème du voyageur de commerce (reformulation)

Donnée : Le graphe complet Kn = (V, E) avec n sommets et une fonction de coût sur les
arêtes c : E → R+ avec c(xy) + c(yz) ≥ c(xz) pour tout x, y, z ∈ V .
Tâche : Trouver un cycle hamiltonien de coût minimum.
Une heuristique naturelle

L’heuristique la plus naturelle est problablement celle consistant à toujours se rendre à
la ville la plus proche non encore visitée. Cette heuristique s’appelle nearest-neighbor. Ses
performances sont en général très mauvaises.
Heuristique de Christofidès
La plus célèbre heuristique du voyageur de commerce dans le cas non-orienté est l’heuristique
de Christofidès qui fournit une 3/2-approximation, c’est-à-dire une solution dont la valeur
est au plus 1,5 fois la valeur optimale.
L’algorithme est très simple (voir l’illustration Figure 11.2).
Trouver un arbre couvrant T de poids minimum ; définir J comme

l’ensemble de sommets de T ayant un degré impair dans T ; trouver
un couplage M de Kn de poids mininimum, reliant les sommets de J.
M ∪T est un graphe eulérien contenant tous les sommets de Kn ; suivre
un cycle eulérien ; prendre des raccourcis quand nécessaire.
Cet algorithme utilise deux routines : celle de l’arbre couvrant de poids minimum, qui est
décrite au chapitre sur la conception de réseau (Chapitre 12) ; et celle du couplage parfait
de poids minimum, non décrit dans ce cours. Il suffit de savoir qu’un couplage parfait est un
couplage qui couvre tous les sommets d’un graphe. Si le graphe est pondéré, et s’il existe
un tel couplage, on sait trouver un couplage parfait de poids minimum avec un algorithme
d’Edmonds.
Théorème 11.2. L’algorithme polynomial décrit ci-dessus fournit une 3/2-approximation
au problème du voyageur de commerce.
Démonstration. Soit H le cycle hamiltonien obtenu à la fin. Il faut prouver que l’on obtient bien
X 3
ce ≤ OP T.
2
e∈H
Pour cela, il faut prouver que le poids de M est ≤ 21 OP T .

Soit H̃ un cycle hamiltonien optimal. J = {j1 , . . . , js } sont les sommets de degré impair de T , numéroté
dans l’ordre de parcours de H̃. Considérons le couplage ji ji+1 pour i = 1, 3, . . ., ainsi que son complémentaire ji ji+1
pour i = 2, 4, . . .. La somme de leur poids est ≤ OP T , par inégalité triangulaire. Par conséquent, l’un des
deux a un poids ≤ 21 OP T . A fortiori, c’est le cas pour M (car c’est le couplage de plus petit poids sur J).
La preuve est illustrée Figure 11.3.
7 7
2
3 4
5
6
4
1
1 5
7
7 2
2
3 3
6
6
4
4
5
5
Figure 11.2 – L’heuristique de Christofidès.

H = cycle hamiltonien de plus petit coût

J = sommets de degré impair dans T .
J = {j1 , j2 , . . . , js }
inégalité triangulaire :
j2 c(M ) + c(M ) ≤ c(H)
j1
M H
j3
j6
M
j5
j4
Figure 11.3 – Illustration de la preuve du facteur d’approximation de l’heuristique de Christofidès.
Recherche locale
On peut aussi se demander si l’on peut attaquer le problème du voyageur de commerce

par des méta-heuristiques. Il faut alors définir la notion de voisinage. Le voisinage 2-OPT
est le plus classique. On dit que deux cycles hamiltoniens C, C 0 sont voisins s’ils diffèrent
d’exactement deux arêtes |C \ C 0 | = |C 0 \ C| = 2, voir Figure 11.4 On peut alors intégrer
ce voisinage dans n’importe quel schéma de métaheuristique du type “recherche locale”
(méthode tabou, recuit simulé,...).
Des généralisations du voisinage 2-OPT existent, ce sont des voisinages k-OPT avec k ≥ 2,
et consistent à échanger k arêtes. En multipliant ce type de voisinages, on peut parvenir à
des recherches locales extrêmement performantes, tout en restant prudant sur la taille du
voisinage à explorer : un k trop grand conduirait à un voisinage trop grand, complètement
ingérable par une recherche locale.
Il existe une recherche locale spécifique au voyageur de commerce : l’heurisique de Lin-
Kernigan [20]. C’est considérée comme la meilleure heuristique pour le problème du voyageur
de commerce. Il en existe différentes versions, toutes basées sur le voisinage k-OPT, avec en
général k ∈ {2, 3}. On considère que cette heuristique, bien implémentée, est capable de
trouver en moins d’une minute sur une machine du commerce l’optimum d’instances jusqu’à
1000 villes.
Formulation sous forme d’un programme linéaire en nombres entiers.

Rappelons qu’un vecteur d’incidence d’une partie A d’un ensemble B est le vecteur
x ∈ {0, 1}B où
1 si e ∈ A
xe =
0 sinon.
On peut modéliser le problème du voyageur de commerce de façon très compacte sous
forme d’un programme linéaire en nombres entiers.
Proposition 11.1. Les vecteurs d’incidences des cycles hamiltoniens sont exactement les
vecteurs entiers du système
0P≤ xe ≤ 1 e∈E
x =2 v∈V
Pe∈δ(v) e
e∈δ(X) xe ≥ 2 X ⊆ V, X 6= ∅, V.
Démonstration. Soit x le vecteur d’incidence d’un cycle hamiltonien. Il est clair que ce vecteur satisfait les
contraintes ci-dessus. Réciproquement, soit x un vecteur satisfaisant les contraintes ci-dessus. Comme
0P≤ xe ≤ 1 e∈E
e∈δ(v) xe = 2 v ∈ V,
les arêtes e telles que xe = 1 forment une collection disjointe de cycles élémentaires couvrant tous les sommets
du graphe. Il P suffit donc de montrer qu’il n’y a qu’un seul cycle dans la collection. C’est une conséquence
des inégalités e∈δ(X) xe ≥ 2 pour tout X ⊆ V, X 6= ∅, V . En effet, s’il y a un cycle qui ne couvre pas tous
les sommets, en posant X l’ensemble des sommets couverts par ce cycle, on obtient une contradiction.
Résoudre le problème du voyageur de commerce, c’est donc résoudre le programme

P
Min e∈E c(e)xe
0 ≤ xe ≤ 1 e∈E
x
Pe ∈ Z e∈E (11.1)
x e = 2 v ∈ V
Pe∈δ(v)
e∈δ(X) xe ≥ 2 X ⊆ V, X 6= ∅, V.
Branch-and-cut
On peut essayer d’en tirer une borne pour construire une méthode de branch-and-bound.
Le problème, c’est que les contraintes sont en nombre exponentiel. On peut en prendre moins
de contraintes, de manière à obtenir des bornes calculables en temps raisonnable, mais la
qualité des bornes est moindre.
P
Min e∈E c(e)xe
0P≤ xe ≤ 1 e∈E
(11.2)
x = 2 v∈V
Pe∈δ(v) e
e∈δ(X) xe ≥ 2 pour certains X ⊆ V, X 6= ∅, V.
Dans les branch-and-bound, la qualité de la borne est cruciale. Une technique efficace,
appelée branch-and-cut, permet d’améliorer la qualité de la borne. Elle consiste à suivre le
schéma d’un branch-and-bound en agrandissant le programme linéaire qui fournit les bornes
au fur et à mesure de l’exploration de l’arbre de branchement.
On résout le programme (11.2). Supposons que l’on ait une solution x∗ du programme
linéaire. Il y a 3 possibilités
1. x∗ est le vecteur d’incidence d’un cycle hamiltonien. On a trouvé une solution
optimale pour le nœud courant de l’arbre de branchement.
P
2. On trouve une inégalité du type e∈δ(X) xe ≥ 2 qui soit violée. Cela se fait
en temps polynomial : c’est un problème de coupe minimum (voir le Chapitre 5). On
ajoute la contrainte violée au programme linéaire, et on résout le nouveau programme
linéaire.
3. On ne trouve aucune inégalité de ce type qui soit violée, mais x∗ n’est pas
entier. On a une borne pour le nœud de l’arbre de branchement. Il faut brancher sur
ce nœud et recommencer pour les fils.
Relaxation lagrangienne
Nous avons vu que dans certains cas, la relaxation lagrangienne pouvait fournir de
bonnes bornes, si une partie des contraintes est facile .
C’est le cas ici (Held et Karp 1970). On peut réécrire le système linéaire (11.1)
0 ≤ xe ≤ 1 e∈E
Pe ∈ Z
x e∈E
x =2 v∈V
Pe∈δ(v) e
e∈E[X] xe ≤ |X| − 1 X ⊆ V, X 6= ∅, V.
où E[X] désigne l’ensemble des arêtes induites par X, i.e. l’ensemble des arêtes ayant leurs
deux extrémités
P dans X. P P P P
En effet 2 e∈E[X] xe + e∈δ(X) xe = v∈X e∈δ(v) xe . Donc, si e∈δ(v) xe = 2 pour tout
P P
v ∈ V , on a 2 e∈E[X] xe + e∈δ(X) xe = 2|X|, d’où l’équivalence des deux formulations. En
faisant jouer un rôle particulier au sommet 1, on peut réécrire le système sous la forme
0 ≤ xe ≤ 1 e∈E
Pe ∈ Z
x e∈E
x = 2
Pe∈δ(1) e
x ≤ |X| − 1 X ⊆ {2, . . . , n}, X 6= ∅
Pe∈E[X] e
Pe∈E xe = n
e∈δ(v) xe = 2 v ∈ {2, . . . , n}.
P
En oubliant les contraintes e∈δ(v) xe = 2 pour v ∈ {2, . . . , n}, on obtient un système
linéaire qui décrit les 1-arbres. Un 1-arbre est un arbre couvrant {2, . . . , n}, avec deux arêtes
supplémentaires quittant 1 (voir la Figure 11.5) et se calcule en temps linéaire (la routine de
calcul des arbres couvrants de poids minimum est décrite au Chapitre 12).
On a tout ce qu’il faut pour calculer une borne par relaxation lagrangienne. Le lagrangien
est  
X n
X X
L(x, λ) := ce x e + λi  xe − 2 .
e∈E i=2 e∈δ(i)
La borne inférieure sur le cycle hamiltonien est donnée par
max G(λ)
λ∈Rn−1
où X
G(λ) := −2 λi + min L(x, λ)
x vecteur d’incidence d’un 1-arbre
i∈V
en posant λ1 := 0, soit encore

X X
G(λ) = −2 λi + min (cij + λi + λj ).
T est un 1-arbre
i∈V ij∈T
On sait calculer G(λ) en temps polynomial, pour tout λ, cela suffit (voir Chapitre 7) pour
pouvoir calculer maxλ∈Rn−1 G(λ) par une méthode de sur-gradient.
Cette borne est très bonne.
Théorème 11.3 (Held Karp 1970). maxλ∈Rn−1 G(λ) est égal à la solution de la relaxation
linéaire (11.1).
Branchement
En général, dans un branch-and-bound ou dans un branch-and-cut, le problème résolu
en un nœud de l’arbre est de même nature qu’à la racine de l’arbre, laquelle consiste en
la résolution du relâché continu du problème de départ. Dans le cas du voyageur de com-
merce, ce n’est pas le cas. En un nœud de l’arbre de branchement, on doit résoudre des
tournées contraintes à passer par certaines arêtes ou à en éviter d’autres, ce qui est a priori
un problème plus général que le problème de départ. Nous expliquons maintenant une façon
classique de traiter cette difficulté.
La façon classique de brancher pour le voyageur de commerce est de choisir une arête e,
et d’écrire l’ensemble des solution X = Xe ∪ (X \ Xe ) où Xe est l’ensemble des solutions
empruntant l’arête e. Par conséquent, tout noeud de l’arbre de branch-and-bound est de la
forme
SA,B = {S ∈ S : A ⊆ S, B ∩ S = ∅} avec A, B ⊆ E.
Résoudre le problème au niveau du noeud SA,B consiste donc à chercher le cycle hamiltonien
de plus petit coût empruntant toutes les arêtes de A, et aucune de B. Il reste à décrire la
façon de calculer des bornes lorsqu’on branche. On pourrait se dire qu’il suffit de calculer des
1-arbres avec des arêtes prescrites (celles de A) et des arêtes interdites (celles de B), mais il
n’y a pas d’algorithme simple qui effectue cette tâche. Une petite astuce permet de pallier
cette difficulté.
On niveau d’un nœud de l’arbre de branchement, on a donc un problème de voyageur de
commerce avec contraintes (ensemble d’arêtes prescrites et interdites). Une petite astuce per-
met d’écrire ce problème de voyageur de commerce avec contraintes , comme un problème
de voyageur de commerce sans contrainte, simplement en modifiant la fonction de coût.
Si on pose 
 c(e) si e ∈ A
0
c (e) := c(e) + C si e ∈ / A∪B
c(e) + 2C si e ∈ B,

P
où C := e∈E c(e) + 1, on a la propriété, qui peut se démontrer assez aisément,
Les cycles hamiltoniens de SA,B sont exactement ceux dont le nouveau coût est ≤ (n +
1 − |A|)C. De plus, les cycles hamiltoniens dans SA,B ont un coût qui diffère de l’ancien coût
d’exactement (n − |A|)C.
On peut donc calculer des bornes pour un problème de voyageur de commerce non
contraint, avec la nouvelle fonction de coût, pour obtenir des bornes inférieures pour le
problème avec contraintes.
11.1.2 Version orientée

Formulation
On a aussi une version orientée de ce problème :
Problème du voyageur de commerce, version orientée

Donnée : Un graphe D = (V, A) avec n sommets et une fonction de coût sur les arêtes
w : A → R+ .
Tâche : Trouver un chemin fermé de coût minimum passant par tous les sommets.
De même que dans le cas non-orienté, on peut reformuler la problème sur le graphe
complet orienté (toute paire de sommets est reliée par deux arcs de sens opposé).
Problème du voyageur de commerce, version orientée (reformulation)

Données : Un graphe Kn = (V, A), avec un arc (i, j) pour tout i 6= j ∈ V , et une fonction
de coût sur les arcs c : A → R+ .
P
Tâche : Trouver un circuit hamiltonien C passant par tous les sommets tel que a∈C c(a)
soit minimum.
Comme dans le cas non-orienté, on a :

Théorème 11.4. Le problème du voyageur de commerce dans sa version orientée est NP-
difficile.
Cela peut se retrouver à partir du Théorème 11.1. En effet, en prenant un graphe non-
orienté, on peut dédoubler les arêtes pour en faire deux arcs parallèles mais de sens opposés.
On se ramène alors au problème du voyageur de commerce sur un graphe orienté, et si
on avait un algorithme polynomial le résolvant, on en aurait également un dans la version
non-orientée, ce qui contredit le Théorème 11.1.
Algorithmes
Le problème dans se version orientée est considéré comme plus difficile.
Voici un résumé de la situation.
— Complexité : pareil, c’est NP-difficile.
— Heuristique nearest-neighbor : également mauvaise.
— Heuristique avec un ratio d’approximation (à la Christofidès) : c’est une question ou-
verte. On ne connaı̂t à ce jour aucun algorithme fournissant en temps polynomial une
solution dans un rapport borné avec l’optimum.
— Recherche locale : même voisinage. En revanche, Lin-Kernighan fonctionne beaucoup
moins bien.
— Branch-and-Bound : pareil :
— La formulation par programme linéaire semblable.
— La relaxation lagrangienne semblable : on cherche alors un 1-arbre orienté, voir
ci-dessous.
Un 1-arbre orienté est un ensemble F d’arcs tel que le

— F est un arbre sur {2, . . . , n}
— degin (v) = 1 si v ∈ {2, . . . , n}
— degin (1) = degout (1) = 1.
On sait trouver un tel ensemble en temps polynomial (théorie des r-arborescences).
11.2 Problème du postier

11.2.1 Version non orientée
Formulation
Le problème du postier se formule de la manière suivante :
Problème du postier

Tâche : Trouver une chaı̂ne fermée de coût minimum passant par toutes les arêtes au moins
une fois.
Ici, G peut être vu comme la modélisation d’une ville, les sommets étant les intersections
de rues et les arêtes les portions de rues. Les poids peuvent être le temps de parcours des
rues. Le problème est alors celui que se pose un facteur voulant déposer tout son courrier en
un minimum de temps.
Algorithme
Contrairement au problème du voyageur de commerce, il existe un algorithme polynomial
simple qui trouve la tournée optimale. Remarquons déjà que dans le cas où le graphe est
eulérien, la question est triviale.
Sinon, on a la propriété suivante.
Lemme 11.1. La chaı̂ne fermée de coût minimum qui passe par toutes les arêtes au moins
une fois passe au plus deux fois par chaque arête.
Démonstration. Soit G = (V, E) le graphe. Soit une chaı̂ne C passant par toutes les arêtes au moins une fois.
Pour chaque arête e, on construit des arêtes e1 , . . . , er correspondant à chacun des passages sur e. Notons
G0 ce nouveau (multi)graphe. G0 est eulérien. On a donc créé des copies de certaines arêtes de manière à
rendre G eulérien. Réciproquement, si on crée des copies d’arêtes pour rendre G eulérien, on a la possibilité
de parcourir le multigraphe en passant par chaque arête du multigraphe une fois et une seule, et cela induit
sur G une chaı̂ne C passant par toutes les arêtes au moins une fois.
Soit un multigraphe G0 eulérien, et soit une arête e présente un nombre s de fois s ≥ 3. Alors, si on
enlève 2p représentant de e, avec p ∈ N et s > 2p, alors G0 reste eulérien.
Chercher la chaı̂ne de G qui passe à moindre coût par toutes les arêtes consiste donc à dupliquer à
moindre coût des arêtes de G afin de le rendre eulérien. Ici, le coût de la duplication est égal à la somme des
coûts des arêtes dupliquées.
On peut donc reformuler le problème du postier de la manière suivante.
Problème du postier
Tâche
P : Trouver F ⊆ E tel que degF (v) = degE (v) mod 2 pour tout v ∈ V , et tel que
e∈F c(e) soit minimal.
P Trouver F ⊆ E tel que degF (v) = degE (v) mod 2 pour tout v ∈ V et tel que
e∈F c(e) soit minimal : On peut vérifier que, si les c(e) ≥ 0, un tel F est constitué de
chaı̂nes appariant les sommets de degré impairs de G (qui sont en nombre pair).
Un tel F est alors facile à trouver : soit J l’ensemble des sommets de degré impair de G.
On considère le graphe complet K sur J, et on met un coût
c(jj 0 ) = le coût de la chaı̂ne de plus petit coût entre j et j 0

sur chaque arête jj 0 de K. Le couplage parfait de plus petit coût donne alors la solution (on
sait trouver un tel couplage en temps polynomial, comme indiqué dans le paragraphe sur
l’heuristique de Christofidès).
D’où
Théorème 11.5. Il existe un algorithme polynomial qui résout le problème du postier .
11.2.2 Version orientée

Formulation
La version orientée existe également. Dans l’exemple de notre facteur, cela permet de
prendre en compte l’existence de sens interdits.
Problème du postier, version orientée

Donnée : Un graphe D = (V, A) et une fonction de coût sur les arcs c : A → R+ .
Tâche : Trouver un chemin fermé de coût minimum passant par tous les arcs au moins une
fois.
Algorithme
Et de même que pour la version non orientée, on a un algorithme de résolution exacte
en temps polynomial, simple à implémenter. En effet, un tel chemin est une circulation
x ∈ RA + de coût minimum, étudiée au Chapitre 5, pour des capacités inférieures la = 1 et
des capacités supérieures ua = +∞ pour tout a ∈ A. (Rappelons qu’une circulation satisfait
la loi de Kirchoff en tous les sommets – c’est un flot sans source ni puits). Réciproquement,
si on a une circulation x ∈ RA + entière satisfaisant ces contraintes, et si D est faiblement
connexe, en vertu du Théorème 2.2, il existe un chemin fermé passant par chaque arc un
nombre xa de fois.
Théorème 11.6. Il existe un algorithme polynomial qui résout le problème du postier, dans
sa version orientée.
11.3 Exercices
11.3.1 Nombre de sommets de degré pair

Montrer que dans tout graphe, le nombre de sommets de degré impair est pair.
11.3.2 Voyageur de commerce dans le plan

On considère la tournée de la Figure 11.6. Les distances sont les distances euclidiennes ( à
vol d’oiseau ). Montrez que cette tournée est optimale en vous inspirant de la Figure 11.7.
11.3.3 Voyageur de commerce, cas orienté

— Ecrire la relaxation linéaire du problème du voyageur de commerce dans le cas orienté,
comme cela a été fait pour le cas non-orienté dans le cours.
— Expliquer pourquoi une relaxation lagrangienne dans ce cas conduit au calcul des 1-
arbres orientés .
11.3.4 T -joints
Soit G un graphe avec des coûts c : E → R (contrairement au cours, on accepte des coûts
négatifs). Soit T un ensemble de cardinalité paire. Notons E − l’ensemble des arêtes de coût
négatif, T − l’ensemble des sommets incidents à un nombre impair d’arêtes de E − , et enfin
d : E → R+ avec d(e) := |c(e)|. On dit que J est un T -joint si degJ (v) est impair si v ∈ T
et pair sinon. (rappel A4B = (A \ B) ∪ (B \ A)).
1. Montrer que c(J) = d(J4E − ) + c(E − ).
2. Montrer que J est un T -joint si et seulement si J4E − est un (T 4T − )-joint.
3. Conclure que J est un T -joint de coût minimal pour le coût c si et seulement si J4E −
est un (T 4T − )-joint de coût minimal pour le coût d.
4. Conclure que l’on sait trouver en temps polynomial un T -joint de coût minimum,
quelque soit le coût.
11.3.5 Plus courte chaı̂ne dans les graphes sans cycle absorbant
Utiliser l’exercice précédent pour montrer que l’on sait calculer en O(n3 ) une plus courte
chaı̂ne dans les graphes sans cycle absorbant (rappel : un cycle absorbant est un cycle de
coût total < 0 ; trouver un couplage parfait de coût min se fait en O(n3 )).
11.3.6 Tournées avec contraintes de temps

Un représentant de commerce doit visiter des clients situés en des villes différentes. Il a
fixé un rendez-vous pour chacun de ses clients, i.e. pour tout client i, le représentant sait
qu’il doit passer après l’instant ai , mais avant l’instant bi . Il souhaite optimiser sa tournée
(et en passant vérifier que les contraintes ne sont pas contradictoires). On suppose qu’il sait
le temps qu’il lui faut pour aller d’une ville à une autre.
Proposer une formulation sous la forme d’un programme linéaire mixte (variables entières
et continues), qui, contrairement au problème du voyageur de commerce usuel, ne contient
pas un nombre exponentiel de contraintes.
11.3.7 Voyageur de commerce et programmation dynamique

Considérons l’instance suivante : un graphe complet Kn = (V, E) à n sommets (n ≥ 3),
des coûts positifs c(vw) définis pour toute paire v, w de sommets, et un sommet particulier
s ∈ V . On cherche la chaı̂ne hamiltonienne de plus petit coût dont une des extrémités est s.
1. En prenant comme états les couples (X, v) tels que v ∈ X ⊆ V \ {s}, montrer que
l’on peut écrire une équation de programmation dynamique permettant le calcul de la chaı̂ne
optimale.
Pour les questions suivantes, on peut se servir des identités indiquées à la fin de l’examen.
2. Quel est le nombre d’états possibles ?
On prend comme opération élémentaire l’addition.
3. Estimez le nombre d’additions que ferait un algorithme exploitant cette équation de
programmation dynamique. Comparez ce nombre au nombre d’additions que ferait un algo-
rithme qui énumérerait toutes les solutions.
4. Si votre ordinateur est capable de faire 1 million d’opérations élémentaires par seconde,
pour chacune des valeurs suivantes de n, indiquez (par un calcul “à la louche”) si vous serez
capable de résoudre le problème avec cet algorithme en 1 seconde, 1 heure, 1 jour, 1 semaine,
1 mois, 1 an, 1 siècle :
n = 15 n = 30 n = 45.
5. Comment utiliser l’algorithme pour résoudre le problème du voyageur de commerce

(cycle hamiltonien de plus petit coût) sur Kn ?
Figure 11.4 – Illustration du voisinage 2-OPT.
7
2
4
5
Figure 11.5 – Un 1-arbre.

Figure 11.6 – Une tournée dans le plan.
Figure 11.7 – Cela permet-il de prouver l’optimalité de la tournée de la Figure 11.6 ?

CHAPITRE 12
Conception de réseaux
Les réseaux sont omniprésents. Qu’ils soient routiers, ferrés, informatiques, électriques
ou gaziers, ils ont souvent des rôles stratégiques et économiques cruciaux, et leur robustesse
(i.e. leur capacité à assurer leur mission même en cas de défaillance locale) est une qualité
souvent recherchée.
L’objet de ce chapitre est de présenter quelques modèles et algorithmes de base dans le
domaine de la conception de réseau robuste – champ essentiel de la recherche opérationnelle.
Nous étudierons deux problèmes :
— celui de l’arbre couvrant de poids minimal : étant donné un graphe pondéré, trouver
un arbre inclus dans ce graphe, de poids minimal, tel que tous les sommets soient reliés
par l’arbre.
— celui de l’arbre de Steiner de poids minimal, qui généralise le problème précédent : étant
donné un graphe pondéré, trouver un arbre inclus dans ce graphe, de poids minimal,
tel que tous les sommets d’un sous-ensemble prédéterminé soient reliés par l’arbre.
12.1 Quelques rappels

Un arbre est un graphe connexe sans cycle. On a la propriété suivante.
Proposition 12.1. Tout arbre à n sommets a n − 1 arêtes.

Démonstration. Par récurrence sur n. Si n = 1, c’est évident. Pour n ≥ 2, prendre un sommet de degré 1 1 .
Retirer ce sommet de l’arbre. Le graphe restant reste un arbre. Par récurrence, il a n − 1 sommets et n − 2
arêtes. En remettant le sommet que l’on vient de retirer, on ajoute un sommet et une arête.
Un arbre couvrant un graphe G = (V, E) est un arbre T := (V, F ) avec F ⊆ E. En

d’autres termes, tous les sommets de G sont couverts par T , et les arêtes de T sont des
arêtes de G. Voir une illustration sur la Figure 12.1.
Un graphe sans cycle mais pas forcément connexe est appelé forêt.
1. Si on veut être précis, il faut encore prouver qu’un tel sommet existe. Cela a l’air évident,... mais il
faut parfois se méfier des évidences en théorie des graphes. Pour le prouver, on prend un sommet quelconque
de l’arbre. On suit une chaı̂ne partant de ce sommet en s’interdisant de repasser par un même sommet. Par
finitude de l’arbre, la chaı̂ne s’arrête en un sommet v. Si v est de degré ≥ 2, alors il existe une autre arête
que par celle par laquelle on est arrivé dont l’autre extrémité est sur la chaı̂ne. Or ceci est impossible, car il
y aurait alors un cycle sur l’arbre. Donc le sommet v est de degré 1.
CHAPITRE 12. CONCEPTION DE RÉSEAUX 160
Figure 12.1 – Un exemple d’arbre couvrant.
12.2 Arbre couvrant de poids minimal

Considérons le problème suivant. On a n villages, les distances entre le village i et le
village j sont données dans le tableau suivant (n = 7)
A B C D E F G
A 0 3 8 9 10 5 5
B 3 0 9 9 12 5 4
C 8 9 0 2 10 9 9
D 9 9 2 0 11 9 8
E 10 12 10 11 0 11 11
F 5 5 9 9 11 0 1
G 5 4 9 8 11 1 0
On veut trouver le réseau routier de distance totale minimale qui relie tous les villages,
sachant qu’un tronçon relie toujours deux villages (il n’y a pas d’embranchement sur les
routes).
On peut modéliser le problème précédent par un graphe complet Kn = (V, E), où V est
l’ensemble des villages et E tous les tronçons possibles, i.e. toutes les paires ij avec i 6= j
des éléments de V . On a une fonction de poids w : E → PR+ .
On cherche alors un sous-ensemble F ⊆ E tel que e∈F w(e) soit minimal et tel que le
graphe (V, F ) soit connexe.
161 CHAPITRE 12. CONCEPTION DE RÉSEAUX
Remarque
Le problème ci-dessus admet toujours une solution qui soit un arbre. En effet, s’il ne l’était
pas, il y aurait nécessairement un cycle puisqu’il est connexe. On pourrait alors supprimer
une arête de ce cycle sans faire disparaı̂tre la connexité et sans détériorer le poids total
puisque la fonction de poids est à valeur ≥ 0.
On cherche donc à résoudre un problème d’arbre couvrant de poids minimal.
Une autre application a déjà été vue : les arbres couvrants apparaissent dans la relaxation
lagrangienne du problème du voyageur de commerce (borne du 1-arbre), voir Chapitre 11.
Cela justifie la formulation sous forme de problème.
Problème de l’arbre couvrant de poids minimal
Donnée : Un graphe G = (V, E), une fonction de poids w : E → R.
Tâche : Trouver un arbre couvrant de plus petit poids.
Pour ce problème, il y a un petit miracle puisque nous allons voir qu’il existe un
algorithme polynomial glouton qui le résout : l’algorithme de Kruskal. Rappelons qu’un
algorithme est dit glouton si à chaque itération on fait le meilleur choix local. Ces algorithmes
sont rarement optimaux (penser aux algorithmes FIRST-FIT et NEXT-FIT du bin-packing :
ils sont gloutons, mais non-optimaux ; de même pour l’algorithme glouton pour le sac-à-dos).
L’algorithme de Kruskal se décrit de la manière suivante.
— Trier les arêtes par poids croissant : e1 , . . . , em .
— Poser F := {e1 }, i := 1.
— Répéter
Faire i := i + 1. Si F ∪ {ei } ne contient pas de cycle, faire
F := F ∪ {ei }.
Théorème 12.1. L’algorithme de Kruskal résout le problème de l’arbre couvrant de poids
minimal.
La preuve s’appuie sur le lemme suivant, illustré Figure 12.2. On dit qu’une forêt F =
(V, F ) est bonne s’il existe un arbre couvrant T = (V, F 0 ) de poids minimal avec F ⊆ F 0
Lemme 12.1. Soit F = (V, F ) une bonne forêt, soit une coupe δ(X) (avec X ⊆ V ) disjointe
de F et e une arête de poids minimal dans δ(X). Alors (V, F ∪ {e}) est encore une bonne
forêt.
Démonstration. Soit T un arbre couvrant de poids minimal contenant F . Soit P le chemin reliant dans T
les extrémités de e. P intersecte δ(X) en au moins une arête f . Alors T 0 := T \ {f } ∪ {e} est encore un arbre
couvrant. D’après la définition de e, on a w(e) ≤ w(f ), et donc w(T 0 ) ≤ w(T ). Par conséquent, T 0 est encore
un arbre couvrant de poids minimal. Comme F ∪ {e} est contenu dans T 0 , c’est encore une bonne forêt.
Preuve du Théorème 12.1. L’algorithme de Kruskal ajoute à chaque itération l’arête de plus petit poids
dans la coupe δ(K), où K est l’une des deux composantes connexes de F = (V, F ) incidentes à ei . Comme
δ(K) est disjointe de F , le Lemme 12.1 s’applique.
Tout au long de l’algorithme, (V, F ∪ {ei }) est donc une bonne forêt. En particulier à la dernière itération
où la forêt se transforme en arbre. Par définition d’une bonne forêt, cet arbre est optimal.
arêtes d’une bonne forêt 4

X
Figure 12.2 – Une bonne forêt, qui reste une bonne forêt lorsqu’on ajoute l’arête e (on suppose que e est
de poids minimal dans δ(X)).
Remarque
Cet algoritme fonctionne quelque soit le signe des poids des arêtes. Dans l’exemple intro-
ductif, on supposait que les poids étaient tous positifs ; cela pour permettre de conclure que
le problème du graphe connexe couvrant de plus petit poids pouvait se ramener au problème
de l’arbre couvrant de plus petit poids. Ce dernier problème lui se résout par l’algorithme
de Kruskal indépendament du signe du poids des arêtes.
12.3 Arbre de Steiner

Dans le problème de l’arbre de Steiner, c’est seulement un sous-ensemble des sommets
du graphe que l’on souhaite voir relié par un arbre. Curieusement, alors que le problème de
l’arbre couvrant de poids minimal est polynomial, celui de l’arbre de Steiner est NP-difficile.
Le problème se formalise comme suit.
Problème de l’arbre de Steiner

Donnée : Un graphe G = (V, E), une fonction de poids w : E → R+ et un ensemble de
sommets S ⊆ V , appelés terminaux.
Tâche : Trouver un arbre T de plus petit poids couvrant S.
Les applications sont innombrables, et ce problème apparaı̂t fréquemment dans la concep-

tion de réseau en tant que tel ou en tant que sous-routine.
Théorème 12.2. Le problème de l’arbre de Steiner est NP-difficile, même si tous les poids
sont égaux à 1.
Comme d’habitude dans ce cas-là, il faut se poser la question de l’existence d’algorithme

d’approximation, d’algorithmes exacts efficaces ou de cadre adapté à la recherche locale.
C’est ce que nous allons voir maintenant.
12.3.2 Une heuristique à la Christofidès

Il existe une heuristique similaire à celle de Christofidès pour le problème du voyageur
de commerce, qui se décrit très simplement.
On suppose G = (V, E) connexe. On construit le graphe complet K = (S, E 0 ) sur S et
sur chaque arête uv ∈ E 0 on met le poids w̄ du plus court chemin de u à v dans G (même
construction que pour le problème du voyageur de commerce – voir Chapitre 11).
On prend l’arbre T 0 de plus petit poids couvrant K pour le poids w̄.
T 0 induit un graphe partiel H de G. On en prend un arbre couvrant de plus petit poids
w.
L’algorithme est illustré Figure 12.3.
Théorème 12.3. L’algorithme décrit ci-dessus fournit une solution de poids au plus 2 fois
plus grand que la solution optimale.
Démonstration. Il suffit de prouver que w̄(T 0 ) est au plus deux fois plus grand que celui de l’arbre de Steiner
T de poids minimum w(T ).
Soit T l’arbre de Steiner de plus petit poids. Dupliquons chacune des arêtes de T . On a donc maintenant
un graphe eulérien que l’on peut parcourir en passant exactement une fois sur chaque arête : cycle C. Cela
induit un cycle hamiltonien C 0 dans K : on parcourt S dans l’ordre de leur première apparition dans C. On
a finalement
w̄(T 0 ) ≤ w̄(C 0 ) ≤ w(C) = 2w(T ).
12.3.3 Programmation dynamique

Dreyfus et Wagner [7] ont trouvé une méthode assez astucieuse – basée sur la program-
mation dynamique (voir Chapitre 3) – qui permet de calculer un arbre de Steiner de poids
minimum, quand le nombre d’éléments de S n’est pas trop grand.
En effet, si on pose pour U ⊆ V et x ∈
/U
p(U ) := min{w(T ) : T est arbre de Steiner pour U },
on a l’équation de programmation dynamique suivante
p(U ∪ {x}) = min (dist(x, y) + p(U 0 ∪ {y}) + p(U \ U 0 ∪ {y})). (12.1)

y∈V,∅$U 0 $U
où dist(x, y) est la distance de x à y, i.e. la longueur d’une plus courte chaı̂ne de x à y
en prenant w comme longueur des arêtes (voir Chapitre 3 pour ces calculs de plus courts
chemins).
Pour voir que l’équation (12.1) est vraie, supposons d’abord que x est une feuille. Dans
ce cas, x est relié par une chaı̂ne à un sommet y qui est tel que
— soit y ∈ U
— soit y ∈
/ U et y de degré au moins 2.
Pour le premier point, l’équation (12.1) est vraie en posant U 0 := {y}. Pour le second point,
l’équation est vraie car alors y est le point de rencontre d’une chaı̂ne partand de x, d’un
arbre couvrant U 0 ∪ {y} et d’un arbre couvrant U \ U 0 ∪ {y}.
Enfin, supposons que x ne soit pas une feuille. Dans ce cas l’équation est vraie pour
y = x.
L’équation (12.1) calculées de proche en proche conduit à
Théorème 12.4. Le problème de l’arbre de Steiner de poids minimum se résout de manière

exacte en O(3s ns + mn + n2 log n), où s est le nombre d’éléments de S.
Elements de preuve. La preuve de l’équation (12.1) a été esquissée ci-dessus. Il reste à expliquer la com-
plexité.
Le terme O(3s n2 ) vient du calcul de p(U ). Supposons que l’on ait calculé tous les p(U ) pour un cardinal
|U | = i. Le calcul d’un p(U ) pour une cardinalité |U | = i+1 se fait en n2i (interprétation de l’équation (12.1)).
Ps−1 s
La complexité totale est donc de l’ordre de i=0 n2i i+1 = O(3s ns).
2
Le terme O(mn + n log n) vient du calcul des plus courtes distances.
Une approche par la programmation dynamique peut donc être pertinente si le nombre
s de terminaux est petit.
12.3.4 Branch-and-cut
L’approche branch-and-cut (voir le Chapitre 11 pour une première approche du branch-
and-cut) repose sur la proposition suivante.
Proposition 12.2. Soit r un sommet arbitraire, r ∈ S. Résoudre le problème de l’arbre de

Steiner de coût minimum revient à résoudre
P
minx∈RE Pe∈E w(e)xe
s.c. e∈δ(X) xe ≥ 1 pour tout X ⊆ V tel que r ∈/X
et X ∩ S 6= ∅
xe ∈ {0, 1} e ∈ E.
Démonstration. Si x est vecteur d’incidence d’un arbre de Steiner, il est clair qu’il satisfait les inégalités ci-
dessus. Réciproquement,
P soit x∗ une solution optimale du programme linéaire. Notons T := {e ∈ E : xe = 1}.
D’après l’inégalité e∈δ(X) xe ≥ 1, l’ensemble T est connexe. Et si T contient un cycle C, on peut trouver
une arête e ∈ C telle que w(e) = 0, arête que l’on peut supprimer sans que les contraintes se retrouvent
violées.
Le programme linéaire en nombres entiers précédent a deux caractéristiques qui le rende

difficile à résoudre.
• il est en nombres entiers.
• il a un nombre exponentiel de contraintes.
On est exactement dans la même situation que pour la formulation PLNE du problème
du voyageur de commerce. La relaxation continue lève le premier problème : la solution de ce
problème fournit une borne inférieure sur la solution optimale. Cela indique qu’une méthode
de branch-and-cut peut être appropriée. Pour résoudre le programme linéaire précédent, on
peut utiliser une approche branch-and-cut très semblable à celle suivie pour le voyageur de
commerce.
Pour pouvoir appliquer un branch-and-cut,
P il faut pouvoir trouver s’il existe X ⊆ V
avec r ∈/ X et X ∩ S 6= ∅ tel que e∈δ(X) xe < 1. Cela se fait par une recherche de coupe
minimum : on recherche le v–r flot maximum pour tout v ∈ S (voir Chapitre 5).
On a donc tout ce qu’il faut pour faire du branch-and-cut. L’algorithme suit le même
schéma que celui décrit au Chapitre 11.

La ressemblance avec les problèmes d’arbres couvrants suggère la modélisation suivante
Proposition 12.3. Soit r un sommet arbitraire, r ∈ S. Soit v0 un nouveau sommet, relié
à tout sommet de V \ S et à r. On étend w par w(v0 v) := 0. On appelle G0 = (V0 , E0 )
ce nouveau graphe. Résoudre le problème de l’arbre de Steiner de poids minimum revient à
résoudre P
minx∈RE e∈E w(e)xe
s.c. xe ∈ {0, 1} et est le vecteur indicateur
(12.2)
d’un arbre couvrant G0 ,
xv0 v + xe ≤ 1 v ∈ V \ S ; e ∈ δG (v)
Démonstration. Si x est vecteur d’incidence d’un arbre de Steiner, il est clair qu’il satisfait les inégalités ci-
dessus, quitte à ajouter des xv0 v := 1, sans modifier le poids. Réciproquement, soit x∗ une solution optimale
du programme linéaire. Notons T := {e ∈ E : xe = 1}. En ne gardant que les arêtes qui sont non incidentes
à v0 , on obtient un arbre de Steiner de même coût.
Comme d’habitude pour ce genre de problème, on peut avoir de meilleures bornes en

utilisant la relaxation lagrangienne, ce qui peut être cruciale pour les problèmes de grande
taille. Il faut donc se demander si la suppression de certaines contraintes du programme (12.2)
rend le problème soluble.
Il est clair que la suppression des contraintes xv0 v + xe ≤ 1 rend le problème polynomial,
grâce à l’algorithme de Kruskal. On écrit donc le lagrangien.
X X X
L(x, λ) := w(e)xe + λv,e (xv0 v + xe − 1).
e∈E v∈V \S e∈δ(v)
Le problème de l’arbre de Steiner consiste à trouver minx maxλ L(x, λ). On peut minorer
cette quantité par max G(λ), avec G(λ) := minx L(x, λ), ie :
G(λ) := P P P
min e∈E w(e)xe + v∈V \S e∈δG (v) λv,e (xv0 v + xe − 1)
s.c. xe est le vecteur indicateur d’un arbre couvrant G0
qui peut se réécrire...
X X
G(λ) := − λv,e + poids minimal d’un arbre couvrant G0
v∈V \S e∈δ(v)
0
où l’arbre couvrant GP 0 est calculé avec les poids wuv := wuv + λu,uv 1(u ∈
/ S) + λv,uv 1(v ∈
/ S)
0
si uv ∈ E et wv0 v := e∈δ(v) λv,e .
G(λ) se calcule donc aisément par l’algorithme de Kruskal, ainsi que ses sur-gradients.
On sait donc maximiser G(λ), et on peut calculer de bonnes bornes inférieures.
Pour le branchement, c’est simple : les solutions réalisables associées à un nœud de l’arbre
de branch-and-bound correspond à l’ensemble des arbres avec un sous-ensemble d’arêtes
imposé. Il est en effet facile de voir que trouver l’arbre couvrant de poids minimum avec des
arêtes imposées se fait encore avec l’algorithme de Kruskal. La situation est ici plus simple
que dans le cas du voyageur de commerce où pour conserver la borne du 1-arbre en fixant
des arêtes et en en interdisant d’autres il faut modifier la fonction de coût.
12.3.6 Recherche locale

Classiquement, les algorithmes de recherche locale pour le problème du Steiner tree s’ap-
puient sur la remarque suivante : Une fois fixés les sommets V 0 ⊆ V de l’arbre de Steiner (on
a bien sûr T ⊆ V 0 ), les arêtes s’obtiennent par un simple calcul d’arbre couvrant de poids
minimum.
Le voisinage se construit sur les parties V 0 de V : on dit que V 0 est voisin de V 00 si l’on
est dans une des ces situations
1. V 00 := V 0 \ {v 0 } pour un v 0 ∈ V 0 , (drop)
2. V 00 := V 0 ∪ {v 00 } pour un v 00 ∈ V \ V 0 (add) ou
3. V 00 := V 0 \ {v 0 } ∪ {v 00 } (swap).
12.4 Quelques remarques pour finir

Reprenons le problème des villages du début, mais maintenant autorisons-nous des em-
branchements. On veut donc convevoir le réseau routier de distance totale minimale tel que
tous les villages soient reliés.
Ici, contrairement à la situation du début, la liste des tronçons possibles est potentiel-
lement infinie, l’input est alors plutôt les coordonnées des n villages. Ce genre de problème
justifie la formalisation du problème suivant.
Problème de l’arbre de Steiner euclidien

Donnée : t points de coordonnées (x1 , y1 ), . . . , (xt , yt ).
Tâche : Trouver l’arbre de plus petite longueur reliant tous les points.
Sans surprise, on a
Théorème 12.5. Le problème de l’arbre de Steiner euclidien est NP-difficile.
Remarquons que l’arbre de Steiner de plus petite longueur est le réseau de plus petite
longueur reliant tous les points, l’existence d’un cycle conduisant toujours à une solution
sous-optimale. Pour une illustration d’un tel réseau, voir Figure 12.4.
Les heuristiques de résolutions, les algorithmes, etc. s’appuient sur la propriété suivante.
On appelle point de Steiner une extrémité de segment qui ne soit pas un des points de l’input.
Proposition 12.4. Les points de Steiner sont toujours de degré 3 (au sens du nombre
d’arêtes). De plus, on ne peut avoir deux segments se rencontrant en un angle faisant stric-
tement moins de 120◦ .
Cette proposition se démontre en résolvant le problème de l’arbre de Steiner euclidien

dans le cas où il n’y a que trois points. Ce problème avait été résolu en son temps par Fermat.
Si ces trois points forment un triangle ABC dont les angles font tous moins de 120◦ , il faut
ajouter un point P dans le triangle, appelé point de Fermat, tel que les angles AP [ B, BP
\ C
◦
et CP A fassent tous trois 120 . La preuve de ce fait est un exercice classique de géométrie
[
plane et passe par les rotations d’angles 120◦ en les points A, B et C.
Si l’un des angles du triangle fait plus de 120◦ , disons ABC, [ alors le réseau optimal est
formé des deux segments [A, B] et [B, C].
Tout comme le problème de l’arbre de Steiner sur un graphe, le problème de l’arbre de
Steiner euclidien est très étudié. On connaı̂t des branch-and-bound efficaces et de bonnes
heuristiques et métaheuristiques du style recherche locale.
Un autre problème très étudié – avec des résultats semblables – est le problème de l’arbre
de Steiner Manhattan , en ne s’autorisant que les segments horizontaux et verticaux. Une
application réside par exemple dans la conception des circuits intégrés.
12.5 Exercices
12.5.1 Un réseau d’eau

Un ensemble de pavillons doit être relié par un réseau de canalisation d’eau au moindre
coût à un château d’eau. Voir Figure 12.5. Sur la figure, les liaisons possibles sont indiquées
par la présence d’un lien entre deux pavillons. Le coût d’ouverture d’une liaison est indiqué
à proximité de ce lien.
Mettez en évidence un réseau de moindre coût sur la figure, indiquez son coût et justifiez
l’optimalité de la solution que vous proposez.
12.5.2 Plus grand poids le plus petit possible

Considérons un graphe G = (V, E) muni de poids w : E → R. On cherche l’arbre couvrant
dont le poids maximal d’une arête est le plus petit possible. Comment peut-on le trouver ?
12.5.3 Produit des poids

Considérons un graphe G = (V, E) muni de poids w : E → R∗+ strictement positifs. Peut-
on trouver en temps polynomial l’arbre couvrant dont le produit des poids est minimal ?
12.5.4 Graphe partiel connexe couvrant

Considérons un graphe G = (V, E) muni de poids w : E → R. Peut-on trouver en temps
polynomial le graphe partiel connexe couvrant de poids minimal ?
Rappelons qu’un graphe partiel H d’un graphe G = (V, E) est tel que H = (V 0 , F ) avec
V 0 ⊆ V et F ⊆ E. Si V 0 = V , on dit qu’il couvre G.
12.5.5 Transmission optimale de message, d’après Ahuja, Alimanti et Orlin [1]

Un service d’espionnage a n agents dans un pays ennemi. Chaque agent connaı̂t certains
des autres agents et peut orgainer une rencontre avec toute personne qu’il connaı̂t. Pour
toute rencontre entre l’agent i et l’agent j, la probabilité que le message tombe entre des
mains hostiles est de pij . Comment transmettre le message à tous les agents en minimisant
la probabilité d’interception ?
12.5.6 Matroı̈des (pour les élèves ayant un goût pour les maths)
Soit E un ensemble fini et soit I une collection de parties de E. Si I satisfait
(i) si I ∈ I et J ⊆ I, alors J ∈ I.
(ii) si I, J ∈ I et |I| < |J|, alors I ∪ {z} ∈ I pour un certain z ∈ J \ I.
alors (E, I) est appelé un matroı̈de.
1. Soit G = (V, E) un graphe connexe. Montrer que (E, F) où F est l’ensemble des forêts
de G est un matroı̈de.
2. Soit E = E1 ∪ E2 ∪ . . . ∪ Ek l’union de k ensemble disjoints, et soient u1 , u2 , . . . , uk des
entiers positifs. Montrer que (E, I) où I est l’ensemble des parties I de E telles que
I ∩ Ei ≤ ui est un matroı̈de (appelé matroı̈de de partition).
3. Soit M une matrice réelle. Soit E l’ensemble des colonnes de M et soit I les sous-
ensembles de colonnes indépendantes (pour l’agèbre linéaire). Montrer que (E, I) est
un matroı̈de (appelé matroı̈de matriciel).
4. Soit (E, I) un matroı̈de. Supposons donnée une fonction de poids w : E → R. Montrer
que trouver l’indépendant de poids maximum peut se faire par l’algorithme glouton.
12.5.7 Design de réseau - un seul bien

Supposons que l’on souhaite calibrer un réseau de transport de façon à pouvoir assurer des
livraisons depuis des sources jusqu’à des destinations. Pour chaque tronçon direct (u, v), on
connaı̂t le coût c(u, v) d’établissement d’une liaison de capacité unitaire. Comment construire
le réseau dont l’établissement soit de coût minimum ? On suppose que l’on connaı̂t pour
les sources, l’offre et pour les destinations, la demande. Modéliser ce problème comme un
problème de flot.
12.5.8 Design de réseau - plusieurs biens

On dispose d’un réseau orienté D = (V, A). Ce réseau a des sources s1 , . . . , sk et des
destinations t1 , . . . , tk . Le bien i circule de la source si à la destination ti . Ce bien est modélisé
par un flot xi : A → R+ .
On doit sélectionner maintenant un sous-ensemble A0 de A tel que chaque bien puisse
circuler de sa source à sa destination.
Le coût de sélection de l’arc a se note fa et le coût d’utilisation de l’arc a pour une unité
de bien i se note cia . On veut trouver A0 tel que le coût total (sélection des arcs et transport
du flot) soit le plus petit possible.
1. Modéliser ce problème sous forme d’un programme liénaire en nombres entiers, en les
variables xia , pour a ∈ A et i = 1, . . . , k, et ya , pour a ∈ A, où ya code la sélection de l’arc
A dans la conception du réseau.
2. Proposer une relaxation lagrangienne qui permette de calculer de bonnes bornes
inférieures.
12.5.9 Un problème de réseau avec une contrainte de degré

On se donne un ensemble T de terminaux à alimenter en électricité et une centrale p, d’où
peuvent partir au plus s câbles. On veut créer un réseau connectant l’ensemble des terminaux
à la centrale. Une connexion consiste soit à relier deux terminaux entre eux, soit à connecter
un terminal à la centrale. Comme la centrale a au plus s câbles la quittant, on peut avoir
au plus s connexions directes à la centrale. Chaque connexion a un coût strictement positif.
On cherche le réseau de plus petit coût.
On modélise ce problème par un graphe complet K = (V, E), avec V = T ∪ {p}. On a
donc un vecteur de coût c ∈ (R∗+ )E . Comme les coûts sont strictement positifs, on cherche
donc un arbre couvrant de K, de plus petit coût, et dont le degré en p n’excède pas s.
Pour un ensemble B ⊆ E, on dit qu’un vecteur x ∈ {0, 1}E est le vecteur indicateur de
B si
xe = 1 ⇔ e ∈ B.
Notons X l’ensemble x ∈ {0, 1}E des vecteurs indicateurs d’arbres couvrants de K. On
cherche donc à résoudre le problème suivant
P
Min Pe∈E ce xe
s.c. e∈δ(p) xe ≤ s (i)
x∈X (ii)
La méthode que l’on va suivre consiste à utiliser la relaxation lagrangienne. Ici, non
seulement elle permettra d’obtenir des bornes inférieures, mais elle permettra également de
trouver l’optimum.
1. Ecrire le lagrangien L(x, λ) de ce problème quand on procède à la relaxation lagran-

gienne de la contrainte (i), avec λ la variable duale associée à cette contrainte.
On définit G(λ) = minx∈X L(x, λ). Calculer G(λ) revient à résoudre un problème de
minimisation. On note xλ la solution dans X correspondante.
2. A λ fixé, peut-on calculer en temps polynomial la valeur de G(λ) ? Avec quel algo-
rithme ?
3. Montrer que si x0 est le vecteur indicateur d’un arbre couvrant K dont le degré en p
est au plus s, alors G(0) ≥ G(λ) pour tout λ ≥ 0. Que peut-on par ailleurs dire de cet arbre
couvrant par rapport à notre problème de départ ? Justifier.
Supposons maintenant que x0 est le vecteur indicateur d’un arbre couvrant K dont le
degré en p est strictement plus grand que s.
4. On veut trouver λ ∈ R+ tel que G(λ) soit maximal. Expliquer pourquoi on peut se
limiter aux valeurs de λ de la forme λ = ce − cf avec e ∈/ δ(p) et f ∈ δ(p). Evaluer une borne
supérieure N sur le nombre de telles valeurs et en conclure que maximiser G se fait en temps
polynomial.
On ordonne ces valeurs de λ de façon à avoir une séquence λ1 < λ2 < cldots < λN . Soit i
le plus petit indice tel que xλi est un arbre couvrant dont le degré en p est inférieur ou égal
à s.
5. Montrer que λi est la valeur de λ en laquelle G est maximal.
6. Montrer que quitte à changer un peu la solution xλi on peut obtenir un arbre couvrant
de degré s en p de vecteur indicateur x∗ tel que
L(xλi , λi ) = L(x∗ , λi ).
7. En déduire que G(λi ) = e∈E ce x∗e et que x∗ est la solution à notre problème de départ.
P
On est donc dans une situation où la borne fournie par la relaxation lagrangienne coı̈ncide
avec l’optimum.
u x
3 3
1 1
2 u x x
2 8 3 u
3
4
7
4
1
1 4
3 4
4
2 4
2 v w v w
v
5
w
u x u x
2
1
1 1
2 2
v v
w w
Figure 12.3 – Illustration de l’heuristique à la Christofidès pour le problème de l’arbre de Steiner.
Figure 12.4 – A gauche, l’input d’un problème de Steiner euclidien, à droite l’output.
Château d’eau
1
4 4
2 2 2 4
2 1
1
2 1 2 2
7
1
2
6
1 2 2
1
1 4
4 4
4 4
5 1 2
Figure 12.5
CHAPITRE 13
Ouverture
En conclusion, signalons les outils de la recherche opérationnelle ainsi que des domaines
à la frontière que nous avons simplement évoqués, par manque de temps et de place, mais
qui sont extrêmement importants.
Ces outils sont les méthodes de décomposition, les méthodes de coupes, l’optimisation
convexe et la simulation.
Ces domaines sont les statistiques, les files d’attente et la théorie des jeux.
13.1 Quelques outils absents de ce livre

13.1.1 Les méthodes de décomposition
Souvent associé au nom de Bender qui initia ces techniques, les méthodes de décomposition
traitent des cas où le nombre de variables est très grand, voire exponentiel en la taille du
problème. Très schématiquement, dans le cas où le problème se formule sous la forme d’un
programme linéaire (P ), ces méthodes procèdent de la façon suivante (on parle alors de
génération de colonnes – le mot colonne étant alors synonyme de variable comme
dans l’algorithme du simplexe) :
1. ne travailler que sur une partie des variables, on appelle ce problème (P 0 ) ;
2. résoudre le dual (D0 ) de ce problème réduit ; de deux choses l’une
— soit la solution de ce dual satisfait toutes les contraintes du dual (D) de (P )
auquel cas, la solution primale optimale de (P 0 ) est également solution optimale
de (P ), et l’algorithme est fini,
— soit la solution de ce dual ne satisfait pas toutes les contraintes de (D). On
sélectionne alors une des contraintes violées (par exemple, la plus violée, ce qui
nécessite souvent un autre problème d’optimisation), on ajoute la variable cor-
respondante à (P 0 ) ce qui donne naissance à un nouveau programme réduit. On
retourne en 1.
13.1.2 Les méthodes de coupes

Les méthodes de coupes sont utilisées pour la programmation linéaire en nombres entiers.
On peut écrire le problème de la programmation linéaire en nombres entiers sous la forme
CHAPITRE 13. OUVERTURE 176
min(cT x : x ∈ P ∩ Zn ), où P est un polyèdre.

Les méthodes de coupes consistent à ajouter des contraintes linéaires qui sont vérifiées par
tous les points entiers de P , mais pas par tous les points de P . Comme on cherche une solution
entière, on ne se prive pas de solution, et la relaxation continue est meilleure. Il existe des
techniques de génération automatique de contraintes linéaires (coupes de Dantzig, Gomory,
Chvátal,...), on peut aussi trouver de telles coupes par des méthodes ad hoc, adaptées au
problème particulier auquel on s’intéresse. On a vu deux exemples dans les exercices du
Chapitre 8.
13.1.3 Optimisation convexe

La généralisation immédiate de la programmation linéaire est la programmation convexe,
dont les contraintes et l’objectif sont convexes. Dans le domaine du transport de gaz ou dans
les réseaux télécom par exemple, on rencontre souvent des problèmes du type : on se donne
un graphe orienté, avec des contraintes de capacité, et des coûts ca : R → R convexes, pour
tout a ∈ A, et on demande de trouver le flot de coût minimum. On dispose de nombreux
algorithmes efficaces (et très souvent polynomiaux) pour résoudre ces problèmes.
Il faut aussi signaler le cas particulier de la programmation semi-définie positive,

résolue en temps polynomial par les points intérieurs. Elle concerne le cas où les vecteurs des
problèmes de programmation linéaires, tant ceux qui définissent l’objectif ou les contraintes
que les variables, sont remplacés par des matrices semi-définie positive, i.e. des matrices
symétriques réelles dont toutes les valeurs propres sont positives ou nulles.
La programmation semi-définie positive ne modélise pas aussi naturellement que la pro-
grammation linéaire des problèmes réels, mais apparaı̂t souvent comme relaxation efficace
de certains problèmes combinatoires, en particulier lorsque le critère comporte des termes
quadratiques.
13.1.4 Simulation
Simuler c’est reproduire à volonté un phénomène original à l’aide d’un modèle qui en
abstrait les éléments essentiels, dans le but de tirer des conclusions sur ce phénomène.
L’intérêt est évident quand
— le phénomène original est difficile à reproduire à volonté (conditions particulières dif-
ficiles à remplir, coût, durée, etc.)
— la modélisation sous forme problème ne se résout pas facilement (par exemple, les
problèmes biniveaux compliqués ; ou en physique : équations Navier-Stokes)
On distingue les simulations à temps continu et ceux à événements discrets.
La simulation peut être utile par exemple pour dimensionner une flotte de véhicule de
transport à la demande, compte tenu de la fonction d’utilité des agents, de la congestion,
etc. ; pour proposer un nouveau système logistique, avec des tarifications variables ; pour
étudier une chaı̂ne d’approvisionnement complexe ; etc.
177 CHAPITRE 13. OUVERTURE
La simulation est souvent couplée avec des techniques plus classiques de recherche opérationnelle,
comme on le dévine aisément à la lecture des exemples ci-dessus.
13.2 Trois domaines à la frontière de la recherche opérationnelle

13.2.1 Statistiques
Les statistiques, que l’on peut définir comme la science de la représentation simplifiée des
grands ensembles de données, interviennent en amont de la partie Donnée d’un Problème :
les données ne sont pas toujours faciles à obtenir, ou peuvent être entachées d’erreurs.
13.2.2 Files d’attente

C’est un outil de modélisation (puissant) des systèmes logistiques et de communication.
Il y a des clients, qui cherchent à accéder à des ressources limitées, afin d’obtenir un service.
Ces demandes concurrentes engendrent des délais et donc des files d’attente de clients.
Les mesures de performance sont en général : nombre moyen de clients en attente
et temps moyen d’attente.
Le modèle le plus simple est donnée Figure 13.1.
λ
µ
départ
arrivée service
attente
Figure 13.1 – Une file d’attente simple.
Les taux d’arrivée et de service, λ et µ sont donnés. Si le processus d’arrivée est poissonien
et si la durée de service suit une loi exponentielle, le nombre de personnes dans la file est
une chaı̂ne de Markov en temps continu. Notons que pour avoir un régime stationnaire, il
faut que λ/µ < 1. En toute généralité, il n’y a pas de raison que la file d’attente puisse être
modélisée par une chaı̂ne de Markov, et leur étude peut devenir extrêmement difficile.
Les applications sont nombreuses : dimensionnement des caisses de supermarché, des
services hospitaliers, des standard téléphoniques, serveurs informatiques, etc.
13.2.3 Théorie des jeux

La théorie des jeux est née en même temps que la recherche opérationnelle, pendant la
seconde guerre mondiale.
Dans ce cours, nous avons vu la théorie des jeux deux fois : dans le Chapitre 4, la
dualité forte nous a permis de démontrer le théorème de von Neumann (Théorème 4.5 ;
dans le Chapitre 6, nous avons vu les mariages stables (théorème de Gale-Shapley), qui
appartiennent au champ des jeux coopératifs où l’on s’intéresse à la stabilité des coalitions.
Il y a parfois des intéractions fortes entre la théorie des jeux et le recherche opérationnelle :
1. lorsque la fonction objectif ne veut pas optimiser mais partager équitablement : les
problèmes académiques sont par exemple les mariages stables, cake cutting, necklace
splitting. Dans ces deux derniers problèmes, on veut partager un objet (un gâteau ou
un collier) et l’on veut que toutes les personnes perçoivent le partage comme juste dans
un certain sens, même si elles n’ont pas la même fonction d’évaluation.
2. lorsque la fonction objectif contient un terme qui résulte d’un terme réponse économique.
Par exemple, lorsqu’on veut concevoir un réseau routier, on est obligé de se demander
par où va s’écouler le flot des usagers. Mais le flot est le résultat de ce que chaque
personne décide de faire, d’un processus d’optimisation locale. Il faut donc évaluer et
comparer les équilibres de Nash selon les choix qui sont faits. On parle alors de problème
biniveau.
Dans ce second cas, il faut souligner que les choses sont difficiles, et peu intuitives comme
en témoigne le célèbre paradoxe de Braess.
v v
c(x) = x c(x) = x
c(x) = 1 c(x) = 1
c(x) = 0
s s
t t
c(x) = 1 c(x) = x c(x) = 1 c(x) = x
w w
Figure 13.2 – Un réseau simple où apparaı̂t le paradoxe de Braess
Considérons les réseaux de la Figure 13.2. Un flot de valeur 1 veut aller de s à t. Chaque
élément infinitésimal du flot – un usager – choisit le chemin le moins coûteux. On obtient
un équilibre de Nash. Dans le réseau de gauche, cet équilibre de Nash est formé d’un flot de
valeur 1/2 empruntant la route supérieure, et d’un flot de valeur 1/2 empruntant la route
inférieure. L’ajout d’une autoroute au milieu détériore tout : on peut vérifier qu’à l’équillibre
de Nash la totalité de flot unitaire suit la route s, v, w, t. On vérifie que le coût s’est détérioré
pour chaque usager.
Enfin, on peut mettre également à l’intersection de la recherche opérationnelle et de

la théorie des jeux, la problématique de yield management, utilisé dans les transports et
l’hôtellerie, et des enchères. La question traitée par le yield management concerne la tra-
jectoire suivie par le tarif d’une prestation en fonction de la date où elle est achetée : on
peut maximiser le bénéfice en suivant une trajectoire tenant compte des différentes fonctions
d’utilité des clients potentiels. Dans les problèmes d’enchères, utilisées en particulier par les
prestataires logistiques, on se demande quelles règles mettre en place pour maximiser le prix
auquel est vendue in fine la prestation.
Eléments de correction
Exercice 2.6.5
Considérons le graphe G = (V, E) dont les sommets V sont les formations, et dans lequel
une arête relie deux formations s’il existe un employé devant suivre ces deux formations. En-
fin, les couleurs sont les jours. Il est clair que tout planning compatible avec les contraintes de
la DRH induit une coloration propre du graphe, et dont le nombre de couleurs est le nombre
de jours de la session. Réciproquement, toute coloration induit un planning compatible avec
les contraintes de la DRH, avec un nombre de jours égal au nombre de couleurs.
Exercice 3.4.5
Ce problème se résout par la programmation dynamique. Les états sont les âges possibles
de la machine en début d’année. Les périodes sont les années. On s’intéresse aux quantités
π(t, k) = profit maximal possible en terminant la tème année en possédant une machine d’âge k.
On souhaite trouver maxk∈{1,2,3} (π(5, k) + pk ).
π(t, k) satisfait les relations suivantes :

0 pour tout k ∈ {2, 3}
π(1, k) =
b 0 − c0 pour k = 0.
π(t + 1, k + 1) = π(t, k) + bk − ck si k ∈ {1, 2}
π(t + 1, 1) = max (π(t, k) + pk−1 − 100000 + b0 − c0 ) si t ∈ {1, 2, 3, 4}
k∈{1,2,3}
On peut alors remplir le tableau des valeurs de π

t 1 2 3 4 5
k
1 70000 90000 110000 90000 150000
2 0 116000 136000 156000 136000
3 0 0 124000 144000 164000
Le profit maximal de l’entreprise est donc max(150000 + 50000, 136000 + 24000, 164000 +
10000) = 200000. Une stratégie optimale consiste à garder la machine deux ans, puis la
vendre et en racheter une nouvelle, encore une fois pour deux ans.
Exercice 3.4.10
1. On peut passer de n’importe quel point à n’importe quel autre point. On peut vérifier
exhaustivement que l’on peut atteindre n’importe quel tronçon depuis le point supérieur
gauche. On peut de plus imposer l’orientation du wagonnet : on peut partir du point supérieur
gauche vers la droite, et suivre un parcours fermé qui ramène la wagonnet au même point
avec l’orientation opposée ; quitte à ajouter ce parcours fermé au début du trajet, on peut
donc fixer l’orientation en fin de trajet.
2. Soient s et t les deux points particuliers. On peut arbitrairement dire que les sommets
associés aux tronçons sont les milieux physiques des tronçons. On les relie conformément à
l’énoncé. On relie s et t aux plus proches milieux de tronçons, et éventuellement entre eux s’ils
ne sont séparés par aucun milieu de tronçon. On obtient donc le graphe dont la construction
est précisée dans l’énoncé, avec en plus deux sommets particuliers s et t. Les coûts sur chaque
arête sont les distances correspondantes dans le réseau. On peut appliquer l’algorithme de
Djikstra pour calculer la chaı̂ne de plus petit coût dans ce graphe, qui correspond au trajet
le plus court dans le réseau.
3. On reprend le graphe de la question précédente, on le duplique. Chaque sommet possède

donc deux copies : l’une correspondant à une orientation du wagonnet et l’autre à l’autre
orientation. On efface maintenant toutes les arêtes et on en construit des nouvelles : deux
sommets sont reliés entre eux s’ils étaient auparavant reliés entre eux et si de plus le trajet qui
passe de l’un des sommets à l’autre est compatible avec les orientations qu’ils représentent.
Si on veut aller de s à t avec des orientations fixées, on peut donc le faire en calculant une
chaı̂ne de plus petit coût dans ce graphe, encore avec l’algorithme de Djikstra.
Exercice 3.4.11
1. On considère le graphe orienté D dont l’ensemble des sommets V est la collection

d’intervalles C (on identifie alors V et C) et dans lequel on a un arc (I, J) si l’extrémité
supérieure de I est strictement inférieure à l’extrémité inférieure de J. C’est un graphe
acircuitique, et les sommets des chemins élémentaires sont précisement les sous-ensembles
d’intervalles deux à deux disjoints. En mettant comme poids sur tout arc (I, J) la quantité
w(I), et en ajoutant un dernier sommet X et tous les arcs (I, X) avec I ∈ C que l’on
pondère avec w(I), chercher le sous-ensemble d’intervalles de C deux à deux disjoints de
poids maximal revient à chercher le plus long chemin de D pour la pondération w, ce qui
se fait par un algorithme de programmation dynamique (le graphe étant acircuitique). Pour
se ramener totalement au cas du cours, on peut également ajouter un sommet Y et tous les
arcs (Y, I) avec I ∈ C que l’on pondère avec 0, et chercher le chemin de Y à X de plus grand
poids.
2. Une demande de location se modélise par un intervalle de la droite réelle dont les
extrémités sont les debut et fin de la location, pondéré par la gain qui serait obtenue en
satisfaisant cette demande. Maximiser le gain revient alors à chercher le sous-ensemble d’in-
tervalles disjoints (les locations ne pouvant se recouvrir) de plus grand poids.
Exercice 5.3.12
1. Considérons le graphe D = (V, A) dont les sommets sont les blocs et pour lequel on a un
arc (u, v) si v ∈ Yu . Une solution du cas statique est un fermé de ce graphe et réciproquement
tout fermé du graphe est une solution du cas statique.
2. Si on met ua := +∞ pour tout a ∈ A, on a la propriété recherchée. En effet, soit

+
X ⊆ V tel que δD̃ (X ∪ {s}) soit une s-t coupe de D̃ de capacité minimale. Aucune arête
de A ne peut être dans cette coupe, sinon sa capacité serait = +∞. Donc, si u ∈ X, tout
successeur de u est encore dans X. Ce qui est précisément la définition de “fermé”.
3. On note X̄ := V \ X. Comme X est fermé, les seuls arcs qui vont jouer un rôle dans
la coupe sont les arcs de la forme (s, v) avec v ∈ X̄ et ceux de la forme (v, t) avec v ∈ X.
On a donc X X X X X
ua = cv − cv = cv − cv .
a∈δ + (X∪{s}) v∈X̄∩V + v∈X∩V − v∈V + v∈X
D̃
P
4. Posons C := v∈V + cv .
Soit X un fermé de D de valeur maximale η. D’après ce qui a été montré ci-dessus, on a
alors une s-t coupe de D̃ de capacité C − η.
Réciproquement, prenons une s-t coupe de D̃ de capacité minimale κ. D’après ce qui a
été montré, l’ensemble X induit sur D est alors fermé et de valeur C − κ.
On a donc : C −κ = η, et chercher une coupe minimale sur D̃ est équivalent à chercher un
fermé maximum sur D. Comme chercher une coupe minimale se fait en temps polynomial,
on sait résoudre le problème de manière efficace.
Exercice 6.6.3
Dans le cas de la Figure, ce maximum est 4. Pour prouver son optimalité, il suffit de
trouver 4 lignes ou colonnes qui contiennent tous les points. Notons ν la cardinalité maximale
d’une famille P de points tels que deux points quelconques de P ne soient jamais dans la
même ligne ou colonne, et notons τ la cardinalité minimale d’une famille R de lignes ou
colonnes contenant tous les points. On a forcément ν ≤ τ puisque chaque élément de R
contient au plus un élément de P .
Ces ensembles P et R de cardinalité 4 sont indiqués sur la Figure 13.3.
O E
Figure 13.3 – Une solution optimale et une preuve d’optimalité.
Le cas général est polynomial. En effet, ce problème se modélise sous la forme d’un graphe
biparti de la façon suivante :
les sommets sont les lignes d’une part et les colonnes d’autre part, une arête relie la ligne l
et la colonne c s’il y a un point noir à leur intersection. Un ensemble de points tels que deux
points quelconques de l’ensemble soient toujours sur des lignes et des colonnes distinctes
correspond à un couplage dans ce graphe. On recherche donc √ un couplage de cardinalité
maximale dans ce graphe biparti, ce qui peut se faire en O( nm) où n est le nombre de
sommets (ici le demi-périmètre du rectangle), et m le nombre d’arêtes (ici le nombre de
points noirs).
Exercice 7.4.2
Gestion dynamique de stock, cas à 1 seul bien
1. Par définition du processus : ce qui reste dans le stock sur la période t, c’est ce qui
était déjà dans le stock à la période t − 1, plus ce qui a été produit, moins ce qui est parti à
cause de la demande.
2. Aux contraintes décrivant la dynamique du stock, il faut ajouter les contraintes de
capacité xtP≤ Pt et les
PTcontraintes de positivité. La fonction objectif est simplement le
T −1
coût total t=1 pt xt + t=1 st yt . On s’arrête à T − 1 pour le stock car comme on souhaite
minimiser et que les coût de stockage sont positifs, on aura toujours yT = 0.
Le programme linéaire s’écrit donc
PT PT −1
Min t=1 pt xt + t=1 st yt
s.c. xt − yt + yt−1 = dt t = 1, . . . , T
x t ≤ Pt t = 1, . . . , T
xt ≥ 0 t = 1, . . . , T
yt ≥ 0 t = 1, . . . , T − 1.
3. Le coût minimal est 37. Le vecteur de production est x = (8, 1, 3, 1) ou x = (9, 0, 4, 0),
ou n’importe quelle combinaison convexe des deux.
4. En dehors du puits et des sources proposées par l’énoncé, il n’y a pas d’autres sommets.
Il y a deux types d’arcs :
— les arcs (v, wt ), avec une capacité supérieure = Pt , une capacité inférieure = 0 et un
coût = pt et
— les arcs (wt−1 , wt ) avec une supérieure = +∞, une capacité inférieure = 0 et un coût
= st−1 .
Le problème du b-flot de coût minimum est exactement le problème linéaire de la question
2. En particulier, la dynamique correspond à la loi de Kirchoff.
5. Les problèmes de flot de coût min sont des cas particuliers de la programmation
linéaire. Ils possèdent des algorithmes dédiés qui peuvent être plus rapides que les solveurs
généraux de programme linéaire (méthode des cycles de coût moyen minimum, vu en cours
par exemple).
Gestion dynamique de stock, cas à plusieurs biens
6. On a ykt = yk(t−1) + xkt − dkt pour tout k, t.
7. C’est K
P
k=1 zkt ≤ 1 pour tout t.
8. C’est xkt ≤ Pkt zkt pour tout k, t.
9. En reprenant les contraintes déjà identifiées en première partie, et cette nouvelle

contrainte, le problème que l’on cherche à résoudre s’écrit
PK PT PK PT −1
Min k=1 t=1 p kt x kt + k=1 t=1 skt ykt
s.c. xkt − ykt + yk(t−1) = dkt t = 1, . . . , T ; k = 1, . . . , K
xkt ≤ Pkt zkt t = 1, . . . , T ; k = 1, . . . , K
PK
k=1 zkt ≤ 1 t = 1, . . . , T
zkt ∈ {0, 1} t = 1, . . . , T , pour k = 1, . . . , K
xkt ≥ 0 t = 1, . . . , T ; k = 1, . . . , K
ykt ≥ 0 t = 1, . . . , T − 1 ; k = 1, . . . , K.
10. Relâchons les contraintes K T

P
k=1 zkt ≤ 1 et xkt ≤ Pkt zkt . On pose λ ∈ R+ le multipli-
cateur de Lagrange associé aux premières contraintes et µ ∈ RT+K celui associé aux secondes
contraintes.
Avec les notations usuelles on a
PT P P PK PT −1
K T PK PT
G(λ, µ) = − λ
t=1 t + min k=1 p x
t=1 kt kt + k=1 s
t=1 kt kty + k=1 (λ
t=1 t − µ P )z
kt kt kt

zkt ∈ {0, 1} t = 1, . . . , T ; k = 1, . . . , K
xkt ≥ 0 t = 1, . . . , T ; k = 1, . . . , K
ykt ≥ 0 t = 1, . . . , T − 1 ; k = 1, . . . , K,
qui peut se réécrire, puisque les biens ne sont plus couplés

PT PK P PT −1
T PT
G(λ, µ) = − t=1 λt + k=1 min t=1 pkt xkt + t=1 skt ykt + t=1 (λt − µkt Pkt )zkt
zkt ∈ {0, 1} t = 1, . . . , T ; k = 1, . . . , K
xkt ≥ 0 t = 1, . . . , T ; k = 1, . . . , K
ykt ≥ 0 t = 1, . . . , T − 1 ; k = 1, . . . , K.
On veut donc résoudre, en oubliant l’indice k,

P PT −1
T PT
min p x
t=1 t t + s y
t=1 t t + (λ
t=1 t − µ P )z
t t t
s.c. xt − yt + yt−1 = dt pour t = 1, . . . , T

zt ∈ {0, 1} t = 1, . . . , T
xt ≥ 0 t = 1, . . . , T
yt ≥ 0 t = 1, . . . , T − 1.
On remarque qu’à l’optimum on peut choisir zt = 0 si λt − µt Pt ≥ 0 et zt = 1 si

λt − µt Pt < 0.
On veut résoudre finalement, puisque la valeur de zt peut être fixée indépendament de x
et y : P
T PT −1
Min p x
t=1 t t + s y
t=1 t t
s.c. xt − yt + yt−1 = dt t = 1, . . . , T
xt ≥ 0 t = 1, . . . , T
yt ≥ 0 t = 1, . . . , T − 1.
qui est précisément le problème de la première partie, sans les capacités de production. C’est
bien un problème de b-flot.
On sait donc facilement trouver les solutions optimales x∗ , y ∗ et z ∗ qui résolvent G(λ, µ).
On sait calculer les sur-gradients de G (d’après le cours). On sait donc maximiser G et donc
trouver de bonnes bornes inférieures à notre problème de départ. Tout est en place pour un
branch-and-bound.
Exercice 7.4.3
1.
Pn PT
Min i=1 (xi,τ − xi,τ −1 )
τ =1 ci,τ
s.c. xi,τ −1 ≤ xi,τ i ∈ {1, . . . , n} ; τ ∈ {1, . . . , T } (i)
Pn xi,τ ≤ xj,τ i ∈ {1, . . . , n} ; j ∈ Yi ; τ ∈ {1, . . . , T } (ii)
i=1 mi (x i,τ − x i,τ −1 ) ≤ Mτ τ ∈ {1, . . . , T } (iii)
xi,τ ∈ {0, 1} i ∈ {1, . . . , n} ; τ ∈ {0, 1, . . . , T } (iv)
xi,0 = 0 i ∈ {1, . . . , n} (v)
xi,τ − xi,τ −1 vaut 1 si le bloc i est extrait au cours de l’année τ et 0 sinon. La fonction
objectif est donc bien celle attendue. Les contraintes (i) imposent que pour i fixé, la séquence
des xi,τ est de la forme 0, 0, . . . , 0, 1, 1, . . . , 1, comme attendu. Les contraintes (ii) imposent
que si un bloc i est extrait au cours de l’année τ ou avant, alors tout bloc de Yi est extrait au
cours de l’année τ ou avant, conformément à la définition de Yi . Les contraintes (iii) imposent
que la masse totale extraite au cours de l’année τ soit inférieure à Mτ , comme attendu.
P∗
2. ττ 0 =1 Mτ 0 est la masse maximale qui a pu être extraite sur les années de 1 à τ ∗ . Si
la masse de Yi∗ et du bloc i∗ est strictement supérieure, forcément le bloc i∗ ne peut être
extrait au cours de l’année τ ∗ ou avant.
P∗
3. ττ 0 =1 Mτ 0 est la masse maximale qui a pu être extraite au cours des années de 1 à τ ∗ .
Si la masse de Yi∗ ∪ Yj ∗ et des blocs i∗ et j ∗ est strictement supérieure, forcément les blocs
i∗ et j ∗ ne peuvent être extraits tous deux au cours de l’année τ ∗ ou avant.
4. La suppression des variables indicées par des bonnes paires réduit le nombre de variables
du programme linéaire. Cela réduit forcément sa complexité. L’ajout des contraintes induites
par des bons triplets ne changent pas les solutions entières du programme linéaire, mais
diminue la valeur de la relaxation continue, ce qui améliore la qualité de la borne utilisée
dans le branch-and-bound – on est dans un problème de maximisation – et donc réduit
potentiellement le nombre de branchements.
Exercice 8.3.3
Question 2. Supposons que l’on ait une solution optimale S et notons p et g respectivement
le plus petit et le plus gros objets qui soient placés. S’ils ne sont pas mis ensemble dans un
conteneur, notons p0 celui qui est avec g et g 0 celui qui est avec p. On a ap ≤ ap0 et ag0 ≤ ag .
Comme ap0 + ag ≤ 1, on a ap0 + ag0 ≤ 1 et ap + ag ≤ 1. Il existe donc toujours une solution
optimale dans laquelle le plus petit et le plus gros objets placés sont ensemble dans un
conteneur. Par induction, on peut montrer qu’en triant les ai et en cherchant à mettre le
plus petit objet courant avec le plus grand possible, on obtient une solution optimale en
O(n log(n)).
Exercice 9.4.3
Nous proposons dans la suite une modélisation, toute en sachant que plusieurs autres
sont possibles.
1. Notons xij (resp. yij ) la part de la demande du client j desservie par l’entrepôt forward
(resp. reverse) i. Notons ui (resp. vi ) la variable binaire codant l’ouverture d’un entrepôt
forward (resp. reverse) i.
Un programme linéaire possible est alors
P P
Min i∈I (fi ui + ri vi + j∈J cij hj (xij + αj yij ))
P
s.c. Pi∈I xij = hj j∈J
Pi∈I yij = αj hj j∈J
x ≤ bi u i i∈I
Pj∈J ij
j∈J yij ≤ ei vi i∈I
ui , vi ∈ {0, 1} i ∈ I, j ∈ J
xij , yij ∈ R+ i ∈ I, j ∈ J.
Ce programme linéaire est décomposable en deux sous-problèmes indépendants : l’un

avec les xij et ui et l’autre avec les yij et vi .
2. En ajoutant la variable zi qui indique la possibilité de fusionner les deux entrepôts
lorsqu’il sont tous deux ouverts en i, on peut modéliser un gain à la mutualisation de la
manière suivante :
P P
Min i∈I (fi ui + ri vi − si zi + j∈J cij hj (xij + αj yij ))
P
s.c. Pi∈I xij = hj j∈J
i∈I yij = αj hj j∈J
zi ≤ ui i∈I
zPi ≤ vi i∈I
x ≤ bi ui i∈I
Pj∈J ij
j∈J yij ≤ ei vi i∈I
ui , vi ∈ {0, 1} i ∈ I, j ∈ J
xij , yij ∈ R+ i ∈ I, j ∈ J.
En effet, si ui et vi sont tous deux égaux à 1, puisqu’on cherche à minimiser la fonction

objectif, zi sera automatiquement mis à 1. Sinon, zi vaut 0, comme souhaité.
3. Même remarque que dans le cours : une fois les ui et vi fixés, toutes les autres variables
(zi , xij , yij ) sont automatiquement fixées, puisqu’on cherche à minimiser la fonction objectif.
Les xij et yij sont alors le résultat d’un problème de transport sur le graphe biparti complet
avec I et J les deux classes de couleur.
Par conséquent, une façon compacte de coder les solutions consistent à ne considérer que
les couples (u, v) ∈ {0, 1}2|I| . La valeur d’une solution (u, v) s’obtient en mettant zi = 1 dès
que ui = vi = 1 et à résoudre le problème de transport.
On dit que deux solutions (u, v) et (u0 , v 0 ) sont voisines si
u = u0

0
on passe de v à v par une opération drop, add ou swap – définies en cours,
ou
on passe de u à u0 par une opération drop, add ou swap – définies en cours,

v = v0
Avec une telle définion de voisinage, l’espace des solutions est clairement connexe, ce qui
assure qu’une recherche locale potentiellement pourra atteindre la meilleure solution.
Remarque : on peut également faire les opérations simultanément sur u et v, mais alors
il faut démontrer, ce qui n’est pas immédiat, que l’espace des solutions est bien connexe...
4. Cela ne change rien, car les hj , αj hj , bi , ei étant entier, le problème de transport a
forcément une solution entière.
Exercice 9.4.4
1. On introduit la variable xi qui vaut 1 si l’entrepôt i est fermé et 0 sinon. On introduit

également la variable yij qui est la quantité transférée de l’entrepôt i à l’entrepôt j. Le
problème se modélise donc de la manière suivante
Pn Pn
Min i=1P j=1 cij yij
n
s.t. qPj + i=1 yij ≤ 1 j ∈ {1, . . . , n}
n
j=1 ij = qi xi
y i ∈ {1, . . . , n}
yij ≤ 1 − xj i, j ∈ {1, . . . , n}
P n
i=1 xi = k
xi ∈ {0, 1} i ∈ {1, . . . , n}
yij ≥ 0 i, j ∈ {1, . . . , n}.
Pn
2. Le problème a une solution réalisable si et seulement si i=1 qi ≤ n − k : il faut
simplement que la capacité totale lorsque les k entrepôts sont fermés soit suffisante pour
tout accueilir.
3. Ce type de problème se résout à l’optimum avec un branch-and-bound. Le principe

est de procéder implicitement à l’énumération exhaustive de toutes les solutions. Une borne
inférieure, calculée ici par relaxation linéaire, permet d’éviter de calculer la valeur exacte
d’un grand nombre de solutions. Puisque le problème est NP-difficile, on ne peut avoir la
garantie d’avoir la solution en quelques minutes dans tous les cas.
4. Oui, le plus célèbre des logiciels libres étant GLPK (ou GUSEK).
5. Une recherche locale permet d’avoir des solutions raisonnables en un temps d’exécution
court. Cela peut permettre à des décideurs de pouvoir obtenir rapidement des solutions
optimisées.
6. Si on note O les entrepôts ouverts et F les entrepôts fermés, le problème à résoudre

s’écrit
P P
Min c y
Pi∈F j∈O ij ij
s.t. Pi∈F yij ≤ 1 − qj j ∈ O
j∈O yij = qi i∈F
yij ≥ 0 i ∈ F, j ∈ O
On reconnaı̂t un problème du type problème de transport de Monge. Il se résout par la

programmation linéaire. Mieux encore, il peut se résoudre par un algorithme de flot de coût
minimum. Une fois fixés les k entrepôts fermés, le calcul du meilleur transfert est donc très
rapide.
7. L’espace des solutions est donc l’ensemble des F ⊆ {1, . . . , n} avec |F | = k. On définit
F et F 0 comme étant voisins si |F \ F 0 | = |F 0 \ F | = 1. Une telle opération s’appelle opération
de pivot, et rappelle le pivot de l’algorithme du simplexe.
Exercice 9.4.5
1. Prenons un graphe G = (V, E) et construisons l’instance suivante du problème des

ambulances : S = C = V , K ambulances, et tu,v = nombre minimum d’arêtes de u à v. Il y a
un dominant à ≤ K sommets dans G si et seulement si le temps maximum pour le problème
des ambulances associé est = 1. Si le problème des ambulances admettait un algorithme
polynomial, on pourrait alors s’en servir pour tester l’existence en temps polynomial de
dominant de taille ≤ K dans le graphe. Ce qui est impossible, ce dernier problème étant
NP-complet.
2. Considérons une solution optimale au problème des ambulances. On construit alors

de la manière suivante une solution au programme linéaire : ys = 1 s’il y a au moins une
ambulance située en s et ys = 0 sinon ; xs,c = 1 si l’ambulance la plus proche de c est située
en s, et xs,c = 0 sinon. Si plusieurs sites sont les plus proches, on en choisit arbitrairement un.
Enfin, on pose h = temps maximum pour qu’une commune soit atteinte par une ambulance.
Cette solution est une solution réalisable du programme linéaire, et de même valeur du critère
à optimiser.
Réciproquement, soit x, y, h une solution optimale du programme linéaire. On positionne
une (ou plusieurs) ambulance en s si ys = 1. Comme on cherche à minimiser h, h est forcément
égal à maxc∈C mins∈S: xs,c =1 ts,c d’après l’inégalité (iv). Combiné avec (ii), cela indique que
toute les communes peuvent être ralliées en un temps maximum h.
Le problème et le programme linéaire ont donc même valeur optimale et on peut passer
directement d’une solution du problème à une solution du programme linéaire et vice-versa.
3. En notant λs le multiplicateur de Lagrange assiocié à la contrainte (ii), on obtient

X XX
Min h + (−λs )|C|ys + λs xs,c
s∈S s∈S c∈C
X
s.c. ys ≤ K (i)
s∈S
X
xs,c = 1 c∈C (iii)
s∈S
xs,c ∈ {0, 1} s ∈ S ; c ∈ C (v)
ys ∈ {0, 1} s ∈ S (vi)
h ∈ R+ (vii)
4. Les variables y d’une part, et les variables x et h d’autre part sont indépendantes dans
les contraintes du programme linéaire de la question précédente. Quelque soit le choix de y,
on peut fixer x et h indépendament. On optimise donc les deux programmes
XX
min h + λs xs,c
s∈S c∈C
X
s.c. xs,c = 1 c∈C (iii)
s∈S
xs,c ∈ {0, 1} s ∈ S ; c ∈ C (v)
h ∈ R+ (vii)
et X
min (−λs )ys
s∈S
X
s.c. ys ≤ K (i)
s∈S
ys ∈ {0, 1} s ∈ S (vi)
indépendament.
5. Optimiser le deuxième programme est simple : il suffit de trier les s par valeurs de λs
décroissantes ; ensuite on met ys = 1 pour les K premiers s, et ys = 0 pour les suivants.
Complexité O(S log S).
Optimiser le premier programme est presque aussi simple. Noter que les λs sont positifs.
A l’optimum, (iv) est une égalité. On essaie successivement dans h toutes les valeurs de ts,c ,
et pour chacune de ces valeurs, on fait la chose suivante : pour chaque c, on cherche parmi
les ts,c ≤ h celui tel que λs est le plus petit, et c’est ce couple (s, c) pour lequel xs,c = 1.
Pour chacune des SC valeurs de h essayées, on obtient une valeur de la fonction objectif ;
on garde alors la plus petite. Complexité O(S 2 C 2 ).
6. Avec les notations de cours, pour tout λ ∈ RS , on sait calculer G(λ) et ses surgradients
en O(S 2 C 2 ) (donc rapidement), et donc optimiser par un algorithme de surgradient G(λ),
fournissant ainsi des bornes au programme linéaire en nombres entiers.
Exercice 10.4.3
Les deux premières questions sont triviales. Pour la dernière, notons pj la durée de la
tâche j. Sans perte de généralité, supposons que les tâches sont ordonnées de manière à ce
que
w1 w2 wn
≥ ≥ ... ≥ .
p1 p2 pn
Prenons maintenant un ordonnancement quelconque et supposons qu’il y ait une tâche j et
w w 0
suivie d’une tâche j 0 telles que pjj ≤ p j0 . En inversant l’ordre de ces deux tâches, on ajoute
j
à la fonction objectif la quantité wj pj 0 − wj 0 pj qui est négative ou nulle. Un ordonnancement
optimal est donc obtenu en ordonnant les tâches dans l’ordre de leur indexation.
Exercice 10.4.8
Si on voit les entrepôts D et C comme des machines, les camions comme des tâches,
et le déchargement et le chargement comme des opérations, on est exactement dans le cas
d’un problème de flow-shop à 2 machines, 15 tâches et minimisation du makespan, ce qui se
résout en temps polynomial (et même à la main) par l’algorithme de Johnson. Les durées
des opérations sont données par le temps qu’il faut pour décharger ou charger les boı̂tes.
Ici la solution est de 91 minutes. On terminera donc au plus tôt à 7h31.
Exercice 11.3.7
Conformément à ce qui a été ajouté à l’oral, on suppose les coûts positifs.
1. Pour (X, v) tels que v ∈ X ⊆ V \ {s}, on note π(X, v) le coût minimum d’une chaı̂ne
élémentaire dont les sommets sont {s} ∪ X et dont les extrémités sont s et v. On a alors

c(sv) si |X| = 1
π(X, v) =
minu∈X\{v} (π(X \ {v}, u) + c(uv)) sinon.
Pour trouver la meilleure chaı̂ne hamiltonienne d’extrémité s, il suffit alors de comparer les
valeurs de π(V, v) pour tout v ∈ V (les coûts étant positifs, on n’a pas intérêt à revenir en
s).
2. C’est le nombre de couples (X, v) comme dans l’énoncé. Il y en a
n−1
n−1
X
k = (n − 1)2n−2 .
k=1
k
3. Pour chaque état (X, v), le nombre d’additions est |X| − 1 (nombre de u possibles dans
l’équation de programmation dynamique). D’où un nombre d’opérations
n−1
n−1
X
k(k − 1) = (n − 1)(n − 2)2n−3 .
k=1
k
√ n
Enumérer toutes les solutions donne un nombre d’additions (n−1)!(n−1) ∼ n! ∼ 2πn ne ,
ce qui est incomparablement plus grand.
4. Pour n = 15, on compte 7450 472 opérations, ce qui se fait en moins d’une seconde.
Pour n = 30, on compte 1.09 × 1011 opérations, ce qui se fait en 1.09 × 105 secondes, soit
environ 30 heures. On ne peut résoudre cette instance en 1 jour, mais en une semaine oui.
Pour n = 45, on compte 8.32 × 1015 opérations, ce qui fait 8.32 × 109 secondes, soit
environ 263 années. Même en un siècle on ne parvient à résoudre cette instance.
5. On sait calculer la plus courte chaı̂ne hamiltonienne de s à v, pour tout v ∈
/ V . Il suffit
alors de comparer les valeurs de π(V, v) + c(vs) pour tout v.
Exercice 12.5.1
C’est une application directe de l’algorithme de Kruskal, qui détermine l’arbre couvrant
de plus petit poids. Il y a plusieurs arbres possibles. L’un est donné Figure 13.4. Le coût
optimal est 35.
Exercice 12.5.9
P P
1. L(x, λ) = e∈E ce xe + λ x
e∈δ(p) e − s .
2. A λ fixé, on cherche à trouver l’arbre couvrant du graphe K de plus petit coût avec comme
coût ce sur l’arête e si e ∈/ δ(p) et ce + λ si e ∈ δ(p). L’algorithme de Kruskal résout cela en
temps polynomial.
3. On a alors e∈δ(p) x0e − s ≤ 0. Donc

P
 
X X X
G(0) = ce x0e ≥ ce x0e + λ  x0e − s ≥ min L(x, λ) = G(λ).
x∈X
e∈E e∈E e∈δ(p)
Château d’eau
1
4 4
2 2 2 4
2 1
1
2 1 2 2
7
1
2
6
1 2 2
1
1 4
4 4
4 4
5 1 2
Figure 13.4
Par ailleurs, x0 est un arbre couvrant, satisfaisant les contraintes de l’énoncé et dont le coût
est égal à G(0) borne inférieure du problème. C’est donc une solution optimale pour notre
problème.
4. Quand λ varie, xλ ne change que lorsque l’ordre obtenu en classant les arêtes par coûts
croissants change (algorithme de Kruskal). Cet ordre ne peut changer que lorsque une arête
f ∈ δ(p) voit son coût coı̈ncider avec celui d’une arête e ∈
/ δ(p), ce qui ne peut arriver que
si λ est de la forme donnée dans l’énoncé. On a alors N ≤ 21 |T |2 (|T | − 1) (en comptant le
nombre de tels couples d’arêtes (e, f )). On peut maximiser G(λ) en appliquant au plus N
fois l’algorithme de Kruskal.
5. Si λ < λi , on a e∈δ(p) xλe > s. Donc, pour tout µ < λ, on a

P
   
X X X X
G(λ) = ce xλe + λ  xλe − s ≥ ce xλe + µ  xλe − s ≥ min L(x, µ) = G(µ).
x∈X
e∈E e∈δ(p) e∈E e∈δ(p)
Avec ce raisonnement, on montre que G(λ) est croissant jusqu’à λi . Comme G(λ) est continue
P suffit en fait), on peut conclure que G(λ) ≤ G(λi ).
(ou concave – cela
Par ailleurs, e∈δ(p) xλe i − s ≤ 0 et donc on a pour tout λ ≥ λi
   
X X X X
G(λi ) = ce xλe i +λi  xλe i − s ≥ ce xλe i +λ  xλe i − s ≥ min L(x, λ) = G(λ).
x∈X
e∈E e∈δ(p) e∈E e∈δ(p)
Avec ce raisonnement, on montre que G(λ) ≤ G(λi ).
6. Si xλi est de degré s en p, il n’y a rien à montrer. Supposons donc que ce ne soit pas le
cas. Pour λ légèrement inférieur à λi , le degré de xλ en p est > s. Notons que xλ et xλi
sont tous deux solutions du problème de minimisation de G(λi ). Ensuite, il faut remarquer
que si on a deux arbres couvrant optimaux d’un graphe pondéré, on peut progressivement
substituer les arêtes de l’un par les arêtes de l’autre, tout en maintenant le caractère optimal.
En procédant à une telle transformation de xλ à xλi , l’un des arbres intermédiaires constitue
une solution à la question.
7. Comme G(λi ) = L(x∗ , λi ) et que le degré de x∗ en p est égal à s, on a G(λi ) = e∈E ce x∗e .
P
Par ailleurs La solution x∗ est une solution réalisable à notre problème, et dont le coût
coı̈ncide avec celui d’une borne inférieure (en l’occurence G(λi )). C’est donc une solution
optimale.
Bibliographie
[1] R.K. Ahuja, T.I. Magnanti, and J.B. Orlin, Network flows, Prentice Hall, 1993.
[2] V. Arya, N. Garg, R. Khandekar, A. Meyerson, K. Mungala, and V. Pandit, Local search
heuristics for k-median and facility location problems, SIAM Journal on Computing 33
(2004), 544–562.
[3] P. Brucker, An efficient algorithm for the job-shop problem with two jobs, Computing
40 (1988), 353–359.
[4] V. Chvátal, Linear programming, W. H. Freeman, New York, 1983.
[5] R. Correa and C. Lemarechal, Convergence of some algorithms for convex minimization,
Mathematical Programming 62 (1993), 261–275.
[6] D. de Werra, T. M. Liebling, and Hêche J.-F., Recherche opérationnelle pour ingénieurs,
Presses polytechniques et universitaires romandes, 2003.
[7] S.E. Dreyfus and R.A. Wagner, The Steiner problem in graphs, Networks (1972), 195–
207.
[8] J. Edmonds and R.M. Karp, Theoretical improvements in algorithmic efficiency for
network flow problems, Journal of the ACM 19 (1972), 248–264.
[9] D. Gale and L.S. Shapley, College admissions and the stability of marriage, American
Mathematical Monthly (1962), 9–15.
[10] M.R. Garey and D.S. Johson, Computers and intractability : A guide to the theory of
np-completness.
[11] A. V. Goldberg, Scaling algorithms for the shortest paths problem, SIAM Journal on
Computing 24 (1995), 222–231.
[12] A.V. Goldberg and R.E. Tarjan, Finding minimum-cost circulations by cancelling ne-
gative cycles, Journal of the ACM 36 (1985), 873–886.
[13] M. Grötchel, L. Lovász, and L. Schrijver, Geometric algorithms and combinatorial op-
timization, 2nd edition, Springer, Heidelberg, 1994.
[14] B. Hajek, Cooling schedules for optimal annealing, Mathematics of Operations Research
13 (1991), 311–329.
BIBLIOGRAPHIE 198
[15] A. Hertz and D. De Werra, Using tabu search techniques for graph coloring, Computing
39 (1987), 345–351.
[16] J.R. Jackson, Scheduling a production line to minimize maximum tardiness, Tech. re-
port, University of California, Los Angeles, 1955.
[17] S.M. Jonson, Optimal two- and three-stage production schedules with setup times inclu-
ded, Naval Res. Log. Quart 1 (1954), 61–68.
[18] R.M. Karp, A characterization of the minimum cycle mean in a digraph, Discrete Ma-
thematics 23 (1978), 309–311.
[19] Kuhn, (1955).
[20] S. Lin and B.W. Kernighan, An effective heuristic algorithm for the traveling-salesman
problem, Operations Research 21 (1973), 498–516.
[21] J. Matousek and B. Gärtner, Understanding and using linear programming, Sringer,
Berlin Heidelberg New York, 2007.
[22] T. Terlaky, An easy way to teach interior-point methods, European Journal of Opera-
tional Research 130 (2001), 1–19.
Annexe
199
Quelques outils de R.O.
Quelques sociétés
Roadef (www.roadef.org) : société francaise de recherche opérationnelle et d’aide à la décision.
Euro (www.euro-online.org) : associations européennes des sociétés de recherche opérationnelle.
Informs (www.informs.org) : Institute for Operations Research and the Management Sciences.
C’est la plus grande société professionnelle dans le domaine de la recherche opérationnelle.
Ressources en ligne
— 24h Operations research.
— Une liste d’outils open-source logiciels pour la Recherche Opérationnelle : NEOS :
Server for optimisation (http ://www-neos.mcs.anl.gov) Propose des serveurs de logiciel
R.O utilisables en ligne via des formats de modélisation standard (AMPL, ...)
— Outils par ordre alphabétique COIN-OR (http ://www.coin-or.org/) COmputational
INfrastructure for Operations Research Projet Open source, ambitieux, d’origine IBM
(C++).
— COMET (http ://www.cs.brown.edu/people/pvh/comet/comet.html) COMET est une
platforme associant la recherche local et la programmation par contrainte. COMET
s’appuit sur un langage objet et peut être étendu (création de contraintes...) en C++.
— GLPK (http ://www.gnu.org/software/glpk/) : La bibliothèque Glpk est livrée avec
un solveur autonome (glpsol), capable de traiter des problèmes linéaires (continus ou
en nombre entier) par des méthodes de simplexe ou de Points Intérieur. Ces problèmes
peuvent être modélisés dans différents langages, dont l’excellent GMPL (clone de
AMPL).
— Page RO de Google (http ://code.google.com/p/or-tools/) : Google a développé pour
ses besoins propres un certain nombre d’outils de recherche opérationnelle. Sur ce site,
ils sont proposés en open-source.
— GUSEK (http ://gusek.sourceforge.net/gusek.html) : le solveur GLPK avec une inter-
face ; pour Windows.
BIBLIOGRAPHIE 202
— Graphviz (http ://www.graphviz.org/) : Logiciel permettant d’afficher automatique-

ment un graphe à partir de formats de description textuels simples.
— LP Solve (http ://groups.yahoo.com/group/lp solve/) : autre solveur de programma-
tion linéaire.
— LocalSolver (http ://www.localsolver.com/) : solveur permettant de modéliser et résoudre
des problèmes d’optimisation discrète par recherche locale ; développé par l’e-lab de
Bouygues.
— Operations Research - Java object (http ://OpsResearch.com/OR-Objects) Librairie
JAVA pour (petits) problèmes de R.O. Utilisation gratuite, mais sources non acces-
sibles. Ne semble plus maintenue, mais reste intéressante pour les API.
— QSopt-Exact Home Page (http ://www.dii.uchile.cl/ daespino/) Solveur linéaire avec
calculs exacts (car rationnels), basé sur la librairie GMP (Gnu Multi Precision)
— TSP (http ://www.tsp.gatech.edu/index.html) : le site de référence sur le TSP. De la
documentation, des solveurs, interfaces, jeux, etc.
— SCILAB(http ://www.scilab.org/) : L’environnement de calcul scientifique open-source
de référence.
— SCIP (http ://scip.zib.de/doc/html/index.html) : Peut-être un des meilleurs logiciels
libres actuels. Il possède de plus une librairie permettant une implémentation simple
des branch-and-cuts.
Quelques SSII spécialisées dans la RO
— Artelys (http ://www.artelys.com/) Société spécialisée en optimisation - formation. Par

ailleurs, Artelys propose désormais Artelys Kalis un environnement (librairie C++ ou
java) de Programmation par Contraintes exploitable avec le langage de modélisation
Xpress-Mosel.
— Eurodécision (http ://www.eurodecision.com) réalise des applications d’aide à la décision
par intégration de technologies d’optimisation et de simulation. Les principaux do-
maines d’application sont : la logistique, les ressources humaines, la production, le
transport, les achats, les télécommunications.
— FuturMaster (http ://www.FuturMaster.com) FuturMaster accompagne ses clients dans
leur démarche d’amélioration de leurs performances logistiques en leur offrant des solu-
tions logicielles pertinentes, évolutives et réactives, pour suivre les changements internes
et externes de l’entreprise.
— Rostudel (http ://www.rostudel.com/) C’est une toute jeune entreprise (fondée par un
ancien élève de l’école des ponts) qui propose des prestations de conseil en recherche
opérationnelle.
203 BIBLIOGRAPHIE
Quelques sociétés éditrices de logiciels de RO

— Amadeus (http ://www.amadeus.com) : propose des solutions d’optimisation dans l’in-
dustrie du voyage et du tourisme.
— Dash optimization (http ://www.dash.co.uk/) : propose l’outil Xpress-MP.
— Equitime (http ://www.equitime.fr/) : propose des logiciels d’optimisation d’emplois
du temps.
— Gower Optimal Algorithms Ltd (http ://www.packyourcontainer.com/index.htm) : op-
timisation de la logistique.
— ILOG (http ://www.ilog.fr/products/optimization) Propose des outils de référence
dans le domaine de l’optimisation comme ILOG/Cplex pour la programmation linéaire
et quadratique et ILOG/CP pour la Programmation par contraintes.
— INRO (http ://www.inro.ca/fr/produits/) : L’INRO est spécialisée dans les logiciels de
planification des transports : EMME/2 et Dynameq.
— KLS Optim (http ://www.klsoptim.com/) : spécialisée dans l’optimisation des plans
de chargement (packing).
— Koalog (http ://www.koalog.com/php/jcs.php) : Cette société française propose entre
autre un Solveur par contraintes écrit 100% en java, avec formation... Une application
permettant le choix d’une configuration d’options d’automobile.
— LoadPlanner (http ://www.loadplanner.com/) : spécialisée dans l’optimisation des
plans de chargement (packing).
— Opti-time (http ://www.opti-time.com) : spécialisée dans l’optimisation de tournées.
Logiciel phare TourSolver.
— Ortec (http ://fr.ortec.com/solutions/lb.aspx : spécialisée dans l’optimisation des plans
de chargement (packing) et des tournées.
— Routing International (http ://www.routing-international.com/index.html) : spécialisée
dans l’optimisation de tournées. Logiciel phare : WinRoute.
Entreprises françaises ayant des départements avec compétences en RO

EDF, SNCF, Bouygues, Renault, ENGIE, Saint-Gobain, Air Liquide, France Telecom,
Air France, Véolia, la Poste, l’Armée de Terre, la Marine, ...
Quelques solveurs de programmation linéaire

Payants : GUROBI, CPLEX, XPRESS, MINOS
Libres : GLPK, LPSOLVE, CLP, SCIP, SOPLEX
En général, ces solveurs peuvent résoudre bien d’autres types de programmes mathématiques.
BIBLIOGRAPHIE 204
Un solveur basé sur de la recherche locale

LocalSolver (payant).
Quelques langages de modélisation

AMPL, APL, OPL, TOMLAB, ...

CoursROPonts PDF

Transféré par

Droits d'auteur :

Formats disponibles

CoursROPonts PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CoursROPonts PDF

Transféré par

Droits d'auteur :

Formats disponibles

Frédéric Meunier

3 Plus courts chemins et programmation dynamique 29

6 Graphes bipartis : problème d’affectation, problème de transport, mariages

7 Que faire face à un problème difficile ? 89

9 Positionnement d’entrepôts 115

10 Ordonnancement industriel 125

12 Conception de réseaux 159

12.4 Quelques remarques pour finir . . . . . . . . . . . . . . . . . . . . . . . . . . 167

Figure 1.1 – Königsberg et ses 7 ponts

nus en prédictions ou opérations dans le monde réel.

certaine pondération, ce qui revient in fine à un vrai problème d’optimisation ; ou alors de

2.1.1 Graphe non-orienté

parties n’induisant chacune aucune arête. Voir exemple Figure 2.3.

Chaı̂ne, cycle, connexité

où k est un entier ≥ 0, vi ∈ V pour i = 0, . . . , k et ej ∈ E pour j = 1, . . . , k avec ej = vj−1 vj .

Figure 2.2 – Exemple de graphe complet.

Figure 2.3 – Exemple de graphe biparti.

2.1.2 Graphe orienté

où k est une entier ≥ 0, vi ∈ V pour i = 0, . . . , k et aj ∈ A pour j = 1, . . . , k avec

2.2 Retour sur les ponts et sur le voyageur

d(uv) + d(vw) ≥ d(uw) pour tous sommets u, v, w.

On cherche le cycle hamiltonien de Kn le plus court pour la fonction de poids d.

Dans le cas orienté, la condition nécessaire et suffisante d’existence de chemin ou circuit

Théorème 2.2. Un graphe faiblement connexe admet un chemin eulérien si et seulement si

2.3.2 Borne et solution approchée

Graphe coloré avec 5 couleurs

Figure 2.8 – Peut-on colorer proprement ce graphe avec moins de 5 couleurs ?

2.3.3 Optimisation continue vs optimisation discrète

2.3.4 Programmation linéaire, programmation convexe

Figure 2.9 – Peut-on trouver un couplage de plus de 3 arêtes ?

avec X 6= ∅, f : X → R, g : X → Rp et h : X → Rq . Comme l’ensemble des so-

2.3.5 Lagrangien et dualité faible

On peut donc réécrire l’équation (P ) de la manière suivante

inf sup L(x, λ, µ) ≥ sup min L(x, λ, µ). (2.1)

on peut regarder le programme mathématique appelé dual de (P )

(P) est alors appelé programme primal.

Problème de la chaı̂ne eulérienne

Celui du voyageur de commerce :

Problème du voyageur de commerce

Donnée : Un graphe complet Kn = (V, E) et une fonction de distance d : E → R+ (qui

Tâche : Trouver le cycle hamiltonien C = v0 , e1 , . . . , en , v0 minimisant nj=1 d(ej ).

2.5 Algorithme et complexité

2.5.1 Algorithme, algorithme exact, algorithme approché

2.5.2 Question de l’efficacité

2.5.3 De l’intérêt de la théorie pour sauver son boulot

Table 2.1 – Comparaison de diverses fonctions de complexité pour un ordinateur effectuant

2.5.4 Notions de base en théorie de la complexité ou comment gagner 1 million de $

Taille de l’instance la plus large que l’on peut résoudre en 1 heure

Table 2.2 – Comparaison de diverses fonctions de complexité.

Considérons le problème suivant.

Problème du cycle eulérien

Problème de la chaı̂ne eulérienne

Considérons maintenant le problème suivant.

Problème du cycle hamiltonien

De même le problème suivant est NP-complet.

Problème de la chaı̂ne hamiltonienne

Résultats de complexité pour des parcours.

La Figure 2.10 illustre les relations entre problèmes P, NP, NP-complets, si P 6= NP

Figure 2.10 – Les problèmes NP