题目大意：

给你一串数（50,000个），和一个最大差 d <= 10,000,000。现在问你这串数有多少个子序列（至少有两个元素）满足每两个相邻的元素之间的差不超过d。

分析：

假设这一串数为存在 a[] 数组里面。

dp建立：

设 dp [ i ] 表示这串数字以 a [ i ] 结尾的满足要求的子序列的个数。
则

状态转移方程为：

dp[i]=(b1∗dp[1]+b2∗dp[2]+...+bi−1∗dp[i−1])+s[i]

边界条件为：

dp[1]=0

状态转移方程描述：

bj 表示 a [ j ] 是否在区间 [ a[i]-d , a[i]+d ] 范围内。s [ i ] 表示 a [ 1 ] 到 a [ i-1 ] 之间有多少在区间 [ a[i]-d , a[i]+d ] 内的。

树状数组优化：

但是发现这样遍历时间复杂度 O(n2) 一定会超时的。然后想到用树状数组优化，树状数组以 a [ i ] 的值作为下标，dp [ i ] 作为该下标对应的要维护的值。这样每次就可以以 O(logn) 的时间复杂度快速求得 a[i]-d , a[i]+d ] 范围内的 dp [ ] 的值的和了。s [ i ] 的求法同理，只需要把维护的值变成1而不是 dp [ i ] 就可以了。

离散化处理：

d的大小最大可能是10^7，我肯定不能开这么大的树状数组来维护这一堆 a [ i ] 的值。所以要想办法把数组 a [ ] 里面这10^5个数映射到区间 [ 1 , 10^5 ] 里面去。肯定是一个格存一个数了，然后我还要以很快的速度知道任意两个的映射完成之后得到的数，他们映射前的值的差是不是小于等于d。如何做到这个，我想就是记录每个区间 [ a[i]-d , a[i]+d ] 映射之后的对应区间，该区间记为 [ l[ i ] , r[ i ] ] 要满足的条件是，以前在范围 [ a[i]-d , a[i]+d ] 的 a[j] 在映射之后还需要在 [ l[ i ] , r[ i ] ] ，以前不在的，在映射之后也不能在新的区间内。
具体代码的实现方法就是：给 a [ ] 排序，然后对于每个 a [ i ] 记录下它左面右面分别有多少个在它对应的范围 [ a[ i ]-d , a[ i ]+d ] 内的 a [ j ] 。然后就相当于记录下了映射之后他该对应的可取值区间 [ l[ i ] , r[ i ] ] 。这个确定每个区间的过程（在排序好的 a[ ] 数组里找 a [ i ]+d 和 a [ i ]-d）如果用遍历，时间复杂度 O(n^2) 是会超时的。要使用二分查找就会变快应该就不超时了。

代码：

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<string.h>

using namespace std;
#define maxn 100500
#define mod 9901 

int n,d;
int dp[maxn];
int tree[2][maxn];
int c[maxn];
struct shu
{
    int val;int num;
}a[maxn];
struct inv
{
    int l;int r;
}b[maxn];

int lowbit(int x)
{
    return x&(-x);
}

void add(int t,int i,int x)
{
    while(i<=n)
    {
        tree[t][i]+=x;
        i+=lowbit(i);
    }
    return;
}

int sum(int i,int x)
{
    int s=0;
    while(x>0)
    {
        s+=tree[i][x];
        x-=lowbit(x);
    }
    return s;
}

bool my_cmp(shu a,shu b)
{
    return a.val<b.val;
}

int my_find(int l,int r,int x,int dis)
{
    if(dis==1)//相等的取到最左面 
    {
        if(l==r)
        {
            return l;
        }
        if(x<=a[(r+l)/2].val)
        {
            return my_find(l,(l+r)/2,x,dis);
        }
        else
        {
            return my_find((l+r)/2+1,r,x,dis);
        }
    }
    else//相等的取到最右面 
    {
        if(l==r)
        {
            return l;
        }
        if(x>=a[(r+l)/2+1].val)
        {
            return my_find((l+r)/2+1,r,x,dis);
        }
        else
        {
            return my_find(l,(l+r)/2,x,dis);
        }
    }

}

int main()
{
    while(scanf("%d%d",&n,&d)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i].val);
            a[i].num=i;
        }
        sort(a+1,a+n+1,my_cmp);
        for(int i=1;i<=n;i++)
        {
            c[a[i].num]=i;
        }
        for(int i=1;i<=n;i++)
        {
            b[a[i].num].l=my_find(1,n,a[i].val-d,1);
            b[a[i].num].r=my_find(1,n,a[i].val+d,2);
        }
        dp[1]=0;
        memset(tree,0,sizeof(tree));
        /*for(int i=1;i<=n;i++) { cout<<a[i].num<<" "<<a[i].val<<endl; cout<<b[i].l<<","<<b[i].r<<endl; }*/
        for(int i=1;i<=n;i++)
        {
            dp[i]=sum(0,b[i].r)-sum(0,b[i].l-1)+sum(1,b[i].r)-sum(1,b[i].l-1);
            dp[i]%=mod;
            add(0,c[i],1);
            add(1,c[i],dp[i]);
        }
        int ans=sum(1,n);
        ans%=mod;
        printf("%d\n",ans);
    }
}

后记：

整整写了一上午的这道题的代码，这个应该算是第一次写二分查找，wa了3次后ac的。总之这道题用到了好多封装思想，要集合起来用，很考验代码能力。（就是我觉得挺难的，从打代码的角度来说，不过这次打的应该还算比较清晰，没有各种打补丁的现象）。
注意离散化映射处理的那部分，从 映射前的下标和值 到 映射后对应的下标和值 再到 存到树状数组里的下标和值 都分别是怎样的对应关系，这个一定要想明白。

carry养成中····