[Yiseull] WEEK 04 Solutions

coin-change/Yiseull.java

@@ -0,0 +1,22 @@
+class Solution {
+
+    private int answer = Integer.MAX_VALUE;
+
+    public int coinChange(int[] coins, int amount) {
+        final int IMPOSSIBLE = amount + 1;
+
+        int[] dp = new int[amount + 1];
+        Arrays.fill(dp, IMPOSSIBLE);
+        dp[0] = 0;
+
+        for (int i = 1; i < amount + 1; i++) {
+            for (int coin : coins) {
+                if (coin <= i) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+
+        return dp[amount] == IMPOSSIBLE ? -1 : dp[amount];
+    }
+}

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

@@ -0,0 +1,21 @@
+class Solution {
+    public int findMin(int[] nums) {
+        return binarySearch(nums);
+    }
+
+    // 공간복잡도: O(1), 시간복잡도: O(logn)
+    private int binarySearch(int[] nums) {
+        int left = 0, right = nums.length - 1;
+
+        while (left < right) {
+            if (nums[left] <= nums[right]) return nums[left];
+
+            int mid = (left + right) / 2;
+
+            if (nums[right] < nums[mid]) left = mid + 1;
+            else right = mid;
+        }
+
+        return nums[left];
+    }
+}

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

@@ -0,0 +1,29 @@
+/**
+ * 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 {
+
+    public int maxDepth(TreeNode root) {
+        return dfs(root);
+    }
+
+    private int dfs(TreeNode node) {
+        if (node == null) {
+            return 0;
+        }
+
+        return 1 + Math.max(dfs(node.left), dfs(node.right));
+    }
+}

merge-two-sorted-lists/Yiseull.java

@@ -0,0 +1,31 @@
+/**
+ * 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) {
+        ListNode head = new ListNode(-1);
+        ListNode current = head;
+
+        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;
+        }
+
+        current.next = (list1 != null) ? list1 : list2;
+
+        return head.next;
+    }
+}

word-search/Yiseull.java

@@ -0,0 +1,35 @@
+class Solution {
+
+    private final int[] dx = {-1, 1, 0, 0};
+    private final int[] dy = {0, 0, -1, 1};
+
+    public boolean exist(char[][] board, String word) {
+        for (int i = 0; i < board.length; i++) {
+            for (int j = 0; j < board[0].length; j++) {
+                if (board[i][j] == word.charAt(0) && dfs(board, word, i, j, 1)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private boolean dfs(char[][] board, String word, int x, int y, int index) {
+        if (index == word.length()) return true;
+
+        char tmp = board[x][y];
+        board[x][y] = '0';
+
+        for (int i = 0; i < 4; i++) {
+            int nextX = x + dx[i], nextY = y + dy[i];
+            if (0 <= nextX && nextX < board.length && 0 <= nextY && nextY < board[0].length && board[nextX][nextY] == word.charAt(index)) {
+                if(dfs(board, word, nextX, nextY, index + 1)) return true;
+            }
+        }
+
+        board[x][y] = tmp;
+
+        return false;
+    }
+}