数据结构：线段树

已于 2023-08-10 20:03:05 修改
阅读量211 收藏
点赞数
文章标签： 算法
于 2023-08-09 13:01:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y2706586063/article/details/132183015
版权

1，模板

这里推荐一篇博客，原理讲的清晰易懂，配合着讲解更容易理解模板的思想

（http://t.csdn.cn/AaXFB）

（1）建树

void build(int p, int l, int r)//创建线段树,id表示存储下标,区间[L,r]
{
    tr[p].l = l, tr[p].r = r, tr[p].lz = 0;
    if (l == r)//左端点等于右端点，即为叶子节点(区间长度为1)，直接赋值即可
    {
        tr[p].sum = a[l];
        return;
    }
    // 否则将当前区间中间拆开成两个区间
    int mid = (l + r) / 2;//mid则为中间点，左儿子的结点区间为[l,mid],右儿子的结点区间为[mid + 1,r]
    build(p * 2, l, mid); //递归构造左儿子结点
    build(p * 2 + 1, mid + 1, r); //递归构造右儿子结点
    //tr[p].sum = min(tr[p * 2].sum, tr[p * 2 + 1].sum);//求区间最小值
    tr[p].sum = tr[p * 2].sum + tr[2 * p + 1].sum;//求区间之和
    return;
}

（2）单点修改

void add(int i, int dis, int k) {
    if (tr[i].l == tr[i].r) {// 找到长度为 1 的区间才返回
        tr[i].sum += k;
        return;
    }
    if (dis <= tr[i * 2].r)  add(i * 2, dis, k);
    else  add(i * 2 + 1, dis, k);

    tr[i].sum = tr[i * 2].sum + tr[i * 2 + 1].sum;//更新区间和
    return;
}

（3）单点查询

int find(int index, int l, int r) {//index是要查找的元素下标
    if (l==r) {
        return tr[l].sum;
    }
    int mid = (l + r) / 2;
    if (index <= mid) {
        return find(index, l, mid);
    }
    else {
        return find(index, mid + 1, r);
    }
}

（4）区间修改

void push_down(int p)
{
    if (tr[p].lz)//如果id有lazy标记
    {
        tr[p * 2].lz += tr[p].lz;//将它的左孩子的lazy加上它的lazy
        tr[p * 2 + 1].lz += tr[p].lz;//将它的右孩子的lazy加上它的lazy
        int mid = (tr[p].l + tr[p].r) / 2;
        tr[p * 2].sum += tr[p].lz * (mid - tr[2 * p].l + 1);//左孩子的Q+它下放的Q*区间长度
        tr[p * 2 + 1].sum += tr[p].lz * (tr[2 * p + 1].r - mid);
        tr[p].lz = 0;//清空lazy标记
    }
}

void query(int p, int l, int r, int k)
{
    if (tr[p].l >= l && tr[p].r <= r)//被[l,r]包含了
    {
        tr[p].lz += k;//暂时不下放,加进lazy标记中
        tr[p].sum += (tr[p].r - tr[p].l + 1) * k;
        return;
    }
    push_down(p);//要来更新下面节点了,赶紧下放
    int mid = (tr[p].l + tr[p].r) / 2;
    if (l <= mid) query(p * 2, l, r, k);//因为只有x<=mid(即[l,mid]有一部分是被[x,y]覆盖了的)才需要去更新[l,mid]
    if (r > mid) query(p * 2 + 1, l, r, k);
    tr[p].sum = tr[2 * p].sum + tr[2 * p + 1].sum;//子节点更新完之后父节点当然也要更新(上升操作)
}

（5）区间替换

void push_down(int p) {
    // 该函数将父节点的懒惰更新（lz）传递给其子节点。
    if (tr[p].lz) {
        tr[2 * p].sum = tr[p].lz * (tr[2 * p].r - tr[2 * p].l + 1);
        tr[2 * p + 1].sum = tr[p].lz * (tr[2 * p + 1].r - tr[2 * p + 1].l + 1);
        tr[2 * p].lz = tr[p].lz;
        tr[2 * p + 1].lz = tr[p].lz;
        // 重置当前节点的懒惰更新值。
        tr[p].lz = 0;
    }
}

void update(int p, int l, int r, int k) {
    // 如果当前节点的范围完全包含在查询范围内,执行懒惰更新并返回。
    if (l <= tr[p].l && tr[p].r <= r) {
        tr[p].sum = (tr[p].r - tr[p].l + 1) * k;
        tr[p].lz = k;
        return;
    }

    push_down(p);//下放

    int m = (tr[p].l + tr[p].r) >> 1;

    if (l <= m) update(2 * p, l, r, k);
    if (r > m) update(2 * p + 1, l, r, k);

    // 基于更新后的子节点和更新当前节点的和。
    tr[p].sum = tr[2 * p].sum + tr[2 * p + 1].sum;
}

（6）区间求和

int find(int p, int l, int r)
{
    if (tr[p].l >= l && tr[p].r <= r) return tr[p].sum;//[l,r]被[x,y]包含了
    push_down(p);//要查到id的子节点了,赶紧下放
    int ans = 0;
    if (tr[2*p].r >= l) ans += find(p * 2, l, r);//ans+=左孩子和
    if (tr[2*p+1].l <= r) ans += find(p * 2 + 1, l, r);//ans+=右孩子和
    return ans;
}

2,模板题练习

1，区间修改，区间求和   【模板】树状数组 1 - 洛谷

#include<bits/stdc++.h>
using namespace std;
#define int long long//防止溢出
const int N = 1e5 + 5;
int a[N];

struct node
{
    int l, r, sum;
    int lz;
}tr[N * 4];//4倍空间

void build(int p, int l, int r);
void push_down(int p);
void query(int p, int l, int r, int k);
int find(int, int , int );

signed main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> a[i];
    build(1, 1, n);
    for (int i = 0; i < m; i++) {
        int flag, l, r, k;
        cin >> flag;
        if (flag == 1) {
            cin >> l >> r >> k;
            query(1, l, r, k);
        }
        else {
            cin >> l >> r;
            cout << find(1, l, r)<<endl;
        }
    }
    return 0;
}

void build(int p, int l, int r)//创建线段树,id表示存储下标,区间[L,r]
{
    tr[p].l = l, tr[p].r = r, tr[p].lz = 0;
    if (l == r)//左端点等于右端点，即为叶子节点(区间长度为1)，直接赋值即可
    {
        tr[p].sum = a[l];
        return;
    }
    // 否则将当前区间中间拆开成两个区间
    int mid = (l + r) / 2;//mid则为中间点，左儿子的结点区间为[l,mid],右儿子的结点区间为[mid + 1,r]
    build(p * 2, l, mid); //递归构造左儿子结点
    build(p * 2 + 1, mid + 1, r); //递归构造右儿子结点
    //tr[p].sum = min(tr[p * 2].sum, tr[p * 2 + 1].sum);//求区间最小值
    tr[p].sum = tr[p * 2].sum + tr[2 * p + 1].sum;//求区间之和
    return;
}

void push_down(int p)
{
    if (tr[p].lz)//如果id有lazy标记
    {
        tr[p * 2].lz += tr[p].lz;//将它的左孩子的lazy加上它的lazy
        tr[p * 2 + 1].lz += tr[p].lz;//将它的右孩子的lazy加上它的lazy
        int mid = (tr[p].l + tr[p].r) / 2;
        tr[p * 2].sum += tr[p].lz * (mid - tr[2 * p].l + 1);//左孩子的Q+它下放的Q*区间长度
        tr[p * 2 + 1].sum += tr[p].lz * (tr[2 * p + 1].r - mid);
        tr[p].lz = 0;//清空lazy标记
    }
}

void query(int p, int l, int r, int k)
{
    if (tr[p].l >= l && tr[p].r <= r)//被[l,r]包含了
    {
        tr[p].lz += k;//暂时不下放,加进lazy标记中
        tr[p].sum += (tr[p].r - tr[p].l + 1) * k;
        return;
    }
    push_down(p);//要来更新下面节点了,赶紧下放
    int mid = (tr[p].l + tr[p].r) / 2;
    if (l <= mid) query(p * 2, l, r, k);//因为只有x<=mid(即[l,mid]有一部分是被[x,y]覆盖了的)才需要去更新[l,mid]
    if (r > mid) query(p * 2 + 1, l, r, k);
    tr[p].sum = tr[2 * p].sum + tr[2 * p + 1].sum;//子节点更新完之后父节点当然也要更新(上升操作)
}

int find(int p, int l, int r)
{
    if (tr[p].l >= l && tr[p].r <= r) return tr[p].sum;//[l,r]被[x,y]包含了
    push_down(p);//要查到id的子节点了,赶紧下放
    int ans = 0;
    if (tr[2*p].r >= l) ans += find(p * 2, l, r);//ans+=左孩子和
    if (tr[2*p+1].l <= r) ans += find(p * 2 + 1, l, r);//ans+=右孩子和
    return ans;
}

2,单点修改,区间查询   【模板】树状数组 1 - 洛谷

#include<bits/stdc++.h>
using namespace std;
#define int long long//防止溢出
const int N = 5e5 + 5;
int a[N];

struct node
{
    int l, r, sum;
    int lz;
}tr[N * 4];//4倍空间

void build(int p, int l, int r);
void add(int i, int dis, int k);
int find(int p, int l, int r);

signed main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> a[i];
    build(1, 1, n);
    for (int i = 0; i < m; i++) {
        int flag, l, r, pos, k;
        cin >> flag;
        if (flag == 1) {
            cin >> pos >> k;
            add(1, pos, k);
        }
        else {
            cin >> l >> r;
            cout << find(1, l, r)<<endl;
        }
    }
    return 0;
}

void build(int p, int l, int r)//创建线段树,id表示存储下标,区间[L,r]
{
    tr[p].l = l, tr[p].r = r, tr[p].lz = 0;
    if (l == r)//左端点等于右端点，即为叶子节点(区间长度为1)，直接赋值即可
    {
        tr[p].sum = a[l];
        return;
    }
    // 否则将当前区间中间拆开成两个区间
    int mid = (l + r) / 2;//mid则为中间点，左儿子的结点区间为[l,mid],右儿子的结点区间为[mid + 1,r]
    build(p * 2, l, mid); //递归构造左儿子结点
    build(p * 2 + 1, mid + 1, r); //递归构造右儿子结点
    //tr[p].sum = min(tr[p * 2].sum, tr[p * 2 + 1].sum);//求区间最小值
    tr[p].sum = tr[p * 2].sum + tr[2 * p + 1].sum;//求区间之和
    return;
}

void add(int i, int dis, int k) {
    if (tr[i].l == tr[i].r) {// 找到长度为 1 的区间才返回
        tr[i].sum += k;
        return;
    }
    if (dis <= tr[i * 2].r)  add(i * 2, dis, k);
    else  add(i * 2 + 1, dis, k);

    tr[i].sum = tr[i * 2].sum + tr[i * 2 + 1].sum;//更新区间和
    return;
}

int find(int p, int l, int r)
{
    if (tr[p].l >= l && tr[p].r <= r) return tr[p].sum;//[l,r]被[x,y]包含了
    //push_down(p);//要查到id的子节点了,赶紧下放
    int ans = 0;
    if (tr[2 * p].r >= l) ans += find(p * 2, l, r);//ans+=左孩子和
    if (tr[2 * p + 1].l <= r) ans += find(p * 2 + 1, l, r);//ans+=右孩子和
    return ans;
}

3,区间修改,单点查询  【模板】树状数组 2 - 洛谷

Tip:这题输入和输出最好用scanf()和printf(),不然可能会超时.

#include<bits/stdc++.h>
using namespace std;
#define int long long//防止溢出
const int N = 5e5 + 5;
int a[N];

struct node
{
    int l, r, sum;
    int lz;
}tr[N * 4];//4倍空间

void build(int p, int l, int r);
void push_down(int p);
void query(int p, int l, int r, int k);
int find(int index, int l, int r);

signed main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> a[i];
    build(1, 1, n);
    for (int i = 0; i < m; i++) {
        int flag, l, r, pos, k;
        cin >> flag;
        if (flag == 1) {
            cin >> l >> r >> k;
            query(1, l, r, k);
        }
        else {
            cin >> l;
            cout << find(1, l, l)<<endl;//找单个区间[L,L]的求和
        }
    }
    return 0;
}

void build(int p, int l, int r)//创建线段树,id表示存储下标,区间[L,r]
{
    tr[p].l = l, tr[p].r = r, tr[p].lz = 0;
    if (l == r)//左端点等于右端点，即为叶子节点(区间长度为1)，直接赋值即可
    {
        tr[p].sum = a[l];
        return;
    }
    // 否则将当前区间中间拆开成两个区间
    int mid = (l + r) / 2;//mid则为中间点，左儿子的结点区间为[l,mid],右儿子的结点区间为[mid + 1,r]
    build(p * 2, l, mid); //递归构造左儿子结点
    build(p * 2 + 1, mid + 1, r); //递归构造右儿子结点
    //tr[p].sum = min(tr[p * 2].sum, tr[p * 2 + 1].sum);//求区间最小值
    tr[p].sum = tr[p * 2].sum + tr[2 * p + 1].sum;//求区间之和
    return;
}

void push_down(int p)
{
    if (tr[p].lz)//如果id有lazy标记
    {
        tr[p * 2].lz += tr[p].lz;//将它的左孩子的lazy加上它的lazy
        tr[p * 2 + 1].lz += tr[p].lz;//将它的右孩子的lazy加上它的lazy
        int mid = (tr[p].l + tr[p].r) / 2;
        tr[p * 2].sum += tr[p].lz * (mid - tr[2 * p].l + 1);//左孩子的Q+它下放的Q*区间长度
        tr[p * 2 + 1].sum += tr[p].lz * (tr[2 * p + 1].r - mid);
        tr[p].lz = 0;//清空lazy标记
    }
}

void query(int p, int l, int r, int k)
{
    if (tr[p].l >= l && tr[p].r <= r)//被[l,r]包含了
    {
        tr[p].lz += k;//暂时不下放,加进lazy标记中
        tr[p].sum += (tr[p].r - tr[p].l + 1) * k;
        return;
    }
    push_down(p);//要来更新下面节点了,赶紧下放
    int mid = (tr[p].l + tr[p].r) / 2;
    if (l <= mid) query(p * 2, l, r, k);//因为只有x<=mid(即[l,mid]有一部分是被[x,y]覆盖了的)才需要去更新[l,mid]
    if (r > mid) query(p * 2 + 1, l, r, k);
    tr[p].sum = tr[2 * p].sum + tr[2 * p + 1].sum;//子节点更新完之后父节点当然也要更新(上升操作)
}

int find(int p, int l, int r)
{
    if (tr[p].l >= l && tr[p].r <= r) return tr[p].sum;//[l,r]被[x,y]包含了
    push_down(p);//要查到id的子节点了,赶紧下放
    int ans = 0;
    if (tr[2 * p].r >= l) ans += find(p * 2, l, r);//ans+=左孩子和
    if (tr[2 * p + 1].l <= r) ans += find(p * 2 + 1, l, r);//ans+=右孩子和
    return ans;
}

4,区间乘法  【模板】线段树 2 - 洛谷

Tip:要写两个懒人标记分别表示加法和乘法,这里的输入和输出也是要用scanf（）和printf().超时警告！！！

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5 + 5;
int a[N], mod;

struct node {
    int l, r, sum;  // 左右区间边界和当前区间元素和
    int ad, mul;    // 懒标记：加法和乘法
} tr[N * 4];

// 函数声明
void build(int p, int l, int r);
void push_down(int p);
void add(int p, int l, int r, int k);
void mult(int p, int l, int r, int k);
int search(int p, int l, int r);

signed main() {
    int n, m;
    cin >> n >> m >> mod; // 输入数列个数n，操作个数m，模数mod
    for (int i = 1; i <= n; i++) cin >> a[i]; // 输入数列元素值
    build(1, 1, n); // 构建线段树
    for (int i = 0; i < m; i++) {
        int flag, l, r, k;
        cin >> flag; // 输入操作标识
        if (flag == 1) {
            cin >> l >> r >> k; // 输入区间 [l, r] 和乘法因子 k
            mult(1, l, r, k); // 执行乘法操作
        }
        else if (flag == 2) {
            cin >> l >> r >> k; // 输入区间 [l, r] 和加法值 k
            add(1, l, r, k); // 执行加法操作
        }
        else {
            cin >> l >> r; // 输入区间 [l, r]
            cout << search(1, l, r) << endl; // 输出区间元素和对模数取模的结果
        }
    }
    return 0;
}

void build(int p, int l, int r) {
    tr[p].l = l, tr[p].r = r, tr[p].mul = 1;
    if (l == r) {
        tr[p].sum = a[l] % mod; // 叶节点直接记录数列元素对模数取模的值
        return;
    }
    int mid = (l + r) / 2;
    build(2 * p, l, mid); // 递归构建左子树
    build(2 * p + 1, mid + 1, r); // 递归构建右子树
    tr[p].sum = (tr[2 * p].sum + tr[2 * p + 1].sum) % mod; // 计算当前节点的元素和
}

void push_down(int p) {
    // 将当前节点的懒标记向下传递给子节点
    tr[2 * p].sum = (tr[2 * p].sum * tr[p].mul + tr[p].ad * (tr[2 * p].r - tr[2 * p].l + 1)) % mod;
    tr[2 * p + 1].sum = (tr[2 * p + 1].sum * tr[p].mul + tr[p].ad * (tr[2 * p + 1].r - tr[2 * p + 1].l + 1)) % mod;

    tr[2 * p].mul = (tr[2 * p].mul * tr[p].mul) % mod;
    tr[2 * p + 1].mul = (tr[2 * p + 1].mul * tr[p].mul) % mod;

    tr[2 * p].ad = (tr[2 * p].ad * tr[p].mul + tr[p].ad) % mod;
    tr[2 * p + 1].ad = (tr[2 * p + 1].ad * tr[p].mul + tr[p].ad) % mod;

    tr[p].ad = 0; // 清空当前节点的懒标记
    tr[p].mul = 1;
    return;
}

void add(int p, int l, int r, int k) {
    if (tr[p].l >= l && tr[p].r <= r) {
        tr[p].ad = (tr[p].ad + k) % mod;
        tr[p].sum = (tr[p].sum + (tr[p].r - tr[p].l + 1) * k) % mod;
        return;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) / 2;
    if (l <= mid) add(2 * p, l, r, k);
    if (r > mid) add(2 * p + 1, l, r, k);
    tr[p].sum = (tr[2 * p].sum + tr[2 * p + 1].sum) % mod;
    return;
}

void mult(int p, int l, int r, int k) {
    if (tr[p].l >= l && tr[p].r <= r) {
        tr[p].ad = (tr[p].ad * k) % mod;
        tr[p].mul = (tr[p].mul * k) % mod;
        tr[p].sum = (tr[p].sum * k) % mod;
        return;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) / 2;
    if (l <= mid) mult(2 * p, l, r, k);
    if (r > mid) mult(2 * p + 1, l, r, k);
    tr[p].sum = (tr[2 * p].sum + tr[2 * p + 1].sum) % mod;
}

int search(int p, int l, int r) {
    if (tr[p].l >= l && tr[p].r <= r) return tr[p].sum;  //[l,r]被[x,y]包含了
    push_down(p);  // 要查到id的子节点了,赶紧下放
    int ans = 0;
    if (tr[2 * p].r >= l) ans = (ans + search(p * 2, l, r)) % mod;  // ans+=左孩子和
    if (tr[2 * p + 1].l <= r) ans = (ans + search(p * 2 + 1, l, r)) % mod;  // ans+=右孩子和
    return ans;
}

5，区间替换，区间求和  线段树2 - Virtual Judge

Tip:同样的，这里的输入和输出也是要用scanf（）和printf().

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];

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

void build(int p, int l, int r);
void push_down(int p);
void update(int p, int l, int r, int k);

int main()
{
	int T, count = 0;
	cin >> T;
	while (T--) {
		int n, m;
		cin >> n >> m;
		for (int i = 1; i <= n; i++) a[i] = 1;
		build(1, 1, n);
		for (int i = 0; i < m; i++) {
			int l, r, k;
			cin >> l >> r >> k;
			update(1, l, r, k);
		}
		count++;
		cout << "Case " << count << ": The total value of the hook is " << tr[1].sum << "." << endl;
	}
	return 0;
}

void build(int p, int l, int r)//创建线段树,id表示存储下标,区间[L,r]
{
	tr[p].l = l, tr[p].r = r, tr[p].lz = 0;
	if (l == r)//左端点等于右端点，即为叶子节点(区间长度为1)，直接赋值即可
	{
		tr[p].sum = a[l];
		return;
	}
	// 否则将当前区间中间拆开成两个区间
	int mid = (l + r) / 2;//mid则为中间点，左儿子的结点区间为[l,mid],右儿子的结点区间为[mid + 1,r]
	build(p * 2, l, mid); //递归构造左儿子结点
	build(p * 2 + 1, mid + 1, r); //递归构造右儿子结点
	//tr[p].sum = min(tr[p * 2].sum, tr[p * 2 + 1].sum);//求区间最小值
	tr[p].sum = tr[p * 2].sum + tr[2 * p + 1].sum;//求区间之和
	return;
}

void push_down(int p) {
	// 该函数将父节点的懒惰更新（lz）传递给其子节点。
	if (tr[p].lz) {
		tr[2 * p].sum = tr[p].lz * (tr[2 * p].r - tr[2 * p].l + 1);
		tr[2 * p + 1].sum = tr[p].lz * (tr[2 * p + 1].r - tr[2 * p + 1].l + 1);
		tr[2 * p].lz = tr[p].lz;
		tr[2 * p + 1].lz = tr[p].lz;
		// 重置当前节点的懒惰更新值。
		tr[p].lz = 0;
	}
}

void update(int p, int l, int r, int k) {
	// 如果当前节点的范围完全包含在查询范围内,执行懒惰更新并返回。
	if (l <= tr[p].l && tr[p].r <= r) {
		tr[p].sum = (tr[p].r - tr[p].l + 1) * k;
		tr[p].lz = k;
		return;
	}

	push_down(p);//下放

	int m = (tr[p].l + tr[p].r) >> 1;

	if (l <= m) update(2 * p, l, r, k);
	if (r > m) update(2 * p + 1, l, r, k);

	// 基于更新后的子节点和更新当前节点的和。
	tr[p].sum = tr[2 * p].sum + tr[2 * p + 1].sum;
}

6，单点替换，区间极值   线段树2 - Virtual Judge

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];

struct node
{
    int l, r, sum;
    int lz;
}tr[N * 4];//4倍空间

void build(int p, int l, int r);
void update(int p, int pos, int k);
int query(int p, int l, int r);

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);//提高输入输出效率
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) cin >> a[i];
	build(1, 1, n);
	for (int i = 0; i < m; i++) {
		char flag;
		int l, r;
		cin >> flag >> l >> r;
		if (flag == 'U') update(1, l, r);
		else cout << query(1, l, r) << endl;
	}
	return 0;
}

void build(int p, int l, int r)//创建线段树,id表示存储下标,区间[L,r]
{
    tr[p].l = l, tr[p].r = r, tr[p].lz = 0;
    if (l == r)//左端点等于右端点，即为叶子节点(区间长度为1)，直接赋值即可
    {
        tr[p].sum = a[l];
        return;
    }
    // 否则将当前区间中间拆开成两个区间
    int mid = (l + r) / 2;//mid则为中间点，左儿子的结点区间为[l,mid],右儿子的结点区间为[mid + 1,r]
    build(p * 2, l, mid); //递归构造左儿子结点
    build(p * 2 + 1, mid + 1, r); //递归构造右儿子结点
    tr[p].sum = max(tr[p * 2].sum, tr[p * 2 + 1].sum);
    return;
}

void update(int i, int dis, int k) {
    if (tr[i].l == tr[i].r) {// 找到长度为 1 的区间才返回
        tr[i].sum = k;
        return;
    }
    if (dis <= tr[i * 2].r)  update(i * 2, dis, k);
    else  update(i * 2 + 1, dis, k);

    tr[i].sum = max(tr[i * 2].sum, tr[i * 2 + 1].sum);//更新区间和
    return;
}

int query(int p, int l, int r)
{
    if (tr[p].l >= l && tr[p].r <= r) return tr[p].sum;//[l,r]被[x,y]包含了
    //push_down(p);//要查到id的子节点了,赶紧下放
    int ans = 0;
    if (tr[2 * p].r >= l) ans = max(ans, query(p * 2, l, r));//ans+=左孩子和
    if (tr[2 * p + 1].l <= r) ans = max(ans, query(p * 2 + 1, l, r));//ans+=右孩子和
    return ans;
}

CV敲击器
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++数据结构进阶线段树习题
07-05
【线段树】是一种高效的数据结构，用于处理区间更新和查询的问题。在C++中，线段树可以用来实现动态维护区间最值、区间加法等操作。它将一个数组分成若干个重叠的子区间，每个节点代表一个子区间，通过节点之间的...
数据结构课程设计-线段树
06-08
线段树作为数据结构中的一种，尤其适用于处理区间查询和更新问题，它在算法设计和复杂性分析中占据着重要的地位。在这个数据结构课程设计中，我们将深入理解线段树的概念、构建方法以及其在实际问题中的应用。 线段...
高级数据结构：线段树入门（c++实现 + 详解）
ylh的博客
01-27 3742
线段树是一种高级数据结构，与树状数组一样，被用来处理区间查询，修改问题，并且线段树的最大优点是对动态数据的处理十分高效。关于树状数组，可以看我这篇博文的介绍： 高级数据结构：树状数组详解来看看线段树能处理的问题：线段树是具有以下形态的二叉树，其中树上的每个节点都是一个线段区间 。看图可以发现线段树的几个特征：这颗二叉树是采用分治法来划分区间，并且构建子树的，左右子树各一半。这颗二叉树的每个节点都是一个线段区间，非叶子节点的线段区间是一段不相等的区间，叶子节点的线段区间的只包含一个元素。这颗二叉树是一颗完全二
高级数据结构：线段树
xylitolz的博客
04-17 387
文章目录为什么要使用线段树？什么是线段树（SegmentTree）？创建线段树线段树的查询线段树中的更新操作More线段树相关问题Reference 为什么要使用线段树？ 对于有一类问题，我们关心的是线段（或者区间） 最经典的线段树问题：区间染色 有一面墙，长度为nnn，每次选择一段墙进行染色，mmm次操作后，可以看见多少种颜色？mmm次操作后，可以在区间[i,j][i,j][i,j]内看见多少种颜色？ 使用数组实现 染色操作（更新区间） O(n)O(n)O(n) 查询操作（查询区
数据结构: 线段树Segment Tree
LOOKTOMMER的博客
11-08 973
????写博客的目的在于巩固所学知识???? ????为什么要有线段树 有这样一个场景：给你一个数组nums 有两个任务 1.将 nums[index]的值更新为val;( 0 =< index < nums.length,val为随机值） 2.计算子数组nums[left, right]的总和（即，nums[left] + nums[left + 1], ..., nums[right]） 这两个任务会执行若干次，执行的顺序随机。 对于第一个任务，...
数据结构：线段树实现详解
Leon14138的博客
12-02 1472
线段树C/C++实现数据类型构造基本操作构造线段树添加结点删除结点查询结点实现原理构造线段树添加结点删除结点查询结点C++代码实现构建线段树添加结点删除结点查询结点Lazy tags优化实例应用 本质为 加了左右端点的树形结构 数据类型构造 struct node{ int l,r; //l左端点 r右端点 int val; //val值域 }n[maxn]; //n[i]表示标号为i的树的结点 基本操作 构造线段树 void make(int left,int right, i
树形数据结构：线段树1
BasketballChick的博客
01-20 959
线段树，是如今维护数组常用的数据结构，其时空复杂度极优，但比较费脑子。
高级数据结构：线段树（Lazy标记的两种处理方法）
yuhaomogui的博客
11-03 622
目录 线段树的使用 1.线段树的建立 2.区间询问 3.单点修改 4.区间修改 例题及其补充
数据结构：线段树及ST算法比较
aotao4494的博客
11-01 334
ST算法是一种高效的计算区间最值的方法。 他的思想是将询问区间分解成两个最长的二次幂的长度的区间并集的形式。 所以与线段树不同，这种区间分解其实存在相交的分解。 因此ST算法能维护的只是一些简单的信息，比如区间最值或者区间gcd问题 ST算法的优势： 实现简单（qwq为什么我觉得线段树更好理解） 效率比线段树高 线段树的优势： 可以更好地维护动态的信息，而ST...
数据结构——线段树
小天狼星_布莱克 的博客
04-09 593
线段树是一棵二叉树，其结点是一条“线段”——[a,b]，它的左儿子和右儿子分别是这条线段的左半段和右半段，即[a, (a+b)/2 ]和[(a+b)/2 ,b]。线段树的叶子结点是长度为1的单位线段[a,a+1]。下图就是一棵根为[1,10]的线段树：易证一棵以[a,b]为根的线段树结点数是2*(b-a)-1。由于线段树是一棵平衡树，因此一棵以[a,b]为根结点的线段树的深度为log2(2*(b-a))。
线段树高级数据结构实现
05-26
线段树点更新
线段树(C++).pptx
04-09
线段树是一种高效的数据结构，尤其适用于处理区间或线段上的动态查询与更新问题。它是一种平衡的二叉树，每个节点代表一个特定的区间，通常用于解决区间求和、区间修改、区间最大值或最小值等问题。在C++中，线段树...
[宫水三叶的刷题日记]：线段树1
08-03
《宫水三叶的刷题日记》系列是关于算法学习的原创专题，专注于线段树这一数据结构。线段树是一种高效处理区间查询和修改的数据结构，尤其适用于处理区间求和问题。本合集更新于2021年10月7日，作者建议按照一定的...
【18】输出字符菱形
2301_78786609的博客
07-19 287
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 108
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 234
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
常见的排序算法，复杂度
m0_61544805的博客
07-16 517
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
代码随想录学习 54day 图论 A star算法
qq_40445763的博客
07-17 426
【代码】代码随想录学习 54day 图论 A star算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值