[SDOI2009] HH的项链 and [GZOI2017] 配对统计

题目

[SDOI2009] HH的项链
[GZOI2017] 配对统计

为什么要把这两道题放在一起讲了，因为他们都是离线查询并且有相通的思想去解决该问题

离线查询和在线查询的不同点就在于，你可以得到全部的答案后再回答。

基于此，你可以利用查询时得到的信息，优化你下次查询的时间

接下来在题目具体运用该思想

[SDOI2009] HH的项链

此题需要在上述的思想基础上，结合题意稍加应用，就能解决

我们首先尝试将询问区间按照r的值从小到大排序

注意题目询问的区间内贝壳的种类，所以如果区间内两个位置都是同一种类，我们可以忽略掉左边的，只保留右边的.

而我们按照区间r的值从小到大排序，每次处理一个区间时，我们都尽量保留最靠近右端的不同的贝壳.

这样就可以用树状数组方便处理，修改值，统计区间和，ans=sum(r)-sum(l-1);

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;
#define lowbit(x) x&-x;
int n,m;
const int maxn=1e6+10;
int t[maxn],a[maxn];
int pre[maxn];
int ans[maxn];
struct node{
	int l,r,p;
}ask[maxn]; 
int read(){
	int 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; 
}
bool cmp(node a,node b){
	return a.r<b.r;
}
void add(int x,int val){
	while(x<=n){
		t[x]+=val;
 		x+=lowbit(x);
	}
} 
int sum(int x){
	int res=0;
	while(x){
		res+=t[x];
		x-=lowbit(x);
	}return res;
}

int main(){
	n=read();
	for(int i=1;i<=n;++i) a[i]=read();
	m=read();
	for(int i=1;i<=m;++i) ask[i].l=read(),ask[i].r=read(),ask[i].p=i;
	sort(ask+1,ask+1+m,cmp);//按照右端点排序
	int nex=1;
	for(int i=1;i<=m;++i){
		for(int j=nex;j<=ask[i].r;++j){//保留最靠近右端点的不同种类的贝壳
			if(pre[a[j]]) add(pre[a[j]],-1);//删除靠左的同种类贝壳
			add(j,1);//添加
			pre[a[j]]=j;//记录这个种类贝壳的位置，下次遇到可以删除
		}
		nex=ask[i].r+1;//跳到区间外，防止反复统计
		ans[ask[i].p]=sum(ask[i].r)-sum(ask[i].l-1);//记录对应的但
	}
	for(int i=1;i<=m;++i) cout<<ans[i]<<endl;
	return 0;
}

[GZOI2017] 配对统计

此题和上题思想差不多，依然是按照数对右端点排序，只不过更加复杂

首先按照题意，我们需要处理出这样的数对。然后不妨将数对看成区间，只有这样一个区间是查询区间的子区间对答案贡献++

• 超时思路：

我们可以很轻而易举的统计（并且是预处理）出区间[0,r]内右端点的个数，于是乎，如果我们能统计出区间[0,l]内左端点的个数，那么我们便可以得到[l,r]中数对的个数

那么如果直接面对每一次回答，都遍历[0,l]，那么必然超时

• 正确思路：

所以我们用上题一样的手法处理，确定一个查询的右端点之后，依次加入小于该右端点区间的左端点.

最后我们查询时，只需要查询[0,l)区间内的左端点个数，而此时，我们遍历到第j-1个区间（数对），于是j-1-query(l-1)就是答案

那么对于

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

using ll=long long; 

typedef pair<int,int> pii; 
const int maxn=3e5+10;

int n,m;
int cnt=0; 
ll t[maxn];
pii p[maxn<<1];
struct node{
	ll val;
	int p;
}a[maxn];
struct Q{
	int l,r,p;
}e[maxn];
bool cmp(node x,node y){
	return x.val<y.val;
}
bool cmpp(pii x,pii y){
	if(x.second!=y.second)return x.second<y.second;
	return x.first<y.first;
}
bool cmppp(Q x,Q y){
	if(x.r!=y.r) return x.r<y.r;
	return x.l<y.l; 
}
int lowbit(int x){
	return x&(-x);
}
void add(int x){
	while(x<=n){
		t[x]++;
		x+=lowbit(x);
	}
}
ll query(ll x){
	ll cnt=0;
	while(x){
		cnt+=t[x];
		x-=lowbit(x);
	}
	return cnt;
}

void adp(node x,node y){
	int l=min(x.p,y.p),r=max(x.p,y.p);
	p[++cnt].first=l;p[cnt].second=r; 
}

int main(){
	ios::sync_with_stdio(0);
	cin>>n>>m;
	if(n==1) {
		cout<<"0"<<endl;
		return 0;
	}
	for(int i=1;i<=n;++i){
		cin>>a[i].val;
		a[i].p=i;
	}
	for(int i=1;i<=m;++i){
		cin>>e[i].l>>e[i].r;
		e[i].p=i;
	}
	sort(a+1,a+1+n,cmp);
	adp(a[1],a[2]),adp(a[n],a[n-1]);
	for(int i=2;i<n;++i){//按照题意处理出数对（区间
		ll ld=a[i].val-a[i-1].val;
		ll rd=a[i+1].val-a[i].val;
		if(ld<rd) adp(a[i],a[i-1]);
		else if(ld==rd) adp(a[i-1],a[i]),adp(a[i+1],a[i]);
		else adp(a[i],a[i+1]);
	}
	sort(p+1,p+1+cnt,cmpp);//按照右端点排序
	int j=1;ll ans=0;
	sort(e+1,e+1+m,cmppp);//询问按照右端点排序
	//j表示小于当前查询区间右端点的区间个数
    for(int i=1;i<=m;++i){
		while(p[j].second<=e[i].r && j<=cnt){
			add(p[j].first);
			++j;
		}
		ans+=(ll)e[i].p*(j-1-query(e[i].l-1));//题目要求的计算答案方式
	}
	cout<<ans<<endl;
	return 0;
}