USTHB - Faculté d’Informatique - Département IA&SD

Module : AL.Av.&Compl - Sections: M1 BioInfo - Année : 2022/2023

Durée : 1h30
Corrigé d’examen du module Algo Av. et Complexité

Exercice 1 (2+2)  4pts

Soit un vecteur T d’entiers de taille n. Un tableau de permutation est un tableau qui
contient des éléments distincts compris entre 1 et n.
1. Ecrire une fonction TabPerm qui vérifie si T est un tableau de permutation avec une
complexité quadratique
Fonction TabPerm (E/T : TAB, E/n : entier) : booléen
i =1 ;
Tant que i <= n
Faire
Si (T[i]<1 ou T[i]>n) alors retourner faux ; fsi ;
j =i+1 ;
Tant que (j <= n)
Faire si (T[j] =T[i]) alors retourner faux ;
fsi ; j++ ; fait ;
i++ ;
Fait ;
Retourner vrai ;
Fin ;

2. Donner une solution linéaire TabPerm2, en utilisant un tableau auxiliaire

Fonction TabPerm2 (E/T : TAB, E/n : entier) : booléen
A = {1, 2, …., n} //tableau auxiliaire
i =1
Tant que (i <= n)
Faire
Si (T[i] <1 ou T[i]>n) alors retourner faux ;
Sinon si (A(T[j]) = 0) alors retourner faux
Sinon A(T[j]) = 0 ; fsi ;
Fsi ;
Fait ;
i=1
Tant que (i<=n)
Faire si (A[i] !=0) alors retourner faux ; fsi ; fait ;
Retourner vrai ;
Fin ;

1 S. Boukhedouma
 Exercice 2 (1,75+0,75+1,5)  4pts
Déroulement

40
22
10
17
17 17
5
5 5
8
8 8
2 22
2 2 22
40
Pile A 40 10
Pile A B C
Pile A B C

2
5
8
8
5 10
10
8 17 8 17
17
2 22 2 22
22
40 10 40 5
40
Pile A B C Pile A B C
Pile A B C

Finalement B sera affectée à A

La procédure effectue le tri de la pile A dans l’ordre croissant (le minimum au sommet de la pile)

Complexité

Soit n le nombre d’éléments de la pile A.

Au meilleur des cas, la pile A est triée dans l’ordre inverse (décroissant), il s’agit de dépiler
tous les éléments de A dans B  complexité linéaire en O(n).
Au pire des cas, la pile A est triée dans l’ordre croissant, A chaque fois, on dépile les
éléments de A dans B et de B dans C et on remet les éléments de C dans B. A chaque tour de
la boucle Tant que externe, une valeur maximale est placée dans la pile B.
La boucle Tant que interne dépile tous les éléments de C dans B, au pire des cas, cette
boucle dépile le 1er élément (n-1) fois, le 2ème (n-2) fois, … le dernier une fois.
Donc C(n) = 1+2+…+n-1 = (n(n-1)/2 = 0(n2) D’où une complexité quadratique

2 S. Boukhedouma
Exercice 3 (1,5+1,5+1)  4pts

n =1 (1+a) >= 1+a

On suppose vrai à l’ordre n et on montre à l’ordre n+1
(1+a)n+1 >= 1+(n+1)a
(1+a)n+1 = (1+a)n (1+a) >= (1+na)(1+a) = 1+a+na+na2
= 1+ a(n+na+1) = 1+(n+1)a +na2 >= 1+(n+1)a (cqfd)

1)
S(n) ∈ O(f(n)) il existe c1/ S(n) <= c1.f(n) n1
T(n) ∈ O(g(n)) il existe c2/ T(n) <= c2.g(n) n2
f(n) ∈ O(g(n)) il existe c3/ f(n) <=c3.g(n) n3
S(n)+T(n) <= c1.f(n)+c2.g(n) <= c1.c3(g(n)+c2g(n) = (c1*c3+c2) g(n)
avec n4 = max(n1, n2, n3)
Donc S(n)+T(n) ∈ O(g(n))

Log (n!) ∈ O(Log(nn))

Il existe c1, n0 / log(n!) <= c1. Log(nn)
Log(n!) / Log(nn) <= c1
Log(n!) / Log(nn) < 1 pour tout n >=2 c1 = 1

Exercice 4 2+1+1,5+1,5+1,5+0,5  8pts

M : matrice(n,n) d’entiers

1. Sachant que le graphe est représenté par une matrice d’adjacence M(nxn). Ecrire un
algorithme qui vérifie si un ensemble E = {S1, …, Sk} donné de sommets est une k-clique.

Rappel : M(i, j) = 1 s’il existe une arête entre les sommets (Si, Sj) ;
= 0 sinon.
Fonction Clique (E/ M : Mat, E/ {S1, …, Sk} de sommets) : booléen

Pour i = 1 à k-1
Faire pour j =i+1 à k
Faire si (M(Si, Sj) = 0) alors retourner faux fsi ; fait ;
Fait ;
Retourner vrai ;
Fin ;

3 S. Boukhedouma
2/Complexité : La boucle j se répète (k-1) + (k-2) + (k-3) +… 1 = k(k-1)/2 = 0(k2)
 complexité quadratique

3/ Soit un graphe G composé de 6 sommets (n = 6) nommés S1, S2, S3, S4, S5, S6, quels sont
les ensembles de 4-cliques possibles (k =4) sur ce graphe?
{S1, S2, S3, S4} {S1, S2, S3, S5} {S1, S2, S3, S6} {S2, S3, S4, S5} {S2, S3, S5, S6}
{S2, S3, S4, S6} {S3, S4, S5, S6} {S1, S3, S4, S5} {S1, S3, S5, S6} {S1, S3, S4, S6}
{S1, S4, S5, S6} {S1, S2, S4, S6} {S1, S2, S5, S6}

Com(3,6) = 6! /(4!(2)! = 720/24*2 = 15 possibilités  15 ensembles de 4 sommets

(Com(n,k) = combinaison de k parmi n)
4/ D’une manière générale, dans un graphe complet de n sommets, on peut trouver un
nombre X de k-cliques (3<=k<=n)
X = Com(3,n) + Com(4,n)+ … Com(k,n) = somme (n!/k! (n-k)!) avec 3<=k<=n
ce qui génère un nombre exponentiel de possibilités

5/ L’algorithme

M : mat //matrice d’adjacence

E, E1 : ensemble de sommets ; k, n : entier // n : nombre de nœuds du graphe
trouv : booléen ;
K =3 ; trouv= faux ;
Tant que (k<=n et trouv = faux)
Faire
E1 = Choisir k sommets parmi n dans E //choix non déterministe
Si (Clique (M, E1)) = vrai alors trouv = vrai ; Fsi ;
K k+1 ;
Fait ;
Si (trouv = vrai) alors Ecrire (‘’ l’ensemble E1 est une clique’’, E1) ;
Sinon Ecrire (‘’aucune clique trouvée’’) ; fsi ;
Fin.

La complexité de l’algorithme est exponentielle vu le nombre de sous-ensembles E1 qui est

exponentiel.
Le meilleur des cas, le premier sous ensemble choisi est une clique  O(|E1|2)
Le pire des cas, aucun sous-ensemble n’est une clique.

4 S. Boukhedouma