线段树总结

于 2023-02-22 22:44:22 发布
阅读量344 收藏
点赞数
分类专栏： 算法 文章标签： 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuzekun/article/details/129172211
版权
文章介绍了线段树在处理区间修改和求值问题中的应用，包括单点修改和区间求值的模板题目，以及如何处理动态开点。通过具体示例如308.二维区域和检索-可变、掉落的方块等LeetCode题目，解释了线段树的构建、更新和查询方法，强调了动态开点时的注意事项，如确保范围正确、处理懒标记等。
摘要由CSDN通过智能技术生成

文章目录

参考文档

线段树动态开点java
动态开点c++
线段树leetcode题目

题目

题目知识点/注意点难度
更新数组后处理求和查询线段树困难
维护序列区间修改、求和困难
掉落的方块右边区间-1困难
leetcode 气球颜色变换右边区间-1
leetcode 218.天际线右边区间-1困难
leetcode 307. 区域和检索 - 数组可修改下标开始的位置困难
leetcode 315. 计算右侧小于当前元素的个数保证r >= l困难
leetcode 493. 翻转对离散化 / 动态开点困难
leetcode 327. 区间和的个数离散化 / 动态开点困难

线段树实现

  1. 一般Push_down和push_up是需要手动实现的。
  2. 注意下标从1开始，build和使用的时候需要注意。
  3. 动态开点的时候，push_down和update会动态开点。
  4. 使用的时候，需要保证r >= l，否则会出现各种问题。
  5. 动态开点的时候，需要保证(l, r)的范围包含全部点。

单点修改，区间求值

模板题目

    static const int maxn = 4e5 + 4;
    int sum[maxn];
    int n;
    void push_up(int u) {
        sum[u] = sum[u << 1] + sum[u << 1 | 1];
    }
    void build(int u, int l, int r, vector<int>&nums) {
        if (l == r) {
            sum[u] = nums[l - 1];
            return ;
        }
        int mid = (l + r) >> 1;
        build(u << 1, l, mid, nums);
        build(u << 1 | 1, mid + 1, r, nums);
        push_up(u);
    }
    void update(int u, int l, int r, int p, int x) {
        if (p == l && l == r) {
            sum[u] = x;
            return ;
        }
        int mid = (l + r) >> 1;
        if (p <= mid) update(u << 1, l, mid, p, x);
        else update(u << 1 | 1, mid + 1, r, p, x);
        push_up(u);
    }
    int query(int u, int l, int r, int L, int R) {
        if (L <= l && r <= R) {
            return sum[u];
        }
        int mid = (l + r) >> 1;
        int ans = 0;
        if (L <= mid) ans = query(u << 1, l, mid, L, R);
        if (R > mid) ans += query(u << 1 | 1, mid + 1, r, L, R);
        return ans; 
    }

308. 二维区域和检索 - 可变

class Solution {
public:

// 加是不行的。为什么呢？因为区间[l, r]上的高度不统一。

    static const int N = 1e6 + 10;
    int maxh[N], lc[N], rc[N], idx = 0, root = 0; //  root应该写成全局变量,
    int lazy[N];
    // int add[N];         // 区间同时增加高度不行

    void push_up(int u) {
        maxh[u] = max(maxh[lc[u]], maxh[rc[u]]);
    }
    // 将区间，改编成add_h。如果没有区间就开点
    void push_down(int &u, int x) {
        if (!u) u = ++idx;                // push_down的时候也需要创建新的
        lazy[u] = maxh[u] = x;
    }
    // 懒标记下推
    void push_down(int u) {
        // if (add[u] == 0) return ;
        if (lazy[u] == 0) return ;
        push_down(lc[u], lazy[u]);
        push_down(rc[u], lazy[u]);
        lazy[u] = 0;                     // 清除懒标记
    }
    // [L, R]增加add_x， 需要加上引用，让lc和rc指向正确位置。
    void update(int &u, int l, int r, int L, int R, int add_x) {
        if (u == 0) u = ++idx;           // 给儿子创建一个新的点
        if (L <= l && r <= R) {
            push_down(u, add_x);
            // printf("add_x = %d\n", add_x);
            return ;
        }
        push_down(u);
        int mid = (l + r) >> 1;
        // printf("mid = %d l = %d r = %d, L = %d, R = %d\n", mid, l, r, L, R);
        if (L <= mid) update(lc[u], l, mid, L, R, add_x);
        if (R > mid) update(rc[u], mid + 1, r, L, R, add_x);
        push_up(u);                     // 没有传递u, 所以u不会变
    }
    // 询问，不用加引用
    int query(int u, int l, int r, int L, int R) {
        if (u == 0) return 0;           // 如果没更新这个区间直接返回
        if (L <= l && r <= R) {
            return maxh[u];
        }
        push_down(u);
        int mid = (l + r) >> 1;
        int maxv = 0;
        // printf("%d %d %d %d %d\n", mid, l, r, L, R);
        if (L <= mid) maxv = query(lc[u], l, mid, L, R);
        if (R > mid) maxv = max(maxv, query(rc[u], mid + 1, r, L, R));
        return maxv;
    }

    vector<int> fallingSquares(vector<vector<int>>& positions) {
        vector<int>ans;
        for (auto vec : positions) {
            int l = vec[0], r = vec[0] + vec[1] - 1, z = vec[1];
            int cur = query(root, 1, 1e9, l, r);
            // printf("cur = %d\n", cur);
            update(root, 1, 1e9, l, r, z + cur);
            ans.push_back(maxh[1]);
        }
        return ans;
    }
};

区间修改，区间求值

1. 掉落的方块（区间开点）

大区间

少查询

动态开点: 使用指针的进行开点

离散化

int x = info[0], h = info[1], cur = query(1, 1, N, x, x + h - 1);

查询 – [x, x + h - 1]

修改 – [x, x + h - 1, cur + h]

当前的最大值就是tr[1].val

class Solution {
public:

// 加是不行的。为什么呢？因为区间[l, r]上的高度不统一。

    static const int N = 1e6 + 10;
    int maxh[N], lc[N], rc[N], idx = 0, root = 0; //  root应该写成全局变量,
    int lazy[N];
    // int add[N];         // 区间同时增加高度不行

    void push_up(int u) {
        maxh[u] = max(maxh[lc[u]], maxh[rc[u]]);
    }
    // 将区间，改编成add_h。如果没有区间就开点
    void push_down(int &u, int x) {
        if (!u) u = ++idx;                // push_down的时候也需要创建新的
        lazy[u] = maxh[u] = x;
    }
    // 懒标记下推
    void push_down(int u) {
        // if (add[u] == 0) return ;
        if (lazy[u] == 0) return ;
        push_down(lc[u], lazy[u]);
        push_down(rc[u], lazy[u]);
        lazy[u] = 0;                     // 清除懒标记
    }
    // [L, R]增加add_x
    void update(int &u, int l, int r, int L, int R, int add_x) {
        if (u == 0) u = ++idx;           // 给儿子创建一个新的点
        if (L <= l && r <= R) {
            push_down(u, add_x);
            // printf("add_x = %d\n", add_x);
            return ;
        }
        push_down(u);
        int mid = (l + r) >> 1;
        // printf("mid = %d l = %d r = %d, L = %d, R = %d\n", mid, l, r, L, R);
        if (L <= mid) update(lc[u], l, mid, L, R, add_x);
        if (R > mid) update(rc[u], mid + 1, r, L, R, add_x);
        push_up(u);                     // 没有传递u, 所以u不会变
    }
    int query(int &u, int l, int r, int L, int R) {
        if (u == 0) return 0;           // 如果没更新这个区间直接返回
        if (L <= l && r <= R) {
            return maxh[u];
        }
        push_down(u);
        int mid = (l + r) >> 1;
        int maxv = 0;
        // printf("%d %d %d %d %d\n", mid, l, r, L, R);
        if (L <= mid) maxv = query(lc[u], l, mid, L, R);
        if (R > mid) maxv = max(maxv, query(rc[u], mid + 1, r, L, R));
        return maxv;
    }

    vector<int> fallingSquares(vector<vector<int>>& positions) {
        vector<int>ans;
        for (auto vec : positions) {
            int l = vec[0], r = vec[0] + vec[1] - 1, z = vec[1];
            int cur = query(root, 1, 1e9, l, r);
            // printf("cur = %d\n", cur);
            update(root, 1, 1e9, l, r, z + cur);
            ans.push_back(maxh[1]);
        }
        return ans;
    }
};
  • 问题1：为什么动态开点不判断u是否为空？询问直接返回就行了，更新的时候需要判断。
  • 问题2：直接把val赋值成为add，是否都是这样？还是仅仅是这个题目这样？仅仅这个题目这样。

2. 维护序列

调试技巧

  1. 首先判断build是否成功
  2. 其次判断询问是否成功
  3. 最后根据根节点的信息判断更新是否成功。
  4. push_down和push_up可以输出前后的sum[u]进行判断

3. 一个简单的问题2

java代码再acwnig的java代码上。

  1. long的使用
  2. 两个push_down
    1. 一个push_down是下推
    2. 另一个是更新区间的sum和懒标记

4. 天际线问题

  1. 离散化
  2. 扫描线
  3. 右端点-1，左端点仍旧可以作为起点。

class NumMatrix {
public:
    // 每一行使用一个线段树来维护
    static const int MAXN = 8e4 + 4;
    static const int N = 3e2 + 4;
    int sum[N][MAXN];
    vector<vector<int>>nums;
    int m, n;
    void push_up(int row, int u) {
        sum[row][u] = sum[row][u << 1] + sum[row][u << 1 | 1];
    }
    void build(int row, int u, int l, int r) {
        if (l == r) 
        {
            sum[row][u] = nums[row][l - 1];
            return ;
        }
        int mid = (l + r) >> 1;
        // printf("%d %d %d\n", l, r, mid);
        build(row, u << 1, l, mid);
        build(row, u << 1 | 1, mid + 1, r);
        push_up(row, u);
    }
    void update(int u, int l, int r, int row, int col, int x) {
        if (l == r && col == l) {       // l == r的时候col一定等于l
            sum[row][u] = x;
            return ;
        }
        int mid = (l + r) >> 1;
        if (col <= mid) update(u << 1, l, mid, row, col, x);
        else update(u << 1 | 1, mid + 1, r, row, col, x);
        push_up(row, u);
    }
    int query(int u, int l, int r, int row, int L, int R) {
        if (L <= l && r <= R) {
            return sum[row][u];
        }
        int mid = (l + r) >> 1;
        int ans = 0;
        if (L <= mid) ans += query(u << 1, l, mid, row, L, R);
        if (R > mid) ans += query(u << 1 | 1, mid + 1, r, row, L, R);
        return ans; 
    }

    NumMatrix(vector<vector<int>>& matrix) {
        this->nums = matrix;
        m = nums.size();
        n = nums[0].size();
        for (int i = 0; i < m; i++) {
            build(i, 1, 1, n);
            // printf("%d\n", sum[i][1]);
        }
    }
    
    void update(int row, int col, int val) {
        col++;
        update(1, 1, n, row, col, val);
    }
    
    int sumRegion(int row1, int col1, int row2, int col2) {
        int ans = 0;
        col1++, col2++;
        for (int i = row1; i <= row2; i++) {

            ans += query(1, 1, n, i, col1, col2);
        }
        return ans;
    }
};

/**
 * Your NumMatrix object will be instantiated and called as such:
 * NumMatrix* obj = new NumMatrix(matrix);
 * obj->update(row,col,val);
 * int param_2 = obj->sumRegion(row1,col1,row2,col2);
 */

动态开点

1. 区间和个数(单点修改开点)

  • 注意求最大和最小值的过程
  • 注意前缀和为0的情况需要加入进去。而前缀和为0的时候，不用考虑query，因为一定为0，所有的点都是0。
  typedef long long LL;
    static const int N = 4e6 + 10;              // 开太小了也爆栈
    LL add[N];
    int idx = 0, root = 0, lc[N], rc[N];
    void push_up(int u) {
        add[u] = add[lc[u]] + add[rc[u]];       // 如果使用node，可能会出现点不存在的情况，但是这里并不会，因为add[0] = 0;
    }
	// 单点修改开点
    void update(int &u, LL l, LL r, LL p) {
        if (!u) u = ++idx;
        // add[u]++;                               // 直接相当于push_up了
        if (l == r && l == p) {
            add[u] += 1;
            return ;
        } 
        LL mid = (l + r) >> 1;
        if (p <= mid) update(lc[u], l, mid, p);
        else update(rc[u], mid + 1, r, p);
        push_up(u);
    }
    LL query(int u, LL l, LL r, LL L, LL R) {
        if (!u) return 0;
        if (L <= l && r <= R) return add[u];
        LL mid = (l + r) >> 1;
        LL ans = 0;
        if (L <= mid) ans += query(lc[u], l, mid, L, R);
        if (R > mid) ans += query(rc[u], mid + 1, r, L, R);
        return ans;
    }
    int countRangeSum(vector<int>& nums, int low, int high) {
        int n = nums.size();
        LL ans = 0;
        vector<LL>sum(n + 1);
        sum[0] = 0;
        memset(lc, 0, sizeof lc);
        memset(rc, 0 ,sizeof rc);
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i - 1] + nums[i - 1];
        }
        LL minv = LLONG_MAX, maxv = LLONG_MIN;
        for (LL x: sum) {
            minv = min({minv, x, x - high});
            maxv = max({maxv, x, x - high});
        }

        // cout << minv << " " << maxv << endl;
        for (LL x: sum) {
            LL l = x - high, r = x - low;
            // cout <<x << " " << l << " " << r << endl;
            ans += query(root, minv, maxv, l, r);
            // cout << query(root, minv, maxv, l, r) << endl;
            update(root, minv, maxv, x);
        }
        return ans;
    }
};

问题以及注意事项

  1. 天际线和方块的问题中，为什么需要右端点-1，而不是左端点 + 1呢？
  2. 具体的调试技巧，看上面的维护序列。
  3. 注意使用的时候，区间从1开始，
天下一般
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树总结（题目合集）
常胜将军的博客
08-19 1294
1、POJ 3321 题意：给出一个苹果树，每个节点一开始都有苹果。C X，如果X点有苹果，则拿掉，如果没有，则新长出一个。Q X，查询X点与它的所有后代分支一共有几个苹果。 分析：利用dfs序将子树节点变成连续区间，然后利用线段树进行单点修改、区间求和就好了。注意vector<int> g[N]会超时，改成vector<vector<int> > g就好了...
leetcode-线段树总结
Less is More
04-06 294
TODO----------
线段树总结[经典、权值、动态开点]
Xm_wy的博客
05-11 1007
ps:这是本蒟蒻的第一篇数据类型博客。   线段树，这是一种非常常用、普遍的信息统计技术。其基本思想是分治（二分），该数据类型本质上是一个储存区间数据二叉树
线段树总结-超级详细版
08-08
线段树总结以及线段树一些经典的例题，代码写的非常简洁和漂亮。
样本的方差的均值等于总体的方差
热门推荐
fuzekun的博客
03-29 1万+
E(s2) = E(Xi2) - E(X均2)      (此处的X均是均值，不会打) = D(Xi) + E(X2) - [DX + E(X均)2]      (不是D(X2i)) = D(Xi) + DX均
getchar()
fuzekun的博客
01-06 6050
while ((chr = getchar()) != '\n') { File nowFile; scanf("%s", nowFile.fileName); if (fileSet.find(nowFile) != fileSet.end()) { printf("%s exists!\n", nowFile.fileName); ...
拓扑排序dfs实现
fuzekun的博客
06-14 4348
用来进行确定前驱关系。 比如a < b , c < d, c < b 可以确定 a < c < b < d 或者 c < a < b < d 如果没有环的话一定可以存在一条这样的链，但是如果有环就不能进行拓扑排序。这个例子就是不能 a > b 且 b > a; 使用dfs 进行 伪代码 //判断是否有环 bool dfs(u) { 本趟节点标记; for(遍历以u为入弧的定点){ if(是本趟节点）return false;
梯度下降matlab实现
fuzekun的博客
12-02 4013
function [k ender]=steepest(f,x,e) %梯度下降法,f为目标函数（两变量x1和x2），x为初始点,如[3;4] syms x1 x2 m; %m为学习率 d=-[diff(f,x1);diff(f,x2)]; %分别求x1和x2的偏导数，即下降的方向 flag=1; %循环标志 k=0; %迭代次数 while(flag) d_temp=subs(d,x1,x(1)); %将起始点代入，求得当次下降x1梯度值 d_temp=subs(d_temp
利用矩阵求斐波那契数列
fuzekun的博客
10-14 3730
利用矩阵的快速幂求斐波那契数列的代码实现 #include&lt;stdio.h&gt; #include&lt;string.h&gt; #define MOD 1000000007 struct juzhen { long long aa[2][2]; }; //矩阵的快速幂 juzhen chengfa(juzhen &amp;a,juzhen &amp;b) { juz...
给个n，求1到n的所有数的约数个数的和~
fuzekun的博客
06-14 2952
题目描述 给个n，求1到n的所有数的约数个数的和~ 输入描述: 第一行一个正整数n 输出描述: 输出一个整数，表示答案 示例1 输入 3 输出 5 说明 样例解释： 1有1个约数1 2有2个约数1,2 3有2个约数1,3 备注: n <= 100000000 思路：从1-n枚举约数 #include<stdio.h> #include<math.h> #include...
蓝桥杯算法训练-逗志芃的危机
fuzekun的博客
10-17 1953
　逗志芃的危机
蓝桥杯分考场
fuzekun的博客
12-23 1802
因为数据量很小可以使用回溯算法。 应用两层回溯： 第一层回溯是将考生放在不同考场里面产生的效果，比如学生3号可以放在教室1和教室2中那么放在那一个教室会产生更好的效果这是一层回溯。 第二层回溯是考生放入以前的考场还是考生自己重新用一个考场。比如考生3号可以放进教室1和教室2，也可以放进教室3。 应用简单的剪枝技巧： 现在考场的数量已经大于以前最少的考场数量了就不用在展开了。 因为题目中没有时间限制...
huffman编码
fuzekun的博客
06-29 1601
huffman编码解码
扩展欧几里得
fuzekun的博客
10-24 1588
扩展欧几里得是用来解决线性同余方程问题。 什么是线性同余方程? 给定三个正整数a, b, d求下面方程的非零整数解。 ax+by=d ax + by = d ax+by=d 如何求解？ 首先，可以观察到这个方程是不一定有解的，比如下面这个方程是一定没有整数解的。 2x+4y=1 2x + 4y = 1 2x+4y=1 那么什么时候有整数解呢？有一个裴蜀定理：线性同余方程有解的充要条件是: d=gcd(a,b) d = gcd(a,b)d=gcd(a,b) 且此gcd(a, b)是最小的.
求组合数的四种方式
最新发布
fuzekun的博客
11-15 1500
组合数
线段树详解与应用
"更新线段树-线段树学习ppt" ...总结来说，线段树是一种强大的数据结构，尤其适用于处理区间上的动态查询和修改。它的构造和操作复杂度较低，可以灵活地适应各种问题，是算法竞赛和实际编程中解决区间问题的利器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值