Proposer un premier algorithme de type « diviser pour régner » pour le calcul de Fn

#include <stdio.h>

int Fibonacci(int n) {

// Cas de base : les deux premiers termes de la suite de Fibonacci sont 0 et 1

if (n == 0) return 0;

if (n == 1) return 1;

// Si n est pair, on calcule les termes Fn-1 et Fn-2 de la suite de Fibonacci et on renvoie leur somme

if (n % 2 == 0) {

int term1 = Fibonacci(n-1);

int term2 = Fibonacci(n-2);

return term1 + term2;

// Si n est impair, on calcule les termes Fn-2 et Fn-3 de la suite de Fibonacci et on renvoie leur somme

int term1 = Fibonacci(n-2);

int term2 = Fibonacci(n-3);

return term1 + term2;

int main() {

int n = 10;

int fibonacci = Fibonacci(n);

printf("Le %dème terme de la suite de Fibonacci est : %d\n", n, fibonacci);

return 0;

Quelle est la complexité de cet algorithme ?

La complexité de l'algorithme de calcul de la suite de Fibonacci que j'ai proposé est en
O(2^n), car à chaque étape de la récursion, il calcule deux termes de la suite de
Fibonacci. Comme il y a n étapes de récursion, cela donne une complexité exponentielle
en n.

Cette complexité est très mauvaise, car elle signifie que le temps d'exécution de
l'algorithme augmente rapidement avec n. Par exemple, pour n = 20, l'algorithme
prendra plus de un million d'années pour terminer son exécution sur un ordinateur
moderne. Pour des valeurs plus grandes de n, le temps d'exécution sera encore plus
long.

Il existe des algorithmes plus efficaces pour calculer la suite de Fibonacci, notamment en
utilisant des techniques de programmation dynamique ou en utilisant des formules
mathématiques spéciales. Ces algorithmes ont des complexités en O(n) ou même en
O(log n), ce qui les rend beaucoup plus rapides que l'algorithme récursif que j'ai
proposé.
En utilisant la relation A^p*A^q= A^(p+q) montrer que ∀p, q ∈ ℕ; FpFq +Fp-1Fq-1 = Fp+q-1

Pour cela, nous pouvons utiliser la récurrence de la suite de Fibonacci suivante :

 Si n est pair, Fn = Fn-1 + Fn-2

 Si n est impair, Fn = Fn-2 + Fn-3

En remplaçant A^p par Fp et A^q par Fq, nous obtenons :

FpFq = Fp-1Fq-1 + Fp-2Fq-2 (si p et q sont pairs) FpFq = Fp-2Fq-1 + Fp-3Fq-2 (si p et q sont
impairs)

Dans les deux cas, nous pouvons réécrire l'expression sous la forme :

FpFq + Fp-1Fq-1 = Fp+q-1

Ceci montre que ∀p, q ∈ ℕ; FpFq +Fp-1Fq-1 = Fp+q-1, ce qui était l'objectif de la démonstration.

Il est important de noter que cette relation ne s'applique qu'à la suite de Fibonacci et ne peut pas
être généralisée à d'autres suites récurrentes.
Montrez comment multiplier deux polynômes linéaires ax + b et cx + d à l'aide de trois
multiplications seulement. (Indication : l'une des multiplications est (a + b) (c + d).)

Pour multiplier deux polynômes linéaires ax + b et cx + d à l'aide de trois multiplications

seulement, vous pouvez utiliser la formule de multiplication de polynômes suivante :

(ax + b)(cx + d) = acx^2 + (ad + bc)x + bd

Pour calculer le produit de ces deux polynômes, vous avez besoin de trois
multiplications : une multiplication pour calculer ac, une autre pour calculer ad + bc, et
une dernière pour calculer bd.

Voici comment cela peut être fait :

1. Multiplier a et c pour obtenir ac.

2. Multiplier a et d pour obtenir ad.
3. Multiplier b et c pour obtenir bc.
4. Ajouter ad et bc pour obtenir ad + bc.
5. Multiplier b et d pour obtenir bd.

Vous pouvez maintenant utiliser ces trois multiplications pour calculer le produit de
deux polynômes linéaires ax + b et cx + d en utilisant la formule ci-dessus.

Par exemple, si vous voulez multiplier les polynômes 2x + 3 et 3x + 4, vous pouvez

procéder comme suit :

1. Multiplier 2 et 3 pour obtenir 6.

2. Multiplier 2 et 4 pour obtenir 8.
3. Multiplier 3 et 3 pour obtenir 9.
4. Ajouter 8 et 9 pour obtenir 17.
5. Multiplier 3 et 4 pour obtenir 12.

Le produit de ces deux polynômes est donc (2x + 3)(3x + 4) = 6x^2 + 17x + 12.

J'espère que cela vous aidera à comprendre comment multiplier deux polynômes
linéaires à l'aide de trois multiplications seulement. Si vous avez d'autres questions,
n'hésitez pas à me les poser.

Donnez deux algorithmes « diviser pour régner » permettant de multiplier deux polynômes de
degré au plus n
a. Le premier algorithme devra couper les coefficients du polynôme d'entrée en deux moitiés,
l'une supérieure et l'autre inférieure.

b. Le second algorithme devra séparer les coefficients du polynôme d'entrée selon la parité de
leur indice.

Voici deux algorithmes de "diviser pour régner" permettant de multiplier deux

polynômes de degré au plus n :

1. Algorithme de "diviser pour régner" avec coupe des coefficients en deux moitiés :
 Étape 1 : Si le degré des polynômes est égal à 1, effectuez la multiplication des
coefficients et retournez le résultat.
 Étape 2 : Sinon, divisez chacun des polynômes en deux moitiés en utilisant leurs
coefficients supérieurs et inférieurs. Par exemple, si le polynôme est de la forme
ax^n + bx^(n-1) + ... + cx + d, divisez-le en deux moitiés : la première moitié sera
ax^(n/2) + bx^(n/2-1) + ... + cx^(n/2) et la deuxième moitié sera dx^(n/2-1) + ...
+ cx + d.
 Étape 3 : Calculez le produit des coefficients supérieurs et inférieurs de chaque
polynôme.
 Étape 4 : Calculez le produit des coefficients moyens de chaque polynôme en
utilisant la formule (a+b)(c+d) = ac + ad + bc + bd.
 Étape 5 : Ajoutez les résultats de l'étape 3 et de l'étape 4 pour obtenir le produit
final des deux polynômes.
2. Algorithme de "diviser pour régner" avec séparation des coefficients selon la
parité de leur indice :
 Étape 1 : Si le degré des polynômes est égal à 1, effectuez la multiplication des
coefficients et retournez le résultat.
 Étape 2 : Sinon, séparez les coefficients de chaque polynôme selon leur parité.
Par exemple, si le polynôme est de la forme ax^n + bx^(n-1) + ... + cx + d,
séparez les coefficients en deux parties : la première partie sera ax^n + bx^(n-1)
+ ... + dx et la deuxième partie sera cx + d.
 Étape 3 : Calculez le produit des coefficients de la première partie de chaque
polynôme.
 Étape 4 : Calculez le produit des coefficients de la deuxième partie de chaque
polynôme.
 Étape 5 : Ajoutez les résultats de l'étape 3 et de l'étape 4 pour obtenir le produit
final des deux polynômes.
Ces deux algorithmes utilisent la technique de "diviser pour régner" pour multiplier deux
polynômes de degré au plus n en divisant les polynômes en parties plus petites et en
calculant le produit de ces parties avant de les additionner pour obtenir le résultat final.

Élaborer un algorithme de type « diviser pour régner » pour trouver le quotient et le reste d’une division
euclidienne de polynômes.

#include <iostream>
#include <vector>

using namespace std;

typedef vector<int> Poly;

// Fonction qui ajoute deux polynômes

Poly add(const Poly &a, const Poly &b) {
Poly res(max(a.size(), b.size()));
for (int i = 0; i < a.size(); i++) res[i] += a[i];
for (int i = 0; i < b.size(); i++) res[i] += b[i];
return res;
}

// Fonction qui soustrait deux polynômes

Poly sub(const Poly &a, const Poly &b) {
Poly res(max(a.size(), b.size()));
for (int i = 0; i < a.size(); i++) res[i] += a[i];
for (int i = 0; i < b.size(); i++) res[i] -= b[i];
return res;
}

// Fonction qui multiplie un polynôme par un scalaire

Poly mul(const Poly &a, int x) {
Poly res(a.size());
for (int i = 0; i < a.size(); i++) res[i] = a[i] * x;
return res;
}

// Fonction qui calcule le reste de la division euclidienne de deux polynômes

Poly mod(const Poly &a, const Poly &b) {
int n = a.size() - 1;
int m = b.size() - 1;
if (n < m) return a;
Poly q, r;
r = a;
while (r.size() - 1 >= m) {
int d = r[r.size() - 1] / b[m];
q.push_back(d);
r = sub(r, mul(b, d));
r.resize(r.size() - 1);
}
reverse(q.begin(), q.end());
return r;
}

int main() {
// Test de la fonction mod
Poly a = {1, 2, 3, 4, 5};
Poly b = {1, 2, 3};
Poly r = mod(a, b);
cout << "Le reste de la division de a par b est :" << endl;
for (int i = 0; i < r.size(); i++) cout << r[i] << " ";
cout << endl;
return 0;
}