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.Brut Force 알고리즘을 이용한 여행하는 세일즈맨 문제


// Brut Force 알고리즘을 사용한 여행하는 판매원 문제

함수 계산거리(행렬, 경로) {
  totalDistance = 0으로 둡니다.
  for (let i = 0; i  {
      if (깊이 == 4) {
          result.push([...조합]);

          반품;
      }

      for (arr의 항목하자) {
          if (combination.indexOf(item)  인덱스)
  console.log(도시)
  const 순열 = 순열(도시);
  console.log(순열)
  minDistance = 무한대를 설정합니다.
  let bestPath = [];

  for(순열 경로 허용) {
    const 거리 = 계산 거리(행렬, 경로);
    if (거리 



Q7. 0/1 배낭 Brut force 문제


// 0/1 배낭 Brut force 문제
function knapsackBruteForce(가중치, 값, 용량) {
  n = 가중치.길이로 설정;
  maxValue = 0으로 놔두세요;
  const subsetResult = [];
  const BinaryVals = [0, 1];

  // 하위 집합의 전체 무게와 값을 계산하는 함수
  함수 계산하위 집합(하위 집합) {
    totalWeight = 0으로 둡니다.
    totalValue = 0으로 둡니다.
    for (let i = 0; i  {
      if (깊이 == 4) {
          subsetResult.push([...조합]);
          반품 ;
      }

      for(binaryVals의 항목 허용) {
          조합.푸시(항목);
          helper(조합, 깊이 1);
          조합.팝()
      }

  }

    도우미([], 0);
    console.log(subsetResult)
  // 이진 표현을 사용하여 모든 하위 집합을 생성합니다.
  for(subsetResult의 하위 집합 허용) {
    let { totalWeight, totalValue } =calculateSubset(subset);
    if (totalWeight  maxValue) {
      maxValue = 총값;
    }
  }

  최대값을 반환합니다.
}

// 사용 예:
const 가중치 = [2, 3, 4, 5];
const 값 = [3, 4, 5, 6];
const 용량 = 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
*/