洛谷P4135 作诗

题意：[l,r]之间有多少个数出现了正偶数次。强制在线。

解：第一眼想到莫队，然后发现强制在线...分块吧。

有个很朴素的想法就是蒲公英那题的套路，做每块前缀和的桶。

然后发现这题空间128M，数组大小我的是133M......看到有人卡到了122M，但是我又不想冒险，就换写法了。(题解里全是空间n^1.5的...)

那就用蒲公英的另一个套路吧。。。vector + 二分。

预处理出每两个块之间的答案，然后查询的时候对边角扫一遍，每个数vector二分，求得出现几次，统计答案。

这样一来块大小是(n/logn)^0.5的，然后交上去发现T成10分...自闭了。

YY出了个做法，每个数维护是第几个出现的该数值的数，然后发现对于某种数值只出现在一边边角的话，不会处理，又只会vector了...虽然还可以值域分块做到log(n^0.5)，但是感觉上没啥太大优化，懒得写了...

把之前的10分代码玄学调了一波块大小，然后吸氧，居然A了。。。。。。自闭了。

// luogu-judger-enable-o2
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cmath>

const int N = 100010;

int bin[N], a[N], sum[1400][1400], n, lm, le[N], re[N], fr[N];
std::vector<int> v[N];
bool vis[N];

inline void read(int &x) {
    x = 0;
    char c = getchar();
    while(c < '0' || c > '9') {
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = (x << 3) + (x << 1) + c - 48;
        c = getchar();
    }
    return;
}

inline int getTime(int x, int y, int c) {
    if(x > y) {
        return 0;
    }
    x = std::lower_bound(v[c].begin(), v[c].end(), x) - v[c].begin();
    y = std::upper_bound(v[c].begin(), v[c].end(), y) - v[c].begin() - 1;
    return y - x + 1;
}

inline int ask(int x, int y) {
    int l = fr[x], r = fr[y], ans = 0;
    if(l == r) {
        for(int k = x; k <= y; k++) {
            if(bin[a[k]]) {
                bin[a[k]] & 1 ? ans++ : ans--;
            }
            bin[a[k]]++;
        }
        for(int k = x; k <= y; k++) {
            bin[a[k]]--;
        }
        return ans;
    }
    for(int k = x; k <= re[l]; k++) {
        bin[a[k]]++;
    }
    for(int k = le[r]; k <= y; k++) {
        bin[a[k]]++;
    }
    for(int k = x; k <= re[l]; k++) {
        if(vis[a[k]]) {
            continue;
        }
        vis[a[k]] = 1;
        if(bin[a[k]] & 1) {
            int t = getTime(le[l + 1], re[r - 1], a[k]);
            if(t) {
                ans += t & 1 ? 1 : -1;
            }
        }
        else {
            ans += getTime(le[l + 1], re[r - 1], a[k]) == 0;
        }
    }
    for(int k = le[r]; k <= y; k++) {
        if(vis[a[k]]) {
            continue;
        }
        vis[a[k]] = 1;
        if(bin[a[k]] & 1) {
            int t = getTime(le[l + 1], re[r - 1], a[k]);
            if(t) {
                ans += t & 1 ? 1 : -1;
            }
        }
        else {
            ans += getTime(le[l + 1], re[r - 1], a[k]) == 0;
        }
    }
    for(int k = x; k <= re[l]; k++) {
        vis[a[k]] = 0;
        bin[a[k]]--;
    }
    for(int k = le[r]; k <= y; k++) {
        vis[a[k]] = 0;
        bin[a[k]]--;
    }
    return ans + sum[l + 1][r - 1];
}

int main() {
    int m;
    read(n);
    read(lm);
    read(m);
    int T = sqrt((double)(n) / log2(n) * 2);
    for(int i = 1; i <= n; i++) {
        read(a[i]);
        v[a[i]].push_back(i);
        fr[i] = (i - 1) / T + 1;
    }
    // prework
    for(int i = 1; i <= fr[n]; i++) {
        le[i] = re[i - 1] + 1;
        re[i] = le[i] + T - 1;
        if(i == fr[n]) {
            re[i] = n;
        }
    }

    for(int l = 1; l <= fr[n]; l++) {
        int ans = 0;
        for(int r = l; r <= fr[n]; r++) {
            for(int k = le[r]; k <= re[r]; k++) {
                if(bin[a[k]]) {
                    bin[a[k]] & 1 ? ans++ : ans--;
                }
                bin[a[k]]++;
            }
            sum[l][r] = ans;
        }
        for(int k = le[l]; k <= n; k++) {
            bin[a[k]]--;
        }
    }

    int lastans = 0;
    for(int i = 1, x, y; i <= m; i++) {
        read(x);
        read(y);
        x = (x + lastans) % n + 1;
        y = (y + lastans) % n + 1;
        if(x > y) {
            std::swap(x, y);
        }
        lastans = ask(x, y);
        printf("%d
", lastans);
    }

    return 0;
}

udpate：其实可以删去只出现一次的数。不过恶意卡的话没啥优化效果。