HDU - 3450 Counting Sequences解题报告(动态规划+离散化+树状数组+二分查找)

题目大意:

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

分析:

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

dp建立:

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

状态转移方程为:

dp[i]=(b1dp[1]+b2dp[2]+...+bi1dp[i1])+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养成中····

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值