洛谷-U40581 树上统计（启发式合并/线段树合并）

最新推荐文章于 2024-08-07 21:15:31 发布
最新推荐文章于 2024-08-07 21:15:31 发布
阅读量678 收藏 1
点赞数 1
分类专栏： 题目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Paulliant/article/details/83831956
版权

题意

https://www.luogu.org/problemnew/show/U40581

思路

这种带两个 ∑ \sum ∑ 的题，显然是要单独算贡献了。在树上常见的就几种情况，点的贡献、边的贡献、 LCA \text{LCA} LCA的贡献。
考虑链的情况，对于一条边而言，能让它产生贡献的权值区间满足其中即含有在边左边的点，又含有在边右边的点。
把在边左边的点标为 1 1 1，右边的点标为 0 0 0，那么即包含 0 0 0 、又包含 1 1 1 的区间就会产生 1 1 1 的贡献，算这个不好算，我们正难则反，算只有 0 0 0、或只有 1 1 1的区间贡献，再用所有区间去减即可。
我们从左到右枚举选择链上的哪条边，用线段树维护上述的权值区间，从而计算不合法区间的情况，这个线段树应该支持单点修改，全局查询。
到了树上，我们可以类似的，把子树内的点标为 1 1 1 ，把子树外的点标为 0 0 0 ，逐个添加为 1 1 1 的点，但是直接添加又会 T \text{T} T，子树内的点？？启发式一下就好了嘛。
复杂度两个 log ⁡ \log log ，可以过，但是有少一个 log ⁡ \log log 的写法，线段树合并。
有了这种写法的基础，过渡下来也不难。我们可以干脆对每个点开一个线段树（动态开点），合并的代码如下：

int merge(int k,int p)
{
	if(!k||!p)return k|p;
	nd[k].lson=merge(nd[k].lson,nd[p].lson);
	nd[k].rson=merge(nd[k].rson,nd[p].rson);
	add_up(k);
	return k;
}

就是把线段树 k k k 向线段树 p p p 合并的过程，现在也暂时用不到这种高级的算法，复杂度不会分析。将来专门练线段树合并时再证复杂度。

代码

启发式合并
#include<bits/stdc++.h>
#define FOR(i,x,y) for(int i=(x),i##END=(y);i<=i##END;++i)
#define DOR(i,x,y) for(int i=(x),i##END=(y);i>=i##END;--i)
typedef long long LL;
using namespace std;
const int N=1e5+5;
template<const int maxn,const int maxm>struct Linked_list
{
    int head[maxn],to[maxm],nxt[maxm],tot;
    Linked_list(){clear();}
    void clear(){memset(head,-1,sizeof(head));}
    void add(int u,int v){to[++tot]=v,nxt[tot]=head[u],head[u]=tot;}
    #define EOR(i,G,u) for(int i=G.head[u];~i;i=G.nxt[i])
};
Linked_list<N,N<<1>G;
struct SegmentTree
{
    LL calc(int n){return 1ll*n*(n+1)/2;}
    struct node
    {
        int L,R,ls,rs;
        bool lc,rc;
        LL ans;
        void reset(bool val)
        {
            ls=rs=1,lc=rc=val;
            ans=1;
        }
        int lth(){return R-L+1;}
    }nd[N<<2];
    void build(int k,int L,int R)
    {
        nd[k].L=L,nd[k].R=R;
        if(L==R)
        {
            nd[k].reset(0);
            return;
        }
        build(k<<1,L,(L+R)>>1);
        build(k<<1|1,((L+R)>>1)+1,R);
        add_up(k);
    }
    void add_up(int k)
    {
        nd[k].lc=nd[k<<1].lc;
        nd[k].rc=nd[k<<1|1].rc;
        nd[k].ls=nd[k<<1].ls;
        nd[k].rs=nd[k<<1|1].rs;
        if(nd[k<<1].ls==nd[k<<1].lth()&&nd[k<<1].lc==nd[k<<1|1].lc)nd[k].ls+=nd[k<<1|1].ls;
        if(nd[k<<1|1].rs==nd[k<<1|1].lth()&&nd[k<<1|1].rc==nd[k<<1].rc)nd[k].rs+=nd[k<<1].rs;
        nd[k].ans=nd[k<<1].ans+nd[k<<1|1].ans;
        if(nd[k<<1].rc==nd[k<<1|1].lc)
        {
            nd[k].ans-=calc(nd[k<<1].rs);
            nd[k].ans-=calc(nd[k<<1|1].ls);
            nd[k].ans+=calc(nd[k<<1].rs+nd[k<<1|1].ls);
        }
    }
    void update(int k,int x,bool val)
    {
        if(nd[k].L==nd[k].R)
        {
            nd[k].reset(val);
            return;
        }
        int mid=(nd[k].L+nd[k].R)>>1;
        if(x<=mid)update(k<<1,x,val);
        else update(k<<1|1,x,val);
        add_up(k);
    }
    LL query(){return nd[1].ans;}
}ST;
int sz[N],son[N],L[N],R[N],ori[N],ord,n;
LL ans;
 
void dfs(int u,int f)
{
    L[u]=++ord,ori[ord]=u,sz[u]=1,son[u]=0;
    EOR(i,G,u)
    {
        int v=G.to[i];
        if(v==f)continue;
        dfs(v,u);
        sz[u]+=sz[v];
        if(sz[v]>sz[son[u]])son[u]=v;
    }
    R[u]=ord;
}
void update(int L,int R,int val){FOR(i,L,R)ST.update(1,ori[i],val);}
void dsu(int u,int f)
{
    EOR(i,G,u)
    {
        int v=G.to[i];
        if(v==f||v==son[u])continue;
        dsu(v,u);update(L[v],R[v],0);
    }
    if(son[u])dsu(son[u],u);
    EOR(i,G,u)
    {
        int v=G.to[i];
        if(v==f||v==son[u])continue;
        update(L[v],R[v],1);
    }
    update(L[u],L[u],1);
    ans+=1ll*n*(n+1)/2-ST.query();
}
 
int main()
{
    scanf("%d",&n);
    FOR(i,1,n-1)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        G.add(u,v),G.add(v,u);
    }
    dfs(1,0);
    ST.build(1,1,n);
    dsu(1,0);
    printf("%lld\n",ans);
    return 0;
}
线段树合并
#include<bits/stdc++.h>
#define FOR(i,x,y) for(int i=(x),i##END=(y);i<=i##END;++i)
#define DOR(i,x,y) for(int i=(x),i##END=(y);i>=i##END;--i)
typedef long long LL;
using namespace std;
const int N=1e5+5;
const int NlogN=2e6+5;
inline LL calc(int n){return 1ll*n*(n+1)/2;}
template<const int maxn,const int maxm>struct Linked_list
{
    int head[maxn],to[maxm],nxt[maxm],tot;
    Linked_list(){clear();}
    void clear(){memset(head,-1,sizeof(head));}
    void add(int u,int v){to[++tot]=v,nxt[tot]=head[u],head[u]=tot;}
    #define EOR(i,G,u) for(int i=G.head[u];~i;i=G.nxt[i])
};
Linked_list<N,N<<1>G;
struct node
{
    int lson,rson;
    int ls,rs;bool lc,rc;
    LL ans;
    void reset(int val,int l,int r)
    {
        ls=rs=ans=r-l+1;
        lc=rc=val;
        ans=calc(r-l+1);
    }
};
struct SegmentTree
{
    node nd[NlogN];
    int rt[N],tot;
    void build(){memset(rt,0,sizeof(rt));}
    void create(int &k){nd[k=++tot]=(node){0,0,0,0,0,0,0};}
    void add_up(int k,int l,int r)
    {
        node A,B;
        int mid=(l+r)>>1;
        if(!nd[k].lson)A.reset(0,l,mid);
        else A=nd[nd[k].lson];
        if(!nd[k].rson)B.reset(0,mid+1,r);
        else B=nd[nd[k].rson];
         
        nd[k].lc=A.lc;
        nd[k].rc=B.rc;
        nd[k].ls=A.ls;
        nd[k].rs=B.rs;
        if(A.ls==mid-l+1&&A.lc==B.lc)nd[k].ls+=B.ls;
        if(B.rs==r-(mid+1)+1&&B.rc==A.rc)nd[k].rs+=A.rs;
        nd[k].ans=A.ans+B.ans;
        if(A.rc==B.lc)
        {
            nd[k].ans-=calc(A.rs);
            nd[k].ans-=calc(B.ls);
            nd[k].ans+=calc(A.rs+B.ls);
        }
    }
    void update(int &k,int x,int val,int l,int r)
    {
        if(!k)create(k);
        if(l==r)
        {
            nd[k].reset(val,l,r);
            return;
        }
        int mid=(l+r)>>1;
        if(x<=mid)update(nd[k].lson,x,val,l,mid);
        else update(nd[k].rson,x,val,mid+1,r);
        add_up(k,l,r);
    }
    int merge(int k,int p,int l,int r)
    {
        if(!k||!p)return k|p;
        int mid=(l+r)>>1;
        nd[k].lson=merge(nd[k].lson,nd[p].lson,l,mid);
        nd[k].rson=merge(nd[k].rson,nd[p].rson,mid+1,r);
        add_up(k,l,r);
        return k;
    }
    LL query(int x){return nd[x].ans;}
}ST;
int n;
LL ans;
 
void dfs(int u,int f)
{
    ST.update(ST.rt[u],u,1,1,n);
    EOR(i,G,u)
    {
        int v=G.to[i];
        if(v==f)continue;
        dfs(v,u);
        ST.rt[u]=ST.merge(ST.rt[u],ST.rt[v],1,n);
    }
    ans+=calc(n)-ST.query(ST.rt[u]);
}
 
int main()
{
    scanf("%d",&n);
    FOR(i,1,n-1)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        G.add(u,v),G.add(v,u);
    }
    ST.build();
    dfs(1,0);
    printf("%lld\n",ans);
    return 0;
}
Paulliant
关注
专栏目录
启发式合并&线段树合并&treap合并&splay合并
ez_yww的博客
08-13 4704
启发式合并​　　有nn个集合，每次让你合并两个集合，或询问一个集合中是否存在某个元素。​　　我们可以用平衡树/set维护集合。​　　对于合并两个A,BA,B，如果|A|<|B||A|<|B|，那么我们就把AA中的每个元素暴力加到BB中，否则就把BB中的元素暴力加到AA中。​　　对于一次把AA中的每个元素暴力加到BB中的操作，|A||A|会变成|A|+|B||A|+|B|，也就是说大小至少会翻倍，所以
dsu on tree(树上启发式合并)算法总结+习题
mumei的博客
02-03 2684
前几天补了一下在camp中没学到的算法，树上启发式合并，一个O(nlogn)处理树上查询问题比较好的算法（其实就是暴力） 前置知识 学习这个算法之前需要知道一些树链剖分中的概念，不知道也没问题，下面我会给出 节点的大小：以当前节点为根的子树中的节点个数 重儿子：所有儿子节点中大小最大的那个节点 轻儿子：除重儿子之外的儿子节点 至于节点的深度等常见概念就不解释了。 算法思想 先拿一...
树上统计treecnt(dsu on tree 并查集 正难则反)
weixin_30776863的博客
09-21 202
题目链接 dalao们怎么都写的线段树合并啊。。 dsu跑的好慢。 \(Description\) 给定一棵\(n(n\leq 10^5)\)个点的树。 定义\(Tree[L,R]\)表示为了使得\(L\sim R\)号点两两连通，最少需要选择的边的数量。 求\[\sum_{l=1}^n\sum_{r=l}^nTree[l,r]\] \(Solution\) 枚举每条边，计算它的贡献。 那么我们...
树 杭电多校1 1003 (线段树合并 + 启发式合并)
最新发布
jushdi的博客
08-07 659
容易联想到启发式合并，顺着这个思路，思考怎么计算将一个数合并进一个集合对答案的贡献。，显然线段树能实现这个功能，于是我们在启发式合并的基础上再套一个线段树合并，这题就结束了。的差值有关，所以多存一个变量记录。的和，这样就可以快速算出贡献)(关于如何想到这一点，对于。，都需要能够快速求出这三个值。所以，对于每个集合和一个。的数，需要引进两个变量。，那么此时的贡献就为。
洛谷3899 谈笑风生 线段树合并
forever_shi的博客
01-17 373
题目链接 题意： 给你一棵n个点的树，边的边权都是1。有q次询问，每次询问给一个a一个x，表示询问满足下列条件的三元组的个数：(a,b,c)，使得a和b都是c的祖先节点并且a与b的距离不超过x。n,q&lt;=300000 题解： 乍一看确实不太好做，如果你没有想到正确的算法的话可能不好做。这个题的做法好像很多，我在这里只介绍一种用线段树合并做的在线做法。 我们考虑告诉你了a之后，b和c会是怎么组...
树上启发式合并 洛谷U41492
stdforces的博客
07-04 190
启发式合并
洛谷U41492（树上启发式合并）
04-30 190
提交通道 洛谷日报 考虑非\(O(n^2)\)的预处理。一遍dfs时，check某颜色有没有的数组何时清空很尴尬：得到某树答案后如果不清，则影响接下来兄弟树的搜索；如果清了，父亲节点又难以收集答案。 解决方法：先让儿子们各顾各的家，算一遍各自的答案（假如能算），check清就清了吧。然后考虑人为优化，即重链求完后等一等！先别清！然后将轻链重新扫一遍，也不清check数组的。代码中的kee...
数据结构专题-学习笔记：线段树合并
Plozia 的小窝
12-08 786
数据结构专题 - 线段树合并的学习笔记。
洛谷 - 试炼场（全部题目备份）
繁凡さん的博客
10-06 3129
新手村 任何一个伟大的目标，都有一个微不足道的开始。 洛谷的第一个任务 勇敢的迈出第一步，了解下语言和洛谷。跟着书本和老师走，不会难的。 P1000 P1001 P1421 P1425 顺序与分支 计算机的智能性开始得以体现，因为计算机能够根据不同的条件选择了。 P1422 P1085 P1089 P1909 循环！循环！循环！ 计算机最不怕的就是重复。你让它做10000次同样的事它也不怕啦，但是让他做1亿亿次的话…… P1008 P1035 P1423 P1424 P1980 数组 跟数组有关
权值线段树/主席树学习笔记+例题
急流勇进
04-05 2022
0. 介绍 以下转自：大佬 还有知乎有一篇比较好的介绍： 浅谈权值线段树到主席树 1.前言 据说主席树这个名字的由来呢，是因为创始人的名字缩写hjt与某位相同，然后他因为不会划分树于是自创了这一个数据结构。好强啊orz 主席树能实现什么操作呢？最经典的就是查询区间第k小了，其他的还有诸如树上路径第k小啦，带修改第k小啦之类的。以静态区间第k小为例 2.定义 先贴一下某神犇对主席树的理解：所谓主席树...
线段树知识点总结和学习心得分享
weixin_45590210的博客
05-05 285
线段树主要用来维护复杂的区间信息.只要满足区间可加性,线段树基本都可以解决. 1.线段树基本操作(单点更新,区间求和等不涉及lazy标记问题) 先来讲建树问题,线段树建树有很多种方法,本文介绍的是把一个区间划分成为[l,mid],[mid+1,r]的建树方法. 我们会把一个大区间分成若干个小区间,tree[1]是表示整个大区间.把它分成两个小区间.用下标tree[2×father], tree[2...
洛谷P3201 [HNOI2009] 梦幻布丁 (启发式合并)
GrittyB的博客
03-22 184
什么是启发式合并？ 题目 int a[N], n, m; int fcol[N]; vector<int> st[N]; int ans = 0; void Merge(int x,int y){ // x -> y // upd ans for(int i :st[x]){ if(a[i-1]==y) ans--; if(a[i+1]==y) ans--; } // upd
树上统计
风雨兼程
12-04 1531
解法很多，主要有主席树+dfs序 树上差分 树上启发式合并 线段树合并1.主席树+dfs序#include<bits/stdc++.h> using namespace std; #define FOR(i,x,y) for(int i=(x),i##_end_=(y);i<=i##_end_;i++) #define DOR(i,x,y) for(int i=(x),i##_end_=(y
[洛谷U40581]树上统计treecnt
weixin_33708432的博客
10-22 528
[洛谷U40581]树上统计treecnt 题目大意： 给定一棵\(n(n\le10^5)\)个点的树。 定义\(Tree[l,r]\)表示为了使得\(l\sim r\)号点两两连通，最少需要选择的边的数量。 求\(\sum_{l=1}^n\sum_{r=l}^nTree[l,r]\)。 思路： 对于每个边考虑贡献，若我们将出现在子树内的点记作\(1\)，出现在子树外的点记作\(0\)，那么答案就...
BZOJ2733[HNOI2012]永无乡——线段树合并+并查集+启发式合并
weixin_34128534的博客
09-25 108
题目描述 永无乡包含 n 座岛，编号从 1 到 n，每座岛都有自己的独一无二的重要度，按照重要度可 以将这 n 座岛排名，名次用 1 到 n 来表示。某些岛之间由巨大的桥连接，通过桥可以从一个岛 到达另一个岛。如果从岛 a 出发经过若干座（含 0 座）桥可以到达岛 b，则称岛 a 和岛 b 是连 通的。现在有两种操作：B x y 表示在岛 x 与岛 y 之间修建一座新桥。Q x k 表示询问...
洛谷-Lomsat gelral-(树上启发式合并-维护答案全局变量)
m0_52398496的博客
03-12 293
DIV2-D 题意： 就是给你一个树，每个点有一个颜色，然后对于每一个子树，求出来颜色占据主导位置的编号和。一个子树可能有多个颜色站主导地位。 思考： 对于这种离线树上查询的问题，可以考虑树上启发式合并，就是对于每个数把所有轻儿子都往重儿子上合并就行了。因为如果每个点都直接去求一次这样复杂度明显就是n*n,如果考虑空间总不能对每个点都开一个二维数组把，这样空间也炸了。所以这样优化之后就是nlogn的复杂度。对于这个题目呢，要维护一个sum和颜色出现最大值就行了。然后当处理到now节点的时候把答案记录下来即可
【金牌导航】【洛谷 P3201】【启发式合并】梦幻布丁
Y的博客
02-15 266
【金牌导航】【洛谷 P3201】【启发式合并】梦幻布丁 题目 解题思路 启发式合并真的就是想到挺难的，想到后简单得很 如何判断有几段还是很容易的，如果和前一个布丁颜色不同，段数+1 将每一种颜色看作一条链 改变颜色可以看作将两条链合并 为了时间更优，肯定是要将数量少的合并到多的 所以要记录原来的颜色x当前是颜色b[x] 如果改颜色后与前面或后面颜色相同，段数-1 合并后要及时更新颜色的数量 代码 #include<iostream> #include<cstdio> usin
[CSP-S模拟测试]:模板(ac)（线段树启发式合并）
weixin_30394251的博客
07-30 146
题目描述 辣鸡$ljh\ NOI$之后就退役了，然后就滚去学文化课了。他每天都被$katarina$大神虐，仗着自己学过一些姿势就给$katarina$大神出了一道题。有一棵$n$个节点的以$1$号节点为根的树，每个节点上有一个小桶，节点$u$上的小桶可以容纳个小球，$ljh$每次可以给一个节点到根路径上的所有节点的小桶内放一个小球，如果这个节点的小桶满了则不能放进这个节点，在放完所有...
【启发式合并】线段树，平衡树
dongchouzhou1607的博客
12-07 222
【启发式合并】线段树，平衡树 启发式合并就是一种复杂度可以证明的贪心合并 平衡树启发式合并： 对于平衡树的启发式合并，我们将一个 $size$ 较小平衡树一个一个结点暴力加入 $size$ 较大的平衡树中 最坏时间复杂度是玄学的 $O（N log^{2} N）$ 空间复杂度 $O（N）$ 模板题：P3224 [HNOI2012]永无乡 1 #include<b...
ZJOI[2008]树上统计
HT008的Blog
01-06 296
一道树剖的裸题，连区间修改都不用，只需要单点修改，区间最值，区间求和即可。 需要注意的是，此题有负数，求最大值时需要考虑。 题目传送门 #include #include #define lson (o #define rson (o using namespace std; const int maxm=310000; int deep[maxm],son[maxm],size[max
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值