[Tony] WEEK 13 Solutions

lowest-common-ancestor-of-a-binary-search-tree/TonyKim9401.java

@@ -0,0 +1,31 @@
+// TC: O(n)
+// need to check all nodes
+// SC: O(h)
+// h can be O(n) in the worst case, O(log n) in the best case
+class Solution {
+    public TreeNode lcaDeepestLeaves(TreeNode root) {
+        return dfs(root, 0).node;
+    }
+
+    private ResultNode dfs(TreeNode node, int depth) {
+        if (node == null) return new ResultNode(null, depth);
+
+        depth += 1;
+        ResultNode leftNode = dfs(node.left, depth);
+        ResultNode rightNode = dfs(node.right, depth);
+
+        if (leftNode.depth == rightNode.depth) return new ResultNode(node, leftNode.depth);
+        else if (leftNode.depth > rightNode.depth) return leftNode;
+        else return rightNode;
+    }
+
+    private class ResultNode {
+        private TreeNode node;
+        private int depth;
+
+        ResultNode(TreeNode node, int depth) {
+            this.node = node;
+            this.depth = depth;
+        }
+    }
+}

meeting-rooms/TonyKim9401.java

@@ -0,0 +1,17 @@
+// TC: O(n log n)
+// list sort
+// SC: O(n)
+// list sort max use O(n)
+public class Solution {
+    public boolean canAttendMeetings(List<Interval> intervals) {
+        intervals.sort(Comparator.comparingInt(o -> o.start));
+
+        for (int i = 0; i < intervals.size() - 1; i++) {
+            Interval preInterval = intervals.get(i);
+            Interval postInterval = intervals.get(i+1);
+
+            if (preInterval.end > postInterval.start) return false;
+        }
+        return true;
+    }
+}