HDU

题目大意：

给你一串数（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养成中····