Cours d’Algorithmique L’algorithme alpha-beta. Sous-arbres alpha et beta d’un arbre minimax et propriétés. Arbres de recherche équilibrés : la problématique, diverses solutions. Recherche textuelle. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Présentation générale Les grandes lignes du cours Trier et chercher, recherche textuelle Listes et arbres Le back-track Arbres équilibrés Récursivité et induction sur la structure Divide and conquer Minimax, alpha-beta Dérécursion Divers problèmes particuliers Logique de Hoare Programmation dynamique Complexité et calculabilité 16 novembre 2006 Cours d'algorithmique 4 - Intranet Cours d'algorithmique

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- A R B R E A L P H A - B E T A 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max 5 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max 5 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : [ 5 … +inf [ Nous nous arrêtons dès que nous savons qu’elle sera inférieure à 5 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 5 … +inf [ 5 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : [ 5 … +inf [ Nous nous arrêtons dès que nous savons qu’elle sera inférieure à 5 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 5 … +inf [ 5 min 3 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : [ 5 … +inf [ Nous nous arrêtons dès que nous savons qu’elle sera inférieure à 5 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 5 … +inf [ 5 min Coupe ! 3 < 5 !!! 3 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : [ 5 … +inf [ Nous nous arrêtons dès que nous savons qu’elle sera inférieure à 5 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 5 … +inf [ 5 min Poursuite! 7 > 5 !!! 7 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : [ 5 … +inf [ Nous nous arrêtons dès que nous savons qu’elle sera inférieure à 5 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- min 3 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- min 3 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : ] -inf … 3 ] Nous nous arrêtons dès que nous savons qu’elle sera supérieure à 3 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- min ] -inf … 3 ] 3 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : ] -inf … 3 ] Nous nous arrêtons dès que nous savons qu’elle sera supérieure à 3 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- min ] -inf … 3 ] 3 max 5 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : ] -inf … 3 ] Nous nous arrêtons dès que nous savons qu’elle sera supérieure à 3 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- min ] -inf … 3 ] 3 max Coupe ! 5 > 3 !!! 5 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : ] -inf … 3 ] Nous nous arrêtons dès que nous savons qu’elle sera supérieure à 3 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- min ] -inf … 3 ] 3 max Poursuite! 1 < 3 !!! 1 ? Nous parcourons le fils droit pour trouver une valeur dans l’intervalle : ] -inf … 3 ] Nous nous arrêtons dès que nous savons qu’elle sera supérieure à 3 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ 3 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ 3 min [ 3 … 9 ] 9 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ 3 min [ 3 … 9 ] 9 max [ 4 … 9 ] 4 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ 3 min [ 3 … 9 ] 9 max [ 4 … 9 ] 4 min [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ [ a , b ] 3 min [ 3 … 9 ] 9 max [ 4 … 9 ] 4 min [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ [ a , b ] 3 min a est la borne minimale garantie ! a grandit seulement … [ 3 … 9 ] 9 max [ 4 … 9 ] 4 min [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ [ a , b ] 3 min a est la borne minimale garantie ! a grandit seulement … [ 3 … 9 ] 9 max [ 4 … 9 ] 4 min [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ [ a , b ] 3 min b est la borne maximale possible ! b diminue seulement … [ 3 … 9 ] 9 max [ 4 … 9 ] 4 min [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ [ a , b ] 3 min b est la borne maximale possible ! b diminue seulement … [ 3 … 9 ] 9 max [ 4 … 9 ] 4 min [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ 3 min [ 3 … 9 ] 9 max [ 4 … 9 ] 4 min Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- ? max [ 3 … +inf [ ? 3 min [ 3 … 9 ] ? 9 max [ 4 … 9 ] ? 4 min Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. 4 <= ? <= 7 [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- ? max [ 3 … +inf [ ? 3 min [ 3 … 9 ] ? 9 max [ 4 … 9 ] ? 4 min Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. 4 <= ? <= 7 [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ 3 min [ 3 … 9 ] 9 max [ 4 … 9 ] ? 4 min Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. ? <= 4 [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- 4 max [ 3 … +inf [ 4 3 min [ 3 … 9 ] 4 9 max [ 4 … 9 ] 4 min ? Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. ? < 4 [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- 4 max [ 3 … +inf [ 4 3 min [ 3 … 9 ] 4 9 max [ 4 … 9 ] 4 min ? Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. ? < 4 [ 4 … 7 ] 7 ? Fail Low 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max [ 3 … +inf [ 3 min [ 3 … 9 ] 9 max [ 4 … 9 ] 4 min 7 < ? Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- 7 max [ 3 … +inf [ 7 3 min [ 3 … 9 ] 7 9 max [ 4 … 9 ] 7 4 min 7 < ? Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. [ 4 … 7 ] 7 ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- 7 max [ 3 … +inf [ 7 3 min [ 3 … 9 ] 7 9 max [ 4 … 9 ] 7 4 min 7 < ? Discussion de la valeur de « ? » par rapport à l’intervalle [ 4 … 7 ]. [ 4 … 7 ] 7 ? Fail High 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- int alpha_beta ( un_type situation , int max_ou_pas , int alpha , int beta ) {if ( est_feuille(situation) ) return( valeur(situation) ) ; else if ( max_ou_pas ) xxx yyy } 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- int alpha_beta ( un_type situation , int max_ou_pas , int alpha , int beta ) {if ( est_feuille(situation) ) return( valeur(situation) ) ; else if ( max_ou_pas ) xxx yyy } Cas d’arrêt : Nous rendons la valeur de la situation ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- int alpha_beta ( un_type situation , int max_ou_pas , int alpha , int beta ) {if ( est_feuille(situation) ) return( valeur(situation) ) ; else if ( max_ou_pas ) xxx yyy } Le cas max ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- int alpha_beta ( un_type situation , int max_ou_pas , int alpha , int beta ) {if ( est_feuille(situation) ) return( valeur(situation) ) ; else if ( max_ou_pas ) xxx yyy } Le cas min ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- xxx Traitement les fils de max for ( « fils » parmi les fils de situation & tantque alpha < beta ) alpha := max( alpha , alpha_beta( fils , not(max_ou_pas) , alpha , beta ) ); return( min(alpha , beta) ); 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- xxx Traitement les fils de max for ( « fils » parmi les fils de situation & tantque alpha < beta ) alpha := max( alpha , alpha_beta( fils , not(max_ou_pas) , alpha , beta ) ); return( min(alpha , beta) ); Parcourons tous les fils, mais arrêtons-nous dès que alpha atteint beta ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- xxx Traitement les fils de max for ( « fils » parmi les fils de situation & tantque alpha < beta ) alpha := max( alpha , alpha_beta( fils , not(max_ou_pas) , alpha , beta ) ); return( min(alpha , beta) ); Parcourons tous les fils, mais arrêtons-nous dès que alpha atteint beta ! alpha peut grandir ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- xxx Traitement les fils de max for ( « fils » parmi les fils de situation & tantque alpha < beta ) alpha := max( alpha , alpha_beta( fils , not(max_ou_pas) , alpha , beta ) ); return( min(alpha , beta) ); Parcourons tous les fils, mais arrêtons-nous dès que alpha atteint beta ! alpha peut grandir ! Rendre « alpha » ou bien « beta » si alpha > beta ! a <= b 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- yyy Traitement les fils de min for ( « fils » parmi les fils de situation & tantque alpha <= beta ) beta := min( beta , alpha_beta( fils , not(max_ou_pas) , alpha , beta ) ); return( max(alpha , beta) ); 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- yyy Traitement les fils de min for ( « fils » parmi les fils de situation & tantque alpha < beta ) beta := min( beta , alpha_beta( fils , not(max_ou_pas) , alpha , beta ) ); return( max(alpha , beta) ); Parcourons tous les fils, mais arrêtons-nous dès que beta atteint alpha ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- yyy Traitement les fils de min for ( « fils » parmi les fils de situation & tantque alpha < beta ) beta := min( beta , alpha_beta( fils , not(max_ou_pas) , alpha , beta ) ); return( max(alpha , beta) ); Parcourons tous les fils, mais arrêtons-nous dès que beta atteint alpha ! beta peut diminuer ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- yyy Traitement les fils de min for ( « fils » parmi les fils de situation & tantque alpha < beta ) beta := min( beta , alpha_beta( fils , not(max_ou_pas) , alpha , beta ) ); return( max(alpha , beta) ); Parcourons tous les fils, mais arrêtons-nous dès que beta atteint alpha ! beta peut diminuer ! Rendre « beta » ou bien « alpha » si beta < alpha ! a <= b 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha ----------------------------------------------------------------- A R B R E A L P H A 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet alpha - beta ----------------------------------------------------------------- max min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha ----------------------------------------------------------------- Nous gardons tous les fils des min . Nous gardons un fils des max (choisi au hasard). max min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha ----------------------------------------------------------------- Nous gardons tous les fils des min . Nous gardons un fils des max (choisi au hasard). 3 max Minimax = minimum ! ! ! min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha ----------------------------------------------------------------- Nous gardons tous les fils des min . Nous gardons un fils des max (choisi au hasard). 3 max Minimax = minimum ! ! ! min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha ----------------------------------------------------------------- Un autre arbre alpha. max min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha ----------------------------------------------------------------- Un autre arbre alpha. 1 max Minimax = minimum ! ! ! min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha ----------------------------------------------------------------- A R B R E B E T A 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre beta ----------------------------------------------------------------- Nous gardons tous les fils des max . Nous gardons un fils des min (choisi au hasard). max min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre beta ----------------------------------------------------------------- Nous gardons tous les fils des max . Nous gardons un fils des min (choisi au hasard). 7 max Minimax = maximum ! ! ! min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre beta ----------------------------------------------------------------- Nous gardons tous les fils des max . Nous gardons un fils des min (choisi au hasard). 7 max Minimax = maximum ! ! ! min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre beta ----------------------------------------------------------------- Un autre arbre beta. max min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre beta ----------------------------------------------------------------- Un autre arbre beta. 8 max Minimax = maximum ! ! ! min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Pour tout arbre A , pour tout sous-arbre alpha de A , alpha( A ) , pour tout sous-arbre beta de A , beta( A ) : minimax ( alpha( A ) ) <= minimax ( A ) <= minimax ( beta( A ) ) Exercice ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Pour tout arbre A , pour tout sous-arbre alpha de A , alpha( A ) , pour tout sous-arbre beta de A , beta( A ) : minimax ( alpha( A ) ) <= minimax ( A ) <= minimax ( beta( A ) ) il existe un sous-arbre alpha de A , alpha_opt( A ) , il existe un sous-arbre beta de A , beta_opt( A ) : minimax ( alpha_opt( A ) ) = minimax ( A ) = minimax ( beta_opt( A ) ) Les liens communs à alpha_opt( A ) et beta_opt( A ) correspondent au chemin minimax de A . Exercice 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Un arbre alpha optimal. 3 max min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Un arbre beta optimal. 3 max min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Un arbre alpha optimal. Un arbre beta optimal. Le chemin minimax. 3 max min min max max max max min min min min 3 1 6 2 5 3 7 1 3 2 8 7 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Preuve : A est une feuille : alpha_opt( A ) = beta_opt( A ) = A , trivial ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Preuve : A est une feuille : alpha_opt( A ) = beta_opt( A ) = A , trivial ! A est l’arbre ci-dessous avec B meilleur que C , i.e. minimax( A ) = minimax( B ) >= minimax( C ) : max B C 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Preuve : A est une feuille : alpha_opt( A ) = beta_opt( A ) = A , trivial ! A est l’arbre ci-dessous avec B meilleur que C , i.e. minimax( A ) = minimax( B ) >= minimax( C ) : Pour B , par hypothèse, de même pour C : minimax ( alpha_opt( B ) ) = minimax ( B ) = minimax ( beta_opt( B ) ) Les liens communs entre alpha_opt( B ) et beta_opt( B ) correspondent au chemin minimax de B . max B C 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- alpha_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( alpha_opt( B ) ) = minimax( alpha_opt( A ) ) >= minimax( C ) max alpha_opt(B) C 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- alpha_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( alpha_opt( B ) ) = minimax( alpha_opt( A ) ) >= minimax( C ) beta_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( beta_opt( B ) ) = minimax( beta_opt( A ) ) max alpha_opt(B) C max beta_opt(B) beta_opt(C) 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- alpha_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( alpha_opt( B ) ) = minimax( alpha_opt( A ) ) >= minimax( C ) beta_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( beta_opt( B ) ) = minimax( beta_opt( A ) ) Chemin minimax : l’arête verte plus le minimax dans B . max alpha_opt(B) C max beta_opt(B) beta_opt(C) 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Preuve (suite) : A est l’arbre ci-dessous avec B meilleur que C , i.e. minimax( A ) = minimax( B ) <= minimax( C ) : Pour B , par hypothèse, de même pour C : minimax ( alpha_opt( B ) ) = minimax ( B ) = minimax ( beta_opt( B ) ) Les liens communs entre alpha_opt( B ) et beta_opt( B ) correspondent au chemin minimax de B . min B C 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- alpha_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( alpha_opt( B ) ) = minimax( alpha_opt( A ) ) min alpha_opt(B) alpha_opt(C) 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- alpha_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( alpha_opt( B ) ) = minimax( alpha_opt( A ) ) beta_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( beta_opt( B ) ) = minimax( beta_opt( A ) ) min alpha_opt(B) alpha_opt(C) min beta_opt(B) C 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- alpha_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( alpha_opt( B ) ) = minimax( alpha_opt( A ) ) beta_opt( A ) est l’arbre : minimax( A ) = minimax( B ) = minimax( beta_opt( B ) ) = minimax( beta_opt( A ) ) Chemin minimax : l’arête verte plus le minimax dans B . min alpha_opt(B) alpha_opt(C) min beta_opt(B) C 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Théorème (exercice) : Si le chemin minimax de l’arbre A est le chemin le plus à gauche dans l’arbre, alors alpha-beta parcourt exactement la superposition d’un arbre alpha optimal et d’un arbre beta optimal. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Théorème (exercice) : Si le chemin minimax de l’arbre A est le chemin le plus à gauche dans l’arbre, alors alpha-beta parcourt exactement la superposition d’un arbre alpha optimal et d’un arbre beta optimal. Heuristique « meilleur d’abord » : Au moment de générer les fils du nœud père, il faut essayer de les trier du (probablement) meilleur au (probablement) pire. Cela semble logique ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Théorème : Un arbre minimax de profondeur uniforme 2p vérifie : Il possède 2 feuilles ! Tout sous-arbre alpha ou beta qu’il contient a 2 feuilles ! Il faut inspecter au minimum 2 * 2 - 1 feuilles pour déterminer la valeur minimax de cet arbre. Ceci correspond à la superposition d’un meilleur sous-arbre alpha avec un meilleur sous-arbre beta . 2p p p 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbre alpha et arbre beta ----------------------------------------------------------------- Parcours de l’arbre minimax optimal : C’est un parcours « best-first » l’ordre de parcours dépend de la « valeur » des noeuds et non de l’ordre de filiation. L’algorithme SSS* (lire : SSS star) de Stockman. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- C h a n g e o n s d e s u j e t ! A R B R E S D E R E C H E R C H E E Q U I L I B R E S ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Arbre de recherche : Les feuilles correspondent aux informations qui admettent un ordre, par exemple celui des entiers. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Arbre de recherche : Les feuilles correspondent aux informations qui admettent un ordre, par exemple celui des entiers. Les nœuds internes comportent une étiquette qui permet d’orienter la recherche, car : les valeurs accessibles dans le sous-arbre de gauche sont plus petites que l‘étiquette, et celles de droite plus grandes ou égales. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Arbre de recherche : Les feuilles correspondent aux informations qui admettent un ordre, par exemple celui des entiers. Les nœuds internes comportent une étiquette qui permet d’orienter la recherche, car : les valeurs accessibles dans le sous-arbre de gauche sont plus petites que l‘étiquette, et celles de droite plus grandes ou égales. L’idée de la recherche par dichotomie est sous-jacente ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- 10 Etiquettes. 6 15 4 7 14 16 15 24 Valeurs. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- 10 Etiquettes. 6 15 4 7 14 16 int recherche ( int x , ptr_arbre arbre ) {if ( feuille( arbre ) ) return( valeur( arbre ) == x ); else if ( x < etiquette( arbre ) ) return( recherche( x , fils_gauche( arbre ) ) ) ; return( recherche( x , fils_droit( arbre ) ) ) ; } 15 24 Valeurs. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- 10 Etiquettes. 6 15 4 7 14 16 int recherche ( int x , ptr_arbre arbre ) {if ( feuille( arbre ) ) return( valeur( arbre ) == x ); else if ( x < etiquette( arbre ) ) return( recherche( x , fils_gauche( arbre ) ) ) ; return( recherche( x , fils_droit( arbre ) ) ) ; } 15 24 Valeurs. Trivial ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- 10 Etiquettes. 6 15 4 7 14 16 int recherche ( int x , ptr_arbre arbre ) {if ( feuille( arbre ) ) return( valeur( arbre ) == x ); else if ( x < etiquette( arbre ) ) return( recherche( x , fils_gauche( arbre ) ) ) ; return( recherche( x , fils_droit( arbre ) ) ) ; } 15 24 Valeurs. A gauche ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- 10 Etiquettes. 6 15 4 7 14 16 int recherche ( int x , ptr_arbre arbre ) {if ( feuille( arbre ) ) return( valeur( arbre ) == x ); else if ( x < etiquette( arbre ) ) return( recherche( x , fils_gauche( arbre ) ) ) ; return( recherche( x , fils_droit( arbre ) ) ) ; } 15 24 Valeurs. A gauche ! ! ! A droite ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Complexité : Recherche : profondeur de l’arbre. Insertion : profondeur de l’arbre. Suppression : profondeur de l’arbre. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Complexité : Recherche : profondeur de l’arbre. Insertion : profondeur de l’arbre. Suppression : profondeur de l’arbre. La profondeur est minimale si l’arbre est équilibré, c’est-à-dire que toutes les feuilles sont +/- à la même profondeur ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Complexité : Recherche : profondeur de l’arbre. Insertion : profondeur de l’arbre. Suppression : profondeur de l’arbre. La profondeur est minimale si l’arbre est équilibré, c’est-à-dire que toutes les feuilles sont +/- à la même profondeur ! Pour un arbre équilibré avec « n » feuilles, nous avons une profondeur de « log n ». 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Complexité des arbres de recherche équilibrés : Tout en « log n ». 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Complexité des arbres de recherche équilibrés : Tout en « log n ». Complexité des tableaux triés : Recherche en « log n ». Insertion et suppression en « n ». 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Complexité des arbres de recherche équilibrés : Tout en « log n ». Complexité des tableaux triés : Recherche en « log n ». Insertion et suppression en « n ». Complexité des listes triées : Tout en « n ». 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- Complexité des arbres de recherche équilibrés : Tout en « log n ». Complexité des tableaux triés : Recherche en « log n ». Insertion et suppression en « n ». Complexité des listes triées : Tout en « n ». Hashage : Comme pour les arbres, si c’est bien fait ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- 10 Si l’arbre est très déséquilibré : Tout en « n ». 7 15 14 16 26 15 24 54 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres de recherche équilibrés ----------------------------------------------------------------- 10 15 24 26 7 54 14 16 Si l’arbre est très déséquilibré : Tout en « n ». Comme pour une liste : 10 15 24 26 7 54 14 16 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Maintien de l’équilibre ----------------------------------------------------------------- Les insertions et suppressions peuvent casser l’équilibre : Situation équilibrée 10 6 15 4 7 14 15 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Maintien de l’équilibre ----------------------------------------------------------------- Les insertions et suppressions peuvent casser l’équilibre : 10 Ajout de l’élément 24, l’équilibre est sauvegardé ! 6 15 4 7 14 16 15 24 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Maintien de l’équilibre ----------------------------------------------------------------- Les insertions et suppressions peuvent casser l’équilibre : Suppression de l’élément 7 : L’équilibre est cassé! 10 15 4 14 16 15 24 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- A R B R E S 2 - 3 - 4 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Trois types de nœuds internes : binaires avec une étiquette pour les séparer, ternaires avec deux étiquettes pour les séparer, quaternaires avec trois étiquettes pour les séparer. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Un nœud binaire devient ternaire : Un nœud ternaire devient quaternaire : x y x v y x y z x y v z 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Un nœud quaternaire pourrait être découpé comme suit : x y z t x y z v t 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Un nœud quaternaire pourrait être découpé comme suit : Mais, nous accroissons la profondeur sans savoir si c’est vraiment indispensable ! x y z t x y z v t 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Une autre stratégie : x y z t Il faut éclater ( x, y , z , t ) ! Essayons de rattacher ( x , y ) et ( z , v , t ) comme frères sous le père de ( x , y , z , t ) ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Une autre stratégie : Père x y z t Il faut éclater ( x, y , z , t ) ! Essayons de rattacher ( x , y ) et ( z , v , t ) comme frères sous le père de ( x , y , z , t ) ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Une autre stratégie : Père x y z t x y z v t Il faut éclater ( x, y , z , t ) ! Essayons de rattacher ( x , y ) et ( z , v , t ) comme frères sous le père de ( x , y , z , t ) ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Une autre stratégie : Nous augmentons donc l’arité du père d’une unité ! Père x y z t x y z v t Il faut éclater ( x, y , z , t ) ! Essayons de rattacher ( x , y ) et ( z , v , t ) comme frères sous le père de ( x , y , z , t ) ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Le problème est résolu, à moins que le père ne soit quaternaire ! Dans ce cas, nous recommençons récursivement pour le père ! Dans le pire des cas, nous devons remonter à la racine … 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Le problème est résolu, à moins que le père ne soit quaternaire ! Dans ce cas, nous recommençons récursivement pour le père ! Dans le pire des cas, nous devons remonter à la racine … et, si elle est quaternaire, l’éclater comme suit : La nouvelle racine ! La racine ! et w x y z t x y z w t 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Insertion d’une valeur « v » dans un tel arbre. Le problème est résolu, à moins que le père ne soit quaternaire ! Dans ce cas, nous recommençons récursivement pour le père ! Dans le pire des cas, nous devons remonter à la racine … et, si elle est quaternaire, l’éclater comme suit : La profondeur de toutes les feuilles augmente alors en même temps ! et w x y z t x y z w t 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Suppression d’une valeur « v » dans un tel arbre. Un nœud quaternaire devient ternaire et un nœud ternaire devient binaire! Problème pour les nœuds binaires ! Il y a deux cas à considérer. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Suppression d’une valeur « v » dans un tel arbre. Un nœud quaternaire devient ternaire et un nœud ternaire devient binaire! Problème pour les nœuds binaires ! Il y a deux cas à considérer. Un des frères est quaternaire : x v a b c d x a b c d 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres 2 - 3 - 4 ----------------------------------------------------------------- Suppression d’une valeur « v » dans un tel arbre. Aucun frère n’est quaternaire. Le voisin « x » de « v » est inséré chez un frère ! Nous diminuons l’arité du père et nous devons peut-être recommencer récursivement ! ! ! x v b c d x b c d 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres red - black ----------------------------------------------------------------- Les arbres 2 – 3 – 4 peuvent être représentés à l’aide de nœuds binaires uniquement, en rajoutant une couleur ( red ou black ). 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres red - black ----------------------------------------------------------------- Les arbres 2 – 3 – 4 peuvent être représentés à l’aide de nœuds binaires uniquement, en rajoutant une couleur ( red ou black ). 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres red - black ----------------------------------------------------------------- Les arbres 2 – 3 – 4 peuvent être représentés à l’aide de nœuds binaires uniquement, en rajoutant une couleur ( red ou black ). 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres red - black ----------------------------------------------------------------- Les arbres 2 – 3 – 4 peuvent être représentés à l’aide de nœuds binaires uniquement, en rajoutant une couleur ( red ou black ). 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres red - black ----------------------------------------------------------------- Les arbres 2 – 3 – 4 peuvent être représentés à l’aide de nœuds binaires uniquement, en rajoutant une couleur ( red ou black ). ou colorier les nœuds … 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres red - black ----------------------------------------------------------------- L’équilibre des arbres red – black est maintenu à l’aide de : la rotation gauche : la rotation droite : 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres red - black ----------------------------------------------------------------- L’équilibre des arbres red – black est maintenu à l’aide de : la rotation gauche : la rotation droite : x y Si « a » n’est pas assez profond ! a y x c b c a b 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres red - black ----------------------------------------------------------------- L’équilibre des arbres red – black est maintenu à l’aide de : la rotation gauche : la rotation droite : x y Si « a » n’est pas assez profond ! a y x c b c a b x y a b c a b c x y Si « c » n’est pas assez profond ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Arbres AVL ----------------------------------------------------------------- Une autre solution : Les AVL, c’est-à-dire des arbres dont les profondeurs des sous-arbres gauche et droit diffèrent d’au plus une unité, quel que soit le nœud considéré. L’équilibre est maintenu à l’aide des opérations de rotation gauche ou droite. Le détail sous forme du 3e devoir. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Recherche textuelle ----------------------------------------------------------------- C h a n g e o n s d e s u j e t ! L ‘ A L G O R I T H M E D E K N U T H - M O R R I S E T P R A T T ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Sujet : Rechercher un pattern de longueur « m » : P[1] , … , P[m] dans un texte de longueur « n » : T[1] , … , T[n]. Recherche structurée : L’algorithme est plus difficile à développer. La complexité est plus petite. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Premier algorithme : trouve = false ; for i = 0 to n-m while not( trouve ) {trouve = true ; for j = 1 to m while trouve trouve = T[ i+j ] == P[ j ] ; i = i + 1 ; } resultat = ( trouve , i ) ; 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Premier algorithme : trouve = false ; for i = 0 to n-m while not( trouve ) {trouve = true ; for j = 1 to m while trouve trouve = T[ i+j ] == P[ j ] ; i = i + 1 ; } resultat = ( trouve , i ) ; Finalement, nous dirons si nous avons trouvé ou non, et où ça ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Premier algorithme : trouve = false ; for i = 0 to n-m while not( trouve ) {trouve = true ; for j = 1 to m while trouve trouve = T[ i+j ] == P[ j ] ; i = i + 1 ; } resultat = ( trouve , i ) ; Nous cherchons la séquence des « m » caractères du motif et nous abandonnons dès qu’il y a un échec ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Premier algorithme : Nous continuons la recherche sur tous les débuts possibles et tant que nous n’avons pas trouvé ! trouve = false ; for i = 0 to n-m while not( trouve ) {trouve = true ; for j = 1 to m while trouve trouve = T[ i+j ] == P[ j ] ; i = i + 1 ; } resultat = ( trouve , i ) ; 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Premier algorithme : trouve = false ; for i = 0 to n-m while not( trouve ) {trouve = true ; for j = 1 to m while trouve trouve = T[ i+j ] == P[ j ] ; i = i + 1 ; } resultat = ( trouve , i ) ; Complexité : O( n * m ) 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Principe de cet algorithme : Echec ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Principe de cet algorithme : Echec ! ! ! Nous recommençons une case plus loin avec le pattern entier. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Autre formulation : i = 1 ; j = 1 ; repeter si T[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( j > m ) ou ( i > n ) ; resultat = ( j > m , i-j+1 ) ; Initialisations ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Autre formulation : i = 1 ; j = 1 ; repeter si T[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( j > m ) ou ( i > n ) ; resultat = ( j > m , i-j+1 ) ; Nous poursuivons normalement jusqu’à avoir reconnu tout le pattern ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Autre formulation : i = 1 ; j = 1 ; repeter si T[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( j > m ) ou ( i > n ) ; resultat = ( j > m , i-j+1 ) ; Sur un échec, nous recommençons au premier caractère du pattern et le caractère convenable de T. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Autre formulation : i = 1 ; j = 1 ; repeter si T[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( j > m ) ou ( i > n ) ; resultat = ( j > m , i-j+1 ) ; Est-ce que nous avons pu aller à la fin du pattern et où ça ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Problème avec cet algorithme : Nous retournons en arrière dans le texte ! Dernière case lue ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Problème avec cet algorithme : Nous retournons en arrière dans le texte ! Dernière case lue ! ! ! Nous retournons en arrière vers cette case ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Or, il est inutile de retourner en arrière dans le texte ! Nous connaissons les valeurs, car ce sont les mêmes que celles du pattern! Dernière case lue ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Or, il est inutile de retourner en arrière dans le texte ! Nous connaissons les valeurs, car ce sont les mêmes que celles du pattern! Dernière case lue ! ! ! z y x z y x 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Or, il est inutile de retourner en arrière dans le texte ! Nous connaissons les valeurs, car ce sont les mêmes que celles du pattern! Dernière case lue ! ! ! z y x z y x ? ? ? z y x 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Principe de Knuth – Morris - Pratt : Après un échec entre T [ i ] et P [ j ] : nous restons sur T [ i ] ou nous avançons vers T [ i+1 ], nous restons sur P [ j ] ou nous reculons vers P [ j-k ]. Conséquences : Nous n’avons pas besoin de mémoriser le tableau T ! C’est idéal pour scruter des flux du genre satellite, ligne téléphonique, flux informatique, . . . 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 1 A B X Y i 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 1 A B X Y i i+1 A B 1 C’est en fait l’unique cas de figure où nous avançons dans T ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 4 A B C D A B C X i 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 4 A B C D A B C X i A B C D 1 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Avancer d’une case ne sert à rien : 4 A B C D A B C X i A B C D 1 P [ 1 ] = P [ 2 ] / 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Avancer de deux cases ne sert à rien : 4 A B C D A B C X i A B C D 1 P [ 1 ] = P [ 3 ] / 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 5 A B A B C A B A B X i 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 5 A B A B C A B A B X i A B A B C 3 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 5 A B A B C A B A B X i A B A B C 3 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 5 A B A B C A B A B X i A B A B C 3 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 4 A B A B C A B A X i 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 4 A B A B C A B A X i A B A B C 2 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Quelques cas de figure : 4 A B A B C A B A X i A B A B C 2 Nous pourrions faire un peu mieux ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Soit next [ 1 .. m ] : next [ j ] est le point de reprise dans le pattern P après un échec en P [ j ] ! next [ 1 ] = 1 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Soit next [ 1 .. m ] : next [ j ] est le point de reprise dans le pattern P après un échec en P [ j ] ! next [ 1 ] = 1 ! 4 A B A B C A B A X i next [ 4 ] = 2 Nous restons sur i ! A B A B C 2 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Soit next [ 1 .. m ] : next [ j ] est le point de reprise dans le pattern P après un échec en P [ j ] ! next [ 1 ] = 1 ! 5 A B A B C A B A B X i next [ 5 ] = 3 Nous restons sur i ! A B A B C 3 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- i = 1 ; j = 1 ; repeter si T[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {si j == 1 i = i+1 ; j = next[ j ] ; } jusqua ( j > m ) ou ( i > n ) ; resultat = ( j > m , i-j+1 ) ; Nouvelle formulation ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- i = 1 ; j = 1 ; repeter si T[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {si j == 1 i = i+1 ; j = next[ j ] ; } jusqua ( j > m ) ou ( i > n ) ; resultat = ( j > m , i-j+1 ) ; Nouvelle formulation ! Si l’erreur a lieu pour le premier caractère du motif, nous avançons sur le texte ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- i = 1 ; j = 1 ; repeter si T[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {si j == 1 i = i+1 ; j = next[ j ] ; } jusqua ( j > m ) ou ( i > n ) ; resultat = ( j > m , i-j+1 ) ; Nouvelle formulation ! Si l’erreur a lieu pour le premier caractère du motif, nous avançons sur le texte ! Dans tous les cas, nous retournons au caractère next[ j ] dans le motif ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Construisons next [ 1 .. m ] : next [ 1 ] = 1 ! next [ 2 ] = 1 ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Construisons next [ 1 .. m ] : next [ 1 ] = 1 ! next [ 2 ] = 1 ! next [ k ] pour k > 2 : Il faut trouver la longueur « l » du plus long préfixe de P [ 1 .. k-1 ] qui est aussi suffixe de P [ 2 .. k-1 ], et choisir next [ k ] = l+1. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Exemple : Soit P = A B A B C et k = 5 (erreur sur C ). P [ 1 .. 4 ] = A B A B P [ 2 .. 4 ] = B A B 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Exemple : Soit P = A B A B C et k = 5 (erreur sur C ). P [ 1 .. 4 ] = A B A B P [ 2 .. 4 ] = B A B l = 2 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Exemple : Soit P = A B A B C et k = 5 (erreur sur C ). P [ 1 .. 4 ] = A B A B P [ 2 .. 4 ] = B A B next [ 5 ] = 3 l = 2 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Exemple : Soit P = A B A B C et k = 5 (erreur sur C ). P [ 1 .. 4 ] = A B A B P [ 2 .. 4 ] = B A B next [ 5 ] = 3 l = 2 5 A B A B C A B A B X i A B A B C 16 novembre 2006 Cours d'algorithmique 4 - Intranet 3

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Exemple : Soit P = A B A B C et k = 5 (erreur sur C ). P [ 1 .. 4 ] = A B A B P [ 2 .. 4 ] = B A B next [ 5 ] = 3 l = 2 5 A B A B C A B A B X i A B A B C 16 novembre 2006 Cours d'algorithmique 4 - Intranet 3

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calcul des next[ k ] pour k variant de 1 à m ! /* Les initialisations sont triviales */ next[ 1 ] = 1 ; next[ 2 ] = 1 ; /* Boucle de calcul des next[ k ] */ for k = 3 to m do next[ k ] = calc_next( k , P ) ; 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calcul des next[ k ] pour k variant de 1 à m ! /* Les initialisations sont triviales */ next[ 1 ] = 1 ; next[ 2 ] = 1 ; /* Boucle de calcul des next[ k ] */ for k = 3 to m do next[ k ] = calc_next( k , P ) ; 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calcul des next[ k ] pour k variant de 1 à m ! /* Les initialisations sont triviales */ next[ 1 ] = 1 ; next[ 2 ] = 1 ; /* Boucle de calcul des next[ k ] */ for k = 3 to m do next[ k ] = calc_next( k , P ) ; 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Les modifications par rapport au programme précédent ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Comment ça marche ? 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Comment ça marche ? Suffixe Préfixe 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Comment ça marche ? Suffixe Préfixe Suite à un échec : Suffixe Préfixe 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Utilisons les next [ … ] déjà calculés ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Utilisons les next [ … ] déjà calculés ! 1 <= j < i < k 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Utilisons les next [ … ] déjà calculés ! 1 <= j < i < k 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Utilisons les next [ … ] déjà calculés ! 1 <= j < i < k 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } /* k > 2 */ Utilisons les next [ … ] déjà calculés ! 1 <= j < i < k 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {i = i-j+2 ; j = 1 ; } jusqua ( i >= k ) ; return( j ) ; } Utilisons les next [ … ] déjà calculés ! 1 <= j < i < k {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Supposons que maintenant i == k ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Comme : next[ k ] = calc_next( k , P ) Supposons que maintenant i == k ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Comme : next[ k ] = calc_next( k , P ) Supposons que maintenant i == k ! Nous calculons en fait : next[ k ] = j 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Comme : next[ k ] = calc_next( k , P ) Supposons que maintenant i == k ! Nous calculons en fait : next[ k ] = j c’est-à-dire next[ i ] = j 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Supposons que maintenant i == k ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Comme : next[ k ] = calc_next( k , P ) Supposons que maintenant i == k ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Comme : next[ k ] = calc_next( k , P ) Nous calculons en fait : next[ k ] = 1 Supposons que maintenant i == k ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) i = i+1 ; j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Comme : next[ k ] = calc_next( k , P ) Nous calculons en fait : next[ k ] = 1 c’est-à-dire next[ i ] = 1 Supposons que maintenant i == k ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) {i = i+1 ; next[ i ] = 1 ; } j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- Calculons tous les next [ … ] en même temps. calc_next ( k , P ) = {i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) {i = i+1 ; next[ i ] = 1 ; } j = next[ j ] ; } jusqua ( i >= k ) ; return( j ) ; } Lorsque k = m nous calculons tous les next [ … ] au passage! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- next[ 1 ] = 1 ; next[ 2 ] = 1 ; i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) next[ i ] = 1 ; } j = next[ j ] ; } jusqua ( i >= m ) ; Calcul de next [ 1 ] à next [ m ] ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- next[ 1 ] = 1 ; next[ 2 ] = 1 ; i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) next[ i ] = 1 ; } j = next[ j ] ; } jusqua ( i >= m ) ; Calcul de next [ 1 ] à next [ m ] ! ! ! Les autres next[ … ] sont calculés au passage ! k = m ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Algorithme K - M - P ----------------------------------------------------------------- next[ 1 ] = 1 ; next[ 2 ] = 1 ; i = 2 ; j = 1 ; repeter si P[ i ] == P[ j ] {i = i+1 ; j = j+1 ; next[ i ] = j ; } sinon {if ( j == 1 ) next[ i ] = 1 ; } j = next[ j ] ; } jusqua ( i >= m ) ; Calcul de next [ 1 ] à next [ m ] ! ! ! Complexité : O ( m ) Les autres next[ … ] sont calculés au passage ! k = m ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet Synthèse ----------------------------------------------------------------- L’algorithme alpha-beta. Arbres alpha et beta et propriétés. Arbres de recherche équilibrés : les contraintes, certaines solutions. Recherche textuelle. 16 novembre 2006 Cours d'algorithmique 4 - Intranet

Cours d'algorithmique 4 - Intranet m E r C i e T b O n N e J o U r N é E ! ! ! n ‘ O u B l I e Z p A s D e p R é P a R e R v O s T D ! ! ! 16 novembre 2006 Cours d'algorithmique 4 - Intranet