AI 助理
备案控制台
开发者社区 人工智能 文章 正文

高级数据结构-线段树

2023-06-13 71
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 线段树树基于分治思想的二叉树，用来维护区间信息(区间和、区间最大值、区间最小值等等)。可以在 O(logn) 的时间内完成区间信息的查询和修改。

title: 线段树
date: 2023-06-12 16:00:34
categories:

  • Algorithm
  • 数据结构
    tags:
  • 数据结构
  • 线段树

线段树

线段树树基于分治思想的二叉树，用来维护区间信息(区间和、区间最大值、区间最小值等等)。可以在$O(logn)$的时间内完成区间信息的查询和修改。

  • 线段树中每个叶子结点存储元素本身，非叶子结点存储区间内元素的统计值

image-20230612160951014

节点数组tr[]

l,r存区间的左右端点，sum存区间和

int n,w[N];
struct node{
   
   
  int l,r,sum;
}tr[N*4];//注意需要开四倍空间

递归建树

父节点的编号为p

左孩子编号为2*p,右孩子编号为2*p+1

#define lc p<<1
#define rc p<<1|1 或者2*p+1

void build(int p,int l,int r){
   
   
  tr[p]={
   
   l,r,w[l]};
  if(l==r) return;//是叶子结点了，直接返回
  int mid=l+r>>1;
  build(lc,l,mid);
  build(rc,mid+1,r);
  tr[p].sum=tr[lc].sum+tr[rc].sum;
}

单点修改

从根节点进入，递归找到叶子结点[x,x],把该结点的值增加k，然后从下往上更新其祖先节点上的统计值。

void update(int p,int x,int k){
   
   //将x位置上的数加k
  if(tr[p].l==x && tr[p].r==x){
   
   
    tr[p].sum+=k;
    return;
  }
  int mid=l+r>>1;
  if(x<=mid) update(lc,x,k); //只会进入一个分支
  else update(rc,x,k);
  tr[p].sum=tr[lc].sum+tr[rc].sum;
}

image-20230612162228410

区间查询

区间查询使用拆分和拼凑的思想，例如，查询区间[4,9]可以拆分为[4,5],[6,8],[9,9]，通过合并这三个区间的答案来求查询的答案。

从根节点进入，递归执行以下过程：

  1. 若查询区间[x,y]完全覆盖当前区间，则立即回溯，并返回该结点的sum值
  2. 若左子节点与[x,y]有重叠，则递归访问左子树
  3. 若右子节点与[x,y]有重叠，则递归访问右子树
int query(int p,int x,int y){
   
   
  if(x<=tr[p].l &&tr[p].r<=y)return tr[p].sum;
  int mid=tr[p].l+tr[p].r>>1;
  int sum=0;
  if(x<=mid) sum+=query(lc,x,y);
  if(y>mid) sum+=query(rc,x,y);
  return sum;
}

image-20230612163124639

区间修改

例如对区间[4,5]内的每个数加上5，如果修改区间[x,y]所覆盖的每个叶子结点，时间是$O(n)$的

可以做懒惰修改，当[x,y]完全覆盖节点区间[a,b]时，先修改区间的sum值，然后打上一个懒标记，然后立即返回，等下次需要的时候，再下传懒标记，这样可以把修改和查询的时间都控制在$O(logn)$内

void pushup(int p){
   
   
  tr[p].sum=tr[lc].sum+tr[rc].sum;
}

void pushdown(int p){
   
   
  if(tr[p].add){
   
   
    tr[lc].sum+=tr[p].add* (tr[lc].r-tr[lc].l+1);
    tr[rc].sum+=tr[p].add* (tr[rc].r-tr[rc].l+1);
    tr[lc].add+=tr[p].add;
    tr[rc].add+=tr[p].add;
    tr[p].add=0;
  }
}

void update(int p,int x,int y,int k){
   
   
  if(x<=tr[p].l &&tr[p].r<=y){
   
   
    tr[p].sum+=(tr[p].r-tr[p].l+1)*k;
    tr[p].add+=k;
    return;
  }
  int m=tr[p].l+tr[p].r>>1;
  pushdown(p);
  if(x<=m) update(lc,x,y,k);
  if(y>m) update(rc,x,y,k);
  pushup(p);
}

【模板】树状数组 1

链接：https://www.luogu.com.cn/problem/P3374

题目描述

如题，已知一个数列，你需要进行下面两种操作：

  • 将某一个数加上 $x$

  • 求出某区间每一个数的和

输入格式

第一行包含两个正整数 $n,m$，分别表示该数列数字的个数和操作的总个数。

第二行包含 $n$ 个用空格分隔的整数，其中第 $i$ 个数字表示数列第 $i$ 项的初始值。

接下来 $m$ 行每行包含 $3$ 个整数，表示一个操作，具体如下：

  • 1 x k 含义：将第 $x$ 个数加上 $k$

  • 2 x y 含义：输出区间 $[x,y]$ 内每个数的和

输出格式

输出包含若干行整数，即为所有操作 $2$ 的结果。

样例 #1

样例输入 #1

5 5
1 5 4 2 3
1 1 3
2 2 5
1 3 -1
1 4 2
2 1 4

样例输出 #1

14
16

提示

【数据范围】

对于 $30\%$ 的数据，$1 \le n \le 8$，$1\le m \le 10$；
对于 $70\%$ 的数据，$1\le n,m \le 10^4$；
对于 $100\%$ 的数据，$1\le n,m \le 5\times 10^5$。

代码

#include <bits/stdc++.h>
#define int long long
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define debug(s, x) cout << "#debug:(" << s << ")=" << x << endl;
using namespace std;

#define lc p << 1
#define rc p << 1 | 1
const int N = 5e5 + 10;

struct tr {
   
   
    int l, r, sum;
} tr[N * 4];
int w[N];
void build(int p, int l, int r) {
   
   
    tr[p] = {
   
   l, r, w[l]};
    if (l == r)
        return;
    int mid = (l + r) >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
    tr[p].sum = tr[lc].sum + tr[rc].sum;
}

void update(int p, int x, int k) {
   
   
    if (tr[p].l == x && tr[p].r == x) {
   
   
        tr[p].sum += k;
        return;
    }
    int mid = (tr[p].l + tr[p].r) >> 1;
    if (x <= mid)
        update(lc, x, k);
    else
        update(rc, x, k);
    tr[p].sum = tr[lc].sum + tr[rc].sum;
}

int query(int p, int x, int y) {
   
   
    if (x <= tr[p].l && tr[p].r <= y) {
   
   
        return tr[p].sum;
    }
    int mid = (tr[p].l + tr[p].r) >> 1;
    int sum = 0;
    if (x <= mid)
        sum += query(lc, x, y);
    if (y > mid)
        sum += query(rc, x, y);
    return sum;
}

void solve() {
   
   
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> w[i];
    build(1, 1, n);
    while (m--) {
   
   
        int a, b, c;
        cin >> a >> b >> c;
        if (a == 1)
            update(1, b, c);
        else
            cout << query(1, b, c) << endl;
    }
}

signed main() {
   
   
    int _=1;
    while (_--)
        solve();
    return 0;
}

【模板】线段树 1

链接：https://www.luogu.com.cn/problem/P3372

题目描述

如题，已知一个数列，你需要进行下面两种操作：

  1. 将某区间每一个数加上 $k$。
  2. 求出某区间每一个数的和。

输入格式

第一行包含两个整数 $n, m$，分别表示该数列数字的个数和操作的总个数。

第二行包含 $n$ 个用空格分隔的整数，其中第 $i$ 个数字表示数列第 $i$ 项的初始值。

接下来 $m$ 行每行包含 $3$ 或 $4$ 个整数，表示一个操作，具体如下：

  1. 1 x y k：将区间 $[x, y]$ 内每个数加上 $k$。
  2. 2 x y：输出区间 $[x, y]$ 内每个数的和。

输出格式

输出包含若干行整数，即为所有操作 2 的结果。

样例 #1

样例输入 #1

5 5
1 5 4 2 3
2 2 4
1 2 3 2
2 3 4
1 1 5 1
2 1 4

样例输出 #1

11
8
20

提示

对于 $30\%$ 的数据：$n \le 8$，$m \le 10$。
对于 $70\%$ 的数据：$n \le {10}^3$，$m \le {10}^4$。
对于 $100\%$ 的数据：$1 \le n, m \le {10}^5$。

保证任意时刻数列中所有元素的绝对值之和 $\le {10}^{18}$。

代码

#include <bits/stdc++.h>
#define int long long
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define debug(s, x) cout << "#debug:(" << s << ")=" << x << endl;
using namespace std;

#define lc p * 2
#define rc p * 2 + 1

const int N = 1e5 + 10;
int n, m;

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

void pushup(int p) {
   
   
    tr[p].sum = tr[lc].sum + tr[rc].sum;
}

void pushdown(int p) {
   
   
    if (tr[p].add) {
   
   
        tr[lc].sum += tr[p].add * (tr[lc].r - tr[lc].l + 1);
        tr[rc].sum += tr[p].add * (tr[rc].r - tr[rc].l + 1);
        tr[lc].add += tr[p].add;
        tr[rc].add += tr[p].add;
        tr[p].add = 0;
    }
}

void build(int p, int l, int r) {
   
   
    tr[p] = {
   
   l, r, w[l], 0};
    if (l == r)
        return;
    int mid = (l + r) >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
    pushup(p);
}

void update(int p, int x, int y, int k) {
   
   
    if (x <= tr[p].l && tr[p].r <= y) {
   
   
        tr[p].sum += (tr[p].r - tr[p].l + 1) * k;
        tr[p].add += k;
        return;
    }
    pushdown(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if (x <= mid)
        update(lc, x, y, k);
    if (y > mid)
        update(rc, x, y, k);
    pushup(p);
}

int query(int p, int x, int y) {
   
   
    if (x <= tr[p].l && tr[p].r <= y) {
   
   
        return tr[p].sum;
    }
    pushdown(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    int res = 0;
    if (x <= mid)
        res += query(lc, x, y);
    if (y > mid)
        res += query(rc, x, y);
    pushup(p);
    return res;
}

void solve() {
   
   
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> w[i];
    build(1, 1, n);
    while (m--) {
   
   
        int op;
        cin >> op;
        if (op == 1) {
   
   
            int x, y, k;
            cin >> x >> y >> k;
            update(1, x, y, k);
        } else {
   
   
            int x, y;
            cin >> x >> y;
            cout << query(1, x, y) << endl;
        }
    }
}
signed main() {
   
   
    int _ = 1;
    while (_--)
        solve();
    return 0;
}

最大数

链接：https://www.acwing.com/problem/content/1277/

给定一个正整数数列 $a_1,a_2,…,a_n$，每一个数都在 $0 \sim p-1$ 之间。

可以对这列数进行两种操作：

  1. 添加操作：向序列后添加一个数，序列长度变成 $n+1$；
  2. 询问操作：询问这个序列中最后 $L$ 个数中最大的数是多少。

程序运行的最开始，整数序列为空。

一共要对整数序列进行 $m$ 次操作。

写一个程序，读入操作的序列，并输出询问操作的答案。

输入格式

第一行有两个正整数 $m,p$，意义如题目描述；

接下来 $m$ 行，每一行表示一个操作。

如果该行的内容是 Q L，则表示这个操作是询问序列中最后 $L$ 个数的最大数是多少；

如果是 A t，则表示向序列后面加一个数，加入的数是 $(t+a)\ mod\ p$。其中，$t$ 是输入的参数，$a$ 是在这个添加操作之前最后一个询问操作的答案（如果之前没有询问操作，则 $a=0$）。

第一个操作一定是添加操作。对于询问操作，$L>0$ 且不超过当前序列的长度。

输出格式

对于每一个询问操作，输出一行。该行只有一个数，即序列中最后 $L$ 个数的最大数。

数据范围

$1 \le m \le 2 \times 10^5$,
$1 \le p \le 2 \times 10^9$,
$0 \le t < p$

输入样例：

10 100
A 97
Q 1
Q 1
A 17
Q 2
A 63
Q 1
Q 1
Q 3
A 99

输出样例：

97
97
97
60
60
97

样例解释

最后的序列是 $97,14,60,96$。

思路

因为一开始序列的长度不知道是多少，但是最多m个询问，最坏情况下数组长度就为m呗，初始化的时候就可以建立1,m的线段树

然后使用线段树维护区间的最大值，使用n记录此时数组的长度，每次添加操作，n就加1

代码

#include <bits/stdc++.h>
#define int long long
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define debug(s, x) cout << "#debug:(" << s << ")=" << x << endl;
using namespace std;

#define lc p << 1
#define rc p << 1 | 1

const int N = 2e5 + 10;

int n = 1, m, p, a;

struct node {
   
   
    int l, r, sum;
} tr[N * 4];

void pushdown(int p) {
   
   
    tr[p].sum = max(tr[lc].sum, tr[rc].sum);
}

void build(int p, int l, int r) {
   
   
    tr[p] = {
   
   l, r, 0};
    if (l == r)
        return;
    int mid = (l + r) >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
}

void update(int p, int x, int k) {
   
   
    if (tr[p].l == x && tr[p].r == x) {
   
   
        tr[p].sum = k;
        return;
    }
    int mid = (tr[p].l + tr[p].r) >> 1;
    if (x <= mid)
        update(lc, x, k);
    else
        update(rc, x, k);
    pushdown(p);
}

int query(int p, int x, int y) {
   
   
    if (x <= tr[p].l && tr[p].r <= y) {
   
   
        return tr[p].sum;
    }
    int mid = (tr[p].l + tr[p].r) >> 1;
    int res = 0;
    if (x <= mid)
        res = max(res, query(lc, x, y));
    if (y > mid)
        res = max(res, query(rc, x, y));
    return res;
}

void solve() {
   
   
    cin >> m >> p;
    build(1, 1, m);
    while (m--) {
   
   
        char op;
        int x;
        cin >> op >> x;
        if (op == 'A') {
   
   
            update(1, n, (a + x) % p);
            n++;
        } else {
   
   
            a = query(1, n - x, n - 1);
            cout << a << endl;
        }
    }
}
signed main() {
   
   
    int _ = 1;
    while (_--)
        solve();
    return 0;
}

你能回答这些问题吗

链接：https://www.acwing.com/problem/content/description/246/

给定长度为 $N$ 的数列 $A$，以及 $M$ 条指令，每条指令可能是以下两种之一：

  1. 1 x y，查询区间 $[x,y]$ 中的最大连续子段和，即 $\max\limits_{x \le l \le r \le y}${$\sum\limits^r_{i=l} A[i]$}。
  2. 2 x y，把 $A[x]$ 改成 $y$。

对于每个查询指令，输出一个整数表示答案。

输入格式

第一行两个整数 $N,M$。

第二行 $N$ 个整数 $A[i]$。

接下来 $M$ 行每行 $3$ 个整数 $k,x,y$，$k=1$ 表示查询（此时如果 $x>y$，请交换 $x,y$），$k=2$ 表示修改。

输出格式

对于每个查询指令输出一个整数表示答案。

每个答案占一行。

数据范围

$N \le 500000, M \le 100000$,
$-1000 \le A[i] \le 1000$

输入样例：

5 3
1 2 -3 4 5
1 2 3
2 2 -1
1 3 2

输出样例：

2
-1

思路

用线段树维护区间最大的连续子段和：

  • $sum$记录区间$[l,r]$的和
  • $lmax$记录区间$[l,r]$的从$l$开始的最大连续子段和
  • $rmax$记录区间$[l,r]$的从$r$开始的最大连续子段和
  • $max$记录区间$[l,r]$的最大连续子段和

在更新父节点的这些数据时，有：

  • $tr[p].sum = tr[lc].sum + tr[rc].sum;$

父节点的区间和就是两个子节点的区间和之和

  • $tr[p].lmax = max(tr[lc].lmax, tr[lc].sum + tr[rc].lmax);$

父节点从左开始的最大连续子段和为 max(左儿子从左开始的最大连续字段和，左孩子的区间和+右儿子从左开始的最大连续子段和)

  • $tr[p].rmax = max(tr[rc].rmax, tr[rc].sum + tr[lc].rmax);$
  • $tr[p].max = max(max(tr[lc].max, tr[rc].max), tr[lc].rmax + tr[rc].lmax);$

父节点的区间最大连续字段和为 左儿子的右连续区间和+右儿子的左连续区间和 以及左右儿子各自最大连续区间和取最大值。

代码

#include <bits/stdc++.h>
#define int long long
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define debug(s, x) cout << "#debug:(" << s << ")=" << x << endl;
using namespace std;
#define lc p << 1
#define rc p << 1 | 1

const int N = 5e5 + 10;
int n, m;
int w[N];
struct node {
   
   
    int l, r, sum, lmax, rmax, max;
} tr[N * 4];

void pushdown(int p) {
   
   
    tr[p].sum = tr[lc].sum + tr[rc].sum;
    tr[p].lmax = max(tr[lc].lmax, tr[lc].sum + tr[rc].lmax);
    tr[p].rmax = max(tr[rc].rmax, tr[rc].sum + tr[lc].rmax);
    tr[p].max = max(max(tr[lc].max, tr[rc].max), tr[lc].rmax + tr[rc].lmax);
}

void build(int p, int l, int r) {
   
   
    tr[p] = {
   
   l, r, w[l], w[l], w[l], w[l]};
    if (l == r)
        return;
    int mid = (l + r) >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
    pushdown(p);
}

void update(int p, int x, int k) {
   
   
    if (tr[p].l == x && tr[p].r == x) {
   
   
        tr[p] = {
   
   x, x, k, k, k, k};
        return;
    }
    int mid = (tr[p].l + tr[p].r) >> 1;
    if (x <= mid)
        update(lc, x, k);
    else
        update(rc, x, k);
    pushdown(p);
}

node query(int p, int x, int y) {
   
   
    if (x <= tr[p].l && tr[p].r <= y) {
   
   
        return tr[p];
    }
    int mid = (tr[p].l + tr[p].r) >> 1;
    if (y <= mid)
        return query(lc, x, y);
    if (x > mid)
        return query(rc, x, y);
    node left = query(lc, x, y);
    node right = query(rc, x, y);
    node t;
    t.sum = left.sum + right.sum;
    t.lmax = max(left.lmax, left.sum + right.lmax);
    t.rmax = max(right.rmax, right.sum + left.rmax);
    t.max = max(max(left.max, right.max), right.lmax + left.rmax);
    return t;
}

void solve() {
   
   
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> w[i];
    build(1, 1, n);
    int op, x, y;
    while (m--) {
   
   
        cin >> op >> x >> y;
        if (op == 1) {
   
   
            if (x > y)
                swap(x, y);
            cout << query(1, x, y).max << endl;
        } else
            update(1, x, y);
    }
}
signed main() {
   
   
    int _ = 1;
    while (_--)
        solve();
    return 0;
}
文章标签：
人工智能
存储
关键词：
数据结构线段树
wtke75czg4pji
目录
相关文章
Echo_Wish
|
6月前
|
编译器 数据库 索引
Python高级数据结构——AVL树
Python高级数据结构——AVL树
Echo_Wish
129 2
TIkitianya
|
6月前
|
存储 人工智能 索引
【数据结构】树状数组和线段树
【数据结构】树状数组和线段树
TIkitianya
68 0
Echo_Wish
|
6月前
|
存储 搜索推荐 算法
Python高级数据结构——字典树（Trie）
Python高级数据结构——字典树（Trie）
Echo_Wish
171 2
Python高级数据结构——字典树（Trie）
妄北y
|
5月前
|
存储 算法 数据安全/隐私保护
【Python学习篇】Python实验小练习——高级数据结构(五)
【Python学习篇】Python实验小练习——高级数据结构(五)
妄北y
68 1
海拥
|
6月前
|
存储 算法 搜索推荐
Java数据结构：从基础到高级应用
Java数据结构：从基础到高级应用
海拥
96 0
众所周知
|
4月前
|
存储 算法 Python
“解锁Python高级数据结构新姿势：图的表示与遍历，让你的算法思维跃升新高度
【7月更文挑战第13天】Python中的图数据结构用于表示复杂关系，通过节点和边连接。常见的表示方法是邻接矩阵（适合稠密图）和邻接表（适合稀疏图）。图遍历包括DFS（深度优先搜索）和BFS（广度优先搜索）：DFS深入探索分支，BFS逐层访问邻居。掌握这些技巧对优化算法和解决实际问题至关重要。**
众所周知
45 1
龙大吉
|
4月前
|
存储 算法 调度
惊呆了！Python高级数据结构堆与优先队列，竟然能这样优化你的程序性能！
【7月更文挑战第10天】Python的heapq模块实现了堆和优先队列，提供heappush和heappop等函数，支持O(log n)时间复杂度的操作。优先队列常用于任务调度和图算法，优化性能。例如，Dijkstra算法利用最小堆加速路径查找。堆通过列表存储，内存效率高。示例展示了添加、弹出和自定义优先级元素。使用堆优化程序，提升效率。
龙大吉
64 2
土木林森
|
4月前
|
存储 数据处理 开发者
告别繁琐查找！Python高级数据结构Trie树与Suffix Tree，让数据处理更轻松！
【7月更文挑战第19天】Python的Trie树优化字符串搜索，利用前缀减少无效操作，提升效率；Suffix Tree则高效处理后缀问题，尤其适用于文本搜索与生物信息学。虽构建复杂，但能加速后缀查询。掌握这两种数据结构，能有效应对大规模数据挑战，简化处理流程，提升开发效率。
土木林森
112 0
龙大吉
|
4月前
|
算法 安全 调度
逆天改命！Python高级数据结构堆（Heap）与优先队列，让你的算法效率飙升至宇宙级！
【7月更文挑战第8天】Python的heapq模块和queue.PriorityQueue实现了堆和优先队列，提供高效算法解决方案。堆用于Dijkstra算法求解最短路径，例如在图论问题中；PriorityQueue则在多线程下载管理中确保高优先级任务优先执行。这两个数据结构提升效率，简化代码，是编程中的强大工具。
龙大吉
52 0
土木林森
|
4月前
|
存储 算法 安全
解锁Python高级数据结构新姿势：堆与优先队列的实战演练，让你的代码更优雅！
【7月更文挑战第8天】Python的`heapq`模块和`queue.PriorityQueue`提供堆与优先队列功能，用于高效数据管理。堆是完全二叉树，`heapq`实现最小堆，常用于任务调度，如按优先级执行任务。当需要线程安全且更复杂操作时，`queue.PriorityQueue`成为优选，例如在管理网络请求时按优先级处理。这两个数据结构能提升代码效率和可读性。
土木林森
39 0