【数据结构2-2】线段树与树状数组 题解

于 2022-09-20 21:36:38 发布
阅读量436 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c++ 算法
;
本文链接：https://blog.csdn.net/m0_60630928/article/details/126961339
版权

头一次老老实实写完一个官方题单，发篇题解纪念一下——

在这里插入图片描述

文章目录

P3372 【模板】线段树 1

令人惆怅，第一个模板题就有延迟标记。

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

int n,m,a[100010];

struct segment_tree
{
	int l,r;
	long long sum,add;
}tree[100010*4];

void build(int p,int l,int r)
{
	tree[p].l=l,tree[p].r=r;
	//cout<<"p:"<<p<<" l:"<<l<<" r:"<<r<<endl;
	if(l==r)
	{
		tree[p].sum=a[l];
		//cout<<"pos:"<<p<<" val:"<<a[l]<<endl;
		return;
	}
	int mid=(l+r)/2;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	tree[p].sum=tree[p*2].sum+tree[p*2+1].sum;
}

void spread(int p)
{
	if(tree[p].add!=0)
	{
		tree[p*2].sum+=(tree[p*2].r-tree[p*2].l+1)*tree[p].add;
		tree[p*2+1].sum+=(tree[p*2+1].r-tree[p*2+1].l+1)*tree[p].add;
		tree[p*2].add+=tree[p].add;
		tree[p*2+1].add+=tree[p].add;
		tree[p].add=0;
	}
}

void change(int p,int l,int r,int x)
{
	if(l<=tree[p].l&&r>=tree[p].r)
	{
		tree[p].sum+=(long long)x*(tree[p].r-tree[p].l+1);
		tree[p].add+=x;
		//cout<<"l:"<<tree[p].l<<" r:"<<tree[p].r<<" x:"<<x<<endl;
		return;
	}
	spread(p);
	int mid=(tree[p].l+tree[p].r)/2;
	if(l<=mid) change(p*2,l,r,x);
	if(r>mid) change(p*2+1,l,r,x);
	tree[p].sum=tree[p*2].sum+tree[p*2+1].sum;
}

long long ask(int p,int l,int r)
{
    if(l<=tree[p].l && r>=tree[p].r) 
		return tree[p].sum;//如果被覆盖，就返回维护的值
    spread(p);//下传懒标记，并查询左右儿子
    int mid=(tree[p].l+tree[p].r)>>1;
    long long ans=0;
    if(l<=mid) ans+=ask(p*2,l,r);
    if(r>mid) ans+=ask(p*2+1,l,r);//累加答案，返回左右儿子的和
    return ans;
}

int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	build(1,1,n);
	while(m--)
	{
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==1)
		{
			int x;
			scanf("%d",&x);
			change(1,l,r,x);
		}
		else if(op==2)
			printf("%lld\n",ask(1,l,r));
	}
	return 0;
}

P3373 【模板】线段树 2

令人叹惋，第二个模板题就这么难调。

区间乘法：将整个区间上的数乘上一个数时同时要把它储存的add和mud都乘上该数。每次延迟标记下放遵循“先乘后加”：先把区间上的数乘上储存的mu再作区间加法。

#include<bits/stdc++.h>
#define ll long long 
using namespace std;
int n,m,a[1000005],mod;

struct segment_tree
{
	ll sum,l,r,mu,add;
}t[1000005];

ll read()
{
	ll x=0;char ch=getchar();
	while(ch<'0'||ch>'9')ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	return x;
}
void build(ll p,ll l,ll r)
{
	t[p].l=l,t[p].r=r,t[p].mu=1;//乘法运算的幺元是1 
	if(l==r)
	{
		t[p].sum=a[l]%mod;
		return;
	}
	ll mid=(l+r)>>1;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}

void spread(ll p)//重点关注 ！！！ 
{ 
	t[p*2].sum=(t[p*2].sum*t[p].mu+(t[p*2].r-t[p*2].l+1)*t[p].add%mod)%mod;
	t[p*2+1].sum=(t[p*2+1].sum*t[p].mu+(t[p*2+1].r-t[p*2+1].l+1)*t[p].add%mod)%mod;
	t[p*2].mu=(t[p*2].mu*t[p].mu)%mod;
	t[p*2+1].mu=(t[p*2+1].mu*t[p].mu)%mod;
	t[p*2].add=(t[p*2].add*t[p].mu+t[p].add)%mod;
	t[p*2+1].add=(t[p*2+1].add*t[p].mu+t[p].add)%mod;
	t[p].add=0;
	t[p].mu=1;
}

void pluss(ll p,ll l,ll r,ll x)
{
	if(l<=t[p].l&&t[p].r<=r)
	{
		t[p].sum=(t[p].sum+(t[p].r-t[p].l+1)*x%mod)%mod;
		t[p].add+=x;
		return;
	}
	spread(p);
	ll mid=(t[p].l+t[p].r)>>1;
	if(l<=mid) pluss(p*2,l,r,x);//一直都是（l,r)，算出mid仅用于比较 
	if(mid<r) pluss(p*2+1,l,r,x);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}

void mu(ll p,ll l,ll r,ll x)
{
	if(l<=t[p].l&&t[p].r<=r)
	{
		t[p].add=(t[p].add*x)%mod;
		t[p].mu=(t[p].mu*x)%mod;
		t[p].sum=(t[p].sum*x)%mod;
		return;
	}
	spread(p);
	ll mid=(t[p].l+t[p].r)>>1;
	if(l<=mid) mu(p*2,l,r,x);
	if(mid<r) mu(p*2+1,l,r,x);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}

ll ask(ll p,ll l,ll r)
{
	if(l<=t[p].l&&t[p].r<=r)
		return t[p].sum;
	spread(p);//每次询问到这里也要下放标记 
	ll mid=(t[p].l+t[p].r)>>1;
	ll val=0;
	if(l<=mid) val=(val+ask(p*2,l,r))%mod;
	if(mid<r )val=(val+ask(p*2+1,l,r))%mod;
	return val;
}
int main()
{
	cin>>n>>m>>mod;
	for(int i=1;i<=n;i++)
		a[i]=read();
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		int op=read();
		if(op==1)
		{
			ll cn=read(),cm=read(),cw=read();
			mu(1,cn,cm,cw);
		}else if(op==2)
		{
			ll cn=read(),cm=read(),cw=read();
			pluss(1,cn,cm,cw);
		}
		else 
		{
			ll cn=read(),cm=read();
			cout<<ask(1,cn,cm)<<endl;
		}
    }
}

P4588 [TJOI2018]数学计算

难在看出是用线段树（没区间没修改没线段……）

题目有两个操作，一个是乘一个值，另一个是除之前乘的某个值。转化一下，操作的目的为：改变一个值，查找之前的值。

可以将数据按时间排序，在时间轴上建线段树，维护区间乘。这样的话根节点就是到现在为止的所有数的乘积。
操作1：在对应时间点上乘上该数；
操作2：找到对应的时间点将该点值修改为1，然后pushup。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
typedef long long llg;
struct tree
{
	int l,r;
	llg val;
}tr[N*4];

int T,Q,M;

void build(int p,int l,int r)
{
	if(l==r) tr[p]={l,r,1};
	else
	{
		int mid=(l+r)>>1;
		build(p<<1,l,mid);
		build(p<<1|1,mid+1,r);
		tr[p]={l,r,1};
	}
}

void mul(int p,int l,int r,int pos,llg t)
{
	if(tr[p].l==tr[p].r)
	{
		tr[p].val*=t;
		tr[p].val%=M;
		return;
	}
	int mid=(tr[p].l+tr[p].r)>>1;
	if(pos<=mid) mul(p<<1,l,mid,pos,t);
	else mul(p<<1|1,mid+1,r,pos,t);
	tr[p].val=tr[p<<1].val*tr[p<<1|1].val%M;
}

void divide(int p,int l,int r,int x)
{
	if(tr[p].l==tr[p].r)
	{
		tr[p].val=1;
		return;
	}
	int mid=(tr[p].l+tr[p].r)>>1;
	if(x<=mid) divide(p<<1,l,mid,x);
	else divide(p<<1|1,mid+1,r,x);
	tr[p].val=tr[p<<1].val*tr[p<<1|1].val%M;
}

int main()
{
	cin>>T;
	while(T--)
	{
		memset(tr,0,sizeof(tr));
		cin>>Q>>M;
		build(1,1,Q);
		for(int i=1;i<=Q;i++)
		{
			int op;
			llg t,ans;
			scanf("%d%ld",&op,&t);
			if(op==1)
			{
				mul(1,1,Q,i,t);
				printf("%ld\n",tr[1].val);
			}
			else
			{
				divide(1,1,Q,t);
				printf("%ld\n",tr[1].val);
			}
		}
	}
	return 0;
}

P1502 窗口的星星

典中典扫描线。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 20010;
struct node{
    ll x,y1,y2;
    ll dat;
}a[N*2];
struct p{
    ll l,r;
    ll dat,add;
}t[N*4];
ll mp[N];
bool cmp(node a,node b)  //将x坐标从小到大排序
{
    if(a.x==b.x) return a.dat<b.dat;
    return a.x<b.x;
}
void build(int p,ll l,ll r)
{
    t[p].l=l,t[p].r=r;
    t[p].add=0, t[p].dat=0;
    if(l==r) return;
    int mid=(l+r)/2;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
}
void spread(int p)  //表示p节点已经被修改，但子节点还没有被修改
{
    //修改子节点，并给子节点打延迟标记
    t[p*2].dat+=t[p].add;
    t[p*2+1].dat+=t[p].add;
    t[p*2].add+=t[p].add;
    t[p*2+1].add+=t[p].add;
    t[p].add=0;  //清除p的标记
}
//线段树维护的内容是在区间1 ~ m内,区域(x, y) ~ (x + w, y + h)亮度的最大值
void change(int p, ll l, ll r, ll x)
{
    if(l<= t[p].l&& r>= t[p].r)
    {
        t[p].add+=x;
        t[p].dat+=x;
        return;
    }
    if(t[p].add) spread(p);//延迟标记
    int mid =(t[p].l+t[p].r)/2;
    if(l<=mid) change(p*2,l,r,x);
    if(r>mid) change(p*2+1,l,r,x);
    t[p].dat=max(t[p*2].dat,t[p*2+1].dat); //更新节点
}
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		ll n,w,h,x,y,c;
	    scanf("%ld%ld%ld",&n,&w,&h);
	        ll num=0;
	        for(int i=1;i<=n; i++)
	        {
	            scanf("%ld%ld%ld",&x,&y,&c);
	            //矩形边界上的星星不算，所以将矩形的上边界减1
	            a[++num]={x,y,y+h-1,c};    
	            mp[num]=y;
	            a[++num]={x+w,y,y+h-1,-c};
	            mp[num]=y+h-1;
	        }
	        sort(mp+1,mp+1+num);
	        int m=unique(mp+1,mp+1+num)-mp-1; //离散化 + 去重
	        for(int i=1;i<=num;i++)
	        {  //预处理出所有坐标离散化之后的结果
	            a[i].y1=lower_bound(mp+1,mp+1+m,a[i].y1)-mp;
	            a[i].y2=lower_bound(mp+1,mp+1+m,a[i].y2)-mp;
	        }
	        sort(a+1,a+1+num,cmp);
	        build(1,1,m);  //建树
	        ll ans=0;
	        for(int i=1;i<=num;i++)
	        {
	            change(1,a[i].y1,a[i].y2,a[i].dat);  
	            ans=max(ans,t[1].dat);
	        }
	        cout<<ans<<endl;
	}
    return 0;
}

P2471 [SCOI2007] 降雨量

小细节最多的一道题，调得我失去智商。
不离散化80pts（两个点RE）。

  1. x>=y无解，出false
  2. y和x均未知，maybe
  3. 包括y和x的整个区间都已知，按题意判断true或false
  4. y和x均已知但中间有未知的，按题意判断maybe或false
  5. 有一个未知，判断另一个与区间的大小关系maybe或false
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
map<int,int>mp;
struct tree
{
	int l,r;
	int val;//降雨量
	bool known;//是否已知
}tr[N*4];
int m,n,cnt,a[N],first,now,mem[N]; 

void build(int p,int l,int r)
{
	if(l==r)
	{
		if(a[l]==-1)
		tr[p]={l,r,0,0};
		else tr[p]={l,r,a[l],1};
		return;
	}
	int mid=(l+r)>>1;
	build(p<<1,l,mid);
	build(p<<1|1,mid+1,r);
	tr[p].l=l,tr[p].r=r;
	tr[p].val=max(tr[p<<1].val,tr[p<<1|1].val);
	tr[p].known=(tr[p<<1].known&&tr[p<<1|1].known)?1:0;
}

int query(int p,int l,int r)
{
	if(l<=tr[p].l&&tr[p].r<=r)
	{
		//cout<<"tr[p].l:"<<tr[p].l<<" tr[p].r:"<<tr[p].r<<" tr[p].val:"<<tr[p].val<<endl;
		return tr[p].val;
	}
	int mid=(tr[p].l+tr[p].r)>>1;
	int maxn=0;
	if(l<=mid) maxn=max(query(p<<1,l,r),maxn);
	if(r>mid) maxn=max(query(p<<1|1,l,r),maxn);
	return maxn;
}

bool ask(int p,int l,int r)
{
	if(l<=tr[p].l&&tr[p].r<=r)
		return tr[p].known;
	int mid=(tr[p].l+tr[p].r)>>1;
	bool flag=1;
	if(l<=mid) flag=ask(p<<1,l,r);
	if(r>mid) flag=ask(p<<1|1,l,r)?flag:0;
	return flag;
}
int main()
{
	cin>>n;
	cin>>first>>a[++cnt];
	a[0]=-1,mp[0]=0;//在最前面插入一个点（前面所有的未知年份压缩成一个）
	now=first,mem[1]=first,mp[first]=cnt;
	for(int i=2;i<=n;i++)
	{
		int year,rain;
		scanf("%d%d",&year,&rain);
		if(year-1!=now)//中间不连续
		{
			a[++cnt]=-1,now++;
			mem[cnt]=now,mp[now]=cnt;//插入一个未知点（如果有很多未知的年份也压缩成一个）
		}
		a[++cnt]=rain,now=year,mem[cnt]=now,mp[now]=cnt;
	}
	a[++cnt]=-1,now++;
	mem[cnt]=now,mp[now]=cnt;//在最后面插入一个点（后面所有的未知年份压缩成一个）
	/*for(int i=1;i<=cnt;i++)
		cout<<a[i]<<' ';
	cout<<endl;
	for(int i=1;i<=cnt;i++)
		cout<<mem[i]<<' ';
	cout<<endl;*/
	build(1,1,cnt);
	cin>>m;
	while(m--)
	{
		int x,y,ok=1;
		scanf("%d%d",&x,&y);
		if(y<=x)
		{
			cout<<"false"<<endl;
			continue;
		}
		int xx=upper_bound(mem+1,mem+cnt+1,x)-mem-1;
		int yy=upper_bound(mem+1,mem+cnt+1,y)-mem-1;
		x=x<first?0:mp[mem[xx]];
		y=mp[mem[yy]];
		//cout<<"x:"<<x<<" a[x]:"<<a[x]<<" y:"<<y<<" a[y]:"<<a[y]<<endl;
		if(a[x]==-1&&a[y]==-1)//均未知
		{
			cout<<"maybe"<<endl;
			continue;
		}
		if(a[x]>0&&a[y]>0&&a[x]<a[y])//均已知
		{
			cout<<"false"<<endl;
			continue;
		}
		if(y-x<1)//特判的情况
		{
			if(a[x]==-1||a[y]==-1)
				cout<<"maybe"<<endl;
			else if(a[x]<a[y])
				cout<<"false"<<endl;
			else cout<<"true"<<endl;
			continue;
		}
		int maxi=query(1,x+1,y-1);//找到中间点的最大降水量
		//cout<<"maxi:"<<maxi<<endl;
		if(a[x]>0&&a[y]>0)
		{
			if(maxi>=a[y])
			{
				cout<<"false"<<endl;
				continue;
			}
			else
			{
				bool ok=ask(1,x+1,y-1);//看看中间是否有未知的
				if(ok) cout<<"true"<<endl;
				else cout<<"maybe"<<endl;
			}
		}
		else//一个已知，一个未知
		{
			if(a[x]>0&&maxi>=a[x])
			{
				cout<<"false"<<endl;
				continue;
			}
			if(a[y]>0&&maxi>=a[y])
			{
				cout<<"false"<<endl;
				continue;
			}
			cout<<"maybe"<<endl;
		}
	}
    return 0;
}

P4198 楼房重建

转化成斜率单调递增序列问题。

//区间最大可修改上升
#include<bits/stdc++.h> 
using namespace std;
const int N=1e5+10;

int n,m;
struct tree
{
	double slope;
	int num;
}tr[N*4];
//slope维护区间内最大的斜率
//num维护区间内递增斜率序列的长度
 
int query(int p,int l,int r,double maxn)
{
	if(tr[p].slope<=maxn) return 0;//不符合条件 
	if(l==r) return tr[p].slope>maxn;//递归到叶结点，判断该点斜率是否大于maxn 
	int mid=(l+r)>>1;
	if(tr[p<<1].slope<=maxn)//左子树中的所有点都会被挡住 
		return query(p<<1|1,mid+1,r,maxn);//找右子树中未被挡住的点 
	else return query(p<<1,l,mid,maxn)+tr[p].num-tr[p<<1].num;
	//右子树中所有点都未被挡住，找左子树中未被挡住的点 
	
}

void modify(int p,int l,int r,int x,int y)
{
	if(l==r)
	{
		tr[p]={1.0*y/x,1};
		return;
	}
	int mid=(l+r)>>1;
	if(x<=mid) modify(p<<1,l,mid,x,y);
	else modify(p<<1|1,mid+1,r,x,y);
	tr[p].slope=max(tr[p<<1].slope,tr[p<<1|1].slope);
	tr[p].num=tr[p<<1].num+query(p<<1|1,mid+1,r,tr[p<<1].slope);
	//左子树递增斜率序列的长度+右子树中递增斜率序列的长度（右子树中算数的斜率应都大于 tr[p<<1].slope） 
}

int main()
{
	cin>>n>>m;
	while(m--)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		modify(1,1,n,x,y);
		printf("%d\n",tr[1].num);
	}
	return 0;
}

P2574 XOR的艺术

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

struct segment_tree
{
	int l,r,num,mark;
}t[N*4];

void build(int p,int l,int r)
{
	t[p].l=l,t[p].r=r;
	if(l==r)
	{
		t[p].num=a[l];
		//cout<<"p:"<<p<<' '<<a[l]<<endl;
		return;
	}
	int mid=(l+r)>>1;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	t[p].num=t[p*2].num+t[p*2+1].num;
}

void spread(int p)
{
	if(t[p].mark)
	{
		t[p*2].num=(t[p*2].r-t[p*2].l+1)-t[p*2].num;
		t[p*2+1].num=(t[p*2+1].r-t[p*2+1].l+1)-t[p*2+1].num;
		t[p*2].mark^=1;
		t[p*2+1].mark^=1;
		t[p].mark=0;
	}
}

void change(int p,int l,int r)
{
	if(l<=t[p].l&&t[p].r<=r)
	{
		t[p].num=(t[p].r-t[p].l+1)-t[p].num;
		t[p].mark^=1;
		return;
	}
	int mid=(t[p].l+t[p].r)>>1;
	spread(p);
	if(l<=mid) change(p*2,l,r);
	if(mid<r) change(p*2+1,l,r);
	t[p].num=t[p*2].num+t[p*2+1].num;
}

int ask(int p,int l,int r)
{
	if(t[p].l>=l&&t[p].r<=r) 
		return t[p].num;//如果完全包含，返回区间
	int mid=(t[p].l+t[p].r)/2;
	int ans=0;
	spread(p);//下传标记
	if(l<=mid) ans+=ask(p*2,l,r);//继续向下
	if(r>mid) ans+=ask(p*2+1,l,r);
	return ans;
}

int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		scanf("%1d",&a[i]);
	build(1,1,n);
	while(m--)
	{
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==1) cout<<ask(1,l,r)<<endl;
		if(op==0) change(1,l,r);
	}
    return 0;
}

P3374 【模板】树状数组 1

#include<bits/stdc++.h>
using namespace std;
long long c[1000010];
int lowbit(int x)
{
	return x&(-x);
}
void update(int j,int n,int x)
{
	for(int i=j;i<=n;i+=lowbit(i))
	{
		c[i]+=x;
	}
}
long long getsum(int add)
{
	long long ans=0;
	for(int i=add;i;i-=lowbit(i))
	{
		ans+=c[i];
	}
	return ans;
}
int main()
{
	int n,q,i;
	cin>>n>>q;
	for(i=1;i<=n;i++)
	{
		int a;
		scanf("%d",&a);
		update(i,n,a);
	}
	while(q--)
	{
		int op;
		cin>>op;
		if(op==1)
		{
			int j,x;
			cin>>j>>x;
			update(j,n,x);
		}
		if(op==2)
		{
			int l,r;
			cin>>l>>r;
			long long sum;
			sum=getsum(r)-getsum(l-1);
			//cout<<"L"<<getsum(l-1)<<endl;
			//cout<<"R"<<getsum(r)<<endl;
			cout<<sum<<endl;	
		}
	}
	return 0;
}

P3368 【模板】树状数组 2

#include<bits/stdc++.h>
using namespace std;
long long a[500005],dif[500005],c[500005];
int n,m;
int lowbit(int x)
{
	return x&(-x);
}
void update(int x,long long p)
{
	for(int i=x;i<=n;i+=lowbit(i))
		c[i]+=p;
}
long long get_sum(int x)
{
	long long sum=0;
	for(int i=x;i;i-=lowbit(i))
		sum+=c[i];
	return sum;
}

int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		scanf("%lld",&a[i]);
	while(m--)
	{
		int option;
		scanf("%d",&option);
		if(option==1)
		{
			int front,tail;
			long long z;
			scanf("%d%d%lld",&front,&tail,&z);
			update(front,z);
			update(tail+1,-z);
		}
		if(option==2)
		{
			int q;
			scanf("%d",&q);
			cout<<get_sum(q)+a[q]<<endl;
		}
	}
	return 0;
}

P1908 逆序对

树状数组也能写，这里就贴古早学习的归并排序了。

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

int temp[500005],a[500005],n;
long long ans;
inline int read()
{
	int 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;
}

void merge(int l,int r)
{
	if(l==r) return;
	int mid=(l+r)/2;
	merge(l,mid);
	merge(mid+1,r);
	int i=l,j=mid+1,p=l;
	while(i<=mid&&j<=r)
	{
		if(a[i]<=a[j])
			temp[p++]=a[i++];
		else
			ans+=(mid-i+1),
			temp[p++]=a[j++];
	}
	while(i<=mid)
		temp[p++]=a[i++];
	while(j<=r)
		temp[p++]=a[j++];
	for(int k=l;k<=r;k++)
		a[k]=temp[k];
}

int main()
{
	n=read();
	for(int i=1;i<=n;i++)
		a[i]=read();
	merge(1,n);
	cout<<ans;
	return 0;
}

P1966 [NOIP2013 提高组] 火柴排队

离散化+求逆序对数

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

const int N=1e5+10;
const int mod=1e8-3;
int a[N],b[N],d[N],e[N],pos[N],n;
long long c[N];
long long ans;
int lowbit(int x)
{
	return x&(-x);
}

long long ask(int p)
{
	long long ret=0;
	for(int i=p;i;i-=lowbit(i))
		ret+=c[i];
	return ret;
}

void add(int p)
{
	for(int i=p;i<=n;i+=lowbit(i))
		c[i]++;
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		scanf("%d",&d[i]),a[i]=d[i];
	for(int i=1;i<=n;i++)
		scanf("%d",&e[i]),b[i]=e[i];
	sort(d+1,d+n+1);
	sort(e+1,e+n+1);
	for(int i=1;i<=n;i++)
	{
		a[i]=lower_bound(d+1,d+n+1,a[i])-d;
		//cout<<"a[i]:"<<a[i]<<' ';
		pos[a[i]]=i;
		b[i]=lower_bound(e+1,e+n+1,b[i])-e;
		//cout<<"pos["<<a[i]<<"]="<<i<<endl;
		//cout<<"b[i]"<<b[i]<<' ';
	}
	for(int i=1;i<=n;i++)
		b[i]=pos[b[i]];
	
	for(int i=1;i<=n;i++)
	{
		ans+=ask(n)-ask(b[i]);
		//cout<<"ans:"<<ans<<' ';
		ans%=mod;
		add(b[i]);
	}
	/*cout<<endl;
	memset(c,0,sizeof(c));
	for(int i=n;i;i--)
	{
		ans+=ask(b[i]);
		cout<<"ans:"<<ans<<' ';
		ans%=mod;
		add(b[i]);
	}*/
	cout<<ans;
    return 0;
}

P5677 [GZOI2017]配对统计

一个数能与它形成好配对的一定是和它差值最小的数。顺着这个思路我们可以考虑将数列排序，排序后对于一个数字能与其匹配的只有它左边或右边的数，对于 1 和 n 的情况进行特判，如果两边差值相等就都是好配对。
现在问题就转化为给定一些配对找在 [ l , r ] [l,r] [l,r]这段区间中有几个好配对，对于这个问题，由于题目并未强制在线，我们可以考虑将询问离线保存，重新排序（按右端点大小）。

#include<bits/stdc++.h>
#define llg long long

using namespace std;
const int N=3e5+10;
int n,m,l,r,total,cnt;
int c[N],pre[N],mem[N];
long long ans;
inline int read()
{
	int 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;
}
int lowbit(int x)
{
	return x&(-x);
}

struct Node
{
	int val,pos;
}a[N];

struct pa
{
	int l,r;
}p[N*2];
bool cmp1(Node x,Node y)
{
	return x.val<y.val;
}

bool cmp2(pa x,pa y)
{
	return x.r<y.r;
}

struct section
{
	int l,r;
	int id;
}sec[N];

bool cmp(section x,section y)
{
    return x.r<y.r;
}

long long get(int pos)
{
	long long ret=0;
	for(int i=pos;i;i-=lowbit(i))
		ret+=c[i];
	return ret;
}

void add(int pos)
{
	for(int i=pos;i<=n;i+=lowbit(i))
		c[i]++;
}
void add_pair(Node x,Node y)
{
	p[++cnt].l=min(x.pos,y.pos);
	p[cnt].r=max(x.pos,y.pos);
}
int main()
{
	cin>>n>>m;
	if(n==1){puts("0");return 0;}
	
	for(int i=1;i<=n;i++)
	{
		a[i].val=read();
		a[i].pos=i;
	}
	sort(a+1,a+n+1,cmp1);
	
	add_pair(a[1],a[2]);
	add_pair(a[n-1],a[n]);
	for(int i=2;i<n;i++)
	{
		int t1=a[i].val-a[i-1].val;
		int t2=a[i+1].val-a[i].val;
		if(t1<t2) add_pair(a[i-1],a[i]);
		else if(t2==t1) add_pair(a[i-1],a[i]),add_pair(a[i],a[i+1]);
		else add_pair(a[i],a[i+1]);;
	}
	sort(p+1,p+cnt+1,cmp2);
	
	for(int i=1;i<=m;i++)
	{
		sec[i].l=read(),sec[i].r=read();
		sec[i].id=i;
	}
	sort(sec+1,sec+m+1,cmp);//按右端点从小到大排序 
	
	for(int i=1,j=1;i<=m ; i++)
	{	//i为当前询问，j为当前待入树状数组的好对 
		while(p[j].r<=sec[i].r&&j<=cnt)
		{
			add(p[j].l);		//如果当前好对的右端点在当前询问的右端点内，就加入树状数组 
			j++;
		}
		ans+=1ll*sec[i].id*(j-1-get(sec[i].l-1));	//计算答案 
	}
	cout<<ans;
    return 0;
}
春弦_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【树状数组详解】
来日浅谈的博客
10-04 517
【树状数组详解】什么是树状数组树状数组的基本操作单点更新区间查询树状数组与线段树的比较树状数组的整体代码（例：HDU - 1166 排兵布阵） 什么是树状数组 树状数组是一个查询和修改复杂度都为log(n)的数据结构。主要用于数组的单点修改&&区间求和. 另外一个拥有类似功能的是线段树. 具体区别和联系如下： 两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度...
树状数组（区间问题）
兜率工的博客
08-14 526
目录 一维树状数组 单点更新，区间查询 区间更新，单点查询 区间更新，区间查询 二维树状数组 单点更新，区间查询 区间更新，单点查询 区间更新，区间查询 区间最值 一维树状数组   单点更新，区间查询 #include &lt;iostream&gt; using namespace std; const int MAX_N=10010; int C[MAX_N]; ...
求区间种类数——树状数组
生活不易，多才多艺
05-24 1649
一提到求区间种类数….脑子里满是莫队啊啊啊怕不是没救了…….. 题意很简单，就是求区间内有多少个不同的数 那怎么做呢qaq 树状数组诶！ 把所有询问按右端点排序，然后每次加到这个点 树状数组按位置建哦 那么树状数组上每个点就记录第一个点到此点有多少个数，因为此时查询的右端点是一点定的，所有每个数都记他最后一次出现的位置，这样也可以保证不会重。 而且查询的时候，因为左端点不一定，所以答案...
POJ 3928-Ping pong（树状数组+加/乘法原理）
Some.
08-08 771
Ping pong Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 2982   Accepted: 1103 Description N(3<=N<=20000) ping pong players live along a west-east street(
树状数组（单点+区间的所有操作）
yu121380的博客
04-14 751
转载：https://blog.csdn.net/I_believe_CWJ/article/details/80374326 更简洁方便的数据结构--树状数组（基于线段树的实现） 1.单点更新+区间求和（基本线段树，简单，自行了解） 2.区间更新+单点求值（基于单点更新+区间求和） 例：HDU 1556-Color the ball 操作1：修改某段区间[l, r]的...
程序员面试指南-数据结构与算法题解
07-23
资源名称：程序员面试指南-数据结构与算法题解资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
java-leetcode面试题解哈希表第170题数据结构设计-题解.zip
最新发布
03-26
java java_leetcode面试题解哈希表第170题数据结构设计_题解
Leetcode题解数据结构与算法.zip
12-27
大数据算法在数据分析中发挥着重要的作用，它可以提高分析工作的效率和准确性，为决策提供有力支持。具体来说，大数据算法可以分类、聚类、预测和关联规则分析等，从而发现数据之间的规律和关联关系，挖掘出潜在的...
第2章 基本放大电路题解1-教程与笔记习题
05-19
第2章 基本放大电路题解1
数据结构和算法题解-1000多页.pdf
05-09
目前自己写了500多道算法题解，部分整理成PDF格式，目前有1000多页，大家可以免费下载学习
【模板】树状数组 区间修改，区间求和 （模板题：洛谷P3368树状数组2）
Dance Of Faith
05-26 562
题目描述 如题，已知一个数列，你需要进行下面两种操作： 1.将某区间每一个数数加上x 2.求出某一个数的和 输入输出格式 输入格式： 第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。 第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。 接下来M行每行包含2或4个整数，表示一个操作，具体如下： 操作1： 格式：1
【小结】树状数组的区间修改与区间查询
热门推荐
每天心塞一点点
02-26 1万+
第一次听到树状数组是zsl来讲课QAQ 然后当时他给我们绕了很久 = = 嗯没懂…………结果后来发现这东西实际上是个简单又好用的玩意QAQ [ 1 ]  树状数组的本职是单点修改+区间查询 维护前缀和 每次修改向上传数据 然后查询区间的时候也是从下往上加值 函数很好写…… 修改： void update(int i, int x) { while(i <= N){
树状数组的区间更新和区间查询
ii0789789789的博客
07-25 971
对于区间修改、区间查询这样的简单问题，打一大堆线段树确实是不划算，所以学习下区间查询+区间修改的树状数组   设原数组是a[n]，差分数组c[n]，c[i]=a[i]-a[i-1]， 那么明显地a[i]=sigma (c[i])，如果想要修改a[i]到a[j](比如+v)，只需令c[i]+=v,c[j+1]-=v   观察式子： a[1]+a[2]+...+a[n] = (c[1]) ...
树状数组的一些区间修改与区间询问的实现
weixin_30908707的博客
04-01 109
原文链接http://www.cnblogs.com/zhouzhendong/p/8685578.html 前置技能 　　基础树状数组。不会的话自己百度。 　　要求掌握树状数组的以下操作： 熟悉树状数组原理以及用途。 单点修改，区间查询。 区间加，单点查询。 问题模型 　　树状数组实现区间加和区间查询。 实现 　　记 　　$A_i$为数列上面的第$i$个元素...
树状数组进阶（区间更新+单点查询，区间更新+区间查询）
摆渡人的博客
07-31 6062
看完之前那篇树状数组入门（https://blog.csdn.net/qq_39562952/article/details/81296502）相信大家对树状数组有了一些了解，这次我们来看更加深一层次的树状数组应用； 问题引入:        在一个【1，1000000000】的区间上改变n次【x，y】（n个位置）的值，并且查询z位置上的元素值；        朴素的方法厉遍的时间复杂度还是...
降雨量程序设计
m0_52744886的博客
03-13 1143
c++基础题目：实验四 题目：编写一个程序，要求用户输入一年12个月每月的降雨总量，并采用一个float数组存储。程序显示：一年的总降雨量，平均每月的降雨量，降雨量最多的月份和最小的月份。 提示：用自定义函数实现 #include<iostream> using namespace std; float a[12], aver = 0, sum = 0, max1, min1; int monthmax, monthmin; //定义全局变量并初始化 void funtion(float a[
[SCOI2007]降雨量(st表)
lvmaooi的博客
03-29 460
题目描述 我们常常会说这样的话：“X年是自Y年以来降雨量最多的”。它的含义是X年的降雨量不超过Y年，且对于任意Y&lt;&lt;&lt;&lt;nnn，为已知的数据。以下nnn行每行两个整数yiyiy_i和ririr_i，为年份和降雨量，按照年份从小到大排列，即yi&lt;yi+1yi&lt;yi+1y_immm，为询问的次数。以下mmm行每行包含两个数Y和X，即询问“X年是自Y年以来降雨量最多...
[BZOJ 1067][SCOI2007]降雨量
weixin_30886233的博客
07-15 49
题目:http://www.lydsy.com/JudgeOnline/problem.php?id=1067 题解: 　　咳咳.这次因为遇到了一些比较有成就感的事情所以来发博。 　　听说这题要用线段树？？开玩笑。当然不。 　　首先我们想想，如果我们知道了X年份的降雨量的时候，向前找已知降雨量比X大或等于的第一个年份(我们设为Z1)，如果Y年份比Z1小则Y到X这个区间一定包含Z1,那么此命...
区间和（离散化）
Axiayouqiaomu的博客
01-19 426
文章目录前言一、离散化二、区间和代码如下： 前言 离散化是程序设计中一个常用的技巧，它可以有效的降低时间复杂度。其基本思想就是在众多可能的情况中，只考虑需要用的值。离散化可以改进一个低效的算法，甚至实现根本不可能实现的算法。要掌握这个思想，必须从大量的题目中理解此方法的特点。例如，在建造线段树空间不够的情况下，可以考虑离散化。 一、离散化 离散化，把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。 通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小。例如： 原数据：1
csp-s2提高组2021第二轮题解
09-25
使用动态规划算法可以解决，按照价格从小到大的顺序遍历书籍，设置一个二维数组dp[i][j]表示在前i本书中，花费j的预算能够买到的最多书籍数量。状态转移方程为：dp[i][j]=max(dp[i-1][j], dp[i-1][j-price[i]]+1)。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

春弦_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值