AlgorlLhmes eL Craphes

Loic PeloueL

Lolc.heloueL[lrlsa.fr
lan
1. uenluons de base
2. arcours
1. en largeur
2. en profondeur
3. Arbres couvranLs : kruskal eL rlm
4. lus courLs chemlns
3. ul[ksLra
6. 8ellman-lord
7. lloyd Warshall
8. !ohnson
3. lloL Maxlmal : lord lulkerson
4. ConnexlLe :
1. 8echerche de cycles : 1lernan
2. ComposanLes connexes : 1ar[an
uenluons
Definition 1 : Un graphe non- orient est un couple G=(V,E) dans lequel
V est un ensemble de sommets
E ! V x V est un ensemble dartes

Definition 2: Un graphe orient est un couple (V,A) dans lequel
V est un ensemble de sommets
A ! V x V est un ensemble dartes

Definition 3: Un graphe pondr est un graphe dans lequel
chaque arte (arc) possde un poids (rel)


Definition 4 Un chemin dans un graphe est une squence ! = s
0
.s
1
s
k
telle que
(s
i
, s
i+1
) est une arte (resp. un arc) de G. Un chemin ! est un cycle ssi
s
0
= s
k

Le poids dun chemin ! = s
0
.s
1
s
k
est :
!
" #
+
1 .. 0
1
) , (
k i
i i
s s c
! ! A c :
uenluons
s
0

s
1

s
3

s
2

Exemple de graphe
s
0

s
1

s
3

s
2

s
0

s
1

s
3

s
2

10
3.5
2
9.1
7
Exemple de graphe orient
Exemple de graphe orient et pondr
Poids(s
0
.s
1
.s
0
.s
1
.s
3
) = 35.2
uenluons
Definition 5 : Un successeur dun sommet x dans un graphe G=(V,E) (resp G=(V,A))
est un sommet y tel que (x,y) " E (resp (x,y) " A)

Definition 6: Le degr dun sommet est le nombre de ses successeurs. Le degr dun
graphe est le degr maximal de ses sommets

Definition 7: Un graphe pondr est un graphe dans lequel
chaque arte (arc) possde un poids (rel)

Definition 8: Un chemin hamiltonien est un chemin de G qui passe une et une seule
fois par tous ses sommets de G. G est un graphe hamiltonien sil possde
un cycle passant par tous ses sommets une et une seule fois

Dfinition 9: deux sommets x et y sont distance k si le plus court chemin
allant de x y comporte k arcs
8epresenLauon
Reprsentation Matricielle
s
0

s
1

s
3

s
2

0
1
2
3
0 1 2 3
F T T F
T F T F
F F T T
F F F F
0
1
2
3
0 1 2 3
-1 9.1 3.5 -1
10 -1 -1 7
-1 -1 -1 2
-1 -1 -1 -1
s
0

s
1

s
3

s
2

10
3.5
2
9.1
7
Espace utilis #(n
2
)
8epresenLauon
Reprsentation par liste
dadjacence
s
0

s
1

s
3

s
2

0
1
2
3
1 2
0 1
2 3
Espace utilis #(n+p)
arcours
Parcours en profondeur dabord

Choisir un sommet de dpart, et suivre un chemin aussi loin que possible en
marquant les sommets, et sans repasser par un sommet marqu.
Lorsquun sommet marqu est atteint, le parcours reprend au dernier choix



Procedure Profondeur (G, s )

Marque:tableau[1..n] de booleens

Pour i dans 1..n faire
marque[i]:=faux
finpour
Pour i dans 1..n faire
si marque[i]:=faux alors
prof(i,G,marque)
finsi
finpour

arcours
Procedure prof (s:entier,
G:Graphe, M:tableau[1..n] de booleens)
Var j,v: entiers /* sommets */

M[s] := vrai
Pour j dans 1.. Degr(s) faire
v:= j
eme
successeur de s
Si M[v]=faux alors prof(v,G,M) finsi

finpour
arcours
Procedure prof (s:entier,
G:Graphe, M:tableau[1..n] de booleens)
Var j: entiers /* sommets */

M[s] := vrai
Pour j dans 1..n faire
si G[s,j]=vrai et M[j]=faux alors
prof(j,G,M)
finsi
finpour
(Version matricielle)
arcours
s
1
2
3
4
1
2
1
2
1
1
1
1
1
1
2
8
3
9
3
4
5
6
7
arcours
Parcours en largeur dabord

Choisir un sommet de dpart s, et visiter tous ses successeurs avant de visiter
les autres descendants.
Le parcours en largeur visite les sommets distance 1 de s
puis les sommets distance 2,
.





arcours
Parcours en largeur dabord

Procedure larg(s: entier, G: graphe,
M: tableau [1..n] dentiers)

Var, v,w,i : entiers, F: file

F:= file vide
M[s]:= vrai
F:= ajouter(F,s)
Tant que (non vide(F)) faire
v:= premier(F)
pour i dans 1.. Degr(v) faire
w= ieme successeur de v
si M[w] = faux alors
M[w] := vrai
F:= ajouter(F,w)
finsi
finpour
Fintantque
arcours
s
1
2
3
4
1
2
1
2
1
1
1
1
1
1
2
8
7
4
5
3
9
6
3
arcours
Algorithmes de base

! pour les graphes : Tarjan, Tiernan
! pour la rsolution de problmes dont
lespace de solutions se reprsente comme un graphe
ex : algos gloutons


Largeur ou profondeur : O(|V| +|A|) (avec les bonnes structures de donnes)

Lequel choisir ?

dpend de la structure du graphe et de la nature du problme
rsoudre

Arbres CouvranLs
Definition : Un arbre couvrant dun graphe G=(V,E) est
un sous-graphe G=(V,E) tel que

! G est un arbre
! E ! E


Le poids dun arbre couvrant est dfini par

!
"
=
' ,
] , [
E j i
j i M W
Arbres couvranLs
6
4
3
9
9
18
10
9
3
2
2
9
9
4
4
1
3
8
9
8
7
Arbre couvranL mlnlmal :

C : graphe
! connexe
! value
! non orlenLe

1rouver un ensemble darrLes:

! connecLanL Lous les sommeLs
! de polds mlnlmal
AlgorlLhme de rlm :
Cholslr un sommeL arblLralre
falre crolLre un arbre a parur de ce sommeL
de la manlere la plus economlque posslble
Arbres couvranLs
AlgorlLhme de rlm !"#$%&'()*+,

Procedure Prim(s,G)

entier s; /* sommet initial*/
graph G =(S,A,C) /*sommets/arrtes/cout*/

Variables :

graph T /* labre en construction*/
int i, m, y ;
real : v ;
Set : M /* sommets non tudis*/
int closer[1..N] /* plus proche sommet de T*/
real d[1..N] /* plus petite distance entre
un sommet et un sommet de larbre*/


Arbres couvranLs
AlgorlLhme de rlm ./*%0'1


T := graphe_vide
M := ensemble_vide
Pour i= 0 jusqu' N Faire
d[i] := cot(s, i, G) /* " si pas darc */
closer[i] := s
M := Ajouter (i,M)
Fin pour

M := Supprimer (s,M) /* s = sommet de dpart */

Tant que M <> Ensemble_vide Faire
m := Choisir_min(M,d)
M := Supprimer (m,M)
z := closer[m]
v := cot (m,z,G)
T := Ajout arte <m,z> de cot v T
Pour tout y successeur de m dans G
Si y#M et (cout(m,y,G) < d[y]) alors
d[y] := cot(m,y,G)
closer[y] := m
Fin Si
Fin Pour
Fin Tant que
6
4
3
9
9
18
10
9
3
2
2
9
9
4
4
1
3
8
9
8
7
6
4
3
9
9
18
10
9
3
2
2
9
9
4
4
1
3
8
9
8
7
6
4
3
9
9
18
10
9
3
2
2
9
9
4
4
1
3
8
9
8
7
6
4
3
9
9
18
10
9
3
2
2
9
9
4
4
1
3
8
9
8
7
Etc
Arbres couvranLs
Prim fonctionne par parcours de larbre en choisissant
les poids minimum

Complexit : O( |V| x |E| )

M,d,closer modlisent en fait un ensemble darrtes.

Chaque arrte ne peut tre choisie quune fois

Pour chaque nouvelle arrte ajoute, on recherche de nouveaux
successeurs (au plus |V| )

Peut tre amlior en O( |E| x log(|V|) ) si
M est modlis par un tas
Arbres couvranLs
Algorithme de Kruskal !"#$%&'()*+,

Utilisation dun tableau

comp[1..n] pour reprsenter les composantes connexes

Comp[i].repr = reprsentant de la composante connexe du sommet i
(sommet de plus petit numro)

Comp[i].card = cardinal de la composante


Arbres CouvranLs
Par union de composantes connexes : Kruskal
Procedure Union(x,y: entiers; /* des numros de sommets */
Var comp tableau[1..n] de structure repr, card
Var j1,j2,k: entiers;


j1:= comp[x].repr ; j2:= comp[y].repr
Si comp[j1].card > comp[j2].card alors
pour k dans 1 n faire
si comp[k].repr = j2 alors comp[k].repr:=j1
finsi
finpour
comp[j1].card := comp[j1].card + comp[j2].card

sinon
pour k dans 1 n faire
si comp[k].repr = j1 alors comp[k].repr:=j2
finpour
comp[j2].card := comp[j2].card + comp[j1].card
finsi
Arbres CouvranLs
Algorithme de Kruskal
Procedure Kruskal (Graphe G, Graphe T)
/* S = sommets de G */
/* cout : fonction de cout des arcs */

Var comp : tableau[1..n] de structure repr, card : 1..n
i: entiers; x,y: entiers /* sommets */

T:= graphe vide
Pour i dans 1 n faire ajouter un sommet T finpour
U:=A
Pour i dans 1 n faire /* autant de composantes que de sommets */
comp[i].repr=i
comp[i].card=1
finpour
i:=1
Tant que i<n faire
{x,y}:=min(U); U := supprimer({x,y},U)
si comp[x].repr <> comp[y].repr alors
union(x,y,comp)
T:= ajouter_arrte {x,y} T
i:=i+1
finsi
fintantque
6
4
3
9
9
18
10
9
3
2
2
9
9
4
4
7
3
8
9
8
7
1
4
5
6
7
8
9
10
2
3
6
4
3
9
9
18
10
9
3
2
9
9
4
4
7
3
8
9
8
7
1
4
5
3
7
8
9
10
2
3
3
6
T=
6
4
3
9
9
18
10
9
3
9
9
4
4
7
3
8
9
8
7
1
3
5
3
7
8
9
10
2
3
3
6
T=
4
6
4
3
9
9
18
10
9
9
9
4
4
7
3
8
9
8
7
1
3
5
3
7
8
9
8
2
3
3
6
T=
4
10
8
Arbres couvranLs
Fonctionnement : par union de composantes connexes

Remarques :
! Kruskall marche sur des graphes non connexes et calcule alors
une fort couvrante minimale
! La structure T calcule nest pas connexe chaque tape, mme dans
un graphe connexe

Complexit : $(max(n
2
,m log m ) si matriciel (ou $(m. log m) avec L.A.)
-initialisation de T en $(n
2
) ($(n))
-initalisation de U en $(n
2
) ($(m))
-initialisation de comp en $(n)
-min() et supprimer : au pire m fois
le tri de U se fait en $(m log m)
- On a un nombre de comparaisons comp[x].repr = comp[x].repr en $(m)
- n-1 appels union(),
et chaque appel coute $(n) au pire : $(n
2
) $(m)
- ajouter_arte() appele n fois : $(n)
!"#$ &$'(")*+,- .)'/012)
rlm 2. 343 + 353 1 Arbre couvranL
kruskal C(|L|. log |v|)
Cu
$(max(n
2
,m log m ))
lorL couvranLe
lus courL chemln
Variantes

! Partant dun sommet s, plus court chemin vers un
sommet t
! Partant dun sommet s, plus court chemin vers tout
autre sommet du graphe
! Plus court chemin de tout s vers tout t
! Plus court chemin passant par tous les sommets

Distance exprime en termes de :

! poids des chemins
! nombre darcs (idem poids 1)
lus courL chemln
Algorithme de Dijkstra [Cormen]

Partant dun sommet s, plus court chemin vers un sommet t
Dijkstra (G:graphe, sdeb:entier)

Initialisation (D : matrice 1..n dentiers)

Pour i dans 1.. N faire
D[i] = "
Finpour
d[sdeb] := 0

/* D[i] = distance de sdeb si */

lus courL chemln
Partant dun sommet s, plus court chemin vers un sommet t

Mise__jour (D: tableau 1.. Dentiers ,
s1: entier,s2:entier)

/* met jour les distances entre s
deb
et s
2
*/
/* vaut-il mieux passer par s1 ou pas ?*/

Si D[s2] > D[s1] + M[s1,s2] alors

D[s2]:= D[s1] + M[s1,s2]
Finsi


lus courL chemln
Partant dun sommet s, plus court chemin vers un sommet t
Dijkstra(G,sdeb,sfin)
Var Q : ensemble de sommets

Initialisation(G,sdeb)

Q := ensemble de tous les nuds

tant que Q n'est pas vide faire
s1 := Trouve_min(Q)
Q := retirer(Q,s1)
pour chaque nud s2 voisin de s1 faire
maj_distances(s1,s2)
finpour
fintantque
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 " " " " " " " " "
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter sdeb


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 " " " " " "
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 " " " " " "
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter s3


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 " " " "
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 " " " "
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter s6


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 14 " " "
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 14 " " "
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter s4


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 " " "
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 " " "
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter s7


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 "
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 "
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter s2


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 27
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 27
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter s5


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 22
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 22
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter s9


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 16
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 16
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter s8


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 16
lus courL chemln
6
4
3
9
9
18
10
9
3
2
2
9
2
4
4
1
3
8
9
8
7
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 16
sdeb
sfin
2
3
6
4
5
8
7
9
Traiter sfin
. et fin de lalgorithme


34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 16
lus courL chemln
34)5 6 7 8 9 : ; < = 3>?
0 9 3 6 12 3 8 13 12 16
On a les distances minimales de sdeb vers tout s
i
trouver le chemin
A= % /* mot vide*/
s:= sfin
A:= s. A
Tant que s<> sdeb faire

s:= predecesseur(D,s)
A:= s. A

fait
Predecesseur(D,s) = s #V, D[s]+M[s,s] =D[s]
lus courL chemln
Restriction : application un graphe connexe dont les poids sont positifs
ou nuls

Complexit : en O(n
2
)

! A chaque tape, on regarde un sommet de G : n itrations
! Dans chaque itration, on regarde le sommet avec la plus petite
distance temporaire. Au pire en O(n)
! puis on met a jour la distance : au pire en O(n)

Soit un algorithme en O(n
2
)

lus courL chemln

Preuve de lalgorithme
A chaque tape de lalgorithme, on peut faire correspondre
un sous graphe de G, dans lequel apparaissent les chemins
de poids minimum de sdeb vers tous les sommets explors

En ajoutant un sommet, on regarde sil connecte de manire plus
optimale ses successeurs.



6
4
3
9
9
3
2
9
2
4
4
1
9
8
7
sdeb
sfin
2
3
6
4
5
8
7
9
lus courL chemln

Preuve de lalgorithme

A chaque tape, les sommets dcouverts sont distance
optimale dans le sous-graphe dcouvert.

Si on ajoute un sommet s
i
, il est forcment plus loin de sdeb que tous les
sommets dj explors, et tout chemin de sdeb vers un s
j
dj explor passant
par s
i
est de poids suprieur au d(sdeb,s
i
) dj connu, et donc de poids infrieur
(car tous les poids des arcs sont positifs)


Donc :
une fois un sommet tudi, sa distance ne change plus
lorsque s
j
est tudi aprs s
i
, s
j
est plus loin de sdeb que s
i

34)5 7 : 8 ; 6 9 = < 3>?
0 3 3 6 8 9 12 12 13 16
lus courL chemln
Algorithme de Bellman- Ford

Permet de chercher le plus court chemin depuis un sommet source s donn
dans un graphe orient ( poids)

Autorise certains arcs ngatifs.

Complexit en O(|V| x |A| )




lus courL chemln
boolen Bellman_Ford(G, s)
Poids : tableau[1..n] dentiers
Pred : tableau [1..n] dentiers
i:entier

Poids[1] =0
Pour i dans 2..n faire poids[i] = " finpour

pour i=1 jusqu' n-1 faire
pour chaque arc (u, v) du graphe faire
paux := poids(u) + poids(arc(u, v))
si paux < poids(v) alors
pred(v) := u;
poids(v) := paux;
finsi
finpour
finpour
pour chaque arc (u, v) du graphe faire
si poids(u) + poids(arc(u, v)) < poids(v) alors
retourner vrai
finsi
finpour

retourner faux
lus courL chemln
Bellman- Ford retourne . Vrai ou faux !!? ?? !

Vrai : il existe un circuit de poids ngatif
les distances calcules ne sont pas bonnes

Faux : pas de circuit de poids ngatif

d[v] est le poids du plus court chemin de s v
Le chemin est contenu dans le tableau pred

lus courL chemln
Algorithme de Floyd-Warshall (Roy-Floyd/ Roy Warshall)

Algoritme cubique permettant de calculer la distance des plus
courts chemins entre toute paire de sommets
procedure FloydWarshall (G : matrice )
W:=G
pour k dans 1 .. n faire
pour i dans 1..n faire
pour j dans 1.. n faire
W[i,j] := min(W[i,j], W[I,k]+W[k,j])
fpour
fpour
fpour
lus courL chemln
Restriction : pas de cycles de poids ngatif

Bas sur lobservations que tout chemin minimal de i vers j

! nemprunte pas k, ou
! emprunte exactement une fois k, et est donc
! la concatnation de chemins de i vers k et de k vers j


Complexit en O(|V|
3
)


lus courL chemln
Algorithme de Johnson :

Plus court chemin entre toute paire de sommets

Principe : repondrer les arcs

Utilise la fois Diskstra et Bellman-Ford comme sous-programmes

Si tous les poids de G sont >0, alors on peut trouver toutes les distances de
sommet sommet en excutant |V| fois Dijkstra

Si G contient des arcs de poids ngatif, repondrer pour pouvoir utiliser
la mme mthode.
lus courL Chemln
Soit G=(V,A) et w : VxV " R une fonction associant un poids tout arc de G

On cherche w : VxV " R telle que

1) pour tout (u,v) # A, w (u,v) & 0

2) si p est un plus court chemin de u v dans G pour w, alors
p est un plus court chemin de u v dans G pour w

En particulier, on va chercher une focntion h assaociant un rel
A chaque sommet.

Pour chaque (u,v) # A, w (u,v) = w(u,v) + h(u) h(v)

Proprit : G contient un cycle de poids ngatif pour w si et seulement si
G contient un cycle de poids ngatif pour w.

lus courL chemln

Construire G(S,A) avec

S=S ' { s }
A = A ' { (s,v) | v # S }

w(s,v) =0

Ne modifie ni les circuits, ni les plus courts chemin ne contenant pas s

Si G et G ne contiennent pas de circuits ngatifs, on choisit
h(v) = ((s,v)
Ou ((s,v) est le poids du plus court chemin de s v

lus courL chemln
Proprit : Si G ne contient aucun circuit de poids ngatif,
alors pour tout u,v
w(u,v) est dfinie
w(u,v) & 0


Proprit :

Soit p un chemin de v
0
v
k
alors w(p) = $(v
0
, v
k
) si et seulement si w(p) = $(v
0
, v
k
)



lus courL chemln
Johnson(G)
Calculer G=(S,A)
Si Bellman-Ford (G,w,s) alors
afficher Circuit ngatif
Sinon
pour chaque sommet v de G faire
h(v) = ((s,v) /* calcul par Bellman Ford */
finpour
pour chaque arc (u,v) # A faire
w(u,v) := w(u,v)+h(u)-h(v)
finpour
pour chaque sommet u # S
executer Dijkstra(G,w,u)
(donne ((u,v) pour tout v # S )
pour chaque sommet v # S faire
D[u,v] := ((u,v) + h(v) - h(u)
finpour
finpour
lus courL chemln
Algorithme de Johnson

Permet de calculer le plus court chemin entre toute paire de sommets

Complexit en O( |V|
2
x log(|V|)+ |V| x |A| )

Soit une amlioration par raport Floyd-Warshall O(|V|
3
)
si le graphe est peu dense

lus courL chemln
ulsksLra C(|v|
2
) cc de s a LouL chemln
as darcs negaufs

8ellman-lord C(|v| x |A| ) cc de s a LouL chemln
as de cycles negaufs

lloyd Warshall C(343
3
) cc enLre LouLe palre de
sommeLs
as de cycles negaufs
!ohnson C( |v|
2
x log |v| + |v|x|
A| )
cc enLre LouLe palre de
sommeLs
as de cycles negaufs

lloL Maxlmal
Problme : Dans un rseau possdant une source s et une
sortie t, trouver le dbit maximum de la source vers la sortie.

Applications pratiques :

Problmes de transports (marchandise, fluide, nergie) dans un
rseau reprsentable par un graphe dont les nuds
reprsentent de points de passage sans stockage et les arcs
des trajets entre ces points
Ville1
Ville2
Ville3
Ville4
Ville5
Ville6
Quel dbit deau peut-on faire passer de la ville 1 la ville 6 sans
faire dborder les canaux ?
Problme : Dans un rseau possdant une source s et une sortie t, trouver
le dbit maximum de la source vers la sortie.

Donnes de lalgorithme:

! un graphe G=(V,E)
! un sommet source s
! un sommet cible t
! une capacit c: V x V " R

Trouver une relation de flot f: V x V " R telle que
! f(u,v) % c(u,v)
! f(u,v) = -f(v,u)
!

lloL Maxlmal
!
"
=
V w
w u f 0 ) , (
Sauf pour s et t
10
20
11
7
12
lloL Maxlmal
v(f) : quantit transporte par le rseau

10
15
11
7
12
8
8
s
t
1
2
3
Valeur du flot:


! !
" "
= =
V x V y
t x f y s f f v ) , ( ) , ( ) (
10
15
10
7
8
8
3
s
t
1
2
3
Graphe G
Flot f

V(f)=25
lloL Maxlmal
Soit G=(V,E) un graphe et f un flot

La capacit rsiduelle dun arc (u,v) est

c
f
(u,v) = c(u,v) f(u,v)

Le graphe rsiduel de G est le graphe G
f
=(V,E
f
)
o:



Reprsente les arcs qui peuvent supporter un flot plus important


{ } 0 ) , ( ) , ( > ! " = v u c V V v u E
f f
lloL Maxlmal
Attention : les arcs du flot rsiduels peuvent ne pas tre des
arcs de G


Explication : f(u,v) >0 implique f(v,u) % 0 et donc c
f
(v,u) = c(u,v) f(v,u) >0
10
15
11
7
8
s
t
1
3
f(s,1)=f(1,t)=7
10
15
4
7
8
s
t
1
3
7
Interprtation : en envoyant 7 units de t vers 1 (i.e annuler le flot)
puis envoyant
lloL Maxlmal
Un chemin amliorant de G est un chemin p de s vers t sans cycle
La capacit du chemin est :





Ide : sil existe un chemin amliorant dans G
f
, alors
le flot f peut tre amlior
{ } p v u v u c p c
f f
! = ) , ( ) , ( min ) (
lloL Maxlmal
Algorithme (principe):

Rpter
trouver un chemin amliorant p
amliorer le flot f avec p
calculer le graphe rsiduel G
f
=(V,E
f
)
Jusqu flot stable



10
15
11
7
12
8
8
s
t
1
2
3
10
15
4
12
8
8
s
t
1
2
3
7
7
lloL Maxlmal
Procedure Ford-Fulkerson(G,s,t)

Pour tout (u,v) dans A
f[u,v]:=0
f[v,u]:=0
finpour
Tant que ) un chemin p de s vers t dans G
f
tel que
c
f
(u,v)>0 pout tout arc de p

trouver p chemin amliorant

c
f
(p) = min{ c
f
(u,v) | (u,v)" p }
pour tout (u,v)" p
f(u,v):= f(u,v)+ c
f
(p)
f(v,u):= -f(u,v)
finpour

fintantque
lloL Maxlmal
10
15
11
7
12
8
8
s
t
1
2
3
10
15
4
12
8
8
s
t
1
2
3
5
4
12
8
8
s
t
1
2
3
7
10
7
7
7
10
4
7
5
8
s
t
1
2
3
7
10
7
15
5
3
lloL Maxlmal
V(f)= 25
4
7
5
8
s
t
1
2
3
7
10
7
15
5
3
4
7
5
8
s
t
1
2
3
7
10
7
15
5
3
8
5
s
t
1
2
3
7
10
10
15
12
1
4
3
lloL Maxlmal
Le fait que de nouveau arcs apparaissent est gnant.
Si le choix du chemin amliorant est mal fait, lalgorithme
peut ne pas terminer

Si les poids des arcs sont des entiers :
complexit en O( |E| . v(f*))

Avec f* le flot maximal trouv par lalgorithme

Une amlioration dans le choix du chemin (Edmonds-Karp)
permet de rduire la complexit O( |V| . |E|
2
)

lloL Maxlmal
Procedure Edmonds-Karp(G,s,t)

Pour tout (u,v) dans A
f[u,v]:=0
f[v,u]:=0
finpour
Tant que ) un chemin p de s vers t dans G
f
tel que
c
f
(u,v)>0 pout tout arc de p

trouver p de longueur minimale
/* parcours en largeur */
c
f
(p) = min{ c
f
(u,v) | (u,v)" p }
pour tout (u,v)" p
f(u,v):= f(u,v)+ c
f
(p)
f(v,u):= -f(u,v)
finpour

fintantque
ConnexlLe
Un graphe non-orient G=(V,E) est dit connexe sil existe un chemin de
tout sommet x tout autre sommet y

Un graphe orient G=(V,A) est dit connexe sil existe un chemin de tout sommet x
tout autre sommet y dans le graphe G=(V,A'A
-1
)

Un graphe orient G=(V,A) est dit fortement connexe sil existe un chemin de
tout sommet x tout autre sommet y dans G.


s
0

s
1

s
3

s
2

s
0

s
1

s
3

s
2

s
0

s
1

s
3

s
2

ConnexlLe
Algorithme de Warshall
Procedure Warshall (C : tableau[1..n,1..n] de boolens,
A : tableau[1..n,1..n] de boolens
Var i,j,k: entiers

Pour i dans 1..n faire
Pour j dans 1..n faire
A[i,j] := C[i,j]
finpour
Pour k dans 1..n faire
Pour i dans 1..n faire
Pour j dans 1..n faire
A[i,j] := A[i,j] or (A[i,k] and A[k,j])
finpour
finpour
finpour
ConnexlLe
Permet de construire la fermeture transitive dun graphe

C : graphe sous forme matricielle
A : fermeture transitive de C la fin de lalgorithme

s
i
et s
j
dans la mme composante connexe si A[i,j] = vrai

s
i
et s
j
dans la mme composante fortement connexe si
A[i,j] = vrai
et A[j,i] = vrai


Complexit en O(|V|
3
)
ConnexlLe
Algorithme de Tiernan : detection de cycles lmentaires
0
1
2
4
3
Cycle : squence de sommets qui
commence et finit sur le mme sommet

Cycle lmentaire :
cycle qui ne passe pas deux fois
par un sommet ( lexception du sommet
de dpart/fin du cycle)


0.1.2.0 , 0.3.2.0 , 2.4.3.2,
ConnexlLe
Algorithme de Tiernan : detection de cycles lmentaires
Input : G, graph of size N

Initialisation

P:=0 ; H:= &
N
;
/* H : tableau 1..N densemble dentiers
/* k # H[i] if k has been considered as a successor of i */
k:=1
P[1]:=1 /* P = current path */

Find_Successor(G: graphe,P: tableau de sommets, k: entier,suc:sommet)
Var suc: entier
Suc:=-1
For j in 1,..,N do
If (1) j > P[1] /* j is not the origin of the cycle */
(2) j ' P /* j not in path */
(3) j ' H[P[k]] /* j not explored */
then suc := j; break
endfor
EC2 : Find_successor( G, P,k,j) /* path extension /

If this j > -1 /* extend the path */
K:=k+l;
P[k]:= j
go to EC2.
Else /* no j meets the conditions, the path cannot be extended */
EC3 [Circuit Confirmation]
If G[P[k],P[1]] = false then
no circuit has been formed, go to EC4.
Otherwise a circuit is reported, Print P.
EC4 [Vertex Closure]
If k = 1, then all of the circuits containing vertex P[1]
have been considered.
go to EC5.
Otherwise,
H[P[k]] := &
H[P[k - 1]]:= H[P[k - 1]] ( P[k]
P[k]:= 0
K:=k-1
go to EC2.
EC5: [Advance Initial Vertex]
If P[1] = N then, go to EC6 Otherwise,
P[1] := P[1] + 1 /* next vertecs as origin of cycles */
K := 1 ; H:= &
N
go to EC2.
EC6: [Terminate]
ConnexlLe
Algorithme de Tiernan

Calcule les cicuits elementaires

Utile pour obtenir une base de cycle : tout cycle de G est
ensuite une combinaison des cycles de cette base

Affichage unique de chaque circuit

Complexit :

For every vertex, a depth first search algorithm
O(n. (m+n))



ComposanLes connexes
Algorithme de Tarjan

Permet de reprer les composantes connexes dans un graphe orient

Principe :

Le graphe est parcouru en profondeur.

Un graphe orient peut tre spar en deux groupes darcs
ceux qui font partie de lexploration en profondeur *
ceux qui connectent les sommets un de leurs
anctres : les frondes -"


ComposanLes connexes
0
10
2
3
6
4
5
8
7
9
ComposanLes connexes
0
10
2
3
6
4
5
8
7
9
ComposanLes connexes
0
10
2
3
6
4
5
8
7
9
ComposanLes connexes
Soit G = (V,E) un graphe orient

On dfinit la relation dquivalence suivante
v et w sont quivalents ssi
w apparait le long dun chemin allant de v v (cycle)

On peut dfinir les sous-graphes
G
i
=(V
i
,E
i
) comme les restrictions de G aux classes dquivalence
de V

On a:
! chaque G
i
est fortement connexe
! chaque G
i
est maximal

ComposanLes connexes
Proposition : soient v,w deux sommet dune mme composante connexe
et F une fort couvrant G. Alors v et w ont un anctre
commun dans F

Proposition : Soit C une composante connexe de G, alors les sommets de C
dfinissent un sous-arbre dun arbre de F.

La racine de cet arbre est appel racine de C

Lalgorithme de Tarjan consiste reprer les racines
ComposanLes connexes
On peut crer deux fonctions num(.) et numAccessible(.)
qui associent tout sommet de G un numro :


Num(v) = ordre dexploration dans le parcours

Numaccessible(v) = min { num(v)
' { num(w)| v(")* -"w
& ) u, u(")*v, u(")*w
& u,w dans la mme CC }


Proprit : les racines sont les sommets pour lesquels
num(v) = numaccessible(v)
ComposanLes connexes
fonction tarjan(graphe G)
num := 0 /* numro associ chaque sommet dans le parcours */
P := pile vide
partition := ensemble vide

pour chaque sommet v de G
si v.num n'est pas dfini
parcours(G, v, P, partition)
finsi
renvoyer partition

fin de fonction

fonction parcours(G: graphe, num:entier, sommet v, P: pile , partition : liste)

v.num := num
v.numAccessible := num
num := num + 1
P.push(v)

pour chaque w successeur de v
si w.num n'est pas dfini /* w non explor par la DFS */

parcours(G,num,w,P,partition)
v.numAccessible := min(v.numAccessible, w.numAccessible)

sinon si w # P /* on vient de reprer un arc fronde */
v.numAccessible := min(v.numAccessible, w.num)
si v.numAccessible = v.num
/* C'est une racine, calcul de la CC dtecte */
C := +
rpter
w := P.pop()
ajouter w C
tant que w diffrent de v
ajouter C partition
finsi
fin de fonction
ComposanLes connexes
10
10
11
11
12
12
13
13
10
10
11
ComposanLes connexes
Rsum :

Recherche des composantes fortment connexes dans
un graphe orient

Detection des racines lors du parcours en profondeur

Complexit en O( |V| + |E| )
Concluslon
Beaucoup de problmes se modlisent comme des problmes de graphes

problmes de chemins optimaux
(itinraire dans un rseau routier)

problmes de cycles et de leurs poids
(saturation de rseaux)

Attention cependant :

tous les problmes sur les graphes ne sont pas polynomiaux !


Chemln PamllLonlen
Trouver un cycle dans un graphe qui passe exactement
une fois par chaque sommet

Application pratique :
tourne dun visiteur commercial, qui doit revenir
dans sa ville de dpart aprs avoir visit des clients dans
chaque ville.
Problme NP-complet

si on choisit un cycle, on sait vrifier en temps polynomial
que cest un cycle, et quil passe par tous les sommets.

Malheureusement, il nexiste pas en gnral de stratgie
polynomiale pour construire un tel cycle
Colorauon de graphe
Associer une couleur chaque sommet du graphe de manire
ce que deux sommets conscutifs ne portent pas la mme couleur

G=(V,E)

Trouver col: V ! C telle que
)(u,v) " E, c(u) * c(v)

Souvent assorti dune contrainte de minimalit :
|col (V)| = nombre chromatique
Problme NP-complet

On peut vrifier en temps linaire en |E| quune coloration
satisfait les conditions ci-dessus, mais on risque davoir considrer
toutes les colorations possibles

8lbllographle
[1] Christine Froidevaux, Marie-Claude Gaudel, Michle Soria,
Types de Donnes et Algorithmes, McGraw-Hill, 1990.

[2] Thomas Cormen, Charles Leiserson, Ronald Rivest,
Introduction lalgorithmique, Dunod, 1994.

[3] Michel Gondran, Michel Minoux,
Graphes et algorithmes, Eyrolles, 1985