Added tasks 3402-3405

Author: javadev

src/main/java/g3401_3500/s3402_minimum_operations_to_make_columns_strictly_increasing/Solution.java

@@ -0,0 +1,18 @@
+package g3401_3500.s3402_minimum_operations_to_make_columns_strictly_increasing;
+
+// #Easy #2024_12_29_Time_1_(100.00%)_Space_44.99_(100.00%)
+
+public class Solution {
+    public int minimumOperations(int[][] grid) {
+        int ans = 0;
+        for (int c = 0; c < grid[0].length; ++c) {
+            for (int r = 1; r < grid.length; ++r) {
+                if (grid[r][c] <= grid[r - 1][c]) {
+                    ans += grid[r - 1][c] + 1 - grid[r][c];
+                    grid[r][c] = grid[r - 1][c] + 1;
+                }
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g3401_3500/s3402_minimum_operations_to_make_columns_strictly_increasing/readme.md

@@ -0,0 +1,43 @@
+3402\. Minimum Operations to Make Columns Strictly Increasing
+
+Easy
+
+You are given a `m x n` matrix `grid` consisting of **non-negative** integers.
+
+In one operation, you can increment the value of any `grid[i][j]` by 1.
+
+Return the **minimum** number of operations needed to make all columns of `grid` **strictly increasing**.
+
+**Example 1:**
+
+**Input:** grid = [[3,2],[1,3],[3,4],[0,1]]
+
+**Output:** 15
+
+**Explanation:**
+
+*   To make the <code>0<sup>th</sup></code> column strictly increasing, we can apply 3 operations on `grid[1][0]`, 2 operations on `grid[2][0]`, and 6 operations on `grid[3][0]`.
+*   To make the <code>1<sup>st</sup></code> column strictly increasing, we can apply 4 operations on `grid[3][1]`.
+
+![](https://assets.leetcode.com/uploads/2024/11/10/firstexample.png)
+
+**Example 2:**
+
+**Input:** grid = [[3,2,1],[2,1,0],[1,2,3]]
+
+**Output:** 12
+
+**Explanation:**
+
+*   To make the <code>0<sup>th</sup></code> column strictly increasing, we can apply 2 operations on `grid[1][0]`, and 4 operations on `grid[2][0]`.
+*   To make the <code>1<sup>st</sup></code> column strictly increasing, we can apply 2 operations on `grid[1][1]`, and 2 operations on `grid[2][1]`.
+*   To make the <code>2<sup>nd</sup></code> column strictly increasing, we can apply 2 operations on `grid[1][2]`.
+
+![](https://assets.leetcode.com/uploads/2024/11/10/secondexample.png)
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 50`
+*   `0 <= grid[i][j] < 2500`

src/main/java/g3401_3500/s3403_find_the_lexicographically_largest_string_from_the_box_i/Solution.java

@@ -0,0 +1,25 @@
+package g3401_3500.s3403_find_the_lexicographically_largest_string_from_the_box_i;
+
+// #Medium #2024_12_29_Time_5_(100.00%)_Space_45.20_(100.00%)
+
+public class Solution {
+    public String answerString(String word, int numFriends) {
+        if (numFriends == 1) {
+            return word;
+        }
+        int n = word.length();
+        int maxlen = n - numFriends + 1;
+        char maxchar = word.charAt(0);
+        String res = "";
+        for (int i = 0; i < n; i++) {
+            if (word.charAt(i) >= maxchar) {
+                String curr = word.substring(i, Math.min(i + maxlen, n));
+                if (curr.compareTo(res) > 0) {
+                    res = curr;
+                }
+                maxchar = word.charAt(i);
+            }
+        }
+        return res;
+    }
+}

src/main/java/g3401_3500/s3403_find_the_lexicographically_largest_string_from_the_box_i/readme.md

@@ -0,0 +1,45 @@
+3403\. Find the Lexicographically Largest String From the Box I
+
+Medium
+
+You are given a string `word`, and an integer `numFriends`.
+
+Alice is organizing a game for her `numFriends` friends. There are multiple rounds in the game, where in each round:
+
+*   `word` is split into `numFriends` **non-empty** strings, such that no previous round has had the **exact** same split.
+*   All the split words are put into a box.
+
+Find the **lexicographically largest** string from the box after all the rounds are finished.
+
+A string `a` is **lexicographically smaller** than a string `b` if in the first position where `a` and `b` differ, string `a` has a letter that appears earlier in the alphabet than the corresponding letter in `b`.   
+ If the first `min(a.length, b.length)` characters do not differ, then the shorter string is the lexicographically smaller one.
+
+**Example 1:**
+
+**Input:** word = "dbca", numFriends = 2
+
+**Output:** "dbc"
+
+**Explanation:**
+
+All possible splits are:
+
+*   `"d"` and `"bca"`.
+*   `"db"` and `"ca"`.
+*   `"dbc"` and `"a"`.
+
+**Example 2:**
+
+**Input:** word = "gggg", numFriends = 4
+
+**Output:** "g"
+
+**Explanation:**
+
+The only possible split is: `"g"`, `"g"`, `"g"`, and `"g"`.
+
+**Constraints:**
+
+*   <code>1 <= word.length <= 5 * 10<sup>3</sup></code>
+*   `word` consists only of lowercase English letters.
+*   `1 <= numFriends <= word.length`

src/main/java/g3401_3500/s3404_count_special_subsequences/Solution.java

@@ -0,0 +1,23 @@
+package g3401_3500.s3404_count_special_subsequences;
+
+// #Medium #2024_12_29_Time_331_(100.00%)_Space_55.49_(100.00%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public long numberOfSubsequences(int[] nums) {
+        Map<Double, Integer> freq = new HashMap<>();
+        long ans = 0;
+        for (int r = 4; r < nums.length; ++r) {
+            for (int p = 0, q = r - 2; p < q - 1; ++p) {
+                Double key = (double) nums[p] / nums[q];
+                freq.put(key, freq.getOrDefault(key, 0) + 1);
+            }
+            for (int s = r + 2; s < nums.length; ++s) {
+                ans += freq.getOrDefault((double) nums[s] / nums[r], 0);
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g3401_3500/s3404_count_special_subsequences/readme.md

@@ -0,0 +1,57 @@
+3404\. Count Special Subsequences
+
+Medium
+
+You are given an array `nums` consisting of positive integers.
+
+A **special subsequence** is defined as a subsequence of length 4, represented by indices `(p, q, r, s)`, where `p < q < r < s`. This subsequence **must** satisfy the following conditions:
+
+*   `nums[p] * nums[r] == nums[q] * nums[s]`
+*   There must be _at least_ **one** element between each pair of indices. In other words, `q - p > 1`, `r - q > 1` and `s - r > 1`.
+
+A subsequence is a sequence derived from the array by deleting zero or more elements without changing the order of the remaining elements.
+
+Return the _number_ of different **special** **subsequences** in `nums`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,3,6,1]
+
+**Output:** 1
+
+**Explanation:**
+
+There is one special subsequence in `nums`.
+
+*   `(p, q, r, s) = (0, 2, 4, 6)`:
+    *   This corresponds to elements `(1, 3, 3, 1)`.
+    *   `nums[p] * nums[r] = nums[0] * nums[4] = 1 * 3 = 3`
+    *   `nums[q] * nums[s] = nums[2] * nums[6] = 3 * 1 = 3`
+
+**Example 2:**
+
+**Input:** nums = [3,4,3,4,3,4,3,4]
+
+**Output:** 3
+
+**Explanation:**
+
+There are three special subsequences in `nums`.
+
+*   `(p, q, r, s) = (0, 2, 4, 6)`:
+    *   This corresponds to elements `(3, 3, 3, 3)`.
+    *   `nums[p] * nums[r] = nums[0] * nums[4] = 3 * 3 = 9`
+    *   `nums[q] * nums[s] = nums[2] * nums[6] = 3 * 3 = 9`
+*   `(p, q, r, s) = (1, 3, 5, 7)`:
+    *   This corresponds to elements `(4, 4, 4, 4)`.
+    *   `nums[p] * nums[r] = nums[1] * nums[5] = 4 * 4 = 16`
+    *   `nums[q] * nums[s] = nums[3] * nums[7] = 4 * 4 = 16`
+*   `(p, q, r, s) = (0, 2, 5, 7)`:
+    *   This corresponds to elements `(3, 3, 4, 4)`.
+    *   `nums[p] * nums[r] = nums[0] * nums[5] = 3 * 4 = 12`
+    *   `nums[q] * nums[s] = nums[2] * nums[7] = 3 * 4 = 12`
+
+**Constraints:**
+
+*   `7 <= nums.length <= 1000`
+*   `1 <= nums[i] <= 1000`

src/main/java/g3401_3500/s3405_count_the_number_of_arrays_with_k_matching_adjacent_elements/Solution.java

@@ -0,0 +1,40 @@
+package g3401_3500.s3405_count_the_number_of_arrays_with_k_matching_adjacent_elements;
+
+// #Hard #2024_12_29_Time_57_(100.00%)_Space_44.55_(100.00%)
+
+public class Solution {
+    private final int mod = (int) (1e9 + 7);
+
+    public int countGoodArrays(int n, int m, int k) {
+        long[] f = new long[n + 1];
+        f[0] = 1;
+        f[1] = 1;
+        for (int i = 2; i < f.length; i++) {
+            f[i] = (f[i - 1] * i % mod);
+        }
+        long ans = comb(n - 1, k, f);
+        ans = ans * m % mod;
+        ans = ans * ex(m - 1, n - k - 1) % mod;
+        return (int) ans;
+    }
+
+    private long ex(long b, long e) {
+        long ans = 1;
+        while (e > 0) {
+            if (e % 2 == 1) {
+                ans = (ans * b) % mod;
+            }
+            b = (b * b) % mod;
+            e = e >> 1;
+        }
+        return ans;
+    }
+
+    private long comb(int n, int r, long[] f) {
+        return f[n] * (ff(f[r])) % mod * ff(f[n - r]) % mod;
+    }
+
+    private long ff(long x) {
+        return ex(x, mod - 2);
+    }
+}

src/main/java/g3401_3500/s3405_count_the_number_of_arrays_with_k_matching_adjacent_elements/readme.md

@@ -0,0 +1,50 @@
+3405\. Count the Number of Arrays with K Matching Adjacent Elements
+
+Hard
+
+You are given three integers `n`, `m`, `k`. A **good array** `arr` of size `n` is defined as follows:
+
+*   Each element in `arr` is in the **inclusive** range `[1, m]`.
+*   _Exactly_ `k` indices `i` (where `1 <= i < n`) satisfy the condition `arr[i - 1] == arr[i]`.
+
+Return the number of **good arrays** that can be formed.
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** n = 3, m = 2, k = 1
+
+**Output:** 4
+
+**Explanation:**
+
+*   There are 4 good arrays. They are `[1, 1, 2]`, `[1, 2, 2]`, `[2, 1, 1]` and `[2, 2, 1]`.
+*   Hence, the answer is 4.
+
+**Example 2:**
+
+**Input:** n = 4, m = 2, k = 2
+
+**Output:** 6
+
+**Explanation:**
+
+*   The good arrays are `[1, 1, 1, 2]`, `[1, 1, 2, 2]`, `[1, 2, 2, 2]`, `[2, 1, 1, 1]`, `[2, 2, 1, 1]` and `[2, 2, 2, 1]`.
+*   Hence, the answer is 6.
+
+**Example 3:**
+
+**Input:** n = 5, m = 2, k = 0
+
+**Output:** 2
+
+**Explanation:**
+
+*   The good arrays are `[1, 2, 1, 2, 1]` and `[2, 1, 2, 1, 2]`. Hence, the answer is 2.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= m <= 10<sup>5</sup></code>
+*   `0 <= k <= n - 1`

src/test/java/g3401_3500/s3402_minimum_operations_to_make_columns_strictly_increasing/SolutionTest.java

@@ -0,0 +1,22 @@
+package g3401_3500.s3402_minimum_operations_to_make_columns_strictly_increasing;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumOperations() {
+        assertThat(
+                new Solution().minimumOperations(new int[][] {{3, 2}, {1, 3}, {3, 4}, {0, 1}}),
+                equalTo(15));
+    }
+
+    @Test
+    void minimumOperations2() {
+        assertThat(
+                new Solution().minimumOperations(new int[][] {{3, 2, 1}, {2, 1, 0}, {1, 2, 3}}),
+                equalTo(12));
+    }
+}

src/test/java/g3401_3500/s3403_find_the_lexicographically_largest_string_from_the_box_i/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3401_3500.s3403_find_the_lexicographically_largest_string_from_the_box_i;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void answerString() {
+        assertThat(new Solution().answerString("dbca", 2), equalTo("dbc"));
+    }
+
+    @Test
+    void answerString2() {
+        assertThat(new Solution().answerString("gggg", 4), equalTo("g"));
+    }
+}