Cours d'algorithmique 8 - Intranet 1 4 décembre 2006 Cours dAlgorithmique Dérécursion (fin) :...

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


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 ! ! !


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.



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 !



• 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.



• 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.



• 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



• 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 ) ) )



• 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 !


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


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


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



• 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 !



• 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



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 )


• 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 ) ) )



• 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 )



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 ! ! !


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



• 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.



• 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 !



• 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.



• 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 !





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 : ......



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


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 )


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 ) )



• 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( ) )




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 )




• 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 !




• 8) Appels avec enveloppe8) Appels avec enveloppe non associative !non associative !

Code itératif déraisonnable !Code itératif déraisonnable !


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


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.


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


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 !


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



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 . . .


• 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 ) .


kkkk kk jjii

00 00

n+1n+1 n+1n+1

ddjj

ffii dd

kkff

kk


• 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


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


. . .. . .


• 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



• 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



• 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 !


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



• 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



• 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



• 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

Cours d'algorithmique 8 - Intranet 1 4 décembre 2006 Cours dAlgorithmique Dérécursion (fin) :...

Documents

Transcript of Cours d'algorithmique 8 - Intranet 1 4 décembre 2006 Cours dAlgorithmique Dérécursion (fin) :...