[ICE0208] WEEK 04 Solutions (#2744)

* merge two sorted lists

* maximum depth of binary tree

* find minimum in rotated sorted array

* word search

* coin change

Author: ICE0208

coin-change/ICE0208.java

@@ -0,0 +1,30 @@
+class Solution {
+    /**
+     * 시간 복잡도: O(amount * coins.length)
+     * 공간 복잡도: O(amount)
+     */
+    public int coinChange(int[] coins, int amount) {
+        // 필요한 동전의 최대 개수는 amount개이므로,
+        // amount + 1은 만들 수 없는 상태를 나타내기에 충분하다.
+        int impossible = amount + 1;
+
+        int[] dp = new int[amount + 1];
+        Arrays.fill(dp, impossible);
+        dp[0] = 0;
+
+        for (int currentAmount = 1; currentAmount <= amount; currentAmount++) {
+            for (int coin : coins) {
+                if (coin > currentAmount) {
+                    continue;
+                }
+
+                dp[currentAmount] = Math.min(
+                    dp[currentAmount],
+                    dp[currentAmount - coin] + 1
+                );
+            }
+        }
+
+        return dp[amount] == impossible ? -1 : dp[amount];
+    }
+}

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

@@ -0,0 +1,25 @@
+class Solution {
+    public int findMin(int[] nums) {
+        return binarySearch(nums, 0, nums.length -1);
+    }
+
+    private int binarySearch(int[] nums, int left, int right) {
+        // 탐색 범위에 원소가 하나만 남은 경우
+        if (left == right) {
+            return nums[left];
+        }
+
+        // [1] 현재 범위가 이미 오름차순이라면 첫 번째 값이 최솟값!
+        if (nums[left] < nums[right]) {
+            return nums[left];
+        }
+
+        int mid = left + (right - left) / 2;
+        // [2-1] 왼쪽 구간이 정렬되어 있다면 최솟값은 오른쪽 구간에 있다
+        if (nums[left] <= nums[mid]) {
+            return binarySearch(nums, mid + 1, right);
+        }
+        // [2-2] 회전 지점이 왼쪽 구간에 있다.
+        return binarySearch(nums, left, mid);
+    }
+}

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

@@ -0,0 +1,12 @@
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        int leftDepth = maxDepth(root.left);
+        int rightDepth = maxDepth(root.right);
+
+        return Math.max(leftDepth, rightDepth) + 1;
+    }
+}

merge-two-sorted-lists/ICE0208.java

@@ -0,0 +1,34 @@
+class Solution {
+    /**
+     * 두 정렬된 연결 리스트의 기존 노드를 재사용하여 하나의 정렬된 리스트로 병합한다.
+     *
+     * 시간 복잡도: O(n + m)
+     * - n: list1의 길이
+     * - m: list2의 길이
+     *
+     * 공간 복잡도: O(1)
+     * - 새로운 노드를 생성하지 않고 기존 노드를 재사용한다.
+     */
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        ListNode dummyHead = new ListNode();
+        ListNode tail = dummyHead;
+
+        // 두 리스트를 순회하며 더 작은 노드를 결과 리스트의 뒤에 연결한다.
+        while (list1 != null && list2 != null) {
+            if (list1.val <= list2.val) {
+                tail.next = list1;
+                list1 = list1.next;
+            } else {
+                tail.next = list2;
+                list2 = list2.next;
+            }
+
+            tail = tail.next;
+        }
+
+        // 한쪽 리스트가 끝나면 다른 리스트의 남은 노드들을 그대로 연결한다.
+        tail.next = list1 != null ? list1 : list2;
+
+        return dummyHead.next;
+    }
+}

word-search/ICE0208.java

@@ -0,0 +1,77 @@
+class Solution {
+    private static final int[][] DIRECTIONS = {
+        {-1, 0},
+        {1, 0},
+        {0, -1},
+        {0, 1}
+    };
+
+    private char[][] board;
+    private String word;
+    private boolean[][] visited;
+    private int rows;
+    private int cols;
+
+    public boolean exist(char[][] board, String word) {
+        this.board = board;
+        this.word = word;
+        this.rows = board.length;
+        this.cols = board[0].length;
+        this.visited = new boolean[rows][cols];
+
+        // 단어가 전체 칸보다 길면 경로를 만들 수 없다.
+        if (word.length() > rows * cols) {
+            return false;
+        }
+
+        for (int row = 0; row < rows; row++) {
+            for (int col = 0; col < cols; col++) {
+                // 첫 문자가 일치하는 위치에서만 탐색을 시작한다.
+                if (board[row][col] == word.charAt(0)
+                        && search(row, col, 0)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private boolean search(int row, int col, int wordIndex) {
+        // 이미 현재 경로에서 사용한 칸이거나 문자가 다르면 탐색을 중단한다.
+        if (visited[row][col]
+                || board[row][col] != word.charAt(wordIndex)) {
+            return false;
+        }
+
+        // 마지막 문자까지 일치했다면 단어를 찾은 것이다.
+        if (wordIndex == word.length() - 1) {
+            return true;
+        }
+
+        visited[row][col] = true;
+
+        for (int[] direction : DIRECTIONS) {
+            int nextRow = row + direction[0];
+            int nextCol = col + direction[1];
+
+            if (!isInBounds(nextRow, nextCol)) {
+                continue;
+            }
+
+            if (search(nextRow, nextCol, wordIndex + 1)) {
+                visited[row][col] = false;
+                return true;
+            }
+        }
+
+        // 다른 경로에서 현재 칸을 다시 사용할 수 있도록 방문 상태를 복구한다.
+        visited[row][col] = false;
+        return false;
+    }
+
+    private boolean isInBounds(int row, int col) {
+        return row >= 0 && row < rows
+                && col >= 0 && col < cols;
+    }
+}