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;
}

原文地址:https://www.cnblogs.com/lokiii/p/10090642.html

时间: 2024-11-01 17:35:33

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

xdoj1065 Efficent Allocation 动态开点的线段树

xdoj1065 Efficent Allocation  动态开点的线段树 1065: Efficent Allocation 时间限制: 8 Sec  内存限制: 256 MB提交: 24  解决: 3[提交][状态][讨论版] 题目描述 由于XDOJ评测机的一些奇怪行为,本题时限调整到8s. lx正在写一个内存分配器,支持下列操作: (1) malloc(size),分配一个大小为size字节的内存块,返回指向该内存块的指针. (2) free(p),释放起始地址是p的内存块. lx使用的

xdoj1023 IP查询 动态开点的线段树

xdoj1023 IP查询    动态开点的线段树 1023: IP查询 时间限制: 1 Sec  内存限制: 128 MB提交: 3473  解决: 228[提交][状态][讨论版] 题目描述 现实生活中,每一个IP段都指向一座城市.为了简化问题,我们将IP段直接看做一个整形数,每座城市也有自己的唯一标识ID,也可以看做一个整数.那么问题来了,现在已知有多个闭区间代表多个IP段,每个区间对应一个城市的ID.现在,小L要查询某个IP属于那个城市,希望聪明的你来帮他完成. 输入 第一行输入T,表示

BZOJ 1901: Zju2112 Dynamic Rankings 区间k大 带修改 在线 线段树套平衡树

之前写线段树套splay数组版..写了6.2k..然后弃疗了.现在发现还是很水的..嘎嘎.. zju过不了,超时. upd:才发现zju是多组数据..TLE一版才发现.然后改了,MLE...手写内存池..尼玛终于过了..附zju2112代码于后. bzoj倒是过了,1A的感觉还是很爽的..可是时间不好看..这就是所谓\(O(nlog^3n)\)的复杂度的可怜之处么? 写挂的地方: insert一定要是传地址指针进去. delete时先把地址指针delete掉,最后把是地址指针指向左儿子or右儿子

[BZOJ 1901] Dynamic Rankings 【树状数组套线段树 || 线段树套线段树】

题目链接:BZOJ - 1901 题目分析 树状数组套线段树或线段树套线段树都可以解决这道题. 第一层是区间,第二层是权值. 空间复杂度和时间复杂度均为 O(n log n). 代码 树状数组套线段树 #include <iostream> #include <cstdlib> #include <cstdio> #include <cmath> #include <algorithm> #include <cstring> usin

BZOJ 3065 带插入区间K小值 替罪羊树套线段树

题目大意:带插入,单点修改的区间k小值在线查询. 思路:本年度做过最酸爽的题. 树套树的本质是一个外层不会动的树来套一个内层会动(或不会动)的树.两个树的时间复杂度相乘也就是差不多O(nlog^2n)左右.但是众所周知,高级数据结构经常会伴有庞大的常数,所以一般来说树套树的常数也不会小到哪去.所以在做这种题的时候先不要考虑常数的问题... 为什么要用替罪羊树呢?因为一般的平衡树都是会动的,这就很难办了.外层的树动了之后,内层的树肯定也是会动的.很显然,一般的二叉平衡树会经常会旋转,这样在动外层的

zoj 2112 Dynamic Rankings 动态第k大 线段树套Treap

Dynamic Rankings Time Limit: 20 Sec Memory Limit: 256 MB 题目连接 http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2112 Description The Company Dynamic Rankings has developed a new kind of computer that is no longer satisfied with the query l

【BZOJ3730】震波 动态树分治+线段树

[BZOJ3730]震波 Description 在一片土地上有N个城市,通过N-1条无向边互相连接,形成一棵树的结构,相邻两个城市的距离为1,其中第i个城市的价值为value[i].不幸的是,这片土地常常发生地震,并且随着时代的发展,城市的价值也往往会发生变动.接下来你需要在线处理M次操作:0 x k 表示发生了一次地震,震中城市为x,影响范围为k,所有与x距离不超过k的城市都将受到影响,该次地震造成的经济损失为所有受影响城市的价值和.1 x y 表示第x个城市的价值变成了y.为了体现程序的在

BZOJ 4026 dC Loves Number Theory 分块+十字链表/可持久化线段树

题目大意:给定一个序列,多次询问某段区间乘积的φ值对1000777的模 我竟然卡过去了233333 将序列分块,记录fi,j表示第i块左端点到第j个点中出现的所有质数p的p?1p之积 每次询问[x,y],首先取出[x,y]区间内所有数的积,然后乘上fst,y(其中st是x后面第一个块端点所在块) 现在还剩[x,l[st]]部分没有统计 由于106以内的数分解得到的不同的质因数最多只有7个,因此暴力枚举零碎部分的质数即可 现在对于每个质数我们需要判断是否出现过 我们只需要判断这个质数下一次出现的位

【BZOJ4372】烁烁的游戏 动态树分治+线段树

[BZOJ4372]烁烁的游戏 Description 背景:烁烁很喜欢爬树,这吓坏了树上的皮皮鼠.题意:给定一颗n个节点的树,边权均为1,初始树上没有皮皮鼠.烁烁他每次会跳到一个节点u,把周围与他距离不超过d的节点各吸引出w只皮皮鼠.皮皮鼠会被烁烁吸引,所以会一直待在节点上不动.烁烁很好奇,在当前时刻,节点u有多少个他的好朋友---皮皮鼠.大意:给一颗n个节点的树,边权均为1,初始点权均为0,m次操作:Q x:询问x的点权.M x d w:将树上与节点x距离不超过d的节点的点权均加上w. In