Added tasks 572, 575, 576, 581

Author: ThanhNIT

README.md

@@ -1219,6 +1219,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0117 |[Populating Next Right Pointers in Each Node II](src/main/kotlin/g0101_0200/s0117_populating_next_right_pointers_in_each_node_ii/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Linked_List | 199 | 94.67
+| 0572 |[Subtree of Another Tree](src/main/kotlin/g0501_0600/s0572_subtree_of_another_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Hash_Function, String_Matching | 214 | 92.39
 
 #### Day 8 Breadth First Search Depth First Search
 
@@ -1658,6 +1659,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
+| 0581 |[Shortest Unsorted Continuous Subarray](src/main/kotlin/g0501_0600/s0581_shortest_unsorted_continuous_subarray/Solution.kt)| Medium | Array, Sorting, Greedy, Two_Pointers, Stack, Monotonic_Stack | 246 | 100.00
+| 0576 |[Out of Boundary Paths](src/main/kotlin/g0501_0600/s0576_out_of_boundary_paths/Solution.kt)| Medium | Dynamic_Programming | 153 | 100.00
+| 0575 |[Distribute Candies](src/main/kotlin/g0501_0600/s0575_distribute_candies/Solution.kt)| Easy | Array, Hash_Table | 538 | 76.92
+| 0572 |[Subtree of Another Tree](src/main/kotlin/g0501_0600/s0572_subtree_of_another_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Hash_Function, String_Matching, Algorithm_II_Day_7_Breadth_First_Search_Depth_First_Search | 214 | 92.39
 | 0567 |[Permutation in String](src/main/kotlin/g0501_0600/s0567_permutation_in_string/Solution.kt)| Medium | String, Hash_Table, Two_Pointers, Sliding_Window, Algorithm_I_Day_6_Sliding_Window | 169 | 100.00
 | 0566 |[Reshape the Matrix](src/main/kotlin/g0501_0600/s0566_reshape_the_matrix/Solution.kt)| Easy | Array, Matrix, Simulation, Data_Structure_I_Day_4_Array, Programming_Skills_I_Day_7_Array | 239 | 99.05
 | 0565 |[Array Nesting](src/main/kotlin/g0501_0600/s0565_array_nesting/Solution.kt)| Medium | Array, Depth_First_Search | 553 | 100.00

src/main/kotlin/g0501_0600/s0572_subtree_of_another_tree/Solution.kt

@@ -0,0 +1,44 @@
+package g0501_0600.s0572_subtree_of_another_tree
+
+import com_github_leetcode.TreeNode
+
+// #Easy #Depth_First_Search #Tree #Binary_Tree #Hash_Function #String_Matching
+// #Algorithm_II_Day_7_Breadth_First_Search_Depth_First_Search
+// #2023_01_23_Time_214_ms_(92.39%)_Space_38.4_MB_(45.65%)
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private fun isSubtreeFound(root: TreeNode?, subRoot: TreeNode?): Boolean {
+        if (root == null && subRoot == null) {
+            return true
+        }
+        if (root == null || subRoot == null) {
+            return false
+        }
+        return if (root.`val` === subRoot.`val`) {
+            isSubtreeFound(root.left, subRoot.left) && isSubtree(root.right, subRoot.right)
+        } else {
+            false
+        }
+    }
+
+    fun isSubtree(root: TreeNode?, subRoot: TreeNode?): Boolean {
+        if (root == null && subRoot == null) {
+            return true
+        }
+        return if (root == null || subRoot == null) {
+            false
+        } else isSubtreeFound(root, subRoot) ||
+            isSubtree(root.left, subRoot) ||
+            isSubtree(root.right, subRoot)
+    }
+}

src/main/kotlin/g0501_0600/s0572_subtree_of_another_tree/readme.md

@@ -0,0 +1,30 @@
+572\. Subtree of Another Tree
+
+Easy
+
+Given the roots of two binary trees `root` and `subRoot`, return `true` if there is a subtree of `root` with the same structure and node values of `subRoot` and `false` otherwise.
+
+A subtree of a binary tree `tree` is a tree that consists of a node in `tree` and all of this node's descendants. The tree `tree` could also be considered as a subtree of itself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/28/subtree1-tree.jpg)
+
+**Input:** root = [3,4,5,1,2], subRoot = [4,1,2]
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/28/subtree2-tree.jpg)
+
+**Input:** root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
+
+**Output:** false
+
+**Constraints:**
+
+*   The number of nodes in the `root` tree is in the range `[1, 2000]`.
+*   The number of nodes in the `subRoot` tree is in the range `[1, 1000]`.
+*   <code>-10<sup>4</sup> <= root.val <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= subRoot.val <= 10<sup>4</sup></code>

src/main/kotlin/g0501_0600/s0575_distribute_candies/Solution.kt

@@ -0,0 +1,20 @@
+package g0501_0600.s0575_distribute_candies
+
+// #Easy #Array #Hash_Table #2023_01_23_Time_538_ms_(76.92%)_Space_47.3_MB_(69.23%)
+
+internal class Solution {
+    fun distributeCandies(candyType: IntArray): Int {
+        val s: MutableSet<Int> = HashSet()
+        for (i in candyType) {
+            if (!s.contains(i)) {
+                s.add(i)
+            }
+        }
+        val canEat = candyType.size / 2
+        return if (s.size >= canEat) {
+            canEat
+        } else {
+            s.size
+        }
+    }
+}

src/main/kotlin/g0501_0600/s0575_distribute_candies/readme.md

@@ -0,0 +1,40 @@
+575\. Distribute Candies
+
+Easy
+
+Alice has `n` candies, where the <code>i<sup>th</sup></code> candy is of type `candyType[i]`. Alice noticed that she started to gain weight, so she visited a doctor.
+
+The doctor advised Alice to only eat `n / 2` of the candies she has (`n` is always even). Alice likes her candies very much, and she wants to eat the maximum number of different types of candies while still following the doctor's advice.
+
+Given the integer array `candyType` of length `n`, return _the **maximum** number of different types of candies she can eat if she only eats_ `n / 2` _of them_.
+
+**Example 1:**
+
+**Input:** candyType = [1,1,2,2,3,3]
+
+**Output:** 3
+
+**Explanation:** Alice can only eat 6 / 2 = 3 candies. Since there are only 3 types, she can eat one of each type.
+
+**Example 2:**
+
+**Input:** candyType = [1,1,2,3]
+
+**Output:** 2
+
+**Explanation:** Alice can only eat 4 / 2 = 2 candies. Whether she eats types [1,2], [1,3], or [2,3], she still can only eat 2 different types.
+
+**Example 3:**
+
+**Input:** candyType = [6,6,6,6]
+
+**Output:** 1
+
+**Explanation:** Alice can only eat 4 / 2 = 2 candies. Even though she can eat 2 candies, she only has 1 type.
+
+**Constraints:**
+
+*   `n == candyType.length`
+*   <code>2 <= n <= 10<sup>4</sup></code>
+*   `n` is even.
+*   <code>-10<sup>5</sup> <= candyType[i] <= 10<sup>5</sup></code>

src/main/kotlin/g0501_0600/s0576_out_of_boundary_paths/Solution.kt

@@ -0,0 +1,51 @@
+package g0501_0600.s0576_out_of_boundary_paths
+
+// #Medium #Dynamic_Programming #2023_01_23_Time_153_ms_(100.00%)_Space_34.7_MB_(80.00%)
+
+import java.util.Arrays
+
+class Solution {
+    private val dRowCol = arrayOf(intArrayOf(1, 0), intArrayOf(-1, 0), intArrayOf(0, 1), intArrayOf(0, -1))
+    private fun dfs(
+        m: Int,
+        n: Int,
+        remainingMoves: Int,
+        currRow: Int,
+        currCol: Int,
+        cache: Array<Array<IntArray>>
+    ): Int {
+        if (currRow < 0 || currRow == m || currCol < 0 || currCol == n) {
+            return 1
+        }
+        if (remainingMoves == 0) {
+            return 0
+        }
+        if (cache[currRow][currCol][remainingMoves] == -1) {
+            var paths = 0
+            for (i in 0..3) {
+                val newRow = currRow + dRowCol[i][0]
+                val newCol = currCol + dRowCol[i][1]
+                val m1 = 1000000007
+                paths = (paths + dfs(m, n, remainingMoves - 1, newRow, newCol, cache)) % m1
+            }
+            cache[currRow][currCol][remainingMoves] = paths
+        }
+        return cache[currRow][currCol][remainingMoves]
+    }
+
+    fun findPaths(m: Int, n: Int, maxMoves: Int, startRow: Int, startCol: Int): Int {
+        val cache = Array(m) {
+            Array(n) {
+                IntArray(
+                    maxMoves + 1
+                )
+            }
+        }
+        for (c1 in cache) {
+            for (c2 in c1) {
+                Arrays.fill(c2, -1)
+            }
+        }
+        return dfs(m, n, maxMoves, startRow, startCol, cache)
+    }
+}

src/main/kotlin/g0501_0600/s0576_out_of_boundary_paths/readme.md

@@ -0,0 +1,30 @@
+576\. Out of Boundary Paths
+
+Medium
+
+There is an `m x n` grid with a ball. The ball is initially at the position `[startRow, startColumn]`. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply **at most** `maxMove` moves to the ball.
+
+Given the five integers `m`, `n`, `maxMove`, `startRow`, `startColumn`, return the number of paths to move the ball out of the grid boundary. Since the answer can be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/28/out_of_boundary_paths_1.png)
+
+**Input:** m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0
+
+**Output:** 6
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/28/out_of_boundary_paths_2.png)
+
+**Input:** m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1
+
+**Output:** 12
+
+**Constraints:**
+
+*   `1 <= m, n <= 50`
+*   `0 <= maxMove <= 50`
+*   `0 <= startRow < m`
+*   `0 <= startColumn < n`

src/main/kotlin/g0501_0600/s0581_shortest_unsorted_continuous_subarray/Solution.kt

@@ -0,0 +1,26 @@
+package g0501_0600.s0581_shortest_unsorted_continuous_subarray
+
+// #Medium #Array #Sorting #Greedy #Two_Pointers #Stack #Monotonic_Stack
+// #2023_01_30_Time_246_ms_(100.00%)_Space_39.4_MB_(50.00%)
+
+class Solution {
+    fun findUnsortedSubarray(nums: IntArray): Int {
+        var end = -2
+        var max = Int.MIN_VALUE
+        for (i in nums.indices) {
+            max = Math.max(max, nums[i])
+            if (nums[i] < max) {
+                end = i
+            }
+        }
+        var start = -1
+        var min = Int.MAX_VALUE
+        for (i in nums.indices.reversed()) {
+            min = Math.min(min, nums[i])
+            if (nums[i] > min) {
+                start = i
+            }
+        }
+        return end - start + 1
+    }
+}

src/main/kotlin/g0501_0600/s0581_shortest_unsorted_continuous_subarray/readme.md

@@ -0,0 +1,34 @@
+581\. Shortest Unsorted Continuous Subarray
+
+Medium
+
+Given an integer array `nums`, you need to find one **continuous subarray** that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order.
+
+Return _the shortest such subarray and output its length_.
+
+**Example 1:**
+
+**Input:** nums = [2,6,4,8,10,9,15]
+
+**Output:** 5
+
+**Explanation:** You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** 0
+
+**Example 3:**
+
+**Input:** nums = [1]
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+
+**Follow up:** Can you solve it in `O(n)` time complexity?

src/test/kotlin/g0501_0600/s0572_subtree_of_another_tree/SolutionTest.kt

@@ -0,0 +1,24 @@
+package g0501_0600.s0572_subtree_of_another_tree
+
+import com_github_leetcode.TreeNode
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isSubtree() {
+        val treeNode: TreeNode = TreeNode.create(listOf(3, 4, 5, 1, 2))!!
+        val subTree: TreeNode = TreeNode.create(listOf(4, 1, 2))!!
+        assertThat(Solution().isSubtree(treeNode, subTree), equalTo(true))
+    }
+
+    @Test
+    fun isSubtree2() {
+        val treeNode: TreeNode = TreeNode.create(
+            listOf(3, 4, 5, 1, 2, null, null, null, null, 0)
+        )!!
+        val subTree: TreeNode = TreeNode.create(listOf(4, 1, 2))!!
+        assertThat(Solution().isSubtree(treeNode, subTree), equalTo(false))
+    }
+}

src/test/kotlin/g0501_0600/s0575_distribute_candies/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0501_0600.s0575_distribute_candies
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun distributeCandies() {
+        assertThat(Solution().distributeCandies(intArrayOf(1, 1, 2, 2, 3, 3)), equalTo(3))
+    }
+
+    @Test
+    fun distributeCandies2() {
+        assertThat(Solution().distributeCandies(intArrayOf(1, 1, 2, 3)), equalTo(2))
+    }
+
+    @Test
+    fun distributeCandies3() {
+        assertThat(Solution().distributeCandies(intArrayOf(6, 6, 6, 6)), equalTo(1))
+    }
+}

src/test/kotlin/g0501_0600/s0576_out_of_boundary_paths/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0501_0600.s0576_out_of_boundary_paths
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findPaths() {
+        assertThat(Solution().findPaths(2, 2, 2, 0, 0), equalTo(6))
+    }
+
+    @Test
+    fun findPaths2() {
+        assertThat(Solution().findPaths(1, 3, 3, 0, 1), equalTo(12))
+    }
+}

src/test/kotlin/g0501_0600/s0581_shortest_unsorted_continuous_subarray/SolutionTest.kt

@@ -0,0 +1,24 @@
+package g0501_0600.s0581_shortest_unsorted_continuous_subarray
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findUnsortedSubarray() {
+        assertThat(
+            Solution().findUnsortedSubarray(intArrayOf(2, 6, 4, 8, 10, 9, 15)), equalTo(5)
+        )
+    }
+
+    @Test
+    fun findUnsortedSubarray2() {
+        assertThat(Solution().findUnsortedSubarray(intArrayOf(1, 2, 3, 4)), equalTo(0))
+    }
+
+    @Test
+    fun findUnsortedSubarray3() {
+        assertThat(Solution().findUnsortedSubarray(intArrayOf(1)), equalTo(0))
+    }
+}