hdu 3450 Counting Sequences

最新推荐文章于 2019-01-10 21:44:20 发布

原创最新推荐文章于 2019-01-10 21:44:20 发布 · 613 阅读

1 ·

CC 4.0 BY-SA版权

树状数组专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一种动态规划(DP)问题的解决方法，通过树状数组和离散化技术来优化算法效率，实现对特定序列问题的有效求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目大意：

给一个序列，从中选m （m>=2）个组成一个子序列（顺序和原序列相同），使得子序列中相邻两项的差的绝对值不超过k.

求这样所有子序列的数目。

基本算法是dp，先不考虑m>=2 , 先求出所有符合相邻差的绝对值不超过k的子序列的数目，然后减去n 就是结果。

基本dp,最开始dp数组初始化为1 ，表示以第i个数为结尾的满足要求的子序列的个数，最开始单个数看作一个序列

按输入顺序更新dp[i]

d[i] += d[j] (j<i && abs(v[i]-v[j])<=k) ,所有dp[i] 的和就是答案。

进行第一次优化,用树状数组。还是按输入顺序更新, query(x) 表示之前出现过的 v[j] 且 v[j]<=x 以v[j]结尾的子序列的数目和

这样 dp[i] +=query(v[i]+k) - query(v[i]-k-1). 所有dp[i]的和就是答案。

不过这样依旧会TLE, 因为 v[i] 的上限为 10000000，每次要更新的次数太多。由于n<=100000, 我们想到了离散化。

即对原序列进行排序，然后从小到大每个值占据树状数组中的一个节点，并记录该节点在树状数组中的位置，还要把原序列的顺序和树状数组中的位置对应上。

然后还是按原序列的顺寻更新，思路和第一次优化一样，不过麻烦了些而已。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 100010
#define MOD 9901
struct Node
{
    int v;
    int pos;//记录在原序列的位置，排序后用原序列的位置对应更新在树状数组中的位置（index[i]）
}node[N];
int n;
int index[N]; //记录原序列的第i个点在树状数组中的位置
int num[N];
bool cmp(struct Node a,struct Node b)
{
    if(a.v!=b.v)  return a.v<b.v;
    return a.pos<b.pos;
}

int find(int x) //求上届，找到一个node[i]使得node[i].v>=x且 i最小
{
    int l=0,r=n,mid=(l+r+1)>>1;
    while(l<r)
    {
        if(node[mid].v<=x)  l=mid;
        else r=mid-1;
        mid=(l+r+1)>>1;
    }
    return mid;
}
int lowbit(int x)
{
    return x&-x;
}
void updata(int x,int v)
{
    while(x<=n)
    {
        num[x]=(num[x]+v)%MOD;
        x+=lowbit(x);
    }
}
int query(int x)
{
    int ret=0;
    while(x>0)
    {
        ret=(ret+num[x])%MOD;
        x-=lowbit(x);
    }
    return ret;
}
int main()
{int m;
    while(cin>>n>>m)
    {   memset(num,0,sizeof(num));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&node[i].v);
            node[i].pos=i;
        }
        sort(node+1,node+1+n,cmp);
        int ans=0;
        for(int i=1;i<=n;i++)  index[node[i].pos]=i; //更新原第i个数在树状数组中的位置
        node[0].v=0;
        for(int i=1;i<=n;i++)
        {
            int r=find(node[index[i]].v+m);
            int l=find(node[index[i]].v-m-1);
            int temp=query(r)-query(l);

            temp++;
            ans=(ans+temp)%MOD;
            updata(index[i],temp);
        }
        ans=(ans-n)%MOD;
        if(ans<0)  ans+=MOD;
        cout<<ans<<endl;
    }
    return 0;
}