【刷题】洛谷 P1966 火柴排队

题目描述

涵涵有两盒火柴，每盒装有 n 根火柴，每根火柴都有一个高度。 现在将每盒中的火柴各自排成一列， 同一列火柴的高度互不相同， 两列火柴之间的距离定义为： ∑(ai-bi)^2

其中 ai 表示第一列火柴中第 i 个火柴的高度，bi 表示第二列火柴中第 i 个火柴的高度。

每列火柴中相邻两根火柴的位置都可以交换，请你通过交换使得两列火柴之间的距离最小。请问得到这个最小的距离，最少需要交换多少次？如果这个数字太大，请输出这个最小交换次数对 99,999,997 取模的结果。

输入输出格式

输入格式：

输入文件为 match.in。

共三行，第一行包含一个整数 n，表示每盒中火柴的数目。

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

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

输出格式：

输出文件为 match.out。

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

输入输出样例

输入样例#1：

【输入输出样例 1】
4
2 3 1 4
3 2 1 4
【输入输出样例 2】
4
1 3 4 2
1 7 2 4

输出样例#1：

【输入输出样例 1】
1
【输入输出样例 2】
2

说明

【输入输出样例说明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 ≤火柴高度≤ maxlongint

题解

刚做完POJ上一道逆序对的题，然后来看这道题，居然误打误撞有了思路。

首先我们看数据，对于：

1 5 6 8

2 8 4 5

我们知道，对于每个序列，只有第一小和第一小搭配一起、第二小和第二小搭配一起……这样公式计算出来的总和才最小，所以我们不妨把两行数据离散化，方便我们思考，于是序列变成了这样：

1 2 3 4

1 4 2 3

那么下一步应该做什么呢？不着急，我们先来看另外一个例子：

1 2 4 3 5

1 2 3 4 5

这个例子我们一看就知道只要移动一次是吧，所以答案就是1，那么我们是怎么看出来的呢？首先每一行的1和2和5都已经两相搭配，并且在各序列的最前面或最后面，那么我们知道，对于每行序列，最前面或最后面如果有已经搭配好的，我们就可以不要管它了，程序中我们只要从最前面往后扫，如果不一样记录下位置，同理再从最后面往前扫一遍，我们只要管中间的一部分就可以了，因此之前的数据可以简化成这样：

2 3 4

4 2 3

接下来，我们以第二行为标准，就知道，我们的任务的实质就是要把一行数字2 3 4移动最少的次数变成4 2 3，很多人已经想到逆序对了，但我们还需要一个步骤：重新标号。既然我们以第二行为标准，那么我们就可以记录4的标准是1，2的标准是2，3的标准是3，使第二行序列变成1 2 3，那么第一行就变成了2 3 1，到这里，不就是最普通的求逆序对了吗？所以归并一下，就出答案了。

 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 using namespace std;
 const int MAXN=+,mod=;
 int n,Dis[MAXN],P[MAXN],Ans[MAXN],temp[MAXN],ans;
 struct node{
     int x;
     int id;
 };
 node A[MAXN],B[MAXN];
 inline void read(int &x)
 {
     int data=,w=;
     char ch=;
     while(ch!='-'&&(ch<''||ch>''))ch=getchar();
     if(ch=='-')w=-,ch=getchar();
     while(ch>=''&&ch<='')data=(data<<)+(data<<)+(ch^''),ch=getchar();
     x=data*w;
 }
 inline int comp1(const node&i,const node&j)
 {
     return i.x<j.x;
 }
 inline int comp2(const node&i,const node&j)
 {
     return i.id<j.id;
 }
 inline void margesort(int left,int right)
 {
     if(left==right)return ;
     int mid=(left+right)/;
     margesort(left,mid);
     margesort(mid+,right);
     int i=left,j=mid+,k=left;
     while(i<=mid&&j<=right)
     {
         if(Ans[i]<Ans[j])temp[k++]=Ans[i++];
         else
         {
             temp[k++]=Ans[j++];
             ans=(ans+mid-i+)%mod;
         }
     }
     while(i<=mid)temp[k++]=Ans[i++];
     while(j<=right)temp[k++]=Ans[j++];
     for(register int p=left;p<=right;++p)Ans[p]=temp[p];
 }
 int main()
 {
     read(n);
     for(register int i=;i<=n;++i)
     {
         read(A[i].x);A[i].id=i;
     }
     sort(A+,A+n+,comp1);
     for(register int i=;i<=n;++i)
     {
         read(B[i].x);B[i].id=i;
     }
     sort(B+,B+n+,comp1);
     for(register int i=;i<=n;++i)
     {
         A[i].x=i;B[i].x=i;
     }
     sort(A+,A+n+,comp2);
     sort(B+,B+n+,comp2);
     int pos=,head,tail;
     for(register int i=;i<=n;++i)
     {
         if(A[i].x!=B[i].x)
         {
             head=i;
             break;
         }
     }
     for(register int i=n;i>=;--i)
     {
         if(A[i].x!=B[i].x)
         {
             tail=i;
             break;
         }
     }
     for(register int i=head;i<=tail;++i)
     {
         P[++pos]=A[i].x;
         Dis[B[i].x]=pos;
     }
     for(register int i=;i<=pos;++i)Ans[i]=Dis[P[i]];
     margesort(,pos);
     printf("%d",ans%mod);
     return ;
 }

P1966 火柴排队