技巧专题3(cdq分治、整体二分等)

cdq分治与整体二分

cdq来源于2008年国家集训队作业陈丹琦(雅礼巨佬)，用一个log的代价完成从静态到动态(很多时候是减少时间那一维的)。

对于一个时间段[L, R]，我们取mid = (L + R) / 2，分治的每层只考虑mid之前的修改对mid之后的查询的贡献，然后递归到[L,mid]，(mid,R]。

整体二分就是将所有询问一起二分，然后获得每个询问的答案。CDQ相比整体二分略有不同，整体二分是按照答案进行分治。

cdq和整体二分适用范围：处理一些用数据结构(如树套树)做起来非常令人难受的题。需要离线。

很多时候需要还原修改操作。

update20180315：

CDQ分治

抱歉上次因为能力不足没有讲清楚。

1 普通cdq分治（三维偏序问题）

按照线段树的形态递归的CDQ分治，保证每一对三元组在线段树上都有且仅有一个LCA(这不废话吗)，而这一组答案就会且仅会在LCA处计算。在每个LCA处，只计算左边的操作对右边的询问的贡献。

具体做法：一维是用来当做"时间"分治(假设为a)，一维是提前排好序的(假设为b)，一维放在数据结构里面查询(假设为c)。对于每一层cdq，我们二分一个时间mid，仍按照b的顺序依次处理，对于a<=mid的修改操作，我们放入数据结构在c位置修改，对于a>mid的查询操作，我们在数据结构里面根据c位置查询。这样我们就把a<=mid的操作对a>mid的操作的贡献全都算完了，然后把 a<=mid 和 a>mid 的操作分到左右两边，递归下去。

2 cdq套cdq（四维偏序问题）

当维数为4的时候，因为多出来的一维，就只能先确定一维的大小关系，使这一维不会影响内层的cdq分治。

具体做法：对于cdq1(外层cdq)，我们二分一个mid，然后把b<=mid的修改操作和b>mid的查询操作拿出来，这个时候我们确定拿出来的这些操作，修改的操作的b一定小于查询的操作的b，那么b这一维我们就可以不管了，所以我们把他们按照a大小关系重新排序,然后直接做普通的cdq分治(内层cdq)。

3 cdq+凸包、cdq+半平面交、cdq+背包

cdq是一个思想，一个技巧，说白了就是用一维来分治，用一个log时间换取排除这一维的干扰，cdq可以套在乱七八糟的东西上，也没有固定的格式，最重要的是适合题目。

下面是原内容：

Mokia

维护一个W*W的矩阵，初始值均为S.每次操作可以增加某格子的权值,或询问某子矩阵的总权值.修改操作数M<=160000,询问数Q<=10000,W<=2000000.

二维单点修改，矩形查询。

首先修改/查询之间的顺序就是时间，我们按时间来分治。

但是由于是二维的，为了省空间不开二维的数据结构，

我们一开始把所有操作按x轴排序，

每次处理我们只需要扫描一下x轴，把y轴的修改/查询放到一个一维树状数组里就好了。

矩形查询拆为4个前缀和查询

具体步骤如下：

(1)把操作离线下来，然后按x轴排序。(必要时离散化)

(2)分治区间[L, R](L, R为时间，即操作的编号)，取mid，从L到R遍历操作，

将mid之前的修改加入一维树状数组，将mid之后的查询在一维树状数组里查询。

(3)注意要还原修改操作，从L到R遍历操作，遇到修改操作，将修改操作改回去。

(4)开一个临时数组，两个指针(一个指针指向左区间的左端点，另一个指针指向右区间的左端点)，

从L到R遍历操作，将mid之前的操作放到左区间，将mid之后的操作放到右区间。

最后把临时数组赋值给操作数组。

(5)递归[L, mid]，[mid + 1, R]，回到(2)。

注意递归边界

在分治的每一层的区间内，x轴都是有序的。虽然时间无序，但是我们遍历操作时按照mid来划分了。

inline void cdq(int l,int r) {

    if(l==r) return;

    int mid=l+r>>1;

    for(int i=l;i<=r;i++)

        if(c[i].opt==1&&c[i].id<=mid) add(c[i].y,c[i].c);

        else if(c[i].opt==2&&c[i].id>mid) ans[c[i].qid]+=c[i].c*sum(c[i].y);

    for(int i=l;i<=r;i++)

        if(c[i].opt==1&&c[i].id<=mid) add(c[i].y,-c[i].c);

    int h1=l,h2=mid;

    for(int i=l;i<=r;i++)

        if(c[i].id<=mid) tmp[h1++]=c[i];

        else tmp[++h2]=c[i];

    for(int i=l;i<=r;i++) c[i]=tmp[i];

    cdq(l,mid); cdq(mid+1,r);

}

动态逆序对

对于序列A，它的逆序对数定义为满足i<j，且Ai>Aj的数对(i,j)的个数。

给1到n的一个排列，按照某种顺序依次删除m个元素.

你的任务是在每次删除一个元素之前统计整个序列的逆序对数。

$n \leq 1e5 , m \leq 5e4$

#include<algorithm>

#include<iostream>

#include<cstring>

#include<cstdlib>

#include<cstdio>

#include<cmath>

using namespace std;

#define ll long long

const int maxn=1e5+10,maxm=5e4+10;

ll n,m,a[maxn],id[maxn],tot;

ll aa;char cc;

ll read() {

	aa=0;cc=getchar();

	while(cc<'0'||cc>'9') cc=getchar();

	while(cc>='0'&&cc<='9') aa=aa*10+cc-'0',cc=getchar();

	return aa;

}

struct Ask{

	int id,x,y;

}ask[maxn];

ll ans[maxn],now[maxn];

bool cmp(const Ask& a,const Ask& b) {

	return now[a.id]<now[b.id];

}

bool cmp2(const Ask& a,const Ask& b) {

	return a.id<b.id;

}

int sz[maxn];

void add(int pos,int x){

	while(pos<=n) {

		sz[pos]+=x;

		pos+=pos&-pos;

	}

}

int q(int pos) {

	ll rs=0;

	while(pos) {

		rs+=sz[pos];

		pos-=pos&-pos;

	}

	return rs;

}

void cdq(int l,int r) {

	if(l==r) return;

	int mid=(l+r)>>1,pos1=l,pos2=mid+1;

	for(int i=l;i<=r;++i) {

		if(ask[i].x<=mid) add(ask[i].y,1),now[ask[i].id]=pos1++;

		else ans[ask[i].id]+=q(n)-q(ask[i].y),now[ask[i].id]=pos2++;

	}

	sort(ask+l,ask+r+1,cmp);

	for(int i=l;i<=mid;++i) add(ask[i].y,-1);

	cdq(l,mid);cdq(mid+1,r);

}

int main() {

	n=read();m=read();

	for(int i=1;i<=n;++i) {

		a[i]=read();

		id[a[i]]=i;

	}

	int x;

	for(int i=1;i<=m;++i) {

		x=read();

		ask[++tot].x=id[x];

		ask[tot].y=x;

		a[id[x]]=0;

	}

	for(int i=1;i<=n;++i) if(a[i]) {

		ask[++tot].x=i;

		ask[tot].y=a[i];

	}

	for(int i=1;i<=n/2;++i) swap(ask[i],ask[n-i+1]);

	for(int i=1;i<=n;++i) ask[i].id=i;

	cdq(1,n);

	for(int i=1;i<=n;++i) ask[i].x=n+1-ask[i].x,ask[i].y=n+1-ask[i].y;

	sort(ask+1,ask+n+1,cmp2);

	cdq(1,n);

	for(int i=1;i<=n;++i) ans[i]+=ans[i-1];

	for(int i=n;i>n-m;--i) printf("%lld\n",ans[i]);

	return 0;

}

Partial Order (3D)

有N个人，每个人有三种能力值Pi,Qi,Ri。如果Pi>Pj && Qi>Qj && Ri>Rj，称I比J有能力.现在要求出最长的一个序列A=(A1,A2,…,At)，满足Ai比Ai+1有能力。

$N \leq 4e4$

尝试在这个问题上进行分治。

定义过程Solve(l,r)，能够得到F[l]..F[r]的值

Solve(l,r):

Solve(l,mid)

处理[l,mid]中元素对[mid+1,r]中F[x]取值的影响

Solve(mid+1,r)

Simplified Partial Order(4D)

有N个人，每个人有四种能力值Pi,Qi,Ri,Si。
如果Pi>Pj && Qi>Qj && Ri>Rj && Si>Sj，称I比J有能力。
对每一个人，输出任意一个比他有能力的人编号，或声明没有人比他有能力。

Partial Order(4D)

有N个人，每个人有三种能力值Pi,Qi,Ri,Si。

如果Pi>Pj && Qi>Qj && Ri>Rj && Si>Sj，称I比J有能力。

现在要求出最长的一个序列A=(A1,A2,…,At)，满足Ai比Ai+1有能力。

$N \leq 2e4$

分治套分治(cdq套cdq)

首先我们按照p一维排序。

Solve(l,r):

Solve(l,mid)

do sth

Solve(mid+1,r)

do sth需要考虑的问题：

给定带权点集X=(Qi,Ri,Si) [l<=i<=mid]，权值F[i]

给定(r-mid)个询问(Qj,Rj,Sj) [mid+1<=j<=r]

对于每个询问，回答点集中满足Qi<Qj,Ri<Rj,Si<Sj的最大权值。

类似于3D偏序问题。

Solve2(l,r):

Solve2(l,mid)

处理(l,mid)中点对(mid+1,r)中询问的影响

Solve2(mid+1,r)

所以说总体就是这样的：

Solve(l,r)

Solve(l,mid)

创建一个[l,r]的副本并按照Q[i]分治

Solve2(l,r)

Solve(mid+1,r)

天使玩偶

维护二维点集P，支持以下两个操作

(1)插入点(x,y)

(2)给定询问(x,y)，求点集中离询问点最近的点

距离定义为曼哈顿距离Dis(P1,P2)=|x1-x2|+|y1-y2|

$N \leq 3e5$

Star(hdu5126)

在一个三维空间当中，每次进行一个操作，添加一个点或者统计空间中的某一个长方体范围内的所有点

$N \leq 5e4$

//Serene

#include<algorithm>

#include<iostream>

#include<cstring>

#include<cstdlib>

#include<cstdio>

#include<cmath>

using namespace std;

const int maxn=4e5+10;

int T,n,tot,qtot,ans[maxn/6];

int pz[maxn/4],tz;

int aa;char cc;

int read() {

	aa=0;cc=getchar();

	while(cc<'0'||cc>'9') cc=getchar();

	while(cc>='0'&&cc<='9') aa=aa*10+cc-'0',cc=getchar();

	return aa;

}

int ef(int x) {

	int l=1,r=tz,mid;

	while(l<=r) {

		mid=(l+r)>>1;

		if(pz[mid]==x) return mid;

		if(pz[mid]<x) l=mid+1;

		else r=mid-1;

	}

}

int xx[maxn],yy[maxn],zz[maxn],fnum[maxn];

struct Ask{

	int qid,id;

}ask[maxn],ask1[maxn],ask2[maxn];

bool cmp(const Ask& a,const Ask& b) {

	return xx[a.id]==xx[b.id]? a.id < b.id : xx[a.id] < xx[b.id];

}

bool cmp2(const Ask& a,const Ask& b) {

	return yy[a.id]==yy[b.id]? a.id < b.id : yy[a.id] < yy[b.id];

}

void add(int x,int y,int z,int num) {

	fnum[++tot]=num;ask[tot].id=tot;

	xx[tot]=x;yy[tot]=y;zz[tot]=z;

	if(num) ask[tot].qid=qtot;

}

int sz[maxn];

int q(int pos) {

	int rs=0;

	while(pos) {

		rs+=sz[pos];

		pos-=pos&-pos;

	}

	return rs;

}

void chge(int pos,int x) {

	while(pos<=tz) {

		sz[pos]+=x;

		pos+=pos&-pos;

	}

}

void cdq2(int l,int r) {

	if(l>=r) return;

	int mid=(l+r)>>1,now=0;

	cdq2(l,mid); cdq2(mid+1,r);

	for(int i=l;i<=mid;++i) if(!fnum[ask1[i].id]) ask2[++now]=ask1[i];

	for(int i=mid+1;i<=r;++i) if(fnum[ask1[i].id]) ask2[++now]=ask1[i];

	sort(ask2+1,ask2+now+1,cmp2);

	for(int i=1;i<=now;++i) {

		if(!fnum[ask2[i].id]) chge(zz[ask2[i].id],1);

		else ans[ask2[i].qid]+=fnum[ask2[i].id]*q(zz[ask2[i].id]);

	}

	for(int i=1;i<=now;++i) if(!fnum[ask2[i].id]) chge(zz[ask2[i].id],-1);

}

void cdq(int l,int r) {

	if(l>=r) return;

	int mid=(l+r)>>1,now=0;

	cdq(l,mid); cdq(mid+1,r);

	for(register int i=l;i<=mid;++i) if(!fnum[ask[i].id]) ask1[++now]=ask[i];

	for(register int i=mid+1;i<=r;++i) if(fnum[ask[i].id]) ask1[++now]=ask[i];

	sort(ask1+1,ask1+now+1,cmp);

	cdq2(1,now);

}

void clear() {

	memset(ans,0,sizeof(ans));

	tz=tot=qtot=0;

}

int main() {

	T=read();

	int op,x,y,z,x1,y1,z1;

	while(T--) {

		n=read(); clear();

		for(int i=1;i<=n;++i) {

			op=read(); x=read(); y=read(); z=read();

			if(op==1) add(x,y,z,0),pz[++tz]=z;

			else {

				x1=read();y1=read();z1=read();++qtot; pz[++tz]=z1; pz[++tz]=z-1;

				add(x-1,y-1,z-1,-1);  add(x1,y1,z1,1);

				add(x1,y-1,z-1,1);	add(x-1,y1,z-1,1);	add(x-1,y-1,z1,1);

				add(x-1,y1,z1,-1);  add(x1,y-1,z1,-1);  add(x1,y1,z-1,-1);

			}

		}

		sort(pz+1,pz+tz+1);

		tz=unique(pz+1,pz+tz+1)-(pz+1);

		for(int i=1;i<=tot;++i) zz[i]=ef(zz[i]);

		cdq(1,tot);

		for(int i=1;i<=qtot;++i) printf("%d\n",ans[i]);

	}

	return 0;

}

cash(noi2007)

小Y最近在一家金券交易所工作．该金券交易所只发行交易两种金券：A纪念券（以下简称 A 券）和 B 纪念券（以下简称 B 券）．

每个持有金券的顾客都有一个自己的帐户．金券的数目可以是一个实数．

每天随着市场的起伏波动，两种金券都有自己当时的价值，即每一单位金券当天可以兑换的人民币数目．我们记录第 K 天中 A 券和 B 券的价值分别为 AK 和 BK（元/单位金券）．

为了方便顾客，金券交易所提供了一种非常方便的交易方式：比例交易法．比例交易法分为两个方面：

A) 卖出金券：顾客提供一个[0，100]内的实数 OP 作为卖出比例，其意义为：将 OP%的 A 券和 OP%的 B 券以当时的价值兑换为人民币；

B) 买入金券：顾客支付 IP 元人民币，交易所将会兑换给用户总价值为

IP 的金券，并且，满足提供给顾客的 A 券和 B 券的比例在第 K 天恰好为 RateK；

例如，假定接下来 3 天内的 Ak、Bk、RateK 的变化分别为：

时间	Ak	Bk	RAtek
第一天	1	1	1
第二天	1	2	2
第三天	2	2	3

假定在第一天时，用户手中有 100 元人民币但是没有任何金券．用户可以执行以下的操作：

时间	用户操作	人民币(元)	A 券的数量	B 券的数量
开户	无	100	0	0
第一天	买入 100 元	0	50	50
第二天	卖出 50%	75	25	25
第二天	买入 60 元	15	55	40
第三天	卖出 100%	205	0	0

注意到，同一天内可以进行多次操作．

小 Y 是一个很有经济头脑的员工，通过较长时间的运作和行情测算，

他已经知道了未来 N 天内的 A 券和 B 券的价值以及 Rate．

他还希望能够计算出来，如果开始时拥有 S 元钱，那么 N 天后最多能够获得多少元钱．

$N \leq 1e5$

我们可以贪心地知道每次卖出金券都是把手中的所有都卖出去最优。

假如用f[i]表示第i天手中的A券，我们可以得到一个dp方程：

ans=max(ans,f[j]*a[i]+f[j]/rate[j]*b[i])

f[i]=ans*rate[i]/(a[i]*rate[i]+b[i])

对于一个i我们需要枚举<i的j(上一次买入金券的时间)。

所以说复杂度是n平方的。

对于刚才的式子，我们假设j比k优并且f[j]<f[k]

令g[i]=f[i]/rate[i]，那么有

f[j]*a[i]+g[j]*b[i]>f[k]*a[i]+g[k]*b[i]

(f[j]-f[k])*a[i]+(g[j]-g[k])*b[i]>0

=>

(g[j]-g[k])/(f[j]-f[k])<-a[i]/b[i]

我们发现式子左边相当于点(f[j],g[j])与(f[k],g[k])的斜率

如果我们维护一个当f增大g减小的上凸壳，

那么我们就需要找到第一个斜率<-a[i]/b[i]的线段(二分)。

由于随着i变大，f、g并不单调，所以不能直接用栈维护凸壳

可以用平衡树来维护(比如splay什么的)

我们考虑用cdq分治来做这个问题。

我们先按照时间排序(就相当于不排序嘛)

solve(l,r):

solve(l,mid)(然后左区间就按照f排好序了)

设置一个右区间的副本并把他按照-a[i]/b[i]排序。

扫一遍更新右区间的f

solve(mid+1,r)(然后右区间就按照f排好序了)

把左右区间合并起来使他们按照f排好序(就相当于归并排序嘛)

MachineWorks

你的公司获得了一个厂房N天的使用权和一笔启动资金，你打算在这N天里租借机器进行生产来获得收益。

可以租借的机器有M台。每台机器有四个参数D,P,R,G。

你可以在第D天花费P的费用（当然，前提是你有至少P元）租借这台机器。

从第D+1天起，操作机器将为你产生每天G的收益。在你不再需要机器时，可以将机器卖掉，一次性获得R的收益。

厂房里只能停留一台机器。不能在购买和卖出机器的那天操作机器，但是可以在同一天卖掉一台机器再买入一台。

在第N+1天，你必须卖掉手上的机器。

求第N+1天后能获得的最大资金。

$N \leq 1e5$

我们将机器按照D排序。

首先考虑dp。设f[i]表示第i天卖掉机器(让厂房空出来)的最大资金。

f[i]=max(f[i-1],f[j]-P[j]+R[j]+(D[i]-D[j]-1)*G[j])

而f[j]-P[j]+R[j]+(D[i]-D[j]-1)*G[j]

=f[j]-P[j]+R[j]-(D[j]+1)*G[j]+D[i]*G[j]

令A[j]=f[j]-P[j]+R[j]-(D[j]+1)*G[j](只和j有关)

那么：f[i]=max(f[i-1],A[j]+D[i]*G[j])

很像斜率优化的式子，而且D单调。

我们就需要维护一个上凸壳。

但是A和G不单调，所以说还是需要cdq分治。

K大数查询

有N个位置，M个操作。操作有两种，每次操作如果是1 a b c的形式表示在第a个位置到第b个位置，每个位置加入一个数c(即一个位置可以没有数也可以有多个数)

如果是2 a b c形式，表示询问从第a个位置到第b个位置，第c大的数是多少。

操作1中$c \leq N$，操作2中$c \leq Maxlongint$

$N,M \leq 5e4$

因为操作1中c<=N，答案种数比较少，所以我们考虑对答案分治。

就是相当于把所有询问分到N个答案上去。

假如说当前区间是[l,r]，那么目前分到这个区间的所有询问的答案一定在[l,r]中。

我们再把这些询问分成两组，一组答案是在[l,mid]中，一组答案是在[mid+1,r]中。

这样就可以继续分治下去最后得到所有答案所对应的询问。

那么现在问题转化为了判断一个询问被分到哪一组。

也就是说判断这个询问的区间内有多少数的数值是在区间[l,mid]中的。

我们就可以用树状数组维护这个东西，按照操作顺序搞一搞。

涉及树状数组区间修改区间查询。

Meteors

有n个国家和m个空间站，每个空间站都属于一个国家，一个国家可以有多个空间站。

所有空间站按照顺序形成一个环，也就是说，m号空间站和1号空间站相邻。

现在，将会有k场流星雨降临，每一场流星雨都会给区间[li,ri]内的每个空间站带来ai单位的陨石。

每个国家都有一个收集陨石的目标pi，即第i个国家需要收集pi单位的陨石。

询问：每个国家最早完成陨石收集目标是在第几场流星雨过后。

1<=n,m,k<=300000

对于当前区间[l,r]，保证目前在这里的所有国家(询问)答案都在[l,r]之间。

用一个数组cur表示这些询问在前l-1场流星雨中的获得量

用线段树或树状数组计算[l,mid]的流星雨，

然后对于每个国家加上对应部分的流星雨。

如果加上后已经达到需要的值，就把这个国家划分到左区间，否则右区间

注意要还原修改操作，还有处理无解情况：可以增加一个INF的流星雨。

Package

有N个物品，每个物品的重量是Wi,价值是Gi
每个物品只能取一个
给定Q个询问，每个询问由两个数(X,I)组成
给定最大容量为X的背包，使用除了第i件物品以外的所有物品，能够得到的最大价值之和

$N \leq 100 , X \leq 10000 , Q \leq 1000000$

考虑01背包复杂度NX，因为每加入一个单个物品的复杂度是X。

询问非常多，但是物品很少，我们考虑把不能选物品相同的询问一起考虑。

扩展成维护不能选物品在区间[l,r]中的询问一起考虑。

假如S是不选区间[l,r]做的01背包情况

然后每次将区间划分成[l,mid]、[mid+1,r]就是在S的基础上继续做01背包。

[l,mid]就是在S基础上加入mid+1~r的物品，

而[mid+1,r]就是在S基础上加入l~mid的物品。

于是询问(X,I)的答案就是当区间为[I,I]的S里面容量为X的值。

Attack

chnlich非常喜欢玩三国志这款游戏，并喜欢用一些策略出奇制胜。现在，他要开始征服世界的旅途了。
他的敌人有N座城市和N个太守，N个城市可以看作在二维平面上的N个点。
N座城市的标号为0,1,2,……,N-1。
第i座城市的坐标为(Xi,Yi)，镇守这座城市的太守的能力值为Zi。
chnlich每次会选择一个边平行于坐标轴的矩形区域，并奇袭其中太守能力值第K小的城市(奇袭结束之后城市与太守依然存在)。
不过，他的敌人经常会偷偷交换两座城市的太守，防止弱点被chnlich发现。
现在，chnlich想要知道，每次奇袭时他的敌人的能力值。

$N \leq 6e4$

参考资料：

http://blog.csdn.net/hbhcy98/article/details/50642773

http://blog.csdn.net/braketbn/article/details/51187181

http://www.cnblogs.com/lazycal/archive/2013/08/05/3239304.html

https://www.cnblogs.com/rootial/p/3950105.html

https://www.cnblogs.com/candy99/p/6441989.html