Algorithmique des graphes 0 — Rappels Anthony Labarre 27 janvier 2021

(1)

Algorithmique des graphes

0 — Rappels

Anthony Labarre

27 janvier 2021

(2)

Complexit´e algorithmique Programmation orient´ee objet en Python Pseudocode Techniques de preuves

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 ;

• Johan Thapper ;

(3)

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 . . . ) ;

(4)

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 . . . ) ;

(5)

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 . . . ) ;

(6)

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 . . . ) ;

(7)

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 . . . ) ;

(8)

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 . . . ) ;

(9)

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 . . . ) ;

(10)

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 !

(11)

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 !

(12)

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 !

(13)

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 !

(14)

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 !

(15)

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 !

(16)

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 !

(17)

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 !

(18)

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

(19)

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(·).

(20)

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(·).

(21)

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(·).

(22)

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(·).

(23)

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(·).

(24)

La notation O(·)

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

∃ n

0

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

0

: |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)

(25)

La notation O(·)

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

∃ n

0

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

0

: |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)

(26)

La notation O(·)

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

∃ n

0

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

0

: |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)

(27)

La notation O(·)

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

∃ n

0

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

0

: |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⁶

n0 f(n) g(n)

0 10 20 30 40 50

n0 f(n) g(n)

0 5 10 15 20 25 30

0 10 20 30

n0

n f(n) g(n)

(28)

La notation O(·)

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

∃ n

0

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

0

: |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)

(29)

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 ;

(30)

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 ;

(31)

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 ;

(32)

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.

(33)

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.

(34)

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.

(35)

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.

(36)

Simplifications

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

1

on oublie les constantes multiplicatives (elles valent 1) ;

2

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant g (n) = 4n

³−

5n

²

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

1n³−1n²

+

1n

+ 3

2

on annule les constantes additives : n

³−

n

²

+ n

+ 0

3

on garde le terme de plus haut degr´ e : n

³ + 0

et on a donc g (n) = O(n

³

).

(37)

Simplifications

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

1

on oublie les constantes multiplicatives (elles valent 1) ;

2

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant g (n) = 4n

³−

5n

²

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

1n³−1n²

+

1n

+ 3

2

on annule les constantes additives : n

³−

n

²

+ n

+ 0

3

on garde le terme de plus haut degr´ e : n

³ + 0

et on a donc g (n) = O(n

³

).

(38)

Simplifications

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

1

on oublie les constantes multiplicatives (elles valent 1) ;

2

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant g (n) = 4n

³−

5n

²

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

1n³−1n²

+

1n

+ 3

2

on annule les constantes additives : n

³−

n

²

+ n

+ 0

3

on garde le terme de plus haut degr´ e : n

³ + 0

et on a donc g (n) = O(n

³

).

(39)

Simplifications

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

1

on oublie les constantes multiplicatives (elles valent 1) ;

2

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant g (n) = 4n

³−

5n

²

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

1n³−1n²

+

1n

+ 3

2

on annule les constantes additives : n

³−

n

²

+ n

+ 0

3

on garde le terme de plus haut degr´ e : n

³ + 0

et on a donc g (n) = O(n

³

).

(40)

Simplifications

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

1

on oublie les constantes multiplicatives (elles valent 1) ;

2

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant g (n) = 4n

³−

5n

²

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

1n³−1n²

+

1n

+ 3

2

on annule les constantes additives : n

³−

n

²

+ n

+ 0

3

on garde le terme de plus haut degr´ e : n

³ + 0

et on a donc g (n) = O(n

³

).

(41)

Simplifications

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

1

on oublie les constantes multiplicatives (elles valent 1) ;

2

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant g (n) = 4n

³−

5n

²

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

1n³−1n²

+

1n

+ 3

2

on annule les constantes additives : n

³−

n

²

+ n

+ 0

3

on garde le terme de plus haut degr´ e : n

³ + 0

et on a donc g (n) = O(n

³

).

(42)

Simplifications

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

1

on oublie les constantes multiplicatives (elles valent 1) ;

2

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant g (n) = 4n

³−

5n

²

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

1n³−1n²

+

1n

+ 3

2

on annule les constantes additives : n

³−

n

²

+ n

+ 0 3

on garde le terme de plus haut degr´ e : n

³+ 0

et on a donc g (n) = O(n

³

).

(43)

Simplifications

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

1

on oublie les constantes multiplicatives (elles valent 1) ;

2

on annule les constantes additives ;

3

on ne retient que les termes dominants.

Exemple 2 (simplifications)

Soit un algorithme effectuant g (n) = 4n

³−

5n

²

+ 2n + 3 op´ erations ;

1

on remplace les constantes multiplicatives par 1 :

1n³−1n²

+

1n

+ 3

2

on annule les constantes additives : n

³−

n

²

+ n

+ 0 3

on garde le terme de plus haut degr´ e : n

³+ 0

et on a donc g(n) = O(n

³

).

(44)

Op´ erations en s´ equence

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

1

(·)) + O(f

2

(·)) = O(f

1

(·) + f

2

(·))

Pareil pour les branchements conditionnels :

si

[condition]

alors :

O(g(·))











= O(g (·) + f

1

(·) + f

2

(·))

## instructions (1)

O(f

1

(·))

sinon

## instructions (2)

O(f

2

(·))

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).

(45)

Op´ erations en s´ equence

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

1

(·)) + O(f

2

(·)) = O(f

1

(·) + f

2

(·))

Pareil pour les branchements conditionnels :

si

[condition]

alors :

O(g(·))











= O(g (·) + f

1

(·) + f

2

(·))

## instructions (1)

O(f

1

(·))

sinon

## instructions (2)

O(f

2

(·))

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).

(46)

Op´ erations en s´ equence

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

1

(·)) + O(f

2

(·)) = O(f

1

(·) + f

2

(·))

Pareil pour les branchements conditionnels :

si

[condition]

alors :

O(g(·))











= O(g (·) + f

1

(·) + f

2

(·))

## instructions (1)

O(f

1

(·))

sinon

## instructions (2)

O(f

2

(·))

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).

(47)

Boucles

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

## si on a m it´erations

tant que

[condition]

faire

O(g(·))

= O(m

∗

(g(·) + f (·)))

## 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) ;

(48)

Boucles

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

tant que

[condition]

faire

O(g(·))

= O(m

∗

(g(·) + f (·)))

## 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) ;

(49)

Boucles

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

tant que

[condition]

faire

O(g(·))

= O(m

∗

(g(·) + f (·)))

## 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) ;

(50)

Boucles

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

tant que

[condition]

faire

O(g(·))

= O(m

∗

(g(·) + f (·)))

## 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) ;

(51)

Boucles

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

tant que

[condition]

faire

O(g(·))

= O(m

∗

(g(·) + f (·)))

## 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) ;

(52)

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.

(53)

Classe basique en Python

Exemple 3

class

Promo(object):

def

__init__(self): # constructeur

self.etudiants

=

dict()

def

ajouter_etudiant(self, nom):

if nom

not in

self.etudiants:

self.etudiants[nom]

=

dict()

def

moyenne(self, nom):

return sum(self.etudiants[nom])

/

len(self.etudiants[nom])

•

self

≡

this en Java ou C++ ;

• __init__

= constructeur ;

(54)

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.

(55)

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.

(56)

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.

(57)

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.

(58)

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.

(59)

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.

(60)

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.

(61)

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.

(62)

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.

(63)

Particularit´ es des objets en Python

•

Pas de surcharge, y compris pour

__init__

; alternatives :

1

param` etres avec valeurs par d´ efaut ;

2

arguments variables (def

methode(self, *args, **kwargs)) ;

•

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

Exemple 4 (champs “priv´ es”)

>>>

class

MaClasse(object):

...

def

__init__(self):

...

self.public

= 1

...

self.__prive

= 0

...

>>>

x

=

MaClasse()

>>>

print(x.public)

1

>>>

print(x.__prive)

Traceback (most recent call last):

File "<stdin>", line

1, in <module>

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

•

Pas de getters ou setters ;

(64)

Particularit´ es des objets en Python

•

Pas de surcharge, y compris pour

__init__

; alternatives :

1

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

MaClasse(object):

...

def

__init__(self):

...

self.public

= 1

...

self.__prive

= 0

...

>>>

x

=

MaClasse()

>>>

print(x.public)

1

>>>

print(x.__prive)

File "<stdin>", line

1, in <module>

•

Pas de getters ou setters ;

(65)

Particularit´ es des objets en Python

•

Pas de surcharge, y compris pour

__init__

; alternatives :

1

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

MaClasse(object):

...

def

__init__(self):

...

self.public

= 1

...

self.__prive

= 0

...

>>>

x

=

MaClasse()

>>>

print(x.public)

1

>>>

print(x.__prive)

File "<stdin>", line

1, in <module>

•

Pas de getters ou setters ;

(66)

Particularit´ es des objets en Python

•

Pas de surcharge, y compris pour

__init__

; alternatives :

1

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

MaClasse(object):

...

def

__init__(self):

...

self.public

= 1

...

self.__prive

= 0

...

>>>

x

=

MaClasse()

>>>

print(x.public)

1

>>>

print(x.__prive)

File "<stdin>", line

1, in <module>

•

Pas de getters ou setters ;

(67)

Particularit´ es des objets en Python

•

Pas de surcharge, y compris pour

__init__

; alternatives :

1

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

MaClasse(object):

...

def

__init__(self):

...

self.public

= 1

...

self.__prive

= 0

...

>>>

x

=

MaClasse()

>>>

print(x.public)

1

>>>

print(x.__prive)

File "<stdin>", line

1, in <module>

•

Pas de getters ou setters ;

(68)

Particularit´ es des objets en Python

•

Pas de surcharge, y compris pour

__init__

; alternatives :

1

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

MaClasse(object):

...

def

__init__(self):

...

self.public

= 1

...

self.__prive

= 0

...

>>>

x

=

MaClasse()

>>>

print(x.public)

1

>>>

print(x.__prive)

File "<stdin>", line

1, in <module>

•

Pas de getters ou setters ;

(69)

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 ;

(70)

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

(71)

Pseudocode

Les algorithmes seront exprim´ es en pseudocode. Par exemple :

Algorithme 1 :TrouverMinimum

(T )

Entr´ees :

un tableau T non vide.

Sortie :

le plus petit ´ el´ ement de T .

1

minimum

←

T [0];

2 pour

i allant de 1 ` a longueur(T )

−

1

faire

3 si

T [i ]

<

minimum

alors

minimum

←

T [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.

(72)

Pseudocode

Les algorithmes seront exprim´ es en pseudocode. Par exemple :

(T )

Entr´ees :

un tableau T non vide.

Sortie :

le plus petit ´ el´ ement de T .

1

minimum

←

T [0];

2 pour

i allant de 1 ` a longueur(T )

−

1

faire

3 si

T [i ]

<

minimum

alors

minimum

←

T [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.

(73)

Pseudocode

Les algorithmes seront exprim´ es en pseudocode. Par exemple :

(T )

Entr´ees :

un tableau T non vide.

Sortie :

le plus petit ´ el´ ement de T .

1

minimum

←

T [0];

2 pour

i allant de 1 ` a longueur(T )

−

1

faire

3 si

T [i ]

<

minimum

alors

minimum

←

T [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, . . . ),

•