[JeonJe] WEEK 04 Solutions (#2742)

* merge two sorted lists solution

* maximum depth of binary tree solution

* find minimum in rotated sorted array solution

* word search solution

* coin change solution

Author: JeonJe

coin-change/JeonJe.java

@@ -0,0 +1,33 @@
+import java.util.*;
+
+// TC: O(n * amount)  (n = coins.length)
+// SC: O(amount)
+class Solution {
+
+    private static final int IMPOSSIBLE = Integer.MAX_VALUE;
+
+    private int[] memo;
+
+    public int coinChange(int[] coins, int amount) {
+        memo = new int[amount + 1];
+        Arrays.fill(memo, -1);
+
+        int result = minCoins(amount, coins);
+        return result == IMPOSSIBLE ? -1 : result;
+    }
+
+    private int minCoins(int target, int[] coins) {
+        if (target == 0) return 0;
+        if (target < 0) return IMPOSSIBLE;
+        if (memo[target] != -1) return memo[target];
+
+        int best = IMPOSSIBLE;
+        for (int coin : coins) {
+            int sub = minCoins(target - coin, coins);
+            if (sub != IMPOSSIBLE) {
+                best = Math.min(best, sub + 1);
+            }
+        }
+        return memo[target] = best;
+    }
+}

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

@@ -0,0 +1,24 @@
+import java.util.*;
+
+// TC: O(log n)
+// SC: O(1)
+class Solution {
+    public int findMin(int[] nums) {
+
+        int lowIndex = 0;
+        int highIndex = nums.length - 1;
+
+        while(lowIndex < highIndex) {
+            int midIndex = (lowIndex + highIndex) / 2;
+
+            //오른 부분이 정렬 되지 않음 = 왼쪽 부분은 정렬됨
+            if(nums[midIndex] > nums[highIndex]) {
+                lowIndex = midIndex + 1;
+            } else {
+                //오른쪽 부분이 정렬 됨 = 왼쪽 부분을 봐야함
+                highIndex = midIndex;
+            }
+        }
+        return nums[lowIndex];
+    }
+}

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

@@ -0,0 +1,15 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(h)
+class Solution {
+    public int maxDepth(TreeNode root) {
+        return calMaxDepth(root);
+    }
+
+    // 현재까지 최대 깊이는 Math.max(왼쪽 서브노드 최대 깊이 , 오른쪽 서브노드 최대깊이) + 1
+    private int calMaxDepth(TreeNode node) {
+        if (node == null) return 0;
+        return Math.max(calMaxDepth(node.left), calMaxDepth(node.right)) + 1;
+    }
+}

merge-two-sorted-lists/JeonJe.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+// TC: O(n+m)
+// SC: O(n+m)
+class Solution {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        ListNode dummy = new ListNode(0);
+        ListNode tail = dummy;
+
+        while (list1 != null && list2 != null) {
+            if (list1.val > list2.val) {
+                tail.next = new ListNode(list2.val);
+                list2 = list2.next;
+            } else {
+                tail.next = new ListNode(list1.val);
+                list1 = list1.next;
+            }
+            tail = tail.next;
+        }
+
+        if (list1 != null) {
+            tail.next = list1;
+        }
+
+        if (list2 != null) {
+            tail.next = list2;
+        }
+
+        return dummy.next;
+    }
+}

word-search/JeonJe.java

@@ -0,0 +1,58 @@
+import java.util.*;
+
+// TC: O(m * n * 4^L)
+// SC: O(m * n)
+class Solution {
+
+    private char[][] board;
+    private int m, n;
+    private boolean[][] visited;
+    private char[] word;
+    private static final int[] dx = {-1, 1, 0, 0};
+    private static final int[] dy = {0, 0, -1, 1};
+
+
+    public boolean exist(char[][] board, String word) {
+        this.board = board;
+        this.word = word.toCharArray();
+        this.n = board.length;
+        this.m = board[0].length;
+        this.visited = new boolean[n][m];
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (dfs(i, j, 0)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean dfs(int x, int y, int wordIndex) {
+        if (board[x][y] != word[wordIndex] || visited[x][y]) {
+            return false;
+        }
+        if (wordIndex == word.length - 1) {
+            return true;
+        }
+
+        visited[x][y] = 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[wordIndex + 1] && !visited[nx][ny]) {
+                if (dfs(nx, ny, wordIndex + 1)) {
+                    return true;
+                }
+            }
+        }
+        visited[x][y] = false;
+        return false;
+    }
+}