作为一个永不咕咕咕的博主，我来更笔记辣qaq
CDQ分治
CDQ分治的思想还是比较简单的。它的基本流程是：
\(1.\)将所有修改操作和查询操作按照时间顺序并在一起，形成一段序列。显然，会影响查询操作结果的修改操作在序列中一定会在这一个查询操作前面
\(2.\)将这一段序列分为左右两半，递归解决左右两半的子问题
\(3.\)考虑左半部分的修改操作对右半部分的查询操作的贡献
CDQ分治的基本思想就是在分治的过程中统计左半部分对右半部分的影响
上面的过程可能比较抽象，举个栗子：归并排序求逆序对
别告诉我你只会树状数组求逆序对
回顾一下归并排序求逆序对的过程：
\(1.\)将当前待排序的序列分为左右两个区间，计算左右区间内部的逆序对数量并将左右区间分别排好序
\(2.\)通过双指针计算一个数在左区间、另一个数在右区间的逆序对数量并将原序列排好序
上面加粗的部分与CDQ分治是异曲同工的。
还有些模糊其实是很正常的，下面来看几道例题感受一下：
三维偏序
二维偏序就是逆序对统计，那么三维偏序应该怎么做呢？我们设三个维度为\((a,b,c)\)，那么方法如下：
\(1.\)对所有点的\(a\)维排序
\(2.\)对\(b\)维归并排序
然后我们考虑在分治过程中如何统计左半边区间对右半边区间的贡献。
可以发现，在当前分治区间合并\(b\)维的时候，\(a\)维是无序的，但是一定会有左半区间的点的\(a\)小于右半区间的点的\(a\)，所以我们不需要考虑\(a\)，只需要统计对于每一个右半区间的点，有多少个\(b,c\)维同时小于它即可。
这个可以在对\(b\)维进行归并排序的时候使用树状数组对\(c\)维进行维护。
然后就做完了QuQ复杂度\(O(nlog^2n)\)
注意一些小细节：
①在合并左右两个区间时可以直接快速排序，因为分治+树状数组已经有\(log^2n\)的复杂度了，快排不会影响最后的复杂度，而且似乎比直接归并要快一些
②每一次树状数组清空的时候不要暴力\(memset\)（这样子复杂度就会退化为\(O(n^2)\)），应该是将左半区间的贡献在树状数组中清除，这样才能保证复杂度。
当然了以上的方法是可以拓展到多维的（使用CDQ+CDQ+CDQ+...+树状数组解决），但是一般当维度大于\(4\)维时使用\(bitset\)会有更优的复杂度。
下面是代码菌
#include<bits/stdc++.h>
using namespace std;
inline int read(){
int a = 0;
char c = getchar();
while(c != EOF && !isdigit(c))
c = getchar();
while(c != EOF && isdigit(c)){
a = (a << 3) + (a << 1) + (c ^ '0');
c = getchar();
}
return a;
}
const int MAXN = 100000;
struct node{
int ind , a , b , c;
}now[MAXN + 10];
int N , K , ans[MAXN + 10] , TreeNum[MAXN + 10 << 1] , cnt[MAXN + 10];
inline int lowbit(int x){
return x & -x;
}
inline void add(int now , int num){
while(now <= K){
TreeNum[now] += num;
now += lowbit(now);
}
}
inline int get(int now){
int sum = 0;
while(now){
sum += TreeNum[now];
now -= lowbit(now);
}
return sum;
}
bool cmp1(node a , node b){
if(a.b == b.b){
if(a.c < b.c)
return a.ind < b.ind;
return a.c < b.c;
}
return a.b < b.b;
}
void solve(int l , int r){
if(l == r)
return;
int mid = l + r >> 1;
solve(l , mid);
solve(mid + 1 , r);
sort(now + l , now + mid + 1 , cmp1);
sort(now + mid + 1 , now + r + 1 , cmp1);
int p1 = l , p2 = mid + 1;
while(p1 <= mid && p2 <= r)
if(now[p1].b <= now[p2].b)
add(now[p1++].c , 1);
else
ans[now[p2++].ind] += get(now[p2].c);
while(p2 <= r)
ans[now[p2++].ind] += get(now[p2].c);
while(--p1 >= l)
add(now[p1].c , -1);
}
bool cmp(node a , node b){
if(a.a == b.a){
if(a.b == b.b){
if(a.c == b.c)
return a.ind < b.ind;
return a.c < b.c;
}
return a.b < b.b;
}
return a.a < b.a;
}
int main(){
N = read();
K = read();
for(int i = 1 ; i <= N ; i++){
now[now[i].ind = i].a = read();
now[i].b = read();
now[i].c = read();
}
sort(now + 1 , now + N + 1 , cmp);
solve(1 , N);
sort(now + 1 , now + N + 1 , cmp);
for(int i = N ; i ; i--)
if(now[i].a == now[i + 1].a && now[i].b == now[i + 1].b && now[i].c == now[i + 1].c)
ans[now[i].ind] = ans[now[i + 1].ind];
for(int i = 1 ; i <= N ; i++)
cnt[ans[i]]++;
for(int i = 0 ; i < N ; i++)
printf("%d\n" , cnt[i]);
return 0;
}动态逆序对
考虑每一次删除实际上会减掉什么
首先考虑会减掉这一个数组成的逆序对数量，然后能够发现会减多一部分。
减多了什么呢？如果两个数能够产生逆序对，那么在这两个数都被删除的时候，这一个逆序对会被算两次。
那么我们考虑在后面被删除的数被删除的时候将这一个贡献加回来
对于每一次删除操作，设其为\((time,pos,val)\)，那么我们需要对于每一个\(j\)求满足\(time_i<time_j,pos_i>pos_j,val_i<val_j\)或者\(time_i<time_j,pos_i<pos_j,val_i>val_j\)的\(i\)的数量。可以发现这是一个三维偏序，然后直接上板子即可。
#include<bits/stdc++.h>
using namespace std;
inline int read(){
int a = 0;
bool f = 0;
char c = getchar();
while(c != EOF && !isdigit(c)){
if(c == '-')
f = 1;
c = getchar();
}
while(c != EOF && isdigit(c)){
a = (a << 3) + (a << 1) + (c ^ '0');
c = getchar();
}
return f ? -a : a;
}
const int MAXN = 100010;
struct del{
int num , ind , p;
}cdq[MAXN];
int N , M , pri1[MAXN] , pri2[MAXN] , Tree[MAXN] , num[MAXN] , ind[MAXN];
long long ans;
inline int lowbit(int x){
return x & -x;
}
inline void add(int x , int num){
while(x <= N){
Tree[x] += num;
x += lowbit(x);
}
}
inline int get(int x){
int sum = 0;
while(x){
sum += Tree[x];
x -= lowbit(x);
}
return sum;
}
bool cmp1(del a , del b){
return a.ind < b.ind;
}
void solve1(int l , int r){
if(l == r)
return;
int mid = l + r >> 1;
solve1(l , mid);
solve1(mid + 1 , r);
int p1 = l , p2 = mid + 1;
while(p1 <= mid && p2 <= r)
if(cdq[p1].ind < cdq[p2].ind){
add(cdq[p1].num , 1);
p1++;
}
else{
pri2[cdq[p2].p] += get(N) - get(cdq[p2].num);
p2++;
}
while(p2 <= r){
pri2[cdq[p2].p] += get(N) - get(cdq[p2].num);
p2++;
}
while(--p1 >= l)
add(cdq[p1].num , -1);
sort(cdq + l , cdq + r + 1 , cmp1);
}
bool cmp2(del a , del b){
return a.ind > b.ind;
}
void solve2(int l , int r){
if(l == r)
return;
int mid = l + r >> 1;
solve2(l , mid);
solve2(mid + 1 , r);
int p1 = l , p2 = mid + 1;
while(p1 <= mid && p2 <= r)
if(cdq[p1].ind > cdq[p2].ind){
add(cdq[p1].num , 1);
p1++;
}
else{
pri2[cdq[p2].p] += get(cdq[p2].num);
p2++;
}
while(p2 <= r){
pri2[cdq[p2].p] += get(cdq[p2].num);
p2++;
}
while(--p1 >= l)
add(cdq[p1].num , -1);
sort(cdq + l , cdq + r + 1 , cmp2);
}
bool cmp3(del a , del b){
return a.p < b.p;
}
int main(){
#ifdef LG
freopen("3157.in" , "r" , stdin);
//freopen("3157.out" , "w" , stdout);
#endif
N = read();
M = read();
for(int i = 1 ; i <= N ; i++){
pri1[i] += get(N) - get(num[i] = read());
add(num[i] , 1);
ans += pri1[i];
ind[num[i]] = i;
}
memset(Tree , 0 , sizeof(Tree));
for(int i = N ; i ; --i){
pri1[i] += get(num[i]);
add(num[i] , 1);
}
memset(Tree , 0 , sizeof(Tree));
for(int i = 1 ; i <= M ; i++)
cdq[cdq[i].p = i].ind = ind[cdq[i].num = read()];
solve1(1 , M);
sort(cdq + 1 , cdq + M + 1 , cmp3);
solve2(1 , M);
sort(cdq + 1 , cdq + M + 1 , cmp3);
for(int i = 1 ; i <= M ; i++){
printf("%lld\n" , ans);
ans -= pri1[cdq[i].ind] - pri2[i];
}
return 0;
}NOI2007 货币兑换
这一道题是CDQ论文里面的题目
做这道题你需要的前置芝士是斜率优化，顺便给我的斜率优化笔记打个广告QAQ
我们来愉快地推\(DP\)
设\(f_i\)表示在第\(i\)天能够获得的最大收益，设\(g_i\)为第\(i\)天最多能够兑换的\(B\)券数量
那么有\(g_i \times B_i + g_i \times Rate_i \times A_i = f_i\)，即\(g_i = \frac{f_i}{B_i + Rate_i \times A_i}\)
而我们的\(DP\)转移为：\(f_i = \max\{A_i\max\limits_{j=1}^{i-1}\{g_j\frac{B_i}{A_i} + g_jRate_j\},f_{i-1}\}\)
可以发现我们的转移是一个斜率式子，可以使用斜率优化解决
但是\(g_i\)与\(i\)并不呈正相关，意味着我们不能像传统的斜率优化一样使用单调队列解决凸包的维护问题
这个时候有两种做法：使用平衡树维护凸包和使用分治维护凸包。第一种比较麻烦也不是这篇文章的重点，所以我们直接看第二种
考虑当前正在求\([l,r]\)的\(f\)值，首先我们先递归进入左区间，将左区间的\(f\)和\(g\)的值求出来，然后先在当前层处理左区间对右区间的影响，然后递归进入右区间求解
对于当前区间的贡献的计算，首先将左区间的所有直线按照斜率排序，使用单调栈建立凸包，然后将右区间的所有询问按照\(x\)递增排序，因为\(x\)递增，所以可以直接在凸包上扫一遍得到答案。当然这一部分也可以不排序，通过在凸包上二分解决。
注意到上面的递归顺序与我们之前见到的大部分分治的递归顺序是不同的，这是因为：如果我们需要正确地得到\(f_i\)，意味着对于所有的\(j<i\)，\(f_j\)必须要在\(f_i\)之前算好并将贡献给\(f_i\)，\(f_i\)才能够正确地给其他值进行贡献。如果我们在当前区间计算贡献之前计算右区间，意味着右区间的所有\(f_i\)都在没有正确地计算出值得情况下对其他值进行了贡献，这会导致答案的错误。
#include<bits/stdc++.h>
#define ld long double
#define eps 1e-10
//This code is written by Itst
using namespace std;
const int MAXN = 100010;
ld f[MAXN] , q[MAXN] , a[MAXN] , b[MAXN] , range[MAXN];
int N , s[MAXN] , num[MAXN] , top;
bool cmp(ld a , ld b){
return a + eps > b && a - eps < b;
}
bool cmp1(int a , int b){
return q[a] < q[b];
}
bool cmp2(int x , int y){
return b[x] / a[x] < b[y] / a[y];
}
inline ld calc(int j , int k){
return (q[j] * range[j] - q[k] * range[k]) / (q[k] - q[j]);
}
inline ld calcAns(int j , ld k){
return q[j] * k + q[j] * range[j];
}
void CDQ(int l , int r){
if(l == r){
if(f[num[l]] < f[num[l] - 1]){
f[num[l]] = f[num[l] - 1];
q[num[l]] = f[num[l]] / (a[num[l]] * range[num[l]] + b[num[l]]);
}
return;
}
int mid = l + r >> 1;
CDQ(l , mid);
sort(num + l , num + mid + 1 , cmp1);
sort(num + mid + 1 , num + r + 1 , cmp2);
top = 0;
for(int i = l ; i <= mid ; i++){
while(top && cmp(q[s[top]] , q[num[i]]) && q[s[top]] * range[s[top]] < q[num[i]] * range[num[i]])
top--;
if(top && cmp(q[s[top]] , q[num[i]]))
continue;
while(top >= 2 && calc(num[i] , s[top]) < calc(s[top] , s[top - 1]) && calc(num[i] , s[top - 1]) < calc(s[top] , s[top - 1]))
top--;
s[++top] = num[i];
}
int p = 1;
for(int i = mid + 1 ; i <= r ; i++){
while(p < top && calcAns(s[p] , b[num[i]] / a[num[i]]) < calcAns(s[p + 1] , b[num[i]] / a[num[i]]))
p++;
if(f[num[i]] < calcAns(s[p] , b[num[i]] / a[num[i]]) * a[num[i]]){
f[num[i]] = calcAns(s[p] , b[num[i]] / a[num[i]]) * a[num[i]];
q[num[i]] = f[num[i]] / (a[num[i]] * range[num[i]] + b[num[i]]);
}
}
sort(num + mid + 1 , num + r + 1);
CDQ(mid + 1 , r);
}
int main(){
#ifdef LG
freopen("4027.in" , "r" , stdin);
//freopen("4027.out" , "w" , stdout);
#endif
ios::sync_with_stdio(0);
cin >> N >> f[1];
for(int i = 1 ; i <= N ; i++){
cin >> a[i] >> b[i] >> range[i];
num[i] = i;
}
q[1] = f[1] / (a[1] * range[1] + b[1]);
CDQ(1 , N);
cout << fixed << setprecision(3) << f[N];
return 0;
}留一道练习题：
BZOJ4237 稻草人 我的题解在这里
整体二分
整体二分与CDQ分治的做法有些像
整体二分的基本思路是将一堆操作和询问放在一起进行二分，一般可以做到\(O(nlog^2n)\)的复杂度
假设我们现在正在解决\(solve(ql,qr,l,r)\)，这表示我们正在解决\([ql,qr]\)区间内的操作和询问，而且满足：区间内所有修改操作的权值范围在\([l,r]\)内，并且已经确定区间内所有询问的答案在\([l,r]\)区间内
接下来是整体二分最重要的\(check\)部分：
取\(mid=\frac{l+r}{2}\)，从左往右执行所有修改和查询操作：
如果某个修改操作的权值范围在\([l,mid]\)内，执行它，否则忽略掉它
如果到了一个查询操作，进行查询，如果满足答案在\([l,mid]\)内的条件，那么它的答案就在\([l,mid]\)范围内，否则在\([mid+1,r]\)范围内
最后把所有权值范围在\([l,mid]\)的修改操作和答案在\([l,mid]\)的查询放在一起，其他的修改和查询放在一起，两边分别递归求解。递归边界为\(l=r\)，就可以确定\([ql,qr]\)的所有询问的答案为\(l\)。
当然，可能在实际的\(check\)过程中需要执行的是\([mid+1,r]\)部分的修改操作。
可能理解起来比较抽象（分治理解起来都比较抽象）来看两道题感受一下：
ZJOI2010 K大数查询
这道题曾经树套树时空双卡，但整体二分表示很轻松
现在空间开大了，但是树套树还是因为超大的常数容易被卡……
仍然考虑\(solve\)函数的\(check\)过程，不妨这么做：
使用一个权值线段树维护每一个位置中，数字范围在\([mid+1,r]\)的数的个数。
对于在\([mid+1,r]\)范围内的修改，也就是加入的数在\([mid+1,r]\)范围内的操作，在它对应的操作区间上\(+1\)；
对于一个查询操作，如果这个查询操作对应的区间上数字范围在\([mid+1,r]\)的数的个数大于等于这一次询问的\(K\)，则表示这一个询问的答案在\([mid+1,r]\)范围内，否则在\([l,mid]\)范围内。
值得注意的是，要清除\([mid+1,r]\)的修改操作对答案在\([l,mid]\)范围内的询问的贡献。
#include<bits/stdc++.h>
#define lch (x << 1)
#define rch (x << 1 | 1)
#define mid ((l + r) >> 1)
#define int long long
//This code is written by Itst
using namespace std;
inline int read(){
int a = 0;
char c = getchar();
bool f = 0;
while(!isdigit(c)){
if(c == '-')
f = 1;
c = getchar();
}
while(isdigit(c)){
a = (a << 3) + (a << 1) + (c ^ '0');
c = getchar();
}
return f ? -a : a;
}
const int MAXN = 5e4 + 10;
struct que{
int ind , a , b , c , to;
}now[MAXN] , pot1[MAXN] , pot2[MAXN];
struct node{
int sum , mark , size;
}Tree[MAXN << 2];
int N , M , cntAns , ans[MAXN];
inline void mark(int x , int num){
Tree[x].mark += num;
Tree[x].sum += num * Tree[x].size;
}
inline void pushup(int x){
Tree[x].sum = Tree[lch].sum + Tree[rch].sum;
}
inline void pushdown(int x){
if(Tree[x].mark){
mark(lch , Tree[x].mark);
mark(rch , Tree[x].mark);
Tree[x].mark = 0;
}
}
void init(int x , int l , int r){
Tree[x].size = r - l + 1;
if(l != r){
init(lch , l , mid);
init(rch , mid + 1 , r);
}
}
void modify(int x , int l , int r , int L , int R , int num){
if(l >= L && r <= R){
mark(x , num);
return;
}
pushdown(x);
if(mid >= L)
modify(lch , l , mid , L , R , num);
if(mid < R)
modify(rch , mid + 1 , r , L , R , num);
pushup(x);
}
int query(int x , int l , int r , int L , int R){
if(l >= L && r <= R)
return Tree[x].sum;
pushdown(x);
int sum = 0;
if(mid >= L)
sum += query(lch , l , mid , L , R);
if(mid < R)
sum += query(rch , mid + 1 , r , L , R);
return sum;
}
void solve(int ql , int qr , int l , int r){
if(ql > qr)
return;
if(l == r){
for(int i = ql ; i <= qr ; ++i)
ans[now[i].to] = l;
return;
}
int p1 = 0 , p2 = 0;
for(int i = ql ; i <= qr ; ++i)
if(now[i].ind == 1)
if(now[i].c > mid){
pot2[++p2] = now[i];
modify(1 , 1 , N , now[i].a , now[i].b , 1);
}
else
pot1[++p1] = now[i];
else{
int k = query(1 , 1 , N , now[i].a , now[i].b);
if(k >= now[i].c)
pot2[++p2] = now[i];
else{
pot1[++p1] = now[i];
pot1[p1].c -= k;
}
}
memcpy(now + ql , pot1 + 1 , sizeof(que) * p1);
memcpy(now + ql + p1 , pot2 + 1 , sizeof(que) * p2);
for(int i = ql + p1 ; i <= qr ; ++i)
if(now[i].ind == 1)
modify(1 , 1 , N , now[i].a , now[i].b , -1);
solve(ql , ql + p1 - 1 , l , mid);
solve(ql + p1 , qr , mid + 1 , r);
}
signed main(){
N = read();
M = read();
init(1 , 1 , N);
int maxN = -1e18 , minN = 1e18;
for(int i = 1 ; i <= M ; ++i){
now[i].ind = read();
now[i].a = read();
now[i].b = read();
now[i].c = read();
if(now[i].ind == 2)
now[i].to = ++cntAns;
else{
maxN = max(maxN , now[i].c);
minN = min(minN , now[i].c);
}
}
solve(1 , M , minN , maxN);
for(int i = 1 ; i <= cntAns ; ++i)
printf("%lld\n" , ans[i]);
return 0;
}HNOI2016 网络
对我来说，这道题在B站上特别卡常……
但是这道题数据又比较水，以至于树链剖分+线段树+堆的\(O(nlog^3n)\)算法都怼过去了
仍然考虑\(check\)函数，我们只对权值在\([mid+1,r]\)的范围内的修改进行操作，操作的方式考虑差分：预处理树的\(dfs\)序，对于一个加入操作\(a,b\)，在\(dfn_a,dfn_b\)处\(+1\)，然后在\(dfn_{LCA(a,b)},dfn_{fa_{LCA(a,b)}}\)处\(-1\)，删除操作反过来即可。
对于一个查询操作，我们需要查询是否当前加入的所有链都经过了当前点，我们直接查询当前点对应的子树中的权值和，如果它与当前加入的链数相等就表示所有链都经过了，答案在\([l,mid]\)范围内，否则在\([mid+1,r]\)范围内。正确性显然分类讨论一下就行了
代码超长预警
#include<bits/stdc++.h>
//This code is written by Itst
using namespace std;
inline int read(){
int a = 0;
bool f = 0;
char c = getchar();
while(c != EOF && !isdigit(c)){
if(c == '-')
f = 1;
c = getchar();
}
while(c != EOF && isdigit(c)){
a = (a << 3) + (a << 1) + (c ^ '0');
c = getchar();
}
return f ? -a : a;
}
const int MAXN = 100010;
struct query{
int ind , l , r , LCA , wei , place;
}now[MAXN << 1] , potL[MAXN << 1] , potR[MAXN << 1];
struct Ed{
int end , upEd;
}Ed[MAXN << 1];
int jump[MAXN][20] , head[MAXN] , dep[MAXN] , dfn[MAXN] , ans[MAXN] , size[MAXN] , Tree[MAXN];
int ts , N , M , cntEd , cntQ;
inline void addEd(int a , int b){
Ed[++cntEd].end = b;
Ed[cntEd].upEd = head[a];
head[a] = cntEd;
}
void dfs(int now , int fa){
size[now] = 1;
dfn[now] = ++ts;
dep[now] = dep[fa] + 1;
jump[now][0] = fa;
for(int i = 1 ; i <= 19 ; i++)
jump[now][i] = jump[jump[now][i - 1]][i - 1];
for(int i = head[now] ; i ; i = Ed[i].upEd)
if(Ed[i].end != fa){
dfs(Ed[i].end , now);
size[now] += size[Ed[i].end];
}
}
inline int jumpToLCA(int x , int y){
if(dep[x] < dep[y])
swap(x , y);
for(int i = 19 ; i >= 0 ; i--)
if(dep[x] - (1 << i) >= dep[y])
x = jump[x][i];
if(x == y)
return y;
for(int i = 19 ; i >= 0 ; i--)
if(jump[x][i] != jump[y][i]){
x = jump[x][i];
y = jump[y][i];
}
return jump[x][0];
}
inline int lowbit(int x){
return x & -x;
}
inline void add(int now , int num){
if(!now)
return;
while(now <= N){
Tree[now] += num;
now += lowbit(now);
}
}
inline int get(int x){
int sum = 0;
while(x){
sum += Tree[x];
x -= lowbit(x);
}
return sum;
}
void solve(int ql , int qr , int l , int r){
if(ql > qr)
return;
if(l == r){
do{
if(now[ql].ind == 3)
ans[now[ql].place] = l;
}while(++ql <= qr);
return;
}
int mid = l + r >> 1 , cntL = 0 , cntR = 0 , cnt = 0;
for(int i = ql ; i <= qr ; ++i)
if(now[i].ind == 1)
if(now[i].wei > mid){
int t = jumpToLCA(now[i].l , now[i].r);
add(dfn[now[i].l] , 1);
add(dfn[now[i].r] , 1);
add(dfn[t] , -1);
add(dfn[jump[t][0]] , -1);
potR[++cntR] = now[i];
++cnt;
}
else
potL[++cntL] = now[i];
else
if(now[i].ind == 2)
if(now[i].wei > mid){
int t = now[i].LCA;
add(dfn[now[i].l] , -1);
add(dfn[now[i].r] , -1);
add(dfn[t] , 1);
add(dfn[jump[t][0]] , 1);
potR[++cntR] = now[i];
--cnt;
}
else
potL[++cntL] = now[i];
else
if(get(dfn[now[i].l] + size[now[i].l] - 1) - get(dfn[now[i].l] - 1) == cnt)
potL[++cntL] = now[i];
else
potR[++cntR] = now[i];
for(int i = 1 ; i <= cntR ; ++i)
if(potR[i].ind == 1){
int t = potR[i].LCA;
add(dfn[potR[i].l] , -1);
add(dfn[potR[i].r] , -1);
add(dfn[t] , 1);
add(dfn[jump[t][0]] , 1);
}
else
if(potR[i].ind == 2){
int t = potR[i].LCA;
add(dfn[potR[i].l] , 1);
add(dfn[potR[i].r] , 1);
add(dfn[t] , -1);
add(dfn[jump[t][0]] , -1);
}
memcpy(now + ql , potL + 1 , sizeof(query) * cntL);
memcpy(now + ql + cntL , potR + 1 , sizeof(query) * cntR);
solve(ql , ql + cntL - 1 , l , mid);
solve(ql + cntL , qr , mid + 1 , r);
}
int main(){
#ifdef LG
freopen("3250.in" , "r" , stdin);
//freopen("3250.out" , "w" , stdout);
#endif
N = read();
M = read();
int maxT = 0;
for(int i = 1 ; i < N ; i++){
int a = read() , b = read();
addEd(a , b);
addEd(b , a);
}
dfs(1 , 0);
for(int i = 1 ; i <= M ; i++)
if((now[i].ind = read() + 1) == 1){
now[i].l = read();
now[i].r = read();
now[i].LCA = jumpToLCA(now[i].l , now[i].r);
now[i].wei = read();
maxT = max(maxT , now[i].wei);
}
else
if(now[i].ind == 2){
now[i] = now[read()];
now[i].ind = 2;
}
else{
now[i].place = ++cntQ;
now[i].l = read();
}
solve(1 , M , 0 , maxT);
for(int i = 1 ; i <= cntQ ; i++)
printf("%d\n" , ans[i] ? ans[i] : -1);
return 0;
}练习题是POI2011 Meteors，暂时还没有写咕咕咕
总结
CDQ分治与整体二分是两种比较优秀的分治算法，一般适用于以下情形：
\(1.\)不强制在线
\(2.\)对时间限制和空间限制要求比较高，使用高级数据结构（点名树套树！）容易被卡
虽然离线是这两种分治算法最大的软肋，出题人只需要加上异或\(lastans\)分治就GG了，但仍然不能改变这两种分治算法的重要地位。