Added tasks 2546-2551

Author: ThanhNIT

src/main/java/g2501_2600/s2546_apply_bitwise_operations_to_make_strings_equal/Solution.java

@@ -0,0 +1,9 @@
+package g2501_2600.s2546_apply_bitwise_operations_to_make_strings_equal;
+
+// #Medium #String #Bit_Manipulation #2023_08_15_Time_0_ms_(100.00%)_Space_44.3_MB_(87.14%)
+
+class Solution {
+    public boolean makeStringsEqual(String s, String target) {
+        return s.contains("1") == target.contains("1");
+    }
+}

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

@@ -0,0 +1,38 @@
+2546\. Apply Bitwise Operations to Make Strings Equal
+
+Medium
+
+You are given two **0-indexed binary** strings `s` and `target` of the same length `n`. You can do the following operation on `s` **any** number of times:
+
+*   Choose two **different** indices `i` and `j` where `0 <= i, j < n`.
+*   Simultaneously, replace `s[i]` with (`s[i]` **OR** `s[j]`) and `s[j]` with (`s[i]` **XOR** `s[j]`).
+
+For example, if `s = "0110"`, you can choose `i = 0` and `j = 2`, then simultaneously replace `s[0]` with (`s[0]` **OR** `s[2]` = `0` **OR** `1` = `1`), and `s[2]` with (`s[0]` **XOR** `s[2]` = `0` **XOR** `1` = `1`), so we will have `s = "1110"`.
+
+Return `true` _if you can make the string_ `s` _equal to_ `target`_, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** s = "1010", target = "0110"
+
+**Output:** true
+
+**Explanation:** We can do the following operations:
+
+- Choose i = 2 and j = 0. We have now s = "**<ins>0</ins>**0**<ins>1</ins>**0".
+
+- Choose i = 2 and j = 1. We have now s = "0**<ins>11</ins>**0". Since we can make s equal to target, we return true.
+
+**Example 2:**
+
+**Input:** s = "11", target = "00"
+
+**Output:** false
+
+**Explanation:** It is not possible to make s equal to target with any number of operations.
+
+**Constraints:**
+
+*   `n == s.length == target.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `s` and `target` consist of only the digits `0` and `1`.

src/main/java/g2501_2600/s2547_minimum_cost_to_split_an_array/Solution.java

@@ -0,0 +1,26 @@
+package g2501_2600.s2547_minimum_cost_to_split_an_array;
+
+// #Hard #Array #Hash_Table #Dynamic_Programming #Counting
+// #2023_08_15_Time_32_ms_(98.70%)_Space_44.3_MB_(66.23%)
+
+class Solution {
+    public int minCost(int[] nums, int k) {
+        int[] dp = new int[nums.length + 1];
+        for (int startPos = nums.length - 1; startPos >= 0; startPos--) {
+            dp[startPos] = Integer.MAX_VALUE;
+            int[] freq = new int[nums.length + 1];
+            int nRepeated = 0;
+            for (int pos = startPos; pos < nums.length; pos++) {
+                int curNum = nums[pos];
+                if (freq[curNum] == 1) {
+                    nRepeated += 2;
+                } else if (freq[curNum] > 0) {
+                    nRepeated++;
+                }
+                freq[curNum]++;
+                dp[startPos] = Math.min(dp[startPos], k + nRepeated + dp[pos + 1]);
+            }
+        }
+        return dp[0];
+    }
+}

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

@@ -0,0 +1,65 @@
+2547\. Minimum Cost to Split an Array
+
+Hard
+
+You are given an integer array `nums` and an integer `k`.
+
+Split the array into some number of non-empty subarrays. The **cost** of a split is the sum of the **importance value** of each subarray in the split.
+
+Let `trimmed(subarray)` be the version of the subarray where all numbers which appear only once are removed.
+
+*   For example, `trimmed([3,1,2,4,3,4]) = [3,4,3,4].`
+
+The **importance value** of a subarray is `k + trimmed(subarray).length`.
+
+*   For example, if a subarray is `[1,2,3,3,3,4,4]`, then trimmed(`[1,2,3,3,3,4,4]) = [3,3,3,4,4].`The importance value of this subarray will be `k + 5`.
+
+Return _the minimum possible cost of a split of_ `nums`.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [1,2,1,2,1,3,3], k = 2
+
+**Output:** 8
+
+**Explanation:** We split nums to have two subarrays: [1,2], [1,2,1,3,3]. '
+
+The importance value of [1,2] is 2 + (0) = 2.
+
+The importance value of [1,2,1,3,3] is 2 + (2 + 2) = 6.
+
+The cost of the split is 2 + 6 = 8. It can be shown that this is the minimum possible cost among all the possible splits.
+
+**Example 2:**
+
+**Input:** nums = [1,2,1,2,1], k = 2
+
+**Output:** 6
+
+**Explanation:** We split nums to have two subarrays: [1,2], [1,2,1].
+
+The importance value of [1,2] is 2 + (0) = 2.
+
+The importance value of [1,2,1] is 2 + (2) = 4.
+
+The cost of the split is 2 + 4 = 6. It can be shown that this is the minimum possible cost among all the possible splits.
+
+**Example 3:**
+
+**Input:** nums = [1,2,1,2,1], k = 5
+
+**Output:** 10
+
+**Explanation:** We split nums to have one subarray: [1,2,1,2,1].
+
+The importance value of [1,2,1,2,1] is 5 + (3 + 2) = 10.
+
+The cost of the split is 10. It can be shown that this is the minimum possible cost among all the possible splits.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `0 <= nums[i] < nums.length`
+*   <code>1 <= k <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2549_count_distinct_numbers_on_board/Solution.java

@@ -0,0 +1,12 @@
+package g2501_2600.s2549_count_distinct_numbers_on_board;
+
+// #Easy #Array #Hash_Table #Math #Simulation #2023_08_15_Time_0_ms_(100.00%)_Space_39.2_MB_(75.23%)
+
+class Solution {
+    public int distinctIntegers(int n) {
+        if (n == 1) {
+            return 1;
+        }
+        return n - 1;
+    }
+}

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

@@ -0,0 +1,41 @@
+2549\. Count Distinct Numbers on Board
+
+Easy
+
+You are given a positive integer `n`, that is initially placed on a board. Every day, for <code>10<sup>9</sup></code> days, you perform the following procedure:
+
+*   For each number `x` present on the board, find all numbers `1 <= i <= n` such that `x % i == 1`.
+*   Then, place those numbers on the board.
+
+Return _the number of **distinct** integers present on the board after_ <code>10<sup>9</sup></code> _days have elapsed_.
+
+**Note:**
+
+*   Once a number is placed on the board, it will remain on it until the end.
+*   `%` stands for the modulo operation. For example, `14 % 3` is `2`.
+
+**Example 1:**
+
+**Input:** n = 5
+
+**Output:** 4
+
+**Explanation:** Initially, 5 is present on the board. 
+
+The next day, 2 and 4 will be added since 5 % 2 == 1 and 5 % 4 == 1.
+
+After that day, 3 will be added to the board because 4 % 3 == 1. 
+
+At the end of a billion days, the distinct numbers on the board will be 2, 3, 4, and 5.
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 2
+
+**Explanation:** Since 3 % 2 == 1, 2 will be added to the board. After a billion days, the only two distinct numbers on the board are 2 and 3.
+
+**Constraints:**
+
+*   `1 <= n <= 100`

src/main/java/g2501_2600/s2550_count_collisions_of_monkeys_on_a_polygon/Solution.java

@@ -0,0 +1,17 @@
+package g2501_2600.s2550_count_collisions_of_monkeys_on_a_polygon;
+
+// #Medium #Math #Recursion #2023_08_15_Time_0_ms_(100.00%)_Space_39.3_MB_(62.81%)
+
+class Solution {
+    public int monkeyMove(int n) {
+        return (int) ((((modPow2(n - 2) - 1) << 2) + 2) % 1000000007);
+    }
+
+    private long modPow2(int n) {
+        if (n == 0) {
+            return 1;
+        }
+        long b = modPow2(n >> 1);
+        return ((b * b) << (n & 1)) % 1000000007;
+    }
+}

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

@@ -0,0 +1,42 @@
+2550\. Count Collisions of Monkeys on a Polygon
+
+Medium
+
+There is a regular convex polygon with `n` vertices. The vertices are labeled from `0` to `n - 1` in a clockwise direction, and each vertex has **exactly one monkey**. The following figure shows a convex polygon of `6` vertices.
+
+![](https://assets.leetcode.com/uploads/2023/01/22/hexagon.jpg)
+
+Each monkey moves simultaneously to a neighboring vertex. A neighboring vertex for a vertex `i` can be:
+
+*   the vertex `(i + 1) % n` in the clockwise direction, or
+*   the vertex `(i - 1 + n) % n` in the counter-clockwise direction.
+
+A **collision** happens if at least two monkeys reside on the same vertex after the movement or intersect on an edge.
+
+Return _the number of ways the monkeys can move so that at least **one collision**_ _happens_. Since the answer may be very large, return it modulo <code>10<sup>9</sup> + 7</code>.
+
+**Note** that each monkey can only move once.
+
+**Example 1:**
+
+**Input:** n = 3
+
+**Output:** 6
+
+**Explanation:** There are 8 total possible movements. 
+
+Two ways such that they collide at some point are: 
+- Monkey 1 moves in a clockwise direction; monkey 2 moves in an anticlockwise direction; monkey 3 moves in a clockwise direction. Monkeys 1 and 2 collide. 
+- Monkey 1 moves in an anticlockwise direction; monkey 2 moves in an anticlockwise direction; monkey 3 moves in a clockwise direction. Monkeys 1 and 3 collide. It can be shown 6 total movements result in a collision.
+
+**Example 2:**
+
+**Input:** n = 4
+
+**Output:** 14
+
+**Explanation:** It can be shown that there are 14 ways for the monkeys to collide.
+
+**Constraints:**
+
+*   <code>3 <= n <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2551_put_marbles_in_bags/Solution.java

@@ -0,0 +1,25 @@
+package g2501_2600.s2551_put_marbles_in_bags;
+
+// #Hard #Array #Sorting #Greedy #Heap_Priority_Queue
+// #2023_08_15_Time_33_ms_(99.82%)_Space_55.1_MB_(97.58%)
+
+import java.util.Arrays;
+
+class Solution {
+    public long putMarbles(int[] weights, int k) {
+        long minAns = weights[0] + (long) weights[weights.length - 1];
+        long maxAns = weights[0] + (long) weights[weights.length - 1];
+        long[] arr = new long[weights.length - 1];
+        for (int i = 1; i < weights.length; i++) {
+            arr[i - 1] = weights[i] + (long) weights[i - 1];
+        }
+        Arrays.sort(arr);
+        for (int i = 0; i < k - 1; i++) {
+            minAns = minAns + arr[i];
+        }
+        for (int i = arr.length - 1; i > arr.length - k; i--) {
+            maxAns = maxAns + arr[i];
+        }
+        return maxAns - minAns;
+    }
+}

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

@@ -0,0 +1,42 @@
+2551\. Put Marbles in Bags
+
+Hard
+
+You have `k` bags. You are given a **0-indexed** integer array `weights` where `weights[i]` is the weight of the <code>i<sup>th</sup></code> marble. You are also given the integer `k.`
+
+Divide the marbles into the `k` bags according to the following rules:
+
+*   No bag is empty.
+*   If the <code>i<sup>th</sup></code> marble and <code>j<sup>th</sup></code> marble are in a bag, then all marbles with an index between the <code>i<sup>th</sup></code> and <code>j<sup>th</sup></code> indices should also be in that same bag.
+*   If a bag consists of all the marbles with an index from `i` to `j` inclusively, then the cost of the bag is `weights[i] + weights[j]`.
+
+The **score** after distributing the marbles is the sum of the costs of all the `k` bags.
+
+Return _the **difference** between the **maximum** and **minimum** scores among marble distributions_.
+
+**Example 1:**
+
+**Input:** weights = [1,3,5,1], k = 2
+
+**Output:** 4
+
+**Explanation:** 
+
+The distribution [1],[3,5,1] results in the minimal score of (1+1) + (3+1) = 6. 
+
+The distribution [1,3],[5,1], results in the maximal score of (1+3) + (5+1) = 10.
+
+Thus, we return their difference 10 - 6 = 4.
+
+**Example 2:**
+
+**Input:** weights = [1, 3], k = 2
+
+**Output:** 0
+
+**Explanation:** The only distribution possible is [1],[3]. Since both the maximal and minimal score are the same, we return 0.
+
+**Constraints:**
+
+*   <code>1 <= k <= weights.length <= 10<sup>5</sup></code>
+*   <code>1 <= weights[i] <= 10<sup>9</sup></code>