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。座位安排

const 包装 = () => {
    常量结果 = [];
    常量组 = ['b1', 'b2', 'g1']
    const helper = (组合, 深度) => {
        如果（深度==3）{
            结果.push([...组合]);
            返回;
        }

        for（让组中的项目）{
            if (combination.indexOf(item) 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) 
Q4。硬币/总和问题

//最小硬币问题
const 包装器 = (值) => {
    让结果= 99999；
    让 resultArr = [];
    常量硬币 = [10, 6, 1];
    const helper = (值, 标签, 组合数组) => {
       如果（值==0）{
           如果（结果>标签）{
               结果=标签；
               resultArr = [...组合数组]
           }
           返回 ;
       }

       对于（让硬币的硬币）{
           if (价值 - 硬币 >=0) {
               组合数组.push(硬币);
               helper(价值币,标签1,combinedArray);
               组合数组.pop();
           }
       }
    }

    助手（值，0，[]）；
    console.log(结果Arr)

    返回结果；
};

const res = 包装器(12);

控制台.log(res);
/*
[ 6, 6 ]
2
*/
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) 
Q5.集合生成

//问题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）{
            if (结果.indexOf(组合) 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) 
Q6.使用暴力算法的旅行推销员问题

//使用暴力算法的旅行推销员问题

函数计算距离（矩阵，路径）{
  让总距离= 0；
  for (让 i = 0; i  {
      如果（深度==4）{
          结果.push([...组合]);

          返回;
      }

      for (let item of arr) {
          if (combination.indexOf(item)  索引)
  console.log(城市)
  const 排列 = 排列（城市）；
  console.log（排列）
  让 minDistance = 无穷大；
  让最佳路径= [];

  for (让排列路径) {
    const距离=计算距离（矩阵，路径）；
    如果（距离 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) Q7。 0/1背包蛮力问题

// 0/1 背包蛮力问题
函数 knapsackBruteForce（权重，值，容量）{
  让 n = 权重.长度；
  让 maxValue = 0;
  const 子集结果 = [];
  const 二进制值 = [0, 1];

  // 计算子集总权重和价值的函数
  函数计算子集（子集）{
    让总权重 = 0;
    让总价值 = 0;
    for (令 i = 0; i  {
      如果（深度==4）{
          subsetResult.push([...组合]);
          返回 ;
      }

      for (让binaryVals项) {
          组合.push(item);
          helper(组合，深度1)；
          组合.pop()
      }

  }

    助手（[]，0）；
    console.log(子集结果)
  // 使用二进制表示生成所有子集
  for（让subsetResult的子集）{
    让 { 总权重，总值 } = 计算子集（子集）；
    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
*/