logseq_notes/journals/2023_04_16.md

77 lines
2.6 KiB
Markdown
Raw Permalink Normal View History

2023-06-14 14:27:22 +08:00
- Leetcode - Non-overlapping Intervals
id:: 643d27e0-7330-4510-a2f7-8e2cecc08e7b
- Times:
- Time when completed: 10:33
- Time taken to complete: 30mins incl. learning
- DONE Revisions:
SCHEDULED: <2023-04-23 Sun>
:LOGBOOK:
CLOCK: [2023-04-16 Sun 10:33:49]--[2023-04-16 Sun 10:33:50] => 00:00:01
CLOCK: [2023-04-23 Sun 11:00:32]--[2023-04-23 Sun 11:09:38] => 00:09:06
:END:
- Tags:
- Algorithms: #greedy
- Data structures: #array #interval
- Difficulty: #difficulty_easy
- Platforms: #leetcode
- Links:
- [link to the problem](https://leetcode.com/problems/non-overlapping-intervals/description/)
- [Previous solution](logseq://graph/logseq_notes?page=Leetcode%20Non-Overlapping-Intervals)
- Problem:
- 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_.
- Examples:
- ```
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 <= 105`
- `intervals[i].length == 2`
- `-5 * 104 <= starti < endi <= 5 * 104`
- Thoughts:
- Intuition:
- This is a classic [[Interval Scheduling]] problem implemented using greedy algorithm.
- Approach:
- Sort the array by the end of interval
- Use greedy algorithm, find the interval with earliest finishing time
- Remove a interval if the starting time is before the finishing time
- otherwise, add the count
- return `length - count` for the intervals to be deleted
- Solution:
- Code
- ```java
class Solution {
public int eraseOverlapIntervals(int[][] intervals) {
Arrays.sort(intervals, (a, b) -> a[1] - b[1]);
// Interval scheduling problem
int count = 1, minEnd = intervals[0][1];
// The first can be scheduled
for (int i = 1; i < intervals.length; i++) {
if (minEnd <= intervals[i][0]) {
// can be scheduled;
count++;
minEnd = intervals[i][1];
}
}
return intervals.length - count;
}
}
```