hdu 5542 The Battle of Chibi（2015CCPC - C题）

　　题目链接：hdu 5542

　　首届CCPC的C题，比赛时一起搞了好久，最后是队友A出的，当时有试过用树状数组来优化 dp，然后今天下午也用树状数组搞了一下午，结果还是踩了和当时一样的坑：我总是把用来记录状态的 dp 数组和树状数组里的内置数组混在一起使用了，而且两重循环的顺序也反了，以至于两组数据

3 2               3 2

1 2 3     和     3 2 1

程序跑都得出了相同的结果，无语。。。之前做 dp 和线段树结合的题时也是傻傻地分不清，说到底就是 dp 的功力很不够，所以在 dp 专场的这场比赛中除了水题外我几乎没什么贡献了，很心塞郁闷了一段时间

　　题目思路：先建立一个经典的 dp 模型：f[k][i] 表示长度为 k，以 b[i] 结尾的上升子序列的数量（即 dp 的状态），所以递推方程为 f[k][i] = sum{ f[k - 1][x], 1<=x< i && 1<= b[x] <= b[i]-1 }，可以看到 k 只依赖于 k-1，而 i 依赖于 b[i] 前面并比 b[i] 小的（和经典的逆序数原理一样），所以可以用树状数组来快速求出，之所以写成 f[k][i] 而不是 f[i][k] 是为了方便树状数组的操作（其实调过来完全可以的，不过脑子一时间转不过弯来，树状数组一直以来都写得太死了，总是模板大法 -_-||）程序实现中还充斥着各种技巧等。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define  lowbit(x)  ((x) & -(x))
 typedef long long ll;
 const int N = ;
 const ll mod = ;

 int maxn;
 ll c[N][N];     // c 数组和 maxn 是树状数组所需的数据结构
 ll f[N][N];     // f[k][i] 表示长度为 k，以 b[i] 结尾的上升子序列的数量（即 dp 的状态）

 ll sum(int len, int x) {        // 树状数组的两个函数
     ll res = ;
     while(x) {
         res += c[len][x];             // c[][] 的 len 对应 f[][] 的 k，x 对应 f[][] 的 b[i]
         if(res >= mod)   res -= mod;
         x -= lowbit(x);
     }
     return res;
 }

 void add(int len, int x, ll v) {
     while(x <= maxn) {
         c[len][x] += v;
         if(c[len][x] >= mod)   c[len][x] -= mod;
         x += lowbit(x);
     }
 }

 int b[N], a[N];

 int main() {
     int t,n,m,Case = ;
     scanf("%d",&t);
     while(t--) {
         scanf("%d %d",&n,&m);
         for(int i = ; i <= n; ++i) {
             scanf("%d", b + i);
             a[i] = b[i];
         }
         sort(a + , a + n + );             // 离散化
         for(int i = ; i <= n; ++i)
             b[i] = lower_bound(a + , a + n + , b[i]) - a;

         maxn = n + ;
         memset(c, , sizeof c);
         memset(f, , sizeof f);             // 记得都要清零

         ll ans = ;
         // 两重循环的顺序不能搞错！
         // 每次对于每个 b[i]，都是已经算好了长度 1~min(i,m) 的上升子序列的数量，即 f[1~min(i,m)][i] 的值；
         // 然后再到 b[i + 1]；所以是先枚举 1~n 的离散化后各个元素，再枚举长度(1~min(i,m))
         for(int i = ; i <= n; ++i) {
             int top = min(i,m);
             for(int k = ; k <= top; ++k) {
                 if(k == )  f[k][i] = ;
                 else {
                     f[k][i] += sum(k - , b[i] - );        // f[k][i] = sum{f[k - 1][x], 1 <= b[x] <= b[i]-1 }
                     if(f[k][i] >= mod)   f[k][i] -= mod;
                 }
                 add(k, b[i], f[k][i]);      // 把算好的 f[k][i] 更新进树状数组中去
             }
             ans += f[m][i];                 // 这时候 f[m][i] 已经算好了，所以加入到答案中
             if(ans >= mod)   ans -= mod;
         }
         printf("Case #%d: %I64d\n", ++Case, ans);
     }
     return ;
 }

　　二重循环中，先固定 i，然后枚举 k，颠倒过来是不行的，原因是如果先固定 k 而枚举 i 的话那么计算完 k-1 后，1~n 的元素都已经进入树状数组中去了，也就是在计算 i 时，i 后面的元素都已经进入树状数组中，这样子就混淆了之前的元素，就好像求逆序数时必须从前往后按顺序来，否则后面比前面的先插入到树状数组中就没意义了。

　　dp 数组记录状态，然后更新进相应的数据结构中，和 hdu 4521 小明系列问题——小明序列 有相似之处，必须好好体会下 dp 和数据结构结合的这种思想与处理方式。