Codeforces 1705E 思维+权值线段树上二分-CSDN博客

本文链接：https://blog.csdn.net/stdforces/article/details/125863209

题意：

给定一个序列，可以将序列出现次数 $\geq2$ 的数 $x$ 合并为 $x + 1$ ，给出 $m$ 个操作，每次操作给出 $x\ k$ ，即把 $a [x]$ 修改为k，在每次操作后，输出序列能合并到的最大值

分析：

出现次数 $\geq2$ 的数 $x$ 合并为 $x + 1$ ，类似于二进制，可以建一颗权值线段树，如果某个数的出现次数 $\geq2$ ，那么合并他，如果合并完还需合并，即合并到了出现次数为1的地方，那么我们就合并到最近的0，比如说出现次数序列为1111100，在最左侧的1++，那么合并后的序列为0000010。

操作处理：把 $a [x]$ 改成 $k$ ，那么 $a [x]$ 的出现次数先单点减少1，再赋值让 $a [x] = k$ 的次数再单点增加1，如果减少之前是0，那么就是找最近的1，然后把 $k$ 到这个位置之前的地方改成1，最近的1位置改成0，正确性证明：

原序列：00000100001

单点减少1后序列 0000010-1001

把最近的1拆分，原序列可以写作：（两行写法都表示上下两个序列相加）

0 0 0 0 0 1 0 -1 0 0 0

1 1 1 1 1 1 1 1 1 1 0 +1

对-1位相加有

0 0 0 0 0 1 0 0 0 0 0

1 1 1 1 1 1 1 0 1 1 0 +1

对下面的序列计算有

0 0 0 0 0 1 0 0 0 0 0

0 0 0 0 0 0 0 1 1 1 0

结果为：

0 0 0 0 0 1 0 0 1 1 0

结论为：如果 $x$ 位为-1，那么找高位方向离 $x$ 最近的1，记这个1的位置为pos，只需要把 $[x, p os - 1]$ 修改为1，pos位置修改为0即可。

TIPS:

不要在有push_down，push_up的函数内再次调用其他有push_down，push_up的函数！！！！！

在本题，也就是单调修改后如果出现了-1或2，记录下来，等单点修改函数结束后再来处理！！！

#include<bits/stdc++.h>
#define ll long long
#define done cout<<"done\n";
using namespace std;

int read()
{
	int ret=0,base=1;
	char ch=getchar();
	while(!isdigit(ch))
	{
		if(ch=='-') base=-1;
		ch=getchar();
	}
	while(isdigit(ch))
	{
		ret=(ret<<3)+(ret<<1)+ch-48;
		ch=getchar();
	}
	return ret*base;
}

const int maxn=210000;

inline int ls(int x){return x<<1;}

inline int rs(int x){return x<<1|1;}

int need1,need2,n,m,min1[3000005],max1[3000005],a[3000005],tag[3000005];

inline void push_up(int x){
	min1[x]=min(min1[ls(x)],min1[rs(x)]);
	max1[x]=max(max1[ls(x)],max1[rs(x)]);
}

inline void get_tag(int l,int r,int x,int k){
	tag[x]=min1[x]=max1[x]=k;
}

void push_down(int l,int r,int x)
{
	if(tag[x]!=-1){
		int mid=l+r>>1;
		get_tag(l,mid,ls(x),tag[x]);
		get_tag(mid+1,r,rs(x),tag[x]);
		tag[x]=-1;
	}
}

int find1(int nl,int nr,int l,int r,int x,int k)//找[nl,nr]第一个大于等于k的数的下标
{
	if(l==r) return max1[x]>=k?l:-1;
	int mid=l+r>>1;
	push_down(l,r,x);
	if(nl==l&&nr==r)
	{
		if(max1[x]<k) return -1;
		else
		{
			if(l==r) return l;
			if(max1[ls(x)]>=k) return find1(nl,mid,l,mid,ls(x),k);
			return find1(mid+1,nr,mid+1,r,rs(x),k);
		}
	}
	else
	{
		if(nr<=mid) return find1(nl,nr,l,mid,ls(x),k);
		else if(nl>mid) return find1(nl,nr,mid+1,r,rs(x),k);
		else
		{
			int temp=find1(nl,mid,l,mid,ls(x),k);
			if(temp==-1) return find1(mid+1,nr,mid+1,r,rs(x),k);
			return temp;
		}
	}
	push_up(x);
}

int find2(int nl,int nr,int l,int r,int x,int k)//找第一个小于等于k的数的下标
{
	if(l==r) return max1[x]<=k?l:-1;
	int mid=l+r>>1;
	push_down(l,r,x);
	if(nl==l&&nr==r)
	{
		if(min1[x]>k) return -1;
		else
		{
			if(l==r) return l;
			if(min1[ls(x)]<=k) return find2(nl,mid,l,mid,ls(x),k);
			return find2(mid+1,nr,mid+1,r,rs(x),k);
		}
	}
	else
	{
		if(nr<=mid) return find2(nl,nr,l,mid,ls(x),k);
		else if(nl>mid) return find2(nl,nr,mid+1,r,rs(x),k);
		else 
		{
			int temp=find2(nl,mid,l,mid,ls(x),k);
			if(temp==-1) return find2(mid+1,nr,mid+1,r,rs(x),k);
			return temp;
		}
	}
	push_up(x);
}

int find3(int nl,int nr,int l,int r,int x,int k)//找最后一个大于等于k的
{
	if(l==r) return max1[x]>=k?l:-1;
	int mid=l+r>>1;
	push_down(l,r,x);
	if(l==nl&&r==nr)
	{
		if(max1[x]<k) return -1;
		else
		{
			if(l==r) return l;
			if(max1[rs(x)]>=k) return find3(mid+1,nr,mid+1,r,rs(x),k);
			return find3(nl,mid,l,mid,ls(x),k);
		}
	}
	else
	{
		if(nr<=mid) return find3(nl,nr,l,mid,ls(x),k);
		else if(nl>mid) return find3(nl,nr,mid+1,r,rs(x),k);
		else
		{
			int temp=find3(mid+1,nr,mid+1,r,rs(x),k);
			if(temp==-1) return find3(nl,mid,l,mid,ls(x),k);
			return temp; 
		}
	}
	push_up(x);
}

void modify(int nl,int nr,int l,int r,int x,int k)
{
	if(nl<=l&&r<=nr){
		min1[x]=max1[x]=k;
		tag[x]=k;
		return;
	}
	int mid=l+r>>1;push_down(l,r,x);
	if(nl<=mid) modify(nl,nr,l,mid,ls(x),k);
	if(nr>mid)  modify(nl,nr,mid+1,r,rs(x),k);
	push_up(x);
}

void solve1(int k)
{
	int pos=find1(k+1,maxn,1,maxn,1,1);
	modify(k,pos-1,1,maxn,1,1);
	modify(pos,pos,1,maxn,1,0);
}

void solve2(int k)
{
	int pos=find2(k+1,maxn,1,maxn,1,0);
	modify(k,pos-1,1,maxn,1,0);
	modify(pos,pos,1,maxn,1,1);
}

void update(int sta,int l,int r,int x,int k)
{
	if(l==sta&&l==r){
		min1[x]+=k;
		max1[x]+=k;
		if(min1[x]==-1) need1=l;
		else if(min1[x]==2) need2=l;
		else need1=need2=0;
		return;
	}
	int mid=l+r>>1;push_down(l,r,x);
	if(sta<=mid) update(sta,l,mid,ls(x),k);
	else update(sta,mid+1,r,rs(x),k);
	push_up(x);
}

int getans(){return find3(1,maxn,1,maxn,1,1);}

void solve()
{
	if(need1) solve1(need1);
	if(need2) solve2(need2);
	need1=need2=0;
}

int main()
{
	n=read();m=read();
	memset(tag,-1,sizeof(tag));
	for(int i=1;i<=n;i++)
	{
		a[i]=read();
		update(a[i],1,maxn,1,1);//单点+1
		solve();
	}
	while(m--)
	{
		int x=read(),k=read();
		update(a[x],1,maxn,1,-1);
		solve();
		update(k,1,maxn,1,1);
		solve();
		a[x]=k;
		printf("%d\n",getans());
	}
 	return 0;
}

另外，附带一个权值线段树二分的模板

根据查询的是第一个还是最后一个来调整先检查左半部分还是右半部分即可

再叶子节点不要push_down，否则会RE

查询的时候记得push_down和push_up

int search(int nl,int nr,int l,int r,int x,int k)//在区间[nl,nr]内寻找第一个大于等于k的数
{
	if(l==r) return max1[x]>=k?l:-1;
	push_down(l,r,x);
	int mid=l+r>>1;
	if(nl==l&&nr==r)//如果当前管辖区间与查询区间重合
	{
		if(max1[x]<k) return -1;//现在这个找到的单点位置最大值都小于等于k了，那么就不存在这样的位置
		else
		{
			//要找第一个大于等于k的数，先检查左区间
			if(max1[ls(x)]>=k) return search(nl,mid,l,mid,ls(x),k);//如果左区间的最大值>=k，那么答案一定存在于左半部分
			return search(mid+1,nr,mid+1,r,rs(x),k);//左端点既然不符合，那么右半部分有就有，没有就没有，直接找右半部分
		}
	}
	else
	{
		//如果查询区间的右端点都小于现在管理区间的左部分的右端点，那么直接在左半部分查即可，即查询区间全在左半部分
		if(nr<=mid) return search(nl,nr,l,mid,ls(x),k);
		else if(nl>mid) return search(nl,nr,mid+1,r,rs(x),k);//同理是查询区间全在右半部分
		else//否则即是左半部分有，右半部分也有，那么此时先查左边，因为要找最近的，如果查回来的是-1，那么再差右半部分
		{
			int ret=search(nl,mid,l,mid,ls(x),k);
			if(ret==-1) return search(mid+1,nr,mid+1,r,rs(x),k);//左半部分查询不到，直接返回右半部分
			return ret;
		}
	}
	push_up(x);
}