1 / 218

Cours d’Algorithmique

Cours d’Algorithmique. Dérécursion (fin) : Équivalences entre programmes récursifs et programmes itératifs avec ou sans gestion de pile. Algorithmes gloutons. Les grandes lignes du cours. Trier et chercher, recherche textuelle Listes et arbres Le back-track Arbres équilibrés

chipo
Download Presentation

Cours d’Algorithmique

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  2. Les grandes lignes du cours • Trier et chercher, recherche textuelle • Listes et arbres • Le back-track • Arbres équilibrés • Récursivité et induction sur la structure • Divide and conquer, algorithmes gloutons • Minimax, alpha-beta • Dérécursion • NP-complétude • Logique de Hoare • Programmation dynamique • Complexité et calculabilité Cours d'algorithmique 8 - Intranet

  3. Deux appels récursifs----------------------------------------------------------------- D i S c U s S i O n D e S d I v E r S • 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 Cours d'algorithmique 8 - Intranet

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

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

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

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

  8. Deux appels récursifs auto-enveloppés----------------------------------------------------------------- • Le cas de base est celui des appels auto-enveloppés ! Cours d'algorithmique 8 - Intranet

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  31. Deux appels récursifs auto-enveloppés----------------------------------------------------------------- • Nous avons : F( acc , E( v , I( ) ) ) Cours d'algorithmique 8 - Intranet

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

More Related