Added tasks 802, 803, 804, 805

Author: ThanhNIT

README.md

@@ -102,6 +102,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0802 |[Find Eventual Safe States](src/main/kotlin/g0801_0900/s0802_find_eventual_safe_states/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort | 511 | 100.00
 
 #### Day 10 Standard Traversal
 
@@ -1710,6 +1711,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 | 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
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
+| 0805 |[Split Array With Same Average](src/main/kotlin/g0801_0900/s0805_split_array_with_same_average/Solution.kt)| Hard | Array, Dynamic_Programming, Math, Bit_Manipulation, Bitmask | 142 | 100.00
+| 0804 |[Unique Morse Code Words](src/main/kotlin/g0801_0900/s0804_unique_morse_code_words/Solution.kt)| Easy | Array, String, Hash_Table | 158 | 80.00
+| 0803 |[Bricks Falling When Hit](src/main/kotlin/g0801_0900/s0803_bricks_falling_when_hit/Solution.kt)| Hard | Array, Matrix, Union_Find | 742 | 100.00
+| 0802 |[Find Eventual Safe States](src/main/kotlin/g0801_0900/s0802_find_eventual_safe_states/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort, Graph_Theory_I_Day_9_Standard_Traversal | 511 | 100.00
 | 0801 |[Minimum Swaps To Make Sequences Increasing](src/main/kotlin/g0801_0900/s0801_minimum_swaps_to_make_sequences_increasing/Solution.kt)| Hard | Array, Dynamic_Programming | 617 | 83.33
 | 0799 |[Champagne Tower](src/main/kotlin/g0701_0800/s0799_champagne_tower/Solution.kt)| Medium | Dynamic_Programming | 153 | 100.00
 | 0798 |[Smallest Rotation with Highest Score](src/main/kotlin/g0701_0800/s0798_smallest_rotation_with_highest_score/Solution.kt)| Hard | Array, Prefix_Sum | 470 | 100.00

src/main/kotlin/g0801_0900/s0802_find_eventual_safe_states/Solution.kt

@@ -0,0 +1,32 @@
+package g0801_0900.s0802_find_eventual_safe_states
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Graph #Topological_Sort
+// #Graph_Theory_I_Day_9_Standard_Traversal
+// #2023_03_16_Time_511_ms_(100.00%)_Space_65.1_MB_(58.33%)
+
+class Solution {
+    fun eventualSafeNodes(graph: Array<IntArray>): List<Int> {
+        val res: MutableList<Int> = ArrayList()
+        val vis = IntArray(graph.size)
+        for (i in graph.indices) {
+            if (dfs(graph, i, vis)) {
+                res.add(i)
+            }
+        }
+        return res
+    }
+
+    private fun dfs(graph: Array<IntArray>, src: Int, vis: IntArray): Boolean {
+        if (vis[src] != 0) {
+            return vis[src] == 2
+        }
+        vis[src] = 1
+        for (x in graph[src]) {
+            if (!dfs(graph, x, vis)) {
+                return false
+            }
+        }
+        vis[src] = 2
+        return true
+    }
+}

src/main/kotlin/g0801_0900/s0802_find_eventual_safe_states/readme.md

@@ -0,0 +1,37 @@
+802\. Find Eventual Safe States
+
+Medium
+
+There is a directed graph of `n` nodes with each node labeled from `0` to `n - 1`. The graph is represented by a **0-indexed** 2D integer array `graph` where `graph[i]` is an integer array of nodes adjacent to node `i`, meaning there is an edge from node `i` to each node in `graph[i]`.
+
+A node is a **terminal node** if there are no outgoing edges. A node is a **safe node** if every possible path starting from that node leads to a **terminal node** (or another safe node).
+
+Return _an array containing all the **safe nodes** of the graph_. The answer should be sorted in **ascending** order.
+
+**Example 1:**
+
+![Illustration of graph](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/03/17/picture1.png)
+
+**Input:** graph = [[1,2],[2,3],[5],[0],[5],[],[]]
+
+**Output:** [2,4,5,6]
+
+**Explanation:** The given graph is shown above. Nodes 5 and 6 are terminal nodes as there are no outgoing edges from either of them. Every path starting at nodes 2, 4, 5, and 6 all lead to either node 5 or 6.
+
+**Example 2:**
+
+**Input:** graph = [[1,2,3,4],[1,2],[3,4],[0,4],[]]
+
+**Output:** [4]
+
+**Explanation:** Only node 4 is a terminal node, and every path starting at node 4 leads to node 4.
+
+**Constraints:**
+
+*   `n == graph.length`
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   `0 <= graph[i].length <= n`
+*   `0 <= graph[i][j] <= n - 1`
+*   `graph[i]` is sorted in a strictly increasing order.
+*   The graph may contain self-loops.
+*   The number of edges in the graph will be in the range <code>[1, 4 * 10<sup>4</sup>]</code>.

src/main/kotlin/g0801_0900/s0803_bricks_falling_when_hit/Solution.kt

@@ -0,0 +1,57 @@
+package g0801_0900.s0803_bricks_falling_when_hit
+
+// #Hard #Array #Matrix #Union_Find #2023_03_16_Time_742_ms_(100.00%)_Space_53.4_MB_(100.00%)
+
+class Solution {
+    private val dirs = arrayOf(intArrayOf(1, 0), intArrayOf(-1, 0), intArrayOf(0, 1), intArrayOf(0, -1))
+    fun hitBricks(grid: Array<IntArray>, hits: Array<IntArray>): IntArray {
+        val cols = grid[0].size
+        for (hit in hits) {
+            val x = hit[0]
+            val y = hit[1]
+            grid[x][y]--
+        }
+        val row = 0
+        for (col in 0 until cols) {
+            dfs(row, col, grid)
+        }
+        val res = IntArray(hits.size)
+        for (i in hits.indices.reversed()) {
+            val x = hits[i][0]
+            val y = hits[i][1]
+            grid[x][y]++
+            if (grid[x][y] == 1 && isConnectedToRoof(x, y, grid)) {
+                res[i] = dfs(x, y, grid) - 1
+            }
+        }
+        return res
+    }
+
+    private fun dfs(i: Int, j: Int, grid: Array<IntArray>): Int {
+        if (i < 0 || i >= grid.size || j < 0 || j >= grid[0].size || grid[i][j] != 1) {
+            return 0
+        }
+        grid[i][j] = 2
+        return (
+            dfs(i + 1, j, grid) +
+                dfs(i - 1, j, grid) +
+                dfs(i, j + 1, grid) +
+                dfs(i, j - 1, grid) +
+                1
+            )
+    }
+
+    private fun isConnectedToRoof(i: Int, j: Int, grid: Array<IntArray>): Boolean {
+        if (i == 0) {
+            return true
+        }
+        for (d in dirs) {
+            val x = i + d[0]
+            val y = j + d[1]
+            if (x >= 0 && x < grid.size && y >= 0 && y < grid[0].size && grid[x][y] == 2) {
+                return true
+            }
+        }
+        return false
+    }
+}

src/main/kotlin/g0801_0900/s0803_bricks_falling_when_hit/readme.md

@@ -0,0 +1,72 @@
+803\. Bricks Falling When Hit
+
+Hard
+
+You are given an `m x n` binary `grid`, where each `1` represents a brick and `0` represents an empty space. A brick is **stable** if:
+
+*   It is directly connected to the top of the grid, or
+*   At least one other brick in its four adjacent cells is **stable**.
+
+You are also given an array `hits`, which is a sequence of erasures we want to apply. Each time we want to erase the brick at the location <code>hits[i] = (row<sub>i</sub>, col<sub>i</sub>)</code>. The brick on that location (if it exists) will disappear. Some other bricks may no longer be stable because of that erasure and will **fall**. Once a brick falls, it is **immediately** erased from the `grid` (i.e., it does not land on other stable bricks).
+
+Return _an array_ `result`_, where each_ `result[i]` _is the number of bricks that will **fall** after the_ <code>i<sup>th</sup></code> _erasure is applied._
+
+**Note** that an erasure may refer to a location with no brick, and if it does, no bricks drop.
+
+**Example 1:**
+
+**Input:** grid = [[1,0,0,0],[1,1,1,0]], hits = [[1,0]]
+
+**Output:** [2]
+
+**Explanation:** Starting with the grid:
+
+[[1,0,0,0], [1,1,1,0]]
+
+We erase the underlined brick at (1,0), resulting in the grid:
+
+[[1,0,0,0], [0,1,1,0]]
+
+The two underlined bricks are no longer stable as they are no longer connected to the top nor adjacent to another stable brick, so they will fall. The resulting grid is:
+
+[[1,0,0,0], [0,0,0,0]]
+
+Hence the result is [2].
+
+**Example 2:**
+
+**Input:** grid = [[1,0,0,0],[1,1,0,0]], hits = [[1,1],[1,0]]
+
+**Output:** [0,0]
+
+**Explanation:** Starting with the grid:
+
+[[1,0,0,0], [1,1,0,0]]
+
+We erase the underlined brick at (1,1), resulting in the grid:
+
+[[1,0,0,0], [1,0,0,0]]
+
+All remaining bricks are still stable, so no bricks fall. The grid remains the same:
+
+[[1,0,0,0], [1,0,0,0]]
+
+Next, we erase the underlined brick at (1,0), resulting in the grid:
+
+[[1,0,0,0], [0,0,0,0]]
+
+Once again, all remaining bricks are still stable, so no bricks fall.
+
+Hence the result is [0,0].
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 200`
+*   `grid[i][j]` is `0` or `1`.
+*   <code>1 <= hits.length <= 4 * 10<sup>4</sup></code>
+*   `hits[i].length == 2`
+*   <code>0 <= x<sub>i </sub><= m - 1</code>
+*   <code>0 <= y<sub>i</sub> <= n - 1</code>
+*   All <code>(x<sub>i</sub>, y<sub>i</sub>)</code> are unique.

src/main/kotlin/g0801_0900/s0804_unique_morse_code_words/Solution.kt

@@ -0,0 +1,22 @@
+package g0801_0900.s0804_unique_morse_code_words
+
+// #Easy #Array #String #Hash_Table #2023_03_16_Time_158_ms_(80.00%)_Space_34.9_MB_(65.71%)
+
+class Solution {
+    fun uniqueMorseRepresentations(words: Array<String>): Int {
+        val morse = arrayOf(
+            ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..",
+            "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-",
+            "-.--", "--.."
+        )
+        val set: MutableSet<String> = HashSet()
+        for (word in words) {
+            val temp = StringBuilder()
+            for (c in word.toCharArray()) {
+                temp.append(morse[c.code - 'a'.code])
+            }
+            set.add(temp.toString())
+        }
+        return set.size
+    }
+}

src/main/kotlin/g0801_0900/s0804_unique_morse_code_words/readme.md

@@ -0,0 +1,49 @@
+804\. Unique Morse Code Words
+
+Easy
+
+International Morse Code defines a standard encoding where each letter is mapped to a series of dots and dashes, as follows:
+
+*   `'a'` maps to `".-"`,
+*   `'b'` maps to `"-..."`,
+*   `'c'` maps to `"-.-."`, and so on.
+
+For convenience, the full table for the `26` letters of the English alphabet is given below:
+
+[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
+
+Given an array of strings `words` where each word can be written as a concatenation of the Morse code of each letter.
+
+*   For example, `"cab"` can be written as `"-.-..--..."`, which is the concatenation of `"-.-."`, `".-"`, and `"-..."`. We will call such a concatenation the **transformation** of a word.
+
+Return _the number of different **transformations** among all words we have_.
+
+**Example 1:**
+
+**Input:** words = ["gin","zen","gig","msg"]
+
+**Output:** 2
+
+**Explanation:** The transformation of each word is: 
+
+"gin" -> "--...-." 
+
+"zen" -> "--...-." 
+
+"gig" -> "--...--." 
+
+"msg" -> "--...--." 
+
+There are 2 different transformations: "--...-." and "--...--.".
+
+**Example 2:**
+
+**Input:** words = ["a"]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   `1 <= words[i].length <= 12`
+*   `words[i]` consists of lowercase English letters.

src/main/kotlin/g0801_0900/s0805_split_array_with_same_average/Solution.kt

@@ -0,0 +1,53 @@
+package g0801_0900.s0805_split_array_with_same_average
+
+// #Hard #Array #Dynamic_Programming #Math #Bit_Manipulation #Bitmask
+// #2023_03_16_Time_142_ms_(100.00%)_Space_33.7_MB_(100.00%)
+
+import java.util.Arrays
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    private lateinit var nums: IntArray
+    private lateinit var sums: IntArray
+    fun splitArraySameAverage(nums: IntArray): Boolean {
+        val len = nums.size
+        if (len == 1) {
+            return false
+        }
+        Arrays.sort(nums)
+        sums = IntArray(len + 1)
+        for (i in 0 until len) {
+            sums[i + 1] = sums[i] + nums[i]
+        }
+        val sum = sums[len]
+        this.nums = nums
+        var i = 1
+        val stop = len / 2
+        while (i <= stop) {
+            if (sum * i % len == 0 && findSum(i, len, sum * i / len)) {
+                return true
+            }
+            i++
+        }
+        return false
+    }
+
+    private fun findSum(k: Int, pos: Int, target: Int): Boolean {
+        var pos = pos
+        if (k == 1) {
+            while (true) {
+                if (nums[--pos] <= target) {
+                    break
+                }
+            }
+            return nums[pos] == target
+        }
+        var i = pos
+        while (sums[i] - sums[i-- - k] >= target) {
+            if (sums[k - 1] <= target - nums[i] && findSum(k - 1, i, target - nums[i])) {
+                return true
+            }
+        }
+        return false
+    }
+}

src/main/kotlin/g0801_0900/s0805_split_array_with_same_average/readme.md

@@ -0,0 +1,30 @@
+805\. Split Array With Same Average
+
+Hard
+
+You are given an integer array `nums`.
+
+You should move each element of `nums` into one of the two arrays `A` and `B` such that `A` and `B` are non-empty, and `average(A) == average(B)`.
+
+Return `true` if it is possible to achieve that and `false` otherwise.
+
+**Note** that for an array `arr`, `average(arr)` is the sum of all the elements of `arr` over the length of `arr`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5,6,7,8]
+
+**Output:** true
+
+**Explanation:** We can split the array into [1,4,5,8] and [2,3,6,7], and both of them have an average of 4.5.
+
+**Example 2:**
+
+**Input:** nums = [3,1]
+
+**Output:** false
+
+**Constraints:**
+
+*   `1 <= nums.length <= 30`
+*   <code>0 <= nums[i] <= 10<sup>4</sup></code>