ZOJ 2112 Dynamic Rankings（动态区间第 k 大+块状链表）

题目大意

给定一个数列，编号从 1 到 n，现在有 m 个操作，操作分两类：

　　1. 修改数列中某个位置的数的值为 val

　　2. 询问 [L, R] 这个区间中第 k 大的是多少

n<=50,000   m<=10,000

做法分析

本以为某一天我会用 splay 或者 树套树 去搞的，结果被用块状链表搞了

其实这题和链表没什么关系，利用了块状链表分块操作的思想

首先，看看数据规模：n<=50,000，那么，我们每一块的大小可以设置为 sqrt(n) 大概 230 的样子

用一个数组 A 存储整个数列，将数列分块的保存在链表中，每块大小为 230，并且，每一个块都从小到大排序，这样的复杂度是 sqrt(n)*sqrt(n)*log₂(sqrt(n))

对于修改操作，先将 A 数组对应的位置的值改了，然后找到对应的分块中，修改并排序，这里可以使用插入排序，也可以直接暴力的调用快排，如果直接调用快排，这里的复杂度是 sqrt(n)*log₂(sqrt(n)) 的

对于查询操作：假设查询的是区间 [L, R]，先把区间开头和结尾的不在一个整块中的提出去组成一个新块并排序，把在区间中的整块也提出去，这样，当前的询问操作就是在这些块中询问了，这样以后在二分答案，依次在每一个块中寻找不大于当前答案的数是多大，在每一个块中询问的时候，可以使用二分，这样快点

查询的时间复杂度比较难算，大概是：log₂(MAX_INTEGER)*sqrt(n)*log₂(sqrt(n)) 差不多是 32*225*8 大概 10^4 的样子

那么，总的时间复杂度大概为 M*log₂(MAX_INTEGER)*sqrt(n)*log₂(sqrt(n)) 为 10^8 级别，题目给了 10 秒，在 zoj 上，这个时间复杂度还是可以去试试的

于是过了，5秒多...

参考代码

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

const int N=50004, LEN=230, INF=0x3fffffff;

struct Block_List {
    struct Node {
        int buff[LEN], Size;
        void init() {
            memset(buff, 0, sizeof buff);
            Size=0;
        }
    } List[LEN];
    int tot;

    void init(int n, int A[]) {
        List[0].init(), tot=1;
        for(int i=0, cur=0; i<n; ) {
            for(int j=0; i<n && j<LEN; j++, i++) {
                List[cur].buff[j]=A[i];
                List[cur].Size++;
            }
            if(i==n) continue;
            List[tot++].init();
            cur++;
        }
        for(int i=0; i<tot; i++) sort(List[i].buff, List[i].buff+List[i].Size);
    }

    void update(int id, int old, int val) {
        for(int i=0; i<List[id].Size; i++) if(List[id].buff[i]==old) {
            List[id].buff[i]=val;
            break;
        }
        sort(List[id].buff, List[id].buff+List[id].Size);
    }

    int query(int id, int val) {
        int L=0, R=List[id].Size-1;
        while(L<R) {
            int mid=(L+R)>>1;
            if(List[id].buff[mid]>val) R=mid;
            else L=mid+1;
        }
        if(List[id].buff[L]>val) L--;
        return L+1;
    }

    void NewNode(int id, int A[], int L, int R) {
        List[id].init();
        for(int i=L; i<=R; i++) List[id].buff[i-L]=A[i];
        List[id].Size=R-L+1;
        sort(List[id].buff, List[id].buff+List[id].Size);
    }
};

int A[N], n, m, t;
Block_List hehe;
char cmd[10];
vector <int> tub;

int main() {
//    freopen("in", "r", stdin);
    scanf("%d", &t);
    for(int ca=1; ca<=t; ca++) {
        scanf("%d%d", &n, &m);
        for(int i=0; i<n; i++) scanf("%d", &A[i]);
        hehe.init(n, A);
        for(int i=0, a, b, c; i<m; i++) {
            scanf("%s", cmd);
            if(cmd[0]=='Q') {
                scanf("%d%d%d", &a, &b, &c);
                a--, b--;
                int id1=a/LEN, id2=b/LEN;
                tub.clear();
                if(id1==id2) {
                    hehe.NewNode(hehe.tot, A, a, b);
                    tub.push_back(hehe.tot);
                }
                else {
                    hehe.NewNode(hehe.tot, A, a, (id1+1)*LEN-1);
                    hehe.NewNode(hehe.tot+1, A, id2*LEN, b);
                    tub.push_back(hehe.tot);
                    tub.push_back(hehe.tot+1);
                    for(int i=id1+1; i<id2; i++) tub.push_back(i);
                }
                int L=0, R=INF;
                while(L<R) {
                    int mid=(L+R)>>1;
                    int sum=0;
                    for(int i=0, len=(int)tub.size(); i<len; i++) {
                        sum+=hehe.query(tub[i], mid);
                    }
                    if(sum<c) L=mid+1;
                    else R=mid;
                }
                printf("%d
", L);
            }
            else {
                scanf("%d%d", &a, &b);
                a--;
                hehe.update(a/LEN, A[a], b);
                A[a]=b;
            }
        }
    }
    return 0;
}

题目链接 & AC 通道

ZOJ 2112 Dynamic Rankings