火柴排队 2013年NOIP全国联赛提高组

题目描述 Description

涵涵有两盒火柴，每盒装有 n 根火柴，每根火柴都有一个高度。现在将每盒中的火柴各自排成一列，同一列火柴的高度互不相同，两列火柴之间的距离定义为：
，其中 a_i表示第一列火柴中第 i 个火柴的高度，b_i表示第二列火柴中第 i 个火柴的高度。
每列火柴中相邻两根火柴的位置都可以交换，请你通过交换使得两列火柴之间的距离最小。请问得到这个最小的距离，最少需要交换多少次？如果这个数字太大，请输出这个最小交换次数对 99,999,997 取模的结果。

输入描述 Input Description

共三行，第一行包含一个整数 n，表示每盒中火柴的数目。
第二行有 n 个整数，每两个整数之间用一个空格隔开，表示第一列火柴的高度。
第三行有 n 个整数，每两个整数之间用一个空格隔开，表示第二列火柴的高度。

输出描述 Output Description

输出共一行，包含一个整数，表示最少交换次数对 99,999,997 取模的结果。

样例输入 Sample Input

[Sample 1]
4 
2 3 1 4 
3 2 1 4
[Sample 2]
4 
1 3 4 2 
1 7 2 4

样例输出 Sample Output

[Sample 1]
1
[Sample 2]
2

数据范围及提示 Data Size & Hint

【样例1说明】
最小距离是 0，最少需要交换 1 次，比如：交换第 1 列的前 2 根火柴或者交换第 2 列的前 2 根火柴。
【样例2说明】
最小距离是 10，最少需要交换 2 次，比如：交换第 1 列的中间 2 根火柴的位置，再交换第 2 列中后 2 根火柴的位置。
【数据范围】
对于 10%的数据， 1 ≤ n ≤ 10； 
对于 30%的数据，1 ≤ n ≤ 100； 
对于 60%的数据，1 ≤ n ≤ 1,000； 
对于 100%的数据，1 ≤ n ≤ 100,000，0 ≤火柴高度≤ 2^31 - 1。

求数组中逆序对 个数。

如果你足够聪明可能第一反应应该是在各个序列中排名一样的数对齐其和距离和最小。

证明也是可以证明的，但不给出了，可以自己设；

选对两排的火柴进行排序，得到了每根火柴对应的那一根。

C[i]表示第i个数应该移动到C[i]位置。

然后就是用求逆序对的方法来算就可以了。

如何进行这种计算？？

http://blog.sina.com.cn/s/blog_963453200101jxqa.html（参考）

先引入逆序对的概念：对于一个包含N个非负整数的数组A[1..n],如果有iA[j],则称A[i],A[j]为数组中的一个逆序对(见百度百科)。

     考虑序列中两个相邻的元素A[i]  和 A[i+1],交换这两个元素不影响它们和序列中其他元素的逆序对数。可能增加一个逆序对（A[i]A[i+1])。交换过程中我们一定不愿意上逆序数增加，所以交换只会出现在是逆序对减少的情况，但是存在一个问题，这样的操作能不能持续下去？即会不会存在某个状态不管怎么交换都必须使逆序对增加呢？可以肯定的讲，在序列没有被排成升序之前这种状态是不存在的。

     于是每次交换一次整个逆序数就减少一个，直到逆序数变为0，即排成升序序列。因此此题实际上就是一个给定序列的逆序对数。

#include 
#include 
#include 
#define SIZE 500010
using namespace std;


struct NODE
{
    int val,pos;
}node[SIZE];
int n,c[SIZE],Hash[SIZE];
bool cmp(const NODE& a, const NODE& b)
{
    return a.val <</span> b.val;
}
int lowbit(int x)
{
    return x&(-x);
}
void update(int x)
{
    while(x<=n)
    {
        c[x]+=1;
        x+=lowbit(x);
    }
}
int getsum(int x)
{
    int sum=0;
    while(x>0)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
int main()
{
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(int i=1;i<=n;i++)
        {
            c[i]=0;
            scanf("%d",&node[i].val);
            node[i].pos=i;
        }
        sort(node + 1, node + n + 1, cmp);
        ///离散化
        for(int i=1;i<=n;i++)
        {
            Hash[node[i].pos]=i;//第i个数排序后在Hash[i]位置
        }
        ///求逆序数
        long long ans=0;
        for(int i=1;i<=n;i++)
        {
            update(Hash[i]);
            ans= ans + i-getsum(Hash[i]);
        }
        printf("%lld\n",ans);
    }
    return 0;
}

然后就得到代码如下：（还输比较难理解的）

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
struct  aaaa{int pos,val;}a[100001],b[100001];
int hash[100001],c[100001],n;
bool cmp(aaaa a,aaaa b){return a.val<b.val;}
int lowbit(int x){return x&(-x);}
void updata(int x){
while(x<=n){
c[x]++;
x+=lowbit(x);
}
}
int getsum(int x){
int sum=0;
while(x>0){
sum+=c[x];
x-=lowbit(x);
}
return sum;
}
int main()
{
    cin>>n;
for(int i=1;i<=n;i++){cin>>a[i].val;a[i].pos=i;}
for(int i=1;i<=n;i++){cin>>b[i].val;b[i].pos=i;}
sort(a+1,a+1+n,cmp);
sort(b+1,b+1+n,cmp);
for(int i=1;i<=n;i++){
hash[b[i].pos]=a[i].pos; 
}
int ans=0;
for(int i=1;i<=n;i++){
updata(hash[i]);
ans+=i-getsum(hash[i]);
ans%=99999997; 
}
cout<<ans;
    return 0;
}

#include 
#include 
#include 
#define SIZE 500010
using namespace std;


struct NODE
{
    int val,pos;
}node[SIZE];
int n,c[SIZE],Hash[SIZE];
bool cmp(const NODE& a, const NODE& b)
{
    return a.val <</span> b.val;
}
int lowbit(int x)
{
    return x&(-x);
}
void update(int x)
{
    while(x<=n)
    {
        c[x]+=1;
        x+=lowbit(x);
    }
}
int getsum(int x)
{
    int sum=0;
    while(x>0)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
int main()
{
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(int i=1;i<=n;i++)
        {
            c[i]=0;
            scanf("%d",&node[i].val);
            node[i].pos=i;
        }
        sort(node + 1, node + n + 1, cmp);
        ///离散化
        for(int i=1;i<=n;i++)
        {
            Hash[node[i].pos]=i;//第i个数排序后在Hash[i]位置
        }
        ///求逆序数
        long long ans=0;
        for(int i=1;i<=n;i++)
        {
            update(Hash[i]);
            ans= ans + i-getsum(Hash[i]);
        }
        printf("%lld\n",ans);
    }
    return 0;
}