差值序列计数 HDU 3450

这个差值序列想到不难想，即便是不暴力，线段树也能处理。大概就是排序，离散化，然后维护dp(x),表示以序列中第x小的数为结尾的子序列的个数

看似简单的水题，WA了差不多10次，好可怕。。。。之前在ZOJ还做了一道类似的题。。。。弱到爆，主要是有一个地方没有处理好

比如这样一组数据

2 3

2 2 2

如果你线段树更新时，dp(x)=sum(v,w)，则这样的数据就会WA

但改成dp(x)+=sum(v,w)，就过了。。。。

为何要累加呢？因为如果一个数列有2个以上相同的数，就会存在x使得dp(x)两次被更新，而x则是相同的数的位置(第几小)

不累加的话，显然是不是少算了呢？这一点格外小心。。。

附代码：

#include <iostream>
#include <cstdio>
#include <algorithm>

#define N 100005
#define cl(a) memset(a,0,sizeof(a))
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define ss(a) scanf("%d",&a)
#define mod 9901

using namespace std;

int a[N],b[N],f[N<<2];

void pushup(int rt)
{
    f[rt]=(f[rt<<1]+f[rt<<1|1])%mod;
}

int sum(int L,int R,int l,int r,int rt)
{
    if (L<=l&&r<=R)
    {
        return f[rt];
    }
    int m=(l+r)>>1,res=0;
    if (L<=m) res+=sum(L,R,lson);
    if (R>m) res+=sum(L,R,rson);
    return res%mod;
}

void update(int i,int value,int l,int r,int rt)
{
    if (l==r)
    {
        f[rt]+=value;
        return;
    }
    int m=(l+r)>>1;
    if (i<=m) update(i,value,lson);
    if (i>m) update(i,value,rson);
    pushup(rt);
}

int binary(int x,int l,int r)
{
    if (r-l<=1)
    {
        if (x>=b[r]) return r;
        else if (x>=b[l]) return l;
        else return l-1; 
    }
    int m=(l+r)>>1;
    if (b[m]==x) return m;
    else if (b[m]>x) return binary(x,l,m-1);
    else return binary(x,m,r);    
}

int main()
{
    int n,i,d;
    while (ss(n)!=EOF)
    {
        ss(d);
        cl(b);
        for (i=1;i<=n;i++) 
        {
            ss(a[i]);
            b[i]=a[i];
        }
        sort(b+1,b+n+1);
        cl(f);
        for (i=1;i<=n;i++)
        {           
            int v,w,t,u;
            v=binary(a[i]-d-1,1,n)+1;
            w=binary(a[i]+d,1,n);
            u=binary(a[i],1,n);
            t=(sum(v,w,1,n,1)+1)%mod;
            update(u,t,1,n,1);
        }
        cout<<(sum(1,n,1,n,1)%mod-n%mod+mod)%mod<<endl;
    }
    return 0;
}