From c38da549ea9a1002eb59cb505f41a58a3e3ac5fa Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Mon, 17 Feb 2025 16:10:41 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.1288 (#4071) No.1288.Remove Covered Intervals --- .../1288.Remove Covered Intervals/README.md | 111 +++++++++++++----- .../README_EN.md | 111 +++++++++++++----- .../Solution.cpp | 20 ++-- .../1288.Remove Covered Intervals/Solution.go | 20 ++-- .../Solution.java | 18 +-- .../1288.Remove Covered Intervals/Solution.js | 16 +++ .../1288.Remove Covered Intervals/Solution.py | 13 +- .../1288.Remove Covered Intervals/Solution.ts | 12 ++ 8 files changed, 223 insertions(+), 98 deletions(-) create mode 100644 solution/1200-1299/1288.Remove Covered Intervals/Solution.js create mode 100644 solution/1200-1299/1288.Remove Covered Intervals/Solution.ts diff --git a/solution/1200-1299/1288.Remove Covered Intervals/README.md b/solution/1200-1299/1288.Remove Covered Intervals/README.md index 5d2bc3403b189..a8a14d4967354 100644 --- a/solution/1200-1299/1288.Remove Covered Intervals/README.md +++ b/solution/1200-1299/1288.Remove Covered Intervals/README.md @@ -51,7 +51,13 @@ tags: -### 方法一 +### 方法一：排序 + +我们可以按照区间的左端点升序排序，如果左端点相同，则按照右端点降序排序。 + +排序后，我们可以遍历区间，如果当前区间的右端点大于之前的右端点，说明当前区间不被覆盖，答案加一。 + +时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 是区间的数量。 @@ -61,12 +67,13 @@ tags: class Solution: def removeCoveredIntervals(self, intervals: List[List[int]]) -> int: intervals.sort(key=lambda x: (x[0], -x[1])) - cnt, pre = 1, intervals[0] - for e in intervals[1:]: - if pre[1] < e[1]: - cnt += 1 - pre = e - return cnt + ans = 0 + pre = -inf + for _, cur in intervals: + if cur > pre: + ans += 1 + pre = cur + return ans ``` #### Java @@ -74,16 +81,16 @@ class Solution: ```java class Solution { public int removeCoveredIntervals(int[][] intervals) { - Arrays.sort(intervals, (a, b) -> a[0] - b[0] == 0 ? b[1] - a[1] : a[0] - b[0]); - int[] pre = intervals[0]; - int cnt = 1; - for (int i = 1; i < intervals.length; ++i) { - if (pre[1] < intervals[i][1]) { - ++cnt; - pre = intervals[i]; + Arrays.sort(intervals, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]); + int ans = 0, pre = Integer.MIN_VALUE; + for (var e : intervals) { + int cur = e[1]; + if (cur > pre) { + ++ans; + pre = cur; } } - return cnt; + return ans; } } ``` @@ -94,16 +101,18 @@ class Solution { class Solution { public: int removeCoveredIntervals(vector>& intervals) { - sort(intervals.begin(), intervals.end(), [](const vector& a, const vector& b) { return a[0] == b[0] ? b[1] < a[1] : a[0] < b[0]; }); - int cnt = 1; - vector pre = intervals[0]; - for (int i = 1; i < intervals.size(); ++i) { - if (pre[1] < intervals[i][1]) { - ++cnt; - pre = intervals[i]; + ranges::sort(intervals, [](const vector& a, const vector& b) { + return a[0] == b[0] ? a[1] > b[1] : a[0] < b[0]; + }); + int ans = 0, pre = INT_MIN; + for (const auto& e : intervals) { + int cur = e[1]; + if (cur > pre) { + ++ans; + pre = cur; } } - return cnt; + return ans; } }; ``` @@ -111,25 +120,63 @@ public: #### Go ```go -func removeCoveredIntervals(intervals [][]int) int { +func removeCoveredIntervals(intervals [][]int) (ans int) { sort.Slice(intervals, func(i, j int) bool { if intervals[i][0] == intervals[j][0] { - return intervals[j][1] < intervals[i][1] + return intervals[i][1] > intervals[j][1] } return intervals[i][0] < intervals[j][0] }) - cnt := 1 - pre := intervals[0] - for i := 1; i < len(intervals); i++ { - if pre[1] < intervals[i][1] { - cnt++ - pre = intervals[i] + pre := math.MinInt32 + for _, e := range intervals { + cur := e[1] + if cur > pre { + ans++ + pre = cur } } - return cnt + return } ``` +#### TypeScript + +```ts +function removeCoveredIntervals(intervals: number[][]): number { + intervals.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])); + let ans = 0; + let pre = -Infinity; + for (const [_, cur] of intervals) { + if (cur > pre) { + ++ans; + pre = cur; + } + } + return ans; +} +``` + +#### JavaScript + +```js +/** + * @param {number[][]} intervals + * @return {number} + */ +var removeCoveredIntervals = function (intervals) { + intervals.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])); + let ans = 0; + let pre = -Infinity; + for (const [_, cur] of intervals) { + if (cur > pre) { + ++ans; + pre = cur; + } + } + return ans; +}; +``` + diff --git a/solution/1200-1299/1288.Remove Covered Intervals/README_EN.md b/solution/1200-1299/1288.Remove Covered Intervals/README_EN.md index 7542d843ebe4f..c42e49f358341 100644 --- a/solution/1200-1299/1288.Remove Covered Intervals/README_EN.md +++ b/solution/1200-1299/1288.Remove Covered Intervals/README_EN.md @@ -57,7 +57,13 @@ tags: -### Solution 1 +### Solution 1: Sorting + +We can sort the intervals in ascending order by their left endpoints, and if the left endpoints are the same, sort them in descending order by their right endpoints. + +After sorting, we can traverse the intervals. If the right endpoint of the current interval is greater than the previous right endpoint, it means the current interval is not covered, and we increment the answer by one. + +The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$. Here, $n$ is the number of intervals. @@ -67,12 +73,13 @@ tags: class Solution: def removeCoveredIntervals(self, intervals: List[List[int]]) -> int: intervals.sort(key=lambda x: (x[0], -x[1])) - cnt, pre = 1, intervals[0] - for e in intervals[1:]: - if pre[1] < e[1]: - cnt += 1 - pre = e - return cnt + ans = 0 + pre = -inf + for _, cur in intervals: + if cur > pre: + ans += 1 + pre = cur + return ans ``` #### Java @@ -80,16 +87,16 @@ class Solution: ```java class Solution { public int removeCoveredIntervals(int[][] intervals) { - Arrays.sort(intervals, (a, b) -> a[0] - b[0] == 0 ? b[1] - a[1] : a[0] - b[0]); - int[] pre = intervals[0]; - int cnt = 1; - for (int i = 1; i < intervals.length; ++i) { - if (pre[1] < intervals[i][1]) { - ++cnt; - pre = intervals[i]; + Arrays.sort(intervals, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]); + int ans = 0, pre = Integer.MIN_VALUE; + for (var e : intervals) { + int cur = e[1]; + if (cur > pre) { + ++ans; + pre = cur; } } - return cnt; + return ans; } } ``` @@ -100,16 +107,18 @@ class Solution { class Solution { public: int removeCoveredIntervals(vector>& intervals) { - sort(intervals.begin(), intervals.end(), [](const vector& a, const vector& b) { return a[0] == b[0] ? b[1] < a[1] : a[0] < b[0]; }); - int cnt = 1; - vector pre = intervals[0]; - for (int i = 1; i < intervals.size(); ++i) { - if (pre[1] < intervals[i][1]) { - ++cnt; - pre = intervals[i]; + ranges::sort(intervals, [](const vector& a, const vector& b) { + return a[0] == b[0] ? a[1] > b[1] : a[0] < b[0]; + }); + int ans = 0, pre = INT_MIN; + for (const auto& e : intervals) { + int cur = e[1]; + if (cur > pre) { + ++ans; + pre = cur; } } - return cnt; + return ans; } }; ``` @@ -117,25 +126,63 @@ public: #### Go ```go -func removeCoveredIntervals(intervals [][]int) int { +func removeCoveredIntervals(intervals [][]int) (ans int) { sort.Slice(intervals, func(i, j int) bool { if intervals[i][0] == intervals[j][0] { - return intervals[j][1] < intervals[i][1] + return intervals[i][1] > intervals[j][1] } return intervals[i][0] < intervals[j][0] }) - cnt := 1 - pre := intervals[0] - for i := 1; i < len(intervals); i++ { - if pre[1] < intervals[i][1] { - cnt++ - pre = intervals[i] + pre := math.MinInt32 + for _, e := range intervals { + cur := e[1] + if cur > pre { + ans++ + pre = cur } } - return cnt + return } ``` +#### TypeScript + +```ts +function removeCoveredIntervals(intervals: number[][]): number { + intervals.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])); + let ans = 0; + let pre = -Infinity; + for (const [_, cur] of intervals) { + if (cur > pre) { + ++ans; + pre = cur; + } + } + return ans; +} +``` + +#### JavaScript + +```js +/** + * @param {number[][]} intervals + * @return {number} + */ +var removeCoveredIntervals = function (intervals) { + intervals.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])); + let ans = 0; + let pre = -Infinity; + for (const [_, cur] of intervals) { + if (cur > pre) { + ++ans; + pre = cur; + } + } + return ans; +}; +``` + diff --git a/solution/1200-1299/1288.Remove Covered Intervals/Solution.cpp b/solution/1200-1299/1288.Remove Covered Intervals/Solution.cpp index 8ff31789a0147..fe807d1282825 100644 --- a/solution/1200-1299/1288.Remove Covered Intervals/Solution.cpp +++ b/solution/1200-1299/1288.Remove Covered Intervals/Solution.cpp @@ -1,15 +1,17 @@ class Solution { public: int removeCoveredIntervals(vector>& intervals) { - sort(intervals.begin(), intervals.end(), [](const vector& a, const vector& b) { return a[0] == b[0] ? b[1] < a[1] : a[0] < b[0]; }); - int cnt = 1; - vector pre = intervals[0]; - for (int i = 1; i < intervals.size(); ++i) { - if (pre[1] < intervals[i][1]) { - ++cnt; - pre = intervals[i]; + ranges::sort(intervals, [](const vector& a, const vector& b) { + return a[0] == b[0] ? a[1] > b[1] : a[0] < b[0]; + }); + int ans = 0, pre = INT_MIN; + for (const auto& e : intervals) { + int cur = e[1]; + if (cur > pre) { + ++ans; + pre = cur; } } - return cnt; + return ans; } -}; \ No newline at end of file +}; diff --git a/solution/1200-1299/1288.Remove Covered Intervals/Solution.go b/solution/1200-1299/1288.Remove Covered Intervals/Solution.go index f93c200f693a3..355173971bc2c 100644 --- a/solution/1200-1299/1288.Remove Covered Intervals/Solution.go +++ b/solution/1200-1299/1288.Remove Covered Intervals/Solution.go @@ -1,17 +1,17 @@ -func removeCoveredIntervals(intervals [][]int) int { +func removeCoveredIntervals(intervals [][]int) (ans int) { sort.Slice(intervals, func(i, j int) bool { if intervals[i][0] == intervals[j][0] { - return intervals[j][1] < intervals[i][1] + return intervals[i][1] > intervals[j][1] } return intervals[i][0] < intervals[j][0] }) - cnt := 1 - pre := intervals[0] - for i := 1; i < len(intervals); i++ { - if pre[1] < intervals[i][1] { - cnt++ - pre = intervals[i] + pre := math.MinInt32 + for _, e := range intervals { + cur := e[1] + if cur > pre { + ans++ + pre = cur } } - return cnt -} \ No newline at end of file + return +} diff --git a/solution/1200-1299/1288.Remove Covered Intervals/Solution.java b/solution/1200-1299/1288.Remove Covered Intervals/Solution.java index a562213d9cf39..43819518e2505 100644 --- a/solution/1200-1299/1288.Remove Covered Intervals/Solution.java +++ b/solution/1200-1299/1288.Remove Covered Intervals/Solution.java @@ -1,14 +1,14 @@ class Solution { public int removeCoveredIntervals(int[][] intervals) { - Arrays.sort(intervals, (a, b) -> a[0] - b[0] == 0 ? b[1] - a[1] : a[0] - b[0]); - int[] pre = intervals[0]; - int cnt = 1; - for (int i = 1; i < intervals.length; ++i) { - if (pre[1] < intervals[i][1]) { - ++cnt; - pre = intervals[i]; + Arrays.sort(intervals, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]); + int ans = 0, pre = Integer.MIN_VALUE; + for (var e : intervals) { + int cur = e[1]; + if (cur > pre) { + ++ans; + pre = cur; } } - return cnt; + return ans; } -} \ No newline at end of file +} diff --git a/solution/1200-1299/1288.Remove Covered Intervals/Solution.js b/solution/1200-1299/1288.Remove Covered Intervals/Solution.js new file mode 100644 index 0000000000000..7571c81385601 --- /dev/null +++ b/solution/1200-1299/1288.Remove Covered Intervals/Solution.js @@ -0,0 +1,16 @@ +/** + * @param {number[][]} intervals + * @return {number} + */ +var removeCoveredIntervals = function (intervals) { + intervals.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])); + let ans = 0; + let pre = -Infinity; + for (const [_, cur] of intervals) { + if (cur > pre) { + ++ans; + pre = cur; + } + } + return ans; +}; diff --git a/solution/1200-1299/1288.Remove Covered Intervals/Solution.py b/solution/1200-1299/1288.Remove Covered Intervals/Solution.py index 50801dd3b4c4c..d93bfa1ed8acd 100644 --- a/solution/1200-1299/1288.Remove Covered Intervals/Solution.py +++ b/solution/1200-1299/1288.Remove Covered Intervals/Solution.py @@ -1,9 +1,10 @@ class Solution: def removeCoveredIntervals(self, intervals: List[List[int]]) -> int: intervals.sort(key=lambda x: (x[0], -x[1])) - cnt, pre = 1, intervals[0] - for e in intervals[1:]: - if pre[1] < e[1]: - cnt += 1 - pre = e - return cnt + ans = 0 + pre = -inf + for _, cur in intervals: + if cur > pre: + ans += 1 + pre = cur + return ans diff --git a/solution/1200-1299/1288.Remove Covered Intervals/Solution.ts b/solution/1200-1299/1288.Remove Covered Intervals/Solution.ts new file mode 100644 index 0000000000000..286ee99a58951 --- /dev/null +++ b/solution/1200-1299/1288.Remove Covered Intervals/Solution.ts @@ -0,0 +1,12 @@ +function removeCoveredIntervals(intervals: number[][]): number { + intervals.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])); + let ans = 0; + let pre = -Infinity; + for (const [_, cur] of intervals) { + if (cur > pre) { + ++ans; + pre = cur; + } + } + return ans; +}