Added tasks 2930-2944

Author: javadev

README.md

@@ -40,25 +40,22 @@ Return `true` if you can finish all courses. Otherwise, return `false`.
 ```kotlin
 class Solution {
     fun canFinish(numCourses: Int, prerequisites: Array<IntArray>): Boolean {
-        val adj: Array<ArrayList<Int>?> = arrayOfNulls<ArrayList<Int>>(numCourses)
-        for (i in 0 until numCourses) {
-            adj[i] = ArrayList()
-        }
+        val adj: Array<ArrayList<Int>> = Array(numCourses) { ArrayList() }
         for (pre in prerequisites) {
-            adj[pre[1]]?.add(pre[0])
+            adj[pre[1]].add(pre[0])
         }
         val colors = IntArray(numCourses)
         for (i in 0 until numCourses) {
-            if (colors[i] == WHITE && !adj[i]?.isEmpty()!! && hasCycle(adj, i, colors)) {
+            if (colors[i] == WHITE && adj[i].isNotEmpty() && hasCycle(adj, i, colors)) {
                 return false
             }
         }
         return true
     }
 
-    private fun hasCycle(adj: Array<ArrayList<Int>?>, node: Int, colors: IntArray): Boolean {
+    private fun hasCycle(adj: Array<ArrayList<Int>>, node: Int, colors: IntArray): Boolean {
         colors[node] = GRAY
-        for (nei in adj[node]!!) {
+        for (nei in adj[node]) {
             if (colors[nei] == GRAY) {
                 return true
             }

src/main/kotlin/g0201_0300/s0207_course_schedule/readme.md

@@ -52,66 +52,77 @@ A **sub-multiset** is an **unordered** collection of elements of the array in wh
 ## Solution
 
 ```kotlin
+import kotlin.math.min
+
+@Suppress("NAME_SHADOWING")
 class Solution {
-    private var map: HashMap<Int, Int>? = null
-    private lateinit var dp: Array<IntArray>
+    private val mod = 1000000007
+    private val intMap = IntMap()
 
-    private fun solve(al: List<Int>, l: Int, r: Int, index: Int, sum: Int): Int {
-        if (sum > r) {
+    fun countSubMultisets(nums: List<Int>, l: Int, r: Int): Int {
+        intMap.clear()
+        intMap.add(0)
+        var total = 0
+        for (num in nums) {
+            intMap.add(num)
+            total += num
+        }
+        if (total < l) {
             return 0
         }
-        var ans: Long = 0
-        if (index >= al.size) {
-            return ans.toInt()
+        val r = min(r, total)
+        val cnt = IntArray(r + 1)
+        cnt[0] = intMap.map[0]
+        var sum = 0
+        for (i in 1 until intMap.size) {
+            val value = intMap.vals[i]
+            val count = intMap.map[value]
+            if (count > 0) {
+                sum = min(r, sum + value * count)
+                update(cnt, value, count, sum)
+            }
         }
-        if (dp[index][sum] != -1) {
-            return dp[index][sum]
+        var res = 0
+        for (i in l..r) {
+            res = (res + cnt[i]) % mod
         }
-        val cur = al[index]
-        val count = map!![cur]!!
-        for (i in 0..count) {
-            val curSum = sum + cur * i
-            if (curSum > r) {
-                break
+        return res
+    }
+
+    private fun update(cnt: IntArray, n: Int, count: Int, sum: Int) {
+        if (count == 1) {
+            for (i in sum downTo n) {
+                cnt[i] = (cnt[i] + cnt[i - n]) % mod
+            }
+        } else {
+            for (i in n..sum) {
+                cnt[i] = (cnt[i] + cnt[i - n]) % mod
             }
-            ans += solve(al, l, r, index + 1, curSum)
-            if (i != 0 && curSum >= l) {
-                ans += 1
+            val max = (count + 1) * n
+            for (i in sum downTo max) {
+                cnt[i] = (cnt[i] - cnt[i - max] + mod) % mod
             }
-            ans %= MOD
         }
-        dp[index][sum] = ans.toInt()
-        return ans.toInt()
     }
 
-    fun countSubMultisets(nums: List<Int>, l: Int, r: Int): Int {
-        map = HashMap()
-        val al: MutableList<Int> = ArrayList()
-        for (cur in nums) {
-            val count = map!!.getOrDefault(cur, 0) + 1
-            map!![cur] = count
-            if (count == 1) {
-                al.add(cur)
+    private class IntMap {
+        private val max = 20001
+        val map = IntArray(max)
+        val vals = IntArray(max)
+        var size = 0
+
+        fun add(v: Int) {
+            if (map[v]++ == 0) {
+                vals[size++] = v
             }
         }
-        val n = al.size
-        dp = Array(n) { IntArray(r + 1) }
-        for (i in dp.indices) {
-            for (j in dp[0].indices) {
-                dp[i][j] = -1
+
+        fun clear() {
+            for (i in 0 until size) {
+                map[vals[i]] = 0
             }
+            size = 0
         }
-        al.sort()
-        var ans = solve(al, l, r, 0, 0)
-        if (l == 0) {
-            ans += 1
-        }
-        ans %= MOD
-        return ans
-    }
-
-    companion object {
-        private const val MOD = 1e9.toInt() + 7
     }
 }
 ```

src/main/kotlin/g2901_3000/s2902_count_of_sub_multisets_with_bounded_sum/readme.md

@@ -61,22 +61,19 @@ It can be shown that the maximum points we can get after collecting coins from a
 import kotlin.math.max
 
 class Solution {
-    private lateinit var adjList: Array<MutableList<Int>?>
+    private lateinit var adjList: Array<MutableList<Int>>
     private lateinit var coins: IntArray
     private var k = 0
     private lateinit var dp: Array<IntArray>
 
     private fun init(edges: Array<IntArray>, coins: IntArray, k: Int) {
         val n = coins.size
-        adjList = arrayOfNulls(n)
-        for (v in 0 until n) {
-            adjList[v] = ArrayList()
-        }
+        adjList = Array(n) { ArrayList() }
         for (edge in edges) {
             val u = edge[0]
             val v = edge[1]
-            adjList[u]?.add(v)
-            adjList[v]?.add(u)
+            adjList[u].add(v)
+            adjList[v].add(u)
         }
         this.coins = coins
         this.k = k
@@ -96,7 +93,7 @@ class Solution {
             val coinsV = coins[v] / (1 shl numOfWay2Parents)
             var s0 = coinsV - k
             var s1 = coinsV / 2
-            for (child in adjList[v]!!) {
+            for (child in adjList[v]) {
                 if (child != p) {
                     s0 += rec(child, v, numOfWay2Parents)
                     s1 += rec(child, v, numOfWay2Parents + 1)

src/main/kotlin/g2901_3000/s2920_maximum_points_after_collecting_coins_from_all_nodes/readme.md

@@ -0,0 +1,79 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 2930\. Number of Strings Which Can Be Rearranged to Contain Substring
+
+Medium
+
+You are given an integer `n`.
+
+A string `s` is called **good** if it contains only lowercase English characters **and** it is possible to rearrange the characters of `s` such that the new string contains `"leet"` as a **substring**.
+
+For example:
+
+*   The string `"lteer"` is good because we can rearrange it to form `"leetr"` .
+*   `"letl"` is not good because we cannot rearrange it to contain `"leet"` as a substring.
+
+Return _the **total** number of good strings of length_ `n`.
+
+Since the answer may be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+A **substring** is a contiguous sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** n = 4
+
+**Output:** 12
+
+**Explanation:** The 12 strings which can be rearranged to have "leet" as a substring are: "eelt", "eetl", "elet", "elte", "etel", "etle", "leet", "lete", "ltee", "teel", "tele", and "tlee".
+
+**Example 2:**
+
+**Input:** n = 10
+
+**Output:** 83943898
+
+**Explanation:** The number of strings with length 10 which can be rearranged to have "leet" as a substring is 526083947580. Hence the answer is 526083947580 % (10<sup>9</sup> + 7) = 83943898.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+
+## Solution
+
+```kotlin
+@Suppress("NAME_SHADOWING")
+class Solution {
+    private fun pow(x: Long, n: Long, mod: Long): Long {
+        var n = n
+        var result: Long = 1
+        var p = x % mod
+        while (n != 0L) {
+            if ((n and 1L) != 0L) {
+                result = (result * p) % mod
+            }
+            p = (p * p) % mod
+            n = n shr 1
+        }
+        return result
+    }
+
+    fun stringCount(n: Int): Int {
+        val mod = 1e9.toInt() + 7L
+        return (
+            (
+                (
+                    pow(26, n.toLong(), mod) -
+                        (n + 75) * pow(25, n - 1L, mod) +
+                        (2 * n + 72) * pow(24, n - 1L, mod) -
+                        (n + 23) * pow(23, n - 1L, mod)
+                    ) %
+                    mod +
+                    mod
+                ) %
+                mod
+            ).toInt()
+    }
+}
+```