【原題】

題目描述

涵涵有兩盒火柴，每盒裝有 n 根火柴，每根火柴都有一個高度。 現在將每盒中的火柴各自排成一列， 同一列火柴的高度互不相同， 兩列火柴之間的距離定義為：$∑(ai−bi)^2 $

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

每列火柴中相鄰兩根火柴的位置都可以交換，請你通過交換使得兩列火柴之間的距離最小。請問得到這個最小的距離，最少需要交換多少次？如果這個數字太大，請輸出這個最小交換次數對 \(10^8-3\) 取模的結果。

輸入格式

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

第二行有 n 個整數，每兩個整數之間用一個空格隔開，表示第一列火柴的高度。

第三行有 n 個整數，每兩個整數之間用一個空格隔開，表示第二列火柴的高度。

輸出格式

一個整數，表示最少交換次數對 \(10^8−31\) 取模的結果。

輸入輸出樣例

輸入 #1

4
2 3 1 4
3 2 1 4

輸出 #1

1

輸入 #2

4
1 3 4 2
1 7 2 4

輸出 #2

2

說明/提示

【輸入輸出樣例說明一】

最小距離是0，最少要交換 1 次，比如：交換第 1 列的前 2 根火柴或者交換第 2 列的前 2 根火柴。

【輸入輸出樣例說明二】

最小距離是 10 ，最少需要交換 2 次，比如：交換第 1 列的中間 2 根火柴的位置，再交換第 2 列中後 2 根火柴的位置。

【資料範圍】

對於 10% 的資料， \(1≤n≤10\)；

對於 30% 的資料，\(1≤n≤100\)；

對於 60% 的資料，\(1≤n≤10^3\)；

對於 100% 的資料，\(1≤n≤10^5\)；，\(0≤\) 火柴高度 < \(2^{31}\)。

【思路】

要使得火柴距離最小，每個位置的火柴長度在自己序列的排名應該相等。離散化處理出火柴在自己序列的排名。存下陣列a每個排名的位置，對應到陣列b中，逆序對個數即最小交換次數。（對應位置的思想和P1439一致，都是把a陣列變為1, 2, 3......n再和b陣列比對）

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <list>
#include <map>
#include <iostream>
#include <iomanip>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define LL long long
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f
#define PI 3.1415926535898
#define F first
#define S second
#define endl '\n'
#define lson  rt << 1
#define rson  rt << 1 | 1
#define f(x, y, z) for (int x = (y), __ = (z); x < __; ++x)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
using namespace std;

const int maxn = 1e5 + 7;
const int maxm = 1e9 + 7;
const int mod = 1e8 - 3;
int n, m;
int a[maxn], b[maxn], tmp[maxn], c[maxn], d[maxn];

int tree[maxn * 4], lz[maxn * 4];
void add(int n, int index, int L, int R, int rt)
{
	if (L == R)
	{
		tree[rt] += n;
		return;
	}
	int mid = (L + R) / 2;
	if (index <= mid) add(n, index, L, mid, lson);
	else add(n, index, mid + 1, R, rson);
	tree[rt] = tree[lson] + tree[rson];
}

void push_down(int rt, int l, int r) {
	if (lz[rt]) {
		int mid = (l + r) / 2;
		lz[lson] += lz[rt];
		lz[rson] += lz[rt];
		tree[lson] += 1LL * (mid - l + 1) * lz[rt];
		tree[rson] += 1LL * (r - mid) * lz[rt];
		lz[rt] = 0;
	}
}

void update_range(int rt, int l, int r, int L, int R, int add) {
	if (l <= L && r >= R) {
		lz[rt] += 1LL * add;
		tree[rt] += 1LL * (R - L + 1) * add;
		return;
	}
	push_down(rt, L, R);
	int mid = (L + R) / 2;
	if (mid >= l) update_range(lson, l, r, L, mid, add);
	if (mid < r) update_range(rson, l, r, mid + 1, R, add);
	tree[rt] = (tree[lson] + tree[rson]) % mod;
}

LL query_range(int rt, int l, int r, int L, int R) {
	if (l <= L && r >= R) return tree[rt];
	push_down(rt, L, R);
	int mid = (L + R) / 2;
	LL sum = 0;
	if (mid >= l) sum = (sum + query_range(lson, l, r, L, mid)) % mod;
	if (mid < r) sum = (sum + query_range(rson, l, r, mid + 1, R)) % mod;
	return sum;
}


int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n;
	_rep(i, 1, n)
	{
		cin >> a[i];
		tmp[i] = a[i];
	}
	sort(tmp + 1, tmp + 1 + n);
	_rep(i, 1, n)
	{
		a[i] = lower_bound(tmp + 1, tmp + n + 1, a[i]) - tmp;
		c[a[i]] = i;
	}
	_rep(i, 1, n)
	{
		cin >> b[i];
		tmp[i] = b[i];
	}
	sort(tmp + 1, tmp + 1 + n);
	_rep(i, 1, n)
	{
		d[i] = lower_bound(tmp + 1, tmp + 1 + n, b[i]) - tmp;
		d[i] = c[d[i]];
	}
	LL ans = 0;
	_rep(i, 1, n)
	{
		ans = (ans + query_range(1, d[i], n, 1, n)) % mod;
		add(1, d[i], 1, n, 1);
	}
	cout << ans << endl;
}