La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Cours d’Algorithmique

Présentations similaires


Présentation au sujet: "Cours d’Algorithmique"— Transcription de la présentation:

1 Cours d’Algorithmique
Dérécursion (fin) : Équivalences entre programmes récursifs et programmes itératifs avec ou sans gestion de pile. Algorithmes gloutons. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

2 Présentation générale
Les grandes lignes du cours Trier et chercher, recherche textuelle Listes et arbres Le back-track Arbres équilibrés Récursivité et induction sur la structure Divide and conquer, algorithmes gloutons Minimax, alpha-beta Dérécursion Divers problèmes particuliers Logique de Hoare Programmation dynamique Complexité et calculabilité 4 décembre 2006 Cours d'algorithmique 8 - Intranet Cours d'algorithmique

3 Cours d'algorithmique 8 - Intranet
Deux appels récursifs D i S c U s S i O n D e S d I v E r S C a S d E f I g U r E : D e U x A p P e L s R é C u R s I f S 4 décembre 2006 Cours d'algorithmique 8 - Intranet

4 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Appréciations ! Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non 4 décembre 2006 Cours d'algorithmique 8 - Intranet

5 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Appréciations ! Un Deux Fonction auto-enveloppée Transformation intéressante ! Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non 4 décembre 2006 Cours d'algorithmique 8 - Intranet

6 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Appréciations ! Un Deux Fonction auto-enveloppée Transformation intéressante ! Celle-là aussi ! Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non 4 décembre 2006 Cours d'algorithmique 8 - Intranet

7 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Appréciations ! Un Deux Fonction auto-enveloppée Transformation intéressante ! Celle-là aussi ! Sans espoir ! ! ! Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non 4 décembre 2006 Cours d'algorithmique 8 - Intranet

8 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non 4 décembre 2006 Cours d'algorithmique 8 - Intranet

9 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le cas de base est celui des appels auto-enveloppés ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

10 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le cas de base est celui des appels auto-enveloppés ! f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

11 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à l’aide d’un accumulateur acc. f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

12 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à l’aide d’un accumulateur acc. Le cas d’arrêt. f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

13 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à l’aide d’un accumulateur acc. Le cas d’arrêt. f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) L’appel récursif interne ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

14 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à l’aide d’un accumulateur acc. Le cas d’arrêt. f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) L’appel récursif interne ! L’appel récursif externe ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

15 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à l’aide d’un accumulateur acc. Le cas d’arrêt. f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) XXXXX L’appel récursif interne ! XX XXXXX XXXXX XXXXX L’appel récursif externe ! Souvent, le schéma est un peu plus simple. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

16 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le flot des informations ! f ( acc , x ) = si ( P( x ) ) a( acc , x ) sinon f( f( acc , a( x ) ) , b( x ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

17 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le flot des informations ! f ( acc , x ) = si ( P( x ) ) a( acc , x ) sinon f( f( acc , a( x ) ) , b( x ) ) acc x a( x ) b( x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

18 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le flot des informations ! f ( acc , x ) = si ( P( x ) ) a( acc , x ) sinon f( f( acc , a( x ) ) , b( x ) ) acc x a( x ) b( x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

19 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le flot des informations ! f ( acc , x ) = si ( P( x ) ) a( acc , x ) sinon f( f( acc , a( x ) ) , b( x ) ) acc x a( x ) b( x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

20 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le flot des informations ! f ( acc , x ) = si ( P( x ) ) a( acc , x ) sinon f( f( acc , a( x ) ) , b( x ) ) acc x a( x ) b( x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

21 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le flot des informations ! f ( acc , x ) = si ( P( x ) ) a( acc , x ) sinon f( f( acc , a( x ) ) , b( x ) ) acc x a( x ) b( x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

22 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Le flot des informations ! f ( acc , x ) = si ( P( x ) ) a( acc , x ) sinon f( f( acc , a( x ) ) , b( x ) ) acc x L’accumulateur récolte les contributions locales au fur et à mesure du parcours ! a( x ) b( x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

23 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Un exemple ! somme( arbre ) = somme_rec( 0 , arbre ) somme_rec( acc , arbre ) = si ( feuille( arbre ) ) acc + valeur( arbre ) sinon somme_rec( somme_rec( acc , fg( arbre ) ) , fd( arbre ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

24 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Simplification de la notation : Nous n’écrivons plus les paramètres acc et x des différentes fonctions ! f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

25 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Simplification de la notation : Nous n’écrivons plus les paramètres acc et x des différentes fonctions ! f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

26 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Simplification de la notation : Nous n’écrivons plus les paramètres acc et x des différentes fonctions ! f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) f ( acc , x ) = si ( P ) a sinon f( f( t , a ) , b ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

27 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Introduisons la fonction F suivante : F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( f( acc , x ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

28 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Introduisons la fonction F suivante : F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( f( acc , x ) , p ) La pile contient les éléments qui sont à traiter. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

29 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Introduisons la fonction F suivante : F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( f( acc , x ) , p ) Nous enlevons la valeur du sommet de la pile. La pile contient les éléments qui sont à traiter. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

30 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Introduisons la fonction F suivante : F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( f( acc , x ) , p ) Nous enlevons la valeur du sommet de la pile. La pile contient les éléments qui sont à traiter. Nous la traitons. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

31 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Introduisons la fonction F suivante : F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( f( acc , x ) , p ) Nous enlevons la valeur du sommet de la pile. La pile contient les éléments qui sont à traiter. Nous la traitons. Et nous recommençons. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

32 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons : F( acc , E( v , I( ) ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

33 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons : F( acc , E( v , I( ) ) ) = si ( V( E( v , I( ) ) ) ) acc sinon x <- S( E( v , I( ) ) ) p <- D( E( v , I( ) ) ) F( f( acc , x ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

34 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons : F( acc , E( v , I( ) ) ) = si ( V( E( v , I( ) ) ) ) acc sinon x <- S( E( v , I( ) ) ) p <- D( E( v , I( ) ) ) F( f( acc , x ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

35 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons : F( acc , E( v , I( ) ) ) = si ( V( E( v , I( ) ) ) ) acc sinon x <- S( E( v , I( ) ) ) v p <- D( E( v , I( ) ) ) I( ) F( f( acc , x ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

36 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons : F( acc , E( v , I( ) ) ) = si ( V( E( v , I( ) ) ) ) acc sinon x <- S( E( v , I( ) ) ) v p <- D( E( v , I( ) ) ) I( ) F( f( acc , x ) , p ) = F( f( acc , v ) , I( ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

37 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons : F( acc , E( v , I( ) ) ) = si ( V( E( v , I( ) ) ) ) acc sinon x <- S( E( v , I( ) ) ) v p <- D( E( v , I( ) ) ) I( ) F( f( acc , x ) , p ) = F( f( acc , v ) , I( ) ) = si ( V( I( ) ) ) f( acc , v ) . . . 4 décembre 2006 Cours d'algorithmique 8 - Intranet

38 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons : F( acc , E( v , I( ) ) ) = si ( V( E( v , I( ) ) ) ) acc sinon x <- S( E( v , I( ) ) ) v p <- D( E( v , I( ) ) ) I( ) F( f( acc , x ) , p ) = F( f( acc , v ) , I( ) ) = si ( V( I( ) ) ) f( acc , v ) . . . = f( acc , v ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

39 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons : F( acc , E( v , I( ) ) ) = si ( V( E( v , I( ) ) ) ) acc sinon x <- S( E( v , I( ) ) ) v p <- D( E( v , I( ) ) ) I( ) F( f( acc , x ) , p ) = F( f( acc , v ) , I( ) ) = si ( V( I( ) ) ) f( acc , v ) . . . = f( acc , v ) Plutôt que d’appeler « f( acc , v ) » nous pouvons appeler F avec « acc » et une pile qui contient le seul élément « v » qui est à traiter. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

40 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons plus généralement : F( acc , E( v , p ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

41 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons plus généralement : F( acc , E( v , p ) ) = si ( V( E( v , p ) ) ) acc sinon x <- S( E( v , p ) ) p <- D( E( v , p ) ) F( f( acc , x ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

42 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons plus généralement : F( acc , E( v , p ) ) = si ( V( E( v , p ) ) ) acc sinon x <- S( E( v , p ) ) p <- D( E( v , p ) ) F( f( acc , x ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

43 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons plus généralement : F( acc , E( v , p ) ) = si ( V( E( v , p ) ) ) acc sinon x <- S( E( v , p ) ) v p <- D( E( v , p ) ) p F( f( acc , x ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

44 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons plus généralement : F( acc , E( v , p ) ) = si ( V( E( v , p ) ) ) acc sinon x <- S( E( v , p ) ) v p <- D( E( v , p ) ) p F( f( acc , x ) , p ) = F( f( acc , v ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

45 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons plus généralement : F( acc , E( v , p ) ) = si ( V( E( v , p ) ) ) acc sinon x <- S( E( v , p ) ) v p <- D( E( v , p ) ) p F( f( acc , x ) , p ) = F( f( acc , v ) , p ) F( acc , E( v , p ) ) = F( f( acc , v ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

46 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Nous avons plus généralement : F( acc , E( v , p ) ) = si ( V( E( v , p ) ) ) acc sinon x <- S( E( v , p ) ) v p <- D( E( v , p ) ) p F( f( acc , x ) , p ) = F( f( acc , v ) , p ) F( acc , E( v , p ) ) = F( f( acc , v ) , p ) Empiler Dépiler 4 décembre 2006 Cours d'algorithmique 8 - Intranet

47 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( f( acc , x ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

48 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( f( acc , x ) , p ) « f » est remplacée par sa définition ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

49 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( si ( P ) a f( f( t , a ) , b ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

50 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) F( si ( P ) a f( f( t , a ) , b ) , p ) Remarque : F( si C alors A sinon B , x ) = si C alors F( A , x ) sinon F( B , x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

51 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) si ( P ) F( a , p ) F( f( f( t , a ) , b ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

52 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) si ( P ) F( a , p ) F( f( f( t , a ) , b ) , p ) Utilisons : F( acc , E( v , p ) ) = F( f( acc , v ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

53 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) si ( P ) F( a , p ) F( f( f( t , a ) , b ) , p ) F( f( t , a ) , E( b , p ) ) Utilisons : F( acc , E( v , p ) ) = F( f( acc , v ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

54 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) si ( P ) F( a , p ) F( f( f( t , a ) , b ) , p ) F( f( t , a ) , E( b , p ) ) Utilisons : F( acc , E( v , p ) ) = F( f( acc , v ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

55 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) si ( P ) F( a , p ) F( f( f( t , a ) , b ) , p ) F( f( t , a ) , E( b , p ) ) F( t , E( a , E( b , p ) ) ) Utilisons : F( acc , E( v , p ) ) = F( f( acc , v ) , p ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

56 F est récursive terminale !
Deux appels récursifs auto-enveloppés Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. F( acc , p ) = si ( V( p ) ) acc sinon x <- S( p ) p <- D( p ) si ( P ) F( a , p ) F( t , E( a , E( b , p ) ) ) F est récursive terminale ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

57 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Pour un appel res <- f( init , v ) nous obtenons le code : acc <- init p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( acc , x ) ) acc <- a( acc , x ) sinon p <- E( b( acc , x ) , p ) p <- E( a( acc , x ) , p ) acc <- t( acc , x ) res <- acc 4 décembre 2006 Cours d'algorithmique 8 - Intranet

58 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Pour un appel res <- f( init , v ) nous obtenons le code : Initialisation de acc et p ! acc <- init p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( acc , x ) ) acc <- a( acc , x ) sinon p <- E( b( acc , x ) , p ) p <- E( a( acc , x ) , p ) acc <- t( acc , x ) res <- acc 4 décembre 2006 Cours d'algorithmique 8 - Intranet

59 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Pour un appel res <- f( init , v ) nous obtenons le code : Initialisation de acc et p ! acc <- init p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( acc , x ) ) acc <- a( acc , x ) sinon p <- E( b( acc , x ) , p ) p <- E( a( acc , x ) , p ) acc <- t( acc , x ) res <- acc Le prochain élément est prélevé sur la pile ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

60 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Pour un appel res <- f( init , v ) nous obtenons le code : Initialisation de acc et p ! acc <- init p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( acc , x ) ) acc <- a( acc , x ) sinon p <- E( b( acc , x ) , p ) p <- E( a( acc , x ) , p ) acc <- t( acc , x ) res <- acc Le prochain élément est prélevé sur la pile ! S’il est élémentaire, nous l’accumulons ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

61 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Pour un appel res <- f( init , v ) nous obtenons le code : Initialisation de acc et p ! acc <- init p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( acc , x ) ) acc <- a( acc , x ) sinon p <- E( b( acc , x ) , p ) p <- E( a( acc , x ) , p ) acc <- t( acc , x ) res <- acc Le prochain élément est prélevé sur la pile ! S’il est élémentaire, nous l’accumulons ! Sinon, nous empilons les deux fils et nous recommençons ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

62 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Pour un appel res <- f( init , v ) nous obtenons le code : Initialisation de acc et p ! acc <- init p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( acc , x ) ) acc <- a( acc , x ) sinon p <- E( b( acc , x ) , p ) p <- E( a( acc , x ) , p ) acc <- t( acc , x ) res <- acc Le prochain élément est prélevé sur la pile ! S’il est élémentaire, nous l’accumulons ! Sinon, nous empilons les deux fils et nous recommençons ! Le résultat final est dans acc ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

63 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés Pour des appels auto-enveloppés, nous avons : res <- f( init , v ) f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) acc <- init p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( acc , x ) ) acc <- a( acc , x ) sinon p <- E( b( acc , x ) , p ) p <- E( a( acc , x ) , p ) acc <- t( acc , x ) res <- acc 4 décembre 2006 Cours d'algorithmique 8 - Intranet

64 Cours d'algorithmique 8 - Intranet
Deux appels récursifs auto-enveloppés L’équivalence se généralise à 3 ou plus d’arguments pour f : acc <- init p <- E( w , I( ) ) p <- E( v , p ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) y <- S( p ) si ( P( acc , x , y ) ) acc <- a( acc , x , y ) sinon p <- E( d( acc , x , y ) , p ) p <- E( b( acc , x , y ) , p ) p <- E( g( acc , x , y ) , p ) p <- E( a( acc , x , y ) , p ) acc <- t( acc , x , y ) res <- acc res <- f( init , v , w ) f ( acc , x , y ) = si ( P( acc , x , y ) ) a( acc , x , y ) sinon f( f( t( acc , x , y ) , a( acc , x , y ) , g( acc , x , y ) ) , b( acc , x , y ) , d( acc , x , y ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

65 Cours d'algorithmique 8 - Intranet
res <- somme_rec( 0 , arbre ) somme_rec( acc , arbre ) = si ( feuille( arb ) ) acc + valeur( arbre ) sinon somme_rec( somme_rec( acc , fg( arbre ) ) , fd( arbre ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

66 Cours d'algorithmique 8 - Intranet
res <- somme_rec( 0 , arbre ) somme_rec( acc , arbre ) = si ( feuille( arb ) ) acc + valeur( arbre ) sinon somme_rec( somme_rec( acc , fg( arbre ) ) , fd( arbre ) ) acc <- 0 p <- E( arbre , I( ) ) while ( ù V( p ) ) arbre <- S( p ) p <- D( p ) si ( feuille ( arbre ) ) acc <- acc + valeur( arbre ) sinon p <- E( fd( arbre ) , p ) p <- E( fg( arbre ) , p ) res <- acc 4 décembre 2006 Cours d'algorithmique 8 - Intranet

67 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre 4 décembre 2006 Cours d'algorithmique 8 - Intranet

68 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Dans la pile ! X Y T Z Y T Z X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

69 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Dans l’accumulateur : acc = ( ( 0 + k ) + l ) Dans la pile ! X Y T k Z l Y T Z X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

70 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Dans l’accumulateur : acc = ( ( 0 + k ) + l ) Dans la pile ! X arbre <- S( p ) p <- D( p ) Y T k Z l Y T Z X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

71 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Dans l’accumulateur : acc = ( ( 0 + k ) + l ) Dans la pile ! X arbre <- S( p ) p <- D( p ) Y k Z l Y arbre = T Z X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

72 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Dans l’accumulateur : acc = ( ( 0 + k ) + l ) Dans la pile ! X arbre <- S( p ) p <- D( p ) Y k Z Premier cas : feuille( arbre ) est vrai et valeur( arbre ) = m l Y arbre = T Z X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

73 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Dans l’accumulateur : acc = ( ( 0 + k ) + l ) Dans la pile ! X arbre <- S( p ) p <- D( p ) Y k Z Premier cas : feuille( arbre ) est vrai et valeur( arbre ) = m l Y arbre = T Z m X acc = ( ( ( 0 + k ) + l ) + m ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

74 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Dans l’accumulateur : acc = ( ( 0 + k ) + l ) Dans la pile ! X arbre <- S( p ) p <- D( p ) Y k Z Second cas : feuille( arbre ) est faux et fg( arbre ) = U et fd( arbre ) = V l Y arbre = T Z X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

75 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Dans l’accumulateur : acc = ( ( 0 + k ) + l ) Dans la pile ! X U arbre <- S( p ) p <- D( p ) Y V k Z Second cas : feuille( arbre ) est faux et fg( arbre ) = U et fd( arbre ) = V l Y Z X U V 4 décembre 2006 Cours d'algorithmique 8 - Intranet

76 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Un Deux Fonction auto-enveloppée Non Oui 4 décembre 2006 Cours d'algorithmique 8 - Intranet

77 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non 4 décembre 2006 Cours d'algorithmique 8 - Intranet

78 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Soient deux appels récursifs avec une enveloppe associative ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

79 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Soient deux appels récursifs avec une enveloppe associative ! La forme générale est la suivante : f ( x ) = si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

80 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Soient deux appels récursifs avec une enveloppe associative ! La forme générale est la suivante : Le flot des informations est le suivant : f ( x ) = si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) h x 4 décembre 2006 Cours d'algorithmique 8 - Intranet

81 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

82 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : 4 décembre 2006 Cours d'algorithmique 8 - Intranet

83 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : « f » est remplacée par sa définition ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

84 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = h( acc , si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) ) « f » est remplacée par sa définition ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

85 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = h( acc , si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) ) = si ( P( x ) ) h( acc , a( x ) ) h( acc , h( f( a( x ) ) , f( b( x ) ) ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

86 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = h( acc , si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) ) = si ( P( x ) ) h( acc , a( x ) ) h( acc , h( f( a( x ) ) , f( b( x ) ) ) ) Associativité de h! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

87 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = h( acc , si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) ) = si ( P( x ) ) h( acc , a( x ) ) h( acc , h( f( a( x ) ) , f( b( x ) ) ) ) h( h( acc , f( a( x ) ) ) , f( b( x ) ) ) Associativité de h! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

88 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = h( acc , si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) ) = si ( P( x ) ) h( acc , a( x ) ) h( acc , h( f( a( x ) ) , f( b( x ) ) ) ) h( h( acc , f( a( x ) ) ) , f( b( x ) ) ) Associativité de h! Définition de g ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

89 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = h( acc , si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) ) = si ( P( x ) ) h( acc , a( x ) ) h( acc , h( f( a( x ) ) , f( b( x ) ) ) ) h( h( acc , f( a( x ) ) ) , f( b( x ) ) ) h( g( acc , a( x ) ) , f( b( x ) ) ) Associativité de h! Définition de g ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

90 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = h( acc , si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) ) = si ( P( x ) ) h( acc , a( x ) ) h( acc , h( f( a( x ) ) , f( b( x ) ) ) ) h( h( acc , f( a( x ) ) ) , f( b( x ) ) ) h( g( acc , a( x ) ) , f( b( x ) ) ) Associativité de h! Définition de g ! Définition de g ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

91 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = h( acc , si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) ) = si ( P( x ) ) h( acc , a( x ) ) h( acc , h( f( a( x ) ) , f( b( x ) ) ) ) h( h( acc , f( a( x ) ) ) , f( b( x ) ) ) h( g( acc , a( x ) ) , f( b( x ) ) ) g( g( acc , a( x ) ) , b( x ) ) Associativité de h! Définition de g ! Définition de g ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

92 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = si ( P( x ) ) h( acc , a( x ) ) sinon g( g( acc , a( x ) ) , b( x ) ) Nous sommes donc revenus au cas d’une fonction auto-enveloppée ! et donc ... 4 décembre 2006 Cours d'algorithmique 8 - Intranet

93 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Nous nous ramenons au cas auto-enveloppé en posant : g( acc , x ) = h( acc , f( x ) ) Alors : g( acc , x ) = si ( P( x ) ) h( acc , a( x ) ) sinon g( g( acc , a( x ) ) , b( x ) ) Le flot des informations a changé : Nous sommes donc revenus au cas d’une fonction auto-enveloppée ! et donc ... h acc x x 4 décembre 2006 Cours d'algorithmique 8 - Intranet

94 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Schéma h( f( a( x ) ) , f( b( x ) ) ) X Y Résultats en attente ! Traitements en attente ! k l Z m Noeud courant 4 décembre 2006 Cours d'algorithmique 8 - Intranet

95 Cours d'algorithmique 8 - Intranet
Sous forme d’arbre Schéma h( f( a( x ) ) , f( b( x ) ) ) Schéma g( g( acc , a( x ) ) , b( x ) ) X Y Résultats en attente ! Traitements en attente ! k l Tout ceci dans l’accumulateur ! ! ! Z m Noeud courant 4 décembre 2006 Cours d'algorithmique 8 - Intranet

96 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Si « h » a un neutre « e », l’initialisation est immédiate : g( e , v ) = h( e , f( v ) ) = f( v ) Le code : acc <- e p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( b( x ) , p ) p <- E( a( x ) , p ) res <- acc 4 décembre 2006 Cours d'algorithmique 8 - Intranet

97 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Pour deux appels avec une enveloppe « h » associative avec neutre « e », nous avons : acc <- e p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( b( x ) , p ) p <- E( a( x ) , p ) res <- acc res <- f( v ) f ( x ) = si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

98 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative L’équivalence se généralise à 2 ou plus d’arguments pour f : acc <- e p <- E( w , I( ) ) p <- E( v , p ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) y <- S( p ) si ( P( x , y ) ) acc <- h( acc , a( x , y ) ) sinon p <- E( d( x ) , p ) p <- E( b( x ) , p ) p <- E( g( x ) , p ) p <- E( a( x ) , p ) res <- acc res <- f( v , w ) f ( x , y ) = si ( P( x , y ) ) a( x , y ) sinon h( f( a( x , y) , g( x , y ) ) , f( b( x , y ) , d( x , y ) ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

99 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Si « h » est sans neutre, c’est plus embêtant. Il faut traiter la première feuille à part ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

100 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Si « h » est sans neutre, c’est plus embêtant. Il faut traiter la première feuille à part ! A B Tout ceci dans la pile ! feuille K 4 décembre 2006 Cours d'algorithmique 8 - Intranet

101 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative x <- v p <- I( ) while ( ù ( P( x ) ) p <- E( b( x ) , p ) x <- a( x ) acc <- a( x ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( a( x ) , p ) res <- acc Si « h » est sans neutre, c’est plus embêtant. Le code : 4 décembre 2006 Cours d'algorithmique 8 - Intranet

102 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative x <- v p <- I( ) while ( ù ( P( x ) ) p <- E( b( x ) , p ) x <- a( x ) acc <- a( x ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( a( x ) , p ) res <- acc Si « h » est sans neutre, c’est plus embêtant. Le code : L’initialisation est triviale ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

103 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative x <- v p <- I( ) while ( ù ( P( x ) ) p <- E( b( x ) , p ) x <- a( x ) acc <- a( x ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( a( x ) , p ) res <- acc Si « h » est sans neutre, c’est plus embêtant. Le code : L’initialisation est triviale ! La descente à gauche vers la première feuille . Nous empilons les fils droits. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

104 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative x <- v p <- I( ) while ( ù ( P( x ) ) p <- E( b( x ) , p ) x <- a( x ) acc <- a( x ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( a( x ) , p ) res <- acc Si « h » est sans neutre, c’est plus embêtant. Le code : L’initialisation est triviale ! La descente à gauche vers la première feuille . Nous empilons les fils droits. Finalement, nous pouvons initialiser l’accumulateur ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

105 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative x <- v p <- I( ) while ( ù ( P( x ) ) p <- E( b( x ) , p ) x <- a( x ) acc <- a( x ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( a( x ) , p ) res <- acc Si « h » est sans neutre, c’est plus embêtant. Le code : L’initialisation est triviale ! La descente à gauche vers la première feuille . Nous empilons les fils droits. Finalement, nous pouvons Initialiser l’accumulateur ! Le reste ne change pas ! ! ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

106 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative Pour deux appels avec une enveloppe « h » associative sans neutre, nous avons : x <- v p <- I( ) while ( ù ( P( x ) ) p <- E( b( x ) , p ) x <- a( x ) acc <- a( x ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( a( x ) , p ) res <- acc res <- f( v ) f ( x ) = si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

107 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe associative x <- v ; y <- w ; p <- I( ) while ( ù ( P( x , y ) ) p <- E( d( x , y ) , p ) p <- E( b( x , y ) , p ) m <- a( x , y ) y <- g( x , y ) x <- m acc <- a( x , y ) while ( ù V( p ) ) x <- S( p ) ; p <- D( p ) y <- S( p ) ; p <- D( p ) si ( P( x , y ) ) acc <- h( acc , a( x , y ) ) sinon p <- E( g( x , y ) , p ) p <- E( a( x , y ) , p ) res <- acc L’équivalence se généralise à 2 ou plus d’arguments pour f : res <- f( v , w ) f ( x , y ) = si ( P( x , y ) ) a( x , y ) sinon h( f( a( x , y) , g( x , y ) ) , f( b( x , y ) , d( x , y ) ) ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

108 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non 4 décembre 2006 Cours d'algorithmique 8 - Intranet

109 Plan -----------------------------------------------------------------
Nombre d’appels récursifs Un Deux Fonction auto-enveloppée Le plus embêtant ! Le plus compliqué ! Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non 4 décembre 2006 Cours d'algorithmique 8 - Intranet

110 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative C’est le cas le plus compliqué à gérer ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

111 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative C’est le cas le plus compliqué à gérer ! Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre : 4 décembre 2006 Cours d'algorithmique 8 - Intranet

112 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative C’est le cas le plus compliqué à gérer ! Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre : Résultats en attente ! X k Traitements en attente ! Y Z l Noeud courant 4 décembre 2006 Cours d'algorithmique 8 - Intranet

113 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative C’est le cas le plus compliqué à gérer ! Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre : Résultats en attente ! X l k Traitements en attente ! Z Y Y Z k l X Noeud courant La pile ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

114 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative C’est le cas le plus compliqué à gérer ! Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre : Résultats en attente ! X l k On mélange tout ! Traitements en attente ! Z Y Y Z k l X Noeud courant La pile ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

115 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative C’est le cas le plus compliqué à gérer ! Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre : Résultats en attente ! X T X On mélange tout ! Traitements en attente ! Z Y Y Z X T X Noeud courant La pile ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

116 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative C’est le cas le plus compliqué à gérer ! Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre : Résultats en attente ! X T X On mélange tout ! Traitements en attente ! Z Y Y Z X ????? T X Noeud courant La pile ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

117 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative C’est le cas le plus compliqué à gérer ! Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre : Il faut un marqueur ! Résultats en attente ! X T X On mélange tout ! Traitements en attente ! Z Y Y Z X ????? T X Noeud courant La pile ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

118 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Nous allons toujours empiler des paires d’informations : soit, un calcul « X » à faire et le marqueur « C », soit, un résultat « res » et le marqueur « R ». 4 décembre 2006 Cours d'algorithmique 8 - Intranet

119 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Nous allons toujours empiler des paires d’informations : soit, un calcul « X » à faire et le marqueur « C », soit, un résultat « res » et le marqueur « R ». C Y R Y X X C X X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

120 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Nous avons quatre variables globales : la variable « x » qui indique l’élément à traiter, la variable « res » qui indique le résultat courant, la variable « marq » qui est la valeur du dernier marqueur, la variable « p » qui est la pile courante. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

121 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Nous avons quatre variables globales : la variable « x » qui indique l’élément à traiter, la variable « res » qui indique le résultat courant, la variable « marq » qui est la valeur du dernier marqueur, la variable « p » qui est la pile courante. Nous distinguons deux types de traitements : cas 1 – la variable « x » ne vérifie pas le test d’arrêt, cas 2 – la variable « x » vérifie le test d’arrêt. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

122 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 1 - la variable « x » ne vérifie pas le test d’arrêt : l’appel « f( x ) » engendre les appels « f( a( x ) ) » et « f( b( x ) ) », 4 décembre 2006 Cours d'algorithmique 8 - Intranet

123 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 1 - la variable « x » ne vérifie pas le test d’arrêt : l’appel « f( x ) » engendre les appels « f( a( x ) ) » et « f( b( x ) ) », nous allons empiler «  b( x ) » avec son marqueur et traiter tout de suite « a( x ) ». 4 décembre 2006 Cours d'algorithmique 8 - Intranet

124 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 1 - la variable « x » ne vérifie pas le test d’arrêt : l’appel « f( x ) » engendre les appels « f( a( x ) ) » et « f( b( x ) ) », nous allons empiler «  b( x ) » avec son marqueur et traiter tout de suite « a( x ) ». p <- E( b( x ) , p ) p <- E( C , p ) x <- a( x ) goto CALCUL 4 décembre 2006 Cours d'algorithmique 8 - Intranet

125 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 2 - la variable « x » vérifie le test d’arrêt : l’appel « f( x ) » engendre le résultat « a( x ) » et 4 décembre 2006 Cours d'algorithmique 8 - Intranet

126 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 2 - la variable « x » vérifie le test d’arrêt : l’appel « f( x ) » engendre le résultat « a( x ) » et nous inspectons la pile pour déterminer la suite des calculs. res <- a( x ) goto PILE 4 décembre 2006 Cours d'algorithmique 8 - Intranet

127 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Fusion des cas 1 & 2 - la variable « x » doit être traitée : CALCUL : si ( P( x ) ) res <- a( x ) goto PILE sinon p <- E( b( x ) , p ) p <- E( C , p ) x <- a( x ) goto CALCUL 4 décembre 2006 Cours d'algorithmique 8 - Intranet

128 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Fusion des cas 1 & 2 - la variable « x » doit être traitée : CALCUL : si ( P( x ) ) res <- a( x ) goto PILE sinon p <- E( b( x ) , p ) p <- E( C , p ) x <- a( x ) goto CALCUL Une sortie ! Une boucle ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

129 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Dès qu’il y a un résultat « res », nous inspectons la pile : Trois cas se présentent pour la pile : cas 3 – elle est vide, cas 4 – elle a un marqueur « C » au sommet et cas 5 – elle a un marqueur « R » au sommet. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

130 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 3 – nous avons « res » et une pile vide : 4 décembre 2006 Cours d'algorithmique 8 - Intranet

131 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 3 – nous avons « res » et une pile vide : « res » est le résultat final et nous avons terminé les calculs. goto FIN 4 décembre 2006 Cours d'algorithmique 8 - Intranet

132 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 4 – nous avons « res » et « C » avec « X » sur la pile : C X . . . 4 décembre 2006 Cours d'algorithmique 8 - Intranet

133 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 4 – nous avons « res » et « C » avec « X » sur la pile : « res » est le résultat du fils gauche et « X » est le fils droit en attente. C X . . . R C res X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

134 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 4 – nous avons « res » et « C » avec « X » sur la pile : « res » est le résultat du fils gauche et « X » est le fils droit en attente. Nous allons donc : dépiler « X » pour le traiter, . . . C X . . . R C res X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

135 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 4 – nous avons « res » et « C » avec « X » sur la pile : « res » est le résultat du fils gauche et « X » est le fils droit en attente. Nous allons donc : dépiler « X » pour le traiter, . . . C X marq <- S( p ) p <- D( p ) x <- S( p ) ... goto CALCUL . . . R C . . . res X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

136 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 4 – nous avons « res » et « C » avec « X » sur la pile : « res » est le résultat du fils gauche et « X » est le fils droit en attente. Nous allons donc : dépiler « X » pour le traiter, sauver « res » sur la pile. C X marq <- S( p ) p <- D( p ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) goto CALCUL . . . R res R C . . . res X 4 décembre 2006 Cours d'algorithmique 8 - Intranet

137 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : R a . . . 4 décembre 2006 Cours d'algorithmique 8 - Intranet

138 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : « res » est le résultat du fils droit et « a » est le résultat gauche en attente. R a . . . R R a res 4 décembre 2006 Cours d'algorithmique 8 - Intranet

139 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : « res » est le résultat du fils droit et « a » est le résultat gauche en attente. Nous allons donc : dépiler « a » pour le combiner avec « res » et . . . R a . . . R R a res 4 décembre 2006 Cours d'algorithmique 8 - Intranet

140 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : « res » est le résultat du fils droit et « a » est le résultat gauche en attente. Nous allons donc : dépiler « a » pour le combiner avec « res » et . . . R a marq <- S( p ) p <- D( p ) res <- h( S( p ) , res ) ... . . . R R a res . . . 4 décembre 2006 Cours d'algorithmique 8 - Intranet

141 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : « res » est le résultat du fils droit et « a » est le résultat gauche en attente. Nous allons donc : dépiler « a » pour le combiner avec « res » et continuer l’inspection de pile. R a marq <- S( p ) p <- D( p ) res <- h( S( p ) , res ) goto PILE . . . R R a res . . . 4 décembre 2006 Cours d'algorithmique 8 - Intranet

142 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative PILE: si ( V( p ) ) goto FIN sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) goto CALCUL res <- h( S( p ) , res ) goto PILE Fusion des cas 3, 4 & 5 : 4 décembre 2006 Cours d'algorithmique 8 - Intranet

143 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative PILE: si ( V( p ) ) goto FIN sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) goto CALCUL res <- h( S( p ) , res ) goto PILE Fusion des cas 3, 4 & 5 : Nous consultons le marqueur ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

144 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative PILE: si ( V( p ) ) goto FIN sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) goto CALCUL res <- h( S( p ) , res ) goto PILE Fusion des cas 3, 4 & 5 : Nous consultons le marqueur ! Nous allons traiter le second fils et sauvons le résultat du premier ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

145 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative PILE: si ( V( p ) ) goto FIN sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) goto CALCUL res <- h( S( p ) , res ) goto PILE Fusion des cas 3, 4 & 5 : Nous consultons le marqueur ! Nous allons traiter le second fils et sauvons le résultat du premier ! Nous combinons deux résultats ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

146 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative PILE: si ( V( p ) ) goto FIN sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) goto CALCUL res <- h( S( p ) , res ) goto PILE Fusion des cas 3, 4 & 5 : Une sortie ! Nous consultons le marqueur ! Nous allons traiter le second fils et sauvons le résultat du premier ! Une sortie ! Nous combinons deux résultats ! Une boucle ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

147 Cours d'algorithmique 8 - Intranet
Deux appels récursifs, enveloppe non associative DEBUT : x <- v p <- I( ) goto CALCUL PILE: si ( V( p ) ) goto FIN sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) goto CALCUL res <- h( S( p ) , res ) goto PILE CALCUL : si ( P( x ) ) res <- a( x ) goto PILE sinon p <- E( b( x ) , p ) p <- E( C , p ) x <- a( x ) goto CALCUL FIN : ... 4 décembre 2006 Cours d'algorithmique 8 - Intranet

148 Se généralise pour "f" et pour "h"
Deux appels récursifs, enveloppe non associative DEBUT : x <- v p <- I( ) goto CALCUL PILE: si ( V( p ) ) goto FIN sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) goto CALCUL res <- h( S( p ) , res ) goto PILE Se généralise pour "f" et pour "h" avec plus d'arguments ! CALCUL : si ( P( x ) ) res <- a( x ) goto PILE sinon p <- E( b( x ) , p ) p <- E( C , p ) x <- a( x ) goto CALCUL FIN : ... 4 décembre 2006 Cours d'algorithmique 8 - Intranet

149 Avec des while à la place des goto !
Deux appels récursifs, enveloppe non associative Avec des while à la place des goto ! DEBUT : x <- v p <- I( ) FIN <- faux CALCUL <- vrai PILE <- faux while ( ù FIN ) while_CALCUL while_PILE while_PILE: while ( PILE ) si ( V( p ) ) PILE <- faux FIN <- vrai sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) CALCUL <- vrai res <- h( S( p ) , res ) while_CALCUL : while ( CALCUL ) si ( P( x ) ) res <- a( x ) CALCUL <- faux PILE <- vrai sinon p <- E( b( x ) , p ) p <- E( C , p ) x <- a( x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

150 Avec des while à la place des goto !
Deux appels récursifs, enveloppe non associative Avec des while à la place des goto ! DEBUT : x <- v p <- I( ) FIN <- faux CALCUL <- vrai PILE <- faux while ( ù FIN ) while_CALCUL while_PILE while_PILE: while ( PILE ) si ( V( p ) ) PILE <- faux FIN <- vrai sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) CALCUL <- vrai res <- h( S( p ) , res ) while_CALCUL : while ( CALCUL ) si ( P( x ) ) res <- a( x ) CALCUL <- faux PILE <- vrai sinon p <- E( b( x ) , p ) p <- E( C , p ) x <- a( x ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

151 Cours d'algorithmique 8 - Intranet
Deux appels récursifs --- résumé Nombre d’appels récursifs Nous retenons les quatre cas suivants ! Un Deux Fonction auto-enveloppée Non Oui Cas 5) Enveloppe associative Oui Non Cas 8) Avec élément neutre Cas 6) Oui Non Cas 7) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

152 Cours d'algorithmique 8 - Intranet
Deux appels récursifs --- résumé 5) Deux appels récursifs auto-enveloppés ! acc <- init p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( acc , x ) ) acc <- a( acc , x ) sinon p <- E( b( acc , x ) , p ) p <- E( a( acc , x ) , p ) acc <- t( acc , x ) res <- acc f ( acc , x ) = si ( P( acc , x ) ) a( acc , x ) sinon f( f( t( acc , x ) , a( acc , x ) ) , b( acc , x ) ) Code itératif peu raisonnable ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

153 Cours d'algorithmique 8 - Intranet
Deux appels récursifs --- résumé 6) Appels avec enveloppe associative et neutre « e » ! acc <- e p <- E( v , I( ) ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( b( x ) , p ) p <- E( a( x ) , p ) res <- acc f ( x ) = si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) Code itératif peu raisonnable ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

154 Cours d'algorithmique 8 - Intranet
Deux appels récursifs --- résumé x <- v p <- I( ) while ( ù ( P( x ) ) p <- E( b( x ) , p ) x <- a( x ) acc <- a( x ) while ( ù V( p ) ) x <- S( p ) p <- D( p ) si ( P( x ) ) acc <- h( acc , a( x ) ) sinon p <- E( a( x ) , p ) res <- acc 7) Appels avec enveloppe associative, sans neutre ! f ( x ) = si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) Code itératif très peu raisonnable ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

155 Cours d'algorithmique 8 - Intranet
Deux appels récursifs --- résumé while_PILE: while ( PILE ) si ( V( p ) ) PILE <- faux FIN <- vrai sinon marq <- S( p ) p <- D( p ) si ( marq = C ) x <- S( p ) p <- E( res , p ) p <- E( R , p ) CALCUL <- vrai res <- h( S( p ) , res ) 8) Appels avec enveloppe non associative ! f ( x ) = si ( P( x ) ) a( x ) sinon h( f( a( x ) ) , f( b( x ) ) ) Code itératif déraisonnable ! while_CALCUL : while ( CALCUL ) si ( P( x ) ) res <- a( x ) CALCUL <- faux PILE <- vrai sinon p <- E( b( x ) , p ) p <- E( C , p ) x <- a( x ) DEBUT : x <- v p <- I( ) FIN <- faux CALCUL <- vrai PILE <- faux while ( ù FIN ) while_CALCUL while_PILE 4 décembre 2006 Cours d'algorithmique 8 - Intranet

156 Cours d'algorithmique 8 - Intranet
Résumé général R E S U M E 4 décembre 2006 Cours d'algorithmique 8 - Intranet

157 Cours d'algorithmique 8 - Intranet
Résumé général Les quatre cas à unique appel récursif : Récursif terminal. Enveloppe associative avec neutre. Enveloppe associative sans neutre. Enveloppe non associative. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

158 Cours d'algorithmique 8 - Intranet
Résumé général Les quatre cas à unique appel récursif : Récursif terminal. Enveloppe associative avec neutre. Enveloppe associative sans neutre. Enveloppe non associative. Se ramène à … 4 décembre 2006 Cours d'algorithmique 8 - Intranet

159 Cours d'algorithmique 8 - Intranet
Résumé général Les quatre cas à unique appel récursif : Récursif terminal. Enveloppe associative avec neutre. Enveloppe associative sans neutre. Enveloppe non associative. Les quatre cas à deux appels récursifs : Récursif auto-enveloppé. Se ramène à … 4 décembre 2006 Cours d'algorithmique 8 - Intranet

160 Cours d'algorithmique 8 - Intranet
Résumé général Les quatre cas à unique appel récursif : Récursif terminal. Enveloppe associative avec neutre. Enveloppe associative sans neutre. Enveloppe non associative. Les quatre cas à deux appels récursifs : Récursif auto-enveloppé. Se ramène à … 4 décembre 2006 Cours d'algorithmique 8 - Intranet

161 Cours d'algorithmique 8 - Intranet
Résumé général Les quatre cas à unique appel récursif : Récursif terminal. Enveloppe associative avec neutre. Enveloppe associative sans neutre. Enveloppe non associative. Les quatre cas à deux appels récursifs : Récursif auto-enveloppé. Récursif ! Se ramène à … 4 décembre 2006 Cours d'algorithmique 8 - Intranet

162 Cours d'algorithmique 8 - Intranet
Résumé général Les quatre cas à unique appel récursif : Récursif terminal. Enveloppe associative avec neutre. Enveloppe associative sans neutre. Enveloppe non associative. Les quatre cas à deux appels récursifs : Récursif auto-enveloppé. Récursif ! Itératif ! Se ramène à … 4 décembre 2006 Cours d'algorithmique 8 - Intranet

163 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons C h a n g e o n s d e s u j e t ! A L G O R I T H M E S G L O U T O N S ! ! ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

164 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Greedy algorithms en anglais ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

165 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Greedy algorithms en anglais ! Une suite de décisions optimales locales conduit à un optimum global ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

166 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Greedy algorithms en anglais ! Une suite de décisions optimales locales conduit à un optimum global ! Complexité pour « n » éléments : O( n * x ) où O( x ) est la complexité de la décision locale ! O( 2 ) pour le back-track (cascade de décisions locales) ! n 4 décembre 2006 Cours d'algorithmique 8 - Intranet

167 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Exemple d’un choix glouton : GLOBAL : Choisir les 10 plus petits de l’amphi ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

168 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Exemple d’un choix glouton : GLOBAL : Choisir les 10 plus petits de l’amphi ! LOCAL : Trouver et retirer le plus petit ! Ce choix est indépendant des autres personnes déjà choisies ou restant à choisir. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

169 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Exemple d’un choix glouton : GLOBAL : Choisir les 10 plus petits de l’amphi ! LOCAL : Trouver et retirer le plus petit ! Ce choix est indépendant des autres personnes déjà choisies ou restant à choisir. Exemple d’un choix non glouton : GLOBAL : Choisir le plus court chemin de Marseille à Paris ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

170 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Exemple d’un choix glouton : GLOBAL : Choisir les 10 plus petits de l’amphi ! LOCAL : Trouver et retirer le plus petit ! Ce choix est indépendant des autres personnes déjà choisies ou restant à choisir. Exemple d’un choix non glouton : GLOBAL : Choisir le plus court chemin de Marseille à Paris ! LOCAL : Trouver à partir de la ville courante, l’étape la plus courte ! Un tel choix n’est pas sûr de nous rapprocher de Paris ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

171 Cours d'algorithmique 8 - Intranet
Action Selection Problem Un exemple complet : Ensemble « E » de tâches, dont le « début » et la « fin » sont connues ! t et t sont compatibles si leurs intersections sont vides ! OBJECTIF : Trouvez le plus grand ensemble de tâches compatibles ! ! ! i j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

172 Cours d'algorithmique 8 - Intranet
Action Selection Problem Un exemple complet : Ensemble « E » de tâches, dont le « début » et la « fin » sont connues ! t et t sont compatibles si leurs intersections sont vides ! OBJECTIF : Trouvez le plus grand ensemble de tâches compatibles ! ! ! i j i d f La première tâche dure de 5 à 7. La deuxième tâche dure de 3 à 9. i i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

173 Cours d'algorithmique 8 - Intranet
Action Selection Problem Un exemple complet : Ensemble « E » de tâches, dont le « début » et la « fin » sont connues ! t et t sont compatibles si leurs intersections sont vides ! OBJECTIF : Trouvez le plus grand ensemble de tâches compatibles ! ! ! i j i d f i d f i i i i Triées par f croissants ! i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

174 Cours d'algorithmique 8 - Intranet
Action Selection Problem Trois approches de solution : Back-track ! Programmation dynamique ! Algorithme glouton ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

175 Cours d'algorithmique 8 - Intranet
Action Selection Problem Les tâches déjà choisies. Les tâches non encore considérées. ens BT ( ens choisies , ens restantes ) = si ( restantes = {} ) choisies sinon choix <- choisir( restantes ) restantes <- restantes \ { choix } sans_choix = BT( choisies , restantes ) si ( compatible( choix , choisies ) ) max_ens( BT( choisies v { choix } , restantes ) , sans_choix ) sans_choix 4 décembre 2006 Cours d'algorithmique 8 - Intranet

176 Cours d'algorithmique 8 - Intranet
Action Selection Problem Les tâches déjà choisies. Les tâches non encore considérées. ens BT ( ens choisies , ens restantes ) = si ( restantes = {} ) choisies sinon choix <- choisir( restantes ) restantes <- restantes \ { choix } sans_choix = BT( choisies , restantes ) si ( compatible( choix , choisies ) ) max_ens( BT( choisies v { choix } , restantes ) , sans_choix ) sans_choix Assez naturel ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

177 Cours d'algorithmique 8 - Intranet
Action Selection Problem Les tâches déjà choisies. Les tâches non encore considérées. ens BT ( ens choisies , ens restantes ) = si ( restantes = {} ) choisies sinon choix <- choisir( restantes ) restantes <- restantes \ { choix } sans_choix = BT( choisies , restantes ) si ( compatible( choix , choisies ) ) max_ens( BT( choisies v { choix } , restantes ) , sans_choix ) sans_choix Assez naturel ! Nous choisissons ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

178 Cours d'algorithmique 8 - Intranet
Action Selection Problem Les tâches déjà choisies. Les tâches non encore considérées. ens BT ( ens choisies , ens restantes ) = si ( restantes = {} ) choisies sinon choix <- choisir( restantes ) restantes <- restantes \ { choix } sans_choix = BT( choisies , restantes ) si ( compatible( choix , choisies ) ) max_ens( BT( choisies v { choix } , restantes ) , sans_choix ) sans_choix Assez naturel ! Nous choisissons ! Nous avons toujours la possibilité de ne pas retenir la tâche choisie ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

179 Cours d'algorithmique 8 - Intranet
Action Selection Problem Les tâches déjà choisies. Les tâches non encore considérées. ens BT ( ens choisies , ens restantes ) = si ( restantes = {} ) choisies sinon choix <- choisir( restantes ) restantes <- restantes \ { choix } sans_choix = BT( choisies , restantes ) si ( compatible( choix , choisies ) ) max_ens( BT( choisies v { choix } , restantes ) , sans_choix ) sans_choix Assez naturel ! Nous choisissons ! Le choix est retenu s’il est compatible . . . Nous avons toujours la possibilité de ne pas retenir la tâche choisie ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

180 Cours d'algorithmique 8 - Intranet
Action Selection Problem Les tâches déjà choisies. Les tâches non encore considérées. ens BT ( ens choisies , ens restantes ) = si ( restantes = {} ) choisies sinon choix <- choisir( restantes ) restantes <- restantes \ { choix } sans_choix = BT( choisies , restantes ) si ( compatible( choix , choisies ) ) max_ens( BT( choisies v { choix } , restantes ) , sans_choix ) sans_choix Assez naturel ! Nous choisissons ! Le choix est retenu s’il est compatible . . . Nous avons toujours la possibilité de ne pas retenir la tâche choisie ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

181 Cours d'algorithmique 8 - Intranet
Action Selection Problem Trois approches de solution : Back-track ! Complexité : O ( 2^n ) Programmation dynamique ! Algorithme glouton ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

182 Cours d'algorithmique 8 - Intranet
Action Selection Problem Considérons : E( i , j ) = { t e E | f <= d <= f <= d } k i k k j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

183 Cours d'algorithmique 8 - Intranet
Action Selection Problem Considérons : E( i , j ) = { t e E | f <= d <= f <= d } k i k k j f d i j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

184 Cours d'algorithmique 8 - Intranet
Action Selection Problem Considérons : E( i , j ) = { t e E | f <= d <= f <= d } k i k k j f d f d i k k j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

185 Cours d'algorithmique 8 - Intranet
Action Selection Problem Considérons : E( i , j ) = { t e E | f <= d <= f <= d } Initialisation : soit t avec f = 0 , soit t avec d = +inf , alors E = E( 0 , n+1 ) . k i k k j f d f d i k k j n+1 n+1 4 décembre 2006 Cours d'algorithmique 8 - Intranet

186 Cours d'algorithmique 8 - Intranet
Action Selection Problem Décomposition : E( i , j ) f d i j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

187 Cours d'algorithmique 8 - Intranet
Action Selection Problem Décomposition : t e E( i , j ) E( i , j ) k f d f d i k k j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

188 Cours d'algorithmique 8 - Intranet
Action Selection Problem Décomposition : t e E( i , j ) E( i , j ) k f d f d i { { k k j E( i , k ) E( k , j ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

189 Cours d'algorithmique 8 - Intranet
Action Selection Problem Décomposition : { } si E( i , j ) = { } S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) } sinon t e E( i , j ) E( i , j ) k f d f d i { { k k j E( i , k ) E( k , j ) { k t e E( i , j ) k 4 décembre 2006 Cours d'algorithmique 8 - Intranet

190 Cours d'algorithmique 8 - Intranet
Action Selection Problem Décomposition : { } si E( i , j ) = { } S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) } sinon t e E( i , j ) E( i , j ) k f d f d i { { k k j E( i , k ) E( k , j ) { On maximise sur tous les choix pour t . k t e E( i , j ) k k 4 décembre 2006 Cours d'algorithmique 8 - Intranet

191 Cours d'algorithmique 8 - Intranet
Action Selection Problem Décomposition : { } si E( i , j ) = { } S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) } sinon t e E( i , j ) E( i , j ) k f d f d i { { k k j E( i , k ) E( k , j ) C’est la tâche t et les solutions optimales pour E( i , k ) et E( k , j ). k { On maximise sur tous les choix pour t . k t e E( i , j ) k k 4 décembre 2006 Cours d'algorithmique 8 - Intranet

192 Cours d'algorithmique 8 - Intranet
Action Selection Problem Tâches triées par f croissants, donc i < k < j ! Graphiquement, pour i < j : x S( i , j ) j i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

193 Cours d'algorithmique 8 - Intranet
Action Selection Problem Tâches triées par f croissants, donc i < k < j ! Graphiquement, pour i < j : x S( i , j ) j i i j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

194 Cours d'algorithmique 8 - Intranet
Action Selection Problem Tâches triées par f croissants, donc i < k < j ! Graphiquement, pour i < j : x S( i , j ) S( k , j ) . . . j . . . S( i , k ) i i j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

195 Cours d'algorithmique 8 - Intranet
Action Selection Problem Tâches triées par f croissants, donc i < k < j ! Graphiquement, pour i < j : x S( i , j ) S( k , j ) . . . j Second axe de temps . . . S( i , k ) i Premier axe de temps i j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

196 Cours d'algorithmique 8 - Intranet
Action Selection Problem Trois approches de solution : Back-track ! Complexité : O ( 2^n ) Programmation dynamique ! Complexité : O ( n^2 ) Algorithme glouton ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

197 Cours d'algorithmique 8 - Intranet
Action Selection Problem L’approche gloutonne dit : Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) ! S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) } k t e E( i , j ) k 4 décembre 2006 Cours d'algorithmique 8 - Intranet

198 Cours d'algorithmique 8 - Intranet
Action Selection Problem L’approche gloutonne dit : Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) ! S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) } Considérez la tâche t avec f minimal sur E( i , j ) ! Alors : k t e E( i , j ) k l l k t e E( i , j ) k 4 décembre 2006 Cours d'algorithmique 8 - Intranet

199 Cours d'algorithmique 8 - Intranet
Action Selection Problem L’approche gloutonne dit : Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) ! S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) } Considérez la tâche t avec f minimal sur E( i , j ) ! Alors : = { t } v S( i , l ) v S( l , j ) k t e E( i , j ) k l l k t e E( i , j ) k l 4 décembre 2006 Cours d'algorithmique 8 - Intranet

200 Cours d'algorithmique 8 - Intranet
Action Selection Problem L’approche gloutonne dit : Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) ! S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) } Considérez la tâche t avec f minimal sur E( i , j ) ! Alors : = { t } v S( i , l ) v S( l , j ) = { t } v S( l , j ) k t e E( i , j ) k l l k t e E( i , j ) k l l 4 décembre 2006 Cours d'algorithmique 8 - Intranet

201 Cours d'algorithmique 8 - Intranet
Action Selection Problem Pourquoi ? Soit S( i , j ) la solution optimale pour E( i , j ) ! f d i j 4 décembre 2006 Cours d'algorithmique 8 - Intranet

202 Cours d'algorithmique 8 - Intranet
Action Selection Problem Pourquoi ? Soit S( i , j ) la solution optimale pour E( i , j ) ! Soit t = t , soit nous remplaçons t par t ! f d i t j x x l x l 4 décembre 2006 Cours d'algorithmique 8 - Intranet

203 Cours d'algorithmique 8 - Intranet
Action Selection Problem Pourquoi ? Soit S( i , j ) la solution optimale pour E( i , j ) ! Soit t = t , soit nous remplaçons t par t ! f d i t j x x l x l f d i t j l 4 décembre 2006 Cours d'algorithmique 8 - Intranet

204 Cours d'algorithmique 8 - Intranet
Action Selection Problem Pourquoi ? Soit S( i , j ) la solution optimale pour E( i , j ) ! Soit t = t , soit nous remplaçons t par t ! Bien-sûr, S( i , l ) = { } S( l , j ) f d i t j x x l x l f d i t j l 4 décembre 2006 Cours d'algorithmique 8 - Intranet

205 Cours d'algorithmique 8 - Intranet
Action Selection Problem Le code : Trier les tâches par fin croissantes d <- 0 Parcourir les tâches t par indices croissants si ( d >= d ) Prendre t d <- f sinon Ignorer t i i i i i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

206 Cours d'algorithmique 8 - Intranet
Action Selection Problem Le code : Trier les tâches par fin croissantes d <- 0 Parcourir les tâches t par indices croissants si ( d >= d ) Prendre t d <- f sinon Ignorer t i i Décision purement locale ! Décision indépendante de toutes les autres décisions ! i i i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

207 Cours d'algorithmique 8 - Intranet
Action Selection Problem Trois approches de solution : Back-track ! Complexité : O ( 2^n ) Programmation dynamique ! Complexité : O ( n^2 ) Algorithme glouton ! Complexité : O ( n ) 4 décembre 2006 Cours d'algorithmique 8 - Intranet

208 Cours d'algorithmique 8 - Intranet
Action Selection Problem Trois approches de solution : Back-track ! Complexité : O ( 2^n ) Programmation dynamique ! Complexité : O ( n^2 ) Algorithme glouton ! Complexité : O ( n ) L’algorithme glouton est souvent obtenu comme optimisation d’une programmation dynamique ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

209 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons U N D E U X I E M E E X E M P L E 4 décembre 2006 Cours d'algorithmique 8 - Intranet

210 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Définition : « n » tâches de temps unitaires ! Chaque tâche « t  » comporte une deadline « d  » et une pénalité « p  », due si la deadline est dépassée. Objectif : Trouver un ordonnancement qui minimise la somme des pénalités ! i i i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

211 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Solution : Trier les tâches par deadlines croissantes. Parcourir les tâches et retenir celles qui peuvent être exécutées dans les temps. Compléter par les autres ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

212 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Solution : Pourquoi est-ce correct ? Soit une suite optimale de tâches : ( t , , t , t , , t ) Trier les tâches par deadlines croissantes. Parcourir les tâches et retenir celles qui peuvent être exécutées dans les temps. Compléter par les autres ! 1 i i+1 n 4 décembre 2006 Cours d'algorithmique 8 - Intranet

213 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Correction : Soit une suite optimale de tâches : ( t , , t , t , , t ) avec t en retard et t à l’heure. 1 i i+1 n i i+1 4 décembre 2006 Cours d'algorithmique 8 - Intranet

214 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Correction : Soit une suite optimale de tâches : ( t , , t , t , , t ) avec t en retard et t à l’heure. On peut échanger t et t sans changer la pénalité : t plus tôt, OK, et t plus tard, OK. 1 i i+1 n i i+1 i i+1 i+1 i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

215 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Correction : Soit une suite optimale de tâches : ( t , , t , t , , t ) avec t en retard et t à l’heure. On peut échanger t et t sans changer la pénalité : t plus tôt, OK, et t plus tard, OK. Donc, il existe une solution optimale telle que : ( t’ , , t’ , t’ , , t’ ) à l’heure en retard 1 i i+1 n i i+1 i i+1 i+1 i 1 k k+1 n 4 décembre 2006 Cours d'algorithmique 8 - Intranet

216 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Correction : Dans une suite optimale, si t et t sont à l’heure et que d > d , on peut les échanger sans modifier les pénalités. i i+1 i i+1 4 décembre 2006 Cours d'algorithmique 8 - Intranet

217 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Correction : Dans une suite optimale, si t et t sont à l’heure et que d > d , on peut les échanger sans modifier les pénalités. Sans pénalité : f <= d et f <= d i i+1 i i+1 i i i+1 i+1 4 décembre 2006 Cours d'algorithmique 8 - Intranet

218 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Correction : Dans une suite optimale, si t et t sont à l’heure et que d > d , on peut les échanger sans modifier les pénalités. Sans pénalité : f <= d et f <= d Par ailleurs : f < f <= d < d . i i+1 i i+1 i i i+1 i+1 i i+1 i+1 i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

219 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Correction : Dans une suite optimale, si t et t sont à l’heure et que d > d , on peut les échanger sans modifier les pénalités. Sans pénalité : f <= d et f <= d Par ailleurs : f < f <= d < d . Donc : f < d et f < d i i+1 i i+1 i i i+1 i+1 i i+1 i+1 i i+1 i i i+1 4 décembre 2006 Cours d'algorithmique 8 - Intranet

220 Cours d'algorithmique 8 - Intranet
Task Scheduling with Penalties Correction : Dans une suite optimale, si t et t sont à l’heure et que d > d , on peut les échanger sans modifier les pénalités. Sans pénalité : f <= d et f <= d Par ailleurs : f < f <= d < d . Donc : f < d et f < d Donc, il existe une solution optimale telle que : ( t’ , , t’ , t’ , , t’ ) à l’heure et d croissants en retard CQFD. i i+1 i i+1 i i i+1 i+1 i i+1 i+1 i i+1 i i i+1 1 k k+1 n i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

221 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Une suite de décisions optimales locales conduisent à un optimum global ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet

222 Cours d'algorithmique 8 - Intranet
Algorithmes gloutons Une suite de décisions optimales locales conduit à un optimum global ! Assez souvent, une suite de décisions optimales locales ne conduit pas à 4 décembre 2006 Cours d'algorithmique 8 - Intranet

223 En particulier, pour les problèmes NP-complets ! ! !
Algorithmes gloutons En particulier, pour les problèmes NP-complets ! ! ! Une suite de décisions optimales locales conduit à un optimum global ! Assez souvent, une suite de décisions optimales locales ne conduit pas à 4 décembre 2006 Cours d'algorithmique 8 - Intranet

224 Équivalences entre programmes récursifs et
Synthèse Dérécursion (fin) : Équivalences entre programmes récursifs et programmes itératifs avec ou sans gestion de pile. Algorithmes gloutons. 4 décembre 2006 Cours d'algorithmique 8 - Intranet

225 Cours d'algorithmique 8 - Intranet
m E r C i e T b O n N e J o U r N é E ! ! ! n ‘ O u B l I e Z p A s D e p R é P a R e R v O s T D ! ! ! 4 décembre 2006 Cours d'algorithmique 8 - Intranet


Télécharger ppt "Cours d’Algorithmique"

Présentations similaires


Annonces Google