[BZOJ] 2120 - 数颜色 - 分块

2120: 数颜色

Time Limit: 6 Sec   Memory Limit: 259 MB
Submit: 6031   Solved: 2392
[ Submit][ Status][ Discuss]

Description

墨墨购买了一套N支彩色画笔（其中有些颜色可能相同），摆成一排，你需要回答墨墨的提问。墨墨会像你发布如下指令： 1、 Q L R代表询问你从第L支画笔到第R支画笔中共有几种不同颜色的画笔。 2、 R P Col 把第P支画笔替换为颜色Col。为了满足墨墨的要求，你知道你需要干什么了吗？

Input

第1行两个整数N，M，分别代表初始画笔的数量以及墨墨会做的事情的个数。第2行N个整数，分别代表初始画笔排中第i支画笔的颜色。第3行到第2+M行，每行分别代表墨墨会做的一件事情，格式见题干部分。

Output

对于每一个Query的询问，你需要在对应的行中给出一个数字，代表第L支画笔到第R支画笔中共有几种不同颜色的画笔。

Sample Input

6 5
1 2 3 4 5 5
Q 1 4
Q 2 6
R 1 2
Q 1 4
Q 2 6

Sample Output

4
4
3
4

HINT

对于100%的数据，N≤10000，M≤10000，修改操作不多于1000次，所有的输入数据中出现的所有整数均大于等于1且不超过10^6。

又是一道紧张刺激的BZOJ

单点更新，区间查询

每次查询区间内有多少个不同的数字

可以说是 poj 2777 的升级版

当颜色过少的时候，可以状压颜色，这样就能用线段树

但是这题颜色很多

“反正数据结构题就是XJB维护一个区间啦”

—— 来自某数据结构大佬的指点

很明显原区间根据我现在的能力不太好维护

所以我们考虑换过一个区间

olast[i] 表示第 i 个元素上次出现的位置

所以对于区间 [l, r] ，如果olast[i] < l， 就说明只出现过一次

所以问题就变成了

多次 单点更新，区间查询

每次查询 [l. r] 中小于 l 的数字有多少个

然后就是分块

查询的时候

对于每个不完整的块暴力查找

对于完整的块

对块的信息进行排序

然后可以二分查找

修改的时候感觉有点麻烦

你需要重构olast

重构过程中如果有块的内容发生改变

那么我们就重构块

复杂度。。。

每次查询是 num * log(sqrt(n))

每次更新是num * sqrt(n) *  log(sqrt(n))    （花在排序上）

似乎最优块的大小是    (sqrt(n)+log(2*n)/log(2))    应该是根据复杂度算的？

但好像没有快多少

#include <bits/stdc++.h>
using namespace std;

const int N = 100010;
const int M = 1000010;

int ma[N];
//int mb[N];
int bl[N];      ///belong
int wl[N];///块的左边界
int wr[N];///块的右边界
int pre[N];///排序后的块信息
int nlast[M];    ///数字 i 最后出现在第 last[i] 处
int olast[N];    ///第 i 个数字最后出现在第 last[i] 处
int block;
int num;
int n, m;

void build()
{
    block = sqrt(n);
    //block=int(sqrt(n)+log(2*n)/log(2));
    num = n / block;
    if(n % block){
        num ++;
    }
    for(int i = 1; i <= n; i ++){
        bl[i] = (i - 1) / block + 1;
    }
    for(int i = 1; i <= num; i ++){
        wl[i] = (i - 1) * block + 1;
        wr[i] = i * block;
    }
    wr[num] = n;
    for(int i = 1; i <= num; i ++){
        for(int j = wl[i]; j <= wr[i]; j ++){
            pre[j] = olast[j];
        }
        sort(pre + wl[i], pre + wr[i] + 1);
    }
}

int query(int ll, int rr)
{
    int ans = 0;

    if(bl[ll] == bl[rr]){
        for(int i = ll; i <= rr; i ++){
            if(olast[i] < ll){
                ans ++;
            }
        }
    }
    else{
        for(int i = ll; i <= wr[bl[ll]]; i ++){
            if(olast[i] < ll){
                ans ++;
            }
        }
        for(int i = bl[ll] + 1; i < bl[rr]; i ++){  ///遍历块
            ans += lower_bound(pre + wl[i], pre + wr[i] + 1, ll) - pre - wl[i];
        }
        for(int i = wl[bl[rr]]; i <= rr; i ++){
            if(olast[i] < ll){
                ans ++;
            }
        }
    }

    return ans;
}

void update(int x, int v)
{
    int mark;

    for(int i = 1; i <= n; i ++){///直接用memset清空复杂度是1e6
        nlast[ma[i]] = 0;
    }
    
    ma[x] = v;
    for(int i = 1; i <= num; i ++){
        mark = 0;
        for(int j = wl[i]; j <= wr[i]; j ++){
            if(olast[j] != nlast[ma[j]]){
                mark = 1;
            }
            olast[j] = nlast[ma[j]];
            nlast[ma[j]] = j;
        }
        if(mark){
            for(int j = wl[i]; j <= wr[i]; j ++){
                pre[j] = olast[j];
            }
            sort(pre + wl[i], pre + wr[i] + 1);
        }
    }
}

int main()
{
    while(scanf("%d%d", &n, &m) == 2){
        memset(nlast, 0, sizeof(nlast));
        for(int i = 1; i <= n; i ++){
            scanf("%d", &ma[i]);
            olast[i] = nlast[ma[i]];
            nlast[ma[i]] = i;
        }
        build();
        for(int i = 0; i < m; i ++){
            char ops[N];
            int x, y;
            int ans;

            scanf("%s%d%d", ops, &x, &y);
            if(ops[0] == 'Q'){
                ans = query(x, y);
                printf("%d\n", ans);
            }
            else{
                update(x, y);
            }
        }
    }
}