分块⑨题

冲着这个智慧的数字"⑨"就值得一写。

T1，区间加，单点查。

打个标记就行了。

#include <cstdio>
#include <cmath>

const int N = 50010;

int le[N], re[N], sum[N], tag[N], a[N], fr[N];

inline void add(int x, int y, int c) {
    int l = fr[x], r = fr[y];
    if(l == r) {
        for(int i = x; i <= y; i++) {
            a[i] += c;
            sum[r] += c;
        }
        return;
    }
    for(int i = l + 1; i < r; i++) {
        sum[i] += c * (re[i] - le[i] + 1);
        tag[i] += c;
    }
    for(int i = x; i <= re[l]; i++) {
        a[i] += c;
        sum[l] += c;
    }
    for(int i = le[r]; i <= y; i++) {
        a[i] += c;
        sum[r] += c;
    }
    return;
}

inline int ask(int x) {
    return a[x] + tag[fr[x]];
}

int main() {
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    int T = sqrt(n);
    for(int i = 1; i <= T; i++) {
        le[i] = T * (i - 1) + 1;
        re[i] = T * i;
        for(int j = le[i]; j <= re[i]; j++) {
            fr[j] = i;
            sum[i] += a[j];
        }
    }
    if(re[T] < n) {
        T++;
        le[T] = re[T - 1] + 1;
        re[T] = n;
        for(int i = le[T]; i <= n; i++) {
            sum[T] += a[i];
            fr[i] = T;
        }
    }

    for(int i = 1, f, x, y, z; i <= n; i++) {
        scanf("%d%d%d%d", &f, &x, &y, &z);
        if(f == 0) {
            add(x, y, z);
        }
        else {
            int t = ask(y);
            printf("%d\n", t);
        }
    }

    return 0;
}

T2，区间加，询问区间比x大的数的个数。

yy了一个n^1.5logn的做法，然后发现复杂度可过......

有一个SB错误害我调了半天：931每块大小是30，这样就会有32块，最后要加上两块，而我只加了一块。

好像有高端写法可以避免...下一题试一下。

#include <cstdio>
#include <cmath>
#include <algorithm>

typedef long long LL;
const int N = 50010;

LL a[N], tag[N], p[2000][2000];
int fr[N], le[N], re[N];

inline void add(int x, int y, LL c) {
    int l = fr[x], r = fr[y];
    if(l == r) {
        for(int i = x; i <= y; i++) {
            a[i] += c;
        }
        p[r][0] = 0;
        for(int i = le[r]; i <= re[r]; i++) {
            p[r][++p[r][0]] = a[i];
        }
        std::sort(p[r] + 1, p[r] + p[r][0] + 1);
        return;
    }
    for(int i = l + 1; i < r; i++) {
        tag[i] += c;
    }
    for(int i = x; i <= re[l]; i++) {
        a[i] += c;
    }
    p[l][0] = 0;
    for(int i = le[l]; i <= re[l]; i++) {
        p[l][++p[l][0]] = a[i];
    }
    std::sort(p[l] + 1, p[l] + p[l][0] + 1);
    for(int i = le[r]; i <= y; i++) {
        a[i] += c;
    }
    p[r][0] = 0;
    for(int i = le[r]; i <= re[r]; i++) {
        p[r][++p[r][0]] = a[i];
    }
    std::sort(p[r] + 1, p[r] + p[r][0] + 1);
    return;
}

inline int ask(int x, int y, LL c) {
    int l = fr[x], r = fr[y], ans = 0;
    if(l == r) {
        for(int i = x; i <= y; i++) {
            ans += (a[i] + tag[r] < c);
        }
        return ans;
    }
    for(int i = l + 1; i < r; i++) {
        int t = std::lower_bound(p[i] + 1, p[i] + p[i][0] + 1, c - tag[i]) - p[i];
        ans += t - 1;
    }
    for(int i = x; i <= re[l]; i++) {
        ans += (a[i] + tag[l] < c);
    }
    for(int i = le[r]; i <= y; i++) {
        ans += (a[i] + tag[r] < c);
    }
    return ans;
}

int main() {

    int n;
    scanf("%d", &n);
    int T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
        fr[i] = (i - 1) / T + 1;
        p[fr[i]][++p[fr[i]][0]] = a[i];
    }
    for(int i = 1; i <= T; i++) {
        le[i] = (i - 1) * T + 1;
        re[i] = i * T;
        std::sort(p[i] + 1, p[i] + p[i][0] + 1);
    }
    while(re[T] < n) {
        T++;
        re[T] = std::min(n, T * re[1]);
        le[T] = re[T - 1] + 1;
        std::sort(p[T] + 1, p[T] + p[T][0] + 1);
    }

    LL z;
    for(int i = 1, f, x, y; i <= n; i++) {
        scanf("%d%d%d%lld", &f, &x, &y, &z);
        if(f == 0) {
            add(x, y, z);
        }
        else {
            int t = ask(x, y, z * z);
            printf("%d\n", t);
        }
    }

    return 0;
}

 T3，区间加，询问区间前驱。

其实跟T2差别不大...数据范围开到100000了。感觉过不去，加了点剪枝，最后还是过了...

剪枝就是记录区间max，min。如果max < c 或 min > c就可以直接判断。

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <climits>

const int N = 100010, INF = LONG_MAX;

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

int a[N], tag[N], large[N], small[N], fr[N], le[N], re[N];
int p[350][350];

inline void update(int x) {
    large[x] = -INF - 1;
    small[x] = INF;
    p[x][0] = 0;
    for(int i = le[x]; i <= re[x]; i++) {
        p[x][++p[x][0]] = a[i];
        large[x] = std::max(large[x], a[i]);
        small[x] = std::min(small[x], a[i]);
    }
    std::sort(p[x] + 1, p[x] + p[x][0] + 1);
    return;
}

inline void add(int x, int y, int c) {
    int l = fr[x], r = fr[y];
    if(l == r) {
        for(int i = x; i <= y; i++) {
            a[i] += c;
        }
        update(r);
        return;
    }
    for(int i = l + 1; i < r; i++) {
        tag[i] += c;
    }
    for(int i = x; i <= re[l]; i++) {
        a[i] += c;
    }
    update(l);
    for(int i = le[r]; i <= y; i++) {
        a[i] += c;
    }
    update(r);
    return;
}

inline int ask(int x, int y, int c) {
    int ans = -1, l = fr[x], r = fr[y];
    if(l == r) {
        if(small[r] + tag[r] >= c) {
            return -1;
        }
        for(int i = x; i <= y; i++) {
            if(a[i] + tag[r] < c) {
                ans = std::max(ans, a[i] + tag[r]);
            }
        }
        return ans;
    }
    for(int i = l + 1; i < r; i++) {
        if(large[i] + tag[i] < c) {
            ans = std::max(ans, large[i] + tag[i]);
            continue;
        }
        if(small[i] + tag[i] >= c) {
            continue;
        }
        int t = std::lower_bound(p[i] + 1, p[i] + p[i][0] + 1, c - tag[i]) - p[i];
        if(t > 1) {
            ans = std::max(ans, p[i][t - 1] + tag[i]);
        }
    }
    for(int i = x; i <= re[l] && small[l] + tag[l] < c; i++) {
        if(a[i] + tag[l] < c) {
            ans = std::max(ans, a[i] + tag[l]);
        }
    }
    for(int i = le[r]; i <= y && small[r] + tag[r] < c; i++) {
        if(a[i] + tag[r] < c) {
            ans = std::max(ans, a[i] + tag[r]);
        }
    }
    return ans;
}

int main() {
    int n;
    read(n);
    int T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        read(a[i]);
        fr[i] = (i - 1) / T + 1;
    }
    for(int i = 1; i <= fr[n]; i++) {
        le[i] = (i - 1) * T + 1;
        re[i] = i * T;
        if(i == fr[n]) {
            re[i] = n;
        }
        update(i);
    }

    for(int i = 1, f, x, y, z; i <= n; i++) {
        read(f);
        read(x);
        read(y);
        read(z);
        if(f == 0) {
            add(x, y, z);
        }
        else {
            int t = ask(x, y, z);
            printf("%d\n", t);
        }
    }

    return 0;
}

T4，区间加，区间求和。

打个标记就行了...

#include <cstdio>
#include <cmath>

typedef long long LL;
const int N = 100010;

int le[N], re[N], fr[N];
LL a[N], tag[N], sum[N];

inline void add(int x, int y, LL c) {
    int l = fr[x], r = fr[y];
    if(l == r) {
        for(int i = x; i <= y; i++) {
            a[i] += c;
            sum[r] += c;
        }
        return;
    }
    for(int i = l + 1; i < r; i++) {
        tag[i] += c;
        sum[i] += c * (re[i] - le[i] + 1);
    }
    for(int i = x; i <= re[l]; i++) {
        a[i] += c;
        sum[l] += c;
    }
    for(int i = le[r]; i <= y; i++) {
        a[i] += c;
        sum[r] += c;
    }
    return;
}

inline LL ask(int x, int y) {
    int l = fr[x], r = fr[y];
    LL ans = 0;
    if(l == r) {
        for(int i = x; i <= y; i++) {
            ans += a[i] + tag[r];
        }
        return ans;
    }
    for(int i = l + 1; i < r; i++) {
        ans += sum[i];
    }
    for(int i = x; i <= re[l]; i++) {
        ans += a[i] + tag[l];
    }
    for(int i = le[r]; i <= y; i++) {
        ans += a[i] + tag[r];
    }
    return ans;
}

int main() {
    int n;
    scanf("%d", &n);
    int T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
        fr[i] = (i - 1) / T + 1;
        sum[fr[i]] += a[i];
    }
    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;
        }
    }

    LL z;
    for(int i = 1, x, y, f; i <= n; i++) {
        scanf("%d%d%d%lld", &f, &x, &y, &z);
        if(f == 0) {
            add(x, y, z);
        }
        else {
            LL t = ask(x, y) % (z + 1);
            printf("%lld\n", t);
        }
    }

    return 0;
}

 T5，区间开方下取整，区间求和。

跟线段树做法一样，维护最大值即可。

#include <cstdio>
#include <cmath>
#include <algorithm>

const int N = 50010;

int fr[N], le[N], re[N], sum[N], large[N], a[N];

inline void update(int x) {
    sum[x] = large[x] = 0;
    for(int i = le[x]; i <= re[x]; i++) {
        sum[x] += a[i];
        large[x] = std::max(large[x], a[i]);
    }
    return;
}

inline void change(int x, int y) {
    int l = fr[x], r = fr[y];
    if(l == r) {
        if(large[r] <= 1) {
            return;
        }
        for(int i = x; i <= y; i++) {
            if(a[i] > 1) {
                a[i] = sqrt(a[i]);
            }
        }
        update(r);
        return;
    }
    for(int i = l + 1; i < r; i++) {
        if(large[i] <= 1) {
            continue;
        }
        for(int j = le[i]; j <= re[i]; j++) {
            if(a[j] > 1) {
                a[j] = sqrt(a[j]);
            }
        }
        update(i);
    }
    if(large[l] > 1) {
        for(int i = x; i <= re[l]; i++) {
            if(a[i] > 1) {
                a[i] = sqrt(a[i]);
            }
        }
        update(l);
    }
    if(large[r] > 1) {
        for(int i = le[r]; i <= y; i++) {
            if(a[i] > 1) {
                a[i] = sqrt(a[i]);
            }
        }
        update(r);
    }
    return;
}

inline int ask(int x, int y) {
    int l = fr[x], r = fr[y], ans = 0;
    if(l == r) {
        for(int i = x; i <= y; i++) {
            ans += a[i];
        }
        return ans;
    }
    for(int i = l + 1; i < r; i++) {
        ans += sum[i];
    }
    for(int i = x; i <= re[l]; i++) {
        ans += a[i];
    }
    for(int i = le[r]; i <= y; i++) {
        ans += a[i];
    }
    return ans;
}

int main() {
    int n;
    scanf("%d", &n);
    int T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        fr[i] = (i - 1) / T + 1;
    }
    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;
        }
        update(i);
    }

    for(int i = 1, f, x, y, z; i <= n; i++) {
        scanf("%d%d%d%d", &f, &x, &y, &z);
        if(f == 0) {
            change(x, y);
        }
        else {
            int t = ask(x, y);
            printf("%d\n", t);
        }
    }

    return 0;
}

 第一个一次写对的分块...感动啊。

T7，区间加，乘，单点查值。

感觉这个顺序比较自然就先写7了...

跟线段树一样打两个标记即可。这个还不用记sum。

#include <cstdio>
#include <cmath>

const int N = 100010, MO = 10007;

int a[N], tagm[N], taga[N];
int fr[N], le[N], re[N];

inline void pushdown(int x) {
    if(tagm[x] != 1) {
        for(int i = le[x]; i <= re[x]; i++) {
            (a[i] *= tagm[x]) %= MO;
        }
        tagm[x] = 1;
    }
    if(taga[x] != 0) {
        for(int i = le[x]; i <= re[x]; i++) {
            (a[i] += taga[x]) %= MO;
        }
        taga[x] = 0;
    }
    return;
}

inline void add(int x, int y, int c) {
    int l = fr[x], r = fr[y];
    if(l == r) {
        pushdown(r);
        for(int i = x; i <= y; i++) {
            (a[i] += c) %= MO;
        }
        return;
    }
    for(int i = l + 1; i < r; i++) {
        (taga[i] += c) %= MO;
    }
    pushdown(l);
    for(int i = x; i <= re[l]; i++) {
        (a[i] += c) %= MO;
    }
    pushdown(r);
    for(int i = le[r]; i <= y; i++) {
        (a[i] += c) %= MO;
    }
    return;
}

inline void mul(int x, int y, int c) {
    int l = fr[x], r = fr[y];
    if(l == r) {
        pushdown(r);
        for(int i = x; i <= y; i++) {
            (a[i] *= c) %= MO;
        }
        return;
    }
    for(int i = l + 1; i < r; i++) {
        (tagm[i] *= c) %= MO;
        (taga[i] *= c) %= MO;
    }
    pushdown(l);
    for(int i = x; i <= re[l]; i++) {
        (a[i] *= c) %= MO;
    }
    pushdown(r);
    for(int i = le[r]; i <= y; i++) {
        (a[i] *= c) %= MO;
    }
    return;
}

inline int ask(int x) {
    return (a[x] * tagm[fr[x]] % MO + taga[fr[x]]) % MO;
}

int main() {
    int n;
    scanf("%d", &n);
    int T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        a[i] %= MO;
        fr[i] = (i - 1) / T + 1;
    }
    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;
        }
        tagm[i] = 1;
    }

    for(int i = 1, f, x, y, z; i <= n; i++) {
        scanf("%d%d%d%d", &f, &x, &y, &z);
        if(!f) {
            add(x, y, z % MO);
        }
        else if(f == 1) {
            mul(x, y, z % MO);
        }
        else {
            int t = ask(y);
            printf("%d\n", t);
        }
    }

    return 0;
}

T8，区间查询等于c的数的个数，并全部改为c。

又是玄学题目...复杂度懒得证了。

维护一个每段是否相同的标记。

#include <cstdio>
#include <cmath>

const int N = 100010;

int a[N], vis[N], tag[N];
int fr[N], le[N], re[N];

inline void solve(int x, int y, int c) {
    int l = fr[x], r = fr[y], ans = 0;
    if(l == r) {
        if(vis[r] && tag[r] == c) {
            printf("%d\n", y - x + 1);
            return;
        }
        else if(vis[r]) {
            vis[r] = 0;
            for(int i = le[r]; i <= re[r]; i++) {
                if(x <= i && i <= y) {
                    a[i] = c;
                }
                else {
                    a[i] = tag[r];
                }
            }
            puts("0");
            return;
        }
        for(int i = x; i <= y; i++) {
            ans += (a[i] == c);
            a[i] = c;
        }
        printf("%d\n", ans);
        return;
    }
    for(int i = l + 1; i < r; i++) {
        if(vis[i]) {
            ans += (tag[i] == c) * (re[i] - le[i] + 1);
            tag[i] = c;
        }
        else {
            vis[i] = 1;
            tag[i] = c;
            for(int j = le[i]; j <= re[i]; j++) {
                ans += (a[j] == c);
            }
        }
    }
    if(vis[l] && tag[l] == c) {
        ans += (re[l] - x + 1);
    }
    else if(vis[l]) {
        vis[l] = 0;
        for(int i = le[l]; i < x; i++) {
            a[i] = tag[l];
        }
        for(int i = x; i <= re[l]; i++) {
            a[i] = c;
        }
    }
    else {
        for(int i = x; i <= re[l]; i++) {
            ans += (a[i] == c);
            a[i] = c;
        }
    }

    if(vis[r] && tag[r] == c) {
        ans += (y - le[r] + 1);
    }
    else if(vis[r]) {
        vis[r] = 0;
        for(int i = le[r]; i <= y; i++) {
            a[i] = c;
        }
        for(int i = y + 1; i <= re[r]; i++) {
            a[i] = tag[r];
        }
    }
    else {
        for(int i = le[r]; i <= y; i++) {
            ans += (a[i] == c);
            a[i] = c;
        }
    }
    printf("%d\n", ans);
    return;
}

int main() {
    int n;
    scanf("%d", &n);
    int T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        fr[i] = (i - 1) / T + 1;
    }
    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 i = 1, x, y, z; i <= n; i++) {
        scanf("%d%d%d", &x, &y, &z);
        solve(x, y, z);
    }

    return 0;
}

T9，静态区间众数。

这道题可以用三种方法，两种在线一种离线。

离线是莫队套值域线段树，维护出现次数最大值，复杂度O(n^1.5logn)，可能需要卡常......

好像可以做到n√n...开两个桶，第一个维护出现次数，第二个维护出现次数为i的有几个数。

在线：

有一个共通的就是，需要预处理出块两两之间的众数。

然后对于某询问，答案要么是块(l, r)之间的众数，要么是在两边出现的数。

枚举两边出现的数，这不超过2n^0.5个，然后对于每个数查询出现次数即可。

①：

处理出sum[i][j]表示前i块中j出现的次数。

查询时用n^0.5的时间调整附近两块的sum到查询区间的sum，然后可以做到O(1)查询。之后再还原。

预处理：块i，j之间的众数，要么是块i，j - 1的众数，要么是第j块中的数。枚举查询即可。

时间复杂度：O(n^1.5 + n^1.5)，空间复杂度：O(n^1.5)

#include <cstdio>
#include <algorithm>
#include <cmath>

const int N = 100010;

int a[N], sum[350][N], X[N], fr[N], le[N], re[N], md[350][350];

inline int ask(int x, int y) {
    int l = fr[x], r = fr[y];
    int ans = md[l + 1][r - 1];
    if(l == r) {
        for(int i = le[l]; i < x; i++) {
            sum[l - 1][a[i]]++;
        }
        for(int i = y + 1; i <= re[r]; i++) {
            sum[r][a[i]]--;
        }
        //
        for(int i = x; i <= y; i++) {
            if(sum[r][a[i]] - sum[l - 1][a[i]] > sum[r][ans] - sum[l - 1][ans]) {
                ans = a[i];
            }
            else if(sum[r][a[i]] - sum[l - 1][a[i]] == sum[r][ans] - sum[l - 1][ans]) {
                ans = std::min(ans, a[i]);
            }
        }
        //
        for(int i = le[l]; i < x; i++) {
            sum[l - 1][a[i]]--;
        }
        for(int i = y + 1; i <= re[r]; i++) {
            sum[r][a[i]]++;
        }
        return ans;
    }
    for(int i = le[l]; i < x; i++) {
        sum[l - 1][a[i]]++;
    }
    for(int i = y + 1; i <= re[r]; i++) {
        sum[r][a[i]]--;
    }
    //
    for(int i = x; i <= re[l]; i++) {
        if(sum[r][a[i]] - sum[l - 1][a[i]] > sum[r][ans] - sum[l - 1][ans]) {
            ans = a[i];
        }
        else if(sum[r][a[i]] - sum[l - 1][a[i]] == sum[r][ans] - sum[l - 1][ans]) {
            ans = std::min(ans, a[i]);
        }
    }
    for(int i = le[r]; i <= y; i++) {
        if(sum[r][a[i]] - sum[l - 1][a[i]] > sum[r][ans] - sum[l - 1][ans]) {
            ans = a[i];
        }
        else if(sum[r][a[i]] - sum[l - 1][a[i]] == sum[r][ans] - sum[l - 1][ans]) {
            ans = std::min(ans, a[i]);
        }
    }
    //
    for(int i = le[l]; i < x; i++) {
        sum[l - 1][a[i]]--;
    }
    for(int i = y + 1; i <= re[r]; i++) {
        sum[r][a[i]]++;
    }
    return ans;
}

int main() {
    int n;
    scanf("%d", &n);
    int T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        fr[i] = (i - 1) / T + 1;
        X[i] = a[i];
    }
    std::sort(X + 1, X + n + 1);
    int temp = std::unique(X + 1, X + n + 1) - X - 1;
    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 i = 1; i <= n; i++) {
        a[i] = std::lower_bound(X + 1, X + temp + 1, a[i]) - X;
        sum[fr[i]][a[i]]++;
    }
    for(int i = 1; i <= fr[n]; i++) {
        for(int j = 1; j <= temp; j++) {
            sum[i][j] += sum[i - 1][j];
        }
    }
    for(int l = 1; l <= fr[n]; l++) {
        for(int r = l; r <= fr[n]; r++) {
            // md l r
            md[l][r] = md[l][r - 1];
            for(int i = le[r]; i <= re[r]; i++) {
                // md[l][r] a[i]
                if(sum[r][a[i]] - sum[l - 1][a[i]] > sum[r][md[l][r]] - sum[l - 1][md[l][r]]) {
                    md[l][r] = a[i];
                }
                else if(sum[r][a[i]] - sum[l - 1][a[i]] == sum[r][md[l][r]] - sum[l - 1][md[l][r]]) {
                    md[l][r] = std::min(md[l][r], a[i]);
                }
            }
        }
    }

    for(int i = 1, x, y; i <= n; i++) {
        scanf("%d%d", &x, &y);
        int t = ask(x, y);
        printf("%d\n", X[t]);
    }

    return 0;
}

②：实测TLE，但是思路值得借鉴：

使用n个vector，v[i]表示i出现的下标。

查询的时候在对应vector里面二分左右边界的下标，然后相减，就是出现次数。

#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>

const int N = 40010;

int a[N], fr[N], le[N], re[N], md[250][250], X[N];
std::vector<int> v[N];

inline int cnt(int x, int y, int c) {
    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();
    // [x, y)
    return y - x;
}

inline int ask(int x, int y) {
    int l = fr[x], r = fr[y];
    int ans = md[l + 1][r - 1];
    int large = cnt(x, y, ans);
    if(l == r) {
        for(int i = x; i <= y; i++) {
            int A = cnt(x, y, a[i]);
            if(A > large) {
                large = A;
                ans = a[i];
            }
            else if(A == large) {
                ans = std::min(ans, a[i]);
            }
        }
        return ans;
    }
    for(int i = x; i <= re[l]; i++) {
        int A = cnt(x, y, a[i]);
        if(A > large) {
            large = A;
            ans = a[i];
        }
        else if(A == large) {
            ans = std::min(ans, a[i]);
        }
    }
    for(int i = le[r]; i <= y; i++) {
        int A = cnt(x, y, a[i]);
        if(A > large) {
            large = A;
            ans = a[i];
        }
        else if(A == large) {
            ans = std::min(ans, a[i]);
        }
    }
    return ans;
}

int main() {
    int n;
    scanf("%d", &n);
    int T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        fr[i] = (i - 1) / T + 1;
        X[i] = a[i];
    }
    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;
        }
    }
    std::sort(X + 1, X + n + 1);
    int temp = std::unique(X + 1, X + n + 1) - X - 1;
    for(int i = 1; i <= n; i++) {
        a[i] = std::lower_bound(X + 1, X + temp + 1, a[i]) - X;
        v[a[i]].push_back(i);
    }
    for(int i = 1; i <= temp; i++) {
        std::sort(v[i].begin(), v[i].end());
    }
    for(int l = 1; l <= fr[n]; l++) {
        for(int r = l; r <= fr[n]; r++) {
            md[l][r] = md[l][r - 1];
            int large = cnt(le[l], re[r], md[l][r]);
            for(int i = le[r]; i <= re[r]; i++) {
                int A = cnt(le[l], re[r], a[i]);
                if(A > large) {
                    md[l][r] = a[i];
                    large = A;
                }
                else if(A == large) {
                    md[l][r] = std::min(md[l][r], a[i]);
                }
            }
        }
    }

    for(int i = 1, x, y; i <= n; i++) {
        scanf("%d%d", &x, &y);
        int t = ask(x, y);
        printf("%d\n", X[t]);
    }

    return 0;
}

还有带修区间众数...没找到啥题，算了。真的遇到就直接上n²好了。

可以带修莫队套值域线段树，n^5/3logn跟n²也差不了多少了...50000的复杂度是10亿呢。

有一种n^1.5logn的做法，懒得学了...

T6，单点插入，单点求值。

块状链表，学鬼啊，直接splay水过去算了。

#include <cstdio>
#include <algorithm>

const int N = 2000010;

int fa[N], s[N][2], val[N], S[N], Sp, siz[N], root, tot, A[N];
bool rev[N];

inline void pushup(int x) {
    siz[x] = siz[s[x][0]] + siz[s[x][1]] + 1;
    if(!fa[x]) {
        root = x;
    }
    return;
}

inline void pushdown(int x) {
    if(rev[x]) {
        if(s[x][0]) {
            rev[s[x][0]] ^= 1;
        }
        if(s[x][1]) {
            rev[s[x][1]] ^= 1;
        }
        std::swap(s[x][0], s[x][1]);
        rev[x] = 0;
    }
    return;
}

inline void rotate(int x) {
    int y = fa[x];
    int z = fa[y];
    bool f = (s[y][1] == x);

    fa[x] = z;
    if(z) {
        s[z][s[z][1] == y] = x;
    }
    s[y][f] = s[x][!f];
    if(s[x][!f]) {
        fa[s[x][!f]] = y;
    }
    s[x][!f] = y;
    fa[y] = x;

    pushup(y);
    pushup(x);
    return;
}

inline void splay(int x, int g = 0) {
    int y = x;
    S[++Sp] = y;
    while(fa[y]) {
        y = fa[y];
        S[++Sp] = y;
    }
    while(Sp) {
        pushdown(S[Sp]);
        Sp--;
    }

    y = fa[x];
    int z = fa[y];
    while(y != g) {
        if(z != g) {
            (s[z][1] == y) ^ (s[y][1] == x) ?
            rotate(x) : rotate(y);
        }
        rotate(x);
        y = fa[x];
        z = fa[y];
    }
    return;
}

inline int np(int x, int f) {
    ++tot;
    val[tot] = x;
    fa[tot] = f;
    pushup(tot);
    return tot;
}

int build(int l, int r, int f) {
    int mid = (l + r) >> 1;
    int p = np(A[mid], f);
    if(l < mid) {
        s[p][0] = build(l, mid - 1, p);
    }
    if(mid < r) {
        s[p][1] = build(mid + 1, r, p);
    }
    pushup(p);
    return p;
}

void out(int x) {
    if(s[x][0]) {
        out(s[x][0]);
    }
    printf("%d", val[x]);
    if(s[x][1]) {
        out(s[x][1]);
    }
    return;
}

inline int getPbyR(int k) {
    int p = root;
    while(1) {
        pushdown(p);
        if(siz[s[p][0]] >= k) {
            p = s[p][0];
        }
        else if(siz[s[p][0]] + 1 == k) {
            break;
        }
        else {
            k -= (siz[s[p][0]] + 1);
            p = s[p][1];
        }
    }
    splay(p);
    return p;
}

inline int getRP() {
    pushdown(root);
    int p = s[root][1];
    pushdown(p);
    while(s[p][0]) {
        p = s[p][0];
        pushdown(p);
    }
    return p;
}

inline void insert(int k, int c) { // after k insert c
    int y = getPbyR(k + 1);
    int x = getRP();
    splay(x, y);
    s[x][0] = build(1, c, x);
    pushup(x);
    pushup(y);
    return;
}

inline void ask(int l, int r) {
    int x = getPbyR(l);
    int y = getPbyR(r + 2);
    splay(x, y);
    out(s[x][1]);
    puts("");
    return;
}

int main() {
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &A[i]);
    }
    root = build(0, n + 1, 0);
    //out(root);
    //puts("");
    for(int i = 1, x, y, z, f; i <= n; i++) {
        scanf("%d%d%d%d", &f, &x, &y, &z);
        if(!f) {
            A[1] = y;
            insert(x - 1, 1);
        }
        else {
            ask(y, y);
        }
        //out(root);
        //puts("");
    }

    return 0;
}

总结：分块就是暴力乱搞......不过很有效，还可能是正解。还能干一些别的数据结构搞不倒的事。