线段树模板

最新推荐文章于 2021-02-05 22:35:05 发布
最新推荐文章于 2021-02-05 22:35:05 发布
阅读量546 收藏
点赞数 1
分类专栏： 模板 线段树 ACM（已完结）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjh_shin/article/details/75423268
版权 
#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <cmath>
#include <cstdio>
#include <algorithm>
#define N 100010
#define LL __int64
#define inf 0x3f3f3f3f
#define lson l,mid,ans<<1
#define rson mid+1,r,ans<<1|1
#define getMid (l+r)>>1
#define movel ans<<1
#define mover ans<<1|1
using namespace std;
const LL mod = 1e9 + 7;
const double eps = 1e-9;
struct node{
    LL sum;
    int lazy;
}sum[N << 2];//线段树主体
struct Segment__Tree {
    int x, y;
    void pushUp(int ans) {
        sum[ans].sum = sum[movel].sum + sum[mover].sum;
    }
    void pushDown(int ans) {
        if (sum[ans].lazy) {
            sum[movel].lazy += sum[ans].lazy;
            sum[mover].lazy += sum[ans].lazy;
            sum[movel].sum += sum[ans].lazy;
            sum[mover].sum += sum[ans].lazy;
            sum[ans].lazy = 0;
        }
    }
    void build(int l, int r, int ans) {
        if (l == r) {
            cin >> sum[ans].sum;
            return;
        }
        int mid = getMid;
        build(lson);
        build(rson);
        pushUp(ans);
    }
    LL solve(int l, int r, int ans) {
        if (l >= x&&r <= y) {
            return sum[ans].sum;
        }
        pushDown(ans);
        int mid = getMid;
        if (mid<x) {
            return solve(rson);
        }
        else if (mid >= y) {
            return solve(lson);
        }
        else {
            return solve(lson) + solve(rson);
        }
    }
    void updata(int l, int r, int ans, int nums) {
        if (l >= x&&r <= y) {
            sum[ans].sum += nums;
            sum[ans].lazy += nums;
            return;
        }
        pushDown(ans);
        int mid = getMid;
        if (mid<x) {
            updata(rson, nums);
        }
        else if (mid >= y) {
            updata(lson, nums);
        }
        else {
            updata(lson, nums);
            updata(rson, nums);
        }
        pushUp(ans);
    }
};
int main() {
    cin.sync_with_stdio(false);
    int c;
    char s;
    int n, q;
    int Case = 1;
    Segment__Tree tree;
    while (cin >> n) {
        tree.build(1, n, 1);
        cin >> q;
        cout << "Case #" << Case++ << ":" << endl;
        while (q--) {
            cin >> s >> tree.x >> tree.y;
            if (tree.x > tree.y) {
                swap(tree.x, tree.y);
            }
            if (s == '1') {
                cout << tree.solve(1, n, 1) << endl;//查询
            }
            else {
                cin >> c;
                tree.updata(1, n, 1, c);//更新
            }
        }
        cout << endl;
    }
    return 0;
}

加一个新的，包括了类似于要空间利用的需要先查找再更新的模板

#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <cmath>
#include <cstdio>
#include <algorithm>
#define N 100010
#define LL __int64
#define inf 0x3f3f3f3f
#define lson l,mid,ans<<1
#define rson mid+1,r,ans<<1|1
#define getMid (l+r)>>1
#define movel ans<<1
#define mover ans<<1|1
using namespace std;
const LL mod = 1e9 + 7;
const double eps = 1e-9;
struct node {
    int l, r, lazy;
    int llen, rlen, maxlen;
}tree[N<<2];
struct nope {
    int l, r;
}now;
map<int, nope> mapp;
struct Segment__Tree {
    void pushDown(int ans, int num) {
        if (tree[ans].lazy != -1) {
            tree[gol].lazy = tree[ans].lazy;
            tree[gor].lazy = tree[ans].lazy;
            tree[gol].llen = tree[gol].rlen = tree[gol].maxlen = (tree[ans].lazy ? 0 : num - (num >> 1));
            tree[gor].llen = tree[gor].rlen = tree[gor].maxlen = (tree[ans].lazy ? 0 : (num >> 1));
            tree[ans].lazy = -1;
        }
    }
    void pushUp(int ans, int num) {
        tree[ans].llen = tree[gol].llen;
        tree[ans].rlen = tree[gor].rlen;
        tree[ans].maxlen = max(tree[gol].maxlen, tree[gor].maxlen);
        if (tree[ans].llen == num - (num >> 1)) {
            tree[ans].llen += tree[gor].llen;
        }
        if (tree[ans].rlen == num >> 1) {
            tree[ans].rlen += tree[gol].rlen;
        }
        tree[ans].maxlen = max(tree[ans].maxlen, tree[gol].rlen + tree[gor].llen);
    }
    void build(int l, int r, int ans) {
        tree[ans].l = l;
        tree[ans].r = r;
        tree[ans].lazy = -1;
        tree[ans].llen = tree[ans].rlen = tree[ans].maxlen = r - l + 1;
        if (l == r) {
            return;
        }
        int mid = getMid;
        build(lson);
        build(rson);
    }
    void updata(int l, int r, int ans, int num) {//更新区间
        if (l <= tree[ans].l&&r >= tree[ans].r) {
            tree[ans].lazy = num;
            tree[ans].llen = tree[ans].rlen = tree[ans].maxlen = (num ? 0 : tree[ans].r - tree[ans].l + 1);
            return;
        }
        pushDown(ans, tree[ans].r - tree[ans].l + 1);
        int mid = (tree[ans].l + tree[ans].r) >> 1;
        if (l <= mid) {
            updata(l, r, gol, num);
        }
        if (mid < r) {
            updata(l, r, gor, num);
        }
        pushUp(ans, tree[ans].r - tree[ans].l + 1);
    }
    int query(int ans, int num) {//查询长度为num的空闲区间
        if (tree[ans].l == tree[ans].r) {
            return tree[ans].l;
        }
        pushDown(ans, tree[ans].r - tree[ans].l + 1);
        int mid = (tree[ans].l + tree[ans].r) >> 1;
        if (tree[gol].maxlen >= num) {
            return query(gol, num);
        }
        if (tree[gol].rlen + tree[gor].llen >= num) {
            return mid - tree[gol].rlen + 1;
        }
        return query(gor, num);
    }
};

有关于面积并，周长并的扫描线模板
要进行离散化

struct Segment__Tree {
    int x, y;
    void pushUp(int l, int r, int ans) {
        if (tree[ans]) sum[ans] = r - l + 1;
        else if (l == r) sum[ans] = 0;
        else sum[ans] = sum[movel] + sum[mover];
    }
    void build() {
        memset(tree, 0, sizeof(tree));
        memset(sum, 0, sizeof(sum));
    }
    void updata(int l, int r, int ans, int num) {
        if (l >= x&&r <= y) {
            tree[ans] += num;
            pushUp(l, r, ans);
            return;
        }
        int mid = getMid;
        if (mid<x) {
            updata(rson, num);
        }
        else if (mid >= y) {
            updata(lson, num);
        }
        else {
            updata(lson, num);
            updata(rson, num);
        }
        pushUp(l, r, ans);
    }
};

求一段区间去重后的和

#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <cmath>
#include <cstdio>
#include <algorithm>
#define N 50010
#define M 200010
#define K 1000010
#define LL __int64
#define inf 0x3f3f3f3f
#define lson l,mid,ans<<1
#define rson mid+1,r,ans<<1|1
#define getMid (l+r)>>1
#define movel ans<<1
#define mover ans<<1|1
using namespace std;
const LL mod = 1e9 + 7;
const double eps = 1e-9;
const double eps = 1e-9;
struct node {
    LL sum;
}sum[N << 2];//线段树主体
struct nope {
    int l, r, id;
}fw[M];
LL num[N];
LL cnt[M];
map<LL,int> vis;
bool cmp(nope a, nope b) {
    return a.r < b.r;
}
struct Segment__Tree {
    int x, y;
    void pushUp(int ans) {
        sum[ans].sum = sum[movel].sum + sum[mover].sum;
    }
    void build(int l, int r, int ans) {
        if (l == r) {
            sum[ans].sum = 0;
            return;
        }
        int mid = getMid;
        build(lson);
        build(rson);
        pushUp(ans);
    }
    LL solve(int l, int r, int ans) {
        if (l >= x&&r <= y) {
            return sum[ans].sum;
        }
        int mid = getMid;
        if (mid<x) {
            return solve(rson);
        }
        else if (mid >= y) {
            return solve(lson);
        }
        else {
            return solve(lson) + solve(rson);
        }
    }
    void updata(int l, int r, int ans, int kk, LL nums) {
        if (l == r) {
            sum[ans].sum += nums;
            return;
        }
        int mid = getMid;
        if (mid >= kk) {
            updata(lson, kk, nums);
        }
        else {
            updata(rson, kk, nums);
        }
        pushUp(ans);
    }
};
int main() {
    cin.sync_with_stdio(false);
    int n, q;
    int T;
    Segment__Tree tree;
    cin >> T;
    while (T--) {
        cin >> n;
        for (int i = 1; i <= n; i++) {
            cin >> num[i];
        }
        tree.build(1, n, 1);
        cin >> q;
        for (int i = 1; i <= q; i++) {
            cin >> fw[i].l >> fw[i].r;
            fw[i].id = i;
        }
        sort(fw + 1, fw + q + 1, cmp);
        int ll = 1;
        vis.clear();
        for (int i = 1; i <= q; i++) {
            while (ll <= fw[i].r) {
                if (vis.find(num[ll]) != vis.end()) {
                    tree.updata(1, n, 1, vis[num[ll]], -num[ll]);
                }
                vis[num[ll]] = ll;
                tree.updata(1, n, 1, ll, num[ll]);
                ll++;
            }
            tree.x = fw[i].l;
            tree.y = fw[i].r;
            cnt[fw[i].id] = tree.solve(1, n, 1);
        }
        for (int i = 1; i <= q; i++) {
            cout << cnt[i] << endl;
        }
    }
    return 0;
}

加分割点的离散化模板

sort(v.begin(), v.end());
        int len = v.size();
        for (int i = 1; i < len; i++) {
            if (v[i] - v[i - 1] > 1) {
                v.push_back(v[i] + 1);
            }
        }
        sort(v.begin(), v.end());
        len = unique(v.begin(), v.end()) - v.begin();
        if (len == 0) {
            printf("0\n");
            continue;
        }
        build(1, len, 1);
        for (int i = 1; i <= n; i++) {
            x = lower_bound(v.begin(), v.begin() + len, point[i].x) - v.begin() + 1;
            y = lower_bound(v.begin(), v.begin() + len, point[i].y) - v.begin() + 1;
            updata(1, len, 1, i);
        }
Cry_Kill
关注
专栏目录
【模板】线段树
夕弦
05-04 546
线段树是一种神奇的数据结构呀~~~ 由于线段树在OI中的运用十分灵活，没有固定性的模板，这里就给出能够完成以下操作的线段树： 1.给一段区间加上一个值 2.询问一个区间内数值的总和 很水对吧，所以这才叫模板。。。。 lazy−taglazy−taglazy-tag是个好东西，要养成写lazy−taglazy−taglazy-tag的好习惯。 先码上一个链表版本的线段树： 链表线段...
线段树模板__模板
12-26
用c语言写的很好的线段树代码，供新手使用.
P3373 【模板】线段树 2
weixin_30377461的博客
02-10 146
P3373 【模板】线段树 2 题目描述 如题，已知一个数列，你需要进行下面三种操作： 1.将某区间每一个数乘上x 2.将某区间每一个数加上x 3.求出某区间每一个数的和 输入输出格式 输入格式： 第一行包含三个整数N、M、P，分别表示该数列数字的个数、操作的总个数和模数。 第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。 接下来M行每行包含3或4个...
【模板】 线段树
高斯的博客
11-20 256
在大家都已经学完treap的时候我终于开始学线段树
线段树模板（1）
A_Pathfinder的博客
03-08 319
本篇只对线段树的基本应用介绍：即整区间单次改变，区间求和，单点改变和区间改变一个道理，只把区间变成点。 剩下的线段树知识点类似：区间求逆序对，区间多次改变（同时+，再*或者/或者-），区间（合并，交），区间过大在改变时对p取模等放在后面学习给出。 若只是需要求区间和或者单点改变，树状数组是个好的选择，但是其他的就老老实实线段树了。线段树由于本身是专门用来处理区间问题的（包括RMQ、RSQ问题等...
完整的线段树模板，基础模板
最新发布
04-22
本资源提供了一个完整的线段树基础模板，旨在帮助开发者快速掌握并应用线段树解决实际问题。 特点： 基础性：适合初学者和有一定基础的开发者，从零开始理解线段树的构建和运作原理。 完整性：包含了线段树的构建...
ZKW线段树模板类
08-06
在ZKW_Segment_Tree.cpp和ZKW_Segment_Tree.h两个文件中，我们可以找到线段树模板类的实现。cpp文件通常包含了函数的具体实现，而h文件则定义了类的接口。类的构造函数可能接收一个整型数组，用于初始化线段树，而...
带懒惰标记的线段树模板
09-02
带懒惰标记的线段树模板
线段树（简单模板）
ojzha的博客
10-02 340
#define LL long long struct hh { int l,r,ls,rs;//l,r为边界，ls,rs为左右儿子的编号 LL date;//权值 }t[800000]; LL n,m,num=0,x,y,v,pd,a[200010],add[200010];//add为标记要增大的值的数组 void pushup(int i)//重新求权值 { t
模板 —— 线段树
佳梦作快马 诗酒趁年华
03-28 159
线段树区间修改 + 区间极值查询#include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cmath&gt; using namespace std; struct node{ int l; int r; int f; long long w; }tree[100000]; int T,n,m,x,y,val; long lo...
线段树--线段树模板
qq_35747066的博客
12-11 148
1.线段树（最大值）线段树 #include<iostream> #include<string> #include<algorithm> using namespace std; const int MAXNODE = 1 << 19; const int MAXN = 2e6 + 10; struct NODE { int valu...
线段树模板及其详细解释
chaoyueziji123的专栏
08-12 897
先摆模板。。。 //线段树模板 struct line { int left,right;//左端点、右端点 int n;//记录这条线段出现了多少次，默认为0 }; struct line a[100]; int sum; //建立 void build(int s,int t,int n) { int mid=(s+t)/2; a[n].left=s; a[n].r
线段树_模板
hengfanz的专栏
03-13 383
#define lson l,m,rt #define rson m+1,r,rt #define maxn 111111 int tree[maxn int col[maxn int f; void pushup(int rt) {          tree[rt]=tree[rt         //max[rt]=max[rt }
线段树模版
aaakirito的博客
07-30 208
#include &lt;cstdio&gt; #include &lt;algorithm&gt; using namespace std; struct me{ int value; int flage; }my[400005]; int v[100005]; void m_build(int root,int left,int right){ my[root].fl...
线段树（模板）
Here_SDUT的博客
02-10 191
刚学了线段树，趁现在理解比较清楚，写篇博客供以后翻阅，线段树有很多应用，如求区间总和，最大值，最小值等，总之求区间问题都可以想想线段树，这里以求和为例 定义全局变量 const int maxn=1e5+10; struct node { int L,R;//当前节点的左右区间 long long big,sum,lazy;//数据类型根据题意改，sum为当前节点的总和 } tre...
模板：线段树
智浩的博客
11-01 315
/*单点更新，区间求和*/ /*应用：1.建空树，可以查询比某值大的数之和，然后单点更新*/ #define N 50050 int num[N]; struct Tree{ int l; int r; int sum; }tree[4*N]; void build(int t,int l,int r){ tree[t].l
线段树 模板
weixin_43911947的博客
02-05 177
区间查询最值，区间和 #include<bits/stdc++.h> using namespace std; #define io cin.tie(0);ios::sync_with_stdio(false); #define debug(x) cout<<#x<<"="<<x<<endl #define lowbit(x) x&(-x) #define pii pair<int,int> #define mk make_
线段树模板（模板）
仰望星空
07-26 314
参考博客 http://blog.csdn.net/metalseed/article/details/8039326持续更新。。。区间存储在数组中的下标对应为 1 2 3
C语言实现线段树模板
本文档提供了一个C语言实现的线段树模板，适合初学者学习和使用。" 线段树是一种二叉树结构，它将一个数组分成多个子区间，并在每个节点上存储这些子区间的某种聚合信息（如和、最大值、最小值等）。这使得我们可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值