B. Swaps

B. Swaps

time limit per test1 second

memory limit per test256 megabytes

inputstandard input

outputstandard output

You are given two arrays aa and bb of length nn. Array aa contains each odd integer from 11 to 2n2n in an arbitrary order, and array bb contains each even integer from 11 to 2n2n in an arbitrary order.

You can perform the following operation on those arrays:

• choose one of the two arrays

• pick an index ii from 11 to n−1n−1

• swap the ii-th and the (i+1)(i+1)-th elements of the chosen array

Compute the minimum number of operations needed to make array aa lexicographically smaller than array bb.

For two different arrays xx and yy of the same length nn, we say that xx is lexicographically smaller than yy if in the first position where xx and yy differ, the array xx has a smaller element than the corresponding element in yy.

Input

Each test contains multiple test cases. The first line contains the number of test cases tt (1≤t≤1041≤t≤104).

The first line of each test case contains a single integer nn (1≤n≤1051≤n≤105) — the length of the arrays.

The second line of each test case contains nn integers a1,a2,…,ana1,a2,…,an (1≤ai≤2n1≤ai≤2n, all aiai are odd and pairwise distinct) — array aa.

The third line of each test case contains nn integers b1,b2,…,bnb1,b2,…,bn (1≤bi≤2n1≤bi≤2n, all bibi are even and pairwise distinct) — array bb.

It is guaranteed that the sum of nn over all test cases does not exceed 105105.

Output

For each test case, print one integer: the minimum number of operations needed to make array aa lexicographically smaller than array bb.

We can show that an answer always exists.

Example

input

Copy

3

2

3 1

4 2

3

5 3 1

2 4 6

5

7 5 9 1 3

2 4 6 10 8

output

Copy

0

2

3

Note

In the first example, the array aa is already lexicographically smaller than array bb, so no operations are required.

In the second example, we can swap 55 and 33 and then swap 22 and 44, which results in [3,5,1][3,5,1] and [4,2,6][4,2,6]. Another correct way is to swap 33 and 11 and then swap 55 and 11, which results in [1,5,3][1,5,3] and [2,4,6][2,4,6]. Yet another correct way is to swap 44 and 66 and then swap 22 and 66, which results in [5,3,1][5,3,1] and [6,2,4][6,2,4].

数组a是1到2n的奇数，数组b是1到2n的偶数

每次可以交换i与i+1位置上的数

使数组a在字典序上小于b

第一感觉是枚举符合规定的a，b的位置时间复杂度是O（n2)

呢如何降低时间复杂度

先对a，b数组从大到小排序

我们可以枚举b数组然后对a数组符合的取一个minn

具体看代码

#include<bits/stdc++.h> 
using namespace std;
#define int long long
int a[200005];
int b[200005];
int aa[200005];
signed main(){
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        for(int i=0;i<n;i++)
        {
            cin>>a[i];
            aa[a[i]]=i;
        }    
        for(int i=0;i<n;i++)
        {
            cin>>b[i];
            aa[b[i]]=i;
        }
        sort(a,a+n);
        sort(b,b+n);
        int minn=0x3f3f3f3f;
        int ans=0x3f3f3f3f;    
        
        for(int i=0;i<n;i++)
        {
            minn=min(minn,aa[a[i]]);
            ans=min(ans,minn+aa[b[i]]);
        }
        cout<<ans<<endl;
        
    }
}