class Solution {

public:

    int maxFreeTime(int eventTime, vector<int>& startTime, vector<int>& endTime) {

        int n = startTime.size();

        vector<int> interval(n + 1);

        interval[0] = startTime[0];

        for (int i = 1; i < n; ++i) {

            interval[i] = startTime[i] - endTime[i - 1];

        }

        interval[n] = eventTime - endTime[n - 1];

        vector<int> event(n);

        for (int i = 0; i < n; ++i) {

            event[i] = endTime[i] - startTime[i];

        }

        int a = 0, b = -1, c = -1; // 维护前三大interval的index

        vector<int> interval_index(n + 1);

        iota(interval_index.begin(), interval_index.end(), 0);

        sort(interval_index.begin(), interval_index.end(),

             [&](int i, int j) { return interval[i] > interval[j]; });

        a = interval_index[0];

        if (n > 1) {

            b = interval_index[1];

        }

        if (n > 2) {

            c = interval_index[2];

        }

        int ans = 0;





        auto get_right = [&](int i) -> int {

            if (i <= interval[a]) return max(a, max(b, c));

            if (i <= interval[b]) return max(b, c);

            if (i <= interval[c]) return c;

            return -1;

        };



        auto get_left = [&](int i) -> int {

            if (i <= interval[a]) return min(a, min(b, c));

            if (i <= interval[b]) return min(b, c);

            if (i <= interval[c]) return c;

            return -1;

        };



        for (int i = 0; i < n; ++i) {

            int left = get_left(event[i]);

            int right = get_right(event[i]);

            if (left == -1 && right == -1) continue;

            if (left == i) ans = max(ans, interval[i + 1] + interval[i]);

            if (right == i + 1)

                ans = max(ans, interval[i] + interval[i + 1]);

            if (left != i && left != -1 && left < i) {

                ans = max(ans, interval[i] + event[i] + interval[i + 1]);

            }

            if (right != i + 1 && right != -1 && right > i + 1) {

                ans = max(ans, interval[i] + event[i] + interval[i + 1]);

            }

        }

        return ans;

       

    }

};



给你一个整数 eventTime 表示一个活动的总时长，这个活动开始于 t = 0 ，结束于 t = eventTime 。

同时给你两个长度为 n 的整数数组 startTime 和 endTime 。它们表示这次活动中 n 个时间 没有重叠 的会议，其中第 i 个会议的时间为 [startTime[i], endTime[i]] 。

你可以重新安排 至多 一个会议，安排的规则是将会议时间平移，且保持原来的 会议时长 ，你的目的是移动会议后 最大化 相邻两个会议之间的 最长 连续空余时间。

请你返回重新安排会议以后，可以得到的 最大 空余时间。

注意，会议 不能 安排到整个活动的时间以外，且会议之间需要保持互不重叠。

注意：重新安排会议以后，会议之间的顺序可以发生改变。

 

示例 1：

输入：eventTime = 5, startTime = [1,3], endTime = [2,5]

输出：2

解释：



将 [1, 2] 的会议安排到 [2, 3] ，得到空余时间 [0, 2] 。

示例 2：

输入：eventTime = 10, startTime = [0,7,9], endTime = [1,8,10]

输出：7

解释：



将 [0, 1] 的会议安排到 [8, 9] ，得到空余时间 [0, 7] 。

示例 3：

输入：eventTime = 10, startTime = [0,3,7,9], endTime = [1,4,8,10]

输出：6

解释：



将 [3, 4] 的会议安排到 [8, 9] ，得到空余时间 [1, 7] 。

示例 4：

输入：eventTime = 5, startTime = [0,1,2,3,4], endTime = [1,2,3,4,5]

输出：0

解释：

活动中的所有时间都被会议安排满了。

 

提示：

1 <= eventTime <= 109

n == startTime.length == endTime.length

2 <= n <= 105

0 <= startTime[i] < endTime[i] <= eventTime

endTime[i] <= startTime[i + 1] 其中 i 在范围 [0, n - 2] 之间。





我的代码哪里出错了