結果

問題 No.3075 Mex Recurrence Formula
ユーザー kwm_t
提出日時 2025-03-30 12:38:35
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 894 ms / 2,000 ms
コード長 4,161 bytes
コンパイル時間 3,835 ms
コンパイル使用メモリ 294,332 KB
実行使用メモリ 28,792 KB
最終ジャッジ日時 2025-03-30 12:39:01
合計ジャッジ時間 25,223 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge2
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 46
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
//using mint = modint1000000007;
//const int mod = 1000000007;
//using mint = modint998244353;
//const int mod = 998244353;
//const int INF = 1e9;
const long long LINF = 1e18;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i,l,r)for(int i=(l);i<(r);++i)
#define rrep(i, n) for (int i = (n) - 1; i >= 0; --i)
#define rrep2(i,l,r)for(int i=(r) - 1;i>=(l);--i)
#define all(x) (x).begin(),(x).end()
#define allR(x) (x).rbegin(),(x).rend()
#define P pair<int,int>
template<typename A, typename B> inline bool chmax(A & a, const B & b) { if (a < b) { a = b; return true; } return false; }
template<typename A, typename B> inline bool chmin(A & a, const B & b) { if (a > b) { a = b; return true; } return false; }
#include <set>
#include <iostream> 
template<typename T>
struct RangeSet {
    // ReadMe:閉区間なことに注意
    // member
    std::set<std::pair<T, T>>st;
    T TINF;
    // constructor
    RangeSet(T lim) {
        TINF = lim + 1;
        st.emplace(-TINF, -TINF);
        st.emplace(TINF, TINF);
    }
    // cover check
    bool IsCovered(T l, T r) {
        auto ite = prev(st.lower_bound({ l + 1,l + 1 }));
        return ((ite->first <= l) && (r <= ite->second));
    }
    bool IsCovered(T x) { return IsCovered(x, x); }
    // get by covered
    std::pair<T, T> ByCovered(T l, T r) {
        auto ite = prev(st.lower_bound({ l + 1,l + 1 }));
        if ((ite->first <= l) && (r <= ite->second)) return *ite;
        return { -TINF, -TINF };
    }
    std::pair<T, T> ByCovered(T  x) { return ByCovered(x, x); }
    // getFront
    std::pair<T, T>getFront() {
        auto itr = st.begin();
        itr++;
        return *itr;
    }
    // getBack
    std::pair<T, T>getBack() {
        auto itr = st.end();
        itr--;
        itr--;
        return *itr;
    }
    // insert
    T Insert(T l, T r) {
        //insertでmargeしないver
        //st.emplace(l, r);
        //return 0;
        T sumErase = T(0);
        auto ite = prev(st.lower_bound({ l + 1,l + 1 }));
        // no need merge
        if (IsCovered(l, r))return sumErase;
        // first merge pos
        if ((ite->first <= l) && (l <= (ite->second + 1))) {
            l = ite->first;
            sumErase += ite->second - ite->first + 1;
            ite = st.erase(ite);
        }
        else ite = next(ite);
        // merge
        while (r > ite->second) {
            sumErase += ite->second - ite->first + 1;
            ite = st.erase(ite);
        }
        if (((ite->first - 1) <= r) && (r <= ite->second)) {
            r = ite->second;
            sumErase += ite->second - ite->first + 1;
            st.erase(ite);
        }
        st.emplace(l, r);
        return (r - l + 1) - sumErase;
    }
    T Insert(T x) { return Insert(x, x); }
    // erase
    T Erase(T l, T r) {
        T ret = T(0);
        auto get = ByCovered(l, r);
        if ((-TINF) != get.first) {
            st.erase(get);
            if (get.first != l)st.emplace(get.first, l - 1);
            if (get.second != r)st.emplace(r + 1, get.second);
            ret += r - l + 1;
            return ret;
        }
        auto ite = prev(st.lower_bound({ l + 1,l + 1 }));
        // first erase
        if ((ite->first <= l) && (l <= ite->second)) {
            ret += ite->second - l + 1;
            if (ite->first != l)st.emplace(ite->first, l - 1);
            ite = st.erase(ite);
        }
        else ite = next(ite);
        // erase
        while (ite->second <= r) {
            ret += ite->second - ite->first + 1;
            ite = st.erase(ite);
        }
        // last
        if ((ite->first <= r) && (r <= ite->second)) {
            ret += r - ite->first + 1;
            if (ite->second != r) st.emplace(r + 1, ite->second);
            st.erase(ite);
        }
        return ret;
    }
    T Erase(T x) { return Erase(x, x); }
    // range count
    int size() { return st.size() - 2; }
    // mex
    T Mex(T x = 0) {
        if (!IsCovered(x)) return x;
        auto ite = prev(st.lower_bound({ x + 1, x + 1 }));
        return ite->second + 1;
    }
    // debug
    void Debug() {
        for (auto[l, r] : st)std::cout << l << " " << r << std::endl;
    }
};
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; cin >> n;
    long long x; cin >> x;
    map<int, int>mp;
    vector<int>a(n);
    RangeSet<long long> rs(LINF);
    rep(i, n) {
        cin >> a[i];
        mp[a[i]]++;
        rs.Insert(a[i]);
    }
    rep(i, n + 1) {
        int x = rs.Mex();
        mp[a[i]]--;
        if (0 == mp[a[i]])rs.Erase(a[i]);
        mp[x]++;
        a.push_back(x);
        rs.Insert(x);
    }
    x--;
    long long idx = x;
    if (idx >= a.size()) {
        idx = n + (idx - n) % (n + 1);
    }
    cout << a[idx] << endl;
    return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0