Post on 03-Apr-2015
Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 114 décembre 20064 décembre 2006
Cours d’AlgorithmiqueCours d’Algorithmique
Dérécursion (fin) :Dérécursion (fin) :
Équivalences entre programmes récursifs etÉquivalences entre programmes récursifs et
programmes itératifs avec ou sans gestion programmes itératifs avec ou sans gestion de pile.de pile.
Algorithmes gloutons.Algorithmes gloutons.
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 22
• Trier et chercher, recherche textuelleTrier et chercher, recherche textuelle• Listes et arbresListes et arbres• Le back-trackLe back-track• Arbres équilibrésArbres équilibrés• Récursivité et induction sur la structureRécursivité et induction sur la structure• Divide and conquerDivide and conquer, algorithmes gloutons, algorithmes gloutons• Minimax, alpha-betaMinimax, alpha-beta• DérécursionDérécursion• Divers problèmes particuliersDivers problèmes particuliers• Logique de HoareLogique de Hoare• Programmation dynamiqueProgrammation dynamique• Complexité et calculabilitéComplexité et calculabilité
Les grandes lignes du coursLes grandes lignes du cours
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 33
PlanPlan----------------------------------------------------------------------------------------------------------------------------------
Nombre d’appels récursifsNombre d’appels récursifs
UnUn DeuxDeuxFonction auto-enveloppéeFonction auto-enveloppée
NonNon OuiOuiEnveloppe associativeEnveloppe associative
OuiOui NonNonAvec élément neutreAvec élément neutre
OuiOui NonNon
Appréciations !Appréciations !
TransformationTransformationintéressante !intéressante !
Celle-là aussi !Celle-là aussi !
Sans espoir ! ! !Sans espoir ! ! !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 44
Deux appels récursifs auto-enveloppésDeux appels récursifs auto-enveloppés----------------------------------------------------------------------------------------------------------------------------------
f ( acc , x ) =f ( acc , x ) = si ( si ( ( acc , x )( acc , x ) ) ) a( acc , x )a( acc , x ) sinonsinon f(f( f( f( ( acc , x ) , ( acc , x ) , ( acc , x ) )( acc , x ) ) ,, ( acc , x ) )( acc , x ) )
Le cas d’arrêt.Le cas d’arrêt.
L’appel récursif interne !L’appel récursif interne !
L’appel récursif externe !L’appel récursif externe !
• Le cas de base est celui des appels auto-enveloppés !Le cas de base est celui des appels auto-enveloppés ! Nous explorons x à l’aideNous explorons x à l’aided’un accumulateur acc.d’un accumulateur acc.
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 55
Deux appels récursifs auto-enveloppésDeux appels récursifs auto-enveloppés----------------------------------------------------------------------------------------------------------------------------------
f ( f ( acc acc , x ) =, x ) = si ( si ( ( x ) )( x ) ) a( acc , x )a( acc , x ) sinonsinon f(f( f( f( acc acc , , ( x ) )( x ) ) , , ( x ) )( x ) )
xx
( x )( x ) ( x )( x )
accacc
Le flot des informations !Le flot des informations !
L’accumulateur récolte lesL’accumulateur récolte lescontributions locales au furcontributions locales au furet à mesure du parcours !et à mesure du parcours !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 66
Deux appels récursifs auto-enveloppésDeux appels récursifs auto-enveloppés----------------------------------------------------------------------------------------------------------------------------------
• Introduisons la fonction F suivante :Introduisons la fonction F suivante :
F( acc , p ) = si F( acc , p ) = si ( V( p ) )( V( p ) ) accacc sinonsinon x <x <-- S( p ) S( p ) p <p <-- D( p ) D( p ) F( F( f( acc , x )f( acc , x ) , p ) , p )
La pile contientLa pile contientles éléments quiles éléments quisont à traiter.sont à traiter.
Nous la traitons.Nous la traitons.
Et nous recommençons.Et nous recommençons.
Nous enlevons laNous enlevons lavaleur du sommetvaleur du sommetde la pile.de la pile.
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 77
Deux appels récursifs auto-enveloppésDeux appels récursifs auto-enveloppés----------------------------------------------------------------------------------------------------------------------------------
• Nous avons :Nous avons :
F( acc , F( acc , E( v , I( ) )E( v , I( ) ) ) = si ( V( E( v , I( ) ) ) ) ) = si ( V( E( v , I( ) ) ) ) accacc sinonsinon x <x <-- S( E( v , I( ) ) ) v S( E( v , I( ) ) ) v p <p <-- D( E( v , I( ) ) ) I( ) D( E( v , I( ) ) ) I( ) F( f( acc , x ) , p )F( f( acc , x ) , p ) = F( f( acc , v ) , I( ) )= F( f( acc , v ) , I( ) ) = si ( V( I( ) ) )= si ( V( I( ) ) ) f( acc , v ) f( acc , v ) sinonsinon . . . . . . = = f( acc , v )f( acc , v )
Plutôt que d’appelerPlutôt que d’appeler« f( acc , v ) » nous« f( acc , v ) » nouspouvons appeler Fpouvons appeler Favec « acc » et uneavec « acc » et unepile qui contient lepile qui contient leseul élément « v »seul élément « v »qui est à traiter.qui est à traiter.
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 88
Deux appels récursifs auto-enveloppésDeux appels récursifs auto-enveloppés----------------------------------------------------------------------------------------------------------------------------------
• Nous avons plus généralement :Nous avons plus généralement :
F( acc , F( acc , E( v , p )E( v , p ) ) = si ( V( E( v , p ) ) ) ) = si ( V( E( v , p ) ) ) accacc sinonsinon x <x <-- S( E( v , p ) ) v S( E( v , p ) ) v p <p <-- D( E( v , p ) ) p D( E( v , p ) ) p F( f( acc , x ) , p )F( f( acc , x ) , p ) = F( f( acc , v ) , p )= F( f( acc , v ) , p )
F( acc , E( v , p ) ) = F( f( acc , v ) , p )F( acc , E( v , p ) ) = F( f( acc , v ) , p )
EmpilerEmpiler
DépilerDépiler
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 99
Deux appels récursifs auto-enveloppésDeux appels récursifs auto-enveloppés----------------------------------------------------------------------------------------------------------------------------------
• Exprimons F à l’aide d ’elle-même et de manière terminale. Exprimons F à l’aide d ’elle-même et de manière terminale. Nous aurons une itération avec gestion de la pile.Nous aurons une itération avec gestion de la pile.
F( acc , p ) = si ( V( p ) )F( acc , p ) = si ( V( p ) ) accacc sinonsinon x <x <-- S( p ) S( p ) p <p <-- D( p ) D( p ) si ( si ( ) ) F( F( a a , p ), p ) sinonsinon F( F( , E( , E( E( E( , p ) ) ) , p ) ) )
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1010
Deux appels récursifs auto-enveloppésDeux appels récursifs auto-enveloppés----------------------------------------------------------------------------------------------------------------------------------
• Pour un appel Pour un appel res <res <-- f( init , v ) f( init , v ) nous obtenons le code nous obtenons le code ::
acc <- initacc <- initp <- E( v , I( ) )p <- E( v , I( ) )
while ( while ( V( p ) ) V( p ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) si si ( ( ( acc , x ) )( acc , x ) ) acc <- a( acc , x )acc <- a( acc , x ) sinonsinon p <- E( p <- E( ( acc , x ) , p )( acc , x ) , p ) p <- E( p <- E( ( acc , x ) , p )( acc , x ) , p ) acc <- acc <- ( acc , x )( acc , x )
res <- accres <- acc
Initialisation de acc et p !Initialisation de acc et p !
Le prochain élémentLe prochain élémentest prélevé sur la pile !est prélevé sur la pile !
Sinon, nous empilonsSinon, nous empilonsles deux fils et nousles deux fils et nousrecommençons !recommençons !
Le résultat final est dans acc !Le résultat final est dans acc !
S’il est élémentaire,S’il est élémentaire,nous l’accumulons !nous l’accumulons !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1111
Sous forme d’arbreSous forme d’arbre----------------------------------------------------------------------------------------------------------------------------------
Dans la pile !Dans la pile !
XX
YYZZarbre = Tarbre = T
XX
ZZ
arbre <arbre <-- S( p ) S( p )p <p <-- D( p ) D( p )
kk
ll
YY
mm
acc = ( ( ( 0 + k ) + l ) + m )acc = ( ( ( 0 + k ) + l ) + m )
Dans l’accumulateur :Dans l’accumulateur :
acc = ( ( 0 + k ) + l )acc = ( ( 0 + k ) + l )
Premier cas :Premier cas :
feuille( arbre ) est vraifeuille( arbre ) est vrai
et valeur( arbre ) = met valeur( arbre ) = m
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1212
Sous forme d’arbreSous forme d’arbre----------------------------------------------------------------------------------------------------------------------------------
Dans la pile !Dans la pile !
XX
YYZZ
XX
ZZ
arbre <arbre <-- S( p ) S( p )p <p <-- D( p ) D( p )
kk
ll
YY
Dans l’accumulateur :Dans l’accumulateur :
acc = ( ( 0 + k ) + l )acc = ( ( 0 + k ) + l )
Second cas :Second cas :
feuille( arbre ) est fauxfeuille( arbre ) est faux
et fg( arbre ) = Uet fg( arbre ) = U
et fd( arbre ) = Vet fd( arbre ) = VVVUU
VV
UU
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1313
Deux appels récursifs, enveloppe associativeDeux appels récursifs, enveloppe associative----------------------------------------------------------------------------------------------------------------------------------
• Soient deux appels récursifs avec une enveloppe associative ! Soient deux appels récursifs avec une enveloppe associative !
• La forme générale est la suivante :La forme générale est la suivante :
• Le flot des informations est le suivant :Le flot des informations est le suivant :
f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( f( f( ( x ) )( x ) ) , , f( f( ( x ) )( x ) ) ) )
xxhh
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1414
Deux appels récursifs, enveloppe associativeDeux appels récursifs, enveloppe associative----------------------------------------------------------------------------------------------------------------------------------
• Nous nous ramenons au cas auto-enveloppé en posant :Nous nous ramenons au cas auto-enveloppé en posant :
g( acc , x ) = h( acc , f( x ) )g( acc , x ) = h( acc , f( x ) )
• Alors :Alors :
g( acc , x ) = h( acc , si ( g( acc , x ) = h( acc , si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( f( h( f( ( x ) ) , f( ( x ) ) , f( ( x ) ) ) )( x ) ) ) ) = si ( = si ( ( x ) )( x ) ) h( acc , a( x ) )h( acc , a( x ) ) sinonsinon h( h( acc acc , h( , h( f( f( ( x ) )( x ) ) , , f( f( ( x ) )( x ) ) ) ) ) ) h( h( h( h( acc acc , , f( f( ( x ) )( x ) ) ) , ) , f( f( ( x ) )( x ) ) ) ) h( g( h( g( acc acc , , ( x )( x ) ) , ) , f( f( ( x ) )( x ) ) ) ) g( g( g( g( acc acc , , ( x )( x ) ) , ) , ( x )( x ) ) )
Associativité de h!Associativité de h!Définition de g !Définition de g !Définition de g !Définition de g !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1515
Deux appels récursifs, enveloppe associativeDeux appels récursifs, enveloppe associative----------------------------------------------------------------------------------------------------------------------------------
• Nous nous ramenons au cas auto-enveloppé en posant :Nous nous ramenons au cas auto-enveloppé en posant :
g( acc , x ) = h( acc , f( x ) )g( acc , x ) = h( acc , f( x ) )
• Alors :Alors :
g( acc , x ) = si ( g( acc , x ) = si ( ( x ) )( x ) ) h( acc , a( x ) )h( acc , a( x ) ) sinonsinon g( g( acc , g( g( acc , ( x ) ) , ( x ) ) , ( x ) )( x ) )
• Le flot des informations a changé :Le flot des informations a changé :
Nous sommes doncNous sommes doncrevenus au cas d’unerevenus au cas d’une
fonction auto-enveloppée !fonction auto-enveloppée !
xxaccacc
xxhh
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1616
Deux appels récursifs, enveloppe associativeDeux appels récursifs, enveloppe associative----------------------------------------------------------------------------------------------------------------------------------
acc <- eacc <- ep <- E( v , I( ) )p <- E( v , I( ) )
while ( while ( V( p ) ) V( p ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) si ( si ( ( x ) )( x ) ) acc <- h( acc , a( x ) )acc <- h( acc , a( x ) ) sinonsinon p <- E( p <- E( ( x ) , p )( x ) , p ) p <- E( p <- E( ( x ) , p )( x ) , p )
res <- accres <- acc
• Pour deux appels avec une enveloppe « h » associative Pour deux appels avec une enveloppe « h » associative avec neutre « e », nous avons :avec neutre « e », nous avons :
res <- f( v )res <- f( v )
f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( f( h( f( ( x ) ) ,( x ) ) , f( f( ( x ) ) )( x ) ) )
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1717
Deux appels récursifs, enveloppe associativeDeux appels récursifs, enveloppe associative----------------------------------------------------------------------------------------------------------------------------------
• Si « h » est sans neutre, Si « h » est sans neutre, c’est plus embêtant.c’est plus embêtant.
• Le code :Le code :
x <- vx <- vp <- I( )p <- I( )
while ( while ( ( ( ( x ) )( x ) ) p <- E( p <- E( ( x ) , p )( x ) , p ) x <- x <- ( x )( x )
acc <- a( x )acc <- a( x )
while ( while ( V( p ) ) V( p ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) si ( si ( ( x ) )( x ) ) acc <- h( acc , a( x ) )acc <- h( acc , a( x ) ) sinonsinon p <- E( p <- E( ( x ) , p )( x ) , p ) p <- E( p <- E( ( x ) , p )( x ) , p )
res <- accres <- acc
L’initialisation est triviale !L’initialisation est triviale !
La descente à gauche versLa descente à gauche versla première feuille . Nousla première feuille . Nousempilons les fils droits.empilons les fils droits.
Finalement, nous pouvonsFinalement, nous pouvonsInitialiser l’accumulateur !Initialiser l’accumulateur !
Le reste ne change pas ! ! !Le reste ne change pas ! ! !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1818
Deux appels récursifs, enveloppe non associativeDeux appels récursifs, enveloppe non associative----------------------------------------------------------------------------------------------------------------------------------
• C’est le cas le plus compliqué à gérer ! C’est le cas le plus compliqué à gérer !
• Comme l’enveloppe n’est pas associative, nous Comme l’enveloppe n’est pas associative, nous devons respecter la structure de l’arbre :devons respecter la structure de l’arbre :
TraitementsTraitementsen attente !en attente !
XX
ZZ
TT
YY
Noeud courantNoeud courant
RésultatsRésultatsen attente !en attente !
La pile !La pile !XX
YY
ZZ
XX
XX
TT
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 1919
Deux appels récursifs, enveloppe non associativeDeux appels récursifs, enveloppe non associative----------------------------------------------------------------------------------------------------------------------------------
• Nous avons quatre variables globales :Nous avons quatre variables globales :
– la variable « x » qui indique l’élément à traiter,la variable « x » qui indique l’élément à traiter,
– la variable « res » qui indique le résultat courant,la variable « res » qui indique le résultat courant,
– la variable « marq » qui est la valeur du dernier la variable « marq » qui est la valeur du dernier marqueur,marqueur,
– la variable « p » qui est la pile courante.la variable « p » qui est la pile courante.
• Nous distinguons deux types de traitements :Nous distinguons deux types de traitements :
– cas 1 – la variable « x » ne vérifie pas le test d’arrêt,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.cas 2 – la variable « x » vérifie le test d’arrêt.
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2020
Deux appels récursifs, enveloppe non associativeDeux appels récursifs, enveloppe non associative----------------------------------------------------------------------------------------------------------------------------------
• Fusion des cas 1 & 2 - la variable « x » doit être traitée Fusion des cas 1 & 2 - la variable « x » doit être traitée ::
CALCUL :CALCUL : si ( si ( ( x ) )( x ) ) res <- a( x )res <- a( x )
goto PILEgoto PILE sinonsinon p <- E( p <- E( ( x ) , p ) ( x ) , p ) p <- E( p <- E( CC , p ) , p )
x <- x <- ( x )( x )
goto CALCULgoto CALCUL
UneUneboucle !boucle !
Une sortie !Une sortie !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2121
Deux appels récursifs, enveloppe non associativeDeux appels récursifs, enveloppe non associative----------------------------------------------------------------------------------------------------------------------------------
• Dès qu’il y a un résultat « res », nous inspectons la pile Dès qu’il y a un résultat « res », nous inspectons la pile ::
• Trois cas se présentent pour la pile :Trois cas se présentent pour la pile :
– cas 3 – elle est vide,cas 3 – elle est vide,
– cas 4 – elle a un marqueur « cas 4 – elle a un marqueur « CC » au sommet et » au sommet et
– cas 5 – elle a un marqueur « cas 5 – elle a un marqueur « RR » au sommet. » au sommet.
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2222
Deux appels récursifs, enveloppe non associativeDeux appels récursifs, enveloppe non associative----------------------------------------------------------------------------------------------------------------------------------
• Fusion desFusion des cas 3, 4 & 5 :cas 3, 4 & 5 :
PILE:PILE: si ( V( p ) )si ( V( p ) ) goto FINgoto FIN sinonsinon marq <- S( p )marq <- S( p ) p <- D( p )p <- D( p ) si ( marq = si ( marq = CC ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) p <- E( res , p )p <- E( res , p ) p <- E( p <- E( RR , p ) , p ) goto CALCULgoto CALCUL sinonsinon res <- h( S( p ) , res )res <- h( S( p ) , res ) p <- D( p )p <- D( p ) goto PILEgoto PILE
Nous consultonsNous consultonsle marqueur !le marqueur !
Nous allons traiter leNous allons traiter lesecond fils et sauvonssecond fils et sauvonsle résultat du premier !le résultat du premier !
Nous combinonsNous combinonsdeux résultats !deux résultats !
Une boucle !Une boucle !
Une sortie !Une sortie !
Une sortie !Une sortie !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2323
Deux appels récursifs, enveloppe non associativeDeux appels récursifs, enveloppe non associative----------------------------------------------------------------------------------------------------------------------------------
PILE:PILE: si ( V( p ) )si ( V( p ) ) goto FINgoto FIN sinonsinon marq <- S( p )marq <- S( p ) p <- D( p )p <- D( p ) si ( marq = si ( marq = CC ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) p <- E( res , p )p <- E( res , p ) p <- E( p <- E( RR , p ) , p ) goto CALCULgoto CALCUL sinonsinon res <- h( S( p ) , res )res <- h( S( p ) , res ) p <- D( p )p <- D( p ) goto PILEgoto PILE
CALCUL :CALCUL : si ( si ( ( x ) )( x ) ) res <- a( x )res <- a( x ) goto PILEgoto PILE sinonsinon p <- E( p <- E( ( x ) , p ) ( x ) , p ) p <- E( p <- E( CC , p ) , p ) x <- x <- ( x )( x ) goto CALCULgoto CALCUL
DEBUT :DEBUT : x <- vx <- v p <- I( )p <- I( ) goto CALCULgoto CALCUL
FIN :FIN : ......
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2424
Deux appels récursifs, enveloppe non associativeDeux appels récursifs, enveloppe non associative----------------------------------------------------------------------------------------------------------------------------------
while_PILE:while_PILE: while ( PILE )while ( PILE ) si ( V( p ) )si ( V( p ) ) PILE <- fauxPILE <- faux FIN <- vraiFIN <- vrai sinonsinon marq <- S( p )marq <- S( p ) p <- D( p )p <- D( p ) si ( marq = si ( marq = CC ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) p <- E( res , p )p <- E( res , p ) p <- E( p <- E( RR , p ) , p ) PILE <- fauxPILE <- faux CALCUL <- vraiCALCUL <- vrai sinonsinon res <- h( S( p ) , res )res <- h( S( p ) , res ) p <- D( p )p <- D( p )
while_CALCUL :while_CALCUL : while ( CALCUL )while ( CALCUL ) si ( si ( ( x ) )( x ) ) res <- a( x )res <- a( x ) CALCUL <- fauxCALCUL <- faux PILE <- vraiPILE <- vrai sinonsinon p <- E( p <- E( ( x ) , p ) ( x ) , p ) p <- E( p <- E( CC , p ) , p ) x <- x <- ( x )( x )
DEBUT :DEBUT : x <- vx <- v p <- I( )p <- I( ) FIN <- fauxFIN <- faux CALCUL <- vraiCALCUL <- vrai PILE <- fauxPILE <- faux while ( while ( FIN ) FIN ) while_CALCULwhile_CALCUL while_PILEwhile_PILE
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2525
acc <- initacc <- initp <- E( v , I( ) )p <- E( v , I( ) )
while ( while ( V( p ) ) V( p ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) si ( si ( ( acc , x ) )( acc , x ) ) acc <- a( acc , x )acc <- a( acc , x ) sinonsinon p <- E( p <- E( ( acc , x ) , p )( acc , x ) , p ) p <- E( p <- E( ( acc , x ) , p )( acc , x ) , p ) acc <- acc <- ( acc , x )( acc , x )
res <- accres <- acc
Deux appels récursifs --- résuméDeux appels récursifs --- résumé----------------------------------------------------------------------------------------------------------------------------------
• 5) Deux appels récursifs auto-enveloppés !5) Deux appels récursifs auto-enveloppés !
Code itératif peu raisonnable !Code itératif peu raisonnable !
f ( acc , x ) =f ( acc , x ) = si ( si ( ( acc , x ) )( acc , x ) ) a( acc , x )a( acc , x ) sinonsinon f( f( f( f( ( acc , x ) ,( acc , x ) , ( acc , x ) ) ,( acc , x ) ) , ( acc , x ) )( acc , x ) )
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2626
Deux appels récursifs --- résuméDeux appels récursifs --- résumé----------------------------------------------------------------------------------------------------------------------------------
• 6) Appels avec enveloppe associative et neutre « e » !6) Appels avec enveloppe associative et neutre « e » !
Code itératif peu raisonnable !Code itératif peu raisonnable !
f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( f( h( f( ( x ) ) , f( ( x ) ) , f( ( x ) ) )( x ) ) )
acc <- eacc <- ep <- E( v , I( ) )p <- E( v , I( ) )
while ( while ( V( p ) ) V( p ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) si ( si ( ( x ) )( x ) ) acc <- h( acc , a( x ) )acc <- h( acc , a( x ) ) sinonsinon p <- E( p <- E( ( x ) , p )( x ) , p ) p <- E( p <- E( ( x ) , p )( x ) , p )
res <- accres <- acc
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2727
x <- vx <- vp <- I( )p <- I( )
while ( while ( ( ( ( x ) )( x ) ) p <- E( p <- E( ( x ) , p )( x ) , p ) x <- x <- ( x )( x )
acc <- a( x )acc <- a( x )
while ( while ( V( p ) ) V( p ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) si ( si ( ( x ) )( x ) ) acc <- h( acc , a( x ) )acc <- h( acc , a( x ) ) sinonsinon p <- E( p <- E( ( x ) , p )( x ) , p ) p <- E( p <- E( ( x ) , p )( x ) , p )
res <- accres <- acc
Deux appels récursifs --- résuméDeux appels récursifs --- résumé----------------------------------------------------------------------------------------------------------------------------------
• 7) Appels avec enveloppe7) Appels avec enveloppe associative, sans neutre !associative, sans neutre !
Code itératif très peu raisonnable !Code itératif très peu raisonnable !
f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( f( h( f( ( x ) ) , f( ( x ) ) , f( ( x ) ) )( x ) ) )
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2828
Deux appels récursifs --- résuméDeux appels récursifs --- résumé----------------------------------------------------------------------------------------------------------------------------------
• 8) Appels avec enveloppe8) Appels avec enveloppe non associative !non associative !
Code itératif déraisonnable !Code itératif déraisonnable !
f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( f( h( f( ( x ) ) , f( ( x ) ) , f( ( x ) ) )( x ) ) )
while_PILE:while_PILE: while ( PILE )while ( PILE ) si ( V( p ) )si ( V( p ) ) PILE <- fauxPILE <- faux FIN <- vraiFIN <- vrai sinonsinon marq <- S( p )marq <- S( p ) p <- D( p )p <- D( p ) si ( marq = si ( marq = CC ) ) x <- S( p )x <- S( p ) p <- D( p )p <- D( p ) p <- E( res , p )p <- E( res , p ) p <- E( p <- E( RR , p ) , p ) PILE <- fauxPILE <- faux CALCUL <- vraiCALCUL <- vrai sinonsinon res <- h( S( p ) ,res <- h( S( p ) , res )res ) p <- D( p )p <- D( p )
while_CALCUL :while_CALCUL : while ( CALCUL )while ( CALCUL ) si ( si ( ( x ) )( x ) ) res <- a( x )res <- a( x ) CALCUL <- fauxCALCUL <- faux PILE <- vraiPILE <- vrai sinonsinon p <- E( b( x ) , p ) p <- E( b( x ) , p ) p <- E( C , p ) p <- E( C , p ) x <- a( x )x <- a( x )
DEBUT :DEBUT : x <- vx <- v p <- I( )p <- I( ) FIN <- fauxFIN <- faux CALCUL <- vraiCALCUL <- vrai PILE <- fauxPILE <- faux while ( while ( FIN ) FIN ) while_CALCULwhile_CALCUL while_PILEwhile_PILE
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 2929
Résumé généralRésumé général----------------------------------------------------------------------------------------------------------------------------------
Récursif !Récursif !
Itératif !Itératif !
Se ramène à …Se ramène à …
• Les quatre cas à unique appel récursif :Les quatre cas à unique appel récursif :
– Récursif terminal.Récursif terminal.
– Enveloppe associative avec neutre.Enveloppe associative avec neutre.
– Enveloppe associative sans neutre.Enveloppe associative sans neutre.
– Enveloppe non associative.Enveloppe non associative.
• Les quatre cas à deux appels récursifs :Les quatre cas à deux appels récursifs :
– Récursif auto-enveloppé.Récursif auto-enveloppé.
– Enveloppe associative avec neutre.Enveloppe associative avec neutre.
– Enveloppe associative sans neutre.Enveloppe associative sans neutre.
– Enveloppe non associative.Enveloppe non associative.
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3030
Algorithmes gloutonsAlgorithmes gloutons----------------------------------------------------------------------------------------------------------------------------------
• Greedy algorithms en anglais !Greedy algorithms en anglais !
• Une suite de Une suite de décisions optimales localesdécisions optimales locales
conduit àconduit à
un un optimum global !optimum global !
• Complexité pour « n » éléments :Complexité pour « n » éléments :
– O( n * x )O( n * x ) où O( x ) est la complexité de la décision locale !où O( x ) est la complexité de la décision locale !
– O( 2 ) O( 2 ) pour le back-track (cascade de décisions locales) ! pour le back-track (cascade de décisions locales) !nn
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3131
Algorithmes gloutonsAlgorithmes gloutons----------------------------------------------------------------------------------------------------------------------------------
• Exemple d’un choix glouton :Exemple d’un choix glouton :
– GLOBAL :GLOBAL : Choisir les 10 plus petits de l’amphi !Choisir les 10 plus petits de l’amphi !
– LOCAL :LOCAL : Trouver et retirer le plus petit !Trouver et retirer le plus petit !
• Ce choix est indépendant des autres personnes déjà Ce choix est indépendant des autres personnes déjà choisies ou restant à choisir.choisies ou restant à choisir.
• Exemple d’un choix Exemple d’un choix non non glouton :glouton :
– GLOBAL :GLOBAL : Choisir le plus court chemin de Marseille à Choisir le plus court chemin de Marseille à Paris !Paris !
– LOCAL :LOCAL : Trouver à partir de la ville courante, l’étape laTrouver à partir de la ville courante, l’étape la plus courte !plus courte !
• Un tel choix n’est pas sûr de nous rapprocher de Paris !Un tel choix n’est pas sûr de nous rapprocher de Paris !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3232
Action Selection ProblemAction Selection Problem----------------------------------------------------------------------------------------------------------------------------------
• Un exemple complet :Un exemple complet :
– Ensemble « E » de tâches, dont le « début » et la Ensemble « E » de tâches, dont le « début » et la « fin » sont connues !« fin » sont connues !
– t et t sont compatibles si leurs intersections sont t et t sont compatibles si leurs intersections sont vides !vides !
– OBJECTIF : Trouvez le plus grand ensemble deOBJECTIF : Trouvez le plus grand ensemble de tâches compatibles ! ! !tâches compatibles ! ! !
ii jj
i 1 2 3 4i 1 2 3 4
d 5 3 1 2d 5 3 1 2
f 7 9 4 5f 7 9 4 5ii
ii
i 1 2 3 4i 1 2 3 4
d 1 2 5 3d 1 2 5 3
f 4 5 7 9f 4 5 7 9ii
ii
Triées par f croissants !Triées par f croissants !ii
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3333
Action Selection ProblemAction Selection Problem----------------------------------------------------------------------------------------------------------------------------------
ens BT ( ens choisies , ens BT ( ens choisies , ens restantesens restantes ) = ) =si si ( restantes = {} )( restantes = {} ) choisieschoisiessinonsinon choix <- choisir( restantes )choix <- choisir( restantes ) restantes <- restantes \ { choix }restantes <- restantes \ { choix } sans_choix = BT( choisies , restantes )sans_choix = BT( choisies , restantes ) si si ( compatible( choix , choisies ) )( compatible( choix , choisies ) ) max_ens(max_ens( BT( choisies v { choix } , restantes ) BT( choisies v { choix } , restantes ) , , sans_choixsans_choix ) ) sinonsinon sans_choixsans_choix
Les tâches déjà choisies.Les tâches déjà choisies. Les tâches non encore considérées.Les tâches non encore considérées.
Assez naturel !Assez naturel !
Nous choisissons !Nous choisissons !
Nous avons toujours la possibilité de ne pas retenir la tâche choisie !Nous avons toujours la possibilité de ne pas retenir la tâche choisie !
Le choix est retenu s’il est compatible . . .Le choix est retenu s’il est compatible . . .
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3434
• Considérons :Considérons :
E( E( ii , , jj ) = { ) = { tt E | E | f <=f <= d <= fd <= f <= d<= d } }
• Initialisation :Initialisation :
– soit t avec f = 0 ,soit t avec f = 0 ,
– soit t avec d = +inf ,soit t avec d = +inf ,
– alors E = E( 0 , n+1 ) .alors E = E( 0 , n+1 ) .
Action Selection ProblemAction Selection Problem----------------------------------------------------------------------------------------------------------------------------------
kkkk kk jjii
00 00
n+1n+1 n+1n+1
ddjj
ffii dd
kkff
kk
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3535
• Décomposition :Décomposition :
{ } si E( i , j ) = { }{ } si E( i , j ) = { }
• S( i , j ) = S( i , j ) =
max_ens { max_ens { { t } v S( i , k ) v S( k , j ){ t } v S( i , k ) v S( k , j ) } sinon } sinon
Action Selection ProblemAction Selection Problem----------------------------------------------------------------------------------------------------------------------------------
ddjj
ffii dd
kkff
kk
E( i , j )E( i , j )t t E( i , j ) E( i , j )kk
{{{{E( i , k )E( i , k ) E( k , j )E( k , j )
{{t t E( i , j ) E( i , j )
kkkk
On maximiseOn maximisesur tous lessur tous leschoix pour t .choix pour t .kk
C’est la tâche t et les solutions optimales pour E( i , k ) et E( k , j ).C’est la tâche t et les solutions optimales pour E( i , k ) et E( k , j ).kk
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3636
. . .. . .
Action Selection ProblemAction Selection Problem----------------------------------------------------------------------------------------------------------------------------------
• Graphiquement, pour i < j :Graphiquement, pour i < j : Tâches triées par fTâches triées par f
croissants, donc i < k < j !croissants, donc i < k < j !
xx
ii
jj
S( i , j )S( i , j )
jj
ii
S( k , j )S( k , j )
S( i , k )S( i , k )
. . .. . .
Premier axe de tempsPremier axe de temps
Second axe de tempsSecond axe de temps
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3737
Action Selection ProblemAction Selection Problem----------------------------------------------------------------------------------------------------------------------------------
• L’approche gloutonne dit :L’approche gloutonne dit :
– Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) !Ce n’est pas la peine de parcourir toutes les tâches de E( i , j ) !
– S( i , j ) = max_ens { S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ){ t } v S( i , k ) v S( k , j ) } }
• Considérez la tâche t avec f minimal sur E( i , j ) ! Alors Considérez la tâche t avec f minimal sur E( i , j ) ! Alors ::
– S( i , j ) = max_ens { S( i , j ) = max_ens { { t } v S( i , k ) v S( k , j ){ t } v S( i , k ) v S( k , j ) } }
= = { t } v S( i , l ) v S( l , j ){ t } v S( i , l ) v S( l , j )
= = { t } v S( l , j ){ t } v S( l , j )
t t E( i , j ) E( i , j )kk
ll
kk
ll
kkt t E( i , j ) E( i , j )
kk
ll
ll
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3838
Action Selection ProblemAction Selection Problem----------------------------------------------------------------------------------------------------------------------------------
• Trois approches de solution :Trois approches de solution :
– Back-track ! Complexité : O ( 2^n )Back-track ! Complexité : O ( 2^n )
– Programmation dynamique ! Complexité : O ( n^2 )Programmation dynamique ! Complexité : O ( n^2 )
– Algorithme glouton ! Complexité : O ( n )Algorithme glouton ! Complexité : O ( n )
• L’algorithme glouton est souvent obtenu comme L’algorithme glouton est souvent obtenu comme optimisation d’une programmation dynamique !optimisation d’une programmation dynamique !
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 3939
Task Scheduling with PenaltiesTask Scheduling with Penalties----------------------------------------------------------------------------------------------------------------------------------
• Définition :Définition :
– « n » tâches de temps unitaires !« n » tâches de temps unitaires !
– Chaque tâche « t » comporte une deadline « d » etChaque tâche « t » comporte une deadline « d » et
une pénalité « p », due si la deadline est dépassée.une pénalité « p », due si la deadline est dépassée.
– Objectif : Trouver un ordonnancement qui minimise Objectif : Trouver un ordonnancement qui minimise la somme des pénalités !la somme des pénalités !
ii
ii ii
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 4040
Task Scheduling with PenaltiesTask Scheduling with Penalties----------------------------------------------------------------------------------------------------------------------------------
• Solution :Solution :
• Pourquoi est-ce correct ?Pourquoi est-ce correct ?
– Soit une suite optimale de tâches :Soit une suite optimale de tâches :
( t , . . . , t , t , . . . , t )( t , . . . , t , t , . . . , t )
Trier les tâches par deadlines croissantes.Trier les tâches par deadlines croissantes.
Parcourir les tâches et retenir celles quiParcourir les tâches et retenir celles quipeuvent être exécutées dans les temps.peuvent être exécutées dans les temps.
Compléter par les autres !Compléter par les autres !
i+1i+111 nnii
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 4141
Task Scheduling with PenaltiesTask Scheduling with Penalties----------------------------------------------------------------------------------------------------------------------------------
• Correction :Correction :
– Soit une suite optimale de tâches :Soit une suite optimale de tâches :
( t , . . . , t , t , . . . , t )( t , . . . , t , t , . . . , t )
avec t en retard et t à l’heure.avec t en retard et t à l’heure.
• On peut échanger t et t sans changer la pénalité :On peut échanger t et t sans changer la pénalité :
– t plus tôt, OK, et t plus tard, OK.t plus tôt, OK, et t plus tard, OK.
• Donc, il existe une solution optimale telle que :Donc, il existe une solution optimale telle que :
( t’ , . . . , t’ , t’ , . . . , t’ )( t’ , . . . , t’ , t’ , . . . , t’ )
à l’heure à l’heure en retarden retard
i+1i+111 nnii
ii i+1i+1
ii i+1i+1
iii+1i+1
k+1k+111 nnkk
4 décembre 20064 décembre 2006 Cours d'algorithmique 8 - IntranetCours d'algorithmique 8 - Intranet 4242
Task Scheduling with PenaltiesTask Scheduling with Penalties----------------------------------------------------------------------------------------------------------------------------------
• Correction :Correction :
– Dans une suite optimale, si t et t sont à l’heure et queDans une suite optimale, si t et t sont à l’heure et que
d > d , on peut les échanger sans modifier les pénalités.d > d , on peut les échanger sans modifier les pénalités.
– Sans pénalité : f <= d et f <= d . Sans pénalité : f <= d et f <= d .
– Par ailleurs : f < f <= d < d .Par ailleurs : f < f <= d < d .
– Donc : f < d et f < d .Donc : f < d et f < d .
• Donc, il existe une solution optimale telle que :Donc, il existe une solution optimale telle que :
( t’ , . . . , t’ , t’ , . . . , t’ )( t’ , . . . , t’ , t’ , . . . , t’ )
à l’heure et d croissants à l’heure et d croissants en retard CQFD.en retard CQFD.
i+1i+1ii
ii i+1i+1
ii i+i+11
ii
i+1i+1
ii i+i+11
ii i+i+11
i+i+11
i+1i+1iiii
k+1k+111 nnkk
ii