【[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;
}