Merge branch 'DaleStudy:main' into main

Author: jylee2033

coin-change/gcount85.py

@@ -0,0 +1,26 @@
+"""
+# Intuition
+dp[n]은 n원을 만드는데 필요한 최소 동전 개수
+e.g. n = 11일 때, 11원을 만들기 위한 최소 동전 개수는 11에서 coins의 원소를 뺀 dp 값 + 1이다.
+
+# Complexity
+- Time complexity: O(amount * coins.length)인데, coins 배열 길이가 상수라서 무시 => O(amount)
+
+- Space complexity: dp 배열 생성으로 O(amount)
+"""
+
+
+class Solution:
+    def coinChange(self, coins: list[int], amount: int) -> int:
+        coins.sort()
+        INF = float("inf")
+        dp = [INF] * (amount + 1)
+        dp[0] = 0
+        for i in range(amount + 1):
+            if dp[i] == INF:
+                continue
+            for c in coins:
+                if i + c > amount:
+                    break
+                dp[i + c] = min(dp[i + c], dp[i] + 1)
+        return dp[-1] if dp[-1] != INF else -1

coin-change/hwi-middle.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int coinChange(vector<int>& coins, int amount) {
+        if (amount < 1)
+        {
+            return 0;
+        }
+
+        vector<int> v(amount);
+        return solve(coins, amount, v);
+    }
+
+    int solve(vector<int>& coins, int amount, vector<int>& count)
+    {
+        if (amount < 0) return -1;
+        if (amount == 0) return 0;
+        if (count[amount - 1] != 0) return count[amount - 1];
+
+        int min = INT_MAX;
+        for (int coin : coins) 
+        {
+            int res = solve(coins, amount - coin, count); // coin을 사용
+            if (res >= 0 && res < min) // 결과가 유효하고 현재 최솟값보다 작으면 업데이트
+            {
+                min = res + 1; // coin을 미리 사용하고 찾은 값이므로 1 더함
+            }
+        }
+
+        count[amount - 1] = (min == INT_MAX) ? -1 : min;
+        return count[amount - 1];
+  }
+};

coin-change/liza0525.py

@@ -0,0 +1,38 @@
+# 7기 풀이
+# 시간 복잡도: O(n * k)
+#  - 타겟 코인 값(amount, 복잡도 계산에선 n으로 표기)과 coins의 길이 만큼 탐색하며 계산
+# 공간 복잡도: O(n)
+#  - 타겟 코인 값(amount, 복잡도 계산에선 n으로 표기) 만큼의 min_coin_count 계산 array를 생성
+class Solution:
+    # 해당 문제는 현재 갖고 있는 돈으로 각 코인 값을 만드는 데에 동전을 얼마나 쓰는지 계산하여
+    # 그 조합 중 가장 작은 값을 계속 찾아가는 문제로, min_coin_count를 사용한다. 
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        min_coin_count = [-1 for _ in range(amount + 1)]  # 각 인덱스는 코인 값, value는 해당 코인 값을 만들 수 있는 동전의 개수(만들 수 없을 땐 -1)
+        min_coin_count[0] = 0  # 코인 값이 0일 때는 동전을 쓰지 않으면 되므로 무조건 0이 된다.
+
+        for target_amount in range(1, len(min_coin_count)):
+            # 각 코인 값에 대해 최소 동전 개수를 찾는다.
+            for coin in coins:
+                if target_amount - coin < 0:
+                    # 대상 코인 값보다 체크할 코인 값이 큰 경우에는 조합을 만들 수 없으므로 넘긴다
+                    continue
+                if min_coin_count[target_amount - coin] < 0:
+                    # target_amount - coin(보수)을 만들 수 없으면 target_amount도 만들 수 없음
+                    # 예시) target=5, coin=3 → 보수 2를 못 만들면 5도 못 만듦
+                    continue
+
+                # 위 두 가지 조건만 넘어가면 동전 개수를 min_coin_count[target_amount]에 정해서 넣을 수 있다는 의미
+                if min_coin_count[target_amount] == -1:
+                    # 값이 -1인 경우에는 처음으로 계산해서 넣는 것이기 때문에
+                    # min_coin_count[target_amount - coin]에다가 1을 더해서(coin 한 개를 추가 한다는 의미) min_coin_count[target_amount]에 할당
+                    min_coin_count[target_amount] = min_coin_count[target_amount - coin] + 1
+                else:
+                    # 값이 -1이 아닌 경우는 이전에 저장된 동전 개수가 있으므로
+                    # 이전 결과 값과 min_coin_count[target_amount - coin] + 1의 값을 비교하여 더 적은 수를 저장한다.
+                    min_coin_count[target_amount] = min(
+                        min_coin_count[target_amount],
+                        min_coin_count[target_amount - coin] + 1
+                    )
+
+        # 모두 계산한 후 min_coin_count[amount]를 반환한다. (== amount를 만드는 동전의 최소 개수)
+        return min_coin_count[amount]

find-minimum-in-rotated-sorted-array/gcount85.py

@@ -0,0 +1,27 @@
+"""
+# Intuition
+이진탐색으로 찾는다.
+
+# Complexity
+- Time complexity: nums의 길이 N일때, O(logN)
+
+- Space complexity: 재귀스택 O(logN)
+"""
+
+
+class Solution:
+    def findMin(self, nums: list[int]) -> int:
+        l, m, r = 0, len(nums) // 2, len(nums) - 1
+
+        def findMinimum(l, m, r):
+            if l == m or r == m:
+                return min(nums[l], nums[r])
+
+            # 오른쪽 구간
+            if nums[m] > nums[r]:
+                return findMinimum(m, (m + r) // 2, r)
+
+            # 왼쪽 구간
+            return findMinimum(l, (l + m) // 2, m)
+
+        return findMinimum(l, m, r)

find-minimum-in-rotated-sorted-array/hwi-middle.cpp

@@ -0,0 +1,42 @@
+class Solution {
+public:
+    int findMin(vector<int>& nums) {
+        return solve(nums, 0, nums.size() - 1);
+    }
+
+    int solve(vector<int>& num, int start, int end)
+    {
+        if (end - start < 2)
+        {
+            return min(num[start], num[end]);
+        }
+
+        // 중간 인덱스 계산
+        int mid = (start + end) / 2;
+
+        // 오름차순 정렬이 깨지기 시작한 부분 -> 최솟값 발견
+        if  (num[mid] < num[mid - 1])
+        {
+            return num[mid];
+        }
+
+        // 왼쪽 영역이 정렬되어 있는 경우
+        if (num[start] <= num[mid])
+        {
+            // 그리고 오른쪽 영역까지도 정렬된 경우
+            if (num[mid] <= num[end])
+            {
+                // 가장 왼쪽에 있는 값이 최솟값
+                return num[start];
+            }
+
+            // 왼쪽 영역만 정렬된 경우
+            // 오른쪽 영역에서 정렬이 깨지는 부분 찾으러 가기
+            return solve(num, mid + 1, end);
+        }
+
+        // 오른쪽 영역이 정렬된 경우
+        // 왼쪽 영역에서 정렬이 깨지는 부분 찾으러 가기
+        return solve(num, start, mid - 1);
+    }
+};

find-minimum-in-rotated-sorted-array/tedkimdev.go

@@ -0,0 +1,26 @@
+// TC: O(log n)
+// SC: O(1)
+func findMin(nums []int) int {
+	min := nums[0]
+	l, r := 0, len(nums)-1
+
+	for l <= r {
+			if nums[l] < min {
+				min = nums[l]
+			}
+			break
+		}
+
+		m := l + (r-l)/2
+		if nums[m] < min {
+			min = nums[m]
+		}
+
+		if nums[m] >= nums[l] {
+			l = m + 1
+		} else {
+			r = m - 1
+		}
+	}
+	return min
+}

maximum-depth-of-binary-tree/DaleSeo.rs

@@ -0,0 +1,19 @@
+// TC: O(n)
+// SC: O(n)
+use std::cell::RefCell;
+use std::rc::Rc;
+
+impl Solution {
+    pub fn max_depth(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        match root {
+            None => 0,
+            Some(node) => {
+                let node = node.borrow();
+                1 + std::cmp::max(
+                    Self::max_depth(node.left.clone()),
+                    Self::max_depth(node.right.clone()),
+                )
+            }
+        }
+    }
+}

maximum-depth-of-binary-tree/gcount85.py

@@ -0,0 +1,18 @@
+"""
+# Intuition
+1) BFS + 큐
+2) DFS + 재귀
+1번으로 풀었다가 2번이 코드가 더 간결해서 바꿨습니다.
+
+# Complexity
+- Time complexity: 모든 노드를 다 봐야 하므로 O(N)
+
+- Space complexity: 재귀 깊이만큼 O(H)
+"""
+
+
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

maximum-depth-of-binary-tree/grapefruit13.ts

@@ -0,0 +1,23 @@
+class TreeNode {
+  val: number;
+  left: TreeNode | null;
+  right: TreeNode | null;
+  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+    this.val = val === undefined ? 0 : val;
+    this.left = left === undefined ? null : left;
+    this.right = right === undefined ? null : right;
+  }
+}
+
+/**
+ * Time Complexity: O(n)
+ * Space Complexity: O(h)
+ */
+function maxDepth(root: TreeNode | null): number {
+  if (root === null) return 0;
+
+  let left = maxDepth(root.left);
+  let right = maxDepth(root.right);
+
+  return 1 + Math.max(left, right);
+}

maximum-depth-of-binary-tree/hwi-middle.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+        return solve(root, 0);
+    }
+
+    int solve(TreeNode* root, int depth)
+    {
+        if (root == nullptr)
+        {
+            return depth;
+        }
+
+        int l = solve(root->left, depth);
+        int r = solve(root->right, depth);
+
+        return max(l, r) + 1;
+    }
+};