outputstandard output
This is the hard version of this problem. The only difference between the easy and hard versions is the constraints on k and m. In this version of the problem, you need to output the answer by modulo 109+7.
You are given a sequence a of length n consisting of integers from 1 to n. The sequence may contain duplicates (i.e. some elements can be equal).
Find the number of tuples of m elements such that the maximum number in the tuple differs from the minimum by no more than k. Formally, you need to find the number of tuples of m indices i1<i2<…<im, such that
max(ai1,ai2,…,aim)−min(ai1,ai2,…,aim)≤k.
For example, if n=4, m=3, k=2, a=[1,2,4,3], then there are two such triples (i=1,j=2,z=4 and i=2,j=3,z=4). If n=4, m=2, k=1, a=[1,1,1,1], then all six possible pairs are suitable.
As the result can be very large, you should print the value modulo 109+7 (the remainder when divided by 109+7).
Input
The first line contains a single integer t (1≤t≤2⋅105) — the number of test cases. Then t test cases follow.
The first line of each test case contains three integers n, m, k (1≤n≤2⋅105, 1≤m≤100, 1≤k≤n) — the length of the sequence a, number of elements in the tuples and the maximum difference of elements in the tuple.
The next line contains n integers a1,a2,…,an (1≤ai≤n) — the sequence a.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅105.
Output
Output t answers to the given test cases. Each answer is the required number of tuples of m elements modulo 109+7, such that the maximum value in the tuple differs from the minimum by no more than k.
Example
inputCopy
4
4 3 2
1 2 4 3
4 2 1
1 1 1 1
1 1
1
10 4 3
5 6 1 3 2 9 8 1 2 4
outputCopy
2
6
1
20i
Wuhu, over! !
Sort the array first like easy, and then traverse from m to n each time to find the position greater than the minimum value of a[i]-k, so that I know the position of the two numbers whose difference is less than k. First take a[i] and then take any two of a[i] from the position of a[i]-k to a[i], which is converted into a problem of modulo a combination number.
Then paste a board for finding the inverse element of the combination number based on the Lucas theorem, and take off directly. =v=.
#include<iostream>
#include<string>
#include<map>
#include<algorithm>
#include<memory.h>
#include<cmath>
#include<assert.h>
using namespace std;
typedef long long ll;
const int maxn=3e5+5;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;
ll a[maxn];
int maxx(int a,int b,int c){
return max(a,max(b,c));
}
int minn(int a,int b,int c){
return min(a,min(b,c));
}
ll f[maxn];
ll qpow(ll a,ll b){
ll ans = 1,base = a;
while(b){
if(b&1) ans = ans * base % mod;
base = base * base % mod;
b>>=1;
}
return ans;
}
void init(){
f[0]=1;
for(int i=1;i<=2e5;i++){
f[i]=f[i-1]*i%mod;
}
}
ll cal(ll n,ll m){
if(n<m) return 0;
return 1ll*f[n]*qpow(f[m],mod-2)%mod*qpow(f[n-m],mod-2)%mod;
}
void solve(){
ll t;
cin>>t;
init();
while(t--)
{
ll n,m,k;
cin>>n>>m>>k;
for(ll i=1;i<=n;i++){
cin>>a[i];
}
sort(a+1,a+1+n);
int cnt=0;
ll sum=0;
for(ll i=m;i<=n;i++){
int x=lower_bound(a+1,a+1+n,a[i]-k)-a;
sum+=cal(i-x,m-1);
sum=sum%mod;
}
cout<<sum%mod<<endl;
}
}
int main()
{
ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
solve();
return 0;
}