Added tasks 1033, 1034, 1035, 1036

Author: ThanhNIT

README.md

@@ -1750,6 +1750,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
 | 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
+| 1036 |[Escape a Large Maze](src/main/kotlin/g1001_1100/s1036_escape_a_large_maze/Solution.kt)| Hard | Array, Hash_Table, Depth_First_Search, Breadth_First_Search | 387 | 100.00
+| 1035 |[Uncrossed Lines](src/main/kotlin/g1001_1100/s1035_uncrossed_lines/Solution.kt)| Medium | Array, Dynamic_Programming | 162 | 93.33
+| 1034 |[Coloring A Border](src/main/kotlin/g1001_1100/s1034_coloring_a_border/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 332 | 100.00
+| 1033 |[Moving Stones Until Consecutive](src/main/kotlin/g1001_1100/s1033_moving_stones_until_consecutive/Solution.kt)| Medium | Math, Brainteaser | 139 | 100.00
 | 1032 |[Stream of Characters](src/main/kotlin/g1001_1100/s1032_stream_of_characters/StreamChecker.kt)| Hard | Array, String, Design, Trie, Data_Stream | 733 | 100.00
 | 1031 |[Maximum Sum of Two Non-Overlapping Subarrays](src/main/kotlin/g1001_1100/s1031_maximum_sum_of_two_non_overlapping_subarrays/Solution.kt)| Medium | Array, Dynamic_Programming, Sliding_Window | 172 | 100.00
 | 1030 |[Matrix Cells in Distance Order](src/main/kotlin/g1001_1100/s1030_matrix_cells_in_distance_order/Solution.kt)| Easy | Array, Math, Sorting, Matrix, Geometry | 426 | 100.00

src/main/kotlin/g1001_1100/s1033_moving_stones_until_consecutive/Solution.kt

@@ -0,0 +1,26 @@
+package g1001_1100.s1033_moving_stones_until_consecutive
+
+// #Medium #Math #Brainteaser #2023_05_25_Time_139_ms_(100.00%)_Space_35.3_MB_(100.00%)
+
+class Solution {
+    private fun minMoves(x: Int, y: Int, z: Int): Int {
+        if (x + 1 == y && y + 1 == z) {
+            return 0
+        }
+        return if (y - x <= 2 || z - y <= 2) {
+            1
+        } else 2
+    }
+
+    private fun maxMoves(x: Int, z: Int): Int {
+        return z - x - 2
+    }
+
+    fun numMovesStones(a: Int, b: Int, c: Int): IntArray {
+        val t = intArrayOf(a, b, c)
+        t.sort()
+        val min = minMoves(t[0], t[1], t[2])
+        val max = maxMoves(t[0], t[2])
+        return intArrayOf(min, max)
+    }
+}

src/main/kotlin/g1001_1100/s1033_moving_stones_until_consecutive/readme.md

@@ -0,0 +1,43 @@
+1033\. Moving Stones Until Consecutive
+
+Medium
+
+There are three stones in different positions on the X-axis. You are given three integers `a`, `b`, and `c`, the positions of the stones.
+
+In one move, you pick up a stone at an endpoint (i.e., either the lowest or highest position stone), and move it to an unoccupied position between those endpoints. Formally, let's say the stones are currently at positions `x`, `y`, and `z` with `x < y < z`. You pick up the stone at either position `x` or position `z`, and move that stone to an integer position `k`, with `x < k < z` and `k != y`.
+
+The game ends when you cannot make any more moves (i.e., the stones are in three consecutive positions).
+
+Return _an integer array_ `answer` _of length_ `2` _where_:
+
+*   `answer[0]` _is the minimum number of moves you can play, and_
+*   `answer[1]` _is the maximum number of moves you can play_.
+
+**Example 1:**
+
+**Input:** a = 1, b = 2, c = 5
+
+**Output:** [1,2]
+
+**Explanation:** Move the stone from 5 to 3, or move the stone from 5 to 4 to 3.
+
+**Example 2:**
+
+**Input:** a = 4, b = 3, c = 2
+
+**Output:** [0,0]
+
+**Explanation:** We cannot make any moves.
+
+**Example 3:**
+
+**Input:** a = 3, b = 5, c = 1
+
+**Output:** [1,2]
+
+**Explanation:** Move the stone from 1 to 4; or move the stone from 1 to 2 to 4.
+
+**Constraints:**
+
+*   `1 <= a, b, c <= 100`
+*   `a`, `b`, and `c` have different values.

src/main/kotlin/g1001_1100/s1034_coloring_a_border/Solution.kt

@@ -0,0 +1,39 @@
+package g1001_1100.s1034_coloring_a_border
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix
+// #2023_05_25_Time_332_ms_(100.00%)_Space_63.2_MB_(100.00%)
+
+import kotlin.math.abs
+
+class Solution {
+    fun colorBorder(grid: Array<IntArray>, row: Int, col: Int, color: Int): Array<IntArray> {
+        getComp(grid, row, col, color, grid[row][col])
+        for (i in grid.indices) {
+            for (j in grid[0].indices) {
+                if (grid[i][j] < 0) {
+                    grid[i][j] = color
+                }
+            }
+        }
+        return grid
+    }
+
+    private fun getComp(grid: Array<IntArray>, r: Int, c: Int, color: Int, stColor: Int): Int {
+        if (r < 0 || c < 0 || r >= grid.size || c >= grid[0].size || abs(grid[r][c]) != stColor) {
+            return 0
+        }
+        if (grid[r][c] == -stColor) {
+            return 1
+        }
+        grid[r][c] = -grid[r][c]
+        var count = 0
+        count += getComp(grid, r - 1, c, color, stColor)
+        count += getComp(grid, r + 1, c, color, stColor)
+        count += getComp(grid, r, c - 1, color, stColor)
+        count += getComp(grid, r, c + 1, color, stColor)
+        if (count == 4) {
+            grid[r][c] = -grid[r][c]
+        }
+        return 1
+    }
+}

src/main/kotlin/g1001_1100/s1034_coloring_a_border/readme.md

@@ -0,0 +1,40 @@
+1034\. Coloring A Border
+
+Medium
+
+You are given an `m x n` integer matrix `grid`, and three integers `row`, `col`, and `color`. Each value in the grid represents the color of the grid square at that location.
+
+Two squares belong to the same **connected component** if they have the same color and are next to each other in any of the 4 directions.
+
+The **border of a connected component** is all the squares in the connected component that are either **4-directionally** adjacent to a square not in the component, or on the boundary of the grid (the first or last row or column).
+
+You should color the **border** of the **connected component** that contains the square `grid[row][col]` with `color`.
+
+Return _the final grid_.
+
+**Example 1:**
+
+**Input:** grid = [[1,1],[1,2]], row = 0, col = 0, color = 3
+
+**Output:** [[3,3],[3,2]]
+
+**Example 2:**
+
+**Input:** grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3
+
+**Output:** [[1,3,3],[2,3,3]]
+
+**Example 3:**
+
+**Input:** grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2
+
+**Output:** [[2,2,2],[2,1,2],[2,2,2]]
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 50`
+*   `1 <= grid[i][j], color <= 1000`
+*   `0 <= row < m`
+*   `0 <= col < n`

src/main/kotlin/g1001_1100/s1035_uncrossed_lines/Solution.kt

@@ -0,0 +1,21 @@
+package g1001_1100.s1035_uncrossed_lines
+
+// #Medium #Array #Dynamic_Programming #2023_05_25_Time_162_ms_(93.33%)_Space_38.5_MB_(34.22%)
+
+class Solution {
+    fun maxUncrossedLines(nums1: IntArray, nums2: IntArray): Int {
+        var dp = IntArray(nums2.size + 1)
+        for (i in 1..nums1.size) {
+            val dpRow = IntArray(nums2.size + 1)
+            for (j in 1..nums2.size) {
+                if (nums1[i - 1] == nums2[j - 1]) {
+                    dpRow[j] = dp[j - 1] + 1
+                } else {
+                    dpRow[j] = dp[j].coerceAtLeast(dpRow[j - 1])
+                }
+            }
+            dp = dpRow
+        }
+        return dp[nums2.size]
+    }
+}

src/main/kotlin/g1001_1100/s1035_uncrossed_lines/readme.md

@@ -0,0 +1,41 @@
+1035\. Uncrossed Lines
+
+Medium
+
+You are given two integer arrays `nums1` and `nums2`. We write the integers of `nums1` and `nums2` (in the order they are given) on two separate horizontal lines.
+
+We may draw connecting lines: a straight line connecting two numbers `nums1[i]` and `nums2[j]` such that:
+
+*   `nums1[i] == nums2[j]`, and
+*   the line we draw does not intersect any other connecting (non-horizontal) line.
+
+Note that a connecting line cannot intersect even at the endpoints (i.e., each number can only belong to one connecting line).
+
+Return _the maximum number of connecting lines we can draw in this way_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/04/26/142.png)
+
+**Input:** nums1 = [1,4,2], nums2 = [1,2,4]
+
+**Output:** 2
+
+**Explanation:** We can draw 2 uncrossed lines as in the diagram. We cannot draw 3 uncrossed lines, because the line from nums1[1] = 4 to nums2[2] = 4 will intersect the line from nums1[2]=2 to nums2[1]=2.
+
+**Example 2:**
+
+**Input:** nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
+
+**Output:** 3
+
+**Example 3:**
+
+**Input:** nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
+
+**Output:** 2
+
+**Constraints:**
+
+*   `1 <= nums1.length, nums2.length <= 500`
+*   `1 <= nums1[i], nums2[j] <= 2000`

src/main/kotlin/g1001_1100/s1036_escape_a_large_maze/Solution.kt

@@ -0,0 +1,47 @@
+package g1001_1100.s1036_escape_a_large_maze
+
+// #Hard #Array #Hash_Table #Depth_First_Search #Breadth_First_Search
+// #2023_05_25_Time_387_ms_(100.00%)_Space_94.1_MB_(100.00%)
+
+class Solution {
+    fun isEscapePossible(blocked: Array<IntArray>, source: IntArray, target: IntArray): Boolean {
+        if (blocked.isEmpty()) {
+            return true
+        }
+        val blocks: MutableSet<Int> = HashSet()
+        for (b in blocked) {
+            if (target[0] * 1000000 + target[1] != b[0] * 1000000 + b[1]) {
+                blocks.add(b[0] * 1000000 + b[1])
+            }
+        }
+        return (
+            dfs(blocks, source, source[0], source[1], HashSet(), target) &&
+                dfs(blocks, target, target[0], target[1], HashSet(), source)
+            )
+    }
+
+    private fun dfs(
+        blocks: Set<Int>,
+        start: IntArray,
+        i: Int,
+        j: Int,
+        visited: MutableSet<Int>,
+        target: IntArray
+    ): Boolean {
+        if (i < 0 || j < 0 || i > 999999 || j > 999999 || blocks.contains(i * 1000000 + j) ||
+            visited.contains(i * 1000000 + j)
+        ) {
+            return false
+        }
+        if (i == target[0] && j == target[1]) {
+            return true
+        }
+        visited.add(i * 1000000 + j)
+        return if (visited.size > blocks.size * (blocks.size + 1)) {
+            true
+        } else dfs(blocks, start, i + 1, j, visited, target) ||
+            dfs(blocks, start, i - 1, j, visited, target) ||
+            dfs(blocks, start, i, j + 1, visited, target) ||
+            dfs(blocks, start, i, j - 1, visited, target)
+    }
+}

src/main/kotlin/g1001_1100/s1036_escape_a_large_maze/readme.md

@@ -0,0 +1,41 @@
+1036\. Escape a Large Maze
+
+Hard
+
+There is a 1 million by 1 million grid on an XY-plane, and the coordinates of each grid square are `(x, y)`.
+
+We start at the <code>source = [s<sub>x</sub>, s<sub>y</sub>]</code> square and want to reach the <code>target = [t<sub>x</sub>, t<sub>y</sub>]</code> square. There is also an array of `blocked` squares, where each <code>blocked[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a blocked square with coordinates <code>(x<sub>i</sub>, y<sub>i</sub>)</code>.
+
+Each move, we can walk one square north, east, south, or west if the square is **not** in the array of `blocked` squares. We are also not allowed to walk outside of the grid.
+
+Return `true` _if and only if it is possible to reach the_ `target` _square from the_ `source` _square through a sequence of valid moves_.
+
+**Example 1:**
+
+**Input:** blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
+
+**Output:** false
+
+**Explanation:** The target square is inaccessible starting from the source square because we cannot move. 
+
+We cannot move north or east because those squares are blocked. 
+
+We cannot move south or west because we cannot go outside of the grid.
+
+**Example 2:**
+
+**Input:** blocked = [], source = [0,0], target = [999999,999999]
+
+**Output:** true
+
+**Explanation:** Because there are no blocked cells, it is possible to reach the target square.
+
+**Constraints:**
+
+*   `0 <= blocked.length <= 200`
+*   `blocked[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> < 10<sup>6</sup></code>
+*   `source.length == target.length == 2`
+*   <code>0 <= s<sub>x</sub>, s<sub>y</sub>, t<sub>x</sub>, t<sub>y</sub> < 10<sup>6</sup></code>
+*   `source != target`
+*   It is guaranteed that `source` and `target` are not blocked.

src/test/kotlin/g1001_1100/s1033_moving_stones_until_consecutive/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g1001_1100.s1033_moving_stones_until_consecutive
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun numMovesStones() {
+        assertThat(Solution().numMovesStones(1, 2, 5), equalTo(intArrayOf(1, 2)))
+    }
+
+    @Test
+    fun numMovesStones2() {
+        assertThat(Solution().numMovesStones(4, 3, 2), equalTo(intArrayOf(0, 0)))
+    }
+
+    @Test
+    fun numMovesStones3() {
+        assertThat(Solution().numMovesStones(3, 5, 1), equalTo(intArrayOf(1, 2)))
+    }
+}