Solution is Added

Author: anjha1

0424.longest-repeating-character-replacement/LongestRepeatingCharacterReplacement.java

@@ -0,0 +1,15 @@
+class LongestRepeatingCharacterReplacement {
+    public int characterReplacement(String s, int k) {
+        int[] count = new int[26];
+        int start = 0, maxCount = 0, maxLength = 0;
+        for (int end = 0; end < s.length(); end++) {
+            maxCount = Math.max(maxCount, ++count[s.charAt(end) - 'A']);
+            while (end - start + 1 - maxCount > k) {
+                count[s.charAt(start) - 'A']--;
+                start++;
+            }
+            maxLength = Math.max(maxLength, end - start + 1);
+        }
+        return maxLength;
+    }
+}

0424.longest-repeating-character-replacement/README.md

@@ -0,0 +1,2 @@
+# [424. Longest Repeating Character Replacement](https://leetcode.com/problems/longest-repeating-character-replacement/)
+

0427.construct-quad-tree/ConstructQuadTree.java

@@ -0,0 +1,72 @@
+/*
+// Definition for a QuadTree node.
+class Node {
+    public boolean val;
+    public boolean isLeaf;
+    public Node topLeft;
+    public Node topRight;
+    public Node bottomLeft;
+    public Node bottomRight;
+
+    
+    public Node() {
+        this.val = false;
+        this.isLeaf = false;
+        this.topLeft = null;
+        this.topRight = null;
+        this.bottomLeft = null;
+        this.bottomRight = null;
+    }
+    
+    public Node(boolean val, boolean isLeaf) {
+        this.val = val;
+        this.isLeaf = isLeaf;
+        this.topLeft = null;
+        this.topRight = null;
+        this.bottomLeft = null;
+        this.bottomRight = null;
+    }
+    
+    public Node(boolean val, boolean isLeaf, Node topLeft, Node topRight, Node bottomLeft, Node bottomRight) {
+        this.val = val;
+        this.isLeaf = isLeaf;
+        this.topLeft = topLeft;
+        this.topRight = topRight;
+        this.bottomLeft = bottomLeft;
+        this.bottomRight = bottomRight;
+    }
+};
+*/
+
+class ConstructQuadTree {
+    public QuadNode construct(int[][] grid) {
+        return dfs(grid, 0, 0, grid.length, grid.length);
+    }
+
+    public QuadNode dfs(int[][] grid, int r0, int c0, int r1, int c1) {
+        boolean same = true;
+        for (int i = r0; i < r1; i++) {
+            for (int j = c0; j < c1; j++) {
+                if (grid[i][j] != grid [r0][c0]) {
+                    same = false;
+                    break;
+                }
+            }
+            if (!same) {
+                break;
+            }
+        }
+
+        if (same)
+            return new QuadNode(grid[r0][c0] == 1, true);
+
+        return new QuadNode(
+                true,
+                false,
+                dfs(grid, r0, c0, (r0 + r1) / 2, (c0 + c1) / 2),
+                dfs(grid, r0, (c0 + c1) / 2, (r0 + r1) / 2, c1),
+                dfs(grid, (r0 + r1) / 2, c0, r1, (c0 + c1) / 2),
+                dfs(grid, (r0 + r1) / 2, (c0 + c1) / 2, r1, c1)
+        );
+    }
+}

0427.construct-quad-tree/README.md

@@ -0,0 +1,7 @@
+# [427. Construct Quad Tree](https://leetcode.com/problems/construct-quad-tree/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n^2\log n)$. $T(n)=4T(\frac{n}{2})+O(n^2)$. According to master theorem, the time complexity is $O(n^2\log n)$.
+- Space Complexity: $O(\log n)$. Every recursion has half of `n`, so the space complexity is $O(\log n)$.

0429.n-ary-tree-level-order-traversal/NAryTreeLevelOrderTraversal.java

@@ -0,0 +1,50 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+import java.util.ArrayList;
+import java.util.List;
+
+class NAryTreeLevelOrderTraversal {
+    private final List<List<Integer>> res = new ArrayList<>();
+
+    private void BFS(Node root, int level) {
+        if (root == null) return;
+        List<Integer> levelList;
+        if (res.size() < level + 1) {
+            levelList = new ArrayList<>();
+            levelList.add(root.val);
+            res.add(levelList);
+        } else {
+            levelList = res.get(level);
+            levelList.add(root.val);
+            res.remove(level);
+            res.add(level, levelList);
+        }
+        if (root.children != null) {
+            for (Node node : root.children) {
+                BFS(node, level + 1);
+            }
+        }
+    }
+
+    public List<List<Integer>> levelOrder(Node root) {
+        BFS(root, 0);
+        return res;
+    }
+}

0429.n-ary-tree-level-order-traversal/README.md

@@ -0,0 +1,2 @@
+# [429. N-ary Tree Level Order Traversal](https://leetcode.com/problems/n-ary-tree-level-order-traversal/)
+

0433.minimum-genetic-mutation/MinimumGeneticMutation.java

@@ -0,0 +1,32 @@
+import java.util.*;
+
+class MinimumGeneticMutation {
+    public int minMutation(String start, String end, String[] bank) {
+        Queue<String> queue = new LinkedList<>();
+        Set<String> seen = new HashSet<>();
+        queue.add(start);
+        seen.add(start);
+
+        int steps = 0;
+
+        while (!queue.isEmpty()) {
+            int nodesInQueue = queue.size();
+            for (int j = 0; j < nodesInQueue; j++) {
+                String node = queue.remove();
+                if (node.equals(end)) return steps;
+                for (char c : new char[]{'A', 'C', 'G', 'T'}) {
+                    for (int i = 0; i < node.length(); i++) {
+                        String neighbor = node.substring(0, i) + c + node.substring(i + 1);
+                        if (!seen.contains(neighbor) && Arrays.asList(bank).contains(neighbor)) {
+                            queue.add(neighbor);
+                            seen.add(neighbor);
+                        }
+                    }
+                }
+            }
+            steps++;
+        }
+
+        return -1;
+    }
+}

0433.minimum-genetic-mutation/README.md

@@ -0,0 +1,2 @@
+# [433. Minimum Genetic Mutation](https://leetcode.com/problems/minimum-genetic-mutation/)
+

0435.non-overlapping-intervals/NonOverlappingIntervals.java

@@ -0,0 +1,21 @@
+import java.util.Arrays;
+import java.util.Comparator;
+
+class NonOverlappingIntervals {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        if (intervals.length == 0) {
+            return 0;
+        }
+        Arrays.sort(intervals, Comparator.comparingInt(o -> o[1]));
+        int cnt = 1;
+        int end = intervals[0][1];
+        for (int i = 1; i < intervals.length; i++) {
+            if (intervals[i][0] < end) {
+                continue;
+            }
+            end = intervals[i][1];
+            cnt++;
+        }
+        return intervals.length - cnt;
+    }
+}

0435.non-overlapping-intervals/README.md

@@ -0,0 +1,2 @@
+# [435. Non-overlapping Intervals](https://leetcode.com/problems/non-overlapping-intervals/)
+

0437.path-sum-iii/PathSumIii.java

@@ -0,0 +1,29 @@
+/**
+ * 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 PathSumIii {
+    private int pathSumStartWithRoot(TreeNode root, long sum) {
+        if (root == null) return 0;
+        int ret = 0;
+        if (root.val == sum) ret++;
+        ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
+        return ret;
+    }
+
+    public int pathSum(TreeNode root, int targetSum) {
+        if (root == null) return 0;
+        return pathSumStartWithRoot(root, targetSum) + pathSum(root.left, targetSum) + pathSum(root.right, targetSum);
+    }
+}

0437.path-sum-iii/README.md

@@ -0,0 +1,2 @@
+# [437. Path Sum III](https://leetcode.com/problems/path-sum-iii/)
+

0438.find-all-anagrams-in-a-string/FindAllAnagramsInAString.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+class FindAllAnagramsInAString {
+    public List<Integer> findAnagrams(String s, String p) {
+        int n = s.length(), m = p.length();
+
+        if (n < m)
+            return new ArrayList<>();
+
+        List<Integer> res = new ArrayList<>();
+        int[] sCount = new int[26];
+        int[] pCount = new int[26];
+        for (int i = 0; i < m; i++) {
+            sCount[s.charAt(i) - 'a']++;
+            pCount[p.charAt(i) - 'a']++;
+        }
+
+        if (Arrays.equals(sCount, pCount))
+            res.add(0);
+
+        for (int i = 0; i < n - m; i++) {
+            sCount[s.charAt(i) - 'a']--;
+            sCount[s.charAt(i + m) - 'a']++;
+
+            if (Arrays.equals(sCount, pCount))
+                res.add(i + 1);
+        }
+
+        return res;
+    }
+}

0438.find-all-anagrams-in-a-string/README.md

@@ -0,0 +1,7 @@
+# [438. Find All Anagrams in a String](https://leetcode.com/problems/find-all-anagrams-in-a-string/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n-m)$. $n$ is the length of `s` and $m$ is the length of `p`. The first loop costs $O(n)$ and the second loop costs $O(26\times(n-m))$. The total time complexity is $O(26n-25m)=O(n-m)$.
+- Space Complexity: $O(1)$. The size of `sCount` and `pCount` is 26 which is constant. Thus, the total space complexity is $O(1)$.

0443.string-compression/README.md

@@ -0,0 +1,7 @@
+# [443. String Compression](https://leetcode.com/problems/string-compression/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `chars`.
+- Space Complexity: $O(1)$.

0443.string-compression/StringCompression.java

@@ -0,0 +1,20 @@
+class StringCompression {
+    public int compress(char[] chars) {
+        int n = chars.length;
+        int write = 0, left = 0;
+        for (int read = 0; read < n; read++) {
+            if (read == n - 1 || chars[read] != chars[read + 1]) {
+                chars[write++] = chars[read];
+                int cnt = read - left + 1;
+                if (cnt > 1) {
+                    String str = String.valueOf(cnt);
+                    for (int i = 0; i < str.length(); i++) {
+                        chars[write++] = str.charAt(i);
+                    }
+                }
+                left = read + 1;
+            }
+        }
+        return write;
+    }
+}

0445.add-two-numbers-ii/AddTwoNumbersIi.java

@@ -0,0 +1,39 @@
+import java.util.Stack;
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class AddTwoNumbersIi {
+    private Stack<Integer> buildStack(ListNode l) {
+        Stack<Integer> stack = new Stack<>();
+        while (l != null) {
+            stack.push(l.val);
+            l = l.next;
+        }
+        return stack;
+    }
+
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        Stack<Integer> l1Stack = buildStack(l1);
+        Stack<Integer> l2Stack = buildStack(l2);
+        ListNode head = new ListNode(-1);
+        int carry = 0;
+        while (!l1Stack.empty() || !l2Stack.empty() || carry != 0) {
+            int x = l1Stack.isEmpty() ? 0 : l1Stack.pop();
+            int y = l2Stack.isEmpty() ? 0 : l2Stack.pop();
+            int sum = x + y + carry;
+            ListNode node = new ListNode(sum % 10);
+            node.next = head.next;
+            head.next = node;
+            carry = sum / 10;
+        }
+        return head.next;
+    }
+}

0445.add-two-numbers-ii/README.md

@@ -0,0 +1,2 @@
+# [445. Add Two Numbers II](https://leetcode.com/problems/add-two-numbers-ii/)
+

0446.arithmetic-slices-ii-subsequence/ArithmeticSlicesIiSubsequence.java

@@ -0,0 +1,23 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class ArithmeticSlicesIiSubsequence {
+    public int numberOfArithmeticSlices(int[] nums) {
+        int ans = 0;
+        int n = nums.length;
+        Map<Long, Integer>[] f = new Map[n];
+        for (int i = 0; i < n; i++) {
+            f[i] = new HashMap<>();
+        }
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < i; j++) {
+                long d = (long) nums[i] - nums[j];
+                int cnt = f[j].getOrDefault(d, 0);
+                ans += cnt;
+                f[i].put(d, f[i].getOrDefault(d, 0) + cnt + 1);
+            }
+        }
+        return ans;
+    }
+}