Code is Added

Author: anjha1

0981.time-based-key-value-store/README.md

@@ -0,0 +1,2 @@
+# [981. Time Based Key-Value Store](https://leetcode.com/problems/time-based-key-value-store/)
+

0981.time-based-key-value-store/TimeBasedKeyValueStore.java

@@ -0,0 +1,37 @@
+import java.util.HashMap;
+
+class TimeMap {
+    private final HashMap<String, HashMap<Integer, String>> keyTimeMap;
+
+    public TimeMap() {
+        keyTimeMap = new HashMap<>();
+    }
+    
+    public void set(String key, String value, int timestamp) {
+        if (!keyTimeMap.containsKey(key)) {
+            keyTimeMap.put(key, new HashMap<>());
+        }
+        keyTimeMap.get(key).put(timestamp, value);
+    }
+    
+    public String get(String key, int timestamp) {
+        if (!keyTimeMap.containsKey(key)) {
+            return "";
+        }
+
+        for (int currTime = timestamp; currTime >= 1; currTime--) {
+            if (keyTimeMap.get(key).containsKey(currTime)) {
+                return keyTimeMap.get(key).get(currTime);
+            }
+        }
+
+        return "";
+    }
+}
+
+/**
+ * Your TimeMap object will be instantiated and called as such:
+ * TimeMap obj = new TimeMap();
+ * obj.set(key,value,timestamp);
+ * String param_2 = obj.get(key,timestamp);
+ */

0983.minimum-cost-for-tickets/MinimumCostForTickets.java

@@ -0,0 +1,33 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class MinimumCostForTickets {
+    int[] costs;
+    Integer[] memo;
+    Set<Integer> set;
+
+    public int mincostTickets(int[] days, int[] costs) {
+        this.costs = costs;
+        memo = new Integer[366];
+        set = new HashSet<>();
+        for (int day : days) {
+            set.add(day);
+        }
+        return dp(1);
+    }
+
+    private int dp(int i) {
+        if (i > 365) {
+            return 0;
+        }
+        if (memo[i] != null) {
+            return memo[i];
+        }
+        if (set.contains(i)) {
+            memo[i] = Math.min(Math.min(dp(i + 1) + costs[0], dp(i + 7) + costs[1]), dp(i + 30) + costs[2]);
+        } else {
+            memo[i] = dp(i + 1);
+        }
+        return memo[i];
+    }
+}

0983.minimum-cost-for-tickets/README.md

@@ -0,0 +1,7 @@
+# [983. Minimum Cost For Tickets](https://leetcode.com/problems/minimum-cost-for-tickets/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(1)$. The total day is 365, so the time complexity is constant.
+- Space Complexity: $O(1)$.

0985.sum-of-even-numbers-after-queries/README.md

@@ -0,0 +1,2 @@
+# [985. Sum of Even Numbers After Queries](https://leetcode.com/problems/sum-of-even-numbers-after-queries/)
+

0985.sum-of-even-numbers-after-queries/SumOfEvenNumbersAfterQueries.java

@@ -0,0 +1,20 @@
+class SumOfEvenNumbersAfterQueries {
+    public int[] sumEvenAfterQueries(int[] nums, int[][] queries) {
+        int sum = 0;
+        for (int num : nums) {
+            if (num % 2 == 0) sum += num;
+        }
+
+        int[] res = new int[nums.length];
+
+        for (int i = 0; i < queries.length; i++) {
+            int val = queries[i][0];
+            int index = queries[i][1];
+            if (nums[index] % 2 == 0) sum -= nums[index];
+            nums[index] += val;
+            if (nums[index] % 2 == 0) sum += nums[index];
+            res[i] = sum;
+        }
+        return res;
+    }
+}

0986.interval-list-intersections/IntervalListIntersections.java

@@ -0,0 +1,18 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class IntervalListIntersections {
+    public int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
+        if (firstList.length == 0 || secondList.length == 0) return new int[][]{};
+        List<int[]> res = new ArrayList<>();
+        int i = 0, j = 0;
+        while (i < firstList.length && j < secondList.length) {
+            int low = Math.max(firstList[i][0], secondList[j][0]);
+            int high = Math.min(firstList[i][1], secondList[j][1]);
+            if (low <= high) res.add(new int[]{low, high});
+            if (firstList[i][1] < secondList[j][1]) i++;
+            else j++;
+        }
+        return res.toArray(new int[res.size()][]);
+    }
+}

0986.interval-list-intersections/README.md

@@ -0,0 +1,2 @@
+# [986. Interval List Intersections](https://leetcode.com/problems/interval-list-intersections/)
+

0987.vertical-order-traversal-of-a-binary-tree/README.md

@@ -0,0 +1,2 @@
+# [987. Vertical Order Traversal of a Binary Tree](https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree/)
+

0987.vertical-order-traversal-of-a-binary-tree/VerticalOrderTraversalOfABinaryTree.java

@@ -0,0 +1,46 @@
+import java.util.*;
+
+/**
+ * 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 VerticalOrderTraversalOfABinaryTree {
+    Map<Integer, TreeMap<Integer, PriorityQueue<Integer>>> map;
+
+    private void dfs(TreeNode root, int index, int level) {
+        if (root == null) return;
+        map.putIfAbsent(index, new TreeMap<>());
+        map.get(index).putIfAbsent(level, new PriorityQueue<>());
+        map.get(index).get(level).add(root.val);
+        dfs(root.left, index - 1, level + 1);
+        dfs(root.right, index + 1, level + 1);
+    }
+
+    public List<List<Integer>> verticalTraversal(TreeNode root) {
+        if (root == null) return null;
+        map = new TreeMap<>();
+        dfs(root, 0, 0);
+        List<List<Integer>> res = new LinkedList<>();
+        for (int key : map.keySet()) {
+            List<Integer> list = new LinkedList<>();
+            TreeMap<Integer, PriorityQueue<Integer>> tm = map.get(key);
+            for (int k : tm.keySet()) {
+                PriorityQueue<Integer> pq = tm.get(k);
+                while (!pq.isEmpty()) list.add(pq.poll());
+            }
+            res.add(list);
+        }
+        return res;
+    }
+}

0989.add-to-array-form-of-integer/AddToArrayFormOfInteger.java

@@ -0,0 +1,16 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class AddToArrayFormOfInteger {
+    public List<Integer> addToArrayForm(int[] num, int k) {
+        List<Integer> ans = new ArrayList<>();
+        for (int i = num.length - 1; i >= 0 || k > 0; i--, k /= 10) {
+            if (i >= 0)
+                k += num[i];
+            ans.add(k % 10);
+        }
+        Collections.reverse(ans);
+        return ans;
+    }
+}

0989.add-to-array-form-of-integer/README.md

@@ -0,0 +1,7 @@
+# [989. Add to Array-Form of Integer](https://leetcode.com/problems/add-to-array-form-of-integer/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(\max(n,\log k))$. $n$ is the length of `num`.
+- Space Complexity: $O(1)$.

0990.satisfiability-of-equality-equations/README.md

@@ -0,0 +1,2 @@
+# [990. Satisfiability of Equality Equations](https://leetcode.com/problems/satisfiability-of-equality-equations/)
+

0990.satisfiability-of-equality-equations/SatisfiabilityOfEqualityEquations.java

@@ -0,0 +1,23 @@
+class SatisfiabilityOfEqualityEquations {
+    int[] parent = new int[26];
+
+    private int find(int x) {
+        if (parent[x] == x) return x;
+        return parent[x] = find(parent[x]);
+    }
+
+    public boolean equationsPossible(String[] equations) {
+        for (int i = 0; i < 26; i++) parent[i] = i;
+        for (String e : equations) {
+            if (e.charAt(1) == '=') {
+                parent[find(e.charAt(0)- 'a')] = find(e.charAt(3) - 'a');
+            }
+        }
+        for (String e : equations) {
+            if (e.charAt(1) == '!' && find(e.charAt(0) - 'a') == find(e.charAt(3) - 'a')) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

0994.rotting-oranges/README.md

@@ -0,0 +1,2 @@
+# [994. Rotting Oranges](https://leetcode.com/problems/rotting-oranges/)
+

0994.rotting-oranges/RottingOranges.java

@@ -0,0 +1,32 @@
+class RottingOranges {
+    private void rotAdjacent(int[][] grid, int i, int j, int minutes) {
+        if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0 || (1 < grid[i][j] && grid[i][j] < minutes)) return;
+        else {
+            grid[i][j] = minutes;
+            rotAdjacent(grid, i - 1, j, minutes + 1);
+            rotAdjacent(grid, i + 1, j, minutes + 1);
+            rotAdjacent(grid, i, j - 1, minutes + 1);
+            rotAdjacent(grid, i, j + 1, minutes + 1);
+        }
+    }
+
+    public int orangesRotting(int[][] grid) {
+        if (grid == null || grid.length == 0) return -1;
+
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 2) rotAdjacent(grid, i, j, 2);
+            }
+        }
+
+        int minutes = 2;
+        for (int[] row : grid) {
+            for (int cell : row) {
+                if (cell == 1) return -1;
+                minutes = Math.max(minutes, cell);
+            }
+        }
+
+        return minutes - 2;
+    }
+}

0997.find-the-town-judge/FindTheTownJudge.java

@@ -0,0 +1,15 @@
+class FindTheTownJudge {
+    public int findJudge(int n, int[][] trust) {
+        int[] isTrusted = new int[n + 1];
+        int[] trustOthers = new int[n + 1];
+        for (int[] edge : trust) {
+            trustOthers[edge[0]]++;
+            isTrusted[edge[1]]++;
+        }
+        for (int i = 1; i <= n; i++) {
+            if (isTrusted[i] == n - 1 && trustOthers[i] == 0)
+                return i;
+        }
+        return -1;
+    }
+}

0997.find-the-town-judge/README.md

@@ -0,0 +1,7 @@
+# [997. Find the Town Judge](https://leetcode.com/problems/find-the-town-judge/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n+m)$. $m$ is the length of `trust` array. We first iterate the `trust` array and iterate $n$ times to find the judge. The total time complexity is $O(n+m)$.
+- Space Complexity: $O(n)$. We use two arrays to record trust other people and is trusted array. The total space complexity is $O(2n)=O(n)$.

1011.capacity-to-ship-packages-within-d-days/CapacityToShipPackagesWithinDDays.java

@@ -0,0 +1,25 @@
+import java.util.Arrays;
+
+class CapacityToShipPackagesWithinDDays {
+    public int shipWithinDays(int[] weights, int days) {
+        int left = Arrays.stream(weights).max().getAsInt();
+        int right = Arrays.stream(weights).sum();
+        while (left < right) {
+            int mid = (left + right) / 2;
+            int need = 1, curr = 0;
+            for (int weight : weights) {
+                if (curr + weight > mid) {
+                    need++;
+                    curr = 0;
+                }
+                curr += weight;
+            }
+            if (need <= days) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+}

1011.capacity-to-ship-packages-within-d-days/README.md

@@ -0,0 +1,7 @@
+# [1011. Capacity To Ship Packages Within D Days](https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $w$ is the sum of `weights` and $n$ is the length of `weights`. Binary Search costs $O(\log w)$. Also, we iterate `weights` in the binary search which costs $O(n)$. The total time complexity is $O(n\log w)$.
+- Space Complexity: $O(1)$.

1026.maximum-difference-between-node-and-ancestor/MaximumDifferenceBetweenNodeAndAncestor.java

@@ -0,0 +1,34 @@
+/**
+ * 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 MaximumDifferenceBetweenNodeAndAncestor {
+    private int result = 0;
+
+    public int maxAncestorDiff(TreeNode root) {
+        if (root == null) return 0;
+        dfs(root, root.val, root.val);
+        return result;
+    }
+
+    private void dfs(TreeNode root, int currMax, int currMin) {
+        if (root == null) return;
+        int possibleResult = Math.max(Math.abs(currMax - root.val), Math.abs(root.val - currMin));
+        result = Math.max(result, possibleResult);
+        currMax = Math.max(currMax, root.val);
+        currMin = Math.min(currMin, root.val);
+        dfs(root.left, currMax, currMin);
+        dfs(root.right, currMax, currMin);
+    }
+}

1026.maximum-difference-between-node-and-ancestor/README.md

@@ -0,0 +1,2 @@
+# [1026. Maximum Difference Between Node and Ancestor](https://leetcode.com/problems/maximum-difference-between-node-and-ancestor/)
+

1035.uncrossed-lines/README.md

@@ -0,0 +1,7 @@
+# [1035. Uncrossed Lines](https://leetcode.com/problems/uncrossed-lines/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n\times m)$.
+- Space Complexity: $O(n\times m)$.