【（待重做）树状数组+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=9901;
const int maxn=1e5+3;
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=0;
    while(k)
    {
        res=(res+tree[k])%mod;
        k-=lowbit(k);
    }
    return res;
}
int query(int l,int r)
{
    return (query(r)-query(l-1)+mod)%mod;
}
int main()
{    
    while(~scanf("%d%d",&n,&d))
    {
        memset(tree,0,sizeof(tree));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            h[i]=a[i];
        }
        sort(h+1,h+n+1);
        int cnt=unique(h+1,h+n+1)-h-1;
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            int fi=1;
            int l=lower_bound(h+1,h+cnt+1,a[i]-d)-h;
            int r=upper_bound(h+1,h+cnt+1,a[i]+d)-h-1;
            int pos=lower_bound(h+1,h+cnt+1,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 0;
}

【知识点】

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

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