Added tasks 928, 929, 930, 931

Author: ThanhNIT

README.md

@@ -1365,6 +1365,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0931 |[Minimum Falling Path Sum](src/main/kotlin/g0901_1000/s0931_minimum_falling_path_sum/Solution.kt)| Medium | Array, Dynamic_Programming, Matrix | 201 | 84.21
 | 0120 |[Triangle](src/main/kotlin/g0101_0200/s0120_triangle/Solution.kt)| Medium | Array, Dynamic_Programming | 194 | 97.87
 
 #### Day 14
@@ -1730,6 +1731,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 |------|----------------|-------------|-------------|----------|---------
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
+| 0931 |[Minimum Falling Path Sum](src/main/kotlin/g0901_1000/s0931_minimum_falling_path_sum/Solution.kt)| Medium | Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_13 | 201 | 84.21
+| 0930 |[Binary Subarrays With Sum](src/main/kotlin/g0901_1000/s0930_binary_subarrays_with_sum/Solution.kt)| Medium | Array, Hash_Table, Prefix_Sum, Sliding_Window | 250 | 93.75
+| 0929 |[Unique Email Addresses](src/main/kotlin/g0901_1000/s0929_unique_email_addresses/Solution.kt)| Easy | Array, String, Hash_Table | 207 | 89.29
+| 0928 |[Minimize Malware Spread II](src/main/kotlin/g0901_1000/s0928_minimize_malware_spread_ii/Solution.kt)| Hard | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 716 | 100.00
 | 0927 |[Three Equal Parts](src/main/kotlin/g0901_1000/s0927_three_equal_parts/Solution.kt)| Hard | Array, Math | 303 | 100.00
 | 0926 |[Flip String to Monotone Increasing](src/main/kotlin/g0901_1000/s0926_flip_string_to_monotone_increasing/Solution.kt)| Medium | String, Dynamic_Programming | 199 | 100.00
 | 0925 |[Long Pressed Name](src/main/kotlin/g0901_1000/s0925_long_pressed_name/Solution.kt)| Easy | String, Two_Pointers | 126 | 92.31

src/main/kotlin/g0901_1000/s0928_minimize_malware_spread_ii/Solution.kt

@@ -0,0 +1,66 @@
+package g0901_1000.s0928_minimize_malware_spread_ii
+
+// #Hard #Array #Depth_First_Search #Breadth_First_Search #Matrix #Union_Find
+// #2023_04_26_Time_716_ms_(100.00%)_Space_63.5_MB_(100.00%)
+
+import java.util.LinkedList
+import java.util.Queue
+
+class Solution {
+    private val adj: MutableMap<Int, ArrayList<Int>> = HashMap()
+    private var visited: MutableSet<Int>? = null
+    private var count = 0
+
+    private fun bfs(ind: Int, initial: IntArray) {
+        val q: Queue<Int> = LinkedList()
+        for (i in initial.indices) {
+            if (i != ind) {
+                q.add(initial[i])
+                visited!!.add(initial[i])
+            }
+        }
+        while (!q.isEmpty()) {
+            val curr = q.poll()
+            if (curr != initial[ind]) {
+                count++
+            }
+            val children = adj[curr]
+            if (children != null) {
+                for (child in children) {
+                    if (!visited!!.contains(child)) {
+                        q.add(child)
+                        visited!!.add(child)
+                    }
+                }
+            }
+        }
+    }
+
+    fun minMalwareSpread(graph: Array<IntArray>, initial: IntArray): Int {
+        val n = graph.size
+        for (i in 0 until n) {
+            adj.putIfAbsent(i, ArrayList())
+            for (j in 0 until n) {
+                if (graph[i][j] == 1) {
+                    adj[i]!!.add(j)
+                }
+            }
+        }
+        var min = n + 1
+        initial.sort()
+        var node = initial[0]
+        for (i in initial.indices) {
+            visited = HashSet()
+            val children = adj[initial[i]]!!
+            adj.remove(initial[i])
+            bfs(i, initial)
+            if (count < min) {
+                min = count
+                node = initial[i]
+            }
+            count = 0
+            adj[initial[i]] = children
+        }
+        return node
+    }
+}

src/main/kotlin/g0901_1000/s0928_minimize_malware_spread_ii/readme.md

@@ -0,0 +1,43 @@
+928\. Minimize Malware Spread II
+
+Hard
+
+You are given a network of `n` nodes represented as an `n x n` adjacency matrix `graph`, where the <code>i<sup>th</sup></code> node is directly connected to the <code>j<sup>th</sup></code> node if `graph[i][j] == 1`.
+
+Some nodes `initial` are initially infected by malware. Whenever two nodes are directly connected, and at least one of those two nodes is infected by malware, both nodes will be infected by malware. This spread of malware will continue until no more nodes can be infected in this manner.
+
+Suppose `M(initial)` is the final number of nodes infected with malware in the entire network after the spread of malware stops.
+
+We will remove **exactly one node** from `initial`, **completely removing it and any connections from this node to any other node**.
+
+Return the node that, if removed, would minimize `M(initial)`. If multiple nodes could be removed to minimize `M(initial)`, return such a node with **the smallest index**.
+
+**Example 1:**
+
+**Input:** graph = [[1,1,0],[1,1,0],[0,0,1]], initial = [0,1]
+
+**Output:** 0
+
+**Example 2:**
+
+**Input:** graph = [[1,1,0],[1,1,1],[0,1,1]], initial = [0,1]
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** graph = [[1,1,0,0],[1,1,1,0],[0,1,1,1],[0,0,1,1]], initial = [0,1]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `n == graph.length`
+*   `n == graph[i].length`
+*   `2 <= n <= 300`
+*   `graph[i][j]` is `0` or `1`.
+*   `graph[i][j] == graph[j][i]`
+*   `graph[i][i] == 1`
+*   `1 <= initial.length < n`
+*   `0 <= initial[i] <= n - 1`
+*   All the integers in `initial` are **unique**.

src/main/kotlin/g0901_1000/s0929_unique_email_addresses/Solution.kt

@@ -0,0 +1,27 @@
+package g0901_1000.s0929_unique_email_addresses
+
+// #Easy #Array #String #Hash_Table #2023_04_26_Time_207_ms_(89.29%)_Space_37.1_MB_(82.14%)
+
+class Solution {
+    fun numUniqueEmails(emails: Array<String>): Int {
+        val set: MutableSet<String> = HashSet()
+        for (s in emails) {
+            val sb = StringBuilder()
+            var i = 0
+            while (i < s.length) {
+                val c = s[i]
+                if (c == '+' || c == '@') {
+                    sb.append('@')
+                    i = s.indexOf("@") + 1
+                    sb.append(s.substring(i))
+                    break
+                } else if (c != '.') {
+                    sb.append(c)
+                }
+                i++
+            }
+            set.add(sb.toString())
+        }
+        return set.size
+    }
+}

src/main/kotlin/g0901_1000/s0929_unique_email_addresses/readme.md

@@ -0,0 +1,43 @@
+929\. Unique Email Addresses
+
+Easy
+
+Every **valid email** consists of a **local name** and a **domain name**, separated by the `'@'` sign. Besides lowercase letters, the email may contain one or more `'.'` or `'+'`.
+
+*   For example, in `"[email protected]"`, `"alice"` is the **local name**, and `"leetcode.com"` is the **domain name**.
+
+If you add periods `'.'` between some characters in the **local name** part of an email address, mail sent there will be forwarded to the same address without dots in the local name. Note that this rule **does not apply** to **domain names**.
+
+*   For example, `"[email protected]"` and `"[email protected]"` forward to the same email address.
+
+If you add a plus `'+'` in the **local name**, everything after the first plus sign **will be ignored**. This allows certain emails to be filtered. Note that this rule **does not apply** to **domain names**.
+
+*   For example, `"[email protected]"` will be forwarded to `"[email protected]"`.
+
+It is possible to use both of these rules at the same time.
+
+Given an array of strings `emails` where we send one email to each `emails[i]`, return _the number of different addresses that actually receive mails_.
+
+**Example 1:**
+
+**Input:** emails = ["[email protected]","[email protected]","[email protected]"]
+
+**Output:** 2
+
+**Explanation:** "[email protected]" and "[email protected]" actually receive mails.
+
+**Example 2:**
+
+**Input:** emails = ["[email protected]","[email protected]","[email protected]"]
+
+**Output:** 3
+
+**Constraints:**
+
+*   `1 <= emails.length <= 100`
+*   `1 <= emails[i].length <= 100`
+*   `emails[i]` consist of lowercase English letters, `'+'`, `'.'` and `'@'`.
+*   Each `emails[i]` contains exactly one `'@'` character.
+*   All local and domain names are non-empty.
+*   Local names do not start with a `'+'` character.
+*   Domain names end with the `".com"` suffix.

src/main/kotlin/g0901_1000/s0930_binary_subarrays_with_sum/Solution.kt

@@ -0,0 +1,29 @@
+package g0901_1000.s0930_binary_subarrays_with_sum
+
+// #Medium #Array #Hash_Table #Prefix_Sum #Sliding_Window
+// #2023_04_26_Time_250_ms_(93.75%)_Space_39.6_MB_(87.50%)
+
+class Solution {
+    fun numSubarraysWithSum(nums: IntArray, goal: Int): Int {
+        return atmostK(nums, goal) - atmostK(nums, goal - 1)
+    }
+
+    fun atmostK(arr: IntArray, k: Int): Int {
+        var cnt = 0
+        var i = 0
+        var j = 0
+        var sum = 0
+        while (j < arr.size) {
+            sum += arr[j]
+            if (sum > k) {
+                while (i <= j && sum > k) {
+                    sum -= arr[i]
+                    i++
+                }
+            }
+            cnt += j - i + 1
+            j++
+        }
+        return cnt
+    }
+}

src/main/kotlin/g0901_1000/s0930_binary_subarrays_with_sum/readme.md

@@ -0,0 +1,35 @@
+930\. Binary Subarrays With Sum
+
+Medium
+
+Given a binary array `nums` and an integer `goal`, return _the number of non-empty **subarrays** with a sum_ `goal`.
+
+A **subarray** is a contiguous part of the array.
+
+**Example 1:**
+
+**Input:** nums = [1,0,1,0,1], goal = 2
+
+**Output:** 4
+
+**Explanation:** The 4 subarrays are bolded and underlined below: 
+
+[<ins>**1,0,1**</ins>,0,1]
+
+[<ins>**1,0,1,0**</ins>,1]
+
+[1,<ins>**0,1,0,1**</ins>] 
+
+[1,0,<ins>**1,0,1**</ins>]
+
+**Example 2:**
+
+**Input:** nums = [0,0,0,0,0], goal = 0
+
+**Output:** 15
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   `nums[i]` is either `0` or `1`.
+*   `0 <= goal <= nums.length`

src/main/kotlin/g0901_1000/s0931_minimum_falling_path_sum/Solution.kt

@@ -0,0 +1,34 @@
+package g0901_1000.s0931_minimum_falling_path_sum
+
+// #Medium #Array #Dynamic_Programming #Matrix #Dynamic_Programming_I_Day_13
+// #2023_04_26_Time_201_ms_(84.21%)_Space_36.7_MB_(94.74%)
+
+class Solution {
+    fun minFallingPathSum(matrix: Array<IntArray>): Int {
+        val l = matrix[0].size
+        var arr = matrix[0]
+        for (i in 1 until matrix.size) {
+            val cur = IntArray(l)
+            for (j in 0 until l) {
+                var left = Int.MAX_VALUE
+                var right = Int.MAX_VALUE
+                val curCell = arr[j]
+                if (j > 0) {
+                    left = arr[j - 1]
+                }
+                if (j < l - 1) {
+                    right = arr[j + 1]
+                }
+                cur[j] = matrix[i][j] + left.coerceAtMost(right.coerceAtMost(curCell))
+            }
+            arr = cur
+        }
+        var min = Int.MAX_VALUE
+        for (i in 0 until l) {
+            if (arr[i] < min) {
+                min = arr[i]
+            }
+        }
+        return min
+    }
+}

src/main/kotlin/g0901_1000/s0931_minimum_falling_path_sum/readme.md

@@ -0,0 +1,33 @@
+931\. Minimum Falling Path Sum
+
+Medium
+
+Given an `n x n` array of integers `matrix`, return _the **minimum sum** of any **falling path** through_ `matrix`.
+
+A **falling path** starts at any element in the first row and chooses the element in the next row that is either directly below or diagonally left/right. Specifically, the next element from position `(row, col)` will be `(row + 1, col - 1)`, `(row + 1, col)`, or `(row + 1, col + 1)`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/11/03/failing1-grid.jpg)
+
+**Input:** matrix = [[2,1,3],[6,5,4],[7,8,9]]
+
+**Output:** 13
+
+**Explanation:** There are two falling paths with a minimum sum as shown.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/11/03/failing2-grid.jpg)
+
+**Input:** matrix = [[-19,57],[-40,-5]]
+
+**Output:** -59
+
+**Explanation:** The falling path with a minimum sum is shown.
+
+**Constraints:**
+
+*   `n == matrix.length == matrix[i].length`
+*   `1 <= n <= 100`
+*   `-100 <= matrix[i][j] <= 100`

src/test/kotlin/g0901_1000/s0928_minimize_malware_spread_ii/SolutionTest.kt

@@ -0,0 +1,48 @@
+package g0901_1000.s0928_minimize_malware_spread_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minMalwareSpread() {
+        assertThat(
+            Solution()
+                .minMalwareSpread(
+                    arrayOf(intArrayOf(1, 1, 0), intArrayOf(1, 1, 0), intArrayOf(0, 0, 1)),
+                    intArrayOf(0, 1)
+                ),
+            equalTo(0)
+        )
+    }
+
+    @Test
+    fun minMalwareSpread2() {
+        assertThat(
+            Solution()
+                .minMalwareSpread(
+                    arrayOf(intArrayOf(1, 1, 0), intArrayOf(1, 1, 1), intArrayOf(0, 1, 1)),
+                    intArrayOf(0, 1)
+                ),
+            equalTo(1)
+        )
+    }
+
+    @Test
+    fun minMalwareSpread3() {
+        assertThat(
+            Solution()
+                .minMalwareSpread(
+                    arrayOf(
+                        intArrayOf(1, 1, 0, 0),
+                        intArrayOf(1, 1, 1, 0),
+                        intArrayOf(0, 1, 1, 1),
+                        intArrayOf(0, 0, 1, 1)
+                    ),
+                    intArrayOf(0, 1)
+                ),
+            equalTo(1)
+        )
+    }
+}