USTHB - Faculté d’Informatique

Module : ALGO Avancée &Complexité M1-BioInformatique Année 2021-2022

Examen du module « ALGO Avancée et Complexité » avec corrigé

Le 05-02-2022
Durée : 1h30
Exercice 1 (10 pts)
Soit T un vecteur d’entiers de taille (n <=500).
1. Ecrire une fonction Nbocc qui retourne le nombre d’occurrences d’une valeur val
dans le vecteur T.
Fonction Nbocc (E/ T : tab, E/n, val : entier) : entier
Var i, nb : entier;
Debut
nb  0 ;
Pour i 1 à n
Faire si (T[i] = val) alors nb  nb+1 ; fait ;
Retourner nb ;
Fin ;
Soit une matrice A (n, m) d’entiers
2. Ecrire une fonction VectOcc qui stocke dans un vecteur V, le nombre d’occurrences
d’une valeur val donnée, pour chaque ligne de la matrice A. C’est-à-dire que
l’élément V[i] contient le nombre d’occurrence de val dans la ligne i de la matrice A.
Fonction VectOcc (E/A : Mat, E/n, m, val : entier) : TAB
Var i, nb : entier; V : TAB ;
Debut
nb  0 ;
Pour i 1 à n
Faire V[i] = Nbocc (A[i], m); Fait ;
Retourner V;
Fin ;
3. Ecrire une procédure Permute qui permute les éléments de deux lignes i1 et i2
données de la matrice A.
Procédure Permute (E-S/ A : Mat, E/m, i1, i2 : entier)
Var j, X : entier;
Debut
Pour i 1 à m
Faire X  A[i1][j] ; A[i1][j]  A[i2][j] ; A[i2][j] X; Fait ;
Fin ;

1 S. Boukhedouma
 4. Ecrire une procédure Ordre qui réordonne les lignes de la matrice A par ordre
croissant du nombre d’occurrences de val dans les lignes (la première ligne sera celle
qui contient le plus petit nombre d’occurrences de val). 10mn 2 pts
4.1 Prouver la validité de la procédure Ordre
4.2 calculer la complexité de la procédure Ordre ? (avec explication).

Procédure Ordre (E-S/ A : Mat, E/n, m, val : entier)

Var j, X : entier, nb1, nb2; V : TAB
Debut
V  VectOcc (A, n, m, val) ; // créer le vecteur de nbre d’occurrences
Pour i 1 à n-1 //on fait un tri par sélection des lignes de la matrice, selon le nbocc
Faire
Min = i;
pour j  i+1 à n
Faire
Si (V[Min] > V[j]) alors Min  j ; fsi ;
Fait;
Si (Min <> i) alors Permute (A, m, i, Min) ; fsi ;
// permuter les lignes i et Min de la matrice
Fait ;
Fin ;

Validité
Terminaison de l’algorithme
n >0 par hypothèse;
i=1 par initialisation et est incrémenté de 1 à chaque tour de boucle ; donc i atteindra la
valeur d’arrêt n-1 après (n-1) itérations;
j=i+1 par initialisation et est incrémenté de 1 à chaque tour de boucle ; donc j atteindra la
valeur d’arrêt n après (n-i) itérations;
Aussi le corps de la boucle ne contient que des comparaisons, affectations et
éventuellement des permutations de lignes  opérations finies
l’algorithme se termine

Validité : Invariants de boucles

A chaque itération de la boucle j, on a dans Min, l’indice de la ligne qui contient le
minimum d’occurrences de val
A chaque itération de la boucle i, la matrice est triée jusqu’à la ligne i (selon le nombre
d’occurrences de val dans chaque ligne).
2 S. Boukhedouma
Complexité : la permutation se fait en O(m)
i =1 ; La boucle j se répète n-1 fois
i =2 ; La boucle j se répète n-2 fois
…
i =k ; La boucle j se répète n-k fois
…
i= n-1 ; La boucle j se répète 1 fois
la boucle j comporte deux instructions
La boucle i comporte 1 affectation + 1 addition +la boucle j (au plus m fois) + condition +
procédure Permute dont la complexité est en O(m)  complexité en O(m)
C(n, m) = (1+2+…+ (n-1)) * (O(m)) = (n(n-1)/2)* (O(m)) = O(n2)*O(m) = O(n2*m)
 complexité cubique C(n, m) = O(n2*m)

5. Reprendre la question 2 pour écrire une procédure récursive permute-Rec qui

permute deux lignes i1 et i2 de la matrice A. 1,25 pt 5mn
Procédure Permute-Rec (E-S/ A : Mat, E/ m, i1, i2, j : entier)
Var j, X : entier;
Debut
Si (j<=m)
alors X  A[i1][j] ; A[i1][j]  A[i2][j] ; A[i2][j] X;
Permute-Rec (A, m, i1, i2, j+1);
Fsi;
Fin ; // on commence avec j =1

6. Calculer la complexité de cette procédure.

On établit et on résout l’équation de récurrence (car procédure récursive)
C(1) = 1 ;
C(m) = 1+ C(m-1)

C(m) = 1+ C(m-1) = 1+1+ C(m-2) = … =1+1+ … +C(m-k) = 1+1+ …+ C(1)= 1+ …+1 (m fois) = m
 C(m) = O(m) linéaire

Exercice 2 6 pts
On considère un problème PB défini comme suit :
Soit E un ensemble fini de valeurs dans N et soit t ∈ N une valeur donnée. On cherche
à savoir s’il existe un sous-ensemble E1 inclus (ou égal) dans E dont les éléments ont
pour somme la valeur t.
3 S. Boukhedouma
 Par exemple E = {25, 6, 17, 64, 256, 105, 1041, 2056, 3200, 67} et t = 2231 alors
E1 = {6, 64, 105, 2056} est une solution.
1. Etant donnés deux ensembles E, E1 (E1 inclus dans E) et une valeur t, écrire
l’algorithme qui vérifie si la somme des éléments de E1 est égale à t. Donnez la
complexité de l’algorithme.

Fonction VérifSomme (E/ E1 : ensemble d’entiers, E/t : entier) : booléen

Var S : entier ;
Debut
S0;
Pour tout élément e dans E1
Faire S  S+e ; Fait;
Si (S = t) alors retourner vrai ;
sinon retourner faux ;
Fin ;

Complexité
La boucle pour se répète n fois, selon le nombre d’éléments de l’ensemble E1
sachant que n est le cardinal de E1.  Complexité linéaire en O(n)

2. On considère un ensemble E de cardinal n (i.e nombre d’éléments est égal à n).

Combien de sous-ensembles pourrait-on construire à partir de l’ensemble E ?
Expliquez
Il s’agit de construire des sous-ensembles de cardinalité (1, 2, 3, …n) par combinaison
d’éléments de E
C(k, n) = combinaison de k éléments parmi n de l’ensemble E

On aura donc : C(1,n) + …+ C(k,n)+…+ … C(n, n) =

k=n

∑ n!/(k!*(n-k)!)
i=1
Ce qui donne un nombre exponentiel de sous-ensembles E1 construits à partir de E

3. Ecrire l’algorithme de résolution du problème PB (défini initialement), en donnant

un pseudo-code seulement. Quelle est la complexité de l’algorithme?
k1
Tant que (k <= n)
Faire
Etiq : Choisir k éléments parmi n //construction de l’ensemble E1
Obtenir l’ensemble E1 (de k éléments)
Si VérifSomme (E1, t) // complexité O(|E1|)
alors retourner vrai ;
sinon
4 S. Boukhedouma
 si (il existe une autre combinaison de k élements)
alors aller à Etiq ;
fsi ;
Fsi ;
k k+1 ;
Fait ;

Complexité : l’algorithme se répète autant de fois que de sous-ensembles E1

construits à partir de E. Ce nombre de sous-ensembles E1 est exponentiel
 L’algorithme a une complexité exponentielle

4. Quelle est la classe du problème PB (L, NL, P ou NP) initialement défini.

Justifiez votre réponse.

Ce problème est de la classe NP (Non déterministe polynômial) car la vérification

solution donnée se fait en temps polynômial (voir question 1)
Mais la solution au problème est non déterministe et nécessite un temps de
calcul exponentiel (voir question 3).

Exercice 3 (4pts)

1) Montrer que les deux sommes S1 et S2 sont égales:

i =n i=n

S1= ∑ = (∑ i)2 = S2
i3 pour tout n >=1
i=1 i=1

Démonstration par récurrence :

Cas se base
i = 1 S1 = 1 et S2 = 1  S1 = S2 //égalité vérifiée
Hypothèse de récurrence
On suppose que l’égalité est vraie à l’ordre n et on montre qu’elle est vraie à l’ordre (n+1)
i =n i=n

Hypothèse: S1= ∑ i3 = (∑ i)2 = S2 pour tout n >=1

i=1 i=1
A l’ordre n+1
i =n+1 i =n

S1= ∑ i3 = ∑ i3 + (n+1)3
i=1 i=1
i=n+1

S2 = (∑ i)2 = (1+ 2+…+n+ (n+1))2 = (n(n+1)/2)2

i=1

5 S. Boukhedouma
 = ((n+1)(n+2)/2)2 = ((n(n+1)/2 + 2*(n+1)/2)2= ((n(n+1)/2+ (n+1))2
= (n(n+1)/2)2 + (n+1)2 + 2*n (n+1)(n+1)/2
// la partie en noir c’est l’hypothèse de récurrence, on calcule la partie en bleu (n+1)2 +
2*n (n+1)(n+1)/2 pour vérifier si elle est égale à (n+1)3
(n+1)2 + 2*n (n+1)(n+1)/2 = (n+1)2 + n (n+1) 2 = (n+1)2 (1+n) = (n+1)3 //cqfd
Donc S1 = S2.
2) Résoudre l’équation de récurrence suivante : // fait en TD
T(1)=1,
T(n) = 2n+1+ 2*T(n/2) si n>1

3) Dites si l’assertion suivante est vraie ou fausse

2n3+n2 log n= Θ (n3)

Il faut trouver C1 et C2 et n0 tels que C1*n3 <= 2n3+n2 log n <= C2*n3
(n>=n0)
C1*n3 <= 2n3+n2 log n <= C2*n3
 C1 <= 2+ logn/n <= C2

(logn/n)< 1 pour tout n>=1

Donc C1 = 2 et C2 = 3 et n0= 1
L’assertion est vraie (on peut utiliser les limites aussi)

6 S. Boukhedouma