洛谷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 = ;

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

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

 inline int getTime(int x, int y, int c) {
     if(x > y) {
         return ;
     }
     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() - ;
     return y - x + ;
 }

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

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

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

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

     return ;
 }

AC代码

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