NOIP2013提高组 T2 火柴排队

一开始看也想不到这居然要用到逆序对，归并排序。

先来看看题目：

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

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

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

样例输入：

样例输出：

　　根据样例，设第二行的数为a｛1，3，4，2｝，第三行的数为b｛1，7，2，4｝。对于题目要求通过交换使得两列火柴之间的的距离最小，满足这个要求只能使a中高度最小的火柴和b中高度最小的火柴搭配，第二小的和第二小的搭配。为了方便处理和后续的操作，把a和b进行离散化。离散化后，a｛1，3，4，2｝，b｛1，4，2，3｝（离散化详解在*1）。遍历数组a，查找a[i]在数组b中所对应的位置（详细处理在*2）（需要用二分查找*3），存入新数组R，处理后为R｛1，4，2，3｝，R[i]即为a[i]将要移到的位置，最小交换的次数正是R的逆序对数量。a中的3要移到R中3的位置，需要向右交换两次。相同的，可以这样认为，R中的3要向左移到a中的3的位置，则需要两次交换。R中3（即R[4]）的逆序对数量为2，整个R的逆序对数量也为2。所求最少交换次数就是R的逆序对数量。使用归并排序。

　　时间复杂度(大概)：O(7*(n log n))  离散化：4*(n log n) （ 4次快排）　　预处理二分查找+二分查找：2*(n log n)　　归并排序：(n log n)  绝对不会超时qwq

*1：离散化前：a｛1，3，4，2｝，b｛1，7，2，4｝，给每个数组的每一个数标上序号，按照数组内容带上序号一起排序，重新编号，再根据之前标上的序号排回来恢复原状。

原始状态：

a	1	3	4	2
序号	1	2	3	4

b	1	7	2	4
序号	1	2	3	4

按照数组内容排序：

a	1	2	3	4
序号	1	4	2	3

b	1	2	4	7
序号	1	3	4	2

重新编号：

a	1	2	3	4
序号	1	4	2	3

b	1	2	3	4
序号	1	3	4	2

按照序号重新排序恢复：

a	1	3	4	2
序号	1	2	3	4

b	1	4	2	3
序号	1	2	3	4

完成，a离散化后和原来一样是因为样例特殊，参考b的离散化过程就好了。

*2：a[i]在数组b中所对应的位置。首先列出数组。

a	1	3	4	2
b	1	4	2	3
序号	1	2	3	4
R

i=1的情况：a[i]为1，b中的1在b[1]中，b[1]对应的序号为1，所以R[i]为1，i=1，所以R[1]填上1。

i=2的情况：a[i]=3，b[4]=3，所以b中的3在b[4]，对应序号为4。R[2]填上4

i=3：a[i]=4，b[2]=4，所以R[i]=2，R[3]填上2

i=4：a[i]=2，b[3]=2，所以R[4]=3

最终得R为：

R

1

4

2

3

*3：如果查找a[i]在数组b中所对应的位置使用两重循环，则查找的时间复杂度为O(n^2)，数据范围为n<=100000，光是查找就会超时，所以需要用二分排序。

贴上代码详细参考：

 type
         arr=array[..] of longint;
 var
         a1,b1,a,r:arr;
         n,i,j:longint;
         left,right,mid:longint;
         ans:qword;
 procedure qsort(var a,b:arr);  //快排a数组，捆绑b数组
     procedure sort(l,r: longint);
       var
          i,j,x,y: longint;
       begin
          i:=l;
          j:=r;
          x:=a[(l+r) div ];
          repeat
            while a[i]<x do
             inc(i);
            while x<a[j] do
             dec(j);
            if not(i>j) then
              begin
                 y:=a[i];
                 a[i]:=a[j];
                 a[j]:=y;
                 y:=b[i];
                 b[i]:=b[j];
                 b[j]:=y;
                 inc(i);
                 dec(j);
              end;
          until i>j;
          if l<j then
            sort(l,j);
          if i<r then
            sort(i,r);
       end;
     begin
        sort(,n);
     end;
 procedure mergesort(s,t:longint);  //归并排序用来统计逆序对
 var
         mid,i,j,k:longint;
 begin
         if s=t then exit;
         mid:=(s+t) div ;
         mergesort(s,mid);
         mergesort(mid+,t);
         i:=s;
         j:=mid+;
         k:=s;
         while (i<=mid) and (j<=t) do
                 if a[i]<=a[j] then
                 begin
                         r[k]:=a[i];
                         inc(i);
                         inc(k);
                 end
                 else
                 begin
                         r[k]:=a[j];
                         inc(j);
                         inc(k);
                         ans:=ans+(mid-i+); //逆序对
                 end;
         while i<=mid do
         begin
                 r[k]:=a[i];
                 inc(i);
                 inc(k);
         end;
         while j<=t do
         begin
                 r[k]:=a[j];
                 inc(j);
                 inc(k);
         end;
         for i:=s to t do
                 a[i]:=r[i];
 end;
 begin
         assign(input,'match.in');
         assign(output,'match.out');
         reset(input);
         rewrite(output);
         readln(n);
         for i:= to n do
         begin
                 read(a1[i]);  //读入a数组
                 r[i]:=i;  //编号
         end;
         qsort(a1,r);  //按照数组内容排序
         for i:= to n do a1[i]:=i;  //重新编号   {离散化}
         qsort(r,a1);  //按照编号排序复原
         readln;
         for i:= to n do
         begin
                 read(b1[i]);  //读入b数组
                 r[i]:=i;  //编号
         end;
         qsort(b1,r);  //按照数组内容排序
         for i:= to n do b1[i]:=i;  //重新编号   {离散化}
         qsort(r,b1);  //按照编号排序复原

         {for i:=1 to n do  //处理a[i]在数组b中所对应的位置，使用两重循环，n到达1000时就会超时，所以舍弃
                 for j:=1 to n do
                         if b1[i]=a1[j] then
                         begin
                                 a[i]:=j;
                                 break;
                         end;  }

         for i:= to n do r[i]:=i;
         qsort(a1,r);  //按照内容排序
         for i:= to n do  //遍历每个b[i]查找在a中的位置（这里a和b交换了，所以是查找b[i]在a中的位置）
         begin
                 left:=;
                 right:=n;
                 mid:=(left+right) div ;
                 while (a1[mid]<>b1[i]) and (left<=right) do  //二分查找，时间复杂度O(n log n)
                 begin
                         if a1[mid]>b1[i] then right:=mid-
                         else left:=mid+;
                         mid:=(left+right) div ;
                 end;
                 a[i]:=r[mid]; //此处的a数组即为上面所讲的R数组
         end;
         ans:=;
         fillchar(r,sizeof(r),);
         mergesort(,n);  //归并排序统计逆序对
         writeln(ans mod );  //依照题意对99999997取模
         close(input);
         close(output);
 end.