Merge branch 'DaleStudy:main' into main

Author: 8804who

best-time-to-buy-and-sell-stock/YuuuuuuYu.java

@@ -0,0 +1,26 @@
+/**
+ * Runtime: 1ms
+ * Time Complexity: O(n)
+ *
+ * Memory: 94.08MB
+ * Space Complexity: O(1)
+ *
+ * Approach: 그리디 알고리즘
+ * - 주어진 prices 배열을 순회하며 최소 가격(min)을 갱신
+ */
+class Solution {
+    public int maxProfit(int[] prices) {
+        int maxProfit = 0;
+        int min = prices[0];
+
+        for (int i=1; i<prices.length; i++) {
+            if (min >= prices[i]) {
+                min = prices[i];
+            } else {
+                maxProfit = Math.max(maxProfit, prices[i]-min);
+            }
+        }
+
+        return maxProfit;
+    }
+}

best-time-to-buy-and-sell-stock/hyunolike.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        // 주식 최대 이익
+        int minPrice = Integer.MAX_VALUE;
+        int maxProfit = 0;
+
+        for (int price : prices) {
+            minPrice = Math.min(minPrice, price);
+            maxProfit = Math.max(maxProfit, price - minPrice);
+        }
+
+        return maxProfit;
+    }
+}

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

@@ -0,0 +1,24 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        # profit: 최대 이익
+        profit = 0
+
+        # current_minimum: 현재까지의 최소 가격
+        current_minimum = prices[0]
+
+        # current_profit: 현재까지의 최대 이익
+        current_profit = 0
+
+        # 전체 배열에서 최솟값과, 최솟값 인덱스 이후 최댓값을 이익으로 계산하는 반복문
+        for i in range(1, len(prices)):
+            # 이익이 발생할 경우 현재 이익 갱신
+            # 현재 이익을 갱신할 때마다 지금까지의 최대 이익도 갱신
+            if prices[i] > current_minimum:
+                current_profit = max(current_profit, prices[i] - current_minimum)
+                profit = max(profit, current_profit)
+            # 이익이 발생하지 않을 경우 최솟값 갱신
+            else:
+                current_minimum = prices[i]
+        
+        # 최대 이익만 저장되어 반환
+        return profit

coin-change/Blossssom.ts

@@ -0,0 +1,29 @@
+/**
+ * @param coins - 동전 종류 배열
+ * @param amount - 총 금액
+ * @returns - 총 사용 코인 갯수
+ * @description
+ * - 탐욕으로 풀면 최소 동전갯수를 구할 수 없음
+ * - dp 로 풀이
+ * - 1 부터 금액의 코인 사용 갯수를 추가해 가며, 이전에 구해놓은 값과 min 비교
+ */
+function coinChange(coins: number[], amount: number): number {
+  const dp = new Array(amount + 1).fill(Infinity);
+
+  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], dp[i - coin] + 1);
+      }
+    }
+  }
+
+  return dp[amount] === Infinity ? -1 : dp[amount];
+}
+
+const coins = [1, 2, 5];
+const amount = 11;
+coinChange(coins, amount);
+

coin-change/ZetBe.py

@@ -0,0 +1,38 @@
+'''
+문제: 주어진 동전 종류로 특정 금액을 만들기 위한 최소 동전 개수를 구하시오.
+풀이: 동적 계획법(DP)을 사용하여 각 금액에 대해 최소 동전 개수를 계산합니다. 만약 특정 금액을 만들 수 없다면 -1을 반환합니다.
+시간 복잡도: O(n * m), n은 금액(amount), m은 동전 종류의 개수입니다. 각 금액에 대해 모든 동전을 확인하므로 전체 시간 복잡도는 O(n * m)입니다.
+공간 복잡도: O(n), 금액(amount)까지의 최소 동전 개수를 저장하는 DP 배열을 사용하므로 공간 복잡도는 O(n)입니다.
+사용한 자료구조: 배열(DP 배열)
+'''
+
+
+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
+        if amount in coins:
+            return 1
+
+        dp = [0 for i in range(amount+1)]
+        
+        for i in range(amount+1):
+            for j in range(len(coins)):
+                if i == 0 and coins[j] < amount:
+                    dp[coins[j]] = 1
+                elif i > 0 and 0 <= i+coins[j] <= amount:
+                    if dp[i] > 0 and dp[i+coins[j]] > 0:
+                        dp[i+coins[j]] = min(dp[i+coins[j]], dp[i]+1)
+                    elif dp[i] > 0 and dp[i+coins[j]] == 0:
+                        dp[i+coins[j]] = dp[i]+1
+                   
+
+
+
+        if dp[amount] == 0:
+            return -1
+        return dp[amount]
+
+

coin-change/casentino.ts

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

coin-change/daiyongg-kim.py

@@ -0,0 +1,26 @@
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        if amount == 0:
+            return 0
+        
+        level = [0]
+        visited = {0}
+        count = 0
+
+        while level:
+            count += 1
+            next_level = []
+
+            for current_amount in level:
+                for coin in coins:
+                    new_amount = current_amount + coin
+
+                    if new_amount == amount:
+                        return count
+                    
+                    if new_amount < amount and new_amount not in visited:
+                        visited.add(new_amount)
+                        next_level.append(new_amount)
+            level = next_level
+
+        return -1

coin-change/dylan-jung.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    long dp[10001];
+    int coinChange(vector<int>& coins, int amount) {
+        long INF = (long)1 << 31;
+        fill(dp, dp+10001, INF);
+
+        for(int& item: coins) {
+            if(item > 10000) continue;
+            dp[item] = 1;
+        }
+
+        for(int i = 1; i <= amount; i++) {
+            for(int& item: coins) {
+                int j = i - item;
+                if(j > 0 && dp[j] != -1) {
+                    dp[i] = min(dp[j] + 1, dp[i]);
+                }
+            }
+        }
+
+        if(dp[amount] == INF) {
+            if(amount == 0) return 0;
+            else return -1;
+        }
+        return dp[amount];
+    }
+};

coin-change/kimjunyoung90.java

@@ -0,0 +1,28 @@
+import java.util.Arrays;
+
+class Solution {
+    //풀이 원리 = 특정 금액을 만들 때 최소 동전 수는 몇 개?
+    //예) 0원은 동전 0개
+    // 1원은 동전 1개
+    // 2원은 동전 1
+    public int coinChange(int[] coins, int amount) {
+        //불가능한 값
+        int max = amount + 1;
+        int[] dp = new int[amount + 1];
+        //최소 동전 수를 모두 불가능한 값으로 설정
+        Arrays.fill(dp, max);
+        dp[0] = 0;
+
+        //금액 1원 부터 계산
+        for (int i = 1; i <= amount; i++) {
+            //사용할 수 있는 동전을 꺼냄
+            for(int coin: coins) {
+                if (coin <= i) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+
+        return dp[amount] > amount ? -1 : dp[amount];
+    }
+}

coin-change/ppxyn1.py

@@ -0,0 +1,47 @@
+# idea: DFS/BFS, DP
+
+from collections import deque
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        # Why Greedy is not possiple way?
+        # A greedy is only optimal in specific coin systems (e.g., denominations like 1, 5, 10, 25)
+        # For arbitrary coin denominations, a greedy approach does not always yield the optimal solution.
+        queue = deque([(0,0)]) # (동전갯수, 누적금액)
+        while queue:
+            count, total = queue.popleft()
+            if total == amount:
+                return count
+            for coin in coins:
+                if total + coin <= amount:
+                    queue.append([count+1, total+ coin])
+        return -1
+
+    # # BFS 
+    # def coinChange(self, coins: List[int], amount: int) -> int:
+    #     queue = deque([(0,0)]) # (동전갯수, 누적금액)
+    #     visited = set()
+    #     while queue:
+    #         count, total = queue.popleft()
+    #         if total == amount:
+    #             return count
+    #         if total in visited:
+    #             continue
+    #         visited.add(total)
+    #         for coin in coins:
+    #             if total + coin <= amount:
+    #                 queue.append([count+1, total+ coin])
+    #     return -1
+
+
+    # DP
+    # dp[i] = min(dp[i], dp[i-coin]+1)
+    # from collections import deque
+    # class Solution:
+    #     def coinChange(self, coins: List[int], amount: int) -> int:
+    #        dp=[0]+[amount+1]*amount
+    #        for coin in coins:
+    #             for i in range(coin, amount+1):
+    #                 dp[i] = min(dp[i], dp[i-coin]+1)
+    #         return dp[amount] if dp[amount] < amount else -1
+
+