Chapitre 9 Algorithmique -...

Informatique (presque) débranchée Chapitre 9

Chapitre 9

AlgorithmiqueOn désigne par algorithmique l'ensemble des activités logiques qui relèvent des algorithmes ; en

particulier, en informatique, cette discipline désigne l'ensemble des règles et des techniques qui sontimpliquées dans la définition et la conception des algorithmes.

9.1. Quelques définitionsLe mot « algorithme » vient du nom du mathématicien Al Khwarizmi, qui, au 9ème siècle écrivit

le premier ouvrage systématique sur la solution des équations linéaires et quadratiques. La notiond'algorithme est donc historiquement liée aux manipulations numériques, mais elle s'estprogressivement développée pour porter sur des objets de plus en plus complexes : des textes, desimages, des formules logiques, des objets physiques, etc.

Un algorithme est un énoncé d'une suite d'opérations permettant de donner la réponse à unproblème.

• Si les opérations s'exécutent sur plusieurs processeurs en parallèle, on parle d'algorithmeparallèle.

• Si les tâches s'exécutent sur un réseau de processeurs on parle d'algorithme distribué. • Un algorithme qui contient un appel à lui-même est dit récursif. • Un algorithme glouton est un algorithme qui suit le principe de faire, étape par étape, un

choix optimum local, dans l'espoir d'obtenir un résultat optimum global. Dans les cas oùl'algorithme ne fournit pas systématiquement la solution optimale, il est appelé uneheuristique gloutonne.

• En optimisation combinatoire, théorie des graphes et théorie de la complexité, uneheuristique est un algorithme qui fournit rapidement (en temps polynomial) une solutionréalisable, mais pas nécessairement optimale, pour un problème d'optimisation difficile.Une heuristique, ou méthode approximative, est donc le contraire d'un algorithme exact quitrouve une solution optimale pour un problème donné. L'usage d'une heuristique estpertinente pour calculer une solution approchée d'un problème et ainsi accélérer leprocessus de résolution exacte.

• Les métaheuristiques forment une famille d'algorithmes d'optimisation visant à résoudre des

Didier Müller 9-1 octobre 2017

Algorithmique

problèmes d'optimisation difficile (souvent issus des domaines de la rechercheopérationnelle, de l'ingénierie ou de l'intelligence artificielle) pour lesquels on ne connaîtpas de méthode classique plus efficace. Ces méthodes utilisent cependant un haut niveaud'abstraction, leur permettant d'être adaptées à une large gamme de problèmes différents.Les métaheuristiques les plus connues sont la recherche avec tabous, le recuit simulé, lesalgorithmes génétiques et les colonies de fourmis.

9.2. Le problème des huit damesLe but du problème des huit dames, est de placer huit damesd'un jeu d'échecs sur un échiquier de 8×8 cases sans que lesdames ne puissent se menacer mutuellement, conformément auxrègles du jeu d'échecs. Par conséquent, deux dames ne devraientjamais partager la même rangée, colonne, ou diagonale (voirdessin ci-contre).

Durant des années, beaucoup de mathématiciens, y comprisGauss ont travaillé sur ce problème, qui est un cas particulier duproblème généralisé des n-dames, posé en 1850 par FranzNauck, et qui est de placer n dames « libres » sur un échiquierde n×n cases. En 1874, S. Gunther proposa une méthode pourtrouver des solutions en employant des déterminants, et J. W. L.Glaisher affina cette approche.

Le problème des huit dames a 92 solutions distinctes, ou seulement 12 solutions si l'on tientcompte de transformations telles que des rotations ou des réflexions.

Le problème des huit dames est un bon exemple de problème simple mais non évident. Pour cetteraison, il est souvent employé comme support de mise en œuvre de différentes techniques deprogrammation, y compris d'approches non traditionnelles de la programmation telles que laprogrammation par contraintes, la programmation logique ou les algorithmes génétiques.

9.2.1. Algorithme naïfL'algorithme naïf de recherche exhaustive teste toutes les manières possibles de placer une dame

par colonne, pour retirer toutes celles pour lesquelles des dames se menacent mutuellement.Il y a 88 = 16'777'216 placements à explorer.

Exercice 9.1Exercice 9.1

Programmez l'algorithme naïf pour trouver les 92 solutions au problème des huit dames. Vous représenterez la position par une liste de nombres de 0 à 7. Ces nombres indiquent la ligne surlaquelle la dame se trouve pour la colonne correspondante. Par exemple, la 12 ème solution dugraphique ci-dessus sera représentée par la liste : [2, 4, 1, 7, 0, 6, 3, 5].



9.2.2. Recherche en profondeurLa recherche en profondeur consiste à trouver les solutions en plaçant les dames de gauche à

droite. Prenons pour simplifier un exemple sur un damier 4x4. Imaginons que toutes les solutionsavec la première dame sur la première ligne ont été trouvées (voir dessin ci-dessous).

On veut maintenant placer la première dame sur la 2ème ligne. Plaçons la deuxième dame sur la ligne 1. Il y a conflit : STOP. On ne cherche pas plus loin. Idem

pour les lignes 2 et 3. La seule solution possible est la 4ème ligne. Plaçons maintenant la troisième dame. On peut la mettre sur la première ligne sans conflit.Plaçons alors la 4ème et dernière dame. La seule ligne possible est la 3ème. On a une solution :

[1,3,0,2].On remonte alors dans l'arbre : la troisième dame ne peut se placer sur aucune autre ligne.Remontons encore d'un cran.On a déjà essayé toutes les lignes pour la deuxième dame.Remontons encore d'un cran : plaçons la première dame sur la 3ème ligne et recommençons une

recherche en profondeur...


Programmez la recherche en profondeur expliquée ci-dessus. Comptez le nombre de situations(intermédiaires et finales) analysées.

9.2.3 Méthode heuristiqueUn algorithme de « réparation itérative » commence typiquement à partir d'un placement de

toutes les dames sur l'échiquier, par exemple avec une seule dame par ligne et par colonne. Il essaieensuite toutes les permutations des colonnes (il n'y a que des conflits diagonaux à tester) pour negarder que les configurations sans conflits.

Il y a 8! = 40'320 placements à explorer.


Placez initialement les 8 dames sur la diagonale de l'échiquier, puis échangez deux colonneschoisies au hasard. Répétez l'opération jusqu'à ce qu'une solution soit trouvée.


Modifiez le programme de l'exercice 9.3 pour trouver les 92 solutions. Le programme ci-dessouspourra vous aider. N'essayez pas de le comprendre, il fait appel à des notions avancées de Python quel'on n'a pas vues (Iterators et generators). Contentez-vous de l'intégrer à votre programme.


Algorithmique

def all_perms(str): if len(str)<=1: yield str else: for perm in all_perms(str[1:]): for i in range(len(perm)+1): yield perm[:i] + str[0:1] + perm[i:]

for p in all_perms([0,1,2]): print(p)

Le résultat sera :

[0, 1, 2][1, 0, 2][1, 2, 0][0, 2, 1][2, 0, 1][2, 1, 0]

9.3. Algorithmes gloutonsUn algorithme glouton (en anglais : greedy) est un algorithme qui suit le principe de faire, étape

par étape, un choix optimum local, dans l'espoir d'obtenir un résultat optimum global. Il n'y a pas deretour en arrière : à chaque étape de décision dans l'algorithme, le choix qui semble le meilleur à cemoment est effectué et est définitif. Les algorithmes gloutons servent surtout à résoudre desproblèmes d'optimisation.

Exemple : rendu de monnaie

Dans le problème du rendu de monnaie (donner une somme avec le moins possible de pièces),l'algorithme consistant à répéter le choix de la pièce de plus grande valeur qui ne dépasse pas lasomme restante est un algorithme glouton.

Suivant le système de pièces, l'algorithme glouton est optimal ou pas. Dans le système de pièceseuropéen (en centimes : 1, 2, 5, 10, 20, 50, 100, 200), où l'algorithme glouton donne la sommesuivante pour 37 : 20+10+5+2, on peut montrer que l'algorithme glouton donne toujours une solutionoptimale.

Dans le système de pièces (1, 3, 4), l'algorithme glouton n'est pas optimal. En effet, il donne pour6 : 4+1+1, alors que 3+3 est optimal.


Une route comporte n stations-service, numérotées dans l'ordre du parcours, de 0 à n-1. Lapremière est à une distance d[0] du départ, la deuxième est à une distance d[1] de la première, latroisième à une distance d[2] de la deuxième, etc. La fin de la route est à une distance d[n] de lan-ième et dernière station-service.

Un automobiliste prend le départ de la route avec une voiture dont le réservoir d'essence est plein.Sa voiture est capable de parcourir une distance r avec un plein.

Question 9.5.1

Donnez une condition nécessaire et suffisante pour que l'automobiliste puisse effectuer leparcours. On la supposera réalisée par la suite.

Question 9.5.2

Prenez 17 stations-service avec les distances d = [23, 40, 12, 44, 21, 9, 67, 32, 51, 30, 11, 55, 24,64, 32, 57, 12, 80] et r = 100.

L'automobiliste désire faire le plein le moins souvent possible. Écrivez une fonction Pythonrapide qui détermine à quelles stations-service il doit s'arrêter.




Un cambrioleur entre par effraction dans une maison. Il n'est capable de porter que K kilos : il luifaudra donc choisir entre les différents objets de valeur, afin d'amasser le plus gros magot possible.

On supposera dans un premier temps que les objets sont fractionnables (on peut en prendren'importe quelle quantité, c'est le cas d'un liquide ou d'une poudre). Il y a n matières différentes,numérotées de 0 à n-1, la i-ème ayant un prix p[i] par kilo. La quantité disponible de cette matièreest q[i]. On suppose que tous les prix sont différents deux à deux.

Question 9.6.1

Proposez un algorithme qui donne un choix optimal pour le voleur. Ce choix est-il unique ?Programmez une fonction voleur en Python qui reprenne cet algorithme (vous pourrez supposer

que le tableau p est trié).

Prenez par exemple : p = [43, 40, 37, 33, 28, 25, 20, 17, 14, 13], q = [7, 6, 12, 11, 2, 23, 1, 4, 24,43], K = 55.

Question 9.6.2

On suppose maintenant que les objets sont non fractionnables (c'est le cas d'un vase ou d'untéléviseur). Le i-ème objet vaut un prix p[i] et pèse un poids q[i].

Proposez une méthode dérivée de la question 1 (sans la programmer). Donne-t-elle un choix optimal ?

http://ow.ly/4tpWm

9.4. Algorithmes de triUne des opérations les plus courantes en programmation est

le tri d'objets. Les ordres les plus utilisés sont l'ordre numériqueet l'ordre lexicographique.

Les principales caractéristiques qui permettent de différencierles algorithmes de tri sont la complexité algorithmique (voir§ 8.5) et les ressources nécessaires (notamment en termed'espace mémoire utilisé) .

On peut montrer que la complexité temporelle en moyenne et dans le pire des cas d'un algorithmebasé sur une fonction de comparaison ne peut pas être meilleure que O(nlog(n)). Les tris qui nedemandent que O(nlog(n)) comparaisons en moyenne sont alors dits optimaux.

Dans les algorithmes ci-dessous, on effectuera des tris par ordre croissant.

9.4.1. Tri par sélectionLe tri par sélection est un des algorithmes de tri les plus triviaux. On recherche le plus grand élément que l'on va replacer à sa position finale, c'est-à-dire en

dernière position. Puis on recherche le second plus grand élément que l'on va placer en avant-dernière position, etc.,

jusqu'à ce que le tableau soit entièrement trié.

def swap(l,i,j): # echange 2 valeurs d'une liste l[i],l[i] = l[j], l[i]

def tri_selection(l): for i in range(len(l)-1): mini=i for j in range(i+1,len(l)): if l[j]<l[mini]: mini=j swap(l,i,mini)


http://ow.ly/4tpWm

Algorithmique

Complexité

• Meilleur des cas : O(n2) quand le tableau est déjà trié.• Pire cas : O(n2) quand le tableau est trié en ordre inverse.• En moyenne : O(n2).

9.4.2. Tri à bulles (Bubble sort)Le tri à bulles est un algorithme de tri qui consiste à faire remonter progressivement les plus

petits éléments d'une liste, comme les bulles d'air remontent à la surface d'un liquide. L'algorithme parcourt la liste, et compare les couples d'éléments successifs. Lorsque deux

éléments successifs ne sont pas dans l'ordre croissant, ils sont échangés. Après chaque parcourscomplet de la liste, l'algorithme recommence l'opération. Lorsqu'aucun échange n'a lieu pendant unparcours, cela signifie que la liste est triée : l'algorithme peut s'arrêter.

Cet algorithme est souvent enseigné en tant qu'exemple algorithmique. Cependant, il présente unecomplexité en O(n2) dans le pire des cas (où n est la longueur de la liste), ce qui le classe parmi lesmauvais algorithmes de tri. Il n'est donc quasiment pas utilisé en pratique.

def swap(l,i,j): # echange 2 valeurs d'une liste l[i],l[j] = l[j],l[i]

def tri_a_bulles(l): for i in range(len(l)): for j in reversed(range(i,len(l))): if l[j]<l[j-1]: swap(l,j-1,j)

Complexité

• Meilleur cas : O(n) quand le tableau est trié.• Pire des cas : O(n2) quand le tableau est trié en ordre inverse (n-1)·(n-1) = O(n2)

9.4.3. Tri par insertionLe tri par insertion est le tri le plus efficace sur des listes de petite taille. C'est pourquoi il est

utilisé par d'autres méthodes comme le Quicksort (voir § 9.4.4). Il est d'autant plus rapide que lesdonnées sont déjà triées en partie dans le bon ordre.

Le principe de ce tri est très simple : c'est le tri que toute personne utilise naturellement quandelle a des dossiers (ou n'importe quoi d'autre) à classer. On prend un dossier et on le met à sa placeparmi les dossiers déjà triés. Puis on recommence avec le dossier suivant.

Pour procéder à un tri par insertion, il suffit de parcourir une liste : on prend les éléments dansl'ordre. Ensuite, on les compare avec les éléments précédents jusqu'à trouver la place de l'élémentqu'on considère. Il ne reste plus qu'à décaler les éléments du tableau pour insérer l'élément considéréà sa place dans la partie déjà triée.

def tri_insertion(liste): j, n = 1, len(liste) while j != n: i = j - 1 temp = liste[j] while i > -1 and liste[i] > temp: liste[i+1] = liste[i] i = i - 1 liste[i+1] = temp j = j + 1

Complexité

• Pire cas : O(n2) quand le tableau est trié en ordre inverse • Moyenne : O(n2)



9.4.4. QuicksortLe Quicksort est une méthode de tri inventée par Sir

Charles Antony Richard Hoare en 1961 et fondée sur laméthode de conception « diviser pour régner ». Il peutêtre implémenté sur un tableau ou sur des listes ; sonutilisation la plus répandue concerne tout de même lestableaux.

Le Quicksort est un tri dont la complexité moyenneest en O(n·log(n)), mais dont la complexité dans le piredes cas est un comportement quadratique en O(n2).Malgré ce désavantage théorique, c'est en pratique un destris les plus rapide pour des données répartiesaléatoirement. Les entrées donnant lieu au comportementquadratique dépendent de l'implémentation del'algorithme, mais sont souvent (si l'implémentation estmaladroite) les entrées déjà presque triées. Il sera plusavantageux alors d'utiliser le tri par insertion.

La méthode consiste à placer un élément du tableau(appelé pivot) à sa place définitive, en permutant tous leséléments de telle sorte que tous ceux qui lui sontinférieurs soient à sa gauche et que tous ceux qui lui sontsupérieurs soient à sa droite. Cette opération s'appelle lepartitionnement.

Pour chacun des sous-tableaux, on définit un nouveaupivot et on répète l'opération de partitionnement. Ceprocessus est répété récursivement, jusqu'à ce quel'ensemble des éléments soit trié.

def partition(tab, debut, fin): while debut < fin: while debut < fin: if tab[debut] > tab[fin]: tab[debut], tab[fin] = tab[fin], tab[debut] break fin = fin - 1 while debut < fin: if tab[debut] > tab[fin]: tab[debut], tab[fin] = tab[fin], tab[debut] break debut = debut + 1 return debut def quicksort(tab, debut=None, fin=None): if debut is None: debut = 0 if fin is None: fin = len(tab) if debut < fin: i = partition(tab, debut, fin-1) quicksort(tab, debut, i) quicksort(tab, i+1, fin)

Dans la pratique, pour les partitions avec un faible nombre d'éléments (jusqu'à environ 15éléments), on a souvent recours à un tri par insertion qui se révèle plus efficace que le Quicksort.

Le problème le plus important est le choix du pivot. Une implémentation du Quicksort qui nechoisit pas adéquatement le pivot sera très inefficace pour certaines entrées. Par exemple, si le pivotest toujours le plus petit élément de la liste, Quicksort sera aussi inefficace qu'un tri par sélection.

Complexité

• Pire des cas : O(n2) quand le tableau est trié en ordre inverse • En moyenne et dans le meilleur des cas : O(nlog(n))


Algorithmique

9.4.5. Tri par fusion (Mergesort)Le tri par fusion repose sur le fait que, pour fusionner deux listes/tableaux trié(e)s dont la somme

des longueurs est n, n-1 comparaisons au maximum sont nécessaires. Pour aller aussi vite que leQuicksort, il a donc besoin d'utiliser O(n)mémoire supplémentaire, mais il a l'avantaged'être stable c'est-à-dire de ne pas mélanger ce quiest déjà trié.

L'algorithme peut être décrit récursivement :

1. On découpe en deux parties à peu prèségales les données à trier.

2. On trie les données de chaque partie.3. On fusionne les deux parties.

La récursivité s'arrête car on finit par arriver àdes listes composées d'un seul élément et le tri estalors trivial.

On peut aussi utiliser un algorithme itératif :

1. On trie les éléments deux à deux.2. On fusionne les listes obtenues.3. On recommence l'opération précédente

jusqu'à ce qu'on ait une seule liste triée.

Complexité

• Moyenne et pire des cas : O(nlog(n))

def merge(l1, l2): liste = [] i = j = 0 n1=len(l1) n2=len(l2) while True: if i<n1 and j<n2: if l1[i]<l2[j]: liste.append(l1[i]) i+=1 else: liste.append(l2[j]) j+=1 elif i>=n1: liste.extend(l2[j:]) break else: liste.extend(l1[i:]) break return liste

def tri_fusion(liste): def tri_fusion_interne(liste): if len(liste)<2 : return liste return merge(tri_fusion_interne(liste[:len(liste)//2]),

tri_fusion_interne(liste[len(liste)//2:])) liste[:] = tri_fusion_interne(liste)



9.4.6. Tri par tas (Heapsort)Cet algorithme permet de trier les éléments d'un tableau en O(n log (n)) dans le pire des cas, où n

est le nombre d'éléments à trier. Les principaux atouts de cette méthode sont la faible consommationmémoire et l'efficacité optimale.

Principe

L'idée qui sous-tend cet algorithme consiste à voir le tableau comme un arbre binaire. Le premierélément est la racine, le deuxième et le troisième sont les deux descendants du premier élément, etc.Ainsi le n-ième élément a pour fils les éléments 2n+1 et 2n+2. Si le tableau n'est pas de taille 2n, lesbranches ne se finissent pas tout à fait à la même profondeur.

Dans l'algorithme, on cherche à obtenir un tas, c'est-à-dire un arbre binaire vérifiant les propriétéssuivantes (les deux premières propriétés découlent de la manière dont on considère les éléments dutableau) :

• la différence maximale de profondeur entre deux feuilles est de 1 (i.e. toutes les feuilles setrouvent sur la dernière ou sur l'avant-dernière ligne) ;

• les feuilles de profondeur maximale sont « tassées » sur la gauche. • chaque nœud est de valeur supérieure à celles de ses deux fils, pour un tri ascendant.

Comme expliqué au paragraphe 6.4.2, un tas ou un arbre binaire presque complet peut être stockédans un tableau, en posant que les deux descendants de l'élément d'indice n sont les élémentsd'indices 2n+1 et 2n+2 (pour un tableau indicé à partir de 0). En d'autres termes, les nœuds de l'arbresont placés dans le tableau ligne par ligne, chaque ligne étant décrite de gauche à droite.

Une fois le tas de départ obtenu, l'opération de base de ce tri est le tamisage d'un élément,supposé le seul « mal placé » dans un arbre qui est presque un tas. Plus précisément, considérons unarbre T = T[0] dont les deux sous-arbres (T[1] et T[2]) sont des tas, tandis que la racine estéventuellement plus petite que ses fils. L'opération de tamisage consiste à échanger la racine avec leplus grand de ses fils, et ainsi de suite récursivement jusqu'à ce qu'elle soit à sa place.

Pour construire un tas à partir d'un arbre quelconque, on tamise les racines de chaque sous-tas, debas en haut (par taille croissante) et de droite à gauche.

Pour trier un tableau à partir de ces opérations, on commence par le transformer en tas. Onéchange la racine avec le dernier élément du tableau, et on restreint le tas en ne touchant plus audernier élément, c'est-à-dire à l'ancienne racine. On tamise la racine dans le nouveau tas, et on répètel'opération sur le tas restreint jusqu'à l'avoir vidé et remplacé par un tableau trié.

def faire_tas(tab, debut, n): # transforme le tableau "tab" en un tas racine = debut while racine*2 + 1 < n: fils = racine*2 + 1 if fils < n-1 and tab[fils] < tab[fils+1]: fils += 1 if tab[racine] < tab[fils]: tab[racine], tab[fils] = tab[fils], tab[racine] racine = fils else: return def heapsort(tab): n = len(tab) debut = n//2 - 1 fin = n - 1 while debut >= 0: faire_tas(tab, debut, n) debut -= 1 while fin > 0: tab[fin], tab[0] = tab[0], tab[fin] faire_tas(tab, 0, fin) fin -= 1


Algorithmique

9.5. Tester si un point est dans un polygone Dans le plan, étant donné un polygone simple (dont les arêtes ne se coupent pas), comment

déterminer si un point se trouve à l'intérieur ou à l'extérieur de ce polygone ?

Méthode

La méthode la plus utilisée est de tracer une demi-droite de ce point vers l'infini et de compter lesintersections entre cette droite et les segments du polygone.

• Tracer une demi-droite à partir du point vers l'infini. • Calculer le nombre L d'intersections entre cette demi-droite et les côtés du polygone. • Un nombre L impair indique que le point est à l'intérieur. • Il faut bien sûr faire attention aux coins qui tombent juste sur la demi-droite.

Nombre pair d'intersection : Nombre impair d'intersections :point à l'extérieur point à l'intérieur

9.5.1. Pour savoir si deux segments se coupentLa première chose à faire est de trouver une méthode

pour localiser un point P par rapport à une ligne passantpar les points P0 et P1. Le dessin ci-dessous illustre lestrois possibilités.

Pour différencier ces trois cas, on peut utiliser lesdéterminants. En effet, rappelons-nous qu'un déterminantpeut être interprété comme une aire signée.

Ainsi, sur le dessin ci-contre :

dét(P0P1, P0P2) > 0dét(P0P1, P0P3) < 0dét(P0P1, P0P4) = 0

où les PiPj désignent des vecteurs-colonnes et dét un déterminant 2x2.

On dira que :

orientation(P0, P1, P2) = 1orientation(P0, P1, P3)= -1orientation(P0, P1, P4)= 0

D'où la condition ci-dessous :

SI orientation(Q0,Q1,P0) orientation(Q0,Q1,P1) ET orientation(P0,P1,Q0) orientation(P0,P1,Q1) ALORS RETOURNER « les deux segments se coupent »




Écrivez un programme Python qui implémente la méthode vue ci-dessus. Le polygone sera donnépar la liste de ses sommets. Vous trouverez sur le site compagnon une ébauche à compléter.

9.6. Enveloppe convexeImaginons une planche avec des clous qui dépassent. Englobons ces points avec un élastique que

l'on relâche. Le polygone obtenu (en bleu ci-dessous) est l'enveloppe convexe (convex hull).

En trois dimensions, l'idée serait la même avec un ballon qui se dégonflerait jusqu'à être encontact avec tous les points qui sont à la surface de l'enveloppe convexe.

9.6.1. Marche de Jarvis (Gift wrapping algorithm)La marche de Jarvis est un algorithme qui « enveloppe » un ensemble de points dans un « papier

cadeau » : on accroche ce papier à un point initial p1, puis on le tend, et on tourne autour du nuage depoints Le premier point rencontré par le papier sera p1, puis p2, ... jusqu'à retrouver p0.

On construit donc l'enveloppe convexe segment par segment, en partant du point p0. Il ne doit yavoir aucun point à gauche du prochain segment pi pi+1. Il n'y aqu'un point pi+1 qui satisfait cette condition ; il faut le chercherparmi les points qui ne sont pas encore sur l'enveloppe convexe.On s'arrête lorsque pi+1 = p0.

Remarquons que les points ne sont pas triés, alors que ce serale cas pour le parcours de Graham.

Cet algorithme doit son nom à R. A. Jarvis, qui publia cetalgorithme en 1973.

Complexité

La complexité est en O(nh), où n est le nombre total desommets et où h représente le nombre de sommets del'enveloppe convexe. On qualifie ce genre d'algorithme de « sensible à la sortie ».


Algorithmique


Écrivez un programme Python qui implémente la marche de Jarvis. Vous trouverez sur le sitecompagnon une ébauche à compléter.

9.6.2. Parcours de Graham (Graham's scan)Cet algorithme doit son nom à Ronald Graham, qui a publié l'algorithme original en 1972.La première étape de cet algorithme consiste à rechercher le point le plus à gauche. S'il y a égalité

entre plusieurs points, l'algorithme choisit parmi eux le point de plus petite ordonnée. Nommons P0

ce point. La complexité en temps de cette étape est en O(n), n étant le nombre de points del'ensemble.

Les autres points Pi sont ensuite triés en fonction de la pente du segment P0Pi, de la plus grandepente à la plus petite. N'importe quel algorithme efficace de tri convient pour cela. À l'issue de cetteétape, on dispose d'un tableau T contenant les points ainsi triés. P0 sera le premier élément de cetableau.

L'algorithme considère ensuite successivement les séquences de trois points contigus dans letableau T, vus comme deux segments successifs. On regarde ensuite si ces deux segments mis aboutà bout constitue un « tournant à gauche » ou un « tournant à droite ».

• Si l'on rencontre un « tournant à droite », l'algorithme passe au point suivant de T. • Si c'est un « tournant à gauche », cela signifie que l'avant-dernier point considéré (le

deuxième des trois) ne fait pas partie de l'enveloppe convexe, et qu'il doit être enlevé de T.Cette analyse se répète ensuite, tant que l'ensemble des trois derniers points est un« tournant à gauche » .

Le processus se terminera quand on retombera sur le point P0. T contiendra alors les pointsformant l'enveloppe convexe.

Complexité

Le tri des points peut se faire avec une complexité en temps en O(nlog(n)). La complexité de laboucle principale peut sembler être en O(n2), parce que l'algorithme revient en arrière à chaque pointpour évaluer si l'un des points précédents est un « tournant à droite ». Mais elle est en fait en O(n),parce que chaque point n'est considéré qu'une seule fois. Ainsi, chaque point analysé soit termine lasous-boucle, soit est retiré de T et n'est donc plus jamais considéré. La complexité globale del'algorithme est donc en O(nlog(n)), puisque la complexité du tri domine la complexité du calculeffectif de l'enveloppe convexe.




Écrivez un programme Python qui implémente le parcours de Graham. Vous trouverez sur le sitecompagnon une ébauche à compléter.

9.7. Algorithmes probabilistesUn algorithme probabiliste est un algorithme dont le déroulement fait appel à des données tirées

au hasard. Dans leur ouvrage Algorithmique, conception et analyse, G. Brassard et P. Bratleyclassent les algorithmes probabilistes en quatre catégories :

Algorithmes numériques

• Utilisés pour approcher la solution à des problèmes numériques (ex. calcul de pi, intégrationnumérique, etc.).

• La précision augmente avec le temps disponible. • Certains auteurs classent ces algorithmes dans la catégorie Monte Carlo

Algorithmes de Sherwood

• Utilisés lorsqu'un algorithme déterministe fonctionne plus rapidement en moyenne qu'enpire cas.

• Ces algorithmes peuvent éliminer la différence entre bonnes et mauvaises entrées. • Exemple : Quicksort

Algorithmes de Las Vegas

• Ces algorithmes peuvent parfois retourner un message disant qu'ils n'ont pas pu trouver laréponse.

• La probabilité d'un échec peut être rendu arbitrairement petite en répétant l'algorithmesuffisamment souvent.

Algorithmes de Monte Carlo

• Ces algorithmes retournent toujours une réponse mais celle-ci n'est pas toujours juste. • La probabilité d'obtenir une réponse correcte augmente avec le temps disponible.


Modifiez le programme de l'exercice 9.7 qui teste si un point est à l'intérieur d'un polygone, afind'estimer l'aire de ce polygone. Pour ce faire, vous générerez 100'000 points au hasard et calculerezle pourcentage de points « tombés » à l'intérieur du polygone.


Développez et programmez une méthode basée sur l'estimation de l'aire d'un quart de cercle pourapprocher la valeur de p.

Exercice 9.12Exercice 9.12 : Le compte est bon (2): Le compte est bon (2)

Nous avons vu au § 7.5 un algorithme récursif cherchant les solutions du jeu. Nous allons ici nouscontenter d'une méthode naïve et peu efficace, mais facile à programmer : il s'agira de rechercheraléatoirement des solutions et de ne garder que celle qui se rapproche le plus du résultat demandé,ou qui l'atteint.

Données : six nombres dans une liste L et le résultat r à approcher.

1. Choisir deux nombres a et b au hasard dans la liste L. 2. Choisir une opération arithmétique (+, -, *, /) au hasard. L'opération doit

être possible (par exemple, on ne peut pas diviser 5 par 9) et utile (il est inutile par exemple de multiplier un nombre par 1).


Algorithmique

3. Poser c := opération(a, b). Mémoriser ce calcul intermédiaire dans une chaînede caractères (une string).

4. Éliminer a et b de la liste L. 5. Ajouter c à la liste L. 6. SI c = r ALORS

afficher tous les calculs intermédiaires. STOP

7. SI il y a plus d'un nombre dans la liste ALORS aller à 1 SINON afficher la liste des calculs intermédiaires et le résultat obtenu

On répétera cet algorithme des milliers de fois et on n'affichera que la meilleure solution trouvée.Programmez cet algorithme en Python.


Modifiez le programme du § 8.11.2 pour trouver la plus belle grille de Ruzzle grâce à unalgorithme probabiliste. Par « plus belle », on entend celle qui contient le plus de mots français.

Vous utiliserez le dictionnaire du chapitre 8 qui est disponible sur le site web compagnon :http://ow.ly/35Jlt

Voici les fréquences des lettres de ce dictionnaire (on a analysé tous les mots de 2 à 16 lettressans tiret et sans apostrophe) :

E S A I R N T O L U C M D

14.89% 10.21% 9.71% 9.40% 8.67% 7.34% 6.82% 5.82% 4.01% 3.60% 3.40% 2.54% 2.36%

P G B F H Z V Q Y X J K W

2.35% 1.60% 1.40% 1.36% 1.16% 1.07% 0.96% 0.50% 0.34% 0.25% 0.18% 0.05% 0.01%

9.8. Le problème des n dames pour illustrer lesmétaheuristiques

Le problème des n dames est une généralisation de du problème des 8 dames, vu au § 9.2 : onconsidère un échiquier n x n au lieu d'un échiquier 8 x 8. Bien que ce ne soit pas à proprement parléun problème d'optimisation, il présente de nombreux avantages :

• il est visuel et facile à comprendre ; • on peut coder la position des dames très simplement : pour chaque colonne, on note sur

quelle ligne se trouve la dame, et on lui soustrait 1. Laposition ci-contre sera : [1, 3, 5, 7, 2, 0, 6, 4]

• on passe très facilement d'une configuration à uneconfiguration voisine (qui ne satisfait pas forcément lescontraintes du problème) : il suffit d'échanger deuxcolonnes. Une position voisine de celle ci-contre pourraitêtre [1, 0, 5, 7, 2, 3, 6, 4].

On peut le traiter comme un problème d'optimisation si l'onconsidère qu'il faut minimiser le nombre de conflits (on parlera deconflit quand deux dames se menacent mutuellement). Il s'agira icide placer n dames sur l'échiquier nxn, sans aucun conflit, enpartant d'une solution avec une seule dame par ligne et parcolonne (par exemple toutes les dames sur la diagonale) et enéchangeant deux colonnes. On ne cherchera pas toutes lessolutions possibles : une seule nous suffira. Notons que dans un problème d'optimisation classique, iln'y a en général qu'une seule meilleure solution. Ici il y en a plusieurs.

Il est à noter qu'il existe un algorithme permettant de trouver une solution quel que soit nsupérieur à 3 (voir exercice 9.14). L'intérêt du § 9.8 n'est donc pas de trouver une solution, maisd'illustrer sur ce problème classique comment se comportent trois des métaheuristiques les plusconnues : la recherche avec tabous, le recuit simulé et un algorithme génétique.


http://ow.ly/35Jlt


Rappelons que l'on passe d'une positionà une position voisine en échangeant deux colonnes.

Exercice 9.14Exercice 9.141. soit r = n mod 122. écrire les nombres pairs de 2 à n3. si r = 3 ou r = 9 mettre le 2 à la fin de la liste4. écrire ensuite les nombres impairs de 1 à n, mais si r=8 permuter les nombres

impairs 2 par 2 (i.e. 3, 1, 7, 5, 11, 9, ...)5. si r = 2, permuter les places de 1 et 3, puis mettre 5 à la fin de la liste6. si r = 3 ou r = 9, mettre 1 puis 3 en fin de liste

Programmez cet algorithme en Python. Il donne une solution au problème des n dames. Ainsi,pour n = 8 on obtient la position [2, 4, 6, 8, 3, 1, 7, 5] (dans cet algorithme, les lignes sont numérotéesà partir de 1). Pour n = 15, on aura la solution [4, 6, 8, 10, 12, 14, 2, 5, 7, 9, 11, 13, 15, 1, 3].

Vérifiez la validité de cet algorithme pour n = 4 ... 1000.

9.8.1. Première approche : descente de plus grande pente1. Générer une position de départ.2. Essayer toutes les permutations de deux colonnes et échanger les deux

colonnes qui permettent de diminuer le plus le nombre de conflits.3. Retourner à 2 jusqu'à obtenir 0 conflit (dans l'idéal) ou un blocage.

Résultats avec la descente de plus grande pente

Nombre de dames (n) 20 40 60 80 100Temps ou nombre de conflits restants 2 conflits 13 sec. 1 conflit 418 sec. 1308 sec.

Commentaires

• Selon la position initiale et le nombre de dames, il arrive que l'algorithme se bloque dans unminimum local. C'est arrivé ici avec 20 et 60 dames placées au départ sur la diagonale.

• Avec 100 dames, on passe d'une situation avec 4950 conflits à une configuration sansconflit en 82 échanges de colonnes.

• Les temps sont seulement indicatifs et dépendent évidemment de l'ordinateur utilisé. Toutesles expériences ont été faites sur le même ordinateur et dans les mêmes conditions.


Modifiez le programme de l'exercice 9.13 pour rechercher la meilleure grille de Ruzzle grâce àune descente de plus grande pente.

9.8.2. Deuxième approche : recherche avec tabousLa méthode taboue est une métaheuristique d'optimisation présentée par Fred Glover en 1986.

On trouve souvent l'appellation « recherche avec tabous » en français.La méthode taboue consiste, à partir d'une position donnée, à explorer le voisinage et à choisir la

position dans ce voisinage qui minimise la fonction objectif (comme dans la descente de plus grandepente). Il est essentiel de noter que cette opération peut conduire à dégrader la valeur de la fonction :c'est le cas lorsque tous les points du voisinage ont une valeur plus élevée. Le risque est qu'à l'étapesuivante, on retombe dans le minimum local auquel on vient d'échapper. C'est pourquoi il faut quel'heuristique ait de la mémoire : le mécanisme consiste à interdire (d'où le nom de « tabou ») derevenir sur les dernières positions explorées.

Méthode taboue

1. Générer une position de départ.2. Parmi les positions voisines, choisir la meilleure qui n'est pas dans la

liste des tabous.3. Si la liste des tabous est pleine, retirer de cette liste la position la plus

ancienne.4. Mettre la position actuelle en queue de la liste des tabous.5. Retourner à 2, tant qu'on n'a pas décidé de s'arrêter.


Algorithmique

Remarque sur le point 4

Ici, on cherche à minimiser le score, qui est le nombre de conflits.Si on cherche à maximiser le score,il faut calculerD = score(P1) - score(P2)

Les positions déjà explorées sont conservées dans une file (voir § 6.2), souvent appelée liste destabous, d'une taille donnée. Cette file doit conserver des positions complètes, mais cela ne pose pasde problèmes avec les n dames. Pour nos expériences, nous avons utilisé une liste de 10 mouvementstabous.

Résultats avec la méthode taboue

Nombre de dames (n) 20 40 60 80 100

Temps ou nombre de conflits restants 1 sec. 15 sec. 114 sec. 422 sec. 1756 sec.

Commentaires

• Le programme ne se bloque plus dans un minimum local.• La solution finale est toujours la même et dépend de la position initiale.• Avec 100 dames, on passe d'une situation avec 4950 conflits à une configuration sans

conflit en 95 échanges de deux colonnes.


Modifiez le programme de l'exercice 9.13 pour rechercher la meilleure grille de Ruzzle grâce àune recherche avec tabous.

9.8.3. Troisième approche : recuit simuléLe recuit simulé (Simulated Annealing en anglais) est une métaheuristique inspirée d'un

processus utilisé en métallurgie. Ce processus alterne des cycles de refroidissement lent et deréchauffage (recuit) qui tendent à minimiser l'énergie du matériau. Elle est aujourd'hui utilisée enoptimisation pour trouver les extrema d'une fonction.

Elle a été mise au point par trois chercheurs de la société IBM, S. Kirkpatrick, C.D. Gelatt etM.P. Vecchi en 1983, et indépendamment par V. Cerny en 1985.

Recuit simulé

1. Choisir une « température » de départ T.2. Générer une position aléatoire. Appelons-la P1.3. Copier la position P1 dans une position P2, puis échanger deux colonnes de P1

choisies aléatoirement.4. Calculer D = score(P2) - score(P1)5. Si D 0, P1 P2 ; le cas échéant, mettre à jour le meilleur score et la

meilleure position. Aller à 8.6. Générer un nombre réel aléatoire entre 0 et 1, que nous appellerons r.7. Si r < exp(-D/T), P1 P2. 8. Diminuer T.9. Retourner à 3, tant qu'on n'a pas décidé de s'arrêter.

Le réglage des paramètres est ici plus délicat. En particulier, comment faut-il faire baisser latempérature ? Trop vite, on risque de se bloquer dans un minimum local. Trop lentement, le temps decalcul augmentera, sans garantie de trouver une solution.

La solution retenue a été de faire baisser la température par palier de longueur 10, avec unetempérature initiale T = 100, avec Tk+1 = 0.6·Tk, k représentant un numéro de palier. C'est trèsinhabituel, car on prend généralement un coefficient proche de 1.

Résultats avec le recuit simulé

Nombre de dames (n) 20 40 60 80 100Temps moyen en cas de succès* 0.3 sec. 1.5 sec 4 sec. 9 sec. 23 sec.Nombre de succès sur 10 essais 7 10 10 10 10

*Il s'agit d'une moyenne sur 10 essais, puisque le hasard joue ici un rôle important. Les temps desessais où l'on n'a pas trouvé de solution n'ont pas été pris en compte.



Commentaires

• Étant donné l'usage du hasard, on ne sait pas quelle solution finale sera trouvée. Ce ne serapas toujours la même, contrairement à la recherche avec tabous.

• Curieusement, le recuit simulé marche le moins bien quand il y a peu de dames (7 succèsseulement avec 20 dames).

• Il est par contre redoutable en temps de calcul, puisqu'il ne lui faut que 23 secondes pourtrouver une solution avec 100 dames, alors que la méthode taboue en mettait 1756.


Modifiez le programme de l'exercice 9.13 pour rechercher la meilleure grille de Ruzzle grâce à unrecuit simulé.

9.8.4. Quatrième approche : algorithme génétiqueLes algorithmes génétiques appartiennent à la famille des algorithmes évolutionnistes (un sous-

ensemble des métaheuristiques). Leur but est d'obtenir une solution approchée, en un temps correct,à un problème d'optimisation, lorsqu'il n'existe pas ou qu'on ne connaît pas de méthode exacte pourle résoudre en un temps raisonnable. Les algorithmes génétiques utilisent la notion de sélectionnaturelle développée au XIXe siècle par le célèbre scientifique Darwin et l'appliquent à unepopulation de solutions potentielles au problème donné. On se rapproche par bonds successifs d'unesolution.

L'utilisation d'algorithmes génétiques, dans la résolution de problèmes, est à l'origine le fruit desrecherches de John Holland et de ses collègues et élèves de l'Université du Michigan qui ont, dès1960, travaillé sur ce sujet. Le premier aboutissement de ces recherches a été la publication en 1975de Adaptation in Natural and Artificial System.

Algorithme génétique

1. Générer une population de 2n positions aléatoires.2. Classer et numéroter ces 2n positions selon leur score, du meilleur au moins

bon.3. Croiser les grilles 2k-1 et 2k, pour k allant de 1 à n.4. Effectuer une mutation pour chaque position : avec une certaine probabilité,

effacer une case et placer un nouveau chiffre de 0 à 7.5. Classer et numéroter les 2n grilles obtenues selon leur score, du meilleur au

moins bon.6. Dupliquer la grille 1 (la meilleure) et placer ce doublon en position 2n,

après avoir éliminé la grille 2n (la moins bonne).7. Le cas échéant, mettre à jour le meilleur score et la meilleure position.8. Retourner à 3, tant qu'on n'a pas décidé de s'arrêter.

Schéma de l'algorithme génétique


Algorithmique

Quelques commentaires sur ce schéma

• Chaque position est représentée pas une liste de n nombres indiquant la ligne occupée pourla colonne correspondante. Avec 8 dames, la position ci-dessous est représentée par la liste [0, 5, 1, 4, 6, 3, 7, 2].

• Chaque position est évaluée grâce à la fonction de performance, ici ce sera le nombre deconflits. (b)

• Une phase de reproduction détermine quelles positions seront sélectionnées pour lareproduction. Certaines positions peuvent être reproduites plusieurs fois, d'autresdisparaîtront. (c)

• Pour chaque paire se combinant, on détermine aléatoirement le point de croisement. (c) • Les enfants sont créés en croisant chaque paire. (d) • Finalement, chaque position subit éventuellement une mutation aléatoire. (e)

Commentaire

• Cette approche n'a (pour l'instant) pas donné de résultats intéressants. Elle ne fonctionnequ'avec de petits damiers. Il semble difficile de choisir les différents paramètres.


Modifiez le programme de l'exercice 9.13 pour rechercher la meilleure grille de Ruzzle grâce à unalgorithme génétique.

Sources[1] Wikipédia, « Algorithmique », <http://fr.wikipedia.org/wiki/Algorithmique>

[2] Wikipédia, « Algorithmes de tri »,


http://fr.wikipedia.org/wiki/Algorithmique


<http://fr.wikipedia.org/wiki/Catégorie:Algorithme_de_tri>

[3] Wikipédia, « Marche de Jarvis », <http://fr.wikipedia.org/wiki/Marche_de_Jarvis>

[4] Wikipédia, « Parcours de Graham », <http://fr.wikipedia.org/wiki/Parcours_de_Graham>

[5] Wikipédia, « Test de primalité de Miller-Rabin », <http://fr.wikipedia.org/wiki/Test_de_primalité_de_Miller-Rabin>

[6] Wikipédia, « Méta-heuristique », <http://fr.wikipedia.org/wiki/Métaheuristique>

[7] Wikipédia, « Recuit simulé », <http://fr.wikipedia.org/wiki/Recuit_simulé>

[8] Wikipédia, « Algorithme génétique », <http://fr.wikipedia.org/wiki/Algorithme_génétique>


http://fr.wikipedia.org/wiki/Algorithme_g%C3%A9n%C3%A9tique

http://fr.wikipedia.org/wiki/Recuit_simul%C3%A9

http://fr.wikipedia.org/wiki/M%C3%A9taheuristique


http://fr.wikipedia.org/wiki/Parcours_de_Graham


http://fr.wikipedia.org/wiki/Cat%C3%A9gorie:Algorithme_de_tri

Chapitre 9 Algorithmique -...

Documents

Transcript of Chapitre 9 Algorithmique -...