Merge branch 'DaleStudy:main' into main

Author: sadie100

3sum/soobing3.ts

@@ -0,0 +1,27 @@
+function threeSum(nums: number[]): number[][] {
+  const result: number[][] = []
+
+  nums.sort((a: number, b: number) => a-b);
+  for(let i = 0; i<nums.length; i++) {
+      if (i > 0 && nums[i] === nums[i - 1]) continue;
+      let left = i + 1;
+      let right = nums.length - 1;
+
+      while(left < right) {
+          const sum = nums[i] + nums[left] + nums[right];
+          if(sum === 0) {
+              result.push([nums[i], nums[left], nums[right]])
+              while (left < right && nums[left] === nums[left + 1]) left++;
+              while (left < right && nums[right] === nums[right - 1]) right--;
+
+              left++;
+              right--;
+          } else if(sum < 0) {
+              left++;
+          } else {
+              right--;
+          }
+      }
+  }
+  return result;
+};

climbing-stairs/01-binary.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+
+var climbStairs = function (n) {
+  if (n === 1) return 1;
+  if (n === 2) return 2;
+  const arr = [0, 1, 2];
+  let i = 3;
+  while (i <= n) {
+    const temp = arr[i - 1] + arr[i - 2];
+    arr.push(temp);
+    i++;
+  }
+
+  return arr[n];
+};

climbing-stairs/soobing3.ts

@@ -0,0 +1,14 @@
+function climbStairs(n: number): number {
+  const memo = new Map<number, number>();
+  
+  function dp (n: number): number {
+      if(n <= 1) return 1;
+      if(memo.has(n)) return memo.get(n)!;
+
+      const result = dp(n-1) + dp(n-2);
+      memo.set(n, result);
+      return result;
+  }
+
+  return dp(n);
+};

coin-change/gcount85.py

@@ -0,0 +1,26 @@
+"""
+# Intuition
+dp[n]은 n원을 만드는데 필요한 최소 동전 개수
+e.g. n = 11일 때, 11원을 만들기 위한 최소 동전 개수는 11에서 coins의 원소를 뺀 dp 값 + 1이다.
+
+# Complexity
+- Time complexity: O(amount * coins.length)인데, coins 배열 길이가 상수라서 무시 => O(amount)
+
+- Space complexity: dp 배열 생성으로 O(amount)
+"""
+
+
+class Solution:
+    def coinChange(self, coins: list[int], amount: int) -> int:
+        coins.sort()
+        INF = float("inf")
+        dp = [INF] * (amount + 1)
+        dp[0] = 0
+        for i in range(amount + 1):
+            if dp[i] == INF:
+                continue
+            for c in coins:
+                if i + c > amount:
+                    break
+                dp[i + c] = min(dp[i + c], dp[i] + 1)
+        return dp[-1] if dp[-1] != INF else -1

coin-change/hwi-middle.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int coinChange(vector<int>& coins, int amount) {
+        if (amount < 1)
+        {
+            return 0;
+        }
+
+        vector<int> v(amount);
+        return solve(coins, amount, v);
+    }
+
+    int solve(vector<int>& coins, int amount, vector<int>& count)
+    {
+        if (amount < 0) return -1;
+        if (amount == 0) return 0;
+        if (count[amount - 1] != 0) return count[amount - 1];
+
+        int min = INT_MAX;
+        for (int coin : coins) 
+        {
+            int res = solve(coins, amount - coin, count); // coin을 사용
+            if (res >= 0 && res < min) // 결과가 유효하고 현재 최솟값보다 작으면 업데이트
+            {
+                min = res + 1; // coin을 미리 사용하고 찾은 값이므로 1 더함
+            }
+        }
+
+        count[amount - 1] = (min == INT_MAX) ? -1 : min;
+        return count[amount - 1];
+  }
+};

coin-change/liza0525.py

@@ -0,0 +1,38 @@
+# 7기 풀이
+# 시간 복잡도: O(n * k)
+#  - 타겟 코인 값(amount, 복잡도 계산에선 n으로 표기)과 coins의 길이 만큼 탐색하며 계산
+# 공간 복잡도: O(n)
+#  - 타겟 코인 값(amount, 복잡도 계산에선 n으로 표기) 만큼의 min_coin_count 계산 array를 생성
+class Solution:
+    # 해당 문제는 현재 갖고 있는 돈으로 각 코인 값을 만드는 데에 동전을 얼마나 쓰는지 계산하여
+    # 그 조합 중 가장 작은 값을 계속 찾아가는 문제로, min_coin_count를 사용한다. 
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        min_coin_count = [-1 for _ in range(amount + 1)]  # 각 인덱스는 코인 값, value는 해당 코인 값을 만들 수 있는 동전의 개수(만들 수 없을 땐 -1)
+        min_coin_count[0] = 0  # 코인 값이 0일 때는 동전을 쓰지 않으면 되므로 무조건 0이 된다.
+
+        for target_amount in range(1, len(min_coin_count)):
+            # 각 코인 값에 대해 최소 동전 개수를 찾는다.
+            for coin in coins:
+                if target_amount - coin < 0:
+                    # 대상 코인 값보다 체크할 코인 값이 큰 경우에는 조합을 만들 수 없으므로 넘긴다
+                    continue
+                if min_coin_count[target_amount - coin] < 0:
+                    # target_amount - coin(보수)을 만들 수 없으면 target_amount도 만들 수 없음
+                    # 예시) target=5, coin=3 → 보수 2를 못 만들면 5도 못 만듦
+                    continue
+
+                # 위 두 가지 조건만 넘어가면 동전 개수를 min_coin_count[target_amount]에 정해서 넣을 수 있다는 의미
+                if min_coin_count[target_amount] == -1:
+                    # 값이 -1인 경우에는 처음으로 계산해서 넣는 것이기 때문에
+                    # min_coin_count[target_amount - coin]에다가 1을 더해서(coin 한 개를 추가 한다는 의미) min_coin_count[target_amount]에 할당
+                    min_coin_count[target_amount] = min_coin_count[target_amount - coin] + 1
+                else:
+                    # 값이 -1이 아닌 경우는 이전에 저장된 동전 개수가 있으므로
+                    # 이전 결과 값과 min_coin_count[target_amount - coin] + 1의 값을 비교하여 더 적은 수를 저장한다.
+                    min_coin_count[target_amount] = min(
+                        min_coin_count[target_amount],
+                        min_coin_count[target_amount - coin] + 1
+                    )
+
+        # 모두 계산한 후 min_coin_count[amount]를 반환한다. (== amount를 만드는 동전의 최소 개수)
+        return min_coin_count[amount]

combination-sum/Cyjin-jani.js

@@ -0,0 +1,24 @@
+// ! 나중에 다시 풀어야 할 문제
+//! 30분 내에 풀지 못해서 AI의 도움을 받아 구현했습니다..
+// recursion의 사용, 종료 조건 등 어느정도 근접한 아이디어를 구현했지만,
+// idx를 넘기지 않고 number를 직접 넘기려고 했던 부분이나, results pop을 놓쳤던 부분 등이 있습니다.
+const combinationSum = function (candidates, target) {
+  const answer = [];
+
+  function recursion(idx, target, results = []) {
+    if (target === 0) {
+      answer.push([...results]);
+      return;
+    }
+    if (target < 0) return;
+
+    for (let i = idx; i < candidates.length; i++) {
+      results.push(candidates[i]);
+      recursion(i, target - candidates[i], results);
+      results.pop();
+    }
+  }
+  recursion(0, target, []);
+
+  return answer;
+};

combination-sum/YOOHYOJEONG.py

@@ -0,0 +1,31 @@
+# https://leetcode.com/problems/combination-sum/
+
+# for문으로 해결이 되지 않아 gpt 도움을 받아 해결하였습니다.
+# 같은 숫자를 재사용하면서, 순서를 고정해서 중복 없는 조합을 DFS로 탐색하는 구조
+# 시간 복잡도 : O(2^n) (백트래킹 탐색)
+# 공간 복잡도 : O(target) (재귀 깊이)
+
+class Solution(object):
+    def combinationSum(self, candidates, target):
+        
+        result = []
+
+        def dfs(start, path, total):
+            # 종료 조건 1 : target을 맞춘 경우
+            if total == target:
+                result.append(path[:])
+                return
+            
+            # 종료 조건 2 : target 초과한 경우
+            if total > target:
+                return
+            
+            # 후보 탐색 -> 같은 방향으로만 탐색
+            for i in range(start, len(candidates)):
+                # 같은 숫자 재사용 가능 -> i를 그대로 넘기기
+                dfs(i, path+[candidates[i]], total+candidates[i])   # 새로운 리스트 만들어서 전달
+            
+        
+        dfs(0, [], 0)
+
+        return result

combination-sum/dohyeon2.java

@@ -0,0 +1,30 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    // TC : O(n!) => TC : O(2^T)
+    // SC : O(n^2) => SC : O(T)
+    ArrayList<List<Integer>> result = new ArrayList<>();
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        backtrack(0, target, candidates, new ArrayList<>());
+        return result;
+    }
+
+    private void backtrack(int start, int diff, int[] candidates, ArrayList<Integer> path) {
+        if (diff == 0) {
+            result.add(new ArrayList<>(path)); // 깊은 복사
+            return;
+        }
+
+        if (diff < 0) {
+            return;
+        }
+
+        for (int i = start; i < candidates.length; i++) {
+            path.add(candidates[i]);
+            backtrack(i, diff - candidates[i], candidates, path);
+            path.remove(path.size() - 1);
+        }
+    }
+}

combination-sum/gcount85.py

@@ -0,0 +1,37 @@
+"""
+# Intuition
+backtracking
+
+# Complexity
+- Time complexity: N을 깊이만큼 곱한다. 따라서 아래와 같을 때, O(N^(T/M))
+    N = candidates 개수
+    T = target
+    M = candidates 중 최소값
+
+- Space complexity: O(T/M)
+"""
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        candidates.sort()
+        answer = []
+        output = []
+
+        def dfs(cur_i, cur_sum):
+            if cur_sum == target:
+                answer.append(output[:])
+                return
+
+            for i in range(cur_i, len(candidates)):
+                num = candidates[i]
+
+                if cur_sum + num > target:
+                    break
+
+                output.append(num)
+                dfs(i, cur_sum + num)
+                output.pop()
+
+        dfs(0, 0)
+        return answer