题意：

思路：
再想过了一些主席树等大数据结构如何维护后，毫无头绪，此时根据数据范围找算法可能，注意到 3 e 4 3e4 3e4的数据那么 O ( n n ) O(n\sqrt n) O(nn ​)也可过，再加上题目里并没有要求我们强制在线处理，再加上这道题目答案的更新在单点添加和删除的是保证正确性的，所以可以用莫队来解决。

下一步就是找一种方法来快速的获得，当前遍历的 [ l , r ] [l , r] [l,r]区间间内值域处于 [ a i − k , a i + k ] [a_i -k,a_i + k] [ai​−k,ai​+k]的数有多少，一开始看到这个无脑想到主席树 l o g n logn logn的查询，就冲了，结果一直 t l e tle tle，后来得知可能是常数太大，无法优化，递归类算法都自带比较大的常数，但一般无人卡。

继续想，莫队处理区间的时候，是一个个位置单点滑动的，所以我们每个位置都更新的话，当前区间其实就跟查整棵数是一致的，因为加的我及时加，不要的我及时消除，到此只需要一个树状数组来维护对应值域内的数有多少个即可。

再就是最好提前将 a i − k a_i - k ai​−k和 a i + k a_i + k ai​+k放入离散化数组，不然的话，对于上界的有些情况需要特殊处理一下，要不然不对，当然细节也不难，很好理解。

#include <bits/stdc++.h>

using namespace std;

#define pb emplace_back
#define MP make_pair
#define pii pair<int,int>
#define pll pair<ll,ll>
#define lson rt<<1
#define rson rt<<1|1
#define CLOSE std::ios::sync_with_stdio(false)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-6;
const int N = 27010;
int n,m,a[N],up[N],down[N],c[N],b[N],cnt,k;
int lowbit(int x) {
	return x & (-x);
}
void add(int pos,int v) {
	while(pos <= n) {
		c[pos] += v;
		pos += lowbit(pos);
	}
}
int query(int pos) {
	int res = 0;
	while(pos) { res += c[pos]; pos -= lowbit(pos); }
	return res;
}
int posq[N],posa[N],ans[N];
struct Q {
	int l,r,id;
}q[N];
bool cmp(Q a,Q b) {
	return posq[a.l] == posq[b.l] ? a.r < b.r : posq[a.l] < posq[b.l];
}
int getid(int x) { return lower_bound(b + 1,b + 1 + cnt,x) - b; }

int main() {
	scanf("%d%d%d",&n,&m,&k);
	int siz = sqrt(n);
	for(int i = 1;i <= n;i ++) {
		scanf("%d",&a[i]);
		posq[i] = (i + siz - 1) / siz;
		b[i] = a[i];
	}
	sort(b + 1,b + 1 + n);
	cnt = unique(b + 1,b + 1 + n) - b - 1;
	for(int i = 1;i <= m;i ++) {
		scanf("%d%d",&q[i].l,&q[i].r);
		q[i].id = i;
	}
	b[cnt+1] = INF;
	sort(q + 1,q + 1 + m,cmp);
	for(int i = 1;i <= n;i ++) {
		posa[a[i]] = getid(a[i]);
		down[a[i]] = getid(a[i] - k);
		int tmp = getid(a[i] + k); 
		up[a[i]] = (b[tmp] > a[i] + k) ? tmp-1 : tmp;//边界的细节情况
	}
	int l = 1,r = 0,sum = 0;
	for(int i = 1;i <= m;i ++) {
			while(q[i].l < l) {
			int tmp = l - 1;
			sum += query(up[a[tmp]]) - query(down[a[tmp]]-1);
			add(posa[a[tmp]],1);
			l--;
		}
		while(q[i].r > r) {
			int tmp = r + 1;
			sum += query(up[a[tmp]]) - query(down[a[tmp]]-1);
			add(posa[a[tmp]],1);
			r++;
		}
		while(q[i].l > l) {
			add(posa[a[l]],-1);
			sum -= query(up[a[l]]) - query(down[a[l]]-1);
			l++;
		}
		while(q[i].r < r) {
			add(posa[a[r]],-1);
			sum -= query(up[a[r]]) - query(down[a[r]]-1);
			r--;
		}
		ans[q[i].id] = sum;
	}
	for(int i = 1;i <= m;i ++) printf("%d\n",ans[i]);
	return 0;
}
/*
7 5 3
2 5 7 5 1 5 6
6 6
1 3
4 6
2 4
3 4
*/