HDU 3450 Counting Sequences (树状数组)

思路：以样例为例， 1 3 7 5 当我们更新到5的时候，设ans[i]表示i这个数有多少种，ans[5]=ans[5-d]+ans[5+d]+1;为什么+1呢，应为最后我们取的是长度大于1的，+1对于之后的更新方便，但在最后要减去n，应为每个数都算了一次+1.当然，这题没有说i最大为多少，显然，我们要离散化，并且每次都要查找i这个数离散化后的下标。这里用了map来维护。当然也可以用二分来场找最小大于等于i-d的数的下标和最大小于等于i+d的数的下标。

而上面的状态方程中的5-d和5+d并不是绝对的，应该是大于等于5-d最近的某个数和小于等于5+d的最近的某个数。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
const int maxn=100002;
const int oo=1000000000;
const int mod=9901;
int c[maxn],n,d,b[maxn],a[maxn];
void add(int x,int val)
{
    while(x<=maxn)
    {
        c[x]+=val;
        c[x]%=mod;
        x+=(x&-x);
    }
}
int sum(int x)
{
    int s=0;
    while(x>0)
    {
        s+=c[x];
        s%=mod;
        x-=(x&-x);
    }
    return s;
}
int main()
{
    int i,id,up,down,val,ans;
    while(~scanf("%d%d",&n,&d))
    {
        map<int,int>flag;
        map<int,int>::iterator it;
        flag[0]=0;
        memset(c,0,sizeof(c));
        for(i=0; i<n; i++)
        {
            scanf("%d",&a[i]);
            b[i]=a[i];
        }
        sort(b,b+n);
        int cnt=2;
        flag[b[0]]=1;
        for(i=1; i<n; i++)
            if(b[i]!=b[i-1])
                flag[b[i]]=cnt++;
        flag[oo]=cnt++;
        for(i=0; i<n; i++)
        {
            it=flag.lower_bound(a[i]);
            id=it->second;
            it=flag.upper_bound(a[i]+d);
            up=it->second-1;
            it=flag.lower_bound(a[i]-d);
            down=it->second;
            val=sum(up)-sum(down-1)+1;
            val=(val%mod+mod)%mod;
            add(id,val);
        }
        ans=sum(cnt);
        ans=((ans-n)%mod+mod)%mod;
        printf("%d\n",ans);
    }
    return 0;
}