[forest000014] Week 04

merge-two-sorted-lists/forest000014.java

@@ -0,0 +1,37 @@
+/**
+
+ (n = list1.length + list2.length)
+ 시간 복잡도: O(n)
+ - 최악의 경우 전체 노드 순회
+ 공간 복잡도: O(n)
+ - 최악의 경우 전체 노드만큼 새 노드 생성
+
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        ListNode head = new ListNode();
+        ListNode curr = head;
+
+        while (true) {
+            if (list1 == null) {
+                curr.next = list2;
+                break;
+            } else if (list2 == null) {
+                curr.next = list1;
+                break;
+            }
+
+            if (list1.val <= list2.val) {
+                curr.next = new ListNode(list1.val);
+                curr = curr.next;
+                list1 = list1.next;
+            } else {
+                curr.next = new ListNode(list2.val);
+                curr = curr.next;
+                list2 = list2.next;
+            }
+        }
+
+        return head.next;
+    }
+}

missing-number/forest000014.java

@@ -0,0 +1,16 @@
+/*
+시간 복잡도: O(n)
+공간 복잡도: O(1)
+
+1 ~ n의 합이 n * (n + 1) / 2 라는 점을 활용
+*/
+class Solution {
+    public int missingNumber(int[] nums) {
+        int n = nums.length;
+        int ans = n * (n + 1) / 2;
+        for (int i = 0; i < n; i++) {
+            ans -= nums[i];
+        }
+        return ans;
+    }
+}

word-search/forest000014.java

@@ -0,0 +1,84 @@
+/*
+Time Complexity: O(m * n * 4^(word.length))
+Space Complexity: O(m * n)
+*/
+
+class Solution {
+    boolean[][] visited;
+    int m, n;
+    int len;
+    int[] dr = {-1, 0, 1, 0}; // clockwise traversal
+    int[] dc = {0, 1, 0, -1};
+    char board2[][];
+    String word2;
+
+    public boolean exist(char[][] board, String word) {
+        int[] cnt = new int[52];
+        board2 = board;
+        word2 = word;
+        m = board.length;
+        n = board[0].length;
+        visited = new boolean[m][n];
+        len = word.length();
+
+        // 1. for pruning, count characters in board and word respectively
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                cnt[charToInt(board[i][j])]++;
+            }
+        }
+        for (int i = 0; i < len; i++) {
+            int idx = charToInt(word.charAt(i));
+            if (--cnt[idx] < 0) {
+                return false;
+            }
+        }
+
+        // 2. DFS
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (board2[i][j] != word.charAt(0)) {
+                    continue;
+                }
+                if (dfs(i, j, 1)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean dfs(int row, int col, int idx) {
+        if (idx == len) { // end of word
+            return true;
+        }
+        visited[row][col] = true;
+
+        for (int i = 0; i < 4; i++) {
+            int nr = row + dr[i];
+            int nc = col + dc[i];
+            if (nr < 0 || nr >= m || nc < 0 || nc >= n) { // check boundary of the board
+                continue;
+            }
+            if (visited[nr][nc]) { // check visited
+                continue;
+            }
+            if (board2[nr][nc] == word2.charAt(idx)) {
+                if (dfs(nr, nc, idx + 1)) {
+                    return true;
+                }
+            }
+        }
+
+        visited[row][col] = false;
+        return false;
+    }
+
+    private int charToInt(char ch) {
+        if (ch <= 'Z') {
+            return ch - 'A';
+        } else {
+            return ch - 'a' + 26;
+        }
+    }
+}