Algorithm I Que

Algorithmique et complexité de calcul
Avril 2008
Pr. Mohsine Eleuldj

Département Génie Informatique
Ecole Mohammadia d’Ingénieurs
Université Mohammed V – Agdal
eleuldj@emi.ac.ma
Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 1

Complexité de calcul
Algorithme 1 Classification :
• Linéaire
• Quadratique
Problème Algorithme 2 • Polynomial
• NP
Algorithme 3
• NP-complet
Indécidable
(problème de l’arrêt)

Algorithmique et complexité de calcul
Objectifs
• Étude des techniques de conception et d'analyse des algorithmes.
• comparaison et classification des algorithmes.
• Ce n’est pas un catalogue d'algorithmes pour la résolution de
problèmes spécifiques.
Plan
I Préliminaires
II Analyse de l'efficacité des algorithmes
III Diviser pour régner
IV Algorithmes voraces
V Programmation dynamique
VI Transformation du domaine
VII Algorithmes probabilistes
VIII Préconditionnement
Chapitre I : Préliminaires
Contenu
1 Notion d’algorithme
2 Efficacité des algorithmes
3 Nature de l’analyse
4 Pourquoi des algorithmes efficaces
5 Calcul des nombres de Fibonacci

1 Notion d’algorithme
Origine : le mot "algorithme" est associé au célèbre auteur Perce Abou
Jaafar Mohammed Ibn Moussa Al Khawarizmi connu pour son livre
"Al Jabr oua El Mokabala" écrit à l'an 825.
Définition : un algorithme est une méthode systématique pour résoudre

un problème donné. L'exécution ne doit pas laisser la place à
l'interprétation, l’intuition ni la créativité.
Definition : l’Algorithmique est l’étude des techniques de conception et
d’analyse des algorithmes
Exemples :
• Multiplication des nombres entiers
• Division
• Calcul du PGCD
• Certaines recettes de cuisines
Exemple : multiplication des nombres
53 53 17
x 17 26 34
371 13 72
53 6 136
901 3 272
1 544
901
Analyse des ressources
Méthode classique : tables de multiplications + addition
Méthode russe : multiplication par 2 et division par 2 (décalages à
droite et à gauche dans une représentation en base 2) + addition
Représentation des algorithmes
Langue naturelle Pseudo-code Langage de

programmation
Langue naturelle : ambiguïté

Langage de programmation : complexité de lecture (détails de programmation
Pseudo-code : description des algorithmes

Algorithme de multiplication russe
fonction russe (A,B)
tableau X,Y
X[1] A, Y[1] B, i 1 { initialisation }
tant que X[i] > 1 faire { former les 2 colonnes }
X[i + 1] X[i] div 2
Y[i + 1] Y[i] * 2
ii+1
P0 { addition des entrées appropriées }
tant que i > 0 faire
si (X[i] mod 2 = 1) alors P P + Y[i]
i i-1
retourner P
Exercice : Faire la trace pour l'exemplaire (17,53). Modifier cet algorithme pour
avoir une seule boucle et en utilisant seulement des variables scalaires.
Autre algorithme de multiplication russe
fonction autre_russe (A,B)

entier x,y
x A, y B, P 0 {initialisation}
tant que x ≥ 1 faire
si (x mod 2 = 1) alors P P + y {ajouter la valeur appropriée}
x x div 2
yy*2
retourner P
Exercice : Faire la trace pour l'exemplaire (35, 17).

Autre algorithme de multiplication
fonction pas_russe (A,B)
tableau X,Y
X[1] A, Y[1] B, i 1 { initialisation }
tant que X[i] > 1 faire { former les 2 colonnes }
X[i + 1] X[i] - 1
Y[i + 1] B
ii+1
P0 { additionner les entrées appropriées }
tant que i > 0 faire
si X[i] > 0 alors P P + Y[i]
i i-1
retourner P
Exercice : Faire la trace pour l'exemplaire (53,17). Ecrire l'algorithme

classique de multiplication
Etapes de résolution d’un problème
1 Trouver différents algorithmes (selon ≠ méthodes de conception)

2 Analyser leur efficacité (en terme de temps, espace mémoire,...)
3 Choisir le meilleur algorithme (selon la taille de l'exemplaire, puissance du
matériel, ordre,...)
Algorithme 1
Problème Algorithme 2
Algorithme 3

2 Efficacité des algorithmes
Définition : Un exemplaire x est l’entrée d’un algorithme, |x| = taille de
l'exemplaire x
Exemples
- Tri : |x| est le nombre d'entiers à ordonner
- Multiplication : |x| est le nombre de chiffres (ou bits) des facteurs
Approches d’analyse
- Empirique : programmation + exécution avec plusieurs exemplaires
- Théorique : déterminer la quantité de ressources (temps, mémoire,...) en
fonction de la taille des exemplaires
Avantages de l'approche théorique

- Indépendance de l'ordinateur et langage de programmation
- Gain dans la programmation et l'exécution des algorithmes inefficaces
- Taille des exemplaires n'est pas une contrainte
3 Nature de l’analyse
Efficacité d’un algorithme dépend
- taille de l’exemplaire
- espace mémoire
-…
Comparaison des algorithmes selon différentes analyses

- meilleur cas (optimiste)
- moyenne
- pire cas (pessimiste)

Tri par insertion
Procédure insert (T[1..n])

pour i 2 jusqu'à n faire
x T[i]
ji-1
tant que j > 0 et T[j] > x faire
T[j + 1] T[j]
jj-1
T[j + 1] x
Exercice : Faire la trace pour

T = [3,1,4,0,5], U = [0,3,4,6,9] et V = [9,6,4,3,0]

Trace de insert(T)
i x j j > 0 et T[j] > x T
- - - - 31405
2 1 1 oui
0 non 13405
3 4 2 non
4 0 3 oui
2 oui 13045
1 oui 10345
0 non 01345
5 5 4 non 01345

Trace de insert(U) et insert(V)
i x j U i x j V
- - - 03469 - - - 96430
2 3 1 2 6 1
3 4 2 0 69 430
4 6 3 3 4 2
5 9 4 1 64930
0 46930
4 3 3
2 46390
1 43690
0 34690
5 0 4
3 34609
2 34069
1 30469
Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 0 03469 16

Tri par sélection
Procédure select (T[1..n])

pour i 1 jusqu'à n-1 faire
minj i, minx T[i]
pour j i + 1 jusqu'à n faire
si T[j] < minx alors
minj j
minx T[j]
T[minj] T[i]
T[i] minx
Exercice : Faire la trace pour

T = [3,1,4,0,5], U = [0,3,4,6,9] et V = [9,6,4,3,0]

Trace de select(T)
i j minj minx T
- - - - 31405
1 - 1 3
2 2 1
3 2 1
4 4 0
5 4 0 01435
2 - 2 1
3 2 1
4 2 1
5 2 1 01435
3 - 3 4
4 4 3
5 4 3 01345
4 - 4 4
5 4 4 01345
Trace de select(U) et select(V)
i j minj minx U i j minj minx V
- - - - 03469 - - - - 96430
1 - 1 0 1 - 1 9
2 1 0 2 2 6
3 1 0 3 3 4
4 1 0 4 4 3
5 1 0 03469 5 4 0 06439
2 - 2 1 2 - 2 6
3 2 3 3 3 4
4 2 3 4 4 3
5 2 3 03469 5 4 3 03469
3 - 3 4 3 - 3 4
4 3 4 4 3 4
5 3 4 03469 5 3 4 96430
4 - 4 6 4 - 4 6
5 4 6 03469 5 4 6 96430
Analyse de insert et select
Trace
U : meilleur cas pour insert
V : pire des cas pour insert
V : meilleur cas pour select
U : pire des cas pour select
Conclusion
analyse au pire cas de insert et select
nous allons voir que insert et select sont de l'ordre de n2, où n = |x|

4 Pourquoi des algorithmes efficaces ?
Supposition
A : un algorithme
M : une machine
A’ : un algorithme plus efficace que A
M’ : une machine plus puissante que M
Question : A sur M’ ou A’ sur M ?
Autrement si
n : taille de l’exemplaire
t(n) : temps d'exécution de A sur M
t'(n) : temps d'exécution de A sur M'
t"(n) : temps d'exécution de A’ sur M
Question : t’(n) < t”(n) ou t”(n) < t’(n) ?

Application numérique
t(n) = 10-4 x 2n s
t'(n) = t(n) x 10-2 = 10-6 x 2n s (M’ 100 plus rapide que M)
t"(n) = 10-2 x n3 s (A’ plus efficace que A)
temps de calcul(s)
t(n)
6 t'(n)
n t(n) t'(n) t"(n) 10
5
10 1/10 s 2 ms 10 s 10
20 2 mn 1s 1mn 4 1 jour
10
t"(n)
30 10 jours 3 heures 5 mn 3
10 1 heure
38 1 année 4 mois 10 mn 2
10
45 - 1 année 20 mn
1 minute
10
200 - - 1 jour
1500 - - 1 année
Taille de l'exemplaire

Calcul des nombres de Fibonacci (1/3)
Définition
f0 = 0, f1 = 1
fn = fn-1 + fn-2 pour n ≥ 2
De Moivre
fn = 1/√5 [ Φn - (-Φ)-n ]
où Φ = (1 + √5)/2 le nombre d'or
Cette formule n'est pas pratique pour calculer la valeur exacte de fn

fonction fib1(n)
si n < 2 alors retourner n
sinon retourner fib1(n-1) + fib1(n-2)
fonction fib2(n)
i 1, j 0
pour k 1 jusqu'à n faire
ji+j
ij-i
retourner j

fonction fib3(n)
i 1, j 0, k 0, h 1
tant que n > 0 faire
si n est impair alors
t jh
j ih + jk + t
i ik + t
t h2
h 2kh + t
k k2 + t
n n div 2
retourner j
Exercice : Faire la trace de fib1, fib2 et fib3 la trace pour n = 5

Exécution de fib1, fib2 et fib3
n 10 20 30 50 102 104 106 108
fib1 8 ms 1s 2 mn 21 j - - - -
fib2 1/6 ms 1/3 ms 1/2 m 3/4 ms 3/2 ms 150 ms 15 s 25 mn
fib3 1/3 ms 2/5 ms 1/2 ms 1/2 ms 1/2 ms 1 ms 3/2 ms 2 ms

Chapitre 2 :
Analyse de l’efficacité des algorithmes
Contenu
1 Notations asymptotiques
2 Analyse des algorithmes itératifs
3 Résolution d’équations de récurrences
4 Analyse des algorithmes récursifs

1 Notations asymptotiques
Remarque : L'analyse théorique de l'efficacité d'un algorithme se fait à une constante
près pour ne pas tenir compte de :
- langage de programmation
- compilateur et système d'exploitation
- puissance de l’ordinateur
Notation "l'ordre de"

Soit f : N ---> R*
O(f(n)) = {t : N → R* / (∃ c ∈ R+) (∃ n0 ∈ N) (∀ n ≥ n0) [t(n) ≤ c f(n)]}
Définitions
O(f(n)) est appelé l'ordre de f(n)
t(n) ∈ O(f(n)) ⇒ t(n) est dans l'ordre de f(n)
t(n) : temps d'exécution d'un algorithme ⇒ algorithme est de l'ordre de f(n)
t(n) ∈ O(f(n))
temps
c f(n)
t(n)
n0 n

Exercices
a) Quel est l’ordre de l’algorithme qui prend un temps borné supérieurement par :
t(n) = 3 s - 18n ms + 27n2 µs
b) Prouver que : f(n) ∈ O(g(n)) et g(n) ∈ O(h(x)) ⇒ f(n) ∈ O(h(n))
c) Déduire que g(n) ∈ O(h(n)) ⇒ O(g(n)) ⊂ O(h(n))
d) Soient f, g : N → R+, montrer que :
O(f(n) + g(n)) = O(max(f(n) , g(n)))
e) Soient f et g: N → R+, prouver que :
limn→∞ f(n) / g(n) = c ∈ R+ ⇒ O(f(n)) = O(g(n))
limn→∞ f(n) / g(n) = 0 ⇒ O(f(n)) ⊂ O(g(n))
f) Prouver que : log n ∈ O(√n) et √n ∉ O(log n)
g) Soit x ∈ R / 0 < x < 1. Utiliser ⊂ et = pour mettre en rang les ordres des
fonctions suivantes:
n log n, n8, n1+x, (1 + x)n, (n2 + 8n + log3n)4 et n2/log n

Réponse (1/3)
Exemple 1 : Soit un algorithme qui prend un temps borné

supérieurement par :
t(n) = 3 s - 18n ms + 27n2 µs.
Trouvons une fonction f aussi simple que possible tel que
cet algorithme prenne un temps dans l'ordre de f(n).
Prenons c = 27 x 10-6 et n0 = 500/3

Soit n > n0 _ n > 500/3 _ 18n > 3000 _ 18n x 10-3 > 3 _ 3
- 18n x 10-3 < 0
_ 3 - 18n x 10-3 + 27n2 x 10-6 _ 27n2 x 10-6 = cn2.
Réponse (2/3)
Exemple 2 : a) Prouver que :

f(n) O(g(n)) et g(n) O(h(x)) _ f(n) O(h(n))
b) Déduire que g(n) O(h(n)) _ O(g(n)) C O(h(n))
Preuve :
f(n) O(g(n)) _ ($ c' R+) ($ n' N) (" n > n') (f(n) _ c'g(n))
g(n) O(h(x)) _ ($ c" R+) ($ n" N) (" n > n") (g(n) _ c"h(n))
Soit c = c'c" et n0 = sup(n',n") alors (" n > n0) f(n) _ c'g(n) _ c'c"h(n)
donc f(n) O(h(n)).
Soit f(n) O(g(n)) d'après (a) f(n) O(h(n)) donc f(n) O(h(n)).
Exemple 3 : Soient f, g : N --> R+, montrer que :
O(f(n) + g(n)) = O(max(f(n) , g(n))).

Réponse (3/3)
Applications :
n3+ 3n2+ n + 8 O(n3 + (3n2 + n + 8)) = O(max(n3 , 3n2 + n + 8)) =
O(n3). Il faut s'assurer que f(n) et g(n) soient positives car sinon on
trouvera la contradiction suivante :
O(n2) = O(n3 + (n2 - n3)) = O(max(n3 , n2 - n3))) = O(n3).
Montrer que O(n2) _ O(n3).
Exercice 1: Soient f et g: N ---> R+. Prouver que :
limn-->_ f(n) / g(n) = l R+ _ O(f(n)) = O(g(n))
limn-->_ f(n) / g(n) = 0 _ O(f(n)) C O(g(n))
Exercice 2 : Prouver que log n O( _n) et _n O(log n)
Exercice 3 : Soit x R / 0 < x <1. Utiliser C (inclusion) et = pour mettre
en rang les ordres des fonctions suivantes:
n log n, n8, n1+x, (1 + x)n, (n2 + 8n + log3n)4 et n2/log n.

Autres notations asymptotiques
Remarque : la notion d'ordre est l'estimation d'une limite supérieure du temps
d'exécution d'un algorithme sur un exemplaire de taille donnée. Nous allons
estimer une limite inférieure.
Omega de f(n)
Ω(f(n)) = {t : N → R* / (∃ c ∈ R+) (∃ n0 ∈ N) (∀ n ≥ n0) [t(n) ≥ c f(n)]}
Exercice : Soient f, g : N → R*, montrer que :

f(n) ∈ O(g(n)) ⇒ g(n) ∈ Ω(f(n))
Ordre exact de f(n)

Θ(f(n)) = O(f(n)) ∩ Ω(f(n))

t(n) ∈ Θ(f(n)) = O(f(n)) ∩ Ω(f(n))
temps
c1 f(n)
t(n)
c2 f(n)
n0 n

2 Analyse des algorithmes itératifs
Soit t(n) : temps d'exécution de l'algorithme pour un exemplaire de taille n
Algorithmes analysés
Calcul de Fibbonacci
Tri par selection
Tri par insersion
Calcul du PGCD

Analyse de fib2
fonction fib2(n)
i ← 1, j ← 0 a
pour k ← 1 jusqu'à n faire

j←i+j b
c
i←j-i
retourner j d
t(n) = a + c + d = a + (Σ1 ≤ k ≤ n b) + d = a + bn + d = a’ + bn où a’=a+d

⇒ t(n) ∈ O(n)

Analyse de fib3
fonction fib3(n)
a
i ← 1, ...
tant que n > 0 faire
... c
b
n ← n div 2
retourner j d
t(n) = a + c + d = a + bk + d où k est le nombre d'itérations

k = nombre de bits dans la représentation binaire de n ⇒ k = log2 n + 1
⇒ t(n) ∈ O(log n)
Analyse de select
Procédure select (T[1...n])
pour i ← 1 jusqu'à n-1 faire
minj ← i, minx ← T[i] a
pour j ← i+1 jusqu'à n faire
si T[j] < minx alors
minj ← j b c
e
minx ← T[j]
T[minj] ← T[i]
d
T[i] ← minx
t(n) = Σ1 ≤ i ≤ n-1 [ a + Σi+1 ≤j ≤ n (b) + d ] = (a + d + bn)(n - 1) - bn(n-1)/2
⇒ t(n) ∈ O(n2)
Analyse de l'algorithme d'Euclide
calcul du PGCD de deux nombres
fonction Euclide(m,n)
tant que m > 0 faire
t <-- n mod m
n <-- m
m <-- t
retourner n
Montrons tout d'abord que : " n, m / n _ m _ n mod m < n/2

Cas 1 : m > n/2 _ 1 _ n/m < 2 _ [n/m] = 1_ n mod m = n - m _ n - n/2 = n/2
Cas 2 : m _ n/2 _ n mod m < m
Soit k le nombre d'itérations de la boucle pour l'exemplaire (m,n). Soient mi et ni les valeurs de m et n après la ième
itération. On déduit que mk = 0 et le système suivant :
ni = mi-1
mi = ni-1 mod mi-1
n0 = n et m0 = m
On peut vérifier que ni > mi pour i _ 1. ⇒ mi = ni-1 mod mi-1 < ni-1/2 = mi-2/2
Supposons que k est impair. Soit d tel que k = 2d + 1 alors :

mk-1 < mk-3/2 < mk-5/22 < ... < m0/2d
Or mk-1 _ 1 _ m0/2d _ 1 _ d log m > k 2log m+1
le cas où k est pair est traité de la même ⇒ t(n) ∈ O(log m).

Analyse de fib1
fonction fib1(n)
si n < 2 alors retourner n
sinon retourner fib1(n-1) + fib1(n-2)
t(n) est la solution du système de récurrence :

t(0) = t(1) = a
t(n) = t(n-1) + t(n-2)

3 Résolution de récurrences
récurrence homogène
a0tn + a1tn-1 + .. + aktn-k = 0 (1)
cherchons une solution de la forme tn = xn (équation caractéristique)

a0xn + a1xn-1 + .. + akxn-k = 0 (2)
cherchons une solution non nulle ⇒ (2) devient :

a0xk + a1xk-1 + .. + ak = 0
supposons que les k racines : r1, r2, ..., rk (réelles ou complexes) sont
distinctes alors :
tn = Σ1 ≤ i ≤ k ci(ri)n
où ci (1 ≤ i ≤ k) constantes déterminées par les conditions initiales
Calcul du nombre de Fibonacci
f0 = 0 et f1 = 1 (1)
fn = fn-1 + fn-2 (2)
Posons fn = xn, alors (2) devient : xn = xn-1 + xn-2 ⇒ x2 - x - 1 = 0
∆ = 1 + 4 = 5 ⇒ r1 = (1- √5)/2 et r2 = (1+ √5)/2
⇒ fn = c1 r1n + c2 r2n
En utilisant les conditions initiales (1) on trouve :

c1 + c2 = 0
c1r1 + c2r2 = 0 ⇒ c1 = -1/√5 et c2 = 1/√5
⇒ fn = 1/√5 [-((1- √5)/2)n + ((1+√5)/2)n] (Méthode de Moivre)

Analyse de fib1
t(0) = t(1) = a (1)
t(n) = t(n - 1) + (n - 2) (2)
D'après le calcul précédent on déduit que :

t(n) = c1 r1n + c2 r2n où r1 = (1 - √5)/2 et r2 = (1 + √5)/2
En utilisant les conditions initiales (1), on trouve le système :

c1 + c2 = 0
c1r1 + c2r2 = 0
⇒ c1 = -a (1 + √5)/2√5 et c2 = a (1 + 3√5)/2√5
⇒ t(n) ∈ O(c2n) où |c2| > 1 ⇒ algorithme exponentiel

récurrences non homogènes
Illustrons ce type de récurrence à l'aide de l'exemple suivant où l’on se
ramène à une récurrence homogène
tn - 2tn-1 = 3n (1)
En multipliant (1) par 3 et en la considérant pour n+1 on trouve:
3tn - 6tn-1 = 3n+1 (2)
tn+1 - 2tn = 3n+1 (3)
En faisant la différence de (2) et (3), on trouve :
tn+1 - 5tn + 6n-1 = 0
L'équation caractéristique de cette équation est :
x2 - 5x + 6 = 0 ⇔ (x - 2) (x - 3) = 0
⇒ tn = c12n + c23n
En utilisant (1), on trouve que tn = -c12n + 3n+1

récurrences non homogènes
Illustrons cette technique à l'aide de l'exemple suivant où nous faisons une
transformation de variable :
T(n) = 4T(n/2) + n, n > 1 avec n = 2k (1)
Posons tk = T(2k). L'équation (1) devient :
tk = 4tk-1 + 2k
En multipliant par 2 et en considérant l'équation pour n+1, on trouve :
2tk = 8tk-1 + 2k+1 (2)
tk+1 = 4tk + 2k+1 (3)
(2) – (3) donne : tk+1 - 2tk = 4tk - 8tk-1 ⇔ tk+1 - 6tk + 8tk-1 = 0
L'équation caractéristique de cette équation est :
x2 - 6x + 8 = 0 ⇔ (x - 2) (x - 4) = 0 _ donc tk = c12k + c24k
donc T(n) = c1n + c2n2
En utilisant (1) on trouve que c1= -1 et par conséquent : T(n) = -n + c2n2

Tours de Hanoï
Problème
Soint trois aiguilles (1, 2 et 3) et m disques, tous de taille différente. Au départ
tous les disques sont placés du plus grand au plus petit dans l’aiguille 1.
Comment déplacer les disques à l’aiguille 2 sans jamais mettre de disque par-
dessus un disque plus petit dans les aiguilles ?
1 2 3
Exercice
1 Comment allez-vous faire pour déplacer 3 disques ?
2 Décrire un algorithme de la solution.
3 Faire la trace pour m = 3.
4 Déterminer le nombre de déplacements en fonction de m.
5 Déduire l’efficacité de l’algorithme.
6 Estimer le temps si m = 64 et si un déplacement prend 1 seconde.
7 Démontrer l’optimalité de l’algorithme.
Trace pour m = 3
1 2 3 1 2 3 1 2 3
1 2 3 2 3
1 1 2 3
1 2 3 2 3
1 1 2 3
Tours de Hanoï
1 2 3
procédure Hanoï (m,i,j)

si m > 0 alors
Hanoï (m-1,i,6-i-j)
écrire (i,"-->",j)
Hanoï (m-1,6-i-j,j)
Soit t(m) le temps d’exécution

t(1) = 1
t(m) = 2 t(m-1) + 1
Tours de Hanoï
Soit t(m) : temps d'exécution de l'algorithme sur un exemplaire de taille m.
t(1) = 1
t(m) = 2t(m-1) + 1
Calculons t(m)
t(m) = 2[ 2 t(m-1) + 1 ] + 1 = 22 t(m-2) + 2 + 1
= 22[ 2 t(m-3) + 1 ] + 2 + 1 = 23 t(m-3) + 22 + 2 + 1
= ..........
= 2k t(m-k) + 2k-1 + ... + 2 + 1
= ..........
= 2m-1 t(1) + 2m-2 + ... + 2 + 1 = 2m-1 + 2m-2 + ... + 21 + 20
= (2m - 1) / (2 - 1) = 2m - 1
donc t(m) ∈ O(2m).
Exercice : Trouver une version non récursive de la procédure Hanoï. Trouver

l'ordre de l'algorithme.
Hanoi(3,1,2)
Hanoi(2,1,3)
Trace à l’aide
Hanoi(1,1,2)
Hanoi(0,1,3) d’appels récursif
12
Hanoi(0,3,2)
13
Hanoi(1,2,3)
Hanoi(0,2,1)
23
Hanoi(0,1,3)
12
Hanoi(2,3,2)
Hanoi(1,3,1)
Hanoi(0,3,2)
31
Hanoi(0,2,1)
32
Hanoi(1,1,2)
Hanoi(0,1,3)
12
Hanoianoi(0,3,2)

Trace à l’aide d’un arbre
H(3,1,2)
H(2,1,3) 12 H(2,3,2)
H(1,1,2) 13 H(1,3,1) H(1,3,1) 32 H(1,1,2)
H(0,1,3) 12 H(0,3,2) H(0,2,1) 23 H(0,1,3) H(0,3,2) 31 H(0,2,1) H(0,1,3) 12 H(0,3,1)

Chapitre 3 : Diviser-pour-régner
diviser-pour-regner (Divide and conquer) est une technique de conception
d'algorithme composée de trois étapes :
- Décomposition de l'exemplaire en sous-exemplaires plus petits,
- Résolution des sous-exemplaires et
- Combinaison des sous-solutions.
Plan
1 Fouille dichotomique
2 Multiplication des grands nombres
3 Multiplication matricielle
4 Exponentiation discrète

Schéma des algorithmes DPR
fonction DPR(x)
si x est suffisamment petit alors retourner ADHOC(x)
décomposer x en sous-exemplaires x1, x2, ..., xk
pour i 1 jusqu'à k faire yi <-- DPR(xi)
combiner les yi pour obtenir une solution y
retourner y

Résolution des récurrences DPR
Théorème : Soient a, b, c ≥ 0 et n = ck. La solution de la récurrence
b pour n = 1
T(n) = aT(n/c) + bn pour n > 1
est :
O(n) si a < c
T(n) ∈ O(n log n) si a = c
O(nlog a) si a > c, où le logarithme en base c
T(n) : temps d'exécution d'un algorithme DPR sur l’exemplaire n

Fouille dichotomique
Problème : localisation de la valeur x dans un tableau T[1..n] trié (dictionnaire ou
annuaire téléphonique)
fonction séquentielle (T[1..n],x)

pour i 1 jusqu'à n faire
si T[i] > x alors retourner i-1
retourner n
fonction dichotomique(T[i..j],x)
si i = j alors retourner i
k (i+j+1) div 2
si x < T[k] alors retourner dichotomique(T[i..k-1],x)
sinon retourner dichotomique(T[k..j],x)
Exercice : Montrer que t(n) ∈ O(log n)

Arithmétique des grands entiers
Utilisation : calcul de très grande précision. En 1986, Π est calculé avec
30 millions de chiffres. Ce calcul a nécessité 30 heures de calcul sur un
ordinateur Cray-2.
Problème : calcul de u*v avec u et v composés de n=2k chiffres
Solution :
Algorithme de multiplication classique ∈ O(n2)
Algorithme de multiplication DPR ∈ ?

Multiplication DPR (1/2)
n n/2 n/2
u w x v y z
u = 10sw + x
v = 10sy + z où 0 ≤ x, z < 10s et s = n/2
⇒ u*v = 102s wy + 10s(wz + yx) + xz

Multiplication DPR (2/2)
fonction multA(u,v: grands-entiers) : grand-entier
n max(u,v)
si n est petit alors
multiplier u et v par l'algorithme classique
retourner le résultat
sinon
s n div 2
w u div 10s, x u mod 10s
y v div 10s, z v mod 10s
retourner multA(w,y) 102s + (multA(w,z) + multA(y,x)) 10s + multA(x,z).
Exercice : Montrer que t(n) ∈ O(n2)

Amélioration de la multiplication DPR (1/2)
u = 10sw + x
v = 10sy + z où 0 ≤ x, z < 10s et s = n/2
Soient r, p et q tels que :

r = (w + x)(y + z) = wy + wz + xy + xz
p = wy
q = xz
⇒ u * v = 102s wy + 10s(wz + yx) + xz
= 102sp + 10s (r - p - q) + q

Amélioration de la multiplication DPR (2/2)
fonction multB(u,v: grands-entiers) : grand-entier
n max(u,v)
si n est petit alors
multiplier u et v par l'algorithme classique
retourner le résultat
sinon
s n div 2
w u div 10s, x u mod 10s
y v div 10s, z v mod 10s
r multB(w+x , y+z)
p multB(w,y)
q multB(x,z)
retourner 102sp + 10s(r-p-q) + q
Exercice : t(n) ∈ O(n1,59)

Multiplication matricielle DPR
Soient A, B deux matrices carrées d'ordre n.
C = AB = (cij) 1≤ i, j ≤ n avec cij = Σ1≤k≤n aikbkj
Algorithme classique de multiplication de matrices appartient à O(n3)

Algorithme DPR (Strassen)
Soient A = a11 a12et B =b11 b12
a21 a22 b21 b22
Soient m1, m2 m3, m4, m5, m6 m7 tels que :
m1 = (a21 + a22 - a11)(b22 - b12 + b11)
m2 = a11b11
m3 = a12b21
m4 = (a11 - a21)(b22 - b12)
m5 = (a21 + a22)(b12 - b11)
m6 = (a12 - a21 + a11 - a22)b22
m7 = a22(b11 + b22 - b12 - b21)
Exercice : Montrer t(n) O(n2,7)

Protocole de cryptage (1976)
Fouad
Ali p grand premier Bahia
g / 2 ≤ g ≤ p-1
A / A aléatoire B / B aléatoire
A<p B<p
a = gA mod p b = gB mod p
x = bA mod p y = aB mod p
Ali et Bahia partagent l’information x = y sans que Fouad puisse la détecter

Exponentiation discrète (1/3)
fonction expod1(g,A,p)
a1
pour i 1 jusqu'à A faire a a g
retourner a mod p
Remarque : xy mod p = ((x mod p) (y mod p)) mod p
fonction expod2(g,A,p)
a1
pour i 1 jusqu'à A faire a a g mod p
retourner a
Exercice : Analyser et comparer le temps d'exécution de expod1 et expod2 en

fonction de A et p. Pour simplifier supposer que g=p/2.

Exemple : calcul de x23

x23 = ((…((x x)x)…)x) ⇒ 22 multiplications
x23 = (((x2)2x)2x)2x ⇒ 7 multiplications
fonction expodrec(x,n) fonction expoditer(x,n)

si n = 0 alors retourner 1 a x, b 1
si n est impair alors tant que n > 0 faire
a expodrec(x,n-1) si n est impair alors
retourner a x bab
sinon a a2
a expodrec(x,n/2) n n div 2
retourner a2 retourner b
fonction expod3(g,A,p) fonction expod4(g,A,p)

si A = 0 alors retourner 1 a g, b 1
si A est impair alors tant que A > 0 faire
a expod3(g,A-1,p) si A est impair alors
b a b mod p
retourner a g mod p
a a2 mod p
sinon
A A div 2
a expod3(g,A/2,p)
retourner b
retourner a2 mod p

Exercice
Soit la matrice F= [ 01 11 ]
fn-1 fn
a) Montrer que Fn = [ fn fn+1 ]
où fn est le nième nombre de Fibonacci.
b) Déduire un algorithme de type diviser-pour-régner pour le calcul de Fn.
c) comparer cet algorithme avec fib3 en prenant comme matrices intermédiaires :

i j k h
. [ ]
A = j i+j et B = h h+k [ ]

Retour à l’algorithme fib3
fonction expod4(F,n) fonction expod5(n)

A F, B I k 0, h 1, i 1, j 0
tant que n > 0 faire tant que n > 0 faire
si n est impair alors si n est impair alors
B AB t hj
A A2 j hi + kj + t
n n div 2 i ki + t
retourner B t h2
h 2hk + t
k k2 + t
n n div 2
retourner j
Chapitre 4 : Algorithmes voraces
Généralement
assez simples ⇒ rapides
résolution des problèmes d'optimisation
solutions approximatives (heuristique)
Contenu
Schéma général
Remise de monnaie
Plus courts chemins
Remise de monnaie
Coloration d’un graphe
Feux de signalisation
Optimisation de la sélection avec contrainte
20 Kg
15 Kg
10 Kg
Capacité = 40 Kg
8 Kg
Solution vorace = 20 + 15 = 35 < 40

Schéma des algorithmes voraces
fonction vorace (C : ensemble) : ensemble
{C est l'ensemble de tous les candidats}
S ← ∅ {ensemble solution}
tant que ¬ solution (S) et C ≠ ∅ faire
x ← l'élément de C qui maximise sélect(x)
C ← C - {x}
si réalisable (S ∪ {x}) alors S ← S ∪ {x}
si solution (S) alors retourner S
sinon retourner pas de solution

Exemple 1 : Remise de monnaie
Problème : remettre la monnaie en donnant le moins de pièces possible.
Solution :
C : ensemble fini de pièces 1, 5, 10, 20, 50 et 100 DH
Solution(S) : total des pièces choisies correspond au montant à rendre
Ensemble réalisable : total des pièces n'excède pas la somme à rendre
fonction de sélection : la plus grande pièce qui reste dans C
Fonction objective : nombre de pièces utilisées dans la solution
Exercice : Décrire un algorithme vorace. Montrer qu’il fournit toujours une

solution optimale lorsqu'elle existe

Exemple 1 : Algorithme vorace
fonction Remise_Monnaie (Montant) : tableau
C ← {1,5,10,20,50,100}
S←0
tant que (Montant > 0) et (C ≠ ∅) faire
x ← max{y/ y ∈ C}
C ← C - {x}
NP ← Montant div x {Nombre de pièces de type x}
S[x] ← NP
Montant ← Montant - NP*x
si (Montant = 0) alors retourner S
sinon retourner pas de solution
Exercice : Montrer l’Optimalité (idée (Ci ≥ 2 Ci+1))

Exemple 1 : qualité de la solution
Soit C ’ = C ∪ {12} = {1, 5, 10, 12, 20, 50, 100}

Montant = 16 =12 + 1 + 1 + 1 + 1 (5 pièces) ⇒ solution non optimale
= 10 + 5 + 1 (3 pièces) ⇒ est la solution optimale
Soit C" = C’ - {1} = {5, 10, 12, 20, 50, 100}

Montant = 15 = 12 + ??? ⇒ pas de solution
= 10 + 5 ⇒ une solution existe

Solution d’un algorithme vorace
Solution optimale
Algorithme vorace Solution approximative

non optimale
Pas de solution
alors qu’elle existe

Exemple 2 : Plus courts chemins
Soit G = (N,A) un graphe orienté où N = {1,2,..,n} ensemble des nœuds et A est
l'ensemble d'arcs. A chaque arc est associé une longueur non négative. Essayons de
déterminer la longueur du plus court chemin de 1 vers les autres sommets.
L : matrice d'ordre n tel que L[i,j] ≥ 0 si l'arc (i,j) existe et L[i,j] = ∞ s'il n'existe pas.
fonction Dijkstra(L[1..n,1..n]) : tableau [2..n]

C ← {2,3,..,n}
pour i ← 2 jusqu'à n faire D[i] ← L[1,i]
répéter n-2 fois
v ← l'élément de C qui minimise D[v]
C ← C - {v}
pour chaque élément w de C faire
D[w] ← min (D[w] , D[v] + L[v,w])
retourner D
Exemple 2 : Trace de l’algorithme
1
50
10
étape v C D
100 30 - - {2,3,4,5} [50,30,100,10]
5 2
2 5 {2,3,4} [50,30,20,10]
10 2 4 {2,3} [40,30,20,10]
20 5 3 3 {2} [35,30,20,10]
4 3
50
Exercice : Déterminer l’ordre de l’algorithme de Dijkstra. Modifier le afin de

trouver le chemin le plus court entre tous les couples de sommets.

Exemple 3 : Minimisation de l'attente
Soient un serveur, n clients et ti : temps de service requis par le client i = 1,2,..,n
minimiser : T = S1 ≤ i ≤ n (temps passé dans le système par le client i)
Exemple : t1 = 4, t2 = 7 , t3 = 3.
ordre T
123 4 + (4 + 7) + (4 + 7 +3) = 29
132 4 + (4 + 3) + (4 + 3 + 7) = 25
213 7 + (7 + 4) + (7 + 4 + 3) = 32
231 7 + (7 + 3) + (7 + 3 + 4) = 33
312 3 + (3 + 4) + (3 + 4 + 7) = 24 ← ordre optimal
321 3 + (3 + 7) + (3 + 7 + 4) = 27
Exercice : Montrer que l’algorithme exhaustif ∈ O(n!). Décrire l'algorithme vorace et
analyser son efficacité. Démontrer que sa solution est optimale.
Exemple 3 : Algorithme vorace
fonction Ordonnancement (n,t) : tableau

C ← {1,2,3,…,n}
pour i=1 à n faire
j ← min{ti/ i ∈ C}
C ← C - {j}
S[x] ← j
retourner S
Exercice : Quel est l’ordre de l’algorithme ?

Exemple 3 : Optimalité de l’algorithme (1/2)
Soit I = (i1,i2,..,in) une permutation quelconque dans {1,2,..,n}.
Soit T(I) le temps total passé dans le système pour les clients i1,i2,..,in.
T(I) = ti1 + (ti1 + ti2) + ... + (ti1 + ti2 + .. tin) = nti1 + (n-1)ti2 + ... + tin
= S1≤k≤n (n - k + 1)tik
Supposons qu'il existe dans I, deux entiers a et b tel que a < b et tia > tib. Inversons
l'ordre de ces deux clients et on obtient l'ordre I'.
Ordre de service 1 2 ... a ... b … n
I i1 i2 ... ia ... ib ... In
I' i1 i2 ... ib ... ia ... in
T(I') = (n-a+1)tib + (n-b+1)tia + S1<k<n et k≠a et b (n-k+1)tik

Exemple 3 : Optimalité de l’algorithme (2/2)
T(I) - T(I') = (n-a+1)tia + (n-b+1)tib - (n-a+1)tib - (n-b+1)tia
= (b-a)tia + (a-b)tib = (b-a) (tia - tib)
Comme b - a > 0 et tia - tib > 0, on déduit que :

T(I) - T(I') > 0 et par conséquent T(I) > T(I').
Nous pouvons améliorer tout ordre de service où un client est servi avant un autre
nécessitant moins de temps
⇒ optimalité de l’algorithme

Exemple 4 : Coloration d’un graphe
Soit G = (N,A) un graphe non orienté.
Colorer le graphe tels que deux sommets reliés doivent être de couleurs
différentes.
3
1 2 5
L'algorithme vorace :
4
- Choisir une couleur et un sommet comme point de départ
- Considérer les autres sommets et essayer de les colorer par cette couleur
- Lorsqu'on ne peut plus faire de progrès choisir une nouvelle couleur et un
nouveau point de départ non coloré
- Colorer tout ce qui est possible avec cette deuxième couleur
- ainsi de suite.
Exemple 4 : Coloration d’un graphe
2-coloration 3-coloration
Remarques
Un algorithme basé sur une heuristique vorace permet la possibilité de trouver une
"bonne" solution mais pas la certitude
l’algorithme exhaustif qui produit une solution optimale est exponentiel
Exemple 5 : Feux de signalisation
E
D
Considérons 5 artères : A, B, C, D et E.
A
C
D et E sont des artères à sens unique
Changements de direction (13)

AB, AC, AD, BA, BC, BD, DA, DB, DC, EA, EB, EC et ED B
AB et EC sont possibles alors que AD et EB peuvent provoquer une collision

Modélisation à l’aide d’un graphe
sommets correspondent aux changements de direction
arêtes joignent les couples de sommets dont les itinéraires se croisent
AB AC AD
BA BC BD
AC DA
DA DB DC
BD EB
EA EB EC ED
4-colorable Graphe complet
Solution optimale car le sous-graphe composé des sommets AC, DA, BD et EB est un
graphe complet de 4 sommets et nécessite par conséquent quatre couleurs.
Les sommets de la même couleur correspondent aux itinéraires sans collision. Les quatre
couleurs correspondent aux quatre phases nécessaires du système de signalisation
Exercices
Exercice 1 : Résoudre le problème de signalisation pour le carrefour suivant :
C A
Exercice 2 : Trouver un algorithme vorace pour résoudre le problème du commis

voyageur en supposons que le graphe est complet.

Chapitre 5 : Programmation dynamique
diviser-pour-régner : méthode descendante
programmation dynamique : méthode ascendante + utilisation espace mémoire
(afin d'éviter de calculer la même chose plus d'une fois)
Contenu
Coefficient du binôme
Principe d’optimalité
Multiplication chaînée de matrices
Plus courts chemins

Exemple 1 : Coefficient du binôme
Coefficient binomial
C(n,k) = C(n-1,k-1) + C(n-1,k) si 0 < k < n
= 1 autrement
fonction C(n,k)
si k=0 ou k=n alors retourner 1
sinon retourner C(n-1 , k-1) + C(n-1 , k)

C(5,2)
Trace pour (5,2) =10
C(4,1) C(4,2)
C(3,0) C(3,1) C(3,1) C(3,2)
C(2,0) C(2,1) C(2,0) C(2,1) C(2,1) C(2,2)
C(1,0) C(1,1) C(1,0)C(1,1) C(1,0) C(1,1)
Remarques : beaucoup de valeurs C(i,j) sont calculées plusieurs fois.

Exercice : Montrer que le nombre d'appels récursifs provoqués par C(n,k) est égal
à:
2
( )-2n
k
Exemple 1 : Triangle de Pascal
0 1 2 3 4 5 ... k-1 k
0 1
1 1 1
2 1 2 1
3 1 3 3 1
4 1 4 6 4 1
5 1 5 10 10 5 1
.
.
n-1 1 C(n-1,k-1) C(n-1,k)
n 1 C(n,k)
Exercice : Décrire cet algorithme. Montrer qu’il demande un espace dans O(k) et un
temps dans O(nk) si on compte chaque addition à coût unitaire.
Exercice : Parmi les algorithmes du calcul des nombres de Fibonacci, lequel est un
algorithme de programme dynamique ?
Principe d’optimalité
La programmation dynamique est souvent utilisée pour résoudre des problèmes
d'optimisation qui satisfont le principe d'optimalité suivant :
Principe d'optimalité : Dans une séquence optimale de décisions ou de choix,
chaque sous-séquence doit être optimale.
Exemple : le problème du plus court chemin vérifie le principe d’optimalité
Exercice : Le principe d'optimalité s'applique-t-il au problème du plus long
chemin simple entre deux villes ? Un chemin simple va directement de ville en
ville sans passer deux fois par la même ville (sans cycle).

Exemple 2 : Multiplication chaînée de
matrices
M = M1M2...Mn
Comme la multiplication matricielle est associative
M = (...((M1M2)M3) ... )Mn
= M1(M2(M3(... (Mn-1Mn) ...)))
= ((M1M2)(M3M4) ... )
= ...
Le choix d'une méthode peut influencer sur le temps de calcul.
Exercice : Montrer que le calcul de AB, où A est d'ordre pxq et B est d'ordre qxr,
par la méthode directe nécessite pqr multiplications de nombres scalaires.

Exemple 2 : Application
Exemple : Soient quatre matrices A, B, C et D d'ordre (13x5), (5x89), (89,3) et (3,
34) respectivement.
Il y a cinq manières différentes de calculer ABCD :
((AB)C)D qui nécessite 10582 multiplications
(AB)(CD) " " 54201 "
(A(BC))D " " 2856 "
A((BC)D) " " 4055 "
A(B(CD)) " " 26418 "
La méthode la plus efficace est 9,5 fois plus rapide que la plus lente

Exemple 2 : Nombre de Catalan
Soit T(n) : nombre de manières différentes d'insérer des parenthèses dans M
M = (M1M2...Mi) (Mi+1 .. Mn)
Nous avons T(i) manières de mettre les parenthèses dans la partie gauche de Mi et
T(n-i) manières de mettre les parenthèses dans la partie droite. Par conséquent
T(n) = S1≤i≤n-1 T(i) T(n-i) n T(n)
et T(1) = 1 1 1
2 2
3 2
T(n) s'appelle nombre de Catalan. 4 5
5 14
10 4862
Exercice : Montrer que T(n) = 1/n ( 2n – 1
n–1 )
Exemple 2 : Algorithme de
programmation dynamique
Soit mij (1 ≤ i ≤ j ≤ n) la solution optimale pour la partie Mi...Mj du produit M.
La solution du problème est m1n.
Supposons que la dimension de Mi est di-1 x di pour i = 1,2,..,n.
Construisons la table mij diagonale par diagonale : la diagonale s contient
l'élément mj tel que j-i = s.
Cas 1 : s = 0 ⇒ mij = 0, i = 1,2,..,n
Cas 2 : s = 1 ⇒ mi,i+1 = di-1 di di+1 , i = 1,2,..,n-1
Cas 3 : 1 < s < n ⇒ mi,i+s = min i ≤ k ≤ i+s-1 (mik + mk+1,i+s + di-1dkdi+s)
Le troisième cas représente le fait que pour calculer (Mi Mi+1...Mi+s) on essaye
toutes les possibilités(Mi...Mk)(Mk+1...Mi+s) pour en choisir la meilleure.

Reprenons l'exemple précédent : d = (13,5,89,3,34)
s = 1 : m12 = 5785, m23 = 1335 et m34 = 9078
s = 2 : m13 = min(m11 + m23 + d0d2d3 , m12 + m33 + d0d2d3) = min(1530 , 9256) = 1530
m24 = min(m22 + m34 + d1d2d4 , m23 + m44 + d1d3d4) = min(24208 , 1845) = 1845
s = 3 : m14 = min(m11+ m24+ d0d1d4 , m12+ m34+ d0d2d4 , m13+ m44 + d0d3d4)
= min(4055 , 54201 , 2856) = 2856
j=1 j=2 j=3 j=4
i=1 0 5785 1530 2856
i=1 0 1335 1845
i=3 0 9078
i=4 0
Exercices
Exercice 1 : Ecrire l'algorithme qui calcule m1n. Comment peut-on modifier

l'algorithme si l'on veut savoir comment calculer M de façon optimale ?
Exercice 2 : Montrer que l’algorithme ∈ θ(n3).

Exemple 3 : Plus courts chemins
Soit G = (N,A) un graphe orienté où N = {1,2,..,n}. Soit L une matrice qui donne la
longueur de chaque arc. Trouvons le plus court chemin entre chaque paire de sommets.
Le principe de l'optimalité s'applique car si k est un sommet intermédiaire sur le plus
court chemin entre i et j alors la portion du trajet de i à k ainsi que celle de k à j doivent
aussi être optimales. A l'itération k on trouve un chemin qui ne passe que par {1,2,..,k}.
Dk[i,j] = min(Dk-1[i,j], Dk-1[i,k] + Dk-1[k,j])
Procédure Floyd (L[1 .. n,1 .. n]) : tableau [1 .. n,1 .. n]
D←L
pour k = 1 à h faire
pour i = 1 à n faire
pour j = 1 à n faire
D[i,j] ← min(D[i,j] , D[i,k] + D[k,j])
retourner D
Exercice : Montrer que t(n) ∈ O(n3)
15
1 4
5
5 50 5 15
30
2 3
15
D0 = L = et D4 =
0 5 ∞ ∞ 0 5 15 10
50 0 15 5 20 0 10 5
30 ∞ 0 15 30 35 0 15
15 ∞ 5 0 15 20 5 0
Chapitre 6 : Transformation du domaine
Soit f : Dt → D une fonction à calculer.
Une transformation consiste en :
- domaine R t f
D D
- injection F : D → R
- fonction g : Rt → R Φ Φ −1
g
tel que : f = F-1 ogoF t
R R
Contenu
Multiplication symbolique de deux polynômes
Transformée de Fourrier
Transformée de Fourier inverse
Exemples de transformation du domaine
Produit de deux nombres positifs
D = ℜ+*, f(u,v) = u*v , R = ℜ et F (u)= ln u et g(x,y) = x+y
f
(u,v) u*v
ln
e
g
(ln u,ln v) ln u + ln v
Addition en représentation romaine (XVI + CIV)

Changement de coordonnées (cartésiennes/ polaires)
Calcul dans un ordinateur (E/S en décimal et calcul en binaire)
Calcul différentiel (transformée de Laplace).

Multiplication symbolique des polynômes
Soient p(x) = ad-1xd-1 + ad-2xd-2 + … + a0 et q(x) = bd-1xd-1 + bd-2 xd-2+ … + b0
On veut calculer r(x) = p(x) q(x)
algorithme classique
∈ O(d2) en comptant les opérations scalaires comme élémentaires.
Transformation du domaine f
p (x ),q (x ) r(x )
f : multiplication symbolique
−1
Φ : évaluation en 2d - 1 points ∈ O(d2) Φ Φ
g
g : multiplication ponctuelle) p ( x i) ,q ( x i) r ( x i) = p ( x i) q ( x i)
i= 0 ,1 ,...,2 d - 2 i= 0 ,1 ,...,2 d - 2
F-1 : interpolation
Exemple de la multiplication de deux
polynômes
p(x) = 2x - 1 et q(x) = x - 1
r(x) = p(x)q(x) = (2x – 1)(x – 1) = 2x2 – 3x + 1
p et q peuvent être représentées à l'aide de leur coefficients ou en 2 valeurs

p = (-1,1) et q = (-1,0) ⇒ r = pq = (1,0)
r(x) n’est pas complètement défini
r est de degré 2 ⇒ il doit être défini de façon unique à l'aide de 3 valeurs
p = (-1,1,3) et q = (-1,0,1) ⇒ r = pq = (1,0,3)
par la méthode de Lagrange (ou résolution d’un système linéaire ou ) on trouve :
r (x) = 2x2 – 3x + 1
Transformée de Fourier (discrète)
Applications (optique, acoustique, télécommunications, traitement du signal)
Soient n = 2k , k > 0,
w / wn = 1 (racine de l’unité)
Exemples
w = 4, n = 8 et le calcul se fait modulo 257
w = (1+i) /√2, n = 8 et le calcul est en arithmétique complexe
Définition
Soit a = (a0,a1, .. ,an-1) vecteur qui définit pa(x) = an-1xn-1 + .. + a0
Transformée de Fourier de a relativement à w est :
Fw(a) = (pa(1), pa(w),..., pa(wn-1))
Exercice
Calculer F (a) et F (a) avec a=(1,-1,-5,3) et b=(-2,6,-4,1)
Algorithmique et complexité de icalcul, M. Eleuldj,
i EMI, Avril 2008 104
Algorithme pour la Transformée de
Fourrier
Supposons n > 1 et posons t = n/2

Soient b = (a0,a2,...,an-2) et c = (a1,a3,...,an-1) tels que :
pa(x) = pb(x2) + x pc(x2).
En particulier :
pa(wi) = pb(bi) + wi pc(bi) où b = w2
bt = 1 ⇒ on peut de parler de Fb(b) et Fb(c)
De plus
bt+i= bi ⇒ pa(wt+i) = pb(bi) + wt+i pc(bi)
comme nous allons voir que wt = -1
⇒ pa(wt+i) = pb(bi) - wi pc(bi)
Algorithme FFT
fonction FFT (a[0...n-1] , w) : tableau [0...n-1]
tableau A[0...n-1] {pour recevoir le résultat}
si n=1 alors A[0] <-- a [0]
sinon t <-- n/2
tableaux b, c, B, C[0...t-1]
pour i <-- 0 à t-1 faire b[i] <-- a[2i] , c[i] <-- a[2i+1]
B <-- FFT(b , w2)
C <-- FFT(c , w2)
b <-- 1
pour i <-- 0 à t-1 faire
A[i] <-- B[i] + b C[i]
A[t+i] <-- B[i] - b C[i]
b <-- bw
retourner A
Exercice 1 : Montrer que FFT ∈ O(n logn).
Trace de FFT
a = (1,-1,-5,3), w=i
FFT(a,i)
t=2, b = (1,-5) et c = (-1,3)
B=FFT(1,5)
t=1, b=(1) et c=(-5)
B=FFT(b,1)=(1)
C=FFT(c,1)=(-5)
A=(-4,6)
C=FFT(c,-1)
t=1, b=(-1) et c=(3)
B=FFT(b,1)=(-1)
C=FFT(c,1)=(3)
A=(2,-4)
A=(-2, 6-4i, -6, 6+4i)
Transformée de Fourrier inverse
Définition : le nombre w est appelé une n-ième racine principale de l'unité si :
i) w ≠ 1 (sauf si n=1)
ii) wn = 1
iii) S1≤j≤n-1 wjp = 0 pour 1 ≤ p < n
Remarques :
l'inverse de w est wn-1
si p = n/2, la deuxième condition implique :
S1≤j≤n-1 wjn/2 = n/2(1 + wn/2) = 0 ⇒ wn/2 = -1.
Exercice :
• Montrer que w-1 est une n-ième racine principale de l'unité.
• Soient n et w des puissances positives de 2 et soit m = wn/2 + 1. Prouver que w
est une n-ième racine principale de l'unité dans l'arithmétique modulo m. Prouver
que n-1 existe,
Algorithmique en
et complexité montrant
de calcul, M. Eleuldj,que n-12008
EMI, Avril = m - (m-1)/n. 108
Transformée de Fourrier inverse
Théorème : Soient A la matrice n x m / A = (aij) et aij = wij. Comme w est une n-
ième racine principale de l'unité et n-1 existe alors A est inversible, son inverse
étant la matrice B / B = (bij) et bij = n-1 w-ij et AB = In où In est la matrice
identité.
Une autre formulation de la définition de la transformée de Fourier est :
Fw(a) = a A
Exercice :
Définir A et B pour n = 4.
Corollaire : 0 ≤ i < j < n ⇒ wi ≠ wj.
Cette propriété est essentielle à l'interpolation du polynôme produit

Algorithme FTT inverse
La transformée de Fourier inverse de a relativement à w est :
F-1w(a) = (n-1pa(1) , n-1pa(w-1) ,...n-1, n-1pa(w-(n-1))
= n-1 Fw-1(a) = n-1 Fwn-1(a).
Exercice 4 : Montrer que F-1w(Fw(a)) = a pour tout vecteur a

fonction FFTinverse (a[0 .. n-1] , w) : tableau[0 .. n-1]
tableau F[0 .. n-1]
F <-- FFT(a , wn-1)
pour i <-- 0 à n-1 faire F[i] <-- n-1F[i]
retourner F
FFT inverse ∈ O(n)

Exercice : Faire
Algorithmique la trace
et complexité de calcul,pour FFTinverse(
M. Eleuldj, EMI, Avril 2008 (-2, 6-4i, -6, 6+4i) 110
Application à la multiplication
symbolique des polynômes
Soient p(x) = as-1xs-1 +...+ a0 et q(x) = bt-1 xt-1 +...+ b0
On veut calculer r(x) = p(x)q(x) de degré d = s + t.
Soient n la plus petite puissance de 2 ≥ d et w une n-ième racine principale de l'unité.
Soient a et b tels que a = (a0,a1,..., as-1,0,...,0) et b = (b0,b1,..., bt-1,0,0,...,0).
Soient A = Fw(a) et B = Fw(b)
Ai = p(wi) et Bi = q(wi) , i = 0,1,...,n-1.
Soit C tel que Ci = AiBi = p(wi)q(wi) = r(wi).
⇒ C = Fw(c) correspond aux coefficients de r
D’où
La multiplication symbolique des polynômes ∈ O(d log d)

Trace de l’exemple
p(x) = 3x3 - 5x2 - x + 1 et q(x) = x3 - 4x2 + 6x – 2
On choisit n=8 et on sait que w=4 est une racine principale de l'unité dans
l‘arithmétique modulo 257.
Soit a = (1,-1,-5,3,0,0,0,0), b = (-2,6,-4,1,0,0,0,0).
Fw(a) = (255,109,199,29,251,247,70,133)
et Fw(b) = (1,22,82,193,244,103,179,188).
Le produit point par point modulo 257 donne C = (255,85,127,200,78,255,194,75)
Comme F-1w(C) = (-2, 8, 0, -31, 37, -17, 3, 0).
alors :
r(x) = 3x6 - 17x5 + 37x4 - 31x3 + 8x - 2

Chapitre 7 : Algorithmes probabilistes
Caractéristiques
Hasard peut prendre certaines décisions
Différentes exécutions sur le même exemplaire peuvent produire des résultats
différents
Conflit avec la définition d’un algorithme
Contenu
Ali Baba et les 40 voleurs
Calcul de Π
Intégration numérique
Test de primalité
Algorithmes génétiques
Exemple 1 : Ali Baba et les 40 voleurs
Hypothèses
Valeur du trésor est T Trésor? 5 jours Trésor ?
les voleurs prélèvent chaque nuit un montant x
Une fois sur place Ali Baba peut reconnaître le trésor
4 jours de calcul pour déterminer le lieu exact 5 jours 5 jours
Indication de Jouha moyennant 3x
Solutions
S1 = T – (4 + 5)x = T – 9 x Ali Baba
S2 = T – (3 + 5)x = T – 8 x
S3 = T - 5x
=T - 10 x ⇒ espérance = (T - 5 x)/2 + (T – 10 x)/2 = T – 7,5 x

Exemple 2 : Calcul de Π
k : nombre des points à l’intérieur du cercle
2r
n : nombre total de points
x x x
S1 = Πr2 : surface du cercle x
x
S2 = (2r)2 = 4 r2 : sUrface du carré x
x r
S1/S2 = Πr2/4r2 = Π/4 ⇒ Π = 4 S1/S2 ≈ 4 k/n x
x
x x
fonction Π (n)
x
k←0 x
x
x ← uniforme(0,1)
y ← uniforme(0,1)
si (x2 + y2 <1) alors k ← k + 1
retourner 4k/n
Exemple 3 : Intégration numérique
Soit f : [0,1] [0,1] continue
Calculons l’intégrale f(x) entre 0 et 1
fonction intégration1(f,n)
k← 0
x ← uniforme(O,1)
y ← uniforme(0,1)
si y ≤ f(x) alors k ← k + 1
retourner k/n

Exemple 3 : Intégration numérique
fonction intégration2(f,n)
somme ← 0
x ← uniforme(O,1)
somme ← somme + f(x)
retourner somme/n
Remarque
Algorithme1 et 2 sont intéressants car les algorithmes systématiques ne donnent
que des valeurs approximatives

Exemple 4 : Test de primalité
fonction premier(n)
d ← uniforme(2, √n)
retourner d
Remarques
• Cas favorable : n =1 x 2 x 3 x … x (n-1) = n!
• Pire cas : n non premier mais est le produit de deux nombres premiers
• n = 2623 = 43x61 ⇒ fiabilité = 2%
• Plusieurs tests permettent d’augmenter la fiabilité
• Il existe d’autres moyens qui donnent des tests plus précis

Exemple 5 : Algorithmes génétiques
analogies avec les phénomènes biologiques (sélection naturelle de Charles Darwin)
vocabulaire : individus (solutions potentielles), population, gènes (variables),
chromosomes, parents, descendants, de reproduction, de croisement, de mutations, etc.

Chapitre 8 : Pré-conditionnement
I : ensemble des exemplaires
J, K ⊂ I tel que i ∈ I, i=<j,k>
i’ est la solution de i
k
j Algorithme A Algorithme Bj i’
Exemples
Réalisation d’une application = Compilation + exécution
Recherche dans un ensemble = Construction du tas + recherche binaire en O(log n)
Evaluation répétée d’un polynôme = forme pré-conditionnée + évaluation

Evaluation répétée d’un polynôme
J : ensemble des polynômes à une variable de degré n
K : ensemble des valeurs que la variable peut prendre
Hypothèses
Coefficient entiers
Évaluation pour des valeurs entières
Polynôme unitaires
n = 2k – 1
Comptage du nombre de multiplications
P(x) = x7 – 5x6 + 4x5 +- 13x4 + 3x3 – 10 x2 + 5 x –17

= (x4 + 2)[(x2 + 3)(x – 5) + (x + 2)] + [(x2 –2 – 4)x + (x + 9)]
⇒ 5 multiplications et 9 additions

Méthode de pré-conditionnement
Soit p(x) un polynôme unitaire de degré 2k – 1
k-1
p’(x) = (x2 + a)(q(x) + r(x))
avec a une constante et q et r deux polynômes unitaires de degré 2k-1 -1
la même procédure est appliquée récursivement à q et r
p’ appelée est la forme pré-conditionnée de p
Exercice : trouver p’ pour x7 + 2x6 – 5x4 + 2x3 – 6x2 + 6x – 32 et x7
Soit M(k) : nombre de multiplications pour évaluer p(x)

k-1
M’(k) = M(k) – k + 1 Si on ne compte pas les multiplications pour x2, x4, …, x2
M’(k) = 0 si k = 0
= 2 M’(k – 1) + 1 si k ≥ 2
⇒ M’(k) = 2k – 1 – 1 ⇒ M(k) = 2k – 1 + k – 2
D’où il suffit de faire : (n-3)/2 + log(n + 1) multiplications

Méthodes d’évaluation d’un polynôme
Méthode Nombre de En général
multiplications pour p
Directe 27 n(n + 1)/2 - 1
Dynamique 12 2n – 2
Horner 6 n–1
Pré-conditionnement 5 (n – 3)/2 + log(n + 1)

Algorithm I Que

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

Algorithm I Que

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique et complexité de calcul

Pr. Mohsine Eleuldj

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 1

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 2

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 4

Définition : un algorithme est une méthode systématique pour résoudre

Langue naturelle Pseudo-code Langage de

Langue naturelle : ambiguïté

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 7

fonction autre_russe (A,B)

Exercice : Faire la trace pour l'exemplaire (35, 17).

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 9

Exercice : Faire la trace pour l'exemplaire (53,17). Ecrire l'algorithme

1 Trouver différents algorithmes (selon ≠ méthodes de conception)

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 11

Avantages de l'approche théorique

Comparaison des algorithmes selon différentes analyses

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 13

Procédure insert (T[1..n])

Exercice : Faire la trace pour

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 14

i x j j > 0 et T[j] > x T

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 15

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 0 03469 16

Procédure select (T[1..n])

Exercice : Faire la trace pour

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 17

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 20

Question : A sur M’ ou A’ sur M ?

Question : t’(n) < t”(n) ou t”(n) < t’(n) ?

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 22

Cette formule n'est pas pratique pour calculer la valeur exacte de fn

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 23

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 24

Exercice : Faire la trace de fib1, fib2 et fib3 la trace pour n = 5

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 25

n 10 20 30 50 102 104 106 108

fib2 1/6 ms 1/3 ms 1/2 m 3/4 ms 3/2 ms 150 ms 15 s 25 mn

fib3 1/3 ms 2/5 ms 1/2 ms 1/2 ms 1/2 ms 1 ms 3/2 ms 2 ms

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 26

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 27

Notation "l'ordre de"

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 29

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 30

Exemple 1 : Soit un algorithme qui prend un temps borné

Prenons c = 27 x 10-6 et n0 = 500/3

Exemple 2 : a) Prouver que :

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 32

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 33

Exercice : Soient f, g : N → R*, montrer que :

Ordre exact de f(n)

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 34

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 35

Soit t(n) : temps d'exécution de l'algorithme pour un exemplaire de taille n

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 36

pour k ← 1 jusqu'à n faire

t(n) = a + c + d = a + (Σ1 ≤ k ≤ n b) + d = a + bn + d = a’ + bn où a’=a+d

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 37

t(n) = a + c + d = a + bk + d où k est le nombre d'itérations

t(n) = Σ1 ≤ i ≤ n-1 [ a + Σi+1 ≤j ≤ n (b) + d ] = (a + d + bn)(n - 1) - bn(n-1)/2

Montrons tout d'abord que : " n, m / n _ m _ n mod m < n/2

Supposons que k est impair. Soit d tel que k = 2d + 1 alors :

Algorithmique et complexité de calcul, M. Eleuldj, EMI, Avril 2008 40