Algorithmique des graphes 0 — Rappels Anthony Labarre 27 janvier 2021

0 — Rappels

Anthony Labarre

27 janvier 2021

Organisation du cours

D´ eroulement :

• 12 s´ eances de CM ;

• 12 s´ eances de TD ;

• Quelques mini-rendus et un projet en Python ;

• . . . et bien sˆ ur un examen ;

Supports de cours :

• Ces transparents ;

• Des notes manuscrites couvrant presque toute la mati` ere ;

Les charg´ es de TD :

• Marie-Pierre B´ eal ;

•

Mises en garde

• Le cours aurait dˆ u se d´ erouler au tableau sans transparents ;

• Il sera forc´ ement moins interactif qu’esp´ er´ e ;

• Attention aux pi` eges des transparents :

1

la mati` ere avance beaucoup plus vite que ce qui serait id´ eal ;

2

on croit beaucoup plus facilement avoir compris ;

• Etudiez les notes de cours associ´ ´ ees, et voyez plutˆ ot ces transparents comme une aide que comme le support officiel ;

• N’h´ esitez pas ` a poser des questions, que ce soit en direct, en

diff´ er´ e, ou bien plus tard apr` es r´ eflexion (mais pas la veille de

l’examen . . . ) ;

Concernant les ´ evaluations

• Une grande partie de l’´ evaluation de vos programmes se fera ` a l’aide d’un correcteur automatique ;

• Il est donc critique de suivre les consignes donn´ ees ` a la lettre :

• respecter le nom des fonctions ;

• respecter la signature des fonctions ;

• ne pas confondre fonction et m´ ethode ;

• respecter le format d’entr´ ee et de sortie ;

• . . .

• Des jeux de tests vous seront parfois fournis pour vous guider,

mais cela ne vous dispense pas d’´ ecrire les vˆ otres !

Avant de rentrer dans le vif du sujet

Commen¸cons par quelques rappels rapides concernant les pr´ erequis :

1 Complexit´ e algorithmique

2 Programmation orient´ ee objet en Python

3 Pseudocode

4 Techniques de preuves

Motivations

• Un algorithme doit ˆ etre correct et efficace, c’est-` a-dire :

• rapide, et

• ´ econome en ressources (espace de stockage, m´ emoire, . . . ).

• Mesurer le temps de calcul r´ eel n´ ecessite d’impl´ ementer (et tester, et d´ ebugger, et optimiser, . . . ) les algorithmes ;

• Pour ´ eviter cela, on ´ evalue le temps d’ex´ ecution th´ eorique ` a l’aide de la complexit´ e algorithmique, qui donnera une

approximation du temps de calcul en fonction de la taille des

donn´ ees, repr´ esent´ ee par la notation O(·).

La notation O(·)

Une fonction f (n) est en O(g (n)) (“en grand O de g (n)”) si :

∃ n

∈ N, ∃ c ∈ R, ∀ n ≥ n

: |f (n)| ≤ c |g (n)|.

Autrement dit : f (n) est en O(g (n)) s’il existe un seuil ` a partir duquel la fonction f (·) est toujours domin´ ee par la fonction g (·), ` a une constante multiplicative fix´ ee pr` es.

Exemple 1 (quelques cas o` u f (n) = O(g (n)))

0 0.2 0.4 0.6 0.8 1

·10⁶ 0

0.2 0.4 0.6 0.8 1

·10⁶

n0

n f(n) g(n)

0 2 4 6 8 10

0 10 20 30 40 50

n0

n f(n) g(n)

0 5 10 15 20 25 30

0 10 20 30

n0

n f(n) g(n)

Complexit´ e d’un algorithme

D´ efinition 1

La complexit´ e d’un algorithme est la mesure asymptotique de son temps d’ex´ ecution dans le pire cas. Elle s’exprime ` a l’aide de la notation O(·) en fonction de la taille des donn´ ees re¸ cues en entr´ ee.

Les deux pr´ ecisions sur le caract` ere de cette mesure importent :

1

asymptotique : on s’int´ eresse ` a des donn´ ees tr` es grandes ;

2

“dans le pire cas” : on s’int´ eresse ` a la performance de

l’algorithme dans les situations o` u le probl` eme prend le plus

de temps ` a r´ esoudre ;

Calcul de la complexit´ e d’un algorithme

On fait les hypoth` eses suivantes :

• chaque instruction basique (affectation d’une variable de type basique ou comparaison de deux types basiques, +, −, ∗, /, ...) consomme un temps constant, not´ e O (1) ;

• chaque it´ eration d’une boucle rajoute la complexit´ e de ce qui est effectu´ e dans le corps de cette boucle ;

• chaque appel de fonction rajoute la complexit´ e de cette fonction ;

• pour obtenir la complexit´ e de l’algorithme, on additionne le

tout.

Simplifications

On aura aussi recours aux simplifications suivantes (justifi´ ees par la d´ efinition de

(·)) :

1

on oublie les constantes multiplicatives (elles valent 1) ;

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant

(n) = 4n

5n

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

+

+ 3

on annule les constantes additives :

+

on garde le terme de plus haut degr´ e :

et on a donc

).

Op´ erations en s´ equence

On additionne les complexit´ es d’op´ erations en s´ equence : O (f

(·)) + O(f

(·)) = O(f

(·) + f

(·))

Pareil pour les branchements conditionnels :

si

[condition]









=

(·) +

(·) +

(·))

## instructions (1) O(f1

(·))

## instructions (2) O(f2

(·))

Les r` egles de simplification vues plus haut s’appliqueront ensuite.

En particulier, une somme constante d’op´ erations constantes sera

constante : O(1) + O(1) = O(1).

Boucles

La complexit´ e d’une boucle se calcule comme suit :

## si on a m it´erations

tant que

[condition]

=

(g(·) +

(·)))

## instructions O(f

(·))

• Si deux boucles sont en s´ equence, on additionne leurs complexit´ es ;

• Si deux boucles sont imbriqu´ ees :

• si elles sont ind´ ependantes, on multiplie leurs complexit´ es ;

• sinon, on devra proc´ eder autrement (voir exemples concrets

plus tard) ;

Complexit´ es fr´ equentes et comparaisons

On regroupe les fonctions ´ equivalentes (f = O(g ) et g = O(f )) dans une mˆ eme classe.

0 1 2 3 4 5 6 7 8 9 10

0 20 40 60 80 100

taille des donn´ees

tempsd’ex´ecution

O(1) O(logn) O(√

n) O(n) O(nlogn) O(n²) O(2ⁿ) O(n!)

En g´ en´ eral, on pr´ ef` ere les algorithmes de complexit´ e minimale.

Classe basique en Python

Exemple 3

class

def

self.etudiants

dict()

def

if nom

self.etudiants:

self.etudiants[nom]

dict()

def

return sum(self.etudiants[nom])

len(self.etudiants[nom])

•

self

this en Java ou C++ ;

• __init__

= constructeur ;

M´ ethodes et donn´ ees membres

• On d´ efinit les m´ ethodes comme les fonctions avec def, mais :

1

on doit les indenter pour les mettre dans la classe ;

2

le premier param` etre doit toujours ˆ etre self ;

• Appeler une m´ ethode :

• dans la classe : self.methode(param)

• en dehors : mon_instance.methode(param)

• Pour les donn´ ees :

• self.data : donn´ ees membres, accessibles dans toute la classe ;

• data sans self : variable locale, accessible seulement dans la

m´ ethode qui la contient.

Particularit´ es des objets en Python

•

Pas de surcharge, y compris pour

; alternatives :

param` etres avec valeurs par d´ efaut ;

2

arguments variables (def

•

On simule les champs priv´ es ` a l’aide du pr´ efixe __ :

Exemple 4 (champs “priv´ es”)

>>>

class

...

def

...

self.public

self.__prive

>>>

x

MaClasse()

>>>

print(x.public)

1

>>>

print(x.__prive)

Traceback (most recent call last):

File "<stdin>", line

AttributeError: 'MaClasse' object has no attribute '__prive'

Int´ erˆ et de la POO dans ce cours

• Nos buts :

• pouvoir supposer qu’il existe une classe Graphe avec une certaine interface ;

• d´ ecrire des algorithmes s’ex´ ecutant de la mˆ eme mani` ere quelle que soit l’impl´ ementation ;

• On verra plus loin qu’il existe plusieurs mani` eres d’impl´ ementer les graphes ;

• Elles auront un impact direct sur la complexit´ e de nos

algorithmes ;

Programmation g´ en´ erique

• Nos fonctions devront parfois renvoyer un sous-graphe du mˆ eme type que celui d’entr´ ee ;

• On y arrivera avec la syntaxe suivante :

Exemple 5

def mon_algo(un_graphe):

resultat = type(un_graphe)()

# ...

return resultat

Pseudocode

Les algorithmes seront exprim´ es en

Algorithme 1 :TrouverMinimum

(T )

un tableau

non vide.

Sortie :

le plus petit ´ el´ ement de

.

1

minimum

[0];

2 pouri allant de

1

)

1

3 siT

[i ]

minimum

[i];

4 renvoyer

minimum;

Instructions pour le pseudocode :

•

´ eviter au maximum les d´ etails d’impl´ ementation li´ es au langage (allocation m´ emoire, pointeurs, . . . ),

•

ˆ etre suffisamment pr´ ecis pour que la traduction de l’algorithme vers

n’importe quel vrai langage soit facile et sans ambigu¨ıt´ e.

Conventions

Le format que nous adopterons sera le suivant :

1

algo standard(donn´ ees) : algorithme “trivial” pas n´ ecessairement vu explicitement ;

2

AlgoDuCours (donn´ ees) : algorithme vu dans ce cours ;

3

description des probl` emes :

• Entr´ ee(s) : ce que l’on re¸ coit, avec les hypoth` eses n´ ecessaires ;

• Sortie / But / Question / R´ esultat : le r´ esultat, avec les

hypoth` eses n´ ecessaires ;

Techniques de preuves

On devra prouver que nos algorithmes sont corrects, ainsi que certaines propri´ et´ es. G´ en´ eralement, on proc` edera :

1

par induction :

1

prouver qu’une propri´ et´ e P est vraie pour un cas de base ;

2

puis prouver que si P est vraie pour le cas n, elle l’est aussi pour le cas n + 1 ;

2

par contraposition : si prouver que A ⇒ B est difficile, on tente plutˆ ot de prouver que ¬B ⇒ ¬A, ce qui est ´ equivalent (cf. cours de logique).

3

par l’absurde (ou contradiction) : s’il est difficile de prouver

que P est vraie, prouvons plutˆ ot qu’il est impossible que P

soit fausse ;