D-卧底探案

D-卧底探案

题目描述：

Bob是我们的情报专家，现已成功潜入到犯罪团伙内部得到了一些简讯，了解到需要参加一个指定的由一些卧底参与的派对，并在派对中找出那些卧底，才能获得完整的犯罪团伙情报

简讯中显示，派对总共有N人参与，进场时每个人按进场顺序会拿到一个序号为 i （从1到N）的卡片，其中序号为 i 的卡片上的数值为 Ai .
我方已经进行了精密的组织与安排：如果两人卡片序号 i,j 之差|i-j|等于两人卡片上的数值之和 Ai+Aj ，那么这两人手中的信息就可以组成一条情报（每个人得到的信息可以使用多次）。

Bob暗中记下了所有人卡片的数值，请你计算Bob在派对中总共能获得多少条情报

P.S.: We cannot let you know the secret.

输入：

• 所有数据都是整数
• 2 ≤ N ≤ 2 * 105
• 1 ≤ Ai ≤ 109 (1 ≤ i ≤ N)

输入将按如下格式:

N
A1 A2 ...  AN 

输出：

输出一行，一个整数，表示Bob能找到多少对卧底来获得情报。

样例：

样例1：

Input
6
2 3 3 1 3 1
Output
3
Hint
A1 + A4 = 4-1=3, 所以Bob找1号和4号可以得到1份情报
A2 + A6 = 6-2=4, 找2号和6号可以得到第2份情报
A4 + A6 = 6-4=2, 找4号和6号可以构成第3份情报

样例2：

Input
6
5 2 4 2 8 8
Output
0
Hint
这场派对里没有自己人，获取0份情报.

样例3：

Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22

分类/来源：

malic-2021寒假热身赛02_D

题源

思路 /注意：

//和大多数人一样的直接思路：用一个二层循环实现，但这时时间复杂度为O(n2),oj上显示超时，故需要降低时间复杂度
//对于一般的OJ系统来说，一秒能承受的运算次数大概是10e7-10e8,故当n的规模为100000时O(n2)的算法无法承受。
	for(int i=0;i<n;i++){
		scanf("%d",a+i);
	}
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			if(a[i]+a[j]==j-i)
				count++;
		}

malic解读：

要求 有多少(i,j)使 j−i=Ai+Aj，即求 j−Aj=i+Ai，令Lk=k−Ak,Rk=k+Ak，就变成一个搜索问题：对于每个{L}中的元素Lk，查找在{R}中出现多少次。这样对R排序后用二分搜，时间复杂度O(NlogN)。

我：

数组和情报个数的类型需要为long long，否则有测试样例会通不过。

malic给的解法用到了stl的算法三个函数。我自己写了一下二分查找还是超时，最后有一个样例没通过。暂时没搞明白。

代码如下：

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll maxSize=200003;
ll a[maxSize],l[maxSize],r[maxSize];
int BinSearch(ll a[],ll n, ll key){
	int low=0,high=n-1;
	int mid;
	while(low<=high){
		mid=(low+high)/2;
		if(a[mid]==key)
			return mid;
		if(a[mid]>key)
			high=mid-1;
		else 
			low=mid+1;
	}
	return -1;
}

int main(){
	int n;
	int pos,la,ra;
	ll ret=0;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",a+i);
		l[i]=i+1+a[i];
		r[i]=(i+1)-a[i];
	}
	sort(r,r+n);
	for(int i=0;i<n;i++){
		if(BinSearch(r,n,l[i])!=-1)
		{
			pos=BinSearch(r,n,l[i]);
			la=pos;
			while(r[la]==l[i]){
				la--;
				if(la<0)break;
			}
			la++;
			ra=pos;
			while(r[ra]==l[i]){
				ra++;
				if(ra>n-1)break;
			}
			ra--;
			ret+=ra-la+1;
		}
	}
	printf("%lld\n",ret);
	return 0;
}

2020年2月18日补充：看了算法笔记二分查找部分才明白二分查找的变式很多，可以实现查找第一个大于或等于关键字x的位置，第一个大于关键字x的位置。题解代码的lower_bound()和upper_bound()函数就是通过上面两个所说函数实现的。以下代码经修改后可AC

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll maxSize=200003;
ll a[maxSize],l[maxSize],r[maxSize];
int BinSearch_l(ll a[],ll n, ll key){
	int low=0,high=n;
	int mid;
	while(low<high){
		mid=(low+high)/2;
		if(a[mid]>=key)
			high=mid;
		else 
			low=mid+1;
	}
	return low;
}

int BinSearch_h(ll a[],ll n, ll key){
	int low=0,high=n;
	int mid;
	while(low<high){
		mid=(low+high)/2;
		if(a[mid]>key)
			high=mid;
		else 
			low=mid+1;
	}
	return low;
}

int main(){
	int n;
	int pos,la,ra;
	ll ret=0;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",a+i);
		l[i]=i+1+a[i];
		r[i]=(i+1)-a[i];
	}
	sort(r,r+n);
	for(int i=0;i<n;i++){
		int left=BinSearch_l(r,n,l[i]);
		int right=BinSearch_h(r,n,l[i]);
		ret+=right-left; 
	}
	printf("%lld\n",ret);
	return 0;
}

题解代码（C++）：

#include<cstdio>
#include<algorithm>
using namespace std;

const int maxSize=200003;
long long a[maxSize],l[maxSize],r[maxSize];
int main(){
	int n;
	long long ret=0,lwbd=0,upbd=0;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",a+i);
		l[i]=i+1+a[i];
		r[i]=i+1-a[i];
	}
	sort(r,r+n); 
	for(int i=0;i<n;i++){
		lwbd=lower_bound(r,r+n,l[i])-&r[0];
		upbd=upper_bound(r,r+n,l[i])-&r[0];
		ret+=upbd-lwbd; 
	}
	printf("%lld\n",ret);
	return 0;
}