lxl 数据结构杂题选讲
CF793F Julia the snail
考虑扫描线，对于一个 \(l_i,r_i\) ，我们需要的操作就是对左端点在 \([1,l_i]\) 中且大于 \(l_i\) 的答案改为 \(r_i\) ，考虑吉司机线段树的思路，如果区间内只有最大值超过了 \(l_i\) 则暴力修改，否则递归下去，均摊复杂度 \(O(n\log n)\) 。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,m,q;
struct node{
int mx1,mx2,lazy;bool le,ri;
node(int _mx1=0,int _mx2=0,bool _le=0,bool _ri=0){
mx1=_mx1;mx2=_mx2;le=_le;ri=_ri;lazy=0;
}
inline node operator +(node b){
node res;
if(mx1>b.mx1)return node(mx1,max(mx2,b.mx1),1,0);
if(mx1<b.mx1)return node(b.mx1,max(b.mx2,mx1),0,1);
return node(mx1,max(mx2,b.mx2),1,1);
}
}tree[400005];
void build(int l=1,int r=n,int i=1){
if(l==r){
tree[i]=node(l,0,0,0);
return ;
}
int mid=(l+r)>>1;
build(l,mid,i<<1);build(mid+1,r,i<<1|1);
tree[i]=tree[i<<1]+tree[i<<1|1];
}
inline void push(int i){
if(tree[i].le)tree[i<<1].mx1=tree[i<<1].lazy=tree[i].lazy;
if(tree[i].ri)tree[i<<1|1].mx1=tree[i<<1|1].lazy=tree[i].lazy;
tree[i].lazy=0;
}
void update(int fr,int to,int lim,int v,int l=1,int r=n,int i=1){
if(fr>r||to<l||tree[i].mx1<lim)return ;
if(fr<=l&&to>=r&&tree[i].mx2<lim){
tree[i].mx1=tree[i].lazy=v;
return ;
}
if(tree[i].lazy)push(i);
int mid=(l+r)>>1;
update(fr,to,lim,v,l,mid,i<<1);update(fr,to,lim,v,mid+1,r,i<<1|1);
tree[i]=tree[i<<1]+tree[i<<1|1];
}
int query(int loc,int l=1,int r=n,int i=1){
if(loc<l||loc>r)return 0;
if(l==r)return tree[i].mx1;
if(tree[i].lazy)push(i);
int mid=(l+r)>>1;
return query(loc,l,mid,i<<1)+query(loc,mid+1,r,i<<1|1);
}
vector<int> vec[100005];
vector<pair<int,int> > qry[100005];
int ans[100005];
int main(){
scanf("%d",&n);
scanf("%d",&m);
for(int i=1;i<=m;i++){
int l,r;scanf("%d%d",&l,&r);
vec[r].push_back(l);
}
scanf("%d",&q);
for(int i=1;i<=q;i++){
int l,r;scanf("%d%d",&l,&r);
qry[r].push_back(make_pair(l,i));
}
build();
for(int i=1;i<=n;i++){
for(auto it:vec[i])update(1,it,it,i);
for(auto it:qry[i]){
ans[it.second]=query(it.first);
}
}
for(int i=1;i<=q;i++)printf("%d\n",ans[i]);
return 0;
}
CF1446D2 Frequency Problem (Hard Version)
可以证明，这两个出现次数最多的元素中，必定有一个是全局的众数。
考虑答案一定是全局删掉一个前缀和一个后缀。
删除的过程中，全局的众数一定一直为众数，直到出现了一个与其出现次数相等的数。
假设众数 \(x\) 出现次数为 \(a\)，我们目前考虑一个值 \(y\)，计算 \(y\) 与 \(x\) 的答案最大是多少，\(y\) 出现 \(b\) 次。
我们如果得到一个 \(O(a+b)\) 的算法，这个题就是根号题了。
我们要得到一个 \(O(b\times \text{polylog}(n))\) 的算法。
初始将每个 \(x\) 出现的位置标记为无意义的位置。
我们枚举 \(y\) 出现的每个位置，然后找离这些位置最近的 \(x\) 出现的无意义位置（左右两边都找），然后将这些位置标记为有意义的位置。
可以证明标记结束后无意义的位置和答案无关，于是无意义的位置将序列分为多段不相关的区间。
所有有意义的位置，与 \(y\) 出现的位置，这些位置左右 \(1\) 的位置可能是答案端点，所以只有 \(O(b)\) 个可能的答案端点。
考虑为了找出答案端点，我们需要一个数据结构，支持查询前驱与删点。
这个可以使用序列线性并查集来做，对每个 \(y\) 的每个位置，预处理出其前面第一个 \(x\) 出现位置挂上去。
本题还需要支持修改后回退，由于每次修改 \(Ω(\log n)\) 次后才有可能进行一次并查集上的合并，所以复杂度正确。
将 \(x\) 的位置设为 \(1\)，\(y\) 的位置设为 \(-1\)，对有意义的位置跑一个前缀和，维护出和为 \(1,2,…b\) 的最长与最短前缀，这样就可以找出和为 \(0\) 的最长子段，即答案了。
如果区间中出现次数最多的数不是 \(x,y\) 也没关系，因为答案是取 \(\max\) 的，这样只是这个区间中 \(x,y\) 的贡献不够优。
所有数的出现次数和为 \(n\)，故每次的 \(b\) 和是 \(O(n)\) 的，总时间复杂度 \(O(n)\) 。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,s=500;
int a[200005],tot[200005],pre[400005];
int ans;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%d",&a[i]);
for(int i=1;i<=n;i++)tot[a[i]]++;
int Tmp=0;
for(int i=1;i<=n;i++)if(tot[i]>tot[Tmp])Tmp=i;
for(int t=1;t<=n;t++){
if(tot[t]<=s||tot[t]==Tmp)continue;
for(int i=0;i<=2*n;i++)pre[i]=0;
int cnt=0;
for(int i=1;i<=n;i++){
if(a[i]==Tmp)cnt++;
else if(a[i]==t)cnt--;
if(pre[cnt+n]||!cnt)ans=max(ans,i-pre[n+cnt]);
else pre[cnt+n]=i;
}
}
for(int t=1;t<=s;t++){
int cnt=0,L=0;
for(int i=1;i<=n;i++)tot[i]=0;
for(int i=1;i<=n;i++){
tot[a[i]]++;
if(tot[a[i]]==t)cnt++;
while(tot[a[i]]>t){
if(tot[a[L+1]]==t)cnt--;
tot[a[++L]]--;
}
if(cnt>=2)ans=max(ans,i-L);
}
}
printf("%d\n",ans);
return 0;
}
CF1340F Nastya and CBS
本来想用矩阵随机化，但互逆矩阵是满足交换律的，处理不了 )( 的情况。
考虑哈希，对于一个区间，消掉可以匹配的括号，剩下的如果是 ...{]... 的形式，那么剩下的部分一定不合法，因此一个可能合法的区间一定存在一个分界点，使得左边只剩右括号，右边只剩左括号。
用结构体维护一个可加可减的哈希，线段树上每个节点维护它左右两边剩余的部分，合并时要将左儿子的左括号和右儿子的右括号相抵消，对于长的那一侧像《楼房重建》那样递归下去查询即可。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
namespace Hashing{
const int md=1e9+7;
inline int pwr(int x,int y){
int res=1;
while(y){
if(y&1)res=1ll*res*x%md;
x=1ll*x*x%md;y>>=1;
}
return res;
}
const int B=114514,iB=pwr(B,md-2);
int _w[200015],*w=_w+100005;
inline void Init(int N){
w[0]=1;
for(int i=1;i<=N;i++){
w[i]=1ll*w[i-1]*B%md;
w[-i]=1ll*w[-i+1]*iB%md;
}
}
struct str{
int x,m;
str(){x=m=0;}
str(int v){x=v,m=1;}
str(int _x,int _m){x=_x;m=_m;}
inline bool operator ==(str b){
return m==b.m&&x==b.x;
}
inline str operator +(str b){
return str((x+1ll*b.x*w[m])%md,m+b.m);
}
inline str operator -(str b){
return str(1ll*(x-b.x+md)*w[-b.m]%md,m-b.m);
}
};
}
using Hashing::str;
int n,k,q;
struct dat{
bool err;
str vl,vr;
dat(){err=0;}
dat(int x){err=0;x>0?vr=str(x):vl=str(-x);}
}tr[400005];
str GetL(int i,int k){
if(!k)return str();
if(k==tr[i].vl.m)return tr[i].vl;
if(k<=tr[i<<1].vl.m)return GetL(i<<1,k);
return tr[i<<1].vl+(GetL(i<<1|1,k-tr[i<<1].vl.m+tr[i<<1].vr.m)-tr[i<<1].vr);
}
str GetR(int i,int k){
if(!k)return str();
if(k==tr[i].vr.m)return tr[i].vr;
if(k<=tr[i<<1|1].vr.m)return GetR(i<<1|1,k);
return tr[i<<1|1].vr+(GetR(i<<1,k-tr[i<<1|1].vr.m+tr[i<<1|1].vl.m)-tr[i<<1|1].vl);
}
inline void pushup(int i){
if(tr[i<<1].err||tr[i<<1|1].err){
tr[i].err=1;
return ;
}
tr[i].err=0;
tr[i].vl=tr[i<<1].vl;tr[i].vr=tr[i<<1|1].vr;
if(tr[i<<1].vr.m<=tr[i<<1|1].vl.m){
if(tr[i<<1].vr==GetL(i<<1|1,tr[i<<1].vr.m))tr[i].vl=tr[i].vl+(tr[i<<1|1].vl-tr[i<<1].vr);
else tr[i].err=1;
}
else{
if(tr[i<<1|1].vl==GetR(i<<1,tr[i<<1|1].vl.m))tr[i].vr=tr[i].vr+(tr[i<<1].vr-tr[i<<1|1].vl);
else tr[i].err=1;
}
}
void build(int l=1,int r=n,int i=1){
if(l==r){
int x;scanf("%d",&x);
tr[i]=x;
return ;
}
int mid=(l+r)>>1;
build(l,mid,i<<1);build(mid+1,r,i<<1|1);
pushup(i);
}
void update(int loc,int v,int l=1,int r=n,int i=1){
if(loc<l||loc>r)return ;
if(l==r){
tr[i]=v;return ;
}
int mid=(l+r)>>1;
update(loc,v,l,mid,i<<1);update(loc,v,mid+1,r,i<<1|1);
pushup(i);
}
int stk[45], tp;
void Extract(int fr,int to,int l=1,int r=n,int i=1){
if(fr>r||to<l)return ;
if(fr<=l&&to>=r){
stk[++tp]=i;return ;
}
int mid=(l+r)>>1;
Extract(fr,to,l,mid,i<<1);Extract(fr,to,mid+1,r,i<<1|1);
}
str seq[45];
str gVal(int i,int k){
if(!k)return str();
if(k==seq[i].m)return seq[i];
if(k<=tr[stk[i]].vr.m)return GetR(stk[i],k);
return tr[stk[i]].vr+(gVal(i-1,k-tr[stk[i]].vr.m+tr[stk[i]].vl.m)-tr[stk[i]].vl);
}
inline bool query(int l,int r){
tp=0;Extract(l,r);
for(int i=1;i<=tp;i++){
if(tr[stk[i]].err)return 0;
if(seq[i-1].m<tr[stk[i]].vl.m)return 0;
if(tr[stk[i]].vl==gVal(i-1,tr[stk[i]].vl.m))seq[i]=tr[stk[i]].vr+(seq[i-1]-tr[stk[i]].vl);
else return 0;
}
return !seq[tp].m;
}
int main(){
scanf("%d%d",&n,&k);
Hashing::Init(n);
build();
scanf("%d",&q);
while(q--){
int op,x,y;scanf("%d%d%d",&op,&x,&y);
if(op==1)update(x,y);
else puts(query(x,y)?"Yes":"No");
}
return 0;
}
P7290 「EZEC-5」暴力出奇迹
考虑一条竖线段 \((i,a)\) — \((i,b)\) 的贡献，它会对所有 \(x\le i\le y\)，\(a\le j\le b\) 的横线段 \((x,j)\) — \((y,j)\) 加 \(1\) 。
考虑扫描线，沿着 \(x\) 轴扫描，\(\text{KDT}\) 维护，竖线段 \((i,a)\) — \((i,b)\) 相当于平面矩形加，对于询问的 \(x,y,l,r\) ，在 \(l\) 处将询问 \((x,y)\) 插入 \(\text{KDT}\) 中，在 \(r\) 处删除，并查询这个点从插入到删除过程中的历史最大值。
时间复杂度 \(O(n\sqrt m+m\log m)\) 。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,m,key;
vector<pair<int,int> > vec[2000005];
struct node{
int x[2],lx,rx,ly,ry,id;
node(int _x=0,int _y=0,int _id=0){
x[0]=lx=rx=_x;x[1]=ly=ry=_y;id=_id;
}
inline bool operator <(const node &b)const{
return x[key]<b.x[key];
}
}a[2000005],tree[2000005];
int le[2000005],ri[2000005],cnt,fa[2000005],mp[2000005];
int build(int l=1,int r=m,int _=0,int fi=0){
if(l>r)return 0;
int mid=(l+r)>>1,i=++cnt;key=_;fa[i]=fi;
nth_element(a+l,a+mid,a+r+1);tree[i]=a[mid];mp[a[mid].id]=i;
le[i]=build(l,mid-1,_^1,i);ri[i]=build(mid+1,r,_^1,i);
if(le[i]){
tree[i].lx=min(tree[i].lx,tree[le[i]].lx);tree[i].ly=min(tree[i].ly,tree[le[i]].ly);
tree[i].rx=max(tree[i].rx,tree[le[i]].rx);tree[i].ry=max(tree[i].ry,tree[le[i]].ry);
}
if(ri[i]){
tree[i].lx=min(tree[i].lx,tree[ri[i]].lx);tree[i].ly=min(tree[i].ly,tree[ri[i]].ly);
tree[i].rx=max(tree[i].rx,tree[ri[i]].rx);tree[i].ry=max(tree[i].ry,tree[ri[i]].ry);
}
// cout<<"build "<<" "<<tree[i].id<<" ["<<tree[i].lx<<" "<<tree[i].rx<<"] ["<<tree[i].ly<<" "<<tree[i].ry<<"]"<<endl;
return i;
}
int mx[2000005],hmx[2000005],lazy[2000005],hlazy[2000005];
inline void add(int i,int v,int hv){
hmx[i]=max(hmx[i],mx[i]+hv);hlazy[i]=max(hlazy[i],lazy[i]+hv);
mx[i]+=v;lazy[i]+=v;
}
inline void push(int i){
if(lazy[i]||hlazy[i]){
add(le[i],lazy[i],hlazy[i]);add(ri[i],lazy[i],hlazy[i]);
lazy[i]=hlazy[i]=0;
}
}
void update(int loc,int v,int i=1){
if(!i||tree[i].lx>loc||tree[i].ry<loc)return ;
if(tree[i].rx<=loc&&tree[i].ly>=loc){
// cout<<"add "<<loc<<" "<<v<<" "<<tree[i].id<<" ["<<tree[i].lx<<" "<<tree[i].rx<<"] ["<<tree[i].ly<<" "<<tree[i].ry<<"]"<<endl;
add(i,v,v);return ;
}
if(tree[i].x[0]<=loc&&tree[i].x[1]>=loc){
// cout<<"add "<<loc<<" "<<v<<" "<<tree[i].id<<" ["<<tree[i].x[0]<<"] ["<<tree[i].x[1]<<"]"<<endl;
mx[i]+=v;hmx[i]=max(hmx[i],mx[i]);
}push(i);
update(loc,v,le[i]);
update(loc,v,ri[i]);
}
int stk[2000005];
inline void insert(int id){
int top=0;
for(int i=mp[id];i;i=fa[i])stk[++top]=i;
while(top)push(stk[top--]);
int x=mp[id];hmx[x]=mx[x];
// cout<<"insert "<<id<<" "<<hmx[fa[id].back()]<<endl;
}
inline int query(int id){
int top=0;
for(int i=mp[id];i;i=fa[i])stk[++top]=i;
while(top)push(stk[top--]);
return hmx[mp[id]];
}
vector<int> Be[2000005],Ed[2000005];
int ans[2000005];
inline int read(){
int res=0;char c=getchar();
while(c<'0'||c>'9')c=getchar();
while(c>='0'&&c<='9')res=10*res+c-'0',c=getchar();
return res;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
int a,b;a=read();b=read();
vec[a].push_back(make_pair(i,1));
vec[b+1].push_back(make_pair(i,-1));
}
scanf("%d",&m);
for(int i=1;i<=m;i++){
int l,r,x,y;l=read();r=read();x=read();y=read();
a[i]=node(x,y,i);
Be[l].push_back(i);
Ed[r].push_back(i);
}
build();
for(int i=1;i<=n;i++){
for(auto it:vec[i])update(it.first,it.second);
for(auto it:Be[i])insert(it);
for(auto it:Ed[i])ans[it]=query(it);
}
for(int i=1;i<=m;i++)printf("%d\n",ans[i]);
return 0;
}
[Ynoi2008] rdCcot
考虑对每个联通块维护一个代表元素，然后做扫描线。
每个点向深度比它小的点匹配，深度相同时编号小的点优先，容易发现这样一来每个联通块有且仅有一个元素匹配不到点，它就是我们需要的代表元素。
点分治对于每个点 \(x\) 预处理出 \(L_x=\max_{i<x,dist(i,x)\le C}\limits i\) 和 \(R_x=\min_{i>x,dist(i,x)\le C}\limits i\) ，询问 \(l,r\) 查询的就是 \(\sum_{i\in[l,r]}\limits[L_i<l]\cdot[R_i>r]\)，扫描线即可。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,m,C;
int ver[600005],ne[600005],head[300005],cnt;
inline void link(int x,int y){
ver[++cnt]=y;
ne[cnt]=head[x];
head[x]=cnt;
}
int dep[300005];
void init(int x,int fi){
dep[x]=dep[fi]+1;
for(int i=head[x];i;i=ne[i]){
int u=ver[i];
if(u==fi)continue;
init(u,x);
}
}
int val[300005],tree[300005],le[300005],ri[300005],rk[300005];
inline void build(){
for(int i=1;i<=n;i++)rk[i]=i;
random_shuffle(rk+1,rk+n+1);
}
inline void pushup(int x){
tree[x]=max(val[x],max(tree[le[x]],tree[ri[x]]));
}
int merge(int x,int y){
if(!x||!y)return x|y;
if(rk[x]>rk[y]){
ri[x]=merge(ri[x],y);pushup(x);
return x;
}
le[y]=merge(x,le[y]);pushup(y);
return y;
}
void split(int x,int v,int &a,int &b){
if(!x){a=0;b=0;return ;}
if(x<=v){
split(ri[x],v,ri[x],b);
a=x;
}
else {
split(le[x],v,a,le[x]);
b=x;
}pushup(x);
}
int Rt;
int Getpre(int x,int v){
if(!x)return 0;
if(ri[x]&&tree[ri[x]]>=v)return Getpre(ri[x],v);
else if(val[x]>=v)return x;
return Getpre(le[x],v);
}
int Getnxt(int x,int v){
if(!x)return n+1;
if(le[x]&&tree[le[x]]>=v)return Getnxt(le[x],v);
else if(val[x]>=v)return x;
return Getnxt(ri[x],v);
}
int siz[300005],mxp[300005],rt;
bool vis[300005];
void findrt(int x,int fi,int tot){
siz[x]=1;mxp[x]=0;
for(int i=head[x];i;i=ne[i]){
int u=ver[i];
if(vis[u]||u==fi)continue;
findrt(u,x,tot);siz[x]+=siz[u];
mxp[x]=max(mxp[x],siz[u]);
}
mxp[x]=max(mxp[x],tot-siz[x]);
if(mxp[x]<mxp[rt])rt=x;
}
vector<pair<int,int> > tmp;
int dis[300005];
void dfs(int x,int fi){
tmp.push_back(make_pair(dep[x],x));
for(int i=head[x];i;i=ne[i]){
int u=ver[i];
if(vis[u]||u==fi)continue;
dis[u]=dis[x]+1;dfs(u,x);
}
}
int L[300005],R[300005];
void solve(int x){
vis[x]=1;tmp.clear();dis[x]=0;dfs(x,x);
sort(tmp.begin(),tmp.end());
for(auto it:tmp){
if(dis[it.second]>C)continue;
int a=0,b=0;split(Rt,it.second,a,b);
L[it.second]=max(L[it.second],Getpre(a,dis[it.second]));
R[it.second]=min(R[it.second],Getnxt(b,dis[it.second]));
tree[it.second]=val[it.second]=C-dis[it.second];le[it.second]=ri[it.second]=0;
Rt=merge(merge(a,it.second),b);
}
Rt=0;
for(int i=head[x];i;i=ne[i]){
int u=ver[i];
if(vis[u])continue;
mxp[rt=0]=n;findrt(u,x,siz[u]);
solve(rt);
}
}
int seg[300005];
inline void add(int x,int v){
while(x<=n+1){
seg[x]+=v;
x+=(x&-x);
}
}
inline int query(int x){
int res=0;
assert(x>=0);
while(x){
res+=seg[x];
x&=(x-1);
}
return res;
}
int ans[600005];
vector<pair<int,int> > vec[300005],qry[300005];
inline int read(){
int res=0;char c=getchar();
while(c<'0'||c>'9')c=getchar();
while(c>='0'&&c<='9')res=10*res+c-'0',c=getchar();
return res;
}
int main(){
scanf("%d%d%d",&n,&m,&C);
for(int i=2;i<=n;i++){
int x;x=read();
link(i,x);link(x,i);
}
init(1,1);
build();
for(int i=1;i<=n;i++)R[i]=n+1;
mxp[rt=0]=n;findrt(1,1,n);solve(rt);
for(int i=1;i<=m;i++){
int l,r;l=read();r=read();
qry[r].push_back(make_pair(l,i));
qry[l-1].push_back(make_pair(l,-i));
}
for(int i=1;i<=n;i++)assert(i<R[i]);
for(int i=1;i<=n;i++){
vec[i].push_back(make_pair(L[i]+1,1));
vec[i].push_back(make_pair(i+1,-1));
vec[R[i]].push_back(make_pair(L[i]+1,-1));
vec[R[i]].push_back(make_pair(i+1,1));
}
for(int i=1;i<=n;i++){
for(auto it:vec[i])add(it.first,it.second);
for(auto it:qry[i]){
ans[it.second]+=query(it.first);
}
}
for(int i=1;i<=m;i++)printf("%d\n",ans[i]);
return 0;
}
P6072 『MdOI R1』Path
我们以 \(1\) 为根，定义 \(a_x\) 为从 \(x\) 到 \(1\) 边权的异或值，\(in_x\) 和 \(out_x\) 为 \(x\) 子树内部和外部选择 \(u\) 和 \(v\) 中 \(a_u\oplus a_v\) 的最大值，那么最后答案显然为 \(\max_{x\ne1}\{in_x+out_x\}\) 。
对于求 \(in_x\) 我们有很多做法，例如启发式合并，\(\text{dsu on tree}\)，或者可持久化 \(\text{trie}\)，需要 \(O(n\log n\log\max w)\) 的时间。
对于求 \(out_x\) ，我们不妨先找到任意两个点 \(p\) 和 \(q\)，使得 \(a_p\oplus a_q\) 最大，这时不以这个点对为最大值的只有 \(p\) 到根上的所有点，和 \(q\) 到根上的所有点。考虑我们只求树上一条链 \(out_x\) ，加入我们按照顺序遍历 到 \(x\)，只需要将 \(x\) 父亲的子树内除去 \(x\) 子树部分加入 \(\text{trie}\) 即可。这一部分复杂度 \(O(n\log \max w)\) 。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,m,i,j,k,tot,totq,p=1,trie_tot=1,SZ,Ans;
int dfn[60005],siz[60005],bel[60005],dis[60005];
int fir[60005],we[120005],to[120005],nxt[120005];
int ch[1800005][2],tag[1800005],ans[60005];
struct ques {
int l,r,id;
ques(){ l=r=id=0;}
ques(int _l,int _r,int i){
l=_l,r=_r,id=i;
}
inline friend bool operator<(ques a,ques b){
if(bel[a.l]==bel[b.l])return a.r<b.r;
else return bel[a.l]<bel[b.l];
}
} q[120005];
inline void link(int u,int v,int w){
static int ce=0;
to[++ce]=v,we[ce]=w,nxt[ce]=fir[u],fir[u]=ce;
}
inline void insert(int a){
int u=1;
for(int i=30;i>=0;i--){
bool v=(a>>i)&1;
if(!ch[u][v])ch[u][v]=++trie_tot;
u=ch[u][v];tag[u]++;
}
}
inline int query(int a){
int u=1,res=0;
for(int i=30;i>=0;i--){
bool v=(a>>i)&1;
if(tag[ch[u][v^1]])res|=1<<i,u=ch[u][v^1];
else u=ch[u][v];
}
return res;
}
inline void del(int a){
int u=1;
for(int i=30;i>=0;i--){
bool v=(a>>i)&1;
u=ch[u][v];
tag[u]--;
}
}
void dfs(int u,int par,int w){
siz[u]=1,dfn[u]=++tot,dis[dfn[u]]=dis[dfn[par]]^w;
for(int i=fir[u],v;i;i=nxt[i]){
if((v=to[i])!=par){
int w=we[i];
dfs(v,u,w);
siz[u]+=siz[v];
}
}
}
inline int calc(int l,int r){
int res=0;
for(int i=l;i<=r;i++)res=max(res,query(dis[i])),insert(dis[i]);
for(int i=l;i<=r;i++)del(dis[i]);
return res;
}
inline void solve(int x){
int br=min(x*SZ,n),l=br+1,r=br;
int _ans=0;
for(;bel[q[p].l]==x;p++){
int ql=q[p].l,qr=q[p].r;
if(bel[qr]==x){ans[q[p].id]+=calc(ql,qr);continue;}
while(r<qr)_ans=max(_ans,query(dis[++r])),insert(dis[r]);
int rev=_ans;
while(l>ql)_ans=max(_ans,query(dis[--l])),insert(dis[l]);
ans[q[p].id]+=_ans;
while(l<=br)del(dis[l++]);_ans=rev;
}
while(r>br)del(dis[r--]);
}
int main(){
scanf("%d",&n);
for(int i=1;i<n;i++){
int u,v,w;scanf("%d%d%d",&u,&v,&w);
link(u,v,w),link(v,u,w);
}
dfs(1,0,0);
for(int i=2;i<=n;i++)q[++totq]=ques(dfn[i],dfn[i]+siz[i]-1,i),q[++totq]=ques(dfn[i]+siz[i],dfn[i]+n-1,i);
for(int i=1;i<=n;i++)dis[i+n]=dis[i];
n<<=1;SZ=sqrt(n);
for(int i=1;i<=n;i++)bel[i]=(i-1)/ SZ+1;
sort(q+1,q+totq+1);
for(int i=1;i<=bel[n];i++)solve(i);
for(int i=1;i<=n;i++)Ans=max(Ans,ans[i]);
printf("%d\n",Ans);
return 0;
}
[Ynoi2006] rldcot
考虑扫描线，每次加入一个点 \(x\) 时将这个点到根的路径上标记上 \(x\) ，如果有某一段之前被标过号 \(y\) 了，那么这一段的底端就是点 \(x\) 和 \(y\) 的 \(\text{lca}\) ，用 \(y\) 更新一下这个点深度最后出现的位置即可，时间复杂度 \(O(n\log^2 n)\) 。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,m;
int ver[200005],ne[200005],head[100005],cnt,len[200005];
inline void link(int x,int y,int v){
ver[++cnt]=y;
ne[cnt]=head[x];
head[x]=cnt;len[cnt]=v;
}
long long dep[100005];
int fa[100005];
void dfs(int x,int fi){
fa[x]=fi;
for(int i=head[x];i;i=ne[i]){
int u=ver[i];
if(u==fi)continue;
dep[u]=dep[x]+len[i];
dfs(u,x);
}
}
vector<long long> hsh;
int son[2][100005],val[100005],lazy[100005];
inline bool isroot(int x){
return son[0][fa[x]]!=x&&son[1][fa[x]]!=x;
}
inline void push(int x){
if(lazy[x]){
val[son[0][x]]=lazy[son[0][x]]=lazy[x];
val[son[1][x]]=lazy[son[1][x]]=lazy[x];
}
lazy[x]=0;
}
inline void rotate(int x){
int y=fa[x],z=fa[y];
if(!isroot(y))son[son[1][z]==y][z]=x;
bool is=(son[1][y]==x);
son[is][y]=son[!is][x];fa[son[!is][x]]=y;
son[!is][x]=y;fa[y]=x;fa[x]=z;
}
int stk[100005],top;
inline void splay(int x){
stk[++top]=x;
for(int i=x;!isroot(i);i=fa[i])stk[++top]=fa[i];
while(top)push(stk[top--]);
while(!isroot(x)){
int y=fa[x],z=fa[y];
if(!isroot(y)){
if((son[1][z]==y)^(son[1][y]==z))rotate(x);
else rotate(y);
}rotate(x);
}
}
int pre[100005],tree[100005];
inline void add(int x,int v){
while(x){
tree[x]+=v;
x&=(x-1);
}
}
inline int query(int x){
int res=0;
while(x<=n){
res+=tree[x];
x+=(x&-x);
}
return res;
}
inline void access(int x){
int tmp=x,i=0;
add(pre[dep[x]],-1);pre[dep[x]]=x;add(pre[dep[x]],1);
while(x){
splay(x);add(pre[dep[x]],-1);
pre[dep[x]]=max(pre[dep[x]],val[x]);add(pre[dep[x]],1);
son[1][x]=i;i=x;x=fa[x];
}
val[i]=lazy[i]=tmp;
}
int ans[500005];
vector<pair<int,int> > vec[100005];
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<n;i++){
int x,y,v;scanf("%d%d%d",&x,&y,&v);
link(x,y,v);link(y,x,v);
}
dfs(1,0);
for(int i=1;i<=n;i++)hsh.push_back(dep[i]);
sort(hsh.begin(),hsh.end());hsh.erase(unique(hsh.begin(),hsh.end()),hsh.end());
for(int i=1;i<=n;i++)dep[i]=upper_bound(hsh.begin(),hsh.end(),dep[i])-hsh.begin();
for(int i=1;i<=m;i++){
int l,r;scanf("%d%d",&l,&r);
vec[r].push_back(make_pair(l,i));
}
for(int i=1;i<=n;i++){
access(i);
for(auto it:vec[i])ans[it.second]=query(it.first);
}
for(int i=1;i<=m;i++)printf("%d\n",ans[i]);
return 0;
}
P6071 『MdOI R1』Treequery
给定一个点 \(x\) ，询问 \(x\) 到 \([l,r]\) 内的点组成的虚树的距离，对于点 \(x\) 与虚树 \([l,r]\) 的关系分类讨论即可。
如果 \([l,r]\) 一部分在 \(x\) 子树内，一部分在子树外，答案为 \(0\) 。
如果 \([l,r]\) 全部在 \(x\) 子树内，答案为点 \(x\) 到 \([l,r]\) 的 \(\text{lca}\) 的距离。
如果 \([l,r]\) 全部在 \(x\) 子树外，答案为点 \(x\) 到其在 \([l,r]\) 内 \(\text{dfs}\) 序上的前驱和后继的之间的链的距离。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,q;
int ver[400005],ne[400005],head[400005],tot,val[400005];
inline void link(int x,int y,int v){
ver[++tot]=y;
ne[tot]=head[x];
head[x]=tot;val[tot]=v;
}
int siz[200005],son[200005],fa[200005];
long long dep[200005];
void dfs1(int x,int fi){
siz[x]=1;fa[x]=fi;
for(int i=head[x];i;i=ne[i]){
int u=ver[i];
if(u==fi)continue;
dep[u]=dep[x]+val[i];
dfs1(u,x);siz[x]+=siz[u];
if(siz[u]>siz[son[x]])son[x]=u;
}
}
int dfn[200005],cnt,top[200005],mp[200005];
void dfs2(int x,int fi){
dfn[x]=++cnt;top[x]=fi;mp[cnt]=x;
if(son[x])dfs2(son[x],fi);
for(int i=head[x];i;i=ne[i]){
int u=ver[i];
if(u==fa[x]||u==son[x])continue;
dfs2(u,u);
}
}
inline int lca(int x,int y){
while(top[x]!=top[y]){
if(dep[top[x]]>=dep[top[y]])x=fa[top[x]];
else y=fa[top[y]];swap(x,y);
}return dep[x]<dep[y]?x:y;
}
inline long long dist(int x,int y){
int lc=lca(x,y);
return dep[x]+dep[y]-2*dep[lc];
}
int tree[4000005],rt[200005],le[4000005],ri[4000005];
int insert(int loc,int old,int l=1,int r=n){
if(loc<l||loc>r)return old;
int i=++cnt;tree[i]=tree[old]+1;
if(l==r)return i;
int mid=(l+r)>>1;
le[i]=insert(loc,le[old],l,mid);ri[i]=insert(loc,ri[old],mid+1,r);
return i;
}
int query(int fr,int to,int a,int b,int l=1,int r=n){
if(fr>r||to<l)return 0;
if(fr<=l&&to>=r)return tree[b]-tree[a];
int mid=(l+r)>>1;
return query(fr,to,le[a],le[b],l,mid)+query(fr,to,ri[a],ri[b],mid+1,r);
}
int find(int k,int a,int b,int l=1,int r=n){
if(l==r)return mp[l];
int mid=(l+r)>>1;
if(tree[le[b]]-tree[le[a]]>=k)return find(k,le[a],le[b],l,mid);
return find(k-tree[le[b]]+tree[le[a]],ri[a],ri[b],mid+1,r);
}
long long lstans;
int main(){
scanf("%d%d",&n,&q);
for(int i=1;i<n;i++){
int x,y,v;scanf("%d%d%d",&x,&y,&v);
link(x,y,v);link(y,x,v);
}
dfs1(1,1);dfs2(1,1);
for(int i=1;i<=n;i++)rt[i]=insert(dfn[i],rt[i-1]);
while(q--){
int x,l,r;scanf("%d%d%d",&x,&l,&r);
x^=lstans;l^=lstans;r^=lstans;
int tmp=query(dfn[x],dfn[x]+siz[x]-1,rt[l-1],rt[r]);
if(tmp==r-l+1){
int rk1=query(1,dfn[x]-1,rt[l-1],rt[r])+1,rk2=rk1+tmp-1;
rk1=find(rk1,rt[l-1],rt[r]);rk2=find(rk2,rt[l-1],rt[r]);
lstans=dist(lca(rk1,rk2),x);
}
else if(!tmp){
int rk1=query(1,dfn[x]-1,rt[l-1],rt[r]),rk2=(rk1!=r-l+1?rk1+1:0);
if(rk1)rk1=find(rk1,rt[l-1],rt[r]);if(rk2)rk2=find(rk2,rt[l-1],rt[r]);
if(rk1&&rk2)lstans=min(dep[x]-dep[lca(x,rk1)],dep[x]-dep[lca(x,rk2)]);
else {
int pre=find(1,rt[l-1],rt[r]),suf=find(r-l+1,rt[l-1],rt[r]);
if(rk1){
lstans=dist(x,lca(pre,rk1));
int t=lca(x,rk1);
if(dist(pre,rk1)==dist(pre,t)+dist(t,rk1))lstans=min(lstans,dep[x]-dep[t]);
}
else if(rk2){
lstans=dist(x,lca(suf,rk2));
int t=lca(x,rk2);
if(dist(suf,rk2)==dist(suf,t)+dist(t,rk2))lstans=min(lstans,dep[x]-dep[t]);
}
}
}
else {
lstans=0;
}
printf("%lld\n",lstans);
}
return 0;
}
[Ynoi2008] rrusq
考虑扫描线，对于每个点 \((i,p_i)\) 记录它最晚被覆盖到的时间，我们需要做的就是批量更新一个矩形内的点，并维护在每个时间点被覆盖的点的权值和。
对点建出 \(\text{KDT}\) , 每次询问在 \(\text{KDT}\) 上打标记并把子树内的所有标记收回。因为收回标记对应着打标记，所以复杂度仍然是 \(\Theta(m)\) 次遍历 \(\text{KDT}\) 的复杂度 , 即 \(\Theta(m\sqrt n)\) 次打标记/收回标记的操作。
现在我们要完成的问题变成了支持 \(\Theta(m\sqrt n)\) 次单点修改和 \(\Theta(m)\) 次后缀查询的数据结构 , 不难发现可以用 \(\Theta(1)-\Theta(\sqrt m)\) 的分块来实现它。
时间复杂度 \(\Theta(n\sqrt m+m\sqrt n)\) , 空间复杂度 \(\Theta(n+m)\) 。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,m,q,key;
struct node{
int x[2],v,sum;
int lx,rx,ly,ry;
node(int _x=0,int _y=0,int _v=0){
lx=rx=x[0]=_x;ly=ry=x[1]=_y;sum=v=_v;
}
inline bool operator <(const node &b)const{
return x[key]<b.x[key];
}
}a[100005],tree[100005];
int le[100005],ri[100005],cnt;
int build(int l=1,int r=n,int _=0){
if(l>r)return 0;
int i=++cnt,mid=(l+r)>>1;key=_;
nth_element(a+l,a+mid,a+r+1);tree[i]=a[mid];
le[i]=build(l,mid-1,_^1);ri[i]=build(mid+1,r,_^1);
if(le[i]){
tree[i].lx=min(tree[i].lx,tree[le[i]].lx);tree[i].ly=min(tree[i].ly,tree[le[i]].ly);
tree[i].rx=max(tree[i].rx,tree[le[i]].rx);tree[i].ry=max(tree[i].ry,tree[le[i]].ry);
tree[i].sum+=tree[le[i]].sum;
}
if(ri[i]){
tree[i].lx=min(tree[i].lx,tree[ri[i]].lx);tree[i].ly=min(tree[i].ly,tree[ri[i]].ly);
tree[i].rx=max(tree[i].rx,tree[ri[i]].rx);tree[i].ry=max(tree[i].ry,tree[ri[i]].ry);
tree[i].sum+=tree[ri[i]].sum;
}
return i;
}
int col[100005],tag[100005],lazy[100005];
inline void push(int i){
if(lazy[i]){
col[le[i]]=tag[le[i]]=lazy[le[i]]=lazy[i];
col[ri[i]]=tag[ri[i]]=lazy[ri[i]]=lazy[i];
}
lazy[i]=0;
}
inline void pushup(int i){
tag[i]=col[i];
if(le[i]&&tag[le[i]]!=tag[i])tag[i]=-1;
if(ri[i]&&tag[ri[i]]!=tag[i])tag[i]=-1;
}
namespace Block{
int s=500,sqr[100005],le[100005],ri[100005];
int a[100005],tot[505];
inline void init(){
for(int i=1;i<=m;i++)sqr[i]=i/s+1;
for(int i=1;i<=m;i++)ri[sqr[i]]=i;
for(int i=m;i>=1;i--)le[sqr[i]]=i;
}
inline void add(int x,int v){
a[x]+=v;tot[sqr[x]]+=v;
}
inline int query(int l,int r){
int res=0;
for(int i=l;i<=ri[sqr[l]]&&i<=r;i++)res+=a[i];
if(sqr[l]==sqr[r])return res;
for(int i=sqr[l]+1;i<sqr[r];i++)res+=tot[i];
for(int i=le[sqr[r]];i<=r;i++)res+=a[i];
return res;
}
}
void update(int lx,int rx,int ly,int ry,int v,int i=1){
if(!i||rx<tree[i].lx||lx>tree[i].rx||ry<tree[i].ly||ly>tree[i].ry)return ;
if(~tag[i]&&lx<=tree[i].lx&&tree[i].rx<=rx&&ly<=tree[i].ly&&tree[i].ry<=ry){
Block::add(tag[i],-tree[i].sum);
col[i]=tag[i]=lazy[i]=v;
Block::add(tag[i],tree[i].sum);return ;
}push(i);
if(lx<=tree[i].x[0]&&tree[i].x[0]<=rx&&ly<=tree[i].x[1]&&tree[i].x[1]<=ry){
Block::add(col[i],-tree[i].v);
col[i]=tag[i]=v;
Block::add(col[i],tree[i].v);
}
update(lx,rx,ly,ry,v,le[i]);
update(lx,rx,ly,ry,v,ri[i]);
pushup(i);
}
int X1[100005],X2[100005],Y1[100005],Y2[100005];
vector<pair<int,int> > vec[100005];
int ans[1000005];
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
int x,v;scanf("%d%d",&x,&v);
a[i]=node(i,x,v);
}
build();
scanf("%d",&m);Block::init();
for(int i=1;i<=m;i++)scanf("%d%d%d%d",&X1[i],&X2[i],&Y1[i],&Y2[i]);
scanf("%d",&q);
for(int i=1;i<=q;i++){
int l,r;scanf("%d%d",&l,&r);
vec[r].push_back(make_pair(l,i));
}
for(int i=1;i<=m;i++){
update(X1[i],X2[i],Y1[i],Y2[i],i);
for(auto it:vec[i]){
ans[it.second]=Block::query(it.first,i);
}
}
for(int i=1;i<=q;i++)printf("%d\n",ans[i]);
return 0;
}
转转的数据结构题
考虑扫描线，\(\text{ODT}\) 维护序列上的连续段，树状数组维护每次操作剩余的对序列的贡献。
点击查看代码
[Ynoi2009] rprmq1
考虑扫描线，因为这个信息不具有可减性，考虑对平面进行分治，每次分治的时候，处理跨过分治中线的询问。
这样一来就把询问拆成了分治中线两侧的一个前缀和一个后缀。
然后我们只需对两边分别做扫描线，维护扫过部分的历史最大值即可，为了让分治的复杂度正确，可以和莫队类似，试着利用之前的信息。
图中是分治的过程，其中红线表示撤回一些修改，并将历史最值设为当前值。后者打标记即可，不过打标记之前要将节点原有的加法标记下传.
否则如果它的加法标记为负数，这个标记将无法加到其子节点的历史最值上。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,m,q;
long long mx[400005],hmx[400005],lazy[400005],hlazy[400005];
bool cov[400005];
inline void add(int i,long long v,long long hv){
hlazy[i]=max(hlazy[i],lazy[i]+hv);
hmx[i]=max(hmx[i],mx[i]+hv);mx[i]+=v;lazy[i]+=v;
}
inline void reset(int i){
if(lazy[i]||hlazy[i]){
add(i<<1,lazy[i],lazy[i]);add(i<<1|1,lazy[i],lazy[i]);
lazy[i]=hlazy[i]=0;
}
hmx[i]=mx[i];hlazy[i]=lazy[i];cov[i]=1;
}
inline void push(int i){
if(cov[i]){
reset(i<<1);reset(i<<1|1);
cov[i]=0;
}
if(lazy[i]||hlazy[i]){
add(i<<1,lazy[i],hlazy[i]);add(i<<1|1,lazy[i],hlazy[i]);
lazy[i]=hlazy[i]=0;
}
}
void update(int fr,int to,long long v,int l=1,int r=n,int i=1){
if(fr>r||to<l)return ;
if(fr<=l&&to>=r){
add(i,v,v);return ;
}
int mid=(l+r)>>1;push(i);
update(fr,to,v,l,mid,i<<1);update(fr,to,v,mid+1,r,i<<1|1);
mx[i]=max(mx[i<<1],mx[i<<1|1]);
hmx[i]=max(hmx[i<<1],hmx[i<<1|1]);
}
long long query(int fr,int to,int l=1,int r=n,int i=1){
if(fr>r||to<l)return -1e18;
if(fr<=l&&to>=r)return hmx[i];
int mid=(l+r)>>1;push(i);
return max(query(fr,to,l,mid,i<<1),query(fr,to,mid+1,r,i<<1|1));
}
struct data{
int l,r,v;
data(int _l,int _r,int _v){
l=_l;r=_r;v=_v;
}
};
vector<data> L[50005],R[50005];
int le[500005],ri[500005],up[500005],down[500005];
long long ans[500005];
vector<int> qryl[50005],qryr[50005];
void solve(int l,int r,int mid){
// cout<<"solve "<<l<<" "<<r<<" "<<mid<<endl;
for(int i=mid;i>=l;i--){
for(auto it:R[i])update(it.l,it.r,it.v);
for(auto it:qryl[i]){
if(ri[it]>=mid&&ri[it]<=r)ans[it]=max(ans[it],query(down[it],up[it]));
//,cout<<"ri "<<it<<" "<<ans[it]<<endl;
}
for(auto it:L[i])update(it.l,it.r,-it.v);
}
if(l!=r){
int midl=(l+mid)>>1;
for(int i=l;i<=midl;i++){
for(auto it:R[i])update(it.l,it.r,-it.v);
for(auto it:L[i])update(it.l,it.r,it.v);
}
hmx[1]=mx[1];hlazy[1]=lazy[1];cov[1]=1;
solve(l,mid,midl);
for(int i=midl+1;i<=mid;i++){
for(auto it:R[i])update(it.l,it.r,-it.v);
for(auto it:L[i])update(it.l,it.r,it.v);
}
hmx[1]=mx[1];hlazy[1]=lazy[1];cov[1]=1;
}
else {
for(int i=l;i<=mid;i++){
for(auto it:R[i])update(it.l,it.r,-it.v);
for(auto it:L[i])update(it.l,it.r,it.v);
}
hmx[1]=mx[1];hlazy[1]=lazy[1];cov[1]=1;
}
for(int i=mid+1;i<=r;i++){
for(auto it:L[i])update(it.l,it.r,it.v);
for(auto it:qryr[i]){
if(le[it]<=mid+1&&le[it]>=l)ans[it]=max(ans[it],query(down[it],up[it]));
//,cout<<"le "<<it<<" "<<ans[it]<<endl;
}
for(auto it:R[i])update(it.l,it.r,-it.v);
}
if(l!=r){
int midr=(mid+1+r)>>1;
for(int i=r;i>midr;i--){
for(auto it:L[i])update(it.l,it.r,-it.v);
for(auto it:R[i])update(it.l,it.r,it.v);
}
hmx[1]=mx[1];hlazy[1]=lazy[1];cov[1]=1;
solve(mid+1,r,midr);
for(int i=midr;i>mid;i--){
for(auto it:L[i])update(it.l,it.r,-it.v);
for(auto it:R[i])update(it.l,it.r,it.v);
}
hmx[1]=mx[1];hlazy[1]=lazy[1];cov[1]=1;
}
else {
for(int i=r;i>=mid+1;i--){
for(auto it:L[i])update(it.l,it.r,-it.v);
for(auto it:R[i])update(it.l,it.r,it.v);
}
hmx[1]=mx[1];hlazy[1]=lazy[1];cov[1]=1;
}
// cout<<"solved "<<l<<" "<<r<<" "<<mid<<endl;
}
inline int read(){
int res=0;char c=getchar();
while(c<'0'||c>'9')c=getchar();
while(c>='0'&&c<='9')res=10*res+c-'0',c=getchar();
return res;
}
int main(){
scanf("%d%d%d",&n,&m,&q);
for(int i=1;i<=m;i++){
int l1,l2,r1,r2,v;l1=read();l2=read();r1=read();r2=read();v=read();
L[l1].push_back(data(l2,r2,v));
R[r1].push_back(data(l2,r2,v));
}
for(int i=1;i<=q;i++){
le[i]=read();down[i]=read();ri[i]=read();up[i]=read();
qryl[le[i]].push_back(i);
qryr[ri[i]].push_back(i);
}
int mid=(1+n)>>1;
for(int i=1;i<=mid;i++){
for(auto it:L[i])update(it.l,it.r,it.v);
for(auto it:R[i])update(it.l,it.r,-it.v);
}
hmx[1]=mx[1];hlazy[1]=lazy[1];cov[1]=1;
solve(1,n,mid);
for(int i=1;i<=q;i++)printf("%lld\n",ans[i]);
return 0;
}
[Ynoi2008] rupq
使用平衡树维护序列，这样可以支持分裂合并。
虽然 \(\text{NAND}\) 没有结合律，但是可以维护它的真值表，使得 \(\max\) 和 \(\text{NAND}\) 都可以写做半群信息的形式，所以直接 \(O(1)\) 合并即可，每个区间的括号合并完成后应该是形如 ))))(((( 的样子。
考虑怎么合并两个儿子的信息，不失一般性，设左儿子的 ( 数量多于右儿子的 ) 数量，其它的情况类似。
那么匹配完成后分为三部分，左儿子的 ))))，左儿子的 ( 和右儿子的 ) 匹配之后左儿子剩下的 ((，右儿子的 ((((。
假如我们分别维护了 )))) 和 (((( 对应的信息，那么我们只需要考虑中间的部分如何维护。
计算左儿子的前若干个 ( 的信息，于是实现函数 \(\text{GetL(u,k)}\) 表示计算节点 \(u\) 的前 \(k\) 个 ( 的信息。
每次只需要向一边递归，复杂度 \(O(\log n)\)，总时间复杂度 \(O(n+m\log^2n)\) 。
点击查看代码
#515. 【UR #19】前进四
容易想到一种类似于楼房重建的方式做到 \(O(n\log^2n)\) ，但是这是不够的，考虑单 \(\log\) 做法。
发现询问都为后缀，以时间为轴开线段树，倒序扫描序列，对于每个位置，每个数出现的时间都是一段区间，吉如一线段树维护每个位置被取 \(\min\) 的次数即可，时间复杂度 \(O(n\log n)\)。
点击查看代码
#include<bits/stdc++.h>
using namespace std;
int n,q;
struct data{
int x,l,r;
data(int _x,int _l,int _r){
x=_x;l=_l;r=_r;
}
};
vector<data> vec[1000005];
vector<int> qry[1000005];
struct node{
int mx1,mx2;
node(){}
node(int _mx1,int _mx2){
mx1=_mx1;mx2=_mx2;
}
inline node operator +(const node &b)const{
if(mx1>b.mx1)return node(mx1,max(mx2,b.mx1));
if(mx1<b.mx1)return node(b.mx1,max(b.mx2,mx1));
return node(mx1,max(mx2,b.mx2));
}
}tree[4000005];
int lazy[4000005];
inline void push(int i){
if(!lazy[i])return ;
if(tree[i<<1].mx1>tree[i].mx1)tree[i<<1].mx1=tree[i].mx1,lazy[i<<1]+=lazy[i];
if(tree[i<<1|1].mx1>tree[i].mx1)tree[i<<1|1].mx1=tree[i].mx1,lazy[i<<1|1]+=lazy[i];
lazy[i]=0;
}
void build(int l=0,int r=q,int i=1){
tree[i]=node(1e9,0);
if(l==r)return ;
int mid=(l+r)>>1;
build(l,mid,i<<1);build(mid+1,r,i<<1|1);
}
void update(int fr,int to,int v,int l=0,int r=q,int i=1){
if(fr>r||to<l||tree[i].mx1<=v)return ;
if(fr<=l&&to>=r&&tree[i].mx2<v){
lazy[i]++;tree[i].mx1=v;
return ;
}
int mid=(l+r)>>1;push(i);
update(fr,to,v,l,mid,i<<1);update(fr,to,v,mid+1,r,i<<1|1);
tree[i]=tree[i<<1]+tree[i<<1|1];
}
int query(int loc,int l=0,int r=q,int i=1){
if(loc<l||loc>r)return 0;
if(l==r)return lazy[i];
int mid=(l+r)>>1;push(i);
return query(loc,l,mid,i<<1)+query(loc,mid+1,r,i<<1|1);
}
int ans[1000005];
int main(){
scanf("%d%d",&n,&q);
for(int i=1;i<=n;i++){
int x;scanf("%d",&x);
vec[i].push_back(data(x,0,q));
}
for(int i=1;i<=q;i++){
int op,x,y;
scanf("%d",&op);
if(op==1){
scanf("%d%d",&x,&y);
vec[x].back().r=i-1;vec[x].push_back(data(y,i,q));
}
else if(op==2){
scanf("%d",&x);qry[x].push_back(i);
}
}
build();
for(int i=n;i;i--){
for(auto it:vec[i])update(it.l,it.r,it.x);
for(auto it:qry[i])ans[it]=query(it);
}
for(int i=1;i<=q;i++)if(ans[i])printf("%d\n",ans[i]);
return 0;
}
