Merge branch 'DaleStudy:main' into main

Author: eunhwa99

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/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/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/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]
+        }
+    }
+}

coin-change/imsosleepy.java

@@ -0,0 +1,21 @@
+// 비슷한 문제를 푼 적이 있어서 쉽게 해결
+// https://www.acmicpc.net/problem/2294
+// O(N * amount) 시간복잡도가 배열 크기와 amount에 종속된다.
+// dp[N]만 사용하므로 공간복잡도는 O(N)
+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) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+
+        return dp[amount] > amount ? -1 : dp[amount];
+    }
+}

coin-change/sungjinwi.py

@@ -0,0 +1,39 @@
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        """
+        Intuition:
+            dp 배열에 이전 금액에 대한 최소 개수를 저장해두고
+            갱신하는 방식으로 작동한다.
+
+            for 루프를 돌면서 현재 가격에서 coin만큼의 가격을
+            뺐을 때 거슬러줄 수 있다면, 그 값에서 1개를 더해준
+            개수를 prev_coins에 저장한다.
+
+            이후 prev_coins가 존재하면 현재 인덱스에서 거슬러줄 수 있는
+            동전의 최소 개수를 갱신한다.
+
+        Time Complexity:
+            O(amount x coins.length):
+                amount 만큼 루프를 순회하는데 각 루프마다
+                coins.length 만큼 prev_coins 배열을 만든다.
+
+        Space Complexity:
+            O(amount):
+                amount만큼의 크기를 가지는 dp 배열을 저장한다.
+        """
+        dp = [0 for _ in range(amount + 1)]
+
+        for coin in coins:
+            if coin <= amount:
+                dp[coin] = 1
+
+        for i in range(1, amount + 1):
+            if dp[i]:
+                continue
+
+            prev_coins = [dp[i - coin] + 1 for coin in coins if i >= coin and dp[i - coin] > 0]
+            if prev_coins:
+                dp[i] = min(prev_coins)
+
+        answer = -1 if amount > 0 and dp[amount] == 0 else dp[amount]
+        return answer

coin-change/thispath98.py

@@ -0,0 +1,73 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        /**
+        1. understanding
+        - merge 2 sorted linked list
+        2. strategy
+        - assign return ListNode
+        - for each node, started in head, compare each node's value, and add smaller value node to return node, and move the node's head to head.next
+        3. complexity
+        - time: O(N + M), N is the length of list1, M is the length of list2
+        - space: O(1), exclude the return variable 
+        */
+        ListNode curr = null;
+        ListNode ret = null;
+
+        while (list1 != null && list2 != null) {
+            if (list1.val < list2.val) {
+                ListNode node = new ListNode(list1.val);
+                if (ret == null) {
+                    ret = node;
+                } else {
+                    curr.next = node;
+                }
+                list1 = list1.next;
+                curr = node;
+            } else {
+                ListNode node = new ListNode(list2.val);
+                if (ret == null) {
+                    ret = node;
+                } else {
+                    curr.next = node;
+                }
+                list2 = list2.next;
+                curr = node;
+            }
+        }
+
+        while (list1 != null) {
+            ListNode node = new ListNode(list1.val);
+            if (ret == null) {
+                ret = node;
+            } else {
+                curr.next = node;
+            }
+            list1 = list1.next;
+            curr = node;
+        }
+
+        while (list2 != null) {
+            ListNode node = new ListNode(list2.val);
+            if (ret == null) {
+                ret = node;
+            } else {
+                curr.next = node;
+            }
+            list2 = list2.next;
+            curr = node;
+        }
+
+        return ret;
+    }
+}
+