【树状数组】hdu 4911 Inversion(离散化+树状数组求逆序数)

Inversion

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 4183    Accepted Submission(s): 1525

Problem Description

bobo has a sequence a₁,a₂,…,a_n. He is allowed to swap twoadjacent numbers for no more than k times.

Find the minimum number of inversions after his swaps.

Note: The number of inversions is the number of pair (i,j) where 1≤i<j≤n and a_i>a_j.

 

Input

The input consists of several tests. For each tests:

The first line contains 2 integers n,k (1≤n≤10⁵,0≤k≤10⁹). The second line contains n integers a₁,a₂,…,a_n (0≤a_i≤10⁹).

 

Output

For each tests:

A single integer denotes the minimum number of inversions.

 

Sample Input

  
  

   
   3 1
2 2 1
3 0
2 2 1
  
  

 

Sample Output

  
  

   
   1
2
  
  

 

题意：给出n个数，每次可以交换相邻的两个数，最多交换k次，求交换后最小的逆序数是多少

分析：如果逆序数大于0，则存在1 ≤ i < n，使得交换ai和ai+1后逆序数减1。所以最后的答案就是max((inversion-k), 0)。利用树状数组求出原序列的逆序对数就可以解决问题了

注意：

因为数据比较大，因此肯定要用sort先排序
问题就在于相等的数怎么处理
如果你用的sort，就算你cmp里设定了相等的数不交换，
他也会交换？为什么？因为快排是不稳定的排序算法。
因此只用sort肯定会WA  
别问我怎么知道的.....WA了一亿发... = =

解决办法用2个，一个使用stable_sort，这个跟sort用法一样，
但绝对不会改变相同的数的顺序

另外一个办法就是把相同的数字合并，或者说是删去计算即可

///AC代码(stable_sort版)

#include <iostream>
#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <bitset>
#include <string>
#include <vector>
#include <iomanip>
#include <cstring>
#include <algorithm>
#include <functional>
#define PI acos(-1)
#define eps 1e-8
#define inf 0x3f3f3f3f
#define debug(x) cout<<"---"<<x<<"---"<<endl
typedef long long ll;
using namespace std;
const int N = 5e5 + 10;

struct  node
{
    int val;
    int pos;
} p[N];
int n, k, a[N], c[N];

bool cmp(const node&a, const node& b)
{
    return a.val < b.val;
}

int lowbit(int x)
{
    return x & (-x);
}
///单点修改+区间求和
inline int sum(int x)
{
    int res = 0;
    while (x)
    {
        res += c[x], x -= lowbit(x);
    }
    return res;
}

inline void add(int x) ///单点修改
{
    while (x <= n)
    {
        c[x] += 1, x += lowbit(x);
    }
}

inline int query(int x, int y)///区间求和
{
    return sum(y) - sum(x - 1);
}

int main()
{
    while (scanf("%d%d", &n, &k) != EOF)
    {
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &p[i].val);
            p[i].pos = i;
        }
        stable_sort(p + 1, p + n + 1, cmp); ///排序
        for (int i = 1; i <= n; i++)
        {
            a[p[i].pos] = i;        ///离散化
        }

        ll ans = 0;
        for (int i = 1; i <= n; i++)///初始化树状数组
        {
            c[i] = 0;
        }
        for (int i = 1; i <= n; i++)
        {
            add(a[i]);
            ans += i - sum(a[i]);
        }

        if (ans - k < 0)
        {
            printf("0\n");
        }
        else
        {
            printf("%lld\n", ans - k);
        }
    }
    return 0;
}

///直接删除相同元素：

#include <iostream>
#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <bitset>
#include <string>
#include <vector>
#include <iomanip>
#include <cstring>
#include <algorithm>
#include <functional>
#define PI acos(-1)
#define eps 1e-8
#define inf 0x3f3f3f3f
#define debug(x) cout<<"---"<<x<<"---"<<endl
typedef long long ll;
using namespace std;
const int N = 5e5 + 10;

struct  node
{
    int val;
    int pos;
} p[N];
int n, k, a[N], c[N];

bool cmp(const node&a, const node& b)
{
    return a.val < b.val;
}

int lowbit(int x)
{
    return x & (-x);
}
///单点修改+区间求和
inline int sum(int x)
{
    int res = 0;
    while (x)
    {
        res += c[x], x -= lowbit(x);
    }
    return res;
}

inline void add(int x) ///单点修改
{
    while (x <= n)
    {
        c[x] += 1, x += lowbit(x);
    }
}

inline int query(int x, int y)///区间求和
{
    return sum(y) - sum(x - 1);
}

int main()
{
    while (scanf("%d%d", &n, &k) != EOF)
    {
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &p[i].val);
            p[i].pos = i;
        }
        //stable_sort(p + 1, p + n + 1, cmp); ///排序
        sort(p + 1, p + n + 1, cmp);
        p[0].val = -1;
        int t = 0;
        for (int i = 1; i <= n; i++)
        {
            if (p[i].val != p[i - 1].val)
            {
                t++;
            }
            a[p[i].pos] = t;        ///离散化
        }

        ll ans = 0;
        for (int i = 1; i <= n; i++)///初始化树状数组
        {
            c[i] = 0;
        }
        for (int i = 1; i <= n; i++)
        {
            add(a[i]);
            ans += i - sum(a[i]);
        }

        if (ans - k < 0)
        {
            printf("0\n");
        }
        else
        {
            printf("%lld\n", ans - k);
        }
    }
    return 0;
}