Merge pull request #1360 from JEONGBEOMKO/main

[JEONGBEOMKO] Week 04 Solutions

Author: JEONGBEOMKO

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

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

@@ -0,0 +1,22 @@
+class Solution {
+    /*
+    time complexity: O(log n)
+    space complexity: O(h)
+     */
+    public int findMin(int[] nums) {
+        int start = 0, end = nums.length - 1;
+
+        if (nums[start] < nums[end]) return nums[start];
+
+        while (start < end) {
+            int mid = start + (end - start) / 2;
+
+            if (nums[mid] < nums[end]) {
+                end = mid;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return nums[start];
+    }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+
+
+class Solution {
+    /*
+    time complexity: O(n)
+    space complexity: O(h)
+     */
+    int maxDepth = 0;
+
+    public int maxDepth(TreeNode root) {
+        depthChk(root, 0);
+        return maxDepth;
+    }
+
+    public void depthChk(TreeNode node, int depth) {
+        if (node == null) {
+            maxDepth = Math.max(depth, maxDepth);
+            return;
+        }
+
+        // 트리의 좌우 탐색
+        depthChk(node.left, depth + 1);
+        depthChk(node.right, depth + 1);
+    }
+}

merge-two-sorted-lists/JEONGBEOMKO.java

@@ -0,0 +1,24 @@
+/**
+ * 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) {
+        if (list1 == null || list2 == null) {
+            return list1 == null ? list2 : list1;
+        }
+        if (list1.val < list2.val) {
+            list1.next = mergeTwoLists(list1.next, list2);
+            return list1;
+        } else {
+            list2.next = mergeTwoLists(list2.next, list1);
+            return list2;
+        }
+    }
+}

word-search/JEONGBEOMKO.java

@@ -0,0 +1,43 @@
+public class Solution {
+    /*
+    time complexity: O(M × N × 3^L)
+    space complexity: O(M × N + L)
+    */
+    private int rows, cols;
+    private boolean[][] visited;
+    private final int[] dx = {0, 1, 0, -1};
+    private final int[] dy = {1, 0, -1, 0};
+
+    public boolean exist(char[][] board, String word) {
+        rows = board.length;
+        cols = board[0].length;
+        visited = new boolean[rows][cols];
+
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (dfs(board, word, i, j, 0)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean dfs(char[][] board, String word, int x, int y, int idx) {
+        if (idx == word.length()) return true;
+
+        if (x < 0 || y < 0 || x >= rows || y >= cols) return false;
+        if (visited[x][y] || board[x][y] != word.charAt(idx)) return false;
+
+        visited[x][y] = true;
+
+        for (int d = 0; d < 4; d++) {
+            if (dfs(board, word, x + dx[d], y + dy[d], idx + 1)) {
+                return true;
+            }
+        }
+
+        visited[x][y] = false; // 백트래킹
+        return false;
+    }
+}