BestCoder Round#8 1003

dp[i][j] 表示以i结尾的长度为j的递增子序列
dp[i][j] = sum(dp[k][j])     k<i && a[i] >a[j]
如果只是单纯的循环
for(j=2; j<=m; ++j)
　　for(i=1; i<=n; ++i)
　　　　for(k=1; k<i; ++k)
　　　　　　if(a[i] > a[j])
　　　　　　　　dp[i][j] += dp[k][j-1];
时间复杂度是O(n * n * m)   TLE
但是k循环可以用树状数组来优化，k循环可以看做是一个区间求和的过程，即求出小于i的dp[k][j-1]有多少个
那么时间复杂度变为O(n * m * logn)

#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 10000 + 10;

LL a[N],b[N],c[N];
int n;
LL dp[N][N];
int lowbit(int t)
{
    return t & (-t);
}
void update(int pos, LL val)
{
    while(pos <= n)
    {
        c[pos] += val;
        pos += lowbit(pos);
    }
}
LL query(int pos)
{
    LL ans = 0;
    while(pos >= 1)
    {
        ans += c[pos] % 123456789;
        pos -= lowbit(pos);
    }
    return ans;
}
int main()
{
    int  m, i, j;
    while(scanf("%d%d",&n, &m) != EOF)
    {
        memset(dp, 0, sizeof(dp));

        for(i=1; i<=n; ++i)
        {
            dp[i][1] = 1;
            scanf("%I64d",&a[i]);
            b[i] = a[i];
        }
        sort(b+1, b+n+1);
        for(j=2; j<=m; ++j)
        {
            memset(c, 0, sizeof(c));
            for(i=1; i<=n; ++i)
            {
                int index = lower_bound(b+1, b+n+1,a[i]) - b ;//离散化，index 表示a[i]在数列中第几大
                dp[i][j] = query(index-1);//找出小于index的长度为j-1的递增子序列有多少个
                update(index,dp[i][j-1]);//更新以i结尾的，长度为j-1的递增子序列有多少个
            }
        }
        LL ans = 0;
        for(i=1; i<=n; ++i)
            ans = (ans + dp[i][m]) % 123456789;
        printf("%I64d
",ans);
    }
}