Cours d'algorithmique 5 - Intranet 1 17/21 novembre 2006 Cours dAlgorithmique Divide and Conquer :...

Cours d'algorithmique 5 - IntranetCours d'algorithmique 5 - Intranet 1117/21 novembre 200617/21 novembre 2006

Cours d’AlgorithmiqueCours d’Algorithmique

Divide and Conquer :Divide and Conquer :

principes et applications.principes et applications.

Calculabilité.Calculabilité.

Complexité.Complexité.

17/21 novembre 200617/21 novembre 2006 Cours d'algorithmique 5 - IntranetCours d'algorithmique 5 - Intranet 22

• Trier et chercher, recherche textuelleTrier et chercher, recherche textuelle• Listes et arbresListes et arbres• Le back-trackLe back-track• Arbres équilibrésArbres équilibrés• Récursivité et induction sur la structureRécursivité et induction sur la structure• Divide and conquerDivide and conquer• Minimax, alpha-betaMinimax, alpha-beta• DérécursionDérécursion• Divers problèmes particuliersDivers problèmes particuliers• Logique de HoareLogique de Hoare• Programmation dynamiqueProgrammation dynamique• Complexité et calculabilitéComplexité et calculabilité

Les grandes lignes du coursLes grandes lignes du cours


Divide and ConquerDivide and Conquer----------------------------------------------------------------------------------------------------------------------------------

Diviser pour régner !Diviser pour régner !

• Principe :Principe :

– Couper en 2 (ou plus) un problème,Couper en 2 (ou plus) un problème,

– résoudre séparément les sous-problèmes résoudre séparément les sous-problèmes créés, ce sont des appels récursifs,créés, ce sont des appels récursifs,

– recombiner les résultats partiels afin recombiner les résultats partiels afin d’obtenir le résultat global !d’obtenir le résultat global !



• Un grand nombre de parcours d’arbres sont de Un grand nombre de parcours d’arbres sont de type « diviser pour régner ».type « diviser pour régner ».

• Exemple , le calcul de la hauteur d’un arbre :Exemple , le calcul de la hauteur d’un arbre :

– Couper en deux sous-arbres, le fils gauche et Couper en deux sous-arbres, le fils gauche et le fils droit,le fils droit,

– calculer séparément les hauteurs des sous-calculer séparément les hauteurs des sous-arbres à l’aide d’appels récursifs,arbres à l’aide d’appels récursifs,

– déduire la hauteur de l’arbre globale à partir déduire la hauteur de l’arbre globale à partir de la hauteur de ses sous-arbres.de la hauteur de ses sous-arbres.

L’induction sur la structure est du Divide and Conquer !L’induction sur la structure est du Divide and Conquer !



• Autre exemple déjà rencontré, le tri par fusion :Autre exemple déjà rencontré, le tri par fusion :

– Nous coupons le tableau en deux sous-Nous coupons le tableau en deux sous-tableaux,tableaux,

– que nous trions récursivement, ce sont deux que nous trions récursivement, ce sont deux appels récursifs indépendants, appels récursifs indépendants,

– avant de les fusionner en une seule liste avant de les fusionner en une seule liste triée. triée.


Pseudo-code pour le Divide and ConquerPseudo-code pour le Divide and Conquer----------------------------------------------------------------------------------------------------------------------------------

un_type divide_and_conquer ( autre_type situation )

{if ( cas_de_base( situation ) )

return( valeur( situation ) ) ;

else

return( recombine( divide_and_conquer(

sous_probleme_A( situation ) ) ,

divide_and_conquer(

sous_probleme_B( situation ) ) ) ) ;

}



• Finalement, tout le principe du « back-track » n’est Finalement, tout le principe du « back-track » n’est que du « diviser pour régner », car :que du « diviser pour régner », car :

– Nous envisageons deux possibilités,Nous envisageons deux possibilités,

– que nous explorons récursivement et que nous explorons récursivement et « indépendamment » l’une de l’autre, « indépendamment » l’une de l’autre,

– afin de retenir la première solution qui nous afin de retenir la première solution qui nous convienne. convienne.


Relation entre Back-track et Divide and ConquerRelation entre Back-track et Divide and Conquer----------------------------------------------------------------------------------------------------------------------------------



return( valeur( situation ) ) ;

else



divide_and_conquer(


}

back_trackback_track



ou_bienou_bien

ou_bien n’est pas une fonction stricte !ou_bien n’est pas une fonction stricte !


Relation entre Back-track et Divide and ConquerRelation entre Back-track et Divide and Conquer----------------------------------------------------------------------------------------------------------------------------------



return( . . . ) ;

else



divide_and_conquer(


}

back_track_toutesback_track_toutes



unionunion


Complexité typique du Divide and ConquerComplexité typique du Divide and Conquer----------------------------------------------------------------------------------------------------------------------------------

• La relation de base, pour un problème de taille n , est :La relation de base, pour un problème de taille n , est :

T ( n ) = 2 * T ( n/2 ) + O ( f(n) )T ( n ) = 2 * T ( n/2 ) + O ( f(n) )

• La complexité de la décomposition et de la La complexité de la décomposition et de la recombinaison est en O ( f(n) ) .recombinaison est en O ( f(n) ) .

• Comme nous l’avons déjà vu, cette équation donne lieu à Comme nous l’avons déjà vu, cette équation donne lieu à la solution générale suivante :la solution générale suivante :

T ( n ) = T ( n ) = 2î2î( f(n/2î) )( f(n/2î) )

• Si f( n ) = n, ce qui est assez fréquent, alors nous Si f( n ) = n, ce qui est assez fréquent, alors nous avons :avons :

T ( n ) = n * ( 1 + log ( n-1 ) ) T ( n ) = n * ( 1 + log ( n-1 ) ) n * log n n * log n

log n-1log n-1

i = 0i = 0



• Archi-classique, les tours de Hanoï :Archi-classique, les tours de Hanoï :

– Trois piquets et une « pagode » de disques,Trois piquets et une « pagode » de disques,

– il faut déplacer la pagode du premier piquet il faut déplacer la pagode du premier piquet vers le 3vers le 3ee, le second servant d’intermédiaire, , le second servant d’intermédiaire,

– et respecter les règles suivantes :et respecter les règles suivantes :

• nous déplaçons un disque à la fois,nous déplaçons un disque à la fois,

• nous ne posons jamais un disque sur un autre nous ne posons jamais un disque sur un autre disque plus petit que lui.disque plus petit que lui.



void hanoi ( int n , piquet depart , piquet arrivee )

{if ( n == 1 )

deplacer( depart , arrivee );

else

{hanoi( n-1 , depart , troisieme( depart , arrivee )) ;

deplacer( depart , arrivee );

hanoi( n-1 , troisieme( depart , arrivee) , arrivee) ;

}

Premier appel récursif !Premier appel récursif !

Deuxième appel récursif !Deuxième appel récursif !La composition !La composition !



void dessine ( int gauche , int droite , int hauteur )

{if ( haut > 0 )

{milieu = ( gauche + droite ) / 2 ;

barre( milieu , haut ) ;

dessine( gauche , milieu , haut - 1 ) ;

dessine( milieu , droite , haut - 1 ) ;

}

Dessine la barre centrale !Dessine la barre centrale !

Dessine la demi-règle gauche !Dessine la demi-règle gauche !

Dessine la demi-règle droite !Dessine la demi-règle droite !



Accélération de l’addition binaire 32 bits !Accélération de l’addition binaire 32 bits !

– Bilan :Bilan :• Chaque demi-additionneur a 2 ou 3 transistors en cascade,Chaque demi-additionneur a 2 ou 3 transistors en cascade,• il y a donc +- 100 transistors en cascade,il y a donc +- 100 transistors en cascade,• d’où, avec 10 pico-secondes par transistor,d’où, avec 10 pico-secondes par transistor,• une latence de 1 nano-seconde,une latence de 1 nano-seconde,

C’est-à-dire une fréquence bloquée à 1 Ghz !C’est-à-dire une fréquence bloquée à 1 Ghz !

++

x1x1

y1y1

++

x2x2

y2y2

++

xnxn

ynyn

R = 0R = 0RR



En rajoutant 50% de transistors :En rajoutant 50% de transistors :

+ 16 bits+ 16 bits R = 0R = 0????

Poids faibles !Poids faibles !

+ 16 bits+ 16 bits????????

Poids forts !Poids forts !

+ 16 bits+ 16 bits ?? = 1?? = 1

?? = 0?? = 0

????????



• Calcul de l’enveloppe convexe de « n » points en 2D Calcul de l’enveloppe convexe de « n » points en 2D !!

MéthodeMéthodeanalogiqueanalogique

dedel’élastique !l’élastique !



• Algorithme :Algorithme :

– Trier en x et en y !Trier en x et en y !

– Diviser verticalement en deux !Diviser verticalement en deux !

– Calculer récursivement les enveloppes convexes !Calculer récursivement les enveloppes convexes !

– Joindre des liens entre les camps :Joindre des liens entre les camps :

• Trouver le plus petit et le grand en yTrouver le plus petit et le grand en y

• et basculer des lignes horizontales pour toucher l’autre et basculer des lignes horizontales pour toucher l’autre camp !camp !

– Enlever les liens superflus !Enlever les liens superflus !



Complexité globale :Complexité globale :

O ( n log n )O ( n log n )

Tri initial en 0 ( n log n )Tri initial en 0 ( n log n )

Décomposition en O ( n )Décomposition en O ( n )

Recombinaison en O ( n )Recombinaison en O ( n )


CalculabilitéCalculabilité----------------------------------------------------------------------------------------------------------------------------------

• Le programme P s’arrête-t-il pour la Le programme P s’arrête-t-il pour la donnée D ?donnée D ?

• Quel est l’ensemble des données pour Quel est l’ensemble des données pour lesquelles P s’arrête ?lesquelles P s’arrête ?

• Plus tard : Combien faut-il Plus tard : Combien faut-il d’opérations ?d’opérations ?



• L’arrêt est semi-décidable ! ! !L’arrêt est semi-décidable ! ! !

• Vous lancez P avec D et vous attendez !Vous lancez P avec D et vous attendez !

– Si programme s’arrête : OUI !Si programme s’arrête : OUI !

soit, il s’arrêtera un peu plus tard !soit, il s’arrêtera un peu plus tard !– Sinon Sinon

soit, il ne s’arrêtera jamais ! ! !soit, il ne s’arrêtera jamais ! ! !

Ce dernier choix ne peut pas être décidé, en général !Ce dernier choix ne peut pas être décidé, en général !



• Théorème :Théorème :

Il n’existe pas de programme de décision DA qui,Il n’existe pas de programme de décision DA qui, pour tout autre programme P et toute donnée Dpour tout autre programme P et toute donnée D dise :dise :

– DA ( P , D ) = oui , si P s’arrête pour la donnée D.DA ( P , D ) = oui , si P s’arrête pour la donnée D.

– DA ( P , D ) = non, si P ne s’arrête pas pour D.DA ( P , D ) = non, si P ne s’arrête pas pour D.

On dit que « l’arrêt de la machine est indécidable » !On dit que « l’arrêt de la machine est indécidable » !



• Toutefois :Toutefois :

Cette question peut quand-même être décidée Cette question peut quand-même être décidée pour un grand nombre de programmes.pour un grand nombre de programmes.

Les programmes suivants s’arrêtent toujours :Les programmes suivants s’arrêtent toujours :

– des constantes, variables et opérations des constantes, variables et opérations simples,simples,

– des séquences finies d’instructions,des séquences finies d’instructions,

– des si-alors-sinon et boucles for (à la Pascal).des si-alors-sinon et boucles for (à la Pascal).

• Seul le « while », qui est équivalent à la récursion, Seul le « while », qui est équivalent à la récursion, pose problème !pose problème !



• Exemple d’un while sans problème :Exemple d’un while sans problème :

• Exemple avec problème (sans réponse connue !) Exemple avec problème (sans réponse connue !) ::

{int n = ... ; assert ( n >= 0 ) ;

while ( n != 0 )

n = n – 1 ; }

{int n = ... ; assert ( n > 0 ) ;

while ( n != 1 )

if ( even( n ) )

n = n / 2 ;

else

n = 3 * n + 1 ; }

Exemple :Exemple :

1313 -> 40 -> 20 ->-> 40 -> 20 ->1414 -> 5 -> 16 ->-> 5 -> 16 -> 8 -> 4 -> 2 -> 18 -> 4 -> 2 -> 1



• Schématiquement :Schématiquement :

ValeurValeurde n de n

Pas de calculPas de calcul

Facile !Facile !C’est le premier exemple.C’est le premier exemple.

Difficile ! ! !Difficile ! ! !C’est le deuxièmeC’est le deuxièmeexemple.exemple.



• Pour prouver l’arrêt il faut :Pour prouver l’arrêt il faut :

– Un ordre bien fondé,Un ordre bien fondé,

– Une mesure sur cet ordre,Une mesure sur cet ordre,

– Un programme qui fait strictement décroître la Un programme qui fait strictement décroître la mesure lors de son exécution.mesure lors de son exécution.

Un ordre bien fondé n’admet pas de chaînes décroissantes infinies :Un ordre bien fondé n’admet pas de chaînes décroissantes infinies :

OK : ( N , < ) car 15 -> 12 -> 11 -> … ce sera fini !OK : ( N , < ) car 15 -> 12 -> 11 -> … ce sera fini !KO : ( Z , < ) car 15 -> 12 -> -5 -> … peut être infinie !KO : ( Z , < ) car 15 -> 12 -> -5 -> … peut être infinie !

N’importe quelle fonction qui transforme les valeurs desN’importe quelle fonction qui transforme les valeurs desvariables en une valeur de l’ordre bien fondé considéré.variables en une valeur de l’ordre bien fondé considéré.


CalculabilitéCalculabilité----------------------------------------------------------------------------------------------------------------------------------• Exemple d’un while sans problème :Exemple d’un while sans problème :

• L’ordre : ( N , < )L’ordre : ( N , < )

• La mesure : m ( n ) = n ( ou m ( n ) = 5 * n +13 )La mesure : m ( n ) = n ( ou m ( n ) = 5 * n +13 )

– Elles sont acceptables car, pour n Elles sont acceptables car, pour n , on a m ( n ) >= 0, on a m ( n ) >= 0

• C’est bien décroissant, car on passe de m ( n ) = n à C’est bien décroissant, car on passe de m ( n ) = n à m( n – 1 ) = n – 1 ! m( n – 1 ) = n – 1 !

( ou de m ( n ) = 5 * n + 13 à m ( n – 1 ) = 5 * n + 8 )( ou de m ( n ) = 5 * n + 13 à m ( n – 1 ) = 5 * n + 8 )

{int n = ... ; assert ( n >= 0 ) ;

while ( n != 0 )

n = n – 1 ; }



{int n = ... ; assert ( n > 0 ) ;

while ( n != 1 )

if ( even( n ) )

n = n / 2 ;

else

n = 3 * n + 1 ; }

• Exemple d’un while avec problème :Exemple d’un while avec problème :

• L’ordre : ( N , < )L’ordre : ( N , < )

• La mesure : m ( n ) = n La mesure : m ( n ) = n

• OK : 8 -> 4 et m ( 8 ) > m ( 4 )OK : 8 -> 4 et m ( 8 ) > m ( 4 )• KO : 7 -> 22 et m ( 7 ) < m ( 22 )KO : 7 -> 22 et m ( 7 ) < m ( 22 )

• Il existe peut-être une mesure qui convient, Il existe peut-être une mesure qui convient, mais personne ne l’a jamais trouvée !mais personne ne l’a jamais trouvée !


ComplexitéComplexité----------------------------------------------------------------------------------------------------------------------------------• Quelques rappels :Quelques rappels :

– Complexité du pire cas.Complexité du pire cas.

– Complexité du meilleur cas.Complexité du meilleur cas.

– Complexité moyenne.Complexité moyenne.

• Elles se calculent par rapport à la taille de la donnée Elles se calculent par rapport à la taille de la donnée ::

– le nombre de cases du tableau,le nombre de cases du tableau,

– le nombre de feuilles de l’arbre,le nombre de feuilles de l’arbre,

– ou le nombre d’octets pour mémoriser la structure.ou le nombre d’octets pour mémoriser la structure.

Usuelle !Usuelle !

Inintéressante !Inintéressante !

Difficile à établir !Difficile à établir !


ComplexitéComplexité----------------------------------------------------------------------------------------------------------------------------------• On s’intéresse seulement à des problèmes dont On s’intéresse seulement à des problèmes dont

la taille « n » est grande :la taille « n » est grande :

– Plus facile, car analyse asymptotique.Plus facile, car analyse asymptotique.

– Plus intéressant.Plus intéressant.

• Comme ce sera une étude asymptotique :Comme ce sera une étude asymptotique :

– Toutes les opérations élémentaires et leurs Toutes les opérations élémentaires et leurs composition de manière finie coûtent 1 .composition de manière finie coûtent 1 .

– Nous comptons les tours de boucles for et while .Nous comptons les tours de boucles for et while .

– Nous travaillons à constante multiplicative près.Nous travaillons à constante multiplicative près.

– Nous ignorons les termes d’ordres inférieurs.Nous ignorons les termes d’ordres inférieurs.


ComplexitéComplexité----------------------------------------------------------------------------------------------------------------------------------• Définition :Définition :

Un algorithme A appartient à l’ensemble O Un algorithme A appartient à l’ensemble O ( f( n ) )( f( n ) )

si, pour une donnée de taille n , la complexité si, pour une donnée de taille n , la complexité dudu

pire cas de A vaut au plus f ( n ) .pire cas de A vaut au plus f ( n ) .

O ( f ( n ) ) =O ( f ( n ) ) =

{ { g ( n )g ( n ) | | k > 0k > 0 , , m >= 0 : m >= 0 :

pour tout n > m :pour tout n > m : g ( n ) <=g ( n ) <= k *k * f ( f ( n )n ) } }

Étude asymptotique.Étude asymptotique.A un facteurA un facteurconstant près …constant près …

lim g ( n ) / f ( n ) <= klim g ( n ) / f ( n ) <= kn -> +n -> +


ComplexitéComplexité----------------------------------------------------------------------------------------------------------------------------------• Illustration :Illustration :

g(n)g(n)

f(n)f(n)

k * f(n)k * f(n)

mm


ComplexitéComplexité----------------------------------------------------------------------------------------------------------------------------------

• Complexité d’un algorithme :Complexité d’un algorithme :

– Dans le pire cas, il faut O ( f ( n ) ) .Dans le pire cas, il faut O ( f ( n ) ) .

– C’est un majorant.C’est un majorant.

• Complexité d’un problème :Complexité d’un problème :

– Le meilleur algorithme pour résoudre le Le meilleur algorithme pour résoudre le problème nécessite au moins problème nécessite au moins ( f ( n ) ) ( f ( n ) ) opérations.opérations.

– C’est un minorant.C’est un minorant.



Le problème P appartient à l’ensemble Le problème P appartient à l’ensemble ( f( n ( f( n ) )) )

si, pour une taille n , la complexité du meilleursi, pour une taille n , la complexité du meilleuralgorithme pour résoudre P vaut au moins f algorithme pour résoudre P vaut au moins f

( n ) .( n ) .

( f ( n ) ) =( f ( n ) ) =

{ { g ( n )g ( n ) | | k > 0k > 0 , , m >= 0 : m >= 0 :

pour tout n > m :pour tout n > m : g ( n ) >=g ( n ) >= k *k * f ( f ( n )n ) } }

Étude asymptotique.Étude asymptotique.A un facteurA un facteurconstant près …constant près …

lim g ( n ) / f ( n ) >= klim g ( n ) / f ( n ) >= kn -> +n -> +


ComplexitéComplexité----------------------------------------------------------------------------------------------------------------------------------• Illustration :Illustration :

g(n)g(n)

f(n)f(n)

k * f(n)k * f(n)

mm


ComplexitéComplexité----------------------------------------------------------------------------------------------------------------------------------• Pour tout problème PPour tout problème P

– de complexité minimale de complexité minimale ( f ( n ) ) ( f ( n ) )

• et tout algorithme A qui résout Pet tout algorithme A qui résout P

– avec une complexité maximale O ( g ( n ) )avec une complexité maximale O ( g ( n ) )

• nous avonsnous avons

( f ( n ) ) <= O ( g ( n ) )( f ( n ) ) <= O ( g ( n ) )L’algorithme est optimal si nous avons l’égalité ! ! !L’algorithme est optimal si nous avons l’égalité ! ! !

==

Ceci signifie en fait que Ceci signifie en fait que ( f ( n ) ) O ( g ( n ) ) ( f ( n ) ) O ( g ( n ) ) n’est pas vide et que f ( n ) = g ( n ).n’est pas vide et que f ( n ) = g ( n ).

vv



( f ( n ) ) = ( f ( n ) ) = ( f ( n ) ) O ( f ( n ) ) = ( f ( n ) ) O ( f ( n ) ) =

{ { g ( n )g ( n ) | | k > 0 , k > 0 , l > 0l > 0 , , m >= 0 : m >= 0 :

pour tout n > m :pour tout n > m : k *k * f ( n ) <= g ( n ) <=f ( n ) <= g ( n ) <= l *l * f f

( n )( n ) } }Étude asymptotique.Étude asymptotique.

A des facteursA des facteursconstants près …constants près …

k <= lim g ( n ) / f ( n ) <= lk <= lim g ( n ) / f ( n ) <= ln -> +n -> +

vv


Complexité d’un problèmeComplexité d’un problème----------------------------------------------------------------------------------------------------------------------------------

• Tri de « n » éléments : Tri de « n » éléments : ( n log n )( n log n )

• Si Si T T est différent de est différent de T’T’ alors alors Opérations Opérations est différent de est différent de Opérations’Opérations’

Tableau TTableau T Tableau T’Tableau T’

Tableau triéTableau trié

OpérationsOpérations Opérations’Opérations’



• Donc, il y a autant de séquences d’opérations distinctes Donc, il y a autant de séquences d’opérations distinctes qu’il y a de tableaux distincts !qu’il y a de tableaux distincts !

– Séquence de longueur 1 : 2 cas (même opération ou non)Séquence de longueur 1 : 2 cas (même opération ou non)

– Séquence de longueur 2 : 4 casSéquence de longueur 2 : 4 cas

– Séquence de longueur k : 2^k casSéquence de longueur k : 2^k cas

• La valeur minimale de k doit vérifier :La valeur minimale de k doit vérifier :

2 >= « nombre de tableaux différents »2 >= « nombre de tableaux différents »

k >= log ( « nombre de tableaux différents » )k >= log ( « nombre de tableaux différents » )

• log ( « nombre de tableaux différents » ) = log ( n! ) = n log log ( « nombre de tableaux différents » ) = log ( n! ) = n log nn

minmin

minmin

kk



• Recherche d’un élément « e » dans un tableau non trié.Recherche d’un élément « e » dans un tableau non trié.

– La recherche séquentielle est en O ( n ).La recherche séquentielle est en O ( n ).

– Mais, quelle est la complexité du problème ?Mais, quelle est la complexité du problème ?

• Nous avons n! tableaux différents, maisNous avons n! tableaux différents, mais

– si nous cherchons par exemple la valeur si nous cherchons par exemple la valeur 22 , alors les tableaux , alors les tableaux

et sont équivalents.et sont équivalents.

• La question à poser est la suivante :La question à poser est la suivante :

– Est-ce que « e » est identique à T [ i ] ?Est-ce que « e » est identique à T [ i ] ?

– Donc, 2^n cas différents et la complexité minimale est Donc, 2^n cas différents et la complexité minimale est ( n ). ( n ).

3 4 …3 4 … 4 3 …4 3 …



• Recherche d’un élément « e » dans un tableau trié.Recherche d’un élément « e » dans un tableau trié.

– La recherche par dichotomie est en O ( log n ).La recherche par dichotomie est en O ( log n ).

– Quelle est la complexité du problème ?Quelle est la complexité du problème ?

• Il y a des tableaux triés oùIl y a des tableaux triés où

– la valeur « e » est en première position,la valeur « e » est en première position,– la valeur « e » est en deuxième position,la valeur « e » est en deuxième position, . . .. . .– la valeur « e » est absente.la valeur « e » est absente.

• Nous avons donc au moins Nous avons donc au moins ( n ) cas différents ! ( n ) cas différents !

• La complexité minimale est La complexité minimale est ( log n ). ( log n ).

Cours d'algorithmique 5 - Intranet 1 17/21 novembre 2006 Cours dAlgorithmique Divide and Conquer :...

Documents

Transcript of Cours d'algorithmique 5 - Intranet 1 17/21 novembre 2006 Cours dAlgorithmique Divide and Conquer :...