Added tasks 814, 815, 816, 817

Author: ThanhNIT

README.md

@@ -379,6 +379,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0210 |[Course Schedule II](src.save/main/kotlin/g0201_0300/s0210_course_schedule_ii/Solution.kt)| Medium | Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort | 266 | 96.32
+| 0815 |[Bus Routes](src/main/kotlin/g0801_0900/s0815_bus_routes/Solution.kt)| Hard | Array, Hash_Table, Breadth_First_Search | 429 | 100.00
 
 #### Day 12 Dynamic Programming
 
@@ -1711,6 +1712,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
+| 0817 |[Linked List Components](src/main/kotlin/g0801_0900/s0817_linked_list_components/Solution.kt)| Medium | Hash_Table, Linked_List | 239 | 100.00
+| 0816 |[Ambiguous Coordinates](src/main/kotlin/g0801_0900/s0816_ambiguous_coordinates/Solution.kt)| Medium | String, Backtracking | 231 | 100.00
+| 0815 |[Bus Routes](src/main/kotlin/g0801_0900/s0815_bus_routes/Solution.kt)| Hard | Array, Hash_Table, Breadth_First_Search, Level_2_Day_11_Graph/BFS/DFS | 429 | 100.00
+| 0814 |[Binary Tree Pruning](src/main/kotlin/g0801_0900/s0814_binary_tree_pruning/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree | 127 | 100.00
 | 0813 |[Largest Sum of Averages](src/main/kotlin/g0801_0900/s0813_largest_sum_of_averages/Solution.kt)| Medium | Array, Dynamic_Programming | 160 | 100.00
 | 0812 |[Largest Triangle Area](src/main/kotlin/g0801_0900/s0812_largest_triangle_area/Solution.kt)| Easy | Array, Math, Geometry | 156 | 71.43
 | 0811 |[Subdomain Visit Count](src/main/kotlin/g0801_0900/s0811_subdomain_visit_count/Solution.kt)| Medium | Array, String, Hash_Table, Counting | 220 | 100.00

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

@@ -0,0 +1,29 @@
+package g0801_0900.s0814_binary_tree_pruning
+
+// #Medium #Depth_First_Search #Tree #Binary_Tree
+// #2023_03_22_Time_127_ms_(100.00%)_Space_34.3_MB_(11.11%)
+
+import com_github_leetcode.TreeNode
+
+/**
+ * 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 {
+    fun pruneTree(root: TreeNode?): TreeNode? {
+        if (root == null) {
+            return root
+        }
+        root.left = pruneTree(root.left)
+        root.right = pruneTree(root.right)
+        return if (root.left == null && root.right == null && root.`val` == 0) {
+            null
+        } else root
+    }
+}

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

@@ -0,0 +1,42 @@
+814\. Binary Tree Pruning
+
+Medium
+
+Given the `root` of a binary tree, return _the same tree where every subtree (of the given tree) not containing a_ `1` _has been removed_.
+
+A subtree of a node `node` is `node` plus every node that is a descendant of `node`.
+
+**Example 1:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_2.png)
+
+**Input:** root = [1,null,0,0,1]
+
+**Output:** [1,null,0,null,1]
+
+**Explanation:** 
+
+Only the red nodes satisfy the property "every subtree not containing a 1".
+
+The diagram on the right represents the answer.
+
+**Example 2:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_1.png)
+
+**Input:** root = [1,0,1,0,0,0,1]
+
+**Output:** [1,null,1,null,1]
+
+**Example 3:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/05/1028.png)
+
+**Input:** root = [1,1,0,1,1,0,1,0]
+
+**Output:** [1,1,0,1,1,null,1]
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 200]`.
+*   `Node.val` is either `0` or `1`.

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

@@ -0,0 +1,93 @@
+package g0801_0900.s0815_bus_routes
+
+// #Hard #Array #Hash_Table #Breadth_First_Search #Level_2_Day_11_Graph/BFS/DFS
+// #2023_03_22_Time_429_ms_(100.00%)_Space_55.8_MB_(100.00%)
+
+import java.util.Arrays
+import java.util.LinkedList
+import java.util.Queue
+import kotlin.collections.ArrayList
+import kotlin.collections.HashSet
+import kotlin.collections.MutableSet
+
+class Solution {
+    fun numBusesToDestination(routes: Array<IntArray>, source: Int, target: Int): Int {
+        if (source == target) {
+            return 0
+        }
+        val targetRoutes: MutableSet<Int> = HashSet()
+        val queue: Queue<Int> = LinkedList()
+        val taken = BooleanArray(routes.size)
+        val graph = buildGraph(routes, source, target, queue, targetRoutes, taken)
+        if (targetRoutes.isEmpty()) {
+            return -1
+        }
+        var bus = 1
+        while (!queue.isEmpty()) {
+            val size = queue.size
+            for (i in 0 until size) {
+                val route = queue.poll()
+                if (targetRoutes.contains(route)) {
+                    return bus
+                }
+                for (nextRoute in graph[route]!!) {
+                    if (!taken[nextRoute]) {
+                        queue.offer(nextRoute)
+                        taken[nextRoute] = true
+                    }
+                }
+            }
+            bus++
+        }
+        return -1
+    }
+
+    private fun buildGraph(
+        routes: Array<IntArray>,
+        source: Int,
+        target: Int,
+        queue: Queue<Int>,
+        targetRoutes: MutableSet<Int>,
+        taken: BooleanArray
+    ): Array<ArrayList<Int>?> {
+        val len = routes.size
+        val graph: Array<ArrayList<Int>?> = arrayOfNulls(len)
+        for (i in 0 until len) {
+            Arrays.sort(routes[i])
+            graph[i] = ArrayList()
+            var id = Arrays.binarySearch(routes[i], source)
+            if (id >= 0) {
+                queue.offer(i)
+                taken[i] = true
+            }
+            id = Arrays.binarySearch(routes[i], target)
+            if (id >= 0) {
+                targetRoutes.add(i)
+            }
+        }
+        for (i in 0 until len) {
+            for (j in i + 1 until len) {
+                if (commonStop(routes[i], routes[j])) {
+                    graph[i]?.add(j)
+                    graph[j]?.add(i)
+                }
+            }
+        }
+        return graph
+    }
+
+    private fun commonStop(routeA: IntArray, routeB: IntArray): Boolean {
+        var idA = 0
+        var idB = 0
+        while (idA < routeA.size && idB < routeB.size) {
+            if (routeA[idA] == routeB[idB]) {
+                return true
+            } else if (routeA[idA] < routeB[idB]) {
+                idA++
+            } else {
+                idB++
+            }
+        }
+        return false
+    }
+}

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

@@ -0,0 +1,34 @@
+815\. Bus Routes
+
+Hard
+
+You are given an array `routes` representing bus routes where `routes[i]` is a bus route that the <code>i<sup>th</sup></code> bus repeats forever.
+
+*   For example, if `routes[0] = [1, 5, 7]`, this means that the <code>0<sup>th</sup></code> bus travels in the sequence `1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 -> ...` forever.
+
+You will start at the bus stop `source` (You are not on any bus initially), and you want to go to the bus stop `target`. You can travel between bus stops by buses only.
+
+Return _the least number of buses you must take to travel from_ `source` _to_ `target`. Return `-1` if it is not possible.
+
+**Example 1:**
+
+**Input:** routes = [[1,2,7],[3,6,7]], source = 1, target = 6
+
+**Output:** 2
+
+**Explanation:** The best strategy is take the first bus to the bus stop 7, then take the second bus to the bus stop 6.
+
+**Example 2:**
+
+**Input:** routes = [[7,12],[4,5,15],[6],[15,19],[9,12,13]], source = 15, target = 12
+
+**Output:** -1
+
+**Constraints:**
+
+*   `1 <= routes.length <= 500`.
+*   <code>1 <= routes[i].length <= 10<sup>5</sup></code>
+*   All the values of `routes[i]` are **unique**.
+*   <code>sum(routes[i].length) <= 10<sup>5</sup></code>
+*   <code>0 <= routes[i][j] < 10<sup>6</sup></code>
+*   <code>0 <= source, target < 10<sup>6</sup></code>

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

@@ -0,0 +1,83 @@
+package g0801_0900.s0816_ambiguous_coordinates
+
+// #Medium #String #Backtracking #2023_03_22_Time_231_ms_(100.00%)_Space_36.2_MB_(100.00%)
+
+@Suppress("kotlin:S107")
+class Solution {
+    fun ambiguousCoordinates(s: String): List<String> {
+        val sc = s.toCharArray()
+        val result: MutableList<String> = ArrayList()
+        val sb = StringBuilder()
+        for (commaPos in 2 until sc.size - 1) {
+            if (isValidNum(sc, 1, commaPos - 1)) {
+                if (isValidNum(sc, commaPos, sc.size - 2)) {
+                    buildNumbs(result, sb, sc, commaPos - 1, 0, commaPos, sc.size - 2, 0)
+                }
+                for (dp2Idx in commaPos + 1 until sc.size - 1) {
+                    if (isValidDPNum(sc, commaPos, sc.size - 2, dp2Idx)) {
+                        buildNumbs(result, sb, sc, commaPos - 1, 0, commaPos, sc.size - 2, dp2Idx)
+                    }
+                }
+            }
+            for (dp1Idx in 2 until commaPos) {
+                if (isValidDPNum(sc, 1, commaPos - 1, dp1Idx)) {
+                    if (isValidNum(sc, commaPos, sc.size - 2)) {
+                        buildNumbs(result, sb, sc, commaPos - 1, dp1Idx, commaPos, sc.size - 2, 0)
+                    }
+                    for (dp2Idx in commaPos + 1 until sc.size - 1) {
+                        if (isValidDPNum(sc, commaPos, sc.size - 2, dp2Idx)) {
+                            buildNumbs(
+                                result,
+                                sb,
+                                sc,
+                                commaPos - 1,
+                                dp1Idx,
+                                commaPos,
+                                sc.size - 2,
+                                dp2Idx
+                            )
+                        }
+                    }
+                }
+            }
+        }
+        return result
+    }
+
+    private fun isValidNum(sc: CharArray, startIdx: Int, lastIdx: Int): Boolean {
+        return sc[startIdx] != '0' || lastIdx - startIdx == 0
+    }
+
+    private fun isValidDPNum(sc: CharArray, startIdx: Int, lastIdx: Int, dpIdx: Int): Boolean {
+        return (sc[startIdx] != '0' || dpIdx - startIdx == 1) && sc[lastIdx] != '0'
+    }
+
+    private fun buildNumbs(
+        result: MutableList<String>,
+        sb: StringBuilder,
+        sc: CharArray,
+        last1Idx: Int,
+        dp1Idx: Int,
+        start2Idx: Int,
+        last2Idx: Int,
+        dp2Idx: Int
+    ) {
+        sb.setLength(0)
+        sb.append('(')
+        if (dp1Idx == 0) {
+            sb.append(sc, 1, last1Idx - 1 + 1)
+        } else {
+            sb.append(sc, 1, dp1Idx - 1).append('.').append(sc, dp1Idx, last1Idx - dp1Idx + 1)
+        }
+        sb.append(',').append(' ')
+        if (dp2Idx == 0) {
+            sb.append(sc, start2Idx, last2Idx - start2Idx + 1)
+        } else {
+            sb.append(sc, start2Idx, dp2Idx - start2Idx)
+                .append('.')
+                .append(sc, dp2Idx, last2Idx - dp2Idx + 1)
+        }
+        sb.append(')')
+        result.add(sb.toString())
+    }
+}

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

@@ -0,0 +1,39 @@
+816\. Ambiguous Coordinates
+
+Medium
+
+We had some 2-dimensional coordinates, like `"(1, 3)"` or `"(2, 0.5)"`. Then, we removed all commas, decimal points, and spaces and ended up with the string s.
+
+*   For example, `"(1, 3)"` becomes `s = "(13)"` and `"(2, 0.5)"` becomes `s = "(205)"`.
+
+Return _a list of strings representing all possibilities for what our original coordinates could have been_.
+
+Our original representation never had extraneous zeroes, so we never started with numbers like `"00"`, `"0.0"`, `"0.00"`, `"1.0"`, `"001"`, `"00.01"`, or any other number that can be represented with fewer digits. Also, a decimal point within a number never occurs without at least one digit occurring before it, so we never started with numbers like `".1"`.
+
+The final answer list can be returned in any order. All coordinates in the final answer have exactly one space between them (occurring after the comma.)
+
+**Example 1:**
+
+**Input:** s = "(123)"
+
+**Output:** ["(1, 2.3)","(1, 23)","(1.2, 3)","(12, 3)"]
+
+**Example 2:**
+
+**Input:** s = "(0123)"
+
+**Output:** ["(0, 1.23)","(0, 12.3)","(0, 123)","(0.1, 2.3)","(0.1, 23)","(0.12, 3)"]
+
+**Explanation:** 0.0, 00, 0001 or 00.01 are not allowed.
+
+**Example 3:**
+
+**Input:** s = "(00011)"
+
+**Output:** ["(0, 0.011)","(0.001, 1)"]
+
+**Constraints:**
+
+*   `4 <= s.length <= 12`
+*   `s[0] == '('` and `s[s.length - 1] == ')'`.
+*   The rest of `s` are digits.

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

@@ -0,0 +1,38 @@
+package g0801_0900.s0817_linked_list_components
+
+// #Medium #Hash_Table #Linked_List #2023_03_22_Time_239_ms_(100.00%)_Space_39.8_MB_(66.67%)
+
+import com_github_leetcode.ListNode
+
+/**
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun numComponents(head: ListNode?, nums: IntArray): Int {
+        var head = head
+        val set: HashSet<Int> = HashSet()
+        for (i in nums) {
+            set.add(i)
+        }
+        var result = 0
+        while (head != null) {
+            if (set.contains(head.`val`)) {
+                while (head != null && set.contains(head.`val`)) {
+                    head = head.next
+                }
+                result++
+            } else {
+                head = head.next
+            }
+        }
+        return result
+    }
+}