Added tasks 3471-3474

Author: javadev

src/main/kotlin/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/Solution.kt

@@ -1,6 +1,6 @@
 package g3401_3500.s3462_maximum_sum_with_at_most_k_elements
 
-// #Medium #Array #Sorting #Greedy #Matrix #Heap_(Priority_Queue)
+// #Medium #Array #Sorting #Greedy #Matrix #Heap_Priority_Queue
 // #2025_02_25_Time_139_ms_(100.00%)_Space_88.84_MB_(79.31%)
 
 class Solution {

src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/Solution.kt

@@ -0,0 +1,24 @@
+package g3401_3500.s3471_find_the_largest_almost_missing_integer
+
+// #Easy #2025_03_02_Time_10_ms_(100.00%)_Space_37.57_MB_(100.00%)
+
+class Solution {
+    fun largestInteger(nums: IntArray, k: Int): Int {
+        val freq = IntArray(51)
+        for (i in 0..nums.size - k) {
+            val set: MutableSet<Int> = HashSet<Int>()
+            for (j in i..<i + k) {
+                set.add(nums[j])
+            }
+            for (key in set) {
+                freq[key]++
+            }
+        }
+        for (i in 50 downTo 0) {
+            if (freq[i] == 1) {
+                return i
+            }
+        }
+        return -1
+    }
+}

src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/readme.md

@@ -0,0 +1,59 @@
+3471\. Find the Largest Almost Missing Integer
+
+Easy
+
+You are given an integer array `nums` and an integer `k`.
+
+An integer `x` is **almost missing** from `nums` if `x` appears in _exactly_ one subarray of size `k` within `nums`.
+
+Return the **largest** **almost missing** integer from `nums`. If no such integer exists, return `-1`.
+
+A **subarray** is a contiguous sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [3,9,2,1,7], k = 3
+
+**Output:** 7
+
+**Explanation:**
+
+*   1 appears in 2 subarrays of size 3: `[9, 2, 1]` and `[2, 1, 7]`.
+*   2 appears in 3 subarrays of size 3: `[3, 9, 2]`, `[9, 2, 1]`, `[2, 1, 7]`.
+*   3 appears in 1 subarray of size 3: `[3, 9, 2]`.
+*   7 appears in 1 subarray of size 3: `[2, 1, 7]`.
+*   9 appears in 2 subarrays of size 3: `[3, 9, 2]`, and `[9, 2, 1]`.
+
+We return 7 since it is the largest integer that appears in exactly one subarray of size `k`.
+
+**Example 2:**
+
+**Input:** nums = [3,9,7,2,1,7], k = 4
+
+**Output:** 3
+
+**Explanation:**
+
+*   1 appears in 2 subarrays of size 4: `[9, 7, 2, 1]`, `[7, 2, 1, 7]`.
+*   2 appears in 3 subarrays of size 4: `[3, 9, 7, 2]`, `[9, 7, 2, 1]`, `[7, 2, 1, 7]`.
+*   3 appears in 1 subarray of size 4: `[3, 9, 7, 2]`.
+*   7 appears in 3 subarrays of size 4: `[3, 9, 7, 2]`, `[9, 7, 2, 1]`, `[7, 2, 1, 7]`.
+*   9 appears in 2 subarrays of size 4: `[3, 9, 7, 2]`, `[9, 7, 2, 1]`.
+
+We return 3 since it is the largest and only integer that appears in exactly one subarray of size `k`.
+
+**Example 3:**
+
+**Input:** nums = [0,0], k = 1
+
+**Output:** \-1
+
+**Explanation:**
+
+There is no integer that appears in only one subarray of size 1.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 50`
+*   `0 <= nums[i] <= 50`
+*   `1 <= k <= nums.length`

src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/Solution.kt

@@ -0,0 +1,42 @@
+package g3401_3500.s3472_longest_palindromic_subsequence_after_at_most_k_operations
+
+// #Medium #2025_03_02_Time_137_ms_(100.00%)_Space_99.18_MB_(100.00%)
+
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun longestPalindromicSubsequence(s: String, k: Int): Int {
+        val n = s.length
+        val arr = Array<IntArray>(26) { IntArray(26) }
+        for (i in 0..25) {
+            for (j in 0..25) {
+                arr[i][j] = min(abs(i - j), (26 - abs(i - j)))
+            }
+        }
+        val dp = Array<Array<IntArray>>(n) { Array<IntArray>(n) { IntArray(k + 1) } }
+        for (i in 0..<n) {
+            for (it in 0..k) {
+                dp[i][i][it] = 1
+            }
+        }
+        for (length in 2..n) {
+            for (i in 0..n - length) {
+                val j = i + length - 1
+                for (it in 0..k) {
+                    if (s[i] == s[j]) {
+                        dp[i][j][it] = 2 + dp[i + 1][j - 1][it]
+                    } else {
+                        val num1 = dp[i + 1][j][it]
+                        val num2 = dp[i][j - 1][it]
+                        val c = arr[s[i].code - 'a'.code][s[j].code - 'a'.code]
+                        val num3 = if (it >= c) 2 + dp[i + 1][j - 1][it - c] else 0
+                        dp[i][j][it] = max(max(num1, num2), num3)
+                    }
+                }
+            }
+        }
+        return dp[0][n - 1][k]
+    }
+}

src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/readme.md

@@ -0,0 +1,42 @@
+3472\. Longest Palindromic Subsequence After at Most K Operations
+
+Medium
+
+You are given a string `s` and an integer `k`.
+
+In one operation, you can replace the character at any position with the next or previous letter in the alphabet (wrapping around so that `'a'` is after `'z'`). For example, replacing `'a'` with the next letter results in `'b'`, and replacing `'a'` with the previous letter results in `'z'`. Similarly, replacing `'z'` with the next letter results in `'a'`, and replacing `'z'` with the previous letter results in `'y'`.
+
+Return the length of the **longest palindromic subsequence** of `s` that can be obtained after performing **at most** `k` operations.
+
+**Example 1:**
+
+**Input:** s = "abced", k = 2
+
+**Output:** 3
+
+**Explanation:**
+
+*   Replace `s[1]` with the next letter, and `s` becomes `"acced"`.
+*   Replace `s[4]` with the previous letter, and `s` becomes `"accec"`.
+
+The subsequence `"ccc"` forms a palindrome of length 3, which is the maximum.
+
+**Example 2:**
+
+**Input:** s = "aaazzz", k = 4
+
+**Output:** 6
+
+**Explanation:**
+
+*   Replace `s[0]` with the previous letter, and `s` becomes `"zaazzz"`.
+*   Replace `s[4]` with the next letter, and `s` becomes `"zaazaz"`.
+*   Replace `s[3]` with the next letter, and `s` becomes `"zaaaaz"`.
+
+The entire string forms a palindrome of length 6.
+
+**Constraints:**
+
+*   `1 <= s.length <= 200`
+*   `1 <= k <= 200`
+*   `s` consists of only lowercase English letters.

src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/Solution.kt

@@ -0,0 +1,44 @@
+package g3401_3500.s3473_sum_of_k_subarrays_with_length_at_least_m
+
+// #Medium #2025_03_02_Time_305_ms_(100.00%)_Space_76.92_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun maxSum(nums: IntArray, k: Int, m: Int): Int {
+        val n = nums.size
+        // Calculate prefix sums
+        val prefixSum = IntArray(n + 1)
+        for (i in 0..<n) {
+            prefixSum[i + 1] = prefixSum[i] + nums[i]
+        }
+        // using elements from nums[0...i-1]
+        val dp = Array<IntArray>(n + 1) { IntArray(k + 1) }
+        // Initialize dp array
+        for (j in 1..k) {
+            for (i in 0..n) {
+                dp[i][j] = Int.Companion.MIN_VALUE / 2
+            }
+        }
+        // Fill dp array
+        for (j in 1..k) {
+            val maxPrev = IntArray(n + 1)
+            for (i in 0..<n + 1) {
+                maxPrev[i] =
+                    if (i == 0) {
+                        dp[0][j - 1] - prefixSum[0]
+                    } else {
+                        max(maxPrev[i - 1], dp[i][j - 1] - prefixSum[i])
+                    }
+            }
+            for (i in m..n) {
+                // Option 1: Don't include the current element in any new subarray
+                dp[i][j] = dp[i - 1][j]
+                // Option 2: Form a new subarray ending at position i
+                // Find the best starting position for the subarray
+                dp[i][j] = max(dp[i][j], prefixSum[i] + maxPrev[i - m])
+            }
+        }
+        return dp[n][k]
+    }
+}

src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/readme.md

@@ -0,0 +1,39 @@
+3473\. Sum of K Subarrays With Length at Least M
+
+Medium
+
+You are given an integer array `nums` and two integers, `k` and `m`.
+
+Return the **maximum** sum of `k` non-overlapping subarrays of `nums`, where each subarray has a length of **at least** `m`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,-1,3,3,4], k = 2, m = 2
+
+**Output:** 13
+
+**Explanation:**
+
+The optimal choice is:
+
+*   Subarray `nums[3..5]` with sum `3 + 3 + 4 = 10` (length is `3 >= m`).
+*   Subarray `nums[0..1]` with sum `1 + 2 = 3` (length is `2 >= m`).
+
+The total sum is `10 + 3 = 13`.
+
+**Example 2:**
+
+**Input:** nums = [-10,3,-1,-2], k = 4, m = 1
+
+**Output:** \-10
+
+**Explanation:**
+
+The optimal choice is choosing each element as a subarray. The output is `(-10) + 3 + (-1) + (-2) = -10`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 2000`
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `1 <= k <= floor(nums.length / m)`
+*   `1 <= m <= 3`

src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/Solution.kt

@@ -0,0 +1,64 @@
+package g3401_3500.s3474_lexicographically_smallest_generated_string
+
+// #Hard #2025_03_02_Time_41_ms_(100.00%)_Space_39.75_MB_(100.00%)
+
+class Solution {
+    fun generateString(str1: String, str2: String): String {
+        val n = str1.length
+        val m = str2.length
+        val l = n + m - 1
+        val word = arrayOfNulls<Char>(l)
+        for (i in 0..<n) {
+            if (str1[i] == 'T') {
+                for (j in 0..<m) {
+                    val pos = i + j
+                    if (word[pos] != null && word[pos] != str2[j]) {
+                        return ""
+                    }
+                    word[pos] = str2[j]
+                }
+            }
+        }
+        val free = BooleanArray(l)
+        for (i in 0..<l) {
+            if (word[i] == null) {
+                word[i] = 'a'
+                free[i] = true
+            }
+        }
+        if (n == 0) {
+            return "a".repeat(l)
+        }
+        for (i in 0..<n) {
+            if (str1[i] == 'F' && intervalEquals(word, str2, i, m)) {
+                var fixed = false
+                for (j in m - 1 downTo 0) {
+                    val pos = i + j
+                    if (free[pos]) {
+                        word[pos] = 'b'
+                        free[pos] = false
+                        fixed = true
+                        break
+                    }
+                }
+                if (!fixed) {
+                    return ""
+                }
+            }
+        }
+        val sb = StringBuilder()
+        for (c in word) {
+            sb.append(c)
+        }
+        return sb.toString()
+    }
+
+    private fun intervalEquals(word: Array<Char?>, str2: String, i: Int, m: Int): Boolean {
+        for (j in 0..<m) {
+            if (word[i + j] == null || word[i + j] != str2[j]) {
+                return false
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/readme.md

@@ -0,0 +1,56 @@
+3474\. Lexicographically Smallest Generated String
+
+Hard
+
+You are given two strings, `str1` and `str2`, of lengths `n` and `m`, respectively.
+
+A string `word` of length `n + m - 1` is defined to be **generated** by `str1` and `str2` if it satisfies the following conditions for **each** index `0 <= i <= n - 1`:
+
+*   If `str1[i] == 'T'`, the **substring** of `word` with size `m` starting at index `i` is **equal** to `str2`, i.e., `word[i..(i + m - 1)] == str2`.
+*   If `str1[i] == 'F'`, the **substring** of `word` with size `m` starting at index `i` is **not equal** to `str2`, i.e., `word[i..(i + m - 1)] != str2`.
+
+Return the **lexicographically smallest** possible string that can be **generated** by `str1` and `str2`. If no string can be generated, return an empty string `""`.
+
+**Example 1:**
+
+**Input:** str1 = "TFTF", str2 = "ab"
+
+**Output:** "ababa"
+
+**Explanation:**
+
+#### The table below represents the string `"ababa"`
+
+| Index | T/F | Substring of length `m` |
+|-------|-----|-------------------------|
+| 0     | 'T' | "ab"                    |
+| 1     | 'F' | "ba"                    |
+| 2     | 'T' | "ab"                    |
+| 3     | 'F' | "ba"                    |
+
+The strings `"ababa"` and `"ababb"` can be generated by `str1` and `str2`.
+
+Return `"ababa"` since it is the lexicographically smaller string.
+
+**Example 2:**
+
+**Input:** str1 = "TFTF", str2 = "abc"
+
+**Output:** ""
+
+**Explanation:**
+
+No string that satisfies the conditions can be generated.
+
+**Example 3:**
+
+**Input:** str1 = "F", str2 = "d"
+
+**Output:** "a"
+
+**Constraints:**
+
+*   <code>1 <= n == str1.length <= 10<sup>4</sup></code>
+*   `1 <= m == str2.length <= 500`
+*   `str1` consists only of `'T'` or `'F'`.
+*   `str2` consists only of lowercase English characters.