力扣 1353. 最多可以参加的会议数目两法--遍历贪心与剪枝优化

1353. 最多可以参加的会议数目

给你一个数组 events，其中 events[i] = [startDayi, endDayi] ，表示会议 i 开始于 startDayi ，结束于 endDayi 。

你可以在满足 startDayi <= d <= endDayi 中的任意一天 d 参加会议 i 。注意，一天只能参加一个会议。

请你返回你可以参加的 最大 会议数目。

示例 1：

输入：events = [[1,2],[2,3],[3,4]]
输出：3
解释：你可以参加所有的三个会议。
安排会议的一种方案如上图。
第 1 天参加第一个会议。
第 2 天参加第二个会议。
第 3 天参加第三个会议。
示例 2：

输入：events= [[1,2],[2,3],[3,4],[1,2]]
输出：4
示例 3：

输入：events = [[1,4],[4,4],[2,2],[3,4],[1,1]]
输出：4
示例 4：

输入：events = [[1,100000]]
输出：1
示例 5：

输入：events = [[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7]]
输出：7

提示：
1 <= events.length <= 10^5
events[i].length == 2
1 <= events[i][0] <= events[i][1] <= 10^5

方法一：遍历+贪心（超时会有两个案例不通过）

主要思路就是先找到天数的区间，即第几天到第几天。然后遍历天数，对每一天都遍历一次events数组，看能否找到有会议召开的区间包含这一天的，若只有一个会议，则就去开他；若有多个会议，根据贪心策略，我们需先开结束日期早的那个，因为结束日期晚的其有很多选择去开他。

代码：

int cmp1(void*_x,void*_y)
{
    int *x=*(int**)_x;
    int *y=*(int**)_y;
    return x[0]>y[0];
}
int cmp2(void*_x,void*_y)
{
    int *x=*(int**)_x;
    int *y=*(int**)_y;
    return x[1]>y[1];
}
int maxEvents(int** events, int eventsSize, int* eventsColSize){
    int sum = 0;
    qsort(events,eventsSize,sizeof(int*),cmp2);
    int N = events[eventsSize-1][1];
    qsort(events,eventsSize,sizeof(int*),cmp1);//使用两次qsort是为了找出天数的区间，即开始的天数和最大的天数
    for(int i=events[0][0];i<=N;i++)//遍历天数
    {
        int index;//储存要开的那个会议的下标
        int x = 0;//中间变量，用来证明是否能开会的
        for(int j=0;j<eventsSize;j++)//遍历数组
        {
            if(events[j][1]<i)//若会议的结束日期小于此时的天数，则一定不会开他，减小运算
                continue;
            if(events[j][0]<=i&&events[j][1]>=i)//在区间内，即可以开他的情况
            {
                x++;//证明能开会
                if(x==1)//在只找到一个能开的会时不用进行谁的结束日期更短
                {
                    index=j;//第一个初始化
                    continue;
                }
                if(events[j][1]<events[index][1])//比较结束日期
                {
                    index=j;
                }
            }
            else
            {
                continue;
            }
        }
        if(x>0)//证明“今天”能开会
        {
            sum++;//所以开了一次
            events[index][1]=INT_MAX;//这样操作的话即默认了此会议开过了
            events[index][0]=INT_MAX;//因为我们把此会议召开的日期改到一个永远到到不了的“天数”了
        }
    }
    return sum;
}

方法二：优化贪心–剪枝

代码：

int *compare(const void *a, const void *b) {
    if((*(int **)a)[1] == (*(int **)b)[1]) {
        return (*(int **)a)[0] - (*(int **)b)[0];
    } else {
        return (*(int **)a)[1] - (*(int **)b)[1];
    }
}

//【算法思路】贪心算法。
//1.按照结束时间排序。
//2.构造注册日期flags，标志已经占用的参加日期
//3.根据结束时间最早的会议的开始时间，抢占最早的参加日期（贪心）
//4.剪枝：如果不同的结束时间个数等于会议个数，直接返回会议个数，全部能够参加
int maxEvents(int** events, int eventsSize, int* eventsColSize){
    if(eventsSize == 0) {
        return 0;
    }

    qsort(events, eventsSize, sizeof(int*), compare);

    //剪枝
    bool find = true;
    for(int i = 1; i < eventsSize; i++) {
        if(events[i][1] == events[i - 1][1]) {
            find = false;
            break;
        }
    }

    if(find == true) {
        return eventsSize;
    }

    int end = events[eventsSize - 1][1];

    int *flags = (int *)calloc(end + 1, sizeof(int));

    int cnt = 0;
    for(int i = 0; i < eventsSize; i++) {
        for(int j = events[i][0]; j <= events[i][1]; j++) {
            if(flags[j] == 1) {
                continue;
            } else {
                flags[j] = 1;
                cnt++;
                break;
            }
        }
    }

    return cnt;
}