diff --git a/Solution/435. Non-overlapping Intervals/435. Non-overlapping Intervals.py b/Solution/435. Non-overlapping Intervals/435. Non-overlapping Intervals.py
new file mode 100644
index 0000000..c5fd2fa
--- /dev/null
+++ b/Solution/435. Non-overlapping Intervals/435. Non-overlapping Intervals.py
@@ -0,0 +1,10 @@
+class Solution:
+ def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+ intervals.sort(key=lambda x: x[1])
+ ans = len(intervals)
+ pre = -inf
+ for l, r in intervals:
+ if pre <= l:
+ ans -= 1
+ pre = r
+ return ans
\ No newline at end of file
diff --git a/Solution/435. Non-overlapping Intervals/readme.md b/Solution/435. Non-overlapping Intervals/readme.md
new file mode 100644
index 0000000..cca7c68
--- /dev/null
+++ b/Solution/435. Non-overlapping Intervals/readme.md
@@ -0,0 +1,142 @@
+---
+comments: true
+difficulty: Medium
+edit_url: Antim
+tags:
+ - Greedy
+ - Array
+ - Dynamic Programming
+ - Sorting
+---
+
+
+
+# [435. Non-overlapping Intervals](https://leetcode.com/problems/non-overlapping-intervals)
+
+## Description
+
+
+
+Given an array of intervals intervals where intervals[i] = [starti, endi], return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
+
+Note that intervals which only touch at a point are non-overlapping. For example, [1, 2] and [2, 3] are non-overlapping.
+
+
+Example 1:
+
+
+Input: intervals = [[1,2],[2,3],[3,4],[1,3]]
+Output: 1
+Explanation: [1,3] can be removed and the rest of the intervals are non-overlapping.
+
+
+Example 2:
+
+
+Input: intervals = [[1,2],[1,2],[1,2]]
+Output: 2
+Explanation: You need to remove two [1,2] to make the rest of the intervals non-overlapping.
+
+
+Example 3:
+
+
+Input: intervals = [[1,2],[2,3]]
+Output: 0
+Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
+
+
+
+Constraints:
+
+
+ 1 <= intervals.length <= 105intervals[i].length == 2-5 * 104 <= starti < endi <= 5 * 104
+
+
+
+## Solutions
+
+
+
+### Solution 1: Sorting + Greedy
+
+We first sort the intervals in ascending order by their right boundary. We use a variable $\textit{pre}$ to record the right boundary of the previous interval and a variable $\textit{ans}$ to record the number of intervals that need to be removed. Initially, $\textit{ans} = \textit{intervals.length}$.
+
+Then we iterate through the intervals. For each interval:
+
+- If the left boundary of the current interval is greater than or equal to $\textit{pre}$, it means that this interval does not need to be removed. We directly update $\textit{pre}$ to the right boundary of the current interval and decrement $\textit{ans}$ by one;
+- Otherwise, it means that this interval needs to be removed, and we do not need to update $\textit{pre}$ and $\textit{ans}$.
+
+Finally, we return $\textit{ans}$.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$, where $n$ is the number of intervals.
+
+
+
+#### Python3
+
+```python
+class Solution:
+ def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+ intervals.sort(key=lambda x: x[1])
+ ans = len(intervals)
+ pre = -inf
+ for l, r in intervals:
+ if pre <= l:
+ ans -= 1
+ pre = r
+ return ans
+```
+
+#### Java
+
+```java
+class Solution {
+ public int eraseOverlapIntervals(int[][] intervals) {
+ Arrays.sort(intervals, (a, b) -> a[1] - b[1]);
+ int ans = intervals.length;
+ int pre = Integer.MIN_VALUE;
+ for (var e : intervals) {
+ int l = e[0], r = e[1];
+ if (pre <= l) {
+ --ans;
+ pre = r;
+ }
+ }
+ return ans;
+ }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+ int eraseOverlapIntervals(vector>& intervals) {
+ ranges::sort(intervals, [](const vector& a, const vector& b) {
+ return a[1] < b[1];
+ });
+ int ans = intervals.size();
+ int pre = INT_MIN;
+ for (const auto& e : intervals) {
+ int l = e[0], r = e[1];
+ if (pre <= l) {
+ --ans;
+ pre = r;
+ }
+ }
+ return ans;
+ }
+};
+```
+
+
+
+
+
+
+
\ No newline at end of file