Code is Added

Author: anjha1

0629.k-inverse-pairs-array/KInversePairsArray.java

@@ -0,0 +1,25 @@
+class KInversePairsArray {
+    private final int mod = (int) Math.pow(10, 9) + 7;
+
+    public int kInversePairs(int n, int k) {
+        // n numbers can generate at most n * (n - 1) / 2 inverse pairs
+        if (k > n * (n - 1) / 2) return 0;
+        if (k == n * (n - 1) / 2 || k == 0) return 1;
+
+        int[][] dp = new int[n + 1][k + 1];
+
+        for (int i = 1; i < n + 1; i++) {
+            // deal with j = 0
+            dp[i][0] = 1;
+            for (int j = 1; j < Math.min(k, i * (i - 1) / 2) + 1; j++) {
+                dp[i][j] = (dp[i][j - 1] + dp[i - 1][j] - (j >= i ? dp[i - 1][j - i] : 0)) % mod;
+                // all dp[i][j] modulo 10^9 + 7
+                // so dp[i - 1][j - 1] might bigger than dp[i][j - 1] + dp[i - 1][j]
+                if (dp[i][j] < 0)
+                    dp[i][j] += mod;
+            }
+        }
+
+        return dp[n][k];
+    }
+}

0629.k-inverse-pairs-array/README.md

@@ -0,0 +1 @@
+# [629. K Inverse Pairs Array](https://leetcode.com/problems/k-inverse-pairs-array/)

0630.course-schedule-iii/CourseScheduleIii.java

@@ -0,0 +1,25 @@
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+class CourseScheduleIii {
+    public int scheduleCourse(int[][] courses) {
+        Arrays.sort(courses, (a, b) -> a[1] - b[1]);
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        int time = 0;
+        for (int[] course : courses) {
+            if (course[0] <= course[1]) {
+                if (course[0] + time <= course[1]) {
+                    pq.offer(course[0]);
+                    time += course[0];
+                } else {
+                    if (pq.peek() > course[0]) {
+                        time -= pq.poll();
+                        time += course[0];
+                        pq.offer(course[0]);
+                    }
+                }
+            }
+        }
+        return pq.size();
+    }
+}

0630.course-schedule-iii/README.md

@@ -0,0 +1,2 @@
+# [630. Course Schedule III](https://leetcode.com/problems/course-schedule-iii/)
+

0633.sum-of-square-numbers/README.md

@@ -0,0 +1,2 @@
+# [633. Sum of Square Numbers](https://leetcode.com/problems/sum-of-square-numbers/)
+

0633.sum-of-square-numbers/SumOfSquareNumbers.java

@@ -0,0 +1,19 @@
+class SumOfSquareNumbers {
+    public boolean judgeSquareSum(int c) {
+        if (c < 0) return false;
+
+        int i = 0, j = (int) Math.sqrt(c);
+        while (i <= j) {
+            long sum = ((long) i * i) + ((long) j * j);
+            if (sum == c) {
+                return true;
+            } else if (sum > c) {
+                j--;
+            } else {
+                i++;
+            }
+        }
+
+        return false;
+    }
+}

0637.average-of-levels-in-binary-tree/AverageOfLevelsInBinaryTree.java

@@ -0,0 +1,40 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * 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 AverageOfLevelsInBinaryTree {
+    public List<Double> averageOfLevels(TreeNode root) {
+        List<Double> ret = new ArrayList<>();
+        if (root == null) return ret;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int cnt = queue.size();
+            double sum = 0;
+            for (int i = 0; i < cnt; i++) {
+                TreeNode node = queue.poll();
+                sum += node != null ? node.val : 0;
+                if (node.left != null) queue.add(node.left);
+                if (node.right != null) queue.add(node.right);
+            }
+            ret.add(sum / cnt);
+        }
+        return ret;
+    }
+}

0637.average-of-levels-in-binary-tree/README.md

@@ -0,0 +1 @@
+# [637. Average of Levels in Binary Tree](https://leetcode.com/problems/average-of-levels-in-binary-tree/)

0645.set-mismatch/README.md

@@ -0,0 +1,2 @@
+# [645. Set Mismatch](https://leetcode.com/problems/set-mismatch/)
+

0645.set-mismatch/SetMismatch.java

@@ -0,0 +1,21 @@
+class SetMismatch {
+    private void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    public int[] findErrorNums(int[] nums) {
+        for (int i = 0; i < nums.length; i++) {
+            while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
+                swap(nums, i, nums[i] - 1);
+            }
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] != i + 1) {
+                return new int[]{nums[i], i + 1};
+            }
+        }
+        return null;
+    }
+}

0647.palindromic-substrings/PalindromicSubstrings.java

@@ -0,0 +1,19 @@
+class PalindromicSubstrings {
+    private int cnt = 0;
+
+    public void extendSubstrings(String s, int start, int end) {
+        while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
+            start--;
+            end++;
+            cnt++;
+        }
+    }
+
+    public int countSubstrings(String s) {
+        for (int i = 0; i < s.length(); i++) {
+            extendSubstrings(s, i, i);
+            extendSubstrings(s, i, i + 1);
+        }
+        return cnt;
+    }
+}

0647.palindromic-substrings/README.md

@@ -0,0 +1 @@
+# [647. Palindromic Substrings](https://leetcode.com/problems/palindromic-substrings/)

0649.dota2-senate/Dota2Senate.java

@@ -0,0 +1,26 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+class Dota2Senate {
+    public String predictPartyVictory(String senate) {
+        int n = senate.length();
+        Queue<Integer> radiant = new LinkedList<>();
+        Queue<Integer> dire = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            if (senate.charAt(i) == 'R') {
+                radiant.offer(i);
+            } else {
+                dire.offer(i);
+            }
+        }
+        while (!radiant.isEmpty() && !dire.isEmpty()) {
+            int radiantIndex = radiant.poll(), direIndex = dire.poll();
+            if (radiantIndex < direIndex) {
+                radiant.offer(radiantIndex + n);
+            } else {
+                dire.offer(direIndex + n);
+            }
+        }
+        return !radiant.isEmpty() ? "Radiant" : "Dire";
+    }
+}

0649.dota2-senate/README.md

@@ -0,0 +1,7 @@
+# [649. Dota2 Senate](https://leetcode.com/problems/dota2-senate/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `senate`.
+- Space Complexity: $O(n)$.

0652.find-duplicate-subtrees/FindDuplicateSubtrees.java

@@ -0,0 +1,44 @@
+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 FindDuplicateSubtrees {
+    Map<String, Pair<TreeNode, Integer>> seen = new HashMap<>();
+    Set<TreeNode> repeat = new HashSet<>();
+    int idx = 0;
+
+    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
+        dfs(root);
+        return new ArrayList<>(repeat);
+    }
+
+    private int dfs(TreeNode node) {
+        if (node == null)
+            return 0;
+
+        int[] tri = {node.val, dfs(node.left), dfs(node.right)};
+        String hash = Arrays.toString(tri);
+        if (seen.containsKey(hash)) {
+            Pair<TreeNode, Integer> pair = seen.get(hash);
+            repeat.add(pair.getKey());
+            return pair.getValue();
+        } else {
+            seen.put(hash, new Pair<>(node, ++idx));
+            return idx;
+        }
+    }
+}

0652.find-duplicate-subtrees/README.md

@@ -0,0 +1,8 @@
+# [652. Find Duplicate Subtrees](https://leetcode.com/problems/find-duplicate-subtrees/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the amount of nodes.
+- Space Complexity: $O(n)$. Hash map costs $O(n)$ space complexity.

0653.two-sum-iv-input-is-a-bst/README.md

@@ -0,0 +1,2 @@
+# [653. Two Sum IV - Input is a BST](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/)
+

0653.two-sum-iv-input-is-a-bst/TwoSumIvInputIsABst.java

@@ -0,0 +1,39 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 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 TwoSumIvInputIsABst {
+    private void inOrder(TreeNode root, List<Integer> nums) {
+        if (root == null) return;
+        inOrder(root.left, nums);
+        nums.add(root.val);
+        inOrder(root.right, nums);
+    }
+
+    public boolean findTarget(TreeNode root, int k) {
+        List<Integer> nums = new ArrayList<>();
+        inOrder(root, nums);
+        int i = 0, j = nums.size() - 1;
+        while (i < j) {
+            int sum = nums.get(i) + nums.get(j);
+            if (sum == k) return true;
+            if (sum < k) i++;
+            else j--;
+        }
+        return false;
+    }
+}

0658.find-k-closest-elements/FindKClosestElements.java

@@ -0,0 +1,17 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class FindKClosestElements {
+    public List<Integer> findClosestElements(int[] arr, int k, int x) {
+        List<Integer> res = new ArrayList<>();
+        int low = 0, high = arr.length - 1;
+        while (high - low >= k) {
+            int diffLow = Math.abs(arr[low] - x);
+            int diffHigh = Math.abs(arr[high] - x);
+            if (diffLow <= diffHigh) high--;
+            else low++;
+        }
+        while (low <= high) res.add(arr[low++]);
+        return res;
+    }
+}

0658.find-k-closest-elements/README.md

@@ -0,0 +1,2 @@
+# [658. Find K Closest Elements](https://leetcode.com/problems/find-k-closest-elements/)
+

0659.split-array-into-consecutive-subsequences/README.md

@@ -0,0 +1,2 @@
+# [659. Split Array into Consecutive Subsequences](https://leetcode.com/problems/split-array-into-consecutive-subsequences/)
+

0659.split-array-into-consecutive-subsequences/SplitArrayIntoConsecutiveSubsequences.java

@@ -0,0 +1,38 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+class SplitArrayIntoConsecutiveSubsequences {
+    public boolean isPossible(int[] nums) {
+        if (nums.length < 3) return false;
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>(map.keySet().size());
+        pq.addAll(map.keySet());
+
+        while (!pq.isEmpty()) {
+            int min = pq.peek();
+            int count = 0;
+            while (true) {
+                if (!map.containsKey(min)) {
+                    if (count < 3) return false;
+                    break;
+                }
+                map.put(min, map.get(min) - 1);
+                count++;
+                if (map.get(min) == 0) {
+                    if (pq.peek() != null && min != pq.peek()) return false;
+                    pq.poll();
+                }
+                if (map.containsKey(min + 1) && map.get(min) + 1 > map.get(min + 1)) {
+                    if (count < 3) return false;
+                    break;
+                }
+                min++;
+            }
+        }
+        return true;
+    }
+}