整体二分

例题

MKTHNUM - K-th Number

考虑如果我们对每个操作进行二分怎么做。

显然是对这个区间不大于二分值 $m i d$ 的数统计个数，看个数 $n u m$ 和 $k$ 的大小关系。如果 $n u m$ 更大，证明 $m i d$ 大了，如果 $n u m$ 更小，证明 $m i d$ 小了。

然后我们考虑推广这种思路。

首先我们询问的答案肯定是原来数组中的一个数，所以我们可以直接把原数组排序，然后用下标代表其权值。这里我们的排序事实上可以用离散化完成，那样做的效果相同，但是排序更方便。

接下来，我们要实现整体二分的核心函数 $s o l v e (l, r, L, R)$ ，表示当前对于编号为 $i d ， i d \in [l, r]$ 的询问，可能的答案为 $[L, R]$ 内的一个数。

当然，给出的询问不会这么巧合正好是上面那种情况的，所以我们在整体二分时需要对询问排序，当然这个后面会说。

因为答案在 $[L, R]$ 内，所以考虑找到中点 $m i d$ ，然后把下标在 $[L, m i d]$ 内的数加到树状数组里（事实上如果权值不大可以加权值，但这题只能使用下标，要不然空间会炸）。

然后考虑如果对于一个询问 $(l, r, k)$ ，树状数组在 $[l, r]$ 内的数的数量 $n u m$ 不小于 $k$ ，证明对于这个询问 $m i d$ 太大了，把他扔到数组 $q 1$ 中；否则就是 $m i d$ 太小了，于是先 $k \leftarrow k - n u m$ ，然后把这个询问扔到数组 $q 2$ 内。

这里说一下为什么要 $k \leftarrow k - n u m$ 。因为我们接下来对这类 $m i d$ 太小了的询问会单独处理，而后面统计的是在新区间内不大于他的数的数量。我们不能忽略之前比他小的数带来的贡献，所以要做这样一个操作。

然后做完这个类似于归并排序的操作后，我们把之前树状数组里的东西清空掉，然后把 $q 1, q 2$ 数组内的东西放回询问数组接着递归处理（事实上就是做了个分类，然后对两类询问继续递归）。

边界情况： $L = R$ ，此时 $[l, r]$ 内的询问的答案结尾 $v a l_{L}$ ，注意不是 $L$ ，因为我们一开始用下标代替了权值。

代码：

#include<bits/stdc++.h>
#define int long long
#define N 100005
using namespace std;
int n,m,c[N],res[N];
struct node{
	int id,x;
	bool operator<(const node &t)const{
		return x<t.x;
	}
}a[N];
struct ask{
	int id,l,r,k;
}q[N],q1[N],q2[N];
int lowbit(int x){
	return x&-x;
}
void modify(int x,int v){
	while(x<=n){
		c[x]+=v;
		x+=lowbit(x);
	}
}
int qry(int x){
	int res=0;
	while(x){
		res+=c[x];
		x-=lowbit(x);
	}
	return res;
}
void solve(int l,int r,int L,int R){
	if(l>r)return;
	if(L==R){
		for(int i=l;i<=r;i++){
			res[q[i].id]=a[L].x;
		}
		return;
	}
	int mid=L+R>>1;
	for(int i=L;i<=mid;i++){
		modify(a[i].id,1);
	}
	int cnt1=0,cnt2=0;
	for(int i=l;i<=r;i++){
		int sum=qry(q[i].r)-qry(q[i].l-1);
		if(q[i].k<=sum){
			q1[++cnt1]=q[i];
		}
		else{
			q[i].k-=sum;
			q2[++cnt2]=q[i];
		}
	}
	for(int i=L;i<=mid;i++){
		modify(a[i].id,-1);
	}
	for(int i=1;i<=cnt1;i++){
		q[i+l-1]=q1[i];
	}
	for(int i=1;i<=cnt2;i++){
		q[i+l+cnt1-1]=q2[i];
	}
	solve(l,l+cnt1-1,L,mid);
	solve(l+cnt1,r,mid+1,R);
}
signed main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i].x;
		a[i].id=i;
	}
	for(int i=1;i<=m;i++){
		cin>>q[i].l>>q[i].r>>q[i].k;
		q[i].id=i;
	}
	sort(a+1,a+n+1);
	solve(1,m,1,n);
	for(int i=1;i<=m;i++){
		cout<<res[i]<<'\n';
	}
	return 0;
}

K大数查询

上一道题的动态版。这里说一句，如果没有第 $c$ 大的数，输出 -1。

注意这道题需要支持区间加区间查询，所以我们需要线段树或者两个树状数组进行维护。这里笔者采用了两个树状数组。

就比方说要求 $\sum_{i = 1}^{k} a_{i}$ ，我们设 $d_{i}$ 为其差分数组。然后原式就是 $\sum_{i = 1}^{k} a_{i} \times (k - i + 1)$ ，再化简一下就是 $k \times \sum_{i = 1}^{k} d_{i} - \sum_{i = 1}^{k} (i - 1) \times d_{i}$ 。所以我们用两个树状数组维护前缀和即可

然后剩下的东西就跟上一道题一样。代码：

#include<bits/stdc++.h>
#define int long long
#define N 50005
using namespace std;
int n,m,res[N],c1[N],c2[N];
struct node{
	int op,l,r,c,id;
}q[N],q1[N],q2[N];
int lowbit(int x){
	return x&-x;
}
void bit_modify(int c[],int x,int v){
	while(x<=n){
		c[x]+=v;
		x+=lowbit(x);
	}
}
int bit_qry(int c[],int x){
	int res=0;
	while(x){
		res+=c[x];
		x-=lowbit(x);
	}
	return res;
}
void modify(int x,int v){
	bit_modify(c1,x,v);
	bit_modify(c2,x,v*(x-1));//这里是树状数组区间加区间查询模板
}
int qry(int x){
	return bit_qry(c1,x)*x-bit_qry(c2,x);//这里是树状数组区间加区间查询模板
}
void solve(int l,int r,int L,int R){
	if(l>r||L>R)return;
	if(L==R){
		for(int i=l;i<=r;i++){
			if(q[i].op==2){
				res[q[i].id]=L;
			}
		}
		return;
	}
	int mid=L+R>>1;
	int cnt1=0,cnt2=0;
	for(int i=l;i<=r;i++){
		if(q[i].op==1){
			if(q[i].c<=mid){
				q1[++cnt1]=q[i];
			}
			else{
				modify(q[i].l,1);
				modify(q[i].r+1,-1);
				q2[++cnt2]=q[i];
			}
		}
		else{
			int sum=qry(q[i].r)-qry(q[i].l-1);
			if(q[i].c<=sum){
				q2[++cnt2]=q[i];
			}
			else{
				q[i].c-=sum;
				q1[++cnt1]=q[i];
			}
		}
	}
	for(int i=l;i<=r;i++){
		if(q[i].op==1){
			if(q[i].c>mid){
				modify(q[i].l,-1);
				modify(q[i].r+1,1);
			}
		}
	}
	for(int i=1;i<=cnt1;i++){
		q[i+l-1]=q1[i];
	}
	for(int i=1;i<=cnt2;i++){
		q[i+l+cnt1-1]=q2[i];
	}
	solve(l,l+cnt1-1,L,mid);
	solve(l+cnt1,r,mid+1,R);
}
signed main(){
	cin>>n>>m;
	int cnt=0;
	for(int i=1;i<=m;i++){
		cin>>q[i].op>>q[i].l>>q[i].r>>q[i].c;
		if(q[i].op==2)q[i].id=++cnt;
	}
	solve(1,m,0,n);
	for(int i=1;i<=cnt;i++){
		if(res[i]==0)res[i]=-1;
		cout<<res[i]<<'\n';
	}
	return 0;
}

小马和路

本题可以使用 $L C T$ 维护 $M S T$ ，但这里不再赘述。

考虑对于每条边，二分一个值，为如果以这条边作为最小边权的边加入所选边集，那么使得 $1, n$ 连通所需加入的最大边权的边的边权最小能是多少。

发现二分 $m$ 次时间过于爆炸，所以我们使用整体二分。

我们首先把待处理的边权倒序排序，然后每次使用可撤销并查集维护信息（不能路径压缩，故使用按秩合并），每次只需要扫一遍加边，判断加完边之后 $1, n$ 是否连通，最后撤销即可。

代码：

#include<bits/stdc++.h>
#define int long long
#define N 200005
#define pii pair<int,int>
#define x first
#define y second
using namespace std;
int n,m,fa[N],siz[N];
int q[N],q1[N],q2[N],res[N];
pii e[N];
stack<pii>s;
int find(int x){
	return fa[x]==x?x:find(fa[x]);
}
void merge(int x,int y){
	x=find(x);y=find(y);
	if(x==y)return;
	if(siz[x]<siz[y])swap(x,y);
	fa[y]=x;
	siz[x]+=siz[y];
	s.push({x,y});
}
void undo(){
	int x=s.top().x,y=s.top().y;
	s.pop();
	siz[x]-=siz[y];
	fa[y]=y;
}
void solve(int l,int r,int L,int R){
	if(l>r||L>R)return;
	if(L==R){
		for(int i=l;i<=r;i++){
			res[q[i]]=L;
		}
		return;
	}
	int mid=L+R>>1;
	int cnt1=0,cnt2=0;
	int now=mid+1;
	for(int i=r;i>=l;i--){
		if(q[i]>mid)q2[++cnt2]=q[i];
		else{
			while(now>q[i]){
				now--;
				merge(e[now].x,e[now].y);
			}
			if(find(1)==find(n))q1[++cnt1]=q[i];
			else q2[++cnt2]=q[i];
		}
	}
	while(!s.empty())undo();
	reverse(q1+1,q1+cnt1+1);
	reverse(q2+1,q2+cnt2+1);
	for(int i=1;i<=cnt1;i++)q[i+l-1]=q1[i];
	for(int i=1;i<=cnt2;i++)q[i+l-1+cnt1]=q2[i];
	solve(l,l+cnt1-1,L,mid);
	solve(l+cnt1,r,mid+1,R);
} 
signed main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>e[i].x>>e[i].y;
		q[i]=i;
	}
	for(int i=1;i<=n;i++){
		fa[i]=i;
		siz[i]=1;
	}
	solve(1,m,1,m+1);
	int mn=2e18;
	for(int i=1;i<=m;i++){
		if(res[i]==m+1)continue;
		mn=min(mn,res[i]-i+1);
	}
	if(mn==2e18)mn=-1;
	cout<<mn;
	return 0;
}