Added tasks 2053-2063

Author: ThanhNIT

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

@@ -0,0 +1,23 @@
+package g2001_2100.s2053_kth_distinct_string_in_an_array
+
+// #Easy #Array #String #Hash_Table #Counting
+// #2023_06_25_Time_181_ms_(90.00%)_Space_36.9_MB_(90.00%)
+
+class Solution {
+    fun kthDistinct(arr: Array<String>, k: Int): String {
+        val m: MutableMap<String, Int> = HashMap()
+        for (value in arr) {
+            m[value] = m.getOrDefault(value, 0) + 1
+        }
+        var c = 0
+        for (s in arr) {
+            if (m[s] == 1) {
+                ++c
+                if (c == k) {
+                    return s
+                }
+            }
+        }
+        return ""
+    }
+}

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

@@ -0,0 +1,49 @@
+2053\. Kth Distinct String in an Array
+
+Easy
+
+A **distinct string** is a string that is present only **once** in an array.
+
+Given an array of strings `arr`, and an integer `k`, return _the_ <code>k<sup>th</sup></code> _**distinct string** present in_ `arr`. If there are **fewer** than `k` distinct strings, return _an **empty string**_ `""`.
+
+Note that the strings are considered in the **order in which they appear** in the array.
+
+**Example 1:**
+
+**Input:** arr = ["d","b","c","b","c","a"], k = 2
+
+**Output:** "a"
+
+**Explanation:**
+
+The only distinct strings in arr are "d" and "a".
+
+"d" appears 1<sup>st</sup>, so it is the 1<sup>st</sup> distinct string.
+
+"a" appears 2<sup>nd</sup>, so it is the 2<sup>nd</sup> distinct string.
+
+Since k == 2, "a" is returned. 
+
+**Example 2:**
+
+**Input:** arr = ["aaa","aa","a"], k = 1
+
+**Output:** "aaa"
+
+**Explanation:**
+
+All strings in arr are distinct, so the 1<sup>st</sup> string "aaa" is returned. 
+
+**Example 3:**
+
+**Input:** arr = ["a","b","a"], k = 3
+
+**Output:** ""
+
+**Explanation:** The only distinct string is "b". Since there are fewer than 3 distinct strings, we return an empty string "". 
+
+**Constraints:**
+
+*   `1 <= k <= arr.length <= 1000`
+*   `1 <= arr[i].length <= 5`
+*   `arr[i]` consists of lowercase English letters.

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

@@ -0,0 +1,40 @@
+package g2001_2100.s2054_two_best_non_overlapping_events
+
+// #Medium #Array #Dynamic_Programming #Sorting #Binary_Search #Heap_Priority_Queue
+// #2023_06_25_Time_851_ms_(100.00%)_Space_108.7_MB_(50.00%)
+
+import java.util.Arrays
+
+class Solution {
+    fun maxTwoEvents(events: Array<IntArray>): Int {
+        Arrays.sort(events) { a: IntArray, b: IntArray -> a[0] - b[0] }
+        val max = IntArray(events.size)
+        for (i in events.indices.reversed()) {
+            if (i == events.size - 1) {
+                max[i] = events[i][2]
+            } else {
+                max[i] = events[i][2].coerceAtLeast(max[i + 1])
+            }
+        }
+        var ans = 0
+        for (i in events.indices) {
+            val end = events[i][1]
+            var left = i + 1
+            var right = events.size
+            while (left < right) {
+                val mid = left + (right - left) / 2
+                if (events[mid][0] <= end) {
+                    left = mid + 1
+                } else {
+                    right = mid
+                }
+            }
+            var value = events[i][2]
+            if (right < events.size) {
+                value += max[right]
+            }
+            ans = ans.coerceAtLeast(value)
+        }
+        return ans
+    }
+}

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

@@ -0,0 +1,46 @@
+2054\. Two Best Non-Overlapping Events
+
+Medium
+
+You are given a **0-indexed** 2D integer array of `events` where <code>events[i] = [startTime<sub>i</sub>, endTime<sub>i</sub>, value<sub>i</sub>]</code>. The <code>i<sup>th</sup></code> event starts at <code>startTime<sub>i</sub></code> and ends at <code>endTime<sub>i</sub></code>, and if you attend this event, you will receive a value of <code>value<sub>i</sub></code>. You can choose **at most** **two** **non-overlapping** events to attend such that the sum of their values is **maximized**.
+
+Return _this **maximum** sum._
+
+Note that the start time and end time is **inclusive**: that is, you cannot attend two events where one of them starts and the other ends at the same time. More specifically, if you attend an event with end time `t`, the next event must start at or after `t + 1`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/09/21/picture5.png)
+
+**Input:** events = [[1,3,2],[4,5,2],[2,4,3]]
+
+**Output:** 4
+
+**Explanation:** Choose the green events, 0 and 1 for a sum of 2 + 2 = 4. 
+
+**Example 2:**
+
+![Example 1 Diagram](https://assets.leetcode.com/uploads/2021/09/21/picture1.png)
+
+**Input:** events = [[1,3,2],[4,5,2],[1,5,5]]
+
+**Output:** 5
+
+**Explanation:** Choose event 2 for a sum of 5. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/09/21/picture3.png)
+
+**Input:** events = [[1,5,3],[1,5,1],[6,6,5]]
+
+**Output:** 8
+
+**Explanation:** Choose events 0 and 2 for a sum of 3 + 5 = 8.
+
+**Constraints:**
+
+*   <code>2 <= events.length <= 10<sup>5</sup></code>
+*   `events[i].length == 3`
+*   <code>1 <= startTime<sub>i</sub> <= endTime<sub>i</sub> <= 10<sup>9</sup></code>
+*   <code>1 <= value<sub>i</sub> <= 10<sup>6</sup></code>

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

@@ -0,0 +1,47 @@
+package g2001_2100.s2055_plates_between_candles
+
+// #Medium #Array #String #Binary_Search #Prefix_Sum
+// #2023_06_25_Time_831_ms_(100.00%)_Space_96.3_MB_(100.00%)
+
+class Solution {
+    fun platesBetweenCandles(s: String, queries: Array<IntArray>): IntArray {
+        val sa = s.toCharArray()
+        val n = sa.size
+        val nextCandle = IntArray(n + 1)
+        nextCandle[n] = -1
+        for (i in n - 1 downTo 0) {
+            nextCandle[i] = if (sa[i] == '|') i else nextCandle[i + 1]
+        }
+        val prevCandle = IntArray(n)
+        val prevPlates = IntArray(n)
+        var countPlate = 0
+        if (sa[0] == '*') {
+            countPlate = 1
+            prevCandle[0] = -1
+        }
+        for (i in 1 until n) {
+            if (sa[i] == '|') {
+                prevCandle[i] = i
+                prevPlates[i] = countPlate
+            } else {
+                prevCandle[i] = prevCandle[i - 1]
+                countPlate++
+            }
+        }
+        val len = queries.size
+        val res = IntArray(len)
+        for (i in 0 until len) {
+            val query = queries[i]
+            val start = query[0]
+            val end = query[1]
+            var curPlates = 0
+            val endCandle = prevCandle[end]
+            if (endCandle >= start) {
+                val startCandle = nextCandle[start]
+                curPlates = prevPlates[endCandle] - prevPlates[startCandle]
+            }
+            res[i] = curPlates
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,39 @@
+2055\. Plates Between Candles
+
+Medium
+
+There is a long table with a line of plates and candles arranged on top of it. You are given a **0-indexed** string `s` consisting of characters `'*'` and `'|'` only, where a `'*'` represents a **plate** and a `'|'` represents a **candle**.
+
+You are also given a **0-indexed** 2D integer array `queries` where <code>queries[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> denotes the **substring** <code>s[left<sub>i</sub>...right<sub>i</sub>]</code> (**inclusive**). For each query, you need to find the **number** of plates **between candles** that are **in the substring**. A plate is considered **between candles** if there is at least one candle to its left **and** at least one candle to its right **in the substring**.
+
+*   For example, `s = "||**||**|*"`, and a query `[3, 8]` denotes the substring `"*||******|"`. The number of plates between candles in this substring is `2`, as each of the two plates has at least one candle **in the substring** to its left **and** right.
+
+Return _an integer array_ `answer` _where_ `answer[i]` _is the answer to the_ <code>i<sup>th</sup></code> _query_.
+
+**Example 1:**
+
+![ex-1](https://assets.leetcode.com/uploads/2021/10/04/ex-1.png)
+
+**Input:** s = "\*\*|\*\*|\*\*\*|", queries = [[2,5],[5,9]]
+
+**Output:** [2,3]
+
+**Explanation:** - queries[0] has two plates between candles. - queries[1] has three plates between candles. 
+
+**Example 2:**
+
+![ex-2](https://assets.leetcode.com/uploads/2021/10/04/ex-2.png)
+
+**Input:** s = "\*\*\*|\*\*|\*\*\*\*\*|\*\*||\*\*|\*", queries = [[1,17],[4,5],[14,17],[5,11],[15,16]]
+
+**Output:** [9,0,0,0,0]
+
+**Explanation:** - queries[0] has nine plates between candles. - The other queries have zero plates between candles. 
+
+**Constraints:**
+
+*   <code>3 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of `'*'` and `'|'` characters.
+*   <code>1 <= queries.length <= 10<sup>5</sup></code>
+*   `queries[i].length == 2`
+*   <code>0 <= left<sub>i</sub> <= right<sub>i</sub> < s.length</code>

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

@@ -0,0 +1,103 @@
+package g2001_2100.s2056_number_of_valid_move_combinations_on_chessboard
+
+// #Hard #Array #String #Simulation #Backtracking
+// #2023_06_25_Time_600_ms_(100.00%)_Space_44.1_MB_(100.00%)
+
+class Solution {
+    // 0: rook, queen, bishop
+    private val dirs = arrayOf(
+        arrayOf(intArrayOf(-1, 0), intArrayOf(1, 0), intArrayOf(0, -1), intArrayOf(0, 1)),
+        arrayOf(
+            intArrayOf(-1, 0),
+            intArrayOf(1, 0),
+            intArrayOf(0, -1),
+            intArrayOf(0, 1),
+            intArrayOf(1, 1),
+            intArrayOf(-1, -1),
+            intArrayOf(-1, 1),
+            intArrayOf(1, -1)
+        ),
+        arrayOf(intArrayOf(1, 1), intArrayOf(-1, -1), intArrayOf(-1, 1), intArrayOf(1, -1))
+    )
+
+    fun countCombinations(pieces: Array<String?>, positions: Array<IntArray>): Int {
+        val endPosition: Array<ArrayList<IntArray>?> = arrayOfNulls(pieces.size)
+        for (i in pieces.indices) {
+            endPosition[i] = ArrayList()
+        }
+        for (i in pieces.indices) {
+            positions[i][0]--
+            positions[i][1]--
+            endPosition[i]!!.add(positions[i])
+            var dirIndex = 0
+            when (pieces[i]) {
+                "rook" -> dirIndex = 0
+                "queen" -> dirIndex = 1
+                "bishop" -> dirIndex = 2
+            }
+            for (d in dirs[dirIndex]) {
+                var r = positions[i][0]
+                var c = positions[i][1]
+                while (true) {
+                    r += d[0]
+                    c += d[1]
+                    if (r < 0 || r >= 8 || c < 0 || c >= 8) {
+                        break
+                    }
+                    endPosition[i]!!.add(intArrayOf(r, c))
+                }
+            }
+        }
+        return dfs(positions, endPosition, IntArray(pieces.size), 0)
+    }
+
+    private fun dfs(positions: Array<IntArray>, stop: Array<ArrayList<IntArray>?>, stopIndex: IntArray, cur: Int): Int {
+        if (cur == stopIndex.size) {
+            val p = Array(positions.size) { IntArray(2) }
+            for (i in p.indices) {
+                p[i] = intArrayOf(positions[i][0], positions[i][1])
+            }
+            return check(p, stop, stopIndex)
+        }
+        var res = 0
+        for (i in stop[cur]!!.indices) {
+            stopIndex[cur] = i
+            res += dfs(positions, stop, stopIndex, cur + 1)
+        }
+        return res
+    }
+
+    private fun check(positions: Array<IntArray>, stop: Array<ArrayList<IntArray>?>, stopIndex: IntArray): Int {
+        var keepGoing = true
+        while (keepGoing) {
+            keepGoing = false
+            for (i in positions.indices) {
+                var diff = stop[i]!![stopIndex[i]][0] - positions[i][0]
+                if (diff > 0) {
+                    keepGoing = true
+                    positions[i][0]++
+                } else if (diff < 0) {
+                    keepGoing = true
+                    positions[i][0]--
+                }
+                diff = stop[i]!![stopIndex[i]][1] - positions[i][1]
+                if (diff > 0) {
+                    keepGoing = true
+                    positions[i][1]++
+                } else if (diff < 0) {
+                    keepGoing = true
+                    positions[i][1]--
+                }
+            }
+            val seen: MutableSet<Int> = HashSet()
+            for (position in positions) {
+                val key = position[0] * 100 + position[1]
+                if (seen.contains(key)) {
+                    return 0
+                }
+                seen.add(key)
+            }
+        }
+        return 1
+    }
+}