zkw线段树

最新推荐文章于 2024-05-21 20:32:19 发布
最新推荐文章于 2024-05-21 20:32:19 发布
阅读量57 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/bennettz/p/8320435.html
版权

zkw线段树是一种用空间换取操作的简便性和时间常数的线段树。
它使线段树节点的存储位置有规律，从而将线段树的递归操作用循环替代

zkw线段树一般分为有区间修改和无区间修改两种,无区间修改的zkw线段树可以做到O(1)的单点查询,比有区间修改的要快

无区间修改的zkw线段树

建树

下面用一张图解释普通线段树和zkw线段树区别

我们发现zkw线段树是一棵完全二叉树，它的左右儿子的编号分别为父节点的2倍和2倍+1，并且叶子节点都在同一层

因为构造这棵完全二叉树会空出一些节点，所以节点数量要开到第一个>=n*2的2次幂(如果不计算可直接开到n*4)

void build(int n){//建树 
    M=1;while((M<<=1)<n);
    M--;
    for(int i=1;i<=n;i++)ma[i+M]=a[i];
    for(int i=M;i;i--){
        ma[i]=max(ma[i<<1],ma[i<<1|1]);
    }
}

单点修改

因为所有子节点都连续,所有直接找到子节点，修改后再向上更新祖先即可

void update(int x){//向上更新 
    while((x<<=1)){
        ma[x]=max(ma[x<<1],ma[x<<1|1]);
    }
}
void change_val(int x,int y){//单点修改 
    ma[x+M]=y;
    update(x+M);
}

单点查询

因为子节点连续，所以可以直接找到位置输出

int query_node(int x){//单点查询 
    return ma[x+M];
}

区间查询

如果区间的左右端点不是同一个父节点，
那么如果左端点是左子节点，则对应右子节点一定全在区间中,更新询问的值即可
同理如果右端点是右子节点，则对应左子节点一定全在区间中,同理,更新询问值
将左右端点变作自己的父亲，继续第一步的判断

如果区间的左右端点是同一个父节点,则所有区间都被统计了,直接返回即可

int query(int l,int r){//区间查询 
    int ans=0;
    for(l=l+M-1,r=r+M+1;l^r^1;l>>=1,r>>=1){
        if(~l&1)ans=max(ma[l^1],ans);
        if(r&1)ans=max(ma[r^1],ans);
    }
    return ans;
}

模板

  • 维护区间和

    void build(int n){//建树 
    M=1;while((M<<=1)<n);
    M--;
    for(int i=1;i<=n;i++)sum[i+M]=a[i];
    for(int i=M;i;i--){
        sum[i]=sum[i<<1]+sum[i<<1|1];
    }
}
void change(int x,int y){//单点修改 
    x+=M;
    sum[x]+=y;
    while((x>>=1)){
        sum[x]+=y;
    }
}
int query_node(int x){//单点查询 
    return sum[x+M];
}
int query(int l,int r){//区间查询 
    int ans=0;
    for(l=l+M-1,r=r+M+1;l^r^1;l>>=1,r>>=1){
        if(~l&1)ans+=sum[l^1];
        if(r&1)ans+=sum[r^1];
    }
    return ans;
}

  • 维护最值

    void build(int n){//建树 
    M=1;while((M<<=1)<n);
    M--;
    for(int i=1;i<=n;i++)ma[i+M]=a[i];
    for(int i=M;i;i--){
        ma[i]=max(ma[i<<1],ma[i<<1|1]);
    }
}
void update(int x){//向上更新 
    while((x>>=1)){
        ma[x]=max(ma[x<<1],ma[x<<1|1]);
    }
}
void change_val(int x,int y){//单点修改 
    ma[x+M]=y;
    update(x+M);
}
int query_node(int x){//单点查询 
    return ma[x+M];
}
int query(int l,int r){//区间查询 
    int ans=0;
    for(l=l+M-1,r=r+M+1;l^r^1;l>>=1,r>>=1){
        if(~l&1)ans=max(ma[l^1],ans);
        if(r&1)ans=max(ma[r^1],ans);
    }
    return ans;
}

     

例题

 延绵的山峰

#include<cstdio>
#include<algorithm>
using namespace std;
#define maxn 10000005
int ma[maxn<<2],a[maxn],M;
void build(int n){//建树 
    M=1;while((M<<=1)<n);
    M--;
    for(int i=1;i<=n;i++)ma[i+M]=a[i];
    for(int i=M;i;i--){
        ma[i]=max(ma[i<<1],ma[i<<1|1]);
    }
}
void update(int x){//向上更新 
    while((x<<=1)){
        ma[x]=max(ma[x<<1],ma[x<<1|1]);
    }
}
void change_val(int x,int y){//单点修改 
    ma[x+M]=y;
    update(x+M);
}
int query_node(int x){//单点查询 
    return ma[x+M];
}
int query(int l,int r){//区间查询 
    int ans=0;
    for(l=l+M-1,r=r+M+1;l^r^1;l>>=1,r>>=1){
        if(~l&1)ans=max(ma[l^1],ans);
        if(r&1)ans=max(ma[r^1],ans);
    }
    return ans;
}
int main(){
    freopen("climb.in","r",stdin);
    freopen("climb.out","w",stdout);
    int n,q,l,r;scanf("%d",&n),n++;
    for(int i=1;i<=n;i++)scanf("%d",a+i);
    build(n);
    scanf("%d",&q);
    for(int i=0;i<q;i++){
        scanf("%d%d",&l,&r);
        printf("%d\n",query(l+1,r+1));
    }
    return 0;
}

带区间修改的zkw线段树

  • 维护区间和

    维护区间和的zkw线段树我们和普通线段树一样打lazy标记

    建树和单点修改(同无区间修改)

    void build(int n){//建树 
    M=1;while((M<<=1)<n);
    M--;
    for(int i=1;i<=n;i++){
        sum[i+M]=a[i];
    } 
    for(int i=M;i>0;i--){
        sum[i]=sum[i<<1]+sum[i<<1|1]; 
    }
}
void change(int x,int y){//单点修改 
    x+=M;
    sum[x]+=y;
    while(x>>=1){
        sum[x]+=y;
    }
}

    区间修改

    区间修改的操作利用了上面区间查询的思想
    如果区间的左右端点不是同一个父节点，
    那么如果左端点是左子节点，则对应右子节点一定全在区间中,这时对右子节点打lazy标记，更新右子节点的sum
    同理如果右端点是右子节点，则对应左子节点一定全在区间中,对左子节点打lazy标记，更新维护的值
    将左右端点变作自己的父亲，继续第一步的判断

    当区间的左右端点是同一个父节点时,就没有lazy标记了,直接向上更新到根的路径上的节点即可

    void modify(int l,int r,int w){//区间修改
    if(l==r){change(l,w);return;}
    int d=1;
    sum[l+M]+=w,sum[r+M]+=w;//注:下面的操作不会更新端点的值，所以提前将端点更新 
    for(l+=M,r+=M;l^r^1;l>>=1,r>>=1){
        if(~l&1)sum[l^1]+=w*d,lazy[l^1]+=w;//在对应的右子节点打个标记，更新sum的值 
        if(r&1)sum[r^1]+=w*d,lazy[r^1]+=w;//在对应的左子节点打个标记，更新sum的值 
        d<<=1;
        sum[l>>1]=sum[l]+sum[l^1]+lazy[l>>1]*d;//更新两个父节点的值,其中d表示父节点表示区间的长度 
        sum[r>>1]=sum[r]+sum[r^1]+lazy[r>>1]*d;
    }
    while(l>>=1)d<<=1,sum[l]=sum[l<<1]+sum[l<<1|1]+lazy[l]*d;//更新路径上节点的sum值 
}

    单点查询

    查询叶子节点的值，然后加上到根节点的路径中的lazy标记即可

    int query_node(int l){//单点查询
    int x=l+M,ans=0;
    while(x>>=1){
        if(lazy[x])ans+=lazy[x];
    }
    return sum[l+M]+ans;
}

    区间查询

    由于统计时是由底部向顶部进行查询
    所以我们不像普通线段树那样下放lazy标记，而是在向上过程中统计lazy标记造成的影响

    代码大体和无区间修改的差不多

    LL query(int l,int r){//区间查询 (区间和)
    int L=0,R=0,d=1;//L，R分别记录所求区间中有多少个节点处于左右端点所在的节点中，d记录所在层次的节点代表的区间长度 
    LL ans=0;
    for(l=l+M-1,r=r+M+1;l^r^1;l>>=1,r>>=1){
        if(lazy[l])ans+=L*lazy[l];//计算lazy[l]影响的值 
        if(lazy[r])ans+=R*lazy[r];//计算lazy[r]影响的值 
        if(~l&1)ans+=sum[l^1],L+=d;//左端点所在的点是左子节点，则对应的右子节点处于区间中，更新L的值 
        if(r&1)ans+=sum[r^1],R+=d;
        d<<=1;
    }
    ans+=lazy[l]*L,ans+=lazy[r]*R,L+=R;
    while(l>>=1){//计算路径上的lazy造成的影响 
        if(lazy[l])ans+=lazy[l]*L;
    }
    return ans;
}

    例题P3372 【模板】线段树 1

    #include<cstdio>
#include<algorithm>
using namespace std;
#define maxn 100005
#define LL long long
LL sum[maxn<<2],a[maxn],M,lazy[maxn<<2],k;
void build(int n){//建树 
    M=1;while((M<<=1)<n);
    M--;
    for(int i=1;i<=n;i++){
        sum[i+M]=a[i];
    } 
    for(int i=M;i>0;i--){
        sum[i]=sum[i<<1]+sum[i<<1|1]; 
    }
}
void change(int x,int y){//单点修改 
    x+=M;
    sum[x]+=y;
    while(x>>=1){
        sum[x]+=y;
    }
}
void modify(int l,int r,int w){//区间修改
    if(l==r){change(l,w);return;}
    int d=1;
    sum[l+M]+=w,sum[r+M]+=w;//注:下面的操作不会更新端点的值，所以提前将端点更新 
    for(l+=M,r+=M;l^r^1;l>>=1,r>>=1){
        if(~l&1)sum[l^1]+=w*d,lazy[l^1]+=w;//在对应的右子节点打个标记，更新sum的值 
        if(r&1)sum[r^1]+=w*d,lazy[r^1]+=w;//在对应的左子节点打个标记，更新sum的值 
        d<<=1;
        sum[l>>1]=sum[l]+sum[l^1]+lazy[l>>1]*d;//更新两个父节点的值,其中d表示父节点表示区间的长度 
        sum[r>>1]=sum[r]+sum[r^1]+lazy[r>>1]*d;
    }
    while(l>>=1)d<<=1,sum[l]=sum[l<<1]+sum[l<<1|1]+lazy[l]*d;//更新路径上节点的sum值 
}
int query_node(int l){//单点查询
    int x=l+M,ans=0;
    while(x>>=1){
        if(lazy[x])ans+=lazy[x];
    }
    return sum[l+M]+ans;
}
LL query(int l,int r){//区间查询 (区间和)
    int L=0,R=0,d=1;//L，R分别记录所求区间中有多少个节点处于左右端点所在的节点中，d记录所在层次的节点代表的区间长度 
    LL ans=0;
    for(l=l+M-1,r=r+M+1;l^r^1;l>>=1,r>>=1){
        if(lazy[l])ans+=L*lazy[l];//计算lazy[l]影响的值 
        if(lazy[r])ans+=R*lazy[r];//计算lazy[r]影响的值 
        if(~l&1)ans+=sum[l^1],L+=d;//左端点所在的点是左子节点，则对应的右子节点处于区间中，更新L的值 
        if(r&1)ans+=sum[r^1],R+=d;
        d<<=1;
    }
    ans+=lazy[l]*L,ans+=lazy[r]*R,L+=R;
    while(l>>=1){//计算路径上的lazy造成的影响 
        if(lazy[l])ans+=lazy[l]*L;
    }
    return ans;
}
int main(){
    int n,q,x,l,r;scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++)scanf("%lld",a+i);
    build(n);
    for(int i=0;i<q;i++){
        scanf("%d",&x);
        if(x==1){
            scanf("%d%d%lld",&l,&r,&k);
            modify(l,r,k);
        }
        else{
            scanf("%d%d",&l,&r);
            printf("%lld\n",query(l,r));
        }
    }
    return 0;
}

  • 维护最大值

    维护最大值时可以不用lazy标记,但需要用到差分思想，即每个节点只存储与父节点的差值

    建树

    和无区间修改的建树差不多,只是每个节点最后要减去父节点的值

    void build(int n){//建树 
    M=1;
    while((M<<=1)<n);
    M--;
    for(int i=0;i<n;i++){
        mi[i+M]=a[i];
    }
    for(int i=M;i;i--){
        mi[i]=min(mi[i<<1],mi[i<<1|1]);
        mi[i<<1]-=mi[i],mi[i<<1|1]-=mi[i];//节点存储与父节点的差值 
    }
}

    单点修改

    和无区间修改的基本一样,只是更新父节点方法不同

    void change(int x,int w){//单点修改 
    x+=M;mi[x]+=w;
    int tmp;
    while(x>>=1){//更新祖先的值 
        tmp=min(mi[x<<1],mi[x<<1|1]);
        mi[x]+=tmp,mi[x<<1]-=tmp,mi[x<<1|1]-=tmp;
    }
}

    区间修改

    还是利用的区间查询的那种思想
    如果区间的左右端点不是同一个父节点，
    那么如果左端点是左子节点，则对应右子节点一定全在区间中,更新右子节点
    同理如果右端点是右子节点，则对应左子节点一定全在区间中,更新左子节点
    更新它们的父亲节点并将左右端点变作自己的父亲，继续第一步的判断

    当区间的左右端点是同一个父节点时,直接向上更新到根的路径上的节点即可

    void modify(int l,int r,int w){//区间修改
    int tmp;
    for(l+=M-1,r+=M+1;l^r^1;l>>=1,r>>=1){
        if(~l&1)mi[l^1]+=w;//如果为左端为左子节点，则右子节点一定被包含,更新值 
        if(r&1)mi[r^1]+=w;//如果为右端为右子节点同理 
        tmp=min(mi[l],mi[l^1]),mi[l]-=tmp,mi[l^1]-=tmp,mi[l>>1]+=tmp;//更新左右端父节点的值 
        tmp=min(mi[r],mi[r^1]),mi[r]-=tmp,mi[r^1]-=tmp,mi[r>>1]+=tmp; 
    }
    while(l>>=1){//更新到根的路径的值 
        tmp=min(mi[l<<1],mi[l<<1|1]),mi[l<<1]-=tmp,mi[l<<1|1]-=tmp,mi[l]+=tmp;
    }
}

    单点查询

    找到叶子节点,答案就是它到根节点路径上值的和

    int query_node(int x){//单点查询 
    x+=M;
    int ans=mi[x];
    while(x>>=1)ans+=mi[x];//因为存的为与父节点的差，所以答案要加上所有路径上的点的值 
    return ans;
}

    区间查询

    用两个整数L,R记录左右端点所在节点表示的区间与所求区间交集的最小值(最小值是与父亲的差值)
    如果区间的左右端点不是同一个父节点，更新这两个整数
    那么如果左端点是左子节点，则对应右子节点一定全在区间中,用它更新L的值
    同理如果右端点是右子节点，则对应左子节点一定全在区间中,用它更新R的值
    将左右端点变作自己的父亲，继续第一步的判断

    当区间的左右端点是同一个父节点时,合并L,R,然后加上到根节点路径上的值

    int query(int l,int r){//区间查询 
    if(l==r)return query_node(l);//特判单点查询，否则会死循环 
    int ans,L=0,R=0;
    for(l+=M,r+=M;l^r^1;l>>=1,r>>=1){
        L+=mi[l],R+=mi[r];//L,R表示左右端点所在节点表示的区间与所求区间交集的最小值 
        if(~l&1)L=min(L,mi[l^1]);//如果为左端为左子节点，则右子节点一定被包含,更新值
        if(r&1)R=min(R,mi[r^1]);//如果为右端为右子节点同理
    }
    L+=mi[l],R+=mi[r],ans=min(L,R);//答案要加上路径上所有的点的值
    while(l>>=1){
        ans+=mi[l];
    }
    return ans;
}

    例题codevs1291 火车线路

    #include<cstdio>
#include<algorithm>
using namespace std;
#define maxn 1<<17
#define inf 0x3fffffff
int mi[maxn],M,s,a[maxn];
void build(int n){
    M=1;
    while((M<<=1)<n);
    M--;
    for(int i=0;i<n;i++){
        mi[i+M]=a[i];
    }
    for(int i=M;i;i--){
        mi[i]=min(mi[i<<1],mi[i<<1|1]);
        mi[i<<1]-=mi[i],mi[i<<1|1]-=mi[i];
    }
}
void change(int x,int w){
    x+=M;mi[x]+=w;
    int tmp;
    while(x>>=1){
        tmp=min(mi[x<<1],mi[x<<1|1]);
        mi[x]+=tmp,mi[x<<1]-=tmp,mi[x<<1|1]-=tmp;
    }
}
void modify(int l,int r,int w){
    if(l==r){change(l,w);return;}
    int tmp;
    mi[l+M]+=w,mi[r+M]+=w;
    for(l+=M,r+=M;l^r^1;l>>=1,r>>=1){
        if(~l&1)mi[l^1]+=w;
        if(r&1)mi[r^1]+=w;
        tmp=min(mi[l],mi[l^1]),mi[l]-=tmp,mi[l^1]-=tmp,mi[l>>1]+=tmp;
        tmp=min(mi[r],mi[r^1]),mi[r]-=tmp,mi[r^1]-=tmp,mi[r>>1]+=tmp;
    }
    while(l>>=1){ 
        tmp=min(mi[l<<1],mi[l<<1|1]),mi[l<<1]-=tmp,mi[l<<1|1]-=tmp,mi[l]+=tmp;
    }
}
int query_node(int x){
    x+=M;
    int ans=mi[x];
    while(x>>=1)ans+=mi[x];
    return ans;
}
int query(int l,int r){
    if(l==r)return query_node(l);
    int ans,L=0,R=0;
    for(l+=M,r+=M;l^r^1;l>>=1,r>>=1){
        L+=mi[l],R+=mi[r];
        if(~l&1)L=min(L,mi[l^1]);
        if(r&1)R=min(R,mi[r^1]);
    }
    L+=mi[l],R+=mi[r],ans=min(L,R);
    while(l>>=1){
        ans+=mi[l];
    }
    return ans;
}
int main(){
    int n,m,l,r,w,x;scanf("%d%d%d",&n,&s,&m);
    build(n);
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&l,&r,&w);
        x=query(l,r-1);
        if(x<w)printf("N\n");
        else{
            printf("T\n");
            modify(l,r-1,-w);
        }
    }
    return 0;
}

     

转载于:https://www.cnblogs.com/bennettz/p/8320435.html

weixin_30627341
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
zkw线段树（详解）
weixin_43823476的博客
06-19 2569
定义 我们已经了解了线段树的许多操作与结构 但是有一些缺点： 1.它是递归操作的 所以空间可能会很大 2.叶子节点深度都不同 这样操作会很麻烦 3.代码量太大... 所以现在可以引进zkw线段树 和普通的线段树相比，zkw线段树主要有这样几个不同点： 1.所有的叶子结点都在同一深度 2.在左右两端各增加了一个哨兵 3.每个点可以根据自己的编号计算父节点编号 以上三点保证了...
zkw 线段树
shk0010的博客
08-05 258
ZKW线段树 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带...
数据结构-ZKW线段树 详解
HeartFireY的博客
06-04 2704
一、ZKW线段树简介 ZKW线段树是由清华大学张昆玮所创立的一种线段树储存结构，由于其基于非递归的实现方式以及精简的代码和较高的效率而闻名。甚至，ZKW线段树能够可持久化。 我们从算法的角度对基础线段树进行分析：其实线段树算法本身的本质仍是统计。因此我们可以从统计的角度入手对线段树进行分析：线段树是将一个个数
zkw线段树详解
热门推荐
keshuqi的博客
08-14 4万+
转载自：http://blog.csdn.net/qq_18455665/article/details/50989113 前言 首先说说出处：清华大学 张昆玮(zkw) - ppt 《统计的力量》本文(辣鸡)编辑：BeiYu写这篇博客的原因：  1.zkw线段树非递归，效率高，代码短  2.网上关于zkw线段树的讲解实在是太少了  3.个人感觉很实用 更新日志
zkw线段树——简单易懂好写好调的线段树
DD(XYX)的硫氰化氘博客
09-03 1447
用了zkw线段树几年了，一直想着要写篇总结
ZKW线段树
时间次元的博客
11-12 164
单点修改： #include &lt;cstdio&gt; #define maxn 100005 using namespace std; long long tree[maxn &lt;&lt; 2]; int n, m, M; void Add(long long s, long long val){     for (tree[s = s + M] += val; s &gt;...
zkw线段树:高效的单点/区间修改+查询（原理+扩展技巧）
偶耶的博客
08-26 3935
出处：清华大学 张昆玮(zkw) - ppt《统计的力量》 重口味线段树不仅比普通线段树速度快、空间小，而且码量小得多，循环结构思路也很清晰，很适合用来优化Dijkstra和套在树剖以及树套树上。
【线段树】ZKW线段树浅谈
BLNG
09-03 603
（学了学一般的线段树，还学了学线段树合并还有扫描线什么的，然后就就看到有一个比较有意思的线段树，，就学了一下） 这里，，警告！ zkw这东西，犹如鸡肋之令，食之无味，弃之可惜，没有太大的作用，本菜鸡就是敲一下板子了解一下即可。。。。。 进入正题，，，， 安利博客：洛谷日报，SinGuLaRiTy，Judge 关于zkw线段树 zkw线段树，就是从底到上建线段树，抛弃掉之前的由上到下不断递归的建树...
ZKW线段树模板类
08-06
zkw线段树模板类，可动态统计区间最大值。代码略作修改即可动态统计区间和
ZKW线段树源码-pascal
03-10
ZKW线段树的实现源码-pascal版，可保证其正确性并在logN时间复杂度类进行区间操作
【zkw线段树讲稿】统计的力量-线段树.pdf
04-14
【zkw线段树讲稿】统计的力量-线段树.pdf
统计的力量(zkw线段树)
06-09
传说中的ZKW线段树 比一般线段树快 这个是ZKW讲课的课件 线段树是二叉搜索树的一种。与一般的二叉搜索树不同的是，线段树保存的是所有元素可能取的值，而不是每个元素。通常情况下，线段树只用叶节点表示每个值。而...
（二刷）代码随想录第8天|344.反转字符串● 541. 反转字符串II
lilith_2001的博客
05-16 486
给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组。如果剩余字符少于 k 个，则将剩余字符全部反转。输入: s = "abcdefg", k = 2。、使用 O(1) 的额外空间解决这一问题。不要给另外的数组分配额外的空间，你必须。输出: "bacdfeg"
【动态规划】训练
最新发布
m0_74183164的博客
05-21 192
这题硬币很像，就是判断条件不同。只有偶数才能转移。输入一个长为n的序列，输出这个序列最长上升子序列的长度。
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环）
<font color="Pink">Tisfy的博客</font>
05-18 856
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环） 给你两个下标从 0 开始的整数数组 nums 和 divisors 。 divisors[i] 的 可整除性得分 等于满足 nums[j] 能被 divisors[i] 整除的下标 j 的数量。 返回 可整除性得分 最大的整数 divisors[i] 。如果有多个整数具有最大得分，则返回数值最小的一个。
链式结构二叉树的应用
Frenemy__的博客
05-21 673
本文将对链式结构二叉树的几种功能进行实现与讲解在链表结构二叉树中，递归的使用是必不可少的，在使用的过程中，要时常问问自己：这个递归结构可不可以这样用？具体的逻辑实现过程是怎样的？只有这样，才能学好链表结构二叉树。！！
算法设计与分析——（各种解决问题的方法）之分治算法、动态规划算法
2302_76516899的博客
05-14 1047
算法设计与分析——（各种解决问题的方法）之分治算法、动态规划算法
zkw线段树的python实现
05-10
以下是 zkw 线段树的 Python 实现： ```python class ZkwSegmentTree: def __init__(self, n): self.sz = 1 while self.sz self.sz self.tree = [0] * (2 * self.sz) def update(self, i, val): i += ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值