Added tasks 838, 839, 840, 841

Author: ThanhNIT

README.md

@@ -91,6 +91,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0797 |[All Paths From Source to Target](src/main/kotlin/g0701_0800/s0797_all_paths_from_source_to_target/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Backtracking | 232 | 100.00
+| 0841 |[Keys and Rooms](src/main/kotlin/g0801_0900/s0841_keys_and_rooms/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph | 189 | 69.23
 
 #### Day 8 Standard Traversal
 
@@ -891,6 +892,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0841 |[Keys and Rooms](src/main/kotlin/g0801_0900/s0841_keys_and_rooms/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph | 189 | 69.23
 
 #### Day 20 Heap Priority Queue
 
@@ -1713,6 +1715,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
+| 0841 |[Keys and Rooms](src/main/kotlin/g0801_0900/s0841_keys_and_rooms/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Data_Structure_II_Day_19_Graph, Graph_Theory_I_Day_7_Standard_Traversal | 189 | 69.23
+| 0840 |[Magic Squares In Grid](src/main/kotlin/g0801_0900/s0840_magic_squares_in_grid/Solution.kt)| Medium | Array, Math, Matrix | 149 | 100.00
+| 0839 |[Similar String Groups](src/main/kotlin/g0801_0900/s0839_similar_string_groups/Solution.kt)| Hard | Array, String, Depth_First_Search, Breadth_First_Search, Union_Find | 205 | 100.00
+| 0838 |[Push Dominoes](src/main/kotlin/g0801_0900/s0838_push_dominoes/Solution.kt)| Medium | String, Dynamic_Programming, Two_Pointers | 270 | 100.00
 | 0837 |[New 21 Game](src/main/kotlin/g0801_0900/s0837_new_21_game/Solution.kt)| Medium | Dynamic_Programming, Math, Sliding_Window, Probability_and_Statistics | 144 | 75.00
 | 0836 |[Rectangle Overlap](src/main/kotlin/g0801_0900/s0836_rectangle_overlap/Solution.kt)| Easy | Math, Geometry | 121 | 100.00
 | 0835 |[Image Overlap](src/main/kotlin/g0801_0900/s0835_image_overlap/Solution.kt)| Medium | Array, Matrix | 163 | 100.00

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

@@ -0,0 +1,54 @@
+package g0801_0900.s0838_push_dominoes
+
+// #Medium #String #Dynamic_Programming #Two_Pointers
+// #2023_03_28_Time_270_ms_(100.00%)_Space_39.5_MB_(100.00%)
+
+class Solution {
+    fun pushDominoes(dominoes: String): String {
+        val ch = CharArray(dominoes.length + 2)
+        ch[0] = 'L'
+        ch[ch.size - 1] = 'R'
+        for (k in 1 until ch.size - 1) {
+            ch[k] = dominoes[k - 1]
+        }
+        var i = 0
+        var j = 1
+        while (j < ch.size) {
+            while (ch[j] == '.') {
+                j++
+            }
+            if (ch[i] == 'L' && ch[j] == 'L') {
+                while (i != j) {
+                    ch[i] = 'L'
+                    i++
+                }
+                j++
+            } else if (ch[i] == 'R' && ch[j] == 'R') {
+                while (i != j) {
+                    ch[i] = 'R'
+                    i++
+                }
+                j++
+            } else if (ch[i] == 'L' && ch[j] == 'R') {
+                i = j
+                j++
+            } else if (ch[i] == 'R' && ch[j] == 'L') {
+                var rTemp = i + 1
+                var lTemp = j - 1
+                while (rTemp < lTemp) {
+                    ch[rTemp] = 'R'
+                    ch[lTemp] = 'L'
+                    rTemp++
+                    lTemp--
+                }
+                i = j
+                j++
+            }
+        }
+        val sb = StringBuilder()
+        for (k in 1 until ch.size - 1) {
+            sb.append(ch[k])
+        }
+        return sb.toString()
+    }
+}

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

@@ -0,0 +1,41 @@
+838\. Push Dominoes
+
+Medium
+
+There are `n` dominoes in a line, and we place each domino vertically upright. In the beginning, we simultaneously push some of the dominoes either to the left or to the right.
+
+After each second, each domino that is falling to the left pushes the adjacent domino on the left. Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right.
+
+When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces.
+
+For the purposes of this question, we will consider that a falling domino expends no additional force to a falling or already fallen domino.
+
+You are given a string `dominoes` representing the initial state where:
+
+*   `dominoes[i] = 'L'`, if the <code>i<sup>th</sup></code> domino has been pushed to the left,
+*   `dominoes[i] = 'R'`, if the <code>i<sup>th</sup></code> domino has been pushed to the right, and
+*   `dominoes[i] = '.'`, if the <code>i<sup>th</sup></code> domino has not been pushed.
+
+Return _a string representing the final state_.
+
+**Example 1:**
+
+**Input:** dominoes = "RR.L"
+
+**Output:** "RR.L"
+
+**Explanation:** The first domino expends no additional force on the second domino.
+
+**Example 2:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/05/18/domino.png)
+
+**Input:** dominoes = ".L.R...LR..L.."
+
+**Output:** "LL.RR.LLRRLL.."
+
+**Constraints:**
+
+*   `n == dominoes.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `dominoes[i]` is either `'L'`, `'R'`, or `'.'`.

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

@@ -0,0 +1,60 @@
+package g0801_0900.s0839_similar_string_groups
+
+// #Hard #Array #String #Depth_First_Search #Breadth_First_Search #Union_Find
+// #2023_03_28_Time_205_ms_(100.00%)_Space_35.9_MB_(100.00%)
+
+import java.util.LinkedList
+import java.util.Queue
+
+class Solution {
+    fun numSimilarGroups(strs: Array<String>): Int {
+        val visited = BooleanArray(strs.size)
+        var res = 0
+        for (i in strs.indices) {
+            if (!visited[i]) {
+                res++
+                bfs(i, visited, strs)
+            }
+        }
+        return res
+    }
+
+    private fun bfs(i: Int, visited: BooleanArray, strs: Array<String>) {
+        val qu: Queue<String> = LinkedList()
+        qu.add(strs[i])
+        visited[i] = true
+        while (!qu.isEmpty()) {
+            val s = qu.poll()
+            for (j in strs.indices) {
+                if (visited[j]) {
+                    continue
+                }
+                if (isSimilar(s, strs[j])) {
+                    visited[j] = true
+                    qu.add(strs[j])
+                }
+            }
+        }
+    }
+
+    private fun isSimilar(s1: String, s2: String): Boolean {
+        var c1: Char? = null
+        var c2: Char? = null
+        var mismatchCount = 0
+        for (i in s1.indices) {
+            if (s1[i] == s2[i]) {
+                continue
+            }
+            mismatchCount++
+            if (c1 == null) {
+                c1 = s1[i]
+                c2 = s2[i]
+            } else if (s2[i] != c1 || s1[i] != c2) {
+                return false
+            } else if (mismatchCount > 2) {
+                return false
+            }
+        }
+        return true
+    }
+}

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

@@ -0,0 +1,30 @@
+839\. Similar String Groups
+
+Hard
+
+Two strings `X` and `Y` are similar if we can swap two letters (in different positions) of `X`, so that it equals `Y`. Also two strings `X` and `Y` are similar if they are equal.
+
+For example, `"tars"` and `"rats"` are similar (swapping at positions `0` and `2`), and `"rats"` and `"arts"` are similar, but `"star"` is not similar to `"tars"`, `"rats"`, or `"arts"`.
+
+Together, these form two connected groups by similarity: `{"tars", "rats", "arts"}` and `{"star"}`. Notice that `"tars"` and `"arts"` are in the same group even though they are not similar. Formally, each group is such that a word is in the group if and only if it is similar to at least one other word in the group.
+
+We are given a list `strs` of strings where every string in `strs` is an anagram of every other string in `strs`. How many groups are there?
+
+**Example 1:**
+
+**Input:** strs = ["tars","rats","arts","star"]
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** strs = ["omv","ovm"]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= strs.length <= 300`
+*   `1 <= strs[i].length <= 300`
+*   `strs[i]` consists of lowercase letters only.
+*   All words in `strs` have the same length and are anagrams of each other.

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

@@ -0,0 +1,49 @@
+package g0801_0900.s0840_magic_squares_in_grid
+
+// #Medium #Array #Math #Matrix #2023_03_28_Time_149_ms_(100.00%)_Space_34.2_MB_(100.00%)
+
+class Solution {
+    fun numMagicSquaresInside(grid: Array<IntArray>): Int {
+        val m = grid.size
+        val n = grid[0].size
+        var count = 0
+        for (i in 0 until m - 2) {
+            for (j in 0 until n - 2) {
+                val set: MutableSet<Int> = HashSet()
+                val sum = grid[i][j] + grid[i][j + 1] + grid[i][j + 2]
+                if (sum == grid[i + 1][j] + grid[i + 1][j + 1] + grid[i + 1][j + 2] && sum == grid[i + 2][j] +
+                    grid[i + 2][j + 1] + grid[i + 2][j + 2] && sum == grid[i][j] + grid[i + 1][j] + grid[i + 2][j] &&
+                    sum == grid[i][j + 1] + grid[i + 1][j + 1] + grid[i + 2][j + 1] && sum == grid[i][j + 2] +
+                    grid[i + 1][j + 2] + grid[i + 2][j + 2] && sum == grid[i][j] + grid[i + 1][j + 1] +
+                    grid[i + 2][j + 2] && sum == grid[i][j + 2] + grid[i + 1][j + 1] + grid[i + 2][j] && set.add(
+                            grid[i][j]
+                        ) &&
+                    isLegit(grid[i][j]) &&
+                    set.add(grid[i][j + 1]) &&
+                    isLegit(grid[i][j + 1]) &&
+                    set.add(grid[i][j + 2]) &&
+                    isLegit(grid[i][j + 2]) &&
+                    set.add(grid[i + 1][j]) &&
+                    isLegit(grid[i + 1][j]) &&
+                    set.add(grid[i + 1][j + 1]) &&
+                    isLegit(grid[i + 1][j + 1]) &&
+                    set.add(grid[i + 1][j + 2]) &&
+                    isLegit(grid[i + 1][j + 2]) &&
+                    set.add(grid[i + 2][j]) &&
+                    isLegit(grid[i + 2][j]) &&
+                    set.add(grid[i + 2][j + 1]) &&
+                    isLegit(grid[i + 2][j + 1]) &&
+                    set.add(grid[i + 2][j + 2]) &&
+                    isLegit(grid[i + 2][j + 2])
+                ) {
+                    count++
+                }
+            }
+        }
+        return count
+    }
+
+    private fun isLegit(num: Int): Boolean {
+        return num in 1..9
+    }
+}

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

@@ -0,0 +1,30 @@
+840\. Magic Squares In Grid
+
+Medium
+
+A `3 x 3` magic square is a `3 x 3` grid filled with distinct numbers **from** `1` **to** `9` such that each row, column, and both diagonals all have the same sum.
+
+Given a `row x col` `grid` of integers, how many `3 x 3` "magic square" subgrids are there? (Each subgrid is contiguous).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/11/magic_main.jpg)
+
+**Input:** grid = [[4,3,8,4],[9,5,1,9],[2,7,6,2]]
+
+**Output:** 1
+
+**Explanation:**  The following subgrid is a 3 x 3 magic square: ![](https://assets.leetcode.com/uploads/2020/09/11/magic_valid.jpg) while this one is not: ![](https://assets.leetcode.com/uploads/2020/09/11/magic_invalid.jpg) In total, there is only one magic square inside the given grid.
+
+**Example 2:**
+
+**Input:** grid = [[8]]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `row == grid.length`
+*   `col == grid[i].length`
+*   `1 <= row, col <= 10`
+*   `0 <= grid[i][j] <= 15`

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

@@ -0,0 +1,25 @@
+package g0801_0900.s0841_keys_and_rooms
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Graph #Data_Structure_II_Day_19_Graph
+// #Graph_Theory_I_Day_7_Standard_Traversal #2023_03_28_Time_189_ms_(69.23%)_Space_35.5_MB_(97.44%)
+
+import java.util.TreeSet
+
+class Solution {
+    fun canVisitAllRooms(rooms: List<List<Int>?>): Boolean {
+        val visited: MutableSet<Int> = HashSet()
+        visited.add(0)
+        val treeSet = TreeSet(rooms[0])
+        while (!treeSet.isEmpty()) {
+            val key = treeSet.pollFirst()
+            if (!visited.add(key)) {
+                continue
+            }
+            if (visited.size == rooms.size) {
+                return true
+            }
+            treeSet.addAll(rooms[key]!!)
+        }
+        return visited.size == rooms.size
+    }
+}

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

@@ -0,0 +1,44 @@
+841\. Keys and Rooms
+
+Medium
+
+There are `n` rooms labeled from `0` to `n - 1` and all the rooms are locked except for room `0`. Your goal is to visit all the rooms. However, you cannot enter a locked room without having its key.
+
+When you visit a room, you may find a set of **distinct keys** in it. Each key has a number on it, denoting which room it unlocks, and you can take all of them with you to unlock the other rooms.
+
+Given an array `rooms` where `rooms[i]` is the set of keys that you can obtain if you visited room `i`, return `true` _if you can visit **all** the rooms, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** rooms = [[1],[2],[3],[]]
+
+**Output:** true
+
+**Explanation:** 
+
+We visit room 0 and pick up key 1.
+
+We then visit room 1 and pick up key 2. 
+
+We then visit room 2 and pick up key 3. 
+
+We then visit room 3. 
+
+Since we were able to visit every room, we return true.
+
+**Example 2:**
+
+**Input:** rooms = [[1,3],[3,0,1],[2],[0]]
+
+**Output:** false
+
+**Explanation:** We can not enter room number 2 since the only key that unlocks it is in that room.
+
+**Constraints:**
+
+*   `n == rooms.length`
+*   `2 <= n <= 1000`
+*   `0 <= rooms[i].length <= 1000`
+*   `1 <= sum(rooms[i].length) <= 3000`
+*   `0 <= rooms[i][j] < n`
+*   All the values of `rooms[i]` are **unique**.

src/test/kotlin/g0801_0900/s0838_push_dominoes/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0801_0900.s0838_push_dominoes
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun pushDominoes() {
+        assertThat(Solution().pushDominoes("RR.L"), equalTo("RR.L"))
+    }
+
+    @Test
+    fun pushDominoes2() {
+        assertThat(Solution().pushDominoes(".L.R...LR..L.."), equalTo("LL.RR.LLRRLL.."))
+    }
+}