acwing算法提高之数据结构--线段树

已于 2024-04-29 23:42:29 修改
阅读量627 收藏 4
点赞数 10
分类专栏： Acwing C++学习 文章标签： 算法 数据结构
于 2024-04-28 00:25:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YMWM_/article/details/138256535
版权
C++学习 同时被 2 个专栏收录
204 篇文章 15 订阅
订阅专栏
Acwing
123 篇文章 1 订阅
订阅专栏

目录

1 介绍

线段树是算法竞赛中常用的用来维护区间信息的数据结构。

线段树可以在O(logN)时间复杂度内完成以下操作：

  1. 单点修改。
  2. 区间修改（需要加入懒标记）。
  3. 区间查询（区间求和、求区间最大值、求区间最小值）。

2 训练

题目1：1275最大数

C++代码如下，
涉及到单点修改、区间查询最大值这两个操作。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 2000010;

int m, p;
struct Node {
    int l, r;
    int v; //区间[l,r]中的最大值
} tr[N * 4];

void pushup(int u) {//由子结点信息，更新父结点信息
    tr[u].v = max(tr[u * 2].v, tr[u * 2 + 1].v);
}

void build(int u, int l, int r) { //建立线段树
    tr[u] = {l, r};
    if (l == r) return;
    int mid = l + r >> 1;
    build(2 * u, l, mid), build(2 * u + 1, mid + 1, r);
}

int query(int u, int l, int r) {//查询区间[l,r]最大值
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v; 
    int mid = tr[u].l + tr[u].r >> 1;
    int v = 0;
    if (l <= mid) v = query(2 * u, l, r);
    if (r > mid) v = max(v, query(2 * u + 1, l, r));
    return v;
}

void modify(int u, int x, int v) { //单点修改:将a[x]修改为v,线段树tr[u]需要进行的操作
    if (tr[u].l == x && tr[u].r == x) tr[u].v = v;
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(2 * u, x, v);
        else modify(2 * u + 1, x, v);
        pushup(u);
    }
}

int main() {
    int n = 0, last = 0;
    cin >> m >> p;
    build(1, 1, m);
    
    int x;
    string op;
    while (m--) {
        cin >> op >> x;
        if (op == "Q") {
            last = query(1, n - x + 1, n);
            cout << last << endl;
        } else {
            modify(1, n + 1, ((LL)last + x) % p);
            n++;
        }
    }
    return 0;
}

题目2：245你能回答这些问题吗

C++代码如下，
涉及到单点修改、求区间的最大连续子数组和这两个操作。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 500010;

int n, m;
int w[N];
struct Node {
    int l, r;
    int sum, lmax, rmax, tmax;
}tr[N * 4];

void pushup(Node &u, Node &l, Node &r) {
    u.sum = l.sum + r.sum;
    u.lmax = max(l.lmax, l.sum + r.lmax);
    u.rmax = max(r.rmax, r.sum + l.rmax);
    u.tmax = max(max(l.tmax, r.tmax), l.rmax + r.lmax);
}

void pushup(int u) {
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

void build(int u, int l, int r) {
    if (l == r) tr[u] = {l, r, w[r], w[r], w[r], w[r]};
    else {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int x, int v) {
    if (tr[u].l == x && tr[u].r == x) tr[u] = {x, x, v, v, v, v};
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x, v);
        else modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

Node query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u];
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else {
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            Node res;
            pushup(res, left, right);
            return res;
        }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
    build(1, 1, n);
    
    int k, x, y;
    while (m--) {
        scanf("%d%d%d", &k, &x, &y);
        if (k == 1) {
            if (x > y) swap(x, y);
            printf("%d\n", query(1, x, y).tmax);
        } else {
            modify(1, x, y);
        }
    }
    
    return 0;
}

题目3：246区间最大公约数

C++代码如下，

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 500010;

int n, m;
LL w[N];
struct Node {
    int l, r;
    LL sum, d;
}tr[N * 4];

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

void pushup(Node &u, Node &l, Node &r) {
    u.sum = l.sum + r.sum;
    u.d = gcd(l.d, r.d);
} 

void pushup(int u) {
    pushup(tr[u], tr[u<<1], tr[u << 1 | 1]);
}

void build(int u, int l, int r) {
    if (l == r) {
        LL b = w[r] - w[r-1];
        tr[u] = {l, r, b, b};
    } else {
        tr[u].l = l, tr[u].r = r;
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int x, LL v) {
    if (tr[u].l == x && tr[u].r == x) {
        LL b = tr[u].sum + v;
        tr[u] = {x, x, b, b};
    } else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x, v);
        else modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

Node query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u];
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else {
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            Node res;
            pushup(res, left, right);
            return res;
        }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) scanf("%lld", &w[i]);
    build(1, 1, n);
    
    int l, r;
    LL d;
    char op[2];
    while (m--) {
        scanf("%s%d%d", op, &l, &r);
        if (*op == 'Q') {
            auto left = query(1, 1, l);
            Node right({0, 0, 0, 0});
            if (l + 1 <= r) right = query(1, l + 1, r);
            printf("%lld\n", abs(gcd(left.sum, right.d)));
        } else {
            scanf("%lld", &d);
            modify(1, l, d);
            if (r + 1 <= n) modify(1, r + 1, -d);
        }
    }
    return 0;
}

题目4：243一个简单的整数问题2

C++代码如下，

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010;

int n, m;
int w[N];
struct Node {
    int l, r;
    LL sum, add;
}tr[N * 4];

void pushup(int u) {
    tr[u].sum = tr[u<<1].sum + tr[u<<1|1].sum;
}

void pushdown(int u) {
    auto &root = tr[u], &left = tr[u<<1], &right = tr[u<<1|1];
    if (root.add) {
        left.add += root.add, left.sum += (LL)(left.r - left.l + 1) * root.add;
        right.add += root.add, right.sum += (LL)(right.r - right.l + 1) * root.add;
        root.add = 0;
    }
}

void build(int u, int l, int r) {
    if (l == r) tr[u] = {l, r, w[r], 0};
    else {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u<<1, l, mid), build(u<<1|1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int l, int r, int d) {
    if (tr[u].l >= l && tr[u].r <= r) {
        tr[u].sum += (LL)(tr[u].r - tr[u].l + 1) * d;
        tr[u].add += d;
    } else {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u<<1, l, r, d);
        if (r > mid) modify(u<<1|1, l, r, d);
        pushup(u);
    }
}

LL query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
    
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    LL sum = 0;
    if (l <= mid) sum = query(u<<1, l, r);
    if (r > mid) sum += query(u<<1|1, l, r);
    return sum;
}

int main() {
    scanf("%d%d", &n, &m);
    
    for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
    
    build(1, 1, n);
    
    char op[2];
    int l, r, d;
    
    while (m--) {
        scanf("%s%d%d", op, &l, &r);
        if (*op == 'C') {
            scanf("%d", &d);
            modify(1, l, r, d);
        } else printf("%lld\n", query(1, l, r));
    }
    
    return 0;
}

题目5：247亚特兰蒂斯

C++代码如下，

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 100010;

int n;
struct Segment {
    double x, y1, y2;
    int k;
    bool operator< (const Segment &t) const {
        return x < t.x;
    }
}seg[N * 2];

struct Node {
    int l, r;
    int cnt;
    double len;
}tr[N * 8];

vector<double> ys;

int find(double y) {
    return lower_bound(ys.begin(), ys.end(), y) - ys.begin();
}

void pushup(int u) {
    if (tr[u].cnt) tr[u].len = ys[tr[u].r + 1] - ys[tr[u].l];
    else if (tr[u].l != tr[u].r) {
        tr[u].len = tr[u<<1].len + tr[u<<1|1].len;
    }else tr[u].len = 0;
}

void build(int u, int l, int r) {
    tr[u] = {l, r, 0, 0};
    if (l != r) {
        int mid = l + r >> 1;
        build(u<<1, l, mid), build(u<<1|1, mid+1, r);
    }
}

void modify(int u, int l, int r, int k) {
    if (tr[u].l >= l && tr[u].r <= r) {
        tr[u].cnt += k;
        pushup(u);
    } else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u<<1, l, r, k);
        if (r > mid) modify(u<<1|1, l, r, k);
        pushup(u);
    }
}

int main() {
    int T = 1;
    while (scanf("%d", &n), n) {
        ys.clear();
        for (int i = 0, j = 0; i < n; ++i) {
            double x1, y1, x2, y2;
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            seg[j++] = {x1, y1, y2, 1};
            seg[j++] = {x2, y1, y2, -1};
            ys.push_back(y1), ys.push_back(y2);
        }
        
        sort(ys.begin(), ys.end());
        ys.erase(unique(ys.begin(), ys.end()), ys.end());
        
        build(1, 0, ys.size() - 2);
        
        sort(seg, seg + n * 2);
        
        double res = 0;
        for (int i = 0; i < n * 2; ++i) {
            if (i > 0) res += tr[1].len * (seg[i].x - seg[i-1].x);
            modify(1, find(seg[i].y1), find(seg[i].y2) - 1, seg[i].k);
        }
        
        printf("Test case #%d\n", T++);
        printf("Total explored area: %.2lf\n\n", res);
    }
    
    return 0;
}

题目6：1277维护序列

C++代码如下，

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010;

int n, p, m;
int w[N];
struct Node {
    int l, r;
    int sum, add, mul;
}tr[N * 4];

void pushup(int u) {
    tr[u].sum = (tr[u<<1].sum + tr[u<<1|1].sum) % p;
}

void eval(Node &t, int add, int mul) {
    t.sum = ((LL)t.sum * mul + (LL)(t.r - t.l + 1) * add) % p;
    t.mul = (LL)t.mul * mul % p;
    t.add = ((LL)t.add * mul + add) % p;
}

void pushdown(int u) {
    eval(tr[u<<1], tr[u].add, tr[u].mul);
    eval(tr[u<<1|1], tr[u].add, tr[u].mul);
    tr[u].add = 0, tr[u].mul = 1;
}

void build(int u, int l, int r) {
    if (l == r) tr[u] = {l, r, w[r], 0, 1};
    else {
        tr[u] = {l, r, 0, 0, 1};
        int mid = l + r >> 1;
        build(u<<1, l, mid), build(u<<1|1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int l, int r, int add, int mul) {
    if (tr[u].l >= l && tr[u].r <= r) eval(tr[u], add, mul);
    else {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u<<1, l, r, add, mul);
        if (r > mid) modify(u<<1|1, l, r, add, mul);
        pushup(u);
    }
}

int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
    
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    int sum = 0;
    if (l <= mid) sum = query(u<<1, l, r);
    if (r > mid) sum = (sum + query(u<<1|1, l, r)) % p;
    return sum;
}

int main() {
    scanf("%d%d", &n, &p);
    for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
    build(1, 1, n);
    
    scanf("%d", &m);
    
    while (m--) {
        int t, l, r, d;
        scanf("%d%d%d", &t, &l, &r);
        if (t == 1) {
            scanf("%d", &d);
            modify(1, l, r, 0, d);
        } else if (t == 2) {
            scanf("%d", &d);
            modify(1, l, r, d, 1);
        } else printf("%d\n", query(1, l, r));
    }
    return 0;
}

3 参考

线段树 - OI Wiki

YMWM_
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Acwing-基础算法-第二章-数据结构
03-24
马上就快要蓝桥杯了，基础算法部分是肯定看不完了，还是觉得看过的多加练习，把看过的练熟，理解思路，也能取到不错的成绩！！！
acwing算法提高之数据结构--可持久化数据结构
最新发布
YMWM_的博客
04-30 785
acwing算法提高之数据结构--可持久化数据结构
AcWing算法提高课 Level-3 第四章 高级数据结构
m0_51448653的博客
10-26 194
并查集 1250. 格子游戏 并查集解决的是连通性（无向图联通分量）和传递性（家谱关系）问题，并且可以动态的维护。抛开格子不看，任意一个图中，增加一条边形成环当且仅当这条边连接的两点已经联通，于是可以将点分为若干个集合，每个集合对应图中的一个连通块。 并查集(典型并查集判断是否存在环的问题) 并查集中一般用一维的坐标会方便一些，所以这个题要把二维坐标转化成一维坐标，有个很常用的方式，(x,y) -> x*n+y，前提是x和y都从0开始 将每个坐标看成一个点值，为了方便计算，将所有的坐标横纵坐标都减
acwing算法提高课 线段树（2）
mmm_n_m的博客
07-08 192
acwing算法提高课线段树第二部分
AcWing提高算法课Level-3 第四章 高级数据结构
小哈里的博客
09-23 750
AcWing提高算法课Level-3 第四章 高级数据结构 并查集 AcWing 1250. 格子游戏1167人打卡 AcWing 1252. 搭配购买1064人打卡 AcWing 237. 程序自动分析940人打卡 AcWing 239. 奇偶游戏629人打卡 AcWing 238. 银河英雄传说844人打卡 树状数组 AcWing 241. 楼兰图腾1083人打卡 AcWing 242. 一个简单的整数问题1050人打卡 AcWing 243. 一个简单的整数问题2916人打卡 AcWing 244.
数据结构-线段树
weixin_52068218的博客
10-20 123
线段树 线段树是一种基于分治思想的的二叉树结构用于在区间上进行信息统计。与二进制位（2的次幂）进行区间划分的树状数组相比，线段树是一种更加通用的结构 性质： 线段树的每个节点都代表一个区间 线段树具有唯一的根节点，代表区间是整个区间统计范围，如[1, n] 线段树的每个叶节点都代表一个长度为1的区间[x, x] 对于内部节点[l, r]，它的左子节点是[l, mid]，右子节点是[mid + 1, r]，其中mid = (l + r) / 2(向下取整) 附一张图：（来自算法进阶指南） 上图就是展示了一
AcWing-算法提高课【合集】
violet的博客
08-29 1万+
先打基础再提高
【算法题归纳合集】高级数据结构-线段树
一只快乐的小蒟蒻~
01-19 732
一、AcWing 1275. 最大数 【题目描述】 给定一个正整数数列a1,a2,…,ana_1,a_2,\dots ,a_na1​,a2​,…,an​，每一个数都在0∼p−10∼p−10∼p−1之间。 可以对这列数进行两种操作： 添加操作：向序列后添加一个数，序列长度变成n+1n+1n+1； 询问操作：询问这个序列中最后LLL个数中最大的数是多少。 程序运行的最开始，整数序列为空。 一共要对整数序列进行mmm次操作。 写一个程序，读入操作的序列，并输出询问操作的答案。 【输入格式 第一行有两个正整数m
acwing-提高课
二哈
08-22 1万+
目录 线段树 线段树 1275 最大数（python3 不带有懒标记的线段树）
数据结构——线段树入门
m0_62021646的博客
07-22 250
线段树入门知识
基础算法与数据结构 -- Java 实现.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
算法-数据结构- 线段树.rar
09-16
算法-数据结构- 线段树.rar
026-数据结构与算法之美026-数据结构与算法之美026-数据结构与算法之美026-数据结构与算法之美
12-27
026-数据结构与算法之美026-数据结构与算法之美026-数据结构与算法之美026-数据结构与算法之美
Acwing-基础算法-第一章-基础算法
03-24
ACWing的基础算法课，整理的第一节的基础算法的笔记，自认为写的比较全面，思路自己可以看懂，为了方便以后查看，得此处上次，最后说一句：Y总是真的厉害，思路绝了！！！
C++中的reverse()函数
热门推荐
YMWM_的博客
04-06 6万+
实现翻转数组，字符串，向量！ 1翻转数组 //头文件 #include <algorithm> //使用方法 reverse(a, a+n);//n为数组中的元素个数 示例代码， #include <iostream> #include <algorithm> using namespace std; void MyShow(int a[], int n) { for(int i = 0; i < n; i++) cout <&l
结构体排序的三种方式
YMWM_的博客
03-23 1万+
结构体排序方法
C++中如何查询map中是否存在某个元素
YMWM_的博客
04-06 9466
//1 利用count #include <unordered_map> unordered_map<string, int> dist; dist.count(x) == 1;//x元素存在 dist.count(x) == 0;//x元素不存在 //2 利用find dist.find(x) != dist.end();//x元素存在 dist.find(x) == dist.end();//x元素不存在 //3 利用迭代器遍历 unordered_map<string,
c++保留两位有效数字和保留小数点后两位
YMWM_的博客
04-30 4205
  演示代码如下： #include <iostream> #include <iomanip> using namespace std; int main() { double a = 123.345; cout << "正常输出为：" << a << endl; cout << "保留两位有效数字：" << setprecision(2) << a <&
acwing 算法基础课数据结构
08-19
第四章是关于贪心算法的内容。贪心算法是一种基于贪心策略的算法思想，它在每一步选择中都采取当前状态下最优的选择，以期望达到全局最优解。 在这一章节中，你将学习到以下内容： 1. 贪心算法的基本思想和特点； 2...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

YMWM_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值