Codeforces Round 921 (Div. 2) A B C

A. We Got Everything Covered!

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

You are given two positive integers $n$ and $k$.

Your task is to find a string $s$ such that all possible strings of length $n$ that can be formed using the first $k$ lowercase English alphabets occur as a subsequence of $s$.

If there are multiple answers, print the one with the smallest length. If there are still multiple answers, you may print any of them.

Note: A string $a$ is called a subsequence of another string $b$ if $a$ can be obtained by deleting some (possibly zero) characters from $b$ without changing the order of the remaining characters.

Input

The first line of input contains a single integer $t$ ($1\le t\le 676$) denoting the number of test cases.

Each test case consists of a single line of input containing two integers $n$ ($1\le n\le 26$) and $k$ ($1\le k\le 26$).

Output

For each test case, print a single line containing a single string $s$ which satisfies the above property. If there are multiple answers, print the one with the smallest length. If there are still multiple answers, you may print any of them.

Example

input

4
1 2
2 1
2 2
2 3

output

ab
aa
baab
abcbac

Note

For the first test case, there are two strings of length $1$ which can be formed using the first $2$ lowercase English alphabets, and they are present in $s$ as a subsequence as follows:

• $\text{a}:\text{a}\text{b}$
• $\text{b}:\text{a}\text{b}$

For the second test case, there is only one string of length $2$ which can be formed using the first lowercase English alphabet, and it is present in $s$ as a subsequence as follows:

• $\text{aa}:\text{aa}$

For the third test case, there are $4$ strings of length $2$ which can be formed using the first $2$ lowercase English alphabets, and they are present in $s$ as a subsequence as follows:

• $\text{aa}:\text{b}\text{aa}\text{b}$
• $\text{ab}:\text{ba}\text{ab}$
• $\text{ba}:\text{ba}\text{ab}$
• $\text{bb}:\text{b}\text{aa}\text{b}$

For the fourth test case, there are $9$ strings of length $2$ which can be formed using the first $3$ lowercase English alphabets, and they are present in $s$ as a subsequence as follows:

• $\text{aa}:\text{a}\text{bcb}\text{a}\text{c}$
• $\text{ab}:\text{ab}\text{cbac}$
• $\text{ac}:\text{abcb}\text{ac}$
• $\text{ba}:\text{abc}\text{ba}\text{c}$
• $\text{bb}:\text{a}\text{b}\text{c}\text{b}\text{ac}$
• $\text{bc}:\text{a}\text{bc}\text{bac}$
• $\text{ca}:\text{ab}\text{c}\text{b}\text{a}\text{c}$
• $\text{cb}:\text{ab}\text{cb}\text{ac}$
• $\text{cc}:\text{ab}\text{c}\text{ba}\text{c}$

Tutorial

要将字符串 $aa\dots aa$作为子序列，您需要在字符串中至少有 $n$ 个字符作为 $a$。,对于所有 $k$ 不同的字符也是如此。 因此，总长度至少为 $n\times k$，所以将前 $k$ 个小写英文字母组成的字符串连续输出 $n$ 次即可满足题意，子序列的每个字母分别来自每一组由前 $k$ 个小写英文字母组成的字符串

Solution

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

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

void solve() {
    int n, k;
    cin >> n >> k;
    string s = "";
    for (char c = 'a'; c < 'a' + k; ++c) {
        s += c;
    }
    for (int i = 0; i < n; ++i) {
        cout << s;
    }
    cout << endl;
}

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

---

B. A Balanced Problemset?

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

Jay managed to create a problem of difficulty $x$ and decided to make it the second problem for Codeforces Round #921.

But Yash fears that this problem will make the contest highly unbalanced, and the coordinator will reject it. So, he decided to break it up into a problemset of $n$ sub-problems such that the difficulties of all the sub-problems are a positive integer and their sum is equal to $x$.

The coordinator, Aleksey, defines the balance of a problemset as the GCD of the difficulties of all sub-problems in the problemset.

Find the maximum balance that Yash can achieve if he chooses the difficulties of the sub-problems optimally.

Input

The first line of input contains a single integer $t$ ($1\le t\le 10^3$) denoting the number of test cases.

Each test case contains a single line of input containing two integers $x$ ($1\le x\le 10^8$) and $n$ ($1\le n\le x$).

Output

For each test case, print a single line containing a single integer denoting the maximum balance of the problemset Yash can achieve.

Example

input

3
10 3
5 5
420 69

output

2
1
6

Note

For the first test case, one possible way is to break up the problem of difficulty $10$ into a problemset having three problems of difficulties $4$, $2$ and $4$ respectively, giving a balance equal to $2$.

For the second test case, there is only one way to break up the problem of difficulty $5$ into a problemset of $5$ problems with each problem having a difficulty $1$ giving a balance equal to $1$.

Tutorial

根据 $GCD$ 的性质，最终答案将始终是 $x$ 的除数，如果 $n\times d⩽x$，则可以选择子问题难度为 $d,d,\dots ,x-(n-1)d$，此时每个子问题的难度都是 $d$ 的倍数

Solution

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

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

void solve() {
    int x, n;
    cin >> x >> n;
    int ans = 1;
    for (int i = 1; i * i <= x; ++i) {
        if (x % i) {
            continue;
        }
        if (x / i >= n) {
            ans = max(ans, i);
        }
        if (i >= n) {
            ans = max(ans, x / i);
        }
    }
    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. Did We Get Everything Covered?

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$ along with a string $s$.

Your task is to check whether all possible strings of length $n$ that can be formed using the first $k$ lowercase English alphabets occur as a subsequence of $s$. If the answer is NO, you also need to print a string of length $n$ that can be formed using the first $k$ lowercase English alphabets which does not occur as a subsequence of $s$.

If there are multiple answers, you may print any of them.

Note: A string $a$ is called a subsequence of another string $b$ if $a$ can be obtained by deleting some (possibly zero) characters from $b$ without changing the order of the remaining characters.

Input

The first line of input contains a single integer $t(1\le t\le 10^5)$, the number of test cases.

The first line of each test case contains $3$ integers $n(1\le n\le 26),k(1\le k\le 26),m(1\le m\le 1000)$, where $n$ and $k$ are the same as described in the input and $m$ is the length of the string $s$.

The second line of each test case contains a single string $s$ of length $m$, comprising only of the first $k$ lowercase English alphabets.

It is guaranteed that the sum of $m$ and the sum of $n$ over all test cases does not exceed $10^6$.

Output

For each test case, print YES if all possible strings of length $n$ that can be formed using the first $k$ lowercase English alphabets occur as a subsequence of $s$, else print NO.

If your answer is NO, print a string of length $n$ that can be formed using the first $k$ lowercase English alphabets which does not occur as a subsequence of $s$ in the next line.

You may print each letter of YES or NO in any case (for example, YES, yES, YeS will all be recognized as a positive answer).

Example

input

3
2 2 4
abba
2 2 3
abb
3 3 10
aabbccabab

output

YES
NO
aa
NO
ccc

Note

For the first test case, all possible strings (aa, ab, ba, bb) of length $2$ that can be formed using the first $2$ English alphabets occur as a subsequence of abba.

For the second test case, the string aa is not a subsequence of abb.

Tutorial

本题为 $A$ 题的一个检查器，需要反向判断给出的字符串 $s$ 是否符合标准，我们可以对前 $k$ 中字符进行一个计数，如果都出现一次后，那么其能表示的 $n$ 就多一位，遍历结束后，如果不能满足题意，错误样例可以通过最后计数器不存在的字符构造出

Solution

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

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

void solve() {
    int n, k, m;
    string s, S;
    cin >> n >> k >> m >> s;
    int mid = 0;
    for (int i = 0; i < m; ++i) {
        mid |= (1 << (s[i] - 'a'));
        if (mid == (1 << k) - 1) { // 一套字母集齐了
            mid = 0;
            S += s[i];
        }
    }
    if ((int)S.size() >= n) { // 每个字母都至少有 n 个
        cout << "YES" << endl;
        return;
    }
    cout << "NO" << endl;
    for (int i = 0; i < k; ++i) {
        if (mid & (1 << i)) {
            continue;
        }
        // 缺啥补啥
        while ((int)S.size() < n) {
            S += (char)('a' + i);
        }
    }
    cout << S << endl;
}

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