Added tasks 834, 835, 836, 837

Author: ThanhNIT

README.md

@@ -1713,6 +1713,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
+| 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
+| 0834 |[Sum of Distances in Tree](src/main/kotlin/g0801_0900/s0834_sum_of_distances_in_tree/Solution.kt)| Hard | Dynamic_Programming, Depth_First_Search, Tree, Graph | 746 | 100.00
 | 0833 |[Find And Replace in String](src/main/kotlin/g0801_0900/s0833_find_and_replace_in_string/Solution.kt)| Medium | Array, String, Sorting | 158 | 100.00
 | 0832 |[Flipping an Image](src/main/kotlin/g0801_0900/s0832_flipping_an_image/Solution.kt)| Easy | Array, Matrix, Two_Pointers, Simulation | 190 | 94.44
 | 0831 |[Masking Personal Information](src/main/kotlin/g0801_0900/s0831_masking_personal_information/Solution.kt)| Medium | String | 149 | 100.00

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

@@ -0,0 +1,48 @@
+package g0801_0900.s0834_sum_of_distances_in_tree
+
+// #Hard #Dynamic_Programming #Depth_First_Search #Tree #Graph
+// #2023_03_27_Time_746_ms_(100.00%)_Space_65.9_MB_(100.00%)
+
+class Solution {
+    private var n = 0
+    private lateinit var count: IntArray
+    private lateinit var answer: IntArray
+    private lateinit var graph: Array<MutableList<Int>?>
+
+    private fun postorder(node: Int, parent: Int) {
+        for (child in graph[node]!!) {
+            if (child != parent) {
+                postorder(child, node)
+                count[node] += count[child]
+                answer[node] += answer[child] + count[child]
+            }
+        }
+    }
+
+    private fun preorder(node: Int, parent: Int) {
+        for (child in graph[node]!!) {
+            if (child != parent) {
+                answer[child] = answer[node] - count[child] + n - count[child]
+                preorder(child, node)
+            }
+        }
+    }
+
+    fun sumOfDistancesInTree(n: Int, edges: Array<IntArray>): IntArray {
+        this.n = n
+        count = IntArray(n)
+        answer = IntArray(n)
+        graph = arrayOfNulls(n)
+        count.fill(1)
+        for (i in 0 until n) {
+            graph[i] = ArrayList()
+        }
+        for (edge in edges) {
+            graph[edge[0]]?.add(edge[1])
+            graph[edge[1]]?.add(edge[0])
+        }
+        postorder(0, -1)
+        preorder(0, -1)
+        return answer
+    }
+}

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

@@ -0,0 +1,48 @@
+834\. Sum of Distances in Tree
+
+Hard
+
+There is an undirected connected tree with `n` nodes labeled from `0` to `n - 1` and `n - 1` edges.
+
+You are given the integer `n` and the array `edges` where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.
+
+Return an array `answer` of length `n` where `answer[i]` is the sum of the distances between the <code>i<sup>th</sup></code> node in the tree and all other nodes.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/07/23/lc-sumdist1.jpg)
+
+**Input:** n = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]
+
+**Output:** [8,12,6,10,10,10]
+
+**Explanation:** The tree is shown above. 
+
+We can see that dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5) equals 1 + 1 + 2 + 2 + 2 = 8. 
+
+Hence, answer[0] = 8, and so on.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/07/23/lc-sumdist2.jpg)
+
+**Input:** n = 1, edges = []
+
+**Output:** [0]
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/07/23/lc-sumdist3.jpg)
+
+**Input:** n = 2, edges = [[1,0]]
+
+**Output:** [1,1]
+
+**Constraints:**
+
+*   <code>1 <= n <= 3 * 10<sup>4</sup></code>
+*   `edges.length == n - 1`
+*   `edges[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   The given input represents a valid tree.

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

@@ -0,0 +1,50 @@
+package g0801_0900.s0835_image_overlap
+
+// #Medium #Array #Matrix #2023_03_27_Time_163_ms_(100.00%)_Space_35.3_MB_(100.00%)
+
+class Solution {
+    fun largestOverlap(img1: Array<IntArray>, img2: Array<IntArray>): Int {
+        val bits1 = bitwise(img1)
+        val bits2 = bitwise(img2)
+        val n = img1.size
+        var res = 0
+        for (hori in -1 * n + 1 until n) {
+            for (veti in -1 * n + 1 until n) {
+                var curOverLapping = 0
+                if (veti < 0) {
+                    for (i in -1 * veti until n) {
+                        curOverLapping += if (hori < 0) {
+                            Integer.bitCount(
+                                bits1[i] shl -1 * hori and bits2[i - -1 * veti]
+                            )
+                        } else {
+                            Integer.bitCount(bits1[i] shr hori and bits2[i - -1 * veti])
+                        }
+                    }
+                } else {
+                    for (i in 0 until n - veti) {
+                        curOverLapping += if (hori < 0) {
+                            Integer.bitCount(bits1[i] shl -1 * hori and bits2[veti + i])
+                        } else {
+                            Integer.bitCount(bits1[i] shr hori and bits2[veti + i])
+                        }
+                    }
+                }
+                res = Math.max(res, curOverLapping)
+            }
+        }
+        return res
+    }
+
+    private fun bitwise(img: Array<IntArray>): IntArray {
+        val bits = IntArray(img.size)
+        for (i in img.indices) {
+            var cur = 0
+            for (j in img[0].indices) {
+                cur = cur * 2 + img[i][j]
+            }
+            bits[i] = cur
+        }
+        return bits
+    }
+}

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

@@ -0,0 +1,41 @@
+835\. Image Overlap
+
+Medium
+
+You are given two images, `img1` and `img2`, represented as binary, square matrices of size `n x n`. A binary matrix has only `0`s and `1`s as values.
+
+We **translate** one image however we choose by sliding all the `1` bits left, right, up, and/or down any number of units. We then place it on top of the other image. We can then calculate the **overlap** by counting the number of positions that have a `1` in **both** images.
+
+Note also that a translation does **not** include any kind of rotation. Any `1` bits that are translated outside of the matrix borders are erased.
+
+Return _the largest possible overlap_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/09/overlap1.jpg)
+
+**Input:** img1 = [[1,1,0],[0,1,0],[0,1,0]], img2 = [[0,0,0],[0,1,1],[0,0,1]]
+
+**Output:** 3
+
+**Explanation:** We translate img1 to right by 1 unit and down by 1 unit. ![](https://assets.leetcode.com/uploads/2020/09/09/overlap_step1.jpg) The number of positions that have a 1 in both images is 3 (shown in red). ![](https://assets.leetcode.com/uploads/2020/09/09/overlap_step2.jpg)
+
+**Example 2:**
+
+**Input:** img1 = [[1]], img2 = [[1]]
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** img1 = [[0]], img2 = [[0]]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `n == img1.length == img1[i].length`
+*   `n == img2.length == img2[i].length`
+*   `1 <= n <= 30`
+*   `img1[i][j]` is either `0` or `1`.
+*   `img2[i][j]` is either `0` or `1`.

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

@@ -0,0 +1,9 @@
+package g0801_0900.s0836_rectangle_overlap
+
+// #Easy #Math #Geometry #2023_03_27_Time_121_ms_(100.00%)_Space_33.3_MB_(90.91%)
+
+class Solution {
+    fun isRectangleOverlap(rec1: IntArray, rec2: IntArray): Boolean {
+        return rec1[0] < rec2[2] && rec2[0] < rec1[2] && rec1[1] < rec2[3] && rec2[1] < rec1[3]
+    }
+}

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

@@ -0,0 +1,34 @@
+836\. Rectangle Overlap
+
+Easy
+
+An axis-aligned rectangle is represented as a list `[x1, y1, x2, y2]`, where `(x1, y1)` is the coordinate of its bottom-left corner, and `(x2, y2)` is the coordinate of its top-right corner. Its top and bottom edges are parallel to the X-axis, and its left and right edges are parallel to the Y-axis.
+
+Two rectangles overlap if the area of their intersection is **positive**. To be clear, two rectangles that only touch at the corner or edges do not overlap.
+
+Given two axis-aligned rectangles `rec1` and `rec2`, return `true` _if they overlap, otherwise return_ `false`.
+
+**Example 1:**
+
+**Input:** rec1 = [0,0,2,2], rec2 = [1,1,3,3]
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** rec1 = [0,0,1,1], rec2 = [1,0,2,1]
+
+**Output:** false
+
+**Example 3:**
+
+**Input:** rec1 = [0,0,1,1], rec2 = [2,2,3,3]
+
+**Output:** false
+
+**Constraints:**
+
+*   `rec1.length == 4`
+*   `rec2.length == 4`
+*   <code>-10<sup>9</sup> <= rec1[i], rec2[i] <= 10<sup>9</sup></code>
+*   `rec1` and `rec2` represent a valid rectangle with a non-zero area.

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

@@ -0,0 +1,28 @@
+package g0801_0900.s0837_new_21_game
+
+// #Medium #Dynamic_Programming #Math #Sliding_Window #Probability_and_Statistics
+// #2023_03_27_Time_144_ms_(75.00%)_Space_35.2_MB_(25.00%)
+
+class Solution {
+    fun new21Game(n: Int, k: Int, maxPts: Int): Double {
+        if (k == 0) return 1.00
+        if (k == 1 && maxPts <= n) return 1.00
+        val dp = DoubleArray(n + 1)
+        dp[0] = 1.00
+        var prev = 0.00
+        for (i in 1..n) {
+            if (i - maxPts - 1 >= 0) {
+                prev -= dp[i - 1 - maxPts]
+            }
+            if (i - 1 < k) {
+                prev += dp[i - 1]
+            }
+            dp[i] = prev / maxPts
+        }
+        var res = 0.00
+        for (i in k..n) {
+            res += dp[i]
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,40 @@
+837\. New 21 Game
+
+Medium
+
+Alice plays the following game, loosely based on the card game **"21"**.
+
+Alice starts with `0` points and draws numbers while she has less than `k` points. During each draw, she gains an integer number of points randomly from the range `[1, maxPts]`, where `maxPts` is an integer. Each draw is independent and the outcomes have equal probabilities.
+
+Alice stops drawing numbers when she gets `k` **or more points**.
+
+Return the probability that Alice has `n` or fewer points.
+
+Answers within <code>10<sup>-5</sup></code> of the actual answer are considered accepted.
+
+**Example 1:**
+
+**Input:** n = 10, k = 1, maxPts = 10
+
+**Output:** 1.00000
+
+**Explanation:** Alice gets a single card, then stops.
+
+**Example 2:**
+
+**Input:** n = 6, k = 1, maxPts = 10
+
+**Output:** 0.60000
+
+**Explanation:** Alice gets a single card, then stops. In 6 out of 10 possibilities, she is at or below 6 points.
+
+**Example 3:**
+
+**Input:** n = 21, k = 17, maxPts = 10
+
+**Output:** 0.73278
+
+**Constraints:**
+
+*   <code>0 <= k <= n <= 10<sup>4</sup></code>
+*   <code>1 <= maxPts <= 10<sup>4</sup></code>

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

@@ -0,0 +1,31 @@
+package g0801_0900.s0834_sum_of_distances_in_tree
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun sumOfDistancesInTree() {
+        assertThat(
+            Solution()
+                .sumOfDistancesInTree(
+                    6, arrayOf(intArrayOf(0, 1), intArrayOf(0, 2), intArrayOf(2, 3), intArrayOf(2, 4), intArrayOf(2, 5))
+                ),
+            equalTo(intArrayOf(8, 12, 6, 10, 10, 10))
+        )
+    }
+
+    @Test
+    fun sumOfDistancesInTree2() {
+        assertThat(Solution().sumOfDistancesInTree(1, arrayOf()), equalTo(intArrayOf(0)))
+    }
+
+    @Test
+    fun sumOfDistancesInTree3() {
+        assertThat(
+            Solution().sumOfDistancesInTree(2, arrayOf(intArrayOf(1, 0))),
+            equalTo(intArrayOf(1, 1))
+        )
+    }
+}

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

@@ -0,0 +1,29 @@
+package g0801_0900.s0835_image_overlap
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun largestOverlap() {
+        assertThat(
+            Solution()
+                .largestOverlap(
+                    arrayOf(intArrayOf(1, 1, 0), intArrayOf(0, 1, 0), intArrayOf(0, 1, 0)),
+                    arrayOf(intArrayOf(0, 0, 0), intArrayOf(0, 1, 1), intArrayOf(0, 0, 1))
+                ),
+            equalTo(3)
+        )
+    }
+
+    @Test
+    fun largestOverlap2() {
+        assertThat(Solution().largestOverlap(arrayOf(intArrayOf(1)), arrayOf(intArrayOf(1))), equalTo(1))
+    }
+
+    @Test
+    fun largestOverlap3() {
+        assertThat(Solution().largestOverlap(arrayOf(intArrayOf(0)), arrayOf(intArrayOf(0))), equalTo(0))
+    }
+}