Added tasks 688, 689, 690, 691

Author: ThanhNIT

README.md

@@ -1676,6 +1676,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 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
 | 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
+| 0691 |[Stickers to Spell Word](src/main/kotlin/g0601_0700/s0691_stickers_to_spell_word/Solution.kt)| Hard | Array, String, Dynamic_Programming, Bit_Manipulation, Backtracking, Bitmask | 249 | 100.00
+| 0690 |[Employee Importance](src/main/kotlin/g0601_0700/s0690_employee_importance/Solution.kt)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search | 255 | 100.00
+| 0689 |[Knight Probability in Chessboard](src/main/kotlin/g0601_0700/s0689_maximum_sum_of_3_non_overlapping_subarrays/Solution.kt)| Hard | Array, Dynamic_Programming | 248 | 100.00
+| 0688 |[Knight Probability in Chessboard](src/main/kotlin/g0601_0700/s0688_knight_probability_in_chessboard/Solution.kt)| Medium | Dynamic_Programming | 144 | 100.00
 | 0687 |[Longest Univalue Path](src/main/kotlin/g0601_0700/s0687_longest_univalue_path/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree | 303 | 100.00
 | 0686 |[Repeated String Match](src/main/kotlin/g0601_0700/s0686_repeated_string_match/Solution.kt)| Medium | String, String_Matching | 164 | 100.00
 | 0685 |[Redundant Connection II](src/main/kotlin/g0601_0700/s0685_redundant_connection_ii/Solution.kt)| Hard | Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 176 | 100.00

src/main/kotlin/com_github_leetcode/Employee.kt

@@ -0,0 +1,10 @@
+package com_github_leetcode
+
+class Employee(
+    /** It's the unique id of each node; unique id of this employee  */
+    var id: Int,
+    /** the importance value of this employee  */
+    var importance: Int,
+    /** the id of direct subordinates  */
+    var subordinates: List<Int> = listOf()
+)

src/main/kotlin/g0601_0700/s0688_knight_probability_in_chessboard/Solution.kt

@@ -0,0 +1,48 @@
+package g0601_0700.s0688_knight_probability_in_chessboard
+
+// #Medium #Dynamic_Programming #2023_02_20_Time_144_ms_(100.00%)_Space_34.9_MB_(100.00%)
+
+class Solution {
+    private val directions = arrayOf(
+        intArrayOf(-2, -1),
+        intArrayOf(-2, 1),
+        intArrayOf(-1, 2),
+        intArrayOf(1, 2),
+        intArrayOf(2, -1),
+        intArrayOf(2, 1),
+        intArrayOf(1, -2),
+        intArrayOf(-1, -2)
+    )
+    private lateinit var probabilityGiven: Array<Array<DoubleArray>>
+    fun knightProbability(n: Int, k: Int, row: Int, column: Int): Double {
+        probabilityGiven = Array(n) {
+            Array(n) {
+                DoubleArray(
+                    k + 1
+                )
+            }
+        }
+        return probability(row, column, k, n)
+    }
+
+    private fun probability(row: Int, column: Int, k: Int, n: Int): Double {
+        return if (k == 0) {
+            1.0
+        } else if (probabilityGiven[row][column][k] != 0.0) {
+            probabilityGiven[row][column][k]
+        } else {
+            var p = 0.0
+            for (dir in directions) {
+                if (isValid(row + dir[0], column + dir[1], n)) {
+                    p += probability(row + dir[0], column + dir[1], k - 1, n)
+                }
+            }
+            probabilityGiven[row][column][k] = p / 8.0
+            probabilityGiven[row][column][k]
+        }
+    }
+
+    private fun isValid(row: Int, column: Int, n: Int): Boolean {
+        return row in 0 until n && column >= 0 && column < n
+    }
+}

src/main/kotlin/g0601_0700/s0688_knight_probability_in_chessboard/readme.md

@@ -0,0 +1,35 @@
+688\. Knight Probability in Chessboard
+
+Medium
+
+On an `n x n` chessboard, a knight starts at the cell `(row, column)` and attempts to make exactly `k` moves. The rows and columns are **0-indexed**, so the top-left cell is `(0, 0)`, and the bottom-right cell is `(n - 1, n - 1)`.
+
+A chess knight has eight possible moves it can make, as illustrated below. Each move is two cells in a cardinal direction, then one cell in an orthogonal direction.
+
+![](https://assets.leetcode.com/uploads/2018/10/12/knight.png)
+
+Each time the knight is to move, it chooses one of eight possible moves uniformly at random (even if the piece would go off the chessboard) and moves there.
+
+The knight continues moving until it has made exactly `k` moves or has moved off the chessboard.
+
+Return _the probability that the knight remains on the board after it has stopped moving_.
+
+**Example 1:**
+
+**Input:** n = 3, k = 2, row = 0, column = 0
+
+**Output:** 0.06250
+
+**Explanation:** There are two moves (to (1,2), (2,1)) that will keep the knight on the board. From each of those positions, there are also two moves that will keep the knight on the board. The total probability the knight stays on the board is 0.0625.
+
+**Example 2:**
+
+**Input:** n = 1, k = 0, row = 0, column = 0
+
+**Output:** 1.00000
+
+**Constraints:**
+
+*   `1 <= n <= 25`
+*   `0 <= k <= 100`
+*   `0 <= row, column <= n - 1`

src/main/kotlin/g0601_0700/s0689_maximum_sum_of_3_non_overlapping_subarrays/Solution.kt

@@ -0,0 +1,68 @@
+package g0601_0700.s0689_maximum_sum_of_3_non_overlapping_subarrays
+
+// #Hard #Array #Dynamic_Programming #2023_02_20_Time_248_ms_(100.00%)_Space_37.6_MB_(100.00%)
+
+class Solution {
+    fun maxSumOfThreeSubarrays(nums: IntArray, k: Int): IntArray {
+        val len = nums.size
+        if (len < 3 * k) {
+            return intArrayOf()
+        }
+        val res = IntArray(3)
+        val left = Array(2) { IntArray(len) }
+        val right = Array(2) { IntArray(len) }
+        var s = 0
+        for (i in 0 until k) {
+            s += nums[i]
+        }
+        left[0][k - 1] = s
+        run {
+            var i = k
+            while (i + 2 * k <= len) {
+                s = s + nums[i] - nums[i - k]
+                if (s > left[0][i - 1]) {
+                    left[0][i] = s
+                    left[1][i] = i - k + 1
+                } else {
+                    left[0][i] = left[0][i - 1]
+                    left[1][i] = left[1][i - 1]
+                }
+                i++
+            }
+        }
+        s = 0
+        for (i in len - 1 downTo len - k) {
+            s += nums[i]
+        }
+        right[0][len - k] = s
+        right[1][len - k] = len - k
+        for (i in len - k - 1 downTo 0) {
+            s = s + nums[i] - nums[i + k]
+            if (s >= right[0][i + 1]) {
+                right[0][i] = s
+                right[1][i] = i
+            } else {
+                right[0][i] = right[0][i + 1]
+                right[1][i] = right[1][i + 1]
+            }
+        }
+        var mid = 0
+        for (i in k until 2 * k) {
+            mid += nums[i]
+        }
+        var max = 0
+        var i = k
+        while (i + 2 * k <= len) {
+            val total = left[0][i - 1] + right[0][i + k] + mid
+            if (total > max) {
+                res[0] = left[1][i - 1]
+                res[1] = i
+                res[2] = right[1][i + k]
+                max = total
+            }
+            mid = mid + nums[i + k] - nums[i]
+            i++
+        }
+        return res
+    }
+}

src/main/kotlin/g0601_0700/s0689_maximum_sum_of_3_non_overlapping_subarrays/readme.md

@@ -0,0 +1,35 @@
+688\. Knight Probability in Chessboard
+
+Medium
+
+On an `n x n` chessboard, a knight starts at the cell `(row, column)` and attempts to make exactly `k` moves. The rows and columns are **0-indexed**, so the top-left cell is `(0, 0)`, and the bottom-right cell is `(n - 1, n - 1)`.
+
+A chess knight has eight possible moves it can make, as illustrated below. Each move is two cells in a cardinal direction, then one cell in an orthogonal direction.
+
+![](https://assets.leetcode.com/uploads/2018/10/12/knight.png)
+
+Each time the knight is to move, it chooses one of eight possible moves uniformly at random (even if the piece would go off the chessboard) and moves there.
+
+The knight continues moving until it has made exactly `k` moves or has moved off the chessboard.
+
+Return _the probability that the knight remains on the board after it has stopped moving_.
+
+**Example 1:**
+
+**Input:** n = 3, k = 2, row = 0, column = 0
+
+**Output:** 0.06250
+
+**Explanation:** There are two moves (to (1,2), (2,1)) that will keep the knight on the board. From each of those positions, there are also two moves that will keep the knight on the board. The total probability the knight stays on the board is 0.0625.
+
+**Example 2:**
+
+**Input:** n = 1, k = 0, row = 0, column = 0
+
+**Output:** 1.00000
+
+**Constraints:**
+
+*   `1 <= n <= 25`
+*   `0 <= k <= 100`
+*   `0 <= row, column <= n - 1`

src/main/kotlin/g0601_0700/s0690_employee_importance/Solution.kt

@@ -0,0 +1,34 @@
+package g0601_0700.s0690_employee_importance
+
+// #Medium #Hash_Table #Depth_First_Search #Breadth_First_Search
+// #2023_02_20_Time_255_ms_(100.00%)_Space_46.3_MB_(71.43%)
+
+import com_github_leetcode.Employee
+
+/*
+ *	// Definition for Employee.
+ *	class Employee {
+ *		var id:Int = 0
+ *		var importance:Int = 0
+ *		var subordinates:List<Int> = listOf()
+ *	}
+ */
+
+class Solution {
+    fun getImportance(employees: List<Employee?>, id: Int): Int {
+        val map: MutableMap<Int, Employee> = HashMap()
+        for (emp in employees) {
+            map[emp!!.id] = emp
+        }
+        return calculateImportance(id, map)
+    }
+
+    private fun calculateImportance(id: Int, map: Map<Int, Employee>): Int {
+        val employee = map[id]
+        var sum = employee!!.importance
+        for (sub in employee.subordinates) {
+            sum += calculateImportance(sub, map)
+        }
+        return sum
+    }
+}

src/main/kotlin/g0601_0700/s0690_employee_importance/readme.md

@@ -0,0 +1,42 @@
+690\. Employee Importance
+
+Medium
+
+You have a data structure of employee information, including the employee's unique ID, importance value, and direct subordinates' IDs.
+
+You are given an array of employees `employees` where:
+
+*   `employees[i].id` is the ID of the <code>i<sup>th</sup></code> employee.
+*   `employees[i].importance` is the importance value of the <code>i<sup>th</sup></code> employee.
+*   `employees[i].subordinates` is a list of the IDs of the direct subordinates of the <code>i<sup>th</sup></code> employee.
+
+Given an integer `id` that represents an employee's ID, return _the **total** importance value of this employee and all their direct and indirect subordinates_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/05/31/emp1-tree.jpg)
+
+**Input:** employees = [[1,5,[2,3]],[2,3,[]],[3,3,[]]], id = 1
+
+**Output:** 11
+
+**Explanation:** Employee 1 has an importance value of 5 and has two direct subordinates: employee 2 and employee 3. They both have an importance value of 3. Thus, the total importance value of employee 1 is 5 + 3 + 3 = 11.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/05/31/emp2-tree.jpg)
+
+**Input:** employees = [[1,2,[5]],[5,-3,[]]], id = 5
+
+**Output:** -3
+
+**Explanation:** Employee 5 has an importance value of -3 and has no direct subordinates. Thus, the total importance value of employee 5 is -3.
+
+**Constraints:**
+
+*   `1 <= employees.length <= 2000`
+*   `1 <= employees[i].id <= 2000`
+*   All `employees[i].id` are **unique**.
+*   `-100 <= employees[i].importance <= 100`
+*   One employee has at most one direct leader and may have several subordinates.
+*   The IDs in `employees[i].subordinates` are valid IDs.

src/main/kotlin/g0601_0700/s0691_stickers_to_spell_word/Solution.kt

@@ -0,0 +1,69 @@
+package g0601_0700.s0691_stickers_to_spell_word
+
+// #Hard #Array #String #Dynamic_Programming #Bit_Manipulation #Backtracking #Bitmask
+// #2023_02_20_Time_249_ms_(100.00%)_Space_42.6_MB_(100.00%)
+
+class Solution {
+    // count the characters of every sticker
+    private lateinit var counts: Array<IntArray>
+
+    // For each character, save the sticker index which has this character
+    private val map: HashMap<Char, HashSet<Int>> = HashMap()
+    private val cache: HashMap<Int, Int> = HashMap()
+    fun minStickers(stickers: Array<String>, target: String): Int {
+        counts = Array(stickers.size) { IntArray(26) }
+        for (i in 0..25) {
+            map[('a'.code + i).toChar()] = HashSet()
+        }
+        for (i in stickers.indices) {
+            for (c in stickers[i].toCharArray()) {
+                counts[i][c.code - 'a'.code]++
+                map[c]!!.add(i)
+            }
+        }
+        val res = dp(0, target)
+        return if (res > target.length) {
+            -1
+        } else res
+    }
+
+    private fun dp(bits: Int, target: String): Int {
+        val len = target.length
+        if (bits == (1 shl len) - 1) {
+            // all bits are 1
+            return 0
+        }
+        if (cache.containsKey(bits)) {
+            return cache[bits]!!
+        }
+        var index = 0
+        // find the first bit which is 0
+        for (i in 0 until len) {
+            if (bits and (1 shl i) == 0) {
+                index = i
+                break
+            }
+        }
+        // In worst case, each character use 1 sticker. So, len + 1 means impossible
+        var res = len + 1
+        for (key in map[target[index]]!!) {
+            val count = counts[key].clone()
+            var mask = bits
+            for (i in index until len) {
+                if (mask and (1 shl i) != 0) {
+                    // this bit has already been 1
+                    continue
+                }
+                val c = target[i]
+                if (count[c.code - 'a'.code] > 0) {
+                    count[c.code - 'a'.code]--
+                    mask = mask or (1 shl i)
+                }
+            }
+            val `val` = dp(mask, target) + 1
+            res = res.coerceAtMost(`val`)
+        }
+        cache[bits] = res
+        return res
+    }
+}

src/main/kotlin/g0601_0700/s0691_stickers_to_spell_word/readme.md

@@ -0,0 +1,33 @@
+691\. Stickers to Spell Word
+
+Hard
+
+We are given `n` different types of `stickers`. Each sticker has a lowercase English word on it.
+
+You would like to spell out the given string `target` by cutting individual letters from your collection of stickers and rearranging them. You can use each sticker more than once if you want, and you have infinite quantities of each sticker.
+
+Return _the minimum number of stickers that you need to spell out_ `target`. If the task is impossible, return `-1`.
+
+**Note:** In all test cases, all words were chosen randomly from the `1000` most common US English words, and `target` was chosen as a concatenation of two random words.
+
+**Example 1:**
+
+**Input:** stickers = ["with","example","science"], target = "thehat"
+
+**Output:** 3
+
+**Explanation:** We can use 2 "with" stickers, and 1 "example" sticker. After cutting and rearrange the letters of those stickers, we can form the target "thehat". Also, this is the minimum number of stickers necessary to form the target string.
+
+**Example 2:**
+
+**Input:** stickers = ["notice","possible"], target = "basicbasic"
+
+**Output:** -1 Explanation: We cannot form the target "basicbasic" from cutting letters from the given stickers.
+
+**Constraints:**
+
+*   `n == stickers.length`
+*   `1 <= n <= 50`
+*   `1 <= stickers[i].length <= 10`
+*   `1 <= target.length <= 15`
+*   `stickers[i]` and `target` consist of lowercase English letters.