Today My Solution is Added

Author: anjha1

0208.implement-trie-prefix-tree/ImplementTriePrefixTree.java

@@ -0,0 +1,63 @@
+class Trie {
+    private class Node {
+        Node[] childs = new Node[26];
+        boolean isLeaf;
+    }
+
+    private Node root = new Node();
+
+    private int indexForChar(char c) {
+        return c - 'a';
+    }
+
+    public Trie() {
+        
+    }
+
+    private void insert(String word, Node node) {
+        if (node == null) return;
+        if (word.length() == 0) {
+            node.isLeaf = true;
+            return;
+        }
+        int index = indexForChar(word.charAt(0));
+        if (node.childs[index] == null) {
+            node.childs[index] = new Node();
+        }
+        insert(word.substring(1), node.childs[index]);
+    }
+    
+    public void insert(String word) {
+        insert(word, root);
+    }
+
+    private boolean search(String word, Node node) {
+        if (node == null) return false;
+        if (word.length() == 0) return node.isLeaf;
+        int index = indexForChar(word.charAt(0));
+        return search(word.substring(1), node.childs[index]);
+    }
+    
+    public boolean search(String word) {
+        return search(word, root);
+    }
+
+    private boolean startWith(String prefix, Node node) {
+        if (node == null) return false;
+        if (prefix.length() == 0) return true;
+        int index = indexForChar(prefix.charAt(0));
+        return startWith(prefix.substring(1), node.childs[index]);
+    }
+    
+    public boolean startsWith(String prefix) {
+        return startWith(prefix, root);
+    }
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * boolean param_2 = obj.search(word);
+ * boolean param_3 = obj.startsWith(prefix);
+ */

0208.implement-trie-prefix-tree/README.md

@@ -0,0 +1,3 @@
+# [208. Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree/)
+
+\

0209.minimum-size-subarray-sum/MinimumSizeSubarraySum.java

@@ -0,0 +1,13 @@
+class MinimumSizeSubarraySum {
+    public int minSubArrayLen(int target, int[] nums) {
+        int sum = 0, left = 0, res = Integer.MAX_VALUE;
+        for (int right = 0; right < nums.length; right++) {
+            sum += nums[right];
+            while (sum >= target) {
+                res = Math.min(res, right - left + 1);
+                sum -= nums[left++];
+            }
+        }
+        return res == Integer.MAX_VALUE ? 0 : res;
+    }
+}

0209.minimum-size-subarray-sum/README.md

@@ -0,0 +1 @@
+# [209. Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum/)

0210.course-schedule-ii/CourseScheduleIi.java

@@ -0,0 +1,47 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+class CourseScheduleIi {
+    private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked, List<Integer>[] graphic, int curNode, Stack<Integer> postOrder) {
+        if (localMarked[curNode]) {
+            return true;
+        }
+        if (globalMarked[curNode]) {
+            return false;
+        }
+        globalMarked[curNode] = true;
+        localMarked[curNode] = true;
+        for (int nextNode : graphic[curNode]) {
+            if (hasCycle(globalMarked, localMarked, graphic, nextNode, postOrder)) {
+                return true;
+            }
+        }
+        localMarked[curNode] = false;
+        postOrder.push(curNode);
+        return false;
+    }
+
+    public int[] findOrder(int numCourses, int[][] prerequisites) {
+        List<Integer>[] graphic = new List[numCourses];
+        for (int i = 0; i < numCourses; i++) {
+            graphic[i] = new ArrayList<>();
+        }
+        for (int[] pre : prerequisites) {
+            graphic[pre[0]].add(pre[1]);
+        }
+        Stack<Integer> postOder = new Stack<>();
+        boolean[] globalMarked = new boolean[numCourses];
+        boolean[] localMarked = new boolean[numCourses];
+        for (int i = 0; i < numCourses; i++) {
+            if (hasCycle(globalMarked, localMarked, graphic, i, postOder)) {
+                return new int[0];
+            }
+        }
+        int[] orders = new int[numCourses];
+        for (int i = numCourses - 1; i >= 0; i--) {
+            orders[i] = postOder.pop();
+        }
+        return orders;
+    }
+}

0210.course-schedule-ii/README.md

@@ -0,0 +1,2 @@
+# [210. Course Schedule II](https://leetcode.com/problems/course-schedule-ii/)
+

0215.kth-largest-element-in-an-array/KthLargestElementInAnArray.java

@@ -0,0 +1,8 @@
+import java.util.Arrays;
+
+class KthLargestElementInAnArray {
+    public int findKthLargest(int[] nums, int k) {
+        Arrays.sort(nums);
+        return nums[nums.length - k];
+    }
+}

0215.kth-largest-element-in-an-array/README.md

@@ -0,0 +1 @@
+# [215. Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/)

0217.contains-duplicate/ContainsDuplicate.java

@@ -0,0 +1,12 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class ContainsDuplicate {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+        return set.size() < nums.length;
+    }
+}

0217.contains-duplicate/README.md

@@ -0,0 +1,2 @@
+# [217. Contains Duplicate](https://leetcode.com/problems/contains-duplicate/)
+

0218.the-skyline-problem/README.md

@@ -0,0 +1,2 @@
+# [218. The Skyline Problem](https://leetcode.com/problems/the-skyline-problem/)
+

0218.the-skyline-problem/TheSkylineProblem.java

@@ -0,0 +1,29 @@
+import java.util.*;
+
+class TheSkylineProblem {
+    public List<List<Integer>> getSkyline(int[][] buildings) {
+        List<List<Integer>> res = new ArrayList<>();
+        List<int[]> height = new ArrayList<>();
+        for (int[] b : buildings) {
+            height.add(new int[]{b[0], -b[2]});
+            height.add(new int[]{b[1], b[2]});
+        }
+        height.sort((a, b) -> {
+            if (a[0] != b[0]) return a[0] - b[0];
+            else return a[1] - b[1];
+        });
+        Queue<Integer> pq = new PriorityQueue<>((a, b) -> (b - a));
+        pq.offer(0);
+        int prev = 0;
+        for (int[] h : height) {
+            if (h[1] < 0) pq.offer(-h[1]);
+            else pq.remove(h[1]);
+            int cur = pq.peek() != null ? pq.peek() : 0;
+            if (prev != cur) {
+                res.add(Arrays.asList(h[0], cur));
+                prev = cur;
+            }
+        }
+        return res;
+    }
+}

0219.contains-duplicate-ii/ContainsDuplicateIi.java

@@ -0,0 +1,15 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class ContainsDuplicateIi {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            if (map.containsKey(nums[i])) {
+                if (Math.abs(map.get(nums[i]) - i) <= k) return true;
+            }
+            map.put(nums[i], i);
+        }
+        return false;
+    }
+}

0219.contains-duplicate-ii/README.md

@@ -0,0 +1,2 @@
+# [219. Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/)
+

0222.count-complete-tree-nodes/CountCompleteTreeNodes.java

@@ -0,0 +1,35 @@
+/**
+ * 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 CountCompleteTreeNodes {
+    private int leftHeight(TreeNode node) {
+        int h = 0;
+        while (node != null) {
+            h++;
+            node = node.left;
+        }
+        return h;
+    }
+
+    public int countNodes(TreeNode root) {
+        if (root == null) return 0;
+
+        int l = leftHeight(root.left);
+        int r = leftHeight(root.right);
+        if (l == r)
+            return countNodes(root.right) + (1 << l);
+        return countNodes(root.left) + (1 << r);
+    }
+}

0222.count-complete-tree-nodes/README.md

@@ -0,0 +1 @@
+# [222. Count Complete Tree Nodes](https://leetcode.com/problems/count-complete-tree-nodes/)

0223.rectangle-area/README.md

@@ -0,0 +1,2 @@
+# [223. Rectangle Area](https://leetcode.com/problems/rectangle-area/)
+

0223.rectangle-area/RectangleArea.java

@@ -0,0 +1,21 @@
+class RectangleArea {
+    public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
+        int areaOfA = (ax2 - ax1) * (ay2 - ay1);
+        int areaOfB = (bx2 - bx1) * (by2 - by1);
+
+        int left = Math.max(ax1, bx1);
+        int right = Math.min(ax2, bx2);
+        int xOverlap = right - left;
+
+        int top = Math.min(ay2, by2);
+        int bottom = Math.max(ay1, by1);
+        int yOverlap = top - bottom;
+
+        int areaOfOverlap = 0;
+        if (xOverlap > 0 && yOverlap > 0) {
+            areaOfOverlap = xOverlap * yOverlap;
+        }
+
+        return areaOfA + areaOfB - areaOfOverlap;
+    }
+}

0224.basic-calculator/BasicCalculator.java

@@ -0,0 +1,34 @@
+import java.util.Stack;
+
+class BasicCalculator {
+    public int calculate(String s) {
+        Stack<Integer> stack = new Stack<>();
+        int result = 0, number = 0, sign = 1;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (Character.isDigit(c)) {
+                number = 10 * number + (int)(c - '0');
+            } else if (c == '+') {
+                result += sign * number;
+                number = 0;
+                sign = 1;
+            } else if (c == '-') {
+                result += sign * number;
+                number = 0;
+                sign = -1;
+            } else if (c == '(') {
+                stack.push(result);
+                stack.push(sign);
+                sign = 1;
+                result = 0;
+            } else if (c == ')') {
+                result += sign * number;
+                number = 0;
+                result *= stack.pop();
+                result += stack.pop();
+            }
+        }
+        if (number != 0) result += sign * number;
+        return result;
+    }
+}

0224.basic-calculator/README.md

@@ -0,0 +1 @@
+# [224. Basic Calculator](https://leetcode.com/problems/basic-calculator/)

0225.implement-stack-using-queues/ImplementStackUsingQueues.java

@@ -0,0 +1,40 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+class MyStack {
+    private Queue<Integer> queue;
+
+    public MyStack() {
+        queue = new LinkedList<>();
+    }
+    
+    public void push(int x) {
+        queue.add(x);
+        int cnt = queue.size();
+        while (cnt -- > 1) {
+            queue.add(queue.poll());
+        }
+    }
+    
+    public int pop() {
+        return queue.remove();
+    }
+    
+    public int top() {
+        if (queue.isEmpty()) return 0;
+        return queue.peek();
+    }
+    
+    public boolean empty() {
+        return queue.isEmpty();
+    }
+}
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * MyStack obj = new MyStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.top();
+ * boolean param_4 = obj.empty();
+ */

0225.implement-stack-using-queues/README.md

@@ -0,0 +1,2 @@
+# [225. Implement Stack using Queues](https://leetcode.com/problems/implement-stack-using-queues/)
+

0226.invert-binary-tree/InvertBinaryTree.java

@@ -0,0 +1,24 @@
+/**
+ * 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 InvertBinaryTree {
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) return null;
+        TreeNode left = root.left;
+        root.left = invertTree(root.right);
+        root.right = invertTree(left);
+        return root;
+    }
+}