题目大意:
给一个序列,从中选m (m>=2)个组成一个子序列(顺序和原序列相同),使得子序列中相邻两项的差的绝对值不超过k.
求这样所有子序列的数目。
基本算法是dp,先不考虑m>=2 , 先求出所有符合相邻差的绝对值不超过k的子序列的数目,然后减去n 就是结果。
基本dp,最开始dp数组初始化为1 ,表示以第i个数为结尾的满足要求的子序列的个数,最开始单个数看作一个序列
按输入顺序更新dp[i]
d[i] += d[j] (j<i && abs(v[i]-v[j])<=k) ,所有dp[i] 的和就是答案。
进行第一次优化,用树状数组。 还是按输入顺序更新, query(x) 表示之前出现过的 v[j] 且 v[j]<=x 以v[j]结尾的子序列的数目和
这样 dp[i] +=query(v[i]+k) - query(v[i]-k-1). 所有dp[i]的和就是答案。
不过这样依旧会TLE, 因为 v[i] 的上限为 10000000, 每次要更新的次数太多。 由于n<=100000, 我们想到了离散化。
即对原序列进行排序,然后从小到大每个值占据树状数组中的一个节点,并记录该节点在树状数组中的位置,还要把原序列的顺序和树状数组中的位置对应上。
然后还是按原序列的顺寻更新,思路和第一次优化一样,不过麻烦了些而已。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 100010
#define MOD 9901
struct Node
{
int v;
int pos;//记录在原序列的位置,排序后用原序列的位置对应更新在树状数组中的位置(index[i])
}node[N];
int n;
int index[N]; //记录原序列的第i个点在树状数组中的位置
int num[N];
bool cmp(struct Node a,struct Node b)
{
if(a.v!=b.v) return a.v<b.v;
return a.pos<b.pos;
}
int find(int x) //求上届,找到一个node[i]使得node[i].v>=x且 i最小
{
int l=0,r=n,mid=(l+r+1)>>1;
while(l<r)
{
if(node[mid].v<=x) l=mid;
else r=mid-1;
mid=(l+r+1)>>1;
}
return mid;
}
int lowbit(int x)
{
return x&-x;
}
void updata(int x,int v)
{
while(x<=n)
{
num[x]=(num[x]+v)%MOD;
x+=lowbit(x);
}
}
int query(int x)
{
int ret=0;
while(x>0)
{
ret=(ret+num[x])%MOD;
x-=lowbit(x);
}
return ret;
}
int main()
{int m;
while(cin>>n>>m)
{ memset(num,0,sizeof(num));
for(int i=1;i<=n;i++)
{
scanf("%d",&node[i].v);
node[i].pos=i;
}
sort(node+1,node+1+n,cmp);
int ans=0;
for(int i=1;i<=n;i++) index[node[i].pos]=i; //更新原第i个数在树状数组中的位置
node[0].v=0;
for(int i=1;i<=n;i++)
{
int r=find(node[index[i]].v+m);
int l=find(node[index[i]].v-m-1);
int temp=query(r)-query(l);
temp++;
ans=(ans+temp)%MOD;
updata(index[i],temp);
}
ans=(ans-n)%MOD;
if(ans<0) ans+=MOD;
cout<<ans<<endl;
}
return 0;
}