Added taks 3309-3321

Author: javadev

README.md

@@ -434,7 +434,7 @@
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0117 |[Populating Next Right Pointers in Each Node II](src/main/java/g0101_0200/s0117_populating_next_right_pointers_in_each_node_ii)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Linked_List | 0 | 100.00
-| 0572 |[Subtree of Another Tree](src/main/java/g0501_0600/s0572_subtree_of_another_tree)| Easy | Depth_First_Search, Tree, Binary_Tree, Hash_Function, String_Matching | 1 | 100.00
+| 0572 |[Subtree of Another Tree](src/main/java/g0501_0600/s0572_subtree_of_another_tree)| Easy | Depth_First_Search, Tree, Binary_Tree, Hash_Function, String_Matching | 2 | 97.06
 
 #### Day 8 Breadth First Search Depth First Search
 
@@ -1816,6 +1816,18 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3321 |[Find X-Sum of All K-Long Subarrays II](src/main/java/g3301_3400/s3321_find_x_sum_of_all_k_long_subarrays_ii)| Hard | Array, Hash_Table, Heap_Priority_Queue, Sliding_Window | 410 | 94.03
+| 3320 |[Count The Number of Winning Sequences](src/main/java/g3301_3400/s3320_count_the_number_of_winning_sequences)| Hard | String, Dynamic_Programming | 43 | 99.76
+| 3319 |[K-th Largest Perfect Subtree Size in Binary Tree](src/main/java/g3301_3400/s3319_k_th_largest_perfect_subtree_size_in_binary_tree)| Medium | Sorting, Tree, Binary_Tree, Depth_First_Search | 10 | 87.48
+| 3318 |[Find X-Sum of All K-Long Subarrays I](src/main/java/g3301_3400/s3318_find_x_sum_of_all_k_long_subarrays_i)| Easy | Array, Hash_Table, Heap_Priority_Queue, Sliding_Window | 11 | 77.35
+| 3317 |[Find the Number of Possible Ways for an Event](src/main/java/g3301_3400/s3317_find_the_number_of_possible_ways_for_an_event)| Hard | Dynamic_Programming, Math, Combinatorics | 20 | 97.08
+| 3316 |[Find Maximum Removals From Source String](src/main/java/g3301_3400/s3316_find_maximum_removals_from_source_string)| Medium | Array, String, Hash_Table, Dynamic_Programming, Two_Pointers | 10 | 100.00
+| 3315 |[Construct the Minimum Bitwise Array II](src/main/java/g3301_3400/s3315_construct_the_minimum_bitwise_array_ii)| Medium | Array, Bit_Manipulation | 1 | 100.00
+| 3314 |[Construct the Minimum Bitwise Array I](src/main/java/g3301_3400/s3314_construct_the_minimum_bitwise_array_i)| Easy | Array, Bit_Manipulation | 3 | 92.32
+| 3312 |[Sorted GCD Pair Queries](src/main/java/g3301_3400/s3312_sorted_gcd_pair_queries)| Hard | Array, Hash_Table, Math, Binary_Search, Prefix_Sum, Counting, Number_Theory, Combinatorics | 29 | 94.69
+| 3311 |[Construct 2D Grid Matching Graph Layout](src/main/java/g3301_3400/s3311_construct_2d_grid_matching_graph_layout)| Hard | Array, Hash_Table, Matrix, Graph | 43 | 94.34
+| 3310 |[Remove Methods From Project](src/main/java/g3301_3400/s3310_remove_methods_from_project)| Medium | Graph, Depth_First_Search, Breadth_First_Search | 41 | 99.76
+| 3309 |[Maximum Possible Number by Binary Concatenation](src/main/java/g3301_3400/s3309_maximum_possible_number_by_binary_concatenation)| Medium | Array, Bit_Manipulation, Enumeration | 3 | 97.01
 | 3307 |[Find the K-th Character in String Game II](src/main/java/g3301_3400/s3307_find_the_k_th_character_in_string_game_ii)| Hard | Math, Bit_Manipulation, Recursion | 1 | 99.65
 | 3306 |[Count of Substrings Containing Every Vowel and K Consonants II](src/main/java/g3301_3400/s3306_count_of_substrings_containing_every_vowel_and_k_consonants_ii)| Medium | String, Hash_Table, Sliding_Window | 340 | 44.09
 | 3305 |[Count of Substrings Containing Every Vowel and K Consonants I](src/main/java/g3301_3400/s3305_count_of_substrings_containing_every_vowel_and_k_consonants_i)| Medium | String, Hash_Table, Sliding_Window | 2 | 99.72
@@ -3980,7 +3992,7 @@
 | 0577 |[Employee Bonus](src/main/java/g0501_0600/s0577_employee_bonus)| Easy | Database | 1473 | 95.83
 | 0576 |[Out of Boundary Paths](src/main/java/g0501_0600/s0576_out_of_boundary_paths)| Medium | Dynamic_Programming | 5 | 92.95
 | 0575 |[Distribute Candies](src/main/java/g0501_0600/s0575_distribute_candies)| Easy | Array, Hash_Table | 67 | 42.81
-| 0572 |[Subtree of Another Tree](src/main/java/g0501_0600/s0572_subtree_of_another_tree)| Easy | Depth_First_Search, Tree, Binary_Tree, Hash_Function, String_Matching, Algorithm_II_Day_7_Breadth_First_Search_Depth_First_Search | 1 | 100.00
+| 0572 |[Subtree of Another Tree](src/main/java/g0501_0600/s0572_subtree_of_another_tree)| Easy | Depth_First_Search, Tree, Binary_Tree, Hash_Function, String_Matching, Algorithm_II_Day_7_Breadth_First_Search_Depth_First_Search | 2 | 97.06
 | 0570 |[Managers with at Least 5 Direct Reports](src/main/java/g0501_0600/s0570_managers_with_at_least_5_direct_reports)| Medium | Database | 503 | 69.79
 | 0567 |[Permutation in String](src/main/java/g0501_0600/s0567_permutation_in_string)| Medium | Top_100_Liked_Questions, String, Hash_Table, Two_Pointers, Sliding_Window, Algorithm_I_Day_6_Sliding_Window | 5 | 93.93
 | 0566 |[Reshape the Matrix](src/main/java/g0501_0600/s0566_reshape_the_matrix)| Easy | Array, Matrix, Simulation, Data_Structure_I_Day_4_Array, Programming_Skills_I_Day_7_Array | 1 | 90.08

src/main/java/g0201_0300/s0208_implement_trie_prefix_tree/readme.md

@@ -43,7 +43,7 @@ Implement the Trie class:
 ```java
 @SuppressWarnings("java:S1104")
 public class Trie {
-    private TrieNode root;
+    private final TrieNode root;
     private boolean startWith;
 
     private static class TrieNode {
@@ -82,7 +82,7 @@ public class Trie {
         return search(word, root, 0);
     }
 
-    public boolean search(String word, TrieNode root, int idx) {
+    private boolean search(String word, TrieNode root, int idx) {
         if (idx == word.length()) {
             startWith = true;
             return root.isWord;

src/main/java/g0401_0500/s0432_all_oone_data_structure/readme.md

@@ -111,12 +111,12 @@ public class AllOne {
 
     /* Returns one of the keys with maximal value. */
     public String getMaxKey() {
-        return tail.pre == head ? "" : (String) tail.pre.keySet.iterator().next();
+        return tail.pre == head ? "" : tail.pre.keySet.iterator().next();
     }
 
     /* Returns one of the keys with Minimal value. */
     public String getMinKey() {
-        return head.next == tail ? "" : (String) head.next.keySet.iterator().next();
+        return head.next == tail ? "" : head.next.keySet.iterator().next();
     }
 
     // helper function to make change on given key according to offset

src/main/java/g0501_0600/s0572_subtree_of_another_tree/readme.md

@@ -53,30 +53,30 @@ import com_github_leetcode.TreeNode;
  * }
  */
 public class Solution {
-    private boolean isSubtreeFound(TreeNode root, TreeNode subRoot) {
-        if (root == null && subRoot == null) {
+    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
+        if (root == null) {
+            return false;
+        }
+        if (traverse(root, subRoot)) {
             return true;
         }
-        if (root == null || subRoot == null) {
+        return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
+    }
+
+    private boolean traverse(TreeNode root, TreeNode subRoot) {
+        if (root == null && subRoot != null) {
             return false;
         }
-        if (root.val == subRoot.val) {
-            return isSubtreeFound(root.left, subRoot.left) && isSubtree(root.right, subRoot.right);
-        } else {
+        if (root != null && subRoot == null) {
             return false;
         }
-    }
-
-    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
-        if (root == null && subRoot == null) {
+        if (root == null) {
             return true;
         }
-        if (root == null || subRoot == null) {
+        if (root.val != subRoot.val) {
             return false;
         }
-        return isSubtreeFound(root, subRoot)
-                || isSubtree(root.left, subRoot)
-                || isSubtree(root.right, subRoot);
+        return traverse(root.left, subRoot.left) && traverse(root.right, subRoot.right);
     }
 }
 ```

src/main/java/g0801_0900/s0843_guess_the_word/readme.md

@@ -60,7 +60,7 @@ import java.util.List;
  * }
  */
 public class Solution {
-    interface Master {
+    public interface Master {
         int guess(String word);
     }
 

src/main/java/g1101_1200/s1191_k_concatenation_maximum_sum/readme.md

@@ -41,13 +41,13 @@ As the answer can be very large, return the answer **modulo** <code>10<sup>9</su
 
 ```java
 public class Solution {
-    private long mod = 1000000007;
+    private static final long MOD = 1000000007;
 
     public int kConcatenationMaxSum(int[] arr, int k) {
         // int kadane = Kadane(arr);
         // #1 when k 1 simply calculate kadanes
         if (k == 1) {
-            return (int) (kadane(arr) % mod);
+            return (int) (kadane(arr) % MOD);
         }
         // #2 else calculate the total sum and then check if sum is -Ve or +Ve
         long totalSum = 0;
@@ -57,11 +57,11 @@ public class Solution {
         // #3 when negative then calculate of arr 2 times only the answer is in there only
         if (totalSum < 0) {
             // when -ve sum put a extra check here of max from 0
-            return (int) Math.max(kadaneTwo(arr) % mod, 0);
+            return (int) Math.max(kadaneTwo(arr) % MOD, 0);
         } else {
             // #4 when sum is positve then the ans is kadane of 2 + sum * (k-2);
             // these two are used sUm*(k-2) ensures that all other are also included
-            return (int) ((kadaneTwo(arr) + ((k - 2) * totalSum) + mod) % mod);
+            return (int) ((kadaneTwo(arr) + ((k - 2) * totalSum) + MOD) % MOD);
         }
     }
 

src/main/java/g1501_1600/s1584_min_cost_to_connect_all_points/readme.md

@@ -69,12 +69,13 @@ public class Solution {
         return cost;
     }
 
-    public void constructMST(
+    private void constructMST(
             int[] parent, int[][] points, boolean[] mst, PriorityQueue<Pair> pq, int[] dist) {
         if (!containsFalse(mst)) {
             return;
         }
         Pair newPair = pq.poll();
+        assert newPair != null;
         int pointIndex = newPair.getV();
         mst[pointIndex] = true;
         for (int i = 0; i < parent.length; i++) {

src/main/java/g2301_2400/s2400_number_of_ways_to_reach_a_position_after_exactly_k_steps/readme.md

@@ -45,7 +45,7 @@ It can be proven that no other way is possible, so we return 3.
 
 ```java
 public class Solution {
-    private int mod = 1000000007;
+    private static final int MOD = 1000000007;
 
     public int numberOfWays(int startPos, int endPos, int k) {
         if (Math.abs(endPos - startPos) > k) {
@@ -64,9 +64,9 @@ public class Solution {
         rev[1] = 1;
         int ans = k;
         for (int i = 2; i <= min; i++) {
-            rev[i] = (int) ((long) (mod - mod / i) * (long) rev[mod % i] % mod);
-            ans = (int) ((long) ans * (long) (k - i + 1) % mod);
-            ans = (int) ((long) ans * (long) rev[i] % mod);
+            rev[i] = (int) ((long) (MOD - MOD / i) * (long) rev[MOD % i] % MOD);
+            ans = (int) ((long) ans * (long) (k - i + 1) % MOD);
+            ans = (int) ((long) ans * (long) rev[i] % MOD);
         }
         return ans;
     }

src/main/java/g2501_2600/s2502_design_memory_allocator/readme.md

@@ -62,7 +62,7 @@ loc.free(7); // Free all memory units with mID 7. The memory array remains the s
 
 ```java
 public class Allocator {
-    Node root;
+    private final Node root;
 
     public Allocator(int n) {
         root = new Node(0, n, -1);
@@ -94,7 +94,7 @@ public class Allocator {
         return collapse(root, mID);
     }
 
-    public int collapse(Node cur, int id) {
+    private int collapse(Node cur, int id) {
         // base case
         if (cur == null) {
             return 0;

src/main/java/g2601_2700/s2612_minimum_reverse_operations/readme.md

@@ -59,14 +59,13 @@ In this case the 1 is initially at position 0, so the answer for that position i
 
 ```java
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 public class Solution {
     public int[] minReverseOperations(int n, int p, int[] banned, int k) {
         int[] out = new int[n];
-        for (int i = 0; i < n; i++) {
-            out[i] = -1;
-        }
+        Arrays.fill(out, -1);
         for (int node : banned) {
             out[node] = -2;
         }

src/main/java/g2801_2900/s2858_minimum_edge_reversals_so_every_node_is_reachable/readme.md

@@ -77,6 +77,7 @@ So, answer[2] = 1.
 
 ```java
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
@@ -95,9 +96,7 @@ public class Solution {
             nexts[v].add(new int[] {-1, u});
         }
         int[] res = new int[n];
-        for (int i = 0; i < n; i++) {
-            res[i] = -1;
-        }
+        Arrays.fill(res, -1);
         res[0] = dfs(nexts, 0, -1);
         Queue<Integer> queue = new LinkedList<>();
         queue.add(0);

src/main/java/g3201_3300/s3210_find_the_encrypted_string/readme.md

@@ -46,10 +46,8 @@ As all the characters are the same, the encrypted string will also be the same.
 public class Solution {
     public String getEncryptedString(String s, int k) {
         int n = s.length();
-        k = k % n;
-        StringBuilder str = new StringBuilder(s.substring(k, n));
-        str.append(s.substring(0, k));
-        return str.toString();
+        int localK = k % n;
+        return s.substring(localK, n) + s.substring(0, localK);
     }
 }
 ```

src/main/java/g3301_3400/s3309_maximum_possible_number_by_binary_concatenation/readme.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3309\. Maximum Possible Number by Binary Concatenation
+
+Medium
+
+You are given an array of integers `nums` of size 3.
+
+Return the **maximum** possible number whose _binary representation_ can be formed by **concatenating** the _binary representation_ of **all** elements in `nums` in some order.
+
+**Note** that the binary representation of any number _does not_ contain leading zeros.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 30
+
+**Explanation:**
+
+Concatenate the numbers in the order `[3, 1, 2]` to get the result `"11110"`, which is the binary representation of 30.
+
+**Example 2:**
+
+**Input:** nums = [2,8,16]
+
+**Output:** 1296
+
+**Explanation:**
+
+Concatenate the numbers in the order `[2, 8, 16]` to get the result `"10100010000"`, which is the binary representation of 1296.
+
+**Constraints:**
+
+*   `nums.length == 3`
+*   `1 <= nums[i] <= 127`
+
+## Solution
+
+```java
+public class Solution {
+    private String result = "0";
+
+    public int maxGoodNumber(int[] nums) {
+        boolean[] visited = new boolean[nums.length];
+        StringBuilder sb = new StringBuilder();
+        solve(nums, visited, 0, sb);
+        int score = 0;
+        int val;
+        for (char c : result.toCharArray()) {
+            val = c - '0';
+            score *= 2;
+            score += val;
+        }
+        return score;
+    }
+
+    private void solve(int[] nums, boolean[] visited, int pos, StringBuilder sb) {
+        if (pos == nums.length) {
+            String val = sb.toString();
+            if ((result.length() == val.length() && result.compareTo(val) < 0)
+                    || val.length() > result.length()) {
+                result = val;
+            }
+            return;
+        }
+        String cur;
+        for (int i = 0; i < nums.length; ++i) {
+            if (visited[i]) {
+                continue;
+            }
+            visited[i] = true;
+            cur = Integer.toBinaryString(nums[i]);
+            sb.append(cur);
+            solve(nums, visited, pos + 1, sb);
+            sb.setLength(sb.length() - cur.length());
+            visited[i] = false;
+        }
+    }
+}
+```