Merge branch 'main' of https://github.com/printjin-gmailcom/Dalle_Code-Leetcode_Study

Author: printjin-gmailcom

climbing-stairs/choidabom.js

@@ -0,0 +1,16 @@
+// https://leetcode.com/problems/climbing-stairs/
+
+// TC: O(N)
+// SC: O(N)
+
+var climbStairs = function (n) {
+  const stairs = [1, 2];
+
+  for (let i = 2; i < n; i++) {
+    stairs[i] = stairs[i - 1] + stairs[i - 2];
+  }
+
+  return stairs[n - 1];
+};
+
+console.log(climbStairs(5));

coin-change/HoonDongKang.ts

@@ -0,0 +1,72 @@
+/**
+ * [Problem]: [322] Coin Change
+ *
+ * (https://leetcode.com/problems/coin-change/description/)
+ */
+function coinChange(coins: number[], amount: number): number {
+    // 시간복잡도: O(c^a)
+    // 공간복잡도: O(a)
+    // Time Exceed
+    function dfsFunc(coins: number[], amount: number): number {
+        if (!amount) return 0;
+        let result = dfs(amount);
+
+        return result <= amount ? result : -1;
+
+        function dfs(remain: number): number {
+            if (remain === 0) return 0;
+            if (remain < 0) return amount + 1;
+
+            let min_count = amount + 1;
+
+            for (let coin of coins) {
+                const result = dfs(remain - coin);
+                min_count = Math.min(min_count, result + 1);
+            }
+
+            return min_count;
+        }
+    }
+    // 시간복잡도: O(ca)
+    // 공간복잡도: O(a)
+    function dpFunc(coins: number[], amount: number): number {
+        const dp = new Array(amount + 1).fill(amount + 1);
+        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] <= amount ? dp[amount] : -1;
+    }
+
+    // 시간복잡도: O(ca)
+    // 공간복잡도: O(a)
+    function memoizationFunc(coins: number[], amount: number): number {
+        const memo: Record<number, number> = {};
+
+        const result = dfs(amount);
+        return result <= amount ? result : -1;
+
+        function dfs(remain: number): number {
+            if (remain === 0) return 0;
+            if (remain < 0) return amount + 1;
+            if (remain in memo) return memo[remain];
+
+            let min_count = amount + 1;
+
+            for (let coin of coins) {
+                const res = dfs(remain - coin);
+                min_count = Math.min(min_count, res + 1);
+            }
+
+            memo[remain] = min_count;
+
+            return min_count;
+        }
+    }
+
+    return memoizationFunc(coins, amount);
+}

coin-change/JEONGBEOMKO.java

@@ -0,0 +1,19 @@
+class Solution {
+    /*
+    time complexity: O(amount × n)
+    space complexity: O(amount)
+    */
+    public int coinChange(int[] coins, int amount) {
+        int[] memo = new int[amount + 1];
+        Arrays.fill(memo, amount + 1); // 초기값: 만들 수 없는 큰 수
+        memo[0] = 0; // 0원을 만들기 위한 동전 수는 0개
+
+        for (int coin : coins) {
+            for (int i = coin; i <= amount; i++) {
+                memo[i] = Math.min(memo[i], memo[i - coin] + 1);
+            }
+        }
+
+        return memo[amount] > amount ? -1 : memo[amount];
+    }
+}

coin-change/Jeehay28.ts

@@ -0,0 +1,72 @@
+// Approach 2: Dynamic Programming
+// // Time Complexity: O(amout * n), where n is the number of coins
+// // Space Complexity: O(amount)
+
+function coinChange(coins: number[], amount: number): number {
+
+    // input: coins = [2, 3, 5], amount = 7
+
+    // initial state dp
+    // 0: 0 
+    // 1: amount + 1 = 8
+    // 2: 8
+    // 3: 8
+    // 4: 8
+    // 5: 8
+    // 6: 8
+    // 7: 8
+
+    // using coin 2
+    // 0: 0 
+    // 1: 8
+    // 2: 8 -> 8 vs dp[2-2] + 1 = 1 -> 1 
+    // 3: 8 -> 8 vs dp[3-2] + 1 = 9 -> 8 
+    // 4: 8 -> 8 vs dp[4-2] + 1 = 2 -> 2
+    // 5: 8 -> 8 vs dp[5-2] + 1 = 9 -> 8
+    // 6: 8 -> 8 vs dp[6-2] + 1 = 3 -> 3
+    // 7: 8 -> 8 vs dp[7-2] + 1 = 9 -> 8
+
+    const dp = Array.from({ length: amount + 1 }, () => amount + 1);
+    dp[0] = 0
+
+    for (const coin of coins) {
+        for (let currentTotal = coin; currentTotal <= amount; currentTotal++) {
+            dp[currentTotal] = Math.min(dp[currentTotal - coin] + 1, dp[currentTotal])
+        }
+    }
+  
+    return dp[amount] > amount ? -1 : dp[amount]
+};
+
+
+// // Approach 1: BFS Traversal
+// // Time Complexity: O(amout * n), where n is the number of coins
+// // Space Complexity: O(amount)
+
+// function coinChange(coins: number[], amount: number): number {
+//   // queue: [[number of coints, current total]]
+//   let queue = [[0, 0]];
+//   let visited = new Set();
+
+//   while (queue.length > 0) {
+//     const [cnt, total] = queue.shift()!;
+
+//     if (total === amount) {
+//       return cnt;
+//     }
+
+//     if (visited.has(total)) {
+//       continue;
+//     }
+//     visited.add(total);
+
+//     for (const coin of coins) {
+//       if (total + coin <= amount) {
+//         queue.push([cnt + 1, total + coin]);
+//       }
+//     }
+//   }
+
+//   return -1;
+// }
+

coin-change/PDKhan.cpp

@@ -0,0 +1,20 @@
+class Solution {
+    public:
+        int coinChange(vector<int>& coins, int amount) {
+            vector<int> dp(amount+1, amount+1);
+    
+            dp[0] = 0;
+            
+            for(int i = 1; i <= amount; i++){
+                for(int j = 0; j < coins.size(); j++){
+                    if(i >= coins[j])
+                        dp[i] = min(dp[i], 1 + dp[i - coins[j]]);
+                }
+            }
+    
+            if(dp[amount] > amount)
+                return -1;
+    
+            return dp[amount];
+        }
+    };

coin-change/Tessa1217.java

@@ -0,0 +1,26 @@
+/**
+ * 정수 배열 coins가 주어졌을 때 amount를 만들 기 위해 최소한의 동전 개수를 반환하세요.
+ 만약 동적으로 amount 조합을 만들어낼 수 없다면 -1을 리턴하세요.
+ */
+import java.util.Arrays;
+
+class Solution {
+
+    // 시간복잡도: O(n * amount), 공간복잡도: O(amount)
+    public int coinChange(int[] coins, int amount) {
+        int[] coinCnt = new int[amount + 1];
+        // coins[i]의 최댓값이 2^31 - 1 이므로 최댓값 설정
+        Arrays.fill(coinCnt, Integer.MAX_VALUE - 1);
+        coinCnt[0] = 0;
+        for (int i = 0; i < coins.length; i++) {
+            for (int j = coins[i]; j < amount + 1; j++) {
+                coinCnt[j] = Math.min(coinCnt[j], coinCnt[j - coins[i]] + 1);
+            }
+        }
+        if (coinCnt[amount] == Integer.MAX_VALUE - 1) {
+            return -1;
+        }
+        return coinCnt[amount];
+    }
+}
+

coin-change/ayosecu.py

@@ -0,0 +1,30 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(CA), C = len(coins), A = amount
+        - Space Complexity: O(A), A = amount
+    """
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        # DP
+        dp = [float("inf")] * (amount + 1)
+        dp[0] = 0   # 0 amount needs 0 coin
+
+        for coin in coins:
+            for i in range(coin, amount + 1):
+                # dp[i] => not use current coin
+                # dp[i - coin] + 1 => use current coin
+                dp[i] = min(dp[i], dp[i - coin] + 1)
+        
+        return dp[amount] if dp[amount] != float("inf") else -1
+
+tc = [
+        ([1,2,5], 11, 3),
+        ([2], 3, -1),
+        ([1], 0, 0)
+]
+
+for i, (coins, amount, e) in enumerate(tc, 1):
+    sol = Solution()
+    r = sol.coinChange(coins, amount)
+    print(f"TC {i} is Passed!" if r == e else f"TC {i} is Failed! - Expected: {e}, Result: {r}")

coin-change/byol-han.js

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+var coinChange = function (coins, amount) {
+  // dp[i]는 금액 i를 만들기 위한 최소 코인 수
+  const dp = new Array(amount + 1).fill(Infinity);
+
+  // 금액 0을 만들기 위해 필요한 코인 수는 0개
+  dp[0] = 0;
+
+  // 1부터 amount까지 반복
+  for (let i = 1; i <= amount; i++) {
+    // 각 금액마다 모든 코인 시도
+    for (let coin of coins) {
+      if (i - coin >= 0) {
+        // 코인을 하나 사용했을 때, 남은 금액의 최소 개수 + 1
+        dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+      }
+    }
+  }
+
+  // 만약 Infinity면 만들 수 없는 금액임
+  return dp[amount] === Infinity ? -1 : dp[amount];
+};

coin-change/crumbs22.cpp

@@ -0,0 +1,36 @@
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+/*
+	- dp[i]: 금액 i를 만드는 최소 코인수
+	- 초기값
+		- dp[0] = 0
+		- 그 외에는 amount + 1 (도달할 수 없는 값)으로 초기화
+	- 현재 금액 i를 만들기 위해서
+		이전 금액인 i - c를 만들고, 거기에 코인 c를 더 썼을 때 최소값을 갱신함
+	예시) coins = [1, 2, 5], i = 3일 때
+			c = 1 ->  3 >= 1 이므로 dp[3] = min(dp[3], dp[2] + 1) 갱신
+			c = 2 ->  3 >= 2 이므로 dp[3] = min(dp[3], dp[1] + 1) 갱신
+			c = 5 ->  3 < 5 이므로 건너뜀
+		=> i - c가 음수면 배열 범위를 벗어나므로 i >= c일때만 연산산
+*/
+class Solution {
+public:
+	int coinChange(vector<int>& coins, int amount) {
+		// dp 테이블 초기화
+		vector<int> dp(amount + 1, amount + 1);
+		dp[0] = 0;
+
+		// bottom up 연산
+		for (int i = 1; i <= amount; ++i) {
+			for (int c : coins) {
+				if (i >= c) {
+					dp[i] = min(dp[i], dp[i - c] + 1);
+				}
+			}
+		}
+
+		return (dp[amount] > amount) ? -1 : dp[amount];
+	}
+};

coin-change/eunhwa99.java

@@ -0,0 +1,24 @@
+import java.util.Arrays;
+
+// 시간 복잡도: O(n * m) - n: 동전의 개수, m: 금액
+// 공간 복잡도: O(n) - dp 배열 사용
+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];
+  }
+}
+
+