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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 1 2 3 4 d 5 3 1 2 f 7 9 4 5 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

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 1 2 3 4 d 5 3 1 2 f 7 9 4 5 i 1 2 3 4 d 1 2 5 3 f 4 5 7 9 i i i i Triées par f croissants ! i 4 décembre 2006 Cours d'algorithmique 8 - Intranet

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

É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

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