Added tasks 2456-2461.

Author: javadev

README.md

@@ -33,36 +33,22 @@ Given a **non-empty** array `nums` containing **only positive integers**, find i
 ```java
 public class Solution {
     public boolean canPartition(int[] nums) {
-        int sum = 0;
+        int sums = 0;
         for (int num : nums) {
-            sum = sum + num;
+            sums += num;
         }
-        if (sum % 2 != 0) {
+        if (sums % 2 == 1) {
             return false;
         }
-        sum = sum / 2;
-        // if use primitive boolean array will make default value to false
-        // we need the default value "null" to help us to do the memo
-        Boolean[] dp = new Boolean[sum + 1];
-        return sumTo(nums, sum, 0, dp);
-    }
-
-    private boolean sumTo(int[] nums, int sum, int index, Boolean[] dp) {
-        if (sum == 0) {
-            return true;
-        }
-        if (sum < 0) {
-            return false;
-        }
-        if (index == nums.length) {
-            return false;
-        }
-        if (dp[sum] != null) {
-            return dp[sum];
+        sums /= 2;
+        boolean[] dp = new boolean[sums + 1];
+        dp[0] = true;
+        for (int num : nums) {
+            for (int sum = sums; sum >= num; sum--) {
+                dp[sum] = dp[sum] || dp[sum - num];
+            }
         }
-        // use the number or not use the number
-        dp[sum] = sumTo(nums, sum - nums[index], index + 1, dp) || sumTo(nums, sum, index + 1, dp);
-        return dp[sum];
+        return dp[sums];
     }
 }
 ```

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

@@ -62,7 +62,6 @@ public class Solution {
         int score = 0;
         int l = 0;
         int r = tokens.length - 1;
-
         while (l <= r) {
             if (tokens[l] <= power) {
                 power -= tokens[l];

src/main/java/g0901_1000/s0948_bag_of_tokens/readme.md

@@ -62,11 +62,9 @@ public class Solution {
                             maxi++;
                         }
                     }
-
                     if (mini == 0 || maxi == 0) {
                         break;
                     }
-
                     for (; mini != 0 && maxi != 0; ans += 1 + (i - b), a++) {
                         if (nums[a] == minK) {
                             mini--;
@@ -79,7 +77,6 @@ public class Solution {
             }
             i++;
         }
-
         return ans;
     }
 }

src/main/java/g2401_2500/s2444_count_subarrays_with_fixed_bounds/readme.md

@@ -0,0 +1,93 @@
+[![](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)
+
+## 2456\. Most Popular Video Creator
+
+Medium
+
+You are given two string arrays `creators` and `ids`, and an integer array `views`, all of length `n`. The <code>i<sup>th</sup></code> video on a platform was created by `creator[i]`, has an id of `ids[i]`, and has `views[i]` views.
+
+The **popularity** of a creator is the **sum** of the number of views on **all** of the creator's videos. Find the creator with the **highest** popularity and the id of their **most** viewed video.
+
+*   If multiple creators have the highest popularity, find all of them.
+*   If multiple videos have the highest view count for a creator, find the lexicographically **smallest** id.
+
+Return _a 2D array of strings_ `answer` _where_ <code>answer[i] = [creator<sub>i</sub>, id<sub>i</sub>]</code> _means that_ <code>creator<sub>i</sub></code> _has the **highest** popularity and_ <code>id<sub>i</sub></code> _is the id of their most popular video._ The answer can be returned in any order.
+
+**Example 1:**
+
+**Input:** creators = ["alice","bob","alice","chris"], ids = ["one","two","three","four"], views = [5,10,5,4]
+
+**Output:** [["alice","one"],["bob","two"]]
+
+**Explanation:** 
+
+The popularity of alice is 5 + 5 = 10. 
+
+The popularity of bob is 10. 
+
+The popularity of chris is 4. 
+
+alice and bob are the most popular creators. 
+
+For bob, the video with the highest view count is "two". 
+
+For alice, the videos with the highest view count are "one" and "three". 
+
+Since "one" is lexicographically smaller than "three", it is included in the answer.
+
+**Example 2:**
+
+**Input:** creators = ["alice","alice","alice"], ids = ["a","b","c"], views = [1,2,2]
+
+**Output:** [["alice","b"]]
+
+**Explanation:** 
+
+The videos with id "b" and "c" have the highest view count. 
+
+Since "b" is lexicographically smaller than "c", it is included in the answer.
+
+**Constraints:**
+
+*   `n == creators.length == ids.length == views.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `1 <= creators[i].length, ids[i].length <= 5`
+*   `creators[i]` and `ids[i]` consist only of lowercase English letters.
+*   <code>0 <= views[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```java
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public List<List<String>> mostPopularCreator(String[] creators, String[] ids, int[] views) {
+        HashMap<String, Long> totalViews = new HashMap<>();
+        HashMap<String, Integer> maxView = new HashMap<>();
+        long globalMaxView = 0;
+        for (int i = 0; i < creators.length; i++) {
+            long currentView = totalViews.getOrDefault(creators[i], 0L) + views[i];
+            globalMaxView = Math.max(currentView, globalMaxView);
+            totalViews.put(creators[i], currentView);
+            int lastIndex = maxView.getOrDefault(creators[i], -1);
+            if (!maxView.containsKey(creators[i])
+                    || views[lastIndex] < views[i]
+                    || (views[lastIndex] == views[i] && ids[lastIndex].compareTo(ids[i]) > 0)) {
+                maxView.put(creators[i], i);
+            }
+        }
+        List<List<String>> res = new ArrayList<>();
+        for (Map.Entry<String, Long> entry : totalViews.entrySet()) {
+            if (entry.getValue() == globalMaxView) {
+                res.add(Arrays.asList(entry.getKey(), ids[maxView.get(entry.getKey())]));
+            }
+        }
+        return res;
+    }
+}
+```

src/main/java/g2401_2500/s2456_most_popular_video_creator/readme.md

@@ -0,0 +1,71 @@
+[![](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)
+
+## 2457\. Minimum Addition to Make Integer Beautiful
+
+Medium
+
+You are given two positive integers `n` and `target`.
+
+An integer is considered **beautiful** if the sum of its digits is less than or equal to `target`.
+
+Return the _minimum **non-negative** integer_ `x` _such that_ `n + x` _is beautiful_. The input will be generated such that it is always possible to make `n` beautiful.
+
+**Example 1:**
+
+**Input:** n = 16, target = 6
+
+**Output:** 4
+
+**Explanation:** Initially n is 16 and its digit sum is 1 + 6 = 7. After adding 4, n becomes 20 and digit sum becomes 2 + 0 = 2. It can be shown that we can not make n beautiful with adding non-negative integer less than 4.
+
+**Example 2:**
+
+**Input:** n = 467, target = 6
+
+**Output:** 33
+
+**Explanation:** Initially n is 467 and its digit sum is 4 + 6 + 7 = 17. After adding 33, n becomes 500 and digit sum becomes 5 + 0 + 0 = 5. It can be shown that we can not make n beautiful with adding non-negative integer less than 33.
+
+**Example 3:**
+
+**Input:** n = 1, target = 1
+
+**Output:** 0
+
+**Explanation:** Initially n is 1 and its digit sum is 1, which is already smaller than or equal to target.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>12</sup></code>
+*   `1 <= target <= 150`
+*   The input will be generated such that it is always possible to make `n` beautiful.
+
+## Solution
+
+```java
+public class Solution {
+    public long makeIntegerBeautiful(long n, int target) {
+        if (sumOfDigits(n) <= target) {
+            return 0;
+        }
+        long old = n;
+        long newNumber = 1;
+        while (sumOfDigits(n) > target) {
+            newNumber = newNumber * 10;
+            n = n / 10 + 1;
+        }
+        newNumber = (n) * newNumber;
+        return newNumber - old;
+    }
+
+    public long sumOfDigits(long n) {
+        long sum = 0;
+        while (n > 0) {
+            sum = sum + n % 10;
+            n = n / 10;
+        }
+        return sum;
+    }
+}
+```

src/main/java/g2401_2500/s2457_minimum_addition_to_make_integer_beautiful/readme.md

@@ -0,0 +1,111 @@
+[![](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)
+
+## 2458\. Height of Binary Tree After Subtree Removal Queries
+
+Hard
+
+You are given the `root` of a **binary tree** with `n` nodes. Each node is assigned a unique value from `1` to `n`. You are also given an array `queries` of size `m`.
+
+You have to perform `m` **independent** queries on the tree where in the <code>i<sup>th</sup></code> query you do the following:
+
+*   **Remove** the subtree rooted at the node with the value `queries[i]` from the tree. It is **guaranteed** that `queries[i]` will **not** be equal to the value of the root.
+
+Return _an array_ `answer` _of size_ `m` _where_ `answer[i]` _is the height of the tree after performing the_ <code>i<sup>th</sup></code> _query_.
+
+**Note**:
+
+*   The queries are independent, so the tree returns to its **initial** state after each query.
+*   The height of a tree is the **number of edges in the longest simple path** from the root to some node in the tree.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/09/07/binaryytreeedrawio-1.png)
+
+**Input:** root = [1,3,4,2,null,6,5,null,null,null,null,null,7], queries = [4]
+
+**Output:** [2]
+
+**Explanation:** The diagram above shows the tree after removing the subtree rooted at node with value 4. The height of the tree is 2 (The path 1 -> 3 -> 2).
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/09/07/binaryytreeedrawio-2.png)
+
+**Input:** root = [5,8,9,2,1,3,7,4,6], queries = [3,2,4,8]
+
+**Output:** [3,2,3,2]
+
+**Explanation:** We have the following queries: 
+
+- Removing the subtree rooted at node with value 3. The height of the tree becomes 3 (The path 5 -> 8 -> 2 -> 4). 
+ 
+- Removing the subtree rooted at node with value 2. The height of the tree becomes 2 (The path 5 -> 8 -> 1). 
+
+- Removing the subtree rooted at node with value 4. The height of the tree becomes 3 (The path 5 -> 8 -> 2 -> 6). 
+
+- Removing the subtree rooted at node with value 8. The height of the tree becomes 2 (The path 5 -> 9 -> 3).
+
+**Constraints:**
+
+*   The number of nodes in the tree is `n`.
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `1 <= Node.val <= n`
+*   All the values in the tree are **unique**.
+*   `m == queries.length`
+*   <code>1 <= m <= min(n, 10<sup>4</sup>)</code>
+*   `1 <= queries[i] <= n`
+*   `queries[i] != root.val`
+
+## Solution
+
+```java
+import com_github_leetcode.TreeNode;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int[] treeQueries(TreeNode root, int[] queries) {
+        Map<Integer, int[]> levels = new HashMap<>();
+        Map<Integer, int[]> map = new HashMap<>();
+        int max = dfs(root, 0, map, levels) - 1;
+        int n = queries.length;
+        for (int i = 0; i < n; i++) {
+            int q = queries[i];
+            int[] node = map.get(q);
+            int height = node[0];
+            int level = node[1];
+            int[] lev = levels.get(level);
+            if (lev[0] == height) {
+                if (lev[1] != -1) {
+                    queries[i] = max - Math.abs(lev[0] - lev[1]);
+                } else {
+                    queries[i] = max - height - 1;
+                }
+            } else {
+                queries[i] = max;
+            }
+        }
+        return queries;
+    }
+
+    private int dfs(TreeNode root, int level, Map<Integer, int[]> map, Map<Integer, int[]> levels) {
+        if (root == null) {
+            return 0;
+        }
+        int left = dfs(root.left, level + 1, map, levels);
+        int right = dfs(root.right, level + 1, map, levels);
+        int height = Math.max(left, right);
+        int[] lev = levels.getOrDefault(level, new int[] {-1, -1});
+        if (height >= lev[0]) {
+            lev[1] = lev[0];
+            lev[0] = height;
+        } else {
+            lev[1] = Math.max(lev[1], height);
+        }
+        levels.put(level, lev);
+        map.put(root.val, new int[] {height, level});
+        return Math.max(left, right) + 1;
+    }
+}
+```