Merge branch 'DaleStudy:main' into main

Author: nowrobin

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/jiji-hoon96.ts

@@ -0,0 +1,5 @@
+function combinationSum(candidates: number[], target: number): number[][] {}
+
+combinationSum([2, 3, 6, 7], 7); // [[2,2,3], [7]]
+combinationSum([2, 3, 5], 8); // [[2,2,2,2],[2,3,3],[3,5]]
+combinationSum([2], 1); // []

combination-sum/ohkingtaek.py

@@ -0,0 +1,25 @@
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        """
+        - 시간복잡도: O(n^2)
+        - 공간복잡도: O(n)
+        DFS 사용
+        1. 모든 조합을 찾기
+        2. 조합을 찾을 때, 중복된 조합을 방지하기
+        """
+        result = []
+
+        def dfs(start, path, total):
+            if total == target:
+                result.append(path[:])
+                return
+            if total > target:
+                return
+
+            for i in range(start, len(candidates)):
+                path.append(candidates[i])
+                dfs(i, path, total + candidates[i])
+                path.pop()
+
+        dfs(0, [], 0)
+        return result

combination-sum/riveroverflows.py

@@ -0,0 +1,33 @@
+class Solution:
+    """
+    TC: O(N^(T/M))
+        - N = len(candidates), T = target, M = min(candidates)
+    SC: O((T/M) * N^(T/M))
+
+    풀이:
+    백트래킹으로 모든 조합을 탐색하되, 중복 조합 방지를 위해
+    start 인덱스를 활용하여 이전 후보는 건너뛰고, 같은 후보는 재사용 허용.
+    path_sum > target이면 가지치기(pruning)하여 불필요한 탐색을 줄임.
+    """
+    def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:
+        answer = []
+
+        def backtrack(start, path, path_sum):
+            if path_sum > target:
+                return
+
+            if path_sum == target:
+                answer.append(path[:])
+                return
+
+            for i in range(start, len(candidates)):
+                candidate = candidates[i]
+                path.append(candidate)
+                path_sum += candidate
+                backtrack(i, path, path_sum)
+                path_sum -= candidate
+                path.pop()
+
+        backtrack(0, [], 0)
+
+        return answer

combination-sum/soobing3.ts

@@ -0,0 +1,19 @@
+function combinationSum(candidates: number[], target: number): number[][] {
+  const result: number[][] = [];
+
+  function backtracking(start: number, current: number[], remaining: number) {
+      if(remaining < 0) return;
+      if(remaining === 0) {
+          result.push([...current]);
+          return;
+      }
+
+      for(let i = start; i < candidates.length; i++) {
+          current.push(candidates[i]);
+          backtracking(i, current, remaining - candidates[i]);
+          current.pop();
+      }
+  }
+  backtracking(0, [], target)
+  return result;
+};

decode-ways/jiji-hoon96.ts

@@ -0,0 +1,5 @@
+function numDecodings(s: string): number {}
+
+numDecodings("12"); // 2
+numDecodings("226"); // 3
+numDecodings("06"); // 0

decode-ways/soobing3.ts

@@ -0,0 +1,14 @@
+function numDecodings(s: string): number {
+  const n = s.length;
+  const dp: number[] = new Array(n + 1).fill(0);
+  dp[0] = 1;
+  dp[1] = s[0] === '0' ? 0 : 1;
+
+  for(let i=2; i<= n; i++) {
+      const one = Number(s[i-1]);
+      const two = Number(s[i-2] + s[i-1]);
+      if(one !== 0) dp[i] += dp[i-1];
+      if(two >= 10 && two <= 26) dp[i] += dp[i-2];
+  }
+  return dp[n];
+};

find-minimum-in-rotated-sorted-array/gcount85.py

@@ -0,0 +1,27 @@
+"""
+# Intuition
+이진탐색으로 찾는다.
+
+# Complexity
+- Time complexity: nums의 길이 N일때, O(logN)
+
+- Space complexity: 재귀스택 O(logN)
+"""
+
+
+class Solution:
+    def findMin(self, nums: list[int]) -> int:
+        l, m, r = 0, len(nums) // 2, len(nums) - 1
+
+        def findMinimum(l, m, r):
+            if l == m or r == m:
+                return min(nums[l], nums[r])
+
+            # 오른쪽 구간
+            if nums[m] > nums[r]:
+                return findMinimum(m, (m + r) // 2, r)
+
+            # 왼쪽 구간
+            return findMinimum(l, (l + m) // 2, m)
+
+        return findMinimum(l, m, r)