洛谷題單指南-分治與倍增-P1966 [NOIP2013 提高組] 火柴排隊

原題連結：https://www.luogu.com.cn/problem/P1966

題意解讀：計算兩個序列∑(ai​−bi​)^2的最小值，對10^8-3取模。

解題思路：

1、貪心思路

要使得兩個序列對應位置元素之差的平方和最小，必須滿足兩個序列相對排序是一致的，什麼意思？

設a序列有兩個元素：a1，a2，b序列有兩個元素b1，b2

當a1<a2，b1<b2時，(a1-b1)^2 + (a2-b2)^2是最小的！

為什麼？

可以分析，如果a1<a2 b1>b2，

令：A = (a1-b1)^2 + (a2-b2)^2，B = (a1-b2)^2 + (a2-b1)^2

將A，B展開，相減

B - A = 2a1b1+2a2b2-2a1b2-2a2b1 = 2a1(b1-b2)-2a2(b1-b2)=2(a1-a2)(b1-b2) < 0

所以B更小，也就是b1,b2交換位置之後，再a1,a2計算距離會更小

所以得出結論：兩個序列的相對順序保持一致是，對應元素之差的平方和最小。

2、逆序對求解

有了以上結論，就可以固定一個序列為標準順序，然後求將另外一個序列轉換成標準順序需要交換的次數

標準順序要定義為升序1~n的，另外一個序列轉成1~n需要的交換次數就是其逆序對個數。

下面模擬樣例：

序列1：1 3 4 2

序列2：1 7 2 4

如果以序列1為基準，先要將序列1的元素進行離散化，這裡正好是1~4四個數字，離散化之後也保持不變，我們對每一個元素給定一個序號，已序號的位置為標準順序

值	1	3	4	2
序號	1	2	3	4

再對序列2進行離散化處理

原值	1	7	2	4
離散化後值	1	4	2	3
序號	1	2	3	4
離散化後值在序列1中的序號	1	3	4	2

接下來，我們的目標是要將

轉換為

只需要計算1 3 4 2的逆序對數，即為2。

100分程式碼：

#include <bits/stdc++.h>
using namespace std;

const int N = 100005, MOD = 1e8 - 3;

struct node 
{
    int value, idx;
};
int n;
long long ans;
node a[N], b[N];
int h[N], c[N];

bool cmp_value(node x, node y)
{
    return x.value < y.value;
}

bool cmp_idx(node x, node y)
{
    return x.idx < y.idx;
}

void merge(int s1, int e1, int s2, int e2)
{
    int i = s1, j = s2;
    int tmp[e2 - s1 + 1], cnt = 0;
    while(i <= e1 && j <= e2)
    {
        if(c[i] <= c[j]) tmp[++cnt] = c[i++];
        // 如果c[i] > c[j]，則c[i]~c[e1]都會比c[j]大，對逆序對的貢獻增加了e1 - i + 1個
        else tmp[++cnt] = c[j++], ans += e1 - i + 1; 
    } 
    while(i <= e1) tmp[++cnt] = c[i++];
    while(j <= e2) tmp[++cnt] = c[j++];
    for(int k = 1; k <= cnt; k++) c[k + s1 - 1] = tmp[k];
}

void merge_sort(int l, int r)
{
    if(l >= r) return;
    int mid = (l + r) / 2;
    merge_sort(l, mid);
    merge_sort(mid + 1, r);
    merge(l, mid, mid + 1, r);
}

int main()
{
    cin >> n;
    for(int i = 1; i <= n; i++) 
    {
        cin >> a[i].value;
        a[i].idx = i;
    }
    sort(a + 1, a + n + 1, cmp_value);
    for(int i = 1; i <= n; i++) a[i].value = i; //把數值按順序離散化處理
    
    for(int i = 1; i <= n; i++) h[a[i].value] = a[i].idx; //儲存value-idx的對映關係

    for(int i = 1; i <= n; i++)
    {
        cin >> b[i].value;
        b[i].idx = i;
    } 
    sort(b + 1, b + n + 1, cmp_value);
    for(int i = 1; i <= n; i++) b[i].value = i; //把數值按順序離散化處理
    sort(b + 1, b + n + 1, cmp_idx); //還原為原來的順序
    for(int i = 1; i <= n; i++) c[i] = h[b[i].value]; //c陣列是將b的value替換為同樣數值在a中對應的idx

    //計算c中的逆序對
    merge_sort(1, n);
    cout << ans % MOD;

    return 0;
}