Algorithmique-programmation Licence d'Informatique

L2 Informatique Structures de Données et Algorithmes

Université de Strasbourg

UFR de Mathématique et d'Informatique

L2 Informatique Semestres S3 et S4

_________

Structures de Données et Algorithmes 1 et 2__________

Fiches d’exercices

année 20092010

1Licence d’Informatique Université de Strasbourg


1. Algorithmique et programmation de base, notations

Constructions de base

Exercice 1 (définitions séquentielles). Spécifier l’établissement d’une petite facture pour un seul type d’articles. On veut afficher le prix unitaire, la quantité, le prix brut, la remise, la TVA, le prix net, en ayant comme données le prix unitaire, la quantité, le taux de remise. Le taux de TVA est fixé à 19,6%. Ensuite, écrire en C un programme pour lire les données, faire les calculs et afficher les résultats avec des libellés clairs. Notations :

définition simple : x = expr avec x1 = expr1, …, xn = exprn ou bien : x = soit x1 = expr1, …, xn = exprn dans expr

lecture en séquence sur organe standard : (x1, …, xn) = donnée écriture en séquence par effet de bord sur organe standard : écrire(y1, …, yn) résultat général (fonction main() de C) : principal = expr1, …, exprn

Exercice 2 (définitions conditionnelles). Spécifier la résolution complète de l’équation du second degré ax2 + bx + c = 0, où les coefficients a, b et c sont des données flottantes, avec a non nul. On distinguera selon la valeur du discriminant le cas réel, où l’on affiche les deux racines, et le cas complexe où l’on affiche la partie réelle et la partie imaginaire des racines. Ecrire en C un programme pour lire les données, faire les calculs et afficher les résultats avec des libellés clairs. Notations :

définition conditionnelle : x = si cond alors expr1 sinon expr2 fsi

Exercice 3 (définitions itératives simples, récurrence). Spécifier et programmer en C l’affichage de la factorielle de l’entier naturel n entré au clavier.Notations :

définition itérative simple : x = init x0 pour i de d à f pas p répéter expr[x, i] frépéter

Exercice 4 (définitions itératives simples). Spécifier et programmer en C l’établissement de la table de multiplication d’un entier naturel quelconque par les entiers de 1 à 10.

Exercice 5 (définitions itératives générales, récurrence). Spécifier et programmer en C l’affichage d’une approximation à 107 près de la racine carrée d’un nombre a entré au clavier. Indication : utiliser la suite u0 = 1, un=1/2(un1 + a/un1). Notations :

définition itérative générale : x = init x0 tantque cond[x] répéter expr[x] frépéter

Exercice 6 (définitions itératives générales, récurrence, nuplets). Spécifier et programmer en C l’affichage du plus petit entier tel que sa factorielle soit supérieure à un entier M entré au clavier.Notations :

définition itérative générale : x = init x0 tantque cond[x] répéter expr[x] frépéter nuplet : (x1, …, xn)



Fonctions et programmes

Exercice 7 (spécifications itératives et programmation). Spécifier itérativement et écrire en C des fonctions pour calculer de manière approchée exp(x), sin(x) et cos(x) pour x flottant quelconque, et ln(1 + x) pour |x| < 1.

Exercice 8 (récursivité et itération). Spécifier et écrire en C une fonction renvoyant xn, pour x flottant et n entier naturel fournis en arguments. En produire deux spécifications récursives, l’une diminuant n de 1 à chaque étape, l’autre le divisant par 2. Les transformer en spécifications itératives. Programmer en C les différentes versions.

Exercice 9 (récursivité double, suite double). Spécifier et écrire en C une fonction u(n) renvoyant le nième terme de la suite de Fibonacci définie par u0 = 0, u1 = 1, un = un1 + un2 pour n > 1. On en donnera deux versions, l’une récursive, l’autre itérative obtenue en introduisant une suite double. Définir et programmer l’affichage d’une table donnant, pour n de 1 à 20, le rapport un/n, où = (1 + √5) / 2 est le nombre d’Or.

Exercice 10 (résultats multiples, entréessorties, lecture à l’avance, suppression de la récursivité). Spécifier et écrire en C une fonction renvoyant la somme et le produit d’entiers relatifs entrés au clavier jusqu’à la frappe de l’entier 100, qui est exclu des calculs. En produire deux versions récursives, l’une non terminale et l’autre terminale, puis une version itérative. Définir et écrire en C une fonction qui calcule les résultats et les affiche au lieu de les renvoyer. Indication : utiliser une lecture à l’avance.

Exercice 11 (approximation numérique, passage de fonction en paramètre). Spécifier et écrire en C une fonction calculant dans l’intervalle [a, b] une approximation du zéro d’une fonction f dérivable strictement croissante telle que f(a)f(b) < 0. On s’appuiera sur une méthode classique : tangente (Newton), point fixe ou dichotomique. Exercice 12 (intégration, passage de fonction en paramètre). Spécifier et écrire en C une fonction calculant une approximation par la méthode des trapèzes de l'intégrale de Riemann dans l’intervalle [a, b] d'une fonction f continue.



2. Généralités sur la spécification et la programmation N.B. Contenu type d’un dossier de programmation : énoncé informel, spécification formelle, programme, jeu d’essai, résultats prévus, résultats obtenus, complexité, commentaires.

Spécification de types et d'opérations, programmation

Exercice 1 (spécification algébrique et implantation des booléens). Spécifier algébriquement les booléens de sorte Bool et leurs opérations classiques : vrai, faux, non, et, ou, ouex, egb (égalité). En représentant en C Bool par unsigned char, montrer comment y programmer ces opérations.

Exercice 2 (spécification algébrique et implantation des entiers). En supposant connus les booléens, spécifier algébriquement les entiers naturels de sorte Nat, et leurs opérations classiques +, *, (renvoyant 0 quand la fonction n’est habituellement pas définie), egn (égalité), <, <=, pair, impair, à partir des constructeurs 0 et S, rendant le successeur d’un entier. En représentant en C Nat par unsigned int, montrer comment se transposent les opérations cidessus.

Exercice 3 (spécification algébrique et implantation d’un stock, preuve de correction d’implantation). Spécifier algébriquement une petite gestion de stock d’au maximum 1000 produits, dont les références vont de 1 à 1000, avec une sorte Stock et les opérations suivantes : création et initialisation de tout le stock, entrée d’une nouvelle référence de produit avec sa quantité, suppression d’une référence, entrée ou sortie d’une quantité d’un produit, réajustement de la quantité d’un produit, interrogation du stock. On écrira soigneusement les préconditions. Faire une représentation en C de la sorte Stock par un type de pointeurs sur un entier relatif pour allouer dynamiquement un tableau, puis programmer les opérations avec mutations et les offrir dans un menu. Prouver la correction totale de l’implantation par rapport à la spécification.

Exercice 4 (spécification et programmation des tableaux, effets de bord). La sorte S et l’entier n > 0 étant considérés comme des paramètres globaux, spécifier algébriquement les tableaux contenant en permanence n objets de sorte S, indicés par les entiers de 0 à n1, avec les opérations gent(a) pour engendrer un tableau dont chaque case contient la même constante a, modt(t, i, a) pour remplacer par a le contenu de la case i du tableau t, élém(t, i) pour accéder à la valeur rangée à la case i de t, encore notée t[i], et éch(t, i, j) pour échanger les valeurs t[i] et t[j]. Proposer en C une implantation de tels tableaux et programmer les opérations avec mutations. Proposer ensuite une spécification et une représentation où n peut varier selon le tableau.

Exercice 5 (drapeau hollandais). Spécifier à l’aide des opérations de l’Exercice 4 une fonction résolvant avec un tableau de caractères ‘B’, ’W’ ou ‘R’ en paramètre le problème du drapeau hollandais. Il s'agit de transformer le tableau initial en un tableau trié dans l'ordre ‘B’, ’W’, ‘R’, en effectuant un seul parcours de gauche à droite, avec, à chaque étape, au maximum un échange de deux valeurs. Programmer cette opération comme une fonction C effectuant une mutation. Définir et programmer des opérations de lecture lect et d’affichage afft d’un tel tableau, ainsi qu’une opération main pour appeler et tester l’opération du drapeau hollandais.

Exercice 6 (récursivité et itération, paramètres passés par adresse). Définir formellement avec les opérations de l’Exercice 4 et écrire en C une fonction renvoyant le minimum et le maximum des valeurs d’un tableau d’entiers naturels. On veut une version séquentielle et une autre dichotomique. Les spécifier formellement et les programmer récursivement puis itérativement.



Exercice 7 (tri de tableau par sélection simple). Définir à l’aide des opérations de l’Exercice 4 et écrire en C une fonction triant en croissant « sur place » un tableau d’entiers naturels par sélection simple. Dans cette méthode, à chaque étape, lors d’un parcours de gauche à droite de la portion de tableau restant à trier, on sélectionne un plus petit élément que l’on place à la première place libre du tableau grâce à un échange. On pourra définir une fonction donnant la place du minimum sélectionné à chaque étape.

Exercice 8 (spécification algébrique et implantation des nombres complexes). Spécifier algébriquement et programmer en C les nombres complexes sur les flottants avec leurs opérations classiques. Implanter en coordonnées cartésiennes, puis en coordonnées polaires.

Exercice 9 (ensembles finis représentés par des entiers). a. L'entier naturel n étant un paramètre global (<= 32), spécifier une bibliothèque de base pour gérer les (sous)ensembles finis de sorte Ens d'entiers pris dans [1, n], avec les opérations classiques : ev, ensemble vide, i, insertion, d, effacement, dans, appartenance, uni, union, inter, intersection, diff, différence, incl, inclusion, ege : égalité. Spécifier aussi une opération d'affichage affe du contenu d'un ensemble.b. Implanter et programmer en C cette bibliothèque en représentant tout ensemble juste par un entier naturel sans signe sur 32 bits. Programmer les opérations cidessus sans mutation, en utilisant des opérations arithmétiques (division par 2, modulo 2…) avec récursivité. Prévoir pour les tests des opérations auxiliaires.c. Avec la même représentation, reprendre la programmation des opérations en utilisant uniquement des décalages dans des chaînes de bits, des opérations logiques et des filtres binaires ad hoc.

Exercice 10 (gestion des multiensembles finis). Spécifier une bibliothèque de base pour gérer les multiensembles finis de caractères ASCII avec les opérations classiques sur les multiensembles. Implanter et programmer en C cette bibliothèque avec une représentation contiguë des multiensembles. On suppose connues les opérations usuelles sur les caractères. Pour chaque opération, choisir et discuter une réalisation avec ou sans mutations.



3. Piles, files, listes

Exercice 1 (implantation des piles d'entiers). Reprendre la spécification algébrique des piles d'entiers, de hauteur bornée par le paramètre n, avec leurs opérations classiques. Les implanter en C de manière contiguë, puis de manière chaînée.

Exercice 2 (implantation de piles de booléens). Spécifier algébriquement les piles de booléens, de hauteur bornée par 31, avec leurs opérations classiques. Les implanter en C sous la forme d’un simple entier naturel et programmer de manière fonctionnelle pure les opérations dans cette représentation. Prouver que cette implantation est correcte totalement.

Exercice 3 (implantation des piles par blocs). Spécifier algébriquement et programmer en C les piles d’entiers naturels non bornées avec leurs opérations classiques. Implanter ces piles de manière contiguë, et programmer avec mutations, avec allocation et désallocation dynamiques de blocs de taille fixe quand c’est nécessaire.

Exercice 4 (gestion d’un couple de piles). Spécifier la gestion d’un couple de piles d’entiers dont la somme des hauteurs est globalement bornée par le paramètre global N. On aura intérêt à spécifier directement les couples sans réutiliser la spécification connue des piles. Programmer en C avec une implantation contiguë et avec mutations.

Exercice 5 (évaluation d’expressions arithmétiques avec deux piles). Spécifier, puis programmer en C une fonction pour évaluer, en calculs sur les entiers, une expression arithmétique. Celleci se présente sous la forme d’une suite d’entiers naturels sur un seul chiffre décimal, d’opérateurs binaires parmi +, , *, /, et de parenthèses ( et ). La suite est supposée correctement et complètement parenthésée. Tous les caractères sont entrés successivement au clavier. On définira cette évaluation de manière récursive sur les entrées, puis itérative, en utilisant une pile pour les opérateurs et une autre pour les opérandes, mais on ne programmera qu’une seule version. On suppose connues les opérations usuelles sur les caractères.

Exercice 6 (évaluation d’expressions arithmétiques avec une seule pile). Reprendre l’Exercice 5, avec une seule pile contenant opérandes et opérateurs, codés de manière convenable.

Exercice 7 (gestion de files PAPS). Spécifier une bibliothèque de base pour gérer des files d’éléments de sorte S en paramètre avec une politique premier arrivépremier servi. On traitera le cas des files de taille bornée et celui des files de taille non bornée. Programmer en C avec mutations dans une implantation contiguë pour les files bornées, et chaînée avec simple pointeur sur la queue pour les files non bornées.

Exercice 8 (files PAPS circulaires, Flavius Josèphe). Spécifier une « boîte à outils » sur les files PAPS d’entiers naturels exactement adaptée à la résolution du problème de la légende de Flavius Josèphe, en mettant en évidence des décalages circulaires à gauche d’une position, puis de p positions. Représenter ces files de manière simplement chaînée et circulaire, puis de manière contiguë. Programmer successivement dans ces deux représentations en C avec mutations.

Exercice 9 (spécification de la suppression d’éléments d’une liste). A partir de la spécification de base des listes d’entiers naturels, spécifier sans précondition les opérations de suppression de tous



les éléments d’une liste vérifiant une propriété exprimée par une fonction à résultat booléen passée en paramètre. Idem pour la suppression et le remplacement par un entier donné en paramètre. Implanter les listes de manière chaînée et programmer les opérations cidessus avec modifications de manière récursive puis itérative.

Exercice 10 (implantation des listes par chaînage). Implanter les listes d'entiers naturels de manière simplement chaînée avec des cellules à deux champs (valeur et pointeur sur le successeur), et programmer avec mutations en C, successivement avec deux variantes, selon qu’on implante la liste vide par un simple pointeur de valeur NULL ou bien par un pointeur sur une cellule contenant un entier quelconque (par exemple la longueur de la liste) et un pointeur de valeur NULL.

Exercice 11 (gestion de listes triées). Spécifier une bibliothèque pour les listes d’entiers naturels triées de manière croissante, avec entre autres des opérations de lecture et d’écriture de listes, une opération d’interclassement de deux listes triées, puis de n listes triées, considérées comme un tableau (Fiche 2, Exercice 4) de n listes. Implanter le tout de manière simplement chaînée et programmer en C de manière récursive.

Exercice 12 (spécification algébrique et implantation des chaînes). En supposant connues les opérations sur les caractères, spécifier algébriquement les chaînes de caractères de longueur maximale N > 0 (paramètre global) avec les opérations : chaîne vide, adjonction en tête, tête, longueur, corps, kième caractère, modification du kième caractère, adjonction en queue, queue, corps inverse, souschaîne, concaténation, égalité, comparaison en ordre lexicographique, lecture, écriture, copie. En implantant les chaînes comme des tableaux, écrire en C les fonctions correspondantes avec et sans mutation, ainsi qu’une opération de désallocation de chaîne. Reprendre cette programmation avec une implantation des chaînes de manière chaînée, chaque chaînon contenant un seul caractère.

Exercice 13 (fonctions sur les chaînes). Utiliser les opérations de l’Exercice 12 pour spécifier et écrire en C une fonction donnant le miroir d’une chaîne, selon deux versions récursives, dont une récursive terminale que l’on transformera en une version itérative. Définir et programmer une fonction testant si une chaîne est un palindrome, une fonction engendrant toutes les permutations d’une chaîne et une fonction testant si une chaîne est un anagramme d’une autre chaîne.

Exercice 14 (gestion des ensembles finis). Soit en paramètres une sorte S quelconque munie d’une égalité et d’un ordre total <=. Spécifier une bibliothèque de base pour gérer les ensembles finis d’objets de sorte S contenant les opérations classiques sur les ensembles. Programmer en C cette bibliothèque avec une représentation chaînée des ensembles où leurs éléments sont ordonnés. Pour chaque opération, choisir et discuter une réalisation avec ou sans mutations.



4. Notions de complexité

Exercice 1. Dire ce que définissent les fonctions suivantes sur Nat, puis calculer leur complexité, pour rec1 en nombre de multiplications par 2 et pour rec2 en nombre d’additions :

rec1(n) = si n == 0 alors 1 sinon 2*rec1(n-1) fsirec2(n) = si n == 0 alors 1 sinon rec2(n-1) + rec2(n-1) fsi

Exercice 2. Evaluer en nombre de comparaisons, puis en nombre d’échanges, la complexité du programme du drapeau hollandais (Fiche 2, Exercice 5), puis de celui du tri par sélection simple (Fiche 2, Exercice 7) en fonction du nombre n d’éléments à trier.

Exercice 3. Evaluer la complexité de la procédure proc en nombre d'appels de inst() :void proc(int n)

{

int i, j, k;

for (i = 1; i <= n 1; i++)

for (j = i + 1; j <= n; j++)

for (k = 1; k <= j; k++) inst();

}

Exercice 4 (calcul d’une puissance). Donner une forme logarithmique simple du nombre de bits de la représentation binaire minimale d’un entier naturel n. Evaluer en nombre de multiplications la complexité dans le pire des cas des 2 versions récursives du calcul de xn (Fiche 1, Exercice 8).

Exercice 5 (suite de Fibonacci). Etudier la complexité des deux versions du calcul du terme général un d’une suite de Fibonacci (Fiche 1, Exercice 9) en nombre d’additions. Pour la version naïve, on pourra minorer par un nombre connu.

Exercice 6. (minimum et maximum). Evaluer et comparer en nombre de comparaisons d’éléments de tableaux la complexité des deux versions de l’Exercice 6 de la Fiche 2.

Exercice 7 (dessins). On travaille dans un repère euclidien du plan. On suppose connues les primitives placer(x, y) et tracer(x, y), qui placent le crayon au point (x, y), la première sans tracer et la seconde en traçant le segment joignant le point courant au point (x, y).a. Soit la procédure récursive suivante, écrite en C :

void triangles1(float x, float y, float d, float h)

{

if (y + d < h)

{

tracer(x d, y + d);

triangles1(x d, y + d, d, h);

tracer(x + d, y + d);

triangles1(x + d, y + d, d, h);

tracer(x, y);

}



}

La séquence placer(x, y); triangles1(x, y, d, h), où d > 0 et h > 0, trace la figure suivante (ne pas tenir compte pour l'instant du contenu grisé de certains triangles) :

O

y

x

(x, y)d

d

a.1. On note T1(y) le nombre d'exécutions de la primitive tracer pour l'appel triangles1(x, y, d, h) avec d > 0. Evaluer T1(y) en fonction de T1(y + d).a.2. Soit k tel que y + k.d < h ≤ y + (k + 1).d. On pose ti = T1(y + i.d), pour i = 0, ..., k. Montrer que ti = 3.(2ki 1), pour i = 0, ..., k. a.3. En déduire la valeur de T1(y) en fonction de k. Comment expliquer ce mauvais résultat ?b. On cherche à améliorer l'efficacité de la procédure précédente.b.1. Ecrire en C une procédure bande(x, y, d, h) traçant à partir du point (x, y) les triangles gris dans la figure et ramenant le crayon en ce point.b.2. Ecrire ensuite une procédure récursive triangles2(x, y, d, h), qui, en utilisant la procédure bande, trace chaque triangle de la figure une et une seule fois,.b.3. On note B(y) et T2(y) les nombres d'exécutions de tracer pour les appels bande(x, y, d, h) et triangles2(x, y, d, h), avec d > 0. Soit k tel que y + k.d < h ≤ y + (k + 1).d. On pose bi = B(y + i.d) et ti = T2(y + i.d), pour i = 0, ..., k. Evaluer bi et ti, pour i = 0, ..., k. b.4. En déduire T2(y) en fonction de k. Comparer avec T1(y). En dénombrant les segments élémentaires, montrer que la complexité T2(y) est optimale en nombre de tracés de segments.

Exercice 8. Soient f et g deux fonctions des entiers naturels dans les réels strictement positifs.a. Montrer que la relation binaire f ∈ O(g) est réflexive et transitive. Montrer que la relation binaire f ∈ Θ (g) est une relation d'équivalence. b. Montrer que f ∈ O(g) implique a.f ∈ O(g) et que f ∈ Θ (g) implique a.f ∈ Θ (g), où a est un réel strictement positif quelconque.

Exercice 9. Soient f1, f2, g1 et g2 des fonctions des entiers naturels dans les réels positifs.a. Montrer que f1 + f2 ∈ O(max(g1, g2)) et f1 * f2 ∈ O(g1 * g2) si f1 ∈ O(g1) et f2 ∈ Ο (g2).b. Montrer que f1 f2 ∈ O(f1) si f1 f2 ≥ 0.c. Montrer que f1 + f2 ∈ Θ (max(g1, g2)) et f1 * f2 ∈ Θ (g1 * g2) si f1 ∈ Θ (g1) et f2 ∈ Θ (g2).

Exercice 10. Soient f et g deux fonctions des entiers dans les réels strictement positifs.a. Montrer que limn→∞ f(n)/g(n) = a ≠ 0 implique f ∈ Θ (g).b. Montrer que limn→∞ f(n)/g(n) = 0 implique f ∈ O(g) et f n'est pas en Θ (g).c. Montrer que limn→∞ f(n)/g(n) = ∞ implique g ∈ O(f) et f n'est pas en Θ (g).



5. Arbres : spécification et programmation

Exercice 1 (arbres binaires : implantation chaînée). Reprendre la spécification des arbres binaires étiquetés avec toutes les opérations de base, et les implanter par chaînage en C, comme dans le cours, avec comme étiquettes des entiers naturels. Définir et programmer également l'affichage d'un arbre sous forme de terme.

Exercice 2 (arbres binomiaux). Les arbres binomiaux sont des arbres généraux étiquetés ordonnés définis inductivement comme suit (noter qu'il n'y a pas d'arbre vide) :• un arbre réduit à un seul nœud est binomial de hauteur nulle ;• un arbre binomial A de hauteur p > 0 est construit, à partir de deux sousarbres binomiaux A1 et

A2 de hauteur p 1, à l'aide d'un lien tel que A1 est le premier fils de A, et A2 un arbre dont l'étiquette à la racine est celle de A et dont les fils sont les fils de A sauf le premier.

Par convention, la profondeur d'un nœud dans un tel arbre est égale au nombre de liens entre la racine et ce nœud, et la hauteur d'un arbre binomial est la profondeur maximale de ses nœuds.a. Dessiner des arbres binomiaux non étiquetés, de la hauteur 0 à la hauteur 4. b. Spécifier algébriquement la sorte Arbinom des arbres binomiaux étiquetés par la sorte S, avec les opérations f, créant un arbre réduit à une feuille, l, liant deux arbres binomiaux selon le principe cidessus, r, donnant l'étiquette à la racine d'un arbre, ef testant si un arbre est une feuille, pf et af, donnant respectivement le premier fils et l'arbre des autres fils d'un arbre binomial, h donnant la hauteur d'un arbre.c. Spécifier, par rapport à f et l, les opérations nn, nf, ni et nh donnant le nombre de nœuds, de feuilles, de nœuds internes, et de nœuds à une profondeur donnée d'un arbre binomial.d. Démontrer par induction que, lorsque A est de hauteur p, son nombre de nœuds est 2p, et son nombre de nœuds à la profondeur k, 0 ≤ k ≤ p, est un coefficient du binôme de Newton. Définir simplement nn et nh en fonction de h.e. A l'aide d'un schéma, expliquer comment transformer un arbre binomial en arbre binaire étiqueté. Proposer alors une définition des arbres binomiaux de la question (b) utilisant la spécification des arbres binaires étiquetés, en exprimant les générateurs d'arbres binomiaux en fonction des générateurs d'arbres binaires. f. Implanter les arbres binomiaux étiquetés par Nat en C, et programmer les opérations cidessus, en reprenant l'implantation des arbres binaires étiquetés.

Exercice 3 (arbres quadratiques). On suppose connue une spécification algébrique des booléens de sorte Bool, notés 1 ou 0, avec leurs opérations habituelles.a. Spécifier algébriquement les arbres quadratiques non bornés de sorte Arbq, étiquetés à chaque feuille par un booléen et non étiquetés aux autres noeuds, avec les fonctions f, renvoyant un arbre réduit à une feuille, e, enracinant 4 arbres quadratiques, ne, no, so, se, renvoyant respectivement les 4 sousarbres, h, la hauteur d'un arbre, c, l’étiquette (1 ou 0) d'une feuille, et estf, testant la réduction d'un arbre à une feuille.b. Pour n = 2k fixé, une image carrée noir et blanc de n × n pixels peut être représentée par un arbre quadratique étiqueté aux feuilles par 1, pour noir, ou 0, pour blanc. Un tel arbre représentant une image est défini récursivement de la manière suivante :• si k = 0 ou si l'image est complètement noire (resp. blanche), l'arbre est réduit à une feuille noire

(resp. blanche) ;



• sinon, l'image est partagée en 4 images carrées de 2k1 × 2k1 pixels chacune et l'arbre possède 4

fils, appelés respectivement ne, no, so et se, pour rappeler les 4 directions à partir du centre. Donner un exemple d’image et d’arbre correspondant avec n = 4. Pour n donné en paramètre général, on dira qu'un arbre quadratique est normal s’il correspond bien à cette définition, c’estàdire s’il est de hauteur bornée (borne à déterminer) et si aucun de ses sousarbres ne possède 4 fils réduits à des feuilles de même couleur.

Spécifier algébriquement une fonction estn testant si un arbre quadratique de hauteur bornée est normal, et une opération normal de conversion d’un tel arbre en arbre normal. c. En combinant si nécessaire les pixels par les opérations booléennes, spécifier sur les arbres quadratiques normaux des fonctions égalité, union, intersection, inclusion des parties noires, correspondant à des opérations sur les images.d. Dans une image n × n, on suppose qu'un pixel est repéré par des coordonnées entières (x, y) où 0 ≤ x, y ≤ n 1, avec comme origine (0, 0), le pixel en bas à gauche (au sudouest). Définir récursivement une opération noir permettant de savoir à partir de l'arbre quadratique normal d'une image si un pixel de coordonnées données est noir. Définir ensuite une opération colorer permettant de noircir ou blanchir un pixel de coordonnées données.e. Proposer une implantation chaînée pour les arbres quadratiques, et la décrire en C. Programmer en C avec mutation les opérations de la question (a) ainsi que normal, union et colorer.

Exercice 4 (gestion de faune). Une faune est un arbre binaire dont les feuilles contiennent des noms d'animaux et leurs caractères, tandis que les nœuds internes contiennent des questions, à réponse par oui ou par non, permettant de scinder en deux parties l'ensemble des animaux. Ainsi, pour chaque question, le sousarbre gauche correspond à la réponse positive et le sousarbre droit à la réponse négative. a. Spécifier algébriquement des faunes vues comme des arbres binaires, avec des fonctions élémentaires de construction, destruction et interrogation. b. Concevoir des opérations de plus haut niveau, pour la gestion et l'interrogation interactives. L'opération essentielle est la rechercheinsertion d'un animal x : si la suite des réponses fournies par un utilisateur aux questions de la machine à propos de x conduit à un animal y qui, manifestement, n'est pas x, il faut introduire x dans la faune à une feuille, avec un caractère discriminant entre x et y, et la question correspondante. c. Concevoir une opération interactive pour détruire une sousarborescence à un nœud à déterminer, et la remplacer par une autre qui serait déjà construite.d. Concevoir une hiérarchie de menus pour appeler interactivement les différentes fonctions offertes à un utilisateur, ainsi que le programme de guidage correspondant. e. Programmer en C les différentes fonctions et le programme de guidage.



6. Arbres : algorithmes, programmes et variantes

Exercice 1 (dérécursivation des parcours d'arbres).a. Donner une version itérative du parcours infixe d'arbres binaires, en utilisant une pile d'arbres (cf. cours). b. Idem avec le parcours préfixe. Indication : à la descente dans l’arbre, empiler des fils droits.c. Idem pour le parcours postfixe. Indication : à la descente dans l’arbre, empiler tous les sousarbres avec la direction gauche/droite (un booléen).

Exercice 2 (suppression de la récursivité double des tours de Hanoï). Spécifier puis programmer en C une version itérative de la résolution du problème des tours de Hanoï. Indication : à la descente dans l’arbre des appels, empiler toutes les directions gauche/droite comme des booléens, et utiliser un simple entier en guise de pile de booléens (voir Fiche 3, Exercice 2).

Exercice 3 (opérations dans les arbres binaires triés). Reprendre la spécification et la programmation en C avec chaînage des arbres binaires triés, les étiquettes étant des entiers naturels (Fiche 5, Exercice 1). a. Spécifier et programmer récursivement puis itérativement les opérations eg(a) et ed(a) qui renvoient les extrémités gauche et droite de l’arbre ab. Spécifier l'opération insf(a, x), qui insère x à une feuille de l'arbre a. Pour cela, spécifier récursivement et utiliser une opération auxiliaire insf1(a, x) traitant le cas où a est non vide. Programmer alors une version itérative de insf(a, x) avec mutation de a. c. Faire de même avec ôtermin(a), qui supprime l’étiquette minimale de l'arbre a. d. Idem avec sup(a, x), qui supprime l’étiquette x de l'arbre a. e. Spécifier algébriquement l'opération rechinsf(a, x) qui recherche dans l'arbre a un nœud contenant l'étiquette x et qui insère x à une nouvelle feuille si la recherche est négative (2 résultats). Programmer cette opération itérativement avec mutation.

Exercice 4 (opérations dans les AVL). Reprendre la spécification des AVL.a. Pour préparer la programmation dérécursivée avec mutation de l'opération insavl(a, x) d'insertion dans un AVL, redéfinir cette opération à l'aide d'une opération auxiliaire insavl1(a, x), qui renvoie l'arbre insf(a, x), ainsi que l'arbre b, dernier sousarbre de l’arbre initial rencontré dans le parcours avec un déséquilibre non nul. Définir aussi une opération rééq(a, x, b) pour mettre à jour les indicateurs de déséquilibre de a, à l'aide d'une opération auxiliaire rééq(b, x) qui le fait exclusivement sous b. Programmer en C avec mutation toutes ces opérations pour une représentation chaînée des arbres et des étiquettes entières. b. Spécifier algébriquement une opération de concaténation d'un AVL a2 à droite d'un AVL a1, en supposant que toutes les étiquettes de a2 sont plus grandes que celles de a1, et que la hauteur de a1 est supérieure ou égale à la hauteur de a2 (le cas inverse étant similaire). Pour cela, l'AVL a'2 est obtenu en supprimant tout d'abord la racine x2 de a2. Ensuite, une descente dans la branche droite de a1 conduit à un sousarbre a'1 tel que h(a'1) - h(a'2) = 0 ou 1. Enfin, a'1 est remplacé par l'arbre obtenu en enracinant a'1 et a'2 sur x2, en veillant à rééquilibrer le tout. c. En utilisant l'opération de concaténation, spécifier l'opération inverse de coupure par une étiquette donnée d'un AVL en deux AVL. Leur concaténation doit redonner l'AVL initial.



Exercice 5 (arbres binaires parfaits et tas). On suppose prédéfinis les modules de spécification BASE , pour les sortes, opérations et propriétés des objets de base, et ORDT étendant BASE et définissant une sorte S munie d'une égalité == et d'un ordre total ≤. Rappelons que, dans un arbre binaire parfait de taille n, les nœuds sont repérés par des adresses de 0 à n-1 affectées dans l'ordre d'un parcours en largeur de gauche à droite à partir de la racine. a. Ecrire un module de spécification ABP étendant ORDT et définissant la sorte Abp des arbres binaires parfaits étiquetés par S munis des opérations Λ : arbre vide, i : insertion dans un arbre a à l'adresse n(a) d'un nouveau nœud étiqueté, s : suppression du nœud étiqueté à l'adresse n(a) - 1, r : remplacement d'une étiquette à une adresse donnée, éch : échange de deux étiquettes d'adresses données, n et nf : nombres de nœuds et de feuilles d'un arbre binaire parfait, v : étiquette à une adresse donnée. Indication : prendre comme constructeurs de base Λ et i, spécifier directement par rapport à eux s, r, n, nf et v, et définir éch à partir de r et v. b. Un arbre binaire parfait étiqueté par S est dit partiellement ordonné par ≤ si chacun de ses nœuds internes possède une étiquette inférieure ou égale à celles de ses fils. Dessiner un tel arbre avec 10 nœuds étiquetés par des caractères munis de leur ordre habituel. Spécifier algébriquement un module ABPPO0 étendant ABP et définissant l’opération booléenne po : test pour savoir si un arbre binaire étiqueté par S est partiellement ordonné par ≤, et l’opération ipo : insertion d'un nouveau nœud étiqueté dans un arbre partiellement ordonné a à partir de l'adresse n(a), de telle manière que l'arbre reste partiellement ordonné. La définition de ipo met en jeu des échanges d'étiquettes filspère en remontant dans un arbre binaire parfait par une opération auxiliaire mont à spécifier également.c. Ecrire un module de spécification générique ABPPO1 étendant ABPPO0 et définissant l’opération spo : suppression de l'étiquette à une adresse donnée dans un arbre binaire parfait partiellement ordonné, de telle manière qu'il le reste. Pour cela, il faut d’abord combler le trou ainsi créé en y plaçant l'étiquette à l'adresse n(a)-1, puis replacer cette étiquette au bon endroit par des échanges appropriés, soit en montant dans l'arbre par mont, soit en y descendant par une autre opération auxiliaire appelée desc. Spécifier desc à l'aide d'une opération imin donnant l'adresse du fils de plus petite étiquette d'un nœud non feuille d'adresse donnée.d. Proposer une implantation contiguë pour les arbres binaires étiquetés en mémorisant aussi leur taille supposée bornée par N (Une telle représentation s'appelle un tas). Définir en langage C les types nécessaires à cette implantation. Programmer en C, sous forme fonctionnelle mais avec mutation quand cela s'y prête, toutes les opérations des questions précédentes.e. Démontrer par récurrence sur n, en supposant connues toutes les propriétés nécessaires sur les entiers, que le nombre de feuilles d'un arbre binaire parfait de Abp de taille n est égal à n/2 . Donner la hauteur d'un arbre binaire parfait non vide de n noeuds. Pour l’implantation précédente, évaluer en fonction de n dans le meilleur et le pire des cas la complexité de l’opération po en nombre de comparaisons ≤ et celles de ipo et spo en nombres d'échanges éch.



7. Graphes : spécification et implantation

Notion de graphe

Exercice 1 (les ponts de Königsberg). Au XVIIIème siècle, la ville de Königsberg (aujourd'hui Kaliningrad) était composée de 4 quartiers, désignés ici par A, B, C et D, communiquant par sept ponts sur la rivière Pregel : 2 ponts reliant A et B, 2 ponts B et C, 1 pont A et D, 1 pont B et D et 1 pont C et D. On a demandé au mathématicien suisse Leonard Euler (1707-1783) s’il était possible de faire une promenade qui fasse traverser chacun des sept ponts exactement une fois, en revenant ou non au point de départ. Qu’a-t-il pu répondre ?

Exercice 2 (mondanités). Lors d'une soirée réunissant 7 couples homme-femme légitimes, Madame X demande à chaque participant de noter sur un papier anonyme combien de mains il a serré. Elle constate que chacun lui a donné une réponse différente. Bien sûr, personne ne s’est lui-même serré la main ou n’a serré la main de son conjoint. Elle en déduit le nombre de mains serrées par son mari. Comment a-t-elle fait ?a. On modélise la situation par un graphe non orienté dont les sommets correspondent aux participants, et dont les arêtes sont définies par la relation binaire symétrique Γ : x Γ y ⇔ x a serré la main de y. Combien de sommets y atil dans le graphe ? Quelles sont les degrés possibles de ses sommets ? Chaque personne ayant donné une réponse différente, que peuton dire de ces degrés ? Que peuton dire de celui du sommet représentant Madame X ?b. Combien de mains ont serré les conjoints des personnes qui ont serré 12 mains, 11 mains, ..., 6 mains. Combien de mains a serré Monsieur X ?

Exercice 3 (jeu des allumettes). Le jeu des allumettes oppose 2 joueurs devant lesquels est disposé un tas de n allumettes, avec n > 0. Chacun tire à son tour 1, 2 ou 3 allumettes, et celui qui prend la dernière a gagné. On s'intéresse à la spécification algébrique d'un algorithme permettant à une personne de se mesurer, au jeu des allumettes, à un ordinateur jouant avec la stratégie optimale. On suppose que le premier joueur, personne ou ordinateur, est tiré au sort.

Il est commode de représenter un tel jeu par un graphe, la stratégie adoptée reposant sur la notion de noyau. Etant donné un graphe G = (E, Γ ), un noyau de G est un sousensemble K de E possédant les deux propriétés :

(i) x ∈ K ⇒ Γ (x) ∩ K = ∅(ii) x ∉ K ⇒ Γ (x) ∩ K ≠ ∅

a. Pour ce jeu, un graphe g = ([n], Γ ) orienté est défini par l'ensemble [n] = {0, ..., n} et la relation binaire Γ : x Γ y ⇔ 0 < x y < 4.Montrer que le sousensemble K de [n] des multiples de 4 est un noyau du graphe, c'estàdire vérifie les propriétés (i) et (ii). b. Quelle est la stratégie optimale pour un jeu représenté par le graphe g ? c. On suppose que l'ordinateur est codé par le booléen faux, le joueur humain par le booléen vrai. Spécifier algébriquement l’opération jeu(n, j) donnant le joueur gagnant, ordinateur ou personne, n étant respectivement le nombre d'allumettes restantes et j le joueur pour le tour suivant. d. Spécifier, programmer et tester un programme conversationnel de simulation d’une partie.



Implantation des graphes orientés et des opérations de base

Exercice 4 (relations binaires dans [0, n-1], graphes et tableaux). a. L'entier n étant un paramètre global, spécifier les relations binaires de sorte Rel dans [0, n-1]. Les opérations de base sont rv, relation vide, ma(r, i, j, b), insérant ou supprimant l'arc (i, j) dans la relation r selon que le booléen b est vrai ou faux, et ea(r, i, j), testant si l'arc (i, j) est dans r.b. Implanter Rel comme un type de tableaux à 1 dimension (avec allocation dynamique) et programmer les opérations comme des fonctions, avec mutations quand la question se pose. Spécifier et programmer une opération d'affichage d'une relation.c. Spécifier puis programmer la relation binaire pleine, la relation identité, la symétrie d'une relation, l'union, l'intersection et la composition de 2 relations. d. Spécifier puis programmer les opérations de fermeture réflexive, symétrique et transitive. e. Reprendre la spécification des graphes orientés finis G = (E, Γ ), où E est toujours [0, n-1]. Comme on ne s'intéresse ni à l'adjonction ni à la suppression de sommets, on voit un graphe G uniquement comme la relation Γ . Spécifier et programmer en C l'opération de transformation d'une relation en un graphe et son inverse. Programmer en C de manière fonctionnelle toutes les opérations sur ces graphes, en reprenant celles sur les relations vues précédemment.

Exercice 5 (implantation des graphes de sommets dans [0, n-1] par matrice d'adjacence). a. L’entier n > 0 étant un paramètre, spécifier algébriquement les ensembles d’entiers de sorte Ens compris entre 0 et n-1, avec les opérations : ev, ensemble vide, i, insertion, d, effacement, uni, union, inter, intersection, et diff, différence. En donner une implantation contiguë en C et programmer les opérations comme des fonctions avec mutations. b. Reprendre la spécification des graphes orientés finis G = (E, Γ ), où E est un ensemble d’entiers entre 0 et n-1 et Γ une relation binaire sur E. On implante un graphe G en représentant E comme en a et Γ comme dans l'Exercice 4. Programmer en C de manière fonctionnelle avec mutations toutes les opérations de base sur ces graphes.c. Spécifier et programmer les opérations renvoyant les ensembles de sommets, de successeurs et de prédécesseurs d'un sommet. d. Spécifier et programmer la lecture et l’écriture d'un graphe.

Exercice 6 (graphes orientés valués sur les arcs et listes d'adjacence triées). a. Reprendre la spécification et l'implantation des listes triées (Fiche 3, Exercice 11) avec leurs opérations de base, pour une sorte S d'objets munie d'un ordre total.b. Spécifier les graphes orientés finis G = (E, Γ ) et leurs opérations de base, avec E un ensemble d'entiers naturels et Γ un ensemble d’arcs munis d’une valuation : un identifiant entier naturel. c. Cette fois, tout graphe G est représenté comme une table de sommets avec leurs listes d’adjacence de successeurs. La table est représentée avec accès associatif, comme une liste chaînée de cellules à trois champs : un pointeur sur le successeur dans la liste, le sommet entier et un pointeur sur la première cellule de la liste d’adjacence des successeurs. Chaque liste d’adjacence d’un sommet est chaînée, avec, pour tout arc d’origine le sommet, une cellule comme précédemment : un pointeur sur le suivant dans la liste, l’identifiant entier de l’arc, et un pointeur sur la cellule de la table contenant le sommet extrémité de l’arc. Toutes les listes intervenant ici sont triées en croissant sur les entiers contenus dans leurs cellules et du même type. On adaptera donc les listes de a. à ce cas pour programmer les opérations de b.d. Spécifier et programmer la lecture et l’écriture d'un graphe représenté comme ci-dessus.



8. Graphes : algorithmes classiques

Exercice 1 (parcours de graphe pour une implantation par matrice d’adjacence). a. Spécifier récursivement une fonction renvoyant une liste des sommets accessibles depuis un sommet x dans un graphe orienté sur Nat implanté par une matrice d’adjacence, comme à l’Exercice 4, Fiche 7. On utilisera pour ce faire une pile de sommets et l'on implantera la liste résultat l comme un tableau de "marques" : l[k] == 0 si k n'a pas été rencontré, sinon son numéro d'entrée. Programmer ce parcours dans la représentation de l’Exercice 4 Fiche 7 après avoir réalisé la fonction prem. b. Spécifier récursivement une procédure affichant tous les chemins sans circuit, d’origine et d’extrémité données, dans un graphe fini orienté lors d’un parcours en profondeur utilisant une pile de sommets. Programmer cette opération dans la représentation précédente.c. Reprendre a. avec un parcours en largeur utilisant une file.d. Reprendre b. avec un parcours en largeur utilisant une file.

Exercice 2 (parcours de graphe pour une implantation par listes d’adjacence). a. Spécifier récursivement une fonction renvoyant une liste des sommets accessibles depuis un sommet donné dans un graphe orienté sur Nat implanté par listes d’adjacences triées, comme à l’Exercice 6, Fiche 7. Les ensembles de sommets seront remplacés partout par des listes triées. Programmer ce parcours dans la représentation de l’Exercice 6. b. Spécifier récursivement une procédure affichant tous les chemins sans circuit d’origine et d’extrémité données dans un graphe fini orienté lors d’un parcours en profondeur. Programmer cette opération dans la représentation par listes d’adjacences triées.c. Reprendre a. avec un parcours en largeur utilisant une file.d. Reprendre b. avec un parcours en largeur utilisant une file.

Exercice 3 (loup, chèvre et chou). Un loup, une chèvre et un chou se trouvent sur la même rive d'une rivière. Un passeur doit les faire traverser tous, mais, sa barque étant trop petite, il ne peut en transporter qu'un seul à la fois. On cherche à trouver toutes les stratégies utilisables par le passeur pour éviter que, hors de sa présence, le loup mange la chèvre ou la chèvre mange le chou.a. Modéliser le problème par un graphe g orienté dont les sommets correspondent aux différents états possibles (par exemple, à l'état initial, tous les acteurs se trouvent ensemble sur une même rive) et les arcs aux transitions possibles entre deux sommets. b. Montrer comment la découverte de toutes les stratégies du passeur se ramène à l'application d'une opération connue sur les graphes. Spécifier et, pour une représentation adéquate du graphe, programmer les opérations nécessaires à cette résolution. Indication : pour noter le chemin en cours, on pourra utiliser une pile d'états, et, à chaque étape, on examinera tous les successeurs de l'état au sommet. A la fin, le chemin pourra être affiché de la base au sommet.

Exercice 4 (cannibales et missionnaires). Trois cannibales et trois missionnaires se trouvant sur une île au milieu d'une lagune veulent aller à terre en utilisant un bateau à deux places. Sachant que l'on ne peut jamais laisser sans risque plus de cannibales que de missionnaires sur l'île ou à terre, on veut trouver les stratégies possibles pour les amener tous à terre sains et saufs.



a. Modéliser le problème par un graphe g orienté dont les sommets correspondent aux différents états possibles sur l'île et à terre (par exemple, à l'état initial les trois cannibales et les trois missionnaires sont sur l'île) et les arcs aux transitions possibles entre deux sommets. b. Montrer comment la résolution du problème se ramène à l'application d'une opération connue sur les graphes. Spécifier et, pour une représentation adéquate du graphe, programmer les opérations nécessaires à cette résolution. Indication : idem Exercice 3. c. En fonction de n et k, montrer comment procéder pour n cannibales, n missionnaires (n ≥ 1) et un bateau à k places (k ≥ 2).

Exercice 5 (problème des cruches). On dispose de deux cruches non graduées de contenances respectives 4 litres et 3 litres. On peut les remplir, les vider complètement, ou encore transvaser le contenu d'une cruche dans l'autre, jusqu'à ce que la première soit vide ou que la deuxième soit pleine. Il s’agit de savoir comment obtenir exactement 2 litres dans la cruche de 4 litres. a. Formaliser le problème à l'aide d'un graphe et de règles de transition. Montrer que le problème se résout par application d'une opération connue sur les graphes. b. Adapter, spécifier et, pour une représentation adéquate du graphe, programmer les opérations nécessaires à cette résolution. Indication : idem Exercice 3.

Exercice 6 (tri topologique par parcours et suppression de racines). Un tri topologique sur un graphe g de n sommets, orienté et sans circuit, construit une liste de tous les sommets de g, un sommet n'apparaissant dans la liste qu’après tous ses prédécesseurs dans le graphe. Ce résultat peut être obtenu simplement en n étapes : à chaque étape, une racine du graphe est placée en queue de la liste résultat, puis supprimée du graphe avec tous ses arcs incidents. On suppose connues les opérations habituelles sur les ensembles.a. Spécifier algébriquement par rapport aux générateurs de graphes l’opération erac(g) donnant l'ensemble des racines du graphe g. b. Spécifier par rapport aux générateurs de graphes l'opération supsa(g, x), où x est une racine de g, renvoyant g privé de x et des arcs d’origine x. Spécifier l’opération erac1(g, er, x), où er est l’ensemble des racines de g et x l’une d’elles, et renvoyant l’ensemble des racines du graphe supsa(g, x) après un examen du seul ensemble des successeurs de x dans g.d. Spécifier itérativement la fonction de tri topologique en utilisant les opérations précédentes. e. Transformer les opérations cidessus pour une implantation à préciser, puis programmer en Cdans cette implantation.

Exercice 7 (algorithme de Dijkstra des plus courts chemins). L'algorithme de Dijkstra recherche dans un graphe fini simple orienté sans boucle un arbre de plus courts chemins d'un sommet donné x1 à tous les sommets du graphe qui lui sont accessibles. Au cours du traitement, il gère en fait une forêt générale f sur tous les sommets du graphe, avec deux fonctions : père(f, z) renvoie le père du nœud z dans f (voir ce qu’il advient des racines) et dm(f, z) renvoie la distance minimale courante dans f de x1 au nœud z (voir ce qu’il advient des noeuds non encore déterminés comme accessibles depuis x1).a. M étant une constante entière fixée, spécifier algébriquement les graphes, de la sorte Graphe, sur les entiers de 0 à n1, simples orientés sans boucle et valués sur les arcs par une distance entière < M, avec les opérations convenables pour l’algorithme de Dijkstra. b. Spécifier algébriquement les forêts générales, de la sorte Forêt, ayant comme nœuds tous les entiers de 0 à n 1, avec les opérations adéquates pour l’algorithme de Dijkstra.



c. Spécifier algébriquement pour l’algorithme de Dijkstra les (sous)ensembles, de la sorte Ensemble, des entiers de 0 à n 1 de distance minimale à x1 non encore connue définitivement, avec les opérations adéquates. d. Pour un graphe g, une forêt courante f, un ensemble e de sommets de distance minimale à x1

non encore connue définitivement après l’étape i1, à l’étape i, l’opération smin(g, f, e) renvoie un sommet xi choisi dans e pour minimiser la distance depuis x1 aux sommets de e, et l’opération majf(g, xi, f, e) renvoie la forêt f et l’ensemble e mis à jour. Spécifier itérativement, avec les opérations définies précédemment, smin, majf et l’opération dijkstra(g, x1) renvoyant une forêt résultat de l’algorithme de Dijkstra sur g et x1.e. On représente toutes les structures de données nécessaires de manière contiguë par des tableaux, des structures et des pointeurs. Déclarer en C les types correspondants et programmer l'opération dijkstra et les opérations auxiliaires cidessus.

Exercice 8 (algorithme de Kruskal). L'algorithme de Kruskal construit une forêt de recouvrement de coût minimum pour un graphe g non orienté et valué sur les arêtes. Les sommets du graphe sont les entiers naturels de 0 à n1. Les arêtes de g sont valuées par des coûts entiers strictement positifs. Pour simplifier, on représente la forêt f de la même manière que le graphe g. On ajoute à f des arêtes de g, une par une, en choisissant à chaque étape, parmi les arêtes qui ne sont pas dans f, une arête de coût minimum ne formant pas de cycle avec les arêtes de f. a. Spécifier algébriquement les graphes, de la sorte Graphe, sur les entiers de 0 à n1, simples non orientés et valués sur les arêtes par un coût entier naturel, avec les opérations convenables pour l’algorithme de Kruskal. Spécifier algébriquement l’opération init(g) définissant f comme le graphe partiel d’un tel graphe g sans aucune arête. Ainsi, les composantes connexes de la forêt f sont au départ les singletons {x} pour x variant de 0 à n1. b. Spécifier algébriquement une opération rep(f, x) donnant pour tout sommet d'une composante connexe de f le même sommet représentant. Ce représentant peut être par exemple le plus petit sommet de la composante connexe. Un sommet isolé est alors son propre représentant. c. Spécifier algébriquement une opération eq(f, x, y) testant si deux sommets sont dans la même composante connexe de f.d. On suppose qu’à une étape, on a déjà construit la forêt partielle f en ayant retiré des arêtes du graphe g. Définir algébriquement l'opération armin(f, g) qui renvoie soit (x, y, vrai), si (x, y) est une arête de coût minimum parmi les arêtes de g ne créant pas de cycle dans f, soit (0, 0, faux), s’il n’y a plus d’arête dans g, ou si les arêtes restant dans g créent toutes un cycle dans f. Spécifier itérativement une fonction kruskal construisant progressivement une forêt de recouvrement minimum f en enlevant une à une les arêtes de g. e. Programmer en C les opérations cidessus pour une implantation à préciser.

Exercice 9 (composantes connexes). a. Pour obtenir les composantes connexes d'un graphe orienté g, un algorithme simple consiste à effectuer un parcours en profondeur du graphe sans tenir compte de l'orientation des arcs. Spécifier algébriquement la détermination de la composante connexe d'un sommet x de g. Le résultat attendu est une simple liste des sommets appartenant à cette composante connexe.b. Programmer en C cette opération pour une implantation à préciser.



9. Tables

Exercice 1 (mélange aléatoire dans un tableau).Dans la spécification des tableaux de l’Exercice 4 Fiche 2, élém(t, i) est aussi noté t[i]. Spécifier une opération de mélange aléatoire d’un tableau t réalisée en tirant aléatoirement selon une loi uniforme pour chaque entier i de 0 à n1, un entier k, 0 ≤ k ≤ i, et en échangeant t[i] et t[k]. Programmer cette opération en C (avec rand et srand) et prévoir un programme principal de test.

Exercice 2 (adressage calculé et matrices).On suppose ici que les lignes et colonnes des matrices sont numérotées à partir de 0.a. Pour les matrices n*n triangulaires supérieures considérées comme des tables, spécifier les opérations zéro, renvoyant la matrice nulle, mod(m, i, j, x) rangeant la valeur x en (i, j) dans la matrice m, et élém(m, i, j) rendant la valeur d’entrée (i, j) de m. b. Spécifier itérativement, puis par rapport aux constructeurs de base, les opérations de multiplication par un scalaire, de somme et de produit de telles matrices. c. Trouver une représentation contiguë économique pour ces matrices, définir une fonction d’adressage calculé a(i, j) convenable et programmer les opérations de a et b.d. Faire de même pour des matrices tridiagonales, sauf pour le produit (pourquoi ?).

Exercice 3 (adressage associatif). a. Spécifier, avec des opérations de base convenables, une table donnant pour tout nom de pays celui de sa capitale. On suppose connues les opérations courantes sur les chaînes de caractères. b. Implanter cette table avec un adressage associatif, à l’aide d’une liste des entrées chaînée, et une fonction d’accès direct. Programmer les opérations de la spécification.c. Refaire l’implantation et la programmation avec la liste des entrées implantée de manière mixte contiguëchaînée, en plaçant dans la partie contiguë les pays de l’Union européenne.

Exercice 4 (matrices et listes orthogonales). a. Reprendre l’Exercice 2, a. et b., avec la multiplication, pour des matrices générales n*n. b. Proposer une représentation des matrices creuses par listes chaînées “orthogonales“. Programmer pour cette représentation les opérations définies cidessus.

Exercice 5 (fonctions de hachage).a. On suppose que toutes les chaînes sont cadrées à gauche sur exactement 20 caractères. Spécifier et programmer une fonction (non injective) conv de conversion d’un nom nom en un entier naturel i = conv(nom) codé sur 32 bits. Pour ce faire, on découpera le nom en 5 souschaînes de 4 caractères que, en passant par le code ASCII des caractères, on codera en 5 entiers dont on fera la « somme » par un ou exclusif. Montrer que cette méthode est sans débordement. b. L'entier m étant une constante telle que m = 2q, spécifier et programmer une fonction de hachage h(i) de type multiplicatif avec un argument i entier sur 32 bits et un résultat dans l'intervalle [0, m1]. c. Spécifier et programmer une fonction p(i) = 2p’(i) + 1, où p’(i) est une fonction de hachage de type modulo prenant ses valeurs dans [0, 2q1 1].



Exercice 6 (suite de l'Exercice 5, hachage double).a. Spécifier une table complétée de m éléments donnant, à partir du nom d’une personne, son année de naissance (strictement positive sur 4 chiffres), avec les opérations de base, dont le nombre de personnes enregistrées. On suppose qu'il n'y a jamais deux fois le même nom. Il faut s'interroger soigneusement sur les cas de table vide ou de risque de débordement. Il faut bien dégager les préconditions, en essayant de les rendre peu contraignantes. b. Implanter cette table en C, et programmer ses opérations de base, avec une technique de double hachage utilisant h et p comme fonctions de hachage primaire (pour le premier accès) et secondaire (pour le pas). Choisir une technique bien claire pour coder les 3 états d'une place : vide, occupée, libérée.c. Préparer des tests complets avec des résultats "internes" montrant bien les phénomènes de collisions primaires et secondaires, par exemple en prenant m = 8 et en listant le contenu de toute la table après modification.



10. Tris internes

S étant une sorte munie d’une égalité == et d’un préordre total ≤ décidable, on s'intéresse ici, sauf indication contraire, au tri en croissant d'une liste de n éléments de S représentée de manière contiguë comme un tableau t, indicé de 0 à n-1.

Tris par sélection

Exercice 1 (méthode de la bulle et méthode du shaker). a. La méthode de la bulle consiste à parcourir à chaque étape une portion de t de gauche à droite en y permutant l’élément courant avec son successeur s’ils sont mal rangés, et ce jusqu’à l’absence de telles inversions. Donner un exemple avec n = 7. Spécifier avec itérations et programmer la fonction tribulle(t) correspondante. Evaluer sa complexité dans le pire des cas, en nombre de comparaisons d’éléments, puis en nombre d’échanges. Proposer des améliorations.b. La méthode du shaker fait de même, mais alternativement, de gauche à droite, puis de droite à gauche. Donner un exemple avec n = 7. Spécifier avec itérations et programmer la fonction trishaker(t) correspondante. Evaluer sa complexité dans le pire des cas, en nombre de comparaisons d’éléments, puis en nombre d’échanges. Proposer des améliorations.

Exercice 2 (tri par tas). La représentation d'un arbre parfait étiqueté partiellement ordonné par un tableau t est appelée un tas. Dans un tas, le minimum est toujours en première place. Le tri par tas est un tri par sélection en croissant, fonctionnant en deux étapes : 1) construction « sur place » d’un tas à partir du tableau t de n éléments à trier, 2) extraction et rangement en dernière position des minima successifs, toujours « sur place ». Programmer avec mutation et tester la version tritas(t) du tri par tas vue en cours.

Tris par insertion

Exercice 3 (tri par insertion dichotomique). Une variante du tri par insertion consiste à rechercher la place où un élément est à insérer par un procédé de recherche dichotomique. a. On suppose que, pour 0 ≤ a ≤ b ≤ n - 1, le tableau t est trié en ordre croissant dans la tranche allant de l'indice a à l'indice b-1. Spécifier une opération dich(t, a, b, x) donnant, par un procédé dichotomique, un indice i, a ≤ i ≤ b, où la valeur x ≤ t[b] peut être insérée dans t, après décalage éventuel à droite d’une position de t[i], ..., t[b - 1], pour que la tranche de a à b soit triée.b. Programmer en C une version récursive et une version itérative de l'opération dich ainsi qu’une version itérative du tri tridich(t) par insertion dichotomique « sur place ».

Exercice 4 (course contre la montre). Les organisateurs d'une course contre la montre voudraient, à tout moment, afficher le classement des participants déjà arrivés. Pour cela, ils disposent d'un ordinateur qui tient à jour le classement lors de la kème arrivée, pour 1 ≤ k ≤ n, sous la forme d'un tableau de n éléments, où n est le nombre des participants.a. Que peut représenter la sorte S des éléments de cette table ? Quel est le préordre ≤ retenu sur S pour le classement ?



b. Proposer une méthode de tri adaptée à ce problème. c. Programmer en C, avec mutation, l'algorithme de tri choisi.

Tri rapide

Exercice 5 (suppression de la récursivité double du tri rapide). Le tri rapide de Hoare spécifié dans le cours met en évidence une récursivité double :

tri(t, a , b) = si a < b alors tri(tri(t', a, j), i, b) avec (t', i, j) = placement(t) sinon t fsi

a. Sur un exemple, construire l'arbre des appels à l'opération tri(t, a, b). Construire également l'arbre des indices (a, j, i, b) à chaque étape. b. On constate qu'un parcours en ordre préfixe de l'arbre permet de dérécursiver le tri, à l’aide d’une pile de couples d’indices (i, b). Spécifier algébriquement une version itérative du tri rapide.c. Décrire en C, à partir d’une spécification des piles, un type de données pour des piles de couples d'indices (i, b) et les opérations, avec mutations, pilevide() de création d'une pile vide, empiler(p, i, b) d'empilement des indices, dépiler(p) de dépilement et sommet(p, pi, pb) où les indices au sommet de la pile sont retournés par leurs adresses pi et pb. d. Programmer en C, avec mutation, cette version itérative du tri rapide.

Tris basés

Exercice 6 (tri par compteurs). Le tri par compteurs d’une file de n entiers, dont on sait qu’ils sont tous compris entre 1 et p, consiste simplement à dénombrer dans un tableau (de compteurs) les occurrences de chaque entier de 1 à p apparaissant dans la file, puis à restituer le tableau en une file résultat triée. Spécifier algébriquement le tri par compteurs, en utilisant des spécifications de files et de tableaux. Programmer en C, avec mutation, cet algorithme de tri.

Exercice 7 (tri basé simple). Au lieu d'un tableau, nous considérons ici une file PAPS de n articles à trier. Chaque article x est muni d'une clé clé(x) appartenant à la base B = [0, m 1], où m est une constante entière strictement positive. Le principe du tri basé simple consiste à construire un tableau t de m files, la iième file étant destinée à recueillir les articles x tels que clé(x) == i. La file triée est alors obtenue en concaténant ces files. Nous supposons dans la suite qu'un article à trier est simplement un couple composé d'une clé entière comprise entre 0 et m 1 et d'un nom représenté par une chaîne de 10 caractères.a. Spécifier une sorte Article avec les opérations ga créant un article à partir d'une clé entière et d'une chaîne de 10 caractères, clé donnant la clé entière et nom le nom d'un article.b. Spécifier algébriquement la sorte File des files (premier arrivépremier servi) d'objets de sorte Article, avec les opérations v, donnant la file vide, a, ajoutant en queue, c, donnant le corps, t, donnant l'élément en tête, ev, testant la vacuité, et conc, concaténant 2 files.c. Spécifier algébriquement une sorte Table de tables de m files indicées de 0 à m - 1, avec les opérations ti de création d'une table composée de m files vides, élém donnant la file figurant dans une table à un indice donné, et mod remplaçant une file d'indice donné par une autre.



d. Spécifier algébriquement une opération ventil répartissant de manière séquentielle les articles d'une file dans un tableau, de façon que l'article courant, de clé i, soit placé en queue de la file d'indice i. e. Spécifier algébriquement une opération concm de concaténation des m files d'une table donnée, en utilisant une opération auxiliaire conc1 définie récursivement sur les entiers.f. Spécifier une opération tribasé qui réalise le tri d'une file d'articles en utilisant les opérations précédentes.

Exercice 8 (tri basé général ou radix sort). Une date est un triplet composé du jour (entier entre 1 et 31), du mois (entier entre 1 et 12) et de l'année (entier entre 1 et 3000). Le tri basé général croissant de n éléments munis d'une clé du type date est obtenu par une mise en œuvre de 3 tris basés simples (Exercice 7), en retenant successivement comme sousclé le jour, le mois, puis l'année. Le tri basé simple sur la 1ère (resp. 2ième, 3ième) sousclé nécessite une table de 31 (resp. 12, 3000) files indicées de 0 à 30 (resp. de 0 à 11, de 0 à 2999).a. Spécifier algébriquement une sorte Date avec les opérations date de création d'une date à partir de trois entiers naturels représentant le jour, le mois et l'année, et jour, mois et année, rendant ces informations. On suppose que les entiers donnés correspondent à une date correcte.b. Spécifier algébriquement une sorte Article avec les opérations ga de création d'un article à partir d'une date et d'une chaîne de 10 caractères, nom(a), donnant le nom d'un article a, et clé(a,

k), donnant l'indice de sa kième sousclé. Spécifier également une opération taille(k) donnant le nombre de valeurs différentes que peut prendre la kième sousclé.c. Reprendre les questions b à e de l’Exercice 7 et les adapter en introduisant dans l'opération

ventil la kième sousclé comme paramètre.d. Spécifier une opération tribase qui réalise le tri, selon leur date croissante, d'une file d'articles, en utilisant les opérations précédentes.


Algorithmique-programmation Licence d'Informatique

Documents

Transcript of Algorithmique-programmation Licence d'Informatique