Merge branch 'DaleStudy:main' into main

Author: togo26

3sum/seueooo.js

@@ -0,0 +1,37 @@
+/**
+정렬, 투포인터
+정렬 후, 첫 번째 수를 고정하고 나머지 두 수를 투포인터로 탐색
+중복되는 경우는 스킵
+시간 복잡도: O(n^2)
+공간 복잡도: O(n)
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  nums.sort((a, b) => a - b);
+  let n = nums.length;
+  let answer = [];
+  for (let i = 0; i < n - 2; i++) {
+    let l = i + 1;
+    let h = n - 1;
+    if (nums[i] > 0) break;
+    // 중복 제거
+    if (i > 0 && nums[i] === nums[i - 1]) continue;
+
+    while (l < h) {
+      const sum = nums[i] + nums[l] + nums[h];
+      if (sum > 0) {
+        h--;
+      } else if (sum < 0) {
+        l++;
+      } else {
+        answer.push([nums[i], nums[l], nums[h]]);
+        while (l < h && nums[l] === nums[l + 1]) l++;
+        while (l < h && nums[h] === nums[h - 1]) h--;
+        l++;
+        h--;
+      }
+    }
+  }
+  return answer;
+};

climbing-stairs/chapse57.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def climbStairs(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+
+
+        if n == 1:
+            return 1
+        if n == 2:
+            return 2
+        a = 1
+        b = 2                
+
+        for i in range(n - 2):   
+            c = a + b
+            a = b
+            b = c
+        return c
+        

coin-change/JeonJe.java

@@ -0,0 +1,33 @@
+import java.util.*;
+
+// TC: O(n * amount)  (n = coins.length)
+// SC: O(amount)
+class Solution {
+
+    private static final int IMPOSSIBLE = Integer.MAX_VALUE;
+
+    private int[] memo;
+
+    public int coinChange(int[] coins, int amount) {
+        memo = new int[amount + 1];
+        Arrays.fill(memo, -1);
+
+        int result = minCoins(amount, coins);
+        return result == IMPOSSIBLE ? -1 : result;
+    }
+
+    private int minCoins(int target, int[] coins) {
+        if (target == 0) return 0;
+        if (target < 0) return IMPOSSIBLE;
+        if (memo[target] != -1) return memo[target];
+
+        int best = IMPOSSIBLE;
+        for (int coin : coins) {
+            int sub = minCoins(target - coin, coins);
+            if (sub != IMPOSSIBLE) {
+                best = Math.min(best, sub + 1);
+            }
+        }
+        return memo[target] = best;
+    }
+}

coin-change/alphaorderly.py

@@ -0,0 +1,72 @@
+"""
+Time Complexity: O(n * amount)
+Space Complexity: O(n * amount)
+
+- DP / Top-Down approach
+- Use a cache to store the results of the subproblems
+"""
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        LARGE = 10 ** 5
+
+        @cache
+        def dp(coin: int, left: int) -> int:
+            if left == 0:
+                return 0
+
+            if left < 0 or coin >= len(coins):
+                return LARGE
+
+            a = dp(coin, left - coins[coin]) + 1
+            b = dp(coin + 1, left)
+
+            return min(a, b)
+
+        ans = dp(0, amount)
+
+        return ans if ans != LARGE else -1
+
+"""
+Time Complexity: O(n * amount)
+Space Complexity: O(n * amount)
+
+- DP / Bottom-Up approach
+- Use a 2D array to store the results of the subproblems
+"""
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        N = len(coins)
+        dp = [[float('inf')] * (amount + 1) for _ in range(N)]
+
+        for c in range(N):
+            dp[c][0] = 0
+
+            if c > 0:
+                for a in range(amount + 1):
+                    dp[c][a] = dp[c - 1][a]
+
+            for a in range(coins[c], amount + 1):
+                dp[c][a] = min(dp[c][a], dp[c][a - coins[c]] + 1)
+
+        ans = dp[-1][-1]
+
+        return ans if ans != float('inf') else -1
+
+"""
+Time Complexity: O(n * amount)
+Space Complexity: O(amount)
+
+- DP / Bottom-Up approach [Space Optimized]
+- Use a 1D array to store the results of the subproblems
+"""
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        N = len(coins)
+        dp = [float("inf")] * (amount + 1)
+        dp[0] = 0
+
+        for c in range(N):
+            for a in range(coins[c], amount + 1):
+                dp[a] = min(dp[a], dp[a - coins[c]] + 1)
+
+        return dp[-1] if dp[-1] != float("inf") else -1

coin-change/dahyeong-yun.java

@@ -0,0 +1,31 @@
+/**
+ * [풀이 개요]
+ * - 시간복잡도 : O(N * amount) (N: 동전 종류의 개수, 최대 12 * 10,000 = 120,000번 연산)
+ * - 공간복잡도 : O(amount) (DP 테이블 크기)
+ */
+class Solution {
+    /**
+     * [문제 풀이 아이디어]
+     * - amount를 금액이라고 해석했을 때, 금액을 만들 수 있는 최소 코인의 갯수를 구하는 문제.
+     * - 가짓 수를 의미하는 배열을 동해 동적 프로그래밍 방식으로 풀 수 있음.
+     * - 바깥 루프에서는 코인을, 안쪽 루프에서는 수를 차례로 순회함.
+     * - 이때 모든 수에 대해 각 코인으로 만들 수 있는 최저 수를 계산해서 넣고, 코인의 액면 값 만큼 적은 횟수에서 해당 코인을 더해서 만들 수 있는 수와 비교한 최솟값을 구함. 
+     * - 시간 복잡도는 코인의 수 * 금액의 수 이므로, 문제의 제약에 따라 12 * 10,000 = 120000 이 된다.
+     */
+    public int coinChange(int[] coins, int amount) {
+        int[] methods = new int[amount + 1]; // 금액별 코인의 최소 갯수
+        Arrays.fill(methods, amount+1);
+
+        methods[0] = 0; // 금액 0원을 만들기 위해서는 코인을 안쓰면 됨.
+        for(int i=0; i<coins.length; i++) {
+            int coin = coins[i];
+            for(int j=1; j <= amount; j++) {
+                if(j >= coin) {
+                    methods[j] = Math.min(methods[j], methods[j - coin] + 1);
+                }
+            }
+        }
+
+        return methods[amount] == amount + 1 ? -1 :  methods[amount];
+    }
+}

coin-change/dolphinflow86.py

@@ -0,0 +1,19 @@
+# 1) Use top-down memoization, recursively calculate the minimum coins required for each remaining amount and cache the results to prune duplicated branches.
+# TC: O(K^M) where K is the number of coins, where M is the amount. We can recurse down at most M depth
+# SC: O(K + M)
+class Solution:
+    def dfs(self, coins: List[int], memo:Dict[int, int], remain: int):
+        if remain == 0: return 0
+        if remain < 0: return float('inf')
+        if remain in memo: return memo[remain]
+
+        min_result = float('inf')
+        for coin in coins:
+            min_result = min(min_result, self.dfs(coins, memo, remain - coin))
+
+        memo[remain] = min_result if min_result == float('inf') else min_result + 1
+        return memo[remain]
+
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        result = self.dfs(coins, {}, amount)
+        return result if result != float('inf') else -1

coin-change/okyungjin.py

@@ -0,0 +1,43 @@
+# coins: 동전의 가격이 적힌 정수 배열, 각 숫자는 유니크함, 정렬에 대한 언급 X, (1 <= coins.length <= 12)
+# amount: 돈의 총합
+
+# amount를 만들 수 있는 가장 적은 동전의 수를 반환한다.
+# coins로 amount를 만들 수 없는 경우 -1을 반환
+# 동전의 종류는 무한대라고 가정하고 문제를 풀 것
+
+# 처음에는 greedy로 접근하려고 했는데, 금액이 큰 동전을 먼저 선택하는게 최소 동전의 수가 아니라서 dp로 풀이했다.
+
+# [복잡도]
+# C: 코인의 개수, # A: amount
+# 시간 복잡도: O(A * C)
+# 공간 복잡도: O(A)
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        NOT_POSSIBLE = amount + 1
+
+        # min_coins: 금액을 만드는데 필요한 동전 개수를 저장하는 배열
+        # min_coins[i]: i원을 만드는데 필요한 최소 동전의 개수
+        min_coins = [NOT_POSSIBLE] * (amount + 1)
+        min_coins[0] = 0
+
+        # 최적화를 위해 정렬
+        coins.sort()
+        
+        for cur_amount in range(1, amount + 1):
+            # coin: 선택한 동전의 금액
+            for coin in coins:
+                # coins가 정렬되어 있으므로, cur_amount 보다 동전의 금액이 더 크면 이후는 확인 불필요
+                if coin > cur_amount:
+                    break
+                
+                # 둘 중 더 작은 값으로 업데이트
+                # 1. 기존에 구한 개수
+                # 2. 현재 동전을 1개 추가해서 만드는 개수
+                min_coins[cur_amount] = min(min_coins[cur_amount], min_coins[cur_amount - coin] + 1)
+        
+        # 초기화된 값 그대로이면 불가능한 조합이므로 -1 반환
+        if min_coins[amount] == NOT_POSSIBLE:
+            return -1
+        # 최소 동전의 개수를 반환
+        else:
+            return min_coins[amount]

coin-change/yuseok89.py

@@ -0,0 +1,24 @@
+# TC: O(amount * len(coins))
+# SC: O(amount)
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+
+        from collections import deque
+
+        v = {0: 0}
+        q = deque([0])
+
+        while q and amount not in v:
+
+            cur = q.popleft()
+
+            for coin in coins:
+
+                if cur + coin > amount or cur + coin in v:
+                    continue
+
+                v[cur + coin] = v[cur] + 1
+                q.append(cur + coin)
+
+        return -1 if amount not in v else v[amount]
+

combination-sum/Chanz82.py

@@ -0,0 +1,22 @@
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+
+        result = []
+        combination = []
+        def find_target(start, combination, target):
+
+            if target == 0 : # 조합 생성 완료.
+                result.append(combination.copy()) # pop 때문에 복사해서 append해야 함.
+                return
+            
+            elif target < 0 or start >= len(candidates):
+                return
+
+            combination.append(candidates[start])
+            find_target(start, combination, target-candidates[start]) # 현재 원소를 더 뽑는 경우
+            combination.pop() # 현재 원소는 다시 조합에서 제거 후, 다음 원소를 뽑음
+            find_target(start+1, combination, target) # 다음 원소를 뽑는 경우
+
+        find_target(0, combination, target)
+
+        return result

combination-sum/ICE0208.java

@@ -0,0 +1,64 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    /*
+    * [백트래킹 풀이]
+    * N: candidates의 길이
+    * M: candidates에서 가장 작은 값
+    *
+    * 시간 복잡도: O(N^(target / M))
+    * - 재귀 한 단계에서 최대 N개의 후보를 선택할 수 있다.
+    * - 가장 작은 숫자를 반복해서 선택하면 재귀 깊이는 최대 target / M이다.
+    * - 실제로는 startIndex와 가지치기로 인해 이보다 적은 경우만 탐색한다.
+    *
+    * 공간 복잡도: O(target / M)
+    * - 재귀 호출 스택과 현재 조합 리스트가 최대 재귀 깊이만큼 사용된다.
+    * - 반환할 결과 리스트는 제외한다.
+    */
+
+    private int[] candidates;
+    private List<List<Integer>> combinations;
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        this.candidates = candidates;
+        this.combinations = new ArrayList<>();
+
+        findCombinations(0, target, new ArrayList<>());
+
+        return combinations;
+    }
+
+    private void findCombinations(
+            int startIndex,
+            int remainingTarget,
+            List<Integer> currentCombination
+    ) {
+        // 목표 합을 정확히 완성한 경우
+        if (remainingTarget == 0) {
+            combinations.add(new ArrayList<>(currentCombination));
+            return;
+        }
+
+        for (int i = startIndex; i < candidates.length; i++) {
+            int candidate = candidates[i];
+
+            // 현재 숫자를 선택하면 목표 합을 초과하는 경우
+            if (candidate > remainingTarget) {
+                continue;
+            }
+
+            currentCombination.add(candidate);
+
+            // 같은 숫자를 여러 번 사용할 수 있으므로 i부터 다시 탐색한다.
+            findCombinations(
+                    i,
+                    remainingTarget - candidate,
+                    currentCombination
+            );
+
+            // 다음 조합을 탐색하기 위해 현재 선택을 되돌린다.
+            currentCombination.remove(currentCombination.size() - 1);
+        }
+    }
+}