1.

Rendu de la monnaie:

Description du problème: Le problème du rendu de monnaie consiste à trouver le nombre minimal de

pièces de monnaie ou de billets nécessaires pour donner la somme exacte à un client, en utilisant les
valeurs disponibles de pièces de monnaie ou de billets.

Algorithme glouton pour le problème du rendu de monnaie:

1. Trier les valeurs des pièces de monnaie (ou des billets) disponibles de la plus grande à la plus petite.

2. Initialiser un compteur de pièces de monnaie à 0.

3. Parcourir les valeurs des pièces de monnaie de la plus grande à la plus petite:

- Si la valeur de la pièce de monnaie est inférieure ou égale à la somme restante à rendre:

- Ajouter la valeur de la pièce de monnaie au compteur de pièces de monnaie.

- Soustraire la valeur de la pièce de monnaie de la somme restante à rendre.

4. Retourner le compteur de pièces de monnaie.

Complexité de l'algorithme: La complexité de cet algorithme glouton est linéaire, c'est-à-dire O(n), où n
est le nombre de valeurs de pièces de monnaie disponibles.

2. Sac à dos:

Description du problème: Le problème du sac à dos consiste à déterminer comment remplir un sac à dos
avec des objets de différentes valeurs et poids, de manière à maximiser la valeur totale des objets sans
dépasser la capacité maximale du sac à dos.

Algorithme glouton pour le problème du sac à dos:

1. Calculer le rapport valeur/poids pour chaque objet.

2. Trier les objets en fonction du ratio valeur/poids, du plus grand au plus petit.

3. Initialiser la valeur totale du sac à dos à 0 et la capacité utilisée du sac à dos à 0.

4. Parcourir les objets triés:

- Si l'objet peut être entièrement placé dans le sac à dos sans dépasser la capacité:

- Ajouter la valeur de l'objet à la valeur totale du sac à dos.

- Ajouter le poids de l'objet à la capacité utilisée du sac à dos.

 - Sinon, ajouter une fraction de l'objet pour remplir le sac à dos jusqu'à atteindre sa capacité
maximale.

5. Retourner la valeur totale du sac à dos.

Complexité de l'algorithme: La complexité de cet algorithme glouton dépend de la méthode de tri

utilisée. Si un algorithme de tri efficace est utilisé, la complexité est généralement O(n log n), où n est le
nombre d'objets disponibles.

3. Location de véhicule:

Description du problème: Le problème de la location de véhicule consiste à sélectionner un ensemble de

véhicules parmi un groupe de véhicules disponibles, de manière à minimiser les coûts totaux tout en
respectant certaines contraintes telles que la capacité maximale des véhicules et les disponibilités des
véhicules.

Algorithme glouton pour le problème de la location de véhicule:

1. Trier les véhicules disponibles en fonction de leur coût par unité de capacité (coût / capacité).

2. Initialiser la capacité totale utilisée à 0 et le coût total à 0.

3. Parcourir les véhicules triés:

- Si l'ajout du véhicule respecte les contraintes de capacité et de disponibilité:

- Ajouter le coût du véhicule au coût total.

- Ajouter la capacité du véhicule à la capacité totale utilisée.

4. Retourner le coût total.

Complexité de l'algorithme: La complexité de cet algorithme glouton dépend de la méthode de tri

utilisée. Si un algorithme de tri efficace est utilisé, la complexité est généralement O(n log n), où n est le
nombre de véhicules disponibles.

4. Arbre couvrant de poids minimal:

Description du problème: Le problème de l'arbre couvrant de poids minimal consiste à trouver un sous-
ensemble des arêtes d'un graphe pondéré qui connecte tous les sommets du graphe avec un poids total
minimal.
Algorithme glouton pour le problème de l'arbre couvrant de poids minimal (Algorithme de Kruskal):

1. Trier toutes les arêtes du graphe par ordre croissant de poids.

2. Initialiser un ensemble vide d'arêtes sélectionnées pour former l'arbre couvrant de poids minimal.

3. Parcourir les arêtes triées:

- Si l'ajout de l'arête ne crée pas de cycle dans l'ensemble des arêtes sélectionnées:

- Ajouter cette arête à l'ensemble des arêtes sélectionnées.

4. Retourner l'ensemble des arêtes sélectionnées.

Complexité de l'algorithme: La complexité de cet algorithme glouton dépend de la méthode de tri

utilisée. Si un algorithme de tri efficace est utilisé, la complexité est généralement O(E log E), où E est le
nombre d'arêtes du graphe.

Voici une implémentation en C des trois versions du tri fusion (scindé en 2, en 3 et en 4) et la mesure des
temps d'exécution :

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

void fusion(int arr[], int l, int m, int r) {

int i, j, k; int n1 = m - l + 1; int n2 = r - m; int L[n1], R[n2];

for (i = 0; i < n1; i++)

L[i] = arr[l + i];

for (j = 0; j < n2; j++)

R[j] = arr[m + 1 + j];

i = 0;

j = 0;

k = l;

while (i < n1 && j < n2) {

if (L[i] <= R[j]) {

arr[k] = L[i];

i++;

else {
 arr[k] = R[j];

j++;

k++;

while (i < n1) {

arr[k] = L[i];

i++;

k++;

while (j < n2) {

arr[k] = R[j];

j++;

k++;

void tri_fusion(int arr[], int l, int r) {

if (l < r) {

int m = l + (r - l) / 2;

tri_fusion(arr, l, m);

tri_fusion(arr, m + 1, r);

fusion(arr, l, m, r);

void tri_fusion_2(int arr[], int l, int r) {

if (l < r) {

int m1 = l + (r - l) / 3; int m2 = l + 2 * (r - l) / 3;
 tri_fusion_2(arr, l, m1);

tri_fusion_2(arr, m1 + 1, m2);

tri_fusion_2(arr, m2 + 1, r);

fusion(arr, l, m1, m2);

fusion(arr, l, m2, r);

void tri_fusion_3(int arr[], int l, int r) {

if (l < r) {

int m1 = l + (r - l) / 4; int m2 = l + 2 * (r - l) / 4; int m3 = l + 3 * (r - l) / 4;

tri_fusion_3(arr, l, m1);

tri_fusion_3(arr, m1 + 1, m2);

tri_fusion_3(arr, m2 + 1, m3);

tri_fusion_3(arr, m3 + 1, r);

fusion(arr, l, m1, m2);

fusion(arr, l, m2, m3);

fusion(arr, l, m3, r);

void random_array(int arr[], int n) {

srand(time(NULL));

for (int i = 0; i < n; i++) {

arr[i] = rand() % 1000;

}
void print_array(int arr[], int n) {

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

printf(" ");

int main() {

int sizes[] = {1000, 5000, 10000, 50000, 100000};

int num_sizes = sizeof(sizes) / sizeof(sizes[0]);

for (int i = 0; i < num_sizes; i++) {

int size = sizes[i];

// Version 1: scindé en 2

int arr1[size];

random_array(arr1, size);

clock_t start = clock();

tri_fusion(arr1, 0, size - 1);

clock_t end = clock();

double time_taken = ((double) (end - start)) / CLOCKS_PER_SEC;

printf("Tri fusion (scindé en 2) pour un tableau de taille %d : %f secondes

", size, time_taken);

// Version 2: scindé en 3

int arr2[size];

random_array(arr2, size);

start = clock();

tri_fusion_2(arr2, 0, size - 1);

end = clock();
 time_taken = ((double) (end - start)) / CLOCKS_PER_SEC;

printf("Tri fusion (scindé en 3) pour un tableau de taille %d : %f secondes", size, time_taken);

// Version 3: scindé en 4

int arr3[size];

random_array(arr3, size);

start = clock();

tri_fusion_3(arr3, 0, size - 1);

end = clock();

time_taken = ((double) (end - start)) / CLOCKS_PER_SEC;

printf("Tri fusion (scindé en 4) pour un tableau de taille %d : %f secondes

", size, time_taken);

return 0;

Cet exemple génère des tableaux aléatoires de tailles différentes (1000, 5000, 10000, 50000 et 100000)
et mesure le temps d'exécution des trois versions du tri fusion sur chaque tableau. Les résultats sont
affichés à la fin de l'exécution du programme.

Notez que la fonction `random_array` génère des entiers aléatoires compris entre 0 et 999 inclus pour
remplir les tableaux. Vous pouvez modifier cette fonction pour utiliser une plage de valeurs différentes si
nécessaire.