[재호] WEEK 03 Solutions

climbing-stairs/wogha95.js

@@ -0,0 +1,21 @@
+// DP 활용하였고 메모리 축소를 위해 현재와 직전의 경우의 수만 관리하였습니다.
+// TC: O(N)
+// SC: O(1)
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  let previousStep = 0;
+  let currentStep = 1;
+
+  while (n > 0) {
+    n -= 1;
+    const nextStep = previousStep + currentStep;
+    previousStep = currentStep;
+    currentStep = nextStep;
+  }
+
+  return currentStep;
+};

coin-change/wogha95.js

@@ -0,0 +1,23 @@
+// TC: O(C * A)
+// SC: O(C)
+// C: coins.length, A: amount
+
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+var coinChange = function (coins, amount) {
+  const dp = new Array(amount + 1).fill(Number.MAX_SAFE_INTEGER);
+  dp[0] = 0;
+
+  for (let index = 1; index < amount + 1; index++) {
+    for (const coin of coins) {
+      if (index - coin >= 0) {
+        dp[index] = Math.min(dp[index - coin] + 1, dp[index]);
+      }
+    }
+  }
+
+  return dp[amount] === Number.MAX_SAFE_INTEGER ? -1 : dp[amount];
+};

combination-sum/wogha95.js

@@ -0,0 +1,84 @@
+// 2차
+// 몫을 활용하여 시간복잡도를 줄이고자 하였으나 generateSubResult에서 추가 시간발생으로 유의미한 결과를 발견하지 못했습니다.
+// TC: O(C^2 * T)
+// SC: O(T)
+// C: candidates.length, T: target
+
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function (candidates, target) {
+  const result = [];
+  // 'q' means 'quotient'.
+  const qList = candidates.map((candidate) => Math.floor(target / candidate));
+
+  dfs([], 0);
+
+  return result;
+
+  function dfs(selectedQList, total) {
+    if (total > target) {
+      return;
+    }
+
+    if (total === target) {
+      result.push(generateSubResult(selectedQList));
+      return;
+    }
+
+    const currentIndex = selectedQList.length;
+    for (let q = qList[currentIndex]; q >= 0; q--) {
+      selectedQList.push(q);
+      dfs(selectedQList, total + candidates[currentIndex] * q);
+      selectedQList.pop();
+    }
+  }
+
+  function generateSubResult(selectedQList) {
+    return selectedQList
+      .map((q, index) => new Array(q).fill(candidates[index]))
+      .flat();
+  }
+};
+
+// 1차
+// dfs를 활용하여 각 요소를 추가 -> 재귀 -> 제거 -> 재귀로 순회합니다.
+// TC: O(C^T)
+// SC: O(C)
+// C: candidates.length, T: target
+
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function (candidates, target) {
+  const result = [];
+
+  dfs([], 0, 0);
+
+  return result;
+
+  function dfs(subResult, total, currentIndex) {
+    if (total > target) {
+      return;
+    }
+
+    if (total === target) {
+      result.push([...subResult]);
+      return;
+    }
+
+    if (currentIndex === candidates.length) {
+      return;
+    }
+
+    const candidate = candidates[currentIndex];
+    subResult.push(candidate);
+    dfs(subResult, total + candidate, currentIndex);
+    subResult.pop();
+    dfs(subResult, total, currentIndex + 1);
+  }
+};

product-of-array-except-self/wogha95.js

@@ -0,0 +1,59 @@
+// 좌->우 방향의 누적곱과 우->좌 방향의 누적곱 활용
+// TC: O(N)
+// SC: O(N) (답안을 제외하면 O(1))
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  const result = new Array(nums.length).fill(1);
+
+  let leftToRight = 1;
+  for (let index = 1; index < nums.length; index++) {
+    leftToRight *= nums[index - 1];
+    result[index] *= leftToRight;
+  }
+
+  let rightToLeft = 1;
+  for (let index = nums.length - 2; index >= 0; index--) {
+    rightToLeft *= nums[index + 1];
+    result[index] *= rightToLeft;
+  }
+
+  return result;
+};
+
+// 1차 풀이
+// 0의 갯수가 0개, 1개, 2개인 경우로 나눠서 풀이
+// 0개인 경우, 답안 배열의 원소는 '모든 원소 곱 / 현재 원소'
+// 1개인 경우, 0의 위치한 원소만 '0을 제외한 모든 원소 곱' 이고 그 외 '0'
+// 2개인 경우, 답안 배열의 모든 원소가 '0'
+
+// TC: O(N)
+// SC: O(N)
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  const zeroCount = nums.filter((num) => num === 0).length;
+  if (zeroCount > 1) {
+    return new Array(nums.length).fill(0);
+  }
+
+  const multipled = nums.reduce(
+    (total, current) => (current === 0 ? total : total * current),
+    1
+  );
+
+  if (zeroCount === 1) {
+    const zeroIndex = nums.findIndex((num) => num === 0);
+    const result = new Array(nums.length).fill(0);
+    result[zeroIndex] = multipled;
+    return result;
+  }
+
+  return nums.map((num) => multipled / num);
+};

two-sum/wogha95.js

@@ -0,0 +1,51 @@
+// 2차: index를 값으로 갖는 Map을 활용하여 한번의 순회로 답안 도출
+// TC: O(N)
+// SC: O(N)
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+  const valueIndexMap = new Map();
+
+  for (let index = 0; index < nums.length; index++) {
+    const value = nums[index];
+    const anotherValue = target - value;
+
+    if (valueIndexMap.has(anotherValue)) {
+      return [index, valueIndexMap.get(anotherValue)];
+    }
+
+    valueIndexMap.set(value, index);
+  }
+};
+
+// 1차: 정렬 후 투포인터 활용
+// TC: O(N * logN)
+// SC: O(N)
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+  const sortedNums = nums
+    .map((value, index) => ({ value, index }))
+    .sort((a, b) => a.value - b.value);
+  let left = 0;
+  let right = sortedNums.length - 1;
+
+  while (left < right) {
+    const sum = sortedNums[left].value + sortedNums[right].value;
+    if (sum < target) {
+      left += 1;
+    } else if (sum > target) {
+      right -= 1;
+    } else {
+      return [sortedNums[left].index, sortedNums[right].index];
+    }
+  }
+};