HDU 6318 - Swaps and Inversions - [离散化+树状数组求逆序数][杭电2018多校赛2]

题目连接：http://acm.hdu.edu.cn/showproblem.php?pid=6318

Problem Description

Long long ago, there was an integer sequence a.
Tonyfang think this sequence is messy, so he will count the number of inversions in this sequence. Because he is angry, you will have to pay x yuan for every inversion in the sequence.
You don't want to pay too much, so you can try to play some tricks before he sees this sequence. You can pay y yuan to swap any two adjacent elements.
What is the minimum amount of money you need to spend?
The definition of inversion in this problem is pair (i,j) which 1≤i<j≤n and ai>aj.

 

Input

There are multiple test cases, please read till the end of input file.
For each test, in the first line, three integers, n,x,y, n represents the length of the sequence.
In the second line, n integers separated by spaces, representing the orginal sequence a.
1≤n,x,y≤100000, numbers in the sequence are in [−1e9,1e9]. There're 10 test cases.

 

Output

For every test case, a single integer representing minimum money to pay.

 

Sample Input

3 233 666

1 2 3

3 1 666

3 2 1

 

Sample Output

0

3

题意：

给出n个元素的序列，现在你有机会，花费y元交换一次任意相邻两个元素，交换完毕后，若存在逆序对，每一个逆序对要花费x元，求最少的花费。

题解：

考虑冒泡排序：

　　1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

　　2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。做完一遍，最后的元素是最大的数。

　　3. 针对所有的元素重复以上的步骤，除了最后一个（因为确定是最大的）。

　　4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

显然，我们每交换一次两个相邻元素，就必然能使逆序数减1，而排序完毕后逆序数等于0，所以冒泡排序交换相邻元素次数等于逆序数。

而且同样易知，我们不可能用更少的交换次数使得逆序数等于0。

所以我们就得到了如下结论：

　　逆序数 = 在只能交换相邻元素条件下，使得序列有序的最少交换次数

而本题中，交换一次花费x，一个逆序对花费y，也就是说，要么全部交换直到没有逆序对，要么一次也不交换。

所以我们只要求出逆序数k，答案ans = k * min(x,y)。

由于本题数值范围[-1e9,1e9]，而n最多1e5，树状数组不可能开2e9，所以只能进行离散化。

时间复杂度：sort函数O(nlogn)，unique函数O(n)，暴力枚举n个元素并获取ID以及树状数组修改+查询操作O(nlogn)，总的O(nlogn)，满足要求。

AC代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=+;

struct _BIT //单点修改、区间查询
{
    int n,C[maxn];
    int lowbit(int x){return x&(-x);}
    void init(int n)
    {
        this->n=n;
        memset(C,,sizeof(C));
    }
    void add(int pos,int val) //在pos点加上val
    {
        while(pos<=n)
        {
            C[pos]+=val;
            pos+=lowbit(pos);
        }
    }
    int ask(int pos) //查询1~pos点的和
    {
        int ret=;
        while(pos>)
        {
            ret+=C[pos];
            pos-=lowbit(pos);
        }
        return ret;
    }
}BIT;

int n;
ll x,y;

int a[maxn];

vector<int> v;
inline int getID(int x){return lower_bound(v.begin(),v.end(),x)-v.begin()+;}
int main()
{
    while(scanf("%d%d%d",&n,&x,&y)!=EOF)
    {
        v.clear();
        for(int i=;i<=n;i++)
        {
            scanf("%d",&a[i]);
            v.push_back(a[i]);
        }
        sort(v.begin(),v.end());
        v.erase(unique(v.begin(),v.end()),v.end());

        BIT.init(v.size());
        ll cnt=;
        for(int i=;i<=n;i++)
        {
            int id=getID(a[i]);
            BIT.add(id,);
            cnt+=BIT.ask(v.size())-BIT.ask(id);
        }

        cout<<cnt*min(x,y)<<endl;
    }
}