双指针—安排会议日程（leetcode 1229）_安排会议日程leetcode

题目描述

你是一名行政助理，手里有两位客户的空闲时间表：slots1 和 slots2，以及会议的预计持续时间 duration，请你为他们安排合适的会议时间。

「会议时间」是两位客户都有空参加，并且持续时间能够满足预计时间 duration 的 最早的时间间隔。

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

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

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

示例 1：

输入：slots1 = [[10,50],[60,120],[140,210]], slots2 = [[0,15],[60,70]], duration = 8
输出：[60,68]

示例 2：

输入：slots1 = [[10,50],[60,120],[140,210]], slots2 = [[0,15],[60,70]], duration = 12
输出：[]

提示：

    1 <= slots1.length, slots2.length <= 10^4
    slots1[i].length, slots2[i].length == 2
    slots1[i][0] < slots1[i][1]
    slots2[i][0] < slots2[i][1]
    0 <= slots1[i][j], slots2[i][j] <= 10^9
    1 <= duration <= 10^6

算法分析

题目保证了同一个人的空闲时间不会出现交叠的情况，于是先把两个人的空闲时间表按照开始时间从小到大排序。

排序后的时间表假设如下：

slots1 = [[10,50],[60,120],[140,210]]

slots2 = [[0,15],[60,70]]

定义一个变量 idx1 用于遍历 slots1，idx2 用于遍历 slots2。

假设 duration 为 8：

1、对于初始的 [10, 50] 和 [0, 15] ，看出开始最早的是客户 2，结束最晚的是客户 1，交集就是 [10, 15] 发现小于 duration，因为结束最晚的是客户 1，于是客户 1 的索引不动，因为可能交集还是在客户 1 当前的 [10, 50] 区间内，让 idx2++；

2、此时两个时间表为 [10, 50] 和 [60, 70]，没有交集，应该继续找下一个时间表，因为此时结束时间最晚的是客户 2，可能的目标交集会在 [60, 70] ，于是让 idx1++；

3、此时两个时间表为 [60, 120] 和 [60, 70]，开始最晚的时间是 60，结束最早的时间是 70，满足 duration，于是返回 [最晚开始时间, 最晚开始时间+duration]

代码

class Solution {
public:
    vector<int> minAvailableDuration(vector<vector<int>>& slots1, vector<vector<int>>& slots2, int duration) {
 
        std::sort(slots1.begin(), slots1.end());
        std::sort(slots2.begin(), slots2.end());
        int i = 0, j = 0;
        while(i < slots1.size() && j < slots2.size()) {
 
            int max_start = std::max(slots1[i][0], slots2[j][0]);
            int min_end = std::min(slots1[i][1], slots2[j][1]);
 
            if(min_end - max_start >= duration) {
                return std::vector<int>{max_start, max_start+duration};
            }
            if(slots1[i][1] <= slots2[j][1]) {
                ++i;
            } else {
                ++j;
            }
        }
        return std::vector<int>{};
    }
};

时间复杂度分析

时间复杂度：O(n)+O(nlogn) = O(nlogn)
空间复杂度：O(1)