Merge pull request #547 from TonyKim9401/main

[Tony] WEEK 11 Solutions

Author: TonyKim9401

binary-tree-maximum-path-sum/TonyKim9401.java

@@ -0,0 +1,24 @@
+// TC: O(n)
+// visit all nodes to find maximum path
+// SC: O(h)
+// h means the high of binary tree
+class Solution {
+    private int output = Integer.MIN_VALUE;
+    public int maxPathSum(TreeNode root) {
+        max(root);
+        return output;
+    }
+
+    private int max(TreeNode node) {
+        if (node == null) return 0;
+
+        int leftSum = Math.max(max(node.left), 0);
+        int rightSum = Math.max(max(node.right), 0);
+
+        int currentMax = node.val + leftSum + rightSum;
+
+        output = Math.max(output, currentMax);
+
+        return node.val + Math.max(leftSum, rightSum);
+    }
+}

graph-valid-tree/TonyKim9401.java

@@ -0,0 +1,37 @@
+// TC: O(n * m)
+// n = the length of edges, m = the length of each element list of edges
+// SC: O(n)
+// n = recursively visit everywhere
+public class Solution {
+    public boolean validTree(int n, int[][] edges) {
+        if (edges.length != n - 1) return false;
+
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        for (int[] edge : edges) {
+            graph.get(edge[0]).add(edge[1]);
+            graph.get(edge[1]).add(edge[0]);
+        }
+
+        boolean[] visited = new boolean[n];
+        if (!dfs(0, -1, graph, visited)) return false;
+
+        for (boolean v : visited) if(!v) return false;
+
+        return true;
+    }
+
+    private boolean dfs(int node, int parent, List<List<Integer>> graph, boolean[] visited) {
+        visited[node] = true;
+
+        for (int neighbor : graph.get(node)) {
+            if (neighbor == parent) continue;
+            if (visited[neighbor]) return false;
+            if (!dfs(neighbor, node, graph, visited)) return false;
+        }
+        return true;
+    }
+}

insert-interval/TonyKim9401.java

@@ -0,0 +1,32 @@
+// TC: O(n)
+// must retrieve all elements
+// SC: O(n)
+// need the same size of memory space in the worst case
+class Solution {
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        List<int[]> output = new ArrayList<>();
+
+        int i = 0;
+        int n = intervals.length;
+
+        while (i < n && intervals[i][1] < newInterval[0]) {
+            output.add(intervals[i]);
+            i += 1;
+        }
+
+        while (i < n && intervals[i][0] <= newInterval[1]) {
+            newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
+            newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
+            i += 1;
+        }
+
+        output.add(newInterval);
+
+        while (i < n) {
+            output.add(intervals[i]);
+            i += 1;
+        }
+
+        return output.toArray(new int[output.size()][]);
+    }
+}

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

@@ -0,0 +1,15 @@
+// TC: O(n)
+// visiting all nodes
+// SC: O(1)
+// constant space complexity
+class Solution {
+    public int maxDepth(TreeNode root) {
+        return getMax(root, 0);
+    }
+
+    private int getMax(TreeNode node, int depth) {
+        if (node == null) return depth;
+        depth += 1;
+        return Math.max(getMax(node.left, depth), getMax(node.right, depth));
+    }
+}

reorder-list/TonyKim9401.java

@@ -0,0 +1,34 @@
+// TC: O(n)
+// -> find middle, reverse, merge -> max O(n)
+// SC: O(1)
+class Solution {
+    public void reorderList(ListNode head) {
+        if (head == null || head.next == null) return;
+
+        ListNode slow = head, fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+
+        ListNode backSide = null;
+        ListNode curr = slow.next;
+        slow.next = null;
+
+        while (curr != null) {
+            ListNode temp = curr.next;
+            curr.next = backSide;
+            backSide = curr;
+            curr = temp;
+        }
+
+        ListNode first = head;
+        ListNode second = backSide;
+        while (second != null) {
+            ListNode temp = first.next;
+            first.next = second;
+            first = second;
+            second = temp;
+        }
+    }
+}