【全程NOIP计划】初级数据结构2

【全程NOIP计划】初级数据结构2

树状数组

可以用于维护前缀信息（可合并）

优点：代码段，速度快

比如：

给定一个长n的数组，支持操作：

1.将第\(i\)个数\(a_i\)加\(v\)

2.询问区间\([l,r]\)中的数的和

\(lowbit(i)\)：只保留\(i\)的二进制表示中最低位的1

树状数组中，节点\(i\)表示的区间为\([i-lowbit(i)+1,i]\)

前缀查询

查询区间\([1,i]\)的和的时候，由\(i\)可以直接得到\([i-lowbit(i)+1,i]\)的和，接下来查询\([1,i-lowbit(i)]\)的区间和，重复上面的步骤就可以了

单点修改

修改\(i\)的时候，寻找包含i的所有区间：

第一个包含\(i\)且\(lowbit\)比\(i\)大的节点是\(i+lowbit(i)\)

int lowbit(int x)
{
    return x&(-x);
}
void add(int x,int y)
{
    for( ;x<=n;x+=lowbit(x)) c[x]+=y;
}
int ask(int x)
{
    int res=0;
    for( ;x;x-=lowbit(x))
        res+=c[x];
    return res;
}

差分

实际上就是用树状数组维护一下差分序列的前缀和就行

区间修改

将区间\([l,r]\)内的数全加v，或者查询\([l,r]\)内数的和

考虑用差分数组来表示\([1,R]\)的前缀和

\[\sum_{k=1}^Ra_k=\sum_{k=1}^R \sum_{i=1}^kd_i \\ =\sum_{i=1}^R \sum_{k=i}^Rd_i \\ =\sum_{i=1}^R(R-i+1)d_i=(R+1)\sum_{i=1}^Rd_i-\sum_{i=1}^Rid_i \]

逆序对

题目

给定序列，求有多少对逆序对

思路

对于每个i，它的前面有多少个数比它大

先离散化，对值域建树状数组

然后从左往右扫描一次，在每个位置需要查询权值的前缀和，然后把这个数加入树状数组

时间复杂度\(O(nlogn)\)

二维树状数组

给定n*m的矩阵\(a_{i,j}\),有\(q\)次操作，每次操作修改某个元素或者查询某个子矩阵的和

记录\(b_{i,j}\)表示从\((i-lowbit(i)+1,j-lowbit(j)+1)\)到\((i,j)\)的子矩阵的和

查询和修改的时候，先枚举第一维，再枚举第二维

时间复杂度\(O(Qlogn \space logm)\)

void update(int x,int y,int z)
{
    for(int i=x;i<=n;i+=lowbit(i))
    {
        for(int j=y;j<=m;j+=lowbit(j))
            b[i][j]+=z;
    }
}
int query(int x,int y)
{
    int res=0;
    for(int i=x;i>0;i-=lowbit(i))
    {
        for(int j=y;j>0;j-=lowbit(j))
            res+=b[i][j];
    }
    return res;
}

线段树

可以用于维护区间信息

比如：

维护长为n的序列：

包括单点修改，区间查询等操作

线段树的形式是一颗二叉树，每个节点维护一段区间的信息

根节点为\([1,n]\)

对于节点\([L,R]\)，设中点\(mid=\lfloor \dfrac {L+R} 2 \rfloor\),把该节点从mid处分开，左边的子节点为\([L,mid]\)，右边的子节点为\([mid+1,R]\)

树高\(O(log n)\)，总结点数2n-1

对于节点x。左儿子为2x,右儿子则为2x-1

建树

根节点为\([1,n]\)，考虑根节点为\([L,R]\)的时候：

设mid=(l+r)/2，对于区间\([L,mid],[mid+1,R]\)递归建树

合并两个区间的信息

int a[N], mx[N << 2];
void update(int x, int L, int R) {
    if(L != R) {
        mx[x] = max(mx[x << 1], mx[x << 1 | 1]);
    }
}
void build(int x, int L, int R) {
    if(L == R) {
        mx[x] = a[L];
        return;
    }
    int mid = (L + R) >> 1;
    build(x << 1, L, mid);
    build(x << 1 | 1, mid + 1, R);
    update(x, L, R);
}

单点修改/查询

单点查询：从上向下找到对应的叶子节点

单点修改：先修改叶子节点，然后从下往上向上更新

int query(int x, int L, int R, int p) {
    if(L == R) return mx[x];
    int mid = (L + R) >> 1;
    if(p <= mid) return query(x << 1, L, mid, p);
    else return query(x << 1 | 1, mid + 1, R, p);
}
int modify(int x, int L, int R) {
    if(L == R) {
        mx[x] = v;
        return;
    }
    int mid = (L + R) >> 1;
    if(p <= mid) modify(x << 1, L, mid, p, v);
    else modify(x << 1 | 1, mid + 1, R, p, v);
    update(x, L, R);
}

区间查询

查询区间\([l,r]\)的时候，可以最多拆成\(2log \space n\)个不相交区间，合并这些区间可以得到答案

从线段树从上往下找答案

区间修改

对区间\([l,r]\)加\(v\)，同样可以拆成最多\(2log\space n\)个区间，并修改这些区间

在一个节点做区间修改的时候，不立刻修改它的子节点

记录懒标记：每个节点x记录还没有加到子树中的值的总和

查询经过某节点的时候，将懒标记下放给它的两个儿子

int mx[N << 2], sum[N << 2], tag[N << 2];
void update(int x) {
    mx[x] = max(mx[x << 1], mx[x << 1 | 1]);
    sum[x] = sum[x << 1] + sum[x << 1 | 1];
}
void pushdown(int x, int L, int R) {
    if(tag[x] == 0) return;
    sum[x] += tag[x] * (R - L + 1);
    mx[x] += tag[x];
    if(L != R) {
        tag[x << 1] += tag[x];
        tag[x << 1 | 1] += tag[x];
    }
    tag[x] = 0;
}
// a[l...r] += v
void modify(int x, int L, int R, int l, int r, int v) {
    pushdown(x, L, R);
    if(L == l && R == r) {
        tag[x] += v;
        pushdown(x, L, R);
        return;
    }
    int mid = (L + R) >> 1;
    if(r <= mid) modify(x << 1, L, mid, l, r, v);
    else if(l > mid) modify(x << 1 | 1, mid+1, R, l, r, v);
    else{
        modify(x << 1, L, mid, l, mid, v);
        modify(x << 1 | 1, mid+1, R, mid+1, r, v);
    }
    update(x);
}

标记永久化

// -------------- 标记永久化 ---
void modify(int x, int L, int R, int l, int r, int v) {
    if(L == l && R == r) {
        tag[x] += v;
        sum[x] += tag[x] * (R - L + 1);
        mx[x] += tag[x];
        return;
    }
    int mid = (L + R) >> 1;
    if(r <= mid) modify(x << 1, L, mid, l, r, v);
    else if(l > mid) modify(x << 1 | 1, mid+1, R, l, r, v);
    else{
        modify(x << 1, L, mid, l, mid, v);
        modify(x << 1 | 1, mid+1, R, mid+1, r, v);
    }
    update(x, L, R);
}
int query(int x, int L, int R, int l, int r, int cur) {
    if(l == L && r == R)
        // return mx[x] + cur;
        return sum[x] + cur * (r - l + 1);
    cur += tag[x];
    int mid = (L + R) >> 1;
    if(r <= mid) return query(x << 1, L, mid, l, r, cur);
    else if(l > mid) return query(x << 1 | 1, mid + 1, R, l, r, cur);
    else{
        int u = query(x << 1, L, mid, l, mid, cur);
        int v = query(x << 1 | 1, mid + 1, R, mid + 1, r, cur);
        // return max(u, v);
        return u + v;
    }
}

P2023 维护序列

思路

实际上就是多一个乘法标记，跟线段树2差不多，就一板子

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int maxn=100010;
int p;
int a[maxn+5];
struct tree{
	int l,r;
	long long dat,lazy,mul;
}t[maxn*4+5];
void pushup(int k)
{
	t[k].dat=(t[k<<1].dat+t[k<<1|1].dat)%p;
}
void build(int k,int l,int r)
{
	t[k].lazy=0,t[k].mul=1;
	t[k].l=l,t[k].r=r;
	if(l==r)
	{
		t[k].dat=a[l];
		return ;
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	pushup(k);
}
void pushdown(int k)
{
		t[k<<1].dat=(t[k<<1].dat*t[k].mul+t[k].lazy*(t[k<<1].r-t[k<<1].l+1))%p;
		t[k<<1|1].dat=(t[k<<1|1].dat*t[k].mul+t[k].lazy*(t[k<<1|1].r-t[k<<1|1].l+1))%p;
		t[k<<1].mul=(t[k<<1].mul*t[k].mul)%p;
		t[k<<1|1].mul=(t[k<<1|1].mul*t[k].mul)%p;
		t[k<<1].lazy=(t[k<<1].lazy*t[k].mul+t[k].lazy)%p;
		t[k<<1|1].lazy=(t[k<<1|1].lazy*t[k].mul+t[k].lazy)%p;
		t[k].mul=1;
		t[k].lazy=0;
}
void updata(int k,int l,int r,int v)
{
	if(l<=t[k].l&&r>=t[k].r)
	{
		t[k].dat=(t[k].dat+(long long)v*(t[k].r-t[k].l+1))%p;
		t[k].lazy=(t[k].lazy+v)%p;
		return ;
	}
	pushdown(k);
	int mid=(t[k].l+t[k].r)>>1;
	if(l<=mid)
	updata(k<<1,l,r,v);
	if(r>mid)
	updata(k<<1|1,l,r,v);
	pushup(k);
}
void updata2(int k,int l,int r,int v)
{
	if(l<=t[k].l&&r>=t[k].r)
	{
		t[k].dat=(t[k].dat*v)%p;
		t[k].lazy=(t[k].lazy*v)%p;
		t[k].mul=(t[k].mul*v)%p;
		return ;
	}
	pushdown(k);
	int mid=(t[k].l+t[k].r)>>1;
	if(l<=mid)
	updata2(k<<1,l,r,v);
	if(r>mid)
	updata2(k<<1|1,l,r,v);
	pushup(k);
}
long long query(int k,int l,int r)
{
	if(l<=t[k].l&&r>=t[k].r)
	return t[k].dat;
	pushdown(k);
	int mid=(t[k].l+t[k].r)>>1;
	long long ans=0%p;
	if(l<=mid)
	ans+=query(k<<1,l,r)%p;
	if(r>mid)
	ans+=query(k<<1|1,l,r)%p;
	return ans%p;
}
int main()
{
	std::ios::sync_with_stdio(false);
	int n,m;
	cin>>n>>p;
	for(int i=1;i<=n;i++)
	cin>>a[i];
	cin>>m;
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		int o;
		cin>>o;
		if(o==1)
		{
			int x,y,k;
			cin>>x>>y>>k;
			updata2(1,x,y,k);
			continue;
		}
		if(o==2)
		{
			int x,y,k;
			cin>>x>>y>>k;
			updata(1,x,y,k);
			continue;
		}
		if(o==3)
		{
			int x,y;
			cin>>x>>y;
			cout<<query(1,x,y)<<'\n';
		}
	}
	return 0;
}

P4513 小白逛公园

思路

在每个节点处维护：

区间最大字段和，区间最大前缀和和区间最大后缀和

合并的时候分类讨论就好了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int maxn=500005;
int n,m;
int a[maxn];
struct tree{
	int l,r;
	int sum,lmax,rmax,maxx;
}t[maxn*4];
void pushup(int k)
{
	t[k].sum=t[k<<1].sum+t[k<<1|1].sum;
	t[k].lmax=max(t[k<<1].sum+t[k<<1|1].lmax,t[k<<1].lmax);
	t[k].rmax=max(t[k<<1|1].sum+t[k<<1].rmax,t[k<<1|1].rmax);
	t[k].maxx=max(max(t[k<<1].maxx,t[k<<1|1].maxx),t[k<<1].rmax+t[k<<1|1].lmax);
}
void build(int k,int l,int r)
{
	t[k].l=l,t[k].r=r;
	if(l==r)
	{
		t[k].sum=t[k].lmax=t[k].rmax=t[k].maxx=a[l];
		return ;
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	pushup(k);
}
void update(int k,int p,int v)
{
	if(t[k].l==t[k].r)
	{
		t[k].sum=t[k].lmax=t[k].rmax=t[k].maxx=v;
		return ;
	}
	int mid=(t[k].l+t[k].r)>>1;
	if(mid>=p)
	update(k<<1,p,v);
	else
	update(k<<1|1,p,v);
	pushup(k);
}
tree query(int k,int l,int r)
{
	if(l<=t[k].l&&t[k].r<=r)
	return t[k];
	int mid=(t[k].l+t[k].r)>>1;
	if(r<=mid)
	return query(k<<1,l,r);
	else if(l>mid)
	return query(k<<1|1,l,r);
	else
	{
		tree x=query(k<<1,l,r);
		tree y=query(k<<1|1,l,r);
		tree merge;
		merge.sum=x.sum+y.sum;
		merge.lmax=max(x.sum+y.lmax,x.lmax);
		merge.rmax=max(y.sum+x.rmax,y.rmax);
		merge.maxx=max(max(x.maxx,y.maxx),x.rmax+y.lmax);
		return merge;
	}
}
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	cin>>a[i];
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		int op;
		cin>>op;
		if(op==1)
		{
			int a,b;
			cin>>a>>b;
			if(a>b) swap(a,b);
			tree ans=query(1,a,b);
			cout<<ans.maxx<<'\n';
		}
		else
		{
			int p,s;
			cin>>p>>s;
			update(1,p,s); 
		}
	}
	return 0;
}

P2894 Hotel

思路

线段树

类似上一道题目

在每个节点处维护：

区间内最长全0的长度，最长全0前缀和最长全0后缀

查询时，在线段树上二分找到最靠前的答案

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int maxn=500005;
int n,m;
struct tree{
	int sum;
	int len;
	int lmax,rmax;
	int lazy;
}t[maxn*4];
void pushup(int k)
{
	if(t[k<<1].sum==t[k<<1].len)
	t[k].lmax=t[k<<1].len+t[k<<1|1].lmax;
	else 
	t[k].lmax=t[k<<1].lmax;
	
	if(t[k<<1|1].sum==t[k<<1|1].len)
	t[k].rmax=t[k<<1|1].len+t[k<<1].rmax; 
	else 
	t[k].rmax=t[k<<1|1].rmax;
	
	t[k].sum=max(max(t[k<<1].sum,t[k<<1|1].sum),t[k<<1].rmax+t[k<<1|1].lmax);
} 
void pushdown(int k)
{
	if(t[k].lazy==0)
	return;
	if(t[k].lazy==1)
	{
	    t[k<<1].lazy=t[k<<1|1].lazy=1;
		t[k<<1].sum=t[k<<1].lmax=t[k<<1].rmax=0;
		t[k<<1|1].sum=t[k<<1|1].lmax=t[k<<1|1].rmax=0;
	}
	if(t[k].lazy==2)
	{
		t[k<<1].lazy=t[k<<1|1].lazy=2;
		t[k<<1].sum=t[k<<1].lmax=t[k<<1].rmax=t[k<<1].len;
		t[k<<1|1].sum=t[k<<1|1].lmax=t[k<<1|1].rmax=t[k<<1|1].len;
	}
	t[k].lazy=0;
}
void build(int k,int l,int r)
{
	t[k].lazy=0;
	t[k].sum=t[k].len=t[k].lmax=t[k].rmax=r-l+1;
	if(l==r)
	return;
	int mid=(l+r)/2;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r); 
}
void update(int k,int l,int r,int tag,int L,int R)
{
	pushdown(k);
	if(L<=l&&r<=R)
	{
    	if(tag==1)t[k].sum=t[k].lmax=t[k].rmax=0;
		else t[k].sum=t[k].lmax=t[k].rmax=t[k].len; 
		t[k].lazy=tag;
		return;
	}
	int mid=(l+r)/2;
	if(L<=mid)
	update(k<<1,l,mid,tag,L,R);
	if(R>mid)
	update(k<<1|1,mid+1,r,tag,L,R);
	pushup(k);
}
int query(int k,int l,int r,int length)
{
	pushdown(k);
	if(l==r)return l;
	int mid=(l+r)/2;
	if(t[k<<1].sum>=length)
	return query(k<<1,l,mid,length);
	if(t[k<<1].rmax+t[k<<1|1].lmax>=length)
	return mid-t[k<<1].rmax+1;
	else 
	return query(k<<1|1,mid+1,r,length);
}
int main()
{
	cin>>n>>m;
	build(1,1,n);
	for(int i=1;i<=m;i++) 
	{
		int op,x,y;
		cin>>op;
		if(op==1)
		{
			cin>>x;
			if(t[1].sum>=x)
			{
				int l=query(1,1,n,x);
				cout<<l<<'\n';
				update(1,1,n,1,l,l+x-1);
			}
			else
			cout<<0<<'\n';
		}
		else
		{
			cin>>x>>y;
			update(1,1,n,2,x,x+y-1);
		}
	}
	return 0;
}

P5490 扫描线

思路

一个扫描线的模板

离散化坐标，并按照x从小到大的顺序扫描

每一步加入或者删除一个矩形（一根线段），线段树维护被覆盖部分

维护被覆盖的面基，节点记录：

实际区间长度，被覆盖部分长度，最小值，最小值部分长度

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;
const int maxn=1e6+5;
int n;
long long x1,y1,x2,y2;
long long x[maxn*2];
struct scanline{
	long long l,r,h;
	int mark;
	bool operator < (const scanline &rhs) const
	{
		return h<rhs.h;
	}
}line[maxn*2];
struct tree{
	int l,r;
	int sum;
	long long len;
}t[maxn*4];
void pushup(int k)
{
	if(t[k].sum)
	t[k].len=x[t[k].r+1]-x[t[k].l];
	else
	t[k].len=t[k<<1].len+t[k<<1|1].len;
}
void build(int k,int l,int r)
{
	t[k].l=l,t[k].r=r;
	t[k].len=0;
	t[k].sum=0;
	if(l==r)
	return ;
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
}
void edit_tree(int k,long long l,long long r,int c)
{
	if(x[t[k].r+1]<=l||r<=x[t[k].l])
	return ;
	if(l<=x[t[k].l]&&x[t[k].r+1]<=r)
	{
		t[k].sum+=c;
		pushup(k);
		return ;
	}
	edit_tree(k<<1,l,r,c);
	edit_tree(k<<1|1,l,r,c);
	pushup(k);
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>x1>>y1>>x2>>y2;
		x[2*i-1]=x1,x[2*i]=x2;
		line[2*i-1]=(scanline){x1,x2,y1,1};
		line[2*i]=(scanline){x1,x2,y2,-1};
	}
	n<<=1;
	sort(line+1,line+1+n);
	sort(x+1,x+1+n);
	//离散化 
	int tot=unique(x+1,x+1+n)-x-1;
	build(1,1,tot-1);
	long long ans=0;
	for(int i=1;i<n;i++)
	{
		edit_tree(1,line[i].l,line[i].r,line[i].mark);
		
		ans+=t[1].len*(line[i+1].h-line[i].h);
	}
	cout<<ans<<endl;
	return 0;
}

线段树的可持久化

可持久化：支持保存和访问数据结构历史版本

可持久化线段树

在单次修改之后，产生变化的节点只有\(O(log \space n)\)个

只需要为这些节点开辟新的空间

不能用堆式编号，需要记录子树节点编号，并动态开点，区间操作需要标记永久化，单次操作的时间和空间复杂度为\(O(log \space n)\)

const int maxn=100005;
struct node{
    int l,r;
    int sum,ls,rs;
}a[20*maxn];
int cnt,root[maxn];//root代表每次操作之后的根节点
void modify(int &x,int L,int R,int p,int v)//把p位置修改成v
{
    if(!x)
        x=++cnt;//如果x还没有开，那就新开一个点
    if(L==R)
    {
        a[x].sum=v;
        return ;
    }
    int mid=(L+R)>>1;
    if(p<=mid)
        modify(a[x].ls,L,mid,p,v);
    else
        modify(a[x].rs,mid+1,R,p,v);
    a[x].sum=a[a[x].ls].sum+a[a[x].rs].sum;//合并信息
}
int query(int x,int L,int R,int l,int r)
{
    if(x==0)
         return 0;
    if(l==L&&r==R)
        return a[x].sum;
    int mid=(L+R)>>1;
    if(r<=mid)
        return query(a[x].ls,L,mid,l,r);
    else if(l>mid)
        return query(a[x].rs,mid+1,R,l,r);
    else
    {
        int u=query(a[x].ls,L,mid,l,mid);
        int v=query(a[x].rs,mid+1,R,mid+1,r);
        return u+v;
    }
}
int main() 
{
    for(int i=1; i<=Q; i++) 
    {
        root[i] = root[i-1];
        modify(root[i], 1, n, p, v);
    }
    return 0;
}

可持久化并查集

用持久化也可以实现可持久化并查集

P3834 可持久化线段树（模板）

思路

考虑区间是\([1,n]\)的情况：

1.离散化之后建立值域线段树，区间\([L,R]\)保存落在\([L,R]\)内的数的个数

2.在线段树上二分找到第k大的值

3.如果左子树的总和\(\le k\)，则向左子树走，否则向右子树走

主席树

区间\([L,R]\)的值域线段树，可以用\([1,R],[1,L-1]\)的相减得到

暴力：开n棵线段树，时间复杂度为\(O(n^2)\)

1.将第i棵线段树在第i-1棵线段树的基础上修改了一个值

2.将线段树可持久化，一共n个版本,查询时同时访问两个历史版本，并把他们相减

int query_kth(int x,int L,int R,int k)
{
    if(L==R)
        return L;
    int mid=(L+R)>>1;
    int =a[a[x].ls].sum-a[a[y].ls].sum;
    if(s>=k)
        return query(a[x].ls,L,mid,k);
    else
        return query(a[x].rc,mid+1,R,k-s);
}

//其他的

const int N = 100005;
struct Node{
    int lc, rc, sum;
}a[20 * N];
int cnt, root[N];
// a[p] = v;
void modify(int& x, int L, int R, int p, int v) {
    a[++cnt] = a[x];
    x = cnt;
    if(L == R) {
        a[x].sum = v;
        return;
    }
    int mid = (L + R) >> 1;
    if(p <= mid) modify(a[x].lc, L, mid, p, v);
    else modify(a[x].rc, mid+1, R, p, v);
    a[x].sum = a[a[x].lc].sum + a[a[x].rc].sum;     // a[0].sum = 0;
}
int query(int x, int L, int R, int l, int r) {
    if(x == 0) return 0;
    if(l == L && r == R) return a[x].sum;
    int mid = (L + R) >> 1;
    if(r <= mid) return query(a[x].lc, L, mid, l, r);
    else if(l > mid) return query(a[x].rc, mid + 1, R, l, r);
    else{
        int u = query(a[x].lc, L, mid, l, mid);
        int v = query(a[x].rc, mid + 1, R, mid + 1, r);
        return u + v;
    }
}
int main() {
    for(int i=1; i<=Q; i++) {
        root[i] = root[i-1];
        modify(root[i], 1, n, p, v);
        // root[i] = ++cnt
    }
    // query(root[i], 1, n, l, r);
    return 0;
}

P4216 情报传递

思路

得到一个路径的主席树

综合练习

P4145 花神游历各国

思路

注意到每个数最多开根6次后就会变成1

方法1：

在线段树上暴力开根，把全都是1的区间打上标记

方法2：

树状数组暴力单点修改，在修改的时候跳过所有的1，可以使用并查集来实现

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
using namespace std;
const int maxn=100005;
long long n,m;
long long a[maxn],b[maxn];
bool vis[maxn]={false};
long long fa[maxn];
long long get(long long x)
{
	return fa[x]=(x==fa[x]? x:get(fa[x]));
}
void init()
{
	for(int i=1;i<=maxn-5;i++)
	fa[i]=i;
}
inline long long read()
{
	long long x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}
long long lowbit(long long x)
{
	return x&(-x);
}
void add(long long x,long long y)
{
	for( ;x<=n;x+=lowbit(x))
	b[x]+=y; 
}
long long ask(long long x)
{
	long long res=0;
	for( ;x;x-=lowbit(x))
	res+=b[x];
	return res;
}
int main()
{
	init();
	n=read();
	for(register long long i=1;i<=n;i++)
	{
		a[i]=read();
		add(i,a[i]);
	}
	fa[n+1]=n+1;
	m=read();
	while(m--)
	{
		int k=read(),l=read(),r=read();
		if(l>r) swap(l,r);
		if(k==0)
		{
			long long t;
			for(int i=l;i<=r;add(i,(t=(int)sqrt(a[i]))-a[i]),a[i]=t,fa[i]=(a[i]<=1)?i+1:i,i=(get(i)==i)?i+1:fa[i]);
		}
		else
		{
			cout<<ask(r)-ask(l-1)<<'\n';
		}
	}
	return 0;
}

P1972 HH的项链

思路

离线询问，从左往右考虑每个下标\(i\)，并处理右端点\(i\)的询问

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int maxn=1000005;
int n,m;
int a[maxn],b[maxn];
int vis[maxn],ans[maxn];
struct qyj{
	int l,r;
	int id;
}q[maxn];
int lowbit(int x)
{
	return x&(-x);
}
void add(int x,int y)
{
	for( ;x<=n;x+=lowbit(x))
	b[x]+=y;
}
int ask(int x)
{
	int res=0;
	for( ;x; x-=lowbit(x))
	res+=b[x];
	return res;
}
bool cmp(qyj x,qyj y)
{
	return x.r<y.r; 
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	cin>>a[i];
	cin>>m;
	for(int i=1;i<=m;i++)
	{
		cin>>q[i].l>>q[i].r;
		q[i].id=i;
	}
	sort(q+1,q+1+m,cmp);
	int pow=1;
	for(int i=1;i<=m;i++)
	{
		for(int j=pow;j<=q[i].r;j++)
		{
			if(vis[a[j]])
			add(vis[a[j]],-1);
			add(j,1);
			vis[a[j]]=j;
		}
		pow=q[i].r+1;
		ans[q[i].id]=ask(q[i].r)-ask(q[i].l-1);
	}
	for(int i=1;i<=m;i++)
	cout<<ans[i]<<'\n';
	return 0;
}

P4587 神秘数

思路

如果没有区间查询：

从小到大考虑每一个数，设当前能表示出\([1,x]\)的数

如果下一个数\(a_i \ge x+2\)，则答案是\(x+1\)

否则，能表示的数的范围则扩充到\([1,x+a_i]\)

优化扩充的过程：设一个last，表示用\(\le last\)的数凑出的范围是\([1,x]\)

如果下一个数\(>x+1\),则答案就是\(x+1\)

否则，求出所有在\([last+1,x]\)之间的数的和\(sum\)

则\(x\)增加到\(x+sum\)，\(last\)增加到原来的\(x\)

扩充不超过\(O(log(\sum a_i))\)步（斐波那契）

然后主席树实现查询

总的时间复杂度为\(O(mlog \space n \space log(\sum a_i))\)

P1712 区间

思路

按照区间长度排序，双指针扫一遍

线段树区间加，维护区间最大值

时间复杂度\(O(nlogn)\)