Luogu P8479 「GLR-R3」谷雨

upd on 2023.10.03 补充了代码以及一些实现细节。

自己写的关于这类剖分方法的 \(blog\)

题意简述

称一条链和与其有连边的点构成的点集为 “毛毛虫”，链上的点为 “毛点”，某个 “毛点” \(x\) 的脚（与之右边但非链点）的点集为 \(T_x\)。

操作：给出一条 “毛毛虫” 的两端 \(u, v\)，将该“毛毛虫”内的点的点权改为 \(k\)；

询问：开始有个空序列 \(q\)，给出一条 “毛毛虫” 的头、尾 \(u, v\)，从头到尾按链上的顺序遍历 “毛点”，每走到一个 “毛点” \(x\)，现将 \(x\) 的点权加入 \(q\)，然后将 \(T_x\) 内的点的点权按点编号从小到大顺序放入 \(q\)。操作完后，询问 \(q\) 的最大子段和（可以为 0）；

主要思路

考虑根据重链构造满足题目修改要求的 dfs 序，然后直接线段树维护。

设 \(S_{Z}\) 为将重链 \(Z\) 作为 “毛毛虫” 时的 \(q\)，特别的，此时 \(q\) 不包含 \(Z\) 链顶的父亲。

我们构造的 dfs 序满足：

每条重链 \(Z\) 的 \(S_{Z}\) 的编号连续；

因为跳重链时会出现半条链的情况，所以需要额外满足：

对于每条重链上的点 \(x\)，\(x\) 与 \(x\) 所有在 \(S_{Z}\) 中的拓展点（即 \(T_x\)）编号连续；

注意到题目中询问分向上走和向下走两种，因此还有一个限制：

重链点的编号的偏序关系和重链点的深度偏序关系全部相同或相反（分别对应向下和向下的情况）。

对于第三个限制，由于不能同时正序和倒序，所以构造两个不同的 dfn 序分别满足相同和相反，分开两棵线段树进行维护。

考虑构造，由于我们树剖时都是向上跳，因此我们对于某条重链，自底向上遍历每个点 \(x\)，对于向上跳的 dfs 序，先给 \(x\) 编号后再给 \(T_{x}\) 编号；对于向下跳的 dfs 序，先给 \(T_{x}\) 编号再给 \(x\) 编号。这样子，对于我们询问中向下跳的部分，只要整体翻转就可以得到正序遍历之后的信息。

void cover(int x){

	if(son[x]) cover(son[x]);

	dfT[x][0]=dfn[0]+1, nfT[x][0]=nfd[0]+1;if(!dfn[x]) dfn[x]=++dfn[0];

	for(auto v:G[x]) if(son[x]^v) dfn[v]=++dfn[0];reverse(G[x].begin(), G[x].end());

	for(auto v:G[x]) if(son[x]^v) nfd[v]=++nfd[0];reverse(G[x].begin(), G[x].end());

	if(!nfd[x]) nfd[x]=++nfd[0];dfT[x][1]=dfn[0], nfT[x][1]=nfd[0];

}

void dfs(int x, int rt){

	top[x]=rt;if(x==rt) cover(x);if(son[x]) dfs(son[x], rt);

	int c=0;for(auto v:G[x]) if(son[x]^v) dfs(v, v), ++c;else pos[x]=c;

}

其中 \(dfn_{x}, nfd_{x}\) 分别为 \(x\) 上跳/下跳的 dfs 序。\(dfT_{x, 0, 1}, nfT_{x, 0/1}\) 则维护了 \(T_{x}\) 的 dfs 序区间。

注意到这样的构造有点不完美：一条重链 \(Z\) 的链顶的 dfs 序与 \(Z\) 可能是分离的。但这只需要 \(O(1)\) 的分讨量，因此是利大于弊的。然而代码细节变得巨多。

代码细节

十分建议先写性质 D，因为询问边界很多需要特殊处理，而修改是覆盖，边界问题基本不用考虑。

对于修改：直接模拟树剖 LCA，注意跳重链时，重链顶部单独拿出来修改，当前所在的半条重链底部的重儿子也要考虑。最后注意 LCA 的父亲也要修改。

对于询问：仍是模拟 LCA，链底/顶单独拿出来，跳完一条重链的时候，可以先将重链顶部的值变为 0，这样就不需要再在上面考虑排除掉这些多余的信息。最后再修改回来即可。

更多的细节可以看代码注释。

Code

#include <stdio.h>

#include <algorithm>

#include <string.h>

#include <cctype>

#include <vector>

#include <queue>

#include <bitset>

#define vi vector<int>

#define pb push_back

#define mp make_pair

#define st first

#define nd second

using namespace std;

typedef long long ll;

typedef pair <int, int> Pii;

const int INF=1e9+1;

const int cp=998244353;

inline int mod(int x){if(x>=cp) x-=cp;if(x<0) x+=cp;return x;}

inline void plust(int &x, int y){x=mod(x+y);return ;}

inline void minut(int &x, int y){x=mod(x-y);return ;}

inline int read(){

	char ch=getchar();int x=0, f=1;

	while(!isdigit(ch)){if(ch=='-') f=-1; ch=getchar();}

	while(isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}

	return x*f;

}

inline void write(int x){

    if(x<0) putchar('-'), x=-x;

    if(x>9) write(x/10);

    putchar(x%10+'0');

}

inline int ksm(int a, int b=cp-2){

	int ret=1;

	for(; b; b>>=1, a=1ll*a*a%cp)

		if(b&1) ret=1ll*ret*a%cp;

	return ret;

}

const int N=1e5+5;

inline ll mx(ll x, ll y){return x>y?x:y;}

struct node{ll sum, lp, rp, ans;};

inline node Node(ll v){return (node){v, mx(v, 0), mx(v, 0), mx(v, 0)};}

const node O=(node){0, 0, 0, 0};

node operator + (node L, node R){

	node res=O;res.sum=L.sum+R.sum;

	res.lp=mx(L.lp, L.sum+R.lp);res.rp=mx(R.rp, R.sum+L.rp);

	res.ans=mx(mx(L.ans, R.ans), L.rp+R.lp);return res;

}

struct Tree{

	#define ls k<<1

	#define rs k<<1|1

	#define mid ((l+r)>>1)

	node tr[N<<2];int tag[N<<2], len[N<<2];

	inline void upd(int k, int v){ll p=1ll*len[k]*v;tr[k]=Node(p);tag[k]=v;}

	inline void pushdown(int k){if(tag[k]!=INF) upd(ls, tag[k]), upd(rs, tag[k]);tag[k]=INF;}

	inline void pushup(int k){tr[k]=tr[ls]+tr[rs];}

	void build(int k, int l, int r){

		len[k]=r-l+1;tag[k]=INF;tr[k]=O;if(l==r) return ;

		build(ls, l, mid);build(rs, mid+1, r);

	}

	int m, x, y, v;inline void init(int n){m=n;build(1, 1, m);}

	int update(int k, int l, int r){

		if(l==r){int r=tr[k].sum;tr[k]=Node(v);return r;}pushdown(k);

		int res=(x<=mid)?update(ls, l, mid):update(rs, mid+1, r);pushup(k);return res;

	}

	inline int flp(int xx, int vv=0){if(!xx) return 0;x=xx, v=vv;int res=update(1, 1, m);return res;}

	void modify(int k, int l, int r){

		if(x>r||y<l||x>y) return ;if(x<=l&&r<=y) return upd(k, v);pushdown(k);

		modify(ls, l, mid);modify(rs, mid+1, r);pushup(k);

	}

	inline void mdy(int xx, int yy, int vv){x=xx, y=yy, v=vv;modify(1, 1, m);}

	node query(int k, int l, int r){

		if(x>r||y<l||x>y) return O;if(x<=l&&r<=y) return tr[k];pushdown(k);

		return query(ls, l, mid)+query(rs, mid+1, r);

	}

	inline node qry(int xx, int yy){if(!xx||!yy) return O;x=xx, y=yy;node res=query(1, 1, m);return res;}

	#undef ls

	#undef rs

	#undef mid

}U, D;

int L[N], n, T, dfn[N], dfT[N][2], nfd[N], nfT[N][2], top[N], dep[N], son[N], pos[N], siz[N], fa[N];vi G[N];

void cover(int x){

	if(son[x]) cover(son[x]);

	dfT[x][0]=dfn[0]+1, nfT[x][0]=nfd[0]+1;if(!dfn[x]) dfn[x]=++dfn[0];

	for(auto v:G[x]) if(son[x]^v) dfn[v]=++dfn[0];reverse(G[x].begin(), G[x].end());

	for(auto v:G[x]) if(son[x]^v) nfd[v]=++nfd[0];reverse(G[x].begin(), G[x].end());

	if(!nfd[x]) nfd[x]=++nfd[0];dfT[x][1]=dfn[0], nfT[x][1]=nfd[0];

}

void dfs(int x, int rt){

	top[x]=rt;if(x==rt) cover(x);if(son[x]) dfs(son[x], rt);

	int c=0;for(auto v:G[x]) if(son[x]^v) dfs(v, v), ++c;else pos[x]=c;

}

inline void chg(int x, int y, int v){

	while(top[x]^top[y]){

		if(dep[top[x]]<dep[top[y]]) swap(x, y);

		U.mdy(dfT[x][0], dfT[top[x]][1], v);U.flp(dfn[top[x]], v), U.flp(dfn[son[x]], v);

		D.mdy(nfT[x][0], nfT[top[x]][1], v);D.flp(nfd[top[x]], v), D.flp(nfd[son[x]], v);

		x=fa[top[x]];

	}

	if(dep[x]>dep[y]) swap(x, y);

	U.mdy(dfT[y][0], dfT[x][1], v);U.flp(dfn[x], v);U.flp(dfn[fa[x]], v);U.flp(dfn[son[y]], v);

	D.mdy(nfT[y][0], nfT[x][1], v);D.flp(nfd[x], v);D.flp(nfd[fa[x]], v);D.flp(nfd[son[y]], v);

}

inline int LCA(int x, int y){

	while(top[x]^top[y]){if(dep[top[x]]<dep[top[y]]) swap(x, y);x=fa[top[x]];}

	return dep[x]<dep[y]?x:y;

}

struct tmper{int x, v, op;};

inline node calc(int x, bool flg){

	//计算 x 的所有儿子（包括重儿子）

	if(!son[x]) return O;node res=O;

	if(flg){

		int l=nfT[x][0], r=nfT[x][1]-(x!=top[x]), mid=r-pos[x]+1;

		// printf("calc [%d %d]+%d+[%d %d]\n", l, mid-1, nfd[son[x]], mid, r);

		res=D.qry(l, mid-1)+D.qry(nfd[son[x]], nfd[son[x]])+D.qry(mid, r);

	// printf("ask %d %lld[%lld %lld]\n", x, res.sum, res.lp, res.rp);

	}

	else{

		int l=dfT[x][0]+(x!=top[x]), r=dfT[x][1], mid=l+pos[x]-1;

		res=U.qry(l, mid)+U.qry(dfn[son[x]], dfn[son[x]])+U.qry(mid+1, r);

	}

	return res;

}

ll ask(int x, int y){

	node res=O, ser=O;int lca=LCA(x, y);vector <tmper> Q;

	while(top[x]^top[lca]){

		res=res+U.qry(dfn[x], dfn[x])+calc(x, 0);

		if(x^top[x]) res=res+U.qry(dfT[fa[x]][0], dfT[son[top[x]]][1])+

		U.qry(dfn[top[x]], dfn[top[x]])+U.qry(dfT[top[x]][0], dfT[top[x]][1]);//注意链顶单独分开

		Q.pb((tmper){dfn[top[x]], U.flp(dfn[top[x]]), 0});/*将链顶标记 删除*/x=fa[top[x]];

	}

	if(x!=lca){

		res=res+U.qry(dfn[x], dfn[x])+calc(x, 0)+U.qry(dfT[fa[x]][0], dfT[son[lca]][1]);

		Q.pb((tmper){dfn[son[lca]], U.flp(dfn[son[lca]]), 0});

	}

	while(top[y]^top[lca]){

		ser=ser+calc(y, 1)+D.qry(nfd[y], nfd[y]);//注意合并顺序

		if(y^top[y]) ser=ser+D.qry(nfT[fa[y]][0], nfT[son[top[y]]][1])+

		D.qry(nfT[top[y]][0], nfT[top[y]][1])+D.qry(nfd[top[y]], nfd[top[y]]);

		Q.pb((tmper){nfd[top[y]], D.flp(nfd[top[y]]), 1});y=top[y];

		if(fa[y]==lca) Q.pb((tmper){dfn[y], U.flp(dfn[y]), 0});y=fa[y];

	}

	if(y!=lca){

		ser=ser+calc(y, 1)+D.qry(nfd[y], nfd[y])+D.qry(nfT[fa[y]][0], nfT[son[lca]][1]);

		Q.pb((tmper){dfn[son[lca]], U.flp(dfn[son[lca]]), 0});//注意理解这里

	}

	res=res+U.qry(dfn[lca], dfn[lca])+U.qry(dfn[fa[lca]], dfn[fa[lca]])+calc(lca, 0);

	for(auto [x, v, op]:Q) (op?D:U).flp(x, v);swap(ser.lp, ser.rp);

	return (res+ser).ans;

}

signed main(){

	T=read(), n=read();

	for(int i=1; i<=n; ++i) L[i]=read(), siz[i]=1;dep[1]=1;

	for(int i=2; i<=n; ++i) G[fa[i]=read()].pb(i), dep[i]=dep[fa[i]]+1;

	for(int i=n; i>=2; --i) siz[fa[i]]+=siz[i], son[fa[i]]=(siz[son[fa[i]]]<siz[i])?i:son[fa[i]];

	dfn[1]=++dfn[0], nfd[1]=++nfd[0], dfs(1, 1);U.init(n);D.init(n);dfn[0]=nfd[0]=0;

	for(int i=1; i<=n; ++i) U.flp(dfn[i], L[i]), D.flp(nfd[i], L[i]);

	int q=read();

	// for(int i=1; i<=n; ++i)

		// printf("%d:%d[%d %d] %d[%d %d] %d %d\n", i, dfn[i], dfT[i][0], dfT[i][1],

		// nfd[i], nfT[i][0], nfT[i][1], top[i], pos[i]);

	for(int i=1; i<=q; ++i){

		int op=read(), u=read(), v=read();

		if(!op) chg(u, v, read());

		else printf("%lld\n", ask(u, v));

	}

	return 0;

}