树链刨分模板题 洛谷P3384

最新推荐文章于 2025-01-20 18:33:42 发布
原创 最新推荐文章于 2025-01-20 18:33:42 发布 · 182 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细解析洛谷P3384树链剖分模板题，提供完整的AC代码，涵盖树链剖分、线段树的实现与应用，以及取模操作在树链剖分和线段树中的具体实现。

洛谷P3384

树链刨分模板题。

推荐一篇讲的比较好的博客：https://www.cnblogs.com/chinhhh/p/7965433.html

因为这题要求取模，所以线段树部分和树链刨分部分都要取模。

ACcode：

精简版：

#include<bits/stdc++.h>
const int N=1e5+10;
using namespace std;
int n,q,r,mod;
int a[N<<2],b[N<<2];
int tot,ver[N<<1],Next[N<<1],head[N<<1];
int dep[N],fa[N],Size[N],son[N];
int cnt,id[N],top[N];
/*
b[i]    初始节点的权值
a[i]    新建节点的权值
题目输入的是b[i]，线段树中用的是a[i]

dep[i]  该节点的深度
fa[i]   该节点的父亲
Size[i] 该非叶子节点的子树大小
son[i]  i的重儿子

cnt     新建节点时用来存编号的
id[i]   该节点的新编号
top[i]  该节点所在链的顶端节点编号
*/
void add(int x,int y)
{
    ver[++tot]=y;Next[tot]=head[x];head[x]=tot;
}
void dfs1(int x,int f,int deep) //当前节点   父亲    深度
{
    dep[x]=deep;
    fa[x]=f;
    Size[x]=1;
    int maxson=-1;
    for(int i=head[x];i;i=Next[i])
    {
        int y=ver[i];
        if(y==f)    continue;
        dfs1(y,x,deep+1);
        Size[x]+=Size[y];
        if(Size[y]>maxson)
            son[x]=y,maxson=Size[y];
    }
}
void dfs2(int x,int topf)    //当前节点  当前链的最顶端的节点
{
    id[x]=++cnt;
    a[cnt]=b[x];
    top[x]=topf;
    if(son[x]==0)   return ;
    dfs2(son[x],topf);
    for(int i=head[x];i;i=Next[i])
    {
        int y=ver[i];
        if(y==fa[x]||y==son[x]) continue;
        dfs2(y,y);
    }
}

//以下是线段树******************************************************************
struct stree
{
    int l,r;
    int sum,add;
} t[N<<2];
void build(int p,int l,int r)   //建树 build(1,1,n)
{
    t[p].l=l,t[p].r=r;
    if(l==r)
    {
        t[p].sum=a[l];
        return ;
    }
    int mid=(l+r)/2;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
    t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}
void spread(int p)
{
    if(t[p].add)
    {
        t[p*2].sum=(t[p*2].sum+t[p].add*(t[p*2].r-t[p*2].l+1)%mod)%mod;
        t[p*2+1].sum=(t[p*2+1].sum+t[p].add*(t[p*2+1].r-t[p*2+1].l+1)%mod)%mod;
        t[p*2].add+=t[p].add;
        t[p*2+1].add+=t[p].add;
        t[p].add=0;
    }
}
//更新节点信息，调用入口：update(1,l,r,d)，把第l到r个数都加d
void update(int p,int l,int r,int d)
{
    if(l<=t[p].l&&r>=t[p].r)
    {
        t[p].sum=(t[p].sum+(int)d*(t[p].r-t[p].l+1)%mod)%mod;
        t[p].add+=d;
        return ;
    }
    spread(p);
    int mid=(t[p].l+t[p].r)/2;
    if(l<=mid) update(p*2,l,r,d);
    if(r>mid)   update(p*2+1,l,r,d);
    t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}
//第l到r个数的和，调用入口：query(1,l,r)
int query(int p,int l,int r)
{
    if(l<=t[p].l&&r>=t[p].r)
        return t[p].sum;
    spread(p);
    int mid=(t[p].l+t[p].r)/2;
    int val=0;
    if(l<=mid)
        val=(val+query(p*2,l,r))%mod;
    if(r>mid)
        val=(val+query(p*2+1,l,r))%mod;
    return val;
}
//以上是线段树*********************************************************************

void update1(int x,int y,int z) //给节点x到节点y这条链上的所有节点都加上z
{
    z%=mod;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        update(1,id[top[x]],id[x],z);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])   swap(x,y);
    update(1,id[x],id[y],z);
}
int query1(int x,int y) //询问节点x到节点y这条链上的所有节点的和
{
    int ret=0,res;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        res=query(1,id[top[x]],id[x]);
        ret+=res;
        ret%=mod;
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])   swap(x,y);
    ret+=query(1,id[x],id[y]);
    ret%=mod;
    return ret;
}
void update2(int x,int z)   //给以x为根的子树的所有节点（包括自己）都加上z
{
    update(1,id[x],id[x]+Size[x]-1,z);
}
int query2(int x)   //询问以x为根的子树的所有节点（包括自己）的和
{
    return query(1,id[x],id[x]+Size[x]-1)%mod;
}
int main()
{
    tot=0;
    cnt=0;
    scanf("%d%d%d%d",&n,&q,&r,&mod);
    for(int i=1;i<=n;i++)   scanf("%d",&b[i]);
    int x,y;
    for(int i=1;i<=n-1;i++)
        {scanf("%d%d",&x,&y);add(x,y);add(y,x);}
    dfs1(r,0,1);
    dfs2(r,r);
    build(1,1,n);
    int ans;
    while(q--)
    {
        int op,x,y,z;
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d%d%d",&x,&y,&z);
            update1(x,y,z);
        }
        else if(op==2)
        {
            scanf("%d%d",&x,&y);
            ans=query1(x,y);
            printf("%d\n",ans);
        }
        else if(op==3)
        {
            scanf("%d%d",&x,&z);
            update2(x,z);
        }
        else if(op==4)
        {
            scanf("%d",&x);
            ans=query2(x);
            printf("%d\n",ans);
        }
    }
    return 0;
}

带注释版：

#include<bits/stdc++.h>
const int N=1e5+10;
using namespace std;
int n,q,r,mod;
int a[N<<2],b[N<<2];
int tot,ver[N<<1],Next[N<<1],head[N<<1];    //链式前向星加边
int dep[N],fa[N],Size[N],son[N];
int cnt,id[N],top[N];
/*
b[i]    初始节点的权值
a[i]    新建节点的权值
题目输入的是b[i]，线段树中用的是a[i]

dep[i]  该节点的深度
fa[i]   该节点的父亲
Size[i] 该非叶子节点的子树大小
son[i]  i的重儿子

cnt     新建节点时用来存编号的
id[i]   该节点的新编号
top[i]  该节点所在链的顶端节点编号
*/
void add(int x,int y)
{
    ver[++tot]=y;Next[tot]=head[x];head[x]=tot;
}
void dfs1(int x,int f,int deep) //当前节点   父亲    深度
{
    dep[x]=deep;    //标记每个点的深度
    fa[x]=f;    //标记每个点的父亲
    Size[x]=1;  //标记每个非叶子节点的子树大小
    int maxson=-1;  //记录重儿子的儿子数
    for(int i=head[x];i;i=Next[i])
    {
        int y=ver[i];
        if(y==f)    continue;   //若该节点为父亲节点则continue
        dfs1(y,x,deep+1);   //dfs其儿子
        Size[x]+=Size[y];   //统计子树大小
        if(Size[y]>maxson)  //查找每个非叶子节点的重儿子编号
            son[x]=y,maxson=Size[y];
    }
}
void dfs2(int x,int topf)    //当前节点  当前链的最顶端的节点
{
    id[x]=++cnt;    //标记每个节点的新编号
    a[cnt]=b[x];    //把每个节点的初始值赋给这个新编号
    top[x]=topf;    //记录这个点所在重链的最顶端
    if(son[x]==0)   return ;    //如果没有儿子，直接返回
    dfs2(son[x],topf);  //先处理重儿子，在处理轻儿子
    for(int i=head[x];i;i=Next[i])
    {
        int y=ver[i];
        if(y==fa[x]||y==son[x]) continue;   //如果该节点是父亲节点或者重儿子，continue
        dfs2(y,y);  //每个轻儿子都有一条以自己为链顶端的重链
    }
}

//以下是线段树******************************************************************
struct stree
{
    int l,r;
    int sum,add;
} t[N<<2];
void build(int p,int l,int r)   //建树 build(1,1,n)
{
    t[p].l=l,t[p].r=r;
    if(l==r)
    {
        t[p].sum=a[l];
        return ;
    }
    int mid=(l+r)/2;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
    t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}
void spread(int p)
{
    if(t[p].add)
    {
        t[p*2].sum=(t[p*2].sum+t[p].add*(t[p*2].r-t[p*2].l+1)%mod)%mod;
        t[p*2+1].sum=(t[p*2+1].sum+t[p].add*(t[p*2+1].r-t[p*2+1].l+1)%mod)%mod;
        t[p*2].add+=t[p].add;
        t[p*2+1].add+=t[p].add;
        t[p].add=0;
    }
}
//更新节点信息，调用入口：update(1,l,r,d)，把第l到r个数都加d
void update(int p,int l,int r,int d)
{
    if(l<=t[p].l&&r>=t[p].r)
    {
        t[p].sum=(t[p].sum+(int)d*(t[p].r-t[p].l+1)%mod)%mod;
        t[p].add+=d;
        return ;
    }
    spread(p);
    int mid=(t[p].l+t[p].r)/2;
    if(l<=mid) update(p*2,l,r,d);
    if(r>mid)   update(p*2+1,l,r,d);
    t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}
//第l到r个数的和，调用入口：query(1,l,r)
int query(int p,int l,int r)
{
    if(l<=t[p].l&&r>=t[p].r)
        return t[p].sum;
    spread(p);
    int mid=(t[p].l+t[p].r)/2;
    int val=0;
    if(l<=mid)
        val=(val+query(p*2,l,r))%mod;
    if(r>mid)
        val=(val+query(p*2+1,l,r))%mod;
    return val;
}
//以上是线段树*********************************************************************

void update1(int x,int y,int z) //给节点x到节点y这条链上的所有节点都加上z
{
    //update1注释同query1
    z%=mod;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        update(1,id[top[x]],id[x],z);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])   swap(x,y);
    update(1,id[x],id[y],z);
}
int query1(int x,int y) //询问节点x到节点y这条链上的所有节点的和
{
    int ret=0,res;
    while(top[x]!=top[y])   //这两个点不在一条链上
    {
        if(dep[top[x]]<dep[top[y]]) swap(x,y);  //设x点为所在链顶端节点的深度更深的那个点
        res=query(1,id[top[x]],id[x]);  //ret加上“x点到x所在链顶端”这一段区间的点权和
        ret+=res;
        ret%=mod;
        x=fa[top[x]];//把x跳到x所在链顶端的那个点的上面一个点
    }
    //此时两个点已经处于一条链上了
    if(dep[x]>dep[y])   swap(x,y);  //设x点为所在链顶端节点的深度更深的那个点
    ret+=query(1,id[x],id[y]);  //再加上两个点的区间和
    ret%=mod;
    return ret;
}
void update2(int x,int z)   //给以x为根的子树的所有节点（包括自己）都加上z
{
    //update2注释同query2
    update(1,id[x],id[x]+Size[x]-1,z);
}
int query2(int x)   //询问以x为根的子树的所有节点（包括自己）的和
{
    return query(1,id[x],id[x]+Size[x]-1)%mod;  //子树区间右断点为id[x]+siz[x]-1
}
int main()
{
    tot=0;
    cnt=0;
    scanf("%d%d%d%d",&n,&q,&r,&mod);
    for(int i=1;i<=n;i++)   scanf("%d",&b[i]);
    //原始节点的点权存在数组b里，新构造出来的点的点权存在数组a里，建线段树用的是数组a
    int x,y;
    for(int i=1;i<=n-1;i++)
        {scanf("%d%d",&x,&y);add(x,y);add(y,x);}
    dfs1(r,0,1);
    dfs2(r,r);
    build(1,1,n);
    int ans;
    while(q--)
    {
        int op,x,y,z;
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d%d%d",&x,&y,&z);
            update1(x,y,z);
        }
        else if(op==2)
        {
            scanf("%d%d",&x,&y);
            ans=query1(x,y);
            printf("%d\n",ans);
        }
        else if(op==3)
        {
            scanf("%d%d",&x,&z);
            update2(x,z);
        }
        else if(op==4)
        {
            scanf("%d",&x);
            ans=query2(x);
            printf("%d\n",ans);
        }
    }
    return 0;
}

 

洛谷 最短路径计数 Dijkstra模板题
hj2207010104的博客
06-05 783
共 N 行，每行一个非负整数，第 i 行输出从顶点 1 到顶点 i 有多少条不同的最短路，由于答案有可能会很大，你只需要输出 ansmod100003 后的结果即可。给出一个 N 个顶点 M 条边的无向无权图，顶点编号为 1∼N。接下来 M 行，每行 2 个正整数 x,y，表示有一条连接顶点 x 和顶点 y 的边，请注意可能有自环与重边。//存储第i条边的起点。//指针,表示第几条边。
【Floyd算法】全源最短路算法 洛谷P3647模板例题讲解
wayua的博客
08-01 1310
Floyd算法讲解，洛谷P3647模板含代码详解 全源最短路 图论
P3995 树链剖分
orz
07-31 198
百紫斩第5天\color{purple}百紫斩第5天百紫斩第5天 洛谷 P3995P3995P3995 树链剖分 原题传送门 适合树剖新手做的题，代码简单，思路稍微有点难理解，便于新手提升水平。 题目大意 给定一棵树，请你给出一种剖分方案（即输出所有结点的重儿子），使所有询问操作总共访问的轻重链总条数最小，由于可能有许多合法方案，请任意输出一种，我们提供 SpecialJudgeSpecial JudgeSpecialJudge 检验你的方案的正确性。 解题思路 前置知识： lca，树上差分，对树剖的理解
树链剖分（重链剖分）
m0_73666576的博客
03-24 3660
本文主要针对于还没有学习过这个算法的新手同学
树链剖分 求 最近公共祖先（LCA)
qq_37746591的博客
03-25 1602
用树链刨分求最近公共祖先的笔记
树链剖分之重链剖分详解
菜鸡Jacky0705的优快云博客
07-28 1697
树链剖分之重链剖分详解一些概念 一些概念 在学习重链剖分前，首先要明白以下几个概念： 中二重儿子：就是一个节点的儿子中最“重”的那个，“重”表示的是子树大小最大，如果都一样大，就随便选一个就好了（用sonsonson数组存储） 亲轻儿子：除了重儿子外其他的儿子 重边：重儿子和父亲之间的边 轻边：轻儿子和父亲之间的边 重链：重边连在一起形成的链 轻链：轻边连在一起形成的链（貌似没啥用） 重链顶点：一条重链中，深度最小的点（用toptoptop数组记录） 为了方便大家理解，这里我画了一张图，来表示重链剖分后
生成树相关模板
平凡人Kalzn的博客
05-15 287
基本的最小生成树的Kruskal, Prime算法不再阐述. 有向图最小树形图 以某一根节点出发，可以到达所有节点，且边权总和最小的子图．这里模板使用的时朱刘算法； 下面时模板代码： /* 朱刘算法: 1.找所有节点的最小入边,标记 2.累加这些边的权值,如果这时没有环,则得到了最优解. 有环则进行下一 3.将环缩点,所有连接此环的入边权值减少当前这个终节点的最小入度边权值(可能减成负的) 4.返回1 复杂度:O(nm) */ const int N = 2e5+5; const int inf =
长链剖分
niiick
10-24 2512
长链剖分也属于树链剖分的一种 一般讲的树剖都指轻重链剖分，它可以用于维护树上路径的信息 而长链剖分则是用于维护有关深度的信息 剖分方法 长链剖分的剖分方法与轻重链剖分极其相似 只需要把以子树大小判断重儿子改成以节点深度判断即可 void dfs1(int u,int pa) { dep[u]=mxd[u]=dep[pa]+1;//mxd是该节点出发能到的最大深度 for(int i=head[u];i;i=E[i].nxt) { int v=E[i].v; if(v==pa) continu
树链剖分——重链剖分，原理剖析，代码详解
EQUINOX1的博客
04-08 1967
重链剖分，也是第33次CSP认证压轴题
树链剖分——详解
w_w_wwwww的博客
01-20 1037
第二个 DFS 记录所在链的链顶（top，应初始化为结点本身）、重边优先遍历时的 DFS 序（dfn）、DFS 序对应的节点编号（rank）。在向上跳的过程中，如果当前节点在重链上，向上跳到重链顶端，如果当前节点不在重链上，向上跳一个节点。重链剖分还能保证划分出的每条链上的节点 DFS 序连续，因此可以方便地用一些维护序列的数据结构（如线段树）来维护树上路径的信息。如果有多个子树最大的子结点，取其一。条连续的链，每条链上的点深度互不相同（即是自底向上的一条链，链上所有点的 LCA 为链的一个端点）。
【高级数据结构】深度剖析树状数组
Jefferyz070607的博客
12-08 1188
深度刨析了树状数组的本质，适合初学者快速进阶树状数组。
快速排序算法【C语言】&洛谷P1177 【模板】快速排序
qq_62440805的博客
02-11 2076
快速排序算法作为最基础的算法之一，同时也是我们最常用的算法，c++也自带了sort之一快速排序的算法来方便我们的使用，今天我们就一起来学习一下简单快排的原理。 洛谷的P1271就是这样的一个题目。事实就是，在昨晚之前，我从来没有去了解过快速排序的原理，在昨晚遇到这个题目，我查了一点资料，大概了解了一下快速排序的原理，它其实是对冒泡排序的一种优化，先从需要排序的数列中取定一个特殊值，将其余的数与其比较，小的放在一边，大的放在一边，这样我们就把需要排序的数组从一变成了二，再对这两个数组进行同样的操作，递归下去
最小生成树算法总结【洛谷P3366】
AnHongjun的博客
01-02 644
一、Prim算法 Prim算法是一种以点集为出发点的最小生成树算法，它将无向图G中所有顶点V分成两个子集A、B。初始时，A中只包含一个随机选取的顶点u，其余顶点属于集合B。每次从集合B中选取一个顶点加入顶点A，该顶点是集合B到集合A中距离最小的一个点。直到V个顶点全部属于A，算法结束。算法时间复杂度O(n^2)。 #define MaxN 5005 int N, M; int G[MaxN][MaxN]; bool flag[MaxN]; int dis[MaxN]; int Prim(...
树套树之线段树套线段树（BZOJ3110、洛谷P3332）
forezxl的博客
01-03 1321
线段树可以维护一个序列。当需要维护一个矩阵（即二维平面）内的数值，或者有什么奇怪的区间操作时，就需要用到二维线段树，也就是线段树“套上”线段树。
随机午餐菜单生成器功能开发
12-21
前端React组件实现的随机午餐菜单生成器的功能
基于机器学习的癫痫病发作预测与脑电波实时分析系统_通过傅里叶变换主成分分析降维和通道间相关性系数提取进行脑电信号特征工程结合随机森林支持向量机逻辑回归和决策树等多元分类算法.zip
12-21
基于机器学习的癫痫病发作预测与脑电波实时分析系统_通过傅里叶变换主成分分析降维和通道间相关性系数提取进行脑电信号特征工程结合随机森林支持向量机逻辑回归和决策树等多元分类算法.zip
需求响应动态冰蓄冷系统与需求响应策略的优化研究（Matlab代码实现）
最新发布
12-21
需求响应动态冰蓄冷系统与需求响应策略的优化研究（Matlab代码实现）内容概要：本文围绕“需求响应动态冰蓄冷系统与需求响应策略的优化研究”展开，基于Matlab代码实现，重点探讨了冰蓄冷系统在电力需求响应背景下的动态建模与优化调度策略。研究结合实际电力负荷与电价信号，构建系统能耗模型，利用优化算法对冰蓄冷系统的运行策略进行求解，旨在降低用电成本、平衡电网负荷，并提升能源利用效率。文中还提及该研究为博士论文复现，涉及系统建模、优化算法应用与仿真验证等关键技术环节，配套提供了完整的Matlab代码资源。; 适合人群：具备一定电力系统、能源管理或优化算法基础，从事科研或工程应用的研究生、高校教师及企业研发人员，尤其适合开展需求响应、综合能源系统优化等相关课题研究的人员。; 使用场景及目标：①复现博士论文中的冰蓄冷系统需求响应优化模型；②学习Matlab在能源系统建模与优化中的具体实现方法；③掌握需求响应策略的设计思路与仿真验证流程，服务于科研项目、论文写作或实际工程方案设计。; 阅读建议：建议结合提供的Matlab代码逐模块分析，重点关注系统建模逻辑与优化算法的实现细节，按文档目录顺序系统学习，并尝试调整参数进行仿真对比，以深入理解不同需求响应策略的效果差异。
综合能源系统零碳优化调度研究（Matlab代码实现）
12-21
综合能源系统零碳优化调度研究（Matlab代码实现）内容概要：本文围绕“综合能源系统零碳优化调度研究”，提供了基于Matlab代码实现的完整解决方案，重点探讨了在高比例可再生能源接入背景下，如何通过优化调度实现零碳排放目标。文中涉及多种先进优化算法（如改进遗传算法、粒子群优化、ADMM等）在综合能源系统中的应用，涵盖风光场景生成、储能配置、需求响应、微电网协同调度等多个关键技术环节，并结合具体案例（如压缩空气储能、光热电站、P2G技术等）进行建模与仿真分析，展示了从问题建模、算法设计到结果验证的全流程实现过程。; 适合人群：具备一定电力系统、能源系统或优化理论基础，熟悉Matlab/Simulink编程，从事新能源、智能电网、综合能源系统等相关领域研究的研究生、科研人员及工程技术人员。; 使用场景及目标：①开展综合能源系统低碳/零碳调度的科研建模与算法开发；②复现高水平期刊（如SCI/EI）论文中的优化模型与仿真结果；③学习如何将智能优化算法（如遗传算法、灰狼优化、ADMM等）应用于实际能源系统调度问题；④掌握Matlab在能源系统仿真与优化中的典型应用方法。; 阅读建议：建议结合文中提供的Matlab代码与网盘资源，边学习理论模型边动手调试程序，重点关注不同优化算法在调度模型中的实现细节与参数设置，同时可扩展应用于自身研究课题中，提升科研效率与模型精度。
基于微信小程序平台开发的顾客端智能点餐系统_实现扫码快速进入餐厅点餐界面_动态加载与展示后台菜品数据_支持用户将心仪菜品添加至虚拟购物车_可在购物车内灵活调整菜品数量或删除已选项目.zip
12-21
基于微信小程序平台开发的顾客端智能点餐系统_实现扫码快速进入餐厅点餐界面_动态加载与展示后台菜品数据_支持用户将心仪菜品添加至虚拟购物车_可在购物车内灵活调整菜品数量或删除已选项目.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值