hdu 2227 dp+树状数组优化

很容易可以想到状态转移方程：

　　dp[i] = segma: dp[j] ( j < i && a[j] <= a[i] ), 其中dp[i]表示以a[i]结尾的不降子序列的个数。

但是n非常大，n^2的算法必然TLE，仔细想想其实式子右边是一个区间和的形式，即小于等于a[i]的a[j]的dp[j]的和，所以可以将a[i]离散化成t后将dp[i]的值存在t位置上，每次求解dp[i]就是查询一个前缀和，可以用树状数组来维护。

举个例子：对于1，50，13，34这四个数，离散化后变成了1，4，2，3。显然dp[1] = 1，所以我们在1位置插入1；而dp[2]就等于查询位置1到4（1+0+0+0）的和再加1，所以dp[2] = 2，我们在4位置插入2；dp[3]就等于（1+0）再加1，dp[3] = 2，我们在2位置插入2；dp[4]就等于（1+2+0）再加1为4，在位置3插入4，最后答案为整个数列的和：1+2+4+2=9.

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

typedef long long ll;
const int N = 100001;
const int MOD = 1000000007;
int c[N];

struct Node 
{
    ll s;
    int id;    
} node[N];

int lb( int i )
{
    return i & -i;
}

void set( int i, int x )
{
    while ( i < N )
    {
        c[i] += x;
        c[i] %= MOD;
        i += lb(i);
    }
}

int get( int i )
{
    int ans = 0;
    while ( i > 0 )
    {
        ans += c[i];
        ans %= MOD;
        i -= lb(i);
    }
    return ans;
}

bool cmp1( Node n1, Node n2 )
{
    if ( n1.s != n2.s ) return n1.s < n2.s;
    return n1.id < n2.id;
}

bool cmp2( Node n1, Node n2 )
{
    return n1.id < n2.id;    
}

int main ()
{
    int n;
    while ( scanf("%d", &n) != EOF )
    {
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%I64d", &node[i].s);
            node[i].id = i;            
        }
        sort( node + 1, node + 1 + n, cmp1 );
        for ( int i = 1; i <= n; i++ )
        {
            node[i].s = i;
        }
        sort( node + 1, node + 1 + n, cmp2 );
        memset( c, 0, sizeof(c) );
        for ( int i = 1; i <= n; i++ )
        {
            int pn = node[i].s;
            int nn = get(pn) + 1;
            set( pn, nn );
        }
        printf("%d
", get(n));
    }
    return 0;
}