POJ 3378 Crazy Thairs(树状数组，DP, 高精度，离散化)

题意：

有一个N个数组成的数列，问你该数列中有多少上升5元序列，即满足如下要求的序列(不要求连续取5个A)：

 

        1 ≤ i < j < k < l < m ≤ N

        Ai < Aj < Ak < Al < Am

题解：

数据大，量不大，所以要离散化。

动态规划：
令d[x][i]  = y 表示原始数据中的以A[x]结尾的上升i（i为1,2,3,4,5）元序列有y个。

边界：全为0；

从做往右读所有的a[i]，假设当前读入的a[i] = x,那么当前读入的a[i] = x。那么d[x][1] = 1。递推公式如下：

d[x][2] = sum{d[y][1]}

d[x][3] = sum{d[y][2]}

d[x][4] = sum{d[y][3]}

d[x][5] = sum{d[y][4]}

其中1<=y<x 且A[y]<A[x]。

由于y值在50000，所以直接加是不可以的，看到sum，可以用树状数组快速实现求和。建5个树状数组c[6][maxn]，每个数组维护一个d[],当新读入一个数x时候，在第一棵树c[1]上执行add(1,x,1),在第二棵树c[2]上执行add(2,x,sum(1,x-1))。

在第i棵树上执行add(I,x,sum(i-1,x-1)).最终的结果sum[5,n]。

数据比较大，long long也会爆，所以使用高精度来计算结果。Base尽量大点。

 

 

 

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;
typedef long long LL;
const int maxn =50000+111;
const int base =10000;
class bignum
{
public:
    int num[7],len;
    bignum():len(0){}
    bignum(int n):len(0)
    {
        for(;n>0;n/=base)
            num[len++] = n%base;
    }

    bignum bigvalue(LL n)
    {
        len = 0;
        while(n)
        {
            num[len++] = n%base;
            len /= base;
        }
        return *this;
    }

    bignum operator +(const bignum& b)
    {
        bignum c;
        int i,carry = 0;
        for(i=0;i<this->len||i<b.len||carry>0;i++)
        {
            if(i < this->len)carry+=this->num[i];
            if(i < b.len)carry+=b.num[i];
            c.num[i] = carry%base;
            carry/=base;
        }
        c.len = i;
        return c;
    }

    bignum operator += (const bignum& b)
    {
        *this = *this +b;
        return *this;
    }

    void print()
    {
        if(len==0)
        {
            cout<<0<<endl;
            return;
        }
        printf("%d",num[len-1]);
        for(int i=len-2;i>=0;i--)
            for(int j=base/10;j>0;j/=10)
        {
            printf("%d",num[i]/j%10);
        }
        puts("");

    }
};
typedef bignum big;
struct node
{
    int v,index;
    bool operator< (const node &a)const
    {
        return v<a.v;
    }
}ns[maxn];
int a[maxn];
bignum c[6][maxn];

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

big sum(int i,int x)
{
    big res = 0;
    while(x>0)
    {
        res+=c[i][x];
        x-=lowbit(x);
    }
    return res;
}

void add(int i,int x,big v)
{
    while(x<maxn)
    {
        c[i][x]+=v;
        x+=lowbit(x);
    }
}

int main()
{
    int n;
    while(cin>>n)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&ns[i].v);
            ns[i].index=i;
        }
        sort(ns+1,ns+1+n);
        int maxv=0;
        a[ns[1].index]=++maxv;
        for(int i=2;i<=n;i++)///离散化
        {
            if(ns[i].v==ns[i-1].v)a[ns[i].index] = maxv;
            else a[ns[i].index] = ++maxv;
        }

        for(int i=1;i<=5;i++)
        for(int j=1;j<=n+10;j++)
            c[i][j]=0;

        for(int i=1;i<=n;i++)
        {
            int x=a[i];
            add(1,x,big(1));
            for(int j=2;j<=5;j++)
                add(j,x,sum(j-1,x-1));
        }
        sum(5,n).print();
    }
}