分块详解

hzwer的9题
https://loj.ac/problem/6277
https://loj.ac/problem/6278
https://loj.ac/problem/6279
https://loj.ac/problem/6280
https://loj.ac/problem/6281
https://loj.ac/problem/6282
https://loj.ac/problem/6283
https://loj.ac/problem/6284
https://loj.ac/problem/6285

例题会稍后放上

分块是一种优雅的暴力

大概思想是这样的:维护\(\sqrt(n)\)个块查询的时候是查询区间内的块如果有的部分不满一个块就用枚举常数较小

对于上面这个说明我举个简单的例子：假设n = 10000 那么每个块就是\(\sqrt n\) = 100 每个块是

1~100
101~200
...
9901~10000

假设要查询 2 ~ 999的值

你只需要维护每个大小为 \(\sqrt n\) 的块也就是大小为 100 的块然后对\(101\)~\(200\) - \(801\)~\(900\)这几个块查询块的值
然后暴力 \(2\)~\(100\) 和 \(901\) ~ \(999\) 的值

之所以称为优雅的暴力分块把朴素暴力的 \(2\) ~ \(999\) 改成了 \(200\) 复杂度左右的暴力

个人觉得 \(2\)~\(999\)是最坏情况

如果查询 \(1\)~\(1000\) 那么分块的优势就出来了

分块的预处理是将每一个数字存入一个块中复杂度是\(\theta n\)

然后区间修改查询什么的最多不超过 \(3\sqrt n\)

证明：一个块的大小是\(\sqrt(n)\) 那么多出来的左区间和右区间的最坏情况是 \(\sqrt(n)\)) 所以易证

分块的时间复杂度大概就是 \(\theta (N + q * \sqrt(N))\)
（n指序列长度 q指查询修改的操作次数）
以上就是一个基本的分块思想简单讲分块比线段树容易实现

\(\text{分块1}\)
分块1是区间修改单点查询

我们用一个数组维护块

如果区间修改的时候包含这个块那么可以把这个块加上需要修改的值如果是多出来的就直接暴力修改了

然后查询的时候输出所在块修改的值和本身的值

// Isaunoya
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std ;
const int N = 50000 + 5 ;
const int Bl = 300 + 5 ;
struct node {
    int l , r ;
    int add ;
} ;
int n ;
int a[N] ;
node atag[Bl] ;
int bl[N] ; int unt ;
inline void change(int l , int r , int c) {
    for(register int i = l ; i <= min(bl[l] * unt , r) ; i ++)
        a[i] += c ;
    if(bl[l] != bl[r])
        for(register int i = (bl[r] - 1) * unt + 1 ; i <= r ; i ++)
            a[i] += c ;
    for(register int i = bl[l] + 1 ; i <= bl[r] - 1 ; i ++)
        atag[i].add += c ;
}
signed main() {
    ios::sync_with_stdio(false) ;
    cin >> n ;
    for(register int i = 1 ; i <= n ; i ++) cin >> a[i] ;
    unt = sqrt(n) ;
    for(register int i = 1 ; i <= n ; i ++) {
        bl[i] = (i - 1) / unt + 1 ;
    }
    for(register int i = 1 ; i <= n ; i ++) {
        int opt ;
        cin >> opt ;
        if(opt == 0) {
            int l , r , c ;
            cin >> l >> r >> c ;
            change(l , r , c) ;
        }
        else {
            int l , r , c ;
            cin >> l >> r >> c ;
            cout << a[r] + atag[bl[r]].add << endl ;
        }
    }
    return 0 ;
}

\(\text{分块2}\)

分块二求的是区间修改区间查询小于\(c^2\)的最大数
vector 每次修改完重构一下左右块就行了

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
inline int read() {
    register int x = 0;
    register int f = 1;
    register char c;
#define gc c = getchar()
    while (isspace(gc))
        ;
    c == '-' ? gc, f = -1 : 0;
    while (x = (x << 3) + (x << 1) + (c & 15), isdigit(gc))
        ;
    return x * f;
}
const int N = 50000 + 5;
const int Bl = 300 + 5;
int n;
int a[N];
struct node {
    int add;
    std::vector<int> v;
};
node atag[Bl];
int unt;
int bl[N];
inline void reset(int x) {
    atag[x].v.clear();
    for (register int i = (x - 1) * unt + 1; i <= min(x * unt, n); i++) atag[x].v.push_back(a[i]);
    sort(atag[x].v.begin(), atag[x].v.end());
    return;
}
inline void change(int l, int r, int c) {
    for (register int i = l; i <= min(bl[l] * unt, r); i++) a[i] += c;
    reset(bl[l]);
    if (bl[l] != bl[r]) {
        for (register int i = (bl[r] - 1) * unt + 1; i <= r; i++) a[i] += c;
        reset(bl[r]);
    }
    for (register int i = bl[l] + 1; i <= bl[r] - 1; i++) atag[i].add += c;
}
inline int query(int l, int r, LL c) {
    int ans = 0;
    for (register int i = l; i <= min(bl[l] * unt, r); i++)
        if (a[i] + atag[bl[l]].add < c)
            ans++;
    if (bl[l] != bl[r]) {
        for (register int i = (bl[r] - 1) * unt + 1; i <= r; i++)
            if (a[i] + atag[bl[r]].add < c)
                ans++;
    }
    for (register int i = bl[l] + 1; i <= bl[r] - 1; i++) {
        int s = c - atag[i].add;
        ans += lower_bound(atag[i].v.begin(), atag[i].v.end(), s) - atag[i].v.begin();
    }
    return ans;
}
signed main() {
    n = read();
    unt = sqrt(n);
    for (register int i = 1; i <= n; i++) a[i] = read();
    for (register int i = 1; i <= n; i++) bl[i] = (i - 1) / unt + 1;
    for (register int i = 1; i <= n; i++) {
        atag[bl[i]].v.push_back(a[i]);
    }
    for (register int i = 1; i <= bl[n]; i++) {
        sort(atag[i].v.begin(), atag[i].v.end());
    }
    for (register int i = 1; i <= n; i++) {
        int opt = read(), L = read(), R = read(), c = read();
        if (opt)
            printf("%lld\n", query(L, R, c * c));
        else
            change(L, R, c);
    }
    return 0;
}

\(\text{分块3}\)

分块3 区间修改询问区间内小于某个值 x的前驱即比x小的最大数

同样使用一个\(multiset\)维护（请仔细思考为什么不能用set）
然后用\(lowerbound\)二分
（部分C++11内容

#pragma GCC diagnostic error "-std=c++11"
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
inline int read() {
    register int x = 0;
    register int f = 1;
    register char c;
#define gc c = getchar()
    while (isspace(gc))
        ;
    c == '-' ? gc, f = -1 : 0;
    while (x = (x << 3) + (x << 1) + (c & 15), isdigit(gc))
        ;
    return x * f;
}
const int N = 100000 + 5;
const int Bl = 400 + 5;
int n;
int a[N];
struct node {
    int add;
};
node atag[Bl];
int unt;
int bl[N];
multiset<int> st[Bl];
inline void change(int l, int r, int c) {
    for (register int i = l; i <= min(bl[l] * unt, r); i++) {
        st[bl[i]].erase(a[i]);
        a[i] += c;
        st[bl[i]].insert(a[i]);
    }
    if (bl[l] != bl[r]) {
        for (register int i = (bl[r] - 1) * unt + 1; i <= r; i++) {
            st[bl[i]].erase(a[i]);
            a[i] += c;
            st[bl[i]].insert(a[i]);
        }
    }
    for (register int i = bl[l] + 1; i <= bl[r] - 1; i++) atag[i].add += c;
}
inline int query(int l, int r, int c) {
    int ans = INT_MIN;
    for (register int i = l; i <= min(bl[l] * unt, r); i++)
        if (a[i] + atag[bl[l]].add < c)
            ans = max(a[i] + atag[bl[l]].add, ans);
    if (bl[l] != bl[r]) {
        for (register int i = (bl[r] - 1) * unt + 1; i <= r; i++)
            if (a[i] + atag[bl[r]].add < c)
                ans = max(a[i] + atag[bl[r]].add, ans);
    }
    for (register int i = bl[l] + 1; i <= bl[r] - 1; i++) {
        int s = c - atag[i].add;
        auto find = st[i].lower_bound(s);
        if (find == st[i].begin())
            continue;
        find--;
        ans = max(ans, *find + atag[i].add);
    }
    return ans == INT_MIN ? -1 : ans;
}
signed main() {
    n = read();
    unt = 500 + 5;
    for (register int i = 1; i <= n; i++) a[i] = read();
    for (register int i = 1; i <= n; i++) bl[i] = (i - 1) / unt + 1;
    for (register int i = 1; i <= n; i++) {
        st[bl[i]].insert(a[i]);
    }
    for (register int i = 1; i <= n; i++) {
        int opt = read(), L = read(), R = read(), c = read();
        if (opt)
            printf("%d\n", query(L, R, c));
        else
            change(L, R, c);
    }
    return 0;
}

\({\text{分块4}}\)

分块4是区间修改区间求和
然后区间和 % \(c+1\)

我们考虑使用一个数组维护区间和然后用一个数组维护整个块的修改情况

维护区间和指的是暴力修改的部分

// Isaunoya
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>

using namespace std ;
#define int long long
inline int read() { register int x = 0 ; register int f = 1 ; register char c ;
#define gc c = getchar()
	while(isspace(gc)) ;
	c == '-' ? gc , f = -1 : 0 ;
	while(x = (x << 1) + (x << 3) + (c ^ 48) , isdigit(gc)) ;
	return x * f ;
}

int n ;
const int N = 50000 + 5 ;
int a[N] ;
int bl[N] ;
int sum[N] ;
int atag[N] ;
int unt ;
inline void change(int l , int r , int c) {
	for(register int i = l ; i <= min(r , bl[l] * unt) ; i ++) {
		a[i] += c ;
		sum[bl[l]] += c ;
	}
	if(bl[l] != bl[r])
		for(register int i = (bl[r] - 1) * unt + 1 ; i <= r ; i ++) {
			a[i] += c ;
			sum[bl[r]] += c ;
		}
	for(register int i = bl[l] + 1 ; i <= bl[r] - 1 ; i ++) atag[i] += c ;
	return ;
}
inline int query(int l , int r , int c) { int ans = 0 ;
	for(register int i = l ; i <= min(r , bl[l] * unt) ; i ++) {
		ans += a[i] + atag[bl[l]] ;
		ans %= c ;
	}
	if(bl[l] != bl[r])
		for(register int i = (bl[r] - 1) * unt + 1 ; i <= r ; i ++) {
			ans += a[i] + atag[bl[r]] ;
			ans %= c ;
		}
	for(register int i = bl[l] + 1 ; i <= bl[r] - 1 ; i ++)
		ans = (ans + sum[i] + atag[i] * unt) % c ;
	return ans ;
}
signed main() {
	n = read() ; unt = sqrt(n) ;
	for(register int i = 1 ; i <= n ; i ++) a[i] = read() ;
	for(register int i = 1 ; i <= n ; i ++) bl[i] = (i - 1) / unt + 1 ;
	for(register int i = 1 ; i <= n ; i ++) {
		sum[bl[i]] += a[i] ;
	}
	for(register int i = 1 ;i <= n ; i ++) {
		int opt = read() ;
		if(opt == 0) {
			int l = read() , r = read() , c = read() ;
			change(l , r , c) ;
		}
		if(opt == 1) {
			int l = read() , r = read() , c = read() ;
			printf("%lld\n" , query(l , r , c + 1)) ;
		}
	}
	return 0 ;
}

\(\text{分块5}\)

分块5是区间开方然后区间查询
对于每个块大小最大是\(2^{31}\)次

\(log(31) ≈ 5\)
所以可以得出一个块最多开方6次
也就是最大是\(6n\)
所以对于区间开方对一个块进行开方然后重构这个块的总和

也就是可以得出大块修改并用一个flg数组标记这个块有没有大于1的数字（如果大于1的话还可以开方
这样可以避免很多次重复开方
那么对于没有完整块的左右区间我们考虑先减掉原数字然后加上开方后的数字（对于乘法操作也是一样的
区间查询上面讲过了（将块的总和加上然后暴力把左右区间求和）

// Isaunoya
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>

using namespace std ;
#define int long long
inline int read() { register int x = 0 ; register int f = 1 ; register char c ;
#define gc c = getchar()
	while(isspace(gc)) ;
	c == '-' ? gc , f = -1 : 0 ;
	while(x = (x << 1) + (x << 3) + (c ^ 48) , isdigit(gc)) ;
	return x * f ;
}

int n ;
const int N = 50000 + 5 ;
int a[N] ;
int bl[N] ;
int flg[N] ;
int sum[N] ;
int unt ;
inline void Reset(int x) {
    if(flg[x]) return ;
    flg[x] = 1 ;
    sum[x] = 0 ;
    for(register int i = (x - 1) * unt + 1 ; i <= x * unt ; i ++) {
        a[i] = sqrt(a[i]) ;
        sum[x] += a[i] ;
        if(a[i] > 1) flg[x] = 0 ;
    }
    return ;
}
inline void change(int l , int r , int c) {
    for(register int i = l ; i <= min(bl[l] * unt , r) ; i ++) {
        sum[bl[l]] -= a[i] ;
        a[i] = sqrt(a[i]) ;
        sum[bl[l]] += a[i] ;
    }
    if(bl[l] != bl[r])
        for(register int i = (bl[r] - 1) * unt + 1 ; i <= r ; i ++) {
            sum[bl[r]] -= a[i] ;
            a[i] = sqrt(a[i]) ;
            sum[bl[r]] += a[i] ;
        }
    for(register int i = bl[l] + 1 ; i <= bl[r] - 1 ; i ++) Reset(i) ;
    return ;
}
inline int query(int l , int r , int c) { int ans = 0 ;
    for(register int i = l ; i <= min(bl[l] * unt , r) ; i ++) {
        ans += a[i] ;
    }
    if(bl[l] != bl[r])
        for(register int i = (bl[r] - 1) * unt + 1 ; i <= r ; i ++) ans += a[i] ;
    for(register int i = bl[l] + 1 ; i <= bl[r] - 1 ; i ++) ans += sum[i] ;
    return ans ;
}
signed main() {
    n = read() ; unt = sqrt(n) ;
    for(register int i = 1 ; i <= n ; i ++) a[i] = read() ;
    for(register int i = 1 ; i <= n ; i ++) bl[i] = (i - 1) / unt + 1 ;
    for(register int i = 1 ; i <= n ; i ++) { sum[bl[i]] += a[i] ; }
    for(register int i = 1 ; i <= n ; i ++) {
        int opt = read() ;
        if(opt == 0) {
            int l , r , c ;
            l = read() ; r = read() ; c = read() ;
            change(l , r , c) ;
        }
        if(opt == 1) {
            int l , r , c ;
            l = read() ; r = read() ; c = read() ;
            printf("%lld\n" , query(l , r , c)) ;
        }
    }
    return 0 ;
}

\(\text{分块6}\)
分块6是可以区间插入一个数字然后查询某个位置
（其实用不到分块 \(vector\) 可以直接做）
只是因为这一题没有区间查询所以可以 \(vector\) 水过去
如果想好好学分块就使用分块的做法
当某个块大于 20 个块的时候就重构块
不然查询的时候比较费劲而且暴力复杂度比较高

// Isaunoya
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC diagnostic error "-std=c++11"
#include<bits/stdc++.h>

using namespace std ;
#define int long long
inline int read() { register int x = 0 ; register int f = 1 ; register char c ;
#define gc c = getchar()
	while(isspace(gc)) ;
	c == '-' ? gc , f = -1 : 0 ;
	while(x = (x << 1) + (x << 3) + (c ^ 48) , isdigit(gc)) ;
	return x * f ;
}
int n ;
int unt ;
const int N = 200000 + 5 ;
int a[N] ;
std::vector< int > v[N] ;
int st[N] ;
int top = 0 ; int m = 0 ;
pair < int  , int > query(int b) {
    int x = 1 ;
    for ( ; b > v[x].size() ; ) b -= v[x ++].size() ;
    return make_pair(x , b - 1) ;
}
inline void Rebuild() {
    top = 0 ;
    for(register int i = 1 ; i <= m ; i ++) {
        for(auto j : v[i]) st[++ top] = j ;
        v[i].clear() ;
    }
    int blo = sqrt(top) ;
    for(register int i = 1 ; i <= top ; i ++) {
        v[(i - 1) / blo + 1].push_back(st[i]) ;
    }
    m = (top - 1) / blo + 1 ;
}
inline void Insert(int x , int y) {
    pair < int , int > p = query(x) ;
    v[p.first].insert(v[p.first].begin() + p.second , y) ;
    if(v[p.first].size() > 20 * unt) Rebuild() ;
}
signed main() {
    n = read() ; unt = sqrt(n) ;
    for(register int i = 1 ; i <= n ; i ++) a[i] = read() ;
    for(register int i = 1 ; i <= n ; i ++) v[(i - 1) / unt + 1].push_back(a[i]) ;
    m = (n - 1) / unt + 1 ;
    for(register int i = 1 ; i <= n ; i ++) {
        int opt = read() ;
        if(opt == 0) {
            int l = read() , r = read() , c = read() ;
            Insert(l , r) ;
        }
        if(opt == 1) {
            int l = read() , r = read() , c = read() ;
            pair < int , int > p = query(r) ;
            printf("%d\n" , v[p.first][p.second]) ;
        }
    }
    return 0 ;
}

\(\text{分块7}\)
分块7是一题 \(\text{区间乘法区间加法单点查询}\) 的题目
那么我们只需要维护一下区间的值乘法的值加法的值就可以
如果乘法那么就需要把加法的值乘上一个值
不过在每次修改的时候需要\(\text{重构这个不完整的块所在的块}\)
（好拗口反正就是在\(左，右区间\)所在的块然后把乘的值归1 然后加法的值清0
这样的话复杂度仍然还是 \(\sqrt n\)
根据这个思路的话我写了一个区间查询的
~~我告诉我旁边的人：知道什么叫做单点查询吗~~
-- \(query(b,b)\)

// Isaunoya
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC diagnostic error "-std=c++11"
#include<bits/stdc++.h>

using namespace std ;
#define int long long

#define rep(i , j , n) for(register int i=j;i<=n;i++)
#define Rep(i , j , n) for(register int i=j;i>=n;i--)
#define gc c = getchar()
#define int long long
inline int read() { register int x = 0 , f = 1 ; register char c ;
    while(isspace(gc)) ; c == '-' ? f = -1 , gc : 0 ;
    while((x *= 10) += (c ^ 48) , isdigit(gc)) ;
    return x * f ;
}

using namespace std ;
int n ;
const int N = 100000 + 5 ;
const int Unt = 2000 ;
const int p = 10000 + 7 ;
int a[N] ;
int unt ;
int block[N] ;
int sum[Unt] ;
int mul[Unt] ;
int size[Unt] ;
int ans[Unt] ;
inline void reset(int x) {
    for(register int i=(x - 1) * unt + 1 ; i <= min(n , x * unt) ; i ++) {
        a[i] = (a[i] * mul[x] + sum[x]) % p ;
    }
    sum[x] = 0 ; mul[x] = 1 ;
}
inline void change_mul(int l , int r , int x) {
    reset(block[l]) ;
    for(register int i=l;i<=min(r , block[l] * unt) ; i ++) {
        ans[block[l]] -= a[i] ;
        a[i] *= x ;
        a[i] %= p ;
        ans[block[l]] += a[i] ;
        ans[block[l]] %= p ;
    }
    if(block[l] != block[r]) {
        reset(block[r]) ;
        for(register int i=(block[r] - 1) * unt + 1 ; i <= r ; i ++) {
            ans[block[r]] -= a[i] ;
            a[i] *= x ;
            a[i] %= p ;
            ans[block[r]] += a[i] ;
            ans[block[r]] %= p ;
        }
        for(register int i=block[l] + 1 ; i <= block[r] - 1 ; i ++) {
            sum[i] *= x ;
            sum[i] %= p ;
            mul[i] *= x ;
            mul[i] %= p ;
            ans[i] *= x ;
            ans[i] %= p ;
        }
    }
}
inline void change_sum(int l , int r , int x) {
    reset(block[l]) ;
    for(register int i=l ; i <= min(r , block[l] * unt) ; i ++) {
        a[i] += x ;
        a[i] %= p ;
        ans[block[l]] += x ;
    }
    if(block[l] != block[r]) {
        reset(block[r]) ;
        for(register int i = (block[r] - 1) * unt + 1 ; i <= r ; i ++) {
            a[i] += x ;
            a[i] %= p ;
            ans[block[r]] += x ;
        }
        for(register int i=block[l] + 1 ; i <= block[r] - 1 ; i ++) {
            sum[i] += x ;
            sum[i] %= p ;
            ans[i] += x * size[i] ;
        }
    }
}
inline int Query(int l , int r) {
    int Ans = 0 ;
    for(register int i=l;i<=min(r , block[l] * unt) ; i ++)
        Ans += (a[i] * mul[block[l]] + sum[block[l]] ) % p ;
    if(block[l] != block[r]) {
        for(register int i = (block[r] - 1) * unt + 1 ; i <= r ; i ++)
            Ans += (a[i] * mul[block[r]] + sum[block[r]] ) % p ;
        for(register int i = block[l] + 1 ; i <= block[r] - 1 ; i ++)
            Ans += ans[i] ;
    }
    return Ans % p ;
}
signed main() {
    n = read() ;
    unt = sqrt(n) ;
    for(register int i=1;i<=n;i++) a[i] = read() ;
    for(register int i=1;i<=n;i++) {
        block[i] = (i - 1) / unt + 1 ;
        ans[block[i]] += a[i] ;
        size[block[i]] ++ ;
    }
    for(register int i=1;i<=block[n];i++) mul[i] = 1 ;
    for(register int i=1;i<=n;i++) {
        int opt = read() ;
        if(opt == 0) {
            int a = read() , b = read() , c = read() ;
            change_sum(a , b , c) ;
        }
        if(opt == 1) {
            int a = read() , b = read() , c = read() ;
            change_mul(a , b , c) ;
        }
        if(opt == 2) {
            int a = read() , b = read() , c = read() ;
            printf("%lld\n" , Query(b , b)) ;
         }
    }
    return 0 ;
}

\(\text{分块8}\)

分块8的话是一个查询区间有多少个\(c\) 并把整个区间改成 \(c\)

同样我们考虑判重把每个块用一个\(flg\)数组记录当前值
然后对于左右区间的修改把左右区间所在的块重构成之前的\(flg\)
然后修改成c 再判断左右区间有多少个c
那么对于\(\text{完整的块}\) 我们只需要加上一个块的长度
这样就可以做到判重的效果了
对于 \(\text{完整的块}\) 我们只需要修改当前块的\(flg\)值就可以了

// Isaunoya
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC diagnostic error "-std=c++11"
#include<bits/stdc++.h>

using namespace std ;
#define int long long

#define rep(i , j , n) for(register int i=j;i<=n;i++)
#define Rep(i , j , n) for(register int i=j;i>=n;i--)
#define gc c = getchar()
#define int long long
inline int read() { register int x = 0 , f = 1 ; register char c ;
    while(isspace(gc)) ; c == '-' ? f = -1 , gc : 0 ;
    while((x *= 10) += (c ^ 48) , isdigit(gc)) ;
    return x * f ;
}

const int N = 100000 + 5 ;
int n ;
int a[N] ;
int unt ;
int flg[N] ;
int bl[N] ;
inline void reset(int x) {
    if(flg[x] == -1) return ;
    for(register int i = (x - 1) * unt + 1 ; i <= x * unt ; i ++) a[i] = flg[x] ;
    flg[x] = -1 ;
}
inline int solve(int l , int r , int c) { int ans = 0 ;
    reset(bl[l]) ;
    for(register int i = l ; i <= min(bl[l] * unt , r) ; i ++) {
        if(a[i] != c) a[i] = c ;
        else ans ++ ;
    }
    if(bl[l] != bl[r]) {
        reset(bl[r]) ;
        for(register int i = (bl[r] - 1) * unt + 1 ; i <= r ; i ++) {
            if(a[i] != c) a[i] = c ;
            else ans ++ ;
        }
    }
    for(register int i = bl[l] + 1 ; i <= bl[r] - 1 ; i ++) {
        if(flg[i] != -1) {
            if(flg[i] != c) flg[i] = c ;
            else ans += unt ;
        }
        else {
            for(register int j = (i - 1) * unt + 1 ; j <= i * unt ; j ++)
                if(a[j] != c) a[j] = c ;
                else ans ++ ;
            flg[i] = c ;
        }
    }
    return ans ;
}
signed main() {
    n = read() ; unt = sqrt(n) ;
    for(register int i = 1 ; i <= n ; i ++) a[i] = read() ;
    for(register int i = 1 ; i <= n ; i ++) bl[i] = (i - 1) / unt + 1 ;
    for(register int i = 1 ; i <= bl[n] ; i ++) flg[i] = -1 ;
    for(register int i = 1 ; i <= n ; i ++) {
        int l = read() , r = read() , c = read() ;
        printf("%lld\n" , solve(l , r , c)) ;
    }
    return 0 ;
}

\(\text{分块9}\)
前置知识：离线莫队
分块9的话我没想到怎么在线做
就是按每次查询的 \(l\) 排序然后瞎搞
（大概是一个莫队的思想

// Isaunoya
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC diagnostic error "-std=c++11"
#include <bits/stdc++.h>

using namespace std;

#define rep(i, j, n) for (register int i = j; i <= n; i++)
#define Inc(i, j, n) for (register int i = j; i <= n; i++)
#define Rep(i, j, n) for (register int i = j; i >= n; i--)

inline int read() {
	register int x = 0, f = 1;
	register char c;
#define gc c = getchar()
	while (isspace(gc))
		;
	c == '-' ? f = -1, gc : 0;
	while ((x *= 10) += (c ^ 48), isdigit(gc))
		;
	return x * f;
}
const int N = 1e5;
int n, siz, k[N + 10], bl[N + 10];
struct Que {
	int L, r, idx;
} q[N + 10];
bool cmp(const Que &A, const Que &B) {
	return bl[A.L] ^ bl[B.L] ? A.L < B.L : A.r < B.r;
}
inline void init() {
	n = read() ;
	Inc(i, 1, n) k[i] = read() ;
	Inc(i, 1, n) {
		int x, y;
		x = read() , y = read() ;
		q[i] = (Que) {
			x, y, i
		};
	}
	siz = sqrt(n);
	Inc(i, 1, n) bl[i] = (i - 1) / siz + 1;
	sort(q + 1, q + 1 + n, cmp);
}
int rp[N + 10];
inline void disc() {
	int tmp[N + 10];
	Inc(i, 1, n) tmp[i] = k[i];
	sort(tmp + 1, tmp + 1 + n);
	int len = unique(tmp + 1, tmp + 1 + n) - tmp - 1;
	Inc(i, 1, n) rp[i] = lower_bound(tmp + 1, tmp + 1 + len, k[i]) - tmp;
}
int cur_ans, cur_num, Ans[N + 10], num[N + 10];
inline void addr(int x) {
	++num[rp[x]];
	if (num[rp[x]] >= cur_num) {
		if (num[rp[x]] == cur_num && k[x] < cur_ans)
			cur_ans = k[x];
		else if (num[rp[x]] > cur_num)
			cur_ans = k[x], cur_num = num[rp[x]];
	}
}
inline void addl(int x, int &ans, int &Num) {
	++num[rp[x]];
	if (num[rp[x]] >= Num) {
		if (num[rp[x]] == Num && k[x] < ans)
			ans = k[x];
		else if (num[rp[x]] > Num)
			ans = k[x], Num = num[rp[x]];
	}
}
inline void remove(int x) {
	--num[rp[x]];
}
inline void solv() {
	int L, r, lim;
	Inc(i, 1, n) {
		if (bl[q[i].L] ^ bl[q[i - 1].L]) {
			memset(num, 0, sizeof(num));
			L = lim = bl[q[i].L] * siz + 1;
			r = bl[q[i].L] * siz;
			cur_ans = cur_num = 0;
		}
		if (bl[q[i].L] == bl[q[i].r]) {
			int ans, nownum = 0;
			Inc(j, q[i].L, q[i].r)++ num[rp[j]];
			Inc(j, q[i].L, q[i].r) if (num[rp[j]] >= nownum) {
				if (num[rp[j]] == nownum && k[j] < ans)
					ans = k[j];
				else if (num[rp[j]] > nownum)
					ans = k[j], nownum = num[rp[j]];
			}
			Inc(j, q[i].L, q[i].r)-- num[rp[j]];
			Ans[q[i].idx] = ans;
			continue;
		}
		while (r < q[i].r) addr(++r);
		int now = cur_ans, nownum = cur_num;
		while (L > q[i].L) addl(--L, now, nownum);
		Ans[q[i].idx] = now;
		while (L < lim) remove(L++);
	}
	Inc(i, 1, n) printf("%d\n" , Ans[i]) ;
}
signed main() {
	init();
	disc();
	solv();
	return 0;
}

\(\text{例题}\)

https://loj.ac/problem/10117

\(\text{LOJ10117}\)

这题就是一个裸的树状数组但是可以用分块做好像更方便呢

// Isaunoya
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define rep(i , j , n) for(register int i = j ; i <= n ; i ++)
#define Rep(i , j , n) for(register int i = j ; i >= n ; i --)
#define to(u) for(register int i = head[u] ; i ; i = edge[i].nxt)

inline int read() { register int x = 0 , f = 1 ; register char c ;
#define gc c = getchar()
	while(isspace(gc)) ; c == '-' ? f = -1 , gc : 0 ;
	while(x = (x << 1) + (x << 3) + (c & 15) , isdigit(gc)) ;
	return x * f ;
}

using namespace std ;
int n ;
const int N = 1e5 + 10 ;
int a[N] ;

int atag[N] ;
int bl[N] ;
int unt ;
inline void change(int l , int r) {
	for(register int i = l ; i <= min(bl[l] * unt , r) ; i ++) a[i] ^= 1 ;
	if(bl[l] != bl[r]) 
		for(register int i = (bl[r] - 1) * unt + 1 ; i <= r ; i ++) a[i] ^= 1 ;
	for(register int i = bl[l] + 1 ; i <= bl[r] - 1 ; i ++) atag[i] ^= 1 ;
	return ;
}
signed main() {
//	freopen(".in" , "r" , stdin) ; freopen(".out" , "w" , stdout) ;
	n = read() ; unt = sqrt(n) ;
	for(register int i = 1 ; i <= n ; i ++) bl[i] = (i - 1) / unt + 1 ;
	for(register int q = read() ; q -- ; ) {
		int opt = read() ;
		if(opt & 1) {
			int l = read() , r = read() ;
			change(l , r) ;
		}
		else {
			int x = read() ;
			printf("%lld\n" , a[x] ^ atag[bl[x]]) ;
		}
	}
	return 0 ;
}

https://www.luogu.org/problem/P3372
https://www.luogu.org/problem/P3373
https://www.luogu.org/problem/P2572
https://www.luogu.org/problem/P3396
https://www.luogu.org/problem/P3203
https://www.luogu.org/problem/P4879
https://www.luogu.org/problem/P3870
https://www.luogu.org/problem/P2574
https://www.luogu.org/problem/P2801
https://www.luogu.org/problem/P4145

posted @ 2019-10-02 18:27 _Isaunoya 阅读(642) 评论(0) 编辑收藏举报

刷新页面返回顶部

Isaunoya

Go Big Or Go Home?

分块详解

公告