【[TJOI2014]上升子序列】

这本质上是一个\(dp\)

如果没有"两个上升子序列相同,那么只需要计算一次"这一个性质，那么就很好做了，我们用\(dp[i]\)表示以\(i\)结尾的上升子序列个数，那么就有\(dp[i]=\sum_{j=1}^{i-1}dp[j]\)

这个暴力转移是\(O(n^2)\)的，我们这里可以直接用树状数组来优化，于是就变成了\(O(nlogn)\)

同时由于数字可能非常大，所以需要离散化

之后再来考虑一下如何去重

首先重复的情况肯定是来自于一个之前已经出现过的数，而这个出现的数又将所有之前那个点算出来的答案又都加了一遍，这样就会有重复的了

那我们怎么去掉这些重复的情况呢

首先直接不考虑这个再次出现的数是肯定不对的，如果这个数和它之前出现的那个位置之间有一些比这个数小的的数，那么这些就就没有被计入答案，于是就错了

但是我们可以对每一个数维护一个\(lastans[i]\)，表示\(i\)这个数上次被计入答案的时候\(\sum_{j=1}^{i-1}dp[j]\)是多少，之后我们还是用树状数组来查询前缀和，之后我们计入答案的应该就是这次查询出来的答案减去\(lastans\)，也就是表示新增的上升子序列的个数是多少，之后我们再把这个数加入树状数组

代码

#include<iostream>
#include<cstring>
#include<cstdio>
#include<map>
#include<algorithm>
#define re register
#define lowbit(x) ((x)&(-(x)))
#define maxn 100005
#define LL long long
#define int long long
const LL mod=1e9+7;
std::map<LL,LL> ma;
LL c[maxn];
int n;
LL a[maxn],b[maxn];
LL lastans[maxn];
int f[maxn];
inline LL read()
{
    char c=getchar();
    LL x=0,r=1;
    while(c<'0'||c>'9') 
    {
        if(c=='-') r=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9')
      x=(x<<3)+(x<<1)+c-48,c=getchar();
    return x*r;
}
inline void add(int x,LL v)
{
    for(re LL i=x;i<=n;i+=lowbit(i))
        c[i]=(c[i]+v)%mod;
}
inline LL query(LL x)
{
    LL ans=0;
    for(re LL i=x;i;i-=lowbit(i))
        ans=(ans+c[i])%mod;
    return ans;
}
signed main()
{
    n=read();
    for(re int i=1;i<=n;i++) a[i]=b[i]=read();
    std::sort(b+1,b+n+1);
    int tot=std::unique(b+1,b+1+n)-b-1;
    for(re int i=1;i<=tot;i++)
        ma[b[i]]=i;
    LL cnt=0;
    for(re int i=1;i<=n;i++)
    {
        int j=ma[a[i]];
        if(!f[j])
        {
            LL mid=query(j-1);
            cnt=(cnt+mid)%mod;
            add(j,mid+1);
            lastans[j]=mid;
            f[j]=1;
            continue;
        }
        LL mid=query(j-1);
        cnt=(cnt+mid-lastans[j]+mod)%mod;
        add(j,(mid-lastans[j]+2*mod)%mod);
        lastans[j]=mid;
    }
    std::cout<<cnt;
    return 0;
}

转载于:https://www.cnblogs.com/asuldb/p/10207862.html