1. 以下は、簡単なレベルから上級レベルまでのいくつかの例です (巡回セールスマン問題と 0/1 ナップザック問題)
2. これらの例は、ブルート フォース アルゴリズムに基づいています

私のメモ:-

1. このブルート フォース アルゴリズムにはいくつかの欠点がありますが、動的プログラミングやその他のアプローチに直接飛び込む前に
2. このアプローチについてアイデアを持っている必要があり、動的プログラミング パターン (再帰記憶) が必要な理由を見つける必要があります

総当たりのパターンをよく観察すると

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. 2 つのコインの組み合わせから始めます

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. 3 つのコインの組み合わせから始めます

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.座席配置

// 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 ラッパー = () => {
    const 結果 = [];
    const グループ = ['b1', 'b2', 'g1']
    const ヘルパー = (組み合わせ、深さ) => {
        if (深さ == 3) {
            result.push([...組み合わせ]);
            戻る;
        }

        for (グループの項目を許可) {
            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.コイン/合計の問題


// 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.セット世代


// 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.総当たりアルゴリズムを使用した巡回セールスマン問題


// ブルート フォース アルゴリズムを使用した巡回セールスマン問題

関数 CalculateDistance(行列, パス) {
  totalDistance = 0 とします。
  for (let i = 0; i  {
      if (深さ == 4) {
          result.push([...組み合わせ]);

          戻る;
      }

      for (arr の項目を許可) {
          if (combination.indexOf(item)  インデックス)
  コンソール.ログ(都市)
  const permutations = permute(都市);
  console.log(順列)
  minDistance = 無限大とします。
  bestPath = []; にします。

  for (置換のパスを許可) {
    const distance = CalculateDistance(行列, パス);
    if (距離 



Q7. 0/1 ナップザック ブルート フォース 問題


// 0/1 ナップサック ブルート フォース 問題
function knapsackBruteForce(重み、値、容量) {
  n = 重み.長さ; とします。
  maxValue = 0 とします。
  const subsetResult = [];
  const binaryVals = [0, 1];

  // サブセットの合計の重みと値を計算する関数
  関数 CalculateSubset(サブセット) {
    totalWeight = 0 とします。
    totalValue = 0 とします。
    for (let i = 0; i  {
      if (深さ == 4) {
          subsetResult.push([...組み合わせ]);
          戻る ;
      }

      for (binaryVals の項目を許可) {
          組み合わせ.プッシュ(アイテム);
          ヘルパー(組み合わせ、深さ 1);
          組み合わせ.ポップ()
      }

  }

    ヘルパー([], 0);
    console.log(サブセット結果)
  // バイナリ表現を使用してすべてのサブセットを生成します
  for (subsetResult のサブセットを許可) {
    let { totalWeight, totalValue } = CalculateSubset(subset);
    if (合計重量  最大値) {
      最大値 = 合計値;
    }
  }

  maxValue を返します。
}

// 使用例:
定数の重み = [2, 3, 4, 5];
const 値 = [3, 4, 5, 6];
定数容量 = 5;
const maxVal = knapsackBruteForce(重み、値、容量);

console.log(`ナップサック内の最大値は ${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 ]
]
ナップザックの最大値は次のとおりです: 7
*/