Codeforces Round 935 (Div. 3) F. Kirill and Mushrooms（主席树求区间第k大值）

As soon as everyone in the camp fell asleep, Kirill sneaked out of the tent and went to the Wise Oak to gather mushrooms.

It is known that there are $n$ mushrooms growing under the Oak, each of which has magic power $v_i$. Kirill really wants to make a magical elixir of maximum strength from the mushrooms.

The strength of the elixir is equal to the product of the number of mushrooms in it and the minimum magic power among these mushrooms. To prepare the elixir, Kirill will sequentially pick one mushroom growing under the Oak. Kirill can gather mushrooms in any order.

However, it’s not that simple. The Wise Oak informed Kirill of a permutation of numbers $p$ from $1$ to $n$. If Kirill picks only $k$ mushrooms, then the magic power of all mushrooms with indices $p_1,p_2,\dots ,p_{k-1}$ will become $0$. Kirill will not use mushrooms with zero magic power to prepare the elixir.

Your task is to help Kirill gather mushrooms in such a way that he can brew the elixir of maximum possible strength. However, Kirill is a little scared to stay near the oak for too long, so out of all the suitable options for gathering mushrooms, he asks you to find the one with the minimum number of mushrooms.

A permutation of length $n$ is an array consisting of $n$ different integers from $1$ to $n$ in any order. For example, $[2,3,1,5,4]$ is a permutation, but $[1,2,2]$ is not a permutation ($2$ appears in the array twice) and $[1,3,4]$ is also not a permutation ($n=3$, but $4$ appears in the array).

Input

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

The first line of each test case contains a single integer $n$ ($1\le n\le 200000$) — the number of mushrooms.

The second line contains an array $v$ of size $n$ ($1\le v_i\le 10^9$) — the magic powers of the mushrooms.

The third line contains a permutation $p$ of numbers from $1$ to $n$.

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

For each test case, output two integers separated by a space — the maximum strength of the elixir that can be brewed and the minimum number of mushrooms that Kirill needs to use for this.
Example
input

6
3
9 8 14
3 2 1
5
1 2 3 4 5
1 2 3 4 5
6
1 2 3 4 5 6
6 5 4 3 2 1
5
1 4 6 10 10
2 1 4 5 3
4
2 2 5 5
4 2 3 1
5
1 2 9 10 10
1 4 2 3 5

output

6
3
9 8 14
3 2 1
5
1 2 3 4 5
1 2 3 4 5
6
1 2 3 4 5 6
6 5 4 3 2 1
5
1 4 6 10 10
2 1 4 5 3
4
2 2 5 5
4 2 3 1
5
1 2 9 10 10
1 4 2 3 5

Note

In the first example, you need to take the mushrooms with indices $1$ and $2$, so the strength of the elixir is equal to $2\cdot \min (a_1,a_2)=2\cdot \min (9,8)=2\cdot 8=16$. Note that the magic power of the mushroom with index $3$ after picking two mushrooms will become $0$.

大体题意
长度为 $n$ 的序列 $v$，以及一个长度为 $n$ 的序列 $p$ ,当取序列 $v$ 中 $k$ 个数时要保证这 $k$ 个数不属于 $p_{1,...,k-1}$ 。对于长度为 $k$ 的序列$a[1-k],\forall (i,j),1\le i<j\le kand{a}_i!=a_{j}and{a}_i,a_j\notin p$，其权值为 m i n { v a i } × k min\{v_{a_i}\} \times k min{vai​​}×k，求出权值最大的序列权值及其序列长度 $k$ 。

思路分析
首先我们很容易想到，当我们选 $k$ 个数时，我们能找到的序列一定从$a_{p_{k,...,n}}$中选到，那我们不妨将序列直接按照 $p$ 序列排一下序；

vector<int> p(n + 10), v(n + 10), a(n + 10);
for (int i = 1; i <= n; i++)
    a[i] = v[p[i]];

由此我们很容易想到的是要是权值最大，当我们要取 $k$ 个数时，我们一定是取当前可以取出当前可取数之中最大的前 $k$ 个数，也就是说我们只要找到序列 $a$ 对应的可取区间 $[k,n]$ 中的第 $k$ 大值并 $\times k$，即得此时权值的最大值，因此我们只需枚举一下 $k$ 即得答案(注意 $k$ 的取值范围是$[1,\lceil \frac{n}{2}\rceil ]$)。

代码

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

#define all(x) x.begin(), x.end()
#define bit1(x) __builtin_popcount(x)
#define Pqueue priority_queue
#define lc p << 1
#define rc p << 1 | 1
#define IOS ios::sync_with_stdio(false), cin.tie(0);
#define fi first
#define se second

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<ll, ll> PII;

const ll mod = 1000000007;
const ll N = 1e6 + 10;
const ld eps = 1e-9;
const ll inf = 1e18;
const ll P = 131;
const ll dir[8][2] = {1, 0, 0, 1, -1, 0, 0, -1, 1, 1, 1, -1, -1, 1, -1, -1};

struct Tree
{
    int l, r, sum;
} tr[N << 4];
int root[N], idx;

void insert(int &p, int t, int l, int r, int k)
{
    p = ++idx;
    tr[p] = tr[t];
    tr[p].sum = tr[t].sum + 1;
    if (l == r)
        return;
    int mid = l + r >> 1;
    if (k <= mid)
        insert(tr[p].l, tr[t].l, l, mid, k);
    else
        insert(tr[p].r, tr[t].r, mid + 1, r, k);
}
int query(int p, int t, int l, int r, int k)
{
    if (l == r)
        return l;
    int mid = l + r >> 1;
    int s = tr[tr[p].l].sum - tr[tr[t].l].sum;
    if (k <= s)
        return query(tr[p].l, tr[t].l, l, mid, k);
    return query(tr[p].r, tr[t].r, mid + 1, r, k - s);
}

void solve()
{
    idx = 0;
    int n;
    cin >> n;
    vector<int> a(n + 10), b(n + 10), c(n + 1);
    for (int i = 1; i <= n; i++)
        cin >> a[i], c[i] = a[i];
    for (int i = 1; i <= n; i++)
        cin >> b[i];
    vector<int> p(n + 10);
    for (int i = 1; i <= n; i++)
        p[i] = a[b[i]];
    sort(all(c));
    c.erase(unique(all(c)), c.end());
    int len = c.size() - 1;
    // cout << ":::";
    // for (int i = 1; i <= n; i++)
    //     cout << p[i] << " \n"[i == n];
    for (int i = 1; i <= n; i++)
    {
        int k = lower_bound(all(c), p[i]) - c.begin();
        insert(root[i], root[i - 1], 1, len, k);
    }
    ll mx = 0, mx_i = 0;
    for (int i = 1; i <= (n + 1) / 2; i++)
    {
        int k = n - (i - 1) * 2;
        int pos = query(root[n], root[i - 1], 1, len, k);
        // cout << c[pos] << " ";
        if (mx < 1ll * i * c[pos])
        {
            mx = 1ll * i * c[pos];
            mx_i = i;
        }
    }
    cout << mx << " " << mx_i << "\n";
}

int main()
{
    IOS int T = 1;
    cin >> T;
    while (T--)
        solve();
    return 0;
}

/*
oxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxox
x                                                                                      o
o       _/_/_/_/                                                              _/       x
x      _/                                                                              o
o     _/_/_/_/ _/  _/_/   _/_/   _/_/_/ _/_/   _/_/_/     _/_/    _/_/_/    _/ _/   _/ x
x    _/       _/_/     _/    _/ _/   _/   _/  _/    _/ _/    _/  _/    _/  _/   _/ _/  o
o   _/       _/       _/    _/ _/   _/   _/  _/    _/ _/    _/  _/    _/  _/    _/_/   x
x  _/       _/         _/_/   _/   _/   _/  _/_/_/     _/_/ _/ _/    _/  _/      _/    o
o                                          _/                           _/      _/     x
x                                         _/                        _/_/       _/      o
o                                                                                      x
xoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxo
*/```