Added tasks 2790-2800

Author: javadev

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

@@ -0,0 +1,29 @@
+package g2701_2800.s2790_maximum_number_of_groups_with_increasing_length
+
+// #Hard #Array #Math #Sorting #Greedy #Binary_Search
+// #2023_08_06_Time_545_ms_(100.00%)_Space_62.7_MB_(92.86%)
+
+import kotlin.math.min
+
+class Solution {
+    fun maxIncreasingGroups(usageLimits: List<Int>): Int {
+        val n: Int = usageLimits.size
+        var total: Long = 0
+        var k: Long = 0
+        val count = IntArray(n + 1)
+        count.fill(0)
+        for (a in usageLimits) {
+            val localA = min(a.toDouble(), n.toDouble()).toInt()
+            count[localA]++
+        }
+        for (i in 0..n) {
+            for (j in 0 until count[i]) {
+                total += i.toLong()
+                if (total >= (k + 1) * (k + 2) / 2) {
+                    k++
+                }
+            }
+        }
+        return k.toInt()
+    }
+}

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

@@ -0,0 +1,77 @@
+2790\. Maximum Number of Groups With Increasing Length
+
+Hard
+
+You are given a **0-indexed** array `usageLimits` of length `n`.
+
+Your task is to create **groups** using numbers from `0` to `n - 1`, ensuring that each number, `i`, is used no more than `usageLimits[i]` times in total **across all groups**. You must also satisfy the following conditions:
+
+*   Each group must consist of **distinct** numbers, meaning that no duplicate numbers are allowed within a single group.
+*   Each group (except the first one) must have a length **strictly greater** than the previous group.
+
+Return _an integer denoting the **maximum** number of groups you can create while satisfying these conditions._
+
+**Example 1:**
+
+**Input:** `usageLimits` = [1,2,5]
+
+**Output:** 3
+
+**Explanation:**
+
+In this example, we can use 0 at most once, 1 at most twice, and 2 at most five times.
+
+One way of creating the maximum number of groups while satisfying the conditions is:
+
+Group 1 contains the number [2].
+
+Group 2 contains the numbers [1,2].
+
+Group 3 contains the numbers [0,1,2].
+
+It can be shown that the maximum number of groups is 3.
+
+So, the output is 3. 
+
+**Example 2:**
+
+**Input:** `usageLimits` = [2,1,2]
+
+**Output:** 2
+
+**Explanation:**
+
+In this example, we can use 0 at most twice, 1 at most once, and 2 at most twice.
+
+One way of creating the maximum number of groups while satisfying the conditions is:
+
+Group 1 contains the number [0].
+
+Group 2 contains the numbers [1,2].
+
+It can be shown that the maximum number of groups is 2.
+
+So, the output is 2. 
+
+**Example 3:**
+
+**Input:** `usageLimits` = [1,1]
+
+**Output:** 1
+
+**Explanation:**
+
+In this example, we can use both 0 and 1 at most once.
+
+One way of creating the maximum number of groups while satisfying the conditions is:
+
+Group 1 contains the number [0].
+
+It can be shown that the maximum number of groups is 1.
+
+So, the output is 1. 
+
+**Constraints:**
+
+*   <code>1 <= usageLimits.length <= 10<sup>5</sup></code>
+*   <code>1 <= usageLimits[i] <= 10<sup>9</sup></code>

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

@@ -0,0 +1,43 @@
+package g2701_2800.s2791_count_paths_that_can_form_a_palindrome_in_a_tree
+
+// #Hard #Dynamic_Programming #Tree #Bit_Manipulation #Bitmask #Depth_First_Search
+// #2023_08_06_Time_683_ms_(100.00%)_Space_54_MB_(100.00%)
+
+class Solution {
+    private fun getMap(parent: List<Int>, s: String, dp: IntArray, idx: Int): Int {
+        if (dp[idx] < 0) {
+            dp[idx] = 0
+            dp[idx] = getMap(parent, s, dp, parent[idx]) xor (1 shl s[idx].code - 'a'.code)
+        }
+        return dp[idx]
+    }
+
+    fun countPalindromePaths(parent: List<Int>, s: String): Long {
+        val n: Int = parent.size
+        val dp = IntArray(n)
+        var ans: Long = 0
+        val mapCount: MutableMap<Int, Int> = HashMap()
+        dp.fill(-1)
+        dp[0] = 0
+        for (i in 0 until n) {
+            val currMap = getMap(parent, s, dp, i)
+            // if map are same, two points can form a path;
+            val evenCount = mapCount[currMap] ?: 0
+            mapCount.put(currMap, evenCount + 1)
+        }
+        for (key in mapCount.keys) {
+            val value = mapCount[key]!!
+            ans += value.toLong() * (value - 1) shr 1
+            for (i in 0..25) {
+                val base = 1 shl i
+                // if this map at i is 1, which means odd this bit
+                if (key and base > 0 && mapCount.containsKey(key xor base)) {
+                    // key ^ base is the map that is 0 at bit i, odd pairs with even,
+                    // can pair and no duplicate
+                    ans += value.toLong() * mapCount[key xor base]!!
+                }
+            }
+        }
+        return ans
+    }
+}

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

@@ -0,0 +1,48 @@
+2791\. Count Paths That Can Form a Palindrome in a Tree
+
+Hard
+
+You are given a **tree** (i.e. a connected, undirected graph that has no cycles) **rooted** at node `0` consisting of `n` nodes numbered from `0` to `n - 1`. The tree is represented by a **0-indexed** array `parent` of size `n`, where `parent[i]` is the parent of node `i`. Since node `0` is the root, `parent[0] == -1`.
+
+You are also given a string `s` of length `n`, where `s[i]` is the character assigned to the edge between `i` and `parent[i]`. `s[0]` can be ignored.
+
+Return _the number of pairs of nodes_ `(u, v)` _such that_ `u < v` _and the characters assigned to edges on the path from_ `u` _to_ `v` _can be **rearranged** to form a **palindrome**_.
+
+A string is a **palindrome** when it reads the same backwards as forwards.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/07/15/treedrawio-8drawio.png)
+
+**Input:** parent = [-1,0,0,1,1,2], s = "acaabc"
+
+**Output:** 8
+
+**Explanation:**
+
+The valid pairs are:
+
+- All the pairs (0,1), (0,2), (1,3), (1,4) and (2,5) result in one character which is always a palindrome.
+
+- The pair (2,3) result in the string "aca" which is a palindrome.
+
+- The pair (1,5) result in the string "cac" which is a palindrome.
+
+- The pair (3,5) result in the string "acac" which can be rearranged into the palindrome "acca". 
+
+**Example 2:**
+
+**Input:** parent = [-1,0,0,0,0], s = "aaaaa"
+
+**Output:** 10
+
+**Explanation:** Any pair of nodes (u,v) where u < v is valid. 
+
+**Constraints:**
+
+*   `n == parent.length == s.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `0 <= parent[i] <= n - 1` for all `i >= 1`
+*   `parent[0] == -1`
+*   `parent` represents a valid tree.
+*   `s` consists of only lowercase English letters.

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

@@ -0,0 +1,15 @@
+package g2701_2800.s2798_number_of_employees_who_met_the_target
+
+// #Easy #Array #Enumeration #2023_08_06_Time_153_ms_(92.50%)_Space_35_MB_(71.25%)
+
+class Solution {
+    fun numberOfEmployeesWhoMetTarget(hours: IntArray, target: Int): Int {
+        var count = 0
+        for (i in hours) {
+            if (i >= target) {
+                count++
+            }
+        }
+        return count
+    }
+}

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

@@ -0,0 +1,50 @@
+2798\. Number of Employees Who Met the Target
+
+Easy
+
+There are `n` employees in a company, numbered from `0` to `n - 1`. Each employee `i` has worked for `hours[i]` hours in the company.
+
+The company requires each employee to work for **at least** `target` hours.
+
+You are given a **0-indexed** array of non-negative integers `hours` of length `n` and a non-negative integer `target`.
+
+Return _the integer denoting the number of employees who worked at least_ `target` _hours_.
+
+**Example 1:**
+
+**Input:** hours = [0,1,2,3,4], target = 2
+
+**Output:** 3
+
+**Explanation:**
+
+The company wants each employee to work for at least 2 hours.
+
+- Employee 0 worked for 0 hours and didn't meet the target.
+
+- Employee 1 worked for 1 hours and didn't meet the target.
+
+- Employee 2 worked for 2 hours and met the target.
+
+- Employee 3 worked for 3 hours and met the target.
+
+- Employee 4 worked for 4 hours and met the target.
+
+There are 3 employees who met the target. 
+
+**Example 2:**
+
+**Input:** hours = [5,1,4,2,2], target = 6
+
+**Output:** 0
+
+**Explanation:**
+
+The company wants each employee to work for at least 6 hours.
+
+There are 0 employees who met the target. 
+
+**Constraints:**
+
+*   `1 <= n == hours.length <= 50`
+*   <code>0 <= hours[i], target <= 10<sup>5</sup></code>

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

@@ -0,0 +1,40 @@
+package g2701_2800.s2799_count_complete_subarrays_in_an_array
+
+// #Medium #Array #Hash_Table #Sliding_Window
+// #2023_08_06_Time_206_ms_(96.97%)_Space_42.2_MB_(72.73%)
+
+class Solution {
+    fun countCompleteSubarrays(nums: IntArray): Int {
+        val n = nums.size
+        var map = IntArray(2001)
+        var distinct = 0
+        var last = 0
+        for (i in 0 until n) {
+            map[nums[i]]++
+            if (map[nums[i]] == 1) {
+                distinct++
+                last = i
+            }
+        }
+        map = IntArray(2001)
+        for (i in 0..last) map[nums[i]]++
+        var ans = 0
+        for (i in 0 until n) {
+            ans += n - last
+            map[nums[i]]--
+            if (map[nums[i]] == 0) {
+                var possLast = 0
+                var j = last + 1
+                while (j < n && map[nums[i]] == 0) {
+                    map[nums[j]]++
+                    possLast = j
+                    ++j
+                }
+                last = if (map[nums[i]] > 0) {
+                    possLast
+                } else break
+            }
+        }
+        return ans
+    }
+}

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

@@ -0,0 +1,34 @@
+2799\. Count Complete Subarrays in an Array
+
+Medium
+
+You are given an array `nums` consisting of **positive** integers.
+
+We call a subarray of an array **complete** if the following condition is satisfied:
+
+*   The number of **distinct** elements in the subarray is equal to the number of distinct elements in the whole array.
+
+Return _the number of **complete** subarrays_.
+
+A **subarray** is a contiguous non-empty part of an array.
+
+**Example 1:**
+
+**Input:** nums = [1,3,1,2,2]
+
+**Output:** 4
+
+**Explanation:** The complete subarrays are the following: [1,3,1,2], [1,3,1,2,2], [3,1,2] and [3,1,2,2]. 
+
+**Example 2:**
+
+**Input:** nums = [5,5,5,5]
+
+**Output:** 10
+
+**Explanation:** The array consists only of the integer 5, so any subarray is complete. The number of subarrays that we can choose is 10. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `1 <= nums[i] <= 2000`