C. Heavy Intervals

You have $n$ intervals $[l_1, r_1], [l_2, r_2], \dots, [l_n, r_n]$, such that $l_i < r_i$ for each $i$, and all the endpoints of the intervals are distinct.

The $i$-th interval has weight $c_i$ per unit length. Therefore, the weight of the $i$-th interval is $c_i \cdot (r_i - l_i)$.

You don't like large weights, so you want to make the sum of weights of the intervals as small as possible. It turns out you can perform all the following three operations:

• rearrange the elements in the array $l$ in any order;
• rearrange the elements in the array $r$ in any order;
• rearrange the elements in the array $c$ in any order.

However, after performing all of the operations, the intervals must still be valid (i.e., for each $i$, $l_i < r_i$ must hold).

What's the minimum possible sum of weights of the intervals after performing the operations?

Input

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^4$). The description of the test cases follows.

The first line of each test case contains a single integer $n$ ($1 \le n \le 10^5$) — the number of intervals.

The second line of each test case contains $n$ integers $l_1, l_2, \ldots, l_n$ ($1 \le l_i \le 2 \cdot 10^5$) — the left endpoints of the initial intervals.

The third line of each test case contains $n$ integers $r_1, r_2, \ldots, r_n$ ($l_i < r_i \le 2 \cdot 10^5$) — the right endpoints of the initial intervals.

It is guaranteed that $\{l_1, l_2, \dots, l_n, r_1, r_2, \dots, r_n\}$ are all distinct.

The fourth line of each test case contains $n$ integers $c_1, c_2, \ldots, c_n$ ($1 \le c_i \le 10^7$) — the initial weights of the intervals per unit length.

It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.

Output

For each test case, output a single integer: the minimum possible sum of weights of the intervals after your operations.

Example

input

2
2
8 3
12 23
100 100
4
20 1 2 5
30 4 3 10
2 3 2 3

output

2400
42

Note

In the first test case, you can make

• $l = [8, 3]$;
• $r = [23, 12]$;
• $c = [100, 100]$.

In that case, there are two intervals:

• interval $[8, 23]$ with weight $100$ per unit length, and $100 \cdot (23-8) = 1500$ in total;
• interval $[3, 12]$ with weight $100$ per unit length, and $100 \cdot (12-3) = 900$ in total.

The sum of the weights is $2400$. It can be shown that there is no configuration of final intervals whose sum of weights is less than $2400$.

In the second test case, you can make

• $l = [1, 2, 5, 20]$;
• $r = [3, 4, 10, 30]$;
• $c = [3, 3, 2, 2]$.

In that case, there are four intervals:

• interval $[1, 3]$ with weight $3$ per unit length, and $3 \cdot (3-1) = 6$ in total;
• interval $[2, 4]$ with weight $3$ per unit length, and $3 \cdot (4-2) = 6$ in total;
• interval $[5, 10]$ with weight $2$ per unit length, and $2 \cdot (10-5) = 10$ in total;
• interval $[20, 30]$ with weight $2$ per unit length, and $2 \cdot (30-20) = 20$ in total.

The sum of the weights is $42$. It can be shown that there is no configuration of final intervals whose sum of weights is less than $42$.

解题思路

  首先为了使得分数最小，根据排序不等式应该让数组 $c$ 以值为关键字，区间以长度为关键字，一个升序另外一个降序，然后对应项相乘并对乘积的结果求和。

  另外容易知道对于任意合法的区间构造方案（即区间的右端点大于左端点），区间的总长度是一个定值 $\sum\limits_{i=1}^{n}{r_i} - \sum\limits_{i=1}^{n}{l_i}$。因此在这个前提下，应该如何构造区间才能使得分数最小。

  考虑例子 $l = [1, 2], \, r = [3, 5], \, c = [1, 2]$。有两种构造方案，分别是 $[1, 3]$ 和 $[2, 5]$，对应的分数是 $(5 - 2) \cdot 1 + (3 - 1) \cdot 2 = 7$。另外一种是 $[1, 5]$ 和 $[2, 3]$，对应的分数是 $(5 - 1) \cdot 1 + (3 - 2) \cdot 2 = 6$。很明显第二种方案会更优，可以发现第一种方案中两个区间是相交的（非包含），而第二种方案的区间是包含的，可以证明把两个相交的区间变成包含关系，分数会变小。

  假设现在有两个区间 $[l_1, r_1]$ 和 $[l_2, r_2]$，并且满足 $l_1 < l_2 < r_1 < r_2$，$r_1 - r_1 \leq r_2 - l_2$，$c_1 \leq c_2$，那么此时分数是 $(r_2 - l_2) \cdot c_1 + (r_1 - l_1) \cdot c_2 \ldots (1)$。将 $r_1$ 和 $r_2$ 交换，区间变成包含关系，分数变成了 $(r_2 - l_1) \cdot c_1 + (r_1 - l_2) \cdot c_2 \ldots (2)$。令 $(1) - (2)$ 得到 $(l_2 - l_1) \cdot (c_2 - c_1) \geq 0$，得证。

  因此只要存在两个区间是非包含的相交关系，则将其变成包含关系，那么最后得到的 $n$ 个区间中的任意两个区间都满足包含关系。要得到这些区间的方法是把所有的 $l_i$ 和 $r_i$ 放到一起排序，从小到大枚举，如果发现是左端点的值，则将其压入栈中，如果是右端点的值，则与栈顶元素匹配变成一个区间，并把栈顶元素弹出。最后把得到的 $n$ 个区间按长度排序，与数组 $c$ 对应项相乘并求和即可。

  AC 代码如下，时间复杂度为 $O(n \log{n})$：

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

typedef long long LL;

const int N = 1e5 + 10;

int a[N], b[N], c[N], p[N];
int stk[N];

void solve() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", a + i);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", b + i);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", c + i);
    }
    sort(a, a + n);
    sort(b, b + n);
    sort(c, c + n);
    for (int i = 0, j = 0, k = 0, tp = 0; k < n; ) {
        if (i < n && a[i] < b[j]) stk[++tp] = a[i++];
        else p[k++] = b[j++] - stk[tp--];
    }
    sort(p, p + n, greater<int>());
    LL ret = 0;
    for (int i = 0; i < n; i++) {
        ret += 1ll * p[i] * c[i];
    }
    printf("%lld\n", ret);
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }
    
    return 0;
}

参考资料

  Editorial of Codeforces Round 917 (Div. 2)：https://codeforces.com/blog/entry/123721

  Codeforces Pinely Round 3 讲解（ABCDF1)：https://www.bilibili.com/BV1iG411k7vX