线段树练习题(C/C++)

已于 2022-11-12 15:48:30 修改
阅读量448 收藏 1
点赞数
分类专栏： 算法习题 文章标签： 算法 c语言 c++
于 2022-11-06 21:08:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51566349/article/details/127642609
版权

文章目录

1. 线段树核心总结

 a.查询/修改操作步骤：分两个步骤
在这里插入图片描述
 b.标记下放完成：标记要恢复默认值

2. 一般区间——查询(无lazy标记等)

 题目链接： 洛谷 P3374
 题目分析：单点修改+区间查询
 修改子区间信息时同时维护父区间信息即可
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#define lrt rt << 1
#define rrt rt << 1 | 1
typedef long long LL;
using namespace std;
const int N = 5e5 + 10;
LL tree[N << 2];
LL n, m;
void push_up(LL rt){
    tree[rt] = tree[lrt] + tree[rrt];
}
void build_tree(LL rt, LL st, LL ed){
    if(st == ed){
        cin >> tree[rt];
        return ;
    }

    LL mid = (st + ed) >> 1;
    build_tree(lrt, st, mid);
    build_tree(rrt, mid + 1, ed);
    push_up(rt);
    return ;
}

void update(LL rt, LL st, LL ed, LL l, LL r, LL k){
    if(st >= l && ed <= r){
        tree[rt] += k;
        return ;
    }

    LL mid = (st + ed) >> 1;
    if(l <= mid) update(lrt, st, mid, l, r, k);
    if(r > mid) update(rrt, mid + 1, ed, l, r, k);
    push_up(rt);
    return ;
}
LL query(LL rt, LL st, LL ed, LL l, LL r){
    if(st >= l && ed <= r){
        return tree[rt];
    }

    LL sum = 0;
    LL mid = (st + ed) >> 1;
    if(l <= mid) sum += query(lrt, st, mid, l, r);
    if(r > mid) sum += query(rrt, mid + 1, ed, l ,r);
    return sum;
}

int main(){
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n >> m;

    build_tree(1, 1, n);
    LL x, y, op;
    while(m --){
        cin >> op >> x >> y;
        if(op == 1){
            update(1, 1, n, x, x, y);
        }
        else{
            LL res = query(1, 1, n, x, y);
            cout << res << endl;
        }
    }

}

 题目链接： POJ 3264
 题目分析：区间内最值信息
 利用子区间去更改父区间信息即可
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#define lrt rt << 1
#define rrt rt << 1 | 1
using namespace std;
const int N = 5e4 + 10;
int mx[N << 2], mn[N << 2], h[N];
int n, q, low_h, tall_h;
void push_up(int rt, int st, int ed){
    mn[rt] = min(mn[lrt], mn[rrt] );
    mx[rt] = max(mx[lrt], mx[rrt] );
}

void build_tree(int rt, int st, int ed){
    if(st == ed){
        mn[rt] = mx[rt] = h[st];
        return ;
    }

    int mid = (st + ed) >> 1;
    build_tree(lrt, st, mid);
    build_tree(rrt, mid + 1, ed);
    push_up(rt, st, ed);
}

void query(int rt, int st, int ed, int l, int r){
    if(st >= l && ed <= r){
        low_h = min(low_h, mn[rt] );
        tall_h = max(tall_h, mx[rt] );
        return ;
    }

    int mid = (st + ed) >> 1;
    if(l <= mid) query(lrt, st, mid, l, r);
    if(r > mid) query(rrt, mid + 1, ed, l, r);
}

int main(){
    ios::sync_with_stdio(false); cin.tie(0);

    scanf("%d%d", &n, &q);
    for(int i = 1; i <= n; i ++ ) scanf("%d", &h[i]);

    build_tree(1, 1, n);

    for(int i = 0; i < q; i ++ ){
        int a, b;
        scanf("%d%d", &a, &b);
        low_h = 1e6 + 10, tall_h = -1;
        query(1, 1, n, a, b);
        printf("%d\n",tall_h - low_h);
    }

}

3. 加减区间——修改与查询

 题目链接： 洛谷 P3372
 题目分析：区间加法
 lazy标记使用：暂时存放对数值的修改,等到下次需要向下搜索再下放标记
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#define lrt rt << 1
#define rrt rt << 1 | 1
typedef long long LL;
using namespace std;
const int N = 1e5 + 10;
LL tree[N << 2], lazy[N << 2];
LL n, m;
void push_down(LL rt, LL st, LL ed){ //标记下放进行信息修改 + 标记清0
    if(lazy[rt]){
        int mid = (st + ed) >> 1;
        tree[lrt] += (mid - st + 1) * lazy[rt];
        tree[rrt] += (ed - mid) * lazy[rt];
        lazy[lrt] += lazy[rt], lazy[rrt] += lazy[rt];
        lazy[rt] = 0;
    }
}
void push_up(LL rt){
    tree[rt] = tree[lrt] + tree[rrt];
}
void build_tree(LL rt, LL st, LL ed){
    if(st == ed){
        cin >> tree[rt];
        return ;
    }

    LL mid = (st + ed) >> 1;
    build_tree(lrt, st, mid);
    build_tree(rrt, mid + 1, ed);
    push_up(rt);
    return ;
}

void update(LL rt, LL st, LL ed, LL l, LL r, LL k){
    if(st >= l && ed <= r){
        tree[rt] += (ed - st + 1) * k;
        lazy[rt] += k;
        return ;
    }

    push_down(rt, st, ed);
    LL mid = (st + ed) >> 1;
    if(l <= mid) update(lrt, st, mid, l, r, k);
    if(r > mid) update(rrt, mid + 1, ed, l, r, k);
    push_up(rt);
    return ;
}
LL query(LL rt, LL st, LL ed, LL l, LL r){
    if(st >= l && ed <= r){
        return tree[rt];
    }

    push_down(rt, st, ed);
    LL sum = 0;
    LL mid = (st + ed) >> 1;
    if(l <= mid) sum += query(lrt, st, mid, l, r);
    if(r > mid) sum += query(rrt, mid + 1, ed, l ,r);
    return sum;
}

int main(){
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n >> m;

    build_tree(1, 1, n);
    LL x, y, k, op, res;
    while(m --){
        cin >> op;
        if(op == 1){
            cin >> x >> y >> k;
            update(1, 1, n, x, y, k);
        }
        else{
            cin >> x >> y;
            res = query(1, 1, n, x, y);
            cout << res << endl;
        }
    }
    
}

4. 乘除区间——修改与查询

 题目链接： 洛谷 P3373
 题目分析：区间乘法
  A. 注意乘法mul[ ]标记默认值：1
  B. 注意标记下放顺序：先下放乘法再下放加法(方便对标记的修改)
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#define lrt rt << 1
#define rrt rt << 1 | 1
typedef long long LL;
using namespace std;
const int N = 1e5 + 10;
LL tree[N << 2], mul[N << 2], add[N << 2];
LL n, m, mod;
void push_down(LL rt, LL st, LL ed){ //标记下放顺序 乘法—加法
    if(mul[rt] != 1){ // mul的默认值是1
        LL k = mul[rt];
        tree[lrt] = tree[lrt] * k % mod;
        tree[rrt] = tree[rrt] * k % mod;
        mul[lrt] = mul[lrt] * k % mod, add[lrt] = add[lrt] * k % mod;
        mul[rrt] = mul[rrt] * k % mod, add[rrt] = add[rrt] * k % mod;
        mul[rt] = 1;
    }
    if(add[rt]){ // add的默认值是0
        LL mid = (st +ed) >> 1;
        LL k = add[rt];
        tree[lrt] = (tree[lrt] + (mid - st +1) * k) % mod;
        tree[rrt] = (tree[rrt] + (ed - mid) * k) % mod;
        add[lrt] = (add[lrt] + k) % mod;
        add[rrt] = (add[rrt] + k) % mod;
        add[rt] = 0;
    }
}
void push_up(LL rt){
    tree[rt] = (tree[lrt] + tree[rrt]) % mod;
}
void build_tree(LL rt, LL st, LL ed){
    if(st == ed){
        cin >> tree[rt];
        tree[rt] %= mod;
        return ;
    }

    LL mid = (st + ed) >> 1;
    build_tree(lrt, st, mid);
    build_tree(rrt, mid + 1, ed);
    push_up(rt);
    return ;
}
void upd_mul(LL rt, LL st, LL ed, LL l, LL r, LL k){
    if(st >= l && ed <= r){
        tree[rt] = tree[rt] * k % mod ;
        mul[rt] = mul[rt] * k % mod;
        add[rt] = add[rt] * k % mod;
        return ;
    }

    push_down(rt, st, ed);
    LL mid = (st + ed) >> 1;
    if(l <= mid) upd_mul(lrt, st, mid, l, r, k);
    if(r > mid) upd_mul(rrt, mid + 1, ed, l, r, k);
    push_up(rt);
    return ;
}
void upd_add(LL rt, LL st, LL ed, LL l, LL r, LL k){
    if(st >= l && ed <= r){
        add[rt] = (add[rt] + k) % mod;
        tree[rt] = (tree[rt] + (ed - st + 1) * k) % mod;
        return ;
    }

    push_down(rt, st, ed);
    LL mid = (st + ed) >> 1;
    if(l <= mid) upd_add(lrt, st, mid, l, r, k);
    if(r > mid) upd_add(rrt, mid + 1, ed, l, r, k);
    push_up(rt);
    return ;
}
LL query(LL rt, LL st, LL ed, LL l, LL r){
    if(st >= l && ed <= r){
        return tree[rt];
    }

    push_down(rt, st, ed);
    LL sum = 0;
    LL mid = (st + ed) >> 1;
    if(l <= mid) sum += query(lrt, st, mid, l, r) % mod;
    if(r > mid) sum += query(rrt, mid + 1, ed, l ,r) % mod;
    return sum % mod;
}


int main(){
    for(int i = 0; i < N << 2; i ++ ) mul[i] = 1;

    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n >> m >> mod;

    build_tree(1, 1, n);
    LL x, y, k, op, res;
    while(m --){
        cin >> op;
        if(op == 1){
            cin >> x >> y >> k;
            upd_mul(1, 1, n, x, y, k);
        }
        else if(op == 2){
            cin >> x >> y >> k;
            upd_add(1, 1, n, x, y, k);
        }
        else{
            cin >> x >> y;
            res = query(1, 1, n, x, y);
            cout << res % mod << endl;
        }
    }
    
}

 题目链接： BZOJ 3211
 题目分析： 区间根号
 其实正常优化一个区间根号是可以记录区间内最大值最小值，如果最大值最小值取根号结果一样则可以对区间进行整体操作，然后写一个根号次数标记下放即可。
 但其实因为一个数即使是Long long 我们也可以在5次左右开根号操作下令其值降到1，其实当某区间最大值为1的时候就可以直接返回了，所以我们可以优化代码只需要保存区间最大值+区间和即可。
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#define lrt rt << 1
#define rrt rt << 1 | 1
typedef long long LL;
using namespace std;
const int N = 1e5 + 10;
LL tree[N << 2], mx[N << 2];
LL n, m;
void push_up(int rt){
    tree[rt] = tree[lrt] + tree[rrt];
    mx[rt] = max(mx[lrt], mx[rrt]);
}
void build_tree(int rt, int st, int ed){
    if(st == ed){
        scanf("%d", &tree[rt]);
        mx[rt] = tree[rt];
        return ;
    }

    int mid = (st + ed) >> 1;
    build_tree(lrt, st, mid);
    build_tree(rrt, mid + 1, ed);
    push_up(rt);
    return ;
}
LL query(int rt, int st, int ed, int l, int r){
    if(st >= l && ed <= r){
        return tree[rt];
    }

    int mid = (st + ed) >> 1;
    LL sum = 0;
    if(l <= mid) sum += query(lrt, st, mid, l, r);
    if(r > mid) sum += query(rrt, mid + 1, ed, l, r);
    return sum;
}
void update(int rt, int st, int ed, int l, int r){
    if(mx[rt] <= 1) return ;

    if(st == ed){
        mx[rt] = tree[rt] = sqrt(tree[rt]);
        return ;
    }

    int mid = (st + ed) >> 1;
    if(l <= mid) update(lrt, st, mid, l, r);
    if(r > mid) update(rrt, mid + 1, ed, l, r);
    push_up(rt);
    return ;
}

int main(){
    scanf("%d", &n);
    build_tree(1, 1, n);
    scanf("%d", &m);
    while(m --){
        int op, x, y;
        scanf("%d%d%d", &op, &x, &y);
        if(op == 1){
            LL res = query(1, 1, n, x, y);
            printf("%lld\n",res);
        }
        else update(1, 1, n, x, y);
    }
}

5. 其他问题类型

 题目链接： POJ 2777
 题目分析：线段树 + 二进制状态表示
  lazy标记表示其颜色状态 + 二进制表示其颜色选择
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#define lrt rt << 1
#define rrt rt << 1 | 1
typedef long long LL;
using namespace std;
const int N = 1e5 + 10;
LL tree[N << 2], mx[N << 2];
LL n, m;
void push_up(int rt){
    tree[rt] = tree[lrt] + tree[rrt];
    mx[rt] = max(mx[lrt], mx[rrt]);
}
void build_tree(int rt, int st, int ed){
    if(st == ed){
        scanf("%d", &tree[rt]);
        mx[rt] = tree[rt];
        return ;
    }

    int mid = (st + ed) >> 1;
    build_tree(lrt, st, mid);
    build_tree(rrt, mid + 1, ed);
    push_up(rt);
    return ;
}
LL query(int rt, int st, int ed, int l, int r){
    if(st >= l && ed <= r){
        return tree[rt];
    }

    int mid = (st + ed) >> 1;
    LL sum = 0;
    if(l <= mid) sum += query(lrt, st, mid, l, r);
    if(r > mid) sum += query(rrt, mid + 1, ed, l, r);
    return sum;
}
void update(int rt, int st, int ed, int l, int r){
    if(mx[rt] <= 1) return ;

    if(st == ed){
        mx[rt] = tree[rt] = sqrt(tree[rt]);
        return ;
    }

    int mid = (st + ed) >> 1;
    if(l <= mid) update(lrt, st, mid, l, r);
    if(r > mid) update(rrt, mid + 1, ed, l, r);
    push_up(rt);
    return ;
}

int main(){
    scanf("%d", &n);
    build_tree(1, 1, n);
    scanf("%d", &m);
    while(m --){
        int op, x, y;
        scanf("%d%d%d", &op, &x, &y);
        if(op == 1){
            LL res = query(1, 1, n, x, y);
            printf("%lld\n",res);
        }
        else update(1, 1, n, x, y);
    }
}

 题目链接： 洛谷 P4198
 题目分析：叶子节点存储斜率 + 信息维护
  tree[ ]维护区间上升斜率长度，mx[ ]维护区间斜率最值 ，信息转移部分优化
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#define lrt rt << 1
#define rrt rt << 1 | 1
typedef long long LL;
using namespace std;
const int N = 1e5 + 10;
int tree[N << 2];
double mn[N << 2], mx[N << 2]; // 可以看到的楼房的斜率最小值和最大值
int n, m;
int query(int rt, int st, int ed, double k){ //查找区间内斜率大于k的上升序列长度
    if(mn[rt] > k) return tree[rt];
    if(mx[rt] <= k) return 0;
    int mid = (rt + ed) >> 1;
    /* 易错点 1 : 直接将左右区间合法的数量求出 ,但会 T L
    int res = 0;
    res += query(lrt, st, mid, k);
    k = max(mx[lrt], k);
    res += query(rrt, mid + 1, ed, k);
    return res;
    */
    /* 优化：若左边最大值比k小直接搜右边即可，若左边最大值比k大，则左边合法 + 已经算出的右边合法结果(不需要再去搜索)
    // 易错点 2 : 注意不可以直接使用tree[rrt], 因为 tree[rt] != tree[lrt] + tree[rrt]
    // tree[rt] = tree[lrt] + tree[rrt]当中的合法数量
    if(mx[lrt] <= k) return query(rrt, mid + 1, ed, k);
    else return query(lrt, st, mid, k) + tree[rrt];
    */

    // 正解
    if(mx[lrt] <= k ) return query(rrt, mid + 1, ed, k);
    else return query(lrt, st, mid, k) + tree[rt] - tree[lrt]; // 直接总合法数量减去左边合法数量 = 右边合法数量

}
void push_up(int rt, int st, int ed){
    mn[rt] = mn[lrt];
    mx[rt] = max(mx[lrt], mx[rrt]);
    int mid = (st + ed) >> 1;
    double k = mx[lrt];
    tree[rt] = tree[lrt] + query(rrt, mid + 1, ed, k);
    return ;
}

void update(int rt, int st, int ed, int l, int r, int k){
    if(st == ed){
        mx[rt] = mn[rt] = (double) k / st;
        tree[rt] = 1;
        return ;
    }

    int mid = (st + ed) >> 1;
    if(l <= mid) update(lrt, st, mid, l, r, k);
    if(r > mid) update(rrt, mid + 1, ed, l, r, k);
    push_up(rt, st, ed);
    return ;
}

int main(){
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n >> m;

    int x, y;
    while(m --){
        cin >> x >> y;
        update(1, 1, n, x, x, y);
        cout << tree[1] << endl;
    }

}

 题目链接： CF1199D
 题目分析：单点修改 + 区间条件修改 + 单点查询
 mx[ ]存储单点最值，lazy标记是否进行区间修改
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#define lrt rt << 1
#define rrt rt << 1 | 1
typedef long long LL;
using namespace std;
const int N = 2e5 + 10;
int mx[N << 2], lazy[N << 2], a[N << 2];
int n, q, op, p, x;
void push_down(int rt, int st, int ed){
    if(lazy[rt] != -1){
        mx[lrt] = max(mx[lrt], lazy[rt]);
        mx[rrt] = max(mx[rrt], lazy[rt]);
        lazy[lrt] = max(lazy[lrt], lazy[rt]);
        lazy[rrt] = max(lazy[rrt], lazy[rt]);
        lazy[rt] = -1;
    }
}
void build(int rt, int st, int ed, int l, int r){
    if(st == ed){
        mx[rt] = a[st];
        return ;
    }
    mx[rt] = -1 ,lazy[rt] = -1;
    int mid = (st + ed) >> 1;
    if(l <= mid) build(lrt, st, mid, l, r);
    if(r > mid) build(rrt, mid + 1, ed, l, r);
}
void update1(int rt, int st, int ed, int l, int r, int k){
    if(st == ed){
        mx[rt] = k;
        return ;
    }
    push_down(rt, st, ed);
    int mid = (st + ed) >> 1;
    if(l <= mid) update1(lrt, st, mid, l, r, k);
    if(r > mid) update1(rrt, mid + 1, ed, l, r, k);
}
void update2(int rt, int st, int ed, int k){
    mx[rt] = max(mx[rt], k);
    lazy[rt] = max(lazy[rt], k);
    return;
}
int query(int rt, int st, int ed, int l, int r){
    if(st == ed){
        return mx[rt];
    }
    push_down(rt, st, ed);
    int mid = (st + ed) >> 1;
    if(l <= mid) return query(lrt, st, mid, l, r);
    if(r > mid) return query(rrt, mid + 1, ed, l, r);

}
int main(){
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);
    build(1, 1, n, 1, n);
    scanf("%d", &q);

    while(q -- ){
        scanf("%d", &op);
        if(op == 1){
            scanf("%d%d", &p, &x);
            update1(1, 1, n, p, p, x);
        }
        else{
            scanf("%d", &x);
            update2(1, 1, n, x);
        }
    }

    for(int i = 1; i <= n; i ++ ){
        cout << query(1, 1, n, i, i) << ' ';
    }

}

 题目链接： POJ 2991
 题目分析：区间向量信息修改 + 父节点信息维护
  tx[ ] ,ty[ ] 分别表示这个区间x , y方向向量长度
  tdeg[ ] 相当于lazy标记，标记这个区间是否需要整体转动
  Π的大小表示 #define PI acos(-1.0)
 代码解析:

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#define lrt rt << 1
#define rrt rt << 1 | 1
#define PI acos(-1.0)
using namespace std;
const int N = 1e4 + 10;
double tx[N << 2], ty[N << 2];// 区间的x, y长度
int tdeg[N << 2], a[N], deg[N], n, q; // deg : 子区间需要转动的角度
void rotate(int rt, int deg){ // 向量顺时针旋转后信息
    double x = tx[rt], y = ty[rt];
    double tmp = (double) deg / 180 * PI;
    tx[rt] = x * cos(tmp) + y * sin(tmp);
    ty[rt] = y * cos(tmp) - x * sin(tmp);
}
void push_up(int rt, int st, int ed){
    tx[rt] = tx[lrt] + tx[rrt];
    ty[rt] = ty[lrt] + ty[rrt];
}
void push_down(int rt, int st, int ed){
    if(tdeg[rt]){
        rotate(lrt, tdeg[rt]);
        rotate(rrt, tdeg[rt]);
        tdeg[lrt] += tdeg[rt];
        tdeg[rrt] += tdeg[rt];
        tdeg[rt] = 0;
    }
}
void build(int rt, int st, int ed){
    if(st == ed){
        tx[rt] = 0, ty[rt] = a[st];
        return ;
    }
    tdeg[rt] = 0;
    int mid = (st + ed) >> 1;
    build(lrt, st, mid);
    build(rrt, mid + 1, ed);
    push_up(rt, st, ed);
}
void update(int rt, int st, int ed, int l, int r, int k){
    if(st >= l && ed <= r){
        tdeg[rt] += k;
        rotate(rt, k);
        return ;
    }

    push_down(rt, st, ed);
    int mid = (st + ed) >> 1;
    if(l <= mid) update(lrt, st, mid, l, r, k);
    if(r > mid) update(rrt, mid + 1, ed, l, r, k);
    push_up(rt, st, ed);

}
int main(){
    int cnt = 0;
    while(scanf("%d%d", &n, &q) != EOF){
        if(cnt ++ ) puts("");
        for(int i = 1; i <= n; i ++ ){
             scanf("%d", &a[i]);
             deg[i] = 180;
        }
        build(1, 1, n);
        while(q -- ){
            int s, d;
            double x = 0, y = 0;
            scanf("%d%d", &s, &d);
            int t = (deg[s] - d + 360) % 360; // 需要顺时针转动的度数
            update(1, 1, n, s + 1, n, t);
            deg[s] = d;
            printf("%.2lf %.2lf\n",tx[1] ,ty[1]);
        }
    }
    
}
psudd
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C/C++分块个人题单
weixin_45540506的博客
12-04 675
分块题单
c++数据结构进阶线段树习题
07-05
在给定的线段树习题中，有四个具体任务： 1. **区间最大连续子段和**：给定一个数组，需要支持两种操作：查询某区间的最大连续子段和，以及修改数组中的某个元素。线段树可以构建为存储每个区间内的最大子段和，...
线段树算法总结(C/C++)
psudd的博客
10-30 456
线段树：原理分析+基本操作代码+习题(分析+细节+代码)
[蓝桥杯] 树状数组与线段树问题（C/C++）
weixin_67596609的博客
03-13 815
本篇文章针对蓝桥杯例出了一些关于树状数组和线段树的习题，并且做出了详细解释，包含了题解代码，帮助你理解到位！线段树是一棵平衡二叉树。母结点代表整个区间的和，越往下区间越小。注意，线段树的每个节点都对应一条线段（区间），但并不保证所有的线段（区间）都是线段树的节点，这两者应当区分开。
一道线段树练习题
xiayuyang
12-20 143
首先我们有一个考虑枚举每个mex,计算其贡献的想法.即有多少个区间的mexmexmex是我们当前枚举的这个值. 然后我们手画一下图,可以发现,一个数如果想要成为一个区间的mexmexmex,必须要这个区间已经出现了所有比它小的数.所以可以从小到大枚举mexmexmex,然后用rrr数组记录对于一个左端点,满足条件的右端点最近的位置,这样就能帮助我们确定之后的mexmexmex在哪些区间. 然后...
2023第十四届蓝桥杯国赛 C/C++ 大学 B 组
Ten_years_star的博客
12-12 1万+
2023第十四届蓝桥杯国赛 C/C++ 大学 B 组 题解、2023第十四届蓝桥杯决赛 C/C++ 大学 B 组
蓝桥杯C/C++B组历届真题刷题【合集】
violet的博客
08-26 1万+
历年真题，解析，练习，进阶，国赛！
第十一届蓝桥杯大赛软件类决赛（C/C++ 大学A组）
热门推荐
NOW I GOT ONE WAY
05-05 1万+
第十一届蓝桥杯大赛软件类决赛 C/C++ 大学 A 组
数据结构专题——树状数组、线段树练习题
愿历尽千帆，归来仍少年
09-22 573
数据结构之线段树、树状数组
算法题目练习（C/c++/java）
yqdid的博客
02-04 198
记录做过的经典题型，以便于以后查看
Line-tree.zip_WEB开发_Visual_C++_
08-11
压缩包内的“Line tree.docx”文件可能是包含线段树理论讲解、示例代码和练习题的文档。通过阅读这份文档，学习者可以深入理解线段树的工作原理，如何构建线段树，以及如何利用线段树解决实际问题。它还可能涵盖了...
ACM常用算法及其相应的练习题.docx
03-11
* 线段树 + poj2528, poj2828, poj2777, poj2886, poj2750 * 静态二叉检索树 + poj2482, poj2352 * 树状树组 + poj1195, poj3321 * RMQ + poj3264, poj3368 * 并查集的高级应用 + poj1703, poj2492 * KMP算法 ...
ACM常用算法及其相应的练习题.pdf
03-11
ACM常用算法及其相应的练习题.pdf 该资源提供了ACM常用的算法和相应的练习题，涵盖了基本算法、图算法、数据结构、搜索、动态规划、数学和计算几何学等领域。下面是对这些知识点的详细说明： 基本算法 * 枚举算法...
(leetcode学习)50. Pow(x, n)
m0_54888411的博客
08-05 152
快速幂，第一次写的时候用 n%2==1，这样不能处理负数的问题。
嵌入式初学-C语言-十五
MaBaB的博客
08-05 484
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
PageRank算法与TextRank算法
最新发布
weixin_74254879的博客
08-06 258
PageRank 是一种用于计算网页重要性的算法，其核心思想源自随机浏览模型。这个模型假设一个网络中的用户通过随机点击链接在网页之间跳转，并根据网页的链接结构计算每个网页的重要性。假设三个网页按以下方式连接，计算每个网页的PR值。2最终的 PageRank 值---> tensor([[0.8575, 0.0925, 0.0500]])从结果得出，网页重要性。
HDU - 2057 (纯C语言模拟16进制加减法)
qq_62224565的博客
08-05 204
首先将16进制转成10进制，再将10进制转成16进制。有个问题就是题目说输入不超过15位，但是。第二，使用abs函数时注意，当数爆int时，用long long 储存使用abs会有误。第一，多组输入注意清空字符数组，令每个字符等于’\0’即可。纯模拟，过了后发现可以用%x，直接输入输出。第三，模拟时记得用long long。以前做题没有怎么用C写过HDU的题。就是求16进制的加法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

psudd

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值