Mathématiques Discrètes et Algorithmique - LMPT

Université François Rabelais de Tours
Laboratoire de Mathématiques et Physique Théorique
Mathématiques Discrètes et Algorithmique
UE 5-4 Option Semestre 5
2. Quelques algorithmes classiques
Dans ce chapitre nous présenterons quelques algorithmes classiques, ce qui nous permettra d’une part de
nous familiariser avec le langage algorithmique (le pseudo-code) et d’autre part d’introduire des notions
essentielles à l’algorithmique.
2.1. La division euclidienne. Rappelons tout d’abord la définition de la division euclidienne.
Théorème 2.1. Soient a∈Net b∈Ntels que b6= 0. Il existe un unique couple (q, r)∈N2tel que
a=qb +roù 0≤r≤b−1
On peut calculer le couple (q, r)avec l’algorithme suivant.
Données :a, b ∈N,b > 0
Résultat :(q, r)tel que a=bq +r
q:= 0
r:= a
tant que r≥bfaire
q:= q+ 1
r:= r−b
fin
retourner (q, r)
Algorithme 2: Division Euclidienne
Exemple 2.2. Appliquons cet algorithme avec les valeurs (14,3). Les variables prennent successivement
les valeurs suivantes :
test du tant que q r
Initialisation 0 14
1ère boucle 14 ≥31 11
2ère boucle 11 ≥32 8
3ère boucle 8≥33 5
4ère boucle 5≥34 2
2≥3
On a bien 14 = 4 ∗3 + 2.
Notation : Soient (a, b)∈N2tels que b > 0. On écrira amod bpour désigner le reste
de la division euclidienne de apar bet a÷bpour désigner le quotient.
On rappelle que le pgcd(a, b)est le plus grand diviseur commun de aet b. On a
Théorème 2.3. Soit (a, b)∈N2− {(0,0)}. Il existe r, s ∈Ztels que pgcd(a, b) = ra +sb
L’algorithme pour calculer ret sde ce théorème est basée sur le résultat suivant :
Lemme 2.4. Soit a=bq +roù a, b, q, r ∈N. On a pgcd(a, b) = pgcd(b, r)
L’algorithme le plus connu pour calculer r, s est l’algorithme d’Euclide étendu. Plutôt que de décrire
l’algorithme, donnons un exemple concret :
65 = 9 ·7 + 2
9 = 2 ·4 + 1
et donc pgcd(65,9) = 1. On a
1 = 9 −(2 ·4) = 9 −4·(65 −9·7) = 29 ·9−4·65.
1

2
Cet algorithme n’est pas très efficace car il necessite la mémorisation de toutes les étapes de calculs inter-
médiaires. Nous allons présenter un algorithme bien plus efficace, l’algorithme de Blankinship.
Supposons que nous voulions calculer le pgcd de 252 et 198. Pour calculer uet von construit la matrice
suivante
M0:= 252 1 0
198 0 1!
puis on applique l’algorithme d’Euclide dans la première colonne tout en étendant les manipulations de
lignes au reste de la matrice. Ce sera plus clair sur un exemple :
Ancienne Matrice Pivot Manipulation Nouvelle matrice
M0:= 252 1 0
198 0 1!198 L1:= L1−L2M1:= 54 1 −1 198 0 1 !
M1:= 54 1 −1
198 0 1 !54 L2:= L2−3L1M2:= 54 1 −1 36 −3 4 !
M2:= 54 1 −1
36 −3 4 !36 L1:= L1−L2M3:= 18 4 −5 36 −3 4 !
M3:= 18 4 −5
36 −3 4 !18 L2:= L2−2L1M4:= 18 4 −5 0−11 14 !
L’algorithme s’arrête lorsque la première colonne contient le pgcd. On a alors
18 = 4 ×252 −5×198
Dans l’algorithme , on notera M:= a u1v1
b u2v2!.
Données :a, b ∈N∗
Résultat :(u, v)tel que d=au +bv
u1:= 1
v1:= 0
u2:= 0
v2:= 1
tant que a > 0et b > 0faire
si a≥balors
q:= a÷b
a:= a−q×b
u1:= u1−q×u2
v1:= v1−q×v2
sinon
q:= b÷a
b:= b−q×a
u2:= u2−q×u1
v2:= v2−q×v1
fin
fin
si a>0 alors
pgcd := a
u:= u1
v:= v1
sinon
pgcd := b
u:= u2
v:= v2
fin
retourner (u, v)
Algorithme 3: Algorithme de Blankinship

3
Démonstration de l’algorithme : On définit les matrices suivantes :
U(λ) = 1λ
0 1!, L(λ) = 1 0 λ1!
Soit Mune matrice à deux lignes. On voit facilement que la matrice
1. U(λ)Mest obtenue à partir de Men ajoutant λ-fois la deuxième ligne de Mà la première ;
2. L(λ)Mest obtenue à partir de Men ajoutant λ-fois la première ligne de Mà la deuxième.
Dans l’algorithme de Blankinship, on multiplie sucessivement la matrice Mpar des matrices E1,...,En
de type U(λ)ou L(λ). On pose E=En...E1. Lorsque l’algorithme se termine on a
En...E1M= d u v
0u′v′!ou En...E1M= 0u′v′ d u v !
On a donc (nous n’étudierons que le premier cas, le deuxième étant similaire)
d u v
0u′v′!=E a
b!, I2=E a
b!, E.
Par identification on obtient E= u v
u′v′!. En regardant le coefficient [1,1] dans l’égalité ci-dessus, on a
d=au +bv.
2.2. Ecriture des nombres dans différentes bases. La manière conventionnelle d’écrire les nombres est
l’écriture décimale. On utilise les chiffres 0–9 pour représenter les puissances de 10. Par exemple lorsqu’on
écrit 34765 on veut dire
3×104+ 4 ×103+ 7 ×102+ 6 ×101+ 5 ×100.
En fait, tout nombre entier positif peut jouer le rôle de base.
Théorème 2.5. Soit b∈N∗. Tout nombre entier ns’écrit uniquement sous la forme
n=akbk+ak−1bk−1+...+a1b+a0
où aiest un entier tel que 0≤ai≤b−1pour tout i= 0,...,k et ak6= 0. Cette expression est appelée
l’écriture de nen base b.
Démonstration. On ne montrera que l’existence. L’idée est simple : appliquer l’algorithme de division
euclidienne. Premièrement on divise npar b
n=bq0+a0où 0≤a0< b.
On divise alors q0par b:
q0=bq1+a1où 0≤a1< b.
On continue
q0=bq1+a1où 0≤a1< b
q1=bq2+a2où 0≤a2< b
.
.
..
.
.
qk−2=bqk−1+ak−1où 0≤ak< b
qk−1=b.0 + akoù 0≤ak+1 < b
On doit avoir qk= 0 pour un certain k∈Npuisque
n > q0> q1> . . . ≥0.
et une suite strictement décroissante d’entier se termine par 0. Finalement, on a
n=bq0+a0
=b(bq1+a1) + a0
=b(b(bq2+a2) + a1) + a0
=...
=akbk+ak−1bk−1+...+a1b+a0

4
Exemple 2.6. Ecrivons 456 en base 9. On applique l’algorithme de la preuve :
456 = 9 ·50 + 6
50 = 9 ·5 + 5
5 = 9 ·0 + 5
et on obtient 456 = 5 ·92+ 5 ·9 + 6.
Définition 2.7. On écrit (ak, ak−1,...a1, a0)bpour représenter l’entier nen base b:
n=akbk+ak−1bk−1+...+a1b+a0.
Voici un algorithme, pour calculer l’écriture en base bd’un nombre n.
Données :n, b ∈N,b > 1
Résultat :(ak,...,a1, a0)tel que n=akbk+...+a1b+a0
q:= n
k:= 0
tant que q6= 0 faire
ak:= qmod b
q:= q÷b
k:= k+ 1
fin
retourner (ak,...,a1, a0)
Algorithme 4: Ecriture en base b
Exemple 2.8. Appliquons l’algorithme à n= 201 et b= 2 :
q k Liste des ak
Initialisation 201 0 ∅
boucle 1 100 1 (1)
boucle 2 50 0 (0,1)
boucle 3 25 0 (0,0,1)
boucle 4 12 0 (1,0,0,1)
boucle 5 6 0 (0,1,0,0,1)
boucle 6 3 0 (0,0,1,0,0,1)
boucle 7 1 0 (1,0,0,1,0,0,1)
boucle 8 0 0 (1,1,0,0,1,0,0,1)
On obtient 201 = 27+ 26+ 23+ 20= (11001001)2.
Proposition 2.9. Soit (n, b)∈Navec b > 1. Le nombre de chiffres dans l’écriture de nen base best
⌊logb(n)⌋+ 1 := ⌊log n
log b⌋+ 1
Démonstration. Montrons que tout ntel que bk−1≤n < bkpeut s’écrire avec kchiffre en base b. On
procède par induction sur k.
Initialisation. Si 1≤n < b alors n= (n)bet ns’écrit avec 1 chiffre en base b.
Hérédité. Soit k > 1. Supposons que le résultat est vrai pour k−1et soit ntel que bk−1≤n < bk. Soit
(q, r)∈N2tel que n=bq +ravec 0≤r < b. On a alors q=n−r
bet
n−r
b<bk b=bk−1
n−r
b>bk−1−b b=bk−2−1
et comme qest un entier on obtient bk−2≤q < bk−1. L’hypothèse de récurrence implique que qs’écrit
avec k−1chiffres en base bi.e. (q)b= (ak−2,...,a0)où ak−26= 0. Alors
(n)b= (ak−2,...,a0, r)

5
et ns’écrit avec kchiffres en base b.
On applique le logarithme à l’inégalité bk−1≤n < bk. On obtient
log(bk−1)≤log n < log bkc’est à dire k−1≤log n
log b< k
et ⌊logb(n)⌋+ 1 = k.
2.3. Exponentation modulaire rapide. En cryptographie, il est extrêmement important de pouvoir
calculer rapidement bmmod n. Ce genre d’opération est généralement effectué sur des nombres qui
contiennent 150, 200 voire 300 chiffres. Dans ce contexte il est hors de question de d’abord calculer bm
puis de réduire modulo n.
L’idée est d’utiliser l’écriture binaire de m(en base 2). Soit m= (ak−1,...,a1, a0)2. On a alors
bm=bak−1·2k−1 . . . ba1·2ba0
Pour calculer bmil suffit donc de calculer b, b2,(b2)2,(b4)2. . . b2k. Lorsqu’on a ces valeurs, il suffit de mul-
tiplier entre elles les valeurs b2jqui vérifient aj= 1. On obtient ainsi bn.
Exemple 2.10. Supposons que l’on veuille calculer 311. On a 311 = 38·32·3. On calcule successivement
32= 9,34= 92= 81,38= (81)2= 6561.
Finalement on obtient 311 = 6561 ·9·3 = 177 147.
Dans le cas modulaire, c’est encore plus simple, on peut (et il faut) réduire modulo nà chaque étape.
Données :b, m, n ∈N∗
Résultat :bmmod n
n= (ak−1,...,a0)2
x:= 1
power := bmod n
pour i= 0 àk−1faire
si ai= 1 alors
x:= x·power mod m
fin
power := power ×power
fin
retourner xAlgorithme 5: Exponentiation modulaire
Exemple 2.11. On utilise l’algorithme pour calculer 3644 mod 645. Tout d’abord, on calcule que 645 =
(1010000100)2. On a
i= 0 a0= 0 x= 1 power = 32mod 645 = 9
i= 1 a1= 0 x= 1 power = 92mod 645 = 81
i= 2 a2= 1 x= 81 power = 812mod 645 = 111
i= 3 a3= 0 x= 81 power = 1112mod 645 = 66
i= 4 a4= 0 x= 81 power = 662mod 645 = 486
i= 5 a5= 0 x= 81 power = 4862mod 645 = 126
i= 6 a6= 0 x= 81 power = 1262mod 645 = 396
i= 7 a7= 1 x= 471 power = 3962mod 645 = 81
i= 8 a8= 0 x= 471 power = 812mod 645 = 111
i= 9 a9= 1 x= 36 power = 1112mod 645 = 36
2.4. Algorithme de tri : Premiers exemples. Un algorithme de tri est, en informatique ou en mathé-
matiques, un algorithme qui permet d’organiser une collection d’objets selon un ordre déterminé. Dans ce
cours, nous allons étudier de nombreux algorithmes de tri. Nous commençons ici avec les plus simples, le
tri à bulle et le tri par insertion.