【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 = 100000 + 10;
const int SIZE = 225;//块状链表的根号50000 
const int M = 50000 + 5;
using namespace std;
typedef long long ll;
int lowbit(int x) {return x & -x;}
struct BLOCK_LIST{
     int C[SIZE][SIZE];
     int t[2][SIZE];//关于a的离散化序列和b的离散化序列 
     void init(){
          memset(C, 0, sizeof(C));
          memset(t, 0, sizeof(t));
     }
     int sum(int x, int y){
         int cnt = 0, f = y;
         //int flag = x;
         while (x > 0){
               while (y > 0){
                     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 = 0, r = 224, Ans;
         while (l <= r){
               int mid = (l + r) >> 1;
               if (t[k][mid] <= x) Ans = mid, l = mid + 1;
               else r = mid - 1;
         }
         return Ans;
     }
}list[SIZE];
struct DATA{
       int t[2];//影响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[3][N], n, m;
int num[N];//num[N]代表i有i存在的逆序对的个数 
ll tot;//记录逆序对的个数 

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