feat: add solutions to lc problem: No.0435

yanglbme · yanglbme · commit cd3a929ee0f5 · 2022-04-10T11:15:42.000+08:00
No.0435.Non-overlapping Intervals
diff --git a/README.md b/README.md
@@ -67,6 +67,7 @@
 -   [摘樱桃](/solution/0700-0799/0741.Cherry%20Pickup/README.md) - 线性 DP、数字三角形模型
 -   [摘樱桃 II](/solution/1400-1499/1463.Cherry%20Pickup%20II/README.md) - 线性 DP、数字三角形模型
 -   [最长递增子序列](/solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README.md) - 线性 DP、最长上升子序列模型
+-   [无重叠区间](/solution/0400-0499/0435.Non-overlapping%20Intervals/README.md) - 线性 DP、最长上升子序列模型、贪心优化
 -   [删列造序 III](/solution/0900-0999/0960.Delete%20Columns%20to%20Make%20Sorted%20III/README.md) - 线性 DP、最长上升子序列模型
 -   [俄罗斯套娃信封问题](/solution/0300-0399/0354.Russian%20Doll%20Envelopes/README.md) - 线性 DP、最长上升子序列模型、贪心优化
 -   [堆叠长方体的最大高度](/solution/1600-1699/1691.Maximum%20Height%20by%20Stacking%20Cuboids/README.md) - 排序、线性 DP、最长上升子序列模型
diff --git a/README_EN.md b/README_EN.md
@@ -66,6 +66,7 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
 -   [Cherry Pickup](/solution/0700-0799/0741.Cherry%20Pickup/README_EN.md) - Linear problem
 -   [Cherry Pickup II](/solution/1400-1499/1463.Cherry%20Pickup%20II/README_EN.md) - Linear problem
 -   [Longest Increasing Subsequence](/solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README_EN.md) - Linear problem, LIS
+-   [Non-overlapping Intervals](/solution/0400-0499/0435.Non-overlapping%20Intervals/README_EN.md) - Linear problem, LIS, Greedy
 -   [Delete Columns to Make Sorted III](/solution/0900-0999/0960.Delete%20Columns%20to%20Make%20Sorted%20III/README_EN.md) - Linear problem, LIS
 -   [Russian Doll Envelopes](/solution/0300-0399/0354.Russian%20Doll%20Envelopes/README_EN.md) - Linear problem, LIS
 -   [Maximum Height by Stacking Cuboids](/solution/1600-1699/1691.Maximum%20Height%20by%20Stacking%20Cuboids/README_EN.md) - Sort, Linear problem, LIS
diff --git a/solution/0400-0499/0435.Non-overlapping Intervals/README.md b/solution/0400-0499/0435.Non-overlapping Intervals/README.md
@@ -48,7 +48,11 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-贪心。
+**方法一：转换为最长上升子序列问题**
+
+最长上升子序列问题，动态规划的做法，时间复杂度是 O(n²)，这里可以采用贪心优化，将复杂度降至 O(nlogn)。
+
+**方法二：排序 + 贪心**
 
 先按照区间右边界排序。优先选择最小的区间的右边界作为起始边界。遍历区间：
 
@@ -57,6 +61,8 @@
 
 最后返回 ans 即可。
 
+时间复杂度 O(nlogn)。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -66,8 +72,6 @@
 ```python
 class Solution:
     def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
-        if not intervals:
-            return 0
         intervals.sort(key=lambda x: x[1])
         ans, t = 0, intervals[0][1]
         for s, e in intervals[1:]:
@@ -78,16 +82,27 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        intervals.sort()
+        d = [intervals[0][1]]
+        for s, e in intervals[1:]:
+            if s >= d[-1]:
+                d.append(e)
+            else:
+                idx = bisect_left(d, s)
+                d[idx] = min(d[idx], e)
+        return len(intervals) - len(d)
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
 class Solution {
     public int eraseOverlapIntervals(int[][] intervals) {
-        if (intervals == null || intervals.length == 0) {
-            return 0;
-        }
         Arrays.sort(intervals, Comparator.comparingInt(a -> a[1]));
         int t = intervals[0][1], ans = 0;
         for (int i = 1; i < intervals.length; ++i) {
@@ -102,16 +117,49 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals, (a, b) -> {
+            if (a[0] != b[0]) {
+                return a[0] - b[0];
+            }
+            return a[1] - b[1];
+        });
+        int n = intervals.length;
+        int[] d = new int[n + 1];
+        d[1] = intervals[0][1];
+        int size = 1;
+        for (int i = 1; i < n; ++i) {
+            int s = intervals[i][0], e = intervals[i][1];
+            if (s >= d[size]) {
+                d[++size] = e;
+            } else {
+                int left = 1, right = size;
+                while (left < right) {
+                    int mid = (left + right) >> 1;
+                    if (d[mid] >= s) {
+                        right = mid;
+                    } else {
+                        left = mid + 1;
+                    }
+                }
+                d[left] = Math.min(d[left], e);
+            }
+        }
+        return n - size;
+    }
+}
+```
+
 ### **TypeScript**
 
 ```ts
 function eraseOverlapIntervals(intervals: number[][]): number {
-    let n = intervals.length;
-    if (n == 0) return 0;
     intervals.sort((a, b) => a[1] - b[1]);
     let end = intervals[0][1],
         ans = 0;
-    for (let i = 1; i < n; ++i) {
+    for (let i = 1; i < intervals.length; ++i) {
         let cur = intervals[i];
         if (end > cur[0]) {
             ans++;
@@ -129,7 +177,6 @@ function eraseOverlapIntervals(intervals: number[][]): number {
 class Solution {
 public:
     int eraseOverlapIntervals(vector<vector<int>>& intervals) {
-        if (intervals.empty()) return 0;
         sort(intervals.begin(), intervals.end(), [](const auto &a, const auto &b) { return a[1] < b[1]; });
         int ans = 0, t = intervals[0][1];
         for (int i = 1; i < intervals.size(); ++i)
@@ -146,9 +193,6 @@ public:
 
 ```go
 func eraseOverlapIntervals(intervals [][]int) int {
-	if intervals == nil || len(intervals) == 0 {
-		return 0
-	}
 	sort.Slice(intervals, func(i, j int) bool {
 		return intervals[i][1] < intervals[j][1]
 	})
diff --git a/solution/0400-0499/0435.Non-overlapping Intervals/README_EN.md b/solution/0400-0499/0435.Non-overlapping Intervals/README_EN.md
@@ -51,8 +51,6 @@ Greedy.
 ```python
 class Solution:
     def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
-        if not intervals:
-            return 0
         intervals.sort(key=lambda x: x[1])
         ans, t = 0, intervals[0][1]
         for s, e in intervals[1:]:
@@ -63,14 +61,25 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        intervals.sort()
+        d = [intervals[0][1]]
+        for s, e in intervals[1:]:
+            if s >= d[-1]:
+                d.append(e)
+            else:
+                idx = bisect_left(d, s)
+                d[idx] = min(d[idx], e)
+        return len(intervals) - len(d)
+```
+
 ### **Java**
 
 ```java
 class Solution {
     public int eraseOverlapIntervals(int[][] intervals) {
-        if (intervals == null || intervals.length == 0) {
-            return 0;
-        }
         Arrays.sort(intervals, Comparator.comparingInt(a -> a[1]));
         int t = intervals[0][1], ans = 0;
         for (int i = 1; i < intervals.length; ++i) {
@@ -85,16 +94,49 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals, (a, b) -> {
+            if (a[0] != b[0]) {
+                return a[0] - b[0];
+            }
+            return a[1] - b[1];
+        });
+        int n = intervals.length;
+        int[] d = new int[n + 1];
+        d[1] = intervals[0][1];
+        int size = 1;
+        for (int i = 1; i < n; ++i) {
+            int s = intervals[i][0], e = intervals[i][1];
+            if (s >= d[size]) {
+                d[++size] = e;
+            } else {
+                int left = 1, right = size;
+                while (left < right) {
+                    int mid = (left + right) >> 1;
+                    if (d[mid] >= s) {
+                        right = mid;
+                    } else {
+                        left = mid + 1;
+                    }
+                }
+                d[left] = Math.min(d[left], e);
+            }
+        }
+        return n - size;
+    }
+}
+```
+
 ### **TypeScript**
 
 ```ts
 function eraseOverlapIntervals(intervals: number[][]): number {
-    let n = intervals.length;
-    if (n == 0) return 0;
     intervals.sort((a, b) => a[1] - b[1]);
     let end = intervals[0][1],
         ans = 0;
-    for (let i = 1; i < n; ++i) {
+    for (let i = 1; i < intervals.length; ++i) {
         let cur = intervals[i];
         if (end > cur[0]) {
             ans++;
@@ -112,7 +154,6 @@ function eraseOverlapIntervals(intervals: number[][]): number {
 class Solution {
 public:
     int eraseOverlapIntervals(vector<vector<int>>& intervals) {
-        if (intervals.empty()) return 0;
         sort(intervals.begin(), intervals.end(), [](const auto &a, const auto &b) { return a[1] < b[1]; });
         int ans = 0, t = intervals[0][1];
         for (int i = 1; i < intervals.size(); ++i)
@@ -129,9 +170,6 @@ public:
 
 ```go
 func eraseOverlapIntervals(intervals [][]int) int {
-	if intervals == nil || len(intervals) == 0 {
-		return 0
-	}
 	sort.Slice(intervals, func(i, j int) bool {
 		return intervals[i][1] < intervals[j][1]
 	})
diff --git a/solution/0400-0499/0435.Non-overlapping Intervals/Solution.cpp b/solution/0400-0499/0435.Non-overlapping Intervals/Solution.cpp
@@ -1,14 +1,13 @@
-class Solution {
-public:
-    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
-        if (intervals.empty()) return 0;
-        sort(intervals.begin(), intervals.end(), [](const auto &a, const auto &b) { return a[1] < b[1]; });
-        int ans = 0, t = intervals[0][1];
-        for (int i = 1; i < intervals.size(); ++i)
-        {
-            if (t <= intervals[i][0]) t = intervals[i][1];
-            else ++ans;
-        }
-        return ans;
-    }
+class Solution {
+public:
+    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
+        sort(intervals.begin(), intervals.end(), [](const auto &a, const auto &b) { return a[1] < b[1]; });
+        int ans = 0, t = intervals[0][1];
+        for (int i = 1; i < intervals.size(); ++i)
+        {
+            if (t <= intervals[i][0]) t = intervals[i][1];
+            else ++ans;
+        }
+        return ans;
+    }
 };
diff --git a/solution/0400-0499/0435.Non-overlapping Intervals/Solution.go b/solution/0400-0499/0435.Non-overlapping Intervals/Solution.go
@@ -1,17 +1,14 @@
-func eraseOverlapIntervals(intervals [][]int) int {
-	if intervals == nil || len(intervals) == 0 {
-		return 0
-	}
-	sort.Slice(intervals, func(i, j int) bool {
-		return intervals[i][1] < intervals[j][1]
-	})
-	t, ans := intervals[0][1], 0
-	for i := 1; i < len(intervals); i++ {
-		if intervals[i][0] >= t {
-			t = intervals[i][1]
-		} else {
-			ans++
-		}
-	}
-	return ans
+func eraseOverlapIntervals(intervals [][]int) int {
+	sort.Slice(intervals, func(i, j int) bool {
+		return intervals[i][1] < intervals[j][1]
+	})
+	t, ans := intervals[0][1], 0
+	for i := 1; i < len(intervals); i++ {
+		if intervals[i][0] >= t {
+			t = intervals[i][1]
+		} else {
+			ans++
+		}
+	}
+	return ans
 }
diff --git a/solution/0400-0499/0435.Non-overlapping Intervals/Solution.java b/solution/0400-0499/0435.Non-overlapping Intervals/Solution.java
@@ -1,17 +1,14 @@
-class Solution {
-    public int eraseOverlapIntervals(int[][] intervals) {
-        if (intervals == null || intervals.length == 0) {
-            return 0;
-        }
-        Arrays.sort(intervals, Comparator.comparingInt(a -> a[1]));
-        int t = intervals[0][1], ans = 0;
-        for (int i = 1; i < intervals.length; ++i) {
-            if (intervals[i][0] >= t) {
-                t = intervals[i][1];
-            } else {
-                ++ans;
-            }
-        }
-        return ans;
-    }
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt(a -> a[1]));
+        int t = intervals[0][1], ans = 0;
+        for (int i = 1; i < intervals.length; ++i) {
+            if (intervals[i][0] >= t) {
+                t = intervals[i][1];
+            } else {
+                ++ans;
+            }
+        }
+        return ans;
+    }
 }
diff --git a/solution/0400-0499/0435.Non-overlapping Intervals/Solution.py b/solution/0400-0499/0435.Non-overlapping Intervals/Solution.py
@@ -1,12 +1,10 @@
-class Solution:
-    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
-        if not intervals:
-            return 0
-        intervals.sort(key=lambda x: x[1])
-        ans, t = 0, intervals[0][1]
-        for s, e in intervals[1:]:
-            if s >= t:
-                t = e
-            else:
-                ans += 1
-        return ans
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        intervals.sort(key=lambda x: x[1])
+        ans, t = 0, intervals[0][1]
+        for s, e in intervals[1:]:
+            if s >= t:
+                t = e
+            else:
+                ans += 1
+        return ans
diff --git a/solution/0400-0499/0435.Non-overlapping Intervals/Solution.ts b/solution/0400-0499/0435.Non-overlapping Intervals/Solution.ts
@@ -1,10 +1,8 @@
 function eraseOverlapIntervals(intervals: number[][]): number {
-    let n = intervals.length;
-    if (n == 0) return 0;
     intervals.sort((a, b) => a[1] - b[1]);
     let end = intervals[0][1],
         ans = 0;
-    for (let i = 1; i < n; ++i) {
+    for (let i = 1; i < intervals.length; ++i) {
         let cur = intervals[i];
         if (end > cur[0]) {
             ans++;
