Merge branch 'DaleStudy:main' into main

Author: yuseok89

best-time-to-buy-and-sell-stock/alphaorderly.py

@@ -0,0 +1,21 @@
+"""
+Time Complexity: O(n)
+Space Complexity: O(1)
+
+- Single Pass approach
+- Use a variable to store the least price
+- Use a variable to store the maximum profit
+- Update the maximum profit whenever the current price is greater than the least price
+"""
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        N = len(prices)
+
+        least = prices[0]
+        ans = 0
+
+        for i in range(1, N):
+            ans = max(ans, prices[i] - least)
+            least = min(least, prices[i])
+
+        return ans

coin-change/ICE0208.java

@@ -0,0 +1,30 @@
+class Solution {
+    /**
+     * 시간 복잡도: O(amount * coins.length)
+     * 공간 복잡도: O(amount)
+     */
+    public int coinChange(int[] coins, int amount) {
+        // 필요한 동전의 최대 개수는 amount개이므로,
+        // amount + 1은 만들 수 없는 상태를 나타내기에 충분하다.
+        int impossible = amount + 1;
+
+        int[] dp = new int[amount + 1];
+        Arrays.fill(dp, impossible);
+        dp[0] = 0;
+
+        for (int currentAmount = 1; currentAmount <= amount; currentAmount++) {
+            for (int coin : coins) {
+                if (coin > currentAmount) {
+                    continue;
+                }
+
+                dp[currentAmount] = Math.min(
+                    dp[currentAmount],
+                    dp[currentAmount - coin] + 1
+                );
+            }
+        }
+
+        return dp[amount] == impossible ? -1 : dp[amount];
+    }
+}

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/Yiseull.java

@@ -0,0 +1,22 @@
+class Solution {
+
+    private int answer = Integer.MAX_VALUE;
+
+    public int coinChange(int[] coins, int amount) {
+        final int IMPOSSIBLE = amount + 1;
+
+        int[] dp = new int[amount + 1];
+        Arrays.fill(dp, IMPOSSIBLE);
+        dp[0] = 0;
+
+        for (int i = 1; i < amount + 1; i++) {
+            for (int coin : coins) {
+                if (coin <= i) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+
+        return dp[amount] == IMPOSSIBLE ? -1 : dp[amount];
+    }
+}

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/freemjstudio.py

@@ -0,0 +1,22 @@
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        if amount == 0:
+            return 0
+        INF = int(1e9)
+        # dp[n] 은 n 원을 만들기 위한 최소한의 동전 개수를 저장한다.
+        dp = [INF] * (amount + 1)
+        usable_coins = []
+        for coin in coins:
+            if coin == amount:
+                return 1
+            if coin < amount:
+                dp[coin] = 1 # dp[3] = 1
+                usable_coins.append(coin)
+
+        # dp 를 채워나가는 과정
+        for i in range(1, amount+1):
+            for coin in usable_coins:
+                if (i - coin) >= 0 and dp[i - coin] != INF:
+                    dp[i] = min(dp[i - coin] + 1, dp[i])
+
+        return -1 if dp[amount] == INF else dp[amount]

coin-change/j2h30728.ts

@@ -0,0 +1,14 @@
+function coinChange(coins: number[], amount: number): number {
+  const dp = new Array(amount + 1).fill(amount + 1);
+    dp[0] = 0;
+    
+    for (let i = 1; i <= amount; i++) {
+        for (const coin of coins) {
+            if (i - coin >= 0) {
+                dp[i] = Math.min(dp[i], 1 + dp[i - coin]);
+            }
+        }
+    }
+    
+    return dp[amount] > amount ? -1 : dp[amount];
+};

coin-change/jaekwang97.java

@@ -0,0 +1,20 @@
+import java.util.Arrays;
+
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        int[] dp = new int[amount + 1];
+
+        Arrays.fill(dp, amount + 1);
+        dp[0] = 0;
+
+        for (int i = 1; i <= amount; i++) {
+            for (int coin : coins) {
+                if (i - coin >= 0) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+
+        return dp[amount] == amount + 1 ? -1 : dp[amount];
+    }
+}