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 8 - Intranet 1 4 décembre 2006 Cours dAlgorithmique Dérécursion (fin) : Équivalences entre programmes récursifs et programmes itératifs.

Présentations similaires


Présentation au sujet: "Cours d'algorithmique 8 - Intranet 1 4 décembre 2006 Cours dAlgorithmique Dérécursion (fin) : Équivalences entre programmes récursifs et programmes itératifs."— Transcription de la présentation:

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

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

3 4 décembre 2006Cours d'algorithmique 8 - Intranet3 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 4 décembre 2006Cours d'algorithmique 8 - Intranet4 Plan Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non Appréciations !

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

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

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

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

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

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

11 4 décembre 2006Cours d'algorithmique 8 - Intranet11 Deux appels récursifs auto-enveloppés f ( acc, x ) = si ( ( acc, x ) ) si ( ( acc, x ) ) a( acc, x ) a( acc, x ) sinon sinon f( f( ( acc, x ), ( acc, x ) ), f( f( ( acc, x ), ( acc, x ) ), ( acc, x ) ) ( acc, x ) ) Nous explorons x à laide dun accumulateur acc. Le cas de base est celui des appels auto-enveloppés ! Le cas de base est celui des appels auto-enveloppés !

12 4 décembre 2006Cours d'algorithmique 8 - Intranet12 Deux appels récursifs auto-enveloppés f ( acc, x ) = si ( ( acc, x ) ) si ( ( acc, x ) ) a( acc, x ) a( acc, x ) sinon sinon f( f( ( acc, x ), ( acc, x ) ), f( f( ( acc, x ), ( acc, x ) ), ( acc, x ) ) ( acc, x ) ) Le cas darrêt. Le cas de base est celui des appels auto-enveloppés ! Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à laide dun accumulateur acc.

13 4 décembre 2006Cours d'algorithmique 8 - Intranet13 Deux appels récursifs auto-enveloppés f ( acc, x ) = si ( ( acc, x ) ) si ( ( acc, x ) ) a( acc, x ) a( acc, x ) sinon sinon f( f( ( acc, x ), ( acc, x ) ), f( f( ( acc, x ), ( acc, x ) ), ( acc, x ) ) ( acc, x ) ) Le cas darrêt. Lappel récursif interne ! Le cas de base est celui des appels auto-enveloppés ! Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à laide dun accumulateur acc.

14 4 décembre 2006Cours d'algorithmique 8 - Intranet14 Deux appels récursifs auto-enveloppés f ( acc, x ) = si ( ( acc, x ) ) si ( ( acc, x ) ) a( acc, x ) a( acc, x ) sinon sinon f( f( ( acc, x ), ( acc, x ) ), f( f( ( acc, x ), ( acc, x ) ), ( acc, x ) ) ( acc, x ) ) Le cas darrêt. Lappel récursif interne ! Lappel récursif externe ! Le cas de base est celui des appels auto-enveloppés ! Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à laide dun accumulateur acc.

15 4 décembre 2006Cours d'algorithmique 8 - Intranet15 Deux appels récursifs auto-enveloppés f ( acc, x ) = si ( ( acc, x ) ) si ( ( acc, x ) ) a( acc, x ) a( acc, x ) sinon sinon f( f( ( acc, x ), ( acc, x ) ), f( f( ( acc, x ), ( acc, x ) ), ( acc, x ) ) ( acc, x ) ) Le cas darrêt. Lappel récursif interne ! Lappel récursif externe ! Souvent, le schéma est un peu plus simple. XXXXX XXXXXXX XXXXX XXXXX Le cas de base est celui des appels auto-enveloppés ! Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à laide dun accumulateur acc.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

49 4 décembre 2006Cours d'algorithmique 8 - Intranet49 Deux appels récursifs auto-enveloppés Exprimons F à laide d elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. Exprimons F à laide 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 ) ) F( acc, p ) = si ( V( p ) ) acc acc sinon sinon x < - S( p ) x < - S( p ) p < - D( p ) p < - D( p ) F( si ( ) F( si ( ) a sinon sinon f( f(, ), ), f( f(, ), ), p ) p )

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

51 4 décembre 2006Cours d'algorithmique 8 - Intranet51 Deux appels récursifs auto-enveloppés Exprimons F à laide d elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. Exprimons F à laide 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 ) ) F( acc, p ) = si ( V( p ) ) acc acc sinon sinon x < - S( p ) x < - S( p ) p < - D( p ) p < - D( p ) si ( ) si ( ) F( a, p ) F( a, p ) sinon sinon F( f( f(, ), ), p ) F( f( f(, ), ), p )

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

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

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

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

56 4 décembre 2006Cours d'algorithmique 8 - Intranet56 Deux appels récursifs auto-enveloppés Exprimons F à laide d elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile. Exprimons F à laide 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 ) ) F( acc, p ) = si ( V( p ) ) acc acc sinon sinon x < - S( p ) x < - S( p ) p < - D( p ) p < - D( p ) si ( ) si ( ) F( a, p ) F( a, p ) sinon sinon F(, E( E(, p ) ) ) F(, E( E(, p ) ) )

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

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

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

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

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

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

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

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

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

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

67 4 décembre 2006Cours d'algorithmique 8 - Intranet67 Sous forme darbre

68 4 décembre 2006Cours d'algorithmique 8 - Intranet68 Sous forme darbre Dans la pile ! X Y ZT X Z T Y

69 4 décembre 2006Cours d'algorithmique 8 - Intranet69 Sous forme darbre Dans la pile ! X Y ZT X Z T k l Dans laccumulateur : acc = ( ( 0 + k ) + l ) Y

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

111 4 décembre 2006Cours d'algorithmique 8 - Intranet111 Deux appels récursifs, enveloppe non associative Cest le cas le plus compliqué à gérer ! Cest le cas le plus compliqué à gérer ! Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre :

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

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

114 4 décembre 2006Cours d'algorithmique 8 - Intranet114 Deux appels récursifs, enveloppe non associative Cest le cas le plus compliqué à gérer ! Cest le cas le plus compliqué à gérer ! Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Traitements en attente ! X Z l Y Noeud courant Résultats en attente ! La pile ! X Y Z k k l

115 4 décembre 2006Cours d'algorithmique 8 - Intranet115 Deux appels récursifs, enveloppe non associative Cest le cas le plus compliqué à gérer ! Cest le cas le plus compliqué à gérer ! Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Traitements en attente ! X Z T Y Noeud courant Résultats en attente ! La pile ! X Y Z X X T

116 4 décembre 2006Cours d'algorithmique 8 - Intranet116 Deux appels récursifs, enveloppe non associative Cest le cas le plus compliqué à gérer ! Cest le cas le plus compliqué à gérer ! Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Traitements en attente ! X Z T Y Noeud courant Résultats en attente ! La pile ! X Y Z X X T

117 4 décembre 2006Cours d'algorithmique 8 - Intranet117 Deux appels récursifs, enveloppe non associative Cest le cas le plus compliqué à gérer ! Cest le cas le plus compliqué à gérer ! Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Comme lenveloppe nest pas associative, nous devons respecter la structure de larbre : Traitements en attente ! X Z T Y Noeud courant Résultats en attente ! La pile ! X Y Z X X T

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

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

120 4 décembre 2006Cours d'algorithmique 8 - Intranet120 Deux appels récursifs, enveloppe non associative Nous avons quatre variables globales : 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.

121 4 décembre 2006Cours d'algorithmique 8 - Intranet121 Deux appels récursifs, enveloppe non associative Nous avons quatre variables globales : 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 : Nous distinguons deux types de traitements : – cas 1 – la variable « x » ne vérifie pas le test darrêt, – cas 2 – la variable « x » vérifie le test darrêt.

122 4 décembre 2006Cours d'algorithmique 8 - Intranet122 Deux appels récursifs, enveloppe non associative Cas 1 - la variable « x » ne vérifie pas le test darrêt : Cas 1 - la variable « x » ne vérifie pas le test darrêt : – lappel « f( x ) » engendre les appels « f( ( x ) ) » et « f( ( x ) ) »,

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

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

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

126 4 décembre 2006Cours d'algorithmique 8 - Intranet126 Deux appels récursifs, enveloppe non associative Cas 2 - la variable « x » vérifie le test darrêt : Cas 2 - la variable « x » vérifie le test darrêt : – lappel « 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

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

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

129 4 décembre 2006Cours d'algorithmique 8 - Intranet129 Deux appels récursifs, enveloppe non associative Dès quil y a un résultat « res », nous inspectons la pile : Dès quil y a un résultat « res », nous inspectons la pile : Trois cas se présentent pour 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.

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

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

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

133 4 décembre 2006Cours d'algorithmique 8 - Intranet133 Deux appels récursifs, enveloppe non associative X... C X C R res Cas 4 – nous avons « res » et « C » avec « X » sur la pile : 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.

134 4 décembre 2006Cours d'algorithmique 8 - Intranet134 Deux appels récursifs, enveloppe non associative X... C X C R res Cas 4 – nous avons « res » et « C » avec « X » sur la pile : 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 : Nous allons donc : – dépiler « X » pour le traiter, –...

135 4 décembre 2006Cours d'algorithmique 8 - Intranet135 Deux appels récursifs, enveloppe non associative X... C X C R res Cas 4 – nous avons « res » et « C » avec « X » sur la pile : 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 : Nous allons donc : – dépiler « X » pour le traiter, –... marq <- S( p ) p <- D( p ) x <- S( p ) p <- D( p ) goto CALCUL

136 4 décembre 2006Cours d'algorithmique 8 - Intranet136 Deux appels récursifs, enveloppe non associative Cas 4 – nous avons « res » et « C » avec « X » sur la pile : 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 : Nous allons donc : – dépiler « X » pour le traiter, – sauver « res » sur la pile. marq <- S( p ) p <- D( p ) x <- S( p ) p <- D( p ) p <- E( res, p ) p <- E( R, p ) goto CALCUL X... C res R X C R res

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

138 4 décembre 2006Cours d'algorithmique 8 - Intranet138 Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : 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. a... R res R R a

139 4 décembre 2006Cours d'algorithmique 8 - Intranet139 Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : 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 : Nous allons donc : – dépiler « a » pour le combiner avec « res » et combiner avec « res » et –... a... R res R R a

140 4 décembre 2006Cours d'algorithmique 8 - Intranet140 Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : 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 : Nous allons donc : – dépiler « a » pour le combiner avec « res » et combiner avec « res » et –... a... R res R R a marq <- S( p ) p <- D( p ) res <- h( S( p ), res ) p <- D( p )...

141 4 décembre 2006Cours d'algorithmique 8 - Intranet141 Deux appels récursifs, enveloppe non associative Cas 5 – nous avons « res » et « R » avec « a » sur la pile : 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 : Nous allons donc : – dépiler « a » pour le combiner avec « res » et combiner avec « res » et – continuer linspection de pile. a... R res R R a marq <- S( p ) p <- D( p ) res <- h( S( p ), res ) p <- D( p ) goto PILE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

159 4 décembre 2006Cours d'algorithmique 8 - Intranet159 Les quatre cas à unique appel récursif : 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 : Les quatre cas à deux appels récursifs : – Récursif auto-enveloppé. – Enveloppe associative avec neutre. – Enveloppe associative sans neutre. – Enveloppe non associative. Résumé général Se ramène à …

160 4 décembre 2006Cours d'algorithmique 8 - Intranet160 Résumé général Se ramène à … Les quatre cas à unique appel récursif : 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 : Les quatre cas à deux appels récursifs : – Récursif auto-enveloppé. – Enveloppe associative avec neutre. – Enveloppe associative sans neutre. – Enveloppe non associative.

161 4 décembre 2006Cours d'algorithmique 8 - Intranet161 Résumé général Récursif ! Se ramène à … Les quatre cas à unique appel récursif : 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 : Les quatre cas à deux appels récursifs : – Récursif auto-enveloppé. – Enveloppe associative avec neutre. – Enveloppe associative sans neutre. – Enveloppe non associative.

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

163 4 décembre 2006Cours d'algorithmique 8 - Intranet163 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 ! ! !

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

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

166 4 décembre 2006Cours d'algorithmique 8 - Intranet166 Algorithmes gloutons Greedy algorithms en anglais ! Greedy algorithms en anglais ! Une suite de décisions optimales locales Une suite de décisions optimales locales conduit à conduit à un optimum global ! un optimum global ! Complexité pour « n » éléments : 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

167 4 décembre 2006Cours d'algorithmique 8 - Intranet167 Algorithmes gloutons Exemple dun choix glouton : Exemple dun choix glouton : – GLOBAL : Choisir les 10 plus petits de lamphi !

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

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

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

171 4 décembre 2006Cours d'algorithmique 8 - Intranet171 Action Selection Problem Un exemple complet : 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 ! ! ! tâches compatibles ! ! ! i j

172 4 décembre 2006Cours d'algorithmique 8 - Intranet172 Action Selection Problem Un exemple complet : 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 ! ! ! tâches compatibles ! ! ! i j i d f i i La première tâche dure de 5 à 7. La deuxième tâche dure de 3 à 9.

173 4 décembre 2006Cours d'algorithmique 8 - Intranet173 Action Selection Problem Un exemple complet : 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 ! ! ! tâches compatibles ! ! ! i j i d f i i i d f i i Triées par f croissants ! i

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

197 4 décembre 2006Cours d'algorithmique 8 - Intranet197 Action Selection Problem Lapproche gloutonne dit : Lapproche gloutonne dit : – Ce nest 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 ) } t E( i, j ) k k

198 4 décembre 2006Cours d'algorithmique 8 - Intranet198 Action Selection Problem Lapproche gloutonne dit : Lapproche gloutonne dit : – Ce nest 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 : Considérez la tâche t avec f minimal sur E( i, j ) ! Alors : – S( i, j ) = max_ens { { t } v S( i, k ) v S( k, j ) } t E( i, j ) k l k l k k

199 4 décembre 2006Cours d'algorithmique 8 - Intranet199 Action Selection Problem Lapproche gloutonne dit : Lapproche gloutonne dit : – Ce nest 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 : Considérez la tâche t avec f minimal sur E( i, j ) ! Alors : – S( i, j ) = max_ens { { t } v S( i, k ) v S( k, j ) } = { t } v S( i, l ) v S( l, j ) = { t } v S( i, l ) v S( l, j ) t E( i, j ) k l k l k k l

200 4 décembre 2006Cours d'algorithmique 8 - Intranet200 Action Selection Problem Lapproche gloutonne dit : Lapproche gloutonne dit : – Ce nest 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 : Considérez la tâche t avec f minimal sur E( i, j ) ! Alors : – S( i, j ) = max_ens { { t } v S( i, k ) v S( k, j ) } = { t } v S( i, l ) v S( l, j ) = { t } v S( i, l ) v S( l, j ) = { t } v S( l, j ) = { t } v S( l, j ) t E( i, j ) k l k l k k l l

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

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

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

204 4 décembre 2006Cours d'algorithmique 8 - Intranet204 x Action Selection Problem Pourquoi ? 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 ) d j f i t xlxl l d j f i t

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

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

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

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

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

210 4 décembre 2006Cours d'algorithmique 8 - Intranet210 Task Scheduling with Penalties Définition : 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. 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 ii

211 4 décembre 2006Cours d'algorithmique 8 - Intranet211 Task Scheduling with Penalties Solution : 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 !

212 4 décembre 2006Cours d'algorithmique 8 - Intranet212 Task Scheduling with Penalties Solution : Solution : Pourquoi est-ce correct ? Pourquoi est-ce correct ? – Soit une suite optimale de tâches : ( t,..., t, t,..., t ) ( 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 ! i+1 1 n i

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

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

215 4 décembre 2006Cours d'algorithmique 8 - Intranet215 Task Scheduling with Penalties Correction : Correction : – Soit une suite optimale de tâches : ( t,..., t, t,..., t ) ( t,..., t, t,..., t ) avec t en retard et t à lheure. avec t en retard et t à lheure. On peut échanger t et t sans changer la pénalité : 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 : Donc, il existe une solution optimale telle que : ( t,..., t, t,..., t ) ( t,..., t, t,..., t ) à lheure en retard à lheure en retard i+1 1 n i ii+1 ii+1 i i+1 k+11 n k

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

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

218 4 décembre 2006Cours d'algorithmique 8 - Intranet218 Task Scheduling with Penalties Correction : Correction : – Dans une suite optimale, si t et t sont à lheure et que d > d, on peut les échanger sans modifier les pénalités. 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+1 i ii+1 ii+1 i ii+1 ii+1i+1

219 4 décembre 2006Cours d'algorithmique 8 - Intranet219 Task Scheduling with Penalties Correction : Correction : – Dans une suite optimale, si t et t sont à lheure et que d > d, on peut les échanger sans modifier les pénalités. 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+1 i ii+1 ii+1 i i+1 ii+1 ii+1i+1 i+1ii

220 4 décembre 2006Cours d'algorithmique 8 - Intranet220 Task Scheduling with Penalties Correction : Correction : – Dans une suite optimale, si t et t sont à lheure et que d > d, on peut les échanger sans modifier les pénalités. 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 : Donc, il existe une solution optimale telle que : ( t,..., t, t,..., t ) ( t,..., t, t,..., t ) à lheure et d croissants en retard CQFD. i+1 i ii+1 ii+1 i i+1 ii+1 ii+1i+1 i+1ii k+11 n k i

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

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

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

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

225 4 décembre 2006Cours d'algorithmique 8 - Intranet225 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 ! ! !


Télécharger ppt "Cours d'algorithmique 8 - Intranet 1 4 décembre 2006 Cours dAlgorithmique Dérécursion (fin) : Équivalences entre programmes récursifs et programmes itératifs."

Présentations similaires


Annonces Google