Icpc2021 Kunming m-violence + chairman tree

The main idea of the topic :

Give you a sequence . Ask one interval at a time Select or deselect each number The smallest value that cannot be added .

Topic ideas :

Consider violence : After sorting, if a prefix and < The next number - 1 Just stop .

If the value range is set to bucket , Then preprocess the prefix and . It's easy to prove that we can lognlogn Within the complexity of violence dichotomy .

It's easy to put this process on the chairman tree . Then remember to discretize the data
Complexity ：$O(nlognlogn)$

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define pb push_back
#define vi vector<int>
#define vll vector<ll>
#define fi first
#define se second
#define mid ((l + r) >> 1)
const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
ll a[maxn] , b[maxn];
int rt[maxn] , ls[maxn << 5] , rs[maxn << 5] , cnt;
ll s[maxn << 5];
ll dist[maxn] , tot;
void pushup (int t){
    
    s[t] = s[ls[t]] + s[rs[t]];
}
int add (int t , int l , int r , int p , int c){
    
    int now = ++cnt;
    ls[now] = ls[t];
    rs[now] = rs[t];
    s[now] = s[t];
    if (l == r){
    
        s[now] += c;
        return now;
    }
    if (p <= mid)
        ls[now] = add(ls[now] , l , mid , p , c);
    else
        rs[now] = add(rs[now] , mid + 1, r , p , c);
    pushup(now);
    return now;
}
ll ask (int t , int l , int r , int L , int R){
    
    if (!t) return 0;
    if (L <= l && r <= R) return s[t];
    ll ans = 0;
    if (L <= mid) ans += ask(ls[t] , l , mid , L , R);
    if (R > mid) ans += ask(rs[t] , mid + 1 , r , L , R);
    return ans;
}
ll getR (ll x){
    
    ll g = upper_bound(dist + 1 , dist + 1 + tot , x) - dist;
    g--;
    return g;
}

ll getL (ll x){
    
    ll g = lower_bound(dist + 1 , dist + 1 + tot , x) - dist;
    return g;
}
ll calc (int l , int r , ll x , ll y){
    
    x = getL(x);
    y = getR(y);
    if (x > y) return -1;
    ll a = ask(rt[r] , 1 , tot , x , y);
    ll b = ask(rt[l - 1] , 1 , tot , x , y);
    return a - b;
}

int main()
{
    
    int n , m; scanf("%d%d" , &n , &m);
    for (int i = 1 ; i <= n ; i++) {
    
        scanf("%lld" , a + i);
        dist[++tot] = a[i];
    }
    sort(dist + 1 , dist + 1 + tot);
    tot = unique(dist + 1 , dist + 1 + tot ) - dist - 1;
    for (int i = 1 ; i <= n ; i++){
    
        b[i] = lower_bound(dist + 1 ,dist + 1 + tot , a[i]) - dist;
        rt[i] = add(rt[i - 1] , 1 , tot , b[i] , a[i]);
    }
    ll ans = 0;
    for (int i = 1 ; i <= m ; i++){
    
        int nl , nr; scanf("%d%d" , &nl , &nr);
        int l = min((nl + ans) % n + 1 , (nr + ans) % n + 1);
        int r = max((nl + ans) % n + 1 , (nr + ans) % n + 1);
        ll now = 0;
        vector<ll> g;
        int ok = true;
        int yy = 0;
        while (1){
    
           // cout << "now this range can be made:" << 0 << " " << now << endl;
            yy++;
            assert(yy <= 100);
            now = calc(l , r , 1 , now + 1);
            if (now == -1){
    
                ok = false;
                break;
            }
            if (g.size() && g.back() == now) break;
            g.push_back(now);
        }
        if (!ok){
    
            printf("%lld\n" , 1);
            continue;
        }
        ans = g.back() + 1;
        printf("%lld\n" , ans);
    }
    return 0;
}