【线段树+离散化】求逆序对数目

题目如下

第三题：lyp 的密码(lyp) 
 
【题目描述】 
众所周知，lyp 喜欢以用各种方式折磨别人为乐，这次，他趁 wars 不在时在他的电脑上
挂了一把神奇的锁，这把锁需要一串巨长无比的数字密码才可以解开，这 个密码由 lyp 自
己保管，这样 wars 就没法 Kingdom Rush 了。但 wars 设法从 lyp 的脑袋中挖出了有关密码
的信息，这些信息是一列非负整数{An}。而解开密 码锁的方式是首先输入这列这数的逆序
对数，而后依次会在 wars 的电脑屏幕上显示两个数字 p,q，你则需要输入将整数列中第 p 个
整数替换成 q 后整个数列的逆序 对数，这样的询问会有 m 个。当然，这样的替换只对这一
次的询问有效。现在 wars 急着去打 Kingdom Rush，因此将打开电脑的任务交给了你。 
 
【输入数据】 
第 1 行 ： n, m 以空格隔开 
第 2 行 ： n 个整数，以空格隔开，第 i 个整数代表 Ai 
第 3~m+2 行 ： p, q 以空格隔开 
 
【输出数据】 
依次输出可以解开密码锁的整数列 
 
【输入样例】 
5 3 
2 3 1 4 5 
3 4 
2 1 
5 1 
 
【输出样例】 
2 
0 
2 
5 
 
【数据约定】 
 n<=50000，m<=50000 
0<=序列的每一元素（包括询问中的）<=100000 
保证询问合法。 

易知此题为求逆序对数目+ 询问每次在最初的数列修改1个值，求此时逆序对数目。

毫无疑问，一眼看此题就知道要写线段树。

因为此题数据范围较大，那么如何用线段树以较好的时间复杂度去完成询问操作才是此题难点。我在考场上啪啪啪瞬间敲完第一问之后问后就写错了，连线段树都写不出来真丢脸，搞得只能交裸，多亏主席后来一语点醒我的错误之处，ORZ。

至于此题建线段树，是以数字大小为区间的，也即为[10, 20]的域记录着数字大小在[10 , 20]的数字个数，与”星星”一题的建树类似。

可以知道，如果真正按照此题要求去一个一个修改值的做是 TLE 惨的，我的解决办法是如下：（尽管貌似我跟其他人讲我的方法他们都表示不理解= =）

我们先离线式的读入所有询问，每个询问记好p、q、wh，p、q见题目描述，而wh则是询问顺序，然后先按p排序。(struct ask)

※实际上，每组询问的解就是将原序列的逆序对数目– 与x[p]有关的逆序对数目 + 与q有关的逆序对数目。

设原序列为val[maxn]，在插入v[i]进线段树前，我们就可以查找到目前树中比val[i]要大的数字个数，也就是位于1~i - 1的数与x[i]组成的逆序对个数。且ask.p已经保证单增，则也可以处理出1~i - 1之前与ask.q组成的逆序对个数。

同样的我们也要找出x[i]与ask.q与位于i + 1 ~ n的逆序对个数，那么只需要把重新倒着建一遍线段树即可，但要注意每次查找就应该是查找比val[i]与ask.q小的数字个数。

然后按照算法输出即可。

如还有不懂那肯定是对线段树的观念没有转换过来

看看我的代码吧（递归版常数稍微大一点）欢迎提意见

#include <iostream>
#include <ctime>
#include <string>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;

const int maxn = 50000 + 5;
const int limt = 100000 + 5;

struct node { int p, q, ans, wh; } ask[maxn];

int n, m, tail, tot;
int trn[limt << 2], val[maxn], before[maxn];

bool _cmp_(node x, node y) { return x.p < y.p; }
bool _cmp__(node x, node y) { return x.p > y.p; }
bool _cmp___(node x, node y) { return x.wh < y.wh; }

void Pushup(int rt)
{
   trn[rt] = trn[rt << 1] + trn[rt << 1 | 1];
}

void buildtree(int l, int r, int rt)
{
   if (l == r) return trn[rt] = 0, (void) 0;
   int mid = (l + r) >> 1;
   if (l <= mid) buildtree(l, mid, rt << 1);
   if (r >  mid) buildtree(mid + 1, r, rt << 1 | 1);
}

int Query(int x, int y, int l, int r, int rt)
{
   if (x <= l && y >= r) return trn[rt];
   int mid = (l + r) >> 1, tnum = 0;
   if (x <= mid) tnum += Query(x, y, l, mid, rt << 1);
   if (y >  mid) tnum += Query(x, y, mid + 1, r, rt << 1 | 1);
   return tnum;
}

void Insert(int x, int l, int r, int rt)
{
   if (x <= l && x >= r) return ++trn[rt], (void) 0;
   int mid = (l + r) >> 1;
   if (x <= mid) return Insert(x, l, mid, rt << 1), Pushup(rt);
   else if (x >  mid) return Insert(x, mid + 1, r, rt << 1 | 1), Pushup(rt);
}

int main()
{
   freopen("lyp.in", "r", stdin);
   freopen("lyp.out", "w", stdout);

   cin >> n >> m;
   for (int i = 1; i <= n; ++i)
      scanf("%d", &val[i]), val[i] += 2;
   for (int i = 1; i <= m; ask[i].q += 2, ask[i].wh = i, ++i)
      scanf("%d%d", &ask[i].p, &ask[i].q);
   sort(ask + 1, ask + m + 1, _cmp_); tail = 1;

   //buildtree(1, limt, 1);实际上这个建树过程是毫无意义的,不过习惯性的一次性都写下来了
   for (int i = 1; i <= n; ++i)
   {
      before[i] += Query(val[i] + 1, limt - 5, 1, limt, 1);
      tot += before[i];
      while (ask[tail].p == i)
         ask[tail].ans += Query(ask[tail].q + 1, limt - 5, 1, limt, 1), ++tail;
      Insert(val[i], 1, limt, 1);
   }
   cout << tot << endl;

   memset(trn, 0, sizeof(trn));
   sort(ask + 1, ask + m + 1, _cmp__); tail = 1;

   for (int i = n; i >= 1; --i)
   {
      before[i] += Query(1, val[i] - 1, 1, limt, 1);
      while (ask[tail].p == i)
         ask[tail].ans += Query(1, ask[tail].q - 1, 1, limt, 1), ++tail;
      Insert(val[i], 1, limt, 1);
   }

   sort(ask + 1, ask + m + 1, _cmp___);
   for (int i = 1; i <= m; ++i)
      ask[i].ans = tot - before[ask[i].p] + ask[i].ans;

   for (int i = 1; i <= m; ++i)
      printf("%d\n", ask[i].ans);

   return 0;
}