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

Présentation générale 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é 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

TSP ----------------------------------------------------------------- Le « Voyageur de Commerce », en anglais « Traveling Salesman Problem » ( TSP ) : 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Le « Voyageur de Commerce », en anglais « Traveling Salesman Problem » ( TSP ) : « n » villes, un réseau routier complet entre ces villes avec les distances, 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ? 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Exemple : B D A C 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Exemple : B 15 30 17 D 35 A 45 C 20 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Exemple : B 15 30 17 D 35 A 45 C 20 Un tour à coût 110 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Exemple : B 15 30 17 D 35 A 45 C 20 Un tour à coût 110 ! Un tour à coût 87 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Exemple : La matrice M des distances : B 15 30 17 D 35 A 45 C 20 ( ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Exemple : La matrice M des distances : B 15 30 17 D 35 A 45 C 20 ( ) +µ +µ La diagonale à +µ ou à 0 ! +µ +µ 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Exemple : La matrice M des distances : B 15 30 17 D 35 A 45 C 20 ( ) A +µ B +µ C +µ D +µ 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Exemple : La matrice M des distances : B 15 30 17 D 35 A 45 C 20 ( ) A +µ 30 20 35 B +µ C +µ D +µ 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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

TSP ----------------------------------------------------------------- Exemple : La matrice M des distances : B 15 30 17 D 35 A 45 C 20 ( ) A +µ 30 20 35 B 30 +µ 17 15 C 20 +µ D 35 +µ 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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

TSP ----------------------------------------------------------------- Exemple : La matrice M des distances : B 15 30 17 D 35 A 45 C 20 ( ) A +µ 30 20 35 B 30 +µ 17 15 C 20 17 +µ 45 D 35 15 +µ 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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

TSP ----------------------------------------------------------------- Pour avoir un circuit il faut sélectionner « n » arêtes ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Pour avoir un circuit il faut sélectionner « n » arêtes ! La représentation du problème : 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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, 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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, 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 », 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 à +µ. 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Lorsque nous avons sélectionné « n » arêtes, il faut rendre « s » comme résultat ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 !) . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Les arêtes sélectionnées ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

TSP ----------------------------------------------------------------- Les arêtes sélectionnées ! Nous pouvons compléter vers un circuit ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 » à +µ . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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. 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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, 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 : 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ) } 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ) <- +µ ] Plus de départ depuis a , plus d ’arrivée vers b ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- E V I T O N S C E R T A I N S C A L C U L S ! ! ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- L’idée est la suivante : 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- L’idée est la suivante : Si les arêtes que nous avons déjà choisies sont très chères, 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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, 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! ! ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Le programme gère une variable opt* qui mémorise la longueur de la meilleure solution trouvée jusqu’à présent. 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ) . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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* . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! ! ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 : Comment exploiter "lb" ? lb( A ) <= opt( A ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Nous allons comparer lb( A ) à opt* : 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Nous allons comparer lb( A ) à opt* : Si opt* <= lb( A ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Nous allons comparer lb( A ) à opt* : Si opt* <= lb( A ) alors opt* <= lb( A ) <= opt( A ) . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! ! ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ). 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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. 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 . . . ? ? ? 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Qui ne tente rien n'a rien ! 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 ! Qui ne tente rien n'a rien ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Principe du Branch-and-Bound ( Séparer et évaluer ) : 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Principe du Branch-and-Bound ( Séparer et évaluer ) : Nous connaissons opt* ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Principe du Branch-and-Bound ( Séparer et évaluer ) : Nous connaissons opt* ! Nous calculons lb( A ) en « temps raisonnable » ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ? 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Le calcul spéculatif : 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Le calcul spéculatif : Si nous lui consacrons trop peu de temps, la borne sera mauvaise et ne servira à rien ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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. 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Pour notre TSP : 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Pour notre TSP : Nous avons « c » , « E » , « s » et « M » . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Pour notre TSP : Nous avons « c » , « E » , « s » et « M » . Donc, il y a « c » lignes complètement remplies avec +µ . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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. 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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. 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 +µ . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cette borne est cependant 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 +µ . Cette borne est cependant assez mauvaise ! ! ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Exemple : ( ) s = 42 +µ +µ +µ +µ 30 +µ +µ 15 10 17 +µ 45 35 +µ +µ +µ 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Exemple : ( ) s = 42 +µ +µ +µ +µ 30 +µ +µ 15 10 17 +µ 45 35 +µ +µ +µ 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Branch and Bound ----------------------------------------------------------------- Exemple : ( ) s = 42 +µ +µ +µ +µ 30 +µ +µ 15 10 17 +µ 45 35 +µ +µ +µ 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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

Branch and Bound ----------------------------------------------------------------- Exemple : ( ) s = 42 +µ +µ +µ +µ 30 +µ +µ 15 10 17 +µ 45 35 +µ 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Branch and Bound ----------------------------------------------------------------- Exemple : ( ) s = 42 +µ +µ +µ +µ 15 +µ +µ 7 +µ 35 +µ 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Branch and Bound ----------------------------------------------------------------- Exemple : ( ) s = 42 +µ +µ +µ +µ 15 +µ +µ 7 +µ 35 +µ 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Branch and Bound ----------------------------------------------------------------- Exemple : ( ) s = 42 +µ +µ +µ +µ 15 +µ +µ 7 +µ 35 +µ 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 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 +µ +µ 7 +µ 35 +µ 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 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Solutions approchées ----------------------------------------------------------------- N O U S R E N O N C O N S A L ‘ O P T I M U M ! ! ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Solutions approchées ----------------------------------------------------------------- Nous renonçons à l’optimum ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Solutions approchées ----------------------------------------------------------------- Nous renonçons à l’optimum ! Une solution rapide et pas trop mauvaise fera l’affaire ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Il n’est pas complet, mais ce n’est pas grave ! Solutions approchées ----------------------------------------------------------------- Il n’est pas complet, mais ce n’est pas grave ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Il n’est pas complet, mais ce n’est pas grave ! Solutions approchées ----------------------------------------------------------------- Il n’est pas complet, mais ce n’est pas grave ! 30 15 8 5 10 12 7 18 9 11 10 janvier 2007 Cours d'algorithmique 12 / Intranet

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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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) ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ) . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Solutions approchées ----------------------------------------------------------------- coût( ARM ) = 45 30 15 8 5 10 12 7 18 9 11 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 9 11 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 Forcément ! coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 Le TSP est le meilleur circuit ! coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 Par construction ! coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

coût( ARM ) <= coût( TSP ) <= coût( CIRC ) = 2*coût( ARM ) 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( CIRC ) = 2*coût( ARM ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ) 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet Solutions approchées ----------------------------------------------------------------- Nous obtenons un circuit en temps O( n^2 ) ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet 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 . 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Exploration combinatoire complète Branch-and-Bound Synthèse ----------------------------------------------------------------- Exploration combinatoire complète Branch-and-Bound Solutions approchées 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Présentation générale 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é 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale Nous n’avons pas parlé de : Langages objets 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale Nous n’avons pas parlé de : Langages objets Langages fonctionnels 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale Nous n’avons pas parlé de : Langages objets Langages fonctionnels Langages logiques 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale Nous n’avons pas parlé de : Langages objets Langages fonctionnels Langages logiques Graphes 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale Nous n’avons pas parlé de : Langages objets Langages fonctionnels Langages logiques Graphes Analyse numérique 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale Nous n’avons pas parlé de : Langages objets Langages fonctionnels Langages logiques Graphes Analyse numérique Calcul parallèle 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale Nous n’avons pas parlé de : Langages objets Langages fonctionnels Langages logiques Graphes Analyse numérique Calcul parallèle Calcul réparti 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale 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 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale 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, . . . 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale 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 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale 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 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale 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 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Présentation générale 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 ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet Cours d'algorithmique

Cours d'algorithmique 12 / Intranet N O U S A L L O N S E N C H A I N E R A V E C L E C O U R S D E G R A P H E S 10 janvier 2007 Cours d'algorithmique 12 / Intranet

Cours d'algorithmique 12 / Intranet B O N N E C H A N C E A L ’ E X A M E N ! ! ! B O N N E C O N T I N U A T I O N ! ! ! 10 janvier 2007 Cours d'algorithmique 12 / Intranet