Added tasks 2836-2842

Author: ThanhNIT

src/main/java/g2801_2900/s2836_maximize_value_of_function_in_a_ball_passing_game/Solution.java

@@ -0,0 +1,51 @@
+package g2801_2900.s2836_maximize_value_of_function_in_a_ball_passing_game;
+
+// #Hard #Array #Dynamic_Programming #Bit_Manipulation
+// #2023_12_12_Time_235_ms_(45.00%)_Space_134.3_MB_(47.50%)
+
+import java.util.List;
+
+public class Solution {
+    public long getMaxFunctionValue(List<Integer> receiver, long k) {
+        int upper = (int) Math.floor(Math.log(k) / Math.log(2));
+        int n = receiver.size();
+        int[][] next = new int[n][upper + 1];
+        long[][] res = new long[n][upper + 1];
+
+        int[] kBit = new int[upper + 1];
+        long currK = k;
+        for (int x = 0; x < n; x++) {
+            next[x][0] = receiver.get(x);
+            res[x][0] = receiver.get(x);
+        }
+        for (int i = 0; i <= upper; i++) {
+            kBit[i] = (int) (currK & 1);
+            currK = currK >> 1;
+        }
+
+        for (int i = 1; i <= upper; i++) {
+            for (int x = 0; x < n; x++) {
+                int nxt = next[x][i - 1];
+                next[x][i] = next[nxt][i - 1];
+                res[x][i] = res[x][i - 1] + res[nxt][i - 1];
+            }
+        }
+        long ans = 0;
+        for (int x = 0; x < n; x++) {
+            long sum = x;
+            int i = 0;
+            int curr = x;
+            while (i <= upper) {
+                if (kBit[i] == 0) {
+                    i++;
+                    continue;
+                }
+                sum += res[curr][i];
+                curr = next[curr][i];
+                i++;
+            }
+            ans = Math.max(ans, sum);
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,115 @@
+2836\. Maximize Value of Function in a Ball Passing Game
+
+Hard
+
+You are given a **0-indexed** integer array `receiver` of length `n` and an integer `k`.
+
+There are `n` players having a **unique id** in the range `[0, n - 1]` who will play a ball passing game, and `receiver[i]` is the id of the player who receives passes from the player with id `i`. Players can pass to themselves, **i.e.** `receiver[i]` may be equal to `i`.
+
+You must choose one of the `n` players as the starting player for the game, and the ball will be passed **exactly** `k` times starting from the chosen player.
+
+For a chosen starting player having id `x`, we define a function `f(x)` that denotes the **sum** of `x` and the **ids** of all players who receive the ball during the `k` passes, **including repetitions**. In other words, <code>f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver<sup>(k)</sup>[x]</code>.
+
+Your task is to choose a starting player having id `x` that **maximizes** the value of `f(x)`.
+
+Return _an integer denoting the **maximum** value of the function._
+
+**Note:** `receiver` may contain duplicates.
+
+**Example 1:**
+
+Pass Number
+
+Sender ID
+
+Receiver ID
+
+x + Receiver IDs
+
+2
+
+1
+
+2
+
+1
+
+3
+
+2
+
+1
+
+0
+
+3
+
+3
+
+0
+
+2
+
+5
+
+4
+
+2
+
+1
+
+6
+
+**Input:** receiver = [2,0,1], k = 4
+
+**Output:** 6
+
+**Explanation:** The table above shows a simulation of the game starting with the player having id x = 2. From the table, f(2) is equal to 6. It can be shown that 6 is the maximum achievable value of the function. Hence, the output is 6.
+
+**Example 2:**
+
+Pass Number
+
+Sender ID
+
+Receiver ID
+
+x + Receiver IDs
+
+4
+
+1
+
+4
+
+3
+
+7
+
+2
+
+3
+
+2
+
+9
+
+3
+
+2
+
+1
+
+10
+
+**Input:** receiver = [1,1,1,2,3], k = 3
+
+**Output:** 10
+
+**Explanation:** The table above shows a simulation of the game starting with the player having id x = 4. From the table, f(4) is equal to 10. It can be shown that 10 is the maximum achievable value of the function. Hence, the output is 10.
+
+**Constraints:**
+
+*   <code>1 <= receiver.length == n <= 10<sup>5</sup></code>
+*   `0 <= receiver[i] <= n - 1`
+*   <code>1 <= k <= 10<sup>10</sup></code>

src/main/java/g2801_2900/s2839_check_if_strings_can_be_made_equal_with_operations_i/Solution.java

@@ -0,0 +1,20 @@
+package g2801_2900.s2839_check_if_strings_can_be_made_equal_with_operations_i;
+
+// #Easy #String #2023_12_12_Time_1_ms_(99.09%)_Space_41.8_MB_(41.03%)
+
+public class Solution {
+    public boolean canBeEqual(String s1, String s2) {
+        return isOk(s1, s2, 0) && isOk(s1, s2, 1);
+    }
+
+    private boolean isOk(String s1, String s2, int i) {
+        char a = s1.charAt(i);
+        char b = s1.charAt(i + 2);
+        char c = s2.charAt(i);
+        char d = s2.charAt(i + 2);
+        if (a == c && b == d) {
+            return true;
+        }
+        return a == d && b == c;
+    }
+}

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

@@ -0,0 +1,34 @@
+2839\. Check if Strings Can be Made Equal With Operations I
+
+Easy
+
+You are given two strings `s1` and `s2`, both of length `4`, consisting of **lowercase** English letters.
+
+You can apply the following operation on any of the two strings **any** number of times:
+
+*   Choose any two indices `i` and `j` such that `j - i = 2`, then **swap** the two characters at those indices in the string.
+
+Return `true` _if you can make the strings_ `s1` _and_ `s2` _equal, and_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** s1 = "abcd", s2 = "cdab"
+
+**Output:** true
+
+**Explanation:** We can do the following operations on s1: 
+- Choose the indices i = 0, j = 2. The resulting string is s1 = "cbad". 
+- Choose the indices i = 1, j = 3. The resulting string is s1 = "cdab" = s2.
+
+**Example 2:**
+
+**Input:** s1 = "abcd", s2 = "dacb"
+
+**Output:** false
+
+**Explanation:** It is not possible to make the two strings equal.
+
+**Constraints:**
+
+*   `s1.length == s2.length == 4`
+*   `s1` and `s2` consist only of lowercase English letters.

src/main/java/g2801_2900/s2840_check_if_strings_can_be_made_equal_with_operations_ii/Solution.java

@@ -0,0 +1,24 @@
+package g2801_2900.s2840_check_if_strings_can_be_made_equal_with_operations_ii;
+
+// #Medium #String #Hash_Table #Sorting #2023_12_12_Time_4_ms_(100.00%)_Space_44.6_MB_(50.60%)
+
+public class Solution {
+    public boolean checkStrings(String s1, String s2) {
+        return check(0, s1, s2) && check(1, s1, s2);
+    }
+
+    boolean check(int start, String s1, String s2) {
+        int step = 2;
+        int[] buf = new int[26];
+        for (int i = start; i < s1.length(); i += step) {
+            buf[s1.charAt(i) - 'a']++;
+            buf[s2.charAt(i) - 'a']--;
+        }
+        for (int j : buf) {
+            if (j != 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,36 @@
+2840\. Check if Strings Can be Made Equal With Operations II
+
+Medium
+
+You are given two strings `s1` and `s2`, both of length `n`, consisting of **lowercase** English letters.
+
+You can apply the following operation on **any** of the two strings **any** number of times:
+
+*   Choose any two indices `i` and `j` such that `i < j` and the difference `j - i` is **even**, then **swap** the two characters at those indices in the string.
+
+Return `true` _if you can make the strings_ `s1` _and_ `s2` _equal, and_`false` _otherwise_.
+
+**Example 1:**
+
+**Input:** s1 = "abcdba", s2 = "cabdab"
+
+**Output:** true
+
+**Explanation:** We can apply the following operations on s1: 
+- Choose the indices i = 0, j = 2. The resulting string is s1 = "cbadba". 
+- Choose the indices i = 2, j = 4. The resulting string is s1 = "cbbdaa". 
+- Choose the indices i = 1, j = 5. The resulting string is s1 = "cabdab" = s2.
+
+**Example 2:**
+
+**Input:** s1 = "abe", s2 = "bea"
+
+**Output:** false
+
+**Explanation:** It is not possible to make the two strings equal.
+
+**Constraints:**
+
+*   `n == s1.length == s2.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `s1` and `s2` consist only of lowercase English letters.

src/main/java/g2801_2900/s2841_maximum_sum_of_almost_unique_subarray/Solution.java

@@ -0,0 +1,39 @@
+package g2801_2900.s2841_maximum_sum_of_almost_unique_subarray;
+
+// #Medium #Array #Hash_Table #Sliding_Window #2023_12_12_Time_18_ms_(97.37%)_Space_45.4_MB_(81.05%)
+
+import java.util.HashMap;
+import java.util.List;
+
+public class Solution {
+    public long maxSum(List<Integer> nums, int m, int k) {
+        HashMap<Integer, Integer> hash = new HashMap<>();
+        int count = 0;
+        long ans = 0;
+        int left = 0;
+        long cur = 0;
+        for (int i = 0; i < nums.size(); i++) {
+            cur += nums.get(i);
+            if (hash.containsKey(nums.get(i))) {
+                hash.put(nums.get(i), hash.get(nums.get(i)) + 1);
+            } else {
+                hash.put(nums.get(i), 1);
+                count++;
+            }
+            if (i - left + 1 == k) {
+                if (count >= m) {
+                    ans = Math.max(ans, cur);
+                }
+                if (hash.get(nums.get(left)) > 1) {
+                    hash.put(nums.get(left), hash.get(nums.get(left)) - 1);
+                } else {
+                    count--;
+                    hash.remove(nums.get(left));
+                }
+                cur -= nums.get(left);
+                left++;
+            }
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,41 @@
+2841\. Maximum Sum of Almost Unique Subarray
+
+Medium
+
+You are given an integer array `nums` and two positive integers `m` and `k`.
+
+Return _the **maximum sum** out of all **almost unique** subarrays of length_ `k` _of_ `nums`. If no such subarray exists, return `0`.
+
+A subarray of `nums` is **almost unique** if it contains at least `m` distinct elements.
+
+A subarray is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [2,6,7,3,1,7], m = 3, k = 4
+
+**Output:** 18
+
+**Explanation:** There are 3 almost unique subarrays of size `k = 4`. These subarrays are [2, 6, 7, 3], [6, 7, 3, 1], and [7, 3, 1, 7]. Among these subarrays, the one with the maximum sum is [2, 6, 7, 3] which has a sum of 18.
+
+**Example 2:**
+
+**Input:** nums = [5,9,9,2,4,5,4], m = 1, k = 3
+
+**Output:** 23
+
+**Explanation:** There are 5 almost unique subarrays of size k. These subarrays are [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], and [4, 5, 4]. Among these subarrays, the one with the maximum sum is [5, 9, 9] which has a sum of 23.
+
+**Example 3:**
+
+**Input:** nums = [1,2,1,2,1,2,1], m = 3, k = 3
+
+**Output:** 0
+
+**Explanation:** There are no subarrays of size `k = 3` that contain at least `m = 3` distinct elements in the given array [1,2,1,2,1,2,1]. Therefore, no almost unique subarrays exist, and the maximum sum is 0.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   `1 <= m <= k <= nums.length`
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>