线性初始化树状数组
void init(){//线性构造
for (int i = 1; i <= n; i++){
sum[i] = sum[i - 1] + a[i];
c[i] = sum[i] - sum[i - lowbit(i)];
}
}
对于线段树千万不要嫌烦
第一遍可以抄一遍题解，大致了解方法；
第二遍半看半打，加深印象；
第三遍就可以开始自己打；
绝对有效
关于线段树大佬们已经讲的很清楚了，我在这里讲几个蒟蒻容易犯的错误(线段树的坑)：
不开long long见祖宗，要开long long，一定要开
每个修改操作的函数中一定要明确出口（return不能少，具体见代码）
记录线段树数值和懒标记的数组至少要开n的4倍
每打完一部分就要检查，否则你将会献出一上午（大佬请忽略此条）
再码字途中，线段树会出现 int mid=(l+r)/2这样的语句，mid也有的写成m，所以这时要注意分清楚题目中的m(通常是操作次数)和mid
懒标记要下传
懒标记一定要乘区间长度，并注意 大减小 (r-l)，反正这是我犯的一个ZZ错误
不要忘记调用build()函数（不开玩笑，新手经常忘）
当要进行区间乘一个数操作时，懒标记初始要设为1，(而不是加法懒标记初始为0)
当进行多种运算操作是，要注意修改顺序，一般是先乘除，再加减
码字时可以尽量写的散一些，反正就是要自己看着不会头皮发麻，这样检查时很省事
以上的线段树坑来自 luogu 老部长卢晨昕
首先先让我们认识离散化用的函数,STL给我们提供了便利:
unique(start,end);//取出有序序列重复元素,左闭右开,返回去重复序列最后一个元素位置
lower_bound(start,end,key);//左闭右开中寻找第一个大等于key的数,返回值
std::sort(a+1,a+n+1);
cnt = std::unique(a+1,a+n+1) - (a+1)//去重并获得去重后长度cnt,注意减的是初始地址qwq我错了一次
for(int i=1;i<=n;i++)
a[i] = lower_bound(a+1,a+1+cnt,a[i]) - a
感觉原来离散化写的很乱，今天重新修一下
在有序int数组中查找大于等于x的最小整数下标
我们需要对原数组进行一次备份（cp 数组），以便后面的复原
p3755 老c的任务
题解:
树状数组
将点按(x)递增；将询问拆成2个，离线，离散化，按(x)递增排序。按x轴排序，y轴维护树状数组。
然后每次找到一个询问，就判断有哪些点可以加到树状数组中，然后查询一下就好了。把区间询问转化为前缀和相减.
注意题目中边上也算是包含，所以应将左下边界-1；同时坐标必须是正的，还需要+2。
P1972HH的项链
#include<cstdio>
#include<algorithm>
#define maxn 1000005
using namespace std;
int n,l,r;
int num[maxn],tree[maxn],booll[maxn],ans[maxn],q;
struct tre{
int l,r,pos;
}ask[maxn];
inline int lowbit(int x){return x&(-x);}
bool cmp(tre a,tre b){return a.r < b.r;}
inline void add(int fa,int ad){
while(fa<=n)
{
tree[fa]+=ad;
fa+=lowbit(fa);
}
}
inline int sum(int n){
int ans = 0;
while(n){
ans += tree[n];
n -= lowbit(n);
}
return ans;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&num[i]);
scanf("%d",&q);
for(int i=1;i<=q;i++)
{
scanf("%d%d",&ask[i].l,&ask[i].r);
ask[i].pos = i;
}
sort(ask+1,ask+q+1,cmp);
int next = 1;
for(int i=1;i<=q;i++){
for(int j=next;j <= ask[i].r;j++){
if(booll[num[j]])
add(booll[num[j]],-1);//注意这里,仔细理解下
add(j,1);
booll[num[j]]=j;}
next=ask[i].r+1;
//更新下一次查询的位置
ans[ask[i].pos]=sum(ask[i].r)-sum(ask[i].l-1);
}
for(int i=1;i<=q;i++)
printf("%d
",ans[i]);
}
P4054计数问题
题解:多维树状数组板子
可以发现 , 矩阵中值的值域很小
(wle 100)考虑暴力思路,
构建(100)个二维树状数组,分别存储各数值 ,在矩阵中出现的次数.
单点修改:将a修改成b,先将a对应的树状数组改掉,对应位置出现次数-1，再对b对应的树状数组对应位置+1
区间查询:直接查询对应子矩阵出现次数即可
#include<cstdio>
#define maxn 301
#define lowbit(x) -x&x
#define ll long long
using namespace std;
inline int read()
{
char ch=getchar();int i=0,f=1;
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){i=(i<<1)+(i<<3)+ch-'0';ch=getchar();}
return i*f;
}
int n,m,q;
int map[maxn][maxn],tree[101][maxn][maxn];
inline void add(int val,int x,int y,int z){//修改操作,将此点权值设为val,并使其次数+=z
map[x][y] = val;
for(int i = x;i <= n;i += lowbit(i))
for(int j = y;j <= m;j += lowbit(j))
tree[val][i][j] += z;
}
inline ll sum(int type,int x,int y){//查询1,1到x,y的type出现次数
int cnt = 0;
for(int i = x;i;i -= lowbit(i))
for(int j = y;j;j -= lowbit(j))
cnt += tree[type][i][j];
return cnt;
}
int main(){
n=read(),m=read();
for(int i = 1;i <= n;i++)
for(int j = 1;j <= m;j++)
add(read(),i,j,1);
q=read();
for(int i=1;i<=q;i++)
{
int opt = read();
if(opt == 1){
int x= read(),y=read(),tem=read();
add(map[x][y],x,y,-1);//原值出现次数-1
add(tem,x,y,1);//新值出现次数+1
}
else{
int x1=read(),x2=read(),y1=read(),y2=read(),type=read();
ll ans1 = sum(type,x2,y2),ans2=sum(type,x1-1,y1-1);
ll ans = ans2 + ans1 - sum(type,x1-1,y2) - sum(type,x2,y1-1);//容斥
//sum是不含边界的
printf("%lld
",ans);
}
}
}
线段树:满足区间可加性(f(x,y)=f(f(x,z),f(z,y)),zin[x,y])
线段树以常数大,空间大,难写难调而臭名远扬,但有时也很给力,当然能不写线段树就不写啦,而且记得要开四倍空间
以下部分参考LightHouseOfficial的内容
区间和,区间最大最小值,区间LCA，区间质数个数......可以用线段树维护
假设数组是{1,2,3,4,5,6}查询区间[2,4]，计算出[2,4]的mid值,mid=(l+r)<<1=3
然后我们查询[l,mid]和[mid+1,r]区间[2,3]和[4,4]
[4,4]是叶子,返回它的值4,回到[2,3]继续递归
p<<1是左儿子,p<<1|1为右儿子
建树:
#define l(x) tree[x].l
#define r(x) tree[x].r
#define val(x) tree[x].val
void pushup(int p){
val(p)=val(p<<1)+val(p<<1|1);
}
void build(int p,int l,int r){
l(p)=l,r(p)=r;//保存每个节点的左右儿子的编号
if(l==r){
val(p)=a[l];
return;
}pushdown(p);
int mid=(l+r)>>1;
build(p<<1,l,mid);build(p<<1|1,mid+1,r);//递归建树
pushup(p);//更新值
}
int query(int p,int l,int r){//查询区间和 p是fa
if(l<=tree[p].l && r>=tree[p].r)return tree[p].val;
pushdown(p);
int mid=(tree[p].l+tree[p].r)>>1;
int ret=0;
if(l<=mid) ret+=query(p<<1,l,r);
if(r>mid) ret+=query(p<<1|1,l,r);
return ret;
}
区间修改,打lazytag 然后pushdown
#define val(x) tree[x].val
#define add(x) tree[x].add
void pushdown(int p){
if(add(p)){
val(p<<1)+=add(p)*(r(p<<1)-l(p<<1)+1);
val(p<<1|1)+=add(p)*(r(p<<1|1)-l(p<<1|1)+1);
add(p<<1)+=add(p);
add(p<<1|1)+=add(p);
add(p)=0;
}
}//加法
void update(int p,int l,int r,int d){//修改
if(l<=l(p) && r>=r(p)){
val(p)+=d*(r(p)-l(p)+1);add(p)+=d;
return;
}
pushdown(p);
int mid=(l(p)+r(p))>>1;
if(l<=mid)update(p<<1,l,r,d);
if(r>mid)update(p<<1|1,l,r,d);
pushup(p);
}
动态开点线段树
由于线段树要maxn<<2,maxn过大显然MLE,这时就要离散化或动态开点了
意思是，你要用到一个点才开那个点，不用的点不开，可以大幅节省空间，空间复杂度降为O(nlogn)
(log_210^6approx20)是不是很给力
接下来是实现：
一开始，你只有一个根节点。
通过update函数往树里面插点，开两个数组记录每个节点的左右儿子编号。
递归进入左右儿子，如果要用新点，就开新点。
可持久化线段树
对于每个询问我们每次不开一整棵树，而是每次把修改节点插入，也就是插入一些历史节点来储存历史值。
空间复杂度成了(nlog^2n)，一般开32倍空间<<5
一般可持久化线段树的题目只要求单点修改，区间修改可以实现不过复杂度比较高。
真的遇到了需要写主席树而且要求区间修改的题目，一般可以转化为单点修改进行操作
时间复杂度((n+m)logn)
还没完咕咕咕