【BZOJ3295】【块状链表+树状数组】动态逆序对

Description

对于序列A，它的逆序对数定义为满足i<j，且A_i>A_j的数对(i,j)的个数。给1到n的一个排列，按照某种顺序依次删除m个元素，你的任务是在每次删除一个元素之前统计整个序列的逆序对数。

Input

输入第一行包含两个整数n和m，即初始元素的个数和删除的元素个数。以下n行每行包含一个1到n之间的正整数，即初始排列。以下m行每行一个正整数，依次为每次删除的元素。

 

Output

 

输出包含m行，依次为删除每个元素之前，逆序对的个数。

Sample Input

5 4
1
5
3
4
2
5
1
4
2

Sample Output

5
2
2
1

样例解释
(1,5,3,4,2)(1,3,4,2)(3,4,2)(3,2)(3)。

HINT

N<=100000 M<=50000

【分析】

这种水题还弄了两节课...真是没法治了。

用很多种方法，最好理解的就是块状链表套树状数组，每个块状链表里面套一个二维的树状数组，再加上离散化。

将m序列中的每一个数字对应一个坐标(在n中坐标，n-数字大小)然后就可以做了。

我还开了3个一维树状数组，卡着时间过的。

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #include <utility>
 #include <iomanip>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <assert.h>
 #include <map>

 const int N =  + ;
 const int SIZE = ;//块状链表的根号50000
 const int M =  + ;
 using namespace std;
 typedef long long ll;
 int lowbit(int x) {return x & -x;}
 struct BLOCK_LIST{
      int C[SIZE][SIZE];
      int t[][SIZE];//关于a的离散化序列和b的离散化序列
      void init(){
           memset(C, , sizeof(C));
           memset(t, , sizeof(t));
      }
      int sum(int x, int y){
          int cnt = , f = y;
          //int flag = x;
          while (x > ){
                while (y > ){
                      cnt += C[x][y];
                      y -= lowbit(y);
                }
                x -= lowbit(x);
                y = f;
          }
          return cnt;
      }
      void add(int x, int y){
           int f = y;
           while (x < SIZE){
                 while (y < SIZE){
                       C[x][y]++;
                       y += lowbit(y);
                 }
                 x += lowbit(x);
                 y = f;
           }
           return;
      }
      //二分搜索，查找x在k内相当的值
      int search(int k, int x){
          int l = , r = , Ans;
          while (l <= r){
                int mid = (l + r) >> ;
                if (t[k][mid] <= x) Ans = mid, l = mid + ;
                else r = mid - ;
          }
          return Ans;
      }
 }list[SIZE];
 struct DATA{
        int t[];//影响m的树状数组的两个值，注意都要进行离散化
        int x;//值
 }rem[M];
 struct LSH{
        int num, order;
        bool operator < (LSH b)const{
             return num < b.num;//专门用来离散化
        }
 }A[M];
 int data[N], c[][N], n, m;
 int num[N];//num[N]代表i有i存在的逆序对的个数
 ll tot;//记录逆序对的个数 

 ll sum(int k, int x){
     ll cnt = ;
     while (x > ){
           cnt += c[k][x];
           x -= lowbit(x);
     }
     return cnt;//记得要用ll
 }
 void add(int k, int x){
      while (x <= n){
           c[k][x]++;
           x += lowbit(x);
      }
      return;
 }
 void init(){
      tot = ;
      memset(num, , sizeof(num));
      memset(c, , sizeof(c));
      scanf("%d%d", &n, &m);
      for (int i = ; i <= n; i++){
          int x;
          scanf("%d", &x);
          data[x] = i;
          int tmp = sum(, x);
          num[x] += (i -  - tmp);//先求出在i之前的比i大的数
          num[x] += (x - tmp - );//后面比i小的数
          tot += (i -  - tmp);
          add(, x);
      }
      //printf("%d\n", tot);
      //for (int i = 1; i <= n; i++) printf("%d\n", num[i]);
 }
 //离散化
 void prepare(){
      //a,b中两个值分别为位置和大小
      for (int i = ; i <= m; i++){
          int tmp;
          scanf("%d", &tmp);
          rem[i].t[] = data[tmp];
          rem[i].t[] = n - tmp + ;
          rem[i].x = tmp;
      }
      //for (int i = 1; i <= m; i++) printf("%d %d %d\n", rem[i].t[0], rem[i].t[1], rem[i].x);
 }
 void get(int k, int l, int r, int x){
      int cnt = r - l + , pos = ;
      for (int i = l; i <= r; i++){
          A[pos].order = i;
          A[pos].num = rem[i].t[k];
          pos++;
      }
      sort(A + , A + cnt + );
      for (int i = ;i <= cnt; i++) list[x].t[k][i] = A[i].num;
      for (int i = ;i <= cnt; i++) rem[A[i].order].t[k] = i;
 }
 void work(){
      for (int i = ; i < SIZE; i++) list[i].init();
      int cnt = ;//cnt是用来记录块的数量
      for (int pos = ; pos <= m; pos++){

          int l = pos;
          l = min(m ,  + pos - );
          //从[l,m]这一段放在list[cnt]里面
          get(, pos, l, cnt);
          get(, pos, l, cnt);
          for (int i = pos; i <= l; i++){
              printf("%lld\n", tot);
              int tmp = list[cnt].sum(rem[i].t[], rem[i].t[]);
              for (int j = ; j < cnt; j++) tmp += list[j].sum(list[j].search(, list[cnt].t[][rem[i].t[]]), list[j].search(, list[cnt].t[][rem[i].t[]]));

              tot -= (num[rem[i].x] - (tmp + (sum(, rem[i].x) - (sum(, list[cnt].t[][rem[i].t[]]) - tmp))));
              list[cnt].add(rem[i].t[], rem[i].t[]);
              add(, list[cnt].t[][rem[i].t[]]);
              add(, rem[i].x);
          }
          cnt++;
          pos = l;
      }
 }

 int main(){
     #ifdef LOCAL
     freopen("data.txt",  "r",  stdin);
     freopen("out.txt",  "w",  stdout);
     #endif
     init();
     prepare();
     if (m == ) return ;
     else work();
     return ;
 }