hdu 5178(尺取法)

pairs

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Problem Description

John has n points on the X axis, and their coordinates are (x[i],0),(i=0,1,2,…,n−1) . He wants to know how many pairs <a,b> that |x[b]−x[a]|≤k.(a<b)

 

Input

The first line contains a single integer T (about 5), indicating the number of cases.
Each test case begins with two integers n,k(1≤n≤100000,1≤k≤109) .
Next n lines contain an integer x[i](−109≤x[i]≤109) , means the X coordinates.

 

Output

For each case, output an integer means how many pairs <a,b> that |x[b]−x[a]|≤k .

 

Sample Input

  
  

   
   2
5 5
-100
0
100
101
102
5 300
-100
0
100
101
102
  
  

 

Sample Output

  
  

   
   3
10
  
  

 

先讲讲我超时的思路：对于每个数xi，分别加入xi，xi+k，xi-k到数组中去，将其离散化之后就可以转化到树状数组的问题上去了。|xb-xa|<=k，所以xb-k<=xa<=xb+k，即只需要找到在这个区间范围内的个数。这也是为什么之前要加入xi，xi+k，xi-k。但这种想法居然超时了，无语。。。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<set>
#include<map>
using namespace std;

const int maxn = 100005;
int n,k,cnt,X[maxn];
int tree[maxn<<1];
set<int> Set;
map<int,int> Map;

int lowbit(int x)
{
	return x & -x;
}

void update(int x,int c)
{
	while(x <= cnt)
	{
		tree[x] += c;
		x += lowbit(x);
	}
}

int getsum(int x)
{
	int sum = 0;
	while(x > 0)
	{
		sum += tree[x];
		x -= lowbit(x);
	}
	return sum;
}

int main()
{
	int t;
	__int64 ans;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&k);	
		Set.clear();
		Map.clear();
		for(int i = 1; i <= n; i++)
		{
			scanf("%d",&X[i]);
			Set.insert(X[i]);
			Set.insert(X[i]+k);
			Set.insert(X[i]-k);
		}
		ans = cnt = 0;
		memset(tree,0,sizeof(tree));
		for(set<int>::iterator it = Set.begin(); it != Set.end(); it++)
			Map[*it] = ++cnt;
		for(int i = 1; i <= n; i++)
		{
			ans += getsum(Map[X[i]+k]) - getsum(Map[X[i]-k]-1);
			update(Map[X[i]],1);
		}
		printf("%I64d\n",ans);
	}
	return 0;
}

实在想不出什么优化的方法，参考了别人的思路，尺取法即可。仔细想想，确实是没问题的，因为是取绝对值的，所以谁前谁后都是不会有影响的。

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

const int maxn = 100005;
int n,k,X[maxn];

int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&k);
		for(int i = 1; i <= n; i++)
			scanf("%d",&X[i]);
		sort(X+1,X+1+n);
		__int64 ans = 0;
		for(int i = 1,j = 1; i <= n; i++)
		{
			while(j + 1 <= n && X[j+1] - X[i] <= k) j++;
			ans += j - i;
		}
		printf("%I64d\n",ans);
	}
	return 0;
}