Untitled

#include <iostream>
#include <set>
#include <unordered_map>
#include <vector>

using namespace std;

struct cmp {
    bool operator()(const pair<int, int>& a, const pair<int, int>& b) const {
        if ((a.second - a.first) == (b.second - b.first)) {
            return a.first < b.first;
        }
        return (a.second - a.first) > (b.second - b.first);
    }
};

set<pair<int, int>, cmp> space;
set<int> locker;
unordered_map<int, int> mp;
int mid;
int n;
int remain;

void init(int N) {
    n = N;
    remain = N;
    mid = -1;
    mp.clear();
    space.clear();

    space.insert(make_pair(1, N));
}

int arrive(int mId) {
    remain--;
    auto it = space.begin();
    auto st = it->first;
    auto en = it->second;

    // Xóa khoảng không gian cũ
    space.erase(it);

    if (st == 1) {
        mid = 1;
        space.insert(make_pair(st + 1, en)); // Sửa n thành en
    } else if (en == n) {
        mid = n;
        space.insert(make_pair(st, en - 1)); // Sửa n thành en - 1
    } else {
        mid = (st + en) / 2;
        if (st <= mid - 1) space.insert(make_pair(st, mid - 1)); // Thêm điều kiện kiểm tra khoảng hợp lệ
        if (mid + 1 <= en) space.insert(make_pair(mid + 1, en)); // Thêm điều kiện kiểm tra khoảng hợp lệ
    }

    locker.insert(mid);
    mp[mId] = mid;
    return mid;
}

int leave(int mId) {
    remain++;
    int idx = mp[mId];
    auto it = locker.find(idx);

    // Kiểm tra biên trước khi sử dụng prev và next
    if (it != locker.begin() && next(it) != locker.end()) {
        auto pre = prev(it);
        auto nex = next(it);

        auto tmp1 = make_pair(*pre + 1, *it - 1);
        auto tmp2 = make_pair(*it + 1, *nex - 1);

        space.erase(tmp1);
        space.erase(tmp2);

        space.insert(make_pair(*pre, *nex)); // Ghép lại khoảng trống mới
    }

    mp.erase(mId);
    locker.erase(it);

    return remain;
}