Cours d algorithmique
Download
1 / 218

Cours d’Algorithmique - PowerPoint PPT Presentation


  • 159 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Cours d’Algorithmique' - chipo


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
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.

Cours d'algorithmique 8 - Intranet


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


Deux appels r cursifs
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


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


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


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


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


Deux appels r cursifs auto envelopp s
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Le cas de base est celui des appels auto-enveloppés !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s1
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


Deux appels r cursifs auto envelopp s2
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


Deux appels r cursifs auto envelopp s3
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


Deux appels r cursifs auto envelopp s4
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


Deux appels r cursifs auto envelopp s5
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


Deux appels r cursifs auto envelopp s6
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


Deux appels r cursifs auto envelopp s7
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


Deux appels r cursifs auto envelopp s8
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


Deux appels r cursifs auto envelopp s9
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


Deux appels r cursifs auto envelopp s10
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


Deux appels r cursifs auto envelopp s11
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


Deux appels r cursifs auto envelopp s12
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


Deux appels r cursifs auto envelopp s13
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


Deux appels r cursifs auto envelopp s14
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


Deux appels r cursifs auto envelopp s15
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


Deux appels r cursifs auto envelopp s16
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


Deux appels r cursifs auto envelopp s17
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


Deux appels r cursifs auto envelopp s18
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


Deux appels r cursifs auto envelopp s19
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


Deux appels r cursifs auto envelopp s20
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


Deux appels r cursifs auto envelopp s21
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


Deux appels r cursifs auto envelopp s22
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


Deux appels r cursifs auto envelopp s23
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Nous avons :

    F( acc , E( v , I( ) ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s24
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


Deux appels r cursifs auto envelopp s25
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


Deux appels r cursifs auto envelopp s26
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


Deux appels r cursifs auto envelopp s27
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


Deux appels r cursifs auto envelopp s28
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


Deux appels r cursifs auto envelopp s29
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


Deux appels r cursifs auto envelopp s30
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


Deux appels r cursifs auto envelopp s31
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Nous avons plus généralement :

    F( acc , E( v , p ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s32
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


Deux appels r cursifs auto envelopp s33
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


Deux appels r cursifs auto envelopp s34
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


Deux appels r cursifs auto envelopp s35
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


Deux appels r cursifs auto envelopp s36
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


Deux appels r cursifs auto envelopp s37
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


Deux appels r cursifs auto envelopp s38
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


Deux appels r cursifs auto envelopp s39
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


Deux appels r cursifs auto envelopp s40
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


Deux appels r cursifs auto envelopp s41
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


Deux appels r cursifs auto envelopp s42
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


Deux appels r cursifs auto envelopp s43
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 )

  • Utilisons :

    F( acc , E( v , p ) ) = F( f( acc , v ) , p )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s44
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 )

    F( f( t , a ) , E(b , p ) )

  • Utilisons :

    F( acc , E( v , p ) ) = F( f( acc , v ) , p )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s45
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 )

    F( f( t , a ) , E(b , p ) )

  • Utilisons :

    F( acc , E( v , p ) ) = F( f( acc , v ) , p )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s46
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 )

    F( f( t , a ) , E(b , p ) )

    F( t , E( a , E(b , p ) ) )

  • Utilisons :

    F( acc , E( v , p ) ) = F( f( acc , v ) , p )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s47
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( t , E( a , E( b , p ) ) )

F est récursive terminale !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s48
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Pour un appel res <- f( init , v ) nous obtenons le code :

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s49
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Pour un appel res <- f( init , v ) nous obtenons le code :

Initialisation de acc et p !

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s50
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Pour un appel res <- f( init , v ) nous obtenons le code :

Initialisation de acc et p !

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

Le prochain élément

est prélevé sur la pile !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s51
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Pour un appel res <- f( init , v ) nous obtenons le code :

Initialisation de acc et p !

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

Le prochain élément

est prélevé sur la pile !

S’il est élémentaire,

nous l’accumulons !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s52
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Pour un appel res <- f( init , v ) nous obtenons le code :

Initialisation de acc et p !

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

Le prochain élément

est prélevé sur la pile !

S’il est élémentaire,

nous l’accumulons !

Sinon, nous empilons

les deux fils et nous

recommençons !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s53
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Pour un appel res <- f( init , v ) nous obtenons le code :

Initialisation de acc et p !

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

Le prochain élément

est prélevé sur la pile !

S’il est élémentaire,

nous l’accumulons !

Sinon, nous empilons

les deux fils et nous

recommençons !

Le résultat final est dans acc !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s54
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • Pour des appels auto-enveloppés, nous avons :

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

res <- f( init , v )

f ( acc , x ) =

si ( P( acc , x ) )

a( acc , x )

sinon

f( f( t( acc , x ) ,

a( acc , x ) ) ,

b( acc , x ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs auto envelopp s55
Deux appels récursifs auto-enveloppés-----------------------------------------------------------------

  • L’équivalence se généralise à 3 ou plus d’arguments pour f :

acc <- init

p <- E( w , I( ) )

p <- E( v , p )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

y <- S( p )

p <- D( p )

si ( P( acc , x , y ) )

acc <- a( acc , x , y )

sinon

p <- E( d( acc , x , y ) , p )

p <- E( b( acc , x , y ) , p )

p <- E( g( acc , x , y ) , p )

p <- E( a( acc , x , y ) , p )

acc <- t( acc , x , y )

res <- acc

res <- f( init , v , w )

f ( acc , x , y ) =

si ( P( acc , x , y ) )

a( acc , x , y )

sinon

f( f( t( acc , x , y ) ,

a( acc , x , y ) ,

g( acc , x , y ) ) ,

b( acc , x , y ) ,

d( acc , x , y ) )

Cours d'algorithmique 8 - Intranet


Res somme rec 0 arbre
res <-somme_rec( 0 , arbre ) -----------------------------------------------------------------

somme_rec( acc , arbre ) =

si ( feuille( arb ) )

acc + valeur( arbre )

sinon

somme_rec( somme_rec( acc , fg( arbre ) ) , fd( arbre ) )

Cours d'algorithmique 8 - Intranet


Res somme rec 0 arbre1
res <-somme_rec( 0 , arbre ) -----------------------------------------------------------------

somme_rec( acc , arbre ) =

si ( feuille( arb ) )

acc + valeur( arbre )

sinon

somme_rec( somme_rec( acc , fg( arbre ) ) , fd( arbre ) )

acc <- 0

p <- E( arbre , I( ) )

while ( ù V( p ) )

arbre <- S( p )

p <- D( p )

si ( feuille ( arbre ) )

acc <- acc + valeur( arbre )

sinon

p <- E( fd( arbre ) , p )

p <- E( fg( arbre ) , p )

res <- acc

Cours d'algorithmique 8 - Intranet


Sous forme d arbre
Sous forme d’arbre-----------------------------------------------------------------

Cours d'algorithmique 8 - Intranet


Sous forme d arbre1
Sous forme d’arbre-----------------------------------------------------------------

Dans la pile !

X

Y

T

Z

Y

T

Z

X

Cours d'algorithmique 8 - Intranet


Sous forme d arbre2
Sous forme d’arbre-----------------------------------------------------------------

Dans l’accumulateur :

acc = ( ( 0 + k ) + l )

Dans la pile !

X

Y

T

k

Z

l

Y

T

Z

X

Cours d'algorithmique 8 - Intranet


Sous forme d arbre3
Sous forme d’arbre-----------------------------------------------------------------

Dans l’accumulateur :

acc = ( ( 0 + k ) + l )

Dans la pile !

X

Y

arbre <- S( p )

p <- D( p )

T

k

Z

l

Y

T

Z

X

Cours d'algorithmique 8 - Intranet


Sous forme d arbre4
Sous forme d’arbre-----------------------------------------------------------------

Dans l’accumulateur :

acc = ( ( 0 + k ) + l )

Dans la pile !

X

Y

arbre <- S( p )

p <- D( p )

k

Z

l

Y

arbre = T

Z

X

Cours d'algorithmique 8 - Intranet


Sous forme d arbre5
Sous forme d’arbre-----------------------------------------------------------------

Dans l’accumulateur :

acc = ( ( 0 + k ) + l )

Dans la pile !

X

Y

arbre <- S( p )

p <- D( p )

k

Z

Premier cas :

feuille( arbre ) est vrai

et valeur( arbre ) = m

l

Y

arbre = T

Z

X

Cours d'algorithmique 8 - Intranet


Sous forme d arbre6
Sous forme d’arbre-----------------------------------------------------------------

Dans l’accumulateur :

acc = ( ( 0 + k ) + l )

Dans la pile !

X

Y

arbre <- S( p )

p <- D( p )

k

Z

Premier cas :

feuille( arbre ) est vrai

et valeur( arbre ) = m

l

Y

arbre = T

Z

X

m

acc = ( ( ( 0 + k ) + l ) + m )

Cours d'algorithmique 8 - Intranet


Sous forme d arbre7
Sous forme d’arbre-----------------------------------------------------------------

Dans l’accumulateur :

acc = ( ( 0 + k ) + l )

Dans la pile !

X

Y

arbre <- S( p )

p <- D( p )

k

Z

Second cas :

feuille( arbre ) est faux

et fg( arbre ) = U

et fd( arbre ) = V

l

Y

arbre = T

Z

X

Cours d'algorithmique 8 - Intranet


Sous forme d arbre8
Sous forme d’arbre-----------------------------------------------------------------

Dans l’accumulateur :

acc = ( ( 0 + k ) + l )

Dans la pile !

X

U

Y

arbre <- S( p )

p <- D( p )

V

k

Z

Second cas :

feuille( arbre ) est faux

et fg( arbre ) = U

et fd( arbre ) = V

l

Y

Z

X

U

V

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Soient deux appels récursifs avec une enveloppe associative !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative1
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Soient deux appels récursifs avec une enveloppe associative !

  • La forme générale est la suivante :

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) , f( b( x ) ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative2
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Soient deux appels récursifs avec une enveloppe associative !

  • La forme générale est la suivante :

  • Le flot des informations est le suivant :

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) , f( b( x ) ) )

h

x

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative3
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative4
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , f( x ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative5
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , f( x ) )

« f » est remplacée

par sa définition !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative6
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , si ( P( x ) )

    a( x )

    sinon

    h( f( a( x ) ) , f( b( x ) ) ) )

« f » est remplacée

par sa définition !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative7
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , si ( P( x ) )

    a( x )

    sinon

    h( f( a( x ) ) , f( b( x ) ) ) )

    = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    h( acc , h( f( a( x ) ) , f( b( x ) ) ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative8
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , si ( P( x ) )

    a( x )

    sinon

    h( f( a( x ) ) , f( b( x ) ) ) )

    = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    h( acc , h( f( a( x ) ) , f( b( x ) ) ) )

Associativité de h!

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative9
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , si ( P( x ) )

    a( x )

    sinon

    h( f( a( x ) ) , f( b( x ) ) ) )

    = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    h( acc , h( f( a( x ) ) , f( b( x ) ) ) )

    h( h( acc , f( a( x ) ) ) , f( b( x ) ) )

Associativité de h!

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative10
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , si ( P( x ) )

    a( x )

    sinon

    h( f( a( x ) ) , f( b( x ) ) ) )

    = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    h( acc , h( f( a( x ) ) , f( b( x ) ) ) )

    h( h( acc , f( a( x ) ) ) , f( b( x ) ) )

Associativité de h!

Définition de g !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative11
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , si ( P( x ) )

    a( x )

    sinon

    h( f( a( x ) ) , f( b( x ) ) ) )

    = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    h( acc , h( f( a( x ) ) , f( b( x ) ) ) )

    h( h( acc , f( a( x ) ) ) , f( b( x ) ) )

    h( g( acc , a( x ) ) , f( b( x ) ) )

Associativité de h!

Définition de g !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative12
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , si ( P( x ) )

    a( x )

    sinon

    h( f( a( x ) ) , f( b( x ) ) ) )

    = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    h( acc , h( f( a( x ) ) , f( b( x ) ) ) )

    h( h( acc , f( a( x ) ) ) , f( b( x ) ) )

    h( g( acc , a( x ) ) , f( b( x ) ) )

Associativité de h!

Définition de g !

Définition de g !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative13
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = h( acc , si ( P( x ) )

    a( x )

    sinon

    h( f( a( x ) ) , f( b( x ) ) ) )

    = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    h( acc , h( f( a( x ) ) , f( b( x ) ) ) )

    h( h( acc , f( a( x ) ) ) , f( b( x ) ) )

    h( g( acc , a( x ) ) , f( b( x ) ) )

    g( g( acc , a( x ) ) , b( x ) )

Associativité de h!

Définition de g !

Définition de g !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative14
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    g( g( acc , a( x ) ) , b( x ) )

Nous sommes donc

revenus au cas d’une

fonction auto-enveloppée !

et donc ...

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative15
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Nous nous ramenons au cas auto-enveloppé en posant :

    g( acc , x ) = h( acc , f( x ) )

  • Alors :

    g( acc , x ) = si ( P( x ) )

    h( acc , a( x ) )

    sinon

    g( g( acc , a( x ) ) , b( x ) )

  • Le flot des informations a changé :

Nous sommes donc

revenus au cas d’une

fonction auto-enveloppée !

et donc ...

h

acc

x

x

Cours d'algorithmique 8 - Intranet


Sous forme d arbre9
Sous forme d’arbre-----------------------------------------------------------------

Schéma h( f( a( x ) ) , f( b( x ) ) )

X

Y

Résultats

en attente !

Traitements

en attente !

k

l

Z

m

Noeud courant

Cours d'algorithmique 8 - Intranet


Sous forme d arbre10
Sous forme d’arbre-----------------------------------------------------------------

Schéma h( f( a( x ) ) , f( b( x ) ) )

Schéma g( g( acc , a( x ) ) , b( x ) )

X

Y

Résultats

en attente !

Traitements

en attente !

k

l

Tout ceci dans

l’accumulateur ! ! !

Z

m

Noeud courant

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative16
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Si « h » a un neutre « e », l’initialisation est immédiate :

    g( e , v ) = h( e , f( v ) ) = f( v )

  • Le code :

acc <- e

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative17
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Pour deux appels avec une enveloppe « h » associative avec neutre « e », nous avons :

acc <- e

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

res <- f( v )

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) ,

f( b( x ) ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative18
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • L’équivalence se généralise à 2 ou plus d’arguments pour f :

acc <- e

p <- E( w , I( ) )

p <- E( v , p )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

y <- S( p )

p <- D( p )

si ( P( x , y ) )

acc <- h( acc , a( x , y ) )

sinon

p <- E( d( x ) , p )

p <- E( b( x ) , p )

p <- E( g( x ) , p )

p <- E( a( x ) , p )

res <- acc

res <- f( v , w )

f ( x , y ) =

si ( P( x , y ) )

a( x , y )

sinon

h( f( a( x , y) ,

g( x , y ) ) ,

f( b( x , y ) ,

d( x , y ) ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative19
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Si « h » est sans neutre, c’est plus embêtant.

  • Il faut traiter la première feuille à part !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative20
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Si « h » est sans neutre, c’est plus embêtant.

  • Il faut traiter la première feuille à part !

A

B

. . .

Tout ceci

dans la pile !

feuille

K

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative21
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

x <- v

p <- I( )

while ( ù ( P( x ) )

p <- E( b( x ) , p )

x <- a( x )

acc <- a( x )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

  • Si « h » est sans neutre, c’est plus embêtant.

  • Le code :

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative22
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

x <- v

p <- I( )

while ( ù ( P( x ) )

p <- E( b( x ) , p )

x <- a( x )

acc <- a( x )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

  • Si « h » est sans neutre, c’est plus embêtant.

  • Le code :

L’initialisation est triviale !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative23
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

x <- v

p <- I( )

while ( ù ( P( x ) )

p <- E( b( x ) , p )

x <- a( x )

acc <- a( x )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

  • Si « h » est sans neutre, c’est plus embêtant.

  • Le code :

L’initialisation est triviale !

La descente à gauche vers

la première feuille . Nous

empilons les fils droits.

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative24
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

x <- v

p <- I( )

while ( ù ( P( x ) )

p <- E( b( x ) , p )

x <- a( x )

acc <- a( x )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

  • Si « h » est sans neutre, c’est plus embêtant.

  • Le code :

L’initialisation est triviale !

La descente à gauche vers

la première feuille . Nous

empilons les fils droits.

Finalement, nous pouvons

initialiser l’accumulateur !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative25
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

x <- v

p <- I( )

while ( ù ( P( x ) )

p <- E( b( x ) , p )

x <- a( x )

acc <- a( x )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

  • Si « h » est sans neutre, c’est plus embêtant.

  • Le code :

L’initialisation est triviale !

La descente à gauche vers

la première feuille . Nous

empilons les fils droits.

Finalement, nous pouvons

Initialiser l’accumulateur !

Le reste ne change pas ! ! !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative26
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

  • Pour deux appels avec une enveloppe « h » associative sans neutre, nous avons :

x <- v

p <- I( )

while ( ù ( P( x ) )

p <- E( b( x ) , p )

x <- a( x )

acc <- a( x )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

res <- f( v )

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) ,

f( b( x ) ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe associative27
Deux appels récursifs, enveloppe associative-----------------------------------------------------------------

x <- v ; y <- w ; p <- I( )

while ( ù ( P( x , y ) )

p <- E( d( x , y ) , p )

p <- E( b( x , y ) , p )

m <- a( x , y )

y <- g( x , y )

x <- m

acc <- a( x , y )

while ( ù V( p ) )

x <- S( p ) ; p <- D( p )

y <- S( p ) ; p <- D( p )

si ( P( x , y ) )

acc <- h( acc , a( x , y ) )

sinon

p <- E( d( x , y ) , p )

p <- E( b( x , y ) , p )

p <- E( g( x , y ) , p )

p <- E( a( x , y ) , p )

res <- acc

  • L’équivalence se généralise à 2 ou plus d’arguments pour f :

res <- f( v , w )

f ( x , y ) =

si ( P( x , y ) )

a( x , y )

sinon

h( f( a( x , y) ,

g( x , y ) ) ,

f( b( x , y ) ,

d( x , y ) ) )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • C’est le cas le plus compliqué à gérer !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative1
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • C’est le cas le plus compliqué à gérer !

  • Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre :

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative2
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • C’est le cas le plus compliqué à gérer !

  • Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre :

Résultats

en attente !

X

k

Traitements

en attente !

Y

Z

l

Noeud courant

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative3
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • C’est le cas le plus compliqué à gérer !

  • Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre :

Résultats

en attente !

X

l

k

Traitements

en attente !

Z

Y

Y

Z

k

l

X

Noeud courant

La pile !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative4
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • C’est le cas le plus compliqué à gérer !

  • Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre :

Résultats

en attente !

X

l

k

On mélange tout !

Traitements

en attente !

Z

Y

Y

Z

k

l

X

Noeud courant

La pile !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative5
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • C’est le cas le plus compliqué à gérer !

  • Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre :

Résultats

en attente !

X

T

X

On mélange tout !

Traitements

en attente !

Z

Y

Y

Z

X

T

X

Noeud courant

La pile !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative6
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • C’est le cas le plus compliqué à gérer !

  • Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre :

Résultats

en attente !

X

T

X

On mélange tout !

Traitements

en attente !

Z

Y

Y

Z

X

?????

T

X

Noeud courant

La pile !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative7
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • C’est le cas le plus compliqué à gérer !

  • Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre :

Il faut un marqueur !

Résultats

en attente !

X

T

X

On mélange tout !

Traitements

en attente !

Z

Y

Y

Z

X

?????

T

X

Noeud courant

La pile !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative8
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Nous allons toujours empiler des paires d’informations :

    • soit, un calcul « X » à faire et le marqueur« C »,

    • soit, un résultat « res » et le marqueur « R ».

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative9
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Nous allons toujours empiler des paires d’informations :

    • soit, un calcul « X » à faire et le marqueur« C »,

    • soit, un résultat « res » et le marqueur « R ».

C

Y

R

Y

X

X

C

X

X

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative10
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Nous avons quatre variables globales :

    • la variable « x » qui indique l’élément à traiter,

    • la variable « res » qui indique le résultat courant,

    • la variable « marq » qui est la valeur du dernier marqueur,

    • la variable « p » qui est la pile courante.

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative11
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Nous avons quatre variables globales :

    • la variable « x » qui indique l’élément à traiter,

    • la variable « res » qui indique le résultat courant,

    • la variable « marq » qui est la valeur du dernier marqueur,

    • la variable « p » qui est la pile courante.

  • Nous distinguons deux types de traitements :

    • cas 1 – la variable « x » ne vérifie pas le test d’arrêt,

    • cas 2 – la variable « x » vérifie le test d’arrêt.

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative12
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 1 - la variable « x » ne vérifie pas le test d’arrêt :

    • l’appel « f( x ) » engendre les appels « f( a( x ) ) » et « f( b( x ) ) »,

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative13
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 1 - la variable « x » ne vérifie pas le test d’arrêt :

    • l’appel « f( x ) » engendre les appels « f( a( x ) ) » et « f( b( x ) ) »,

    • nous allons empiler «  b( x ) » et

    • traiter tout de suite « a( x ) ».

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative14
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 1 - la variable « x » ne vérifie pas le test d’arrêt :

    • l’appel « f( x ) » engendre les appels « f( a( x ) ) » et « f( b( x ) ) »,

    • nous allons empiler «  b( x ) » et

    • traiter tout de suite « a( x ) ».

p <- E( b( x ) , p )

p <- E( C , p )

x <- a( x )

goto CALCUL

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative15
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 2 - la variable « x » vérifie le test d’arrêt :

    • l’appel « f( x ) » engendre le résultat « a( x ) » et

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative16
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 2 - la variable « x » vérifie le test d’arrêt :

    • l’appel « f( x ) » engendre le résultat « a( x ) » et

    • nous inspectons la pile pour déterminer la suite des calculs.

res <- a( x )

goto PILE

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative17
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Fusion des cas 1 & 2 - la variable « x » doit être traitée :

CALCUL :

si ( P( x ) )

res <- a( x )

goto PILE

sinon

p <- E( b( x ) , p )

p <- E( C , p )

x <- a( x )

goto CALCUL

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative18
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Fusion des cas 1 & 2 - la variable « x » doit être traitée :

CALCUL :

si ( P( x ) )

res <- a( x )

goto PILE

sinon

p <- E( b( x ) , p )

p <- E( C , p )

x <- a( x )

goto CALCUL

Une sortie !

Une

boucle !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative19
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Dès qu’il y a un résultat « res », nous inspectons la pile :

  • Trois cas se présentent pour la pile :

    • cas 3 – elle est vide,

    • cas 4 – elle a un marqueur « C » au sommet et

    • cas 5 – elle a un marqueur « R » au sommet.

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative20
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 3 – nous avons « res » et une pile vide :

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative21
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 3 – nous avons « res » et une pile vide :

    • « res » est le résultat final et

    • nous avons terminé les calculs.

goto FIN

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative22
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 4 – nous avons « res » et « C » avec « X » sur la pile :

C

X

. . .

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative23
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 4 – nous avons « res » et « C » avec « X » sur la pile :

    • « res » est le résultat du fils gauche et

    • « X » est le fils droit en attente.

C

X

. . .

R

C

res

X

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative24
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 4 – nous avons « res » et « C » avec « X » sur la pile :

    • « res » est le résultat du fils gauche et

    • « X » est le fils droit en attente.

  • Nous allons donc :

    • dépiler « X » pour le traiter,

    • . . .

C

X

. . .

R

C

res

X

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative25
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 4 – nous avons « res » et « C » avec « X » sur la pile :

    • « res » est le résultat du fils gauche et

    • « X » est le fils droit en attente.

  • Nous allons donc :

    • dépiler « X » pour le traiter,

    • . . .

C

X

marq <- S( p )

p <- D( p )

x <- S( p )

p <- D( p )

...

...

goto CALCUL

. . .

R

C

. . .

res

X

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative26
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 4 – nous avons « res » et « C » avec « X » sur la pile :

    • « res » est le résultat du fils gauche et

    • « X » est le fils droit en attente.

  • Nous allons donc :

    • dépiler « X » pour le traiter,

    • sauver « res » sur la pile.

C

X

marq <- S( p )

p <- D( p )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

goto CALCUL

. . .

R

res

R

C

. . .

res

X

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative27
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 5 – nous avons « res » et « R » avec « a » sur la pile :

R

a

. . .

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative28
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 5 – nous avons « res » et « R » avec « a » sur la pile :

    • « res » est le résultat du fils droit et

    • « a » est le résultat gauche en attente.

R

a

. . .

R

R

a

res

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative29
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 5 – nous avons « res » et « R » avec « a » sur la pile :

    • « res » est le résultat du fils droit et

    • « a » est le résultat gauche en attente.

  • Nous allons donc :

    • dépiler « a » pour le

      combiner avec « res » et

    • . . .

R

a

. . .

R

R

a

res

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative30
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 5 – nous avons « res » et « R » avec « a » sur la pile :

    • « res » est le résultat du fils droit et

    • « a » est le résultat gauche en attente.

  • Nous allons donc :

    • dépiler « a » pour le

      combiner avec « res » et

    • . . .

R

a

. . .

marq <- S( p )

p <- D( p )

res <- h( S( p ) , res )

p <- D( p )

...

R

R

a

res

. . .

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative31
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

  • Cas 5 – nous avons « res » et « R » avec « a » sur la pile :

    • « res » est le résultat du fils droit et

    • « a » est le résultat gauche en attente.

  • Nous allons donc :

    • dépiler « a » pour le

      combiner avec « res » et

    • continuer l’inspection de pile.

R

a

. . .

marq <- S( p )

p <- D( p )

res <- h( S( p ) , res )

p <- D( p )

goto PILE

R

R

a

res

. . .

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative32
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

PILE:

si ( V( p ) )

goto FIN

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

goto CALCUL

sinon

res <- h( S( p ) , res )

p <- D( p )

goto PILE

  • Fusion des

    cas 3, 4 & 5 :

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative33
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

PILE:

si ( V( p ) )

goto FIN

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

goto CALCUL

sinon

res <- h( S( p ) , res )

p <- D( p )

goto PILE

  • Fusion des

    cas 3, 4 & 5 :

Nous consultons

le marqueur !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative34
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

PILE:

si ( V( p ) )

goto FIN

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

goto CALCUL

sinon

res <- h( S( p ) , res )

p <- D( p )

goto PILE

  • Fusion des

    cas 3, 4 & 5 :

Nous consultons

le marqueur !

Nous allons traiter le

second fils et sauvons

le résultat du premier !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative35
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

PILE:

si ( V( p ) )

goto FIN

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

goto CALCUL

sinon

res <- h( S( p ) , res )

p <- D( p )

goto PILE

  • Fusion des

    cas 3, 4 & 5 :

Nous consultons

le marqueur !

Nous allons traiter le

second fils et sauvons

le résultat du premier !

Nous combinons

deux résultats !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative36
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

PILE:

si ( V( p ) )

goto FIN

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

goto CALCUL

sinon

res <- h( S( p ) , res )

p <- D( p )

goto PILE

  • Fusion des

    cas 3, 4 & 5 :

Une sortie !

Nous consultons

le marqueur !

Nous allons traiter le

second fils et sauvons

le résultat du premier !

Une sortie !

Nous combinons

deux résultats !

Une boucle !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative37
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

DEBUT :

x <- v

p <- I( )

goto CALCUL

PILE:

si ( V( p ) )

goto FIN

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

goto CALCUL

sinon

res <- h( S( p ) , res )

p <- D( p )

goto PILE

CALCUL :

si ( P( x ) )

res <- a( x )

goto PILE

sinon

p <- E( b( x ) , p )

p <- E( C , p )

x <- a( x )

goto CALCUL

FIN :

...

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative38
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

DEBUT :

x <- v

p <- I( )

goto CALCUL

PILE:

si ( V( p ) )

goto FIN

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

goto CALCUL

sinon

res <- h( S( p ) , res )

p <- D( p )

goto PILE

Se généralise pour "f" et pour "h"

avec plus d'arguments !

CALCUL :

si ( P( x ) )

res <- a( x )

goto PILE

sinon

p <- E( b( x ) , p )

p <- E( C , p )

x <- a( x )

goto CALCUL

FIN :

...

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs enveloppe non associative39
Deux appels récursifs, enveloppe non associative-----------------------------------------------------------------

DEBUT :

x <- v

p <- I( )

FIN <- faux

CALCUL <- vrai

PILE <- faux

while ( ù FIN )

while_CALCUL

while_PILE

while_PILE:

while ( PILE )

si ( V( p ) )

PILE <- faux

FIN <- vrai

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

PILE <- faux

CALCUL <- vrai

sinon

res <- h( S( p ) , res )

p <- D( p )

while_CALCUL :

while ( CALCUL )

si ( P( x ) )

res <- a( x )

CALCUL <- faux

PILE <- vrai

sinon

p <- E( b( x ) , p )

p <- E( C , p )

x <- a( x )

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum
Deux appels récursifs --- résumé-----------------------------------------------------------------

Nombre d’appels récursifs

Nous retenons les

quatre cas suivants !

Un

Deux

Fonction auto-enveloppée

Non

Oui

Cas 5)

Enveloppe associative

Oui

Non

Cas 8)

Avec élément neutre

Oui

Cas 6)

Non

Cas 7)

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum1
Deux appels récursifs --- résumé-----------------------------------------------------------------

  • 5) Deux appels récursifs auto-enveloppés !

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

f ( acc , x ) =

si ( P( acc , x ) )

a( acc , x )

sinon

f( f( t( acc , x ) ,

a( acc , x ) ) ,

b( acc , x ) )

Code itératif peu raisonnable !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum2
Deux appels récursifs --- résumé-----------------------------------------------------------------

  • 5) Deux appels récursifs auto-enveloppés !

acc <- init

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( acc , x ) )

acc <- a( acc , x )

sinon

p <- E( b( acc , x ) , p )

p <- E( a( acc , x ) , p )

acc <- t( acc , x )

res <- acc

f ( acc , x ) =

si ( P( acc , x ) )

a( acc , x )

sinon

f( f( t( acc , x ) ,

a( acc , x ) ) ,

b( acc , x ) )

L'arité de "f" peut varier !

Code itératif peu raisonnable !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum3
Deux appels récursifs --- résumé-----------------------------------------------------------------

  • 6) Appels avec enveloppe associative et neutre « e » !

acc <- e

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) , f( b( x ) ) )

Code itératif peu raisonnable !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum4
Deux appels récursifs --- résumé-----------------------------------------------------------------

  • 6) Appels avec enveloppe associative et neutre « e » !

acc <- e

p <- E( v , I( ) )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) , f( b( x ) ) )

L'arité de "f" peut varier !

Code itératif peu raisonnable !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum5
Deux appels récursifs --- résumé-----------------------------------------------------------------

x <- v

p <- I( )

while ( ù ( P( x ) )

p <- E( b( x ) , p )

x <- a( x )

acc <- a( x )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

  • 7) Appels avec enveloppe

    associative, sans neutre !

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) , f( b( x ) ) )

Code itératif très peu raisonnable !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum6
Deux appels récursifs --- résumé-----------------------------------------------------------------

x <- v

p <- I( )

while ( ù ( P( x ) )

p <- E( b( x ) , p )

x <- a( x )

acc <- a( x )

while ( ù V( p ) )

x <- S( p )

p <- D( p )

si ( P( x ) )

acc <- h( acc , a( x ) )

sinon

p <- E( b( x ) , p )

p <- E( a( x ) , p )

res <- acc

  • 7) Appels avec enveloppe

    associative, sans neutre !

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) , f( b( x ) ) )

L'arité de "f" peut varier !

Code itératif très peu raisonnable !

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum7
Deux appels récursifs --- résumé-----------------------------------------------------------------

while_PILE:

while ( PILE )

si ( V( p ) )

PILE <- faux

FIN <- vrai

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

PILE <- faux

CALCUL <- vrai

sinon

res <- h( S( p ) ,

res )

p <- D( p )

  • 8) Appels avec enveloppe

    non associative !

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) , f( b( x ) ) )

Code itératif déraisonnable !

while_CALCUL :

while ( CALCUL )

si ( P( x ) )

res <- a( x )

CALCUL <- faux

PILE <- vrai

sinon

p <- E( b( x ) , p )

p <- E( C , p )

x <- a( x )

DEBUT :

x <- v

p <- I( )

FIN <- faux

CALCUL <- vrai

PILE <- faux

while ( ù FIN )

while_CALCUL

while_PILE

Cours d'algorithmique 8 - Intranet


Deux appels r cursifs r sum8
Deux appels récursifs --- résumé-----------------------------------------------------------------

while_PILE:

while ( PILE )

si ( V( p ) )

PILE <- faux

FIN <- vrai

sinon

marq <- S( p )

p <- D( p )

si ( marq = C )

x <- S( p )

p <- D( p )

p <- E( res , p )

p <- E( R , p )

PILE <- faux

CALCUL <- vrai

sinon

res <- h( S( p ) ,

res )

p <- D( p )

  • 8) Appels avec enveloppe

    non associative !

f ( x ) =

si ( P( x ) )

a( x )

sinon

h( f( a( x ) ) , f( b( x ) ) )

Code itératif déraisonnable !

while_CALCUL :

while ( CALCUL )

si ( P( x ) )

res <- a( x )

CALCUL <- faux

PILE <- vrai

sinon

p <- E( b( x ) , p )

p <- E( C , p )

x <- a( x )

DEBUT :

x <- v

p <- I( )

FIN <- faux

CALCUL <- vrai

PILE <- faux

while ( ù FIN )

while_CALCUL

while_PILE

Les arités de "f" et "h" peuvent varier !

Cours d'algorithmique 8 - Intranet


R sum g n ral
Résumé général-----------------------------------------------------------------

  • Les quatre cas à unique appel récursif :

    • Récursif terminal.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

Cours d'algorithmique 8 - Intranet


R sum g n ral1
Résumé général-----------------------------------------------------------------

  • Les quatre cas à unique appel récursif :

    • Récursif terminal.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

Se ramène à …

Cours d'algorithmique 8 - Intranet


R sum g n ral2
Résumé général-----------------------------------------------------------------

  • Les quatre cas à unique appel récursif :

    • Récursif terminal.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

  • Les quatre cas à deux appels récursifs :

    • Récursif auto-enveloppé.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

Se ramène à …

Cours d'algorithmique 8 - Intranet


R sum g n ral3
Résumé général-----------------------------------------------------------------

  • Les quatre cas à unique appel récursif :

    • Récursif terminal.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

  • Les quatre cas à deux appels récursifs :

    • Récursif auto-enveloppé.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

Se ramène à …

Cours d'algorithmique 8 - Intranet


R sum g n ral4
Résumé général-----------------------------------------------------------------

  • Les quatre cas à unique appel récursif :

    • Récursif terminal.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

  • Les quatre cas à deux appels récursifs :

    • Récursif auto-enveloppé.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

Récursif !

Se ramène à …

Cours d'algorithmique 8 - Intranet


R sum g n ral5
Résumé général-----------------------------------------------------------------

  • Les quatre cas à unique appel récursif :

    • Récursif terminal.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

  • Les quatre cas à deux appels récursifs :

    • Récursif auto-enveloppé.

    • Enveloppe associative avec neutre.

    • Enveloppe associative sans neutre.

    • Enveloppe non associative.

Récursif !

Itératif !

Se ramène à …

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons
Algorithmes gloutons-----------------------------------------------------------------

  • h a n g e o n s d e s u j e t !

  • L G O R I T H M E S

    G L O U T O N S ! ! !

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons1
Algorithmes gloutons-----------------------------------------------------------------

  • Greedy algorithms en anglais !

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons2
Algorithmes gloutons-----------------------------------------------------------------

  • Greedy algorithms en anglais !

  • Une suite de décisions optimales locales

    conduisent à

    un optimum global !

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons3
Algorithmes gloutons-----------------------------------------------------------------

  • Greedy algorithms en anglais !

  • Une suite de décisions optimales locales

    conduisent à

    un optimum global !

  • Complexité pour « n » éléments :

    • O( n * x )où O( x ) est la complexité de la décision locale !

    • O( 2 ) pour le back-track (cascade de décisions locales) !

n

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons4
Algorithmes gloutons-----------------------------------------------------------------

  • Exemple d’un choix glouton :

    • GLOBAL :Choisir les 10 plus petits de l’amphi !

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons5
Algorithmes gloutons-----------------------------------------------------------------

  • Exemple d’un choix glouton :

    • GLOBAL :Choisir les 10 plus petits de l’amphi !

    • LOCAL :Trouver et retirer le plus petit !

      • Ce choix est indépendant des autres personnes déjà choisies ou restant à choisir.

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons6
Algorithmes gloutons-----------------------------------------------------------------

  • Exemple d’un choix glouton :

    • GLOBAL :Choisir les 10 plus petits de l’amphi !

    • LOCAL :Trouver et retirer le plus petit !

      • Ce choix est indépendant des autres personnes déjà choisies ou restant à choisir.

  • Exemple d’un choix non glouton :

    • GLOBAL :Choisir le plus court chemin de Marseille à Paris !

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons7
Algorithmes gloutons-----------------------------------------------------------------

  • Exemple d’un choix glouton :

    • GLOBAL :Choisir les 10 plus petits de l’amphi !

    • LOCAL :Trouver et retirer le plus petit !

      • Ce choix est indépendant des autres personnes déjà choisies ou restant à choisir.

  • Exemple d’un choix non glouton :

    • GLOBAL :Choisir le plus court chemin de Marseille à Paris !

    • LOCAL :Trouver à partir de la ville courante, l’étape la

      plus courte !

      • Un tel choix n’est pas sûr de nous rapprocher de Paris !

Cours d'algorithmique 8 - Intranet


Action selection problem
Action Selection Problem-----------------------------------------------------------------

  • Un exemple complet :

    • Ensemble « E » de tâches, dont le « début » et la « fin » sont connues !

    • t et t sont compatibles si leurs intersections sont vides !

    • OBJECTIF : Trouvez le plus grand ensemble de

      tâches compatibles ! ! !

i

j

Cours d'algorithmique 8 - Intranet


Action selection problem1
Action Selection Problem-----------------------------------------------------------------

  • Un exemple complet :

    • Ensemble « E » de tâches, dont le « début » et la « fin » sont connues !

    • t et t sont compatibles si leurs intersections sont vides !

    • OBJECTIF : Trouvez le plus grand ensemble de

      tâches compatibles ! ! !

i

j

i 1 2 3 4

d 5 3 1 2

f 7 9 4 5

i

i

Cours d'algorithmique 8 - Intranet


Action selection problem2
Action Selection Problem-----------------------------------------------------------------

  • Un exemple complet :

    • Ensemble « E » de tâches, dont le « début » et la « fin » sont connues !

    • t et t sont compatibles si leurs intersections sont vides !

    • OBJECTIF : Trouvez le plus grand ensemble de

      tâches compatibles ! ! !

i

j

i 1 2 3 4

d 5 3 1 2

f 7 9 4 5

i 1 2 3 4

d 1 2 5 3

f 4 5 7 9

i

i

i

i

triées par f croissants !

i

Cours d'algorithmique 8 - Intranet


Action selection problem3
Action Selection Problem-----------------------------------------------------------------

  • Trois approches de solution :

    • Back-track !

    • Programmation dynamique !

    • Algorithme glouton !

Cours d'algorithmique 8 - Intranet


Action selection problem4
Action Selection Problem-----------------------------------------------------------------

Les tâches déjà choisies.

Les tâches non encore considérées.

ens BT ( ens choisies , ens restantes ) =

si ( restantes = {} )

choisies

sinon

choix <- choisir( restantes )

restantes <- restantes \ { choix }

sans_choix = BT( choisies , restantes )

si ( compatible( choix , choisies ) )

max_ens( BT( choisies v { choix } , restantes ) ,

sans_choix )

sinon

sans_choix

Cours d'algorithmique 8 - Intranet


Action selection problem5
Action Selection Problem-----------------------------------------------------------------

Les tâches déjà choisies.

Les tâches non encore considérées.

ens BT ( ens choisies , ens restantes ) =

si ( restantes = {} )

choisies

sinon

choix <- choisir( restantes )

restantes <- restantes \ { choix }

sans_choix = BT( choisies , restantes )

si ( compatible( choix , choisies ) )

max_ens( BT( choisies v { choix } , restantes ) ,

sans_choix )

sinon

sans_choix

Assez naturel !

Cours d'algorithmique 8 - Intranet


Action selection problem6
Action Selection Problem-----------------------------------------------------------------

Les tâches déjà choisies.

Les tâches non encore considérées.

ens BT ( ens choisies , ens restantes ) =

si ( restantes = {} )

choisies

sinon

choix <- choisir( restantes )

restantes <- restantes \ { choix }

sans_choix = BT( choisies , restantes )

si ( compatible( choix , choisies ) )

max_ens( BT( choisies v { choix } , restantes ) ,

sans_choix )

sinon

sans_choix

Assez naturel !

Nous choisissons !

Cours d'algorithmique 8 - Intranet


Action selection problem7
Action Selection Problem-----------------------------------------------------------------

Les tâches déjà choisies.

Les tâches non encore considérées.

ens BT ( ens choisies , ens restantes ) =

si ( restantes = {} )

choisies

sinon

choix <- choisir( restantes )

restantes <- restantes \ { choix }

sans_choix = BT( choisies , restantes )

si ( compatible( choix , choisies ) )

max_ens( BT( choisies v { choix } , restantes ) ,

sans_choix )

sinon

sans_choix

Assez naturel !

Nous choisissons !

Nous avons toujours la possibilité de ne pas retenir la tâche choisie !

Cours d'algorithmique 8 - Intranet


Action selection problem8
Action Selection Problem-----------------------------------------------------------------

Les tâches déjà choisies.

Les tâches non encore considérées.

ens BT ( ens choisies , ens restantes ) =

si ( restantes = {} )

choisies

sinon

choix <- choisir( restantes )

restantes <- restantes \ { choix }

sans_choix = BT( choisies , restantes )

si ( compatible( choix , choisies ) )

max_ens( BT( choisies v { choix } , restantes ),

sans_choix )

sinon

sans_choix

Assez naturel !

Nous choisissons !

Le choix est retenu s’il est compatible . . .

Nous avons toujours la possibilité de ne pas retenir la tâche choisie !

Cours d'algorithmique 8 - Intranet


Action selection problem9
Action Selection Problem-----------------------------------------------------------------

  • Trois approches de solution :

    • Back-track ! Complexité : O ( 2^n )

    • Programmation dynamique !

    • Algorithme glouton !

Cours d'algorithmique 8 - Intranet


Action selection problem10
Action Selection Problem-----------------------------------------------------------------

  • Considérons :

    E( i , j ) = { te E | f <=d <= f<= d }

k

i

k

k

j

Cours d'algorithmique 8 - Intranet


Action selection problem11
Action Selection Problem-----------------------------------------------------------------

  • Considérons :

    E( i , j ) = { te E | f <=d <= f<= d }

k

i

k

k

j

f

d

i

j

Cours d'algorithmique 8 - Intranet


Action selection problem12
Action Selection Problem-----------------------------------------------------------------

  • Considérons :

    E( i , j ) = { te E | f <=d <= f<= d }

k

i

k

k

j

f

d

d

f

i

j

k

k

Cours d'algorithmique 8 - Intranet


Action selection problem13
Action Selection Problem-----------------------------------------------------------------

  • Considérons :

    E( i , j ) = { te E | f <=d <= f<= d }

  • Initialisation :

    • soit t avec f = 0 ,

    • soit t avec d = +inf ,

    • alors E = E( 0 , n+1 ) .

k

i

k

k

j

f

d

d

f

i

j

k

k

0

0

n+1

n+1

Cours d'algorithmique 8 - Intranet


Action selection problem14
Action Selection Problem-----------------------------------------------------------------

E( i , j )

  • Décomposition :

f

d

i

j

Cours d'algorithmique 8 - Intranet


Action selection problem15
Action Selection Problem-----------------------------------------------------------------

E( i , j )

t e E( i , j )

  • Décomposition :

k

f

d

d

f

i

j

k

k

Cours d'algorithmique 8 - Intranet


Action selection problem16
Action Selection Problem-----------------------------------------------------------------

E( i , j )

t e E( i , j )

  • Décomposition :

k

f

d

d

f

{

{

i

j

k

k

E( i , k )

E( k , j )

Cours d'algorithmique 8 - Intranet


Action selection problem17
Action Selection Problem-----------------------------------------------------------------

E( i , j )

t e E( i , j )

  • Décomposition :

    { } si E( i , j ) = { }

  • S( i , j ) =

    max_ens { { t } v S( i , k ) v S( k , j ) } sinon

k

f

d

d

f

{

{

i

j

k

k

E( i , k )

E( k , j )

{

k

t e E( i , j )

k

Cours d'algorithmique 8 - Intranet


Action selection problem18
Action Selection Problem-----------------------------------------------------------------

E( i , j )

t e E( i , j )

  • Décomposition :

    { } si E( i , j ) = { }

  • S( i , j ) =

    max_ens { { t } v S( i , k ) v S( k , j ) } sinon

k

f

d

d

f

{

{

i

j

k

k

E( i , k )

E( k , j )

{

On maximise

sur tous les

choix pour t .

k

t e E( i , j )

k

k

Cours d'algorithmique 8 - Intranet


Action selection problem19
Action Selection Problem-----------------------------------------------------------------

E( i , j )

t e E( i , j )

  • Décomposition :

    { } si E( i , j ) = { }

  • S( i , j ) =

    max_ens { { t } v S( i , k ) v S( k , j ) } sinon

k

f

d

d

f

{

{

i

j

k

k

E( i , k )

E( k , j )

C’est la tâche t et les solutions optimales pour E( i , k ) et E( k , j ).

k

{

On maximise

sur tous les

choix pour t .

k

t e E( i , j )

k

k

Cours d'algorithmique 8 - Intranet


Action selection problem20
Action Selection Problem-----------------------------------------------------------------

Tâches triées par f

croissants, donc i < k < j !

  • Graphiquement, pour i < j :

x

S( i , j )

j

i

Cours d'algorithmique 8 - Intranet


Action selection problem21
Action Selection Problem-----------------------------------------------------------------

Tâches triées par f

croissants, donc i < k < j !

  • Graphiquement, pour i < j :

x

S( i , j )

j

i

j

i

Cours d'algorithmique 8 - Intranet


Action selection problem22

. . .

. . .

Action Selection Problem-----------------------------------------------------------------

Tâches triées par f

croissants, donc i < k < j !

  • Graphiquement, pour i < j :

x

S( i , j )

S( k , j )

j

S( i , k )

i

j

i

Cours d'algorithmique 8 - Intranet


Action selection problem23

. . .

. . .

Action Selection Problem-----------------------------------------------------------------

Tâches triées par f

croissants, donc i < k < j !

  • Graphiquement, pour i < j :

x

S( i , j )

S( k , j )

j

Second axe de temps

S( i , k )

i

Premier axe de temps

j

i

Cours d'algorithmique 8 - Intranet


Action selection problem24
Action Selection Problem-----------------------------------------------------------------

  • Trois approches de solution :

    • Back-track ! Complexité : O ( 2^n )

    • Programmation dynamique ! Complexité : O ( n^2 )

    • Algorithme glouton !

Cours d'algorithmique 8 - Intranet


Action selection problem25
Action Selection Problem-----------------------------------------------------------------

  • L’approche gloutonne dit :

    • Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) !

    • S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) }

k

t e E( i , j )

k

Cours d'algorithmique 8 - Intranet


Action selection problem26
Action Selection Problem-----------------------------------------------------------------

  • L’approche gloutonne dit :

    • Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) !

    • S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) }

  • Considérez la tâche t avec f minimal sur E( i , j ) ! Alors :

    • S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) }

k

t e E( i , j )

k

l

l

k

t e E( i , j )

k

Cours d'algorithmique 8 - Intranet


Action selection problem27
Action Selection Problem-----------------------------------------------------------------

  • L’approche gloutonne dit :

    • Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) !

    • S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) }

  • Considérez la tâche t avec f minimal sur E( i , j ) ! Alors :

    • S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) }

      = { t } v S( i , l ) v S( l , j )

k

t e E( i , j )

k

l

l

k

t e E( i , j )

k

l

Cours d'algorithmique 8 - Intranet


Action selection problem28
Action Selection Problem-----------------------------------------------------------------

  • L’approche gloutonne dit :

    • Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) !

    • S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ) }

  • Considérez la tâche t avec f minimal sur E( i , j ) ! Alors :

    • 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( l , j )

k

t e E( i , j )

k

l

l

k

t e E( i , j )

k

l

l

Cours d'algorithmique 8 - Intranet


Action selection problem29
Action Selection Problem-----------------------------------------------------------------

  • Pourquoi ?

    • Soit S( i , j ) la solution optimale pour E( i , j ) !

f

d

i

j

Cours d'algorithmique 8 - Intranet


Action selection problem30
Action Selection Problem-----------------------------------------------------------------

  • Pourquoi ?

    • Soit S( i , j ) la solution optimale pour E( i , j ) !

    • Soit t = t , soit nous remplaçons t par t !

f

d

t

i

j

x

x

l

x

l

Cours d'algorithmique 8 - Intranet


Action selection problem31
Action Selection Problem-----------------------------------------------------------------

  • Pourquoi ?

    • Soit S( i , j ) la solution optimale pour E( i , j ) !

    • Soit t = t , soit nous remplaçons t par t !

f

d

t

i

j

x

x

l

x

l

f

d

t

i

j

l

Cours d'algorithmique 8 - Intranet


Action selection problem32
Action Selection Problem-----------------------------------------------------------------

  • Pourquoi ?

    • Soit S( i , j ) la solution optimale pour E( i , j ) !

    • Soit t = t , soit nous remplaçons t par t !

    • Bien-sûr, S( i , l ) = { } . S( l , j )

f

d

t

i

j

x

x

l

x

l

f

d

t

i

j

l

Cours d'algorithmique 8 - Intranet


Action selection problem33
Action Selection Problem-----------------------------------------------------------------

  • Le code :

Trier les tâches par fin croissantes

d <- 0

Parcourir les tâches t par indices croissants

si ( d >= d )

Prendre t

d <- f

sinon

Ignorer t

i

i

i

i

i

Cours d'algorithmique 8 - Intranet


Action selection problem34
Action Selection Problem-----------------------------------------------------------------

  • Le code :

Trier les tâches par fin croissantes

d <- 0

Parcourir les tâches t par indices croissants

si ( d >= d )

Prendre t

d <- f

sinon

Ignorer t

i

i

Décision purement locale !

Décision indépendante de

toutes les autres décisions !

i

i

i

Cours d'algorithmique 8 - Intranet


Action selection problem35
Action Selection Problem-----------------------------------------------------------------

  • Trois approches de solution :

    • Back-track ! Complexité : O ( 2^n )

    • Programmation dynamique ! Complexité : O ( n^2 )

    • Algorithme glouton ! Complexité : O ( n )

Cours d'algorithmique 8 - Intranet


Action selection problem36
Action Selection Problem-----------------------------------------------------------------

  • Trois approches de solution :

    • Back-track ! Complexité : O ( 2^n )

    • Programmation dynamique ! Complexité : O ( n^2 )

    • Algorithme glouton ! Complexité : O ( n )

  • L’algorithme glouton est souvent obtenu comme optimisation d’une programmation dynamique !

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties
Task Scheduling with Penalties-----------------------------------------------------------------

  • Définition :

    • « n » tâches de temps unitaires !

    • Chaque tâche « t  » comporte une deadline « d  » et

      une pénalité « p  », due si la deadline est dépassée.

    • Objectif : Trouver un ordonnancement qui minimise la somme des pénalités !

i

i

i

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties1
Task Scheduling with Penalties-----------------------------------------------------------------

  • Solution :

Trier les tâches par deadlines croissantes.

Parcourir les tâches et retenir celles qui

peuvent être exécutées dans les temps.

Compléter par les autres !

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties2
Task Scheduling with Penalties-----------------------------------------------------------------

  • Solution :

  • Pourquoi est-ce correct ?

    • Soit une suite optimale de tâches :

      ( t , . . . , t , t , . . . , t )

Trier les tâches par deadlines croissantes.

Parcourir les tâches et retenir celles qui

peuvent être exécutées dans les temps.

Compléter par les autres !

i+1

n

1

i

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties3
Task Scheduling with Penalties-----------------------------------------------------------------

  • Correction :

    • Soit une suite optimale de tâches :

      ( t , . . . , t , t , . . . , t )

      avec t en retard et t à l’heure.

i+1

n

1

i

i

i+1

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties4
Task Scheduling with Penalties-----------------------------------------------------------------

  • Correction :

    • Soit une suite optimale de tâches :

      ( t , . . . , t , t , . . . , t )

      avec t en retard et t à l’heure.

  • On peut échanger t et t sans changer la pénalité :

    • t plus tôt, OK, et t plus tard, OK.

i+1

n

1

i

i

i+1

i

i+1

i

i+1

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties5
Task Scheduling with Penalties-----------------------------------------------------------------

  • Correction :

    • Soit une suite optimale de tâches :

      ( t , . . . , t , t , . . . , t )

      avec t en retard et t à l’heure.

  • On peut échanger t et t sans changer la pénalité :

    • t plus tôt, OK, et t plus tard, OK.

  • Donc, il existe une solution optimale telle que :

    ( t’ , . . . , t’ , t’ , . . . , t’ )

    à l’heure en retard

i+1

n

1

i

i

i+1

i

i+1

i

i+1

n

1

k

k+1

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties6
Task Scheduling with Penalties-----------------------------------------------------------------

  • Correction :

    • Dans une suite optimale, si t et t sont à l’heure et que

      d > d , on peut les échanger sans modifier les pénalités.

i

i+1

i

i+1

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties7
Task Scheduling with Penalties-----------------------------------------------------------------

  • Correction :

    • Dans une suite optimale, si t et t sont à l’heure et que

      d > d , on peut les échanger sans modifier les pénalités.

    • Sans pénalité : f <= d et f <= d .

i

i+1

i

i+1

i

i

i+1

i+1

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties8
Task Scheduling with Penalties-----------------------------------------------------------------

  • Correction :

    • Dans une suite optimale, si t et t sont à l’heure et que

      d > d , on peut les échanger sans modifier les pénalités.

    • Sans pénalité : f <= d et f <= d .

    • Par ailleurs : f < f <= d < d .

i

i+1

i

i+1

i

i

i+1

i+1

i

i+1

i+1

i

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties9
Task Scheduling with Penalties-----------------------------------------------------------------

  • Correction :

    • Dans une suite optimale, si t et t sont à l’heure et que

      d > d , on peut les échanger sans modifier les pénalités.

    • Sans pénalité : f <= d et f <= d .

    • Par ailleurs : f < f <= d < d .

    • Donc : f < d et f < d .

i

i+1

i

i+1

i

i

i+1

i+1

i

i+1

i+1

i

i+1

i

i

i+1

Cours d'algorithmique 8 - Intranet


Task scheduling with penalties10
Task Scheduling with Penalties-----------------------------------------------------------------

  • Correction :

    • Dans une suite optimale, si t et t sont à l’heure et que

      d > d , on peut les échanger sans modifier les pénalités.

    • Sans pénalité : f <= d et f <= d .

    • Par ailleurs : f < f <= d < d .

    • Donc : f < d et f < d .

  • Donc, il existe une solution optimale telle que :

    ( t’ , . . . , t’ , t’ , . . . , t’ )

    à l’heure et d croissants en retard CQFD.

i

i+1

i

i+1

i

i

i+1

i+1

i

i+1

i+1

i

i+1

i

i

i+1

n

1

k

k+1

i

Cours d'algorithmique 8 - Intranet


Algorithmes gloutons8
Algorithmes gloutons-----------------------------------------------------------------

  • Une suite de décisions optimales locales

    conduisent à

    un optimum global !

Cours d'algorithmique 8 - Intranet


Synth se
Synthèse-----------------------------------------------------------------

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


m E r C i e T

  • O n N e J o U r N é E ! ! !

  • ‘ o U b l I e Z p A s D e

  • r é P a R e R v O s

    T D ! ! !

Cours d'algorithmique 8 - Intranet


ad