Educational Codeforces Round 161 (Rated for Div. 2) A B C D E

A. Tricky Template

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

You are given an integer $n$ and three strings $a,b,c$, each consisting of $n$ lowercase Latin letters.

Let a template be a string $t$ consisting of $n$ lowercase and/or uppercase Latin letters. The string $s$ matches the template $t$ if the following conditions hold for all $i$ from $1$ to $n$:

• if the $i$-th letter of the template is lowercase, then $s_i$ must be the same as $t_i$;
• if the $i$-th letter of the template is uppercase, then $s_i$ must be different from the lowercase version of $t_i$. For example, if there is a letter ‘A’ in the template, you cannot use the letter ‘a’ in the corresponding position of the string.

Accordingly, the string doesn’t match the template if the condition doesn’t hold for at least one $i$.

Determine whether there exists a template $t$ such that the strings $a$ and $b$ match it, while the string $c$ does not.

Input

The first line contains an integer $t$ ($1\le t\le 1000$) — the number of test cases.

The first line of each test case contains an integer $n$ ($1\le n\le 20$) — the length of the given strings.

The next three lines contain the strings $a,b$ and $c$. Each string consists of exactly $n$ lowercase Latin letters.

Output

For each testcase, print “YES” if there exists a template $t$ such that the strings $a$ and $b$ match it, while the string $c$ does not. Otherwise, print “NO”.

Example

input

4
1
a
b
c
2
aa
bb
aa
10
mathforces
luckforces
adhoccoder
3
acc
abd
abc

output

YES
NO
YES
NO

Note

In the first test case, you can use the template “C”. The first letter of strings $a$ and $b$ differ from ‘c’, so they match the template. The first letter of string $c$ equals ‘c’, so it doesn’t match.

In the third test case, you can use the template “CODEforces”.

Tutorial

只需要字符串 $c$ 存在一个位置与字符串 $a$ 和字符串 $b$ 都不同即可

Solution

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

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

void solve() {
    int n, cnt = 0;
    string a, b, c;
    cin >> n >> a >> b >> c;
    for (int i = 0; i < n; ++i) {
        cnt += (a[i] == c[i] or b[i] == c[i]);
    }
    cout << (cnt == n ? "NO" : "YES") << endl;
}

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

---

B. Forming Triangles

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

You have $n$ sticks, numbered from $1$ to $n$. The length of the $i$-th stick is $2^{a_i}$.

You want to choose exactly $3$ sticks out of the given $n$ sticks, and form a non-degenerate triangle out of them, using the sticks as the sides of the triangle. A triangle is called non-degenerate if its area is strictly greater than $0$.

You have to calculate the number of ways to choose exactly $3$ sticks so that a triangle can be formed out of them. Note that the order of choosing sticks does not matter (for example, choosing the $1$-st, $2$-nd and $4$-th stick is the same as choosing the $2$-nd, $4$-th and $1$-st stick).

Input

The first line contains one integer $t$ ($1\le t\le 10^4$) — the number of test cases.

Each test case consists of two lines:

• the first line contains one integer $n$ ($1\le n\le 3\cdot 10^5$);
• the second line contains $n$ integers $a_1,a_2,\dots ,a_n$ ($0\le a_i\le n$).

Additional constraint on the input: the sum of $n$ over all test cases does not exceed $3\cdot 10^5$.

Output

For each test case, print one integer — the number of ways to choose exactly $3$ sticks so that a triangle can be formed out of them.

Example

input

4
7
1 1 1 1 1 1 1
4
3 2 1 3
3
1 2 3
1
1

output

35
2
0
0

Note

In the first test case of the example, any three sticks out of the given $7$ can be chosen.

In the second test case of the example, you can choose the $1$-st, $2$-nd and $4$-th stick, or the $1$-st, $3$-rd and $4$-th stick.

In the third test case of the example, you cannot form a triangle out of the given sticks with lengths $2$, $4$ and $8$.

Tutorial

由题意可得，每根棍子长度为 $2^{a_i}$，设三条边长度从小到大分别是 $a_i,a_j,a_k$，则 $2^{a_i}+2^{a_j}>2^{a_k}$，所以如果需要满足这个条件，就所取的三角形一定是等腰三角形，才能满足题意，设最长边长度为 $x$，比最长边短的边的个数为 $sum$：

• 如果三条边的长度都相同，则有 $\frac{cn{t}_x\times (cn{t}_x-1)\times (cn{t}_x-2)}{6}$ 种取法
• 如果两条最长边相同，另取一条比它们小的边，有 $\frac{cn{t}_x\times (cn{t}_x-1)}{2}\times sum$ 种取法

则答案可通过遍历一次计数表即可得到

Solution

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

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

void solve() {
    int n, ans = 0;
    cin >> n;
    vector<int> a(n);
    map<int, int> mp;
    for (int &ai : a) {
        cin >> ai;
        mp[ai]++;
    }
    int sum = 0;
    for (auto [x, y] : mp) {
        ans += y * (y - 1) * (y - 2) / 6 + sum * (y - 1) * y / 2;
        sum += y;
    }
    
    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. Closest Cities

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

There are $n$ cities located on the number line, the $i$-th city is in the point $a_i$. The coordinates of the cities are given in ascending order, so $a_1<a_2<\cdots <a_n$.

The distance between two cities $x$ and $y$ is equal to $|a_x-a_y|$.

For each city $i$, let’s define the closest city $j$ as the city such that the distance between $i$ and $j$ is not greater than the distance between $i$ and each other city $k$. For example, if the cities are located in points $[0,8,12,15,20]$, then:

• the closest city to the city $1$ is the city $2$;
• the closest city to the city $2$ is the city $3$;
• the closest city to the city $3$ is the city $4$;
• the closest city to the city $4$ is the city $3$;
• the closest city to the city $5$ is the city $4$.

The cities are located in such a way that for every city, the closest city is unique. For example, it is impossible for the cities to be situated in points $[1,2,3]$, since this would mean that the city $2$ has two closest cities ($1$ and $3$, both having distance $1$).

You can travel between cities. Suppose you are currently in the city $x$. Then you can perform one of the following actions:

• travel to any other city $y$, paying $|a_x-a_y|$ coins;
• travel to the city which is the closest to $x$, paying $1$ coin.

You are given $m$ queries. In each query, you will be given two cities, and you have to calculate the minimum number of coins you have to spend to travel from one city to the other city.

Input

The first line contains one integer $t$ ($1\le t\le 10^4$) — the number of test cases.

Each test case is given in the following format:

• the first line contains one integer $n$ ($2\le n\le 10^5$);
• the second line contains $n$ integers $a_1,a_2,\dots ,a_n$ ($0\le a_1<a_2<\cdots <a_n\le 10^9$);
• the third line contains one integer $m$ ($1\le m\le 10^5$);
• then $m$ lines follow; the $i$-th of them contains two integers $x_i$ and $y_i$ ($1\le x_i,y_i\le n$; $x_i\ne y_i$), denoting that in the $i$-th query, you have to calculate the minimum number of coins you have to spend to travel from the city $x_i$ to the city $y_i$.

Additional constraints on the input:

• in every test case, for each city, the closest city is determined uniquely;
• the sum of $n$ over all test cases does not exceed $10^5$;
• the sum of $m$ over all test cases does not exceed $10^5$.

Output

For each query, print one integer — the minimum number of coins you have to spend.

Example

input

1
5
0 8 12 15 20
5
1 4
1 5
3 4
3 2
5 1

output

3
8
1
4
14

Note

Let’s consider the first two queries in the example from the statement:

• in the first query, you are initially in the city $1$. You can travel to the closest city (which is the city $2$), paying $1$ coin. Then you travel to the closest city (which is the city $3$) again, paying $1$ coin. Then you travel to the closest city (which is the city $4$) again, paying $1$ coin. In total, you spend $3$ coins to get from the city $1$ to the city $4$;
• in the second query, you can use the same way to get from the city $1$ to the city $4$, and then spend $5$ coins to travel from the city $4$ to the city $5$.

Tutorial

用两个数组分别记录当前位置向左走和向右走所需要的花费，然后对它们进行前缀和计算，即可通过方向判断，得到当前位置到目标位置到总花费

Solution

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

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

void solve() {
    int n, m, x, y;
    cin >> n;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    // 每个点 向右走的花费 和 向左走的花费
    vector<int> pre(n + 2), suf(n + 2);
    pre[1] = suf[n] = 1;
    for (int i = 2; i < n; ++i) {
        pre[i] = (a[i] - a[i - 1] < a[i + 1] - a[i] ? a[i + 1] - a[i] : 1);
    }
    for (int i = n - 1; i > 1; --i) {
        suf[i] = (a[i] - a[i - 1] > a[i + 1] - a[i] ? a[i] - a[i - 1] : 1);
    }
    for (int i = 1; i < n; ++i) {
        pre[i] += pre[i - 1];
    }
    for (int i = n; i > 0; --i) {
        suf[i] += suf[i + 1];
    }
    cin >> m;
    while (m--) {
        cin >> x >> y;
        if (x > y) {
            cout << suf[y + 1] - suf[x + 1] << endl;
        } else {
            cout << pre[y - 1] - pre[x - 1] << endl;
        }
    }
}

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

---

D. Berserk Monsters

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

Monocarp is playing a computer game (yet again). Guess what is he doing? That’s right, killing monsters.

There are $n$ monsters in a row, numbered from $1$ to $n$. The $i$-th monster has two parameters: attack value equal to $a_i$ and defense value equal to $d_i$. In order to kill these monsters, Monocarp put a berserk spell on them, so they’re attacking each other instead of Monocarp’s character.

The fight consists of $n$ rounds. Every round, the following happens:

• first, every alive monster $i$ deals $a_i$ damage to the closest alive monster to the left (if it exists) and the closest alive monster to the right (if it exists);
• then, every alive monster $j$ which received more than $d_j$ damage during this round dies. I. e. the $j$-th monster dies if and only if its defense value $d_j$ is strictly less than the total damage it received this round.

For each round, calculate the number of monsters that will die during that round.

Input

The first line contains one integer $t$ ($1\le t\le 10^4$) — the number of test cases.

Each test case consists of three lines:

• the first line contains one integer $n$ ($1\le n\le 3\cdot 10^5$);
• the second line contains $n$ integers $a_1,a_2,\dots ,a_n$ ($1\le a_i\le 10^9$);
• the third line contains $n$ integers $d_1,d_2,\dots ,d_n$ ($1\le d_i\le 10^9$).

Additional constraint on the input: the sum of $n$ over all test cases does not exceed $3\cdot 10^5$.

Output

For each test case, print $n$ integers. The $i$-th integer should be equal to the number of monsters that die during the $i$-th round.

Example

input

3
5
3 4 7 5 10
4 9 1 18 1
2
2 1
1 3
4
1 1 2 4
3 3 4 2

output

3 1 0 0 0 
0 0 
1 1 1 0 

Note

Explanation for the first test case of the example:

During the first round, the following happens:

• the monster $1$ deals $3$ damage to the monster $2$;
• the monster $2$ deals $4$ damage to the monster $1$ and the monster $3$;
• the monster $3$ deals $7$ damage to the monster $2$ and the monster $4$;
• the monster $4$ deals $5$ damage to the monster $3$ and the monster $5$;
• the monster $5$ deals $10$ damage to the monster $4$;
• the monster $1$ does not die, since it received $4$ damage and its defense is $4$;
• the monster $2$ dies, since it received $10$ damage and its defense is $9$;
• the monster $3$ dies, since it received $9$ damage and its defense is $1$;
• the monster $4$ does not die, since it received $17$ damage and its defense is $18$;
• the monster $5$ dies, since it received $5$ damage and its defense is $1$.

After the first round, the monsters $1$ and $4$ stay alive.

During the second round, the following happens:

• the monster $1$ deals $3$ damage to the monster $4$;
• the monster $4$ deals $5$ damage to the monster $1$;
• the monster $1$ dies, since it received $5$ damage and its defense is $4$;
• the monster $4$ does not die, since it received $3$ damage and its defense is $18$.

During the next three rounds, only the $4$-th monster is alive, so nothing happens.

Tutorial

先记录每个怪物的左怪物和右怪物，在之后的每次死亡后，死亡怪物左右两边的怪物的左右怪物都会因此受到影响，此时，左怪物的右怪物会更新，右怪物的左怪物会更新

在每次攻击回合时，只需要对还存活的怪物进行判断即可，用 $set$ 记录存活的怪物即可（一个怪物可能被左右两边的怪物存入 $set$ 中）

Solution

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

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

void solve() {
    int n;
    cin >> n;
    vector<int> a(n), d(n), l(n), r(n), ans(n), mid;
    vector<bool> vis(n);
    for (int &ai : a) {
        cin >> ai;
    }
    for (int &di : d) {
        cin >> di;
    }
    for (int i = 0; i < n; ++i) {
        l[i] = i - 1;
        r[i] = i + 1;
    }
    
    // 进行攻击
    function<int(int)> hack = [&](int id) -> int {
        int ans = 0;
        if (l[id] ^ -1) {
            ans += a[l[id]];
        }
        if (r[id] ^ n) {
            ans += a[r[id]];
        }
        return ans;
    };

    for (int i = 0; i < n; ++i) {
        int blood = hack(i);
        if (blood > d[i]) {
            mid.emplace_back(i);
        }
    }

    for (int i = 0; i < n; ++i) {
        set<int> update;
        ans[i] = mid.size();
        for (int id : mid) {
            vis[id] = true;
            if (l[id] ^ -1) {
                r[l[id]] = r[id];
                update.insert(l[id]);
            }
            if (r[id] ^ n) {
                l[r[id]] = l[id];
                update.insert(r[id]);
            }
        }
        mid.clear();

        for (int id : update) {
            if (vis[id]) {
                continue;
            }
            int blood = hack(id);
            if (blood > d[id]) {
                mid.emplace_back(id);
            }
        }
    }
    for (int i = 0; i < n; ++i) {
        cout << ans[i] << " \n"[i == n - 1];
    }
}

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

---

E. Increasing Subsequences

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

Let’s recall that an increasing subsequence of the array $a$ is a sequence that can be obtained from it by removing some elements without changing the order of the remaining elements, and the remaining elements are strictly increasing (i. e $a_{b_1}<a_{b_2}<\cdots <a_{b_k}$ and $b_1<b_2<\cdots <b_k$). Note that an empty subsequence is also increasing.

You are given a positive integer $X$. Your task is to find an array of integers of length at most $200$, such that it has exactly $X$ increasing subsequences, or report that there is no such array. If there are several answers, you can print any of them.

If two subsequences consist of the same elements, but correspond to different positions in the array, they are considered different (for example, the array $[2,2]$ has two different subsequences equal to $[2]$).

Input

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

The only line of each test case contains a single integer $X$ ($2\le X\le 10^{18}$).

Output

For each query, print the answer to it. If it is impossible to find the required array, print -1 on the first line. Otherwise, print a positive integer $n$ on the first line — the length of the array. On the second line, print $n$ integers — the required array itself. If there are several answers, you can print any of them. All elements of the array should be in the range $[-10^9;10^9]$.

Example

input

4
2
5
13
37

output

1
0
3
0 1 0
5
2 2 3 4 2
7
-1 -1 0 0 2 3 -1

Tutorial

设 $cnt$ 为递增子序列个数，此时：

• 在末尾添加 0，此时这个新加入的 0 是一个新的递增子序列，$cnt$ 变为 $cnt+1$
• 在末尾添加比最大值还大的数，此时这个数可以与前面所有递增子序列构成一个新的递增子序列，也可以自己构成一个新的递增子序列，$cnt$ 变为 $2\times cnt+1$

我们可以利用逆向思维：

• 如果 $x$ 是偶数，此时可以在数组前面添加 0，然后 $x$ 变为 $x-1$
• 如果 $x$ 是奇数，此时可以在数组前面添加 $cur$，然后 $x$ 变为 $\frac{x-1}{2}$，$cur$ 变为 $cur-1$
• 注意：在此之前需要先把空子序列减去

Solution

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

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

void solve() {
    int x, cur = 100;
    cin >> x;
    vector<int> ans;
    x--;
    while (x) {
        if (x & 1) {
            ans.emplace_back(cur--);
            x >>= 1;
        } else {
            ans.emplace_back(0);
            --x;
        }
    }
    cout << ans.size() << endl;
    for (int i = ans.size() - 1; i >= 0; --i) {
        cout << ans[i] << " \n"[not i];
    }
}

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