LeetCode //C - 435. Non-overlapping Intervals

435. Non-overlapping Intervals

Given an array of intervals intervals where intervals[i] = [ s t a r t i , e n d i ] [start_i, end_i] [starti,endi], return the minimum number of intervals you need to remove to make the rest of the intervals 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 < = i n t e r v a l s . l e n g t h < = 1 0 5 1 <= intervals.length <= 10^5 1<=intervals.length<=105
  • intervals[i].length == 2
  • − 5 ∗ 1 0 4 < = s t a r t i < e n d i < = 5 ∗ 1 0 4 -5 * 10^4 <= starti < endi <= 5 * 10^4 −5∗104<=starti<endi<=5∗104

From: LeetCode

Link: 435. Non-overlapping Intervals


Solution:

Ideas:
  1. Sorting: The intervals are first sorted based on their end times using qsort and a custom comparator. Sorting by end time helps in selecting the intervals that finish the earliest, reducing the chance of future overlaps.

  2. Greedy Selection: We then iterate through the sorted intervals. The variable lastEnd keeps track of the end time of the last interval that was added to our timeline. For each interval, if its start time is less than lastEnd, it means the interval overlaps with the previous one, and we need to remove it. Otherwise, we update lastEnd to the current interval's end time.

  3. Counting Removals: The variable removeCount keeps track of the number of intervals that need to be removed. This is incremented each time we find an overlapping interval.

Caode:
c 复制代码
// Comparator function for qsort
int compare(const void* a, const void* b) {
    int* intervalA = *(int**)a;
    int* intervalB = *(int**)b;
    return intervalA[1] - intervalB[1];
}

int eraseOverlapIntervals(int** intervals, int intervalsSize, int* intervalsColSize) {
    // Sort the intervals based on their end times
    qsort(intervals, intervalsSize, sizeof(int*), compare);
    
    int removeCount = 0; // Count of intervals to remove
    int lastEnd = intervals[0][1]; // End time of the last interval considered in the timeline

    // Iterate through the intervals starting from the second one
    for (int i = 1; i < intervalsSize; i++) {
        // If the current interval starts before the last one ends, it overlaps
        if (intervals[i][0] < lastEnd) {
            removeCount++; // Need to remove an interval
        } else {
            // No overlap, update the end time to the current interval's end
            lastEnd = intervals[i][1];
        }
    }
    
    return removeCount; // Number of intervals that need to be removed
}
相关推荐
珹洺4 分钟前
C++算法竞赛篇:DevC++ 如何进行debug调试
java·c++·算法
Norvyn_713 分钟前
LeetCode|Day18|20. 有效的括号|Python刷题笔记
笔记·python·leetcode
呆呆的小鳄鱼42 分钟前
leetcode:冗余连接 II[并查集检查环][节点入度]
算法·leetcode·职场和发展
墨染点香42 分钟前
LeetCode Hot100【6. Z 字形变换】
java·算法·leetcode
沧澜sincerely43 分钟前
排序【各种题型+对应LeetCode习题练习】
算法·leetcode·排序算法
CQ_071243 分钟前
自学力扣:最长连续序列
数据结构·算法·leetcode
弥彦_1 小时前
cf1925B&C
数据结构·算法
Y4090011 小时前
C语言转Java语言,相同与相异之处
java·c语言·开发语言·笔记
YuTaoShao1 小时前
【LeetCode 热题 100】994. 腐烂的橘子——BFS
java·linux·算法·leetcode·宽度优先
Wendy14419 小时前
【线性回归(最小二乘法MSE)】——机器学习
算法·机器学习·线性回归