Cours d’Algorithmique

Présentation au sujet: "Cours d’Algorithmique"— Transcription de la présentation:

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

2 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

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

4 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

5 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

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

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

8 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

9 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

10 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

11 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

12 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

13 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

14 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

15 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

16 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

17 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

18 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

19 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

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

21 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

22 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

23 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

24 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

25 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

26 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

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

28 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

29 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

30 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

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

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

33 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

34 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

35 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

36 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

37 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

38 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

39 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

40 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

41 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

42 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

43 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

44 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

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

46 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

47 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

48 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

49 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

50 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

51 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

52 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

53 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

54 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

55 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

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

57 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

58 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

59 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

60 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

61 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

62 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

63 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

64 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

65 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

66 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

67 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

68 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

69 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

70 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

71 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

72 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

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

74 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

75 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

76 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

77 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

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

79 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

80 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

81 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

82 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

83 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

84 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

85 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

86 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

87 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

88 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

89 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

90 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

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

92 Branch and Bound -----------------------------------------------------------------
Exemple : ( ) s = 42 +µ +µ +µ +µ 30 +µ +µ 15 10 17 +µ 45 35 +µ Donc : lb ( A ) = 102 = +µ +µ 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

93 Branch and Bound -----------------------------------------------------------------
Exemple : ( ) s = 42 +µ +µ +µ +µ 15 +µ +µ 7 +µ 35 +µ Donc : lb ( A ) = 102 = +µ +µ 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

94 Branch and Bound -----------------------------------------------------------------
Exemple : ( ) s = 42 +µ +µ +µ +µ 15 +µ +µ 7 +µ 35 +µ Donc : lb ( A ) = 102 = +µ +µ 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

95 Branch and Bound -----------------------------------------------------------------
Exemple : ( ) s = 42 +µ +µ +µ +µ 15 +µ +µ 7 +µ 35 +µ Donc : lb ( A ) = 102 = +µ +µ Mieux, nous diminuons chaque ligne de son minimum et nous appliquons le même raisonnement aux colonnes ! lb ( A ) = 109 = 10 janvier 2007 Cours d'algorithmique 12 / Intranet

96 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 = +µ +µ Mieux, nous diminuons chaque ligne de son minimum et nous appliquons le même raisonnement aux colonnes ! lb ( A ) = 109 = 10 janvier 2007 Cours d'algorithmique 12 / Intranet

97 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

98 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

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

100 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

101 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

102 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

103 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

104 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

105 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

106 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

107 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

108 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

109 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

110 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

111 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

112 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

113 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

114 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

115 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

116 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

117 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

118 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

119 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

120 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

121 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

122 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

123 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

124 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

125 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

126 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

127 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

128 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

129 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

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

131 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

132 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

133 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

134 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

135 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

136 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

137 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

138 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

139 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

140 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

141 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

142 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

143 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

144 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