Day26 2Q Jiho

Jiho/Day24/Leetcode_39. Combination Sum.js

@@ -0,0 +1,30 @@
+var combinationSum = function (candidates, target) {
+  const len = candidates.length;
+  let answer = [];
+  let accumulate = [];
+  function backtracking(remain, arr, index) {
+    if (remain === 0) {
+      answer.push(arr);
+      return;
+    }
+    if (index < 0) {
+      return;
+    }
+    const val = candidates[index];
+    const q = Math.floor(remain / val); // q번 만큼 backtracking 해야함
+
+    for (let i = q; i >= 0; i--) {
+      const new_arr = [...arr];
+      for (let j = 0; j < i; j++) {
+        new_arr.push(val);
+      }
+
+      backtracking(remain - i * val, new_arr, index - 1);
+    }
+  }
+
+  backtracking(target, accumulate, len - 1);
+  return answer;
+};
+
+console.log(combinationSum([2], 1));

Jiho/Day24/Leetcode_78. Subsets.js

@@ -0,0 +1,20 @@
+var subsets = function (nums) {
+  let accumulate = [];
+  let answer = [];
+  function backtracking(arr, index) {
+    // 마지막
+    if (index === nums.length) {
+      answer.push(arr);
+      return;
+    }
+    const cpy = [...arr];
+    backtracking(cpy, index + 1);
+    arr.push(nums[index]);
+    backtracking(arr, index + 1);
+  }
+  backtracking(accumulate, 0);
+
+  return answer;
+};
+
+console.log(subsets([1, 2, 3]));

Jiho/Day26/Leetcode_46. Permutations.js

@@ -0,0 +1,26 @@
+var permute = function (nums) {
+  const len = nums.length;
+  const check = new Array(len).fill(false);
+  let answer = [];
+  const backtracking = (row, accumulate) => {
+    // End of DFS
+    if (row === len) {
+      answer.push([...accumulate]);
+      return;
+    }
+    for (let i = 0; i < len; i++) {
+      if (!check[i]) {
+        check[i] = true;
+        accumulate.push(nums[i]);
+        backtracking(row + 1, accumulate);
+        check[i] = false;
+        accumulate.pop();
+      }
+    }
+  };
+
+  backtracking(0, []);
+  return answer;
+};
+
+console.log(permute([1, 2, 3, 4]));

Jiho/Day26/Leetcode_90. Subsets II.js

@@ -0,0 +1,56 @@
+var subsetsWithDup = function (nums) {
+  const len = nums.length;
+
+  let answer = [];
+  const backtracking = (index, accumulate) => {
+    if (index === len) {
+      // #3. 존재 여부 확인
+      const targetMap = getMap(accumulate);
+      let sameExist = false;
+      answer.forEach((ans) => {
+        if (isIdentical(getMap(ans), targetMap)) {
+          sameExist = true;
+        }
+      });
+      sameExist === false ? answer.push([...accumulate]) : undefined;
+
+      return;
+    }
+    // #1. 선택X
+    const arr1 = [...accumulate];
+    // #2. 선택O
+    accumulate.push(nums[index]);
+    const arr2 = [...accumulate];
+
+    backtracking(index + 1, arr1);
+    backtracking(index + 1, arr2);
+  };
+  backtracking(0, []);
+  return answer;
+};
+
+function isIdentical(iMap, tMap) {
+  if (iMap.size !== tMap.size) {
+    return false;
+  }
+  for (let [key, value] of iMap) {
+    if (tMap.has(key)) {
+      if (value !== tMap.get(key)) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function getMap(array) {
+  const map = new Map();
+  for (const elm of array) {
+    map.set(elm, (map.get(elm) | 0) + 1);
+  }
+  return map;
+}
+console.log(subsetsWithDup([0]));