Master 1 D'informatique 2010 / 2011 Recherche Opérationnelle

Master 1 d’Informatique Recherche Opérationnelle
2010 / 2011
TD no 1
Généralités sur les graphes
Exercice 1 Soit G = (V, E) un graphe.

(a) Si G est orienté : |E| = ∑x∈V δ − (x) = ∑x∈V δ + (x).
(b) Si G est non orienté : ∑x∈V δ (x) = 2|E|. En particulier, les sommets de G de degré impair
sont en nombre pair.
Exercice 2 Dans un graphe non orienté, il y a toujours deux sommets de même degré.
Exercice 3 Le complémentaire d’un graphe non orienté G est le graphe G défini par : V (G) =
V (G) et ∀x, y ∈ V (G), (x, y) ∈ E(G) ssi (x, y) ∈
/ E(G). Prouver ou infirmer les assertions sui-
vantes :
(a) Deux graphes sont isomorphes ssi leurs complémentaires sont isomorphes.
(b) Si G est non connexe alors G est connexe.
(c) Si G est connexe alors G est non connexe.
Exercice 4 (a) Quels sont ceux des graphes suivants qui sont isomorphes ?
(b) Combien il y a-t-il de graphes non orientés sur un ensemble fixé de 4 sommets ? Combien il
y en a-t-il à isomorphisme près ? Lesquels ?
Exercice 5 Prouver le Lemme 4.
Exercice 6 G est connexe ssi pour toute bipartition (X,Y ) de V (G), il existe une arête ayant une
extrémité dans X et l’autre dans Y .
Exercice 7 Vrai ou faux ? Si chaque sommet d’un graphe non orienté G est de degré 2 alors G
est un cycle.
Exercice 8 Un sommet x d’un graphe non orienté connexe G est dit point d’articulation de G
si G − x est non connexe. Montrer que tout graphe connexe contient au moins deux sommets qui
ne sont pas points d’articulation.
Exercice 9 On définit inductivement une classe de graphes non orientés C par :
1
1. tout sommet isolé est dans C ;
2. si G ∈ C , tout graphe H obtenu en ajoutant à G un sommet x et une ou plusieurs arêtes
adjacentes à x est dans C .
Montrer que C est exactement la classe des graphes connexes. En déduire une nouvelle preuve
de la Proposition 5 (G connexe ⇒ |E(G)| ≥ |V (G)| − 1).
Exercice 10 Un graphe non orienté G est dit biparti s’il existe une partition de V (G) en deux
ensembles X et Y telle que tout arête de G joint un sommet de X à un sommet de Y . Montrer que
G est biparti ssi G ne contient aucun cycle de longueur impaire.
Exercice 11 Tout graphe non orienté connexe admet un sous-graphe couvrant connexe et acy-
clique (appelé arbre couvrant du graphe). Par conséquent, tout graphe non orienté admet un
sous-graphe couvrant acyclique (appelé forêt couvrante du graphe).
Exercice 12 Combien existe-t-il de graphes orientés (resp. non orientés) à n sommets ?
Exercice 13 Montrer que le nombre d’arbres sur un ensemble fixé de n sommets est nn−2 .
Exercice 14 (Connectivité de sous-graphes et d’extensions de graphes). On désigne par ω(G)

la connectivité d’un graphe non orienté G, c’est à dire le nombre de ses composantes connexes.
En particulier, G est connexe ssi ω(G) = 1. Soient G = (V, E) un GNO et I un ensemble de paires
de sommets de G. Prouver les assertions suivantes :
1. ω(G) ≥ ω(G + I) ≥ ω(G) − |I|.
2. ω(G) ≤ ω(G − I) ≤ ω(G) + |I|.
3. Si ω(G − e) > ω(G) pour tout e ∈ I, alors ω(G − I) = ω(G) + |I|.
4. ω(G) ≥ |V | − |E|.
5. G est acyclique ssi ω(G) = |V | − |E|.
Exercice 15 Prouver le Lemme 8.
Exercice 16 Prouver la Proposition 10.
Exercice 17 Quand on utilise la représentation par matrice d’adjacence, la plupart des algo-
rithmes sur les graphes à n sommets s’exécutent en O(n2 ), mais il y a des exceptions. Montrer
qu’il est possible de déterminer en O(n) si un graphe orienté contient un trou noir – un sommet
de degré entrant n − 1 et de degré sortant 0 –, même si on utilise une représentation par matrice
d’adjacence.
Exercice 18 Soit G un graphe non orienté. Montrer que G est un cycle ssi G est non acyclique
minimal.
2
2010 / 2011
Corrigé du TD no 1
Généralités sur les graphes
Correction exercice 1.
(a) Clairement, E = x∈V Entrants(x) = x∈V Sortants(x). Comme les ensembles d’arcs Entrants(x)
S S
(resp. Sortants(x)), x ∈ V , sont deux à deux disjoints : |E| = ∑x∈V |Entrants(x)| = ∑x∈V |Sortants(x)|.
C’est le résultat cherché.
(b) Si H est une orientation du graphe non orienté G, on a clairement : |E(G)| = |E(H)|, soit,
d’après ce qui précède :
1 1 1
|E(G)| = ( ∑ δH− (x) + ∑ δH+ (x)) = ∑ δH (x) = ∑ δG(x).
2 x∈V (H) x∈V (H)
2 x∈V (H)
2 x∈V (G)
Correction exercice 2. Soit G un graphe non orienté à n sommets. Soit D l’ensemble des
degrés des sommets de G. Puisque chaque sommet est relié à au plus n − 1 autres sommets,
D ⊆ {0, . . . , n − 1}. Si par ailleurs les degrés sont deux à deux distincts, D est de cardinal n et
donc, nécessairement, D = {0, . . . , n − 1}. Mais G ne peut contenir simultanément un sommet de
degré 0 et un sommet de degré n − 1, puisque un sommet de degré n − 1 est relié à tous les autres
sommets du graphe. Donc |D| < n et deux sommets au moins ont même degré.
(a) Clair : tout isomorphisme h de G sur H est aussi un isomorphisme de G sur H puisque :
(x, y) ∈ V (G) ssi (x, y) ∈
/ V (G) ssi (x, y) ∈
/ V (H) ssi (x, y) ∈ V (H).
(b) Supposons donc G non connexe. Soient x, y deux sommets de V (G) = V (G). Si x, y sont
dans deux composantes connexes distinctes de G, alors (x, y) ∈ / E(G) donc (x, y) ∈ E(G) et
ces sommets sont connectés dans G. Si x, y sont dans une même composante connexe de G,
soit z un sommet appartenant à une autre composante connexe de G (un tel sommet existe
puisque G est non connexe). Alors, par le même raisonnement que précédemment, (x, z) et
(y, z) sont deux arêtes de G, donc x et y sont connectés dans G par le chemin xzy.
(c) Cette assertion est fausse : le graphe G = ({1, 2, 3, 4}, {{1, 2}, {2, 3}, {3, 4}}) et son com-
plémentaire sont tous les deux connexes.
3
(a) Désignons par G1 , G2 , G3 , G4 les quatre graphes représentés de gauche à droite. Il est facile
de voir que G1 , G2 et G4 ont tous pour complémentaire une union de deux triangles. Ces
trois graphes sont donc isomorphes, en vertu du (a) de l’exercice 3. Par contre G3 contient
un triangle, ce qui n’est pas le cas de G1 . Donc ces G3 n’est pas isomorphe à G1 (ni à G2 ou
G4 ).
n!
(b) Dans un graphe non orienté à n sommets, il y a Cn2 = 2!(n−2)! paires de sommets. Chacune
2
de ces paires peut constituer ou ne pas constituer une arête du graphe. Ce qui donne 2Cn
graphes possibles sur un ensemble fixé de n sommets. Pour n = 4 on obtient 26 = 64 graphes
possibles. Ces graphes se répartissent dans les 11 classes d’isomorphismes suivantes :
Correction exercice 5. Récurrence sur la longueur k du chemin : L’hypothèse est claire pour
k = 1 : tout chemin de longueur 1 est élémentaire. Supposons l’hypothèse de récurrence vé-
rifiée par tout chemin de longueur inférieure à un k fixé. Soit p = x0 a1 x1 . . . ak+1 xk+1 un che-
min de longueur k + 1. Si p n’est pas élémentaire, soit i l’indice du premier sommet interne
de p qui admet plusieurs occurences dans p. Soit j le plus petit indice tel que x j = xi . Alors
p0 = x0 a1 x1 . . . ai xi a j+1 x j+1 . . . ak+1 xk+1 est un chemin entre x0 et xk+1 de longueur inférieure à
k. Par hypothèse de récurrence, il existe un chemin élémentaire entre x0 et xk+1 .
Correction exercice 6. ⇒ : Soient (U,V ) la bipartition de V (G), u ∈ U, v ∈ V . Soit p :

x0 x1 . . . xk−1 xk un chemin de u = x0 à v = xk (dont l’existence est garantie par la connexité de
G). On note i le plus grand indice des sommets de p appartenant à U. Alors i < k (puisque xk ∈ V
et V ∩U = ∅) et xi+1 ∈ / U (par maximalité de i). Donc xi+1 ∈ V et (xi , xi+1 ) est l’arête cherchée.
⇐ : Soit U une composante connexe de G. Si U est unique, le graphe est connexe. Sinon,
(U, ¬U) constitue une bipartition non triviale de V (G) et donc il existe une arête qui traverse
(U, ¬U) : une contradiction.
Correction exercice 7. Faux : prendre un graphe constitué de deux cycles disjoints. Montrons
que la bonne assertion est : si chaque sommet d’un graphe non orienté G est de degré 2 alors
G est une union de cycles élémentaires. Il revient au même de prouver que tout graphe connexe
dont tous les sommets sont de degré 2 est un cycle élémentaire. Soit donc G un tel graphe. Par
le Lemme 2, G contient un cycle et donc, un cycle élémentaire p (Lemme 4). Ce cycle couvre
nécessairement tous les sommets de G : sinon, il existerait une arête a entre V (p) et V (G) −V (p)
(par connexité de G et grâce à l’exercice 6), et l’extrémité x de a qui est sur p serait adjacente
à 3 sommets (ses 2 voisins dans p et l’autre extrémité de a), ce qui contredirait l’hypothèse
δ (x) = 2. Enfin, G ne contient aucune arête autre que celles intervenant dans p, toujours grâce
4
à l’hypothèse sur les degrés. Par conséquent, G = p. (Notons qu’on a même : tout sommet de G
est de degré 2 ssi G est une union de cycles élémentaires.)
Correction exercice 8. Commençons par introduire quelques définitions : si p : x y et q :

p q
y z sont deux chemins partageant une même extrémité y, on note pq le chemin x y
z. Un chemin p est un sous-chemin d’un chemin q s’il existe deux chemins p1 , p2 tels que
q = p1 p p2 . Un chemin est maximal s’il n’est sous-chemin propre d’aucun chemin. Si p est un
chemin élémentaire et si x, y sont deux sommets apparaissant dans cet ordre dans p, on note
p[x, y] l’unique sous-chemin de p d’extrémités x et y.
Considérons l’extrémité u d’un chemin élémentaire maximal p0 de G. Tout sommet v adja-
cent à u est sur p0 (sinon on pourrait prolonger p0 ). Soient x, y ∈ V (G) et p : x y un chemin
élémentaire de x à y dans G. Si p ne contient pas u, alors p est aussi un chemin élémentaire de
x à y dans G − u. Si p contient u, notons α et β le prédécesseur et le successeur de u dans p.
D’après ce qui précède, α et β sont sur p0 . De plus, u ∈ / p0 [α, β ], puisque u est une extrémité
de p0 . Donc le chemin obtenu à partir de p en remplaçant le sous-chemin p[α, β ] = αuβ par le
chemin p0 [α, β ] est un chemin de x à y qui ne contient pas u. Autrement dit, c’est un chemin de
x à y dans G − u. On a ainsi montré que deux sommets distincts de u connectés dans G sont aussi
connectés dans G − u. Comme G est connexe, on en déduit que G − u est connexe : u n’est pas
un point d’articulation de G. Par symmétrie, il en va de même pour l’autre extrémité de p0 , ce
qui finit de prouver le résultat annoncé.
Correction exercice 9. Il est clair que C est inclu dans la classe des graphes connexes : tout
sommet isolé est connexe et, si G est connexe, les graphes obtenus à partir de G par application de
la règle de construction décrite en 2 sont aussi connexes. Montrons qu’inversement, tout graphe
connexe G est dans C : c’est clair si G est un sommet isolé. Supposons le résultat vérifié pour tout
graphe à au plus n sommets, pour un entier n fixé. Soit G un graphe connexe à n + 1 sommets.
D’après l’exercice 8, il existe un sommet u de G qui n’est pas point d’articulation. Par conséquent,
G − u est un graphe connexe à n sommets et donc, par hypothèse de récurrence, G − u ∈ C .
Comme G est obtenu à partir de G − u par adjonction du sommet u et des arêtes de Incid(u), G
est lui-même dans C .
Application : si G est connexe, alors |E(G)| ≥ |V (G)| − 1. Le résultat est clair pour les som-
mets isolés. S’il est vrai pour un graphe connexe fixé G, il l’est pour tout graphe H obtenu
à partir de G par application de la règle 2 puisque, selon cette règle, |V (H)| = |V (G)| + 1 et
|E(H)| ≥ |E(G)| + 1.
Correction exercice 10. L’implication ⇒ est claire : tout chemin de longueur impaire dans
le graphe (X,Y )-biparti a nécessairement une extrémité dans X et l’autre dans Y . Ça ne peut
donc pas être un cycle. Réciproquement, supposons que G ne contienne aucun cycle de longueur
impaire et montrons que G est biparti. Notons tout d’abord qu’un graphe est biparti ssi chacune
de ses composantes connexes non triviales est biparti. Soit donc H une composante connexe non
triviale de G et u un sommet de H. Pour tout x ∈ V (H), on note d(x) la longueur d’un plus court
chemin entre x et u. (Comme H est connexe, d est bien définie sur tout x ∈ V (H).) Notons alors
5
X = {x ∈ V (H) : d(x) est pair} et Y = {x ∈ V (H) : d(x) est impair}. Soient a = {x, y} ∈ E(H) et
p q−1 a
p (resp. q) un plus court chemin de x (resp. y) à u. Alors x u y → x est un cycle de longueur
|p| + |q| + 1 = d(x) + d(y) + 1. Ce cycle étant de longueur paire (par hypothèse), d(x) et d(y)
sont de parités opposées. Autrement dit, les extrémités de a ne sont pas simultanément dans X
ou dans Y : H est (X,Y )-biparti.
1ère méthode. Soient G un graphe connexe L’ensemble des sous-graphes couvrant et connexes
de G est non vide : il contient G. Soit T un sous-graphe couvrant connexe de G, minimal pour le
nombre d’arêtes. Pour toute a ∈ E(T ), T − a est un sous-graphe couvrant de G comportant moins
d’arête que T . Il est donc non connexe, par hypothèse de minimalité sur T . Ainsi, la suppression
d’un arête quelconque du graphe connexe T le déconnecte : T est un arbre (Théorème 7-(??)) et
donc un arbre couvrant de G.
2ème méthode. Soient G un graphe connexe. L’ensemble des sous-graphes couvrant et acy-
cliques de G est non vide : il contient (V (G), ∅). Soit T un sous-graphe couvrant acyclique
maximal de G. Montrons par l’absurde que T est connexe : si tel n’est pas le cas, T comporte
une composante connexe H telle que V (H) 6= V (G) et par connexité de G, il existe une arête
a = {x, y} de G qui joint V (H) et V (G) − V (H) (Exercice 6). Or T + a est acyclique, sinon
a p
il existerait un cycle élémentaire de T + a contenant a (puisque T est acyclique) : x → y x,
et donc un chemin p entre x et y dans T . Par conséquent, T + a est un sous-graphe acyclique
de G qui contient T :contradiction avec l’hypothèse de maximalité de T . Finalement, T est un
sous-graphe couvrant acyclique et connexe de G : c’est un arbre couvrant de G.
3ème méthode. Méthode algorithmique. Tant qu’il existe des arêtes a sur un cycle de G,
choisir une telle a, faire G = G − a. Le graphe obtenu est tjs couvrant, connexec et contient au
moins une arête "cyclique" de moins. Le graphe obtenu à la sortie de la boucle TQ est l’arbre
cherché.
Correction exercice 12. Il y a n(n − 1) couples de sommets distincts et donc 2n(n−1) graphes
n(n−1) n(n−1)
orientés possibles. Il y a ∑n−1
i=1 i = 2 paires de sommets et donc 2 2 graphes non orientés
possibles.
Correction exercice 13. Le problème posé revient à calculer le nombre d’arbres possibles
sur l’ensemble à n sommets V = {1, . . . , n}. Nous allons montrer que les arbres sur V sont en
bijection avec les (n − 2)-uplets d’éléments de V . A tout arbre T sur V on associe les deux suites
de sommets ( fi )0<i≤n−2 et (si )0<i≤n−2 définies comme suit :
– f1 est la plus petite feuille de T , s1 est le voisin de f1 dans T , et ∀i < n − 2 :
– fi+1 est la plus petite feuille de T − { f1 , . . . , fi } ;
– si+1 est le voisin de fi dans T − { f1 , . . . , fi }.
6
La Figure 1, donne l’exemple d’un arbre sur {0, . . . , 8} et des suites associées.
5 8
3 4
7
1
2 6
F IGURE 1 – ( fi ) = (2, 1, 5, 3, 6, 7) ; (si ) = (1, 3, 3, 4, 4, 4)
On s’intéresse en fait uniquement au (n − 2)-uplet U = (s1 , . . . , sn−2 ) qui identifie de manière

unique l’arbre T . En effet, à tout (n − 2)-uplet d’éléments de V on peut associer l’arbre T sur V
construit de la manière suivante : on part du graphe on repère le plus petit i1 ∈ V −U. Alors l’arête
(i1 , s1 ) est dans T . On retire i1 de V et s − 1 de U, et on réitère l’opération avec les nouveaux V
et U. Lorsqu’il ne reste plus d’élément dans U, on termine en ajoutant à T l’arête constituée des
deux derniers éléments de V .
Ces deux constructions prouvent l’équipotence de l’ensemble des arbres et de l’ensemble des
(n − 2)-uplets sur {1, . . . , n}. Comme ce dernier ensemble est de cardinal nn−2 , on a le résultat
cherché.

1 L’inégalité ω(G) ≥ ω(G + I) est claire : l’ajoût d’arêtes à G ne peut pas faire croître le
nombre de composantes connexes. Dans le même temps, une arête ajoutée à un graphe
relie au plus deux composantes connexes de ce graphe et donc réduit d’au plus un sa
connectivité. Par conséquent, si I = {e1 , . . . , em }, la connectivité de G + I = (. . . ((G +
e1 ) + e2 ) + · · · + em ) est minorée par ω(G) − m.
2 Les arguments sont similaires à ceux de la question précédente : le retrait d’arêtes ne
peut pas faire décroître la connectivité, d’où l’inégalité ω(G) ≤ ω(G − I). De plus, le
retrait d’une arête provoque la scission d’au plus une composante connexe. La majoration
ω(G − I) ≤ ω(G) + |I| s’en déduit facilement.
3 Notons I = {e1 , . . . , em }. Le fait que ω(G−e) > ω(G) pour tout e ∈ I signifie qu’aucune de
ces arête n’est sur un cycle de G. Puisque le retrait d’arêtes diminue le nombre de cycles,
on sait a fortiori que ω(G − e1 ) < ω((G − e1 ) − e2 ) < ω(((G − e1 ) − e2 ) − e3 ) < . . . Par
ailleurs, chaque inégalité de la forme ω(G − e) > ω(G) équivaut à ω(G − e) = ω(G) + 1,
par la question 2. Il s’ensuit que ω(G − I) = ω((. . . ((G − e1 ) − e2 ) − e3 ) − · · · − em ) =
ω(G) + m.
4 Le graphe G − E est sans arête et donc, clairement, ω(G − E) = |V |. Par ailleurs, par 2,
ω(G − E) ≤ ω(G) + |E|. D’où finalement : |V | ≤ ω(G) + |E|.
5 ⇒ : si G est acyclique, alors aucune arête de G n’est sur un cycle et donc, la suppression
de toute e ∈ E incrémente le nombre de composantes connexes de G. Autrement dit :
ω(G − e) > ω(G) pour tout e ∈ E. Il s’ensuit, par 3, que ω(G − E) = ω(G) + |E| et la
conclusion vient de ω(G − E) = |V |.
7
⇐ : supposons ω(G) = |V | − |E|. Pour tout e ∈ E, ω(G − e) ≥ |V | − (|E| − 1) par 4. D’où
ω(G−e) ≥ |V |−|E|+1 = ω(G)+1 > ω(G) pour tout e ∈ E. Ceci signifie qu’aucun e ∈ E
n’est sur un cycle de G : G est acyclique.

– Si G est une arborescence de racine r, alors le graphe non orienté sous-jacent à G est
connexe, puisque le chemin orienté de r à deux sommets quelconques x et y donne lieu à un
chemin non orienté entre ces deux sommets. Il est aussi acyclique. Sinon, soit C un cycle.
Une arborescence étant clairement sans circuit, il existe un sommet x de C comportant
deux prédécesseurs u et v dans C. Soient p (resp. q) l’unique chemin orienté de r à u (resp.
v). Alors p.ux et q.vx sont deux chemins orientés distincts de r à x : une contradiction.
– Soient G un arbre et r ∈ V (G). On sait qu’il existe un chemin unique px de r à n’importe
quel sommet x de G (voir Theorem 7, Item 6). On oriente alors tous les arcs de px de r
vers x. Cette orientation peut être renouvellée sans conflit sur tout autre chemin py issu de
r. En effet, si l’arc uv apparaît dans px , vu n’apparaît pas dans py . Si cela se produisait on
aurait : r u → v x et r v → u y, et ceci entraînerait l’existence de deux chemins
distincts de r vers u.
Correction exercice 16. Récurrence sur k. Le résultat est immédiat pour k = 1 puisqu’un che-
min de longueur k est un arc du graphe. Le calcul de M k pour k > 1 donne :
n
Mikj = ∑ Mi`k−1M` j .
`=1
Or tout chemin de longueur k entre xi et x j se décompose en un chemin de longueur k − 1 entre

xi et un certain x` , suivi d’un arc reliant x` et x j . Le résultat découle alors de l’hypothèse de
récurrence selon laquelle Mi`k−1 est le nombre de chemins de longueur k − 1 joignant xi à xk .
Correction exercice 18. ⇒ est clair. Pour la réciproque, considérons un cycle élémentaire C
de G. S’il existe une arête a ∈ E \ C, alors G − a est non acyclique : une contradiction. Donc
G = C.
8
2010 / 2011
TD no 2
Arbres couvrants minimaux
R APPELS : Soit un graphe non orienté G = (V, E). Si P est une partie non triviale de V (i.e.,
P 6= ∅ et P 6= V ), le couple (P,V − P) est appelé coupure du graphe et noté (P, ¬P). On dit d’un
chemin p : x y de G qu’il traverse la coupure (P, ¬P) si x ∈ P et y ∈ / P. En particulier, une
arête a traverse (P, ¬P) si l’une de ses extrémités est dans P et l’autre non.
Exercice 1 (a) Montrer que tout chemin p traversant une coupure (P, ¬P) contient une arête qui
traverse cette même coupure.
(b) Montrer que si une arête est sur un cycle C et traverse une coupure (P, ¬P), alors il existe
une autre arête de C traversant cette même coupure.
Exercice 2 Dans un graphe pondéré, une arête a est dite minimale pour la traversée d’une cou-
pure (P, ¬P) si a est de poids minimal parmi les arêtes qui traversent (P, ¬P). Soit a une arête
d’un graphe non orienté connexe pondéré. Montrer l’équivalence des assertions suivantes :
(a) il existe un ACM T de G qui contient a ;
(b) il existe une coupure (P, ¬P) de G telle que a est minimale pour la traversée de cette coupure.
Exercice 3 Soit G un graphe non orienté pondéré, connexe et non acyclique. Soient T un ACM
de G et a une arête de G n’apparaissant pas dans T . On sait qu’alors T + a contient un unique
cycle C passant par a.
(a) Montrer que toute arête de C est de poids inférieur ou égal à celui de a.
(b) Montrer que si de plus a appartient à un arbre couvrant minimal T 0 , alors C contient une
arête b 6= a de même poids que a.
Pour tout sous-graphe H de G, on note `(H) la suite des poids des arêtes de H triés en ordre
croissant.
(c) Montrer que pour deux ACM T et T 0 quelconques de G, `(T ) = `(T 0 ).
Exercice 4 Soit a une arête de poids minimal dans un graphe pondéré. Montrer que a appartient
à un arbre couvrant minimal du graphe.
Exercice 5 Soit (G, c) un graphe non orienté connexe valué par une fonction injective. Prouver
ou infirmer :
(a) Tout ACM de G contient l’arête de poids minimum ;
(b) Aucun ACM ne contient l’arête de poids maximum ;
(c) Il n’y a qu’un ACM.
1
Exercice 6 Dans un graphe non orienté connexe valué (G, c), on construit un sous-graphe T de
la manière suivante :
On considère une partition V1 tV2 de V (G). On note G1 , G2 les sous-graphes de G
induits, respectivement, par V1 et V2 . Soit T1 (resp. T2 ) un ACM de G1 (resp. G2 ). On
choisit une arête a de coût minimum parmi les arêtes joignant V1 à V2 et on appelle
T le sous-graphe T = (T1 ∪ T2 ) + a.
Le graphe T est-il un arbre couvrant minimal de G ?
Exercice 7 Faire tourner l’algorithme de Kruskal sur les graphes pondérés suivants :
b 8 7
c d
4 2 9
c f
a 11 i 4 14 e 1 2 1 2
8 7 5 10 a b d e
1 5 1
h g f
1 2
Exercice 8 Montrer que la variante suivante de l’algorithme de Kruskal retourne un arbre

couvrant minimal de G :
Algorithme 1: Variante de l’algorithme de Kruskal
Données : Un graphe pondéré connexe (G, c)
Résultat : Un ACM F de (G, c)
1 F =∅;
2 numéroter les arêtes de G dans un ordre quelconque a1 . . . am ;
3 pour i = 1 à m faire
4 F = F + ai ;
5 si F contient un cycle alors
6 choisir une arête b de poids maximal sur ce cycle ;
7 F = F −b ;
fin
fin
8 retourner F
Exercice 9 Pour A un ensemble d’arêtes de G, on note m(A) le poids maximal d’une arête de A.
Modifier l’algorithme de Prim pour déterminer un arbre couvrant A ayant le plus petit m(A).
Exercice 10 L’algorithme de Kruskal peut retourner des ACM différents suivants le tri des
arêtes par poids croissant à partir duquel il effectue son calcul. Montrer que pour tout ACM T de
G, il existe un tri des arêtes par poids croissant à partir duquel Kruskal retourne T .
Exercice 11 Montrer que si H est un sous-graphe d’un ACM de G et si de plus a est une arête
de G minimale pour la traversée d’une coupure qui contient H, alors H + a est lui aussi un sous-
graphe d’un ACM de G. En déduire une nouvelle preuve de la correction de l’algorithme de
Kruskal.
2
Exercice 12 Soient G = (V, E, w) un graphe non orienté connexe et pondéré. On considère l’al-
gorithme suivant.
Données : Un graphe non orienté connexe pondéré G = (V, E, w)

1 F =G;
2 trier les arêtes par poids décroissants ;
3 pour chaque arête a prise dans cet ordre faire
4 si F − a est connexe alors F = F − a ;
fin
5 retourner F
(a) Montrer que cet algorithme termine sur toute entrée.

(b) Montrer qu’il retourne un arbre couvrant.
(c) Cet arbre couvrant est-il toujours de poids minimal ?
3
2010 / 2011
Corrigé du TD no 2
Arbres couvrants minimaux
(a) On considère le premier sommet u de p appartenant à ¬P. Alors l’arête qui précède u dans
p fait l’affaire.
(b)
Correction exercice 2. (a) ⇒ (b) : le graphe T − a admet deux composantes connexes P1 et

P2 . Montrons que le couple (P1 , P2 ) est la coupure cherchée. Notons tout d’abord que a traverse
(P1 , P2 ) (clair). Par ailleurs, aucune arête de T − a ne traverse (P1 , P2 ) (sinon ces deux parties
seraient connectées dans T − a). Donc s’il existe une arête b = {x, y} distincte de a et traversant
b p
(P1 , P2 ), b ∈
/ T . Par conséquent, T + b comporte un unique cycle de la forme x → y x, où p
est un chemin dans T . Comme p traverse (P1 , P2 ), il contient une arête qui traverse cette coupure
(d’après la question précédente), et cette arête ne peut être que a. Ainsi, a est sur l’unique cycle
de T + b et par conséquent, le graphe T 0 = (T + b) − a est un arbre couvrant de G. Il doit donc
être de poids ≥ à celui de T , ce qui entraîne que b est de poids ≥ à celui de a : l’arête a est bien
minimale pour la traversée de (P1 , P2 ).
(b) ⇒ (a) : Soit T0 un ACM de G. Si T0 contient a, c’est terminé. Sinon, T0 + a contient un
a p
unique cycle de la forme x → y x, où p est un chemin de T0 . Comme p traverse la coupure
(P, ¬P), il contient une arête b traversant cette coupure. Par minimalité de a pour la traversée de
(P, ¬P), b est de poids ≥ à celui de a. Par conséquent, T = (T0 + a) − b est un arbre couvrant de
poids ≤ à celui de T0 : c’est un ACM de G qui contient a.
(a) Soit b 6= a appartenant à C. Alors (T + a) − b est un arbre couvrant de (G, c). Par conséquent,
c((T + a) − b) ≥ c(T ). Autrement dit, c(T ) + c(a) − c(b) ≥ c(T ) et donc c(b) ≤ c(a).
(b) Si a appartient à un ACM, alors a est minimale pour la traversée d’une coupure (P, ¬P). Mais
alors, le sous-chemin de C obtenu en retirant l’arête a de C est un chemin dans T qui traverse
la coupure (P, ¬P). Ce chemin contient donc nécessairement une arête b de T qui traverse
(P, ¬P). Comme b est sur le cycle, c(b) ≤ c(a), d’après la question précédente. Comme b
traverse (P, ¬P), c(a) ≤ c(b), puisque a est minimale pour la traversée. Finalement, c(b) =
c(a).
(c) On note a1 , a2 , . . . , ak la suite des arêtes de T 0 . Soit (Ti )0≤i≤k la suite de sous-graphes de G
définie récursivement par : T0 = T et pour tout i < k,
5
– si ai+1 ∈ Ti alors Ti+1 = Ti ;
– sinon Ti+1 = (Ti + ai ) − bi , où bi est une arête de même poids que ai sur l’unique cycle de
Ti + ai . (Voir (b).)
Alors pour tout i > 0 :
(1) Ti est un arbre couvrant qui contient (a1 , . . . , ai ) ;
(2) `(Ti ) = `(Ti−1 ).
Par conséquent, Tk = T 0 et `(T 0 ) = `(T0 ) = `(T ).
1ère méthode. Il suffit de faire tourner l’algorithme de Kruskal à partir d’un tri des arêtes
par poids croissant dans lequel a apparaît en première position (un tel tri existe puisque a est
de poids minimal). Alors a sera sélectionnée lors du premier passage dans la boucle “pour” et
placée dans le graphe F en construction. Le résultat se déduit alors de la preuve de la correction
de cet algorithme, qui établit que le graphe F retourné est un ACM de G.
2ème méthode. Soit T un ACM de G. Si T contient a, c’est fini. Sinon, T + a contient un

unique cycle passant par a. Donc le graphe T 0 obtenu à partir de T + a en retirant une arête b 6= a
de ce cycle est un arbre couvrant (connexe parce qu’on a enlevé une arête d’un cycle d’un graphe
connexe, acyclique parce que ce cycle était unique, couvrant parce que V (T 0 ) = V (T )). De plus,
c(T 0 ) = c(T ) + c(a) − c(b) ≤ c(T ) puisque c(a) ≤ c(b). Comme T est de poids minimal, T 0 est
un ACM (qui contient a).
(a) est vraie. Soit T un ACM de G qui ne contient pas l’arête de poids minimum a. Alors T + a
contient un unique cycle qui passe par a et, comme dans l’Exercice 4, pour toute arête b 6= a
de ce cycle, (T + a) − b est un arbre couvrant de G. De plus, c((T + a) − b) = c(T ) + c(a) −
c(b). Comme a est de poids minimum et comme c est injective, on a c(a) < c(b) et donc
c((T + a) − b) < c(T ) : T n’est donc pas minimal.
(b) est fausse : prendre un chemin de longueur 2 dont les arêtes sont valuées, respectivement,
par 1 et 2.
(c) est vraie : Supposons que G admette deux ACM distincts, T et T 0 . Soit a1 , a2 ,. . ., ak (resp.
b1 , b2 , . . . , bk ) un tri des arêtes de T (resp. de T 0 ) par pondérations croissantes. Soit ` le plus
petit des indices i tels que ai ∈ / E(T 0 ). Alors T 0 + a` comporte un cycle, et ce cycle contient
au moins une arête qui n’est pas dans T (sinon ce serait un cycle dans T ). Soit b une telle
arête. Comme b ∈ E(T 0 ) − E(T ), b ∈ {bi , i > `}. De plus (T 0 + a` ) − b est un arbre couvrant
de G. Enfin, c((T 0 + a` ) − b) = c(T 0 ) + c(a` ) − c(b) < c(T 0 ) : contradiction.
Correction exercice 6. Non. Contre exemple, un carré x − y − z −t − x avec c(xy) = c(zt) = 10,
c(yz) = c(xt) = 1 et V1 = {x, y}.
6
Correction exercice 8. On remarque d’abord que l’algorithme termine bien sur toute entrée,
puisque son unique boucle consiste en un parcours d’une liste finie d’arêtes. On note H le graphe
engendré par toutes les arêtes de G envisagées à un instant donné de l’exécution de l’algorithme,
que ces arêtes aient été retenues ou non dans F. En d’autres termes, H est le graphe vide avant le
premier passage dans la boucle ; c’est le graphe engendré par (a1 , . . . , ai ) après i passages dans
la boucle. Montrons que l’assertion suivante est un invariant de la boucle “pour” :
F est un sous-graphe acyclique couvrant de poids minimal de H. (∗)
Supposons que l’assertion (∗) soit vrai avant un passage dans la boucle et prouvons que tel est
encore le cas après ce passage. Soit donc a l’arête ajoutée à F ligne 4.
Si F + a est acyclique, les instructions 6 et 7 ne sont pas exécutées et après passage dans la
boucle, F est remplacé par F + a, et H par H + a.
Sinon, F + a est remplacé par (F + a) − b,

(a) L’algorithme termine sur toute entrée puisque la seule boucle qu’il contient consiste en une
boucle pour qui parcourt une liste finie.
(b) Le graphe F, obtenu par suppression d’arêtes de G, est clairement un sous-graphe couvrant
de G. De plus, initialisé à G, qui est connexe, et modifié dans le seul cas où cette modification
de compromet pas la connexité, F reste connexe tout au long de l’algorithme. Enfin, lorsque
l’algorithme termine, toute arête de F a été laissée dans F parce que sa suppression aurait
déconnecté F. Donc le graphe F récupéré en fin d’algorithme est un sous-graphe couvrant
connexe minimal de G, c’est à dire un arbre couvrant de G.
(c) Cet arbre couvrant est minimal. Pour le prouver, montrons que l’assertion suivante : (∗)
« F contient un ACM de G comme sous-graphe », est un invariant de l’algorithme. Elle est
évidemment vraie à l’initialisation F = G. Supposons-la vérifiée avant une exécution de la
boucle pour. Soit a l’arête considérée lors de cette exécution. Si F − a est non connexe,
alors F n’est pas modifié et la validité de l’assertion (∗) est préservée. Sinon, F est remplacé
par F − a. Soit T l’ACM contenu dans F. Si a ∈ / T , alors T est encore un sous-graphe de
F − a et (∗) est préservée. Sinon, T − a comporte deux composantes connexes. On sait que
l’hypothèse « F − a connexe » signifie que a est sur un cycle de F. Ce cycle comporte
nécessairement une arête b distincte de a qui connecte les deux composantes connexes de
T − a. De ce fait, T − a + b est un arbre couvrant de G. De plus, b n’a pas encore été
considérée par l’algorithme au moment où s’exécute ce passage dans la boucle pour (sinon,
puisqu’elle est sur un cycle de F, elle en aurait été retirée). Ceci garantit que w(b) ≤ w(a).
Par conséquent, w(T − a + b) ≤ w(T ) et T − a + b est un ACM de G qui contient F − a.
Ainsi, l’assertion (∗) est vraie tout au long de l’algorithme. En particulier, le graphe F re-
tourné ligne 5 contient un ACM de G. Comme F est lui-même un arbre couvrant, il s’iden-
tifie à cet ACM. C’est le résultat cherché.
7
2010 / 2011
TD no 3
Algorithmes gloutons - Matroïdes
Exercice 1 (Divers matroïdes). Rappelons qu’une base d’un matroïde est un ensemble indé-
pendant maximal pour l’inclusion. Par ailleurs, on appelle circuit d’un matroïde tout ensemble
dépendant minimal. Autrement dit, C est un circuit de M = (X, I ) si C ∈/ I et C − x ∈ I pour
tout x ∈ C. Pour chacun des exemples suivants, vous montrerez que (X, I ) est un matroïde et
vous décrirez ses bases et ses circuits.
1. Matroïde graphique M(G) : Étant donné un GNO G = (V, E), on pose X = E et un ensemble
I ⊆ X est indépendant si le sous-graphe (V, I) de G est acyclique.
2. Matroïde cographique M ∗ (G) : Étant donné un GNO G = (V, E) connexe, on pose X = E
et un ensemble I ⊆ X est indépendant si le sous-graphe (V, E \ I) de G est connexe.
3. Matroïde uniforme Uk,n : On pose X = {1, . . . , n} et un ensemble I ⊆ X est indépendant si
|I| ≤ k.
Exercice 2 (Min/Max graphique/cographique). Relire les définitions des matroïdes graphique

et cographique associés à un graphe G (les structures M(G) et M ∗ (G) de l’Exercice 1). Soit
G = (V, E, w) un graphe pondéré.
1. Montrer que I est une base de poids maximal de M(G) ssi E \ I est une base de poids
minimal de M ∗ (G).
2. En déduire un nouvel algorithme pour le calcul d’un arbre couvrant minimal.
Exercice 3 (Kruskal et matroïde). Montrer que Kruskal est un cas particulier de recherche d’in-
dépendant maximal dans un matroïde.
Exercice 4 (Calculer dans un matroïde). On se donne un matroïde M = (E, I ) et un algorithme

qui détermine si un sous-ensemble de E est indépendant en temps polynomial en la taille du
sous-ensemble.
1. Le rang d’un sous-ensemble X de E est le cardinal maximum d’un indépendant inclus dans
X. Donner un algorithme qui calcule le rang d’un sous-ensemble X en temps polynomial
en la taille de X,
2. Donner un algorithme qui construit une base contenant un ensemble indépendant X donné,
en temps polynomial en la taille de E.
Exercice 5 (Un problème d’ordonnancement). De nombreux problèmes rencontrés dans l’affec-
tation de tâches sur un processeur s’apparentent à ceux concernant l’organisation du travail dans
les ateliers. En voici un exemple : on suppose que l’on doit réaliser des taches T1 , T2 , . . . , Tn sur
une seule machine. Chaque tâche Ti a une durée di et une priorité pi . Une réalisation de ces tâches
est donnéee par une permutation Ti1 , Ti2 , . . . , Tin de celles-ci, représentant l’ordre dans lequel elles
sont effectuées sur la machine. La date de fin Fi d’une tâche Ti est donnée par la somme des du-
rées des tâches qui la précèdent dans la permutation augmentée de sa durée propre di . On mesure
la pénalité d’une réalisation par la quantité ∑ni=1 pi Fi qui devra être rendue minimum, ainsi les
tâches de priorités plus grandes devraient être réalisées avant celles de priorités plus petites.
1. On suppose qu’il y a 4 tâches ayant pour durées 3, 5, 7, 4, et de priorités 6, 11, 9, 5.
Laquelle de ces deux réalisations est-elle la meilleure : T1 , T4 , T2 , T3 ou T4 , T1 , T3 , T2 ?
d
2. Soient deux tâches Ti et T j qui se suivent dans une réalisation et telles que dpii < p jj . Laquelle
de ces deux tâches doit on mettre avant l’autre pour minimiser la pénalité ?
3. En déduire un algorithme glouton permettant d’obtenir la réalisation de plus faible pénalité.
Exercice 6 (Processeur séquentiel). On considère un ensemble de tâches Ti , 1 ≤ i ≤ n, ayant

toutes une durée unitaire. Pour chaque tâche sont fixés un délai di et une pénalité pi qui est à
acquitter quand la tâche n’est pas remplie avant le temps di . On veut trouver un ordre d’exécution
des tâches sur une machine unique qui minimise la somme des pénalités. Soit F la famille des
sous-ensembles F de {T1 , . . . , Tn } telle que F ∈ F ssi les tâches de F peuvent être toutes réalisées
à temps. On appellera ces ensembles réalisables. Montrer que F est une famille d’ensembles
formant un matroïde. (On pourra chercher, étant donnés deux ensembles réalisables X et Y ,
chacun ordonné par délai croissant, et tels que |X| < |Y |, quel élément de Y on peut ajouter à X
tout en conservant la réalisabilité.) On conclura donc qu’il suffit de classer les tâches par ordre
de pénalité décroissante pour obtenir la réalisation optimale.
Exercice 7 (Des limites de la gloutonnerie). Cet exercice a pour but de montrer que de nombreux
problèmes ne sont pas résolubles par un algorithme glouton. Considérons par exemple celui dit
du sac à dos. On doit emporter en voyage un certain nombre d’objets parmi n, l’objet i a un poids
pi et un intérêt ai . On est limité par le poids total P des objets à emporter et on cherche donc un
sous-ensemble d’objets dont la somme des intérêts est maximale parmi ceux dont la somme des
poids est inférieure ou égale à P.
1. On applique l’algorithme consistant à classer les objets par intérêt décroissant et à consi-
dérer les objets itérativement dans cette liste ; on emporte ceux dont le poids ne fait pas
dépasser le poids total P acceptable. Montrer en donnant un exemple que cet algorithme
ne donne pas toujours l’optimum.
2. On applique ensuite l’algorithme consistant à classer les objets par poids croissant et à
procéder ensuite comme pour l’algorithme précédent. Donner un nouvel exemple montrant
que cet algorithme ne donne pas l’optimum.
3. On applique enfin l’algorithme consistant à classer les objets suivant le rapport (inté-
rêt/poids) et à poursuivre comme plus haut. Montrer à nouveau que cet algorithme ne
donne pas l’optimum.
Exercice 8 (Axiomatisation des bases d’un matroïde). Étant donnés un ensemble fini X et un
ensemble de parties de X, B ⊆ P(X), on considère les propriétés suivantes :
/ B.
(B1 ) ∅ ∈
(B2 ) si X,Y ∈ B et x ∈ X \Y , alors ∃y ∈ Y \ X t.q. X − x + y ∈ B.
Montrer que B satisfait (B1 ) et (B2 ) ⇔ B est l’ensemble des bases d’un matroïde.
Exercice 9 (Un nouveau matroïde). On considère un ensemble fini E et une partition E1 , . . . , Ek

de E en sous-ensembles disjoints non vides. On définit la structure (E, I ) par la condition :
I = {I ⊆ E : |I ∩ Ei | ≤ 1 pour i = 1, . . . , k}.
Montrer que (E, I ) est un matroïde.
Exercice 10 Soient G = (V, E) un graphe non orienté. Un ensemble de sommets C ⊆ V est une
couverture des sommets (vertex-cover en anglais) de G si toute arête de G est incidente à un
sommet x ∈ C. On considère le problème de minimisation suivant :
Problème : V ERTEX -C OVER
Input : Un graphe non orienté G = (V, E)
Output : Une couverture des sommets minimale de G
Une approche gloutonne pour le traitement de ce problème consiste à construire C itérative-
ment (à partir de ∅) en ajoutant à chaque étape un sommet v de degré aussi grand que possible,
de façon à maximiser le nombre d’arête "couvertes" par v. On espère ainsi minimiser le nombre
de sommets à ajouter pour couvrir l’ensemble des arêtes. Ceci donne lieu à l’algorithme suivant :
Données : Un graphe non orienté G

1 C=∅;
2 repeat
3 choisir dans G un sommet v de degré maximal ;
4 C = C ∪ {v} ;
5 G = G−v
6 E(G) = ∅;
until
7 retourner C
(a) Montrer que cet algorithme termine sur toute entrée.

(b) Montrer qu’il retourne bien une couverture des sommets.
(c) Cette couverture des sommets est-elle toujours minimale ?
2010 / 2011
Corrigé du TD no 3
Matroïdes
Correction exercice 1. Pour chaque exemple (X, I ) envisagé on montre que :

(a) ∅ ∈ I ; (b) I ⊆ J ∈ I ⇒ I ∈ I ; (c) (I, J ∈ I ∧ |I| < |J|) ⇒ ∃x ∈ J \ I : I ∪ {x} ∈ I .
Puis on décrit : (d) les bases de M ; (e) les circuits de M.
Matroïde graphique M(G) : (a) ∅ ∈ I parce qu’un graphe sans arête est acyclique.
(b) I ⊆ J et J ∈ I signifie que I est un sous-ensemble de l’ensemble d’arêtes acyclique J,
donc I est lui même acyclique (donc dans I ).
(c) Si I, J ∈ I et |I| < |J| : Soit C l’ensemble des composantes connexes de (V, I). Pour
chaque C ∈ C , on note IC (resp. JC ) l’ensemble des arêtes de I (resp. de J) dont les deux extré-
mités sont dans C. Alors chaque JC a au plus |C| − 1 = |IC | éléments (sinon (V, J) comporterait
un cycle. Donc ∑C∈C |JC | ≤ ∑C∈C |IC | = |I| < |J|. Par conséquent, il existe une arête e ∈ J dont
les deux extrémités ne sont pas dans une même composante I-connexe. Et l’on a (V, I ∪ {e})
acyclique, i.e. I ∪ {e} ∈ I .
(d) On sait que les ensemble d’arêtes acycliques maximaux - i.e. les bases de M(G) - sont
les arbres couvrants de G.
(e) Un circuit de M(G) est un ensemble d’arêtes non acyclique mais que la suppression d’une
arête quelconque rend acyclique. Les circuit de M(G) sont donc exactement les cycles de G.
Matroïde cographique M ∗ (G) : Par définition de M ∗ (G), un ensemble I ⊆ E est indépendant

ssi G − I est connexe.
(a) ∅ ∈ I , puisque G − ∅ = G est connexe.
(b) Si I ⊆ J et J ∈ I , alors G − J est connexe et est un sous-graphe de G − I. Par conséquent,
G − I est aussi connexe, i.e. I ∈ I .
(c) Supposons que I, J ∈ I et |I| < |J|. Ceci signifie que G − I et G − J sont tous deux
connexes. Nous voudrions prouver qu’il existe e ∈ J \ I tel que I ∪ {e} ∈ I , c’est à dire tel
que (G − I) − e soit connexe. Supposons, en vue d’une contradiction, qu’un tel e n’existe pas.
Autrement dit, pour tout e ∈ J \ I, ω((G − I) − e) > 1 = ω(G − I). Cela entraîne, grâce à la
question 3 de l’exercice 14 :
ω((G − I) − J \ I) = ω(G − I) + |J \ I|. (1)
Par ailleurs, le graphe G − J peut être obtenu à partir de (G − I) − J \ I en rajoutant toutes les
arêtes de I qui ne sont pas dans J. En d’autres termes : G − J = ((G − I) − J \ I) + I \ J. Mais
alors
ω(G − J) = ω(((G − I) − J \ I) + I \ J) ≥ ω((G − I) − J \ I) − |I \ J|
et donc, par (1) :
ω(G − J) ≥ ω(G − I) + |J \ I| − |I \ J|.
Or, l’inégalité |J| > |I| posée en hypothèse équivaut à |J \ I| > |I \ J|. De plus, ω(G − I) = 1
puisque G − I est connexe. On obtient finalement :
ω(G − J) > 1,
ce qui contredit l’hypothèse « G − J connexe ».

(d) Un ensemble d’arêtes I est une base de M ∗ (G) si G − I est connexe et si G − I − x est non
connexe pour tout x ∈ E \ I. Autrement dit, I est une base si G − I est un sous-graphe connexe
minimal de G, donc si G − I est un arbre couvrant de G. Les bases de M ∗ (G) sont donc les
complémentaires d’arbres couvrants de G.
(e) I est un circuit de M ∗ (G) ssi G − I est non connexe mais pour tout J ( I, G − J est
connexe. Autrement dit, les circuits de G sont les ensembles minimaux d’arêtes dont la suppres-
sion déconnecte G. C’est ce qu’on appelle les cocycles de G.
Matroïde uniforme Uk,n : (a) |∅| ≤ k.

(b) I ⊆ J et |J| ≤ k entraîne |I| ≤ k.
(c) |I|, |J| ≤ k et |I| < |J| entraîne |I| < k et donc, pour tout x ∈ J \ I : |I ∪ {x}| ≤ k.
(d) Clairement, les bases de Uk,n sont les parties de cardinal k de {1, . . . , n}.
(e) Les circuits de Uk,n sont les parties de cardinal k + 1 de {1, . . . , n}.
Correction exercice 3. Il suffit de constater qu’un arbre couvrant minimal pour la pondération
w est un arbre couvrant maximal (donc un indépendant maximal du matroïde graphique) pour
la pondération C − w, où C est une constante suffisament grande (C = w(G) par exemple). On
vérifie alors facilement que Kruskal est la transcription exacte de l’algorithme glouton pour
les indépendant maximaux.
1. L’ensemble des indépendants inclus dans X forme un matroïde (le vérifier). Pour trouver
un indépendants maximum il suffit donc d’appliquer l’algorithme glouton en donnant 1
comme valuation à chaque élément.
2. Si X n’est pas un indépendant il n’existe pas de base le contenant. Sinon l’ensemble des
parties Y de M \ X telles que X ∪Y soit un indépendant forme un matroïde (le vérifier). De
nouveau il suffit donc d’appliquer l’algorithme glouton.
1. La suite T1 , T4 , T2 , T3 donne F1 = 3, F4 = 7, F2 = 12, F3 = 19, soit une pénalité totale de
3.6 + 12.11 + 9.19 + 5.7 = 356. La suite T4 , T1 , T3 , T2 donne F1 = 7, F2 = 19, F3 = 14,
F4 = 4, soit une pénalité de 7.6 + 19.11 + 9.14 + 5.4 = 397. Le premier choix est donc le
meilleur.
2. Si ces deux tâches se suivent, soit T le temps écoulé avant la première des deux. Alors si
i précède j, la pénalité sera (T + di )pi + (T + di + d j )p j ; dans le cas contraire la pénalité
sera (T + d j )p j + (T + d j + di )pi . La différence de ces deux valeurs vaut di p j − d j pi . Il
s’ensuit que i doit précéder j si di p j − d j pi < 0, soit encore di /pi < d j /p j .
3. Supposons que dans l’affectation optimale, les tâches ne soient pas effectuées par d/p
croissant. Il existe alors deux tâches t = (d, p) et t 0 = (d 0 , p0 ) avec d/p > d 0 /p0 telle que t
est effectuée juste avant t 0 . La question précédente montre alors qu’inverser t et t 0 améliore
l’affectation, contradiction. Il suffit donc d’utiliser l’algorithme glouton en ordonnant les
tâches par ordre d/p croissant. Sur l’exemple de l’énoncé on obtient T 2, T 1, T 3, T 4 pour
une pénalité de 333.
Correction exercice 6. On vérifie les axiomes de matroïde. La partie F est non vide (elle
contient ∅), et manifestement si F ∈ F , alors pour tout G ⊂ F, G ∈ F . Vérifions l’axiome
d’extension. Soit un ensemble de tâches X = {Ti1 , Ti1 , . . . , Tik } réalisable dans cet ordre et un
autre ensemble Y = {T j1 , Ti2 , . . . , T j` } réalisable dans cet ordre avec l > k. Soit T j p la tâche la plus
tardive de Y qui n’est pas dans X. L’ensemble de tâche obtenu en ajoutant T j p à X est réalisable,
dans l’ordre X”, T j p ,Y 0 où Y 0 = T j p +1 , . . . , T j` est l’ensemble des tâches qui se trouvent après T j p
dans Y (et qui sont aussi des tâches de X), et où X” est la suite des tâches restantes de X. Pour
vérifier que cet ordre est bien réalisable, on remarque que :
– les tâches de X 00 sont effectuées en un temps qui est inférieur ou égal à celui où elles
l’étaient dans X,
– les tâches T j p et dans Y 0 sont effectuées en un temps qui est inférieur ou égal à celui où
elles l’étaient dans Y .
On a donc bien prouvé que F définit un matroïde. Il suffit donc d’appliquer l’algorithme glouton
pour les valuations auxquelles on s’intéresse, ici les pénalités : la fonction d’intérêt à maximiser
est la somme des pénalités des tâches effectuées.
Correction exercice 7. Il suffit de considérer la suite d’objets (poids, intérêt) suivante : (2, 3),
(1, 2), (1, 2). Dans un sac de capacité 2, l’algorithme glouton reposant sur l’intérêt choisira d’em-
porter l’objet 1, alors qu’il est préférable d’emporter les objets 2 et 3. Dans un sac de capacité 3,
l’algorithme glouton basé sur le rapport intérêt/poids choisira d’emporter les objets 2 et 3, tandis
que 2 et 1 (ou 3 et 1) serait préférable ; il en est de même pour l’algorithme glouton basé sur le
poids.
Correction exercice 8. ⇐ Soit B l’ensemble des bases d’un matroïde (X, I ), c’est-à-dire,
l’ensemble des indépendant maximaux de (X, I ). Si X est non trivial (i.e., contient un indépen-
dant non vide), alors aucune base n’est vide, donc B satisfait (B1 ).
Par ailleurs, si X,Y sont deux bases et si x ∈ X \Y , alors X − x ∈ I et |X − x| < |Y | (puisque
|X| = |Y |), donc ∃y ∈ Y \ X t.q. X − x + y ∈ I (axiome d’échange des indépendants). Mais
puisque |X − x + y| = |X|, on a de plus X − x + y ∈ B.
⇒ Si B ⊆ P(X) satisfait (B1 ) et (B2 ), l’ensemble I ⊆ P(X) défini par : « I ∈ I ssi ∃B ∈
B tel que I ⊆ B » est un ensemble d’indépendants (autrement dit, (X, I ) est un matroïde). En
effet :
/ B : clair.
1. ∅ ∈
2. I ⊆ J ⊆ B avec B ∈ B entraîne I ⊆ B et donc I ∈ I .
3. Soient I, J ∈ I tels que |I| < |J|. Soient de plus X,Y ∈ B tels que I ⊆ X ∈ B et J ⊆ Y ∈ B.
Considérons un élément a de J \ I. (En particulier, a ∈ Y .)
Si a ∈ X alors I + a ⊆ X et donc I + a ∈ I .
Sinon, a ∈ Y \ X donc, par (B2 ), ∃b ∈ X \Y tel que X + a − b ∈ B. Or, I + a ⊆ X + a − b
puisque b ∈ / I. Il s’ensuit : I + a ∈ I .
/ X et donc b ∈
(a) ∅ ∈ I : On a clairement pour tout i ≤ k : |∅ ∩ Ei | = 0.
(b) I est héréditaire : si I ⊂ J ∈ I alors ∀i, |I ∩ Ei | ≤ |J ∩ Ei | ≤ 1 ; d’où I ∈ I .
(c) Propriété d’échange : Considérons I, J ∈ I avec |I| < |J|. Puisque (Ei )i est une partition,
J = i (J ∩ Ei ) et I = i (I ∩ Ei ). L’hypothèse |I| < |J| entraîne donc l’existence d’un i ≤ k
S S
tel que |I ∩ Ei | < |J ∩ Ei | ≤ 1, c’est-à-dire : |I ∩ Ei | = 0 et |J ∩ Ei | = 1. Clairement, l’unique

élément x de J ∩ Ei réalise I ∪ {x} ∈ I .

(a) G est privé d’un sommet de degré maximal à chaque passage de boucle. Or, puisque l’exé-
cution du repeat suppose que E(G) 6= ∅, le degré du sommet v choisi est toujours non nul,
de sorte que l’instruction G = G − v s’accompagne nécessairement de la suppression d’une
arête. Ainsi, le nombre d’arêtes de G décroît strictement à chaque passage de boucle, et la
condition « G = ∅ » finit par devenir vraie au bout d’un nombre fini d’étapes.
(b) À chaque passage dans la boucle repeat, un sommet v est ajouté à C (ligne 4) et des arêtes
sont retirées de G, via l’instruction de la ligne 5, qui sont toutes incidentes à v. Ainsi, par
construction, chaque arêtes retirée de G est incidente à un sommet de C. Comme à l’issue de
l’algorithme, toutes les arêtes de G ont été retirées, on peut conclure que toute arête de G est
incidente à un sommet de C, i.e. C est une couverture des sommets.
(c) La couverture des sommets obtenue par cette procédure n’es pas toujours minimale. Consi-
dérons par exemple le graphe 1—2—3—4—5 qui admet une couverture minimale de taille
2 ({2, 4}). L’algorithme de l’énoncé peut pourtant opérer aux choix suivants : 3 (puisque
δG (3) = 2 est maximal), puis 1 (δG−3 (1) = 1 est maximal), puis 5 (δG−{3,1} (5) = 1 est
maximal). La couverture retournée dans ce cas, {1, 3, 5}, n’est pas minimale.
2010 / 2011
TD no 4
Programmation dynamique
Exercice 1 (Amélioration Fibonacci). Soit (Fn )n≥0 la suite de Fibonacci.

(a) Montrer que pour tout n > 0 :

Fn 0 1 Fn−1
=
Fn+1 1 1 Fn
(b) En déduire un algorithme en O(log n) pour le calcul de Fn .
Exercice 2 (Tri topologique).

(a) Montrer que tout graphe orienté sans circuit admet un sommet de degré entrant nul.
(b) En déduire un algorithme qui produit le tri topologique d’un DAG en temps linéaire.
(c) Prouver sa correction.
(d) Évaluer sa complexité. (On supposera que le graphe est donné par sa matrice d’adjacence.)
(e) Montrer qu’un graphe orienté est sans circuit ssi il admet un tri topologique.
( f ) Écrire la liste des sommets obtenue par application de cet algorithme sur le graphe suivant.
On supposera qu’à chaque étape nécessitant un choix arbitraire de sommet, ce choix se fait
suivant l’ordre alphabétique des étiquettes.
m n o p
q r s
t u v w
x y z
Exercice 3 (Inversion d’un Graphe). L’inverse d’un graphe orienté G = (V, E) est le graphe
Gr = (V, E r ) où E r est définie par E r (x, y) ssi E(y, x). Écrire un algorithme de complexité linéaire
qui inverse un graphe présenté par listes d’adjacence.
Exercice 4 Déduire des exercices 2 et 3 la complexité exacte de l’algorithme pccDagiter vu

en cours.
Exercice 5 (a) Améliorer l’algoritme plsciter vu en cours pour qu’il fonctionne en espace
O(min(m, n)) plutôt que O(mn).
(b) Comment faire pour calculer, en plus de la longueur des PLSC de X et Y , un exemplaire de
PLSC (X,Y ) ?
Exercice 6 (Sous-suites croissantes maximales). Une sous-suite d’une suite d’entiers a = a1 , . . . , an

est une suite de la forme ai1 , . . . , ai p , avec i1 < · · · < i p . On parle de sous-suite croissante si de
plus ai1 ≤ · · · ≤ ai p . Par exemple, 2369 est une sous-suite croissante de 5, 2, 8, 6, 3, 6, 9, 7 qui, de
surcroît, est de taille maximale parmi les sous-suites croissantes de la suite initiale. On cherche
à résoudre le problème des sous-suites croissantes maximales, défini comme suit :
SSCM : Entrée : une suite d’entiers a ;

Sortie : la taille maximale d’une sous-suite croissante de a.
1. Montrer que ce problème se ramène à la recherche d’un plus long chemin dans un DAG.
2. En déduire un algorithme linéaire pour SSCM.
Exercice 7 (Sous-tableau de somme maximum). Etant donné un tableau de réels T [1..n], un

sous-tableau de T est un fragment continu de T . C’est donc un tableau de la forme T [`..h], où 1 ≤
` ≤ h ≤ n. La somme d’un tableau de nombres est la somme des éléments qui le composent. Le
problème du sous-tableau de somme maximum, noté STSM, consiste en la recherche de la valeur
maximale des sommes des sous-tableau d’un tableau donné. Autrement dit, c’est le problème
suivant :
STSM : Entrée : un tableau de réels T [1..n] ;

h
Sortie : max{ ∑ T [i], 1 ≤ ` ≤ h ≤ n}.
i=`
(a) Donner un sous-tableau de somme maximale pour T = (5, 15, −30, 10, −5, 40, 10).
(b) Ecrire un algorithme qui résout STSM de manière naïve, en calculant les sommes de tous les
sous-tableaux T [`..h], pour 1 ≤ ` ≤ h ≤ n, et en mettant à jour au fur et à mesure la valeur
maximale obtenue.
(c) Donner, en la justifiant, la complexité de cet algorithme.
On se propose maintenant d’aborder ce problème sous l’angle de la programmation dyna-
mique. Commençons par noter M( j) la valeur maximale des sommes des sous-tableaux qui ter-
minent sur la case j. Autrement dit, pour tout j ∈ {1, . . . , n} :
j
M( j) = max{ ∑ T [i], 1 ≤ ` ≤ j},
i=`
(d) Calculer M(1) et établir une relation entre M( j + 1) et M( j) pour j < n.

(e) Comment s’exprime la somme maximale des sous-tableaux de T [1..n] en fonction de M(1), . . . , M(n) ?
( f ) En déduire un algorithme en temps linéaire pour STSM.
Exercice 8 (Rendu de monnaie). Un commerçant dispose d’une quantité illimitée de pièces de

1, 2, 5 et 10 euros. Il peut obtenir n’importe quelle somme x ∈ N à partir de ces pièces, mais
cherche à minimiser le nombre total de pièces utilisées.
1. Proposez un algorithme glouton qui, prenant en argument une valeur x ∈ N, retourne le
nombre de pièces minimal M(x) permettant d’obtenir x.
2. Prouvez la correction de votre algorithme.
On appelle jeu de pièces tout ensemble d’entiers J = {c1 , . . . , cn } qui contient 1.
3. Adaptez votre algorithme pour qu’il opère sur un jeu de pièces quelconque J = {c1 , . . . , cn }.
On supposera que c1 > c2 > · · · > cn = 1.
4. Montrez, sur un contre-exemple, que votre algorithme ne fonctionne pas pour le jeu J =
{1, 4, 6}.
On cherche désormais à concevoir un algorithme qui calcule, pour tout jeu de pièces J, le nombre
de pièces minimal MJ (x) permettant de fabriquer x. On fixe x ∈ N et on considère un c ∈ J tel
que c ≤ x.
5. Montrer que MJ (x) ≤ 1 + MJ (x − c).
6. Montrer que MJ (x) = 1 + MJ (x − c) si, et seulement si, c apparaît dans une solution opti-
male pour x.
Notons a le plus grand entier tel que a ∈ J et a ≤ x.
7. Déduire de ce qui précède : MJ (x) = 1 + min MJ (x − c).
c∈J, c≤a
8. En déduire un algorithme de programmation dynamique qui, prenant en entrée un jeu de
pièces J et un montant x, retourne MJ (x).
9. Évaluer sa complexité.
10. Faites tourner votre algorithme sur l’entrée x = 13, J = {1, 4, 6}.
Exercice 9 (Les coefficients binomiaux). Les coefficients binomiaux interviennent dans de

nombreuses situations, dans des calculs algébriques, en combinatoire, en probabilité. . . On veut
les calculer de manière efficace. La formule suivante permet un calcul récursif de Cnp , pour
0≤ p≤n:
p−1 p
Cnn = Cn0 = 1 ; Cnp = Cn−1 +Cn−1
1. Écrire une fonction récursive c(n, p) qui calcule Cnp

2. Décrire l’arbre des appels récursifs pour c(6, 3) et calculer le nombre d’appels récursifs.
3. Expliquer pourquoi cet algorithme a un coût exponentiel. Indication : décrire l’arbre des
appels pour le calcul de c(2n, n) et comparer le nombre d’appels récursifs pour c(2n, n) et
c(2n − 2, n − 1).
4. La fonction précédente a un coût trop élevé, on veut donc maintenant améliorer le calcul.
Dessiner le triangle de Pascal pour n = 5, et montrer qu’on peut calculer une ligne en se
contentant de stocker dans un tableau certains des calculs précédents.
5. Écrire une fonction qui calcule les Cnp avec un coût polynomial en utilisant la programma-
tion dynamique.
Exercice 10 (Algorithme de Floyd-Marshall). On considère le problème suivant : étant donné

un graphe valué G = (V, E, `) sans cycle négatif, déterminer la longueur d’un plus court chemin
de u à v pour tout couple de sommets (u, v). On peut résoudre ce problème en applicant l’algo-
rithme de Bellman-Ford à chaque sommet de G. Ceci nécessite un temps O(V ×V E) = O(V 2 E).
Mais il est possible d’améliorer cette borne par un algorithme issu de la programmation dyna-
mique.
(a) Pour définir une notion pertinente de sous-problèmes, on note dist(i, j, k) le poids d’un plus
court chemin de i à j dont tous les sommets intérieurs (i.e., hors extrémités) sont dans
{1, . . . , k}. Etablissez une relation entre dist(i, j, k) et des valeurs de la fonction dist sur
des triplets de "taille" inférieure à celle de (i, j, k). (On utilisera le lien entre les plus courts
chemins de i à j passant par {1, . . . , k} et les plus courts chemins de i à k et de k à j passant
par {1, . . . , k − 1}.)
(b) Construire un ordre sur les triplets de V 3 tel que pour chaque triplet (i, j, k), les triplets
nécessaires au calcul de dist(i, j, k) (selon la relation trouvée en (a)) soient avant (i, j, k)
selon cet ordre.
(c) En déduire l’algorithme attendu.
Exercice 11 (Distance d’édition). Etant donnés deux mots X = x1 . . . xm et Y = y1 . . . yn sur un

alphabet V , on appelle alignement de (X,Y ) tout couple de mots (X 0 ,Y 0 ) sur V ∪ {−} tel que :
1. |X 0 | = |Y 0 | ;
2. X 0 \ − = X et Y 0 \ − = Y ;
3. ∀i ≤ |X 0 |, on n’a pas simultanément X 0 [i] = − et Y 0 [i] = −.
Le coût d’un tel alignement est le nombre de positions sur lesquelles X 0 et Y 0 diffèrent. Autrement
dit :
coût(X 0 ,Y 0 ) = card{i t.q. X 0 [i] 6= Y 0 [i]}.
Exemple :
A B B − B A − B B R C A
A B R A C A D A B R − A
est un alignement de (ABBBABBRCA, ABRACADABRA) de coût 6. La distance d’édition de X à
Y est le coût minimal d’un alignement de (X,Y ). On la note edit(X,Y ).
Écrire un algorithme qui calcule edit(X,Y ).
2010 / 2011
Corrigé du TD no 4
Programmation dynamique
Correction
exercice
1.
0 1 Fn−1 Fn Fn
(a) = =
1 1 Fn Fn−1 + Fn Fn+1
n n
Fn 0 1 F0 0 1 0
(b) D’où l’on déduit : = = .
Fn+1 1 1 F1 1 1 1
n
0 1
Le calcul de Fn se ramène donc à celui de qui se fait en O(log n) multiplications
1 1
scalaires, grâce à l’exponentiation rapide. Si l’on convient que le coût d’une telle multipli-
cation est constant (ce qui est discutable dans ce contexte. . .), on obtient le résultat annoncé.
(a) Soit p = x1 x2 . . . xk un chemin élémentaire de longueur maximale dans G. Alors x1 ne peut
avoir de prédécesseur. Car si tel était le cas, un prédécesseur x de x1 ne pourrait appartenir
à p (sinon le graphe comporterait un cycle), et par conséquent, p0 = xx1 x2 . . . xk serait un
chemin élémentaire de G strictement plus long que p : une contradiction. Il s’ensuit que
δ − (x1 ) = 0.
(b) Outre la structure de donnée matricielle qui code le graphe, l’algorithme ci-dessous utilise
un tableau d − pour tenir à jour les degrés entrants et faciliter le choix d’un sommet de degré
entrant nul. Un ensemble F est par ailleurs créé, qui contient les sommets non encore traités
(i.e., non affichés).
Algorithme 2: Tri topologique
Données : G sous forme d’une matrice G[x, y]
Résultat : Tri topologique à l’affichage
pour x = 1 à n faire
pour y = 1 à n faire si G[x, y]==1 alors d − [y]++
fin
F = V;
tant que F 6= ∅ faire
Choisir x ∈ F tel que d − [x] = 0;
Afficher x;
F = F − {x};
pour y = 1 à n faire
si G[x, y]==1 alors d − [y]- -
fin
fin
(c) L’assertion suivante est un invariant de la boucle tant que :
∀y ∈ F, d − [y] est le nombre de prédécesseurs de y appartenant à F. (∗)
En effet, si elle est vraie avant un passage de boucle, elle l’est encore après puisque les seules
instructions modifiant d − dans la boucle consistent à décrémenter d − [y] pour les successeurs
y d’un sommet qui vient précisément d’être retiré de F, et pour eux seulement. Comme par
ailleurs (∗) est vraie dès lors que l’initialisation de F a été faite (puisqu’à ce moment-là,
F = V et d − contient les degrés entrants des sommets de G), il s’ensuit qu’elle est vraie
à chaque passage de boucle. Par conséquent, le sommet x retiré de F et affiché lors d’un
passage étant caractérisé par d − [x] = 0, on est assuré qu’aucun de ses successeurs ne sera
affiché après lui. L’ordre d’affichage réalisé par l’algorithme est donc bien topologique.
(d) Les deux boucles pour imbriquées qui réalisent l’initialisation de d − s’exécutent clairement
en O(n2 ) (où n est le nombre de sommets du graphe). La boucle tant que est traversée n fois,
puisque F est initialisé à V et que chaque passage dans la boucle décrémente F d’exactement
un sommet. À l’intérieur de la boucle, la première ligne nécessite, dans le pire des cas, un
parcours intégral du tableau d − ; coût : O(n). Les deux instructions suivantes se font en
temps constant et la dernière (boucle pour) s’exécute en O(n). Au total, la boucle tant que
s’exécute en temps O(n2 ) : c’est aussi la complexité de l’algorithme. Notons que pour une
présentation par matrice d’adjacence, cette complexité est qualifiée de linéaire, puisqu’elle
est proportionnelle à la taille de l’entrée.
(e) L’implication ⇒ découle de la preuve de correction établie en (c). La réciproque est immé-
diate.
( f ) mnpoqsrutyvwxz
Correction exercice 3. Soit G = (V, E) un graphe orienté. Pour chaque x ∈ V , on note succ(x)
l’ensemble des successeurs de x (i.e., l’ensemble des y ∈ V tels que xy ∈ E). Si Gr désigne le
graphe inverse de G et si pour y ∈ V , on note succr (y) la liste des successeurs de y dans Gr , on a
clairement : y ∈ succ(x) ssi x ∈ succr (y). L’algorithme qui suit en découle facilement : il déclare
un tableau Gr indexé par les sommets y ∈ V , chaque y pointant vers vers une liste de successeurs
initialisée à ∅. Puis on parcourt les G-successeurs y de chaque sommet x ∈ V , et pour chacun
d’entre eux, on rajoute x à la liste des Gr -successeurs de y.
Algorithme 3: Inversion d’un graphe

Données : G sous forme de listes de successeurs
Résultat : Le graphe inverse de G
pour y ∈ V faire succr (y) = ∅ ;
pour x ∈ V faire
pour y ∈ succ(x) faire
succr (y) = succr (y) + x
fin
fin
retourner Gr
Complexité : la première boucle pour prend clairement un temps O(|V |). L’instruction
succr (y) = succr (y) + x provoque l’ajoût de x en tête de la liste chaînée des successeurs de y
dans Gr : elle s’exécute en temps constant. Les boucles pour imbriquées réalisent un parcours
de tous les successeurs de chaque sommet de G avec exécution, pour chacun d’entre eux, d’une
instruction en temps constant. Le coût total de cette double boucle, et donc de l’algorithme, est
en O(|V | + |E|).
Correction exercice 4. Rappelons l’algorithme vu en cours, pour le calcul des distances à un

sommet fixé :
Algorithme 4: pccDagiter
Données : un DAG pondéré G = (V, E, `) et un sommet s ∈ V .
Résultat : Les distances de s à tout sommet de G
initialiser (d,s) ;
Trier topologiquement V ;
pour chaque v ∈ V dans l’ordre croissant faire
d(v) = min {d(u) + `(u, v)}
u∈pred(v)
fin
retourner d
Nous avons vu que l’initialisation de d se fait en O(|V |). Le tri topologique se fait en O(|V | +
|E|) (Voir Exercice 2). Reste la dernière instruction, exécutée pour chaque v ∈ V . Il est facile
de voir que son temps d’exécution est du même ordre que celui du parcours de la liste des
prédécesseurs de v (le calcul du min se faisant au fur et à mesure de ce parcours, il ne modifie le
temps de calcul que par une constante multiplicative). Dans le cas d’une représentation du graphe
par matrice d’adjacence, le parcours de la liste des prédécesseurs de v se fait en O(|V |) : il suffit
de scanner les 1 dans la colonne de rang v de la matrice. Pour une représentation par liste de
successeurs, c’est plus délicat : repérer tous les prédecesseurs de v nécessite un parcours complet
des listes de successeurs, ce qui se fait en O(|V | + |E|). Plutôt que de consommer ce temps
pour chaque sommet, il est préférable d’inverser le graphe une fois pour toute, de sorte que la
recherche des u ∈ pred(v) se ramène à celle des u ∈ succr (v), bien plus rapide. L’algorithme
s’écrit alors :
Algorithme 5: pccDagiter avec inversion du graphe
Données : un DAG pondéré G = (V, E, `) et un sommet s ∈ V .
Résultat : Les distances de s à tout sommet de G
initialiser (d,s) ;
Trier topologiquement V ;
Calculer Gr ;
pour chaque v ∈ V dans l’ordre croissant faire
d(v) = min {d(u) + `(u, v)}
u∈succr (v)
fin
retourner d
Aux temps de calcul O(|V |) (initialisation de d) et O(|V | + |E|) (tri topologique) déjà évo-
qués, s’ajoutent maintenant le temps consommé par le calcul de Gr , soit O(|V | + |E|) d’après
l’Exercice 3, et celui correspondant à la boucle pour qui consiste essentiellement en un parcours
des successeurs de tous les sommets du graphe, et qui s’exécute donc en O(|V | + |E|). La com-
plexité globale de l’algorithme ainsi détaillé est donc bien en O(|V | + |E|), comme annoncé dans
le cours.
(a) On convient ici que pour une liste T = [t0 ,t1 , . . . ,tn ], l’instruction « insérer r en fin de T »
remplace la T par la liste [t1 ,t2 , . . . ,tn , r]. On améliore alors l’algorithme plsciter en utili-
sant un tableau de dimension 1 et de taille n, de la manière suivante :
Algorithme 6: Amelioration de plsciter
Données : Deux suites X et Y
Résultat : La longueur d’une plus longue sous-suite commune de X et Y
m = lg(X) ; n = lg(Y ) ;
pour j = 0 à n faire T [ j] = 0 ;
pour i = 1 à m faire
pour j = 0 à n faire
si [X]i = [Y ] j alors
r = 1 + T [0]
sinon
r = max{ T [1], T [n]}
fin
insérer r en fin de T
fin
fin
retourner T (n) ;
La procédure « insérer r en fin de T » peut être exécutée en temps constant en représentant
T par une liste chaînée avec un pointeur en tête et un pointeur en fin de liste. Il s’ensuit
facilement que la complexité en temps de cet algorithme est en O(mn), comme l’algorithme
initial. Par contre, la complexité en espace devient un O(n) = O(min(m, n)). (On a supposé
ici que n ≤ m. Dans le cas contraire, il suffit d’inverser les rôles de m et n.)
Correction exercice 6. À chaque suite d’entiers a = a1 , . . . , an on associe le graphe orienté Ga

défini comme suit : Ga comporte n sommets étiquetés par a1 , . . ., an ; un arc joint ai à a j si et
seulement si i < j et ai ≤ a j . Par exemple, pour la suite a = 5, 2, 8, 6, 3, 6, 9, 7 on obtient pour
Ga :
5 2 8 6 3 6 9 7
Par construction, le tri des sommets de Ga selon l’ordre a1 , . . . , an de leurs étiquettes est to-
pologique. Le graphe est donc sans circuit. Par ailleurs, on se convainc aisément du fait que les
sous-suites croissantes de longueur maximale de a correspondent aux chemins de longueur maxi-
male dans Ga . Le problème posé, SSCM(a), se ramène donc au calcul de la longueur maximale
d’un chemin dans le DAG Ga , pondéré par la fonction qui affecte la même longueur 1 à tous les
arcs. D’où l’algorithme, directement adapté de pccDagiter (voir exercice 4) :
Algorithme 7: sscm
initialiser (d,s) ;
max = 0 ;
pour chaque j = 1, . . . , n faire
d( j) = 1 + max{d(i), i ∈ pred( j)} ;
si d( j) > max alors max = d( j) ;
fin
retourner max ;
(a) (10, −5, 40, 10) est un sous-tableau de somme 10 − 5 + 40 + 10 = 55 maximale.
(b) Algorithme très naïf :

Algorithme 8: stsm-tres-naif
Données : Un tableau de réels T [1..n]
Résultat : La valeur maximale de la somme d’un sous-tableau de T
res = 0 ;
pour ` = 1 à n faire
pour h = ` + 1 à n faire
S = T [`] ;
pour i = ` + 1 à h faire S = S + T [i] ;
res = max(res, S) ;
fin
fin
retourner res ;
p p
p(p + 1) p(p + 1)(2p + 1)
Complexité : O(n3 )(grâce aux identités : ∑ j=
2
et ∑ j2 = 6
).
j=1 j=1
Un algorithme moins naïf pour ce problème consiste à parcourir chaque sous-tableau T [`.. j]
en sommant ses éléments. Une variable (res) est comparée à la somme S du sous-tableau et
remplacée par S si S > res.
Algorithme 9: stsm-naif
res = 0 ;
pour ` = 1 à n faire
S = T [`] ;
pour h = ` + 1 à n faire S = S + T [h] ;
res = max(res, S) ;
fin
retourner res ;
(c) Toutes les instructions élémentaires s’exécutent en temps constant. La complexité de l’al-
gorithme est donc proportionnelle au nombre de passage dans la boucle imbriquée. Or pour
chaque ` = 1, . . . , n, la boucle indexée par j s’exécute n − ` fois. Au total, l’exécution des
deux boucle prend donc un temps propotionnel à ∑n`=1 (n − `) = n2 − ∑n`=1 ` = n2 − n(n+1) 2 =
n(n−1) 2
2 . Finalement, la complexité globale de l’algorithme est en O(n ).
1
(d) M(1) = max{ ∑ T [i], 1 ≤ ` ≤ 1} = T [1].
i=`
j
Pour 1 ≤ ` ≤ j ≤ n, notons S(`, j) la somme ∑i=` T [i]. Ainsi, la fonction M( j) de l’énoncé
s’écrit, pour j ∈ {1, . . . , n} : M( j) = max{S(`, j), 1 ≤ ` ≤ j}. De plus, pour tous 1 ≤ ` ≤
j ≤ n : S( j, j) = T [ j] et, si j < n, S(`, j + 1) = S(`, j) + T [ j + 1].
M( j + 1) = max{S(`, j + 1), 1 ≤ ` ≤ j + 1}
= max{S( j + 1, j + 1), max{S(`, j + 1), 1 ≤ ` ≤ j}}
= max{T [ j + 1], max{S(`, j) + T [ j + 1], 1 ≤ ` ≤ j}}
= max{T [ j + 1], T [ j + 1] + max{S(`, j), 1 ≤ ` ≤ j}}
= max{T [ j + 1], T [ j + 1] + M( j)}
Finalement, M( j + 1) = T [ j + 1] + max{0, M( j)}.
(e) La somme maximale des sous-tableaux de T [1..n] s’écrit STSM(T ) = max{S(`, j), 1 ≤ ` ≤
h ≤ n}, c’est à dire : STSM(T ) = max{M( j), 1 ≤ j ≤ n}.
( f ) L’algorithme tire parti de l’égalité établie en (d) pour calculer chaque M( j) par simple mise
à jour de la valeur de M( j − 1) selon que celle-ci est positive ou non. Les valeurs succes-
sivement calculées sont stockées dans une variable M. Le maximum des M( j) – qui est le
résultat cherché, selon (e) –, est stocké dans une variable res et calculé à la volée : res est
comparé à chaque nouvelle valeur de M et mis à jour si nécessaire.
Algorithme 10: stsm
res = 0 ; M = T [1] ;
pour j = 2 à n faire
M = T [ j] + max(0, M) ;
res = max(res, M) ;
fin
retourner res ;
L’algorithme s’exécute clairement en temps O(n).
1. Algorithme glouton pour le calcul de M(x) :
Données : Un entier x ∈ N
Résultat : M(x)
1 res = 0 ;
2 pour c = 10, 5, 2, 1 pris dans cet ordre faire
3 tant que x − c ≥ 0 faire
4 x = x−c ;
5 res++ ;
fin
fin
6 retourner res

3. Adaptation de l’algorithme précédent à un jeu de pièces quelconque J = {c1 , . . . , cn }, avec
c1 > · · · > cn = 1.
Résultat : MJ (x)
1 res = 0 ;
2 pour i = 1 à n faire
3 tant que x − ci ≥ 0 faire
4 x = x − ci ;
5 res++ ;
fin
fin
6 retourner res
4. Pour le jeu J = {1, 4, 6} et l’entrée x = 8, l’algo précédent renvoie 3 (puisque 8 = 6 + 1 + 1)

alors que l’optimum est 2 (8 = 4 + 4).
On fixe x ∈ N et on considère un c ∈ J tel que c ≤ x.
5. Si l’on peut construire x − c avec k pièces de J, alors on peut construire x avec k + 1
pièces de J (en rajoutant une pièce de valeur c aux k pièces précédentes). Ainsi, le nombre
minimal de pièces de J nécessaire pour construire x est inférieur à k + 1. En particulier, en
prenant pour k le nombre MJ (x−c), on obtient la relation cherchée : MJ (x) ≤ 1+MJ (x−c).
male pour x.
⇐ Si c apparaît dans une solution optimale pour x, alors l’ensemble de pièces obtenu en
retirant de cette solution une pièce de valeur c est une solution optimale pour x − c. D’où
MJ (x − c) = MJ (x) − 1.
⇒ Si MJ (x) = 1 + MJ (x − c), notons a1 , . . . , ak une solution optimale pour x − c. En
d’autres termes, supposons que :
– k = MJ (x − c) ;
– les ai sont des éléments non nécessairement distincts de J ;
– x − c = a1 + · · · + ak .
Alors a1 , . . . , ak , c est une solution pour x puisque x = a1 + · · · + ak + c et puisque c, comme
chaque ai , est dans J. Cette solution étant de taille k +1, il s’ensuit que MJ (x) ≤ k +1, c’est-
à-dire, MJ (x) ≤ 1 + MJ (x − c). L’inégalité inverse, prouvée dans la question précédente,
permet de conclure.
7. Soit Ex l’ensemble des entiers de la forme 1 + MJ (x − c) obtenus pour les c ∈ J inférieurs
à x. Autrement dit :
Ex = {1 + MJ (x − c) pour c ∈ J, c ≤ x}.
La question 5 se traduit facilement en : MJ (x) minore Ex (i.e., est inférieur à chaque élément
de Ex ). La question 6 affirme pour sa part que tout c apparaissant dans une solution optimale
pour x réalise l’égalité MJ (x) = 1+MJ (x−c). Ceci entraîne notamment que l’un des entiers
de Ex au moins a pour valeur MJ (x). Ainsi, MJ (x) minore l’ensemble Ex et appartient à cet
ensemble. Cela s’écrit MJ (x) = min Ex , ou encore
MJ (x) = min{1 + MJ (x − c) pour c ∈ J, c ≤ x}
= 1 + min{MJ (x − c) pour c ∈ J, c ≤ x}
C’est l’égalité cherchée.
Données : Un entier x ∈ N ; un jeu de pièces J

Résultat : MJ (x)
M[0] = 0 ;
pour y = 1 à x faire
M[y] = 1 + min M[y − c] ;
c∈J, c≤y
fin
retourner M[x]
9. Complexité : O(x|J|).
10. Simulation de l’algorithme sur l’entrée x = 13, J = {1, 4, 6} :
0 1 2 3 1 2 1 2 2 3 2 3 2 3
D’où : M{1,4,6} (13) = 3.
Distance d’édition
Soit Σ un alphabet et − un symbole n’apparaissant pas dans Σ. Pour tout mot u ∈ (Σ ∪ {−})∗ ,
on note u\− le mot obtenu à partir de u en supprimant toutes les occurences de −. Une expansion
d’un mot x ∈ Σ∗ est un mot u ∈ (Σ ∪ {−})∗ tel u \ − = x. Un alignement de deux mots x, y ∈ Σ∗
est un couple de mots (u = u1 . . . u p , v = v1 . . . vq ) tel que :
1. p = q ;
2. ∀i ≤ p : ui 6= − ou vi 6= − ;
3. u est une expansion de x et v est une expansion de y.
On appelle coût d’un tel alignement le nombre de positions sur lesquelles u et v diffèrent, i.e.
l’entier
coût(u, v) = |{i ≤ p : ui 6= vi }|.
La distance d’édition de deux mots x, y est le coût minimal d’un alignement de ces deux mots.
On la note edit(x, y).
Lemme 1 ∀x, y ∈ Σ∗ , ∀a ∈ Σ : edit(xa, ya) = edit(x, y).
P REUVE . Soit (u1 . . . u p , v1 . . . v p ) un alignement de xa, ya. Soient i, j ≤ p les entiers maximaux
pour lesquels ui 6= − et v j 6= −. Alors ui = v j = a, car la dernière lettre d’une expansion d’un
mot qui diffère de − est égale à la dernière lettre de ce mot. Par ailleurs, l’un de ces entiers au
moins vaut p, sinon on aurait x p = y p = −. Supposons donc, sans perte de généralité, que i = p
(i.e. u p = a). Les deux expansions s’écrivent alors :
u1 . . . u j−1 u j u j+1 . . . u p−1 a

v1 . . . v j−1 a −... − −
avec u j+1 , . . . , u p−1 ∈ Σ∗ . Il s’ensuit que le couple
u1 . . . u j−1 u j u j+1 . . . u p−1 a

v1 . . . v j−1 − − . . . − a
est un nouvel alignement de xa, ya de coût inférieur ou égal au précédent (égal si u j = a, inférieur
sinon). En particulier, si le premier alignement est optimal, le second l’est aussi. Tout ceci permet
d’affirmer que le couple (xa, ya) admet un alignement optimal dont les termes terminent tous
deux par la lettre a.
Considérons donc un alignement optimal de la forme (ua, va) pour xa, ya. Clairement, (u, v)
est un alignement de x, y. De plus, pour tout autre alignement (r, s) de x, y, (ra, sa) est un aligne-
ment de xa, ya et l’on a : coût(r, s) = coût(ra, sa), coût(u, v) = coût(ua, va), et coût(ra, sa) ≥
coût(ua, va), par optimalité de (ua, va). Par conséquent, coût(r, s) ≥ coût(u, v). Ainsi, coût(u, v)
minore le coût de tout alignement de x, y : c’est un alignement optimal.
On obtient finalement :
– edit(x, y) = coût(u, v), par optimalité de (u, v) pour x, y ;
– edit(xa, ya) = coût(ua, va), par optimalité de (ua, va) pour xa, ya ;
– coût(u, v) = coût(ua, va).
D’où le résultat annoncé.
2010 / 2011
TD no 5
Flot maximum
Exercice 1 Trouver le flot maximum du réseau de la figure 2 à l’aide de l’algorithme de Ford-

Fulkerson.
w x
12 20
16
s 10 4 7 t
9
13 4
14 z
y
F IGURE 2 – Un réseau
Exercice 2 Donner un exemple d’exécution de l’algorithme de Ford-Fulkerson qui accomplit

Θ(|E|| f ∗ |) améliorations, où f ∗ est un flot maximal.
Exercice 3 Montrer que le flot de la figure 3 est maximal.
2/2 1/3 0/1 3/3
s b c t
3/4 2/2 2/5
F IGURE 3 – Un flot maximal
Exercice 4 Réseaux à sources et puits multiples. Soient G = (V, E) un graphe orienté, c une
fonction de capacité sur G, S et T deux sous-ensembles disjoints de V , dont les éléments sont
appelés sources et puits respectivement. Un flot sur un tel graphe est une fonction f : E → E qui
satisfait aux deux contraintes :
1. ∀(u, v) ∈ E : 0 ≤ f (u, v) ≤ c(u, v) ;
2. ∀u 6∈ S ∪ T , f (u,V − u) = f (V − u, u).
La valeur du flot f est alors défini par : | f | = f (S,V \ S). Donner un algorithme pour calculer le
flot maximum dans ce contexte, en se ramenant à un problème de flot maximum sur un réseau à
source unique et puits unique.
Exercice 5 Chacun des n chercheurs d’un laboratoire doit utiliser un ordinateur vectoriel pour
effectuer des calculs pendant une ou plusieurs périodes d’une heure. Chaque chercheur i a donné
l’ensemble ci = {h1i , . . . , hdi i } des créneaux horaires où il est disponible pour effectuer ses calculs,
ainsi que le nombre ri de créneaux (ri ≤ di ) dont il a effectivement besoin.
On cherche à affecter les créneaux horaires aux chercheurs de manière à satisfaire tout le
monde, sachant que l’ordinateur ne peut accueillir plus de deux personnes à la fois.
(a) Modéliser ce problème en terme de problème de flots.
(b) Résoudre le problème pour les entrées suivantes :
c1 = {1, 2, 4, 5} r1 = 3 c1 = {1, 2, 3, 4, 5} r1 = 3
c2 = {2, 3, 4, 6} r2 = 2 c2 = {2, 3, 4} r2 = 2
c3 = {1, 3, 4} r3 = 2 c3 = {2, 3} r3 = 2
c4 = {2, 3, 4, 5} r4 = 3 c4 = {3, 4} r4 = 2
c5 = {4, 5, 6} r5 = 1 c5 = {2, 4} r5 = 1
c6 = {1, 3, 5} r6 = 1
Exercice 6 Un graphe non orienté G = (V, E) est biparti si son domaine V admet une partition
V = L ∪ R telle que toute arête (u, v) ∈ E ait une extrémité dans L et l’autre dans R. Un couplage
dans un tel graphe est un ensemble d’arêtes M ⊆ E tel que chaque sommet u ∈ V touche au plus
une arête de M. Un couplage maximal est un couplage de cardinal maximal.
Soit G = (V, E) un graphe biparti pour la partition V = L ∪ R. On considère le réseau G0 =
(V 0 , E 0 ) défini comme suit : V 0 = V ∪ {s,t} où s et t sont deux nouveaux sommets n’appartenant
pas à V ; E 0 = (E ∩ (L × R)) ∪ ({s} × L) ∪ (R × {t}). Chaque arc est étiqueté d’une capacité 1.
(a) Soit M un couplage de G. Montrer qu’il existe un flot f sur G0 de valeur | f | = |M|.
(b) Soit f un flot sur G0 . Montrer qu’il existe un couplage de G de cardinal |M| = | f |.
Exercice 7 Connectivité et flot. La connectivité d’un graphe non orienté est le nombre minimum
d’arêtes qu’il faut supprimer pour déconnecter le graphe.
(a) Quelle est la connectivité d’un arbre ? D’un cycle ?
(b) Comment calculer la connectivité d’un graphe en exécutant un algorithme de recherche du
flot maximum sur au plus |V | réseaux, chacun comportant O(V ) sommets et O(E) arcs ?
Exercice 8 (Intersection et union de coupures minimales. ). Soient (S1 , S1 ) et (S2 , S2 ) deux cou-
pures minimales dans un réseau. Montrer que les coupures (S1 ∪ S2 , S1 ∪ S2 ) et (S1 ∩ S2 , S1 ∩ S2 )
sont minimales.
Exercice 9 (Chemins intérieurement sommet-disjoints). À l’aide de l’algorithme de F ORD -
F ULKERSON, trouver le nombre maximum de st-chemins intérieurement sommet-disjoints du
graphe de la figure 4.
Exercice 10 La connexité κ(u, v) entre deux sommets u et v d’un graphe est le nombre minimal
de sommets que l’on doit retirer du graphe pour déconnecter u et v. La connexité de G, notée
κ(G), est la cardinalité minimum d’un ensemble de sommets S tel que G − S n’est pas connexe.
Un graphe est k-connexe si κ(G) ≥ k.
a b
s t
c d
F IGURE 4 – Chemins intérieurement disjoints
(a) Montrer que κ(G) = min{(u, v)|u, v ∈ V (G)}.

(b) Montrer que κ(u, v) est égal au nombre maximum de chemins deux à deux sommet-disjoints
reliant u et v.
(c) En déduire le théorème suivant du à Menger : un graphe est k-connexe si et seulement si
pour tout couple de sommets (u, v), il existe k (u, v)-chemins sommet-disjoints.
(d) Donner un exemple de graphe régulier de degré k et de connexité 1.
(e) Montrer que un graphe est régulier de degré 4k, alors il contient un sous-graphe k-connexe.
(On pourra montrer le résultat par induction sur le nombre de sommets de G).
Exercice 11 (Un étrange phénomène). L’algorithme de Ford-Fulkerson commence par le flot

nul. Cette contrainte est importante comme nous allons le voir maintenant.
On pose α la racine positive de l’équation x3 + x − 1 = 0, et on considère le réseau (G, c, s,t)
décrit Fig. 5 où toutes les capacités sont ∞. On part du flot f0 donné sur cette même figure.
Considérer la suite de chemins augmentants :
– ∀m, p4m = scdabt, avec s ← c → d ← a → b ← t
– ∀m, p4m+1 = scbadt, avec s ← c → b ← a → d ← t
– ∀m, p4m+2 = sabcdt, avec s ← a → b ← c → d ← t
– ∀m, p4m+3 = sadcbt, avec s ← a → d ← c → b ← t
(a) Que vaut le flot max de ce réseau ?

(b) Calculer par récurrence le flot fi (i > 0) obtenu à partir de fi−1 par augmentation le long du
chemin pi−1 .
(c) En déduire limi→∞ val( fi ).
Exercice 12 (Un algorithme de couplage sur les bipartis). La démonstration du théorème Min-
Max de KÖNIG donne immédiatement l’algorithme (très schématique) suivant :
α
0
a d
0 1
0
α s 1 t
0 1+α2
α+α2
b c
α2
0
F IGURE 5 – Un flot bizarre
Algorithme 11: Un algorithme de couplage

Données : un graphe biparti G, et A ∪ B une bipartition de G
Résultat : la taille d’un plus grand couplage M de G.
Orienter toutes les arêtes {a, b} (avec a ∈ A et b ∈ B) de a vers b;
Rajouter un sommet s et toutes les arêtes s → a, a ∈ A;
Rajouter un sommet t et toutes les arêtes b → t, b ∈ B;
Soit G0 ce nouveau graphe ;
Calculer une st-sommet coupure (ou le nombre maximal de st-chemins intérieurement
sommet-disjoints) de G;
Le problème, c’est que le calcul d’une sommet-coupure est lourd à implanter.
(a) Montrer que dans G0 , les st-chemins sommet-disjoints sont les st-chemins arête-disjoints.
Donc on peut se contenter de calculer le nombre maximal de st chemins arête-disjoints de
G0 .
(b) Faire tourner cette version améliorée sur le graphe de la figure 6 :
F IGURE 6 – Quel est le couplage maximum ?
Exercice 13 (L’algorithme d’E DMONDS -K ARP). L’objectif de cet exercice est de prouver la
complexité de l’algorithme d’E DMONDS -K ARP, qui calcule un flot maximal en temps O(V E 2 ).
Cet algorithme ne se différencie de celui de F ORD -F ULKERSON que par l’heuristique suivante :
dans chaque nouveau graphe résiduel, l’algorithme d’E DMONDS -K ARP choisit comme chemin
améliorant un plus court chemin entre s et t.
(a) Considérant un réseau G = (V, E, c, s,t), notons G1 , . . . , Gk les réseau résiduels successive-
ment obtenus dans l’exécution de l’algorithme d’E DMONDS -K ARP sur l’entrée G. Notons
de plus di (v), pour chaque sommet v, la distance de s à v dans Gi . Montrer que pour tout
i < k et tout v ∈ V : di (v) ≤ di+1 (v).
(b) Au cours de l’algorithme, un arc uv peut apparaître et disparaître un certain nombre de fois
dans le graphe résiduel. Montrer que ce nombre est majoré par V /2.
(c) En déduire que l’algorithme d’E DMONDS -K ARP s’exécute en temps O(V E 2 ).
2010 / 2011
Corrigé du TD no 5
Flot maximum

(a) Pour i < k fixé, on prouve di (v) ≤ di+1 (v) par récurrence sur di+1 (v). Si di+1 (v) = 0, alors
v = s et le résultat est clair puisque d j (s) = 0 pour tout j. Sinon, soit u le prédécesseur de v
dans un plus court chemin de s à v. (S’il n’y a pas de chemin entre s et v, alors di+1 (v) = ∞
et le résultat est clair.) Alors di+1 (u) = di+1 (v) − 1 et donc, par hypothèse de récurrence :
di (u) ≤ di+1 (u). D’où
di+1 (v) ≥ di (u) + 1. (2)
Deux cas de figure se présentent alors :
• Si uv ∈ Ei , alors di (v) ≤ di (u) + 1 (puisque un pcc entre s et u suivit de l’arc uv constitue
un chemin de longueur di (u) + 1 entre s et v). Il s’ensuit di+1 (v) ≥ di (v) par (3).
• Si uv ∈/ Ei , alors nécessairement vu ∈ Ei , et même : vu est sur le chemin améliorant choisi
par l’algorithme dans Gi pour augmenter le flot 1 . Ceci signifie, par définition de l’algorithme
d’E DMONDS -K ARP, que vu est sur un plus court chemin de s à u. Par conséquent, di (v) =
di (u) − 1, d’où par (3), di+1 (v) ≥ di (v) + 1 et a fortiori : di+1 (v) ≥ di (v).
(b) Supposons qu’un arc uv soit dans Gi et G j+1 (i < j) mais dans aucun des réseaux résiduels
Gi+1 , . . . , G j . Alors, uv est dans le chemin augmentant choisi en Gi et donc di (v) = di (u) + 1.
D’autre part, vu est dans le chemin augmentant choisi en G j et donc d j (v) = d j (u) − 1.
L’inégalité établie en (a) entraîne alors : d j (v) ≥ di (v) d’où d j (u) − 1 ≥ di (u) + 1, c’est-à-
dire : d j (u) ≥ di (u) + 2.
Ainsi, la distance de s à u s’accroît d’au moins deux unités à chaque réapparition de uv
dans le graphe résiduel. Comme cette distance est majorée par |V | (ou ∞), il s’ensuit que le
nombre de disparitions de uv est majoré par |V |/2.
(c) Il s’ensuit que le nombre de disparitions d’arc au cours de l’exécution de l’algorihthme
d’E DMONDS -K ARP est majoré par EV /2. Comme il se produit au moins une telle dispari-
tion à chaque amélioration, cela signifie que le nombre d’amélioration est lui même majoré
par EV /2. Or chaque amélioration coûte un temps O(E). La complexité annoncée s’en dé-
duit.
1. Notons que pour tout arc uv de G, un réseau résiduel de G contient au moins l’un des couples uv et vu. De
plus, si uv n’est pas dans un Gi , cela implique que le flux est saturé entre u et v. Mais si cet arc apparaît dans Gi+1 ,
c’est qu’entre temps le flux entre u et v a été modifié. Ceci impose que uv est sur le chemin améliorant issu de Gi .
2010 / 2011
TD no 6
Révisions
Exercice 1 (L’algorithme d’E DMONDS -K ARP). L’objectif de cet exercice est de prouver la
complexité de l’algorithme d’E DMONDS -K ARP, qui calcule un flot maximal en temps O(V E 2 ).
Cet algorithme ne se différencie de celui de F ORD -F ULKERSON que par l’heuristique suivante :
dans chaque nouveau graphe résiduel, l’algorithme d’E DMONDS -K ARP choisit comme chemin
améliorant un plus court chemin entre s et t.
(a) Considérant un réseau G = (V, E, c, s,t), notons G0 , G1 , . . . , Gk les réseau résiduels successi-
vement obtenus dans l’exécution de l’algorithme d’E DMONDS -K ARP sur l’entrée G. Notons
de plus di (v), pour chaque sommet v, la distance de s à v dans Gi . Montrer que pour tout i < k
et tout v ∈ V : di (v) ≤ di+1 (v).
(b) Au cours de l’algorithme, un arc uv peut apparaître et disparaître un certain nombre de fois
dans le graphe résiduel. Montrer que ce nombre est majoré par V /2.
(c) En déduire que l’algorithme d’E DMONDS -K ARP s’exécute en temps O(V E 2 ).
Exercice 2 (Rendu de monnaie). Un commerçant dispose d’une quantité illimitée de pièces de

1, 2, 5 et 10 euros. Il peut obtenir n’importe quelle somme x ∈ N à partir de ces pièces, mais
cherche à minimiser le nombre total de pièces utilisées.
1. Proposez un algorithme glouton qui, prenant en argument une valeur x ∈ N, retourne le
nombre de pièces minimal M(x) permettant d’obtenir x.
On appelle jeu de pièces tout ensemble d’entiers J = {c1 , . . . , cn } qui contient 1.
3. Adaptez votre algorithme pour qu’il opère sur un jeu de pièces quelconque J = {c1 , . . . , cn }.
On supposera que c1 > c2 > · · · > cn = 1.
4. Montrez, sur un contre-exemple, que votre algorithme ne fonctionne pas pour le jeu J =
{1, 4, 6}.
On cherche désormais à concevoir un algorithme qui calcule, pour tout jeu de pièces J, le nombre
de pièces minimal MJ (x) permettant de fabriquer x. On fixe x ∈ N et on considère un c ∈ J tel
que c ≤ x.
5. Montrer que MJ (x) ≤ 1 + MJ (x − c).
male pour x.
Notons a le plus grand entier tel que a ∈ J et a ≤ x.
7. Déduire de ce qui précède : MJ (x) = 1 + min MJ (x − c).
c∈J, c≤a
9. Évaluer sa complexité.
10. Faites tourner votre algorithme sur l’entrée x = 13, J = {1, 4, 6}.
2010 / 2011
Corrigé du TD no 6
Révisions
(a) Pour i < k fixé, on prouve di (v) ≤ di+1 (v) par récurrence sur di+1 (v). Si di+1 (v) = 0, alors
v = s et le résultat est clair puisque d j (s) = 0 pour tout j. Sinon, soit u le prédécesseur de v
dans un plus court chemin de s à v. (S’il n’y a pas de chemin entre s et v, alors di+1 (v) = ∞
et le résultat est clair.) Alors di+1 (u) = di+1 (v) − 1 et donc, par hypothèse de récurrence :
di (u) ≤ di+1 (u). D’où
di+1 (v) ≥ di (u) + 1. (3)
Deux cas de figure se présentent alors :

• Si uv ∈ Ei , alors di (v) ≤ di (u) + 1 (puisque un pcc entre s et u suivit de l’arc uv constitue
un chemin de longueur di (u) + 1 entre s et v). Il s’ensuit di+1 (v) ≥ di (v) par (3).
• Si uv ∈/ Ei , alors nécessairement vu ∈ Ei , et même : vu est sur le chemin améliorant choisi
par l’algorithme dans Gi pour augmenter le flot 2 . Ceci signifie, par définition de l’algorithme
d’E DMONDS -K ARP, que vu est sur un plus court chemin de s à u. Par conséquent, di (v) =
di (u) − 1, d’où par (3), di+1 (v) ≥ di (v) + 1 et a fortiori : di+1 (v) ≥ di (v).
(b) Supposons qu’un arc uv soit dans Gi et G j+1 (i < j) mais dans aucun des réseaux résiduels
Gi+1 , . . . , G j . Alors, uv est dans le chemin augmentant choisi en Gi et donc di (v) = di (u) + 1.
D’autre part, vu est dans le chemin augmentant choisi en G j et donc d j (v) = d j (u) − 1.
L’inégalité établie en (a) entraîne alors : d j (v) ≥ di (v) d’où d j (u) − 1 ≥ di (u) + 1, c’est-à-
dire : d j (u) ≥ di (u) + 2.
Ainsi, la distance de s à u s’accroît d’au moins deux unités à chaque réapparition de uv
dans le graphe résiduel. Comme cette distance est majorée par |V | (ou ∞), il s’ensuit que le
nombre de disparitions de uv est majoré par |V |/2.
(c) Il s’ensuit que le nombre de disparitions d’arc au cours de l’exécution de l’algorihthme
d’E DMONDS -K ARP est majoré par EV /2. Comme il se produit au moins une telle dispari-
tion à chaque amélioration, cela signifie que le nombre d’amélioration est lui même majoré
par EV /2. Or chaque amélioration coûte un temps O(E). La complexité annoncée s’en dé-
duit.
2. Notons que pour tout arc uv de G, un réseau résiduel de G contient au moins l’un des couples uv et vu. De
plus, si uv n’est pas dans un Gi , cela implique que le flux est saturé entre u et v. Mais si cet arc apparaît dans Gi+1 ,
c’est qu’entre temps le flux entre u et v a été modifié. Ceci impose que uv est sur le chemin améliorant issu de Gi .
1. Algorithme glouton pour le calcul de M(x) :
Résultat : M(x)
1 res = 0 ;
2 pour c = 10, 5, 2, 1 pris dans cet ordre faire
3 tant que x − c ≥ 0 faire
4 x = x−c ;
5 res++ ;
fin
fin
6 retourner res
3. Adaptation de l’algorithme précédent à un jeu de pièces quelconque J = {c1 , . . . , cn }, avec
c1 > · · · > cn = 1.
Résultat : MJ (x)
1 res = 0 ;
2 pour i = 1 à n faire
3 tant que x − ci ≥ 0 faire
4 x = x − ci ;
5 res++ ;
fin
fin
6 retourner res
4. Pour le jeu J = {1, 4, 6} et l’entrée x = 8, l’algo précédent renvoie 3 (puisque 8 = 6 + 1 + 1)
alors que l’optimum est 2 (8 = 4 + 4).
On fixe x ∈ N et on considère un c ∈ J tel que c ≤ x.
5. Si l’on peut construire x − c avec k pièces de J, alors on peut construire x avec k + 1
pièces de J (en rajoutant une pièce de valeur c aux k pièces précédentes). Ainsi, le nombre
minimal de pièces de J nécessaire pour construire x est inférieur à k + 1. En particulier, en
prenant pour k le nombre MJ (x−c), on obtient la relation cherchée : MJ (x) ≤ 1+MJ (x−c).
male pour x.
⇐ Si c apparaît dans une solution optimale pour x, alors l’ensemble de pièces obtenu en
retirant de cette solution une pièce de valeur c est une solution optimale pour x − c. D’où
MJ (x − c) = MJ (x) − 1.
⇒ Si MJ (x) = 1 + MJ (x − c), notons a1 , . . . , ak une solution optimale pour x − c. En
d’autres termes, supposons que :
– k = MJ (x − c) ;
– les ai sont des éléments non nécessairement distincts de J ;
– x − c = a1 + · · · + ak .
Alors a1 , . . . , ak , c est une solution pour x puisque x = a1 + · · · + ak + c et puisque c, comme
chaque ai , est dans J. Cette solution étant de taille k +1, il s’ensuit que MJ (x) ≤ k +1, c’est-
à-dire, MJ (x) ≤ 1 + MJ (x − c). L’inégalité inverse, prouvée dans la question précédente,
permet de conclure.
7. Soit Ex l’ensemble des entiers de la forme 1 + MJ (x − c) obtenus pour les c ∈ J inférieurs
à x. Autrement dit :
Ex = {1 + MJ (x − c) pour c ∈ J, c ≤ x}.
La question 5 se traduit facilement en : MJ (x) minore Ex (i.e., est inférieur à chaque élément
de Ex ). La question 6 affirme pour sa part que tout c apparaissant dans une solution optimale
pour x réalise l’égalité MJ (x) = 1+MJ (x−c). Ceci entraîne notamment que l’un des entiers
de Ex au moins a pour valeur MJ (x). Ainsi, MJ (x) minore l’ensemble Ex et appartient à cet
ensemble. Cela s’écrit MJ (x) = min Ex , ou encore
MJ (x) = min{1 + MJ (x − c) pour c ∈ J, c ≤ x}

= 1 + min{MJ (x − c) pour c ∈ J, c ≤ x}
C’est l’égalité cherchée.

Données : Un entier x ∈ N ; un jeu de pièces J

Résultat : MJ (x)
M[0] = 0 ;
pour y = 1 à x faire
M[y] = 1 + min M[y − c] ;
c∈J, c≤y
fin
retourner M[x]
9. Complexité : O(x|J|).
10. Simulation de l’algorithme sur l’entrée x = 13, J = {1, 4, 6} :
0 1 2 3 1 2 1 2 2 3 2 3 2 3
D’où : M{1,4,6} (13) = 3.

Master 1 D'informatique 2010 / 2011 Recherche Opérationnelle

Transféré par

Informations du documentcliquez pour développer les informations du document

Droits d'auteur :

Formats disponibles

Master 1 D'informatique 2010 / 2011 Recherche Opérationnelle

Transféré par

Informations du document

Description originale:

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

Master 1 D'informatique 2010 / 2011 Recherche Opérationnelle

Transféré par

Droits d'auteur :

Formats disponibles

Master 1 d’Informatique Recherche Opérationnelle

Généralités sur les graphes

Exercice 1 Soit G = (V, E) un graphe.

Exercice 5 Prouver le Lemme 4.

Exercice 9 On définit inductivement une classe de graphes non orientés C par :

Exercice 12 Combien existe-t-il de graphes orientés (resp. non orientés) à n sommets ?

Exercice 14 (Connectivité de sous-graphes et d’extensions de graphes). On désigne par ω(G)

Exercice 15 Prouver le Lemme 8.

Exercice 16 Prouver la Proposition 10.

Généralités sur les graphes

Correction exercice 6. ⇒ : Soient (U,V ) la bipartition de V (G), u ∈ U, v ∈ V . Soit p :

Correction exercice 8. Commençons par introduire quelques définitions : si p : x y et q :

Correction exercice 11.

F IGURE 1 – ( fi ) = (2, 1, 5, 3, 6, 7) ; (si ) = (1, 3, 3, 4, 4, 4)

On s’intéresse en fait uniquement au (n − 2)-uplet U = (s1 , . . . , sn−2 ) qui identifie de manière

Correction exercice 14.

Correction exercice 15.

Or tout chemin de longueur k entre xi et x j se décompose en un chemin de longueur k − 1 entre

Arbres couvrants minimaux

Exercice 8 Montrer que la variante suivante de l’algorithme de Kruskal retourne un arbre

Données : Un graphe non orienté connexe pondéré G = (V, E, w)

(a) Montrer que cet algorithme termine sur toute entrée.

Arbres couvrants minimaux

Correction exercice 2. (a) ⇒ (b) : le graphe T − a admet deux composantes connexes P1 et

2ème méthode. Soit T un ACM de G. Si T contient a, c’est fini. Sinon, T + a contient un

F est un sous-graphe acyclique couvrant de poids minimal de H. (∗)

Correction exercice 12.

Algorithmes gloutons - Matroïdes

Exercice 2 (Min/Max graphique/cographique). Relire les définitions des matroïdes graphique

Exercice 4 (Calculer dans un matroïde). On se donne un matroïde M = (E, I ) et un algorithme

Exercice 6 (Processeur séquentiel). On considère un ensemble de tâches Ti , 1 ≤ i ≤ n, ayant

Exercice 9 (Un nouveau matroïde). On considère un ensemble fini E et une partition E1 , . . . , Ek

Montrer que (E, I ) est un matroïde.

Données : Un graphe non orienté G

(a) Montrer que cet algorithme termine sur toute entrée.

Correction exercice 1. Pour chaque exemple (X, I ) envisagé on montre que :

Matroïde cographique M ∗ (G) : Par définition de M ∗ (G), un ensemble I ⊆ E est indépendant

ce qui contredit l’hypothèse « G − J connexe ».

Matroïde uniforme Uk,n : (a) |∅| ≤ k.

tel que |I ∩ Ei | < |J ∩ Ei | ≤ 1, c’est-à-dire : |I ∩ Ei | = 0 et |J ∩ Ei | = 1. Clairement, l’unique

Correction exercice 10.

Exercice 1 (Amélioration Fibonacci). Soit (Fn )n≥0 la suite de Fibonacci.

(b) En déduire un algorithme en O(log n) pour le calcul de Fn .

Exercice 2 (Tri topologique).

Exercice 4 Déduire des exercices 2 et 3 la complexité exacte de l’algorithme pccDagiter vu

Exercice 6 (Sous-suites croissantes maximales). Une sous-suite d’une suite d’entiers a = a1 , . . . , an

SSCM : Entrée : une suite d’entiers a ;

Exercice 7 (Sous-tableau de somme maximum). Etant donné un tableau de réels T [1..n], un

STSM : Entrée : un tableau de réels T [1..n] ;

(d) Calculer M(1) et établir une relation entre M( j + 1) et M( j) pour j < n.

Exercice 8 (Rendu de monnaie). Un commerçant dispose d’une quantité illimitée de pièces de

Exercice 9 (Les coefficients binomiaux). Les coefficients binomiaux interviennent dans de

1. Écrire une fonction récursive c(n, p) qui calcule Cnp

Exercice 10 (Algorithme de Floyd-Marshall). On considère le problème suivant : étant donné

Exercice 11 (Distance d’édition). Etant donnés deux mots X = x1 . . . xm et Y = y1 . . . yn sur un

Algorithme 3: Inversion d’un graphe

Correction exercice 4. Rappelons l’algorithme vu en cours, pour le calcul des distances à un