Added tasks 674, 675, 676, 677

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
+| 0677 |[Map Sum Pairs](src/main/kotlin/g0601_0700/s0677_map_sum_pairs/MapSum.kt)| Medium | String, Hash_Table, Design, Trie | 197 | 80.00
+| 0676 |[Implement Magic Dictionary](src/main/kotlin/g0601_0700/s0676_implement_magic_dictionary/MagicDictionary.kt)| Medium | String, Hash_Table, Design, Trie | 256 | 100.00
+| 0675 |[Cut Off Trees for Golf Event](src/main/kotlin/g0601_0700/s0675_cut_off_trees_for_golf_event/Solution.kt)| Hard | Array, Breadth_First_Search, Matrix, Heap_Priority_Queue | 777 | 100.00
+| 0674 |[Longest Continuous Increasing Subsequence](src/main/kotlin/g0601_0700/s0674_longest_continuous_increasing_subsequence/Solution.kt)| Easy | Array | 201 | 84.21
 | 0673 |[Number of Longest Increasing Subsequence](src/main/kotlin/g0601_0700/s0673_number_of_longest_increasing_subsequence/Solution.kt)| Medium | Array, Dynamic_Programming, Segment_Tree, Binary_Indexed_Tree, Algorithm_II_Day_16_Dynamic_Programming | 226 | 91.67
 | 0672 |[Bulb Switcher II](src/main/kotlin/g0601_0700/s0672_bulb_switcher_ii/Solution.kt)| Medium | Math, Depth_First_Search, Breadth_First_Search, Bit_Manipulation | 131 | 100.00
 | 0671 |[Second Minimum Node In a Binary Tree](src/main/kotlin/g0601_0700/s0671_second_minimum_node_in_a_binary_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 128 | 100.00

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

@@ -0,0 +1,23 @@
+package g0601_0700.s0674_longest_continuous_increasing_subsequence
+
+// #Easy #Array #2023_02_15_Time_201_ms_(84.21%)_Space_36.9_MB_(68.42%)
+
+class Solution {
+    fun findLengthOfLCIS(nums: IntArray): Int {
+        var ans = 1
+        var count = 1
+        for (i in 0 until nums.size - 1) {
+            if (nums[i] < nums[i + 1]) {
+                count++
+            } else {
+                ans = max(count, ans)
+                count = 1
+            }
+        }
+        return max(ans, count)
+    }
+
+    private fun max(n1: Int, n2: Int): Int {
+        return Math.max(n1, n2)
+    }
+}

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

@@ -0,0 +1,28 @@
+674\. Longest Continuous Increasing Subsequence
+
+Easy
+
+Given an unsorted array of integers `nums`, return _the length of the longest **continuous increasing subsequence** (i.e. subarray)_. The subsequence must be **strictly** increasing.
+
+A **continuous increasing subsequence** is defined by two indices `l` and `r` (`l < r`) such that it is `[nums[l], nums[l + 1], ..., nums[r - 1], nums[r]]` and for each `l <= i < r`, `nums[i] < nums[i + 1]`.
+
+**Example 1:**
+
+**Input:** nums = [1,3,5,4,7]
+
+**Output:** 3
+
+**Explanation:** The longest continuous increasing subsequence is [1,3,5] with length 3. Even though [1,3,5,7] is an increasing subsequence, it is not continuous as elements 5 and 7 are separated by element 4.
+
+**Example 2:**
+
+**Input:** nums = [2,2,2,2,2]
+
+**Output:** 1
+
+**Explanation:** The longest continuous increasing subsequence is [2] with length 1. Note that it must be strictly increasing.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>

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

@@ -0,0 +1,71 @@
+package g0601_0700.s0675_cut_off_trees_for_golf_event
+
+// #Hard #Array #Breadth_First_Search #Matrix #Heap_Priority_Queue
+// #2023_02_15_Time_777_ms_(100.00%)_Space_43.4_MB_(100.00%)
+
+import java.util.LinkedList
+import java.util.Objects
+import java.util.PriorityQueue
+import java.util.Queue
+
+class Solution {
+    private var r = 0
+    private var c = 0
+    fun cutOffTree(forest: List<List<Int>>): Int {
+        val pq = PriorityQueue<Int>()
+        for (integers in forest) {
+            for (v in integers) {
+                if (v > 1) {
+                    pq.add(v)
+                }
+            }
+        }
+        var steps = 0
+        while (!pq.isEmpty()) {
+            val count = minSteps(forest, pq.poll())
+            if (count == -1) {
+                return -1
+            }
+            steps += count
+        }
+        return steps
+    }
+
+    private fun minSteps(forest: List<List<Int>>, target: Int): Int {
+        var steps = 0
+        val dirs = arrayOf(intArrayOf(0, 1), intArrayOf(0, -1), intArrayOf(1, 0), intArrayOf(-1, 0))
+        val visited = Array(forest.size) {
+            BooleanArray(
+                forest[0].size
+            )
+        }
+        val q: Queue<IntArray> = LinkedList()
+        q.add(intArrayOf(r, c))
+        visited[r][c] = true
+        while (!q.isEmpty()) {
+            val qSize = q.size
+            for (i in 0 until qSize) {
+                val curr = q.poll()
+                if (forest[Objects.requireNonNull(curr)[0]][curr[1]] == target) {
+                    r = curr[0]
+                    c = curr[1]
+                    return steps
+                }
+                for (k in 0..3) {
+                    val dir = dirs[k]
+                    val nr = dir[0] + curr[0]
+                    val nc = dir[1] + curr[1]
+                    if (nr < 0 || nr == visited.size || nc < 0 || nc == visited[0].size ||
+                        visited[nr][nc] || forest[nr][nc] == 0
+                    ) {
+                        continue
+                    }
+                    q.add(intArrayOf(nr, nc))
+                    visited[nr][nc] = true
+                }
+            }
+            steps++
+        }
+        return -1
+    }
+}

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

@@ -0,0 +1,53 @@
+675\. Cut Off Trees for Golf Event
+
+Hard
+
+You are asked to cut off all the trees in a forest for a golf event. The forest is represented as an `m x n` matrix. In this matrix:
+
+*   `0` means the cell cannot be walked through.
+*   `1` represents an empty cell that can be walked through.
+*   A number greater than `1` represents a tree in a cell that can be walked through, and this number is the tree's height.
+
+In one step, you can walk in any of the four directions: north, east, south, and west. If you are standing in a cell with a tree, you can choose whether to cut it off.
+
+You must cut off the trees in order from shortest to tallest. When you cut off a tree, the value at its cell becomes `1` (an empty cell).
+
+Starting from the point `(0, 0)`, return _the minimum steps you need to walk to cut off all the trees_. If you cannot cut off all the trees, return `-1`.
+
+**Note:** The input is generated such that no two trees have the same height, and there is at least one tree needs to be cut off.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/trees1.jpg)
+
+**Input:** forest = [[1,2,3],[0,0,4],[7,6,5]]
+
+**Output:** 6
+
+**Explanation:** Following the path above allows you to cut off the trees from shortest to tallest in 6 steps.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/trees2.jpg)
+
+**Input:** forest = [[1,2,3],[0,0,0],[7,6,5]]
+
+**Output:** -1
+
+**Explanation:** The trees in the bottom row cannot be accessed as the middle row is blocked.
+
+**Example 3:**
+
+**Input:** forest = [[2,3,4],[0,0,5],[8,7,6]]
+
+**Output:** 6
+
+**Explanation:** You can follow the same path as Example 1 to cut off all the trees. Note that you can cut off the first tree at (0, 0) before making any steps.
+
+**Constraints:**
+
+*   `m == forest.length`
+*   `n == forest[i].length`
+*   `1 <= m, n <= 50`
+*   <code>0 <= forest[i][j] <= 10<sup>9</sup></code>
+*   Heights of all trees are **distinct**.

src/main/kotlin/g0601_0700/s0676_implement_magic_dictionary/MagicDictionary.kt

@@ -0,0 +1,51 @@
+package g0601_0700.s0676_implement_magic_dictionary
+
+// #Medium #String #Hash_Table #Design #Trie
+// #2023_02_15_Time_256_ms_(100.00%)_Space_37.7_MB_(100.00%)
+
+class MagicDictionary {
+    private var dictionaryWords: Array<String>? = null
+    fun buildDict(dictionary: Array<String>?) {
+        dictionaryWords = dictionary
+    }
+
+    fun search(searchWord: String): Boolean {
+        for (word in dictionaryWords!!) {
+            if (isOffByOneLetter(word, searchWord)) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun isOffByOneLetter(word: String, searchWord: String): Boolean {
+        if (isDifferentLengths(word, searchWord) || word == searchWord) {
+            return false
+        }
+        var numDifferentLetters = 0
+        for (i in word.indices) {
+            if (isNotTheSameLetter(word[i], searchWord[i])) {
+                numDifferentLetters++
+            }
+            if (numDifferentLetters > 1) {
+                return false
+            }
+        }
+        return numDifferentLetters == 1
+    }
+
+    private fun isDifferentLengths(word: String, searchWord: String): Boolean {
+        return word.length != searchWord.length
+    }
+
+    private fun isNotTheSameLetter(c1: Char, c2: Char): Boolean {
+        return c1 != c2
+    }
+}
+
+/*
+ * Your MagicDictionary object will be instantiated and called as such:
+ * var obj = MagicDictionary()
+ * obj.buildDict(dictionary)
+ * var param_2 = obj.search(searchWord)
+ */

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

@@ -0,0 +1,41 @@
+676\. Implement Magic Dictionary
+
+Medium
+
+Design a data structure that is initialized with a list of **different** words. Provided a string, you should determine if you can change exactly one character in this string to match any word in the data structure.
+
+Implement the `MagicDictionary` class:
+
+*   `MagicDictionary()` Initializes the object.
+*   `void buildDict(String[] dictionary)` Sets the data structure with an array of distinct strings `dictionary`.
+*   `bool search(String searchWord)` Returns `true` if you can change **exactly one character** in `searchWord` to match any string in the data structure, otherwise returns `false`.
+
+**Example 1:**
+
+**Input**
+
+["MagicDictionary", "buildDict", "search", "search", "search", "search"] [[],
+
+[["hello", "leetcode"]], ["hello"], ["hhllo"], ["hell"], ["leetcoded"]]
+
+**Output:** [null, null, false, true, false, false]
+
+**Explanation:**
+
+    MagicDictionary magicDictionary = new MagicDictionary(); 
+    magicDictionary.buildDict(["hello", "leetcode"]); 
+    magicDictionary.search("hello"); // return False 
+    magicDictionary.search("hhllo"); // We can change the second 'h' to 'e' to match "hello" so we return True 
+    magicDictionary.search("hell"); // return False 
+    magicDictionary.search("leetcoded"); // return False
+
+**Constraints:**
+
+*   `1 <= dictionary.length <= 100`
+*   `1 <= dictionary[i].length <= 100`
+*   `dictionary[i]` consists of only lower-case English letters.
+*   All the strings in `dictionary` are **distinct**.
+*   `1 <= searchWord.length <= 100`
+*   `searchWord` consists of only lower-case English letters.
+*   `buildDict` will be called only once before `search`.
+*   At most `100` calls will be made to `search`.

src/main/kotlin/g0601_0700/s0677_map_sum_pairs/MapSum.kt

@@ -0,0 +1,52 @@
+package g0601_0700.s0677_map_sum_pairs
+
+// #Medium #String #Hash_Table #Design #Trie #2023_02_15_Time_197_ms_(80.00%)_Space_36.1_MB_(55.00%)
+
+class MapSum {
+    internal class Node {
+        var `val`: Int = 0
+        var child: Array<Node?> = arrayOfNulls(26)
+    }
+
+    private val root: Node = Node()
+
+    fun insert(key: String, `val`: Int) {
+        var curr: Node? = root
+        for (c in key.toCharArray()) {
+            if (curr!!.child[c.code - 'a'.code] == null) {
+                curr.child[c.code - 'a'.code] = Node()
+            }
+            curr = curr.child[c.code - 'a'.code]
+        }
+        curr!!.`val` = `val`
+    }
+
+    private fun sumHelper(root: Node?): Int {
+        var o = 0
+        for (i in 0..25) {
+            if (root!!.child[i] != null) {
+                o += root.child[i]!!.`val` + sumHelper(root.child[i])
+            }
+        }
+        return o
+    }
+
+    fun sum(prefix: String): Int {
+        var curr: Node? = root
+        for (c in prefix.toCharArray()) {
+            if (curr!!.child[c.code - 'a'.code] == null) {
+                return 0
+            }
+            curr = curr.child[c.code - 'a'.code]
+        }
+        val sum = curr!!.`val`
+        return sum + sumHelper(curr)
+    }
+}
+
+/*
+ * Your MapSum object will be instantiated and called as such:
+ * var obj = MapSum()
+ * obj.insert(key,`val`)
+ * var param_2 = obj.sum(prefix)
+ */

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

@@ -0,0 +1,39 @@
+677\. Map Sum Pairs
+
+Medium
+
+Design a map that allows you to do the following:
+
+*   Maps a string key to a given value.
+*   Returns the sum of the values that have a key with a prefix equal to a given string.
+
+Implement the `MapSum` class:
+
+*   `MapSum()` Initializes the `MapSum` object.
+*   `void insert(String key, int val)` Inserts the `key-val` pair into the map. If the `key` already existed, the original `key-value` pair will be overridden to the new one.
+*   `int sum(string prefix)` Returns the sum of all the pairs' value whose `key` starts with the `prefix`.
+
+**Example 1:**
+
+**Input**
+
+["MapSum", "insert", "sum", "insert", "sum"] [[],
+
+["apple", 3], ["ap"], ["app", 2], ["ap"]]
+
+**Output:** [null, null, 3, null, 5]
+
+**Explanation:**
+
+    MapSum mapSum = new MapSum(); 
+    mapSum.insert("apple", 3); 
+    mapSum.sum("ap"); // return 3 (apple = 3) 
+    mapSum.insert("app", 2); 
+    mapSum.sum("ap"); // return 5 (apple + app = 3 + 2 = 5)
+
+**Constraints:**
+
+*   `1 <= key.length, prefix.length <= 50`
+*   `key` and `prefix` consist of only lowercase English letters.
+*   `1 <= val <= 1000`
+*   At most `50` calls will be made to `insert` and `sum`.

src/test/kotlin/g0601_0700/s0674_longest_continuous_increasing_subsequence/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0601_0700.s0674_longest_continuous_increasing_subsequence
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findNumberOfLIS2() {
+        assertThat(Solution().findLengthOfLCIS(intArrayOf(1, 3, 5, 4, 7)), equalTo(3))
+    }
+
+    @Test
+    fun findNumberOfLIS22() {
+        assertThat(Solution().findLengthOfLCIS(intArrayOf(2, 2, 2, 2, 2)), equalTo(1))
+    }
+}