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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

19 4 décembre 2006Cours d'algorithmique 8 - Intranet19 Deux appels récursifs, enveloppe non associative ----------------------------------------------------------------- Nous avons quatre variables globales : Nous avons quatre variables globales : – la variable « x » qui indique lélément à traiter, – la variable « res » qui indique le résultat courant, – la variable « marq » qui est la valeur du dernier marqueur, – la variable « p » qui est la pile courante. Nous distinguons deux types de traitements : Nous distinguons deux types de traitements : – cas 1 – la variable « x » ne vérifie pas le test darrêt, – cas 2 – la variable « x » vérifie le test darrêt.

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

21 4 décembre 2006Cours d'algorithmique 8 - Intranet21 Deux appels récursifs, enveloppe non associative ----------------------------------------------------------------- Dès quil y a un résultat « res », nous inspectons la pile : Dès quil y a un résultat « res », nous inspectons la pile : Trois cas se présentent pour la pile : Trois cas se présentent pour la pile : – cas 3 – elle est vide, – cas 4 – elle a un marqueur « C » au sommet et – cas 5 – elle a un marqueur « R » au sommet.

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

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

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

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

26 4 décembre 2006Cours d'algorithmique 8 - Intranet26 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 ! f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( f( ( x ) ), f( ( x ) ) ) h( f( ( x ) ), f( ( x ) ) ) acc <- e p <- E( v, I( ) ) while ( V( p ) ) x <- S( p ) x <- S( p ) p <- D( p ) p <- D( p ) si ( ( x ) ) si ( ( x ) ) acc <- h( acc, a( x ) ) acc <- h( acc, a( x ) ) sinon sinon p <- E( ( x ), p ) p <- E( ( x ), p ) res <- acc

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

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

29 4 décembre 2006Cours d'algorithmique 8 - Intranet29 Résumé général ----------------------------------------------------------------- Récursif ! Itératif ! Se ramène à … Les quatre cas à unique appel récursif : Les quatre cas à unique appel récursif : – Récursif terminal. – Enveloppe associative avec neutre. – Enveloppe associative sans neutre. – Enveloppe non associative. Les quatre cas à deux appels récursifs : Les quatre cas à deux appels récursifs : – Récursif auto-enveloppé. – Enveloppe associative avec neutre. – Enveloppe associative sans neutre. – Enveloppe non associative.

30 4 décembre 2006Cours d'algorithmique 8 - Intranet30 Algorithmes gloutons ----------------------------------------------------------------- Greedy algorithms en anglais ! Greedy algorithms en anglais ! Une suite de décisions optimales locales Une suite de décisions optimales locales conduit à conduit à un optimum global ! un optimum global ! Complexité pour « n » éléments : Complexité pour « n » éléments : – O( n * x ) où O( x ) est la complexité de la décision locale ! – O( 2 ) pour le back-track (cascade de décisions locales) ! n

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

32 4 décembre 2006Cours d'algorithmique 8 - Intranet32 Action Selection Problem ----------------------------------------------------------------- Un exemple complet : Un exemple complet : – Ensemble « E » de tâches, dont le « début » et la « fin » sont connues ! – t et t sont compatibles si leurs intersections sont vides ! – OBJECTIF : Trouvez le plus grand ensemble de tâches compatibles ! ! ! tâches compatibles ! ! ! i j i 1 2 3 4 d 5 3 1 2 f 7 9 4 5 i i i 1 2 3 4 d 1 2 5 3 f 4 5 7 9 i i Triées par f croissants ! i

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

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

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

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

37 4 décembre 2006Cours d'algorithmique 8 - Intranet37 Action Selection Problem ----------------------------------------------------------------- Lapproche gloutonne dit : Lapproche gloutonne dit : – Ce nest pas la peine de parcourir toutes les tâches de E( i, j ) ! – S( i, j ) = max_ens { { t } v S( i, k ) v S( k, j ) } Considérez la tâche t avec f minimal sur E( i, j ) ! Alors : Considérez la tâche t avec f minimal sur E( i, j ) ! Alors : – S( i, j ) = max_ens { { t } v S( i, k ) v S( k, j ) } = { t } v S( i, l ) v S( l, j ) = { t } v S( i, l ) v S( l, j ) = { t } v S( l, j ) = { t } v S( l, j ) t E( i, j ) k l k l k k l l

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

39 4 décembre 2006Cours d'algorithmique 8 - Intranet39 Task Scheduling with Penalties ----------------------------------------------------------------- Définition : Définition : – « n » tâches de temps unitaires ! – Chaque tâche « t » comporte une deadline « d » et une pénalité « p », due si la deadline est dépassée. une pénalité « p », due si la deadline est dépassée. – Objectif : Trouver un ordonnancement qui minimise la somme des pénalités ! i ii

40 4 décembre 2006Cours d'algorithmique 8 - Intranet40 Task Scheduling with Penalties ----------------------------------------------------------------- Solution : Solution : Pourquoi est-ce correct ? Pourquoi est-ce correct ? – Soit une suite optimale de tâches : ( t,..., t, t,..., t ) ( t,..., t, t,..., t ) Trier les tâches par deadlines croissantes. Parcourir les tâches et retenir celles qui peuvent être exécutées dans les temps. Compléter par les autres ! i+1 1 n i

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

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