2019.04.01【校内模拟】Cac（圆方树）（DFS序）

传送门

---

解析：

仙人掌上路径问题考虑转换为圆方树上的问题。

将所有点双和割边改造为方点会让这道题好写一点。

现在考虑一条圆方树上的路径。

考虑对所有方点维护加法标记，表示它的所有亲儿子的权值需要加上多少。

加法标记对圆点无效。

显然当路径LCA是方点的时候我们需要特殊处理一个圆点，拿一个桶来记录单独加了多少，每次修改只会有$O(1)$次这种操作，不会影响复杂度。

对于询问我们在桶里面查询权值之后，询问父亲的权值。

发现是一个链加，单点求值，DFS序加树状数组差分维护一下就行了。

---

代码：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define gc get_char
#define cs const

namespace IO{
	inline char get_char(){
		static cs int Rlen=1<<20|1;
		static char buf[Rlen],*p1,*p2;
		return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,Rlen,stdin),p1==p2)?EOF:*p1++;
	}
	
	inline int getint(){
		re char c;
		while(!isdigit(c=gc()));re int num=c^48;
		while(isdigit(c=gc()))num=(num+(num<<2)<<1)+(c^48);
		return num;
	}
}
using namespace IO;

using std::cerr;
using std::cout;

cs int mod=998244353;
inline int add(int a,int b){return a+b>=mod?a+b-mod:a+b;}
inline void Inc(int &a,int b){(a+=b)>=mod?a-=mod:a;}
inline int dec(int a,int b){return a<b?a-b+mod:a-b;}

cs int N=3e5+5;
int n,m,q;

int ext;
namespace Tree{
	static cs int N=::N<<1;
	std::vector<int> G[N];
	inline void addedge(int u,int v){
		G[u].push_back(v);
		G[v].push_back(u);
	}
	
	int fa[N],top[N],dep[N],siz[N],son[N];
	int in[N],out[N],dfs_clock;
	void dfs1(int u){
		if(u>n)in[u]=++dfs_clock;
		else in[u]=in[fa[u]];
		siz[u]=1;
		for(int &v:G[u])if(v!=fa[u]){
			fa[v]=u;
			dep[v]=dep[u]+1;
			dfs1(v);
			siz[u]+=siz[v];
			if(siz[v]>siz[son[u]])son[u]=v;
		}
		out[u]=dfs_clock;
	}
	
	void dfs2(int u){
		if(son[u]){
			top[son[u]]=top[u];
			dfs2(son[u]);
		}
		else return ;
		for(int &v:G[u])if(v!=fa[u]&&v!=son[u]){
			top[v]=v;
			dfs2(v);
		}
	}
	
	inline int LCA(int u,int v){
		while(top[u]^top[v])dep[top[u]]>dep[top[v]]?u=fa[top[u]]:v=fa[top[v]];
		return dep[u]>dep[v]?v:u;
	}
	
	int bit[N];
	inline void add(int pos,int val){
		for(;pos<=dfs_clock;pos+=pos&-pos)Inc(bit[pos],val);
	}
	
	inline int qy(int pos){int res=0;
		for(;pos;pos^=pos&-pos)Inc(res,bit[pos]);
		return res;
	}
	
	inline int query(int l,int r){
		return dec(qy(r),qy(l-1));
	}
	
	int val[N];
	inline void modify(int u,int v,int w){
		int lca=LCA(u,v);
		add(in[u],w);
		add(in[v],w);
		add(in[lca],dec(0,w));
		if(fa[lca])add(in[fa[lca]],dec(0,w));
		if(lca>n)Inc(val[fa[lca]],w);
		else Inc(val[lca],w);
	}
	
	inline int query(int u){
		return ::add(val[u],query(in[fa[u]],out[fa[u]]));
	}
	
	inline void build(){
		dfs1(ext);
		top[ext]=ext;
		dfs2(ext);
		in[0]=1;
	}
}

namespace Cactu{
	static cs int N=::N;
	std::vector<int> G[N];
	inline void addedge(int u,int v){
		G[u].push_back(v);
		G[v].push_back(u);
	}
	
	int fa[N],dfn[N],low[N],dfs_clock;
	
	inline void solve(cs int u,cs int v){
		++ext;
		for(int re i=v;i!=fa[u];i=fa[i])Tree::addedge(ext,i);
	}
	
	void tarjan(int u,int pa){
		dfn[u]=low[u]=++dfs_clock;
		for(int &v:G[u])if(v!=pa){
			if(!dfn[v]){
				fa[v]=u;
				tarjan(v,u);
				low[u]=std::min(low[u],low[v]);
			}
			else low[u]=std::min(low[u],dfn[v]);
			if(low[v]>dfn[u])Tree::addedge(++ext,v),Tree::addedge(ext,u);
		}
		for(int &v:G[u])if(fa[v]!=u&&dfn[v]>dfn[u])solve(u,v);
	}
}

signed main(){
	ext=n=getint(),m=getint(),q=getint();
	for(int re i=1;i<=m;++i)Cactu::addedge(getint(),getint());
	Cactu::tarjan(1,0);
	Tree::build();
	while(q--)switch(getint()){
		case 0:{
			int u=getint(),v=getint(),val=getint();
			Tree::modify(u,v,val);
			break;
		}
		case 1:{
			cout<<Tree::query(getint())<<'\n';
			break;
		}
	}
	exit(0);
}