Added tasks 3442-3446

Author: javadev

src/main/java/g3401_3500/s3442_maximum_difference_between_even_and_odd_frequency_i/Solution.java

@@ -0,0 +1,25 @@
+package g3401_3500.s3442_maximum_difference_between_even_and_odd_frequency_i;
+
+// #Easy #2025_02_02_Time_1_(100.00%)_Space_42.30_(_%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maxDifference(String s) {
+        int[] freq = new int[26];
+        Arrays.fill(freq, 0);
+        int maxOdd = 0;
+        int minEven = 1000;
+        for (int i = 0; i < s.length(); ++i) {
+            freq[s.charAt(i) - 'a']++;
+        }
+        for (int j : freq) {
+            if (j != 0 && j % 2 == 0) {
+                minEven = Math.min(minEven, j);
+            } else {
+                maxOdd = Math.max(maxOdd, j);
+            }
+        }
+        return maxOdd - minEven;
+    }
+}

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

@@ -0,0 +1,38 @@
+3442\. Maximum Difference Between Even and Odd Frequency I
+
+Easy
+
+You are given a string `s` consisting of lowercase English letters. Your task is to find the **maximum** difference between the frequency of **two** characters in the string such that:
+
+*   One of the characters has an **even frequency** in the string.
+*   The other character has an **odd frequency** in the string.
+
+Return the **maximum** difference, calculated as the frequency of the character with an **odd** frequency **minus** the frequency of the character with an **even** frequency.
+
+**Example 1:**
+
+**Input:** s = "aaaaabbc"
+
+**Output:** 3
+
+**Explanation:**
+
+*   The character `'a'` has an **odd frequency** of `5`, and `'b'` has an **even frequency** of `2`.
+*   The maximum difference is `5 - 2 = 3`.
+
+**Example 2:**
+
+**Input:** s = "abcabcab"
+
+**Output:** 1
+
+**Explanation:**
+
+*   The character `'a'` has an **odd frequency** of `3`, and `'c'` has an **even frequency** of 2.
+*   The maximum difference is `3 - 2 = 1`.
+
+**Constraints:**
+
+*   `3 <= s.length <= 100`
+*   `s` consists only of lowercase English letters.
+*   `s` contains at least one character with an odd frequency and one with an even frequency.

src/main/java/g3401_3500/s3443_maximum_manhattan_distance_after_k_changes/Solution.java

@@ -0,0 +1,28 @@
+package g3401_3500.s3443_maximum_manhattan_distance_after_k_changes;
+
+// #Medium #2025_02_02_Time_189_(_%)_Space_45.65_(100.00%)
+
+public class Solution {
+    public int maxDistance(String s, int k) {
+        int ans = 0;
+        char[][] dir = new char[][] {{'N', 'E'}, {'N', 'W'}, {'S', 'E'}, {'S', 'W'}};
+        for (char[] d : dir) {
+            int curr = 0;
+            int t = k;
+            for (int i = 0; i < s.length(); ++i) {
+                if (s.charAt(i) == d[0] || s.charAt(i) == d[1]) {
+                    if (t > 0) {
+                        t--;
+                        curr++;
+                    } else {
+                        curr--;
+                    }
+                } else {
+                    curr++;
+                }
+                ans = Math.max(ans, curr);
+            }
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,53 @@
+3443\. Maximum Manhattan Distance After K Changes
+
+Medium
+
+You are given a string `s` consisting of the characters `'N'`, `'S'`, `'E'`, and `'W'`, where `s[i]` indicates movements in an infinite grid:
+
+*   `'N'` : Move north by 1 unit.
+*   `'S'` : Move south by 1 unit.
+*   `'E'` : Move east by 1 unit.
+*   `'W'` : Move west by 1 unit.
+
+Initially, you are at the origin `(0, 0)`. You can change **at most** `k` characters to any of the four directions.
+
+Find the **maximum** **Manhattan distance** from the origin that can be achieved **at any time** while performing the movements **in order**.
+
+The **Manhattan Distance** between two cells <code>(x<sub>i</sub>, y<sub>i</sub>)</code> and <code>(x<sub>j</sub>, y<sub>j</sub>)</code> is <code>|x<sub>i</sub> - x<sub>j</sub>| + |y<sub>i</sub> - y<sub>j</sub>|</code>.
+
+**Example 1:**
+
+**Input:** s = "NWSE", k = 1
+
+**Output:** 3
+
+**Explanation:**
+
+Change `s[2]` from `'S'` to `'N'`. The string `s` becomes `"NWNE"`.
+
+| Movement         | Position (x, y) | Manhattan Distance | Maximum |
+|-----------------|----------------|--------------------|---------|
+| s[0] == 'N'    | (0, 1)         | 0 + 1 = 1         | 1       |
+| s[1] == 'W'    | (-1, 1)        | 1 + 1 = 2         | 2       |
+| s[2] == 'N'    | (-1, 2)        | 1 + 2 = 3         | 3       |
+| s[3] == 'E'    | (0, 2)         | 0 + 2 = 2         | 3       |
+
+The maximum Manhattan distance from the origin that can be achieved is 3. Hence, 3 is the output.
+
+**Example 2:**
+
+**Input:** s = "NSWWEW", k = 3
+
+**Output:** 6
+
+**Explanation:**
+
+Change `s[1]` from `'S'` to `'N'`, and `s[4]` from `'E'` to `'W'`. The string `s` becomes `"NNWWWW"`.
+
+The maximum Manhattan distance from the origin that can be achieved is 6. Hence, 6 is the output.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `0 <= k <= s.length`
+*   `s` consists of only `'N'`, `'S'`, `'E'`, and `'W'`.

src/main/java/g3401_3500/s3444_minimum_increments_for_target_multiples_in_an_array/Solution.java

@@ -0,0 +1,48 @@
+package g3401_3500.s3444_minimum_increments_for_target_multiples_in_an_array;
+
+// #Hard #2025_02_02_Time_47_(100.00%)_Space_47.37_(100.00%)
+
+public class Solution {
+    public int minimumIncrements(int[] nums, int[] target) {
+        int m = target.length;
+        int fullMask = (1 << m) - 1;
+        long[] lcmArr = new long[1 << m];
+        for (int mask = 1; mask < (1 << m); mask++) {
+            long l = 1;
+            for (int j = 0; j < m; j++) {
+                if ((mask & (1 << j)) != 0) {
+                    l = lcm(l, target[j]);
+                }
+            }
+            lcmArr[mask] = l;
+        }
+        long inf = Long.MAX_VALUE / 2;
+        long[] dp = new long[1 << m];
+        for (int i = 0; i < (1 << m); i++) {
+            dp[i] = inf;
+        }
+        dp[0] = 0;
+        for (int x : nums) {
+            long[] newdp = dp.clone();
+            for (int mask = 1; mask < (1 << m); mask++) {
+                long l = lcmArr[mask];
+                long r = x % l;
+                long cost = (r == 0 ? 0 : l - r);
+                for (int old = 0; old < (1 << m); old++) {
+                    int newMask = old | mask;
+                    newdp[newMask] = Math.min(newdp[newMask], dp[old] + cost);
+                }
+            }
+            dp = newdp;
+        }
+        return (int) dp[fullMask];
+    }
+
+    private long gcd(long a, long b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+
+    private long lcm(long a, long b) {
+        return a / gcd(a, b) * b;
+    }
+}

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

@@ -0,0 +1,50 @@
+3444\. Minimum Increments for Target Multiples in an Array
+
+Hard
+
+You are given two arrays, `nums` and `target`.
+
+In a single operation, you may increment any element of `nums` by 1.
+
+Return **the minimum number** of operations required so that each element in `target` has **at least** one multiple in `nums`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], target = [4]
+
+**Output:** 1
+
+**Explanation:**
+
+The minimum number of operations required to satisfy the condition is 1.
+
+*   Increment 3 to 4 with just one operation, making 4 a multiple of itself.
+
+**Example 2:**
+
+**Input:** nums = [8,4], target = [10,5]
+
+**Output:** 2
+
+**Explanation:**
+
+The minimum number of operations required to satisfy the condition is 2.
+
+*   Increment 8 to 10 with 2 operations, making 10 a multiple of both 5 and 10.
+
+**Example 3:**
+
+**Input:** nums = [7,9,10], target = [7]
+
+**Output:** 0
+
+**Explanation:**
+
+Target 7 already has a multiple in nums, so no additional operations are needed.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 5 * 10<sup>4</sup></code>
+*   `1 <= target.length <= 4`
+*   `target.length <= nums.length`
+*   <code>1 <= nums[i], target[i] <= 10<sup>4</sup></code>

src/main/java/g3401_3500/s3445_maximum_difference_between_even_and_odd_frequency_ii/Solution.java

@@ -0,0 +1,91 @@
+package g3401_3500.s3445_maximum_difference_between_even_and_odd_frequency_ii;
+
+// #Hard #2025_02_02_Time_97_(100.00%)_Space_52.67_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maxDifference(String s, int k) {
+        int n = s.length();
+        int[][] pre = new int[5][n];
+        int[][] closestRight = new int[5][n];
+        for (int x = 0; x < 5; x++) {
+            Arrays.fill(closestRight[x], n);
+            for (int i = 0; i < n; i++) {
+                int num = s.charAt(i) - '0';
+                pre[x][i] = (num == x) ? 1 : 0;
+                if (i > 0) {
+                    pre[x][i] += pre[x][i - 1];
+                }
+            }
+            for (int i = n - 1; i >= 0; i--) {
+                int num = s.charAt(i) - '0';
+                if (i < n - 1) {
+                    closestRight[x][i] = closestRight[x][i + 1];
+                }
+                if (num == x) {
+                    closestRight[x][i] = i;
+                }
+            }
+        }
+        int ans = Integer.MIN_VALUE;
+        for (int a = 0; a <= 4; a++) {
+            for (int b = 0; b <= 4; b++) {
+                if (a != b) {
+                    ans = Math.max(ans, go(k, a, b, pre, closestRight, n));
+                }
+            }
+        }
+        return ans;
+    }
+
+    private int go(int k, int odd, int even, int[][] pre, int[][] closestRight, int n) {
+        int[][][] suf = new int[2][2][n];
+        for (int[][] arr2D : suf) {
+            for (int[] arr : arr2D) {
+                Arrays.fill(arr, Integer.MIN_VALUE);
+            }
+        }
+        for (int endIdx = 0; endIdx < n; endIdx++) {
+            int oddParity = pre[odd][endIdx] % 2;
+            int evenParity = pre[even][endIdx] % 2;
+            if (pre[odd][endIdx] > 0 && pre[even][endIdx] > 0) {
+                suf[oddParity][evenParity][endIdx] = pre[odd][endIdx] - pre[even][endIdx];
+            }
+        }
+        for (int oddParity = 0; oddParity < 2; oddParity++) {
+            for (int evenParity = 0; evenParity < 2; evenParity++) {
+                for (int endIdx = n - 2; endIdx >= 0; endIdx--) {
+                    suf[oddParity][evenParity][endIdx] =
+                            Math.max(
+                                    suf[oddParity][evenParity][endIdx],
+                                    suf[oddParity][evenParity][endIdx + 1]);
+                }
+            }
+        }
+        int ans = Integer.MIN_VALUE;
+        for (int startIdx = 0; startIdx < n; startIdx++) {
+            int minEndIdx = startIdx + k - 1;
+            if (minEndIdx >= n) {
+                break;
+            }
+            int oddBelowI = (startIdx == 0 ? 0 : pre[odd][startIdx - 1]);
+            int evenBelowI = (startIdx == 0 ? 0 : pre[even][startIdx - 1]);
+            int goodOddParity = (oddBelowI + 1) % 2;
+            int goodEvenParity = evenBelowI % 2;
+            int query =
+                    Math.max(
+                            Math.max(startIdx + k - 1, closestRight[odd][startIdx]),
+                            closestRight[even][startIdx]);
+            if (query >= n) {
+                continue;
+            }
+            int val = suf[goodOddParity][goodEvenParity][query];
+            if (val == Integer.MIN_VALUE) {
+                continue;
+            }
+            ans = Math.max(ans, val - oddBelowI + evenBelowI);
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,50 @@
+3445\. Maximum Difference Between Even and Odd Frequency II
+
+Hard
+
+You are given a string `s` and an integer `k`. Your task is to find the **maximum** difference between the frequency of **two** characters, `freq[a] - freq[b]`, in a
+
+substring
+
+`subs` of `s`, such that:
+
+*   `subs` has a size of **at least** `k`.
+*   Character `a` has an _odd frequency_ in `subs`.
+*   Character `b` has an _even frequency_ in `subs`.
+
+Return the **maximum** difference.
+
+**Note** that `subs` can contain more than 2 **distinct** characters.
+
+**Example 1:**
+
+**Input:** s = "12233", k = 4
+
+**Output:** \-1
+
+**Explanation:**
+
+For the substring `"12233"`, the frequency of `'1'` is 1 and the frequency of `'3'` is 2. The difference is `1 - 2 = -1`.
+
+**Example 2:**
+
+**Input:** s = "1122211", k = 3
+
+**Output:** 1
+
+**Explanation:**
+
+For the substring `"11222"`, the frequency of `'2'` is 3 and the frequency of `'1'` is 2. The difference is `3 - 2 = 1`.
+
+**Example 3:**
+
+**Input:** s = "110", k = 3
+
+**Output:** \-1
+
+**Constraints:**
+
+*   <code>3 <= s.length <= 3 * 10<sup>4</sup></code>
+*   `s` consists only of digits `'0'` to `'4'`.
+*   The input is generated that at least one substring has a character with an even frequency and a character with an odd frequency.
+*   `1 <= k <= s.length`