CodeForces 1187D Subarray Sorting

Problem

You are given an array \(a_1\),\(a_2\),…,\(a_n\) and an array \(b_1\),\(b_2\),…,\(b_n\).

For one operation you can sort in non-decreasing order any subarray \(a[l…r]\) of the array \(a\).

For example, if \(a=[4,2,2,1,3,1]\) and you choose subbarray \(a[2…5]\), then the array turns into \([4,1,2,2,3,1]\).

You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array \(a\).

Input

The first line contains one integer \(t (1≤t≤3⋅10^5)\) — the number of queries.

The first line of each query contains one integer \(n (1≤n≤3⋅105)\).

The second line of each query contains \(n\) integers \(a_1,a_2,…,a_n (1≤a_i≤n)\).

The third line of each query contains n integers \(b_1,b_2,…,b_n (1≤b_i≤n)\).

It is guaranteed that \(\sum{n}≤3⋅10^5\) over all queries in a test.

Output

For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.

Example

Input

4

7

1 7 1 4 4 5 6

1 1 4 4 5 7 6

5

1 1 3 3 5

1 1 3 3 5

2

1 1

1 2

3

1 2 3

3 2 1

Output

YES

YES

NO

NO

Note

In first test case the can sort subarray \(a_1…a_5\), then a will turn into \([1,1,4,4,7,5,6]\), and then sort subarray \(a_5…a_6\).

感想

这题也过分，一定要发朋友圈博客。

OI带到这里的“坏”习惯——及时break。ACM里遍地都是多组数据，判断出一组答案，及时break之后，这一组还没读完读数据就被下一组读了，自然WA了。

这题调了一上午的原因就在于此——经验不足，以至于完全看不出我的代码及时break的问题。

另外，这是我的第一篇用markdown写的博客，markdown真好用。

解题思路

支持的操作是对子区间升序排序，这意味着，我们可以把一个区间内的最大值移动到该区间最右端，也可以把一个区间内的最小值移动到该区间最左端。

由于b是从左到右输入，对于每一个b，a也要将合适的数字左移，所以我们移动区间最小值到最左端。其实想一想不一定总是要到最左端，一个区间内的最小值可以左移到任意位置，还不会影响其他数字的顺序(每次排序最小值和最小值左边的第一个数，总共两个数)。

首先读入a数组，经过一堆后面会说的预处理(为了快速找到下文说的pos[b])，然后依次读入b。

对于每一个读入的b(假设是第i个)，寻找这个数字b在a中最早出现的位置（pos[b]）。

• 如果找到的位置为无穷，换句话说a里没有这个数，那么答案就是NO，就可以break了就可以把flag标记设置成false，然后读完剩下数据，输出NO。
• 如果找到了一个位置，那么我们的目标就是把这个b向前移动到位置i，由之前的思考可得，b需要是是a数组里下标i到pos[b]之间的最小值。
• 再进一步，能读入第i个b，说明前面i-1个位置已经匹配完成了，或前面或后面，已经有i-1个数被设置成了INF，一定大于b，不会影响我们。
• 考虑1到pos[b]这个区间，假设里面的情况这样 █ █ █ █ ▂ █ █b， █ 形象地代表大于等于b的数字，它们不会干扰我们左移b。 ▂ 形象地代表小于b的数字，当然还没被使用(使用了就被设置成INF了)，它会阻挡b左移，换句话说，b只能向左移动到 ▂ 的右边那段(或者不移动)。
  • 如果现在i在 ▂ 左边，或者说i到pos[b]的最小值小于b，那答案也就是NO了。
  • 如果现在i在 ▂ 右边，或者说i到pos[b]的最小值就是b，那么这次移动就可以完成。可是，完成这次以后，我们会发现， ▂ 还是在左边，没有被使用。由于a和b是同样长的，a、b含有不同数字的情况我们之前也排除了，所以在以后的时光里(雾)， ▂ 一定会被用到， ▂ 就需要被右移（把 ▂ 右边的左移），但是， ▂ 的右边至少有个b挡着啊，b比 ▂ 大， ▂ 不可能右移到目标位置的。
• 综上，1到pos[b]的区间内，如果最小值小于b，那答案无论如何都是NO。
• 类似的，我们也可以证明（其实是太晚了，想睡觉了），如果1到pos[b]内的最小值总是等于b，那么目标可以达成，答案是YES

然后完善一些小地方，区间最小值连上更新，就用线段树，挺方便。快速找pos[b]，思路类似莫队里经常出现的pos数组和nxt数组(SDOI2009 HH的项链)。另外，memset不要每组数组都全部清零，第18个测试点很变态（见代码59行）。

源代码

#include <stdio.h>
#include <string.h>
#include <algorithm>
int T;
int n;
int a[300010], nxt[300010], pos[300010];
struct Segtree
{
    int l, r;
    int min;
} s[1200010];
inline int lson(int x) { return x << 1; }
inline int rson(int x) { return x << 1 | 1; }
inline void pushup(int x) { s[x].min = std::min(s[lson(x)].min, s[rson(x)].min); }
void build(int x, int l, int r)
{
    s[x] = {l, r, 0};
    if (l == r)
    {
        s[x].min = a[l];
        return;
    }
    int mid = l + r >> 1;
    build(lson(x), l, mid);
    build(rson(x), mid + 1, r);
    pushup(x);
}
void update(int x, int position)
{
    if (position > s[x].r || position < s[x].l)
        return;
    if (s[x].l == s[x].r && s[x].l == position)
    {
        s[x].min = 0x7fffffff;
        return;
    }
    update(lson(x), position);
    update(rson(x), position);
    pushup(x);
}
int que(int x, int l, int r)
{
    if (r < s[x].l || l > s[x].r)
        return 0x7fffffff;
    if (l <= s[x].l && s[x].r <= r)
        return s[x].min;
    return std::min(que(lson(x), l, r), que(rson(x), l, r));
}

int main()
{
    //freopen("test.in","r",stdin);
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
            scanf("%d", a + i);
        memset(nxt, 0x7f, sizeof(int)*(n+2));//第18个测试点十分丧病，T是几十万，每组n是1
        memset(pos, 0x7f, sizeof(int)*(n+2));
        for (int i = n; i >= 1; i--)
        {
            nxt[i] = pos[a[i]];
            pos[a[i]] = i;
        }
        build(1, 1, n);
        bool ok = 1;
        for (int i = 1, b; i <= n; i++)
        {
            scanf("%d", &b);
            if(!ok) continue;//不要break，数据要读完
            if (pos[b] == 0x7f7f7f7f)
                ok = 0;
            if (que(1, 1, pos[b]) == b)
            {
                update(1, pos[b]);
                pos[b] = nxt[b];
            }
            else
                ok = 0;
        }
        puts(ok ? "YES" : "NO");
    }
    return 0;
}