Merge pull request #1367 from eunhwa99/main

[eunhwa99] Week 04 solutions

Author: eunhwa99

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

find-minimum-in-rotated-sorted-array/eunhwa99.java

@@ -1,17 +1,21 @@
 class Solution {
-  // TC: O(log N)
-  // SC: O(1)
+  // 시간 복잡도: O(log N) - Binary search
+  // 공간 복잡도: O(1) - Constant extra space
   public int findMin(int[] nums) {
-    int left = 0;
-    int right = nums.length - 1;
-    while (left < right) {
-      int mid = left + (right - left) / 2;
-      if (nums[mid] < nums[right]) {
-        right = mid;
+    int low = 0;
+    int high = nums.length - 1;
+
+    while (low < high) {
+      int mid = low + (high - low) / 2;
+
+      if (nums[mid] < nums[high]) {
+        high = mid;
       } else {
-        left = mid + 1;
+        low = mid + 1;
       }
     }
-    return nums[left];
+
+    return nums[low];
   }
 }
+

maximum-depth-of-binary-tree/eunhwa99.java

@@ -0,0 +1,14 @@
+public class eunhwa99 {
+
+  // 시간 복잡도: O(n) - 트리를 한 번 순회
+  // 공간 복잡도: O(h) - 재귀 호출 스택 공간 (h는 트리의 높이)
+  class Solution {
+    public int maxDepth(TreeNode root) {
+      if (root == null) return 0; // 빈 노드인 경우 깊이는 0
+      int leftDepth = maxDepth(root.left); // 왼쪽 서브트리 깊이
+      int rightDepth = maxDepth(root.right); // 오른쪽 서브트리 깊이
+      return Math.max(leftDepth, rightDepth) + 1; // 최대 깊이 + 1 (현재 노드)
+    }
+  }
+}
+

merge-two-sorted-lists/eunhwa99.java

@@ -0,0 +1,34 @@
+public class eunhwa99 {
+
+  // 시간 복잡도: O(n) - 두 개의 리스트를 한 번씩 순회
+  // 공간 복잡도: O(1) - 추가적인 공간 사용 없음
+  class Solution {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+      if (list1 == null) return list2;
+      if (list2 == null) return list1;
+
+      ListNode dummy = new ListNode(0);
+      ListNode current = dummy;
+
+      while (list1 != null && list2 != null) {
+        if (list1.val <= list2.val) {
+          current.next = list1;
+          list1 = list1.next;
+        } else {
+          current.next = list2;
+          list2 = list2.next;
+        }
+        current = current.next;
+      }
+
+      if (list1 != null) {
+        current.next = list1;
+      } else {
+        current.next = list2;
+      }
+
+      return dummy.next;
+    }
+  }
+}
+

word-search/eunhwa99.java

@@ -0,0 +1,43 @@
+class Solution {
+
+  // 시간 복잡도: O(m * n * 4^L) - m: 행, n: 열, L: 단어 길이
+  // 공간 복잡도: O(m * n) - 방문 체크를 위한 공간
+  public boolean exist(char[][] board, String word) {
+    int rows = board.length;
+    int cols = board[0].length;
+
+    for (int r = 0; r < rows; r++) {
+      for (int c = 0; c < cols; c++) {
+        if (dfs(board, word, 0, r, c)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  private boolean dfs(char[][] board, String word, int index, int r, int c) {
+    if (index == word.length()) {
+      return true;
+    }
+
+    if (r < 0 || r >= board.length || c < 0 || c >= board[0].length || board[r][c] != word.charAt(
+        index)) {
+      return false;
+    }
+
+    char temp = board[r][c];
+    board[r][c] = '#';
+
+    boolean found =
+        dfs(board, word, index + 1, r + 1, c) ||
+            dfs(board, word, index + 1, r - 1, c) ||
+            dfs(board, word, index + 1, r, c + 1) ||
+            dfs(board, word, index + 1, r, c - 1);
+
+    board[r][c] = temp;
+    return found;
+  }
+}
+