一个简单的区间问题

Problem

徐寅展论文里的题

Solution

为了叙述方便，不妨称题目中初始给出的赋值操作为第一类操作，赋值操作因为会直接覆盖前面操作的贡献，所以有一定的时间作用区间，那么按时间作用区间处理后得到新的操作，不妨称之为第二类操作。

考虑用线段树先模拟一遍，一个标记会把原来在它子树中的操作无效化，记得下推标记时要把标记分裂。但是这样的操作数就达到了$O(m\log n)$。但如果仔细分析，以操作块数作为势能函数，那么每个操作顶多增加2的势能，所以总的势能其实是$O(m)$的。因此要把子树中相同的操作合并起来。收集标记可以暴力dfs，势能分析可证复杂度上限为$O(m{\log }^{2}n)$。

经过处理后的第二类操作，如果在时间线段树上有交集，则他们必定在空间上无交集。把第二类操作打到时间线段树上去。那么怎么处理询问呢，整体二分？？然后复杂度又变成$O(m{\log }^{3}n)$的了

有一个巧妙的处理方法，询问是一个叶子上的，它的答案都是到根的路径上的操作做的贡献，那么我们就摒弃以前前缀和的方法，单独考虑每个节点。考虑把询问加入到叶子到根上所有点中去，如果我们把每个节点中的操作按照权值排序，那么就只需要用一个数据结构支持区间加和区间求和了！所有的修改和询问总的复杂度为$O(m{\log }^{2}n)$。

综上，时间复杂度为$O(m{\log }^{2}n)$。

好久没打过行数100+的代码了，又有了之前做数据结构码农题时的那种欲生欲死的感觉…

Code

#include <algorithm>
#include <cstdio>
#include <vector>
#define lowbit(x) ((x)&(-(x)))
using namespace std;
typedef long long ll;
const int maxn=100010;
template <typename Tp> inline int getmin(Tp &x,Tp y){return y<x?x=y,1:0;}
template <typename Tp> inline int getmax(Tp &x,Tp y){return y>x?x=y,1:0;}
template <typename Tp> inline void read(Tp &x)
{
    x=0;int f=0;char ch=getchar();
    while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
    if(ch=='-') f=1,ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    if(f) x=-x;
}
int n,m,tm,oc,qc,stk[maxn],ans[maxn];
struct Oper{
	int op,l,r,x,tm;
	bool operator < (const Oper &t)const
	{
		if(x^t.x) return x<t.x;
		return op<t.op;
	}
	Oper operator + (const Oper &t)const
	{
		Oper res=*this;
		getmin(res.l,t.l);getmax(res.r,t.r);
		return res;
	}
}q[maxn<<1],qy[maxn];
struct BIT{
	ll a[maxn],a2[maxn];
	void add(int p,int v){for(int i=p;i<=n;i+=lowbit(i)) a[i]+=v,a2[i]+=(ll)p*v;}
	ll query(int p)
	{
		ll res=0;
		for(int i=p;i;i-=lowbit(i)) res+=(ll)(p+1)*a[i]-a2[i];
		return res;
	}
}bit;
struct TIME_SGT{
	vector<Oper> op[maxn<<3];
	vector<Oper>::iterator itr;
	void update(int l,int r,int L,int R,int rt,Oper t)
	{
		if(L<=l&&r<=R){op[rt].push_back(t);return ;}
		int m=(l+r)>>1;
		if(L<=m) update(l,m,L,R,rt<<1,t);
		if(m<R) update(m+1,r,L,R,rt<<1|1,t);
	}
	void addq(int l,int r,int pos,int rt,Oper t)
	{
		op[rt].push_back(t);
		if(l==r) return ;
		int m=(l+r)>>1;
		if(pos<=m) addq(l,m,pos,rt<<1,t);
		else addq(m+1,r,pos,rt<<1|1,t);
	}
	void dfs(int l,int r,int rt)
	{
		sort(op[rt].begin(),op[rt].end());
		for(itr=op[rt].begin();itr!=op[rt].end();++itr)
		{
			if(!itr->op) bit.add(itr->l,1),bit.add(itr->r+1,-1);
			if(itr->op) ans[itr->tm-n]+=bit.query(itr->r)-bit.query(itr->l-1);
		}
		for(itr=op[rt].begin();itr!=op[rt].end();++itr)
		  if(!itr->op)
		    bit.add(itr->l,-1),bit.add(itr->r+1,1);
		if(l==r) return ;
		int m=(l+r)>>1;
		dfs(l,m,rt<<1);
		dfs(m+1,r,rt<<1|1);
	}
}t;
struct SGT{
	int cnt,sz[maxn<<2],tag[maxn<<2];
	Oper xu[maxn],tmp[maxn<<2];
	void pushdown(int l,int m,int r,int rt)
	{
		tag[rt<<1]=tag[rt<<1|1]=tag[rt];tag[rt]=0;
		sz[rt<<1]=sz[rt<<1|1]=1;
		tmp[rt<<1]=tmp[rt<<1|1]=tmp[rt];tmp[rt]=(Oper){0,0,0,0,0};
		getmin(tmp[rt<<1].r,m);getmax(tmp[rt<<1|1].l,m+1);
	}
	void build(int l,int r,int rt)
	{
		sz[rt]=1;
		if(l==r){tag[rt]=l;tmp[rt]=q[l];return ;}
		int m=(l+r)>>1;
		build(l,m,rt<<1);build(m+1,r,rt<<1|1);
	}
	void dfs(int l,int r,int rt)
	{
		if(!sz[rt]) return ;
		if(tag[rt]){xu[++cnt]=tmp[rt];tag[rt]=0;tmp[rt]=(Oper){0,0,0,0,0};}
		if(l==r){sz[rt]=0;return ;}
		int m=(l+r)>>1;sz[rt]=0;
		dfs(l,m,rt<<1);dfs(m+1,r,rt<<1|1);
	}
	void update(int l,int r,int L,int R,int rt,Oper t)
	{
		if(L<=l&&r<=R)
		{
			dfs(l,r,rt);sz[rt]=1;tag[rt]=t.tm;
			tmp[rt]=t;tmp[rt].l=l;tmp[rt].r=r;
			return ;
		}
		int m=(l+r)>>1;
		if(tag[rt]) pushdown(l,m,r,rt);
		if(L<=m) update(l,m,L,R,rt<<1,t);
		if(m<R) update(m+1,r,L,R,rt<<1|1,t);
		sz[rt]=sz[rt<<1]|sz[rt<<1|1]|tag[rt];
	}
}sgt;
void input()
{
	int op;Oper now;
	read(n);read(m);oc=n;
	for(int i=1;i<=n;i++){read(q[i].x);q[i].l=q[i].r=q[i].tm=i;q[i].op=0;}
	sgt.build(1,n,1);
	for(int i=1;i<=m;i++)
	{
		read(op);
		if(op==1)
		{
			q[++oc].op=0;q[oc].tm=i+n;sgt.cnt=0;
			read(q[oc].l);read(q[oc].r);read(q[oc].x);
			sgt.update(1,n,q[oc].l,q[oc].r,1,q[oc]);
			sgt.xu[++sgt.cnt]=(Oper){0,0,0,0,0};now=sgt.xu[1];
			for(int j=2;j<=sgt.cnt;j++)
			{
				if(sgt.xu[j-1].r+1!=sgt.xu[j].l||sgt.xu[j].tm!=sgt.xu[j-1].tm)
				  t.update(1,n+m,now.tm,n+i-1,1,now),now=sgt.xu[j];
				else now=now+sgt.xu[j];
			}
		}
		if(op==2)
		{
			qy[++qc].op=1;qy[qc].tm=i+n;stk[qc]=i;
			read(qy[qc].l);read(qy[qc].r);read(qy[qc].x);
		}
	}
	sgt.cnt=0;sgt.dfs(1,n,1);sgt.xu[++sgt.cnt]=(Oper){0,0,0,0,0};now=sgt.xu[1];
	for(int j=2;j<=sgt.cnt;j++)
	{
		if(sgt.xu[j-1].r+1!=sgt.xu[j].l||sgt.xu[j].tm!=sgt.xu[j-1].tm)
		  t.update(1,n+m,now.tm,n+m,1,now),now=sgt.xu[j];
		else now=now+sgt.xu[j];
	}
	for(int i=1;i<=qc;i++) t.addq(1,n+m,qy[i].tm,1,qy[i]);
}
int main()
{
	input();
	t.dfs(1,n+m,1);
	for(int i=1;i<=qc;i++) printf("%d\n",ans[stk[i]]);
	return 0;
}