数据结构
Tags:Noip前的大抱佛脚
知识点及其应用
线段树
注意：空间开4倍
神奇标记
From8.26 Test_zsy（CPU监控）
如果一个点权为(val)的点被打上了((a,b))标记，那么他的实际点权为(max(a+val,b))
干啥滴？
标记不下放
- 区间加标记不下放，维护区间max或者最大值
方法是当前(tag)维护当前区域标记，(t)维护左右儿子的(max+tag[now])，并没有快多少，如果仍然忘记见提交记录
并查集
维护二分图
并查集每个点维护是否要改颜色，然后按秩合并/按大小合并即可
实际上可以说是用期望树高为(logn)的树形结构维护信息
维护后继位置
快速得到后继位置
-
[BZOJ2054]疯狂的馒头 维护数列的后继位置
对一个数列进行(10^7)次区间覆盖，查询最终颜色。
倒序做，每次做完一个区间把([l,r])的并查集父亲指向(r+1)，表示扫到该区间，要从(r+1)开始染色，这样就可以快速得到下一个染色的位置，复杂度为(O(n))
-
[BZOJ2238]Mst 维护树形结构的后继位置
对树上路径进行染色，查询最终颜色。
路径拆成直上直下的两条，(x,lca、y,lca)，于是每次弄完把([x,lca])的并查集父亲指向(fa[lca])，就可以类似数列一样快速求得下一个位置了，复杂度为(O(n))
堆
对于所有的父子结构，一定都有父亲的优先级大于左右儿子的优先级
可并堆的可持久化
左偏树可持久化，每次合并两个堆，只需要给经过的(log)个结点复制一遍就好了
#define lc H[x].ch[0]
#define rc H[x].ch[1]
struct heap {int ch[2],dis;double w;}H[M];
int Merge(int x,int y)
{
if(!x||!y) return x+y;
H[++node]=H[x];x=node;
if(H[x].w>H[y].w) swap(x,y);
rc=Merge(rc,y);
if(H[lc].dis<H[rc].dis) swap(lc,rc);
H[x].dis=H[rc].dis+1;
return x;
}
这个可以用来完成(k)短路问题
dsu on tree
姑且叫它数据结构
方式&原理
步骤：
- 先递归做轻儿子的答案，再递归做重儿子的答案
- 暴力把当前结点的轻儿子扫一遍统计答案
- 如果当前结点是递归下来的轻儿子，扫一遍把答案清空，否则不做处理
要求： 离线算法
复杂度： (O(nlogn))
分析：只需要考虑每个点被扫的次数，树剖下来每个点到根的路径最多有(log)条链，每逢轻重链交替的时候就会暴力去扫，于是每个点最多只会被扫(log)次，复杂度得证
适用范围
适用一些子树信息不好统计的题，可以类比于树上莫队
- 统计子树内数量最多的颜色的编号之和（Codeforces600E）
- 统计子树内距离(i)点不超过(k)的点的颜色数/某权值之和（BZOJ4771七彩树离线版/[湖南集训]谈笑风生）
单调队列
尺取合法区间
这大概是一个常见用法。
丢一道萝卜的题：长度为(n)的序列，每个数是([l[i],r[i]])内的一个值，求可能的LIS长度。
解法：当新加入的区间右端点大于前面所有区间的左端点时，产生矛盾。维护一个左端点的下降队列即可。
模板库
线段树
【模板】线段树 2
就是标记的优先顺序
const int N=1e5+10;
int n,m,t[N<<2],t1[N<<2],t2[N<<2],P;
void mul(int &x,int y) {x=1ll*x*y%P;}
void put(int x,int k,int op,int l,int r)
{
if(op==1) (t[x]+=1ll*(r-l+1)*k%P)%=P,(t2[x]+=k)%=P;
else mul(t[x],k),mul(t2[x],k),mul(t1[x],k);
}
void pushdown(int x,int l,int mid,int r)
{
int &s1=t1[x],&s2=t2[x];
if(s1!=1) put(x<<1,s1,2,l,mid),put(x<<1|1,s1,2,mid+1,r),s1=1;
if(s2!=0) put(x<<1,s2,1,l,mid),put(x<<1|1,s2,1,mid+1,r),s2=0;
}
void Add(int now,int l,int r,int gl,int gr,int op,int k)
{
if(l>=gl&&r<=gr) {put(now,k,op,l,r);return;}
int mid=(l+r)>>1;
pushdown(now,l,mid,r);
if(gl<=mid) Add(now<<1,l,mid,gl,gr,op,k);
if(gr>mid) Add(now<<1|1,mid+1,r,gl,gr,op,k);
t[now]=(t[now<<1]+t[now<<1|1])%P;
}
int Query(int now,int l,int r,int gl,int gr)
{
if(l>=gl&&r<=gr) return t[now];
int mid=(l+r)>>1,res=0;
pushdown(now,l,mid,r);
if(gl<=mid) res=Query(now<<1,l,mid,gl,gr);
if(gr>mid) res+=Query(now<<1|1,mid+1,r,gl,gr);
return res%P;
}
int main()
{
cin>>n>>m>>P;
for(int i=1;i<=n*4;i++) t1[i]=1;
for(int i=1,x;i<=n;i++) cin>>x,Add(1,1,n,i,i,1,x);
for(int i=1,x,y,k,op;i<=m;i++)
{
cin>>op>>x>>y;
if(op==1) cin>>k,Add(1,1,n,x,y,2,k);
if(op==2) cin>>k,Add(1,1,n,x,y,1,k);
if(op==3) cout<<Query(1,1,n,x,y)<<endl;
}
return 0;
}
点分治
一种分治思想，解决树上链的问题
const int N=21000;
struct edge{int next,to,w;}a[N];
int n,m,K[N],head[N],cnt,siz[N],rt,mx[N];
int sum,ans[N],vis[N],P[N],cc;
map<int,int> Map;
void Getroot(int x,int fr)
{
siz[x]=1;mx[x]=0;
for(int i=head[x];i;i=a[i].next)
{
int R=a[i].to;if(R==fr||vis[R]) continue;
Getroot(R,x);siz[x]+=siz[R];
mx[x]=max(mx[x],siz[R]);
}
mx[x]=max(mx[x],sum-siz[x]);
if(mx[x]<mx[rt]) rt=x;
}
void calcsum(int x,int fr)
{
sum++;
for(int i=head[x];i;i=a[i].next)
if(a[i].to!=fr&&!vis[a[i].to]) calcsum(a[i].to,x);
}
void Getdis(int x,int d,int fr)
{
P[++cc]=d;
for(int i=head[x];i;i=a[i].next)
if(!vis[a[i].to]&&a[i].to!=fr)
Getdis(a[i].to,d+a[i].w,x);
}
void solve(int x)
{
rt=0;mx[0]=1e9;
sum=0;calcsum(x,0);
Getroot(x,0);
vis[x=rt]=1;Map.clear();
for(int i=head[x];i;i=a[i].next)
{
int R=a[i].to;if(vis[R]) continue;
cc=0;Getdis(R,a[i].w,x);
for(int j=1;j<=m;j++)
for(int w=1;w<=cc;w++)
if(Map.find(K[j]-P[w])!=Map.end()) ans[j]=1;
for(int w=1;w<=cc;w++) Map[P[w]]=1;
}
for(int j=1;j<=m;j++) if(Map.find(K[j])!=Map.end()) ans[j]=1;
for(int i=head[x];i;i=a[i].next)
if(!vis[a[i].to]) solve(a[i].to);
}
int main()
{
cin>>n>>m;
for(int i=1;i<n;i++)
{
int x,y,w;scanf("%d%d%d",&x,&y,&w);
a[++cnt]=(edge){head[x],y,w};head[x]=cnt;
a[++cnt]=(edge){head[y],x,w};head[y]=cnt;
}
for(int i=1;i<=m;i++) cin>>K[i];
solve(1);
for(int i=1;i<=m;i++) ans[i]?puts("AYE"):puts("NAY");
}