Merge branch 'DaleStudy:main' into main

Author: s0ooo0k

3sum/sora0319.java

@@ -35,3 +35,4 @@ public List<List<Integer>> threeSum(int[] nums) {
     }
 }
 
+

coin-change/devyejin.py

@@ -0,0 +1,46 @@
+# # 중복조합
+# class Solution:
+#     def coinChange(self, coins: List[int], amount: int) -> int:
+#
+#         def backtrack(current, total):
+#             if total == amount:
+#                 return len(current)
+#
+#             if total > amount:
+#                 return float('inf')
+#
+#             min_count = float('inf')
+#             for coin in coins:
+#                 current.append(coin)
+#                 result = backtrack(current, total + coin)
+#                 min_count = min(min_count, result)
+#                 current.pop()
+#
+#             return min_count
+#
+#         ans = backtrack([], 0)
+#         return -1 if ans == float('inf') else ans
+from collections import deque
+from typing import List
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        if amount == 0:
+            return 0
+
+        queue = deque([(0, 0)])
+        visited = set([0])
+
+        while queue:
+            current_amount, count = queue.popleft()
+
+            for coin in coins:
+                new_amount = current_amount + coin
+                if new_amount == amount:
+                    return count + 1
+                if new_amount < amount and new_amount not in visited:
+                    visited.add(new_amount)
+                    queue.append((new_amount, count + 1))
+
+        return -1
+

coin-change/grapefruitgreentealoe.js

@@ -0,0 +1,73 @@
+
+//1. top-down
+var coinChange = function(coins, amount) {
+    if(amount == 0 ) return 0
+    /*
+    점화식 : dp[n] = Math.min(dp[n],dp[n-k]+1)
+    */
+    const dp = new Array(amount+1).fill(Math.pow(10,4));
+    for(let c of coins){
+        dp[c] = 1
+    }
+    function dfs(idx,coin){
+        if(idx + coin > amount) return
+        dp[idx+coin] = Math.min(dp[idx+coin],dp[idx]+1)
+        if(idx + coin == amount){
+            return 
+        }else{
+            for(let c of coins){
+                dfs(idx+coin,c)
+            }
+        }
+    }
+    dfs(0,coins[0])
+
+    if(dp[amount] > amount) return -1
+
+    return dp[amount]
+   
+};
+
+// 타임리밋에 걸린다. dfs의 가지치기가 덜 되어서 그렇다. 
+// 그렇다면, 순차적인 dp를 좀더 활용하는 것이 좋아보인다. 현재로서는 메모이제이션의 이점을 제대로 활용할 수 없어보인다. 
+
+
+
+//2. bottom-up
+var coinChange = function(coins, amount) {
+    coins = coins.filter(x=> x<=amount)
+    if(amount == 0) return 0
+    /*
+    점화식 : dp[n] = Math.min(dp[n],dp[n-k]+1)
+    */
+    const dp = new Array(amount+1).fill(Math.pow(10,4)+1);
+    dp[0] = 0
+    //dfs를 쓰고 싶지 않다면, amount만큼의 for문을 돌면서 dp를 초기화해주면 된다. 
+    for(let i=1; i <amount+1; i++){
+        for(let coin of coins){
+            if(i-coin >= 0){
+                dp[i] = Math.min(dp[i-coin] + 1,dp[i])
+            }
+        }
+    }
+    if(dp[amount] > amount) return -1
+    return dp[amount]
+   
+};
+
+/**
+dfs를 쓰고 싶지 않다면, amount만큼의 for문을 돌면서 dp를 초기화해주면 된다. 
+처음에 coins = coins.filter(x=> x<=amount)
+이렇게 쓴 이유는, amount보다 작은 코인만 필터하여 최적화한다. 
+
+이 문제 풀이 소요시간이 1시간이 넘었는데, 
+그 이유가, i-coin이 아니라, i+coin을 기준을 삼았었다. 
+그러다보니 그러다 보니 각 금액 `i`의 최솟값을 찾기 위해 `dp[i]`를 `dp[i-coin]` 기반으로 갱신해야 한다는 핵심적인 아이디어를 적용하기 어려웠다.
+`dp[i+coin]` 방식으로 접근하면, `dp[i]` 자체가 아직 최적의 상태가 아닌데도 그 값을 기반으로 미래의 `dp[i+coin]`을 업데이트하려 하기 때문에, 정확한 최적해를 찾아내기 어려웠다.
+현재 금액 `i`를 만들기 위한 가장 효율적인 방법을 과거의 `dp[i-coin]`에서 찾는 '바텀업(Bottom-Up)' 방식이 이 문제에 훨씬 적합하다는 것을 깨닫는 데 시간이 걸렸다.
+
+
+
+시간복잡도:  O(n * m)
+공간 복잡도 : O(n)
+ */

coin-change/hoyeongkwak.java

@@ -0,0 +1,21 @@
+/*
+Time Complexity : O(n)
+Space Complexity : O(n) 
+*/
+
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        if (amount == 0) return 0;
+        int[] dp = new int[amount + 1];
+        Arrays.fill(dp, Integer.MAX_VALUE);
+        dp[0] = 0;
+        for (int coin : coins) {
+            for (int i = coin; i <= amount; i++) {
+                if (dp[i - coin] != Integer.MAX_VALUE) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }   
+            }
+        }
+        return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
+    }
+}

coin-change/hu6r1s.py

@@ -0,0 +1,63 @@
+from collections import deque
+
+class Solution:
+    """
+    1. 가장 큰 수부터 차례대로 빼면서 확인 - 틀린 풀이
+    가장 큰 수부터 차례대로 빼면 안되는 경우가 있음
+    coins = [186,419,83,408], amount = 6249
+    이건 419부터 안될때까지 빼는 방식으로 되지 않음, 즉 최적의 금액을 찾아야 함.
+    그리디 같은 문제일 듯
+
+    """
+    """
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        if amount == 0:
+            return 0
+
+        coins.sort(reverse=True)
+        result = 0
+        for coin in coins:
+            while amount >= coin:
+                amount -= coin
+                result += 1
+        
+        if amount:
+            return -1
+        return result
+    """
+    """
+    - BFS를 사용하여 "동전 합"을 0에서 시작해 amount까지 도달하는 최소 단계를 탐색
+    - 큐의 원소: (cnt, total)
+        cnt   : 현재까지 사용한 동전 개수
+        total : 현재까지 만든 합
+    - visited 집합으로 이미 방문한 합을 중복 탐색하지 않게 함
+    - 첫 번째로 amount에 도달하는 순간이 최소 동전 개수 (BFS 특성상)
+    
+    시간 복잡도:
+    - 최악의 경우 모든 합(0 ~ amount)을 탐색하며,
+      각 합에서 최대 len(coins)개의 새로운 상태를 큐에 넣음
+    - O(amount × n), n = len(coins)
+
+    공간 복잡도:
+    - visited 집합: 최대 amount+1 크기
+    - 큐(queue): 최악의 경우 O(amount × n) 상태 저장 가능
+    - O(amount)
+    """
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        def bfs():
+            queue = deque([(0, 0)])
+            visited = set()
+            while queue:
+                cnt, total = queue.popleft()
+                if amount == total:
+                    return cnt
+                if total in visited:
+                    continue
+                visited.add(total)
+
+                for coin in coins:
+                    if coin + total <= amount:
+                        queue.append((cnt + 1, total + coin))
+            return -1
+        
+        return bfs()

coin-change/hyer0705.ts

@@ -0,0 +1,17 @@
+function coinChange(coins: number[], amount: number): number {
+  // dp[i] = i 금액을 만드는 데 필요한 최소 동전의 갯수...
+  const dp: number[] = Array(amount + 1).fill(Infinity);
+  dp[0] = 0;
+
+  for (let i = 1; i <= amount; i++) {
+    let min = Infinity;
+    for (const coin of coins) {
+      if (i >= coin) {
+        min = Math.min(dp[i - coin] + 1, min);
+      }
+    }
+    dp[i] = min;
+  }
+
+  return Number.isFinite(dp[amount]) ? dp[amount] : -1;
+}

coin-change/hyunjung-choi.kt

@@ -0,0 +1,21 @@
+/**
+ * 시간복잡도: O(amount × coins.length)
+ * 공간복잡도: O(amount)
+ */
+
+class Solution {
+    fun coinChange(coins: IntArray, amount: Int): Int {
+        val dp = IntArray(amount + 1) { Int.MAX_VALUE }
+        dp[0] = 0
+
+        for (i in 1..amount) {
+            for (coin in coins) {
+                if (i - coin >= 0 && dp[i - coin] != Int.MAX_VALUE) {
+                    dp[i] = minOf(dp[i], dp[i - coin] + 1)
+                }
+            }
+        }
+
+        return if (dp[amount] == Int.MAX_VALUE) -1 else dp[amount]
+    }
+}

coin-change/jinvicky.java

@@ -0,0 +1,16 @@
+import java.util.Arrays;
+
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        int max=amount+1;
+        int [] dp=new int[amount+1];
+        Arrays.fill(dp,max);
+        dp[0]=0;
+        for(int coin:coins){
+            for(int j=coin;j<=amount;j++){ // coin부터 시작해서 일반 루프보다 성능 향상
+                dp[j]=Math.min(dp[j],dp[j-coin]+1);
+            }
+        }
+        return dp[amount]>amount ? -1:dp[amount];
+    }
+}

coin-change/jun0811.js

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

coin-change/sora0319.java

@@ -19,3 +19,4 @@ public int coinChange(int[] coins, int amount) {
 }
 
 
+