Codeforces-1326E Bombs

Codeforces-1326E Bombs

You are given a permutation, (p_1, p_2, ldots, p_n).

Imagine that some positions of the permutation contain bombs, such that there exists at least one position without a bomb.

For some fixed configuration of bombs, consider the following process. Initially, there is an empty set, (A).

For each (i) from (1) to (n):

• Add (p_i) to (A).
• If the (i)-th position contains a bomb, remove the largest element in (A).

After the process is completed, (A) will be non-empty. The cost of the configuration of bombs equals the largest element in (A).

You are given another permutation, (q_1, q_2, ldots, q_n).

For each (1 leq i leq n), find the cost of a configuration of bombs such that there exists a bomb in positions (q_1, q_2, ldots, q_{i-1}).

For example, for (i=1), you need to find the cost of a configuration without bombs, and for (i=n), you need to find the cost of a configuration with bombs in positions (q_1, q_2, ldots, q_{n-1}).

Input

The first line contains a single integer, (n) ((2 leq n leq 300\,000)).

The second line contains (n) distinct integers (p_1, p_2, ldots, p_n) ((1 leq p_i leq n)).

The third line contains (n) distinct integers (q_1, q_2, ldots, q_n) ((1 leq q_i leq n)).

Output

Print (n) space-separated integers, such that the (i)-th of them equals the cost of a configuration of bombs in positions (q_1, q_2, ldots, q_{i-1}).

Examples

Input

3
3 2 1
1 2 3

Output

3 2 1 

Input

6
2 3 6 1 5 4
5 2 1 4 6 3

Output

6 5 5 5 4 1 

Note

In the first test:

• If there are no bombs, (A) is equal to ({1, 2, 3}) at the end of the process, so the cost of the configuration is (3).
• If there is one bomb in position (1), (A) is equal to ({1, 2}) at the end of the process, so the cost of the configuration is (2);
• If there are two bombs in positions (1) and (2), (A) is equal to ({1}) at the end of the process, so the cost of the configuration is (1).

In the second test:

Let's consider the process for (i = 4). There are three bombs on positions (q_1 = 5), (q_2 = 2), and (q_3 = 1).

At the beginning, (A = {}).

• Operation (1): Add (p_1 = 2) to (A), so (A) is equal to ({2}). There exists a bomb in position (1), so we should delete the largest element from (A). (A) is equal to ({}).
• Operation (2): Add (p_2 = 3) to (A), so (A) is equal to ({3}). There exists a bomb in position (2), so we should delete the largest element from (A). (A) is equal to ({}).
• Operation (3): Add (p_3 = 6) to (A), so (A) is equal to ({6}). There is no bomb in position (3), so we do nothing.
• Operation (4): Add (p_4 = 1) to (A), so (A) is equal to ({1, 6}). There is no bomb in position (4), so we do nothing.
• Operation (5): Add (p_5 = 5) to (A), so (A) is equal to ({1, 5, 6}). There exists a bomb in position (5), so we delete the largest element from (A). Now, (A) is equal to ({1, 5}).
• Operation (6): Add (p_6 = 4) to (A), so (A) is equal to ({1, 4, 5}). There is no bomb in position (6), so we do nothing.

In the end, we have (A = {1, 4, 5}), so the cost of the configuration is equal to (5).

题意

给定一个排列p,再给定一个q,表示了n颗炸弹,每次操作添加(q_1, q_2, ldots, q_{i-1})的炸弹,并向(A[])添加一个数(p_i),第(i)颗炸弹会在加入p中第(q_i)个元素的时候引爆,使(A[])中最大的元素消失,问每一次操作之后(A[])中最大的元素是多少

题解

显然第一次操作之后答案就是n,因为没有炸弹,答案为最大值.

注意到每添加一颗炸弹,炸弹的对应关系会基本打乱,所以正常维护不可能做到

可以观察到,每一次操作之后的答案是递减的,也就是说如果我们能快速算出能否使答案为(x)成立,就可以在(O(n*f(计算答案为x是否成立)))的复杂度内算出答案

我们要使答案x成立,就要炸掉所有(ge x)的值

我们维护一个数组,表示(i dots n 中 ge x的数量-炸弹的数量),如果对于每一个i这个值都满足(le 0)的话,就说明答案为(x)不成立 ,因为所有(ge x)的值都被炸掉了,我们令(x-1),同时加入值为(x-1)的数对数组的影响即可

这个数组用线段树维护即可,复杂度(O(nlogn))

代码

#include <bits/stdc++.h>
#define lson (o << 1)
#define rson (o << 1 | 1)
using namespace std;
typedef long long ll;
const int N = 3e5 + 50;
int p[N], q[N];
int pos[N];
int maxv[N << 2];
int addv[N << 2];
void pushup(int o) {
    maxv[o] = max(maxv[lson], maxv[rson]);
}
void pushdown(int o) {
    if (addv[o]) {
        addv[lson] += addv[o]; addv[rson] += addv[o];
        maxv[lson] += addv[o]; maxv[rson] += addv[o];
        addv[o] = 0; 
    }
}
void update(int o, int l, int r, int ql, int qr, int v) {
    if (ql <= l && r <= qr) {
        maxv[o] += v;
        addv[o] += v;
        return;
    }
    pushdown(o);
    int mid = (l + r) >> 1;
    if (ql <= mid) update(lson, l, mid, ql, qr, v);
    if (qr > mid) update(rson, mid + 1, r, ql, qr, v);
    pushup(o);
}
int main() {
    int n; scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%d", &p[i]), pos[p[i]] = i;
    for (int i = 1; i <= n; i++) scanf("%d", &q[i]);
    int ans = n; printf("%d", n);
    update(1, 1, n, 1, pos[ans], 1);
    for (int i = 1; i < n; i++) {
        update(1, 1, n, 1, q[i], -1);
        while (maxv[1] <= 0) {
            ans--;
            update(1, 1, n, 1, pos[ans], 1);
        }
        printf(" %d", ans);
    }
    return 0;
}