feat: add solutions to lc problem: No.0435. Non-overlapping Intervals

Author: yanglbme

solution/0000-0099/0005.Longest Palindromic Substring/README.md

@@ -79,7 +79,7 @@ class Solution:
                     dp[i][j] = dp[i + 1][j - 1] and s[i] == s[j]
                 if dp[i][j] and mx < j - i + 1:
                     start, mx = i, j - i + 1
-        return s[start:start+mx]
+        return s[start:start + mx]
 ```
 
 ### **Java**

solution/0000-0099/0005.Longest Palindromic Substring/README_EN.md

@@ -101,7 +101,7 @@ class Solution:
                     dp[i][j] = dp[i + 1][j - 1] and s[i] == s[j]
                 if dp[i][j] and mx < j - i + 1:
                     start, mx = i, j - i + 1
-        return s[start:start+mx]
+        return s[start:start + mx]
 ```
 
 ### **Java**

solution/0000-0099/0005.Longest Palindromic Substring/Solution.py

@@ -11,4 +11,4 @@ def longestPalindrome(self, s: str) -> str:
                     dp[i][j] = dp[i + 1][j - 1] and s[i] == s[j]
                 if dp[i][j] and mx < j - i + 1:
                     start, mx = i, j - i + 1
-        return s[start:start+mx]
+        return s[start:start + mx]

solution/0400-0499/0435.Non-overlapping Intervals/README.md

@@ -45,27 +45,84 @@
 <strong>解释:</strong> 你不需要移除任何区间，因为它们已经是无重叠的了。
 </pre>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+贪心。
+
+先按照区间右边界排序。优先选择最小的区间的右边界作为起始边界。遍历区间：
+
+- 若当前区间左边界大于等于起始右边界，说明该区间无需移除，直接更新起始右边界；
+- 否则说明该区间需要移除，更新移除区间的数量 cnt。
+
+最后返回 cnt 即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        if not intervals:
+            return 0
+        intervals.sort(key=lambda x: x[1])
+        cnt, end = 0, intervals[0][1]
+        for interval in intervals[1:]:
+            if interval[0] >= end:
+                end = interval[1]
+            else:
+                cnt += 1
+        return cnt
 ```
 
 ### **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 end = intervals[0][1], cnt = 0;
+        for (int i = 1; i < intervals.length; ++i) {
+            if (intervals[i][0] >= end) {
+                end = intervals[i][1];
+            } else {
+                ++cnt;
+            }
+        }
+        return cnt;
+    }
+}
+```
 
+### **Go**
+
+```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]
+	})
+	end, cnt := intervals[0][1], 0
+	for i := 1; i < len(intervals); i++ {
+		if intervals[i][0] >= end {
+			end = intervals[i][1]
+		} else {
+			cnt++
+		}
+	}
+	return cnt
+}
 ```
 
 ### **...**

solution/0400-0499/0435.Non-overlapping Intervals/README_EN.md

@@ -43,18 +43,69 @@
 
 ## Solutions
 
+Greedy.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        if not intervals:
+            return 0
+        intervals.sort(key=lambda x: x[1])
+        cnt, end = 0, intervals[0][1]
+        for interval in intervals[1:]:
+            if interval[0] >= end:
+                end = interval[1]
+            else:
+                cnt += 1
+        return cnt
 ```
 
 ### **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 end = intervals[0][1], cnt = 0;
+        for (int i = 1; i < intervals.length; ++i) {
+            if (intervals[i][0] >= end) {
+                end = intervals[i][1];
+            } else {
+                ++cnt;
+            }
+        }
+        return cnt;
+    }
+}
+```
 
+### **Go**
+
+```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]
+	})
+	end, cnt := intervals[0][1], 0
+	for i := 1; i < len(intervals); i++ {
+		if intervals[i][0] >= end {
+			end = intervals[i][1]
+		} else {
+			cnt++
+		}
+	}
+	return cnt
+}
 ```
 
 ### **...**

solution/0400-0499/0435.Non-overlapping Intervals/Solution.go

@@ -0,0 +1,17 @@
+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]
+	})
+	end, cnt := intervals[0][1], 0
+	for i := 1; i < len(intervals); i++ {
+		if intervals[i][0] >= end {
+			end = intervals[i][1]
+		} else {
+			cnt++
+		}
+	}
+	return cnt
+}

solution/0400-0499/0435.Non-overlapping Intervals/Solution.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        if (intervals == null || intervals.length == 0) {
+            return 0;
+        }
+        Arrays.sort(intervals, Comparator.comparingInt(a -> a[1]));
+        int end = intervals[0][1], cnt = 0;
+        for (int i = 1; i < intervals.length; ++i) {
+            if (intervals[i][0] >= end) {
+                end = intervals[i][1];
+            } else {
+                ++cnt;
+            }
+        }
+        return cnt;
+    }
+}

solution/0400-0499/0435.Non-overlapping Intervals/Solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        if not intervals:
+            return 0
+        intervals.sort(key=lambda x: x[1])
+        cnt, end = 0, intervals[0][1]
+        for interval in intervals[1:]:
+            if interval[0] >= end:
+                end = interval[1]
+            else:
+                cnt += 1
+        return cnt