AlgorithmiqueAvancéesPython

Algorithmes Avancés et
Programmation avec Python
I.
II.
III.
IV.
Analyse des algorithmes
Complexité des algorithmes récursifs
Tris et rangs
Les files avec priorités (tas binomial, tas de
fibonacci)
V. Les tables de Hachage
VI. Graphes et structures de données pour les graphes
VII. Les algorithmes gloutons
VIII.La programmation dynamique
Responsable du cours : Mariem Gzara
Mastère Big Data
Université de Djibouti-Faculté des Sciences
2019-2020
ALGORITHMES AVANCÉS ET
PROGRAMMATION AVEC
PYTHON
1
2
Analyse des algorithmes
• Motivations pour calculer la complexité
• Complexité des algorithmes
• Notations asymptotiques et grandeurs de
fonctions
• Notations asymptotiques et algorithmes
Analyse des algorithmes
3
4
1
Motivations
Motivations
Algorithme: recherche_valeur
Entrée : tableau T, Valeur
Début
(1) I1
Tant que(
(IN)(2)
et
(T[I]  valeur)(3)
(4) II+1
Fin tant que
(5) Si (I>N) alors
(6) écrire (valeur pas dans le tableau)
Sinon
(7) écrire (valeur dans tableau)
Fin Si
Fin
• Considérons le problème de recherche d’une valeur a
dans une séquence <a1, a2…an> de taille n.
• Instances possibles du problème de recherche d’une
valeur:
<5,10,8,19,30>, n=5, a=10
<18, 19, 20, 48,58>, n=5, a=10
<18, 100,30,…,150>, n=100, a=19

Une instance d’un problème est constituée de
toutes les entrées nécessaires pour calculer une
solution du problème.
5
Motivations
6
Motivations
Exécution à la main:
Instance 1: <5,10,8,19,30>, n=5, a=5
(1) I=1
(2)15 vrai
(3) T[1]=5  5 faux
(5) 1 5 vrai
(6) Retourner vrai
Instance 2: <5,10,8,19,30>, n=5, a=30
(1) I=1
(2)15 vrai
(3) T[1]=5  30 vrai
(4) I=2
(2)25 vrai
3) T[2]=10  30 vrai
 5 instructions élémentaires
(4) I=3
(2)35 vrai
(3) T[3]=8  30 vrai
(4) I=4
(2)45 vrai
(3) T[4]=19  30 vrai
(4) I=5
(2) 55 vrai
(3) T[5]=30  30 faux
(5) 5 5 vrai
(6) Retourner vrai
 17 instructions élémentaires
 Le nombre d’instructions élémentaires exécutées dépend de la position de la
valeur recherchée dans l’instance
)
Exécution à la main:
Instance 2: <5,10,8,19,30,16,22>, n=7, a=22
(1) I=1
(4) I=6
(2)17 vrai
(2) 67 vrai
(3) T[1]=5  22 vrai
(3) T[6]=16  22 vrai
(4) I=2
(4) I=7
(2)27 vrai
(2) 77 vrai
(3) T[2]=10  22 vrai
(3) T[7]=22 22 faux
(4) I=3
(5) 7 7 vrai
(2)37 vrai
(6) Retourner vrai
(3) T[3]=8  22 vrai
 23 instructions élémentaires
(4) I=4
(2)47 vrai
(3) T[4]=19  22 vrai
(4) I=5
(2) 57 vrai
(3) T[5]=30  22 vrai
 Le nombre d’instructions élémentaires exécutées dépend de la taille de
linstance
7
8
2
Motivations
Motivations
• Un nombre maximum d’instructions est exécuté si valeur
se trouve sur le dernier élément du tableau ou bien ne
fait pas partie du tableau
• Un nombre minimum d’instructions est exécuté si valeur
se trouve sur le premier élément du tableau
T(meilleur des cas)temps exécution instanceT(pire des cas)

exécutées dans un algorithme dépend de
l’instance, c-à-d dépend de l’entrée de
l’algorithme :
– dépend de la taille de l’entrée
– dépend de la nature de l’entrée

Cas le plus favorable
 Le nombre d’instructions élémentaires
Cas le plus défavorable
Comment prévoir le temps de réponse d’un algorithme?????????
9
Motivations
10
Motivations
Calcul de xn, x réel, n entier
Méthode naïve
Puissance(x,n)
y1
I 1
Pour I allant de 1 à n faire
y y*x
Fin pour
Retourner y
Pour calculer x23, il faut effectuer 23
multiplications
Méthode binaire
1. Écrire n sous forme binaire
2. Remplacer chaque :
– « 1 » par la paire de lettres « SX » ;
– « 0 » par la lettre « S ».
3. Éliminer la paire « SX » la plus à
gauche.
4. Résultat : un mode de calcul de xn où
– S signifie « élever au carré »
– X signifie « multiplier par x ».
Le tout en partant de x.
• Double problématique de l’algorithmique:
• Trouver une méthode de résolution (exacte ou
approchée) du problème.
• Trouver une méthode efficace.
Savoir résoudre un problème est une chose, le
résoudre efficacement en est une autre.
Pour calculer x23, il faut 7 multiplications
23 =10111
SX
S
SX
SX
SX
S
SX
SX
SX
x2
x5
x11
x2311
12
3
Motivation
Complexité des algorithmes
• Objectifs:
• La Complexité spatiale d’un algorithme est la
mesure du nombre de mots mémoire
nécessaires pour la mise en œuvre de
l’algorithme
– prévoir les ressources nécessaires à un algorithme (temps, mémoire)
– mesurer l’efficacité d’un algorithme
– comparer des algorithmes
• Les critères de choix d’un algorithme sont:
– Simplicité de compréhension, de mise en œuvre
– Exploitation optimale des ressources de l’ordinateur, mémoire et
entrée/sortie
– Rapidité d’exécution
• La complexité temporelle d’un algorithme est la
mesure du nombre d’opérations fondamentales
qu’il effectue sur un jeu de données
• Le temps d’exécution d’un algorithme dépend :
– du nombre et de la nature des entrées/sorties.
– des performances de l’unité centrale, de la taille de la mémoire centrale
relativement à la taille des données manipulées
– de la complexité algorithmique du programme.
• La complexité est exprimée comme une fonction
de la taille du jeu de données
13
Complexité spatiale
14
Temps de calcul
• Complexité en temps
• Réduction de la complexité spatiale complexité spatiale : Une
matrice de permutation contient un seul 1 par ligne et par colonne.
Quelle structure de données minimale permet de stocker une telle
matrice ?
T(algo, d) =
temps d'exécution de l'algorithme algo appliqué aux
données d
• Éléments de calcul de la complexité en temps
– T(opération élémentaire) = constant
– T( si C alors I sinon J ) = T(C) + max (T(I), T(J))
– T( pour i allant de e1 à e2 faire li ) = T(e1) + T(e2) +  T(Ii)
– Temps de calcul de procédures récursives est solution
d’équations de récurrence
15
16
4
Tri-insertion
Temps de calcul
Coû meilleur
t
cas
Tri_insertion(T,n)
pire cas
Pour j2 à N faire c1
clé A[j] c2
Insertion de A[j] dans la séquence
trié A[1,j-1]
i j-1 c3
Tant que i>=1 et A[i]>clé Faire c4 c5
A[i+1] A[i] c6
i i-1 c7
Fin Tant que
A[i+1] clé c8
Fin pour
• T(algo, d) dépend en général de d.
• Complexité au pire
TMAX (algo, n)=max {T(algo, d) ; d de taille n }
• Complexité au mieux
TMIN (algo, n)=min {T(algo, d) ; d de taille n }
• Complexité en moyenne
TMOY (algo, n)=  p(d).T(algo, d)
p(d) = probabilité d'avoir la donnée d
TMIN (algo, n)  TMOY (algo, n)  TMAX (algo, n)
17
Complexité des algorithmes
•
Étudier l’efficacité asymptotique des algorithmes, c-à-d la limite du
temps d’exécution en fonction de la taille de l’entrée
•
Mesurer le comportement asymptotiques de grandeurs données
(encombrement et temps d’exécution)
•
Taille mémoire nécessaire
•
Dans le pire cas
•
•
Dans le meilleur cas
En encadrement (cas moyen) : pas facile à calculer hypothèses
probabilistes sur la répartition des données
18
Notation asymptotique et Grandeur des fonctions
Notation O
• La notation O définit une borne
asymptotique supérieure.
• Pour une fonction g(n) donnée, on note
O(g(n)) l’ensemble des fonctions tel que:
O(g(n))={f(n): il existe deux constantes
strictement positives c et n0 telles que
0f(n)c.g(n) pour tout nn0}
19
20
5
Notation 
Notation 
• La notation  définit une borne asymptotique
inférieure.
• Pour une fonction g(n) donnée on note (g(n))
l’ensemble des fonctions tel que
(g(n))={f(n): il existe deux constantes
strictement positives c et n0 telles que
0c.g(n)f(n) pour tout nn0}
• La notation  définit pour une fonction g(n)
donnée l’ensemble des fonctions:
(g(n))={f(n): il existe des constantes strictement
positives c1, c2 et n0 telles que
0 c1.g(n) f(n)c2.g(n) pour tout nn0}
21
22
Notations asymptotiques et
algorithmes
Propriétés des notations O,  et 
• Réflexivité
f= (f)
g=O(g)
g=(g)
• Symétrie
f= (g) ssi g= (f)
• Transitivité
f=O(g) et g=O(h) alors f=O(h)
f= (g) et g= (h) alors f= (h)
• Produit par un scalaire
>0, .O(g)=O(g)
• Somme et produit de fonctions
O(f)+O(g)=O(max(f,g))
O(f).O(g)=O(f.g)
• Notations asymptotiques dans les
équations:
2n2+3n+1=2n2+(n)= (n2)
• Règle de sommation: soit un programme
composé de deux parties de temps
d’exécution T1(n)=O(f1(n)) et T2(n)=O(f2(n))
T(n)=T1(n)+T2(n)=O(f1(n)+f2(n))
23
24
6
Notations asymptotiques et
algorithmes
Notations asymptotiques et algorithmes
• Ordres de grandeur (exemples) 1, log n, n, n.log
n, n2, n3, 2n
2
2
• If
Si O(fif(n)) et O(felse(n)) sont les bornes supérieures des
instructions du bloc if et else, alors:
O(max{fif(n), felse(n)}) est une borne supérieure du
temps d’exécution de l’instruction
• do{ }while, while{ }, for
Si O(f(n)) est la borne supérieure du corps de la boucle
et si O(g(n)) est la borne supérieure du nombre des
parcours de la boucle alors:
O(g(n).f(n)) est une borne supérieure du temps
d’exécution de l’instruction
n
n
n
T(n)
Log n
1
25
26
n
Notations asymptotiques et algorithmes
Optimalité:
• E (P) = ensemble des algorithmes qui
résolvent un problème P au moyen de
certaines opérations élémentaires.
• A E (P) est optimal en temps (par rapport
à E(P)) ssi
B  E (P),  donnée d, T(B,d) T(A,d)
• A  E (P) est asymptotiquement optimal
ssi T(A,n) = O(T(B,n))
• Ordres de grandeur
Évolution du temps
quand la taille est
10 fois plus grande
Évolution de la taille
quand le temps est
10 fois plus grand
1
log2n
t
t + 3,32

n
10 x t
10 x n
n log2n
(10 + ) x t
(10 - ) x t
n2
100 x t
3,16 x n
n3
1000 x t
2,15 x n
2n
t
10
Notations asymptotiques et algorithmes
n10
n + 3,32
27
28
7
Classes d’optimalité
Conclusion
• Classification des problèmes en fonction
des meilleurs algorithmes connus
Logarithmique (ln(n))
Linéaire (n)
Quasi-linéaire (n ln(n))
Polynomiale (nk), k entier >1
Exponentielle (an) avec a>1
•
La complexité de la description nuit à la mise à jour d ’un algorithme.
•
Les constantes de proportionnalité peuvent être importantes si les
données sont réduites.
•
Réduire le temps peut conduire à augmenter l’espace nécessaire
•
Pour les algorithmes numériques, la précision et la stabilité des
valeurs sont des critères importants.
•
La nature d’un problème fait que certaines opérations deviennent plus
fondamentales que d’autres. Leur nombre intervient alors
principalement dans l’étude de la complexité de l’algorithme
Recherche d’un élément (liste, tableau, arbre) comparaisons
Tri (listes, tableau, fichier) comparaisons, déplacement
Multiplication (polynômes, matrices) addition, multiplications
29
30
La récursivité
• La récursivité
• Principes et dangers de la récursivité
• Résolution des récurrences
Complexité des
algorithmes récursifs
31
32
8
La récursivité
La récursivité
F(x)
Début
• Une procédure P est récursive si son
exécution peut provoquer un ou plusieurs
appels (dits récursif à P)
– Récursivité simple: tous les appels récursifs à
P apparaissent dans le corps de la procédure
récursive P
– Récursivité croisée: c’est ce qui ce produit
quand une procédure P appelle une
procédure Q qui déclenche un appel récursif
àP
Si c(x) alors
a(x)
Si non
b(x)
Fin si
Fin
c: condition d’arrêt de la récursivité
a: expression contenant n’importe quel traitement sauf un appel à f
b: expression contenant n’importe quel traitement plus au moins un
appel obligatoire à f (récursivité simple) ou bien au moins un appel
à une procédure q qui déclenche un appel récursif à p
33
Exemples
Exemples
• Écrire un algorithme récursif qui calcule
P(x,n)=xn avec nN
n
x
34
puissance(x,n)
Début
Si n=0 alors
retourner 1
Si non
x*puissance(x,n-1)
Fin si
Fin
1 si n  0

n 1
si non
x x
1 si n  0
 n/2 n/2
n

x x x si n est pair

n/2
n/2
si n est impair
x x x
35
36
9
Exemples
Exemples
exposant(x,n)
Début
Si n=0 alors
retourner 1
Si non
yexposant(x,n/2)
Si n mod 2=0 alors
retourner y*y
Si non
retourner x*y*y
Fin si
Fin si
Fin
Pair(n)
Si n = 0 alors
retourner vrai
Si non
retourner impair(n-1)
Fin si
Impair(n)
Si n = 0 alors
retourner faux
Si non
Retourner pair(n-1)
Fin si
37
"Diviser pour régner"
38
Tours de Hanoï
• Le paradigme diviser pour régner:
– Diviser le problème en un certains nombre de
sous-problèmes
– Régner sur les sous-problèmes en les
résolvant récursivement, ou si la taille d’un
sous-problème est assez réduite, le résoudre
directement
– Combiner: les solutions des sous-problèmes
en une solution complète du problème
39
• C'est également un problème classique, et un
jeu pour enfants. On dispose de trois piquets et
d'un certain nombre de disques empilés sur l'un
des piquets. On désire déplacer la totalité des
disques sur un autre piquet en respectant les
règles suivantes
– On déplace un disque à la fois
– Les disques doivent être disposés du plus petit
diamètre au plus grand sur chaque piquet
40
10
Principe et dangers de la récursivité
• La fonction doit être complètement définie sur tout son domaine
d’application
• Il faut s’assurer que l’on retombera toujours sur un cas connu,
c’est-à-dire sur une condition d’arrêt
Algorithme sans-fin(n)
Début
Si n=1 alors
retourner 1
Si non
Début
Si n est impair alors
retourner n *sans _fin(n-1)
Si non
retourner n*sans_fin(n-2)
Fin si
Fin
Fin si
Fin
41
La récursivité
si n  c
(1)

T(n)  
n
aT( b )  D(n )  C(n)
Temps d’exécution
d’un problème
de taille n
Temps d’exécution
d’un problème de
taille n/b
Le problème initial est diviser en a
sous-problèmes, la taille de chacun
étant 1/b de la taille du problème initial
Principe et dangers de la
récursivité
• Importance de l’ordre des appels récursifs
Algorithme A(n)
Si n=0 alors
affiche 0
Si non
affiche n
A(n-1)
Fin si
Algorithme B(n)
Si n=0 alors
affiche 0
Si non
B(n-1)
affiche n
Fin si
42
Résolution des récurrences
• Trois méthodes de résolution des
récurrences:
si non
Temps pour
construire la
solution finale à
partir des
solutions initiales
Temps pour diviser le
problème en sousproblèmes
43
– Méthode par substitution
– Méthode itérative
– La méthode générale
44
11
Résolution des récurrences
Résolution des récurrences
• Méthode itérative:
transforme la récurrence
en une sommation de
termes dépendants
uniquement de n et des
conditions initiales et
s’appuie ensuite pour la
résoudre sur des
techniques permettant de
borner des sommations
Résoudre les récurrences
suivantes:
n
T(n )  3T( )  n
4
n
T(n )  2T( )  n
2
n
T(n )  2T( )  1
2
• Méthode par
substitution: on presse
une borne puis on
utilise une récurrence
mathématique pour
démontrer que notre
hypothèse est correcte.
S’applique si la forme
de la réponse est facile
à deviner.
Résoudre par substitution la
récurrence:
T (n)  2T ( n )  lg(n)
n
T ( n)  T ( )  1
2
45
46
Soient a  1 et b  1deux constantes, soit f(n) une fonction
et soit T(n) définie pour les entiers positifs par la récurrence :
Résolution des récurrences
si n  c
(1)

T ( n)  
n
si non
aT ( b )  f ( n)
Éviter les pièges
On veut démontrer par substitution que la
récurrence
n
n 
n
soit comme  , soit comme   ,
b
b
b 
T(n) peut alors être bornée asymptotiquement comme suit :
Où l’ on interprète
n
T(n )  2T( )  n  O(n )
2
(1) Si f(n)  O(n ( logb a )  ) pour une certaine constante   0,
alors T(n)  (nlogb )
a
( 2) si f (n)  (nlogb ), alors T (n)  (nlogb log n)
a
a
n
(3) si f (n)  (n (logb a )  ) pour une cons tan te   0, et si a. f ( )  c. f ( n)
b
pour une cons tan te c  1 et tous les n suffisamment grands,
47
alors T (n)  ( f ( n))
48
12
Résolution des récurrences
Résolution des récurrences
• Résoudre par la méthode générale la récurrence:
• Attention: la méthode générale ne s’applique pas
n
à la récurrence T (n)  2T ( )  n. log n bien qu’elle ait la
2
forme correcte a=2, b=2, f(n)=n.logn et on
pourrait croire que le cas 3 s’applique puisque
f(n)=n.logn est plus grande asymptotiquement
que nlogba  n
n
T(n )  9T( )  n
3
49
50
Tris et Rangs
1. Le problème de tri
2. Les algorithmes de tri: tri à bulle, tri sélection, tri
insertion, tri rapide, tri fusion, tri par tas, tri par
comptage, tri par paquets «Bucket sort », Introsort, par
dénombrement, tri par champs, etc
3. Recherche dichotomique, recherche par interpolation
(exercices)
4. Calcul de rang (exercices)
5. Classification des algorithmes de Tri
6. Les algorithmes de tri, recherche et rang dans des
applications réelles. (5 et 6 travail individuel à rendre)
Tris et Rangs
51
52
13
Tris et Rangs
• Classification des algorithmes de tri
Les files avec priorités
– Tri sur place
– Tri stable
– Tri interne/externe
– Tri itératif/récursif
(tas binomial, tas de fibonacci)
• Critères de choix d’un algorithme de tri
53
plan
•
•
•
•
•
54
Définitions
• Arbres de tournoi: arbre
binaire dont les sommets
sont munis d’une clé et
tel que pour tout sommet
autre que la racine, la clé
du sommet est inférieure
(resp. supérieure) ou
égale à celle de son père
Définitions
Propriétés
Algorithmes Entasser, Construire_tas
Tri par tas
File de priorité
• Tas: arbre de tournoi
parfait
55
1
3
4
6
9
9
8
7
56
14
Propriétés
Définitions
• Un tableau A sert à
stocker les données
• Une donnée possède
une clé
• Le tableau A a pour taille
maximale longueur[A]
• Le nombre de données
dans le tas est de taille[A]
(qui est longueur[A]
nombre d’éléments du
tas)
1
2
5
8
9
Tas min: A[i]≥A[père(i)]
3
2
4
4
Tas max: A[i]A[père(i)]
Racine(A)
retourner(1)
6
Pere(i)
retourner(i/2)
7
Gauche(i)
retourner(2i)
10
Les éléments entre les indices
taille[A/2] +1 et taille[A] sont
des feuilles
Droit(i)
retourner(2i+1)
57
Entasser(A,i)
MoveDown
58
Construire_Tas(A)
lGauche(i)
rDroit(i)
Si ltaille[A] et A[l]>A[i] alors
max l
Si non
max i
Si rtaille[A] et A[r]>A[max] alors
max r
Si max i alors
échange(A[i],A[max])
Entasser(A,max)
Taille[A]longueur[A]
Pour i   longueur[A]/2 à 1 faire
Entasser(A, i)
Complexité?
Exemple: entasser(A,2)
Complexité?
59
60
15
File_de_priorité
Extraire_Max_tas(A)
Trier_tas(A)
Construire_tas(A)
Pour i longueur[A] à 2 faire
echange(A[1],A[i])
taille[A] taille[A]-1
Entasser(A,1)
Si taille[A]<1 alors
Erreur("débordement négatif ")
max  A[1]
A[1] A[taille[A]]
taille[A] taille[A]-1
Entasser(A,1)
Retourner(max)
Complexité?
Complexité?
61
62
File de priorité
(MoveUp)
Inserer_tas(A, cle)
taille[A] taille[A]+1
i taille[A]
Tant que i>1 et A[Pere(i)]<cle faire
A[i] A[Père(i)]
i Père(i)
A[i]  cle
Les tables de Hachage
Complexité?
63
64
16
Plan
•
•
•
•
•
•
Objectif et idée
Objectif, idée et hypothèse de base
Tables à adressage direct
Tables à adressage ouvert
Gestion des collisions par chaînage
Gestion des collisions par sondage
Fonctions de hachage
• Gestion d’ensembles dynamiques de
données
• Calculer à partir de l’indice k l’indice i de la
case où se trouve potentiellement
l’information à stocker, consulter ou
détruire
• La correspondance entre l’ensemble des
clés et l’ensemble des informations est
univoque
– Méthodes de la division
– Méthode de la multiplication
65
66
Tables à adressage direct
Tables de hachage
• Si l’univers U des clés n’est pas trop
important, on utilise alors un tableau T de
même cardinal
• T est appelée table de hachage direct
• À une alvéole (case) de T correspond une clé
k de U
• Une alvéole pointe vers un élément de
l’ensemble ayant pour clé k
• Opérations d’accès (recherche, insertion,
suppression)
• Soit U l’univers des clés et k l’ensemble
des clés réellement utilisées et |U|>>|k|
• Utiliser une fonction de hachage h(k) qui
retourne un numéro d’alvéole de la table
de hachage T. on pose |T|=m et n le
nombre de clés
• Une collision survient si deux clés
différentes ont la même valeur de hachage
67
68
17
Gestion des collisions par
chaînage
Opérations de base
• Résolution des collisions par chaînage
• Opérations de base
• Soit n le nombre de clés à gérer, on définit
le facteur de remplissage par =n/m
• Gestion en zone de débordement et en
interne
• La performance moyenne est en (1+)
• Inserer_H_chaine(T,x)
– Insérer en tête de la liste T[h(cle[x])]
• Recherche_H_chaine(T,k)
– Rechercher un élément de clé k dans la liste
T[h(k)]
• Supprimer_H_chaîne(T,x)
– Supprimer x de la liste T[h(cle[x])]
69
Fonctions de hachage (1)
70
Méthode da la division
• Les clés doivent être interprétées comme
des entiers naturels
• Donc il faut mettre au point une fonction
de transformation si tel n’est pas le cas
• Ex: addition et décalage de bits ou
bijection
• H(k)=k modulo m
• Choix de m:
– Toute la clé doit participer au résultat
– Pas de puissance de 2 ( p bits poids faible)
– Idem puissance de 10 si l’application est
guidée par des nombres décimaux
– Nombre premier éloigné de puissance de 2
71
72
18
Autres techniques
Méthode da la multiplication
• Hachage universel (fonction h choisie
aléatoirement)
• Adressage ouvert:
• Multiplier la clé k par une constante A
avec 0<A<1
• Extraire la partie fractionnaire de kA
• Multiplier le résultat par m et garder la
partie entière
• Choix de m: puissance de 2
• Choix de A:
(Knuth)
– Sonde h: U{0,1, …, m-1} {0,1, …, m-1}
– La séquence de sondage est une permutation
sur [0,1, …, m-1]
– Ex: sondage linéaire: h(k,i)=(h’(k)+i) modulo
m
74
73
Graphes
•
•
•
•
Introduction
Définitions
Codage et opérateurs d’accès
Algorithmes de parcours en largeur et en
profondeur
• Quelques problèmes sur les graphes
Graphes et structures de
données pour les graphes
75
14/09/10
Mariem Gzara-ISIMMonastir
76
19
Graphes définitions
Graphes définitions
• Graphe non orienté: Un graphe non
• Graphe orienté: Un graphe orienté G=(S,A) est
orienté G=(S,A) est un couple où S est un
un couple où S est un ensemble de sommets
ensemble de sommets (noeuds) et A une
(nœuds) et A une partie de S×S dont les
a
1
éléments sont appelés arcs.
non orienté:
4
famille de paires de S dont les éléments
e
2
d
S={ 1,2,3,4,5}
f
5
A={{1,4}, {4,3}, {3,5}, {1,5}, {2,5}, {2,4}}
b
2
3
Mariem Gzara-ISIMMonastir
2
f
S={ 1,2,3,4,5}
4
e
d
c
Dans l’exemple: les nœuds ont des labels numériques, Les arcs ont
des labels alphanumériques
14/09/10
a
1
sont appelés arêtes.
b
2
5
3
c
77
Graphes- définitions
A={(1,4), (4,3), (3,5), (1,5), (5,2), (2,4)}
78
Graphes
a(3,5)
1
4
• Codage et opérateurs d’accès
e(6,7)
2
d(1,8)
f(4,2)
2
5
– Statique: matrice d’adjacence, matrice
d’incidence, liste des successeurs
– Dynamique: codage nœuds et arcs,
b(4,2)
3
c(2,3)
Graphe valué:
un triplet G=(S,A,v) où
(S,A) est un graphe et
v une application de A dans R (ensemble des réels)
14/09/10
Mariem Gzara-ISIMMonastir
79
successeur(i), prédécesseur(i)
Label, nom, identificateurs de nœuds et d’arcs
Valeurs sur les nœuds et arcs
80
20
Graphes (codage statique)
Matrice d’adjacence
•M(G) est une matrice carrée
indicée par S
•M[i,j]= 1 si (i,j)A
0 si non
j
1
2
3
4
5
1
0
0
0
1
1
2
0
0
0
1
0
3
0
0
0
0
1
4
0
0
1
0
0
5
0
1
0
0
0
i
•successeur(i),
prédécesseur(i)
•Label, nom, identificateurs
de nœuds et d’arcs
•Valeurs sur les nœuds et arcs
14/09/10
Mariem Gzara-ISIMMonastir
81
Parcours en profondeur
ParcoursProfondeur (G(X,E))
/*1*/Pour chaque sommet u de G
faire
/*2*/ Couleur[u] BLANC
/*3*/ pere[u]  NIL
Fin pour
/*4*/date  0
/*5*/Pour chaque sommet u de G
faire
/*6*/ Si couleur[u] =Blanc alors
/*7*/
visiterProfondeur(u)
Fin Si
Fin Pour
21/11/2019
21/11/2019
ParcoursLargeur(G(X,E),s)
/*1*/ Pour chaque sommet u de G faire
/*2*/
Couleur[u] BLANC
/*3*/
d[u]  
/*4*/
pere[u]  NIL
Fin pour
/*5*/ Couleur[s]  Gris
/*6*/ d[s] 0
/*7*/ pere[s] NIL
/*8*/ F créer_file()
/*9*/ Enfiler(F,s)
/*10*/
Tant que non file_vide(F) faire
/*11*/
u defiler(F)
/*12*/
Pour chaque nœud v successeur du nœud u
faire
/*13*/
Si couleur [v] =Blanc alors
/*14*/
couleur [v] Gris
/*15*/
d[v]  d[u]+1
/*16*/
pere[v]  u
/*17*/
Enfiler(F,v)
Fin si
Fin pour
/*18*/
Couleur[u] Noir
M. Gzara - Théorie des graphes
82
Fin Tant que
Les algorithmes gloutons
visiterProfondeur(u)
/*1*/ couleur [u] Gris
/*2*/ date date+1
/*3*/ D[u]  date
/*4*/ Pour chaque nœud v successeur du
nœud u faire
/*5*/
Si couleur [v] =Blanc alors
/*6*/
pere[v]  u
/*7*/
visiterProfondeur(v)
Fin si
Fin Pour
/*8*/ Couleur[u] Noir
/*9*/ F[u] date date+1
83
• Principe général
– Technique pour résoudre des problèmes
d’optimisation
– Solution optimale obtenue en effectuant une suite de
choix : à chaque étape on fait le meilleur choix local
– Pas de retour en arrière : à chaque étape de décision
dans l’algorithme, le choix qui semble le meilleur à ce
moment est effectué.
– Progression descendante : choix puis résolution d’un
problème plus petit
84
21
Algorithmes gloutons
pour le sac à dos
Les algorithmes gloutons
• Stratégie gloutonne : Un algorithme glouton
produit des solutions optimales si les deux
propriétés suivantes sont vérifiées :
• Enoncé du problème de sac à dos
• L’algorithme du problème de sac à dos
– calculer le rapport (vi / pi) pour chaque objet i
– trier tous les objets par ordre décroissant de
cette valeur
– sélectionner les objets un à un dans l’ordre du
tri et ajouter l’objet sélectionné dans le sac si
le poids maximal reste respecté.
– Propriété du choix glouton : Il existe toujours une
solution optimale commençant par un choix glouton.
– Propriété de sous-structure optimale : trouver une
solution optimale contenant le premier choix glouton
se réduit à trouver une solution optimale pour un
sous-problème de même nature.
Exemple : p=30; pi={13,12,8,10}, wi={7,4,3,3}
85
Algorithme glouton pour le problème
d’arbre couvrant: Algorithme de Kruskal
• Soit G = (X,E) un graphe. Le graphe G’ = (X,E’) est un
graphe partiel de G, si E’ est inclus dans E . Autrement dit,
on obtient G’ en enlevant une ou plusieurs arêtes au graphe
G.
• Un arbre couvrant ‘spanning tree’ d’un graphe est un graphe
partiel de G qui est un arbre
• Proposition : un graphe connexe G a (au moins) un arbre
couvrant.
• Un arbre couvrant de coût minimum ‘minimum spanning
tree’ est une arbre couvrant dont la somme des poids des
arêtes est minimum.
87
86
Algorithme de Kruskal
Procédure Kruskal (G: graphe)
T←ø
F←E
Tant que|T| < n-1 faire
trouver une arête e ∈ F de poids minimal
F ← F-e
Si T+e est acyclique alors T ← T ∪ e Fin Si
Fin Tant que
Fin Procédure
88
22
La programmation dynamique
Algorithme de Kruskal
• Paradigmes algorithmiques:
– Algorithme glouton : construit une solution de manière incrémentale, en
optimisant un critère de manière locale.
– Diviser pour régner : divise un problème en sous-problèmes
indépendants (qui ne se chevauchent pas), résout chaque sousproblème, et combine les solutions des sous problèmes pour former
une solution du problème initial.
– Programmation dynamique : divise un problème en sous problèmes qui
sont non indépendants (qui se chevauchent), et cherche (et stocke) des
solutions de sous-problèmes de plus en plus grands
• Programmation dynamique : paradigme développé par Richard
Bellman en 1953 chez RAND Corporation.
Les différentes étapes de construction de T
90
89
Illustration: Suite de Fibonaci
Illustration: Suite de Fibonaci
• Complexité?
Complexité?
91
Mémoriser = conserver
à la fin de l’exécution
d’une fonction le
résultat associé aux
arguments d’appels,
pour ne pas avoir à
recalculer ce résultat
lors d’un autre appel
récursif.
92
23
Concevoir une procédure de
programmation dynamique
Programmation dynamique
• Idée :
• Quatre étapes :
– mémoriser et réutiliser les solutions des sousproblèmes qui aident à résoudre le problème.
– Complexité temporelle :
nombre de sous-problèmes x complexité par sous-problème
on ne compte pas les appels récursifs.
– Définir les sous-problèmes.
– Identifier une relation de récurrence entre les
solutions des sous-problèmes.
– En déduire un algorithme récursif avec
mémorisation ou une approche du bas vers le
haut
– Résoudre le problème original à partir des
solutions des sous-problèmes
93
94
Python on mode console : saisir les commandes
Atelier algorithmique
avancées avec Python
Opérateurs arithmétiques et logiques
a + b, a - b, a * b
a/b
a // b
a% b
abs(x)
x**n
95
96
24
Type de données et commentaires
Booléens et opérateurs logiques
Type de données
Booléens: Python les valeurs sont True et False
Les comparaisons :
Test d’égalité : a == b
— Test inférieur strict : a < b
— Test inférieur large : a <= b
— Test supérieur : a > b ou a >= b
— Test non égalité : a != b
Opérations entre les booléens.
— Et logique. «P and Q»
— Ou logique. «P or Q»
— Négation. «not P»
int Entier. Exemples : 123 ou -15.
float Nombre flottant (ou à virgule).
str Caractère ou chaîne de caractères.
bool Booléen. True ou False.
list Liste. Exemple : [1,2,3,4].
Commentaires et docstring
# Boucle principale
Docstring
""" Calcule le produit de deux nombres Entrée : deux nombres x et y Sortie : le
produit de x par y """
97
98
Entrée clavier
! Attention! Python distingue les majuscules des
minuscules
99
100
25
Une liste est une suite d’éléments hétérogènes
Génération de séquences avec range
101
102
Les fonctions de Python sont regroupées dans des modules
Module math contient les fonctions mathématiques
Encore des listes
103
sqrt(x) racine carrée
cos(x), sin(x), tan(x) fonctions trigonométriques cosx, sinx, tanx en radians
pi valeur approchée de π =3.14159265...
floor(x) entier juste en-dessous de x
ceil(x) entier juste au-dessus de x
gcd(a,b) pgcd de a et de b
104
26
Voici comment utiliser for avec python
• Générer des valeurs aléatoires
Matplotlib: permet de tracer des graphiques et visualiser des données.
Tkinter: permet d’afficher des fenêtres graphiques.
Time: pour l’heure, la date et chronométrer.
Timeit: pour mesurer le temps d’exécution d’une fonction.
Attention !!!!!!!!!!
ce qui délimite le bloc d’instructions à répéter, c’est l’indentation
Toutes les lignes d’un bloc doivent avoir exactement la même
indentation.
!! N’oublie pas les deux points en fin de la ligne de la déclaration du for!
105
106
Voici comment utiliser while avec python
107
108
27
Voici comment utiliser if
avec python
109
Ma première fonction avec python
110
Fonctions avec python
111
112
28
Programmation orienté objet avec python
Portée des variables
113
114
Programmer efficacement vos algorithmes
avec python
• Implémenter le tri rapide
• Implémenter la classe tas avec python:
– Un tas est un tableau T caractérisé par
taille[T] qui est le nombre de clés dans le tas,
– père(i), gauche(i), droit(i), entasser, construire
tas, trie_tas, extraire_tas, insérer_tas,
augmenter_tas
• Mini-projet en python
115
116
29
Références
• Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford
Stein, « Introduction à l’algorithmique », édition DUNOD
• Bruno Baynat, Philippe Chrétienne, Claire Hanen, Safia KedadSidhoum, Alix Munier-Kordon, Christophe Picouleau, « Exercices et
problèmes d’algorithmique », édition DUNOD
• Joan M. Aldous et Robin J. Wilson, Graphs and Applications: an
introductory approach, édition Springer, 2004.
• Michel Gondron et Michel Minous, Graphes et algorithmes, édition
Eyrolles, 1985.
117
30