TD 13 - Tris - Récursivité
Partie A - Tris
1. Ecrire une fonction TriSel(L) qui prend en argument une liste de nombres et qui les trie dans l'ordre croissant, par la méthode du tri par sélection.
2. (a) Ecrire une fonction Fusion(L1,L2) qui prend en argument deux listes déjà triées par ordre croissant, et qui renvoie la liste L1+L2 triée par ordre croissant.
(b) Ecrire une fonction TriFusion(L) qui renvoie la liste L triée par ordre croissant, à l'aide du tri fusion.
3. Ecrire une fonction TriRapide(L) qui trie la liste L par la méthode du tri rapide.
Partie B - Récursivité - Petites questions
I - Coecients binomiaux En utilisant∀n, k∈N∗,
n k
= n k×
n−1 k−1
, écrire une fonction récursive def C(k,n) qui renvoie n k
pourn, k∈N.
II - Suite de Fibonacci
On noteF0= 0,F1= 1 et∀n∈N,Fn+2=Fn+1+Fn.
1. Ecrire une fonction itérative F(n) qui renvoieFn. Quelle est sa complexité en temps et en mémoire ? 2. Ecrire une fonction récursive F_rec(n) qui renvoieFn. Quelle est sa complexité en temps ?
III - Tours de Hanoï
Ecrire une fonction Hanoi(nb, deb, fin) qui renvoie une suite de coups à jouer au jeu des tours de Hanoï pour déplacer une tour de nb étages de l'emplacement deb vers l'emplacement fin, sous la forme d'une liste de couples (position_deb,position_fin)
Par exemple, Hanoi(2,0,2) renverra [(0, 1), (0, 2), (1, 2)]
(on a numéroté les 3 emplacements de 0 à 2 )
IV - Permutations
1. Ecrire une fonction InsereDansL (L,x) qui prend en argument une liste d'entiers et un entier, et qui renvoie une liste de listes comportant l'entier à tous les endroits possibles.
Un exemple sera plus clair :
InsereDansL([0,3,5],2) devra renvoyer [[2, 0, 3, 5], [0, 2, 3, 5], [0, 3, 2, 5], [0, 3, 5, 2]]
2. En déduire une fonction récursive Permut(n) qui renvoie la liste des permutations de l'ensemble [1,2,...,n]
Par exemple, Permut(3) pourra renvoyer [[3, 2, 1], [2, 3, 1], [2, 1, 3], [3, 1, 2], [1, 3, 2], [1, 2, 3]]
1
Partie C - Recherche du plus grand rectangle blanc
•Soit a une matrice modélisant les cases d'une grille de mots croisés.
Les 0 représentent les cases blanches et les 1 les cases noires.
On souhaite calculer la surface du plus grand rectangle blanc présent dans cette grille.
Par exemple, si
a = [ [1,1,0,0,0], [1,1,0,0,0], [0,0,0,1,0], [1,0,0,0,0], [0,1,1,0,0] ]
l'aire du plus grand rectangle blanc est 6 (c'est le rectangle blanc situé en haut à droite)
•An d'alléger les notations,
on noterarect(a, i, j, k, `)la sous matrice de a dontle coin supérieur gauche a pour coordonnées (i,j) le coin inférieur droit a pour coordonnées (k,l)
•Algorithme 1 : itératif ( à ne pas coder )
1. On considère la fonction EstBlanc(a,i,j,k,l) qui renvoie True sirect(a, i, j, k, `)est tout blanc et qui renvoie False si au moins une case de ce rectangle est noire.
Quelle est la complexité au pire de EstBlanc en fonction de n = len(a) ?
2. On imagine ensuite la fonction PGRB_lent(a) qui passe en revue tous les rectangles possibles de a, et qui renvoie l'aire du plus grand rectangle blanc trouvé.
Quelle est la complexité au pire de PGRB_lent en fonction de n = len(a) ?
•Algorithme 2 : récursif ( à coder )
1. Ecrire une fonction itérative ( c'est-à-dire non-récursive ) NoireHG(a,i,j,k,l)
→qui renvoie (-1,-1) sirect(a, i, j, k, `)est tout blanc
→ et sinon, qui renvoie le couple (u,v) de coordonnées de la case noire la plus en Haut à Gauche des cases noires de rect(a, i, j, k, `), le critère prioritaire étant d'être le plus Haut possible, et parmi les cases noires le plus Haut dans la matrice, on choisira la plus à Gauche.
2. Si un rectanglerect(a, i, j, k, `)possède au moins une case noire, et si on note (u,v)=NoireHG(a,i,j,k,l), alors son plus grand rectangle blanc se trouvera dans une des 4 sous-matrices suivantes :
- celle constituée des cases derect(a, i, j, k, `)situées strictement au-dessus de (u,v) (ie des cases(y, x)avec
i6y < u j6x6` ) - celle constituée des cases derect(a, i, j, k, `)situées strictement au-dessous de (u,v)
- celle constituée des cases derect(a, i, j, k, `)situées strictement à gauche de (u,v) - celle constituée des cases derect(a, i, j, k, `)situées strictement à droite de (u,v)
•A l'aide de la remarque ci-dessus, écrire une fonction récursive PGRB_rapide(a), qui renvoie la même chose que PGRB_lent(a).
→ On pourra dans un premier temps écrire une fonction récursive PGRB_rec(a,i,j,k,l) qui renvoie la taille du plus grand rectangle blanc contenu dansrect(a, i, j, k, l)
→Avec le tableau a de 20 lignes et 20 colonnes dont toutes les cases valent 0,
sauf les cases a[3][7], a[10][10], a[5][17], a[15][3] égales à 1, PGRB_rapide(a) doit renvoyer 144
2
Partie D - Multiplication rapide de 2 polynômes( méthode de Karatsuba ) On modélise un polynôme par un tableau de la façon suivante :
par exemple, A=[1,2,3,4,0,0] représente le polynômeA(X) = 1 + 2X+ 3X2+ 4X3. Méthode naïve ( à ne pas coder )
On imagine une fonction mult(P,Q) qui prend en argument 2 tableaux P et Q de même longueur représentant 2 polynômes P et Q, et qui renvoie un tableau représentant le polynôme P Q.
Déterminer la complexité de mult(P,Q) en fonction de n=len(P)=len(Q) Méthode de Karatsuba ( à coder )
1. SoientN ∈N∗ etn= 2N. On considère 2 polynômes réelsP(X) =
n−1
X
k=0
akXk et Q(X) =
n−1
X
k=0
bkXk. An d'alléger les notations, on confondra désormais polynôme et tableau représentant ce polynôme.
•On noteP1 etP0le quotient et le reste de la division euclidienne deP parXn/2, et de même pourQ. On a donc
P=Xn/2P1+P0
Q=Xn/2Q1+Q0 . On poseR0=P0Q0et R2=P1Q1.
•Montrer la relation P(X)∗Q(X) =R2Xn+
(P0+P1)(Q0+Q1)−R2−R0
Xn/2+R0
2. Ecrire Add(P,Q) qui prend en argument 2 polynômes tels que len(P)=len(Q), et qui renvoieP+Q. 3. Ecrire Minus(P,Q) qui prend en argument 2 polynômes tels que len(P)=len(Q), et qui renvoieP−Q.
4. Ecrire Remix(R0,R1,R2), qui prend en argument 3 polynômes tels que d=len(R0)=len(R1)=len(R2) soit pair, et qui renvoie le polynômeres=R2Xd+R1Xd/2+R0, tel que len(res)=2*d.
Par exemple, Remix([1,2,3,4],[5,6,7,8],[9,10,11,12]) renverra [1, 2, 8, 10, 16, 18, 11, 12].
5. Ecrire Karats(P,Q) qui prend en argument 2 polynômes tels que n=len(P)=len(Q) soit une puissance de 2,
et qui renvoie le produit le polynômeP Qsous forme d'un tableau de 2n cases, récursivement, grâce à la formule (♥). Karats( [4],[5] ) doit donc renvoyer [20,0]
Karats( [1,2,1,54] , [5,8,3,-34] ) doit renvoyer [5, 18, 24, 250, 367, 128, -1836, 0]
6. Montrer que Karats(P,Q) eectue seulementO nln2(3)multiplications de réels. (ln2(3)≈1.58)
3
