Added tasks 697, 698, 699, 700

Author: ThanhNIT

README.md

@@ -620,6 +620,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0448 |[Find All Numbers Disappeared in an Array](src.save/main/kotlin/g0401_0500/s0448_find_all_numbers_disappeared_in_an_array/Solution.kt)| Easy | Array, Hash_Table | 394 | 100.00
 | 0442 |[Find All Duplicates in an Array](src.save/main/kotlin/g0401_0500/s0442_find_all_duplicates_in_an_array/Solution.kt)| Medium | Array, Hash_Table | 480 | 73.81
 | 0041 |[First Missing Positive](src.save/main/kotlin/g0001_0100/s0041_first_missing_positive/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 345 | 100.00
+| 0697 |[Degree of an Array](src/main/kotlin/g0601_0700/s0697_degree_of_an_array/Solution.kt)| Easy | Array, Hash_Table | 289 | 84.62
 | 0532 |[K-diff Pairs in an Array](src.save/main/kotlin/g0501_0600/s0532_k_diff_pairs_in_an_array/Solution.kt)| Medium | Array, Hash_Table, Sorting, Binary_Search, Two_Pointers | 230 | 84.62
 | 0456 |[132 Pattern](src.save/main/kotlin/g0401_0500/s0456_132_pattern/Solution.kt)| Medium | Array, Binary_Search, Stack, Ordered_Set, Monotonic_Stack | 434 | 100.00
 | 0239 |[Sliding Window Maximum](src.save/main/kotlin/g0201_0300/s0239_sliding_window_maximum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Heap_Priority_Queue, Sliding_Window, Queue, Monotonic_Queue | 1059 | 86.14
@@ -855,6 +856,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0700 |[Search in a Binary Search Tree](src/main/kotlin/g0601_0700/s0700_search_in_a_binary_search_tree/Solution.kt)| Easy | Tree, Binary_Tree, Binary_Search_Tree | 251 | 88.31
 
 #### Day 14 Tree
 
@@ -1679,6 +1681,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
+| 0700 |[Search in a Binary Search Tree](src/main/kotlin/g0601_0700/s0700_search_in_a_binary_search_tree/Solution.kt)| Easy | Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_13_Tree | 251 | 88.31
+| 0699 |[Falling Squares](src/main/kotlin/g0601_0700/s0699_falling_squares/Solution.kt)| Hard | Array, Ordered_Set, Segment_Tree | 293 | 100.00
+| 0698 |[Partition to K Equal Sum Subsets](src/main/kotlin/g0601_0700/s0698_partition_to_k_equal_sum_subsets/Solution.kt)| Medium | Array, Dynamic_Programming, Bit_Manipulation, Backtracking, Bitmask, Memoization | 191 | 100.00
+| 0697 |[Degree of an Array](src/main/kotlin/g0601_0700/s0697_degree_of_an_array/Solution.kt)| Easy | Array, Hash_Table, Udemy_Arrays | 289 | 84.62
 | 0696 |[Count Binary Substrings](src/main/kotlin/g0601_0700/s0696_count_binary_substrings/Solution.kt)| Easy | String, Two_Pointers | 222 | 100.00
 | 0695 |[Max Area of Island](src/main/kotlin/g0601_0700/s0695_max_area_of_island/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Algorithm_I_Day_7_Breadth_First_Search_Depth_First_Search, Graph_Theory_I_Day_2_Matrix_Related_Problems | 324 | 24.06
 | 0693 |[Binary Number with Alternating Bits](src/main/kotlin/g0601_0700/s0693_binary_number_with_alternating_bits/Solution.kt)| Easy | Bit_Manipulation | 129 | 100.00

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

@@ -0,0 +1,31 @@
+package g0601_0700.s0697_degree_of_an_array
+
+// #Easy #Array #Hash_Table #Udemy_Arrays #2023_02_22_Time_289_ms_(84.62%)_Space_58.4_MB_(19.23%)
+
+class Solution {
+    private class Value(var count: Int, var start: Int, var end: Int)
+
+    fun findShortestSubArray(nums: IntArray): Int {
+        var max = 1
+        val map: MutableMap<Int, Value> = HashMap()
+        for (i in nums.indices) {
+            val j = nums[i]
+            if (map.containsKey(j)) {
+                val v = map[j]
+                v!!.count++
+                max = Math.max(max, v.count)
+                v.end = i
+            } else {
+                map[j] = Value(1, i, i)
+            }
+        }
+        var min = Int.MAX_VALUE
+        for (entry in map.entries.iterator()) {
+            val v: Value = entry.value
+            if (v.count == max) {
+                min = min.coerceAtMost(v.end - v.start)
+            }
+        }
+        return min + 1
+    }
+}

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

@@ -0,0 +1,28 @@
+697\. Degree of an Array
+
+Easy
+
+Given a non-empty array of non-negative integers `nums`, the **degree** of this array is defined as the maximum frequency of any one of its elements.
+
+Your task is to find the smallest possible length of a (contiguous) subarray of `nums`, that has the same degree as `nums`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2,3,1]
+
+**Output:** 2
+
+**Explanation:** The input array has a degree of 2 because both elements 1 and 2 appear twice. Of the subarrays that have the same degree: [1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2] The shortest length is 2. So return 2.
+
+**Example 2:**
+
+**Input:** nums = [1,2,2,3,1,4,2]
+
+**Output:** 6
+
+**Explanation:** The degree is 3 because the element 2 is repeated 3 times. So [2,2,3,1,4,2] is the shortest subarray, therefore returning 6.
+
+**Constraints:**
+
+*   `nums.length` will be between 1 and 50,000.
+*   `nums[i]` will be an integer between 0 and 49,999.

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

@@ -0,0 +1,48 @@
+package g0601_0700.s0698_partition_to_k_equal_sum_subsets
+
+// #Medium #Array #Dynamic_Programming #Bit_Manipulation #Backtracking #Bitmask #Memoization
+// #2023_02_22_Time_191_ms_(100.00%)_Space_45.5_MB_(50.00%)
+
+import java.util.Arrays
+
+class Solution {
+    fun canPartitionKSubsets(nums: IntArray, k: Int): Boolean {
+        if (nums.isEmpty()) {
+            return false
+        }
+        val n = nums.size
+        var sum = 0
+        for (num in nums) {
+            sum += num
+        }
+        if (sum % k != 0) {
+            return false
+        }
+        // sum of each subset = sum / k
+        sum /= k
+        val dp = IntArray(1 shl n)
+        Arrays.fill(dp, -1)
+        dp[0] = 0
+        for (i in 0 until (1 shl n)) {
+            if (dp[i] == -1) {
+                continue
+            }
+            val rem = sum - dp[i] % sum
+            for (j in 0 until n) {
+                // bitmask
+                val tmp = i or (1 shl j)
+                // skip if the bit is already taken
+                if (tmp != i) {
+                    // num too big for current subset
+                    if (nums[j] > rem) {
+                        break
+                    }
+                    // cumulative sum
+                    dp[tmp] = dp[i] + nums[j]
+                }
+            }
+        }
+        // true if total sum of all nums is the same
+        return dp[(1 shl n) - 1] == k * sum
+    }
+}

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

@@ -0,0 +1,25 @@
+698\. Partition to K Equal Sum Subsets
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return `true` if it is possible to divide this array into `k` non-empty subsets whose sums are all equal.
+
+**Example 1:**
+
+**Input:** nums = [4,3,2,3,5,2,1], k = 4
+
+**Output:** true
+
+**Explanation:** It is possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal sums.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4], k = 3
+
+**Output:** false
+
+**Constraints:**
+
+*   `1 <= k <= nums.length <= 16`
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>
+*   The frequency of each element is in the range `[1, 4]`.

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

@@ -0,0 +1,45 @@
+package g0601_0700.s0699_falling_squares
+
+// #Hard #Array #Ordered_Set #Segment_Tree #2023_02_22_Time_293_ms_(100.00%)_Space_48.8_MB_(50.00%)
+
+import java.util.Collections
+import java.util.TreeSet
+
+class Solution {
+    fun fallingSquares(positions: Array<IntArray>): List<Int> {
+        // Coordinate compression using TreeSet
+        val unique: MutableSet<Int> = TreeSet()
+        for (square in positions) {
+            unique.add(square[0])
+            unique.add(square[0] + square[1] - 1)
+        }
+        // converted the TreeSet to a List
+        val sorted: List<Int> = ArrayList(unique)
+        // Storing the max heights for compressed coordinates
+        val heights = IntArray(sorted.size)
+        // Our answer list
+        val list: MutableList<Int> = ArrayList(positions.size)
+        // Global Max
+        var max = 0
+        for (square in positions) {
+            // coordinate compression lookup
+            val x1 = Collections.binarySearch(sorted, square[0])
+            val x2 = Collections.binarySearch(sorted, square[0] + square[1] - 1)
+            // get the current max for the interval between x1 and x2
+            var current = 0
+            for (i in x1..x2) {
+                current = current.coerceAtLeast(heights[i])
+            }
+            // add the new square on the top
+            current += square[1]
+            // update the interval with the new value
+            for (i in x1..x2) {
+                heights[i] = current
+            }
+            // recalculate the global max
+            max = max.coerceAtLeast(current)
+            list.add(max)
+        }
+        return list
+    }
+}

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

@@ -0,0 +1,53 @@
+699\. Falling Squares
+
+Hard
+
+There are several squares being dropped onto the X-axis of a 2D plane.
+
+You are given a 2D integer array `positions` where <code>positions[i] = [left<sub>i</sub>, sideLength<sub>i</sub>]</code> represents the <code>i<sup>th</sup></code> square with a side length of <code>sideLength<sub>i</sub></code> that is dropped with its left edge aligned with X-coordinate <code>left<sub>i</sub></code>.
+
+Each square is dropped one at a time from a height above any landed squares. It then falls downward (negative Y direction) until it either lands **on the top side of another square** or **on the X-axis**. A square brushing the left/right side of another square does not count as landing on it. Once it lands, it freezes in place and cannot be moved.
+
+After each square is dropped, you must record the **height of the current tallest stack of squares**.
+
+Return _an integer array_ `ans` _where_ `ans[i]` _represents the height described above after dropping the_ <code>i<sup>th</sup></code> _square_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/28/fallingsq1-plane.jpg)
+
+**Input:** positions = [[1,2],[2,3],[6,1]]
+
+**Output:** [2,5,5]
+
+**Explanation:**
+
+After the first drop, the tallest stack is square 1 with a height of 2.
+
+After the second drop, the tallest stack is squares 1 and 2 with a height of 5.
+
+After the third drop, the tallest stack is still squares 1 and 2 with a height of 5.
+
+Thus, we return an answer of [2, 5, 5].
+
+**Example 2:**
+
+**Input:** positions = [[100,100],[200,100]]
+
+**Output:** [100,100]
+
+**Explanation:**
+
+After the first drop, the tallest stack is square 1 with a height of 100.
+
+After the second drop, the tallest stack is either square 1 or square 2, both with heights of 100.
+
+Thus, we return an answer of [100, 100].
+
+Note that square 2 only brushes the right side of square 1, which does not count as landing on it.
+
+**Constraints:**
+
+*   `1 <= positions.length <= 1000`
+*   <code>1 <= left<sub>i</sub> <= 10<sup>8</sup></code>
+*   <code>1 <= sideLength<sub>i</sub> <= 10<sup>6</sup></code>

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

@@ -0,0 +1,31 @@
+package g0601_0700.s0700_search_in_a_binary_search_tree
+
+// #Easy #Tree #Binary_Tree #Binary_Search_Tree #Data_Structure_I_Day_13_Tree
+// #2023_02_22_Time_251_ms_(88.31%)_Space_51_MB_(7.79%)
+
+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
+ * }
+ */
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun searchBST(root: TreeNode?, `val`: Int): TreeNode? {
+        var root: TreeNode? = root
+        while (root != null && root.`val` != `val`) {
+            root = if (root.`val` > `val`) {
+                root.left
+            } else {
+                root.right
+            }
+        }
+        return root
+    }
+}

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

@@ -0,0 +1,30 @@
+700\. Search in a Binary Search Tree
+
+Easy
+
+You are given the `root` of a binary search tree (BST) and an integer `val`.
+
+Find the node in the BST that the node's value equals `val` and return the subtree rooted with that node. If such a node does not exist, return `null`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/12/tree1.jpg)
+
+**Input:** root = [4,2,7,1,3], val = 2
+
+**Output:** [2,1,3]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/12/tree2.jpg)
+
+**Input:** root = [4,2,7,1,3], val = 5
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 5000]`.
+*   <code>1 <= Node.val <= 10<sup>7</sup></code>
+*   `root` is a binary search tree.
+*   <code>1 <= val <= 10<sup>7</sup></code>

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

@@ -0,0 +1,19 @@
+package g0601_0700.s0697_degree_of_an_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findShortestSubArray() {
+        assertThat(Solution().findShortestSubArray(intArrayOf(1, 2, 2, 3, 1)), equalTo(2))
+    }
+
+    @Test
+    fun findShortestSubArray2() {
+        assertThat(
+            Solution().findShortestSubArray(intArrayOf(1, 2, 2, 3, 1, 4, 2)), equalTo(6)
+        )
+    }
+}