洛谷题单【数据结构2-2】线段树与树状数组

已于 2022-09-03 21:18:22 修改
阅读量427 收藏 1
点赞数
分类专栏： 洛谷 文章标签： 算法
于 2022-08-14 22:50:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tracy_yi/article/details/126336331
版权

P3372 【模板】线段树 1

思路

线段树是一种完全二叉树，父节点的值是两个子结点的值之和
线段树可用于区间修改、区间查询、求最值等

实现

来自Pecco的知乎文章

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 1e5 + 5;
ll tree[MAXN << 2], mark[MAXN << 2], n, m, A[MAXN];
//将标记向下传递 
void push_down(int p, int len)
{
    if (len <= 1) return;
    tree[p << 1] += mark[p] * (len - len / 2);
    mark[p << 1] += mark[p];
    tree[p << 1 | 1] += mark[p] * (len / 2);
    mark[p << 1 | 1] += mark[p];
    mark[p] = 0;
}
void build(int p = 1, int cl = 1, int cr = n)
{
	//到达叶结点 
    if (cl == cr) return void(tree[p] = A[cl]);
    int mid = (cl + cr) >> 1;
    build(p << 1, cl, mid);
    build(p << 1 | 1, mid + 1, cr);
    tree[p] = tree[p << 1] + tree[p << 1 | 1];
}
ll query(int l, int r, int p = 1, int cl = 1, int cr = n)
{
	//区间包含 
    if (cl >= l && cr <= r) return tree[p];
    //区间重叠但不包含，需要先将标记向下传递 
    push_down(p, cr - cl + 1);
    ll mid = (cl + cr) >> 1, ans = 0;
    if (mid >= l) ans += query(l, r, p << 1, cl, mid);
    if (mid < r) ans += query(l, r, p << 1 | 1, mid + 1, cr);
    return ans;
}
void update(int l, int r, int d, int p = 1, int cl = 1, int cr = n)
{
	//区间包含，直接更改该节点的值，更新标记 
    if (cl >= l && cr <= r) 
	{
		tree[p] += d * (cr - cl + 1), mark[p] += d;
		return ;
	}
    //区间重叠但不包含 
    push_down(p, cr - cl + 1);
    int mid = (cl + cr) >> 1;
    if (mid >= l) update(l, r, d, p << 1, cl, mid);
    if (mid < r) update(l, r, d, p << 1 | 1, mid + 1, cr);
    tree[p] = tree[p << 1] + tree[p << 1 | 1];
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
        cin >> A[i];
    build();
    while (m--)
    {
        int o, l, r, d;
        cin >> o >> l >> r;
        if (o == 1)
            cin >> d, update(l, r, d);
        else
            cout << query(l, r) << '\n';
    }
    return 0;
}

P3374 【模板】树状数组 1

思路

前缀和维护的区间和是[1,Ai],而树状数组维护的区间和是(Ai-lowbit(Ai),Ai]
树状数组常用于区间查询和单点修改

实现

来自Pecco的知乎文章

#include <bits/stdc++.h>
using namespace std;
#define MAXN 500005
#define lowbit(x) ((x) & (-x))
int tree[MAXN];
int n,m;
inline void update(int i, int x)
{
    for (int pos = i; pos <= n; pos += lowbit(pos))
        tree[pos] += x;
}
inline int query(int n)
{
    int ans = 0;
    for (int pos = n; pos; pos -= lowbit(pos))
        ans += tree[pos];
    return ans;
}
inline int query(int a, int b)
{
    return query(b) - query(a - 1);
}
int main()
{
	cin>>n>>m;
	int t;
	memset(tree, 0, sizeof(tree));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&t);
		update(i,t);
	}
	int a,b,c;
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		if(a==1)
			update(b,c);
		else
			printf("%d\n",query(b,c));
	}
    return 0;
}

P3368 【模板】树状数组 2

思路

树状数组用于区间修改和单点查询时，只要维护差分数组即可

实现

#include <bits/stdc++.h>
using namespace std;
#define MAXN 500005
#define lowbit(x) ((x) & (-x))
int tree[MAXN];
int a[MAXN];
int n,m;
inline void update(int i, int x)
{
    for (int pos = i; pos <= n; pos += lowbit(pos))
        tree[pos] += x;
}
inline int query(int n)
{
    int ans = 0;
    for (int pos = n; pos; pos -= lowbit(pos))
        ans += tree[pos];
    return ans;
}
int main()
{
	cin>>n>>m;
	int t;
	memset(tree, 0, sizeof(tree));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	int op;
	int x,y,k;
	for(int i=0;i<m;i++)
	{
		scanf("%d",&op);
		if(op==1)
		{
			scanf("%d%d%d",&x,&y,&k);
			update(x,k);
			update(y+1,-k);
		}
		else
		{
			scanf("%d",&k);
			printf("%d\n",a[k]+query(k));
		}
	}
    return 0;
}

P2574 XOR的艺术

思路

和线段树的模板题相比，仅仅是标记的使用方法和更新方式发生了变化
标记变为bool值，每次与1异或
而tree数组的更新则是当标记值为1时，tree[p] = len-tree[p]

实现

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 200005;
int tree[MAXN << 2], mark[MAXN << 2], n, m, A[MAXN];
//将标记向下传递 
void push_down(int p, int len)
{
	if(!mark[p]) return ;
    if (len <= 1) return ;
    tree[p << 1] = (len - len / 2) - tree[p << 1];
    mark[p << 1] ^= 1;
    tree[p << 1 | 1] = (len / 2) - tree[p << 1 | 1];
    mark[p << 1 | 1] ^= 1;
    mark[p] = 0;
}
void build(int p = 1, int cl = 1, int cr = n)
{
	//到达叶结点 
    if (cl == cr) return void(tree[p] = A[cl]);
    int mid = (cl + cr) >> 1;
    build(p << 1, cl, mid);
    build(p << 1 | 1, mid + 1, cr);
    tree[p] = tree[p << 1] + tree[p << 1 | 1];
}
ll query(int l, int r, int p = 1, int cl = 1, int cr = n)
{
	//区间包含 
    if (cl >= l && cr <= r) return tree[p];
    //区间重叠但不包含，需要先将标记向下传递 
    push_down(p, cr - cl + 1);
    ll mid = (cl + cr) >> 1, ans = 0;
    if (mid >= l) ans += query(l, r, p << 1, cl, mid);
    if (mid < r) ans += query(l, r, p << 1 | 1, mid + 1, cr);
    return ans;
}

//[cl,cr]是当前树的区间，[l,r]是要操作的区间 
void update(int l, int r,int p = 1, int cl = 1, int cr = n)
{
	//区间包含，直接更改该节点的值，更新标记 
    if (cl >= l && cr <= r) 
	{
		tree[p] = (cr - cl + 1) - tree[p], mark[p] ^= 1;
		return ;
	}
    //区间重叠但不包含 
    if(mark[p])
    push_down(p, cr - cl + 1);
    
    int mid = (cl + cr) >> 1;
    if (mid >= l) update(l, r, p << 1, cl, mid);
    if (mid < r) update(l, r, p << 1 | 1, mid + 1, cr);
    tree[p] = tree[p << 1] + tree[p << 1 | 1];
}
int main()
{
//	freopen("P2574_1.in","r",stdin); 
//    ios::sync_with_stdio(false);
    scanf("%d %d\n",&n,&m);
    char ch;
    for (int i = 1; i <= n; ++i)
    {
    	ch = getchar();
    	A[i] = ch - '0';
	}
    build();
    while (m--)
    {
        int o, l, r;
        scanf("%d%d%d",&o,&l,&r);
        if (o == 0)
            update(l, r);
        else
            cout << query(l, r) << '\n';

    }
    return 0;
}

P3373 【模板】线段树 2

思路

  • 需要两个标记，一个代表加一个代表乘，同时也需要两个update函数
  • push_down的时候注意
    • 子结点的值 = 子结点的值 * 父结点的乘法标记 + 区间长度 * 父结点的加法标记
    • 子结点的乘法标记 *= 父节点的乘法标记
    • 子结点的加法标记 = 子结点的加法标记 * 父节点的乘法标记 + 子节点的加法标记
  • 同时所有的计算最后需要模p

实现

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 1e5 + 5;
ll tree[MAXN << 2], mark[MAXN << 2], mark2[MAXN << 2], n, m, P, A[MAXN];
//将标记向下传递 
void push_down(int p, int len)
{
    if (len <= 1) return;
    tree[p << 1] = (tree[p << 1] * mark2[p] + mark[p] * (len - len / 2)) % P;
    mark[p << 1] = (mark[p << 1] * mark2[p] + mark[p]) % P;
    mark2[p << 1] *= mark2[p];
    
    tree[p << 1 | 1] = (tree[p << 1 | 1] * mark2[p] + mark[p] * (len / 2)) % P;
    mark[p << 1 | 1] = (mark[p << 1 | 1] * mark2[p] + mark[p]) % P;
    mark2[p << 1 | 1] *= mark2[p];
    
	mark2[p << 1] %= P;
	mark2[p << 1 | 1] %= P;
	
    mark[p] = 0;
    mark2[p] = 1; 
    return ;
}
void build(int p = 1, int cl = 1, int cr = n)
{
	//到达叶结点 
    if (cl == cr) return void(tree[p] = A[cl]);
    int mid = (cl + cr) >> 1;
    build(p << 1, cl, mid);
    build(p << 1 | 1, mid + 1, cr);
	tree[p] = (tree[p << 1] + tree[p << 1 | 1]) % P;
}
ll query(int l, int r, int p = 1, int cl = 1, int cr = n)
{
	//区间包含 
    if (cl >= l && cr <= r) return tree[p];
    //区间重叠但不包含，需要先将标记向下传递 
    push_down(p, cr - cl + 1);
    ll mid = (cl + cr) >> 1, ans = 0;
    if (mid >= l) ans += query(l, r, p << 1, cl, mid);
    if (mid < r) ans += query(l, r, p << 1 | 1, mid + 1, cr);
    return ans;
}
void update(int l, int r, int d, int p = 1, int cl = 1, int cr = n)
{
	//区间包含，直接更改该节点的值，更新标记 
    if (cl >= l && cr <= r) 
	{
		tree[p] = (tree[p] + d * (cr - cl + 1)) % P, mark[p] += d, mark[p] %= P;
		return ;
	}
    //区间重叠但不包含 
    push_down(p, cr - cl + 1);
    int mid = (cl + cr) >> 1;
    if (mid >= l) update(l, r, d, p << 1, cl, mid);
    if (mid < r) update(l, r, d, p << 1 | 1, mid + 1, cr);
	tree[p] = (tree[p << 1] + tree[p << 1 | 1]) % P;
}

void update2(int l, int r, int d, int p = 1, int cl = 1, int cr = n)
{
	//区间包含，直接更改该节点的值，更新标记 
    if (cl >= l && cr <= r) 
	{
		tree[p] *= d, mark2[p] *= d, mark[p] *= d, tree[p] %= P, mark[p] %= P, mark2[p] %= P;
		return ;
	}
    //区间重叠但不包含 
    push_down(p, cr - cl + 1);
    int mid = (cl + cr) >> 1;
    if (mid >= l) update2(l, r, d, p << 1, cl, mid);
    if (mid < r) update2(l, r, d, p << 1 | 1, mid + 1, cr);
    tree[p] = (tree[p << 1] + tree[p << 1 | 1]) % P;
}

int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m >> P;
    for (int i = 1; i <= n; ++i)
        cin >> A[i];
    build();
//    cout<<"p: "<<P<<endl;
    for(int i = 0; i <= 2*n; ++i)
    	mark2[i] = 1;
    	
//    for(int i = 0; i <= 2*n; ++i)
//    	cout<<tree[i]<<" ";
//    	cout<<endl;
     	
    while (m--)
    {
        int o, l, r, d;
        cin >> o >> l >> r;
        if (o == 1)  //乘操作 
            cin >> d, update2(l, r, d);
        else if(o==2)  //加操作 
        	cin >> d, update(l, r, d);
        else
            cout << query(l, r) % P << '\n';
    }
    return 0;
}

P1908 逆序对

思路

【算法2-3】分治中提到的解法是归并排序，这道题也可以使用离散化+树状数组来做

实现

//来自洛谷题解区 学无止境
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int tree[500010],ranks[500010],n;
long long ans; 
struct point
{
    int num,val;
}a[500010];
inline bool cmp(point q,point w)
{
    if(q.val==w.val)
        return q.num<w.num;
    return q.val<w.val;
}
inline void insert(int p,int d)
{
    for(;p<=n;p+=p&-p)
        tree[p]+=d; 
}
inline int query(int p)
{
    int sum=0;
    for(;p;p-=p&-p)
        sum+=tree[p];
    return sum;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i].val),a[i].num=i;
    sort(a+1,a+1+n,cmp);
    for(int i=1;i<=n;i++)
        ranks[a[i].num]=i;
    for(int i=1;i<=n;i++)
    {
        insert(ranks[i],1);
        ans+=i-query(ranks[i]);
    }
    printf("%lld",ans);
    return 0;
}

P1966 [NOIP2013 提高组] 火柴排队

思路

两列火柴中，每个位置的火柴在所在列中的长度排名都相同时， ∑ ( a i − b i ) 2 \sum(a_i-b_i)^2 ∑(ai​−bi​)2最小
转化为逆序对问题

实现

#include<bits/stdc++.h>
using namespace std;
typedef struct{
	int v;
	int k;
}node;
int n;
node a[100010],b[100010];
int x[100010],c[100010];
long long ans;
void msort(int b,int e)
{
    if(b==e)  
		return;
    int mid=(b+e)/2,i=b,j=mid+1,k=b;
    msort(b,mid),msort(mid+1,e);
    while(i<=mid&&j<=e)
    {
    	if(x[i]<=x[j]) 
    		c[k++]=x[i++];  //c数组辅助归并排序
    	else  //左边比右边大，产生逆序对
    		c[k++]=x[j++],ans= (ans+mid-i+1) % (99999997);
    }
    while(i<=mid)  //如果左边没有放完就把左边区间所有剩下的数放进去
    	c[k++]=x[i++];
    while(j<=e)    //右边同理
    	c[k++]=x[j++];
    for(int l=b;l<=e;l++)  //更新a
    	x[l]=c[l];
} 
bool cmp(node a,node b)
{
	return a.v<b.v;
}
int main()
{
    scanf("%d",&n); 
    for(int i=1;i<=n;i++)
    {
		scanf("%d",&a[i].v);
		a[i].k = i;
	}
    
    for(int i=1;i<=n;i++)
    {
		scanf("%d",&b[i].v);
		b[i].k = i;
	}    
    
    sort(a+1,a+1+n,cmp);
    sort(b+1,b+1+n,cmp);
    
    for(int i=1;i<=n;i++)
    {
    	x[b[i].k] = a[i].k;
	}
    
    msort(1,n);
    printf("%lld",ans%(99999997));
    return 0;
}

P5677 [GZOI2017]配对统计

思路

预处理出所有好对+树状数组
洛谷题解区一篇优秀的题解

实现

#include <bits/stdc++.h>
using namespace std;
#define MAXN 300005
#define lowbit(x) ((x) & (-x))
typedef long long ll;
ll tree[MAXN];
int n,m;
struct query{
	int l,r;
	int index;
}querys[MAXN];
struct node{
	int num;
	int pos;
}a[MAXN];
struct goodpair{
	int l,r;
}pairs[MAXN<<2];
int paircount;
void add_pair(int a,int b)
{
	int i;
	if(a>b) i = a,a = b,b = i;
	pairs[++paircount].l = a;
	pairs[paircount].r = b;
}
inline void update(int i, int x)
{
    for (int pos = i; pos <= n; pos += lowbit(pos))
        tree[pos] += 1;
}
inline ll Query(int n)
{
    ll ans = 0;
    for (int pos = n; pos; pos -= lowbit(pos))
        ans += tree[pos];
    return ans;
}
inline ll Query(int a, int b)
{
    return Query(b) - Query(a - 1);
}
bool cmp(struct node a,struct node b)
{
	return a.num<b.num;
}
bool cmp_pair(struct goodpair a,struct goodpair b)
{
	if(a.r!=b.r) return a.r<b.r;
	return a.l<b.l;
}
bool cmp_query(struct query a,struct query b)
{
	if(a.r!=b.r) return a.r<b.r;
	return a.l<b.l;	
}
int main()
{
	cin>>n>>m;
	if(n==1) 
	{cout<<"0";
	return 0;
}
	int t;
	memset(tree, 0, sizeof(tree));
	for(int i = 1; i <= n; ++i)
	{
		scanf("%d",&t);
		a[i].num = t;
		a[i].pos = i;
	}
	sort(a+1,a+1+n,cmp);
	for(int i = 1; i <= m; ++i)
	{
		scanf("%d%d",&querys[i].l,&querys[i].r);
		querys[i].index = i;
	}
	sort(querys+1,querys+1+m,cmp_query);
	if(n!=1)
	{
		add_pair(a[1].pos,a[2].pos);
		add_pair(a[n].pos,a[n-1].pos);
	}
	for(int i=2;i<n;i++)
	{
		int d1 = a[i].num-a[i-1].num;
		int d2 = a[i+1].num-a[i].num;
		if(d1==d2) add_pair(a[i].pos,a[i-1].pos),add_pair(a[i+1].pos,a[i].pos);
		else if(d1>d2) add_pair(a[i].pos,a[i+1].pos);
		else add_pair(a[i].pos,a[i-1].pos);
	}
	sort(pairs+1,pairs+1+paircount,cmp_pair);
	ll ans = 0;

	for(int i=1,j=1;i<=m;i++)
	{
		while(pairs[j].r<=querys[i].r && j<=paircount)
		{
			update(pairs[j].l,1);
			j++;
		}
		ans+=querys[i].index*(j-1-Query(querys[i].l-1));
	}
	printf("%lld",ans);
    return 0;
}

这部分的题好难 不想再写剩下的了= =

欢迎指正-

岁余十二.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
洛谷精选-树形数据结构例题（1）
12-29
来自洛谷的精选树形数据结构，覆盖线段树、可持久化线段树、树状数组、并查集、平衡树、堆、cdq分治等多种树形数据结构，写完之后轻松掌握树形数据结构！！！
线段树树状数组课件（ppt）
02-16
线段树&树状数组课件 树状数组&线段树是最基本的高级数据结构之二 一般出现于较难题中 应用广泛，可用于直接写正解/把暴力改进成正解/拿大量部分分
洛谷练习题——高级数据结构篇
m0_72747430的博客
02-06 161
洛谷练习题
枚举专题
zxwsbg的博客
07-30 335
无聊听了蓝桥学苑的系列网课，有些东西还是值得学习的。   哈希表的运用（unordered_map) c++ 11的新东西，map是基于红黑树的，这个是基于哈希表的，所以单次复杂度是O (1)，但是建表的时候时间复杂度可能会退化。 题目1链接：http://hihocoder.com/problemset/problem/1494?sid=1342022 题目大意：略 题解：求最...
洛谷 P3372 【模板】线段树 1
qq_17807067的博客
10-01 702
线段树简单理解
【洛谷题单刷题日记】线段树
CUMT_William_Liu的博客
01-30 421
1：洛谷 P3372 【模板】线段树 1   线段树是用来解决区间和/区间最值/区间覆盖的问题，而本道题涉及到了区间和问题，是区间修改和区间查询的问题（单点查询和单点修改对应的就是l==rl==rl==r的情况）。如果修改一个区间时，每次都修改到叶结点，那么一个叶节点的修改所需的复杂度是O(nlogn)O(nlogn)O(nlogn),修改一次区间的时间复杂度是O(nlogn)O(nlogn)O(nlogn),QQQ次区间修改的时间复杂度是O(n2logn)O(n^2logn)O(n2logn),效率甚至低
[洛谷]P3372 【模板】线段树 1 (#线段树)
A.pro的博客
07-16 328
题目描述 如题，已知一个数列，你需要进行下面两种操作： 1.将某区间每一个数加上x 2.求出某区间每一个数的和 输入输出格式 输入格式： 第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。 第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。 接下来M行每行包含3或4个整数，表示一个操作，具体如下： 操作1： 格式：1 x y k 含义：将区间[...
洛谷线段树题解
qq_48344603的博客
09-02 291
P3372 【模板】线段树 1 #include<iostream> #include<cmath> #include<algorithm> #include<iomanip> #include<cstring> #include<map> #include<vector> #include<queue> #include<functional> #include<memory.h>
线段树 树状数组 数据结构
07-24
线段树 树状数组 数据结构 线段树 树状数组 数据结构 acm 线段树 树状数组 数据结构 线段树 树状数组 数据结构 acm 线段树 树状数组 数据结构 线段树 树状数组 数据结构 acm 线段树 树状数组 数据结构 线段树 树状...
数据结构课程设计-线段树
06-08
数据结构课程的课程设计
c++数据结构进阶线段树习题
07-05
【线段树】是一种高效的数据结构，用于处理区间更新和查询的问题。在C++中，线段树可以用来实现动态维护区间最值、区间加法等操作。它将一个数组分成若干个重叠的子区间，每个节点代表一个子区间，通过节点之间的...
洛谷上若干经典树状数组题解集（lg1774、lg1966、lg1972）
hans774882968的博客
04-26 228
文章目录lg1774lg1966lg1774的升级版简化一下c数组的求法代码lg1972 juejin传送门 lg1774 传送门 经典题：排序只能交换相邻元素的最少操作次数。 为什么答案是逆序数：升序数组逆序数为0。一次操作逆序数减少0或1。因此最优方案必定满足：每一步的逆序数都能减少1。证毕。 但我们还是不知道最优方案长啥样！对于a[i] <= a[i+1]的i，交换它们是多余的，因为逆序数不减少。因此我们设右侧是已经升序排好的部分，那么我们就需要在左侧找到最大值并把它放到期望的位置（当然还有一些
单点修改&区间求和
AlanJobs的博客
02-10 661
题目描述 如题，已知一个数列，你需要进行下面两种操作： 将某一个数加上xx 求出某区间每一个数的和 输入格式 第一行包含两个正整数n,mn,m，分别表示该数列数字的个数和操作的总个数。 第二行包含nn个用空格分隔的整数，其中第ii个数字表示数列第ii项的初始值。 接下来mm行每行包含33个整数，表示一个操作，具体如下： 1 x k含义：将...
洛谷 P3374：树状数组模板题
hnjzsyjyj的专栏
10-01 321
【问题描述】 题目来源：https://www.luogu.com.cn/problem/P3374 如题，已知一个数列，你需要进行下面两种操作： • 将某一个数加上 x； • 求出某区间每一个数的和。【输入格式】 第一行包含两个正整数 n，m，分别表示该数列数字的个数和操作的总个数。 第二行包含 n 个用空格分隔的整数，其中第 i 个数字表示数列第 i 项的初始值。 接下来 m 行每行包含 3 个整数，表示一个操作，具体如下： • 1 x k 含义：将第 x 个数加上 k； • 2 x y 含义：输出区间
洛谷 - P3368 树状数组2
cowgoodsheep的博客
03-08 232
洛谷 - P3368 树状数组2
洛谷篇 线段树模板
m0_53056473的博客
06-20 136
区间求和 需要用线段树这样的数据结构来储存数据，从而降低操作的时间复杂度。模板说明：输出：1.区间求和 2.区间求极值操作：单点修改、区间修改const int inf=0x3f3f3f3f;const int maxn=1e5+5;Long long sum[maxn*4],minn[maxn*4],maxx[maxn*4],vis[maxn*4]Int Map[maxn],n;//sum储存和，minn最小值，maxx最大值，vis作为求最值的标记数组，Map是原数组//建树void built(int
线段树详解（洛谷模板题）
spencer12138的博客
11-11 1123
一、算法概况     线段树是一种二叉搜索树，它将一个区间分成多个单元区间，每个单元区间对应线段树的一个叶子节点，有查询区间和，查询区间最大值、最小值等功能（本篇讲解的是求区间和的代码），由于它二叉结构的特性，使得他的操作复杂读为O(logN）     线段树的根节点代表所要维护的值在总区间 [a,b] 的值，他的左子节点代表区间 [a,(a+b)/2] ,他的右子节点代表区间 [(a+b)/
P3372 ---洛谷---线段树(模板)---C++
Ashen的博客
01-12 156
题目描述 如题，已知一个数列，你需要进行下面两种操作： 将某区间每一个数加上x 求出某区间每一个数的和 输入格式 第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。 第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。 接下来M行每行包含3或4个整数，表示一个操作，具体如下： 操作1： 格式：1 x y k 含义：将区间[x,y]内每个数加上k 操作2： 格式...
洛谷 线段树1
离开那天的博客
05-10 187
线段树模板 看题目戳这多打几遍就好了 记住define后面不能加分号aaaaa #include<bits/stdc++.h> #define ll long long using namespace std; struct node{ int l,r; ll sum,add; #define sum(x) tree[x].sum #define add(x) tree[x]....
c++线段树和树状数组
最新发布
10-05
线段树和树状数组都是用于解决区间查询问题的数据结构，它们在不同的场景下有不同的应用。 首先，树状数组（Binary Indexed Tree，BIT），也称为Fenwick树，是一种用于高效实现区间查询的数据结构。它通过将原始数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值