leetcode435，无重叠区间。给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。 [ [1,2], [2,3], [3,4], [1,3] ]移除1,3即可。
leetcode452，用最少数量的箭引爆气球。[[10,16], [2,8], [1,6], [7,12]]，分别代表每个气球的左右距离，需要一个弓箭戳破。我们在x=6和x=11上就可以戳破[2,8],[1,6]和[10,16],[7,12]
对这种两两集合求交集区间的思路如下：
1、按照结束位置排序
2、创造index，start在前面，end在后面
3、以第一个start的结束位置来看，是否包含end的起始位置，进行交叉条件判断。
leetcode56，合并区间。[[1,3],[2,6],[8,10],[15,18]]合并为[[1,6],[8,10],[15,18]]
对这种两两集合求并集区间的思路如下：
1、按照开始位置排序
2、创造index，start在前面，end在后面
3、以第一个start的结束位置来看，是否包含end的起始位置，进行交叉条件判断。
leetcode253，会议室II。上下车游戏，需要把上车和下车分别排序，如果上车人数就计数++，下车时间到了就计数-- start表示占用的资源，end表示可释放的资源。
1、需要一个start函数，和他的index：si
2、需要一个end函数，和他的index：ei
3、如果start占用的资源时间到了end[ei]，就count释放，不然就占用更多的资源
56
/**
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
int Comp(const void *a, const void *b)
{
int ret = (*(int**)a)[0] - (*(int**)b)[0];
if (ret != 0) {
return ret;
}
return (*(int**)a)[1] - (*(int**)b)[1];
}
int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes){
if (intervalsSize == 0) {
* returnSize = 0;
return NULL;
}
int s1, s2, cnt;
s1 = 0;
s2 = s1 + 1;
cnt = 0;
qsort(intervals, intervalsSize, sizeof(int*), Comp);
int ** ret = (int**)malloc(sizeof(int*)*intervalsSize);
* returnColumnSizes = (int*)malloc(sizeof(int)*intervalsSize);
while(s1 < intervalsSize) {
if (s2 < intervalsSize && intervals[s1][1] >= intervals[s2][0]) {
//有交叉
intervals[s1][1] = intervals[s1][1] > intervals[s2][1] ? intervals[s1][1] : intervals[s2][1];
s2++;
} else {
//无交叉，输出s1
ret[cnt] = (int*)malloc(sizeof(int)*2);
ret[cnt][0] = intervals[s1][0];
ret[cnt][1] = intervals[s1][1];
(* returnColumnSizes)[cnt] = 2;
cnt++;
s1 = s2;
s2 = s2 + 1;
}
}
* returnSize = cnt;
return ret;
}
253
#define MAX 10000
int Comp(const void *a, const void *b)
{
return *(int*)a - *(int*)b;
}
int minMeetingRooms(int** intervals, int intervalsSize, int* intervalsColSize){
int stime[MAX];
int etime[MAX];
int i, start, end, ret, curr;
for (i = 0; i < intervalsSize; i++) {
stime[i] = intervals[i][0];
etime[i] = intervals[i][1];
}
qsort(stime, intervalsSize, sizeof(int), Comp);
qsort(etime, intervalsSize, sizeof(int), Comp);
start = 0;
end = 0;
ret = 0;
curr = 0;
while (start<intervalsSize && end < intervalsSize) {
if (etime[end] > stime[start]){
curr++;
start++;
ret = curr > ret ? curr : ret;
} else {
end ++;
curr--;
}
}
return ret;
}
435
int Comp(const void*a, const void *b)
{
return (*(int**)a)[1] - (*(int**)b)[1];
}
int eraseOverlapIntervals(int** intervals, int intervalsSize, int* intervalsColSize) {
if (intervalsSize == 0 || intervalsSize == 1) {
return 0;
}
qsort(intervals, intervalsSize, sizeof(int*), Comp);//按照终点排序
int start, end, count;
start = 0;
count = 0;
end = start + 1;
while (start < intervalsSize && end < intervalsSize) {
if (intervals[start][1] <= intervals[end][0]) {
//如果end的起点 比start的重点小，直接过
start = end;
end = end + 1;
}
else {
// 如果起点 start 与end有重叠，有重叠，舍弃end
end++;
count++;
}
}
return count;
}
452
int Comp(const void *a, const void *b)
{
return (*(int**)a)[1] - (*(int**)b)[1];
}
int findMinArrowShots(int** points, int pointsSize, int* pointsColSize){
if (pointsSize == 0) {
return 0;
}
if (pointsSize == 1) {
return 1;
}
qsort(points, pointsSize, sizeof(int*), Comp);
int start, end, count;
start = 0;
end = start + 1;
count = 1;
while (end < pointsSize) {
if (points[start][1] < points[end][0]) {
//start 已经戳不破下一个的气球了
count++;
start = end;
end = end + 1;
} else {
end++; //这个start还能用
}
}
return count;
}