1. Vous trouverez ci-dessous quelques exemples qui commencent avec un niveau simple à avancé (problème de voyageur de commerce et problème de sac à dos 0/1)
2. Ces exemples sont basés sur l'algorithme de force brute

Ma note :-

1. Il y a plusieurs inconvénients à cet algorithme de force brute, mais avant de se lancer directement dans la programmation dynamique et d'autres approches
2. vous devriez avoir des idées sur cette approche et vous devez découvrir pourquoi nous avons besoin d'un modèle de programmation dynamique (mémorisation par récursion)

Si vous observez attentivement le modèle de la force brute

const wrapper = (value) => {
    const helper = (combinedArray, depth) => {
       if (depth == 3) {
          // operation
           return ;
       }

       for (let coin of coins) {
           if (value - coin >=0) {
               combinedArray.push(coin);
               helper(combinedArray, label 1);
               combinedArray.pop();
           }
       }
    }

    helper([], 0);
    return result;
};

const res = wrapper(value);
console.log(res);

Q1. Commencez avec 2 combinaisons de pièces

const wrapper = () => {
    const coinSide = ['head', 'tail']
    const result = [];
    const helper = (currentCombination, depth) => {
        if (depth == 2) {
            result.push([...currentCombination]);
            return ;
        }

        for (side of coinSide) {
            currentCombination.push(side);
            helper(currentCombination, depth  1);
            currentCombination.pop()
        }
    }

    helper([], 0);

    return result;
};

const res = wrapper();

console.log(res);

Q2. Commencez avec 3 combinaisons de pièces

const wrapper = () => {
    const coinSide = ['head', 'tail']
    const result = [];
    const helper = (currentCombination, depth) => {
        if (depth == 3) {
            result.push([...currentCombination]);
            return ;
        }

        for (side of coinSide) {
            currentCombination.push(side);
            helper(currentCombination, depth  1);
            currentCombination.pop()
        }
    }

    helper([], 0);

    return result;
};

const res = wrapper();

console.log(res);

/*
[
  [ 'head', 'head', 'head' ],
  [ 'head', 'head', 'tail' ],
  [ 'head', 'tail', 'head' ],
  [ 'head', 'tail', 'tail' ],
  [ 'tail', 'head', 'head' ],
  [ 'tail', 'head', 'tail' ],
  [ 'tail', 'tail', 'head' ],
  [ 'tail', 'tail', 'tail' ]
]
*/

, , ,
,

const wrapper = () => {
    const result = [];
    const group = ['b1', 'b2', 'g1']
    const helper = (combination, depth) => {
        if (depth == 3) {
            result.push([...combination]);
            return;
        }

        for (let item of group) {
            if (combination.indexOf(item) 
]
*/




Q3. Disposition des sièges

// Minimum coin Problem
const wrapper = (value) => {
    let result = 99999;
    let resultArr = [];
    const coins = [10, 6, 1];
    const helper = (value, label, combinedArray) => {
       if (value == 0) {
           if (result > label) {
               result = label;
               resultArr = [...combinedArray]
           }
           return ;
       }

       for (let coin of coins) {
           if (value - coin >=0) {
               combinedArray.push(coin);
               helper(value-coin, label 1, combinedArray);
               combinedArray.pop();
           }
       }
    }

    helper(value, 0, []);
    console.log(resultArr)

    return result;
};

const res = wrapper(12);

console.log(res);
/*
[ 6, 6 ]
2
*/
const wrapper = () => {
    résultat const = [];
    groupe const = ['b1', 'b2', 'g1']
    const helper = (combinaison, profondeur) => {
        si (profondeur == 3) {
            result.push([...combinaison]);
            retour;
        }

        pour (laisser l'élément du groupe) {
            if (combination.indexOf(item) ,
  ,
  ,
  
,
  ,
  
// Problem 1: Generating All Subsets of a Set
// Problem Statement:
// Given a set of unique elements, generate all possible subsets (the power set).
// This solution need more enhancement.
// Example:
// Input: [1, 2, 3]
// Output: [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]


const wrapper = () => {
    const result = [[]];
    const input = [1,2,3];
    input.forEach(item => result.push([item]));

    const helper = (combination, depth) => {
        if (depth == 2) {
            if (result.indexOf(combination) 



Q4. Problème de pièce/somme


// Travelling sales man problem using brut force algorithm

function calculateDistance(matrix, path) {
  let totalDistance = 0;
  for (let i = 0; i  {
      if (depth == 4) {
          result.push([...combination]);

          return;
      }

      for (let item of arr) {
          if (combination.indexOf(item)  index)
  console.log(cities)
  const permutations = permute(cities);
  console.log(permutations)
  let minDistance = Infinity;
  let bestPath = [];

  for (let path of permutations) {
    const distance = calculateDistance(matrix, path);
    if (distance 



Q5.Génération de jeux


// 0/1 knapsack Brut force Problem
function knapsackBruteForce(weights, values, capacity) {
  let n = weights.length;
  let maxValue = 0;
  const subsetResult = [];
  const binaryVals = [0, 1];

  // Function to calculate the total weight and value of a subset
  function calculateSubset(subset) {
    let totalWeight = 0;
    let totalValue = 0;
    for (let i = 0; i  {
      if (depth == 4) {
          subsetResult.push([...combination]);
          return ;
      }

      for (let item of binaryVals) {
          combination.push(item);
          helper(combination, depth  1);
          combination.pop()
      }

  }

    helper([], 0);
    console.log(subsetResult)
  // Generate all subsets using binary representation
  for (let subset of subsetResult) {
    let { totalWeight, totalValue } = calculateSubset(subset);
    if (totalWeight  maxValue) {
      maxValue = totalValue;
    }
  }

  return maxValue;
}

// Example usage:
const weights = [2, 3, 4, 5];
const values = [3, 4, 5, 6];
const capacity = 5;
const maxVal = knapsackBruteForce(weights, values, capacity);

console.log(`The maximum value in the knapsack is: ${maxVal}`);
/*
[
  [ 0, 0, 0, 0 ], [ 0, 0, 0, 1 ],
  [ 0, 0, 1, 0 ], [ 0, 0, 1, 1 ],
  [ 0, 1, 0, 0 ], [ 0, 1, 0, 1 ],
  [ 0, 1, 1, 0 ], [ 0, 1, 1, 1 ],
  [ 1, 0, 0, 0 ], [ 1, 0, 0, 1 ],
  [ 1, 0, 1, 0 ], [ 1, 0, 1, 1 ],
  [ 1, 1, 0, 0 ], [ 1, 1, 0, 1 ],
  [ 1, 1, 1, 0 ], [ 1, 1, 1, 1 ]
]
The maximum value in the knapsack is: 7
*/





Q6.Problème de vendeur itinérant utilisant l'algorithme de force brute


// Problème de vendeur itinérant utilisant l'algorithme de force brute

function calculateDistance (matrice, chemin) {
  soit totalDistance = 0 ;
  pour (soit i = 0; i  {
      si (profondeur == 4) {
          result.push([...combinaison]);

          retour;
      }

      pour (laisser l'élément de l'arr) {
          if (combination.indexOf(item)  index)
  console.log(villes)
  const permutations = permute(villes);
  console.log(permutations)
  laissez minDistance = Infini ;
  laissez bestPath = [];

  pour (laisser le chemin des permutations) {
    const distance = calculateDistance (matrice, chemin);
    si (distance 



Q7. 0/1 sac à dos Force brute Problème


// 0/1 sac à dos Force brute Problème
function knapsackBruteForce (poids, valeurs, capacité) {
  soit n = poids.longueur;
  laissez maxValue = 0 ;
  const sous-ensembleResult = [];
  const binaireVals = [0, 1];

  // Fonction pour calculer le poids total et la valeur d'un sous-ensemble
  fonction calculerSubset(sous-ensemble) {
    soit totalWeight = 0 ;
    soit totalValue = 0 ;
    pour (soit i = 0; i  {
      si (profondeur == 4) {
          subsetResult.push([...combinaison]);
          retour ;
      }

      pour (laisser l'élément de binaireVals) {
          combinaison.push(élément);
          assistant(combinaison, profondeur 1);
          combinaison.pop()
      }

  }

    aide([], 0);
    console.log(subsetResult)
  // Génère tous les sous-ensembles en utilisant la représentation binaire
  for (laisser le sous-ensemble de subsetResult) {
    let { totalWeight, totalValue } = calculateSubset(sous-ensemble);
    if (totalWeight  maxValue) {
      valeur max = valeur totale ;
    }
  }

  renvoyer valeurmax;
}

// Exemple d'utilisation :
poids const = [2, 3, 4, 5] ;
valeurs const = [3, 4, 5, 6] ;
capacité constante = 5 ;
const maxVal = knapsackBruteForce(poids, valeurs, capacité);

console.log(`La valeur maximale dans le sac à dos est : ${maxVal}`);
/*
[
  [ 0, 0, 0, 0 ], [ 0, 0, 0, 1 ],
  [ 0, 0, 1, 0 ], [ 0, 0, 1, 1 ],
  [ 0, 1, 0, 0 ], [ 0, 1, 0, 1 ],
  [ 0, 1, 1, 0 ], [ 0, 1, 1, 1 ],
  [ 1, 0, 0, 0 ], [ 1, 0, 0, 1 ],
  [ 1, 0, 1, 0 ], [ 1, 0, 1, 1 ],
  [ 1, 1, 0, 0 ], [ 1, 1, 0, 1 ],
  [ 1, 1, 1, 0 ], [ 1, 1, 1, 1 ]
]
La valeur maximale dans le sac à dos est : 7
*/