1. Im Folgenden finden Sie einige Beispiele, die mit einem einfachen bis fortgeschrittenen Level beginnen (Problem des Handlungsreisenden und 0/1-Rucksackproblem)
2. Diese Beispiele basieren auf dem Brute-Force-Algorithmus

Meine Notiz:-

1. Es gibt mehrere Nachteile dieses Brute-Force-Algorithmus, aber bevor wir direkt in die dynamische Programmierung und andere Ansätze einsteigen
2. Sie sollten Ideen zu diesem Ansatz haben und herausfinden, warum wir ein dynamisches Programmiermuster (Rekursionsspeicherung) benötigen

Wenn Sie das Muster für die rohe Gewalt genau beobachten

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. Beginnen Sie mit 2 Münzkombinationen

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. Beginnen Sie mit 3 Münzkombinationen

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' ]
]
*/

, ['Schwanz', 'Kopf', 'Schwanz'], , ] */

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) 



const wrapper = () => {
    const result = [];
    const group = ['b1', 'b2', 'g1']
    const helper = (Kombination, Tiefe) => {
        if (Tiefe == 3) {
            result.push([...kombination]);
            zurückkehren;
        }

        for (lass Element der Gruppe) {
            if (combination.indexOf(item) ,
  
,
  
// 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
*/
,
  
,
  
]
*/





Q4. Münz-/Summenproblem
// 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) 


// Minimales Münzproblem
const wrapper = (Wert) => {
    let result = 99999;
    let resultArr = [];
    const Münzen = [10, 6, 1];
    const helper = (value, label, CombinedArray) => {
       if (Wert == 0) {
           if (Ergebnis > Label) {
               Ergebnis = Etikett;
               resultArr = [...combinedArray]
           }
           zurückkehren ;
       }

       für (sei eine Münze von Münzen) {
           if (Wert - Münze >=0) {
               CombinedArray.push(coin);
               Helfer(Wertmünze, Etikett 1, kombiniertesArray);
               CombinedArray.pop();
           }
       }
    }

    Helfer(Wert, 0, []);
    console.log(resultArr)

    Ergebnis zurückgeben;
};

const res = wrapper(12);

console.log(res);
/*
[ 6, 6 ]
2
*/





Q5.Generierung festlegen
// 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) 


// Problem 1: Alle Teilmengen einer Menge generieren
// Problemstellung:
// Generiere bei einer gegebenen Menge eindeutiger Elemente alle möglichen Teilmengen (die Potenzmenge).
// Diese Lösung benötigt weitere Verbesserungen.
// Beispiel:
// Eingabe: [1, 2, 3]
// Ausgabe: [[], [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 = (Kombination, Tiefe) => {
        if (Tiefe == 2) {
            if (result.indexOf(combination) 




F6.Problem mit reisenden Verkäufern unter Verwendung des Brut-Force-Algorithmus
// 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) 


// Problem mit reisenden Verkäufern unter Verwendung des Brut-Force-Algorithmus

Funktion berechneDistanz(Matrix, Pfad) {
  sei totalDistance = 0;
  for (let i = 0; i  {
      if (Tiefe == 4) {
          result.push([...kombination]);

          zurückkehren;
      }

      for (lassen Sie Element von arr) {
          if (combination.indexOf(item)  index)
  console.log(Städte)
  const permutations = permute(cities);
  console.log(Permutationen)
  sei minDistance = Infinity;
  let bestPath = [];

  for (sei Pfad der Permutationen) {
    const distance = berechneDistanz(Matrix, Pfad);
    if (Distanz 



Q7. 0/1 Rucksack Brut Force Problem



// 0/1 Rucksack Brut-Force-Problem
Funktion knapsackBruteForce(Gewichte, Werte, Kapazität) {
  sei n = Gewichte.Länge;
  sei maxValue = 0;
  const subsetResult = [];
  const binäreVals = [0, 1];

  // Funktion zur Berechnung des Gesamtgewichts und -werts einer Teilmenge
  Funktion berechneSubset(Teilmenge) {
    sei totalWeight = 0;
    sei totalValue = 0;
    for (let i = 0; i  {
      if (Tiefe == 4) {
          subsetResult.push([...kombination]);
          zurückkehren ;
      }

      for (lassen Sie ein Element von BinaryVals) {
          Kombination.push(item);
          Helfer(Kombination, Tiefe 1);
          Kombination.pop()
      }

  }

    Helfer([], 0);
    console.log(subsetResult)
  // Alle Teilmengen mit binärer Darstellung generieren
  for (let subset of subsetResult) {
    let { totalWeight, totalValue } = berechneSubset(subset);
    if (totalWeight  maxValue) {
      maxValue = totalValue;
    }
  }

  return maxValue;
}

// Beispielverwendung:
const-Gewichte = [2, 3, 4, 5];
const-Werte = [3, 4, 5, 6];
konstante Kapazität = 5;
const maxVal = knapsackBruteForce(gewichte, werte, kapazität);

console.log(`Der maximale Wert im Rucksack ist: ${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 ]
]
Der Maximalwert im Rucksack beträgt: 7
*/