TD 1 RecComp Correction

Département d’Informatique
Faculté des Sciences, Université Ibn Zohr 2012-2013

Agadir
Algorithmique et structures de données

TD2 - Correction
Exercice 1: Écrire un algorithme (programme en langage C) itératif donnant l’indice

de la première occurence d’un élément minimal dans un tableau de N entiers (on suppose
N ≥ 2). Exemple : si la suite des élément du tableau est 5,2,4,2,1,7,9,4,1,1, il y a 3
occurrences de l’élément minimal et l’indice de sa première occurence est 5. La fonction
pourra par exemple s’écrire int min(int tab[N]); . Évaluer sa complexité.
Solution 1:
#include<stdio.h>
#define N 4
int min(int tab[N])
{
int i;
// 1 premire affectation de index
int index = 0;
// n comparaisons + n-1 affectations
for(i=1; i<N; i++)
{
// n-1 comparaisons
// dans le pire des cas, n-1 affectations
if(tab[i] < tab[index])
index = i;
}
return index;
}
main()
{
int tt[] ={7,4,2,4,2,9};
printf("index du min est = %d\n", min(tt));
}
• Complexité : T(n) = 1+n+(n-1)+2*(n-1) = 4n-2 ;
• Ordre : O(n) ;
Exercice 2: On appelle MiniMax d’une matrice d’entiers la valeur minimale des maxi-
mas de chaque ligne. Écrire un algorithme qui retourne la valeur MiniMax d’une ma-
trice d’entiers n × m. On suppose N ≥ 1 et M ≥ 1. La fonction pourra être
int MiniMax(int tab[N][M]); . Évaluer sa complexité.
Solution 2:
#define m 3
#define n 3
int MiniMax(int tab[n][m])
{
Pr. Mohamed EL ANSARI Page 1 sur 4

int i;
int j;
int max;
int minimax;
// (n) comparaisons
// n -1 affectations
for(i=0; i<n; i++)
{
// n initialisations du max. pour chaque nouvelle ligne
max = tab[i][0];
// (n)*m comparaisons
// (n)(m-1) affectations
for(j=1; j<m; j++)
{
// (n)(m-1) comparaisons
// (n)(m-1) affectations
if(tab[i][j] > max)
max = tab[i][j];
}
// n comparaisons
// 1 affectation
if(i==0)
minimax = max;
// n comparaisons
// (n-1) comparaisons
else if(minimax > max)
minimax = max;
}
return minimax;
}
main(){
int t[3][3] = {{2,3,4},
{5,6,7},
{8,9,10}};
printf("MiniMax = %d\n", MiniMax(t));
}
• Compexité: T(m,n)=4*m*n+3*n-2;
• Ordre: O(nm), si m = n alors on est en O(n2 ) ;
Exercice 3:
1. Donner une fonction récursive puissance(a,i) qui calcule ai .
2. Refaire la même fonction en utilisant l’exponentiation rapide (voir cours).
3. Calculer la complexité dans les deux cas (1 et 2).

∑n
4. Donner une fonction récursive somme(a,n) qui calcule i=0 ai .
5. Calculer la complexité de l’algorithme précédent (somme).

Solution 3:
1. int puissance(a,i)
int puissance(int a,int i)

{
if(i==0)
return 1;
else
return (a*puissance(a,i-1));
}
2. Complexité de int puissance(a,i). On peut se contenter de la calculer en nombre

de multiplications
T(0) = 0;
T(1) = 1 + T(0) = 1;
T(n) = 1+T(n-1) = 1 + 1 + T(n-2) = n+T(n-n) = n+T(0) = n;
T (n) = O(n)
3. méthode rapide
int expRapide(int a, int i)

{
int p;
if (i==0)
return 1;
else if (i%2)
{
p = expRapide(a,i/2);
p = a*p*p;
return p;
}
else {
p = expRapide(a,i/2);
p = p*p;
return p;
}
}
4. complexité (en nombre de mutilpications): On évalue la complexité pour les valeurs

de n qui sont des puissances de 2 n = 2k .
Pour n=2, P (puissance) = a *a, 1 multiplication (1=ln(2))
Pour n=4, P= (a ∗ a)2 , 2 multiplications (2=ln(4))
Pour n=8, P = ((a ∗ a)2 ), 3 multiplications (3=ln(8))
pour n = 2k , k multiplications (k=ln(n))
On peut déduire que la complexité est O(ln(n))

5. somme
int somme(int a, int n)

{
if(n==0)
return 1;
else
return (puissance(a,n)+somme(a,n-1));
}
6. complexité:
T(s(a,n)) = T(p(a,n))+T(somme(a,n-1))
= T(p(a,n))+T(p(a,n-1))+T(somme(a,n-2))
= T(p(a,n))+T(p(a,n-1))+T(p(a,n-2))+T(p(a,n-3))+...+T(p(a,1))+1
= n + (n-1) + ....+1 = n(n+1)/2
est en O(n2 )
Exercice 4: Dire ce que définissent les fonctions suivantes, puis calculer leur complexité,
pour rec1 en nombre de multiplications par 2 et pour rec2 en nombre d’additions ;
int rec1(int n) int rec2(int n)
{ {
if(n == 0) if(n == 0)
return 1; return 1;
else else
return 2*rec1(n-1); return (rec2(n-1) + rec2(n-1));
} }
• Les deux fonctions calculent 2n
• Complexité de rec1(n):
T1(0) = 0; T1(1)=1+T1(0) = 1;
T1(n)=1+T1(n-1)=1+1+T1(n-2)=n = O(n)
• Complexité de rec2(n):
T2(0) = 0; T2(1)=1+2*T2(0)=1;
T2(2) = 1+2*T2(1) = 1 +2
T2(3)= 1+ 2 T2(2) = 1 + 2 + 22
T2(n) = 1+ 2 + 22 +.....+2n−1
T2(n)= 2n = O(2n )

TD 1 RecComp Correction

Transféré par

Droits d'auteur :

Formats disponibles

TD 1 RecComp Correction

Transféré par

Informations du document

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

TD 1 RecComp Correction

Transféré par

Droits d'auteur :

Formats disponibles

Département d’Informatique

Faculté des Sciences, Université Ibn Zohr 2012-2013

Algorithmique et structures de données

Exercice 1: Écrire un algorithme (programme en langage C) itératif donnant l’indice

• Complexité : T(n) = 1+n+(n-1)+2*(n-1) = 4n-2 ;

Pr. Mohamed EL ANSARI Page 1 sur 4

• Ordre: O(nm), si m = n alors on est en O(n2 ) ;

1. Donner une fonction récursive puissance(a,i) qui calcule ai .

2. Refaire la même fonction en utilisant l’exponentiation rapide (voir cours).

3. Calculer la complexité dans les deux cas (1 et 2).

5. Calculer la complexité de l’algorithme précédent (somme).

Pr. Mohamed EL ANSARI Page 2 sur 4

int puissance(int a,int i)

2. Complexité de int puissance(a,i). On peut se contenter de la calculer en nombre

int expRapide(int a, int i)

4. complexité (en nombre de mutilpications): On évalue la complexité pour les valeurs

Pr. Mohamed EL ANSARI Page 3 sur 4

int somme(int a, int n)

Pr. Mohamed EL ANSARI Page 4 sur 4

Vous aimerez peut-être aussi

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.