Added tasks 1978, 2001, 2002, 2003, 2006, 2007, 2008, 2009

Author: ThanhNIT

README.md

@@ -1847,6 +1847,13 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2009 |[Minimum Number of Operations to Make Array Continuous](src/main/kotlin/g2001_2100/s2009_minimum_number_of_operations_to_make_array_continuous/Solution.kt)| Hard | Array, Binary_Search | 603 | 100.00
+| 2008 |[Maximum Earnings From Taxi](src/main/kotlin/g2001_2100/s2008_maximum_earnings_from_taxi/Solution.kt)| Medium | Array, Dynamic_Programming, Sorting, Binary_Search | 1008 | 100.00
+| 2007 |[Find Original Array From Doubled Array](src/main/kotlin/g2001_2100/s2007_find_original_array_from_doubled_array/Solution.kt)| Medium | Array, Hash_Table, Sorting, Greedy | 753 | 100.00
+| 2006 |[Count Number of Pairs With Absolute Difference K](src/main/kotlin/g2001_2100/s2006_count_number_of_pairs_with_absolute_difference_k/Solution.kt)| Easy | Array, Hash_Table, Counting | 186 | 100.00
+| 2003 |[Smallest Missing Genetic Value in Each Subtree](src/main/kotlin/g2001_2100/s2003_smallest_missing_genetic_value_in_each_subtree/Solution.kt)| Hard | Dynamic_Programming, Depth_First_Search, Tree, Union_Find | 984 | 100.00
+| 2002 |[Maximum Product of the Length of Two Palindromic Subsequences](src/main/kotlin/g2001_2100/s2002_maximum_product_of_the_length_of_two_palindromic_subsequences/Solution.kt)| Medium | String, Dynamic_Programming, Bit_Manipulation, Backtracking, Bitmask | 389 | 100.00
+| 2001 |[Number of Pairs of Interchangeable Rectangles](src/main/kotlin/g2001_2100/s2001_number_of_pairs_of_interchangeable_rectangles/Solution.kt)| Medium | Array, Hash_Table, Math, Counting, Number_Theory | 797 | 100.00
 | 2000 |[Reverse Prefix of Word](src/main/kotlin/g1901_2000/s2000_reverse_prefix_of_word/Solution.kt)| Easy | String, Two_Pointers | 164 | 31.25
 | 1998 |[GCD Sort of an Array](src/main/kotlin/g1901_2000/s1998_gcd_sort_of_an_array/Solution.kt)| Hard | Array, Math, Sorting, Union_Find | 437 | 100.00
 | 1997 |[First Day Where You Have Been in All the Rooms](src/main/kotlin/g1901_2000/s1997_first_day_where_you_have_been_in_all_the_rooms/Solution.kt)| Medium | Array, Dynamic_Programming | 572 | 100.00
@@ -1864,6 +1871,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 | 1981 |[Minimize the Difference Between Target and Chosen Elements](src/main/kotlin/g1901_2000/s1981_minimize_the_difference_between_target_and_chosen_elements/Solution.kt)| Medium | Array, Dynamic_Programming, Matrix | 588 | 100.00
 | 1980 |[Find Unique Binary String](src/main/kotlin/g1901_2000/s1980_find_unique_binary_string/Solution.kt)| Medium | Array, String, Backtracking | 186 | 50.00
 | 1979 |[Find Greatest Common Divisor of Array](src/main/kotlin/g1901_2000/s1979_find_greatest_common_divisor_of_array/Solution.kt)| Easy | Array, Math, Number_Theory | 172 | 100.00
+| 1978 |[Employees Whose Manager Left the Company](src/main/kotlin/g1901_2000/s1978_employees_whose_manager_left_the_company/script.sql)| Easy | Database | 686 | 64.74
 | 1977 |[Number of Ways to Separate Numbers](src/main/kotlin/g1901_2000/s1977_number_of_ways_to_separate_numbers/Solution.kt)| Hard | String, Dynamic_Programming, Suffix_Array | 199 | 100.00
 | 1976 |[Number of Ways to Arrive at Destination](src/main/kotlin/g1901_2000/s1976_number_of_ways_to_arrive_at_destination/Solution.kt)| Medium | Dynamic_Programming, Graph, Topological_Sort, Shortest_Path | 282 | 100.00
 | 1975 |[Maximum Matrix Sum](src/main/kotlin/g1901_2000/s1975_maximum_matrix_sum/Solution.kt)| Medium | Array, Greedy, Matrix | 535 | 100.00

src/main/kotlin/g1901_2000/s1978_employees_whose_manager_left_the_company/readme.md

@@ -0,0 +1,55 @@
+1978\. Employees Whose Manager Left the Company
+
+Easy
+
+SQL Schema
+
+Table: `Employees`
+
+    +-------------+----------+ 
+    | Column Name | Type     | 
+    +-------------+----------+ 
+    | employee_id | int      | 
+    | name        | varchar  | 
+    | manager_id  | int      | 
+    | salary      | int      | 
+    +-------------+----------+ 
+
+employee_id is the primary key for this table. This table contains information about the employees, their salary, and the ID of their manager. Some employees do not have a manager (manager_id is null).
+
+Write an SQL query to report the IDs of the employees whose salary is strictly less than `$30000` and whose manager left the company. When a manager leaves the company, their information is deleted from the `Employees` table, but the reports still have their `manager_id` set to the manager that left.
+
+Return the result table ordered by `employee_id`.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+**Input: ** Employees table: 
+
+    +-------------+-----------+------------+--------+ 
+    | employee_id | name      | manager_id | salary | 
+    +-------------+-----------+------------+--------+ 
+    | 3           | Mila      | 9          | 60301  | 
+    | 12          | Antonella | null       | 31000  | 
+    | 13          | Emery     | null       | 67084  | 
+    | 1           | Kalel     | 11         | 21241  | 
+    | 9           | Mikaela   | null       | 50937  | 
+    | 11          | Joziah    | 6          | 28485  | 
+    +-------------+-----------+------------+--------+
+
+**Output:** 
+
+    +-------------+ 
+    | employee_id | 
+    +-------------+ 
+    | 11          | 
+    +-------------+
+
+**Explanation:**
+
+The employees with a salary less than $30000 are 1 (Kalel) and 11 (Joziah). 
+
+Kalel's manager is employee 11, who is still in the company (Joziah).
+
+Joziah's manager is employee 6, who left the company because there is no row for employee 6 as it was deleted. 

src/main/kotlin/g1901_2000/s1978_employees_whose_manager_left_the_company/script.sql

@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+# #Easy #Database #2023_06_23_Time_686_ms_(64.74%)_Space_0B_(100.00%)
+select employee_id from employees where manager_id not in (select distinct (employee_id) from employees)
+AND salary < 30000 order by employee_id
+

src/main/kotlin/g2001_2100/s2001_number_of_pairs_of_interchangeable_rectangles/Solution.kt

@@ -0,0 +1,37 @@
+package g2001_2100.s2001_number_of_pairs_of_interchangeable_rectangles
+
+// #Medium #Array #Hash_Table #Math #Counting #Number_Theory
+// #2023_06_23_Time_797_ms_(100.00%)_Space_78.6_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    private fun factorial(n: Long): Long {
+        var n = n
+        var m: Long = 0
+        while (n > 0) {
+            m += n
+            n -= 1
+        }
+        return m
+    }
+
+    fun interchangeableRectangles(rec: Array<IntArray>): Long {
+        val ratio = DoubleArray(rec.size)
+        for (i in rec.indices) {
+            ratio[i] = rec[i][0].toDouble() / rec[i][1]
+        }
+        ratio.sort()
+        var res: Long = 0
+        var k = 0
+        for (j in 0 until ratio.size - 1) {
+            if (ratio[j] == ratio[j + 1]) {
+                k++
+            }
+            if (ratio[j] != ratio[j + 1] || j + 2 == ratio.size) {
+                res += factorial(k.toLong())
+                k = 0
+            }
+        }
+        return res
+    }
+}

src/main/kotlin/g2001_2100/s2001_number_of_pairs_of_interchangeable_rectangles/readme.md

@@ -0,0 +1,44 @@
+2001\. Number of Pairs of Interchangeable Rectangles
+
+Medium
+
+You are given `n` rectangles represented by a **0-indexed** 2D integer array `rectangles`, where <code>rectangles[i] = [width<sub>i</sub>, height<sub>i</sub>]</code> denotes the width and height of the <code>i<sup>th</sup></code> rectangle.
+
+Two rectangles `i` and `j` (`i < j`) are considered **interchangeable** if they have the **same** width-to-height ratio. More formally, two rectangles are **interchangeable** if <code>width<sub>i</sub>/height<sub>i</sub> == width<sub>j</sub>/height<sub>j</sub></code> (using decimal division, not integer division).
+
+Return _the **number** of pairs of **interchangeable** rectangles in_ `rectangles`.
+
+**Example 1:**
+
+**Input:** rectangles = [[4,8],[3,6],[10,20],[15,30]]
+
+**Output:** 6
+
+**Explanation:** The following are the interchangeable pairs of rectangles by index (0-indexed): 
+
+- Rectangle 0 with rectangle 1: 4/8 == 3/6. 
+
+- Rectangle 0 with rectangle 2: 4/8 == 10/20. 
+
+- Rectangle 0 with rectangle 3: 4/8 == 15/30. 
+
+- Rectangle 1 with rectangle 2: 3/6 == 10/20. 
+
+- Rectangle 1 with rectangle 3: 3/6 == 15/30. 
+
+- Rectangle 2 with rectangle 3: 10/20 == 15/30.
+
+**Example 2:**
+
+**Input:** rectangles = [[4,5],[7,8]]
+
+**Output:** 0
+
+**Explanation:** There are no interchangeable pairs of rectangles.
+
+**Constraints:**
+
+*   `n == rectangles.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `rectangles[i].length == 2`
+*   <code>1 <= width<sub>i</sub>, height<sub>i</sub> <= 10<sup>5</sup></code>

src/main/kotlin/g2001_2100/s2002_maximum_product_of_the_length_of_two_palindromic_subsequences/Solution.kt

@@ -0,0 +1,73 @@
+package g2001_2100.s2002_maximum_product_of_the_length_of_two_palindromic_subsequences
+
+// #Medium #String #Dynamic_Programming #Bit_Manipulation #Backtracking #Bitmask
+// #2023_06_23_Time_389_ms_(100.00%)_Space_43.3_MB_(100.00%)
+
+class Solution {
+    fun maxProduct(s: String): Int {
+        if (s.length == 2) {
+            return 1
+        }
+        val list: MutableList<State> = ArrayList()
+        val chars = s.toCharArray()
+        val visited: MutableSet<State> = HashSet()
+        for (i in chars.indices) {
+            val mask = 1 shl i
+            recur(chars, State(i, i, 0, mask), list, visited)
+            recur(chars, State(i, i + 1, 0, mask), list, visited)
+        }
+        list.sortWith { a: State, b: State -> b.cnt - a.cnt }
+        var res = 1
+        val explored: MutableSet<Int> = HashSet()
+        for (i in 0 until list.size - 1) {
+            if (explored.contains(i)) {
+                continue
+            }
+            val cur = list[i]
+            if (cur.cnt == 1) {
+                break
+            }
+            for (j in i + 1 until list.size) {
+                val cand = list[j]
+                if (cur.mask and cand.mask < 1) {
+                    if (explored.add(j)) {
+                        res = res.coerceAtLeast(cur.cnt * cand.cnt)
+                    }
+                    break
+                }
+            }
+        }
+        return res
+    }
+
+    private fun recur(chars: CharArray, s: State, list: MutableList<State>, visited: MutableSet<State>) {
+        if (s.i < 0 || s.j >= chars.size) {
+            return
+        }
+        if (!visited.add(s)) {
+            return
+        }
+        if (chars[s.i] == chars[s.j]) {
+            val m = s.mask or (1 shl s.i) or (1 shl s.j)
+            val nextCnt = s.cnt + if (s.i < s.j) 2 else 1
+            list.add(State(s.i, s.j, nextCnt, m))
+            recur(chars, State(s.i - 1, s.j + 1, nextCnt, m), list, visited)
+        }
+        recur(chars, State(s.i - 1, s.j, s.cnt, s.mask), list, visited)
+        recur(chars, State(s.i, s.j + 1, s.cnt, s.mask), list, visited)
+    }
+
+    private class State(var i: Int, var j: Int, var cnt: Int, var mask: Int) {
+        override fun equals(other: Any?): Boolean {
+            if (other == null || other.javaClass != this.javaClass) {
+                return false
+            }
+            val s = other as State
+            return i == s.i && j == s.j && mask == s.mask
+        }
+
+        override fun hashCode(): Int {
+            return (i * 31 + j) * 31 + mask
+        }
+    }
+}

src/main/kotlin/g2001_2100/s2002_maximum_product_of_the_length_of_two_palindromic_subsequences/readme.md

@@ -0,0 +1,46 @@
+2002\. Maximum Product of the Length of Two Palindromic Subsequences
+
+Medium
+
+Given a string `s`, find two **disjoint palindromic subsequences** of `s` such that the **product** of their lengths is **maximized**. The two subsequences are **disjoint** if they do not both pick a character at the same index.
+
+Return _the **maximum** possible **product** of the lengths of the two palindromic subsequences_.
+
+A **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters. A string is **palindromic** if it reads the same forward and backward.
+
+**Example 1:**
+
+![example-1](https://assets.leetcode.com/uploads/2021/08/24/two-palindromic-subsequences.png)
+
+**Input:** s = "leetcodecom"
+
+**Output:** 9
+
+**Explanation:** An optimal solution is to choose "ete" for the 1<sup>st</sup> subsequence and "cdc" for the 2<sup>nd</sup> subsequence.
+
+The product of their lengths is: 3 \* 3 = 9. 
+
+**Example 2:**
+
+**Input:** s = "bb"
+
+**Output:** 1
+
+**Explanation:** An optimal solution is to choose "b" (the first character) for the 1<sup>st</sup> subsequence and "b" (the second character) for the 2<sup>nd</sup> subsequence.
+
+The product of their lengths is: 1 \* 1 = 1. 
+
+**Example 3:**
+
+**Input:** s = "accbcaxxcxx"
+
+**Output:** 25
+
+**Explanation:** An optimal solution is to choose "accca" for the 1<sup>st</sup> subsequence and "xxcxx" for the 2<sup>nd</sup> subsequence.
+
+The product of their lengths is: 5 \* 5 = 25. 
+
+**Constraints:**
+
+*   `2 <= s.length <= 12`
+*   `s` consists of lowercase English letters only.

src/main/kotlin/g2001_2100/s2003_smallest_missing_genetic_value_in_each_subtree/Solution.kt

@@ -0,0 +1,79 @@
+package g2001_2100.s2003_smallest_missing_genetic_value_in_each_subtree
+
+// #Hard #Dynamic_Programming #Depth_First_Search #Tree #Union_Find
+// #2023_06_23_Time_984_ms_(100.00%)_Space_78.9_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun smallestMissingValueSubtree(parents: IntArray, nums: IntArray): IntArray {
+        val ans = IntArray(parents.size)
+        val all = arrayOfNulls<Node>(parents.size)
+        var max = 0
+        for (i in nums.indices) {
+            all[i] = Node(i, nums[i])
+            max = max.coerceAtLeast(nums[i])
+        }
+        for (i in 1 until parents.size) {
+            all[parents[i]]!!.nodes.add(all[i])
+        }
+        solve(all[0], ans, UF(++max, nums))
+        return ans
+    }
+
+    private fun solve(root: Node?, ans: IntArray, uf: UF) {
+        var max = 1
+        for (child in root!!.nodes) {
+            solve(child, ans, uf)
+            uf.union(root.`val`, child!!.`val`)
+            max = ans[child.idx].coerceAtLeast(max)
+        }
+        while (max <= ans.size && uf.isConnected(max, root.`val`)) {
+            ++max
+        }
+        ans[root.idx] = max
+    }
+
+    private class Node internal constructor(var idx: Int, var `val`: Int) {
+        var nodes: MutableList<Node?> = ArrayList()
+    }
+
+    private class UF internal constructor(n: Int, nums: IntArray) {
+        var rank: IntArray
+        var parent: IntArray
+
+        init {
+            rank = IntArray(n)
+            parent = IntArray(n)
+            for (m in nums) {
+                parent[m] = m
+            }
+        }
+
+        private fun find(x: Int): Int {
+            if (x == parent[x]) {
+                return x
+            }
+            parent[x] = find(parent[x])
+            return parent[x]
+        }
+
+        fun union(x: Int, y: Int) {
+            var x = x
+            var y = y
+            x = find(x)
+            y = find(y)
+            if (rank[x] > rank[y]) {
+                parent[y] = x
+            } else {
+                parent[x] = y
+                if (rank[x] == rank[y]) {
+                    rank[y]++
+                }
+            }
+        }
+
+        fun isConnected(x: Int, y: Int): Boolean {
+            return find(x) == find(y)
+        }
+    }
+}