A-B数对（题解）

A-B 数对

题目背景

出题是一件痛苦的事情！

相同的题目看多了也会有审美疲劳，于是我舍弃了大家所熟悉的 A+B Problem，改用 A-B 了哈哈！

题目描述

给出一串正整数数列以及一个正整数 $C$，要求计算出所有满足 $A-B=C$ 的数对的个数（不同位置的数字一样的数对算不同的数对）。

输入格式

输入共两行。

第一行，两个正整数 $N,C$。

第二行，$N$ 个正整数，作为要求处理的那串数。

输出格式

一行，表示该串正整数中包含的满足 $A-B=C$ 的数对的个数。

样例 #1

样例输入 #1

4 1
1 1 2 3

样例输出 #1

3

提示

对于 $75\%$ 的数据，$1\le N\le 2000$。

对于 $100\%$ 的数据，$1\le N\le 2\times 10^5$，$0\le a_i<2^{30}$，$1\le C<2^{30}$。

---

第一种方法：

• 分析
  如果决定枚举$A$，那么问题就变成了统计数列中$B+C$出现了多少次。把数列排序，那么$B+C$会对应这个数列的连续一段。只要能快速找到这个连续端的左端点和右端点。也就是$B+C$在有序数列中第一次出现和最后一次出现的位置，这道题目就可以迎刃而解。

数组	0	1	2	3	4	5	6	7
原输入	7	3	4	3	3	3	7	4
排序后	3	3	3	3	4	4	7	7

$N=8$时的情况

仔细一看，现在的问题已经归纳成了一道二分查找题。这里介绍一下 $STL$ 中的

lower_bound() 和 upper_bound()//需要用到include<algorithm>

用法如下：

lower_bound(begin,end,val)在值有序的数组连续地址[begin,end)中找到第一个位置并返回其地址使得val插
入在这个位置前面，整个数组仍然保持有序

upper_bound(begin,end,val)在值有序的数组连续地址[begin,end)中找到最后一个位置并返回其地址使得val
插入在这个位置前面，整个数组仍然保持有序

假如排序后的数组名为$a$。如果对“地址”不是很了解，也可以认为其返回值减去数组名$a$（其实等于$a[0]$）刚好等于所要找的元素的数组下标。例如：

lower_bound(a,a+n,3)-a=0,lower_bound(a,a+n,7)-a=6,
upper_bound(a,a+n,3)-a=4,upper_bound(a,a+n,7)-a=8

既然lower_bound能找到某数第一次出现的位置，upper_bound能找到某数最后一次出现的位置（的后面），那么这个数出现的次数就可以表示为upper_bound(···）-lower_bound（···），基于这个优雅的表达，给出如下代码：

#include<cstdio>
#include<algorithm>
#define maxn 200010
using namespace std;
typedef long long ll;
ll a[maxn];
int n,c;
int main(){
	ios::sync_with_stdi(false);
	cin.tie(0);
	for(int i=0;i<n;i++){
		cin>>a[i];
	}sort(a,a+n);
	ll tot=0;
	for(int i=0;i<n;i++){
		tot+=upper_bound(a,a+n,a[i]+c)-lower_bound(a,a+n,a[i]+c);
	}
	cout<<tot;
	return 0;
}

---

第二种方法

当然，这道题还有一种(排序后）$O(n)$的做法：同样是寻找lower_bound和upper_bound的位置，可以发现随着被查询的$a[i]+c$的增大，lower_bound和upper_bound的位置也在变后，那么可以把这两个位置维护出来，即随着$a[i]+c$的增大而向后移动。因为这两个指针的移动次数不超过$n$，所以这个算法是$O(n)$的，代码如下：

#include<cstdio>
#include<algorithm>
#define maxn 200010
using namespace std;
typedef long long ll;
ll a[maxn];
int n,c;
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	
	for(int i=0;i<n;i++){
		cin>>a[i];
	}sort(a,a+n);
	ll tot=0;
	for(int i=0,l=0,r=0;i<n;i++){
		while(l<n&&a[l]<a[i]+c)l++;//l相当于lower_bound，第一个a[l]>=a[i] +c的位置上
		while(r<n&&a[r]<=a[i]+c)r++;//r相当于upper_bound，第一个a[r]>a[i] +c的位置上
		tot+=r-l;
	}
	cout<<tot;
	return 0;
} 

---

第三种方法

举个例子，假设$C=3,$数列是$2,5,3,7,5,2,4,8$。将数列排序得到$2,2,3,4,5,5$。对于序列中的一个数$s[i]$，想要快速找到$s[i]-C$。如果$s[i]-C$ 。如果$s[i]-C$这个数字存在的话，一定在排序后的数列中是连续。维护两个指针，左指针$l$和右指针$r$使得$s[l]$是首个大于等于$s[i]-C$的数，$s[r]$是首个大于$s[i]-C$的数。这样，从$s[l]$到$s[r-1]$都是等于$s[i]-C$的数字，即等于$s[i]-C$的数字个数有$r-1$个，累加进答案中。$s[i]-C$是越来越大，所以$l$和$r$都会越来越往右

$i$	0	1	2	3	4	5	6	7
排序后的$s[i]$	2	2	3	4	5	5	7	8	$l=r=0$
$s[0]$	2	2	3	4	5	5	7	8	$l=r=0$
$s[1]$	2	2	3	4	5	5	7	8	$l=r=0$
$s[2]$	2	2	3	4	5	5	7	8	$l=r=0$
$s[3]$	2	2	3	4	5	5	7	8	$l=0;r=2;$答案增加$r-l=2$
$s[4]$	2	2	3	4	5	5	7	8	$l=0;r=2;$答案增加$r-l=2$
$s[5]$	2	2	3	4	5	5	7	8	$l=0;r=2;$答案增加$r-l=2$
$s[6]$	2	2	3	4	5	5	7	8	$l=3;r=4;$答案增加$r-l=1$
$s[7]$	2	2	3	4	5	5	7	8	$l=4;r=6;$答案增加$r-l=2$

#include<bits/stdc++.h>
using namespace std;
#define maxn 200010
#define ll long long
int s[maxn];
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n,c;
	cin>>n>>c;
	for(int i=0;i<n;i++)cin>>s[i];
	sort(s,s+n);
	int l=0,r=0;
	ll sum=0;
	for(int i=0;i<n;i++){
		while(s[l]<s[i]-c&&l<n)l++;
		while(s[r]<=s[i]-c&&r<n)r++;
		if(s[i]-s[l]==c){
			sum+=r-l;
		}
	}
	cout<<sum;
	return 0;
}