HDU 3450 Counting Sequences(树状数组+DP+离散化)

HDU 3450 Counting Sequences(树状数组+DP+离散化)

http://acm.hdu.edu.cn/showproblem.php?pid=3450

题意：

        For a set of sequences of integers｛a1，a2，a3，...an｝, we define a sequence｛ai1,ai2,ai3...aik｝in which 1<=i1<i2<i3<...<ik<=n, as the sub-sequence of ｛a1，a2，a3，...an｝. It is quite obvious that a sequence with the length n has 2^n sub-sequences. And for a sub-sequence｛ai1,ai2,ai3...aik｝，if it matches the following qualities: k >= 2, and the neighboring 2 elements have the difference not larger than d, it will be defined as a Perfect Sub-sequence. Now given an integer sequence, calculate the number of its perfect sub-sequence.

分析：

        对于一个给定的序列a[n]，令d[i]表示以a[i]为结尾的完美序列的个数。那么有下列递推公式：

        d[i] = A+B

        其中A是d[j]且 j<i 且 |a[j]-a[i]|<=D

        其中B是从a[1]到a[i-1]这段数列中 满足 |a[j]-a[i]|<=D的j的个数

        最终我们所求为d[1]+d[2]+d[3]+...d[n]==sum(2，maxn)。(即对第二颗树状数组求和，后文会介绍)

        由上面的公式可知我们可以动态的用树状数组来更新a和d数组。即维护两个树状数组，其中一个树状数组A[1][n]假设A[1][X]==1表示a[i]==X的值已经出现了一个，如果出现了，那么add(1，a[i]，1)(表示对第一颗树状数组的a[i]位置加1)。第二颗树状数组A[2][n]，假设A[2][5]==3，表示以d[j]==5这个值结尾的完美序列一共有3个。

        我们从左到右依次读入每一个a[i]，我们每新读入一个a[i]，首先对第一棵树状数组执行add(1，a[i]，1)，然后对第二棵树状数组执行add(2，a[i]，(sum(1，a[i]+D)-sum(1，a[i]-D) )  )

        这样到最后我们用sum(2，MAXN)就可以算出答案.

        但是此题的数据范围很大，D最大1000W，我们不可能开个1000W的数组来处理，所以我们需要将输入的数据离散化集中,重新映射到一个小范围的数组内.且要满足如果原先abs(ai-aj)<=D，那么就在重新映射的时候记录下与原a[i]差值不差过D的L[i]和R[i]位置即可。

        L[i]表示编号为i的数,在重新映射之后,求与a[i]原始差值<=D的a[j]时，应该去[L[i],R[i]]区间找b[L]和b[R]。

        L[i]中存的是新值不是下标.

        到此a[i]被赋予了新值b[i],且每次求d[2][i]=sum(1,[L[i],R[i]])+sum(2, [L[i],R[i]]),而不再是d[2][i]=sum(1,[i-D,i+D])+sum(2, [i-D,i+D])了.

最终答案,中间结果记得要对9901求余.

        两点:

        一是有求余的结果一定要记得各个地方都要求好余数，不要想当然。

        二是本题求L[i]和R[i]要用二分查找，用数组循环超时。

AC代码:250ms

<span style="font-size:18px;">#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN =100000+100;
const int MOD=9901;
struct node
{
    int v;
    int index;
    bool operator <(const node&b)const
    {
        return v<b.v;
    }
}nodes[MAXN];
int n,D;
int a[MAXN],L[MAXN],R[MAXN];
int c[3][MAXN];
int b[MAXN];
int lowbit(int x)
{
    return x&(-x);
}
int sum(int i,int x)
{
    int res=0;
    while(x)
    {
        res +=c[i][x];
        res%=MOD;//不加这句就是WA
        x-=lowbit(x);
    }
    return res;
}
void add(int i,int x,int v)
{
    while(x<MAXN)
    {
        c[i][x]+=v;
        c[i][x]%=MOD;
        x+=lowbit(x);
    }
}
int find_L(int i)//找到初值为b[i]的数能接触到的新值的下界
{
    int l=1,r=n,max_v=b[i];
    while(r>l)
    {
        int mid= l+(r-l)/2;
        if(max_v-nodes[mid].v<D)
            r=mid;
        else if(max_v-nodes[mid].v == D)
            r=mid;
        else
            l=mid+1;
    }
    return a[nodes[r].index];
}
int find_R(int i)//找到初值为b[i]的数能接触到的新值的上界
{
    int l=1,r=n,min_v=b[i];
    while(r>l)
    {
        int mid= l+(r-l+1)/2;
        if(nodes[mid].v-min_v < D)
            l=mid;
        else if(nodes[mid].v-min_v == D)
            l=mid;
        else
            r=mid-1;
    }
    return a[nodes[l].index];
}
int main()
{
    while(scanf("%d%d",&n,&D)==2&&n&&D)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&nodes[i].v);
            b[i]=nodes[i].v;
            nodes[i].index=i;
        }
        sort(nodes+1,nodes+n+1);
        int max_num=1;
        a[nodes[1].index]=1;
        for(int i=2;i<=n;i++)//数值重新映射
        {
            if( nodes[i].v== nodes[i-1].v )
            {
                a[nodes[i].index]= max_num;
            }
            else
            {
                a[nodes[i].index]= ++max_num;
            }
        }
        memset(c,0,sizeof(c));
        for(int i=1;i<=n;i++)
        {
            L[i]=find_L(i);
            R[i]=find_R(i);
            int temp =sum(1,R[i])-sum(1,L[i]-1)+sum(2, R[i])-sum(2,L[i]-1) ;//sum求和取差不一定是正确
            temp = (temp+MOD)%MOD;//注意这里
            add(2,a[i],temp);
            add(1,a[i],1);
        }
        printf("%d\n",sum(2,n)%MOD);
    }
    return 0;
}
</span>