火柴排队

Posted 2022-12-26 aprincess

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了火柴排队相关的知识，希望对你有一定的参考价值。

题目描述

涵涵有两盒火柴，每盒装有 $两列火柴之间的距离定义为：∑(a_i-b_i)^2$

其中 $a_i 表示第一列火柴中第i个火柴的高度，b_i?表示第二列火柴中第 i 个火柴的高度。$

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

输入格式

共三行，第一行包含一个整数

第二行有

第三行有

输出格式

一个整数，表示最少交换次数对

输入输出样例

输入 #1

4
2 3 1 4
3 2 1 4

输出 #1

输入 #2

4
1 3 4 2
1 7 2 4

输出 #2

说明/提示

【输入输出样例说明1】

最小距离是

【输入输出样例说明2】

最小距离是

【数据范围】

对于 $10\%的数据， 1 ≤ n ≤ 10；$

对于 $30\%的数据，1 ≤ n ≤ 100；$

对于 $60\%的数据，1 ≤ n ≤ 1,000；$

对于 $100\%的数据，1 ≤ n ≤ 100,000,0 ≤火柴高度≤ maxlongint$

引导：

首先看到这道题我们，我们先好好动下脑经想：如何排序火柴才能将∑(a_i−b_i)^2 最大值求出来。

思路：

所以我们应该容易想到将两个队列先进行排序，比如说将两个队列的最大的元素对齐，次大的元素对齐，以此类推，就可以发现 | a - b | 的值就会是最小的，那么这样 ∑(a_i−b_i)^2的值是最小的。

这里我们提供两种代码：线段树和树状数组（~~其实是同一种思想~~）

如何实现代码：

使用是树状数组时前面的模板是通用的，然后主函数理只需要将两个数组排序，再进行前面说到的匹配，就好了。
使用线段树时，也是一样先模板敲好，接下来最最关键的就是离散化，观察题目，我们可以发现，所谓的求最少次数交换位置，因为离散化好后，不就是求这个数组中的逆序对？于是，代码就明确了！

何谓离散化？离散化就是不在乎这个数组内具体某一个值的大小（在这里我们称之为绝对数值），而是在乎这个数组内的相对大小（相对数值，也可以理解为排序后的排名）。比如下面有两个数组

A ：100 200 399 488

B ：938 132 144 77

在这里我们可以看到A【1】 = 488，A【2】 = 399，以此类推，说明A数组的离散化后 488** 所对应的值就是 1。 B 数组同理。

那么我们就可以很轻松的敲出代码即可。

若还是有不懂离散化的，下面代码里有详解。

（个人意见：跟着代码走更好理解。）

华丽丽的分割线

树状数组：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define mod 99999997
using namespace std;
typedef long long LL;
int n, ans;
int c[1000009], d[1000009];
int a[1000009], b[1000009];
int q[1000009];
bool cmp1(int i, int j) return a[i] < a[j];
bool cmp2(int i, int j) return b[i] < b[j];

namespace Tree
    int low[1000009];

    LL lowbit(LL x) return -x&x;

    LL sum(LL x)
        LL ret = 0;
        while (x > 0)
            ret += low[x];
            x -= lowbit(x);
        
        return ret;
    

    void add(LL x, LL d)
        while (x <= n)
            low[x] += d;
            x += lowbit(x);
           
    

using namespace Tree;

void solve()

    ans = 0;
    for (int i = n; i >= 1; i--)
        ans += sum(q[i] - 1);
        add(q[i], 1);
        if (ans >= mod) ans -= mod;
    
    printf("%d", (ans % mod + mod) % mod);


int main()

    scanf("%d", &n);
    for (int i = 1; i <= n; i++)    scanf("%d", &a[i]), c[i] = i;
    for (int i = 1; i <= n; i++)    scanf("%d", &b[i]), d[i] = i;
    sort(c + 1, c + n + 1, cmp1);
    sort(d + 1, d + n + 1, cmp2);
    memset(q, 0, sizeof(q));
    for (int i = 1; i <= n; i++)
        q[c[i]] = d[i];
    
    solve();
    return 0;

线段树：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cmath>
#include<set>
#include<cstring>
using namespace std;
//head
//时间复杂度: O(nlogn)
//这个题目又是求逆序对的。。。
#define lsn l,mid,rt<<1
#define rsn mid+1,r,rt<<1|1
const int N = 1000005;
const int mod = 99999997;
int n;
int v[N], a[N], b[N], c[N], pos[N], tree[N<<2];
void add(int l, int r, int rt, int p, int v)
    if(l == r)
        tree[rt] += v;
        return;
    
    int mid = (l + r) >> 1;
    if(p <= mid) add(lsn, p, v);
    else add(rsn, p, v);
    tree[rt] = tree[rt<<1|1] + tree[rt<<1];

int query(int l, int r, int rt, int p)
    if(r <= p) return tree[rt];
    if(l > p) return 0;
    int ans = 0;
    int mid = (l + r) >> 1;
    ans += query(lsn, p);
    ans += query(rsn, p);
    return ans;

int main()
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i)
        scanf("%d", a+i);
        v[i] = a[i];
    
    sort(v+1, v+n+1);
    for(int i = 1; i <= n; ++i)
         a[i] = lower_bound(v+1, v+n+1, a[i]) - v;  //离散化，就是我们只需要a[i]中每个元素的相对排名，并不关心它们的具体的数值大小
         pos[a[i]] = i;                         //记录排名第a[i]的位置
    
    for(int i = 1; i <= n; ++i)
        scanf("%d", b+i);
        v[i] = b[i];
    
    sort(v+1, v+n+1);
    for(int i = 1; i <= n; ++i) b[i] = lower_bound(v+1, v+n+1, b[i]) - v;   //同样对b数组进行离散化
    for(int i = 1; i <= n; ++i)
        c[i] = pos[b[i]];               //用c数组来表示b数组中的第i个元素 应该放置的位置
    
    //求逆序对
    long long ans = 0;
    for(int i = 1; i <= n; ++i)
        int num = query(1, n, 1, c[i]);
        ans = (ans + i - 1 - num) % mod;
        add(1, n, 1, c[i], 1);
    
    printf("%lld\n", ans);
    return 0;