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. Начните с двух комбинаций монет

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);

В2. Начните с 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' ]
]
*/

Q3. Расположение сидений

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) ,
  ['b2', 'b1', 'g1'],
  ['b2', 'g1', 'b1'],
  
,
  ['g1', 'b2', 'b1']
]
*/





Q4. Проблема с монетой/суммой
// 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
*/


// Задача о минимальном количестве монет
константная оболочка = (значение) => {
    пусть результат = 99999;
    пусть resultArr = [];
    константные монеты = [10, 6, 1];
    const helper = (значение, метка, комбинированный массив) => {
       если (значение == 0) {
           если (результат > метка) {
               результат = метка;
               resultArr = [...combinedArray]
           }
           возвращаться ;
       }

       for (пусть монета из монет) {
           if (значение - монета >=0) {
               комбинированныйArray.push(монета);
               помощник (ценная монета, метка 1, комбинированный массив);
               комбинированныйArray.pop();
           }
       }
    }

    помощник (значение, 0, []);
    console.log(результатАрр)

    вернуть результат;
};

const res = оболочка (12);

console.log(рез);
/*
[ 6, 6 ]
2
*/





Q5.Генерация набора
// 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
*/


// Проблема 1: создание всех подмножеств набора
// Постановка задачи:
// Учитывая набор уникальных элементов, сгенерируйте все возможные подмножества (набор мощности).
// Это решение требует дальнейшего улучшения.
// Пример:
// Ввод: [1, 2, 3]
// Вывод: [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]


константная оболочка = () => {
    константный результат = [[]];
    константный ввод = [1,2,3];
    input.forEach(item => result.push([item]));

    const helper = (комбинация, глубина) => {
        если (глубина == 2) {
            если (result.indexOf(комбинация) 




Q6. Задача коммивояжера с использованием алгоритма грубой силы
// 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
*/


// Задача коммивояжера с использованием алгоритма брутфорса

функция CalcDistance(матрица, путь) {
  пусть TotalDistance = 0;
  for (пусть я = 0; я  {
      если (глубина == 4) {
          result.push([...комбинация]);

          возвращаться;
      }

      for (пусть элемент arr) {
          если (combination.indexOf(item)  индекс)
  console.log(города)
  const permutations = permute(города);
  console.log(перестановки)
  пусть minDistance = Бесконечность;
  пусть bestPath = [];

  for (пусть путь перестановок) {
    константное расстояние = вычислениеDistance (матрица, путь);
    если (расстояние 




Q7. 0/1 рюкзак Проблема с брутфорсом
// 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
*/


// 0/1 рюкзак Проблема с брутфорсом
function knapsackBruteForce(веса, значения, вместимость) {
  пусть n = Weights.length;
  пусть maxValue = 0;
  const subsetResult = [];
  constbinaryVals = [0, 1];

  // Функция для расчета общего веса и стоимости подмножества
  функцияcultSubset(подмножество) {
    пусть TotalWeight = 0;
    пусть TotalValue = 0;
    for (пусть я = 0; я  {
      если (глубина == 4) {
          subsetResult.push([...комбинация]);
          возвращаться ;
      }

      for (пусть элементbinaryVals) {
          Комбинация.push(предмет);
          помощник(комбинация, глубина 1);
          комбинация.pop()
      }

  }

    помощник([], 0);
    console.log(subsetResult)
  // Генерируем все подмножества, используя двоичное представление
  for (пусть подмножество subsetResult) {
    пусть { TotalWeight, TotalValue } = CalcultSubset (подмножество);
    if (totalWeight  maxValue) {
      максимальное значение = общее значение;
    }
  }

  вернуть максимальное значение;
}

// Пример использования:
константные веса = [2, 3, 4, 5];
константные значения = [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
*/