Added tasks 3467-3470

Author: javadev

src/main/java/g3401_3500/s3467_transform_array_by_parity/Solution.java

@@ -0,0 +1,19 @@
+package g3401_3500.s3467_transform_array_by_parity;
+
+// #Easy #2025_03_02_Time_2_ms_(100.00%)_Space_45.06_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[] transformArray(int[] nums) {
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] % 2 == 0) {
+                nums[i] = 0;
+            } else {
+                nums[i] = 1;
+            }
+        }
+        Arrays.sort(nums);
+        return nums;
+    }
+}

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

@@ -0,0 +1,38 @@
+3467\. Transform Array by Parity
+
+Easy
+
+You are given an integer array `nums`. Transform `nums` by performing the following operations in the **exact** order specified:
+
+1.  Replace each even number with 0.
+2.  Replace each odd numbers with 1.
+3.  Sort the modified array in **non-decreasing** order.
+
+Return the resulting array after performing these operations.
+
+**Example 1:**
+
+**Input:** nums = [4,3,2,1]
+
+**Output:** [0,0,1,1]
+
+**Explanation:**
+
+*   Replace the even numbers (4 and 2) with 0 and the odd numbers (3 and 1) with 1. Now, `nums = [0, 1, 0, 1]`.
+*   After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1]`.
+
+**Example 2:**
+
+**Input:** nums = [1,5,1,4,2]
+
+**Output:** [0,0,1,1,1]
+
+**Explanation:**
+
+*   Replace the even numbers (4 and 2) with 0 and the odd numbers (1, 5 and 1) with 1. Now, `nums = [1, 1, 1, 0, 0]`.
+*   After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1, 1]`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 1000`

src/main/java/g3401_3500/s3468_find_the_number_of_copy_arrays/Solution.java

@@ -0,0 +1,18 @@
+package g3401_3500.s3468_find_the_number_of_copy_arrays;
+
+// #Medium #2025_03_02_Time_2_ms_(100.00%)_Space_97.78_MB_(100.00%)
+
+public class Solution {
+    int countArrays(int[] original, int[][] bounds) {
+        int low = bounds[0][0];
+        int high = bounds[0][1];
+        int ans = high - low + 1;
+        for (int i = 1; i < original.length; ++i) {
+            int diff = original[i] - original[i - 1];
+            low = Math.max(low + diff, bounds[i][0]);
+            high = Math.min(high + diff, bounds[i][1]);
+            ans = Math.min(ans, high - low + 1);
+        }
+        return Math.max(ans, 0);
+    }
+}

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

@@ -0,0 +1,58 @@
+3468\. Find the Number of Copy Arrays
+
+Medium
+
+You are given an array `original` of length `n` and a 2D array `bounds` of length `n x 2`, where <code>bounds[i] = [u<sub>i</sub>, v<sub>i</sub>]</code>.
+
+You need to find the number of **possible** arrays `copy` of length `n` such that:
+
+1.  `(copy[i] - copy[i - 1]) == (original[i] - original[i - 1])` for `1 <= i <= n - 1`.
+2.  <code>u<sub>i</sub> <= copy[i] <= v<sub>i</sub></code> for `0 <= i <= n - 1`.
+
+Return the number of such arrays.
+
+**Example 1:**
+
+**Input:** original = [1,2,3,4], bounds = [[1,2],[2,3],[3,4],[4,5]]
+
+**Output:** 2
+
+**Explanation:**
+
+The possible arrays are:
+
+*   `[1, 2, 3, 4]`
+*   `[2, 3, 4, 5]`
+
+**Example 2:**
+
+**Input:** original = [1,2,3,4], bounds = [[1,10],[2,9],[3,8],[4,7]]
+
+**Output:** 4
+
+**Explanation:**
+
+The possible arrays are:
+
+*   `[1, 2, 3, 4]`
+*   `[2, 3, 4, 5]`
+*   `[3, 4, 5, 6]`
+*   `[4, 5, 6, 7]`
+
+**Example 3:**
+
+**Input:** original = [1,2,1,2], bounds = [[1,1],[2,3],[3,3],[2,3]]
+
+**Output:** 0
+
+**Explanation:**
+
+No array is possible.
+
+**Constraints:**
+
+*   <code>2 <= n == original.length <= 10<sup>5</sup></code>
+*   <code>1 <= original[i] <= 10<sup>9</sup></code>
+*   `bounds.length == n`
+*   `bounds[i].length == 2`
+*   <code>1 <= bounds[i][0] <= bounds[i][1] <= 10<sup>9</sup></code>

src/main/java/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/Solution.java

@@ -0,0 +1,28 @@
+package g3401_3500.s3469_find_minimum_cost_to_remove_array_elements;
+
+// #Medium #2025_03_02_Time_540_ms_(100.00%)_Space_57.03_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private int[][] dp;
+
+    public int minCost(int[] nums) {
+        dp = new int[1001][1001];
+        Arrays.stream(dp).forEach(row -> Arrays.fill(row, -1));
+        return solve(nums, 1, 0);
+    }
+
+    private int solve(int[] nums, int i, int last) {
+        if (i + 1 >= nums.length) {
+            return Math.max(nums[last], (i < nums.length ? nums[i] : 0));
+        }
+        if (dp[i][last] != -1) {
+            return dp[i][last];
+        }
+        int res = Math.max(nums[i], nums[i + 1]) + solve(nums, i + 2, last);
+        res = Math.min(res, Math.max(nums[i], nums[last]) + solve(nums, i + 2, i + 1));
+        res = Math.min(res, Math.max(nums[i + 1], nums[last]) + solve(nums, i + 2, i));
+        return dp[i][last] = res;
+    }
+}

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

@@ -0,0 +1,45 @@
+3469\. Find Minimum Cost to Remove Array Elements
+
+Medium
+
+You are given an integer array `nums`. Your task is to remove **all elements** from the array by performing one of the following operations at each step until `nums` is empty:
+
+*   Choose any two elements from the first three elements of `nums` and remove them. The cost of this operation is the **maximum** of the two elements removed.
+*   If fewer than three elements remain in `nums`, remove all the remaining elements in a single operation. The cost of this operation is the **maximum** of the remaining elements.
+
+Return the **minimum** cost required to remove all the elements.
+
+**Example 1:**
+
+**Input:** nums = [6,2,8,4]
+
+**Output:** 12
+
+**Explanation:**
+
+Initially, `nums = [6, 2, 8, 4]`.
+
+*   In the first operation, remove `nums[0] = 6` and `nums[2] = 8` with a cost of `max(6, 8) = 8`. Now, `nums = [2, 4]`.
+*   In the second operation, remove the remaining elements with a cost of `max(2, 4) = 4`.
+
+The cost to remove all elements is `8 + 4 = 12`. This is the minimum cost to remove all elements in `nums`. Hence, the output is 12.
+
+**Example 2:**
+
+**Input:** nums = [2,1,3,3]
+
+**Output:** 5
+
+**Explanation:**
+
+Initially, `nums = [2, 1, 3, 3]`.
+
+*   In the first operation, remove `nums[0] = 2` and `nums[1] = 1` with a cost of `max(2, 1) = 2`. Now, `nums = [3, 3]`.
+*   In the second operation remove the remaining elements with a cost of `max(3, 3) = 3`.
+
+The cost to remove all elements is `2 + 3 = 5`. This is the minimum cost to remove all elements in `nums`. Hence, the output is 5.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>

src/main/java/g3401_3500/s3470_permutations_iv/Solution.java

@@ -0,0 +1,147 @@
+package g3401_3500.s3470_permutations_iv;
+
+// #Hard #2025_03_02_Time_12_ms_(100.00%)_Space_45.94_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    // Define a large constant value to cap calculations and prevent overflow
+    private static final long CAP = 1000000000000001L;
+    // 3D DP array to store precomputed results for dynamic programming
+    private static final long[][][] DP = new long[105][105][3];
+
+    // Initialize DP array with -1 (indicating uncomputed states)
+    static {
+        for (long[][] longs : DP) {
+            for (long[] aLong : longs) {
+                Arrays.fill(aLong, -1);
+            }
+        }
+    }
+
+    // Recursive function to count alternating permutations
+    private long rec(int o, int e, int req) {
+        if (o == 0 && e == 0) {
+            return 1;
+        }
+        if (DP[o][e][req] != -1) {
+            return DP[o][e][req];
+        }
+        long count = 0;
+        if (req == 2) {
+            if (o > 0) {
+                count = addCapped(count, multiplyCapped(o, rec(o - 1, e, 1)));
+            }
+            if (e > 0) {
+                count = addCapped(count, multiplyCapped(e, rec(o, e - 1, 0)));
+            }
+        } else if (req == 0) {
+            if (o > 0) {
+                count = multiplyCapped(o, rec(o - 1, e, 1));
+            }
+        } else {
+            if (e > 0) {
+                count = multiplyCapped(e, rec(o, e - 1, 0));
+            }
+        }
+        DP[o][e][req] = count;
+        return count;
+    }
+
+    // Helper function to prevent overflow when multiplying
+    private long multiplyCapped(long a, long b) {
+        if (b == 0) {
+            return 0;
+        }
+        if (a >= CAP || b >= CAP || a > CAP / b) {
+            return CAP;
+        }
+        return a * b;
+    }
+
+    // Helper function to prevent overflow when adding
+    private long addCapped(long a, long b) {
+        long res = a + b;
+        return Math.min(res, CAP);
+    }
+
+    public int[] permute(int n, long k) {
+        // Separate odd and even numbers from 1 to n
+        List<Integer> odds = new ArrayList<>();
+        List<Integer> evens = new ArrayList<>();
+        for (int x = 1; x <= n; x++) {
+            if ((x & 1) == 1) {
+                odds.add(x);
+            } else {
+                evens.add(x);
+            }
+        }
+        // Count the number of odd and even elements
+        int oCount = odds.size();
+        int eCount = evens.size();
+        long ansTotal = rec(oCount, eCount, 2);
+        if (k > ansTotal) {
+            return new int[0];
+        }
+        List<Integer> result = new ArrayList<>();
+        int req = 2;
+        while (oCount + eCount > 0) {
+            List<Integer> candidates = new ArrayList<>();
+            if (req == 2) {
+                int i = 0;
+                int j = 0;
+                while (i < odds.size() || j < evens.size()) {
+                    if (j >= evens.size() || (i < odds.size() && odds.get(i) < evens.get(j))) {
+                        candidates.add(odds.get(i++));
+                    } else {
+                        candidates.add(evens.get(j++));
+                    }
+                }
+            } else if (req == 0) {
+                candidates.addAll(odds);
+            } else {
+                candidates.addAll(evens);
+            }
+            boolean found = false;
+            for (int num : candidates) {
+                int candidateParity = (num % 2 == 1) ? 0 : 1;
+                if (req != 2 && candidateParity != req) {
+                    continue;
+                }
+                long ways;
+                if (candidateParity == 0) {
+                    ways = rec(oCount - 1, eCount, 1);
+                } else {
+                    ways = rec(oCount, eCount - 1, 0);
+                }
+                if (ways >= k) {
+                    result.add(num);
+                    if (candidateParity == 0) {
+                        odds.remove(Integer.valueOf(num));
+                        oCount--;
+                        req = 1;
+                    } else {
+                        evens.remove(Integer.valueOf(num));
+                        eCount--;
+                        req = 0;
+                    }
+                    found = true;
+                    break;
+                } else {
+                    k -= ways;
+                }
+            }
+            if (!found) {
+                return new int[0];
+            }
+        }
+        // Convert result list to array and return
+        int[] ans = new int[result.size()];
+        for (int i = 0; i < result.size(); i++) {
+            ans[i] = result.get(i);
+        }
+        return ans;
+    }
+}