Added tasks 3658-3661

Author: javadev

src/main/java/g3601_3700/s3658_gcd_of_odd_and_even_sums/Solution.java

@@ -0,0 +1,9 @@
+package g3601_3700.s3658_gcd_of_odd_and_even_sums;
+
+// #Easy #Weekly_Contest_464 #2025_08_24_Time_1_ms_(100.00%)_Space_41.16_MB_(100.00%)
+
+public class Solution {
+    public int gcdOfOddEvenSums(int n) {
+        return (n < 0) ? -n : n;
+    }
+}

src/main/java/g3601_3700/s3658_gcd_of_odd_and_even_sums/readme.md

@@ -0,0 +1,42 @@
+3658\. GCD of Odd and Even Sums
+
+Easy
+
+You are given an integer `n`. Your task is to compute the **GCD** (greatest common divisor) of two values:
+
+*   `sumOdd`: the sum of the first `n` odd numbers.
+    
+*   `sumEven`: the sum of the first `n` even numbers.
+    
+
+Return the GCD of `sumOdd` and `sumEven`.
+
+**Example 1:**
+
+**Input:** n = 4
+
+**Output:** 4
+
+**Explanation:**
+
+*   Sum of the first 4 odd numbers `sumOdd = 1 + 3 + 5 + 7 = 16`
+*   Sum of the first 4 even numbers `sumEven = 2 + 4 + 6 + 8 = 20`
+
+Hence, `GCD(sumOdd, sumEven) = GCD(16, 20) = 4`.
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** 5
+
+**Explanation:**
+
+*   Sum of the first 5 odd numbers `sumOdd = 1 + 3 + 5 + 7 + 9 = 25`
+*   Sum of the first 5 even numbers `sumEven = 2 + 4 + 6 + 8 + 10 = 30`
+
+Hence, `GCD(sumOdd, sumEven) = GCD(25, 30) = 5`.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`

src/main/java/g3601_3700/s3659_partition_array_into_k_distinct_groups/Solution.java

@@ -0,0 +1,20 @@
+package g3601_3700.s3659_partition_array_into_k_distinct_groups;
+
+// #Medium #Weekly_Contest_464 #2025_08_24_Time_81_ms_(100.00%)_Space_62.78_MB_(100.00%)
+
+import java.util.HashMap;
+
+public class Solution {
+    public boolean partitionArray(int[] nums, int k) {
+        HashMap<Integer, Integer> mpp = new HashMap<>();
+        for (int x : nums) {
+            mpp.put(x, mpp.getOrDefault(x, 0) + 1);
+        }
+        for (int count : mpp.values()) {
+            if (count > nums.length / k) {
+                return false;
+            }
+        }
+        return nums.length % k == 0;
+    }
+}

src/main/java/g3601_3700/s3659_partition_array_into_k_distinct_groups/readme.md

@@ -0,0 +1,58 @@
+3659\. Partition Array Into K-Distinct Groups
+
+Medium
+
+You are given an integer array `nums` and an integer `k`.
+
+Your task is to determine whether it is possible to partition all elements of `nums` into one or more groups such that:
+
+*   Each group contains **exactly** `k` **distinct** elements.
+*   Each element in `nums` must be assigned to **exactly** one group.
+
+Return `true` if such a partition is possible, otherwise return `false`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4], k = 2
+
+**Output:** true
+
+**Explanation:**
+
+One possible partition is to have 2 groups:
+
+*   Group 1: `[1, 2]`
+*   Group 2: `[3, 4]`
+
+Each group contains `k = 2` distinct elements, and all elements are used exactly once.
+
+**Example 2:**
+
+**Input:** nums = [3,5,2,2], k = 2
+
+**Output:** true
+
+**Explanation:**
+
+One possible partition is to have 2 groups:
+
+*   Group 1: `[2, 3]`
+*   Group 2: `[2, 5]`
+
+Each group contains `k = 2` distinct elements, and all elements are used exactly once.
+
+**Example 3:**
+
+**Input:** nums = [1,5,2,3], k = 3
+
+**Output:** false
+
+**Explanation:**
+
+We cannot form groups of `k = 3` distinct elements using all values exactly once.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   `1 <= k <= nums.length`

src/main/java/g3601_3700/s3660_jump_game_ix/Solution.java

@@ -0,0 +1,89 @@
+package g3601_3700.s3660_jump_game_ix;
+
+// #Medium #Weekly_Contest_464 #2025_08_24_Time_248_ms_(100.00%)_Space_72.98_MB_(100.00%)
+
+import java.util.ArrayDeque;
+import java.util.HashMap;
+
+public class Solution {
+    public int[] maxValue(int[] nums) {
+        int n = nums.length;
+        ArrayDeque<Integer> st = new ArrayDeque<>();
+        UnionFind uf = new UnionFind(n);
+        for (int i = 0; i < n; i++) {
+            int prev = i;
+            if (!st.isEmpty()) {
+                prev = st.peek();
+            }
+            while (!st.isEmpty() && nums[i] < nums[st.peek()]) {
+                uf.union(st.pop(), i);
+            }
+            if (nums[i] > nums[prev]) {
+                st.push(i);
+            } else {
+                st.push(prev);
+            }
+        }
+        st.clear();
+        for (int i = n - 1; i >= 0; i--) {
+            int prev = i;
+            if (!st.isEmpty()) {
+                prev = st.peek();
+            }
+            while (!st.isEmpty() && nums[i] > nums[st.peek()]) {
+                uf.union(st.pop(), i);
+            }
+            if (nums[i] < nums[prev]) {
+                st.push(i);
+            } else {
+                st.push(prev);
+            }
+        }
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            int root = uf.find(i);
+            map.put(root, Math.max(map.getOrDefault(root, Integer.MIN_VALUE), nums[i]));
+        }
+        int[] ans = new int[n];
+        for (int i = 0; i < n; i++) {
+            ans[i] = map.get(uf.find(i));
+        }
+        return ans;
+    }
+
+    private static class UnionFind {
+        int[] par;
+        int[] rank;
+
+        UnionFind(int n) {
+            par = new int[n];
+            rank = new int[n];
+            for (int i = 0; i < n; i++) {
+                par[i] = i;
+            }
+        }
+
+        int find(int x) {
+            if (par[x] != x) {
+                par[x] = find(par[x]);
+            }
+            return par[x];
+        }
+
+        void union(int x, int y) {
+            x = find(x);
+            y = find(y);
+            if (x == y) {
+                return;
+            }
+            if (rank[x] < rank[y]) {
+                par[x] = y;
+            } else if (rank[x] > rank[y]) {
+                par[y] = x;
+            } else {
+                par[y] = x;
+                rank[x]++;
+            }
+        }
+    }
+}

src/main/java/g3601_3700/s3660_jump_game_ix/readme.md

@@ -0,0 +1,47 @@
+3660\. Jump Game IX
+
+Medium
+
+You are given an integer array `nums`.
+
+From any index `i`, you can jump to another index `j` under the following rules:
+
+*   Jump to index `j` where `j > i` is allowed only if `nums[j] < nums[i]`.
+*   Jump to index `j` where `j < i` is allowed only if `nums[j] > nums[i]`.
+
+For each index `i`, find the **maximum** **value** in `nums` that can be reached by following **any** sequence of valid jumps starting at `i`.
+
+Return an array `ans` where `ans[i]` is the **maximum** **value** reachable starting from index `i`.
+
+**Example 1:**
+
+**Input:** nums = [2,1,3]
+
+**Output:** [2,2,3]
+
+**Explanation:**
+
+*   For `i = 0`: No jump increases the value.
+*   For `i = 1`: Jump to `j = 0` as `nums[j] = 2` is greater than `nums[i]`.
+*   For `i = 2`: Since `nums[2] = 3` is the maximum value in `nums`, no jump increases the value.
+
+Thus, `ans = [2, 2, 3]`.
+
+**Example 2:**
+
+**Input:** nums = [2,3,1]
+
+**Output:** [3,3,3]
+
+**Explanation:**
+
+*   For `i = 0`: Jump forward to `j = 2` as `nums[j] = 1` is less than `nums[i] = 2`, then from `i = 2` jump to `j = 1` as `nums[j] = 3` is greater than `nums[2]`.
+*   For `i = 1`: Since `nums[1] = 3` is the maximum value in `nums`, no jump increases the value.
+*   For `i = 2`: Jump to `j = 1` as `nums[j] = 3` is greater than `nums[2] = 1`.
+
+Thus, `ans = [3, 3, 3]`.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g3601_3700/s3661_maximum_walls_destroyed_by_robots/Solution.java

@@ -0,0 +1,120 @@
+package g3601_3700.s3661_maximum_walls_destroyed_by_robots;
+
+// #Hard #Weekly_Contest_464 #2025_08_24_Time_164_ms_(100.00%)_Space_59.97_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maxWalls(int[] robots, int[] distance, int[] walls) {
+        int n = robots.length;
+        // Pair robots with distances and sort
+        int[][] rpair = new int[n][2];
+        for (int i = 0; i < n; i++) {
+            rpair[i][0] = robots[i];
+            rpair[i][1] = distance[i];
+        }
+        Arrays.sort(rpair, (a, b) -> Integer.compare(a[0], b[0]));
+        int[] r = new int[n];
+        int[] d = new int[n];
+        for (int i = 0; i < n; i++) {
+            r[i] = rpair[i][0];
+            d[i] = rpair[i][1];
+        }
+        Arrays.sort(walls);
+        // Count walls at robot positions
+        int base = 0;
+        for (int i = 0; i < n; i++) {
+            int idx = Arrays.binarySearch(walls, r[i]);
+            if (idx >= 0) {
+                base++;
+            }
+        }
+        // Tail walls
+        int leftTail = countRange(walls, r[0] - d[0], r[0] - 1);
+        int rightTail = countRange(walls, r[n - 1] + 1, r[n - 1] + d[n - 1]);
+        // Precompute segment ranges
+        int segs = n - 1;
+        int max = Math.max(0, segs);
+        int[] a = new int[max];
+        int[] b = new int[max];
+        int[] c = new int[max];
+        for (int i = 0; i < segs; i++) {
+            int segL = r[i] + 1;
+            int segR = r[i + 1] - 1;
+            if (segL > segR) {
+                a[i] = b[i] = c[i] = 0;
+                continue;
+            }
+            int aHigh = Math.min(segR, r[i] + d[i]);
+            a[i] = countRange(walls, segL, aHigh);
+            int bLow = Math.max(segL, r[i + 1] - d[i + 1]);
+            b[i] = countRange(walls, bLow, segR);
+            int cLow = Math.max(segL, r[i + 1] - d[i + 1]);
+            int cHigh = Math.min(segR, r[i] + d[i]);
+            c[i] = countRange(walls, cLow, cHigh);
+        }
+        int[][] dp = new int[n][2];
+        Arrays.fill(dp[0], Integer.MIN_VALUE / 4);
+        // first fires left
+        dp[0][0] = base + leftTail;
+        // first fires right
+        dp[0][1] = base;
+        for (int i = 0; i < n - 1; i++) {
+            Arrays.fill(dp[i + 1], Integer.MIN_VALUE / 4);
+            for (int choice = 0; choice <= 1; choice++) {
+                int cur = dp[i][choice];
+                if (cur < 0) {
+                    continue;
+                }
+                int addIfNextLeft = (choice == 1) ? a[i] + b[i] - c[i] : b[i];
+                dp[i + 1][0] = Math.max(dp[i + 1][0], cur + addIfNextLeft);
+                int addIfNextRight = (choice == 1) ? a[i] : 0;
+                dp[i + 1][1] = Math.max(dp[i + 1][1], cur + addIfNextRight);
+            }
+        }
+        int res;
+        if (n == 1) {
+            res = Math.max(dp[0][0], dp[0][1] + rightTail);
+        } else {
+            res = Math.max(dp[n - 1][0], dp[n - 1][1] + rightTail);
+        }
+        return res;
+    }
+
+    private int countRange(int[] arr, long l, long r) {
+        if (l > r || arr.length == 0) {
+            return 0;
+        }
+        int leftIdx = lowerBound(arr, l);
+        int rightIdx = upperBound(arr, r);
+        return Math.max(0, rightIdx - leftIdx);
+    }
+
+    private int lowerBound(int[] a, long x) {
+        int l = 0;
+        int r = a.length;
+        while (l < r) {
+            int m = (l + r) >>> 1;
+            if (a[m] < x) {
+                l = m + 1;
+            } else {
+                r = m;
+            }
+        }
+        return l;
+    }
+
+    private int upperBound(int[] a, long x) {
+        int l = 0;
+        int r = a.length;
+        while (l < r) {
+            int m = (l + r) >>> 1;
+            if (a[m] <= x) {
+                l = m + 1;
+            } else {
+                r = m;
+            }
+        }
+        return l;
+    }
+}