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 =  + ;

 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 = ;
     while(pos >= )
     {
         ans += c[pos] % ;
         pos -= lowbit(pos);
     }
     return ans;
 }
 int main()
 {
     int  m, i, j;
     while(scanf("%d%d",&n, &m) != EOF)
     {
         memset(dp, , sizeof(dp));

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