Codeforces Round #301 (Div. 2) E . Infinite Inversions 树状数组求逆序数

                                                                E. Infinite Inversions

                                                                                         time limit per test

                                                                                              2 seconds

                                                                                      memory limit per test

                                                                                          256 megabytes

                                                                                     input standard input

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 output standard output

 

There is an infinite sequence consisting of all positive integers in the increasing order: p = {1, 2, 3, ...}. We performed n swapoperations with this sequence. A swap(a, b) is an operation of swapping the elements of the sequence on positions a and b. Your task is to find the number of inversions in the resulting sequence, i.e. the number of such index pairs (i, j), that i < j and pi > pj.

Input

The first line contains a single integer n (1 ≤ n ≤ 105) — the number of swap operations applied to the sequence.

Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109, ai ≠ bi) — the arguments of the swap operation.

Output

Print a single integer — the number of inversions in the resulting sequence.

Sample test(s)

input

2
4 2
1 4

output

4

input

3
1 6
3 4
2 5

output

15

题意：一个无限 长的数组（1， 2， 3， 4， .....）， n次操作， 每次交换两个位置上的值.

输出最终 有多少逆序对数。

由于这题是 数字可能会很多，，我们只能 离散化之后来求 逆序数了，， 先把所有操作读进来，，离散化 被操作数。  而那些被操作数之间的数字可以缩点来处理（就是把所有的数字看成一个数字来处理）。然后就可以求出结果了。。

#include <set>
#include <map>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int MAXN = 4e5+10;
int a[MAXN], tot, n;
int A[MAXN], B[MAXN];
int lowbit (int x)
{
    return x & -x;
}
long long arr[MAXN], M;
void modify (int x, int d)
{
    while (x < M)
    {
        arr[x] += d;
        x += lowbit (x);
    }
}
int sum(int x)
{
    int ans = 0;
    while (x)
    {
        ans += arr[x];
        x -= lowbit (x);
    }
    return ans;
}
int p[MAXN],kk[MAXN];
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
    #endif
    while (cin >> n)
    {
        int x, y;
        tot = 0;
        memset (arr, 0, sizeof (arr));
        memset(kk, 0, sizeof (kk));
        long long minv = inf;
        long long maxv = 0;
        map<int, int>pp;
        for (int i = 0; i < n; i++)
        {
            scanf ("%d%d", &x, &y);
            minv = min(minv, (long long)min(x, y));
            maxv = max(maxv, (long long)max(x, y));
            a[tot++] = x;
            a[tot++] = y;
            A[i] = x;
            B[i] = y;
        }
        sort (a, a+tot);

        tot = unique(a, a+tot) - a;
        int ok = 0;
        int tmp = tot;
        long long j = minv;
        int tt;
        vector<int>vec;
        for (int i = 0; i < tot; )
        {
            if (a[i] == j)
            {
                i++;
                j++;
                ok = 0;
            }
            else
            {
                if (ok == 0)            // 缩点
                {
                    ok = j;
                    a[tmp++] = j;
                    tt = j;
                    vec.push_back(tt);
                }
                pp[ok] += a[i]-j;
                j = a[i];
            }
        }
        tot = tmp;
        sort (a, a+tot);
        for (int i = 0; i < vec.size(); i++)
        {
            int qq = vec[i];
            if (pp.count(qq) >= 1)
            {
                int ix = lower_bound(a, a+tot, qq)-a+1;
                kk[ix] = pp[qq];
            }
        }
        for (int i = 0; i < n; i++)
        {
            A[i] = lower_bound(a,a+tot, A[i]) - a + 1;   // 离散化
            B[i] = lower_bound(a,a+tot, B[i]) - a + 1;
        }
        maxv = lower_bound(a, a+tot, maxv) - a + 1;
        M = maxv+10;
        for (int i = 1; i <= maxv; i++)
        {
            p[i] = i;
        }
        for (int i = 0; i < n; i++)
        {
            swap(p[A[i]], p[B[i]]);
        }
        long long ans = 0;
        long long cnt = 0;
        for (int i = 1; i <= maxv; i++)
        {
            ans += (long long)(i-1+cnt - sum(p[i]))*max(1,kk[i]);
            modify(p[i], max(1,kk[i]));
            cnt += max(1,kk[i]) - 1;
        }
        printf("%I64d
", ans);
    }
    return 0;
}