Merge pull request #1647 from sora0319/main

[sora0319] Week14 Solutions

Author: sora0319

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

@@ -0,0 +1,26 @@
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        if (root == null) return new ArrayList<>();
+
+        List<List<Integer>> output = new ArrayList<>();
+        Queue<TreeNode> q = new LinkedList<>();
+        q.offer(root);
+
+        while (!q.isEmpty()) {
+            List<Integer> values = new ArrayList<>();
+            int size = q.size();
+
+            for (int i = 0; i < size; i++) {
+                TreeNode node = q.poll();
+                values.add(node.val);
+
+                if (node.left != null) q.offer(node.left);
+                if (node.right != null) q.offer(node.right);
+            }
+
+            output.add(values);
+        }
+
+        return output;
+    }
+}

counting-bits/sora0319.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int[] countBits(int n) {
+        int[] bits = new int[n + 1];
+        int i = 1;
+        
+        for (int num = 1; num <= n; num++) {
+            if (i << 1 == num) {
+                i = num;
+            }
+            bits[num] = 1 + bits[num - i];
+        }
+        
+        return bits;
+    }
+}

house-robber-ii/sora0319.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int rob(int[] nums) {
+        if (nums.length == 1) return nums[0];
+
+        return Math.max(dp(nums, 0, nums.length - 1),
+                        dp(nums, 1, nums.length));
+    }
+
+    private int dp(int[] nums, int start, int end) {
+        int back = 0;
+        int curr = 0;
+
+        for (int i = start; i < end; i++) {
+            int temp = curr;
+            curr = Math.max(back + nums[i], curr);
+            back = temp;
+        }
+
+        return curr;
+    }
+}

meeting-rooms-ii/sora0319.java

@@ -0,0 +1,33 @@
+public class Solution {
+    public int minMeetingRooms(int[][] intervals) {
+        int n = intervals.length;
+        int[] starts = new int[n];
+        int[] ends = new int[n];
+
+        for (int i = 0; i < n; i++) {
+            starts[i] = intervals[i][0];
+            ends[i] = intervals[i][1];
+        }
+
+        Arrays.sort(starts);
+        Arrays.sort(ends);
+
+        int maxCount = 0;
+        int count = 0;
+        int s = 0;
+        int e = 0;
+
+        while (s < n) {
+            if (starts[s] < ends[e]) {
+                count++;
+                maxCount = Math.max(maxCount, count);
+                s++;
+            } else {
+                count--;
+                e++;
+            }
+        }
+
+        return maxCount;
+    }
+}