Merge branch 'DaleStudy:main' into main

coin-change/EcoFriendlyAppleSu.kt

@@ -0,0 +1,40 @@
+package leetcode_study
+
+/*
+* 주어진 동전의 종류와 개수를 사용하여 주어진 금액을 만들 때, 중복을 허용한 최소 동전 개수를 구하는 문제
+* 너비 우선 탐색을 사용해 문제 해결
+* 시간 복잡도: O(n)
+* -> queue 자료구조에서 각 동전(n)을 꺼내고 목표 금액(amount == k)까지 도달하는 경우: O(n * k)
+* 공간 복잡도: O(k)
+* -> 동전 사용 횟수를 저장하는 board의 크기
+* */
+fun coinChange(coins: IntArray, amount: Int): Int {
+    if (amount == 0) return 0
+    if (coins.isEmpty() || coins.any { it <= 0 }) return -1
+
+    val board = IntArray(amount + 1) { -1 }
+    val queue = ArrayDeque<Int>()
+
+    for (coin in coins) {
+        if (coin <= amount) {
+            queue.add(coin)
+            board[coin] = 1 // 동전 하나로 구성 가능
+        }
+    }
+
+    while (queue.isNotEmpty()) {
+        val currentPosition = queue.pollFirst()
+        for (coin in coins) {
+            val nextPosition = currentPosition + coin
+            if (nextPosition in 1..amount) {
+                // 아직 방문하지 않았거나 더 적은 동전으로 구성 가능하면 업데이트
+                if (board[nextPosition] == -1 || board[nextPosition] > board[currentPosition] + 1) {
+                    queue.add(nextPosition)
+                    board[nextPosition] = board[currentPosition] + 1
+                }
+            }
+        }
+    }
+
+    return board[amount]
+}

coin-change/GangBean.java

@@ -0,0 +1,31 @@
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        /**
+        1. understanding
+        - given coins that can be used, find the minimum count of coins sum up to input amount value.
+        - [1,2,5]: 11
+            - 2 * 5 + 1 * 1: 3 -> use high value coin as much as possible if the remain can be sumed up by remain coins.
+        2. strategy
+        - If you search in greedy way, it will takes over O(min(amount/coin) ^ N), given N is the length of coins.
+        - Let dp[k] is the number of coins which are sum up to amount k, in a given coin set.
+        - Then, dp[k] = min(dp[k], dp[k-coin] + 1)
+        3. complexity
+        - time: O(CA), where C is the length of coins, A is amount value
+        - space: O(A), where A is amount value
+        */
+
+        int[] dp = new int[amount + 1];
+        for (int i = 1; i <= amount; i++) {
+            dp[i] = amount + 1;
+        }
+
+        for (int coin: coins) { // O(C)
+            for (int k = coin; k <= amount; k++) { // O(A)
+                dp[k] = Math.min(dp[k], dp[k-coin] + 1);
+            }
+        }
+
+        return (dp[amount] >= amount + 1) ? -1 : dp[amount];
+    }
+}
+

coin-change/HerrineKim.js

@@ -0,0 +1,21 @@
+// 시간 복잡도: O(n * m)
+// 공간 복잡도: O(n)
+
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+var coinChange = function(coins, amount) {
+  const dp = new Array(amount + 1).fill(Infinity);
+  dp[0] = 0;
+
+  for (let coin of coins) {
+      for (let i = coin; i <= amount; i++) {
+          dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+      }
+  }
+
+  return dp[amount] === Infinity ? -1 : dp[amount];
+};
+

coin-change/HodaeSsi.py

@@ -0,0 +1,17 @@
+# space complexity: O(n) (여기서 n은 amount)
+# time complexity: O(n * m) (여기서 n은 amount, m은 coins의 길이)
+from typing import List
+
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        dp = [float('inf')] * (amount + 1)
+        dp[0] = 0
+
+        for i in range(1, amount + 1):
+            for coin in coins:
+                if coin <= i:
+                    dp[i] = min(dp[i], dp[i - coin] + 1)
+
+        return dp[amount] if dp[amount] != float('inf') else -1
+

coin-change/Jeehay28.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+
+// TC : O(c*a), where c is the number of coins, and a is amount
+// SC : O(a) // dp array requires O(a) space
+
+var coinChange = function (coins, amount) {
+  // dynamic programming approach
+
+  // dp[amount] : the minimum number of coins
+  // as a default, dp[0] = 0, for other amounts, dp[amount] = amount + 1 ()
+  // [0, amount+1, amount+1, ...]
+  const dp = [0, ...new Array(amount).fill(amount + 1)];
+
+  // start from coin because i - coin >= 0
+  for (const coin of coins) {
+    for (let i = coin; i <= amount; i++) {
+      // dp[i] : not using the current coin
+      // dp[i - coin] + 1 : using the current coin
+      dp[i] = Math.min(dp[i - coin] + 1, dp[i]);
+    }
+  }
+
+  // dp[amount] === amount + 1 : that amount of money cannot be made up by any combination of the coins
+  return dp[amount] < amount + 1 ? dp[amount] : -1;
+};
+
+

coin-change/KwonNayeon.py

@@ -0,0 +1,30 @@
+"""
+Constraints:
+1. 1 <= coins.length <= 12
+2. 1 <= coins[i] <= 2^31 - 1
+3. 0 <= amount <= 10^4
+
+Time Complexity: O(N*M) 
+- N은 amount
+- M은 동전의 개수 (coins.length)
+
+Space Complexity: O(N) 
+- N은 amount
+
+To Do:
+- DP 문제 복습하기
+- Bottom-up과 Top-down 방식의 차이점 이해하기
+- 그리디와 DP의 차이점 복습하기
+"""
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        dp = [sys.maxsize // 2] * (amount + 1)
+        dp[0] = 0
+
+        for i in range(1, amount + 1):
+            for coin in coins:
+                if i >= coin:
+                    dp[i] = min(dp[i], dp[i-coin] + 1)
+
+        return dp[amount] if dp[amount] != sys.maxsize // 2 else -1

coin-change/YeomChaeeun.ts

@@ -0,0 +1,20 @@
+/**
+ * 동전들로 금액을 만들때 필요한 최소 동전의 개수 찾기
+ * 알고리즘 복잡도
+ * - 시간 복잡도: O(nxm) 동전의 개수 x 만들어야하는 금액의 크기
+ * - 공간 복잡도: O(m) 주어진 금액에 비례함
+ * @param coins
+ * @param amount
+ */
+function coinChange(coins: number[], amount: number): number {
+    const dp = new Array(amount + 1).fill(amount + 1)
+    dp[0] = 0 // 0원은 0개
+
+    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 ? -1 : dp[amount]
+}

coin-change/Yjason-K.ts

@@ -0,0 +1,46 @@
+/**
+ * 가지고 있는 동전을 최대한 활용하여 최소의 조합으로 amount를 만드는 최소 동전 개수 구하는 함수
+ * 
+ * @param {number[]} coins  - 사용 가능한 동전 배열
+ * @param {number} amount - 만들어야 하는 총합
+ * @returns {number}
+ * 
+ * 시간 복잡도 O(n * m)
+ *   - n은 동전 배열의 크기
+ *   - m은 amount
+ * 
+ * 공간 복잡도 (n);
+ *  - 큐에 최대 n개의 요소가 들어갈 수 있음
+ */
+function coinChange(coins: number[], amount: number): number {
+    // 총합이 0인 경우 0 반환
+    if (amount === 0) return 0;
+
+    // 너비 우선 탐색을 활용한 풀이
+
+    const queue: [number, number] [] = [[0, 0]]; // [현재 총합, 깊이]
+    const visited = new Set<number>();
+
+    while (queue.length > 0) {
+        const [currentSum, depth] = queue.shift()!;
+
+        // 동전을 하나씩 더해서 다음 깊이을 탐색
+        for (const coin of coins) {
+            const nextSum = currentSum + coin;
+
+            // 목표 금액에 도달하면 현재 깊이를 반환
+            if (nextSum === amount) return depth + 1;
+
+            // 아직 총합에 도달하지 않았고, 중복되지 않아 탐색 가능한 경우
+            if (nextSum < amount && !visited.has(nextSum)) {
+                queue.push([nextSum, depth + 1]);
+                visited.add(nextSum)
+            }
+
+        }
+    }
+
+    // 탐색 조건을 완료 해도 경우의 수를 찾지 못한 경우
+    return -1;
+}
+

coin-change/dusunax.py

@@ -0,0 +1,49 @@
+'''
+# 322. Coin Change
+
+use a queue for BFS & iterate through the coins and check the amount is down to 0.
+use a set to the visited check.
+
+## Time and Space Complexity
+
+```
+TC: O(n * Amount)
+SC: O(Amount)
+```
+
+#### TC is O(n * Amount):
+- sorting the coins = O(n log n)
+- reversing the coins = O(n)
+- iterating through the queue = O(Amount)
+- iterating through the coins and check the remaining amount is down to 0 = O(n)
+
+#### SC is O(Amount):
+- using a queue to store (the remaining amount, the count of coins) tuple = O(Amount)
+- using a set to store the visited check = O(Amount)
+'''
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        if amount == 0:
+            return 0
+        if len(coins) == 1 and coins[0] == amount:
+            return 1
+
+        coins.sort() # TC: O(n log n)
+        coins.reverse() # TC: O(n)
+
+        queue = deque([(amount, 0)]) # SC: O(Amount)
+        visited = set() # SC: O(Amount)
+
+        while queue: # TC: O(Amount)
+            remain, count = queue.popleft()
+
+            for coin in coins: # TC: O(n)
+                next_remain = remain - coin
+
+                if next_remain == 0:
+                    return count + 1
+                if next_remain > 0 and next_remain not in visited:
+                    queue.append((next_remain, count + 1))
+                    visited.add(next_remain)
+
+        return -1

coin-change/ekgns33.java

@@ -0,0 +1,48 @@
+/*
+input : array of integers each element represents coins, single integer amount
+output : fewest number of coin to make up the amount
+constraint
+1) elements are positive?
+yes
+2) coins are in integer range?
+yes
+3) range of amoutn
+integer range?
+[0, 10^4]
+4) at least one valid answer exists?
+nope. if there no exist than return -1
+
+edge. case
+1) if amount == 0 return 0;
+
+ solution 1) top-down approach
+
+amount - each coin
+    until amount == 0
+    return min
+tc : O(n * k) when n is amount, k is unique coin numbers
+sc : O(n) call stack
+
+solution 2) bottom-up
+tc : O(n*k)
+sc : O(n)
+let dp[i] the minimum number of coins to make up amount i
+
+ */
+class Solution {
+  public int coinChange(int[] coins, int amount) {
+    //edge
+    if(amount == 0) return 0;
+    int[] dp = new int[amount+1];
+    dp[0] = 0;
+    for(int i = 1; i<= amount; i++) {
+      dp[i] = amount+1;
+      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];
+  }
+}

coin-change/forest000014.java

@@ -0,0 +1,28 @@
+/* 
+Time Complexity: O(coins.length * amount)
+Space Complexity: O(amount)
+
+1 ~ i-1원까지의 최적해를 알고 있다면, i원의 최적해를 구할 때 coins 배열 iteration으로 구할 수 있음
+*/
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        int c = coins.length;
+
+        int[] dp = new int[amount + 1];
+        Arrays.fill(dp, 99999);
+        dp[0] = 0;
+
+        for (int i = 1; i <= amount; i++) {
+            for (int j = 0; j < c; j++) {
+                if (i - coins[j] < 0) {
+                    continue;
+                }
+                if (dp[i - coins[j]] >= 0 && dp[i - coins[j]] + 1 < dp[i]) {
+                    dp[i] = dp[i - coins[j]] + 1;
+                }
+            }
+        }
+
+        return dp[amount] == 99999 ? -1 : dp[amount];
+    }
+}

coin-change/gmlwls96.kt

@@ -0,0 +1,25 @@
+class Solution {
+    // 알고리즘 : dp
+    /** 풀이
+     * dp배열에 최소한의 동전의 개수를 저장.
+     * dp[i] = min(dp[i - 동전값], dp[i]) 중 더 작은값이 최소 동전의 개수.
+     * */
+    // 시간 : O(coins.len*amount), 공간 : O(amount)
+    fun coinChange(coins: IntArray, amount: Int): Int {
+        val initValue = Int.MAX_VALUE / 2
+        val dp = IntArray(amount + 1) { initValue }
+        dp[0] = 0
+        for (i in 1..amount) {
+            coins.forEach { c ->
+                if (c <= i) {
+                    dp[i] = min(dp[i - c] + 1, dp[i])
+                }
+            }
+        }
+        return if (dp[amount] == initValue) {
+            -1
+        } else {
+            dp[amount]
+        }
+    }
+}