+ problem 1964

Author: fruit-in

Problemset/1964-Find the Longest Valid Obstacle Course at Each Position/README.md

@@ -0,0 +1,77 @@
+# 1964. Find the Longest Valid Obstacle Course at Each Position
+You want to build some obstacle courses. You are given a **0-indexed** integer array `obstacles` of length `n`, where `obstacles[i]` describes the height of the <code>i<sup>th</sup></code> obstacle.
+
+For every index `i` between `0` and `n - 1` (**inclusive**), find the length of the **longest obstacle course** in `obstacles` such that:
+
+* You choose any number of obstacles between `0` and `i` **inclusive**.
+* You must include the <code>i<sup>th</sup></code> obstacle in the course.
+* You must put the chosen obstacles in the **same order** as they appear in `obstacles`.
+* Every obstacle (except the first) is **taller** than or the **same height** as the obstacle immediately before it.
+
+Return *an array* `ans` *of length* `n`, *where* `ans[i]` *is the length of the **longest obstacle course** for index* `i` *as described above*.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> obstacles = [1,2,3,2]
+<strong>Output:</strong> [1,2,3,3]
+<strong>Explanation:</strong> The longest valid obstacle course at each position is:
+- i = 0: [1], [1] has length 1.
+- i = 1: [1,2], [1,2] has length 2.
+- i = 2: [1,2,3], [1,2,3] has length 3.
+- i = 3: [1,2,3,2], [1,2,2] has length 3.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> obstacles = [2,2,1]
+<strong>Output:</strong> [1,2,1]
+<strong>Explanation:</strong> The longest valid obstacle course at each position is:
+- i = 0: [2], [2] has length 1.
+- i = 1: [2,2], [2,2] has length 2.
+- i = 2: [2,2,1], [1] has length 1.
+</pre>
+
+#### Example 3:
+<pre>
+<strong>Input:</strong> obstacles = [3,1,5,6,4,2]
+<strong>Output:</strong> [1,1,2,3,2,2]
+<strong>Explanation:</strong> The longest valid obstacle course at each position is:
+- i = 0: [3], [3] has length 1.
+- i = 1: [3,1], [1] has length 1.
+- i = 2: [3,1,5], [3,5] has length 2. [1,5] is also valid.
+- i = 3: [3,1,5,6], [3,5,6] has length 3. [1,5,6] is also valid.
+- i = 4: [3,1,5,6,4], [3,4] has length 2. [1,4] is also valid.
+- i = 5: [3,1,5,6,4,2], [1,2] has length 2.
+</pre>
+
+#### Constraints:
+* `n == obstacles.length`
+* <code>1 <= n <= 10<sup>5</sup></code>
+* <code>1 <= obstacles[i] <= 10<sup>7</sup></code>
+
+## Solutions (Python)
+
+### 1. Solution
+```Python
+from sortedcontainers import SortedList
+
+
+class Solution:
+    def longestObstacleCourseAtEachPosition(self, obstacles: List[int]) -> List[int]:
+        n = len(obstacles)
+        sl = SortedList([(0, 0)])
+        ans = [1] * n
+
+        for i in range(n):
+            j = sl.bisect_left((obstacles[i], n)) - 1
+            ans[i] = sl[j][1] + 1
+
+            if j + 1 < len(sl) and sl[j + 1][1] == ans[i]:
+                sl.pop(j + 1)
+            if sl[j][0] == obstacles[i]:
+                sl.pop(j)
+
+            sl.add((obstacles[i], ans[i]))
+
+        return ans
+```

Problemset/1964-Find the Longest Valid Obstacle Course at Each Position/README_CN.md

@@ -0,0 +1,77 @@
+# 1964. 找出到每个位置为止最长的有效障碍赛跑路线
+你打算构建一些障碍赛跑路线。给你一个 **下标从 0 开始** 的整数数组 `obstacles` ，数组长度为 `n` ，其中 `obstacles[i]` 表示第 `i` 个障碍的高度。
+
+对于每个介于 `0` 和 `n - 1` 之间（包含 `0` 和 `n - 1`）的下标  `i` ，在满足下述条件的前提下，请你找出 `obstacles` 能构成的最长障碍路线的长度：
+
+* 你可以选择下标介于 `0` 到 `i` 之间（包含 `0` 和 `i`）的任意个障碍。
+* 在这条路线中，必须包含第 `i` 个障碍。
+* 你必须按障碍在 `obstacles` 中的 **出现顺序** 布置这些障碍。
+* 除第一个障碍外，路线中每个障碍的高度都必须和前一个障碍 **相同** 或者 **更高** 。
+
+返回长度为 `n` 的答案数组 `ans` ，其中 `ans[i]` 是上面所述的下标 `i` 对应的最长障碍赛跑路线的长度。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> obstacles = [1,2,3,2]
+<strong>输出:</strong> [1,2,3,3]
+<strong>解释:</strong> 每个位置的最长有效障碍路线是：
+- i = 0: [1], [1] 长度为 1
+- i = 1: [1,2], [1,2] 长度为 2
+- i = 2: [1,2,3], [1,2,3] 长度为 3
+- i = 3: [1,2,3,2], [1,2,2] 长度为 3
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> obstacles = [2,2,1]
+<strong>输出:</strong> [1,2,1]
+<strong>解释:</strong> 每个位置的最长有效障碍路线是：
+- i = 0: [2], [2] 长度为 1
+- i = 1: [2,2], [2,2] 长度为 2
+- i = 2: [2,2,1], [1] 长度为 1
+</pre>
+
+#### 示例 3:
+<pre>
+<strong>输入:</strong> obstacles = [3,1,5,6,4,2]
+<strong>输出:</strong> [1,1,2,3,2,2]
+<strong>解释:</strong> 每个位置的最长有效障碍路线是：
+- i = 0: [3], [3] 长度为 1
+- i = 1: [3,1], [1] 长度为 1
+- i = 2: [3,1,5], [3,5] 长度为 2, [1,5] 也是有效的障碍赛跑路线
+- i = 3: [3,1,5,6], [3,5,6] 长度为 3, [1,5,6] 也是有效的障碍赛跑路线
+- i = 4: [3,1,5,6,4], [3,4] 长度为 2, [1,4] 也是有效的障碍赛跑路线
+- i = 5: [3,1,5,6,4,2], [1,2] 长度为 2
+</pre>
+
+#### 提示:
+* `n == obstacles.length`
+* <code>1 <= n <= 10<sup>5</sup></code>
+* <code>1 <= obstacles[i] <= 10<sup>7</sup></code>
+
+## 题解 (Python)
+
+### 1. 题解
+```Python
+from sortedcontainers import SortedList
+
+
+class Solution:
+    def longestObstacleCourseAtEachPosition(self, obstacles: List[int]) -> List[int]:
+        n = len(obstacles)
+        sl = SortedList([(0, 0)])
+        ans = [1] * n
+
+        for i in range(n):
+            j = sl.bisect_left((obstacles[i], n)) - 1
+            ans[i] = sl[j][1] + 1
+
+            if j + 1 < len(sl) and sl[j + 1][1] == ans[i]:
+                sl.pop(j + 1)
+            if sl[j][0] == obstacles[i]:
+                sl.pop(j)
+
+            sl.add((obstacles[i], ans[i]))
+
+        return ans
+```

Problemset/1964-Find the Longest Valid Obstacle Course at Each Position/Solution.py

@@ -0,0 +1,21 @@
+from sortedcontainers import SortedList
+
+
+class Solution:
+    def longestObstacleCourseAtEachPosition(self, obstacles: List[int]) -> List[int]:
+        n = len(obstacles)
+        sl = SortedList([(0, 0)])
+        ans = [1] * n
+
+        for i in range(n):
+            j = sl.bisect_left((obstacles[i], n)) - 1
+            ans[i] = sl[j][1] + 1
+
+            if j + 1 < len(sl) and sl[j + 1][1] == ans[i]:
+                sl.pop(j + 1)
+            if sl[j][0] == obstacles[i]:
+                sl.pop(j)
+
+            sl.add((obstacles[i], ans[i]))
+
+        return ans

README.md

@@ -1183,6 +1183,7 @@
 [1961][1961l]|[Check If String Is a Prefix of Array][1961]                                          |![py]
 [1962][1962l]|[Remove Stones to Minimize the Total][1962]                                           |![rs]
 [1963][1963l]|[Minimum Number of Swaps to Make the String Balanced][1963]                           |![rs]
+[1964][1964l]|[Find the Longest Valid Obstacle Course at Each Position][1964]                       |![py]
 [1967][1967l]|[Number of Strings That Appear as Substrings in Word][1967]                           |![py]
 [1968][1968l]|[Array With Elements Not Equal to Average of Neighbors][1968]                         |![rs]
 [1969][1969l]|[Minimum Non-Zero Product of the Array Elements][1969]                                |![rs]
@@ -2718,6 +2719,7 @@
 [1961]:Problemset/1961-Check%20If%20String%20Is%20a%20Prefix%20of%20Array/README.md#1961-check-if-string-is-a-prefix-of-array
 [1962]:Problemset/1962-Remove%20Stones%20to%20Minimize%20the%20Total/README.md#1962-remove-stones-to-minimize-the-total
 [1963]:Problemset/1963-Minimum%20Number%20of%20Swaps%20to%20Make%20the%20String%20Balanced/README.md#1963-minimum-number-of-swaps-to-make-the-string-balanced
+[1964]:Problemset/1964-Find%20the%20Longest%20Valid%20Obstacle%20Course%20at%20Each%20Position/README.md#1964-find-the-longest-valid-obstacle-course-at-each-position
 [1967]:Problemset/1967-Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word/README.md#1967-number-of-strings-that-appear-as-substrings-in-word
 [1968]:Problemset/1968-Array%20With%20Elements%20Not%20Equal%20to%20Average%20of%20Neighbors/README.md#1968-array-with-elements-not-equal-to-average-of-neighbors
 [1969]:Problemset/1969-Minimum%20Non-Zero%20Product%20of%20the%20Array%20Elements/README.md#1969-minimum-non-zero-product-of-the-array-elements
@@ -4252,6 +4254,7 @@
 [1961l]:https://leetcode.com/problems/check-if-string-is-a-prefix-of-array/
 [1962l]:https://leetcode.com/problems/remove-stones-to-minimize-the-total/
 [1963l]:https://leetcode.com/problems/minimum-number-of-swaps-to-make-the-string-balanced/
+[1964l]:https://leetcode.com/problems/find-the-longest-valid-obstacle-course-at-each-position/
 [1967l]:https://leetcode.com/problems/number-of-strings-that-appear-as-substrings-in-word/
 [1968l]:https://leetcode.com/problems/array-with-elements-not-equal-to-average-of-neighbors/
 [1969l]:https://leetcode.com/problems/minimum-non-zero-product-of-the-array-elements/

README_CN.md

@@ -1183,6 +1183,7 @@
 [1961][1961l]|[检查字符串是否为数组前缀][1961]                          |![py]
 [1962][1962l]|[移除石子使总数最小][1962]                                |![rs]
 [1963][1963l]|[使字符串平衡的最小交换次数][1963]                        |![rs]
+[1964][1964l]|[找出到每个位置为止最长的有效障碍赛跑路线][1964]          |![py]
 [1967][1967l]|[作为子字符串出现在单词中的字符串数目][1967]              |![py]
 [1968][1968l]|[构造元素不等于两相邻元素平均值的数组][1968]              |![rs]
 [1969][1969l]|[数组元素的最小非零乘积][1969]                            |![rs]
@@ -2718,6 +2719,7 @@
 [1961]:Problemset/1961-Check%20If%20String%20Is%20a%20Prefix%20of%20Array/README_CN.md#1961-检查字符串是否为数组前缀
 [1962]:Problemset/1962-Remove%20Stones%20to%20Minimize%20the%20Total/README_CN.md#1962-移除石子使总数最小
 [1963]:Problemset/1963-Minimum%20Number%20of%20Swaps%20to%20Make%20the%20String%20Balanced/README_CN.md#1963-使字符串平衡的最小交换次数
+[1964]:Problemset/1964-Find%20the%20Longest%20Valid%20Obstacle%20Course%20at%20Each%20Position/README_CN.md#1964-找出到每个位置为止最长的有效障碍赛跑路线
 [1967]:Problemset/1967-Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word/README_CN.md#1967-作为子字符串出现在单词中的字符串数目
 [1968]:Problemset/1968-Array%20With%20Elements%20Not%20Equal%20to%20Average%20of%20Neighbors/README_CN.md#1968-构造元素不等于两相邻元素平均值的数组
 [1969]:Problemset/1969-Minimum%20Non-Zero%20Product%20of%20the%20Array%20Elements/README_CN.md#1969-数组元素的最小非零乘积
@@ -4252,6 +4254,7 @@
 [1961l]:https://leetcode.cn/problems/check-if-string-is-a-prefix-of-array/
 [1962l]:https://leetcode.cn/problems/remove-stones-to-minimize-the-total/
 [1963l]:https://leetcode.cn/problems/minimum-number-of-swaps-to-make-the-string-balanced/
+[1964l]:https://leetcode.cn/problems/find-the-longest-valid-obstacle-course-at-each-position/
 [1967l]:https://leetcode.cn/problems/number-of-strings-that-appear-as-substrings-in-word/
 [1968l]:https://leetcode.cn/problems/array-with-elements-not-equal-to-average-of-neighbors/
 [1969l]:https://leetcode.cn/problems/minimum-non-zero-product-of-the-array-elements/