Added tasks 2596-2601

Author: javadev

src/main/java/g2501_2600/s2596_check_knight_tour_configuration/Solution.java

@@ -0,0 +1,37 @@
+package g2501_2600.s2596_check_knight_tour_configuration;
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix #Simulation
+// #2023_08_29_Time_1_ms_(100.00%)_Space_43.4_MB_(42.62%)
+
+public class Solution {
+    public boolean checkValidGrid(int[][] grid) {
+        if (grid[0][0] != 0) {
+            return false;
+        }
+        int n = grid.length;
+        int m = grid[0].length;
+        int[] rmove = {2, 2, -2, -2, 1, 1, -1, -1};
+        int[] cmove = {1, -1, 1, -1, 2, -2, 2, -2};
+        int cnt = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                int val = grid[i][j];
+                boolean isPoss = false;
+                for (int d = 0; d < 8; d++) {
+                    int r = i + rmove[d];
+                    int c = j + cmove[d];
+                    if (r >= 0 && c >= 0 && r < n && c < m && grid[r][c] == val + 1) {
+                        isPoss = true;
+                    }
+                }
+                if (!isPoss) {
+                    cnt++;
+                }
+                if (cnt > 1) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

src/main/java/g2501_2600/s2596_check_knight_tour_configuration/readme.md

@@ -0,0 +1,40 @@
+2596\. Check Knight Tour Configuration
+
+Medium
+
+There is a knight on an `n x n` chessboard. In a valid configuration, the knight starts **at the top-left cell** of the board and visits every cell on the board **exactly once**.
+
+You are given an `n x n` integer matrix `grid` consisting of distinct integers from the range `[0, n * n - 1]` where `grid[row][col]` indicates that the cell `(row, col)` is the <code>grid[row][col]<sup>th</sup></code> cell that the knight visited. The moves are **0-indexed**.
+
+Return `true` _if_ `grid` _represents a valid configuration of the knight's movements or_ `false` _otherwise_.
+
+**Note** that a valid knight move consists of moving two squares vertically and one square horizontally, or two squares horizontally and one square vertically. The figure below illustrates all the possible eight moves of a knight from some cell.
+
+![](https://assets.leetcode.com/uploads/2018/10/12/knight.png)
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/12/28/yetgriddrawio-5.png)
+
+**Input:** grid = [[0,11,16,5,20],[17,4,19,10,15],[12,1,8,21,6],[3,18,23,14,9],[24,13,2,7,22]]
+
+**Output:** true
+
+**Explanation:** The above diagram represents the grid. It can be shown that it is a valid configuration.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/12/28/yetgriddrawio-6.png)
+
+**Input:** grid = [[0,3,6],[5,8,1],[2,7,4]]
+
+**Output:** false
+
+**Explanation:** The above diagram represents the grid. The 8<sup>th</sup> move of the knight is not valid considering its position after the 7<sup>th</sup> move.
+
+**Constraints:**
+
+*   `n == grid.length == grid[i].length`
+*   `3 <= n <= 7`
+*   `0 <= grid[row][col] < n * n`
+*   All integers in `grid` are **unique**.

src/main/java/g2501_2600/s2597_the_number_of_beautiful_subsets/Solution.java

@@ -0,0 +1,56 @@
+package g2501_2600.s2597_the_number_of_beautiful_subsets;
+
+// #Medium #Array #Dynamic_Programming #Backtracking
+// #2023_08_29_Time_4_ms_(100.00%)_Space_43.8_MB_(67.74%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public int beautifulSubsets(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int n : nums) {
+            map.put(n, map.getOrDefault(n, 0) + 1);
+        }
+        int res = 1;
+        for (int key : map.keySet()) {
+            if (!map.containsKey(key - k)) {
+                if (!map.containsKey(key + k)) {
+                    res *= 1 << map.get(key);
+                } else {
+                    List<Integer> freq = new ArrayList<>();
+                    int localKey = key;
+                    while (map.containsKey(localKey)) {
+                        freq.add(map.get(localKey));
+                        localKey += k;
+                    }
+                    res *= helper(freq);
+                }
+            }
+        }
+        return res - 1;
+    }
+
+    private int helper(List<Integer> freq) {
+        int n = freq.size();
+        if (n == 1) {
+            return 1 << freq.get(0);
+        }
+        int[] dp = new int[n];
+        dp[0] = (1 << freq.get(0)) - 1;
+        dp[1] = (1 << freq.get(1)) - 1;
+        if (n == 2) {
+            return dp[0] + dp[1] + 1;
+        }
+        for (int i = 2; i < n; i++) {
+            if (i > 2) {
+                dp[i - 2] += dp[i - 3];
+            }
+
+            dp[i] = (dp[i - 2] + 1) * ((1 << freq.get(i)) - 1);
+        }
+        return dp[n - 1] + dp[n - 2] + dp[n - 3] + 1;
+    }
+}

src/main/java/g2501_2600/s2597_the_number_of_beautiful_subsets/readme.md

@@ -0,0 +1,40 @@
+2597\. The Number of Beautiful Subsets
+
+Medium
+
+You are given an array `nums` of positive integers and a **positive** integer `k`.
+
+A subset of `nums` is **beautiful** if it does not contain two integers with an absolute difference equal to `k`.
+
+Return _the number of **non-empty beautiful** subsets of the array_ `nums`.
+
+A **subset** of `nums` is an array that can be obtained by deleting some (possibly none) elements from `nums`. Two subsets are different if and only if the chosen indices to delete are different.
+
+**Example 1:**
+
+**Input:** nums = [2,4,6], k = 2
+
+**Output:** 4
+
+**Explanation:**
+
+The beautiful subsets of the array nums are: [2], [4], [6], [2, 6].
+
+It can be proved that there are only 4 beautiful subsets in the array [2,4,6].
+
+**Example 2:**
+
+**Input:** nums = [1], k = 1
+
+**Output:** 1
+
+**Explanation:**
+
+The beautiful subset of the array nums is [1].
+
+It can be proved that there is only 1 beautiful subset in the array [1].
+
+**Constraints:**
+
+*   `1 <= nums.length <= 20`
+*   `1 <= nums[i], k <= 1000`

src/main/java/g2501_2600/s2598_smallest_missing_non_negative_integer_after_operations/Solution.java

@@ -0,0 +1,37 @@
+package g2501_2600.s2598_smallest_missing_non_negative_integer_after_operations;
+
+// #Medium #Array #Hash_Table #Math #Greedy #2023_08_29_Time_4_ms_(99.19%)_Space_58.2_MB_(83.87%)
+
+public class Solution {
+    public int findSmallestInteger(int[] nums, int value) {
+        int n = nums.length;
+        if (value == 1) {
+            return n;
+        }
+        int[] a = new int[value];
+        for (int i = 0; i < n; i++) {
+            int k = nums[i] % value;
+            if (k < 0) {
+                k = (value + k) % value;
+            }
+            a[k]++;
+        }
+        int[] minsResult = mins(a);
+        int min = minsResult[0];
+        int minIndex = minsResult[1];
+        return min * value + minIndex;
+    }
+
+    private int[] mins(int[] a) {
+        int n = a.length;
+        int min = 100001;
+        int minIndex = -1;
+        for (int i = 0; i < n; i++) {
+            if (a[i] < min) {
+                min = a[i];
+                minIndex = i;
+            }
+        }
+        return new int[] {min, minIndex};
+    }
+}

src/main/java/g2501_2600/s2598_smallest_missing_non_negative_integer_after_operations/readme.md

@@ -0,0 +1,52 @@
+2598\. Smallest Missing Non-negative Integer After Operations
+
+Medium
+
+You are given a **0-indexed** integer array `nums` and an integer `value`.
+
+In one operation, you can add or subtract `value` from any element of `nums`.
+
+*   For example, if `nums = [1,2,3]` and `value = 2`, you can choose to subtract `value` from `nums[0]` to make `nums = [-1,2,3]`.
+
+The MEX (minimum excluded) of an array is the smallest missing **non-negative** integer in it.
+
+*   For example, the MEX of `[-1,2,3]` is `0` while the MEX of `[1,0,3]` is `2`.
+
+Return _the maximum MEX of_ `nums` _after applying the mentioned operation **any number of times**_.
+
+**Example 1:**
+
+**Input:** nums = [1,-10,7,13,6,8], value = 5
+
+**Output:** 4
+
+**Explanation:**
+
+One can achieve this result by applying the following operations:
+
+- Add value to nums[1] twice to make nums = [1,**<ins>0</ins>**,7,13,6,8]
+
+- Subtract value from nums[2] once to make nums = [1,0,**<ins>2</ins>**,13,6,8]
+
+- Subtract value from nums[3] twice to make nums = [1,0,2,**<ins>3</ins>**,6,8]
+
+The MEX of nums is 4. It can be shown that 4 is the maximum MEX we can achieve.
+
+**Example 2:**
+
+**Input:** nums = [1,-10,7,13,6,8], value = 7
+
+**Output:** 2
+
+**Explanation:**
+
+One can achieve this result by applying the following operation:
+
+- subtract value from nums[2] once to make nums = [1,-10,<ins>**0**</ins>,13,6,8]
+
+The MEX of nums is 2. It can be shown that 2 is the maximum MEX we can achieve.
+
+**Constraints:**
+
+*   <code>1 <= nums.length, value <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2600_k_items_with_the_maximum_sum/Solution.java

@@ -0,0 +1,16 @@
+package g2501_2600.s2600_k_items_with_the_maximum_sum;
+
+// #Easy #Math #Greedy #2023_08_29_Time_1_ms_(100.00%)_Space_40.3_MB_(19.10%)
+
+public class Solution {
+    public int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {
+        if (k <= numOnes) {
+            return k;
+        }
+        if (k <= numOnes + numZeros) {
+            return numOnes;
+        }
+        int remainingSum = k - (numOnes + numZeros);
+        return numOnes - remainingSum;
+    }
+}

src/main/java/g2501_2600/s2600_k_items_with_the_maximum_sum/readme.md

@@ -0,0 +1,36 @@
+2600\. K Items With the Maximum Sum
+
+Easy
+
+There is a bag that consists of items, each item has a number `1`, `0`, or `-1` written on it.
+
+You are given four **non-negative** integers `numOnes`, `numZeros`, `numNegOnes`, and `k`.
+
+The bag initially contains:
+
+*   `numOnes` items with `1`s written on them.
+*   `numZeroes` items with `0`s written on them.
+*   `numNegOnes` items with `-1`s written on them.
+
+We want to pick exactly `k` items among the available items. Return _the **maximum** possible sum of numbers written on the items_.
+
+**Example 1:**
+
+**Input:** numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2
+
+**Output:** 2
+
+**Explanation:** We have a bag of items with numbers written on them {1, 1, 1, 0, 0}. We take 2 items with 1 written on them and get a sum in a total of 2. It can be proven that 2 is the maximum possible sum.
+
+**Example 2:**
+
+**Input:** numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4
+
+**Output:** 3
+
+**Explanation:** We have a bag of items with numbers written on them {1, 1, 1, 0, 0}. We take 3 items with 1 written on them, and 1 item with 0 written on it, and get a sum in a total of 3. It can be proven that 3 is the maximum possible sum.
+
+**Constraints:**
+
+*   `0 <= numOnes, numZeros, numNegOnes <= 50`
+*   `0 <= k <= numOnes + numZeros + numNegOnes`

src/main/java/g2601_2700/s2601_prime_subtraction_operation/Solution.java

@@ -0,0 +1,50 @@
+package g2601_2700.s2601_prime_subtraction_operation;
+
+// #Medium #Array #Math #Greedy #Binary_Search #Number_Theory
+// #2023_08_29_Time_2_ms_(100.00%)_Space_43.9_MB_(39.47%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private int[] primesUntil(int n) {
+        if (n < 2) {
+            return new int[0];
+        }
+        int[] primes = new int[200];
+        boolean[] composite = new boolean[n + 1];
+        primes[0] = 2;
+        int added = 1;
+        int i = 3;
+        while (i <= n) {
+            if (composite[i]) {
+                i += 2;
+                continue;
+            }
+            primes[added++] = i;
+            int j = i * i;
+            while (j <= n) {
+                composite[j] = true;
+                j += i;
+            }
+            i += 2;
+        }
+        return Arrays.copyOf(primes, added);
+    }
+
+    public boolean primeSubOperation(int[] nums) {
+        int max = 0;
+        for (int n : nums) {
+            max = Math.max(max, n);
+        }
+        int[] primes = primesUntil(max);
+        int prev = 0;
+        for (int n : nums) {
+            int pos = Arrays.binarySearch(primes, n - prev - 1);
+            if (pos == -1 && n <= prev) {
+                return false;
+            }
+            prev = n - (pos == -1 ? 0 : (pos < 0 ? primes[-pos - 2] : primes[pos]));
+        }
+        return true;
+    }
+}