Codeforces Round 923 (Div. 3) A B C D E

A. Make it White

time limit per test: 2 second memory limit per test: 256 megabytes input: standard input output: standard output

You have a horizontal strip of $n$ cells. Each cell is either white or black.

You can choose a continuous segment of cells once and paint them all white. After this action, all the black cells in this segment will become white, and the white ones will remain white.

What is the minimum length of the segment that needs to be painted white in order for all $n$ cells to become white?

Input

The first line of the input contains a single integer $t$ ($1\le t\le 10^4$) — the number of test cases. The descriptions of the test cases follow.

The first line of each test case contains a single integer $n$ ($1\le n\le 10$) — the length of the strip.

The second line of each test case contains a string $s$, consisting of $n$ characters, each of which is either ‘W’ or ‘B’. The symbol ‘W’ denotes a white cell, and ‘B’ — a black one. It is guaranteed that at least one cell of the given strip is black.

Output

For each test case, output a single number — the minimum length of a continuous segment of cells that needs to be painted white in order for the entire strip to become white.

Example

input

8
6
WBBWBW
1
B
2
WB
3
BBW
4
BWWB
6
BWBWWB
6
WWBBWB
9
WBWBWWWBW

output

4
1
1
2
4
6
4
7

Note

In the first test case of the example for the strip “WBBWBW”, the minimum length of the segment to be repainted white is $4$. It is necessary to repaint to white the segment from the $2$-nd to the $5$-th cell (the cells are numbered from $1$ from left to right).

Tutorial

由于只能选择一次连续的单元格段，所以必须一次包含所有的 B，此时记录最左边的 B 的位置和最右边 B 的位置即可，时间复杂度 $O(n)$

Solution

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

#define endl '\n'
#define int long long

void solve() {
    int n;
    string s;
    cin >> n >> s;
    int mn = INF, mx = 0;
    for (int i = 0; i < n; ++i) {
        if (s[i] == 'B') {
            mn = min(mn, i);
            mx = max(mx, i);
        }
    }
    cout << mx - mn + 1 << endl;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

---

B. Following the String

time limit per test: 2 second memory limit per test: 256 megabytes input: standard input output: standard output

Polycarp lost the string $s$ of length $n$ consisting of lowercase Latin letters, but he still has its trace.

The trace of the string $s$ is an array $a$ of $n$ integers, where $a_i$ is the number of such indices $j$ ($j<i$) that $s_i=s_j$. For example, the trace of the string abracadabra is the array [$0,0,0,1,0,2,0,3,1,1,4$].

Given a trace of a string, find any string $s$ from which it could have been obtained. The string $s$ should consist only of lowercase Latin letters a-z.

Input

The first line of the input contains a single integer $t$ ($1\le t\le 10^4$) — the number of test cases. Then the descriptions of the test cases follow.

The first line of each test case contains a single integer $n$ ($1\le n\le 2\cdot 10^5$) — the length of the lost string.

The second line of each test case contains $n$ integers $a_1,a_2,\dots ,a_n$ ($0\le a_i<n$) — the trace of the string. It is guaranteed that for the given trace, there exists a suitable string $s$.

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

Output

For each test case, output a string $s$ that corresponds to the given trace. If there are multiple such strings $s$, then output any of them.

The string $s$ should consist of lowercase Latin letters a-z.

It is guaranteed that for each test case, a valid answer exists.

Example

input

5
11
0 0 0 1 0 2 0 3 1 1 4
10
0 0 0 0 0 1 0 1 1 0
1
0
8
0 1 2 3 4 5 6 7
8
0 0 0 0 0 0 0 0

output

abracadabra
codeforces
a
aaaaaaaa
dijkstra

Tutorial

题目已经表明必定存在有效的答案了，所以只需要在每个位置遍历 a ~ z，找出符合出现次数要求的字母加到答案中即可，时间复杂度 $O(n)$

Solution

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

#define endl '\n'
#define int long long

void solve() {
    int n;
    string ans = "";
    cin >> n;
    vector<int> a(n);
    map<char, int> mp;
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        for (char c = 'a'; c <= 'z'; ++c) {
            if (mp[c] == x) {
                ans += c;
                ++mp[c];
                break;
            }
        }
    }
    cout << ans << endl;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

---

C. Choose the Different Ones!

time limit per test: 2 second memory limit per test: 256 megabytes input: standard input output: standard output

Given an array $a$ of $n$ integers, an array $b$ of $m$ integers, and an even number $k$.

Your task is to determine whether it is possible to choose exactly $\frac{k}{2}$ elements from both arrays in such a way that among the chosen elements, every integer from $1$ to $k$ is included.

For example:

• If $a=[2,3,8,5,6,5]$, $b=[1,3,4,10,5]$, $k=6$, then it is possible to choose elements with values $2,3,6$ from array $a$ and elements with values $1,4,5$ from array $b$. In this case, all numbers from $1$ to $k=6$ will be included among the chosen elements.
• If $a=[2,3,4,5,6,5]$, $b=[1,3,8,10,3]$, $k=6$, then it is not possible to choose elements in the required way.

Note that you are not required to find a way to choose the elements — your program should only check whether it is possible to choose the elements in the required way.

Input

The first line of the input contains a single integer $t$ ($1\le t\le 10^4$) — the number of test cases. The descriptions of the test cases follow.

The first line of each test case contains three integers $n$, $m$, and $k$ ($1\le n,m\le 2\cdot 10^5$, $2\le k\le 2\cdot \min (n,m)$, $k$ is even) — the length of array $a$, the length of array $b$, and the number of elements to be chosen, respectively.

The second line of each test case contains $n$ integers $a_1,a_2,\dots ,a_n$ ($1\le a_i\le 10^6$) — the elements of array $a$.

The third line of each test case contains $m$ integers $b_1,b_2,\dots ,b_m$ ($1\le b_j\le 10^6$) — the elements of array $b$.

It is guaranteed that the sum of values $n$ and $m$ over all test cases in a test does not exceed $4\cdot 10^5$.

Output

Output $t$ lines, each of which is the answer to the corresponding test case. As the answer, output “YES” if it is possible to choose $\frac{k}{2}$ numbers from each array in such a way that among the chosen elements, every integer from $1$ to $k$ is included. Otherwise, output “NO”.

You can output each letter in any case (lowercase or uppercase). For example, the strings “yEs”, “yes”, “Yes”, and “YES” will be accepted as a positive answer.

Example

input

6
6 5 6
2 3 8 5 6 5
1 3 4 10 5
6 5 6
2 3 4 5 6 5
1 3 8 10 3
3 3 4
1 3 5
2 4 6
2 5 4
1 4
7 3 4 4 2
1 4 2
2
6 4 4 2
1 5 2
3
2 2 1 4 3

output

YES
NO
YES
YES
NO
NO

Note

In the first test case of the example, it is possible to choose elements equal to $2$, $3$, and $6$ from array $a$ and elements equal to $1$, $4$, and $5$ from array $b$. Thus, all numbers from $1$ to $k=6$ are included among the chosen elements.

In the second test case of the example, it can be shown that it is not possible to choose exactly three elements from each array in the required way.

In the third test case of the example, it is possible to choose elements equal to $1$ and $3$ from array $a$ and elements equal to $2$ and $4$ from array $b$. Thus, all numbers from $1$ to $k=4$ are included among the chosen elements.

Tutorial

$a$ 数组和 $b$ 数组对于只有自己有的数字必须是自己拿，所以可以贪心地先将这部分拿到，判断有没有某一个数组拿的个数超过了 $\frac{k}{2}$，如果有一个数组拿的个数超过了 $\frac{k}{2}$ 说明不满足题意，输出 $NO$，然后判断 $a$ 数组和 $b$ 数组都有的数能否将剩余的数补齐，如果能刚好补齐，则输出 $YES$，反之为 $NO$，时间复杂度为 $O(k)$

Solution

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

#define endl '\n'
#define int long long

void solve() {
    int n, m, k, cnt1 = 0, cnt2 = 0, cnt3 = 0;
    cin >> n >> m >> k;
    vector<int> a(n), b(m), mid1, mid2;
    map<int, int> mp1, mp2, mp;
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        mp1[x]++;
    }
    for (int i = 0; i < m; ++i) {
        int x;
        cin >> x;
        mp2[x]++;
    }
    for (int i = 1; i <= k; ++i) {
        if (mp1[i] and not mp2[i]) {
            cnt1++;
        } else if (mp2[i] and not mp1[i]) {
            cnt2++;
        } else if (mp1[i] and mp2[i]) {
            cnt3++;
        } else {
            cout << "NO" << endl;
            return;
        }
    }
    if (cnt1 <= k / 2 and cnt2 <= k / 2) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

---

D. Find the Different Ones!

time limit per test: 5 second memory limit per test: 256 megabytes input: standard input output: standard output

You are given an array $a$ of $n$ integers, and $q$ queries.

Each query is represented by two integers $l$ and $r$ ($1\le l\le r\le n$). Your task is to find, for each query, two indices $i$ and $j$ (or determine that they do not exist) such that:

• $l\le i\le r$;
• $l\le j\le r$;
• $a_i\ne a_j$.

In other words, for each query, you need to find a pair of different elements among $a_l,a_{l+1},\dots ,a_r$, or report that such a pair does not exist.

Input

The first line of the input contains a single integer $t$ ($1\le t\le 10^4$) — the number of test cases. The descriptions of the test cases follow.

The first line of each test case contains a single integer $n$ ($2\le n\le 2\cdot 10^5$) — the length of the array $a$.

The second line of each test case contains $n$ integers $a_1,a_2,\dots ,a_n$ ($1\le a_i\le 10^6$) — the elements of the array $a$.

The third line of each test case contains a single integer $q$ ($1\le q\le 2\cdot 10^5$) — the number of queries.

The next $q$ lines contain two integers each, $l$ and $r$ ($1\le l<r\le n$) — the boundaries of the query.

It is guaranteed that the sum of the values of $n$ across all test cases does not exceed $2\cdot 10^5$. Similarly, it is guaranteed that the sum of the values of $q$ across all test cases does not exceed $2\cdot 10^5$.

Output

For each query, output two integers separated by space: $i$ and $j$ ($l\le i,j\le r$), for which $a_i\ne a_j$. If such a pair does not exist, output $i=-1$ and $j=-1$.

You may separate the outputs for the test cases with empty lines. This is not a mandatory requirement.

Example

input

5
5
1 1 2 1 1
3
1 5
1 2
1 3
6
30 20 20 10 10 20
5
1 2
2 3
2 4
2 6
3 5
4
5 2 3 4
4
1 2
1 4
2 3
2 4
5
1 4 3 2 4
5
1 5
2 4
3 4
3 5
4 5
5
2 3 1 4 2
7
1 2
1 4
1 5
2 4
2 5
3 5
4 5

output

2 3
-1 -1
1 3

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

1 2
1 2
2 3
3 2

1 3
2 4
3 4
5 3
5 4

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

Tutorial

• 方法一：

用前缀和数组记录当前位置之前有多少个数和自己前面的数不同，对于每次查询，只需要查找第一个与 $a_l$​ 不同的数的位置即可，此时前缀和数组必定是递增的，所以可以利用二分查找找到这个位置，时间复杂度 $O(n+q\cdot logn)$

• 方法二：

用数组记录当前位置前，第一个与自己不同的数的位置，对于每次查询可以直接用 $O(1)$ 时间复杂度得到，总的时间复杂度为 $O(n)$

Solution

方法一：

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

#define endl '\n'
#define int long long

const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7; // 998244353;

void solve() {
    int n, q;
    cin >> n;
    vector<int> a(n + 1), pre(n + 1);
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
        pre[i] = pre[i - 1];
        if (a[i] != a[i - 1]) {
            pre[i]++;
        }
    }
    cin >> q;
    while (q--) {
        int l, r;
        cin >> l >> r;
        if (pre[r] == pre[l]) {
            cout << -1 << " " << -1 << endl;
            continue;
        }
        int j = upper_bound(pre.begin() + l, pre.begin() + r + 1, pre[l]) - pre.begin();
        cout << l << " " << j << endl;
    }
    cout << endl;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

方法二：

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

#define endl '\n'
#define int long long

const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7; // 998244353;

void solve() {
    int n, q;
    cin >> n;
    vector<int> a(n + 1), diff(n + 1);
    for (int i = 1; i <= n; i += 1) {
        cin >> a[i];
        if (a[i] == a[i - 1]) {
            diff[i] = diff[i - 1];
        } else {
            diff[i] = i - 1;
        }
    }
    cin >> q;
    while (q--) {
        int l, r;
        cin >> l >> r;
        if (diff[r] >= l) {
            cout << diff[r] << " " << r << "\n";
        } else {
            cout << "-1 -1\n";
        }
    }
    cout << endl
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
        solve();
    return 0;
}

---

E. Klever Permutation

time limit per test: 2 second memory limit per test: 256 megabytes input: standard input output: standard output

You are given two integers $n$ and $k$ ($k\le n$), where $k$ is even.

A permutation of length $n$ is an array consisting of $n$ distinct 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 (as $2$ appears twice in the array) and $[0,1,2]$ is also not a permutation (as $n=3$, but $3$ is not present in the array).

Your task is to construct a $k$-level permutation of length $n$.

A permutation is called $k$-level if, among all the sums of continuous segments of length $k$ (of which there are exactly $n-k+1$), any two sums differ by no more than $1$.

More formally, to determine if the permutation $p$ is $k$-level, first construct an array $s$ of length $n-k+1$, where $s_i={\sum }_{j=i}^{i+k-1}{p}_j$, i.e., the $i$-th element is equal to the sum of $p_i,p_{i+1},\dots ,p_{i+k-1}$.

A permutation is called $k$-level if $\max (s)-\min (s)\le 1$.

Find any $k$-level permutation of length $n$.

Input

The first line of the input contains a single integer $t$ ($1\le t\le 10^4$) — the number of test cases. This is followed by the description of the test cases.

The first and only line of each test case contains two integers $n$ and $k$ ($2\le k\le n\le 2\cdot 10^5$, $k$ is even), where $n$ is the length of the desired permutation.

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

Output

For each test case, output any $k$-level permutation of length $n$.

It is guaranteed that such a permutation always exists given the constraints.

Example

input

5
2 2
3 2
10 4
13 4
7 4

output

1 2
3 1 2
8 3 10 1 7 4 9 2 6 5
13 4 9 1 12 5 8 2 11 6 7 3 10
1 7 3 5 2 6 4

Note

In the second test case of the example:

• $p_1+p_2=3+1=4$;
• $p_2+p_3=1+2=3$.

The maximum among the sums is $4$, and the minimum is $3$.

Tutorial

本题为构造体题，根据题意我们先考虑相邻两个长度为 $k$ 的子数组，我们会发现前一个子数组($p_i-p_{i+k-1}$)的第一个和后一个子数组($p_{i+1}-p_{i+k}$)的最后一个元素只能相差为 $1$ ，因为其中间($p_{i+1}-p_{i+k-1}$)都为重叠的元素。所以我们可以分成 $k$ 组，每组两个相邻的元素他们的坐标之差都为 $k$，相邻两组之间一组从小到大构造，一组从大到小构造，直到所有数字都用完，即可保证所有的长度为 $k$ 的子数组的总和差值都至多为 $1$

Solution

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

#define endl '\n'
#define int long long

void solve() {
    int n, k;
    cin >> n >> k;
    vector<int> ans(n + 1);
    int l = 1, r = n;
    for (int i = 1; i <= k; ++i) {
        if (i & 1) {
            for (int j = i; j <= n; j += k) {
                ans[j] = l;
                ++l;
            }
        } else {
            for (int j = i; j <= n; j += k) {
                ans[j] = r;
                --r;
            }
        }
    }
    for (int i = 1; i <= n; ++i) {
        cout << ans[i] << " \n"[i == n];
    }
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

---