Cours Algoritnmique Avancée

Module:
Algorithmique Avancée et
calcule haute performance HPC
Plan du cours d’ Algorithmique
Avancée
 Introduction Général
 Les algorithmes itératifs et récursifs
 La notion de complexité algorithmique
 Etudes d’algorithmes et analyse de complexité
Algorithme itératif
Algorithme récursif <diviser pour régner>
Autres algorithmes
12/01/2021 Algo. Avancée, Master SER(S3), FSTH 2

Algorithmique (introduction)
 Définition d’Algorithme:
 Un algorithme est suite finie d’opérations élémentaires
constituant un schéma de calcul ou de résolution d’un
problème.
 Problématiques d’algorithmique ?
1. Trouver une méthode de résolution (exacte ou
approchée) du problème.
2. Trouver une méthode efficace.
=>Savoir résoudre un problème est une chose, le résoudre

efficacement en est une autre (temps de calcul, espace
minimale …), ou encore montrer qu’il est correcte …!!
Rappels: algorithme itératif et récursif
 Définition (Définition itérative et récursive, algorithme itératif et récursif):
La récursivité est le fait pour une méthode de s'appeler elle même. On parle alors de
méthode récursive, alors que un alg. itérative désigne l'action de répéter un
processus
Exemple : Le calcul de la factorielle de N.
N != N*(N-1)*(N-2)*…*2*1 , on peut écrire ainsi N != N*(N-1)!
La factorielle de N est définie en fonction de la factorielle de N-1
La fonction a besoin d’elle-même pour donner un résultat
Pour calculer N! il faut savoir calculer (N-1) ! et pour calculer (N-1) ! Il faut
savoir calculer (N-2) ! et ainsi jusqu’à 1! qui est égal à 1 et qui permet à la
récursivité de s’arrêter après une série d’auto appels.
 Il est impératif donc de prévoir une condition d’arrêt à la récursion sinon le
programme ne s’arrête jamais!
A l’opposé de la récursion, l’itération utilise les structures de contrôle
répétitives comme POUR, TANT QUE, REPETER JUSQU'À etc…
Exemple: algorithme itératif et récursif
 L’algorithme suivant calcule et retourne n!:
Exemple itératif Exemple récursive
Algorithme Algorithme
début début
n,i, f:entier; n,i, f:entier;
f← 1; lire(n);
lire(n); Fact(n)
pour i ← 2 à n par pas de 1 faire Si (n=1) alors
f ← f * i;
revoyer (1);
fin pour
Sinon
renvoyer(f);
revoyer (n*Fact(n-1));
fin
fin Si
fin

Rappels: algorithme itératif et récursif
 Exemple: Développons le calcul qui est effectué pour calculer 4!.
 factorielle 4 = 4 * (factorielle(3))
= 4 * (3 * (factorielle(2)))
= 4 * (3 * (2 * factorielle(1)))
= 4 * (3 * (2 * (1 * factorielle(0))))
= 4 * (3 * (2 * (1 * 1))) Application du condition d’arrêt.
= 4 * (3 * (2 * 1))
= 4 * (3 * 2)
=4*6
= 24
Les quatre premières lignes constituent ce que l’on appelle la descente
récursive. La cinquième ligne est l’application du cas de base. Les quatre
dernières lignes forment la remontée récursive c’est-à-dire les étapes finales de
calcul.
Exemple: algorithme itératif et récursif
 L’algorithme suivant calcule et affiche 2ⁿ, où n est saisi au clavier:
Exemples itératif
Algorithme2
Algorithme1 début
début entier i, n, puiss;
entier i, n, puiss; puiss ← 1;
puiss ← 1; i ← 0;
lire(n); lire(n);
pour i ← 0 à n-1 pas 1 faire tant que i<n faire
puiss ← puiss * 2; puiss ← puiss * 2;
fin faire i ← i+1
ecrire(puiss); fin faire
fin ecrire(puiss);
fin

Algorithmique introduction
 Exemple:
 problème : calcule de xn (algorithmes itératifs)
données : x : réel , n: entier
Méthode 1 : x0 = 1; xi = x* xi-1 i >0 T(n) = n-1  O(n)
Méthode 2 : x0 = 1; T (n)= log2 n dans le meilleur cas
xi = xi/2 * xi/2 , si i est pair; Ω(log n)
xi = x*xi/2 * xi/2 si i est impair T (n)= 2*log2 n -1 dans le pire cas
résultats : y = xn  O(log n)
 Laquelle choisir? et pourquoi (complexité) ? (Plutôt la deuxième).
=>Dans un algorithme itératif, les instructions prennent un temps
de calcul constant, les affectations également. Les boucles par
contre vont faire grimper la complexité.
La notion de complexité :
 Complexité
Définition (Complexité). La complexité d’un algorithme
est la mesure du nombre d’opérations fondamentales qu’il
effectue sur un jeu de données. La complexité est exprimée
comme une fonction de la taille du jeu de données.
 Nous notons T(n) ou C(n) le coût de l’algorithme sur la
donnée.
 Complexité au meilleur : Tmin(n). C’est le plus petit
nombre d’opérations qu’aura à exécuter l’algorithme sur
un jeu de données de taille fixée, ici à n. C’est une borne
inférieure de la complexité de l’algorithme sur un jeu de
données de taille n.
Analyse de la complexité :
 Complexité au pire : Tmax(n) C’est le plus grand nombre
d’opérations qu’aura à exécuter l’algorithme sur un jeu de
données de taille n.
 Avantage : il s’agit d’un maximum, et l’algorithme finira donc toujours
avant d’avoir effectué Tmax(n) opérations.
 Inconvénient : cette complexité peut ne pas refléter le comportement «

usuel » de l’algorithme, le pire cas pouvant ne se produire que très
rarement, mais il n’est pas rare que le cas moyen soit aussi mauvais que
le pire cas.

Complexité en moyenne : Tmoy(n)
C’est la moyenne des complexités de l’algorithme sur des jeux de
données de taille n (en toute rigueur, il faut bien évidemment tenir
compte de la probabilité d’apparition de chacun des jeux de données).
Avantage : reflète le comportement « général » de l’algorithme si les cas
extrêmes sont rares ou si la complexité varie peu en fonction des données.
Inconvénient : la complexité en pratique sur un jeu de données particulier peut
être nettement plus importante que la complexité en moyenne, dans ce cas la
complexité en moyenne ne donnera pas une bonne indication du
comportement de l’algorithme.
En pratique, nous ne intéresserons qu’à la complexité au pire cas et un peu
moins à la complexité en moyenne.

 Modèle de machine
Pour que le résultat de l’analyse d’un algorithme soit
pertinent, il faut avoir un modèle de la machine sur
laquelle l’algorithme sera implémenté (sous forme de
programme). On prendra comme référence un modèle
de machine à accès aléatoire (RAM) et à processeur
unique, où les instructions sont exécutées l’unes après
les autres, sans opérations simultanées.

La complexité :
 Notation de Landau:
 On ne s’intéresse pas en général à la complexité exacte, mais
à son ordre de grandeur.
 besoin de notations asymptotiques.
f est asymptotiquement majoré
par O(g(n)), minoré par Ω(g(n),
dominée par o(g(n)) et bornée
par Θ(g(n)).

La complexité :
 Pourquoi s’intéresser à l’ordre de grandeur :
 Soit un algorithme dont la complexité (coût en temps pour
s’exécuté) et décrit par : T(n) = 3n² + 10n +10.
 Prenons n = 100 : on a l’ordre de grandeur de T(n) est O(n²).
i. Temps d’exécution de 3n² en %

ii. Temps d’exécution de 10n en %
iii. Temps d’exécution de 10 en %
Le poids de l’ordre du grandeur du T(n) {3n²}règne alors sur la
complexité de l’algorithme 97%. Donc on peut négliger les termes
{10n et 10}.

Classe de complexité :
Généralement on s’intéresse qu’à la complexité O, et on peut distinguer
plusieurs classe de la complexité algorithmique f(n)=O(g(n)).

Calcul de complexité :
Complexité algorithmique pour une affectation, écriture et lecture
x : entier ;
y : entier ;
x0;
yx;
La complexité vaut Max {O(1),O(1)}= O(1).
Complexité algorithmique pour une boucle itératif Tant Que:

Tant Que (condition) faire
Traitement …
Fin Tant que  La complexité vaut le nombre d’itérations*
{O(T condition) + O(T traitement)}
Premier algorithme de tri (Naïf)
 Illustration : cas du tri par insertion
 Problématique du tri
données : une séquence de n nombre a1, a2, . . . , an.
résultats : une permutation <a’1, a ’2, . . . , a ’n> des données t.q.
a’1  a’2 , . . . ,  a’n
 Exemple [5;2;4;6;1;3] :

premier algorithme de tri
 Illustration : cas du tri par insertion
 Algorithme:

Analyse de la complexité : algorithme de tri
 Complexité
 attribution d’un coût en temps ci à chaque instruction
 compter le nombre d’exécutions de chacune des instructions.
 Pour chaque valeur de j  [2..n], nous notons t j le nombre d’exécutions de la
boucle tant que pour cette valeur de j.
Il est à noter que la valeur de tj dépend des données…
 Le temps d’exécution total de l’algorithme est alors T(n):

 Complexité au meilleur : le cas le plus favorable pour

l’algorithme TRI-INSERTION est quand le tableau est
déjà trié. Dans ce cas tj = 1 pour tout j.
 T(n) = (C1 + C2+ C3 + C4 + C7 ) n - ( C2+ C3 + C7 )
 T(n) peut ici être écrit sous la forme T(n) = an+b, a et

b étant des constantes indépendantes des entrées.
 T(n) est donc une fonction linéaire de n  O(n).
Algo. Avancée, Master SER(S3),
12/01/2021 FSTH 20
 Complexité au pire : le cas le plus défavorable pour

l’algorithme TRI-INSERTION est quand le tableau est déjà
trié dans l ’ordre inverse. Dans ce cas tj =j pour tout j.
 T(n) peut ici être écrit sous la forme T(n) = an2 +bn +c.
 Avec a, b et c des constantes, et T(n) est donc une fonction
quadratique  O(n2).

12/01/2021 FSTH 21
 Ordre de grandeur de la complexité : Seul le terme dominant de la

formule exprimant la complexité nous importe pour l’ordre de
grandeur du temps d’exécution, les termes d’ordres inférieurs n’étant
pas significatifs quand n devient grand. On ignore également le
coefficient multiplicateur constant du terme dominant.
 meilleur cas : O(n).
 pire cas : O(n2).
 moyenne : O(n2).
 En général, on considère qu’un algorithme est plus efficace qu’un
autre si sa complexité dans le pire cas a un ordre de grandeur
inférieur.
Récursivité Diviser pour régner
Divide and Conquer strategy
 Principe

La récursivité
Le paradigme « diviser pour régner »
 Définition:
Un nombres d’algorithmes qu'ont une structure récursive :
pour résoudre un problème donné, ils s’appellent eux-
mêmes récursivement une ou plusieurs fois sur des
problèmes très similaires, mais de tailles moindres.
Récursivité simple
Reprenons la fonction puissance x  xn. Cette fonction peut être
définie récursivement :
PUISSANCE (x, n)
Si n = 0 alors renvoyer 1
sinon renvoyer x×PUISSANCE(x, n-1)

La récursivité
et le paradigme « diviser pour régner »
 Récursivité multiple
Une définition récursive peut contenir plus d’un appel récursif.
Nous voulons calculer ici les combinaisons Cpn en se servant de la
relation de Pascal :
COMBINAISON (n, p)
Début
Si p = 0 ou p = n alors renvoyer 1
sinon renvoyer COMBINAISON (n-1, p) + COMBINAISON (n-1, p-1)
Fin Si
Fin
12/01/2021 FSTH 25
La récursivité et le paradigme
« diviser pour régner »
 Récursivité mutuelle
Des définitions sont dites mutuellement récursives si elles
dépendent les unes des autres. Ça peut être le cas pour la
définition de la parité :
Les algorithmes correspondants s’écrivent :

PAIR (n) IMPAIR (n)
Si n = 0 alors renvoyer vrai Si n = 0 alors renvoyer faux
sinon renvoyer IMPAIR (n-1) sinon renvoyer PAIR (n-1)

12/01/2021 FSTH 26
La récursivité
 Récursivité imbriquée
La fonction d’Ackermann est définie comme suit :
ACKERMANN(m, n)
si m = 0
alors renvoyer n+1
sinon si n = 0 alors renvoyer ACKERMANN (m-1, 1)
sinon renvoyer ACKERMANN(m-1, ACKERMANN(m, n-1))
En résumé on peut utiliser la récursivité comme l’on veut, à peu près
n’importe comment.
La récursivité
 Principe et dangers de la récursivité
 Principe et intérêt : ce sont les mêmes que ceux de la
démonstration par récurrence en mathématiques. On doit
avoir :
– un certain nombre de cas dont la résolution est connue, ces «
cas simples » formeront les cas d’arrêt de la récursion;
– un moyen de se ramener d’un cas « compliqué » à un cas «
plus simple ».
 La récursivité permet d’écrire des algorithmes concis et
élégants.
12/01/2021 FSTH 28
La récursivité
 Difficultés :
– la définition peut être dénuée de sens :
Algorithme A(n)
renvoyer A(n)
– il faut être certains que l’on retombera toujours sur un cas
connu, c’est-à-dire sur un cas d’arrêt ; il nous faut nous
assurer que la fonction est complètement définie.

12/01/2021 FSTH 29
Terminaison d’une Algorithme
 Indécidabilité de la terminaison
Peut-on écrire un programme qui vérifie automatiquement
si un programme donné P termine quand il est exécuté
sur un jeu de données D?
 Entrée: Un programme P et un jeu de données D.
 Sortie: vrai si le programme P termine sur le jeu de données D,
et faux sinon.
 Démonstration de l’indécidabilité
 Supposons qu’il existe un tel programme, nommé termine, de
vérification de la terminaison. À partir de ce programme on
conçoit le programme Q suivant :
Terminaison d’une Algorithme
programme Q
résultat = termine(Q)
tant que résultat = vrai faire Rien… fin tant que
renvoyer résultat
 Supposons que le programme Q, qui ne prend pas d’arguments,
termine. Donc termine(Q) renvoie vrai, la deuxième instruction de
Q boucle indéfiniment et Q ne termine pas. Il y a donc contradiction
et le programme Q ne termine pas. Si termine(Q) renvoie faux, la
deuxième instruction de Q ne boucle pas, et le programme Q
termine normalement. Il y a une nouvelle fois contradiction.
 par conséquent, il n’existe pas de programme tel que termine et le
problème de la terminaison est indécidable!!
12/01/2021 FSTH 31
Justesse d’un Algorithme
 Comment s’assurer qu’un algorithme se termine, qui il est correct ?
et efficace ?
 Un algorithme est totalement correct (qui fait ce qu'il est censé de
faire) si il renvoi une solution correcte pour chaque instance.
Algorithme correcte? Algorithme termine?
• il faut prouver que la première la preuve est par récurrence, en
itération renvoi un résultat vrai. montrant qu’il existe un
• La solution reste vrai pendant les convergence, i.e. une quantité qui
itérations qui suit (par induction). strictement diminue ou augment à
• Il faut montrer qu’après la chaque itération (ou appelle
dernière itération on obtient bien le récursive), de façon à s’approcher du
résultat désiré (la sortie de boucle). condition d’ arrêt.
12/01/2021 FSTH 32
La récursivité
 Exemple : Tours de HANOI
 Le problème est constitué des tiges qui sont enfilés des disques de
diamètres tous différents. Les seules règles du jeu sont 1- on ne peut
déplacer qu’un seul disque à la fois, et 2- il est interdit de poser un
disque sur un autre plus petit. Au début tous les disques sont sur la
tige de gauche, et à la fin sur celle de droite.
 Algorithme
HANOÏ(n, départ, intermédiaire, destination)
Si n = 1 alors déplacer le disque supérieur de la tige départ vers la tige destination
sinon HANOÏ(n-1, départ, destination, intermédiaire)
déplacer le disque supérieur de la tige départ vers la tige destination
HANOÏ(n-1, intermédiaire, départ, destination)
Fin Si
Analyse de complexité
 Exemple : Tours d’HANOÎ
Méthode récursive pour la résolution du problème de Hanoï:
A B C
Calculer la Complexité C(n) et son Ordre?

12/01/2021 FSTH 34
Analyse de complexité
 Exemple n=3D : pour trois disques, on peut déplacer la tour du
piquet A au piquet C en effectuant (C(n)= 2³-1) 7 mouvements
comme illustré ci-dessous.

12/01/2021 FSTH 35

Cours Algoritnmique Avancée

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

Cours Algoritnmique Avancée

Transféré par

Droits d'auteur :

Formats disponibles

Module:

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 2

=>Savoir résoudre un problème est une chose, le résoudre

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 5

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 7

 Inconvénient : cette complexité peut ne pas refléter le comportement «

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 10

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 11

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 12

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 13

i. Temps d’exécution de 3n² en %

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 14

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 15

Complexité algorithmique pour une boucle itératif Tant Que:

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 17

 Illustration : cas du tri par insertion

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 18

 Le temps d’exécution total de l’algorithme est alors T(n):

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 19

 Complexité au meilleur : le cas le plus favorable pour

 T(n) = (C1 + C2+ C3 + C4 + C7 ) n - ( C2+ C3 + C7 )

 T(n) peut ici être écrit sous la forme T(n) = an+b, a et

 Complexité au pire : le cas le plus défavorable pour

Algo. Avancée, Master SER(S3),

 Ordre de grandeur de la complexité : Seul le terme dominant de la

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 23

12/01/2021 Algo. Avancée, Master SER(S3), FSTH 24

Les algorithmes correspondants s’écrivent :

Algo. Avancée, Master SER(S3),

Algo. Avancée, Master SER(S3),

Calculer la Complexité C(n) et son Ordre?

Algo. Avancée, Master SER(S3),

Vous aimerez peut-être aussi