bzoj 5210: 最大连通子块和【动态dp+树剖+线段树+堆】

参考：https://www.cnblogs.com/CQzhangyu/p/8632904.html

要开longlong的

首先看dp，设f[u]为必选u点的子树内最大联通块，p[u]为不一定选u的子树内最大联通块，转移很显然就是f[u]=max(Σf[v],0),p[u]=max(max(p[v]),f[u])

然后看动态的部分，设g是不算重儿子的f，然后每条链上的真实f值要用一棵线段树维护g来得到，具体形式是f[u]=max(g[v]+f[hs[v]],0)，是一个最长连续子序列的形式，所以这个可以通过在线段树上维护s：g的和；sl从左边起最大连续子序列；sr从右边起最大连续子序列；sm这一段的最大连续子序列，向上合并的时候就像dp一样做就行了，然后最终答案是p，所以改一下sm的定义，除了这一段的最大连续子序列外再维护轻儿子的p的max，因为要修改所以用一个可删堆维护

这样一来对于x到root上的点，只影响重链的最下点，每次每个最下点都改一下堆里的元素，并且改掉线段树里的相应点即可，然后查询的时候查询x所在的重链的x到最下点即可

每条重链建一个动态开点线段树会比较快

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int N=200005;
int n,m,h[N],cnt,de[N],fa[N],hs[N],si[N],fr[N],la[N],id[N],rl[N],tot,rt[N];
long long a[N],f[N],g[N],p[N];
char s[10];
struct qwe
{
	int ne,to;
}e[N<<1];
struct dui
{
	priority_queue<long long>q1,q2;
	void push(long long x)
	{
		q1.push(x);
	}
	void del(long long x)
	{
		q2.push(x);
	}
	long long top()
	{
		long long r=0;
		while(!q1.empty()&&!q2.empty()&&q1.top()==q2.top())
			q1.pop(),q2.pop();
		if(!q1.empty())
			r=q1.top();
		return r;
	}
}mx[N];
struct xds
{
	int l,r,ls,rs;
	long long s,sl,sr,sm;
	xds operator + (const xds &b) const
	{
		xds c;
		c.s=s+b.s;
		c.sl=max(sl,s+b.sl);
		c.sr=max(b.sr,sr+b.s);
		c.sm=max(sr+b.sl,max(sm,b.sm));
		return c;
	}
}t[N<<2];
int read()
{
	int r=0,f=1;
	char p=getchar();
	while(p>'9'||p<'0')
	{
		if(p=='-')
			f=-1;
		p=getchar();
	}
	while(p>='0'&&p<='9')
	{
		r=r*10+p-48;
		p=getchar();
	}
	return r*f;
}
void add(int u,int v)
{
	cnt++;
	e[cnt].ne=h[u];
	e[cnt].to=v;
	h[u]=cnt;
}
void dfs1(int u,int fat)
{
	fa[u]=fat;
	de[u]=de[fat]+1;
	si[u]=1;
	for(int i=h[u];i;i=e[i].ne)
		if(e[i].to!=fat)
		{
			dfs1(e[i].to,u);
			si[u]+=si[e[i].to];
			if(si[e[i].to]>si[hs[u]])
				hs[u]=e[i].to;
		}
}
void dfs2(int u,int top)
{
	fr[u]=top;
	la[top]=u;
	id[u]=++tot;
	rl[tot]=u;
	if(!hs[u])
		return;
	dfs2(hs[u],top);
	for(int i=h[u];i;i=e[i].ne)
		if(e[i].to!=fa[u]&&e[i].to!=hs[u])
			dfs2(e[i].to,e[i].to);
}
void dfs(int u,int fa)
{
	f[u]=g[u]=a[u];
	for(int i=h[u];i;i=e[i].ne)
		if(e[i].to!=fa)
		{
			dfs(e[i].to,u);
			f[u]+=f[e[i].to];
			p[u]=max(p[u],p[e[i].to]);
			if(e[i].to!=hs[u])
				g[u]+=f[e[i].to],mx[u].push(p[e[i].to]);
		}
	f[u]=max(f[u],0ll),p[u]=max(p[u],f[u]);
}
void ud(int ro)
{
	t[ro].s=t[t[ro].ls].s+t[t[ro].rs].s;
	t[ro].sl=max(t[t[ro].ls].sl,t[t[ro].ls].s+t[t[ro].rs].sl);
	t[ro].sr=max(t[t[ro].rs].sr,t[t[ro].ls].sr+t[t[ro].rs].s);
	t[ro].sm=max(t[t[ro].ls].sr+t[t[ro].rs].sl,max(t[t[ro].ls].sm,t[t[ro].rs].sm));
}
void build(int &ro,int l,int r,int u)
{
	ro=++tot;
	t[ro].l=l,t[ro].r=r;
	if(l==r)
	{
		t[ro].s=g[rl[id[u]+l-1]];
		t[ro].sl=t[ro].sr=max(g[rl[id[u]+l-1]],0ll);
		t[ro].sm=max(g[rl[id[u]+l-1]],mx[rl[id[u]+l-1]].top());
		return;
	}
	int mid=(l+r)>>1;
	build(t[ro].ls,l,mid,u);
	build(t[ro].rs,mid+1,r,u);
	ud(ro);
}
void update(int ro,int p,int u)
{
	if(t[ro].l==t[ro].r)
	{
		t[ro].s=g[u];
		t[ro].sl=t[ro].sr=max(g[u],0ll);
		t[ro].sm=max(g[u],mx[u].top());
		return;
	}
	int mid=(t[ro].l+t[ro].r)>>1;
	if(p<=mid)
		update(t[ro].ls,p,u);
	else
		update(t[ro].rs,p,u);
	ud(ro);
}
xds ques(int ro,int l,int r)
{//cerr<<ro<<" "<<l<<" "<<r<<endl;
	if(t[ro].l==l&&t[ro].r==r)
		return t[ro];
	int mid=(t[ro].l+t[ro].r)>>1;
	if(r<=mid)
		return ques(t[ro].ls,l,r);
	else if(l>mid)
		return ques(t[ro].rs,l,r);
	else
		return ques(t[ro].ls,l,mid)+ques(t[ro].rs,mid+1,r);
}
void gai(int x,long long y)
{
	int fl=0;
	xds a,b,c;
	while(x)
	{
		c=t[rt[fr[x]]];
		if(fl)
			mx[x].del(a.sm),mx[x].push(b.sm);
		a=c,fl=1;
		g[x]+=y;
		update(rt[fr[x]],de[x]-de[fr[x]]+1,x);
		b=t[rt[fr[x]]];
		y=b.sl-f[fr[x]],f[fr[x]]=b.sl;
		x=fa[fr[x]];
	}
}
int main()
{
	n=read(),m=read();
	for(int i=1;i<=n;i++)
		a[i]=read();
	for(int i=1;i<n;i++)
	{
		int x=read(),y=read();
		add(x,y),add(y,x);
	}
	dfs1(1,0);
	dfs2(1,1);
	dfs(1,0);
	tot=0;
	for(int i=1;i<=n;i++)
		if(fr[i]==i)
			build(rt[i],1,de[la[i]]-de[i]+1,i);
	while(m--)
	{
		scanf("%s",s+1);
		if(s[1]=='M')
		{
			int x=read(),y=read();
			gai(x,y-a[x]);
			a[x]=y;
		}
		else
		{
			int x=read();
			printf("%lld\n",ques(rt[fr[x]],de[x]-de[fr[x]]+1,de[la[fr[x]]]-de[fr[x]]+1).sm);
		}
	}
	return 0;
}