leetcode 253. 会议室 II 和1229. 安排会议日程

给你一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，返回 所需会议室的最小数量 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/meeting-rooms-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    static bool Compare(const vector<int>& a,const vector<int>& b)
    {
        if (a[0] == b[0]) {
            return a[1] < b[1];
        }
        return a[0] < b[0];
    }

    int minMeetingRooms(vector<vector<int>>& intervals)
    {
        if (intervals.size() == 0) {
            return 0;
        }
        vector<int> rooms;
        sort(intervals.begin(), intervals.end(), Compare);
        rooms.push_back(intervals[0][1]);
        for (size_t i = 1; i < intervals.size(); ++i) {
            bool needAdd = true;
            for (size_t j = 0; j < rooms.size(); ++j) {
                if (rooms[j] <= intervals[i][0]) {
                    rooms[j] = intervals[i][1];
                    needAdd = false;
                    break;
                }
            }
            if (needAdd) {
                rooms.push_back(intervals[i][1]);
            }
        }
        return rooms.size();
    }
};

 

1229. 安排会议日程

给定两个人的空闲时间表：slots1 和 slots2，以及会议的预计持续时间 duration，请你为他们安排 时间段最早 且合适的会议时间。

如果没有满足要求的会议时间，就请返回一个 空数组。

「空闲时间」的格式是 [start, end]，由开始时间 start 和结束时间 end 组成，表示从 start 开始，到 end 结束。 

题目保证数据有效：同一个人的空闲时间不会出现交叠的情况，也就是说，对于同一个人的两个空闲时间 [start1, end1] 和 [start2, end2]，要么 start1 > end2，要么 start2 > end1。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/meeting-scheduler
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    static bool Compare(const vector<int>& a,const vector<int>& b)
    {
        if (a[0] == b[0]) {
            return a[1] < b[1];
        }
        return a[0] < b[0];
    }
    vector<int> minAvailableDuration(vector<vector<int>>& slots1, vector<vector<int>>& slots2, int duration) {
        sort(slots1.begin(), slots1.end(), Compare);
        sort(slots2.begin(), slots2.end(), Compare);
        vector<int> res;

        for (size_t i = 0; i < slots1.size(); ++i) {
            if (slots1[i][1] - slots1[i][0] < duration) {
                continue;
            }
            bool find = false;
            int lasttime = slots1[i][1] - duration;
            for (size_t j = 0; j < slots2.size(); j++) {
                if (slots2[j][0] + duration > slots1[i][1] ||
                    (slots1[i][0] + duration > slots2[j][1]) ||
                    (slots2[j][1] - slots2[j][0] < duration)) {
                    continue;
                }
                if (slots2[j][0] > lasttime) {
                    break;
                }
                find = true;
                int start = slots1[i][0] >= slots2[j][0] ? slots1[i][0] : slots2[j][0];
                res.push_back(start);
                res.push_back(start + duration);
            }
            if (find) {
                break;
            }
        }
        return res;
    }

};