1 / 42

Cours d’Algorithmique

Cours d’Algorithmique. Exploration combinatoire complète Branch-and-Bound Solutions approchées. Les grandes lignes du cours. Trier et chercher, recherche textuelle Listes et arbres Le back-track, solutions approchées Arbres équilibrés Récursivité et induction sur la structure

loring
Télécharger la présentation

Cours d’Algorithmique

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Cours d’Algorithmique Exploration combinatoire complète Branch-and-Bound Solutions approchées Cours d'algorithmique 12 / Intranet

  2. Les grandes lignes du cours • Trier et chercher, recherche textuelle • Listes et arbres • Le back-track, solutions approchées • Arbres équilibrés • Récursivité et induction sur la structure • Divide and conquer, algorithmes gloutons • Minimax, alpha-beta • Dérécursion • NP-complétude, Branch-and-Bound • Logique de Hoare • Programmation dynamique • Complexité et calculabilité Cours d'algorithmique 12 / Intranet

  3. TSP-----------------------------------------------------------------TSP----------------------------------------------------------------- • Le « Voyageur de Commerce », en anglais « Traveling Salesman Problem » ( TSP ) : • « n » villes, • un réseau routier complet entre ces villes avec les distances, • La question : Quel est le coût du circuit (point de départ = point d’arrivée) le moins cher qui visite chaque ville une et une seule fois ? Cours d'algorithmique 12 / Intranet

  4. TSP-----------------------------------------------------------------TSP----------------------------------------------------------------- • Exemple : B 15 30 17 D 35 A 45 C 20 Un tour à coût 110 ! Un tour à coût 87 ! Il suffit d’un inspecter tous les circuits ! Seulement, il y en a n ! pour n villes ! Cours d'algorithmique 12 / Intranet

  5. TSP-----------------------------------------------------------------TSP----------------------------------------------------------------- • Exemple : • La matrice M des distances : B 15 30 17 D 35 A 45 C 20 ) ( +µ 30 20 35 A B 30 +µ 17 15 Par symétrie ! 20 17 +µ 45 C D 35 15 45 +µ Cours d'algorithmique 12 / Intranet

  6. TSP-----------------------------------------------------------------TSP----------------------------------------------------------------- • Pour avoir un circuit il faut sélectionner « n » arêtes ! • La représentation du problème : • « c » est le nombre d’arêtes déjà choisies, • « E » est l’ensemble de ces arêtes, • « s » est la somme des longueurs des arêtes de « E », • « M » est la matrice courante avec les arêtes interdites ou déjà choisies mises à +µ. • Le principe du back-track : • Nous choisissons une arête pour l’imposer ou l’interdire ! Cours d'algorithmique 12 / Intranet

  7. TSP-----------------------------------------------------------------TSP----------------------------------------------------------------- • Lorsque nous avons sélectionné « n » arêtes, • il faut rendre « s » comme résultat ! • Sinon, • nous choisissons une arête ( a , b ) de poids fini ! • Si ce n’est pas possible, nous sommes dans une impasse et nous rendons +µ (pas de circuit !). • Si l’arête ( a , b ) ferme le circuit trop tôt, • nous ne pouvons que l’interdire ! Cours d'algorithmique 12 / Intranet

  8. TSP-----------------------------------------------------------------TSP----------------------------------------------------------------- a b Les arêtes sélectionnées ! Nous pouvons compléter vers un circuit ! Nous ne pouvons plus compléter vers un circuit ! Cours d'algorithmique 12 / Intranet

  9. TSP-----------------------------------------------------------------TSP----------------------------------------------------------------- • Interdire une arête revient à : • garder le même nombre « c » d’arêtes sélectionnées, • le même ensemble « E », • la même somme « s », • mettre l’entrée ( a , b ) de « M » à +µ . • Notation : • M [ ( a , b ) <- v , ( c , d ) <- w ] : 2 entrées sont changées. • M [ ( a , _ ) <- v ] : une ligne est modifiée. Cours d'algorithmique 12 / Intranet

  10. TSP-----------------------------------------------------------------TSP----------------------------------------------------------------- • Lorsque l’arête ( a , b ) est de poids fini et acceptable, nous pouvons décider de • soit l’interdire, nous avons vu comment faire, • soit, la sélectionner. A ce moment : • c <- c + 1 • e <- E v { ( a , b ) } • s <- s + M( a , b ) • M <- M[ ( a , _ ) <- +µ , ( _ , b ) <- +µ ] • Ensuite, nous continuons l’exploration et nous rendons la meilleure des deux solutions ! Au moins 2^n cas à inspecter ! Cours d'algorithmique 12 / Intranet

  11. Branch and Bound----------------------------------------------------------------- • L’idée est la suivante : • Si les arêtes que nous avons déjà choisies sont très chères, • alors, même en continuant de la meilleure manière, notre solution sera très chère, • et même plus chère qu’une solution complète déjà connue ! Arrêtons les frais ! ! ! Cours d'algorithmique 12 / Intranet

  12. Branch and Bound----------------------------------------------------------------- • Le programme gère une variable opt* qui mémorise la longueur de la meilleure solution trouvée jusqu’à présent. • Nous explorons un arbre (problème) « A » à la recherche de la meilleure solution locale : opt( A ) . • Nous espérons que opt( A ) soit meilleure que opt* . • Avant d’explorer complètement A , nous aimerions avoir une « petite idée » des solutions que nous risquons d’y trouver ! ! ! • Supposons qu’une fonction « lb », pas trop compliquée à calculer, nous donne un minorant de la meilleure solution : lb( A ) <= opt( A ) Cours d'algorithmique 12 / Intranet

  13. Branch and Bound----------------------------------------------------------------- • Nous allons comparer lb( A ) à opt* : • Si opt* <= lb( A ) alors opt* <= lb( A ) <= opt( A ) . • Ce n’est pas la peine d’explorer A ! ! ! • Le calcul lb( A ) est beaucoup plus rapide que celui de opt( A ). • Tout bénef ! • Si opt* > lb( A ) alors on ne peut rien en déduire. • En effet, lb( A ) <= opt( A ) et lb( A ) < opt* , mais . . . ? ? ? • Le calcul lb( A ) ne sert à rien ! Cours d'algorithmique 12 / Intranet

  14. Branch and Bound----------------------------------------------------------------- • Principe du Branch-and-Bound ( Séparer et évaluer ) : • Nous connaissons opt* ! • Nous calculons lb( A ) en « temps raisonnable » ! • Si opt* <= lb( A ) , nous pouvons éliminer A ! • Si opt* > lb( A ) , nous explorons A normalement ! Calcul spéculatif ! Il faut savoir combien de temps lui attribuer ? Cours d'algorithmique 12 / Intranet

  15. Branch and Bound----------------------------------------------------------------- • Le calcul spéculatif : • Si nous lui consacrons trop peu de temps, la borne sera mauvaise et ne servira à rien ! • Si nous lui consacrons trop de temps, c’est contre-productif ! Augmenter, encore et encore, le temps n’améliore pas nécessairement la borne ! • Tout est une question d’expérience, purement empirique ! • Pour le TSP, des bornes en complexité n^3 ont donné les meilleurs résultats, si n est grand. Cours d'algorithmique 12 / Intranet

  16. Branch and Bound----------------------------------------------------------------- • Pour notre TSP : • Nous avons « c » , « E » , « s » et « M » . • Donc, il y a « c » lignes complètement remplies avec +µ . • Il y a « n-c » lignes contenant des valeurs finies ! • Dans chaque ligne, il faut choisir une valeur. • Cette valeur sera au moins aussi grande que la plus petite valeur finie dans la ligne. • Nous obtenons une borne inférieure en sommant « s » et les « n-c » minima des lignes non complètement remplis de +µ . Cours d'algorithmique 12 / Intranet

  17. Branch and Bound----------------------------------------------------------------- • Exemple : ) s = 42 ( +µ +µ +µ +µ 30 +µ +µ 15 10 17 +µ 45 35 +µ +µ +µ L’idée : Il faudra bien partir de la seconde ville et cela coûtera au moins 15, de même pour les autres villes ! Notre raisonnement reste incomplet car il ne tient pas compte du fait que nous ne pourrons pas aller deux fois vers la première ville ! Cours d'algorithmique 12 / Intranet

  18. Branch and Bound----------------------------------------------------------------- • Exemple : ) s = 42 ( +µ +µ +µ +µ 30 +µ +µ 15 10 17 +µ 45 35 +µ +µ +µ Donc : lb ( A ) = 102 = 42 + 15+ 10+ 35 Cours d'algorithmique 12 / Intranet

  19. Branch and Bound----------------------------------------------------------------- • Exemple : ) s = 42 ( +µ +µ +µ +µ Cette borne inférieure correspond par chance à la longueur du plus court circuit : A – C – B – D – A 15 +µ +µ 0 0 7 +µ 35 0 +µ +µ +µ Donc : lb ( A ) = 102 = 42 + 15+ 10+ 35 Mieux, nous diminuons chaque ligne de son minimum et nous appliquons le même raisonnement aux colonnes ! lb ( A ) = 109 = 102+ 7 Cours d'algorithmique 12 / Intranet

  20. Branch and Bound----------------------------------------------------------------- • Principe du Branch-and-Bound ( Séparer et évaluer ) : • Nous connaissons opt* ! • Nous calculons lb( A ) en « temps raisonnable » ! • Si opt* <= lb( A ) , nous pouvons éliminer A ! • Si opt* > lb( A ) , nous explorons A normalement ! Cours d'algorithmique 12 / Intranet

  21. Solutions approchées----------------------------------------------------------------- • Nous renonçons à l’optimum ! • Une solution rapide et pas trop mauvaise fera l’affaire ! • Calculons juste un réseau connexe de poids minimal ! Cours d'algorithmique 12 / Intranet

  22. Solutions approchées----------------------------------------------------------------- Il n’est pas complet, mais ce n’est pas grave ! 30 15 8 5 10 12 7 18 9 11 Nous relions tout le monde au coût minimal ! Cours d'algorithmique 12 / Intranet

  23. Solutions approchées----------------------------------------------------------------- • Nous renonçons à l’optimum ! • Une solution rapide et pas trop mauvaise fera l’affaire ! • Calculons juste un réseau connexe de poids minimal ! • C’est un « arbre de recouvrement minimal » (ARM) ! • Son calcul est en O( n^2 ) . • Nous allons en déduire un circuit, peut-être pas optimal ! • Mais, notre solution sera rapide à calculer ! Cours d'algorithmique 12 / Intranet

  24. Solutions approchées----------------------------------------------------------------- coût( ARM ) = 45 30 Nous doublons chaque arête et construisons un circuit : CIRC 15 8 5 10 12 7 18 coût( CIRC ) = 90 9 11 coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) Cours d'algorithmique 12 / Intranet

  25. Solutions approchées----------------------------------------------------------------- coût( ARM ) = 45 30 Nous doublons chaque arête et construisons un circuit : CIRC 15 8 5 10 12 7 18 coût( CIRC ) = 90 9 11 Nous évitons de passer plusieurs fois dans un sommet en prenant un raccourci ! ! ! coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) Cours d'algorithmique 12 / Intranet

  26. Solutions approchées----------------------------------------------------------------- coût( ARM ) = 45 30 Nous doublons chaque arête et construisons un circuit : CIRC 15 8 5 10 12 7 18 coût( CIRC ) = 90 9 11 Nous évitons de passer plusieurs fois dans un sommet en prenant un raccourci ! ! ! coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) Cours d'algorithmique 12 / Intranet

  27. Solutions approchées----------------------------------------------------------------- coût( ARM ) = 45 30 Nous doublons chaque arête et construisons un circuit : CIRC 15 8 5 10 12 7 18 coût( CIRC ) = 90 9 11 Si l’inégalité triangulaire est vérifiée le circuit SOL que nous trouvons est plus court que CIRC ! ! ! Nous évitons de passer plusieurs fois dans un sommet en prenant un raccourci ! ! ! coût( ARM ) <= coût( TSP ) <= coût( SOL ) <= coût( CIRC ) = 2*coût( ARM ) Cours d'algorithmique 12 / Intranet

  28. Solutions approchées----------------------------------------------------------------- • Nous obtenons un circuit en temps O( n^2 ) ! • Notre solution est au pire deux fois plus longue que le circuit optimal ! • C’est en fait très mauvais, dans le pire des cas ! • En moyenne, nous sommes à 5% ou 10% de l’optimum ! • Il y a des algorithmes approchés meilleurs que celui-ci . Cours d'algorithmique 12 / Intranet

  29. Nous avons parlé de tout ceci : • Trier et chercher, recherche textuelle • Listes et arbres • Le back-track, solutions approchées • Arbres équilibrés • Récursivité et induction sur la structure • Divide and conquer, algorithmes gloutons • Minimax, alpha-beta • Dérécursion • NP-complétude, Branch-and-Bound • Logique de Hoare • Programmation dynamique • Complexité et calculabilité Cours d'algorithmique 12 / Intranet

  30. Nous n’avons pas parlé de : • Langages objets Cours d'algorithmique 12 / Intranet

  31. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels Cours d'algorithmique 12 / Intranet

  32. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques Cours d'algorithmique 12 / Intranet

  33. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes Cours d'algorithmique 12 / Intranet

  34. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique Cours d'algorithmique 12 / Intranet

  35. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique • Calcul parallèle Cours d'algorithmique 12 / Intranet

  36. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique • Calcul parallèle • Calcul réparti Cours d'algorithmique 12 / Intranet

  37. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique • Calcul parallèle • Calcul réparti • Du Web et ses langages Cours d'algorithmique 12 / Intranet

  38. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique • Calcul parallèle • Calcul réparti • Du Web et ses langages • Traitement d’images, son, . . . Cours d'algorithmique 12 / Intranet

  39. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique • Calcul parallèle • Calcul réparti • Du Web et ses langages • Traitement d’images, son, . . . • Optimisation combinatoire Cours d'algorithmique 12 / Intranet

  40. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique • Calcul parallèle • Calcul réparti • Du Web et ses langages • Traitement d’images, son, . . . • Optimisation combinatoire • Génie logiciel Cours d'algorithmique 12 / Intranet

  41. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique • Calcul parallèle • Calcul réparti • Du Web et ses langages • Traitement d’images, son, . . . • Optimisation combinatoire • Génie logiciel • Tests de programmes Cours d'algorithmique 12 / Intranet

  42. Nous n’avons pas parlé de : • Langages objets • Langages fonctionnels • Langages logiques • Graphes • Analyse numérique • Calcul parallèle • Calcul réparti • Du Web et ses langages • Traitement d’images, son, . . . • Optimisation combinatoire • Génie logiciel • Tests de programmes • . . . et bien d’autres ! Cours d'algorithmique 12 / Intranet

More Related