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

Transcription

1 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

2 2

3 Constructions de base 1. Algorithmique et programmation de base, notations 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 x 1 = expr 1,, x n = expr n ou bien : x = soit x 1 = expr 1,, x n = expr n dans expr lecture en séquence sur organe standard : (x 1,, x n ) = donnée écriture en séquence par effet de bord sur organe standard : écrire(y 1,, y n ) résultat général (fonction main() de C) : principal = expr 1,, expr n Exercice 2 (définitions conditionnelles). Spécifier la résolution complète de l équation du second degré ax 2 + 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 expr 1 sinon expr 2 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 x 0 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 à 10 7 près de la racine carrée d un nombre a entré au clavier. Indication : utiliser la suite u 0 = 1, u n =1/2(u n 1 + a/u n 1 ). Notations : définition itérative générale : x = init x 0 tantque cond[x] répéter expr[x] frépéter Exercice 6 (définitions itératives générales, récurrence, n uplets). 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 x 0 tantque cond[x] répéter expr[x] frépéter n uplet : (x 1,, x n ) 3

4 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 x n, 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 n ième terme de la suite de Fibonacci définie par u 0 = 0, u 1 = 1, u n = u n 1 + u n 2 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 u n / n, où = (1 + 5) / 2 est le nombre d Or. Exercice 10 (résultats multiples, entrées sorties, 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. 4

5 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 ci dessus. 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 à n 1, 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. 5

6 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 ci dessus 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. 6

7 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. Celle ci 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 7

8 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 ci dessus 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, k ième caractère, modification du k ième caractère, adjonction en queue, queue, corps inverse, sous chaî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. 8

9 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) fsi rec2(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 x n (Fiche 1, Exercice 8). Exercice 5 (suite de Fibonacci). Etudier la complexité des deux versions du calcul du terme général u n 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); } 9

10 } 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) : y d (x, y) O 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.(2k i 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). x 10

11 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 sous arbres 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 ci dessus, 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 ci dessus, 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 sous arbres, 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) ; 11

12 sinon, l'image est partagée en 4 images carrées de 2 k 1 2 k 1 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 sous arbres 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 sud ouest). 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 sous arbre gauche correspond à la réponse positive et le sous arbre 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 recherche insertion 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 sous arborescence à 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. 12

13 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 a b. 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 sous arbre 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 sous arbre 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. 13

14 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 fils pè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. 14

15 Notion de graphe 7. Graphes : spécification et implantation 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 ( ) 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 luimê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 a t il dans le graphe? Quelles sont les degrés possibles de ses sommets? Chaque personne ayant donné une réponse différente, que peut on dire de ces degrés? Que peut on 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 sous ensemble 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 sous ensemble 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. 15

16 Implantationdes 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. 16

17 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. 17

18 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 ci dessus pour une implantation à préciser, puis programmer en C dans 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é x 1 à 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 x 1 au nœud z (voir ce qu il advient des noeuds non encore déterminés comme accessibles depuis x 1 ). a. M étant une constante entière fixée, spécifier algébriquement les graphes, de la sorte Graphe, sur les entiers de 0 à n 1, 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. 18

19 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 à x 1 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 à x 1 non encore connue définitivement après l étape i 1, à l étape i, l opération smin(g, f, e) renvoie un sommet x i choisi dans e pour minimiser la distance depuis x 1 aux sommets de e, et l opération majf(g, x i, 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, x 1 ) renvoyant une forêt résultat de l algorithme de Dijkstra sur g et x 1. 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 ci dessus. 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 à n 1. 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 à n 1, 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 à n 1. 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 ci dessus 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. 19

20 20