Added tasks 2732-2736

Author: ThanhNIT

src/main/kotlin/g2701_2800/s2732_find_a_good_subset_of_the_matrix/Solution.kt

@@ -0,0 +1,37 @@
+package g2701_2800.s2732_find_a_good_subset_of_the_matrix
+
+// #Hard #Array #Greedy #Matrix #Bit_Manipulation
+// #2023_08_05_Time_760_ms_(98.36%)_Space_71.4_MB_(78.69%)
+
+class Solution {
+    fun goodSubsetofBinaryMatrix(grid: Array<IntArray>): List<Int> {
+        val m = grid.size
+        val n = grid[0].size
+        if (m == 1 && grid[0].sum() == 0) {
+            return listOf(0)
+        }
+        val pos = mutableMapOf<Int, Int>()
+        for (i in grid.indices) {
+            for (mask in 0 until (1 shl n)) {
+                var valid = true
+                for (j in 0 until n) {
+                    if ((mask and (1 shl j)) != 0 && grid[i][j] + 1 > 1) {
+                        valid = false
+                        break
+                    }
+                }
+                if (valid && mask in pos) {
+                    return listOf(pos[mask]!!, i)
+                }
+            }
+            var curr = 0
+            for (j in 0 until n) {
+                if (grid[i][j] == 1) {
+                    curr = curr or (1 shl j)
+                }
+            }
+            pos[curr] = i
+        }
+        return emptyList()
+    }
+}

src/main/kotlin/g2701_2800/s2732_find_a_good_subset_of_the_matrix/readme.md

@@ -0,0 +1,52 @@
+2732\. Find a Good Subset of the Matrix
+
+Hard
+
+You are given a **0-indexed** `m x n` binary matrix `grid`.
+
+Let us call a **non-empty** subset of rows **good** if the sum of each column of the subset is at most half of the length of the subset.
+
+More formally, if the length of the chosen subset of rows is `k`, then the sum of each column should be at most `floor(k / 2)`.
+
+Return _an integer array that contains row indices of a good subset sorted in **ascending** order._
+
+If there are multiple good subsets, you can return any of them. If there are no good subsets, return an empty array.
+
+A **subset** of rows of the matrix `grid` is any matrix that can be obtained by deleting some (possibly none or all) rows from `grid`.
+
+**Example 1:**
+
+**Input:** grid = [[0,1,1,0],[0,0,0,1],[1,1,1,1]]
+
+**Output:** [0,1]
+
+**Explanation:** We can choose the 0<sup>th</sup> and 1<sup>st</sup> rows to create a good subset of rows. The length of the chosen subset is 2. 
+- The sum of the 0<sup>th</sup> column is 0 + 0 = 0, which is at most half of the length of the subset. 
+- The sum of the 1<sup>st</sup> column is 1 + 0 = 1, which is at most half of the length of the subset. 
+- The sum of the 2<sup>nd</sup> column is 1 + 0 = 1, which is at most half of the length of the subset. 
+- The sum of the 3<sup>rd</sup> column is 0 + 1 = 1, which is at most half of the length of the subset.
+
+**Example 2:**
+
+**Input:** grid = [[0]]
+
+**Output:** [0]
+
+**Explanation:** We can choose the 0<sup>th</sup> row to create a good subset of rows. The length of the chosen subset is 1. 
+- The sum of the 0<sup>th</sup> column is 0, which is at most half of the length of the subset.
+
+**Example 3:**
+
+**Input:** grid = [[1,1,1],[1,1,1]]
+
+**Output:** []
+
+**Explanation:** It is impossible to choose any subset of rows to create a good subset.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   <code>1 <= m <= 10<sup>4</sup></code>
+*   `1 <= n <= 5`
+*   `grid[i][j]` is either `0` or `1`.

src/main/kotlin/g2701_2800/s2733_neither_minimum_nor_maximum/Solution.kt

@@ -0,0 +1,18 @@
+package g2701_2800.s2733_neither_minimum_nor_maximum
+
+// #Easy #Array #Sorting #2023_08_05_Time_286_ms_(100.00%)_Space_44.2_MB_(92.79%)
+
+class Solution {
+    fun findNonMinOrMax(nums: IntArray): Int {
+        var mn = 999
+        var mx: Int = -1
+        nums.forEach {
+            mn = kotlin.math.min(it, mn)
+            mx = kotlin.math.max(it, mx)
+        }
+        nums.forEach {
+            if (it != mn && it != mx)return it
+        }
+        return -1
+    }
+}

src/main/kotlin/g2701_2800/s2733_neither_minimum_nor_maximum/readme.md

@@ -0,0 +1,37 @@
+2733\. Neither Minimum nor Maximum
+
+Easy
+
+Given an integer array `nums` containing **distinct** **positive** integers, find and return **any** number from the array that is neither the **minimum** nor the **maximum** value in the array, or **`-1`** if there is no such number.
+
+Return _the selected integer._
+
+**Example 1:**
+
+**Input:** nums = [3,2,1,4]
+
+**Output:** 2
+
+**Explanation:** In this example, the minimum value is 1 and the maximum value is 4. Therefore, either 2 or 3 can be valid answers.
+
+**Example 2:**
+
+**Input:** nums = [1,2]
+
+**Output:** -1
+
+**Explanation:** Since there is no number in nums that is neither the maximum nor the minimum, we cannot select a number that satisfies the given condition. Therefore, there is no answer.
+
+**Example 3:**
+
+**Input:** nums = [2,1,3]
+
+**Output:** 2
+
+**Explanation:** Since 2 is neither the maximum nor the minimum value in nums, it is the only valid answer.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 100`
+*   All values in `nums` are distinct

src/main/kotlin/g2701_2800/s2734_lexicographically_smallest_string_after_substring_operation/Solution.kt

@@ -0,0 +1,41 @@
+package g2701_2800.s2734_lexicographically_smallest_string_after_substring_operation
+
+// #Medium #String #Greedy #2023_08_05_Time_384_ms_(100.00%)_Space_48.4_MB_(95.56%)
+
+class Solution {
+    fun smallestString(s: String): String {
+        var resultArray = CharArray(s.length)
+        var found = false
+        var i = 0
+        while (i < s.length) {
+            var c = s[i]
+            if (c != 'a' && !found) {
+                found = true
+                while (i < s.length) {
+                    c = s[i]
+                    if (c != 'a') {
+                        c--
+                        resultArray[i] = c
+                    } else {
+                        i--
+                        break
+                    }
+                    i++
+                }
+            } else {
+                resultArray[i] = c
+            }
+            i++
+        }
+        if (!found) {
+            resultArray = CharArray(s.length)
+            i = 0
+            while (i < s.length - 1) {
+                resultArray[i] = 'a'
+                i++
+            }
+            resultArray[s.length - 1] = 'z'
+        }
+        return String(resultArray)
+    }
+}

src/main/kotlin/g2701_2800/s2734_lexicographically_smallest_string_after_substring_operation/readme.md

@@ -0,0 +1,42 @@
+2734\. Lexicographically Smallest String After Substring Operation
+
+Medium
+
+You are given a string `s` consisting of only lowercase English letters. In one operation, you can do the following:
+
+*   Select any non-empty substring of `s`, possibly the entire string, then replace each one of its characters with the previous character of the English alphabet. For example, 'b' is converted to 'a', and 'a' is converted to 'z'.
+
+Return _the **lexicographically smallest** string you can obtain after performing the above operation **exactly once**._
+
+A **substring** is a contiguous sequence of characters in a string.
+
+A string `x` is **lexicographically smaller** than a string `y` of the same length if `x[i]` comes before `y[i]` in alphabetic order for the first position `i` such that `x[i] != y[i]`.
+
+**Example 1:**
+
+**Input:** s = "cbabc"
+
+**Output:** "baabc"
+
+**Explanation:** We apply the operation on the substring starting at index 0, and ending at index 1 inclusive. It can be proven that the resulting string is the lexicographically smallest.
+
+**Example 2:**
+
+**Input:** s = "acbbc"
+
+**Output:** "abaab"
+
+**Explanation:** We apply the operation on the substring starting at index 1, and ending at index 4 inclusive. It can be proven that the resulting string is the lexicographically smallest.
+
+**Example 3:**
+
+**Input:** s = "leetcode"
+
+**Output:** "kddsbncd"
+
+**Explanation:** We apply the operation on the entire string. It can be proven that the resulting string is the lexicographically smallest.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 3 * 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters

src/main/kotlin/g2701_2800/s2735_collecting_chocolates/Solution.kt

@@ -0,0 +1,25 @@
+package g2701_2800.s2735_collecting_chocolates
+
+// #Medium #Array #Enumeration #2023_08_05_Time_237_ms_(100.00%)_Space_39.6_MB_(95.45%)
+
+class Solution {
+    fun minCost(nums: IntArray, x: Int): Long {
+        val n = nums.size
+        val dp = IntArray(n)
+        var res: Long = 0
+        for (i in 0 until n) {
+            dp[i] = nums[i]
+            res += nums[i].toLong()
+        }
+        for (i in 1 until n) {
+            var sum: Long = i.toLong() * x.toLong()
+            for (j in 0 until n) {
+                val currIndex: Int = if (j + i >= n) j + i - n else j + i
+                dp[j] = dp[j].coerceAtMost(nums[currIndex])
+                sum += dp[j].toLong()
+            }
+            res = res.coerceAtMost(sum)
+        }
+        return res
+    }
+}

src/main/kotlin/g2701_2800/s2735_collecting_chocolates/readme.md

@@ -0,0 +1,39 @@
+2735\. Collecting Chocolates
+
+Medium
+
+You are given a **0-indexed** integer array `nums` of size `n` representing the cost of collecting different chocolates. The cost of collecting the chocolate at the index `i` is `nums[i]`. Each chocolate is of a different type, and initially, the chocolate at the index `i` is of <code>i<sup>th</sup></code> type.
+
+In one operation, you can do the following with an incurred **cost** of `x`:
+
+*   Simultaneously change the chocolate of <code>i<sup>th</sup></code> type to <code>((i + 1) mod n)<sup>th</sup></code> type for all chocolates.
+
+Return _the minimum cost to collect chocolates of all types, given that you can perform as many operations as you would like._
+
+**Example 1:**
+
+**Input:** nums = [20,1,15], x = 5
+
+**Output:** 13
+
+**Explanation:** Initially, the chocolate types are [0,1,2]. We will buy the 1<sup>st</sup> type of chocolate at a cost of 1. 
+
+Now, we will perform the operation at a cost of 5, and the types of chocolates will become [1,2,0]. We will buy the 2<sup>nd</sup> type of chocolate at a cost of 1.
+
+Now, we will again perform the operation at a cost of 5, and the chocolate types will become [2,0,1]. We will buy the 0<sup>th</sup> type of chocolate at a cost of 1. 
+
+Thus, the total cost will become (1 + 5 + 1 + 5 + 1) = 13. We can prove that this is optimal.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3], x = 4
+
+**Output:** 6
+
+**Explanation:** We will collect all three types of chocolates at their own price without performing any operations. Therefore, the total cost is 1 + 2 + 3 = 6.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   <code>1 <= x <= 10<sup>9</sup></code>

src/main/kotlin/g2701_2800/s2736_maximum_sum_queries/Solution.kt

@@ -0,0 +1,54 @@
+package g2701_2800.s2736_maximum_sum_queries
+
+// #Hard #Array #Sorting #Binary_Search #Stack #Monotonic_Stack #Segment_Tree #Binary_Indexed_Tree
+// #2023_08_05_Time_1043_ms_(100.00%)_Space_126.2_MB_(9.09%)
+
+import java.util.TreeMap
+
+class Solution {
+    private fun update(map: TreeMap<Int, Int>, num: Int, sum: Int) {
+        var entry = map.floorEntry(num)
+        while (entry != null && entry.value <= sum) {
+            map.remove(entry.key)
+            val x = entry.key
+            entry = map.floorEntry(x)
+        }
+        entry = map.ceilingEntry(num)
+        if (entry == null || entry.value < sum) map.put(num, sum)
+    }
+
+    private fun queryVal(map: TreeMap<Int, Int>, num: Int): Int {
+        val (_, value) = map.ceilingEntry(num) ?: return -1
+        return value
+    }
+
+    fun maximumSumQueries(nums1: IntArray, nums2: IntArray, queries: Array<IntArray>): IntArray {
+        val n = nums1.size
+        val m = queries.size
+        val v: MutableList<IntArray> = ArrayList()
+        for (i in 0 until n) {
+            v.add(intArrayOf(nums1[i], nums2[i]))
+        }
+        v.sortWith(
+            Comparator { a: IntArray, b: IntArray ->
+                a[0] - b[0]
+            }
+        )
+        val ind: MutableList<Int> = ArrayList()
+        for (i in 0 until m) ind.add(i)
+        ind.sortWith(Comparator { a: Int?, b: Int? -> queries[b!!][0] - queries[a!!][0] })
+        val values = TreeMap<Int, Int>()
+        var j = n - 1
+        val ans = IntArray(m)
+        for (i in ind) {
+            val a = queries[i][0]
+            val b = queries[i][1]
+            while (j >= 0 && v[j][0] >= a) {
+                update(values, v[j][1], v[j][0] + v[j][1])
+                j--
+            }
+            ans[i] = queryVal(values, b)
+        }
+        return ans
+    }
+}