Added tasks 3471-3474

Author: javadev

src/main/java/g3401_3500/s3471_find_the_largest_almost_missing_integer/Solution.java

@@ -0,0 +1,27 @@
+package g3401_3500.s3471_find_the_largest_almost_missing_integer;
+
+// #Easy #2025_03_02_Time_4_ms_(100.00%)_Space_44.26_MB_(100.00%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public int largestInteger(int[] nums, int k) {
+        int[] freq = new int[51];
+        for (int i = 0; i <= nums.length - k; i++) {
+            Set<Integer> set = new HashSet<>();
+            for (int j = i; j < i + k; j++) {
+                set.add(nums[j]);
+            }
+            for (int key : set) {
+                freq[key]++;
+            }
+        }
+        for (int i = 50; i >= 0; i--) {
+            if (freq[i] == 1) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

src/main/java/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/java/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/Solution.java

@@ -0,0 +1,38 @@
+package g3401_3500.s3472_longest_palindromic_subsequence_after_at_most_k_operations;
+
+// #Medium #2025_03_02_Time_153_ms_(100.00%)_Space_87.64_MB_(100.00%)
+
+public class Solution {
+    public int longestPalindromicSubsequence(String s, int k) {
+        int n = s.length();
+        int[][] arr = new int[26][26];
+        for (int i = 0; i < 26; i++) {
+            for (int j = 0; j < 26; j++) {
+                arr[i][j] = Math.min(Math.abs(i - j), 26 - Math.abs(i - j));
+            }
+        }
+        int[][][] dp = new int[n][n][k + 1];
+        for (int i = 0; i < n; i++) {
+            for (int it = 0; it <= k; it++) {
+                dp[i][i][it] = 1;
+            }
+        }
+        for (int length = 2; length <= n; length++) {
+            for (int i = 0; i <= n - length; i++) {
+                int j = i + length - 1;
+                for (int it = 0; it <= k; it++) {
+                    if (s.charAt(i) == s.charAt(j)) {
+                        dp[i][j][it] = 2 + dp[i + 1][j - 1][it];
+                    } else {
+                        int num1 = dp[i + 1][j][it];
+                        int num2 = dp[i][j - 1][it];
+                        int c = arr[s.charAt(i) - 'a'][s.charAt(j) - 'a'];
+                        int num3 = (it >= c) ? 2 + dp[i + 1][j - 1][it - c] : 0;
+                        dp[i][j][it] = Math.max(Math.max(num1, num2), num3);
+                    }
+                }
+            }
+        }
+        return dp[0][n - 1][k];
+    }
+}

src/main/java/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/java/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/Solution.java

@@ -0,0 +1,40 @@
+package g3401_3500.s3473_sum_of_k_subarrays_with_length_at_least_m;
+
+// #Medium #2025_03_02_Time_198_ms_(100.00%)_Space_83.70_MB_(100.00%)
+
+public class Solution {
+    public int maxSum(int[] nums, int k, int m) {
+        int n = nums.length;
+        // Calculate prefix sums
+        int[] prefixSum = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            prefixSum[i + 1] = prefixSum[i] + nums[i];
+        }
+        // using elements from nums[0...i-1]
+        int[][] dp = new int[n + 1][k + 1];
+        // Initialize dp array
+        for (int j = 1; j <= k; j++) {
+            for (int i = 0; i <= n; i++) {
+                dp[i][j] = Integer.MIN_VALUE / 2;
+            }
+        }
+        // Fill dp array
+        for (int j = 1; j <= k; j++) {
+            int[] maxPrev = new int[n + 1];
+            for (int i = 0; i < n + 1; i++) {
+                maxPrev[i] =
+                        (i == 0)
+                                ? dp[0][j - 1] - prefixSum[0]
+                                : Math.max(maxPrev[i - 1], dp[i][j - 1] - prefixSum[i]);
+            }
+            for (int i = m; i <= n; i++) {
+                // 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] = Math.max(dp[i][j], prefixSum[i] + maxPrev[i - m]);
+            }
+        }
+        return dp[n][k];
+    }
+}

src/main/java/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/java/g3401_3500/s3474_lexicographically_smallest_generated_string/Solution.java

@@ -0,0 +1,66 @@
+package g3401_3500.s3474_lexicographically_smallest_generated_string;
+
+// #Hard #2025_03_02_Time_16_ms_(100.00%)_Space_45.37_MB_(100.00%)
+
+public class Solution {
+    public String generateString(String str1, String str2) {
+        int n = str1.length();
+        int m = str2.length();
+        int l = n + m - 1;
+        Character[] word = new Character[l];
+        for (int i = 0; i < n; i++) {
+            if (str1.charAt(i) == 'T') {
+                for (int j = 0; j < m; j++) {
+                    int pos = i + j;
+                    if (word[pos] != null && word[pos] != str2.charAt(j)) {
+                        return "";
+                    }
+                    word[pos] = str2.charAt(j);
+                }
+            }
+        }
+        boolean[] free = new boolean[l];
+        for (int i = 0; i < l; i++) {
+            if (word[i] == null) {
+                word[i] = 'a';
+                free[i] = true;
+            }
+        }
+        if (n == 0) {
+            return String.join("", java.util.Collections.nCopies(l, "a"));
+        }
+        for (int i = 0; i < n; i++) {
+            if (str1.charAt(i) == 'F') {
+                if (intervalEquals(word, str2, i, m)) {
+                    boolean fixed = false;
+                    for (int j = m - 1; j >= 0; j--) {
+                        int pos = i + j;
+                        if (free[pos]) {
+                            word[pos] = 'b';
+                            free[pos] = false;
+                            fixed = true;
+                            break;
+                        }
+                    }
+                    if (!fixed) {
+                        return "";
+                    }
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (Character c : word) {
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+
+    private boolean intervalEquals(Character[] word, String str2, int i, int m) {
+        for (int j = 0; j < m; j++) {
+            if (word[i + j] == null || word[i + j] != str2.charAt(j)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/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.