Chapitre 2

2.3.4. Organigramme de l'algorithme fond sur le test 2 permettant de testant

l'absence de circuit.
Soit M la matrice d'adjacence d'un
graphe G.
Dfinir la matrice A en posant
A=M.

Il existe dans A une

ligne i ne comportant
que des zros.

NON

Il existe au moins un
circuit.

OUI
Eventuellement,
obtention d'un
circuit en
appliquant
l'algorithme 2.3.5.

Supprimer dans A la ligne et la

colonne i.
Soit R la matrice rsultante..
Redfinir A en posant A=R

NON

OUI
A ne contient
que des zros.

Le graphe est sans circuit.

2.3.5. Organigramme de l'algorithme d'obtention d'un circuit.

Supposons qu'aprs l'application de l'algorithme 2.3.4, nous voyons qu'un graphe G
possde au moins un circuit. Il est possible alors de construire explicitement un tel
circuit. Pour ce faire, il faut partir d'un sommet du sous graphe G* dfini par la
matrice M* = (a*ij) obtenue la dernire itration de l'algorithme 2.3.4.
M*;
I={i1}
;
k=1;

ik 1 ;

k=k+1

I I ik 1

ij I /

ai

k j

OUI

Obtention d'un circuit :

NON

Choisir tel que :

2.3.7. Organigramme de l'algorithme d'obtention des niveaux d'un graphe sans

circuit.
Considrons un graphe sans circuit G=(X,U) de matrice d'adjacence M.
Les n niveaux de G sont les n sous-ensembles de sommets dfinis en 2.3.2.
X(i) , i=0,..n de la faon suivante:
X(0)= {x / xX , +(x)=}
X(1)={x / xX - X(0), +(x) X(0) }
X(2)={x / xX - ( X(0)X(1) ), +(x) X(0) X(1)}
.
.
.

X(n)={x / xX - ( X(0)X(1)X(n-1) ), +(x) X(0)X(1)X(n-1)}

L'algorithme suivant permet de construire les niveaux successifs d'un graphe sans
circuit :
M
i=0

X(i) est l'ensemble des sommets correspondants aux lignes non

marqus ne contenant que des 1 barres ou des zros.
i=i+1
Marquer les
lignes de X(i) et
barrer les
colonnes
correspondantes

NON

OUI
X(i) =

FIN

Le partage en niveaux d'un graphe simplifie la recherche de chemon minimale ou

maximale entre sommets.

2.4.4. Organigramme de l'algorithme d'obtention du noyau d'un graphe sans

circuit.
L'existence d'un tel noyau est justifie par le thorme 2.4.2.

Choisir une ligne ne contenant que des zros.

Marquer cette ligne d'une croix. Entourer la

colonne correspondante cette ligne. Barrer les
lignes ayant un 1 dans la colonne entoure. Barrer
les colonnes correspondantes.

Il existe une ligne non

marque et non barre
ne contenant que des 1
barrs ou des zros.

Choisir une ligne non marque et

non barre ne contenant que des 1
barrs ou des zros

Noyau = { sommets marqus}

Chapitre 3
3.2.1 Version rcursive du parcours en profondeur d'un graphe.
3.2.1.1 Algorithme gnral
Le programme principal a la structure suivante :
var i : integer ;
gr : GRAPHE ;
marque : array[1..n] of boolean ;
.
begin
for i:=1 to n do marque[i]:=false ;
for i:=1 to n do
if not (marque[i]) then prof(i,gr,marque)
end;
La procdure rcursive prof de parcours en profondeur ressemble :
procedure prof(i : Integer; g : GRAPHE; var M : array[1..n] of boolean);
{ s est un sommet o commence le parcours }
var i,v : Integer ; { v est un sommet }
M[s] := true ;
{ on marque le sommet s }
{ 1 : premire rencontre avec s }
for j :=1 to n do d+ de s dans g do
begin
v:=j ime- succ-de s dans g ; { rencontre de larc (s,v) laller }
if not (M[v]) then prof(v,g,M) ; { rencontre de larc (s,v) au retour }
end
{ 2 : dernire rencontre avec s }
end prof ;

3.2.2. Parcours d'un graphe en profondeur reprsent par sa matrice adjacente.

type GRAPHE= array[1..n,1..n] of boolean;
procedure prof(i : Integer; g : GRAPHE; var M : array[1..n] of boolean);
var j : Integer;
begin
M[i]:=true;
for j:=1 to n do
if g[i,j] and not(M[j]) then prof(j,g, M);
end prof;

3.2.3. Parcours d'un graphe en profondeur reprsent par listes d'adjacence.

Type adr= doublet;
GRAPHE= record
no : 1..n;
suiv : adr;
end;
procedure prof(i : Integer; g : GRAPHE; var M : array[1..n] of boolean);
var j : Integer;
s : adr;
begin
M[i]:= true;
s:=g[i];
while s nil do begin
j:=s.no;
if not (M[j]) then prof(j,g,M);
s:=s.suiv
end
end prof;

3.2.2. Procdure iterprof de parcours en profondeur itrative.

procedure iterprof(s : Integer; g : GRAPHE; var M : array[1..n] of boolean);
{ s dsigne un sommet de dpart}
var i,j,d : Integer; { i et j sont des sommets}
poursuite : boolean;
Q :Pile;
begin
i:=s;
pile-vide(Q); { partir avec une pile vide}
poursuite :=false;
M[i]:=true;
{ premire rencontre avec avec i }
Q:=empiler(Q,i);
if d+ de i dans g0 then begin
poursuite :=true;
j:=premsucc(i,g) ; { premier successeur de i dans g}
end;
while not (est-vide(Q)) do begin
while poursuite do
if not (M[j]) then begin { j n'est pas marqu et donc on progresse}
M[j]:=true ; { premire rencontre avec j }
Q:=empiler(Q,j);
i:=j; { on passe aux successeurs}
if d+ de i dans g >0 then j:=premsucc(i,g)
else poursuite :=false { pas de successeur}
end
else begin { j est marqu, donc on regarde les autres successeurs de i }
d:=d+ de i dans g;
if j d me-succ-de i dans g then j:=succsuivant(i,j,g)
else poursuite :=false { il n'y a pas d'autres successeurs de i}
end;
{ retour arrire}
j:=sommet(Q);
Q:=dpiler(Q); 'dernire rencontre avec j}
if not (est_vide(Q)) then begin
i:=sommet(Q);
d:=d+ de i dans g;
if jd me-succ-de i dans g then begin
j:=succsuivant(i,j,g);
poursuite:=true
end
{sinon tous les successeurs de i ont t marqus;
on est sur la dernire rencontre de i;
on continue le retour arrire}
end
end
end iterprof;

3.4. Parcours en largeur.

Algorithme
Utilisation d'une structure de file : lorsque l'on visite les successeurs non
marqus d'un sommet s, il faut les ranger successivement dans une file FIFO;
la recherche au niveau suivant repartira des chacun des successeurs de s,
partir du premier de la file.
Rappelons que pour le type File, les adjonction se font une extrmit et les
accs ou suppression l'autre extrmit.
Procedure larg(s : integer; G : Graphe; var M : array[1..n] of boolean);
{ s est un sommet}
var v,w,i : integer; F : File;
{v et w sont des sommets}
begin
F:=file-vide; M[s]:=True;
F:=ajouter(F,s);
while not (est-vide(F)) do begin
v:=premier(F); F:=retirer(F);
{ v est le premier lment de la File qui est retir de F}
for i:=1 to d+ de v dans G do begin
w:=i me successeur-de v dans G;
if not( M[w]) then begin
M[w]:=true; F:=ajouter(F,w);
end
end
end
end larg;

Chapitre 5
Organigramme de l'algorithme de coloration de Welsh et Powell

Ranger les sommets de X par ordre de

degrs non croissants : soit M la matrice
d'adjacence du graphe ainsi ordonn

k=1
N=M
Colorer par la couleur ck la premire ligne non
encore colore dans N, ainsi que la colonne
correspondante.
N = ensemble des lignes non encore colores
ayant un zro dans les colonnes de couleur ck
NON
N=
OUI

k=k+1 ;
Changer de
couleur

NONN

Toutes
les
lignes
sont
colorie
s

OUI

STOP
La coloration
obtenue est une
k-coloration

5.5.3.2. Algorithme du couplage maximun

G=(XY,E)
Couplage initial C
XM=YM= ; XN=X ; YN=Y
NON

xX-C

Supprimer dans C toutes

les artes appartenant C
qui sont reprises dans la
chane A.
Ajouter dans C toutes les
artes n'appartenant pas
C qui sont reprises dans la
chane A.

OUI
Marquer + un tel sommet x
XM=XM{x} ; XN=XN - {x}
NON

y(x)YN
(1)
OUI

Marquer (+,x) un tel sommet y

YM=YM{y} ; YN=YN - {y}
NON

Soit y*YM - C ;
Dterminer la chane
A=(x,,y*)
commennant en un
sommet marqu + et
qui a conduit au
marquage de y*

x(y)CXN (2)
o yYM
OUI
Marquer (-,y) un tel sommet x
XM=XM{x} ; XN=XN - {x}
G=(X,E
Tous les yYM
)
appartiennent C

NON

Construire le graphe adjacent G' de G

STOP. Le couplage C obtenu

OUI
est unOrganigramme
couplage maximum
5.6.2.
de l'algorithme de coloration des artes
Colorer
les
sommets
de G'
en
algorithme
'5.4.2.
Le problme
de coloration
des artes
de G
est appliquant
quivalent la coloration
des sommets
de G'.
de coloration de Welsh et Powell. La coloration obtenue est
une k-coloration des artes de G

5.7.4. Organigramme de l'algorithme de Kruskal

G=(X,E), w

Ranger les artes de par ordre de

poids dcroissants
F={e1} ; k=1

F possede-il n-1
lments ?

OUI

NON

k=k+1

OUI

Existe-t-il un
cycle dans
F{ek} ?

NON
F= F {ek}
Algorithme de Kruskal

Stop

A*=(X,F) est l'arbre

partiel de poids
minimum

Chapitre 6
1=0

j=, j1
(chemin plus court)

j=-, j1

(chemin plus long)

(xi,xj)U tel que :

j > i + l i j
l
j < i + i j
NON

OUI
Marquer xj de
j = i + l i j

STOP - Identification
du (des) chemin(s)
cherch(s) par
l'algorithme 6.3.2

Principe de l'algorithme de Ford

On part avec les marques :

( j)j=1,..n
k=n;
=(xn)
Rechercher xj tel que j= k - l j k
Poser k=j
= (xk,)
NON

xk=x1

OUI

STOP; est l'un

des chemins
recherchs.

Chemin de valeur optimale

 1(0)=0

j(0)=, j1
(chemin plus court)

j(0)=-, j1
(chemin plus long)

k=0
k=k+1

j(k)=

1(k)=0

min{ i(k-1)+l i j } ,j1

(chemin de long.minimale)

OUI

j(k)=

max{ i(k-1)+l i j } ,j1

(chemin de long. maximale)

xj tel que :
j(k) j(k-1)

NON

STOP - Identification
du (des) chemin(s)
cherch(s) par
l'algorithme 6.3.2
Algorithme de Bellman-Kalaba

G est un graphe partag en

niveaux tels que :
{x1}N1,N2, Nk,,{xn}NK
k=0
1=0
NON

k=k+1

OUI
xj Nk
non marqu

Marquer xj

Fj={ i + l i j | xiN1N2Nk-1}
j=min Fj

j=maxFj

OUI

NON

xn marqu

STOP - Identification du (des)

chemin(s) cherchs au
moyen de l'algorithme 6.3.2.

Algorithme de Bellman-Kalaba pour un graphe partag en niveaux

D={x1} ;
1=0;

j=l1j, j1
k=min j

Voir remarque

xjD
D=D { xk }

j=min { j, k+ lkj }
NON

xn D

OUI

Algorithme de Dijkstra

STOP Identification d'un

chemin le
plus court par 6.3.2.

Chapitre 7
Algorithme de Ford Fulkerson:
Version 1

T=(X,U,C)

Flot ralisable initial de valeur () ; m1=[ ; +]

STOP. Le flot
obtenu est un flot

un x j non marqu tel que

NON

pour un x i marqu

de valeur

(I) c i j - i j > 0 ou bien

minimale

(II) j i >0
OUI
Choisir un tel x j

Marquage direct de x j :
m j=[i ; j ; + ]

Marquage indirect de x j :

avec
j=min{ i , r i j=c i j-

xn marqu

(I)
i j

cas (I) ou
cas (II)

m j = [i ; j ; -] avec
j=min { i , r

i j

j i

NON

OUI
()= () + n

i j = i j + n

(II)

j=n

m j=

(I)

(I) [ i ; j ; + ]
(II) [ i ; j ; - ]

j=i
Effacer m j , j1

OUI

j=1

NON

(II)

ji = ji - n

Algorithme de Ford Fulkerson: Version 2

T = (X , U ,C)
Flot ralisable initial , de valeur ()

Construire le graphe d'cart G( ) = ( X , U( )) : (x i , x j ) U( ) si

cas (I) : (x i , x j ) U et c i j - i j>0

ou bien
cas (II) : (x j, x i) U et si j i > 0
un chemin allant de x 1 x n
dans G()
NON
OUI

STOP. Le flot
obtenu est un flot de
valeur maximale.

Construire un tel chemin ( en appliquant, par

exemple, l'algorithme de Dijkstra tudi en 6.3.5.
pour l'obtention des chemins de longueurs
minimales en attribuant chaque arc de U() la
longueur 1).

c i j - i j si ( x i , x j ) U
r ij =
ij

si (x i , x j) - U

= min { r i j / (x i , x j)

ji +

si ( x i , x j ) U

ij -

si ( x i , x j ) - U

ij=

7.5.2. Organigramme de l'algorithme permettant d'obtenir un flot de valeur

= (X , U ,C) ; f ; 0
Flot ralisable initial = { i j =0 , (xi,xj)U }, de
valeur ()=0
Construire le graphe d'cart G( ) = ( X , U( )) : (x i , x j ) U( ) si

cas (I) : (x i , x j ) U et c i j - i j>0

ou bien
cas (II) : (x j, x i) U et si j i > 0
un chemin allant de x 1 x n
dans G()
NON
OUI

STOP. Le flot obtenu est un

flot de valeur maximale< 0 et
de cot minimum.

lij= fij si (xi,xj) U ()U et lij= - fji si (xi,xj) U ()- U

Construire dans G() chemin de x1 xn de longueur minimale( en
appliquant, par exemple, l'algorithme de Dijkstra tudi en 6.3.5. pour l'obtention des
chemins de longueurs minimales en attribuant chaque arc de U() la longueur 1).

c i j - i j si ( x i , x j ) U
r ij =
ji

si (x i , x j) - U

= min { r i j / (x i , x j)
()=()+

NON

OUI

STOP. Le flot de composantes :

0 ()

i j = i j + 0 - () si ( x i , x j ) U

i j = i j + si ( x i , x j ) U

i j = i j - 0 + () si ( x i , x j ) - U

i j = i j - si ( x i , x j ) - U

est un flot de valeur 0 et de cot minimum

Chapitre 8
C ) LALGORITHME DU SIMPLEXE : Principe.
Considrons le cas o lensemble des solutions ralisables
forment un polydre convexe. On sait que la solution
optimale est un sommet de ce polydre. Seuls les sommets
doivent tre examins pour atteindre cette solution
optimale.
Il y a identit entre sommet et solution de base ralisable :
pour atteindre l'optimun, il suffit d'examiner les solutions
de base ralisables.
Le principe de l'algorithme est le suivant :
a) Dterminer la premire solution de base ralisable;
b)

Cheminer de solution de base ralisable en solution

de base ralisable en augmentant (pour un PL
maximum ; l'augmentation peut tre parfois nulle)
chaque itration la valeur de la fonction conomique;
le cheminement de sommet en sommet se fait le long
de la frontire du polydre.

c)

Arrter la procdure lorsqu'il n'est plus possible

d'accrotre (pour un PL maximum) la valeur de la
fonction conomique ; la dernire solution de base
ralisable obtenue constitue une solution optimale.

La mme procdure est applique lorsque l'ensemble polydrique convexe des solutions
ralisables est non born.

L'algorithme permet de voir si la solution optimale est

finie ou non.
TABLEAUX DU SIMPLEX

La rsolution d'un PL par la mthode du simplex se fait

sous formes de tableaux successifs, dits tableaux du
simplex. Le premier tableau du simplex est form des
lments constitutifs du PL : contraintes mises sous
formes d'galits et de la fonction conomique.

ORGANIGRAMME DE L'ALGORITHME DU SIMPLEX

PL Maximum

Mise des contraintes sous forme d'galits

Recherche d'une premire solution de base ralisable

Construction du tableau du Simplex

Tous les cj-zj 0

cj zj > 0 tel
que x i j 0

FIN
la solution optimale
est atteinte

FIN
Max=+
(Polydre non born)

i=1,,n

Changement de base
(1) Dtermination

des vecteurs entrant et sortant

Pk entre si ck-zk = max j {cj-zj
/ cj-zj>0}
Pr sort si xr /xr k = min i { xi / xi k / xi k>0 }
(xr k est dit le pivot)
(2) Construction du nouveau tableau du Simplex
Sur la ligne de pivot : x'k = xr / xr k
x'k j = xr j/xr k
Ailleurs (ik) :
et

x'i = xi (xi k / xr k) xr
x'i j = xi j (xi k / xr k) xr j
-z'0 = -z0 (xr / xr k) (ck zk)
cj z'j = cj zj (xr j /xr k) (ck-zk)

Organigramme de la mthode M et de la mthode en deux phases

PL maximum.

Mettre les contraintes sous forme d'galits

Rendre positif le second membre des contraintes

Introduire des variables artificielles dans les contraintes :

j1aij x jvib

, xj,vi 0, j=1,,n ; i=1,,m (Contraites C)

Mthodes en deux phases

Mthode M

Rsoudre le PL :
n

i 1

max z c j x j M vi

sous les contraintes C

max z1vi
i 1

sous les contraintes C

(M>0, arbitrairement grand)

v i = 0 , i=1m

PHASE 1
Rsoudre le PL:

NON

NON

v i = 0 , i=1m

OUI

FIN
La solution
optimale du PL de
dpart est atteinte

OUI
FIN
Pas de solution
ralisable

PHASE 2
Rsoudre le PL:

max z2 c j x j
j 1

j1aij x jb

xj 0, j=1,,n ; i=1,,m
en prenant comme solution