Codeforces Round 806 (Div. 4)

---

A. YES or YES?

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

There is a string $s$ of length $3$, consisting of uppercase and lowercase English letters. Check if it is equal to “YES” (without quotes), where each letter can be in any case. For example, “yES”, “Yes”, “yes” are all allowable.

Input

The first line of the input contains an integer $t$ ($1\le t\le 10^3$) — the number of testcases.

The description of each test consists of one line containing one string $s$ consisting of three characters. Each character of $s$ is either an uppercase or lowercase English letter.

Output

For each test case, output “YES” (without quotes) if $s$ satisfies the condition, and “NO” (without quotes) otherwise.

You can output “YES” and “NO” in any case (for example, strings “yES”, “yes” and “Yes” will be recognized as a positive response).

Example
input

10
YES
yES
yes
Yes
YeS
Noo
orZ
yEz
Yas
XES

output

YES
YES
YES
YES
YES
NO
NO
NO
NO
NO

Note

The first five test cases contain the strings “YES”, “yES”, “yes”, “Yes”, “YeS”. All of these are equal to “YES”, where each character is either uppercase or lowercase.

Tutorial
将字符串转换为小写后与 yes 做比较

Solution

for _ in range(int(input())):
    s = input().strip()
    print("YES" if s.lower() == "yes" else "NO")

---

B. ICPC Balloons

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

In an ICPC contest, balloons are distributed as follows:

• Whenever a team solves a problem, that team gets a balloon.
• The first team to solve a problem gets an additional balloon.

A contest has 26 problems, labelled $\text{A}$, $\text{B}$, $\text{C}$, …, $\text{Z}$. You are given the order of solved problems in the contest, denoted as a string $s$, where the $i$-th character indicates that the problem $s_i$ has been solved by some team. No team will solve the same problem twice.

Determine the total number of balloons that the teams received. Note that some problems may be solved by none of the teams.

Input

The first line of the input contains an integer $t$ ($1\le t\le 100$) — the number of testcases.

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

The second line of each test case contains a string $s$ of length $n$ consisting of uppercase English letters, denoting the order of solved problems.

Output

For each test case, output a single integer — the total number of balloons that the teams received.

Example
input

6
3
ABA
1
A
3
ORZ
5
BAAAA
4
BKPT
10
CODEFORCES

output

5
2
6
7
8
17

Note

In the first test case, $5$ balloons are given out:

• Problem $\text{A}$ is solved. That team receives $2$ balloons: one because they solved the problem, an an additional one because they are the first team to solve problem $\text{A}$.
• Problem $\text{B}$ is solved. That team receives $2$ balloons: one because they solved the problem, an an additional one because they are the first team to solve problem $\text{B}$.
• Problem $\text{A}$ is solved. That team receives only $1$ balloon, because they solved the problem. Note that they don’t get an additional balloon because they are not the first team to solve problem $\text{A}$.

The total number of balloons given out is $2+2+1=5$.

In the second test case, there is only one problem solved. The team who solved it receives $2$ balloons: one because they solved the problem, an an additional one because they are the first team to solve problem $\text{A}$.

Tutorial
当这个字母第一次出现时 $+2$，以后出现都是 $+1$

Solution

from collections import *

for _ in range(int(input())):
    input()
    ans = 0
    s = input().strip()
    mp = Counter()
    for c in s:
        ans += (1 if mp[c] else 2)
        if not mp[c]:
            mp[c] = True
    print(ans)

---

C. Cypher

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

Luca has a cypher made up of a sequence of $n$ wheels, each with a digit $a_i$ written on it. On the $i$-th wheel, he made $b_i$ moves. Each move is one of two types:

• up move (denoted by $\text{U}$): it increases the $i$-th digit by $1$. After applying the up move on $9$, it becomes $0$.
• down move (denoted by $\text{D}$): it decreases the $i$-th digit by $1$. After applying the down move on $0$, it becomes $9$.

Example for $n=4$. The current sequence is 0 0 0 0.

Luca knows the final sequence of wheels and the moves for each wheel. Help him find the original sequence and crack the cypher.

Input

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

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

The second line contains $n$ integers $a_i$ ($0\le a_i\le 9$) — the digit shown on the $i$-th wheel after all moves have been performed.

Then $n$ lines follow, the $i$-th of which contains the integer $b_i$ ($1\le b_i\le 10$) and $b_i$ characters that are either $\text{U}$ or $\text{D}$ — the number of moves performed on the $i$-th wheel, and the moves performed. $\text{U}$ and $\text{D}$ represent an up move and a down move respectively.

Output

For each test case, output $n$ space-separated digits — the initial sequence of the cypher.

Example
input

3
3
9 3 1
3 DDD
4 UDUU
2 DU
2
0 9
9 DDDDDDDDD
9 UUUUUUUUU
5
0 5 9 8 3
10 UUUUUUUUUU
3 UUD
8 UUDUUDDD
10 UUDUUDUDDU
4 UUUU

output

2 1 1 
9 0 
0 4 9 6 9 

Note

In the first test case, we can prove that initial sequence was $[2,1,1]$. In that case, the following moves were performed:

• On the first wheel: $2\underset{\text{D}}{\to }1\underset{\text{D}}{\to }0\underset{\text{D}}{\to }9$.
• On the second wheel: $1\underset{\text{U}}{\to }2\underset{\text{D}}{\to }1\underset{\text{U}}{\to }2\underset{\text{U}}{\to }3$.
• On the third wheel: $1\underset{\text{D}}{\to }0\underset{\text{U}}{\to }1$.

The final sequence was $[9,3,1]$, which matches the input.

Tutorial
此题就是知结果推初始状态，根据题意反向模拟即可

Solution

for _ in range(int(input())):
    n = int(input())
    ans = list(map(int, input().split()))
    for i in range(n):
        s = list(map(str, input().split()))
        print((ans[i] + len(s[1]) - 2 * s[1].count('U')) % 10, end=" \n"[i == n - 1])

---

D. Double Strings

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

You are given $n$ strings $s_1,s_2,\dots ,s_n$ of length at most $8$.

For each string $s_i$, determine if there exist two strings $s_j$ and $s_k$ such that $s_i=s_j+s_k$. That is, $s_i$ is the concatenation of $s_j$ and $s_k$. Note that $j$ can be equal to $k$.

Recall that the concatenation of strings $s$ and $t$ is $s+t=s_1{s}_2\dots s_p{t}_1{t}_2\dots t_q$, where $p$ and $q$ are the lengths of strings $s$ and $t$ respectively. For example, concatenation of “code” and “forces” is “codeforces”.

Input

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

The first line of each test case contains a single integer $n$ ($1\le n\le 10^5$) — the number of strings.

Then $n$ lines follow, the $i$-th of which contains non-empty string $s_i$ of length at most $8$, consisting of lowercase English letters. Among the given $n$ strings, there may be equal (duplicates).

The sum of $n$ over all test cases doesn’t exceed $10^5$.

Output

For each test case, output a binary string of length $n$. The $i$-th bit should be $\text{1}$ if there exist two strings $s_j$ and $s_k$ where $s_i=s_j+s_k$, and $\text{0}$ otherwise. Note that $j$ can be equal to $k$.

Example
input

3
5
abab
ab
abc
abacb
c
3
x
xx
xxx
8
codeforc
es
codes
cod
forc
forces
e
code

output

10100
011
10100101

Note

In the first test case, we have the following:

• $s_1=s_2+s_2$, since $\text{abab}=\text{ab}+\text{ab}$. Remember that $j$ can be equal to $k$.
• $s_2$ is not the concatenation of any two strings in the list.
• $s_3=s_2+s_5$, since $\text{abc}=\text{ab}+\text{c}$.
• $s_4$ is not the concatenation of any two strings in the list.
• $s_5$ is not the concatenation of any two strings in the list.

Since only $s_1$ and $s_3$ satisfy the conditions, only the first and third bits in the answer should be $\text{1}$, so the answer is $\text{10100}$.

Tutorial
由题意得每个 $test$ 的字符串个数范围为 $1\le n\le 10^5$，每个字符串的长度为多为 $8$，所以这就是一个暴力比较的过程，只需要先记忆每个字符串是否出现过，然后将每个字符串拆分，判断两个部分是否出现过即可

Solution

from collections import Counter

for _ in range(int(input())):
    n = int(input())
    mp = Counter()
    a = []
    for __ in range(n):
        s = input()
        a.append(s)
        mp[s] = True
    for s in a:
        flag = False
        for i in range(min(len(s), 8) - 1):
            if mp[s[:i + 1]] and mp[s[i + 1:]]:
                flag = True
                break
        print(1 if flag else 0, end="")
    print()

---

E. Mirror Grid

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

You are given a square grid with $n$ rows and $n$ columns. Each cell contains either $0$ or $1$.

In an operation, you can select a cell of the grid and flip it (from $0\to 1$ or $1\to 0$). Find the minimum number of operations you need to obtain a square that remains the same when rotated $0^{\circ }$, $90^{\circ }$, $180^{\circ }$ and $270^{\circ }$.

The picture below shows an example of all rotations of a grid.

Input

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

The first line of each test case contains a single integer $n$ ($1\le n\le 100$) — the size of the grid.

Then $n$ lines follow, each with $n$ characters $a_{i,j}$ ($0\le a_{i,j}\le 1$) — the number written in each cell.

Output

For each test case output a single integer — the minimum number of operations needed to make the square look the same rotated $0^{\circ }$, $90^{\circ }$, $180^{\circ }$ and $270^{\circ }$.

Example
input

5
3
010
110
010
1
0
5
11100
11011
01011
10011
11000
5
01000
10101
01010
00010
01001
5
11001
00000
11111
10110
01111

output

1
0
9
7
6

Note

In the first test case, we can perform one operations to make the grid $\begin{array}{ccc}0& 1& 0\\ 1& 1& 1\\ 0& 1& 0\end{array}$. Now, all rotations of the square are the same.

In the second test case, all rotations of the square are already the same, so we don’t need any flips.

Tutorial
根据题意得，需要对 $0^{\circ }$, $90^{\circ }$, $180^{\circ }$, $270^{\circ }$ 四个旋转方向进行判断，所以需要将原本的正方形分成四个方块，然后以其中一个方块为基础，判断四个方块上对应的位置的值是什么，然后更改出现少的值就可以了（因为只会出现 $0$ 和 $1$ 两种值）

注意边界处理，避免漏判断以及重复判断

Solution

import sys
input = sys.stdin.readline

for _ in range(int(input())):
    n = int(input())
    ans = 0
    g = [list(map(int, input().strip())) for __ in range(n)]
    for i in range(n // 2):
        for j in range((n + 1) // 2):
            cnt = g[i][j] + g[j][n - i - 1] + g[n - i - 1][n - j - 1] + g[n - j - 1][i]
            ans += min(cnt, 4 - cnt)
    print(ans)

---

F. Yet Another Problem About Pairs Satisfying an Inequality

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

You are given an array $a_1,a_2,\dots a_n$. Count the number of pairs of indices $1\le i,j\le n$ such that $a_i<i<a_j<j$.

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$ ($2\le n\le 2\cdot 10^5$) — the length of the array.

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

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

Output

For each test case, output a single integer — the number of pairs of indices satisfying the condition in the statement.

Please note, that the answer for some test cases won’t fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language (like long long for C++).

Example
input

5
8
1 1 2 3 8 2 1 4
2
1 2
10
0 2 1 6 3 4 1 2 8 3
2
1 1000000000
3
0 1000000000 2

output

3
0
10
0
1

Note

For the first test cases the pairs are $(i,j)$ = $\{(2,4),(2,8),(3,8)\}$.

• The pair $(2,4)$ is true because $a_2=1$, $a_4=3$ and $1<2<3<4$.
• The pair $(2,8)$ is true because $a_2=1$, $a_8=4$ and $1<2<4<8$.
• The pair $(3,8)$ is true because $a_3=2$, $a_8=4$ and $2<3<4<8$.

Tutorial
从前往后遍历，遇到满足 $a_i<i$ 的值就将其坐标 $i$存起来

在存每个坐标之前，需要对已经存起来的坐标进行判断，有多少个数字满足 $j<a_i$（其中 $j$ 为数组中的坐标），此时直接用二分查找即可

Solution

import sys
from bisect import bisect_left
input = sys.stdin.readline

for _ in range(int(input())):
    n = int(input())
    a = list(map(int, input().split()))
    ans = 0
    all = []
    for i, x in enumerate(a):
        if x <= i:
            ans += bisect_left(all, x)
            all.append(i + 1)
    print(ans)

---

G. Good Key, Bad Key

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

There are $n$ chests. The $i$-th chest contains $a_i$ coins. You need to open all $n$ chests in order from chest $1$ to chest $n$.

There are two types of keys you can use to open a chest:

• a good key, which costs $k$ coins to use;
• a bad key, which does not cost any coins, but will halve all the coins in each unopened chest, including the chest it is about to open. The halving operation will round down to the nearest integer for each chest halved. In other words using a bad key to open chest $i$ will do $a_i=\lfloor \frac{a_i}{2}\rfloor$, $a_{i+1}=\lfloor \frac{a_{i+1}}{2}\rfloor ,\dots ,a_n=\lfloor \frac{a_n}{2}\rfloor$;
• any key (both good and bad) breaks after a usage, that is, it is a one-time use.

You need to use in total $n$ keys, one for each chest. Initially, you have no coins and no keys. If you want to use a good key, then you need to buy it.

During the process, you are allowed to go into debt; for example, if you have $1$ coin, you are allowed to buy a good key worth $k=3$ coins, and your balance will become $-2$ coins.

Find the maximum number of coins you can have after opening all $n$ chests in order from chest $1$ to chest $n$.

Input

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

The first line of each test case contains two integers $n$ and $k$ ($1\le n\le 10^5$; $0\le k\le 10^9$) — the number of chests and the cost of a good key respectively.

The second line of each test case contains $n$ integers $a_i$ ($0\le a_i\le 10^9$) — the amount of coins in each chest.

The sum of $n$ over all test cases does not exceed $10^5$.

Output

For each test case output a single integer — the maximum number of coins you can obtain after opening the chests in order from chest $1$ to chest $n$.

Please note, that the answer for some test cases won’t fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language (like long long for C++).

Example
input

5
4 5
10 10 3 1
1 2
1
3 12
10 10 29
12 51
5 74 89 45 18 69 67 67 11 96 23 59
2 57
85 60

output

11
0
13
60
58

Note

In the first test case, one possible strategy is as follows:

• Buy a good key for $5$ coins, and open chest $1$, receiving $10$ coins. Your current balance is $0+10-5=5$ coins.
• Buy a good key for $5$ coins, and open chest $2$, receiving $10$ coins. Your current balance is $5+10-5=10$ coins.
• Use a bad key and open chest $3$. As a result of using a bad key, the number of coins in chest $3$ becomes $\lfloor \frac{3}{2}\rfloor =1$, and the number of coins in chest $4$ becomes $\lfloor \frac{1}{2}\rfloor =0$. Your current balance is $10+1=11$.
• Use a bad key and open chest $4$. As a result of using a bad key, the number of coins in chest $4$ becomes $\lfloor \frac{0}{2}\rfloor =0$. Your current balance is $11+0=11$.

At the end of the process, you have $11$ coins, which can be proven to be maximal.

Tutorial
先全部用好钥匙，最后再用坏钥匙是最佳的，证明过程如下：

假设我们使用了一把坏钥匙，然后又使用了一把好钥匙，这样我们就获得了 $\lfloor \frac{a_i}{2}\rfloor +\lfloor \frac{a_{i+1}}{2}\rfloor -k$ 个硬币，如果我们先使用好钥匙，再使用坏钥匙，那么我们将会得到 $a_i+\lfloor \frac{a_{i+1}}{2}\rfloor -k$ 个硬币，由此可见，先使用好钥匙，再使用坏钥匙会是最优解

所以我们只需要从前往后遍历，从每个数往后判断 $30$ 个坏钥匙（因为数据范围为 $0\le a_i\le 10^9$ ，而 ${\log }_2(10^9)\approx 30$，所以只需要往后判断 $30$ 个数），求和判断最大值即可

Solution

import sys
input = sys.stdin.readline

for _ in range(int(input())):
    n, k = map(int, input().split())
    a = list(map(int, input().split()))
    ans, cnt = sum(x >> (i + 1) for i, x in enumerate(a[:31])), 0
    for i in range(n):
        cnt += a[i] - k
        mid = 0
        for j in range(1, min(31, n - i)):
            mid += a[i + j] >> j
        ans = max(ans, cnt + mid)
    print(ans)