[bky373] Week 3 Solutions

climbing-stairs/bky373.java

@@ -0,0 +1,20 @@
+class Solution {
+
+    public int climbStairs(int n) {
+        int[] ans = new int[n + 1];
+        if (n <= 2) {
+            return n;
+        }
+        ans[1] = 1;
+        ans[2] = 2;
+
+        for (int i = 3; i < n + 1; i++) {
+            ans[i] = ans[i - 1] + ans[i - 2];
+        }
+        return ans[n];
+    }
+}
+/**
+ * TC: O(N)
+ * SC: O(N)
+ */

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

@@ -0,0 +1,17 @@
+/**
+ * TC: O(N)
+ * SC: O(N)
+ */
+class Solution {
+
+    public int maxDepth(TreeNode root) {
+        return findMax(root, 0);
+    }
+
+    public int findMax(TreeNode node, int depth) {
+        if (node == null) {
+            return depth;
+        }
+        return Math.max(findMax(node.left, depth + 1), findMax(node.right, depth + 1));
+    }
+}

meeting-rooms/bky373.java

@@ -0,0 +1,19 @@
+class Solution {
+
+    public boolean canAttendMeetings(int[][] intervals) {
+        if (intervals.length == 0) {
+            return true;
+        }
+        Arrays.sort(intervals, (o1, o2) -> o1[0] - o2[0]);
+        for (int i = 0; i < intervals.length - 1; i++) {
+            if (intervals[i][1] > intervals[i + 1][0]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+/**
+ * TC: O(nlogn), due to the sorting array.
+ * SC: O(1)
+ */

same-tree/bky373.java

@@ -0,0 +1,11 @@
+/**
+ * TC: O(N)
+ * SC: O(N)
+ */
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        if (p == null && q == null) return true;
+        if (p == null || q == null || p.val != q.val) return false;
+        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+    }
+}

subtree-of-another-tree/bky373.java

@@ -0,0 +1,25 @@
+/**
+ * TC: O(M * N) - M: 메인 트리(root)의 노드 수, N: 서브 트리(subtree)의 노드 수
+ * SC: O(N) - N: 메인 트리(root)의 높이
+ */
+class Solution {
+    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
+        if (root == null) {
+            return false;
+        }
+        if (isSameTree(root, subRoot)) {
+            return true;
+        }
+        return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
+    }
+
+    public boolean isSameTree(TreeNode n1, TreeNode n2) {
+        if (n1 == null || n2 == null) {
+            return n1 == n2;
+        }
+        if (n1.val != n2.val) {
+            return false;
+        }
+        return isSameTree(n1.left, n2.left) && isSameTree(n1.right, n2.right);
+    }
+}