POJ3378_Crazy Thairs

这个题目很有意思，也是一个很好的题目，涉及的知识点比较广，要求较高。

题目是这样的，给定你一个n个数的数列，问你有多少个长度为5的上升序列。

首先看到有50000，我们就知道肯定不会是DP。（但是不知道为什么我居然在DP优化这个章节里面做到了这个题）

由于给的数是在int范围里面的，我们需要首先将其离散化，这样相当于每个数的范围只有5000了。

剩下的就是这个题目的最最精华的地方了。

其实这里的统计是用树状数组来实现的。但是不是单单由一个树状数组实现的，而是5个。

什么意思呢？我们用f[i][j]表示不大于j的长度为i的上升序列有多少个。

这样就是一个递推了哦。而对于每一个查询我们都是通过树状数组来实现的，每次查询前面每一个长度，然后加入当前这个数字，这样每次操作的时间复杂度都是O(n*log(n))。

这样答案就呼之欲出了。

但是，你确定？

自己算一下就会发现，如果给你的数为50000个上升的数字，你的程序就直接跪了。

什么意思呢？你可以算一算，C(50000,5)> 2^64，也就是说超过了long long的范围。

这个嘛，有点那个啥。

不过我们可以这样做，保存和更新的只需要是长度为4的有多少个，C(50000,4)是不会超的。这样对于最后一次加法，直接用一个高精度数组保存答案和输出就可以了。

代码如下：

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxn 50500
#define M 1000000000
using namespace std;

typedef long long ll;
struct node{
    ll num,pos;
}a[maxn];

struct big{
    ll b[20],top;
    void Clear()
    {
        memset(b,0,sizeof b);
        top=0;
    }
    void output()
    {
        printf("%I64d",b[top]);
        for (ll i=top-1; i>=0; i--) printf("%09I64d",b[i]);
        printf("
");
    }
    void Add(ll x)
    {
        ll cur=0;
        while (x) b[cur++]+=x%M,x/=M;
        for (ll i=0; i<top; i++) b[i+1]+=b[i]/M,b[i]%=M;
        while (b[top]>=M) b[top+1]+=b[top]/M,b[top]%=M,top++;
    }
}ans;


ll f[6][maxn],g[maxn];
ll n,tep;

bool cmp(node n1,node n2) { return n1.num<n2.num; }

void rankthem()
{
    ll cur=0;
    for (ll i=1; i<=n; i++)
    {
        if (a[i].num!=a[i-1].num) cur++;
        g[a[i].pos]=cur;
    }
}

ll lowbit(ll x) { return x&(-x); }

void add(ll u[],ll x,ll v) { while (x<maxn) u[x]+=v,x+=lowbit(x); }

ll sum(ll u[],ll x)
{
    ll tot=0;
    while (x) tot+=u[x],x-=lowbit(x);
    return tot;
}

int main()
{
    a[0].num=~0U>>1;
    while (scanf("%I64d",&n)!=EOF)
    {
        ans.Clear();
        for (ll i=1; i<=n; i++) scanf("%I64d",&a[i].num),a[i].pos=i;
        sort(a+1,a+1+n,cmp);
        rankthem();  
        memset(f,0,sizeof f);
        for (ll i=1; i<=n; i++)
        {
            ans.Add(sum(f[4],g[i]-1));
            for (ll j=4; j>1; j--)
            {
                tep=sum(f[j-1],g[i]-1); 
                add(f[j],g[i],tep);
            }
            add(f[1],g[i],1);
        }
        ans.output();
    }  
    return 0;
}