【bzoj1901】Zju2112 Dynamic Rankings

最新推荐文章于 2018-08-20 08:25:00 发布

johann_wyh

最新推荐文章于 2018-08-20 08:25:00 发布

阅读量501

点赞数

分类专栏： BZOJ 树套树

本文链接：https://blog.csdn.net/johann_oier/article/details/50975616

版权

BZOJ 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

树套树

1 篇文章 0 订阅

订阅专栏

Problem

Description

给定一个含有n个数的序列a[1],a[2],a[3]……a[n]，程序必须回答这样的询问：对于给定的i,j,k，在a[i],a[i+1],a[i+2]……a[j]中第k小的数是多少(1≤k≤j-i+1)，并且，你可以改变一些a[i]的值，改变后，程序还能针对改变后的a继续回答上面的问题。你需要编一个这样的程序，从输入文件中读入序列a，然后读入一系列的指令，包括询问指令和修改指令。对于每一个询问指令，你必须输出正确的回答。
第一行有两个正整数n(1≤n≤10000)，m(1≤m≤10000)。分别表示序列的长度和指令的个数。第二行有n个数，表示a[1],a[2]……a[n]，这些数都小于10^9。接下来的m行描述每条指令，每行的格式是下面两种格式中的一种。 Q i j k 或者 C i t
Q i j k （i,j,k是数字，1≤i≤j≤n, 1≤k≤j-i+1）表示询问指令，询问a[i]，a[i+1]……a[j]中第k小的数。
C i t (1≤i≤n，0≤t≤10^9)表示把a[i]改变成为t。

Sample Input

5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

Sample Output

3
6

HINT

20%的数据中，m,n≤100; 40%的数据中，m,n≤1000; 100%的数据中，m,n≤10000。

Solution

树套树，外层是一个用于统计前缀和的树状数组，内层就是一个动态开节点的线段树。
这是不是主席树啊QAQ
相比于静态的区间第K小值，动态的问题唯一区别在于用树状数组维护前缀和。
这就好比，如果是对一个数列做前缀和。若不用修改，则只需要一个sum数组，sum[i] = sum[i-1] + a[i]，区间[l,r]的部分和即为sum[r] - sum[l-1]。若要修改，就用一个树状数组来实现。
类比到树套树。唯一的变化在于，前一个问题中每一个单元记录了一个数，而这里记录的是一棵树。

Code

#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define red(i, a, b) for(int i = (a); i >= (b); i--)
#define ll long long

inline int read() {
    char c = getchar(); int x = 0, f = 1;
    while(!isdigit(c)) { if (c == '-') f = -1; c = getchar(); }
    while(isdigit(c)) { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxn = 11111;
const int NN = maxn * 100;
struct node {
    int x, y, z;
}a[maxn << 1];
int n, m, nn, N, sz = 0;
int seq[maxn], RL[maxn], RR[maxn], root[maxn], lnk[maxn << 1];
int lc[NN], rc[NN], sum[NN];
int opr[maxn << 1][4];
map <int, int> hash;

bool cmp1(node a, node b) { return a.x < b.x; }
bool cmp2(node a, node b) { return a.y < b.y; }
int lowbit(int x) { return x & (-x); }

void update(int l, int r, int& y, int v, int p) {
    if (!y) y = ++sz;
    sum[y] += p;
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (v <= mid) update(l, mid, lc[y], v, p);
    else update(mid + 1, r, rc[y], v, p);
}

int query(int l, int r, int kth) {
    int mid = (l + r) >> 1;
    if (l == r) return l;
    int suml = 0, sumr = 0;
    rep(i, 1, RL[0]) suml += sum[lc[RL[i]]];
    rep(i, 1, RR[0]) sumr += sum[lc[RR[i]]];
    if (sumr - suml >= kth) {
        rep(i, 1, RL[0]) RL[i] = lc[RL[i]];
        rep(i, 1, RR[0]) RR[i] = lc[RR[i]];
        return query(l, mid, kth);
    }else {
        rep(i, 1, RL[0]) RL[i] = rc[RL[i]];
        rep(i, 1, RR[0]) RR[i] = rc[RR[i]];
        return query(mid + 1, r, kth - sumr + suml);
    }
}

int main() {
    n = read(); m = read();
    rep(i, 1, n) {
        a[i].x = read();
        a[i].y = i;
    }
    nn = n;
    rep(i, 1, m) {
        char ch = getchar();
        while(ch != 'Q' && ch != 'C') ch = getchar();
        if (ch == 'C') {
            int pos = read(), x = read();
            opr[i][0] = 0; opr[i][1] = pos; opr[i][2] = x;
            a[++nn].x = x; a[nn].y = nn;
        }
        if (ch == 'Q') {
            int ql = read(), qr = read(), kth = read();
            opr[i][0] = 1; opr[i][1] = ql; opr[i][2] = qr; opr[i][3] = kth;
        }
    }

    sort(a + 1, a + nn + 1, cmp1);
    N = 1;
    a[1].z = 1; lnk[1] = a[1].x; hash[a[1].x] = 1;
    rep(i, 2, nn) {
        a[i].z = a[i].x == a[i-1].x ? N : ++N;
        lnk[N] = a[i].x;
        hash[a[i].x] = N;
    }
    sort(a + 1, a + nn + 1, cmp2);
    rep(i, 1, n) seq[i] = a[i].z;

    memset(root, 0, sizeof(root)); 
    rep(i, 1, n) {
        for(int j = i; j <= n; j += lowbit(j))
            update(1, N, root[j], a[i].z, 1);
    }
    rep(i, 1, m) {
        int op = opr[i][0];
        if (op == 0) {
            int pos = opr[i][1], cur = opr[i][2], pre = seq[pos];
            cur = hash[cur];
            for(int j = pos; j <= n; j += lowbit(j)) {
                update(1, N, root[j], pre, -1);
                update(1, N, root[j], cur, 1);
            }
            seq[pos] = cur;
        }else {
            int ql = opr[i][1], qr = opr[i][2], kth = opr[i][3];
            memset(RL, 0, sizeof(RL));
            memset(RR, 0, sizeof(RR));
            for(int j = ql - 1; j > 0; j -= lowbit(j)) RL[++RL[0]] = root[j];
            for(int j = qr; j > 0; j -= lowbit(j)) RR[++RR[0]] = root[j];
            int kc = query(1, N, kth);
            printf("%d\n", lnk[kc]);
        }
    }
    return 0;
}