树链刨分模板题 洛谷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;
}

 

[NOIP][C++]洛谷 P1395 会议(树的重心)
Dust的博客
07-16 1247
摘要 本文解决了一个在树形村庄中选择最佳会议地点的问题。给定n个村民和n-1条连接路径构成的树形结构，要求找到一个村民家作为会议地点，使得所有村民到该点的距离之和最小。通过两次深度优先搜索(DFS)实现：第一次DFS计算子树大小并确定树的重心（最优会议点），第二次DFS计算该点到所有其他点的距离之和。算法时间复杂度为O(n)，适用于大规模数据（n≤5×10^4）。最终输出最优会议点编号及最小距离和，若有多解则选择编号最小者。
洛谷 最短路径计数 Dijkstra模板题
hj2207010104的博客
06-05 783
共 N 行，每行一个非负整数，第 i 行输出从顶点 1 到顶点 i 有多少条不同的最短路，由于答案有可能会很大，你只需要输出 ansmod100003 后的结果即可。给出一个 N 个顶点 M 条边的无向无权图，顶点编号为 1∼N。接下来 M 行，每行 2 个正整数 x,y，表示有一条连接顶点 x 和顶点 y 的边，请注意可能有自环与重边。//存储第i条边的起点。//指针,表示第几条边。
P3995 树链剖分
orz
07-31 198
百紫斩第5天\color{purple}百紫斩第5天百紫斩第5天 洛谷 P3995P3995P3995 树链剖分 原题传送门 适合树剖新手做的题，代码简单，思路稍微有点难理解，便于新手提升水平。 题目大意 给定一棵树，请你给出一种剖分方案（即输出所有结点的重儿子），使所有询问操作总共访问的轻重链总条数最小，由于可能有许多合法方案，请任意输出一种，我们提供 SpecialJudgeSpecial JudgeSpecialJudge 检验你的方案的正确性。 解题思路 前置知识： lca，树上差分，对树剖的理解
树链剖分（重链剖分）
m0_73666576的博客
03-24 3658
本文主要针对于还没有学习过这个算法的新手同学
树链剖分 求 最近公共祖先（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 1187
深度刨析了树状数组的本质，适合初学者快速进阶树状数组。
【Floyd算法】全源最短路算法 洛谷P3647模板例题讲解
wayua的博客
08-01 1310
Floyd算法讲解，洛谷P3647模板含代码详解 全源最短路 图论
快速排序算法【C语言】&洛谷P1177 【模板】快速排序
qq_62440805的博客
02-11 2076
快速排序算法作为最基础的算法之一，同时也是我们最常用的算法，c++也自带了sort之一快速排序的算法来方便我们的使用，今天我们就一起来学习一下简单快排的原理。 洛谷的P1271就是这样的一个题目。事实就是，在昨晚之前，我从来没有去了解过快速排序的原理，在昨晚遇到这个题目，我查了一点资料，大概了解了一下快速排序的原理，它其实是对冒泡排序的一种优化，先从需要排序的数列中取定一个特殊值，将其余的数与其比较，小的放在一边，大的放在一边，这样我们就把需要排序的数组从一变成了二，再对这两个数组进行同样的操作，递归下去
树套树之线段树套线段树（BZOJ3110、洛谷P3332）
forezxl的博客
01-03 1321
线段树可以维护一个序列。当需要维护一个矩阵（即二维平面）内的数值，或者有什么奇怪的区间操作时，就需要用到二维线段树，也就是线段树“套上”线段树。
通过结合结合键力行为与机器学习方法来设计高熵陶瓷.zip
12-21
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
发动机故障检测数据集：1K+记录、11维传感器特征与多级故障标签CSV
12-21
该数据集通过合成方式模拟了多种发动机在运行过程中的传感器监测数据，旨在构建一个用于机械系统故障检测的基准资源，特别适用于汽车领域的诊断分析。数据按固定时间间隔采集，涵盖了发动机性能指标、异常状态以及工作模式等多维度信息。 时间戳：数据类型为日期时间，记录了每个数据点的采集时刻。序列起始于2024年12月24日10:00，并以5分钟为间隔持续生成，体现了对发动机运行状态的连续监测。 温度（摄氏度）：以浮点数形式记录发动机的温度读数。其数值范围通常处于60至120摄氏度之间，反映了发动机在常规工况下的典型温度区间。 转速（转/分钟）：以浮点数表示发动机曲轴的旋转速度。该参数在1000至4000转/分钟的范围内随机生成，符合多数发动机在正常运转时的转速特征。 燃油效率（公里/升）：浮点型变量，用于衡量发动机的燃料利用效能，即每升燃料所能支持的行驶里程。其取值范围设定在15至30公里/升之间。 振动_X、振动_Y、振动_Z：这三个浮点数列分别记录了发动机在三维空间坐标系中各轴向的振动强度。测量值标准化至0到1的标度，较高的数值通常暗示存在异常振动，可能与潜在的机械故障相关。 扭矩（牛·米）：以浮点数表征发动机输出的旋转力矩，数值区间为50至200牛·米，体现了发动机的负载能力。 功率输出（千瓦）：浮点型变量，描述发动机单位时间内做功的速率，取值范围为20至100千瓦。 故障状态：整型分类变量，用于标识发动机的异常程度，共分为四个等级：0代表正常状态，1表示轻微故障，2对应中等故障，3指示严重故障。该列作为分类任务的目标变量，支持基于传感器数据预测故障等级。 运行模式：字符串类型变量，描述发动机当前的工作状态，主要包括：怠速（发动机运转但无负载）、巡航（发动机在常规负载下平稳运行）、重载（发动机承受高负荷或高压工况）。 数据集整体包含1000条记录，每条记录对应特定时刻的发动机性能快照。其中故障状态涵盖从正常到严重故障的四级分类，有助于训练模型实现故障预测与诊断。所有数据均为合成生成，旨在模拟真实的发动机性能变化与典型故障场景，所包含的温度、转速、燃油效率、振动、扭矩及功率输出等关键传感指标，均为影响发动机故障判定的重要因素。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
DLMS/COSEM与HDLC通信协议标准文档及软件实现源码
12-21
本资料汇编了DLMS/COSEM通信规范的中英文技术文档及其配套实现代码，并涵盖HDLC通信协议的相关技术资料与源码。DLMS/COSEM协议由国际电工委员会主导制定，旨在为自动抄表系统及各类计量应用提供统一的数据采集、设备部署、运维管理及系统集成解决方案。该协议凭借卓越的系统兼容性与交互能力，已成为当前电能计量领域公认的完备通信标准体系，并正式纳入IEC国际标准序列，编号为IEC62056系列。基于上述标准，本研究设计了一款符合自动抄表技术演进需求的智能电能表。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
基于查询图消歧的自然语言问答系统实现
12-21
自然语言问答系统能够将用户提出的自然语言问题转换为蕴含语义结构的查询图表示。随后，该系统将查询图进一步转化为符合规范的SPARQL查询语句，并在图数据库环境中执行这些查询，从而获取并返回用户所需的答案信息。在实现过程中，系统采用基于数据驱动的消歧策略：于查询图构建阶段，系统会保留实体与谓词可能存在的多种候选链接方案；进入查询执行阶段后，则依据实际图谱中的匹配结果对前述候选链接进行筛选与消歧，以排除错误的链接指向。具体部署步骤请参见相关说明文档。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
工具变量-省级山水工程DID数据（2000-2025年）.xlsx
最新发布
12-21
详细介绍及样例数据：https://blog.youkuaiyun.com/T0620514/article/details/156134266
全面指南：数据分级分类与安全管控模板
资源摘要信息: "本资源集包含了与数据分级分类相关的标准、指南和模板。数据分级分类是信息技术领域中的一个重要实践，旨在根据数据的重要性、敏感性和风险程度对数据进行分类和分级。这样的管理策略对于保护数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值