Added tasks 375, 376, 377, 380.

Author: ThanhNIT

README.md

@@ -276,6 +276,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0300 |[Longest Increasing Subsequence](src.save/main/kotlin/g0201_0300/s0300_longest_increasing_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Binary_Search | 318 | 82.28
+| 0376 |[Wiggle Subsequence](src/main/kotlin/g0301_0400/s0376_wiggle_subsequence/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy | 162 | 88.89
 
 #### Day 19
 
@@ -294,6 +295,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0377 |[Combination Sum IV](src/main/kotlin/g0301_0400/s0377_combination_sum_iv/Solution.kt)| Medium | Array, Dynamic_Programming | 217 | 72.41
 | 0343 |[Integer Break](src/main/kotlin/g0301_0400/s0343_integer_break/Solution.kt)| Medium | Dynamic_Programming, Math | 218 | 63.89
 | 0279 |[Perfect Squares](src.save/main/kotlin/g0201_0300/s0279_perfect_squares/Solution.kt)| Medium | Top_Interview_Questions, Dynamic_Programming, Math, Breadth_First_Search | 176 | 98.80
 
@@ -487,6 +489,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0380 |[Insert Delete GetRandom O(1)](src/main/kotlin/g0301_0400/s0380_insert_delete_getrandom_o1/RandomizedSet.kt)| Medium | Top_Interview_Questions, Array, Hash_Table, Math, Design, Randomized | 1326 | 68.23
 
 ### Graph Theory I
 
@@ -1607,7 +1610,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
 | 0416 |[Partition Equal Subset Sum](src/main/kotlin/g0401_0500/s0416_partition_equal_subset_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Level_2_Day_13_Dynamic_Programming | 509 | 57.56
 | 0394 |[Decode String](src/main/kotlin/g0301_0400/s0394_decode_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Stack, Recursion, Level_1_Day_14_Stack, Udemy_Strings | 224 | 64.86
+| 0380 |[Insert Delete GetRandom O(1)](src/main/kotlin/g0301_0400/s0380_insert_delete_getrandom_o1/RandomizedSet.kt)| Medium | Top_Interview_Questions, Array, Hash_Table, Math, Design, Randomized, Programming_Skills_II_Day_20 | 1326 | 68.23
 | 0378 |[Kth Smallest Element in a Sorted Matrix](src/main/kotlin/g0301_0400/s0378_kth_smallest_element_in_a_sorted_matrix/Solution.kt)| Medium | Top_Interview_Questions, Array, Sorting, Binary_Search, Matrix, Heap_Priority_Queue | 522 | 59.78
+| 0377 |[Combination Sum IV](src/main/kotlin/g0301_0400/s0377_combination_sum_iv/Solution.kt)| Medium | Array, Dynamic_Programming, Dynamic_Programming_I_Day_21 | 217 | 72.41
+| 0376 |[Wiggle Subsequence](src/main/kotlin/g0301_0400/s0376_wiggle_subsequence/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy, Dynamic_Programming_I_Day_18 | 162 | 88.89
+| 0375 |[Guess Number Higher or Lower II](src/main/kotlin/g0301_0400/s0375_guess_number_higher_or_lower_ii/Solution.kt)| Medium | Dynamic_Programming, Math, Game_Theory | 235 | 75.00
 | 0374 |[Guess Number Higher or Lower](src/main/kotlin/g0301_0400/s0374_guess_number_higher_or_lower/Solution.kt)| Easy | Binary_Search, Interactive, Binary_Search_I_Day_1 | 134 | 94.19
 | 0373 |[Find K Pairs with Smallest Sums](src/main/kotlin/g0301_0400/s0373_find_k_pairs_with_smallest_sums/Solution.kt)| Medium | Array, Heap_Priority_Queue | 1809 | 80.95
 | 0372 |[Super Pow](src/main/kotlin/g0301_0400/s0372_super_pow/Solution.kt)| Medium | Math, Divide_and_Conquer | 196 | 100.00

src/main/kotlin/g0301_0400/s0375_guess_number_higher_or_lower_ii/Solution.kt

@@ -0,0 +1,44 @@
+package g0301_0400.s0375_guess_number_higher_or_lower_ii
+
+// #Medium #Dynamic_Programming #Math #Game_Theory
+// #2022_11_22_Time_235_ms_(75.00%)_Space_35.1_MB_(50.00%)
+
+class Solution {
+    lateinit var matrix: Array<IntArray>
+    fun getMoneyAmount(n: Int): Int {
+        matrix = Array(n + 1) { IntArray(n + 1) }
+        return get(1, n)
+    }
+
+    private operator fun get(min: Int, max: Int): Int {
+        if (max - min < 3) {
+            return if (max - min <= 0) 0 else max - 1
+        }
+        if (matrix[min][max] != 0) {
+            return matrix[min][max]
+        }
+        var select = max - 3
+        var minRes = Int.MAX_VALUE
+        var res: Int
+        val end = min + (max - min shr 1) - 1
+        var cnt = 0
+        while (true) {
+            res = select + Math.max(get(min, select - 1), get(select + 1, max))
+            if (res > minRes) {
+                cnt++
+                if (cnt >= 3) {
+                    break
+                }
+            }
+            if (res < minRes) {
+                minRes = res
+            }
+            select--
+            if (select <= end) {
+                break
+            }
+        }
+        matrix[min][max] = minRes
+        return minRes
+    }
+}

src/main/kotlin/g0301_0400/s0375_guess_number_higher_or_lower_ii/readme.md

@@ -0,0 +1,67 @@
+375\. Guess Number Higher or Lower II
+
+Medium
+
+We are playing the Guessing Game. The game will work as follows:
+
+1.  I pick a number between `1` and `n`.
+2.  You guess a number.
+3.  If you guess the right number, **you win the game**.
+4.  If you guess the wrong number, then I will tell you whether the number I picked is **higher or lower**, and you will continue guessing.
+5.  Every time you guess a wrong number `x`, you will pay `x` dollars. If you run out of money, **you lose the game**.
+
+Given a particular `n`, return _the minimum amount of money you need to **guarantee a win regardless of what number I pick**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/10/graph.png)
+
+**Input:** n = 10
+
+**Output:** 16
+
+**Explanation:**
+
+    The winning strategy is as follows:
+    - The range is [1,10]. Guess 7. 
+        - If this is my number, your total is $0. Otherwise, you pay $7. 
+        - If my number is higher, the range is [8,10]. Guess 9. 
+            - If this is my number, your total is $7. Otherwise, you pay $9. 
+            - If my number is higher, it must be 10. Guess 10. Your total is $7 + $9 = $16. 
+            - If my number is lower, it must be 8. Guess 8. Your total is $7 + $9 = $16. 
+        - If my number is lower, the range is [1,6]. Guess 3. 
+            - If this is my number, your total is $7. Otherwise, you pay $3. 
+            - If my number is higher, the range is [4,6]. Guess 5. 
+                - If this is my number, your total is $7 + $3 = $10. Otherwise, you pay $5. 
+                - If my number is higher, it must be 6. Guess 6. Your total is $7 + $3 + $5 = $15. 
+                - If my number is lower, it must be 4. Guess 4. Your total is $7 + $3 + $5 = $15. 
+            - If my number is lower, the range is [1,2]. Guess 1. 
+                - If this is my number, your total is $7 + $3 = $10. Otherwise, you pay $1. 
+                - If my number is higher, it must be 2. Guess 2. Your total is $7 + $3 + $1 = $11.
+    The worst case in all these scenarios is that you pay $16. Hence, you only need $16 to guarantee a win.
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 0
+
+**Explanation:** There is only one possible number, so you can guess 1 and not have to pay anything.
+
+**Example 3:**
+
+**Input:** n = 2
+
+**Output:** 1
+
+**Explanation:**
+
+    There are two possible numbers, 1 and 2.
+    - Guess 1.
+        - If this is my number, your total is $0. Otherwise, you pay $1.
+        - If my number is higher, it must be 2. Guess 2. Your total is $1.
+    The worst case is that you pay $1.
+
+**Constraints:**
+
+*   `1 <= n <= 200`

src/main/kotlin/g0301_0400/s0376_wiggle_subsequence/Solution.kt

@@ -0,0 +1,19 @@
+package g0301_0400.s0376_wiggle_subsequence
+
+// #Medium #Array #Dynamic_Programming #Greedy #Dynamic_Programming_I_Day_18
+// #2022_11_22_Time_162_ms_(88.89%)_Space_33.6_MB_(100.00%)
+
+class Solution {
+    fun wiggleMaxLength(nums: IntArray): Int {
+        var lt = 1
+        var gt = 1
+        for (i in 1 until nums.size) {
+            if (nums[i - 1] < nums[i]) {
+                lt = gt + 1
+            } else if (nums[i - 1] > nums[i]) {
+                gt = lt + 1
+            }
+        }
+        return Math.max(lt, gt)
+    }
+}

src/main/kotlin/g0301_0400/s0376_wiggle_subsequence/readme.md

@@ -0,0 +1,41 @@
+376\. Wiggle Subsequence
+
+Medium
+
+A **wiggle sequence** is a sequence where the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with one element and a sequence with two non-equal elements are trivially wiggle sequences.
+
+*   For example, `[1, 7, 4, 9, 2, 5]` is a **wiggle sequence** because the differences `(6, -3, 5, -7, 3)` alternate between positive and negative.
+*   In contrast, `[1, 4, 7, 2, 5]` and `[1, 7, 4, 5, 5]` are not wiggle sequences. The first is not because its first two differences are positive, and the second is not because its last difference is zero.
+
+A **subsequence** is obtained by deleting some elements (possibly zero) from the original sequence, leaving the remaining elements in their original order.
+
+Given an integer array `nums`, return _the length of the longest **wiggle subsequence** of_ `nums`.
+
+**Example 1:**
+
+**Input:** nums = [1,7,4,9,2,5]
+
+**Output:** 6
+
+**Explanation:** The entire sequence is a wiggle sequence with differences (6, -3, 5, -7, 3).
+
+**Example 2:**
+
+**Input:** nums = [1,17,5,10,13,15,10,5,16,8]
+
+**Output:** 7
+
+**Explanation:** There are several subsequences that achieve this length. One is [1, 17, 10, 13, 10, 16, 8] with differences (16, -7, 3, -3, 6, -8).
+
+**Example 3:**
+
+**Input:** nums = [1,2,3,4,5,6,7,8,9]
+
+**Output:** 2
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `0 <= nums[i] <= 1000`
+
+**Follow up:** Could you solve this in `O(n)` time?

src/main/kotlin/g0301_0400/s0377_combination_sum_iv/Solution.kt

@@ -0,0 +1,34 @@
+package g0301_0400.s0377_combination_sum_iv
+
+// #Medium #Array #Dynamic_Programming #Dynamic_Programming_I_Day_21
+// #2022_11_22_Time_217_ms_(72.41%)_Space_33.9_MB_(86.21%)
+
+import java.util.Arrays
+
+class Solution {
+    private lateinit var storage: IntArray
+
+    fun combinationSum4(nums: IntArray, target: Int): Int {
+        storage = IntArray(target + 1)
+        Arrays.fill(storage, -1)
+        return result(nums, target)
+    }
+
+    private fun result(nums: IntArray, target: Int): Int {
+        if (target < 0) {
+            return 0
+        }
+        if (target == 0) {
+            return 1
+        }
+        if (storage[target] != -1) {
+            return storage[target]
+        }
+        var count = 0
+        for (i in nums) {
+            count += result(nums, target - i)
+        }
+        storage[target] = count
+        return count
+    }
+}

src/main/kotlin/g0301_0400/s0377_combination_sum_iv/readme.md

@@ -0,0 +1,40 @@
+377\. Combination Sum IV
+
+Medium
+
+Given an array of **distinct** integers `nums` and a target integer `target`, return _the number of possible combinations that add up to_ `target`.
+
+The test cases are generated so that the answer can fit in a **32-bit** integer.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], target = 4
+
+**Output:** 7
+
+**Explanation:**
+
+    The possible combination ways are:
+    (1, 1, 1, 1)
+    (1, 1, 2)
+    (1, 2, 1)
+    (1, 3)
+    (2, 1, 1)
+    (2, 2)
+    (3, 1)
+    Note that different sequences are counted as different combinations.
+
+**Example 2:**
+
+**Input:** nums = [9], target = 3
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= nums.length <= 200`
+*   `1 <= nums[i] <= 1000`
+*   All the elements of `nums` are **unique**.
+*   `1 <= target <= 1000`
+
+**Follow up:** What if negative numbers are allowed in the given array? How does it change the problem? What limitation we need to add to the question to allow negative numbers?

src/main/kotlin/g0301_0400/s0380_insert_delete_getrandom_o1/RandomizedSet.kt

@@ -0,0 +1,58 @@
+package g0301_0400.s0380_insert_delete_getrandom_o1
+
+import java.util.Random
+
+// #Medium #Top_Interview_Questions #Array #Hash_Table #Math #Design #Randomized
+// #Programming_Skills_II_Day_20 #2022_11_22_Time_1326_ms_(68.23%)_Space_119.7_MB_(83.53%)
+
+@Suppress("kotlin:S2245")
+class RandomizedSet {
+    private val rand: Random
+    private val list: MutableList<Int>
+    private val map: MutableMap<Int, Int>
+
+    /* Initialize your data structure here. */
+    init {
+        rand = Random()
+        list = ArrayList()
+        map = HashMap()
+    }
+
+    /* Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    fun insert(`val`: Int): Boolean {
+        if (map.containsKey(`val`)) {
+            return false
+        }
+        map[`val`] = list.size
+        list.add(`val`)
+        return true
+    }
+
+    /* Removes a value from the set. Returns true if the set contained the specified element. */
+    fun remove(`val`: Int): Boolean {
+        if (!map.containsKey(`val`)) {
+            return false
+        }
+        val swap1 = map[`val`]!!
+        val swap2 = list.size - 1
+        val val2 = list[swap2]
+        map[val2] = swap1
+        map.remove(`val`)
+        list[swap1] = val2
+        list.removeAt(list.size - 1)
+        return true
+    }
+
+    /* Get a random element from the set. */
+    fun getRandom(): Int {
+        return list[rand.nextInt(list.size)]
+    }
+}
+
+/*
+ * Your RandomizedSet object will be instantiated and called as such:
+ * var obj = RandomizedSet()
+ * var param_1 = obj.insert(`val`)
+ * var param_2 = obj.remove(`val`)
+ * var param_3 = obj.getRandom()
+ */

src/main/kotlin/g0301_0400/s0380_insert_delete_getrandom_o1/readme.md

@@ -0,0 +1,38 @@
+380\. Insert Delete GetRandom O(1)
+
+Medium
+
+Implement the `RandomizedSet` class:
+
+*   `RandomizedSet()` Initializes the `RandomizedSet` object.
+*   `bool insert(int val)` Inserts an item `val` into the set if not present. Returns `true` if the item was not present, `false` otherwise.
+*   `bool remove(int val)` Removes an item `val` from the set if present. Returns `true` if the item was present, `false` otherwise.
+*   `int getRandom()` Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the **same probability** of being returned.
+
+You must implement the functions of the class such that each function works in **average** `O(1)` time complexity.
+
+**Example 1:**
+
+**Input**
+
+    ["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"] 
+    [[], [1], [2], [2], [], [1], [2], []]
+
+**Output:** [null, true, false, true, 2, true, false, 2]
+
+**Explanation:**
+
+    RandomizedSet randomizedSet = new RandomizedSet(); 
+    randomizedSet.insert(1); // Inserts 1 to the set. Returns true as 1 was inserted successfully. 
+    randomizedSet.remove(2); // Returns false as 2 does not exist in the set. 
+    randomizedSet.insert(2); // Inserts 2 to the set, returns true. Set now contains [1,2]. 
+    randomizedSet.getRandom(); // getRandom() should return either 1 or 2 randomly. 
+    randomizedSet.remove(1); // Removes 1 from the set, returns true. Set now contains [2]. 
+    randomizedSet.insert(2); // 2 was already in the set, so return false. 
+    randomizedSet.getRandom(); // Since 2 is the only number in the set, getRandom() will always return 2.
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
+*   At most `2 * `<code>10<sup>5</sup></code> calls will be made to `insert`, `remove`, and `getRandom`.
+*   There will be **at least one** element in the data structure when `getRandom` is called.