[jaekwang97] WEEK 04 Solutions

coin-change/jaekwang97.java

@@ -0,0 +1,20 @@
+import java.util.Arrays;
+
+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/jaekwang97.java

@@ -0,0 +1,18 @@
+class Solution {
+    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]) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return nums[left];
+    }
+}

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

@@ -0,0 +1,25 @@
+class Solution {
+    private int max;
+
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        max = 0;
+        dfs(root, 1);
+
+        return max;
+    }
+
+    private void dfs(TreeNode node, int depth) {
+        if (node == null) {
+            return;
+        }
+
+        max = Math.max(max, depth);
+
+        dfs(node.left, depth + 1);
+        dfs(node.right, depth + 1);
+    }
+}

merge-two-sorted-lists/jaekwang97.java

@@ -0,0 +1,32 @@
+class Solution {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        ListNode dummy = new ListNode();
+        ListNode tail = dummy;
+
+        while (list1 != null && list2 != null) {
+            if (list1.val <= list2.val) {
+                tail.next = new ListNode(list1.val);
+                list1 = list1.next;
+            } else {
+                tail.next = new ListNode(list2.val);
+                list2 = list2.next;
+            }
+
+            tail = tail.next;
+        }
+
+        while (list1 != null) {
+            tail.next = new ListNode(list1.val);
+            tail = tail.next;
+            list1 = list1.next;
+        }
+
+        while (list2 != null) {
+            tail.next = new ListNode(list2.val);
+            tail = tail.next;
+            list2 = list2.next;
+        }
+
+        return dummy.next;
+    }
+}

word-search/jaekwang97.java

@@ -0,0 +1,55 @@
+class Solution {
+
+    static int[] dx = {0, 1, 0, -1};
+    static int[] dy = {1, 0, -1, 0};
+    static int n, m;
+
+    public boolean exist(char[][] board, String word) {
+        m = board[0].length;
+        n = board.length;
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (board[i][j] != word.charAt(0)) continue;
+
+                char cur = board[i][j];
+                board[i][j] = '#';
+                boolean flag = dfs(board, word, 1, i, j);
+                board[i][j] = cur;
+
+                if (flag) return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static boolean dfs(
+        char[][] board,
+        String word,
+        int idx,
+        int x,
+        int y
+    ) {
+        if (idx == word.length()) return true;
+
+        for (int i = 0; i < 4; i++) {
+            int nx = x + dx[i];
+            int ny = y + dy[i];
+
+            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
+            if (board[nx][ny] != word.charAt(idx)) continue;
+
+            char cur = board[nx][ny];
+            board[nx][ny] = '#';
+
+            boolean flag = dfs(board, word, idx + 1, nx, ny);
+
+            board[nx][ny] = cur;
+
+            if (flag) return true;
+        }
+
+        return false;
+    }
+}