Merge pull request #1640 from Tessa1217/week14

[Tessa1217] Week14 Solutions

Author: Tessa1217

binary-tree-level-order-traversal/Tessa1217.java

@@ -0,0 +1,87 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * 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 {
+
+    // DFS 풀이
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        dfs(root, 0, result);
+        return result;
+    }
+
+    private void dfs(TreeNode node, int depth, List<List<Integer>> result) {
+        if (node == null) {
+            return;
+        }
+
+        // 깊이만큼의 리스트가 없으면 새 리스트 추가하기
+        if (depth == result.size()) {
+            result.add(new ArrayList<>());
+        }
+
+        result.get(depth).add(node.val);
+
+        dfs(node.left, depth + 1, result);
+        dfs(node.right, depth + 1, result);
+
+
+    }
+
+    // BFS로 풀이
+    // O(n)
+//    public List<List<Integer>> levelOrder(TreeNode root) {
+//
+//        List<List<Integer>> result = new ArrayList<>();
+//
+//        if (root == null) {
+//            return result;
+//        }
+//
+//        Queue<TreeNode> queue = new LinkedList<>();
+//        queue.offer(root);
+//
+//        while (!queue.isEmpty()) {
+//            int nodeCnt = queue.size();
+//            List<Integer> currentLevelNodes = new ArrayList<>();
+//
+//            for (int i = 0; i < nodeCnt; i++) {
+//                TreeNode current = queue.poll();
+//                currentLevelNodes.add(current.val);
+//
+//                if (current.left != null) {
+//                    queue.offer(current.left);
+//                }
+//
+//                if (current.right != null) {
+//                    queue.offer(current.right);
+//                }
+//
+//            }
+//
+//            result.add(currentLevelNodes);
+//
+//        }
+//
+//        return result;
+//
+//    }
+}
+

counting-bits/Tessa1217.java

@@ -0,0 +1,14 @@
+class Solution {
+
+    // 시간복잡도: O(n)
+    public int[] countBits(int n) {
+        int[] bitsArray = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            // Shift 연산자 사용
+            // i&1 => 마지막 비트가 0인지 1인지 확인
+            bitsArray[i] = bitsArray[i >> 1] + (i & 1);
+        }
+        return bitsArray;
+    }
+}
+

house-robber-ii/Tessa1217.java

@@ -0,0 +1,45 @@
+class Solution {
+
+    // DP
+    public int rob(int[] nums) {
+        int n = nums.length;
+
+        if (n == 0) {
+            return 0;
+        }
+
+        if (n == 1) {
+            return nums[0];
+        }
+
+        int notRobbingLast = robHouses(nums, 0, n - 2);
+        int notRobbingFirst = robHouses(nums, 1, n - 1);
+
+        return Math.max(notRobbingLast, notRobbingFirst);
+    }
+
+    private int robHouses(int[] nums, int start, int end) {
+
+        int length = end - start + 1;
+
+        if (length == 0) {
+            return 0;
+        }
+
+        if (length == 1) {
+            return nums[start];
+        }
+
+        int[] dp = new int[length];
+
+        dp[0] = nums[start];
+        dp[1] = Math.max(nums[start], nums[start + 1]);
+
+        for (int i = 2; i < length; i++) {
+            dp[i] = Math.max(dp[i - 2] + nums[start + i], dp[i - 1]);
+        }
+
+        return dp[length - 1];
+    }
+}
+

meeting-rooms-ii/Tessa1217.java

@@ -0,0 +1,55 @@
+import java.util.List;
+import java.util.PriorityQueue;
+
+/**
+ * Definition of Interval:
+ * public class Interval {
+ *     int start, end;
+ *     Interval(int start, int end) {
+ *         this.start = start;
+ *         this.end = end;
+ *     }
+ * }
+ */
+
+public class Solution {
+    /**
+     * @param intervals: an array of meeting time intervals
+     * @return: the minimum number of conference rooms required
+     */
+    // 시간복잡도: O(n log n)
+    public int minMeetingRooms(List<Interval> intervals) {
+
+        if (intervals == null || intervals.isEmpty()) {
+            return 0;
+        }
+
+        // 주어진 시간 인터벌 리스트를 시작 시간 기준으로 정렬
+        intervals.sort((i1, i2) -> i1.start - i2.start);
+
+        // PriorityQueue 선언: 시간 interval의 end time 기준
+        PriorityQueue<Interval> meetingRooms = new PriorityQueue<>((i1, i2) -> i1.end - i2.end);
+
+        for (Interval interval : intervals) {
+
+            // 최초 meeting room 
+            if (meetingRooms.isEmpty()) {
+                meetingRooms.offer(interval);
+                continue;
+            }
+
+            Interval meeting = meetingRooms.peek();
+            // (0, 8), (8, 10) is not conflict at 8
+            if (meeting.end <= interval.start) {
+                // 앞의 회의 종료되었으므로 회의실 재사용
+                meetingRooms.poll();
+            }
+            // 새 회의실 추가
+            meetingRooms.offer(interval);
+        }
+
+        return meetingRooms.size();
+
+    }
+}
+

word-search-ii/Tessa1217.java

@@ -0,0 +1,90 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+
+    private int[] dx = {0, 0, 1, -1};
+    private int[] dy = {1, -1, 0, 0};
+
+    private int m;
+    private int n;
+
+    class TrieNode {
+        // 단어는 영어 소문자만으로 이루어짐
+        TrieNode[] nodes = new TrieNode[26];
+        String word = null;
+    }
+
+    private void insert(TrieNode root, String word) {
+        TrieNode node = root;
+        for (char c : word.toCharArray()) {
+            int idx = c - 'a';
+            if (node.nodes[idx] == null) {
+                node.nodes[idx] = new TrieNode();
+            }
+            node = node.nodes[idx];
+        }
+        // 단어
+        node.word = word;
+    }
+
+    public List<String> findWords(char[][] board, String[] words) {
+
+        List<String> existingWords = new ArrayList<>();
+
+        // 탐색 최적화를 위해 TrieNode 생성
+        TrieNode root = new TrieNode();
+        for (String word : words) {
+            insert(root, word);
+        }
+
+        m = board.length;
+        n = board[0].length;
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                dfs(board, i, j, root, existingWords);
+            }
+        }
+
+        return existingWords;
+    }
+
+    private void dfs(char[][] board, int i, int j, TrieNode node, List<String> existingWords) {
+
+        char c = board[i][j];
+
+        // 방문 처리 되었거나 TrieNode에 없는 글자라면 탐색 X => Pruning
+        if (c == '#' || node.nodes[c - 'a'] == null) {
+            return;
+        }
+
+        node = node.nodes[c - 'a'];
+
+        // node의 완성된 단어가 있다면
+        if (node.word != null) {
+            existingWords.add(node.word);
+            node.word = null;
+        }
+
+        // 방문 처리
+        board[i][j] = '#';
+
+        for (int idx = 0; idx < 4; idx++) {
+            int ni = i + dx[idx];
+            int nj = j + dy[idx];
+            if (isRange(ni, nj)) {
+                dfs(board, ni, nj, node, existingWords);
+            }
+        }
+
+        board[i][j] = c;
+    }
+
+    // 탐색 범위 조건
+    private boolean isRange(int i, int j) {
+        return i >= 0 && j >= 0 && i < m && j < n;
+    }
+
+}
+