标签：动态 struct 合并 最大 || else include 形式 queue
参考：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;
}bzoj 5210: 最大连通子块和【动态dp+树剖+线段树+堆】
标签：动态 struct 合并 最大 || else include 形式 queue
原文地址：https://www.cnblogs.com/lokiii/p/10090642.html
