【（待重做）树状数组+dp+离散化】Counting Sequences

https://www.bnuoj.com/v3/contest_show.php?cid=9149#problem/G

【题意】

给定一个数组a，问这个数组有多少个子序列，满足子序列中任意两个相邻数的差（绝对值）都不大于d.

【思路】

首先，朴素的dp思想：

dp[i]为以a[i]结尾的子问题的答案，则dp[i]=sum(dp[k]),k<i&&|a[k]-a[i]|<=d

但是时间复杂度为O(n^2),会超时。

我们可以这样想：

如果数组a排好序后，dp[i]就是区间(a[i]-d,a[i]+d)的结果和（直接把a[i]加到原数组后面）

所以自然而然就想到了用树状数组,区间求和求出dp[i],然后单点修改dp[i]以备后用。

这样时间复杂度就变成了O(nlogn)

另外要注意原来是很稀疏的大数据，我们要离散化压缩状态（排序去重）

先把长度为1的姑且认为是完美子序列，然后再减去n,怎样状态就很好转移，所以看到代码里fi初始值为1.

【Accepted】

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<algorithm>
 #include<cmath>

 using namespace std;
 const int mod=;
 const int maxn=1e5+;
 int n,d;
 int a[maxn],h[maxn],tree[maxn];
 int lowbit(int x)
 {
     return x&(-x);
  }
 void add(int k,int x)
 {
     while(k<=n)
     {
         tree[k]=(tree[k]+x)%mod;
         k+=lowbit(k);
     }
 }
 int query(int k)
 {
     int res=;
     while(k)
     {
         res=(res+tree[k])%mod;
         k-=lowbit(k);
     }
     return res;
 }
 int query(int l,int r)
 {
     return (query(r)-query(l-)+mod)%mod;
 }
 int main()
 {
     while(~scanf("%d%d",&n,&d))
     {
         memset(tree,,sizeof(tree));
         for(int i=;i<=n;i++)
         {
             scanf("%d",&a[i]);
             h[i]=a[i];
         }
         sort(h+,h+n+);
         int cnt=unique(h+,h+n+)-h-;
         int ans=;
         for(int i=;i<=n;i++)
         {
             int fi=;
             int l=lower_bound(h+,h+cnt+,a[i]-d)-h;
             int r=upper_bound(h+,h+cnt+,a[i]+d)-h-;
             int pos=lower_bound(h+,h+cnt+,a[i])-h;
             fi=(fi+query(l,r))%mod;
             ans=(ans+fi)%mod;
             add(pos,fi);
         }
         ans=(ans-n%mod+mod)%mod;
         cout<<ans<<endl;
     }
     return ;
 }

【知识点】

lower_bound返回第一个大于等于查找值的迭代器指针

upper_bound返回第一个大于（没有等于）查找值的迭代器指针