text
stringlengths 424
69.5k
|
|---|
### Prompt
Construct a CPP code solution to the problem outlined:
A boy Petya loves chess very much. He even came up with a chess piece of his own, a semiknight. The semiknight can move in any of these four directions: 2 squares forward and 2 squares to the right, 2 squares forward and 2 squares to the left, 2 squares backward and 2 to the right and 2 squares backward and 2 to the left. Naturally, the semiknight cannot move beyond the limits of the chessboard.
Petya put two semiknights on a standard chessboard. Petya simultaneously moves with both semiknights. The squares are rather large, so after some move the semiknights can meet, that is, they can end up in the same square. After the meeting the semiknights can move on, so it is possible that they meet again. Petya wonders if there is such sequence of moves when the semiknights meet. Petya considers some squares bad. That is, they do not suit for the meeting. The semiknights can move through these squares but their meetings in these squares don't count.
Petya prepared multiple chess boards. Help Petya find out whether the semiknights can meet on some good square for each board.
Please see the test case analysis.
Input
The first line contains number t (1 ≤ t ≤ 50) — the number of boards. Each board is described by a matrix of characters, consisting of 8 rows and 8 columns. The matrix consists of characters ".", "#", "K", representing an empty good square, a bad square and the semiknight's position, correspondingly. It is guaranteed that matrix contains exactly 2 semiknights. The semiknight's squares are considered good for the meeting. The tests are separated by empty line.
Output
For each test, print on a single line the answer to the problem: "YES", if the semiknights can meet and "NO" otherwise.
Examples
Input
2
........
........
......#.
K..##..#
.......#
...##..#
......#.
K.......
........
........
..#.....
..#..#..
..####..
...##...
........
....K#K#
Output
YES
NO
Note
Consider the first board from the sample. We will assume the rows and columns of the matrix to be numbered 1 through 8 from top to bottom and from left to right, correspondingly. The knights can meet, for example, in square (2, 7). The semiknight from square (4, 1) goes to square (2, 3) and the semiknight goes from square (8, 1) to square (6, 3). Then both semiknights go to (4, 5) but this square is bad, so they move together to square (2, 7).
On the second board the semiknights will never meet.
### Response
```cpp
#include <bits/stdc++.h>
char board[8][8];
int target[2];
int start[2];
int found;
void test() {
if ((target[0] - start[0]) % 4) {
found = 0;
return;
}
if ((target[1] - start[1]) % 4) {
found = 0;
return;
}
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
if ((i - target[0]) % 4) continue;
if ((j - target[1]) % 4) continue;
if (board[i][j] != '#') {
found = 1;
break;
}
}
}
int main() {
int already;
int q;
scanf("%d\n", &q);
char temp;
while (q-- > 0) {
already = 0;
memset(board, 0, sizeof(board));
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
scanf("%1c", &temp);
while (temp == '\n') {
scanf("%1c", &temp);
}
board[i][j] = temp;
if (!already && board[i][j] == 'K') {
start[0] = i;
start[1] = j;
already = 1;
}
if (already && board[i][j] == 'K') {
target[0] = i;
target[1] = j;
}
}
found = 0;
test();
if (found)
printf("YES\n", found);
else
printf("NO\n", found);
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Today Tavas got his test result as an integer score and he wants to share it with his girlfriend, Nafas.
His phone operating system is Tavdroid, and its keyboard doesn't have any digits! He wants to share his score with Nafas via text, so he has no choice but to send this number using words.
<image>
He ate coffee mix without water again, so right now he's really messed up and can't think.
Your task is to help him by telling him what to type.
Input
The first and only line of input contains an integer s (0 ≤ s ≤ 99), Tavas's score.
Output
In the first and only line of output, print a single string consisting only from English lowercase letters and hyphens ('-'). Do not use spaces.
Examples
Input
6
Output
six
Input
99
Output
ninety-nine
Input
20
Output
twenty
Note
You can find all you need to know about English numerals in <http://en.wikipedia.org/wiki/English_numerals> .
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[3];
while (cin >> s) {
int l = strlen(s);
string a[] = {"twenty", "thirty", "forty", "fifty",
"sixty", "seventy", "eighty", "ninety"};
string b[] = {"zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine"};
if (l == 1) {
for (int i = 0; i < 10; i++)
if ((s[0] - 48) == i) cout << b[i] << endl;
} else if (l == 2) {
if (s[0] != '1') {
for (int i = 2; i <= 9; i++) {
if ((s[0] - 48) == i) {
for (int j = 1; j < 10; j++) {
if ((s[1] - 48) == j) cout << a[i - 2] << "-" << b[j] << endl;
}
if ((s[1] - 48) == 0) cout << a[i - 2] << endl;
}
}
} else if (s[0] == '1') {
if (s[1] == '0') cout << "ten" << endl;
if (s[1] == '1') cout << "eleven" << endl;
if (s[1] == '2') cout << "twelve" << endl;
if (s[1] == '3') cout << "thirteen" << endl;
if (s[1] == '4') cout << "fourteen" << endl;
if (s[1] == '5') cout << "fifteen" << endl;
if (s[1] == '6') cout << "sixteen" << endl;
if (s[1] == '7') cout << "seventeen" << endl;
if (s[1] == '8') cout << "eighteen" << endl;
if (s[1] == '9') cout << "nineteen" << endl;
}
}
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Given is a positive integer N.
Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:
* When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.
Constraints
* 1 \leq N \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
25
Output
17
Input
1
Output
1
Input
100
Output
108
Input
2020
Output
40812
Input
200000
Output
400000008
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int sum[10][10];
int main(){
long long int N,ans=0;
cin >> N;
for(int i=1;i<=N;i++){
string S = to_string(i);
sum[S[0]-'0'][S.back()-'0']++;
}
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
ans += sum[i][j]*sum[j][i];
}
}
cout << ans << endl;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Of course, many of you can calculate φ(n) — the number of positive integers that are less than or equal to n, that are coprime with n. But what if we need to calculate φ(φ(...φ(n))), where function φ is taken k times and n is given in the canonical decomposition into prime factors?
You are given n and k, calculate the value of φ(φ(...φ(n))). Print the result in the canonical decomposition into prime factors.
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of distinct prime divisors in the canonical representaion of n.
Each of the next m lines contains a pair of space-separated integers pi, ai (2 ≤ pi ≤ 106; 1 ≤ ai ≤ 1017) — another prime divisor of number n and its power in the canonical representation. The sum of all ai doesn't exceed 1017. Prime divisors in the input follow in the strictly increasing order.
The last line contains integer k (1 ≤ k ≤ 1018).
Output
In the first line, print integer w — the number of distinct prime divisors of number φ(φ(...φ(n))), where function φ is taken k times.
Each of the next w lines must contain two space-separated integers qi, bi (bi ≥ 1) — another prime divisor and its power in the canonical representaion of the result. Numbers qi must go in the strictly increasing order.
Examples
Input
1
7 1
1
Output
2
2 1
3 1
Input
1
7 1
2
Output
1
2 1
Input
1
2 100000000000000000
10000000000000000
Output
1
2 90000000000000000
Note
You can read about canonical representation of a positive integer here: http://en.wikipedia.org/wiki/Fundamental_theorem_of_arithmetic.
You can read about function φ(n) here: http://en.wikipedia.org/wiki/Euler's_totient_function.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000006;
const int T = 1000000;
int n, m, x, cnt, num;
int p[maxn], com[maxn], id[maxn];
long long t;
long long a[maxn], k[maxn], sos[maxn];
bool flag;
void ols(int n) {
for (register int i = 2; i <= n; ++i) {
if (!com[i]) p[++cnt] = com[i] = i, id[i] = cnt;
for (register int j = 1; j <= cnt && i * p[j] <= n; ++j) {
com[i * p[j]] = p[j];
if (i % p[j] == 0) break;
}
}
}
int main() {
ols(T);
scanf("%d", &m);
while (m--) scanf("%d", &x), scanf("%I64d", &a[id[x]]);
scanf("%I64d", &t);
for (register int i = 1; i <= cnt; ++i) k[i] = t;
flag = true;
while (flag) {
flag = false;
for (register int i = 1; i <= cnt; ++i)
if (a[i]) {
if (!k[i]) continue;
t = min(a[i], k[i]);
a[i] -= t, k[i] -= t;
sos[i] += t - 1, flag = true;
int tmp = p[i] - 1;
while (tmp != 1) {
int cur = id[com[tmp]];
a[cur] += t;
tmp /= com[tmp];
}
} else if (sos[i])
--sos[i];
else if (k[i])
--k[i];
}
for (register int i = 1; i <= cnt; ++i) num += (bool)a[i];
printf("%d\n", num);
for (register int i = 1; i <= cnt; ++i)
if (a[i]) printf("%d %I64d\n", p[i], a[i]);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 ≤ |s| ≤ 2·105) — the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' — the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s = s + '.';
for (int i = 0; i < s.size() - 1; i++)
if (s[i] == s[i + 1]) {
if (s[i] != 'a' && s[i + 2] != 'a')
s[i + 1] = 'a';
else if (s[i] != 'b' && s[i + 2] != 'b')
s[i + 1] = 'b';
else if (s[i] != 'c' && s[i + 2] != 'c')
s[i + 1] = 'c';
}
s.resize(s.size() - 1);
cout << s << endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool vwl(char c) {
return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
}
string cnst(string a, string b, string c, string d) {
if (a == b && b == c && c == d) return "aaaa";
if (a == b && c == d && b != c) return "aabb";
if (b == c && a == d && b != a) return "abba";
if (a == c && b == d && a != b) return "abab";
return "NO";
}
void solve() {
int n, k;
cin >> n >> k;
vector<string> v(4 * n);
for (auto &x : v) cin >> x;
string p1, p2, p3, p4;
p1 = p2 = p3 = p4 = "b";
int ln = v[0].size(), now = 0;
for (int i = ln - 1; i >= 0; i--) {
if (vwl(v[0][i])) now++;
if (now == k) {
p1 = v[0].substr(i);
break;
}
}
if (p1 == "b") {
cout << "NO\n";
return;
}
ln = v[1].size(), now = 0;
for (int i = ln - 1; i >= 0; i--) {
if (vwl(v[1][i])) now++;
if (now == k) {
p2 = v[1].substr(i);
break;
}
}
if (p2 == "b") {
cout << "NO\n";
return;
}
ln = v[2].size(), now = 0;
for (int i = ln - 1; i >= 0; i--) {
if (vwl(v[2][i])) now++;
if (now == k) {
p3 = v[2].substr(i);
break;
}
}
if (p3 == "b") {
cout << "NO\n";
return;
}
ln = v[3].size(), now = 0;
for (int i = ln - 1; i >= 0; i--) {
if (vwl(v[3][i])) now++;
if (now == k) {
p4 = v[3].substr(i);
break;
}
}
if (p4 == "b") {
cout << "NO\n";
return;
}
string res = cnst(p1, p2, p3, p4);
if (res == "NO") {
cout << res + '\n';
return;
}
for (int i = 4; i < 4 * n; i += 4) {
string s1, s2, s3, s4;
s1 = s2 = s3 = s4 = "b";
now = 0, ln = v[i].size();
for (int j = ln - 1; j >= 0; j--) {
if (vwl(v[i][j])) now++;
if (now == k) {
s1 = v[i].substr(j);
break;
}
}
if (s1 == "b") {
cout << "NO\n";
return;
}
now = 0, ln = v[i + 1].size();
for (int j = ln - 1; j >= 0; j--) {
if (vwl(v[i + 1][j])) now++;
if (now == k) {
s2 = v[i + 1].substr(j);
break;
}
}
if (s2 == "b") {
cout << "NO\n";
return;
}
now = 0, ln = v[i + 2].size();
for (int j = ln - 1; j >= 0; j--) {
if (vwl(v[i + 2][j])) now++;
if (now == k) {
s3 = v[i + 2].substr(j);
break;
}
}
if (s3 == "b") {
cout << "NO\n";
return;
}
now = 0, ln = v[i + 3].size();
for (int j = ln - 1; j >= 0; j--) {
if (vwl(v[i + 3][j])) now++;
if (now == k) {
s4 = v[i + 3].substr(j);
break;
}
}
if (s4 == "b") {
cout << "NO\n";
return;
}
string cres = cnst(s1, s2, s3, s4);
if (res == "aaaa" && cres != "aaaa") {
res = cres;
continue;
}
if (cres == "aaaa") continue;
if (cres == "NO" || cres != res) {
cout << "NO\n";
return;
}
}
cout << res + '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Little Vasya likes very much to play with sets consisting of positive integers. To make the game more interesting, Vasya chose n non-empty sets in such a way, that no two of them have common elements.
One day he wanted to show his friends just how interesting playing with numbers is. For that he wrote out all possible unions of two different sets on n·(n - 1) / 2 pieces of paper. Then he shuffled the pieces of paper. He had written out the numbers in the unions in an arbitrary order.
For example, if n = 4, and the actual sets have the following form {1, 3}, {5}, {2, 4}, {7}, then the number of set pairs equals to six. The six pieces of paper can contain the following numbers:
* 2, 7, 4.
* 1, 7, 3;
* 5, 4, 2;
* 1, 3, 5;
* 3, 1, 2, 4;
* 5, 7.
Then Vasya showed the pieces of paper to his friends, but kept the n sets secret from them. His friends managed to calculate which sets Vasya had thought of in the first place. And how about you, can you restore the sets by the given pieces of paper?
Input
The first input file line contains a number n (2 ≤ n ≤ 200), n is the number of sets at Vasya's disposal. Then follow sets of numbers from the pieces of paper written on n·(n - 1) / 2 lines. Each set starts with the number ki (2 ≤ ki ≤ 200), which is the number of numbers written of the i-th piece of paper, and then follow ki numbers aij (1 ≤ aij ≤ 200). All the numbers on the lines are separated by exactly one space. It is guaranteed that the input data is constructed according to the above given rules from n non-intersecting sets.
Output
Print on n lines Vasya's sets' description. The first number on the line shows how many numbers the current set has. Then the set should be recorded by listing its elements. Separate the numbers by spaces. Each number and each set should be printed exactly once. Print the sets and the numbers in the sets in any order. If there are several answers to that problem, print any of them.
It is guaranteed that there is a solution.
Examples
Input
4
3 2 7 4
3 1 7 3
3 5 4 2
3 1 3 5
4 3 1 2 4
2 5 7
Output
1 7
2 2 4
2 1 3
1 5
Input
4
5 6 7 8 9 100
4 7 8 9 1
4 7 8 9 2
3 1 6 100
3 2 6 100
2 1 2
Output
3 7 8 9
2 6 100
1 1
1 2
Input
3
2 1 2
2 1 3
2 2 3
Output
1 1
1 2
1 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int parent[205];
void init() {
for (long long i = 0; i < ((long long)205); i++) parent[i] = i;
}
int find(int a) {
if (parent[a] == a) return a;
return parent[a] = find(parent[a]);
}
void uni(int a, int b) {
parent[find(a)] = find(b);
return;
}
bool exist[205];
int cnt[205][205];
int n, m, a[205];
int main() {
for (long long i = 0; i < ((long long)205); i++) exist[i] = false;
for (long long i = 0; i < ((long long)205); i++)
for (long long j = 0; j < ((long long)205); j++) cnt[i][j] = 0;
init();
scanf("%d", &n);
for (long long i = 0; i < ((long long)n * (n - 1) / 2); i++) {
scanf("%d", &m);
for (long long j = 0; j < ((long long)m); j++) scanf("%d", &a[j]);
for (long long j = 0; j < ((long long)m); j++) exist[a[j]] = true;
for (long long j = 0; j < ((long long)m); j++)
for (long long k = 0; k < ((long long)m); k++) cnt[a[j]][a[k]]++;
}
for (long long i = 0; i < ((long long)205); i++)
for (long long j = 0; j < ((long long)i); j++)
if (cnt[i][j] == n - 1) uni(i, j);
vector<int> res[205];
for (long long i = 0; i < ((long long)205); i++)
if (exist[i]) res[find(i)].push_back(i);
if (n != 2) {
for (long long i = 0; i < ((long long)205); i++)
if (((long long)res[i].size())) {
cout << ((long long)res[i].size()) << " ";
for (long long j = 0; j < ((long long)((long long)res[i].size())); j++)
cout << res[i][j] << " ";
cout << endl;
}
} else {
cout << "1 " << a[0] << endl;
cout << m - 1 << " ";
for (long long i = 0; i < ((long long)m - 1); i++) cout << a[i + 1] << " ";
cout << endl;
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
The Fire Lord attacked the Frost Kingdom. He has already got to the Ice Fortress, where the Snow Queen dwells. He arranged his army on a segment n in length not far from the city walls. And only the frost magician Solomon can save the Frost Kingdom.
<image>
The n-long segment is located at a distance equal exactly to 1 from the castle walls. It can be imaginarily divided into unit segments. On some of the unit segments fire demons are located — no more than one demon per position. Each demon is characterised by his strength - by some positive integer. We can regard the fire demons being idle.
Initially Solomon is positioned on the fortress wall. He can perform the following actions several times in a row:
* "L" — Solomon shifts one unit to the left. This movement cannot be performed on the castle wall.
* "R" — Solomon shifts one unit to the left. This movement cannot be performed if there's no ice block to the right.
* "A" — If there's nothing to the right of Solomon, then Solomon creates an ice block that immediately freezes to the block that Solomon is currently standing on. If there already is an ice block, then Solomon destroys it. At that the ice blocks to the right of the destroyed one can remain but they are left unsupported. Those ice blocks fall down.
Solomon spends exactly a second on each of these actions.
As the result of Solomon's actions, ice blocks' segments fall down. When an ice block falls on a fire demon, the block evaporates and the demon's strength is reduced by 1. When the demons' strength is equal to 0, the fire demon vanishes. The picture below shows how it happens. The ice block that falls on the position with no demon, breaks into lots of tiny pieces and vanishes without hurting anybody.
<image>
Help Solomon destroy all the Fire Lord's army in minimum time.
Input
The first line contains an integer n (1 ≤ n ≤ 1000). The next line contains n numbers, the i-th of them represents the strength of the fire demon standing of the i-th position, an integer from 1 to 100. If there's no demon on the i-th position, then the i-th number equals to 0. It is guaranteed that the input data have at least one fire demon.
Output
Print a string of minimum length, containing characters "L", "R" and "A" — the succession of actions leading to the required result.
If there are several possible answers, print any of them.
Examples
Input
3
1 0 1
Output
ARARARALLLA
Input
3
0 2 0
Output
ARARALAARALA
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int v[1024];
int vv[1024];
int N;
int try_it(int last) {
for (int i = (0); i < (N); i++) vv[i] = v[i];
for (int i = (last); i < (N); i++) vv[i] = max(0, vv[i] - 1);
vv[N] = 0;
int NN = N;
while (NN > 0 && vv[NN - 1] == 0) --NN;
int moves = 0, p = -1;
while (vv[NN - 1] > 0) {
moves += 3;
++p;
while (vv[p + 1] >= vv[p]) {
moves += 2;
++p;
}
++moves;
--vv[p];
--p;
while (p >= 0 && vv[p] == vv[p + 1] + 1) {
--vv[p];
--p;
moves++;
}
moves++;
}
return moves + N * 3 - 2 * p - last;
}
void do_it(int last) {
for (int i = (0); i < (N); i++) vv[i] = v[i];
for (int i = (last); i < (N); i++) vv[i] = max(0, vv[i] - 1);
vv[N] = 0;
int NN = N;
while (NN > 0 && vv[NN - 1] == 0) --NN;
int p = -1;
while (vv[NN - 1] > 0) {
cout << "ARA";
++p;
while (vv[p + 1] >= vv[p]) {
cout << "RA";
++p;
}
cout << "L";
--vv[p];
--p;
while (p >= 0 && vv[p] == vv[p + 1] + 1) {
--vv[p];
--p;
cout << "L";
}
cout << "A";
}
while (p++ < N - 1) cout << "AR";
cout << "A";
while (p-- > last) cout << "L";
cout << "A\n";
}
int main() {
ios::sync_with_stdio(false);
cin >> N;
for (int i = (0); i < (N); i++) cin >> v[i];
v[N] = 0;
while (N > 0 && v[N - 1] == 0) --N;
int best = try_it(0);
int last = 0;
for (int i = (1); i < (N); i++) {
int c = try_it(i);
if (c < best) {
best = c;
last = i;
}
}
do_it(last);
return 0;
int p = -1;
int K = 0;
while (v[N - 1] > 0 && K++ < 10) {
cout << "ARA";
++p;
while (v[p + 1] >= v[p]) {
cout << "RA";
++p;
}
cout << "L";
--v[p];
--p;
while (p >= 0 && v[p] == v[p + 1] + 1) {
--v[p];
--p;
cout << "L";
}
cout << "A";
cout << endl;
cout << p << endl;
for (int i = (0); i < (N); i++) cout << v[i] << " ";
cout << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 ≤ n ≤ 200 000, 0 ≤ s_x, s_y ≤ 10^{9}) — the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^{9}) — the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c — the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y — the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sx, sy, x, y, countsx_ = 0, countsy_ = 0, countsx = 0,
countsy = 0;
cin >> n >> sx >> sy;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if ((min(x, sx) <= sx - 1 && sx - 1 <= max(x, sx)) &&
(min(y, sy) <= sy && sy <= max(y, sy)))
countsx_++;
if ((min(x, sx) <= sx && sx <= max(x, sx)) &&
(min(y, sy) <= sy - 1 && sy - 1 <= max(y, sy)))
countsy_++;
if ((min(x, sx) <= sx + 1 && sx + 1 <= max(x, sx)) &&
(min(y, sy) <= sy && sy <= max(y, sy)))
countsx++;
if ((min(x, sx) <= sx && sx <= max(x, sx)) &&
(min(y, sy) <= sy + 1 && sy + 1 <= max(y, sy)))
countsy++;
}
long long m = max(countsx, max(countsx_, max(countsy, countsy_)));
if (countsx == m)
cout << countsx << '\n' << sx + 1 << ' ' << sy;
else if (countsx_ == m)
cout << countsx_ << '\n' << sx - 1 << ' ' << sy;
else if (countsy == m)
cout << countsy << '\n' << sx << ' ' << sy + 1;
else if (countsy_ == m)
cout << countsy_ << '\n' << sx << ' ' << sy - 1;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
problem
Play by arranging white and black stones on the table. First, place the stones on the left edge of the table. Then place the stones in the second place from the left. Repeat this n times to arrange n stones in a horizontal row. However, when placing a new i-th go stone, replace the go stone on the table according to the following rules.
* If i is odd: Do not replace the stones that were on the table, but place the new stones i-th from the left.
* If i is even: If the color of the new go stone placed i-th from the left and the color of the rightmost go stone on the table are the same, the go stone on the table is not replaced and the new go stone is placed i-th from the left. If this is not the case, that is, if the color of the new i-th go stone from the left is different from the color of the right-most go stone on the table, first remove all the consecutive right-end go stones of the same color on the table, and then use the i-th go stone. Replace with a go stone of the same color, and place the i-th go stone on the right edge of the table.
For example, when the first 7 go stones are placed,
○○ ●● ○○○
(○ represents white go stones, ● represents black go stones.)
* If the 8th go stone is white (○), it is the same color as the rightmost go stone, so leave it as it is. Therefore, the go stone on the table is
○○ ●● ○○○○
Will be.
* If the 8th go stone is black (●), the color is different from the rightmost go stone (○), so first remove the 3 consecutive white go stones (○) on the right end of the table, and then remove the black go stone (●). And put the eighth go stone on the far right. Therefore, the go stone on the table
○○ ●●●●●●
Will be.
Given the order of the stones to be placed as input, create a program to find the number of white stones placed on the table after arranging n stones.
input
The input consists of multiple datasets. Each dataset is given in the following format.
A positive integer n (1 ≤ n ≤ 100000) is written on the first line. In the second and subsequent lines i + 1 (1 ≤ i ≤ n), the color of the go stone placed in the i-th position is written. The integer ci is written, and if ci is 0, it means that the color of the i-th go stone is white, and if it is 1, it means that the color of the i-th go stone is black.
Of the scoring data, 50% of the points are given by satisfying n ≤ 10000.
When n is 0, it indicates the end of input. The number of datasets does not exceed 10.
output
For each dataset, output the number of white stones placed on the table after arranging n stones in one line.
Examples
Input
8
1
0
1
1
0
0
0
0
8
1
0
1
1
0
0
0
1
0
Output
6
2
Input
None
Output
None
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
while(1){
int n,c,a[100000+2],b[100000+2],k=0,ans=0;
scanf("%d",&n);
if(n==0)break;
scanf("%d",&a[0]);
b[0]=1;
for(int i=2;i<=n;i++){
scanf("%d",&c);
if(i%2!=0){
if(c==a[k])b[k]++;
else {a[k+1]=c; b[k+1]=1; k++;}
}
else {
if(c==a[k])b[k]++;
else {
if(k==0){a[0]=c; b[0]+=1;}
else {b[k-1]+=b[k]+1; k--;}
}
}
}
for(int i=0;i<=k;i++){
if(a[i]==0)ans+=b[i];
}
printf("%d\n",ans);
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
The tablet interface technology, which can be operated by touching the screen with a finger, has also been applied in the field of games, and various types of games with new operability have been created. The game currently being developed by AZ is one of them.
The requirements for this software (game) are as follows.
* The screen has a 2D grid of X columns x Y rows.
* The cells of the grid are painted in one of three colors: red (R), green (G), and brown (B).
* There are buttons R, G, B to change the color of the cell, and when this button is pressed, the upper left (0,0) cell will be changed to that color.
* When the color of the top left cell is changed, all adjacent cells painted in the same color as the original color of that cell will change to the specified color. That is, all cells that are connected by cells with the same original color will be changed to the specified color.
It is a game that fills the grid in this way and finally makes the entire grid one color. A high score will be given if you solve it with a few steps.
As a programmer at AZ, you have decided to develop a part of the logic of this game. First of all, in order to calculate this maximum score, I decided to make a program to find out how many times the selection button should be operated to make the grid one color if the game is solved in the shortest time.
<image>
input
Given multiple datasets. The end of the input is indicated by two zeros. Each dataset is given in the following format:
X Y
c1,1 c2,1 ... cX,1
c1,2 c2,2 ... cX,2
::
c1, Y c2, Y ... cX, Y
The first row gives the grid columns and row sizes X, Y (2 ≤ X, Y ≤ 10). The following Y-row is given the letters ci, j, which represent the color of the cells in the i-th and j-th rows, separated by blanks.
output
Outputs the minimum number of button operations on one line for each dataset.
Example
Input
3 3
R G B
G G G
G B B
2 4
R G
G G
R B
B R
4 3
G G B R
G R R G
B G G R
0 0
Output
2
4
4
### Response
```cpp
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cmath>
#include<cstring>
#include<cctype>
#include<complex>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<functional>
#include<vector>
#include<string>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<bitset>
using namespace std;
const int dx[] = {1,0,-1,0};
const int dy[] = {0,1,0,-1};
#define INF 1e+8
#define EPS 1e-10
#define PB push_back
#define fi first
#define se second
#define ll long long
#define reps(i,j,k) for(int i = (j); i < (k); i++)
#define rep(i,j) reps(i,0,j)
typedef pair<int,int> Pii;
typedef vector<int> vi;
class Data{
public:
char field[10][10];
int cnt;
Data(){}
Data(char _field[10][10],int _cnt){
cnt = _cnt;
rep(i,10){
rep(j,10){
field[i][j] = _field[i][j];
}
}
}
};
bool check(char stage[10][10],int w,int h){
int top = stage[0][0];
rep(i,h){
rep(j,w){
if(top != stage[i][j])return false;
}
}
return true;
}
void copy(char sub[2][10][10],char stage[10][10],int w,int h){
rep(i,h){
rep(j,w){
sub[0][i][j] = stage[i][j];
sub[1][i][j] = stage[i][j];
}
}
return ;
}
void dfs(int y,int x,bool memo[10][10],int w,int h,char stage[2][10][10],int col){
rep(i,4){
int nx = x + dx[i];
int ny = y + dy[i];
if(nx < 0 || nx > w-1 || ny < 0 || ny > h-1 || memo[ny][nx]==1 )continue;
if(col == stage[0][ny][nx] || col == stage[1][ny][nx]){
stage[0][ny][nx] = (col+1)%3;
stage[1][ny][nx] = (col+2)%3;
memo[ny][nx] = 1;
dfs(ny,nx,memo,w,h,stage,col);
}
}
return ;
}
int bfs(char stage[10][10],int w,int h){
int ans = -1;
queue < Data > Q;
Q.push(Data(stage,0));
while( !Q.empty() ){
Data d = Q.front();Q.pop();
if(check(d.field,w,h)){
ans = d.cnt;
break;
}
bool memo[10][10]={{0}};
char sub[2][10][10]={{0}};
copy(sub,d.field,w,h);
memo[0][0] = 1;
sub[0][0][0] = (d.field[0][0]+1)%3;
sub[1][0][0] = (d.field[0][0]+2)%3;
dfs(0,0,memo,w,h,sub,d.field[0][0]);
Q.push(Data(sub[0],d.cnt+1));
Q.push(Data(sub[1],d.cnt+1));
}
return ans;
}
int main(){
int w,h;
while(scanf("%d%d",&w,&h),w){
char stage[10][10];
rep(i,h){
rep(j,w){
char tmp;
scanf(" %c",&tmp);
stage[i][j] = ((tmp == 'R')? 0 : (tmp == 'G') ? 1 : 2);
}
}
int ans = bfs(stage,w,h);
printf("%d\n",ans);
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Making Lunch Boxes
Taro has been hooked on making lunch boxes recently. Taro has obtained a new lunch box recipe book today, and wants to try as many of the recipes listed in the book as possible.
Enough of the ingredients for all the recipes are at hand, but they all are in vacuum packs of two. If only one of them is used leaving the other, the leftover will be rotten easily, but making two of the same recipe is not interesting. Thus he decided to make a set of lunch boxes, each with different recipe, that wouldn't leave any unused ingredients.
Note that the book may include recipes for different lunch boxes made of the same set of ingredients.
How many lunch box recipes can Taro try today at most following his dogma?
Input
The input consists of at most 50 datasets, each in the following format.
n m
b1,1...b1,m
...
bn,1...bn,m
The first line contains n, which is the number of recipes listed in the book, and m, which is the number of ingredients. Both n and m are positive integers and satisfy 1 ≤ n ≤ 500, 1 ≤ m ≤ 500 and 1 ≤ n × m ≤ 500. The following n lines contain the information for each recipe with the string of length m consisting of 0 or 1. bi,j implies whether the i-th recipe needs the j-th ingredient. 1 means the ingredient is needed for the recipe and 0 means not. Each line contains at least one 1.
The end of the input is indicated by a line containing two zeros.
Output
For each dataset, output the maximum number of recipes Taro can try.
Sample Input
4 3
110
101
011
110
7 1
1
1
1
1
1
1
1
4 5
10000
01000
00100
00010
6 6
111111
011000
100000
000010
100001
100100
0 0
Output for the Sample Input
3
6
0
6
Example
Input
4 3
110
101
011
110
7 1
1
1
1
1
1
1
1
4 5
10000
01000
00100
00010
6 6
111111
011000
100000
000010
100001
100100
0 0
Output
3
6
0
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define REP(i, n) for (long long i = 0, max_i = (n); i < max_i; i++)
#define REPI(i, a, b) for (long long i = (a), max_i = (b); i < max_i; i++)
#define ALL(obj) begin(obj), end(obj)
#define RALL(obj) rbegin(obj), rend(obj)
#define fi first
#define se second
using ii = pair<int, int>;
vector<ii> dirs = {
{1, 0}, {0, 1}, {-1, 0}, {0, -1}, // 4方向
{1, 1}, {-1, 1}, {-1, -1}, {1, -1}, // 斜め
{0, 0}, // 自身
};
template <class T> inline bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; } return false; }
template <class T> inline bool chmin(T& a, const T& b) { if (a > b) { a = b; return true; } return false; }
// debug
template <class T> ostream& operator<<(ostream& s, vector<T>& d) { REP (i, d.size()) s << d[i] << (i == d.size() - 1 ? "" : " "); return s; }
template <class T> ostream& operator<<(ostream& s, vector<vector<T>>& d) { REP (i, d.size()) s << d[i] << (i == d.size() - 1 ? "" : "\n"); return s; }
template <class T, class S> ostream& operator<<(ostream& s, pair<T, S>& p) { s << "{" << p.first << ", " << p.second << "}"; return s; }
template <class T, class S> ostream& operator<<(ostream& s, map<T, S> m) { for (auto it = m.begin(); it != m.end(); it++) { s << *it << (next(it) == m.end() ? "" : "\n"); } return s; }
#ifdef _MY_DEBUG
#define dump(...) cerr << "/* " << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" << endl, dump_func(__VA_ARGS__), cerr << "*/\n\n";
#else
#define dump(...)
#define endl "\n"
#endif
void dump_func() { cerr << endl; }
template <class Head, class... Tail> void dump_func(Head&& h, Tail&&... t) { cerr << h << (sizeof...(Tail) == 0 ? "" : ", "), dump_func(forward<Tail>(t)...); }
struct Fast { Fast() { cin.tie(0); ios::sync_with_stdio(false); } } fast;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
constexpr int MOD = 1000000007;
// *************** TEMPLATE END ***************
using S = bitset<500>;
const S ZERO;
void solve() {
int n, m; cin >> n >> m;
if (n == 0) exit(0);
vector<unordered_map<S, int>> dp(2);
dp[0][ZERO] = 0;
REP (i, n) {
string s; cin >> s;
S b(s);
for (auto& p: dp[0]) {
chmax(dp[1][p.fi], p.se);
chmax(dp[1][p.fi ^ b], p.se + 1);
}
swap(dp[0], dp[1]);
}
cout << dp[0][ZERO] << endl;
}
signed main() {
while (1) solve();
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You have r red, g green and b blue balloons. To decorate a single table for the banquet you need exactly three balloons. Three balloons attached to some table shouldn't have the same color. What maximum number t of tables can be decorated if we know number of balloons of each color?
Your task is to write a program that for given values r, g and b will find the maximum number t of tables, that can be decorated in the required manner.
Input
The single line contains three integers r, g and b (0 ≤ r, g, b ≤ 2·109) — the number of red, green and blue baloons respectively. The numbers are separated by exactly one space.
Output
Print a single integer t — the maximum number of tables that can be decorated in the required manner.
Examples
Input
5 4 3
Output
4
Input
1 1 1
Output
1
Input
2 3 3
Output
2
Note
In the first sample you can decorate the tables with the following balloon sets: "rgg", "gbb", "brr", "rrg", where "r", "g" and "b" represent the red, green and blue balls, respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 100;
long long int inf = 1e17 + 100;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long int r, b, g;
cin >> r >> b >> g;
long long int sum = r + b + g, mx = max({r, b, g});
cout << min(sum / 3, sum - mx) << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Tavas is a cheerleader in the new sports competition named "Pashmaks".
<image>
This competition consists of two part: swimming and then running. People will immediately start running R meters after they finished swimming exactly S meters. A winner is a such person that nobody else finishes running before him/her (there may be more than one winner).
Before the match starts, Tavas knows that there are n competitors registered for the match. Also, he knows that i-th person's swimming speed is si meters per second and his/her running speed is ri meters per second. Unfortunately, he doesn't know the values of R and S, but he knows that they are real numbers greater than 0.
As a cheerleader, Tavas wants to know who to cheer up. So, he wants to know all people that might win. We consider a competitor might win if and only if there are some values of R and S such that with these values, (s)he will be a winner.
Tavas isn't really familiar with programming, so he asked you to help him.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 2 × 105).
The next n lines contain the details of competitors. i-th line contains two integers si and ri (1 ≤ si, ri ≤ 104).
Output
In the first and the only line of output, print a sequence of numbers of possible winners in increasing order.
Examples
Input
3
1 3
2 2
3 1
Output
1 2 3
Input
3
1 2
1 1
2 1
Output
1 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000003;
int m;
int n;
int x[200001];
int y[200002];
int p[200002];
int l;
int s[200002];
vector<int> v[200002];
bool cmp(int i, int j) { return x[i] > x[j] || (x[i] == x[j] && y[i] > y[j]); }
bool cross(int a, int b, int c) {
return (long long)(x[a] - x[c]) * (y[a] - y[b]) * x[b] * y[c] >
(long long)(y[a] - y[c]) * (x[a] - x[b]) * x[c] * y[b];
}
int main(int argc, char *argv[]) {
cin >> n;
for (int i = 0; i < n; ++i) scanf("%d %d", x + i, y + i);
for (int i = 0; i < n; ++i) p[i] = i;
sort(p, p + n, cmp);
m = 1;
s[0] = p[0];
for (int i = 1; i < n; ++i) {
int j = p[i];
if (x[s[m - 1]] == x[j] && y[s[m - 1]] == y[j]) {
v[s[m - 1]].push_back(j);
continue;
}
if (y[j] <= y[s[m - 1]]) continue;
while (m > 1 && cross(s[m - 2], s[m - 1], j)) --m;
s[m++] = j;
}
for (int i = 0; i < m; ++i) {
for (int j : v[s[i]]) s[m++] = j;
}
sort(s, s + m);
for (int i = 0; i < m; ++i) printf("%d ", s[i] + 1);
cout << endl;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
We have N integers A_1, A_2, ..., A_N.
There are \frac{N(N-1)}{2} ways to choose two of them and form a pair. If we compute the product of each of those pairs and sort the results in ascending order, what will be the K-th number in that list?
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq K \leq \frac{N(N-1)}{2}
* -10^9 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 \dots A_N
Output
Print the answer.
Examples
Input
4 3
3 3 -4 -2
Output
-6
Input
10 40
5 4 3 2 -1 0 0 0 0 0
Output
6
Input
30 413
-170202098 -268409015 537203564 983211703 21608710 -443999067 -937727165 -97596546 -372334013 398994917 -972141167 798607104 -949068442 -959948616 37909651 0 886627544 -20098238 0 -948955241 0 -214720580 277222296 -18897162 834475626 0 -425610555 110117526 663621752 0
Output
448283280358331064
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll N,K;
int my_b_search(ll key,ll val,bool mode,vector<int64_t>& A){
//mode -> true ならば昇順での二分探索 falseなら降順での二分探索
int ok = mode ? -1 : N;
int ng = mode ? N : -1;
while(abs(ok-ng)>1){
int mid=(ok+ng)/2;
if(val*A[mid]<=key)ok=mid;
else ng=mid;
}
return ok;
}
bool f(ll key,vector<int64_t>& A){
ll cnt=0;
for(int i=0;i<N;i++){
if(A[i]>=0){
cnt+=my_b_search(key,A[i],true,A)+1;
}else{
cnt+=N-my_b_search(key,A[i],false,A);
}
if(key>=A[i]*A[i])cnt--;
}
return cnt>=2*K;
}
int main(){
cin>>N>>K;
vector<int64_t> A(N);
for(int64_t& a:A){
cin>>a;
}
sort(A.begin(),A.end());
int64_t ok=1e18,ng=-1e18;
while(ok-ng!=1){
int64_t mid=(ok+ng)/2;
if(f(mid,A)){
ok=mid;
}else{
ng=mid;
}
}
cout<<ok<<endl;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
The winter in Berland lasts n days. For each day we know the forecast for the average air temperature that day.
Vasya has a new set of winter tires which allows him to drive safely no more than k days at any average air temperature. After k days of using it (regardless of the temperature of these days) the set of winter tires wears down and cannot be used more. It is not necessary that these k days form a continuous segment of days.
Before the first winter day Vasya still uses summer tires. It is possible to drive safely on summer tires any number of days when the average air temperature is non-negative. It is impossible to drive on summer tires at days when the average air temperature is negative.
Vasya can change summer tires to winter tires and vice versa at the beginning of any day.
Find the minimum number of times Vasya needs to change summer tires to winter tires and vice versa to drive safely during the winter. At the end of the winter the car can be with any set of tires.
Input
The first line contains two positive integers n and k (1 ≤ n ≤ 2·105, 0 ≤ k ≤ n) — the number of winter days and the number of days winter tires can be used. It is allowed to drive on winter tires at any temperature, but no more than k days in total.
The second line contains a sequence of n integers t1, t2, ..., tn ( - 20 ≤ ti ≤ 20) — the average air temperature in the i-th winter day.
Output
Print the minimum number of times Vasya has to change summer tires to winter tires and vice versa to drive safely during all winter. If it is impossible, print -1.
Examples
Input
4 3
-5 20 -3 0
Output
2
Input
4 2
-5 20 -3 0
Output
4
Input
10 6
2 -5 1 3 0 0 -4 -3 1 0
Output
3
Note
In the first example before the first winter day Vasya should change summer tires to winter tires, use it for three days, and then change winter tires to summer tires because he can drive safely with the winter tires for just three days. Thus, the total number of tires' changes equals two.
In the second example before the first winter day Vasya should change summer tires to winter tires, and then after the first winter day change winter tires to summer tires. After the second day it is necessary to change summer tires to winter tires again, and after the third day it is necessary to change winter tires to summer tires. Thus, the total number of tires' changes equals four.
### Response
```cpp
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
const int mod = (int)1e9 + 7;
const int maxn = (int)2e5 + 5;
const long long INF = 0x3f3f3f3f3f3f3f3f;
using namespace std;
int a[maxn];
vector<int> v, v2;
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (__typeof(n) i = 1; i <= (n); i++) {
int x;
scanf("%d", &x);
a[i] = x;
if (x < 0) v.push_back(i);
}
int len = v.size();
if (!len) return 0 * puts("0");
if (len > k) return 0 * puts("-1");
int res = k - len;
for (__typeof(len - 2) i = 0; i <= (len - 2); i++) {
v2.push_back(v[i + 1] - v[i] - 1);
}
int ans = 0;
for (__typeof(n) i = 1; i <= (n); i++) {
if ((a[i] < 0 && a[i - 1] >= 0) || (a[i] >= 0 && a[i - 1] < 0)) ans++;
}
int t = inf;
if (a[n] >= 0) t = (n - v[len - 1]);
sort(v2.begin(), v2.end());
len = v2.size();
for (__typeof(len - 1) i = 0; i <= (len - 1); i++) {
if (!v2[i]) continue;
if (res >= v2[i])
res -= v2[i], ans -= 2;
else
break;
}
if (res >= t) ans--;
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Vasya and Petya were tired of studying so they decided to play a game. Before the game begins Vasya looks at array a consisting of n integers. As soon as he remembers all elements of a the game begins. Vasya closes his eyes and Petya does q actions of one of two types:
1) Petya says 4 integers l1, r1, l2, r2 — boundaries of two non-intersecting segments. After that he swaps one random element from the [l1, r1] segment with another random element from the [l2, r2] segment.
2) Petya asks Vasya the sum of the elements of a in the [l, r] segment.
Vasya is a mathematician so he answers Petya the mathematical expectation of the sum of the elements in the segment.
Your task is to write a program which will answer the second type questions as Vasya would do it. In other words your program should print the mathematical expectation of the sum of the elements of a in the [l, r] segment for every second type query.
Input
The first line contains two integers n, q (2 ≤ n ≤ 105, 1 ≤ q ≤ 105) — the number of elements in the array and the number of queries you need to handle.
The second line contains n integers ai (1 ≤ ai ≤ 109) — elements of the array.
The next q lines contain Petya's actions of type 1 or 2.
If it is a type 1 action then the line contains 5 integers 1, l1, r1, l2, r2 (1 ≤ l1 ≤ r1 ≤ n, 1 ≤ l2 ≤ r2 ≤ n).
If it is a type 2 query then the line contains 3 integers 2, l, r (1 ≤ l ≤ r ≤ n).
It is guaranteed that there is at least one type 2 query and segments [l1, r1], [l2, r2] don't have common elements.
Output
For each type 2 query print one real number — the mathematical expectation of the sum of elements in the segment.
Your answer will be considered correct if its absolute or relative error doesn't exceed 10 - 4 — formally, the answer is correct if <image> where x is jury's answer and y is yours.
Examples
Input
4 4
1 1 2 2
1 2 2 3 3
2 1 2
1 1 2 3 4
2 1 2
Output
3.0000000
3.0000000
Input
10 5
1 1 1 1 1 2 2 2 2 2
1 1 5 6 10
2 1 5
1 1 5 6 10
1 1 5 6 10
2 6 10
Output
6.0000000
8.0400000
Input
10 10
1 2 3 4 5 6 7 8 9 10
1 1 5 6 10
1 1 5 6 10
2 1 5
1 1 3 6 9
2 1 3
1 5 7 8 10
1 1 1 10 10
2 1 5
2 7 10
2 1 10
Output
23.0000000
14.0000000
28.0133333
21.5733333
55.0000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, q, L[maxn << 2], R[maxn << 2];
double sum[maxn << 2], add[maxn << 2], mul[maxn << 2];
void pushup(int o) { sum[o] = sum[o * 2] + sum[o * 2 + 1]; }
void pushdown(int o) {
sum[o * 2] = sum[o * 2] * mul[o] + add[o] * (R[o * 2] - L[o * 2] + 1);
sum[o * 2 + 1] =
sum[o * 2 + 1] * mul[o] + add[o] * (R[o * 2 + 1] - L[o * 2 + 1] + 1);
add[o * 2] = add[o * 2] * mul[o] + add[o];
add[o * 2 + 1] = add[o * 2 + 1] * mul[o] + add[o];
mul[o * 2] = mul[o * 2] * mul[o];
mul[o * 2 + 1] = mul[o * 2 + 1] * mul[o];
mul[o] = 1;
add[o] = 0;
}
void build(int o, int l, int r) {
L[o] = l;
R[o] = r;
add[o] = 0;
mul[o] = 1;
if (l == r) {
cin >> sum[o];
return;
}
int mid = (l + r) >> 1;
build(o * 2, l, mid);
build(o * 2 + 1, mid + 1, r);
pushup(o);
}
double query(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) return sum[o];
pushdown(o);
int mid = (l + r) >> 1;
double res = 0.0;
if (x <= mid) res += query(o * 2, l, mid, x, y);
if (y > mid) res += query(o * 2 + 1, mid + 1, r, x, y);
return res;
}
void update1(int o, int l, int r, int x, int y, double v) {
if (x <= l && r <= y) {
sum[o] += v * (r - l + 1);
add[o] += v;
return;
}
pushdown(o);
int mid = (l + r) >> 1;
if (x <= mid) update1(o * 2, l, mid, x, y, v);
if (y > mid) update1(o * 2 + 1, mid + 1, r, x, y, v);
pushup(o);
}
void update2(int o, int l, int r, int x, int y, double v) {
if (x <= l && r <= y) {
add[o] *= v;
sum[o] *= v;
mul[o] *= v;
return;
}
pushdown(o);
int mid = (l + r) >> 1;
if (x <= mid) update2(o * 2, l, mid, x, y, v);
if (y > mid) update2(o * 2 + 1, mid + 1, r, x, y, v);
pushup(o);
}
int main() {
scanf("%d%d", &n, &q);
build(1, 1, n);
while (q--) {
int l1, r1, l2, r2;
int id;
scanf("%d", &id);
if (id == 1) {
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
double sum1 = query(1, 1, n, l1, r1), sum2 = query(1, 1, n, l2, r2);
double len1 = r1 - l1 + 1, len2 = r2 - l2 + 1;
update2(1, 1, n, l1, r1, (len1 - 1) / len1);
update2(1, 1, n, l2, r2, (len2 - 1) / len2);
update1(1, 1, n, l1, r1, 1.0 / len1 * (sum2 / len2));
update1(1, 1, n, l2, r2, 1.0 / len2 * (sum1 / len1));
} else {
scanf("%d%d", &l1, &r1);
printf("%.7lf\n", query(1, 1, n, l1, r1));
}
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You have recently fallen through a hole and, after several hours of unconsciousness, have realized you are in an underground city. On one of your regular, daily walks through the unknown, you have encountered two unusually looking skeletons called Sanz and P’pairus, who decided to accompany you and give you some puzzles for seemingly unknown reasons.
One day, Sanz has created a crossword for you. Not any kind of crossword, but a 1D crossword! You are given m words and a string of length n. You are also given an array p, which designates how much each word is worth — the i-th word is worth pi points. Whenever you find one of the m words in the string, you are given the corresponding number of points. Each position in the crossword can be used at most x times. A certain word can be counted at different places, but you cannot count the same appearance of a word multiple times. If a word is a substring of another word, you can count them both (presuming you haven’t used the positions more than x times).
In order to solve the puzzle, you need to tell Sanz what’s the maximum achievable number of points in the crossword. There is no need to cover all postions, just get the maximal score! Crossword and words contain only lowercase English letters.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 500) — the length of the crossword. The second line contains the crossword string. The third line contains a single integer m (1 ≤ m ≤ 100) — the number of given words, and next m lines contain description of words: each line will have a string representing a non-empty word (its length doesn't exceed the length of the crossword) and integer pi (0 ≤ pi ≤ 100). Last line of the input will contain x (1 ≤ x ≤ 100) — maximum number of times a position in crossword can be used.
Output
Output single integer — maximum number of points you can get.
Example
Input
6
abacba
2
aba 6
ba 3
3
Output
12
Note
For example, with the string "abacba", words "aba" (6 points) and "ba" (3 points), and x = 3, you can get at most 12 points - the word "aba" appears once ("abacba"), while "ba" appears two times ("abacba"). Note that for x = 1, you could get at most 9 points, since you wouldn’t be able to count both "aba" and the first appearance of "ba".
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class T, class U>
inline void Max(T &a, U b) {
if (a < b) a = b;
}
template <class T, class U>
inline void Min(T &a, U b) {
if (a > b) a = b;
}
inline void add(int &a, int b) {
a += b;
while (a >= 1000000007) a -= 1000000007;
}
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = ans * (long long)a % 1000000007;
a = (long long)a * a % 1000000007;
b >>= 1;
}
return ans;
}
char b[505];
const int M = 1000000;
int q[505], h[505], cnt, head[600], d[600], p[600], vis[600];
int cal(int i, int j) {
return (h[j] - 1LL * h[i] * q[j - i] % 1000000007 + 1000000007) % 1000000007;
}
struct node {
int v, c, w, _next;
} g[200010];
void add(int a, int b, int c, int w) {
g[cnt] = {b, c, w, head[a]};
head[a] = cnt++;
g[cnt] = {a, 0, -w, head[b]};
head[b] = cnt++;
}
bool bfs(int s, int t) {
for (int i = 0; i < t + 1; i++) d[i] = -1000000007, vis[i] = 0;
queue<int> q;
q.push(s);
d[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = head[u]; ~i; i = g[i]._next) {
int j = g[i].v, k = g[i].w;
if (g[i].c && d[j] < d[u] + k) {
d[j] = d[u] + k;
p[j] = i;
if (!vis[j]) vis[j] = 1, q.push(j);
}
}
}
return d[t] > -1000000007;
}
int max_flow(int s, int t) {
int ans = 0;
while (bfs(s, t)) {
int first = t, f = 1000000007;
while (first != s) {
Min(f, g[p[first]].c), first = g[p[first] ^ 1].v;
}
ans += d[t] * f;
first = t;
while (first != s) {
g[p[first]].c -= f, g[p[first] ^ 1].c += f, first = g[p[first] ^ 1].v;
}
}
return ans;
}
int main() {
int i, j, k = 0, ca = 0, T, K, m = 0, n;
scanf("%d%s%d", &n, b, &m);
q[0] = 1;
for (int i = 0; i < n; i++)
h[i + 1] = (h[i] * 29LL + b[i]) % 1000000007,
q[i + 1] = q[i] * 29LL % 1000000007;
memset(head, -1, sizeof(head));
int s = 0, t = n + 1;
for (int i = 0; i < m; i++) {
scanf("%s%d", b, &k);
int len = strlen(b);
long long st = 0;
for (int j = 0; j < len; j++) st = (st * 29LL + b[j]) % 1000000007;
for (int j = 0; j < n - len + 1; j++) {
if (cal(j, j + len) == st) add(j + 1, j + len + 1, 1, k);
}
}
scanf("%d", &k);
for (int i = 0; i < n + 1; i++) add(i, i + 1, k, 0);
int ans = max_flow(s, t);
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
The Holmes children are fighting over who amongst them is the cleverest.
Mycroft asked Sherlock and Eurus to find value of f(n), where f(1) = 1 and for n ≥ 2, f(n) is the number of distinct ordered positive integer pairs (x, y) that satisfy x + y = n and gcd(x, y) = 1. The integer gcd(a, b) is the greatest common divisor of a and b.
Sherlock said that solving this was child's play and asked Mycroft to instead get the value of <image>. Summation is done over all positive integers d that divide n.
Eurus was quietly observing all this and finally came up with her problem to astonish both Sherlock and Mycroft.
She defined a k-composite function Fk(n) recursively as follows:
<image>
She wants them to tell the value of Fk(n) modulo 1000000007.
Input
A single line of input contains two space separated integers n (1 ≤ n ≤ 1012) and k (1 ≤ k ≤ 1012) indicating that Eurus asks Sherlock and Mycroft to find the value of Fk(n) modulo 1000000007.
Output
Output a single integer — the value of Fk(n) modulo 1000000007.
Examples
Input
7 1
Output
6
Input
10 2
Output
4
Note
In the first case, there are 6 distinct ordered pairs (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) and (6, 1) satisfying x + y = 7 and gcd(x, y) = 1. Hence, f(7) = 6. So, F1(7) = f(g(7)) = f(f(7) + f(1)) = f(6 + 1) = f(7) = 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
using ll = long long;
using ld = long double;
constexpr int nax = 1000 * 1000 + 105;
constexpr int infty = 1000 * 1000 * 1000 + 5;
constexpr int mod = 1000 * 1000 * 1000 + 7;
ll phi(ll n) {
debug() << "phi("
<< " ["
<< "n"
": "
<< (n) << "] "
<< ")";
ll wyn = 1ll;
auto Dolicz = [&wyn](ll p, int wyk) -> void {
debug() << "Dolicz("
<< " ["
<< "p"
": "
<< (p) << "] "
<< " ["
<< "wyk"
": "
<< (wyk) << "] "
<< ")";
ll il = 1ll;
while (wyk--) {
il *= p;
}
wyn *= il - il / p;
};
for (ll p = 2; p * p <= n; p++) {
int wyk = 0;
while (n % p == 0) {
n /= p;
wyk++;
}
if (wyk > 0) {
Dolicz(p, wyk);
}
}
if (n != 1) {
Dolicz(n, 1);
}
debug() << " ["
<< "wyn"
": "
<< (wyn) << "] ";
return wyn;
}
int main() {
ll n, k;
scanf("%lld%lld", &n, &k);
k = (k + 1) / 2;
while (k--) {
debug() << " ["
<< "n"
": "
<< (n) << "] ";
n = phi(n);
if (n == 1) {
break;
}
}
debug() << " ["
<< "n"
": "
<< (n) << "] ";
printf("%lld\n", n % mod);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Noora is a student of one famous high school. It's her final year in school — she is going to study in university next year. However, she has to get an «A» graduation certificate in order to apply to a prestigious one.
In school, where Noora is studying, teachers are putting down marks to the online class register, which are integers from 1 to k. The worst mark is 1, the best is k. Mark that is going to the certificate, is calculated as an average of all the marks, rounded to the closest integer. If several answers are possible, rounding up is produced. For example, 7.3 is rounded to 7, but 7.5 and 7.8784 — to 8.
For instance, if Noora has marks [8, 9], then the mark to the certificate is 9, because the average is equal to 8.5 and rounded to 9, but if the marks are [8, 8, 9], Noora will have graduation certificate with 8.
To graduate with «A» certificate, Noora has to have mark k.
Noora got n marks in register this year. However, she is afraid that her marks are not enough to get final mark k. Noora decided to ask for help in the internet, where hacker Leha immediately responded to her request. He is ready to hack class register for Noora and to add Noora any number of additional marks from 1 to k. At the same time, Leha want his hack be unseen to everyone, so he decided to add as less as possible additional marks. Please help Leha to calculate the minimal number of marks he has to add, so that final Noora's mark will become equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 100) denoting the number of marks, received by Noora and the value of highest possible mark.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ k) denoting marks received by Noora before Leha's hack.
Output
Print a single integer — minimal number of additional marks, that Leha has to add in order to change Noora's final mark to k.
Examples
Input
2 10
8 9
Output
4
Input
3 5
4 4 4
Output
3
Note
Consider the first example testcase.
Maximal mark is 10, Noora received two marks — 8 and 9, so current final mark is 9. To fix it, Leha can add marks [10, 10, 10, 10] (4 marks in total) to the registry, achieving Noora having average mark equal to <image>. Consequently, new final mark is 10. Less number of marks won't fix the situation.
In the second example Leha can add [5, 5, 5] to the registry, so that making average mark equal to 4.5, which is enough to have 5 in the certificate.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, m, arr[100], up(0.0), x(1.0), f(0.0), z(0.0);
cin >> n >> m;
z = m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
up += arr[i];
}
if (up / n >= m - .5) {
return cout << 0 << "\n", 0;
}
for (int i = 0;; i++) {
up += m;
f = up / (n + i + 1);
if (f >= m - .5) {
return cout << i + 1 << "\n", 0;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
They say that Berland has exactly two problems, fools and roads. Besides, Berland has n cities, populated by the fools and connected by the roads. All Berland roads are bidirectional. As there are many fools in Berland, between each pair of cities there is a path (or else the fools would get upset). Also, between each pair of cities there is no more than one simple path (or else the fools would get lost).
But that is not the end of Berland's special features. In this country fools sometimes visit each other and thus spoil the roads. The fools aren't very smart, so they always use only the simple paths.
A simple path is the path which goes through every Berland city not more than once.
The Berland government knows the paths which the fools use. Help the government count for each road, how many distinct fools can go on it.
Note how the fools' paths are given in the input.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the number of cities.
Each of the next n - 1 lines contains two space-separated integers ui, vi (1 ≤ ui, vi ≤ n, ui ≠ vi), that means that there is a road connecting cities ui and vi.
The next line contains integer k (0 ≤ k ≤ 105) — the number of pairs of fools who visit each other.
Next k lines contain two space-separated numbers. The i-th line (i > 0) contains numbers ai, bi (1 ≤ ai, bi ≤ n). That means that the fool number 2i - 1 lives in city ai and visits the fool number 2i, who lives in city bi. The given pairs describe simple paths, because between every pair of cities there is only one simple path.
Output
Print n - 1 integer. The integers should be separated by spaces. The i-th number should equal the number of fools who can go on the i-th road. The roads are numbered starting from one in the order, in which they occur in the input.
Examples
Input
5
1 2
1 3
2 4
2 5
2
1 4
3 5
Output
2 1 1 1
Input
5
3 4
4 5
1 4
2 4
3
2 3
1 3
3 5
Output
3 1 1 1
Note
In the first sample the fool number one goes on the first and third road and the fool number 3 goes on the second, first and fourth ones.
In the second sample, the fools number 1, 3 and 5 go on the first road, the fool number 5 will go on the second road, on the third road goes the fool number 3, and on the fourth one goes fool number 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, LOG = 17;
vector<int> adj[N];
map<pair<int, int>, int> sum;
pair<int, int> idx[N];
int parent[N][LOG], height[N], sub[N], sigma[N];
bool marked[N];
void dfs(int v) {
sub[v] = 1;
for (int i = 1; i < LOG; ++i) parent[v][i] = parent[parent[v][i - 1]][i - 1];
for (auto i : adj[v])
if (not sub[i])
height[i] = height[v] + 1, parent[i][0] = v, dfs(i), sub[v] += sub[i];
}
inline int up(int u, int h) {
for (int i = 0; i < LOG; ++i)
if (h & (1 << i)) u = parent[u][i];
return u;
}
inline int lca(int u, int v) {
if (height[u] < height[v]) swap(u, v);
u = up(u, height[u] - height[v]);
if (u == v) return u;
for (int i = LOG - 1; i >= 0; --i)
if (parent[u][i] != parent[v][i]) u = parent[u][i], v = parent[v][i];
return parent[u][0];
}
inline int dis(int u, int v, int l) {
return height[u] + height[v] - 2 * height[l];
}
int dfs2(int v) {
marked[v] = true;
for (auto i : adj[v])
if (not marked[i]) {
int add = dfs2(i);
sum[{v, i}] += add;
sum[{i, v}] += add;
sigma[v] += add;
}
return sigma[v];
}
int main() {
int n, k;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
idx[i] = {u, v};
}
dfs(1);
scanf("%d", &k);
while (k--) {
int u, v;
scanf("%d%d", &u, &v);
++sigma[u], ++sigma[v], sigma[lca(u, v)] -= 2;
}
dfs2(1);
for (int i = 0; i < n - 1; ++i) cout << sum[idx[i]] << ' ';
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
This is the easier version of the problem. In this version, 1 ≤ n ≤ 10^5 and 0 ≤ a_i ≤ 1. You can hack this problem only if you solve and lock both problems.
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
1 0 1
Output
2
Input
1
1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long> get_pr(long long n) {
vector<long long> ans;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
}
ans.push_back(i);
}
}
if (n > 1) {
ans.push_back(n);
}
return ans;
}
long long get(vector<long long> &tmp) {
long long n = tmp.size();
long long sum = 0;
for (long long i = 0; i < n; i++) {
sum += tmp[i];
}
long long m = (sum + 1) / 2;
long long mth = 0, pos = 0;
for (long long i = 0; i < n; i++) {
if (mth + tmp[i] >= m) {
pos = i;
break;
}
mth += tmp[i];
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += tmp[i] * abs(i - pos);
}
return ans;
}
long long solve(long long n, vector<long long> a, long long sum, long long k) {
long long sz = k;
long long ans = 0;
vector<long long> tmp;
long long sumt = 0;
for (long long i = 0; i < n; i++) {
if (a[i] + sumt >= sz) {
tmp.push_back(sz - sumt);
a[i] -= (sz - sumt);
a[i] %= sz;
ans += get(tmp);
tmp.clear();
sumt = 0;
}
tmp.push_back(a[i]);
sumt += a[i];
}
return ans;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, sum = 0;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum == 1) {
cout << -1;
exit(0);
}
long long ans = 1e18;
vector<long long> dv = get_pr(sum);
for (long long i : dv) {
ans = min(ans, solve(n, a, sum, i));
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
The Old City is a rectangular city represented as an m × n grid of blocks. This city contains many buildings, straight two-way streets and junctions. Each junction and each building is exactly one block. All the streets have width of one block and are either vertical or horizontal. There is a junction on both sides of each street. We call two blocks adjacent if and only if they share a common side. No two blocks of different streets are adjacent and no two junctions are adjacent.
There is an annual festival and as a part of it, The Old Peykan follows a special path in the city. This path starts from a block in a street, continues with many junctions and ends in a block of some street. For each street block, we know how much time it takes for the Old Peykan to go from this block to an adjacent block. Also the Old Peykan can go from each junction to its adjacent street blocks in one minute. Of course Old Peykan can't go to building blocks.
We know the initial position of the Old Peykan and the sequence of junctions that it passes to reach its destination. After passing all the junctions and reaching the destination, it will stay there forever. Your task is to find out where will the Old Peykan be k minutes after it starts moving. Consider that The Old Peykan always follows the shortest path that passes through the given sequence of junctions and reaches the destination.
Note that the Old Peykan may visit some blocks more than once.
Input
The first line of input contains three integers m, n and k (3 ≤ m, n ≤ 100, 1 ≤ k ≤ 100000). Next m lines are representing the city's map. Each of them containts n characters, each character is a block:
* Character "#" represents a building.
* Digits "1", "2", ..., "9" represent a block of an street and this digit means the number of minutes it takes for the Old Peykan to pass this block.
* Characters "a", "b", ..., "z" means that this block is a junction and this character is it's name. All the junction names are unique.
Consider that all blocks have the coordinates: the j-th in the i-th line have coordinates (i, j) (1 ≤ i ≤ m, 1 ≤ j ≤ n).
The (m + 2)th line contains two integers rs and cs (1 ≤ rs ≤ m, 1 ≤ cs ≤ n), string s and another two integers re and ce (1 ≤ re ≤ m, 1 ≤ ce ≤ n). The path starts from block (rs, cs), continues through junctions in the order that is specified by s and will end in block (re, ce). Length of s is between 1 and 1000.
It's guaranteed that string s denotes a correct path from the start position to the end position and string s doesn't contain two consecutive equal letters. Also start position (rs, cs) and the end position (re, ce) are street blocks.
Output
In a single line print two integers rf and cf — (rf, cf) being the position of the Old Peykan after exactly k minutes.
Examples
Input
3 10 12
##########
#z1a1111b#
##########
2 3 ab 2 8
Output
2 8
Input
10 3 5
###
#w#
#1#
#a#
#1#
#1#
#1#
#1#
#b#
###
3 2 abababababababab 6 2
Output
8 2
Input
3 10 6
##########
#z1a1311b#
##########
2 3 ab 2 8
Output
2 7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int x[35], y[35], n, m, k, p, q, si;
char s[1005], a[105][105];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%s", a[i] + 1);
for (int j = 1; j <= m; j++) {
if ((a[i][j] >= 'a') && (a[i][j] <= 'z')) {
x[a[i][j] - 'a'] = i;
y[a[i][j] - 'a'] = j;
a[i][j] = 1;
} else {
a[i][j] -= '0';
}
}
}
scanf("%d%d%s%d%d", &p, &q, s + 1, &x[26], &y[26]);
si = strlen(s + 1) + 1;
s[si] = 26;
for (int i = 1; i < si; i++) s[i] -= 'a';
for (int i = 1; i <= si && k > 0; i++) {
while ((p != x[s[i]]) || (q != y[s[i]])) {
k -= a[p][q];
if (k < 0) break;
if (p > x[s[i]]) --p;
if (p < x[s[i]]) ++p;
if (q > y[s[i]]) --q;
if (q < y[s[i]]) ++q;
}
}
printf("%d %d", p, q);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Some days ago, I learned the concept of LCM (least common multiple). I've played with it for several times and I want to make a big number with it.
But I also don't want to use many numbers, so I'll choose three positive integers (they don't have to be distinct) which are not greater than n. Can you help me to find the maximum possible least common multiple of these three integers?
Input
The first line contains an integer n (1 ≤ n ≤ 106) — the n mentioned in the statement.
Output
Print a single integer — the maximum possible LCM of three not necessarily distinct positive integers that are not greater than n.
Examples
Input
9
Output
504
Input
7
Output
210
Note
The least common multiple of some positive integers is the least positive integer which is multiple for each of them.
The result may become very large, 32-bit integer won't be enough. So using 64-bit integers is recommended.
For the last example, we can chose numbers 7, 6, 5 and the LCM of them is 7·6·5 = 210. It is the maximum value we can get.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
long long n, ans, tot, j;
cin >> n, ans = n;
for (long long i = n; ((i - 3) * i + 2) * i > ans; i--) {
tot = i * i - i;
for (j = i - 1; gcd(tot, j) != 1; j--)
;
ans = max(ans, tot * j);
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Levko loves strings of length n, consisting of lowercase English letters, very much. He has one such string s. For each string t of length n, Levko defines its beauty relative to s as the number of pairs of indexes i, j (1 ≤ i ≤ j ≤ n), such that substring t[i..j] is lexicographically larger than substring s[i..j].
The boy wondered how many strings t are there, such that their beauty relative to s equals exactly k. Help him, find the remainder after division this number by 1000000007 (109 + 7).
A substring s[i..j] of string s = s1s2... sn is string sisi + 1... sj.
String x = x1x2... xp is lexicographically larger than string y = y1y2... yp, if there is such number r (r < p), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. The string characters are compared by their ASCII codes.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ 2000).
The second line contains a non-empty string s of length n. String s consists only of lowercase English letters.
Output
Print a single number — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
2 2
yz
Output
26
Input
2 3
yx
Output
2
Input
4 7
abcd
Output
21962
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2005;
void add(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int mul(int a, int b) { return 1ll * a * b % mod; }
int f[maxn][maxn], g[maxn][maxn], N, K;
string str;
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("A.INP", "r")) {
freopen("A.INP", "r", stdin);
freopen("A.OUT", "w", stdout);
}
if (fopen(""
".inp",
"r")) {
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
cin >> N >> K >> str;
str = " " + str;
f[0][0] = g[0][0] = 1;
for (int i = 1; i <= N; ++i) {
for (int j = 0; j <= K; ++j) {
add(f[i][j], mul(g[i - 1][j], str[i] - 'a'));
for (int k = i - 1; k >= 0 && j + (i - k) * (N + 1 - i) <= K; --k) {
add(f[i][j + (i - k) * (N + 1 - i)], mul(f[k][j], 'z' - str[i]));
}
add(g[i][j], f[i][j]);
add(g[i][j], g[i - 1][j]);
}
}
cout << g[N][K] << '\n';
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Mashmokh's boss, Bimokh, didn't like Mashmokh. So he fired him. Mashmokh decided to go to university and participate in ACM instead of finding a new job. He wants to become a member of Bamokh's team. In order to join he was given some programming tasks and one week to solve them. Mashmokh is not a very experienced programmer. Actually he is not a programmer at all. So he wasn't able to solve them. That's why he asked you to help him with these tasks. One of these tasks is the following.
You have an array a of length 2n and m queries on it. The i-th query is described by an integer qi. In order to perform the i-th query you must:
* split the array into 2n - qi parts, where each part is a subarray consisting of 2qi numbers; the j-th subarray (1 ≤ j ≤ 2n - qi) should contain the elements a[(j - 1)·2qi + 1], a[(j - 1)·2qi + 2], ..., a[(j - 1)·2qi + 2qi];
* reverse each of the subarrays;
* join them into a single array in the same order (this array becomes new array a);
* output the number of inversions in the new a.
Given initial array a and all the queries. Answer all the queries. Please, note that the changes from some query is saved for further queries.
Input
The first line of input contains a single integer n (0 ≤ n ≤ 20).
The second line of input contains 2n space-separated integers a[1], a[2], ..., a[2n] (1 ≤ a[i] ≤ 109), the initial array.
The third line of input contains a single integer m (1 ≤ m ≤ 106).
The fourth line of input contains m space-separated integers q1, q2, ..., qm (0 ≤ qi ≤ n), the queries.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
Output m lines. In the i-th line print the answer (the number of inversions) for the i-th query.
Examples
Input
2
2 1 4 3
4
1 2 0 2
Output
0
6
6
0
Input
1
1 2
3
0 1 1
Output
0
1
0
Note
If we reverse an array x[1], x[2], ..., x[n] it becomes new array y[1], y[2], ..., y[n], where y[i] = x[n - i + 1] for each i.
The number of inversions of an array x[1], x[2], ..., x[n] is the number of pairs of indices i, j such that: i < j and x[i] > x[j].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return x * x; }
long double sqrd(long double x) { return x * x; }
mt19937 Random((int)time(0));
long long rnd(long long x) { return Random() % x; }
const long long INF = (long long)1e9 + 282;
const long long MOD = (long long)1e9 + 7;
const long double PI = acosl(-1.0);
const int L = 22;
const int N = (1ll << (L)) + 10;
int arr[N];
long long cnt[N][2], sum[L][2];
void calc(int v, int l, int r, vector<int>& arr, int d) {
if (l == r) {
return;
}
int m = (l + r) / 2;
vector<int> a, b;
for (int i = 0; i < (int)(arr).size() / 2; i++) {
a.push_back(arr[i]);
}
for (int i = (int)(arr).size() / 2; i < (int)(arr).size(); i++) {
b.push_back(arr[i]);
}
calc(v * 2, l, m, a, d + 1);
calc(v * 2 + 1, m + 1, r, b, d + 1);
arr.clear();
int x = 0, y = 0;
while (x < (int)(a).size() && y < (int)(b).size()) {
if (a[x] == b[y]) {
arr.push_back(a[x++]);
arr.push_back(b[y++]);
continue;
}
if (a[x] < b[y]) {
arr.push_back(a[x++]);
} else {
arr.push_back(b[y++]);
}
}
while (x < (int)(a).size()) {
arr.push_back(a[x++]);
}
while (y < (int)(b).size()) {
arr.push_back(b[y++]);
}
int p = 0;
for (int i = 0; i < (int)(a).size(); i++) {
while (p < (int)(b).size() && b[p] <= a[i]) {
p++;
}
cnt[v][1] += (int)(b).size() - p;
}
p = 0;
for (int i = 0; i < (int)(b).size(); i++) {
while (p < (int)(a).size() && a[p] <= b[i]) {
p++;
}
cnt[v][0] += (int)(a).size() - p;
}
sum[d][0] += cnt[v][0];
sum[d][1] += cnt[v][1];
}
void mane() {
int n;
cin >> n;
int l = n;
n = (1ll << (n));
vector<int> res;
res.reserve(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
res.push_back(arr[i]);
}
calc(1, 0, n - 1, res, 0);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int h;
cin >> h;
h = l - h;
for (int j = h; j <= l; j++) {
swap(sum[j][0], sum[j][1]);
}
long long ans = 0;
for (int j = 0; j <= l; j++) {
ans += sum[j][0];
}
cout << ans << "\n";
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios_base::fixed, ios_base::floatfield);
cout.precision(12);
mane();
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
There is a game called "I Wanna Be the Guy", consisting of n levels. Little X and his friend Little Y are addicted to the game. Each of them wants to pass the whole game.
Little X can pass only p levels of the game. And Little Y can pass only q levels of the game. You are given the indices of levels Little X can pass and the indices of levels Little Y can pass. Will Little X and Little Y pass the whole game, if they cooperate each other?
Input
The first line contains a single integer n (1 ≤ n ≤ 100).
The next line contains an integer p (0 ≤ p ≤ n) at first, then follows p distinct integers a1, a2, ..., ap (1 ≤ ai ≤ n). These integers denote the indices of levels Little X can pass. The next line contains the levels Little Y can pass in the same format. It's assumed that levels are numbered from 1 to n.
Output
If they can pass all the levels, print "I become the guy.". If it's impossible, print "Oh, my keyboard!" (without the quotes).
Examples
Input
4
3 1 2 3
2 2 4
Output
I become the guy.
Input
4
3 1 2 3
2 2 3
Output
Oh, my keyboard!
Note
In the first sample, Little X can pass levels [1 2 3], and Little Y can pass level [2 4], so they can pass all the levels both.
In the second sample, no one can pass level 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long v[112];
int32_t main() {
cout.precision(12);
cout.setf(ios::fixed);
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
long long m;
cin >> m;
for (long long i = 0; i < m; i++) {
long long a;
cin >> a;
v[a]++;
}
cin >> m;
for (long long i = 0; i < m; i++) {
long long a;
cin >> a;
v[a]++;
}
for (long long i = 1; i <= n; i++) {
if (v[i] == 0) {
cout << "Oh, my keyboard!" << endl;
return 0;
}
}
cout << "I become the guy." << endl;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Consider the following set of rules for encoding strings consisting of `0` and `1`:
* Strings `0` and `1` can be encoded as `0` and `1`, respectively.
* If strings A and B can be encoded as P and Q, respectively, then string AB can be encoded as PQ.
* If string A can be encoded as P and K \geq 2 is a positive integer, then string AA...A (A repeated K times) can be encoded as `(`P`x`K`)`.
For example, string `001001001`, among other possibilities, can be encoded as `001001001`, `00(1(0x2)x2)1` and `(001x3)`.
Let's call string A a subset of string B if:
* A and B are equal in length and consist of `0` and `1`;
* for all indices i such that A_i = `1`, it's also true that B_i = `1`.
You are given string S consisting of `0` and `1`. Find the total number of distinct encodings of all subsets of S, modulo 998244353.
Constraints
* 1 \leq |S| \leq 100
* S consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the total number of distinct encodings of all subsets of S modulo 998244353.
Examples
Input
011
Output
9
Input
0000
Output
10
Input
101110
Output
156
Input
001110111010110001100000100111
Output
363383189
### Response
```cpp
#include <bits/stdc++.h>
#define MOD 998244353LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
map<string,ll> dp;
ll solve(string s){
if(s.size()==0)return 1;
if(s.size()==1){
if(s[0]=='1')return 2;
else return 1;
}
if(dp.find(s)!=dp.end()){
return dp[s];
}
ll sum=solve(s.substr(0,1))*solve(s.substr(1))%MOD;
for(int i=1;i<=s.size();i++){
string subs=s.substr(0,i);
for(int j=1;j<=100;j++){
if(i*(j+1)>s.size())break;
for(int k=0;k<i;k++){
if(s[i*j+k]=='0')subs[k]='0';
}
sum=(sum+solve(subs)*solve(s.substr(i*(j+1)))%MOD)%MOD;
}
}
return (dp[s]=sum);
}
int main(void){
string str;
cin >> str;
printf("%lld\n",solve(str));
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
FizzBuzz is a game in which integers of 1 or more are spoken in order according to the following rules.
* "Fizz" when divisible by 3
* "Buzz" when divisible by 5
* "FizzBuzz" when divisible by both 3 and 5
* At other times, that number
An example of the progress of the game is shown below.
1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz, 16,…
The character string obtained by combining the obtained remarks into one character string is called FizzBuzz String. Since the index s is given, output 20 characters from the s character of the FizzBuzz String. However, the index may start from 1, and the length of the obtained character string may be sufficiently large (s + 20 or more).
Constraints
* s is an integer
* 1 ≤ s ≤ 1018
Input
Input is given in the following format
> s
>
Output
Output 20 characters from the s character of FizzBuzz String on one line
Examples
Input
1
Output
12Fizz4BuzzFizz78Fiz
Input
20
Output
zzBuzz11Fizz1314Fizz
Input
10000000000
Output
93FizzBuzz1418650796
### Response
```cpp
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define DBG 1
#define dump(o) if(DBG){cerr<<#o<<" "<<o<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define each(it,c) for(auto it=(c).begin();it!=(c).end();it++)
#define all(c) c.begin(),c.end()
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
int cntNum(int l, int r, int div) {
return (r - 1) / div - (l - 1) / div;
}
int calc(int x) {
int p = 1;
int np = 10 * p;
int ans = 0;
int cnt(1);
while (np < x) {
int fizzbuzz = cntNum(p, np, 15);
int fizz = cntNum(p, np, 3) - fizzbuzz;
int buzz = cntNum(p, np, 5) - fizzbuzz;
int other = (np - p) - (fizzbuzz + fizz + buzz);
ans += fizzbuzz * 8 + (fizz + buzz) * 4 + other*cnt;
cnt++;
p = np;
np *= 10;
}
int fizzbuzz = cntNum(p, x + 1, 15);
int fizz = cntNum(p, x + 1, 3) - fizzbuzz;
int buzz = cntNum(p, x + 1, 5) - fizzbuzz;
int other = (x + 1 - p) - (fizzbuzz + buzz + fizz);
ans += fizzbuzz * 8 + (fizz + buzz) * 4 + other*cnt;
return ans;
}
string number = "0123456789";
string trans(int x) {
if (x % 15 == 0)return "FizzBuzz";
else if (x % 5 == 0)return "Buzz";
else if (x % 3 == 0)return "Fizz";
string ret;
while (x) {
ret += number[(int)(x % 10)];
x /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
signed main() {
int n; cin >> n;
int low(0), high(1ll << 60);
while (low + 1 < high) {
int mid = (low + high) / 2;
if (calc(mid) >= n)high = mid;
else low = mid;
}
n -= calc(low);
string ans;
//cout << n << endl;
rep(i, 0, 20) {
low++;
if (low % 15 == 0)ans += "FizzBuzz";
else if (low % 5 == 0)ans += "Buzz";
else if (low % 3 == 0)ans += "Fizz";
else ans += trans(low);
}
//cout << ans << endl;
cout << ans.substr(n-1, 20) << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Two players decided to play one interesting card game.
There is a deck of n cards, with values from 1 to n. The values of cards are pairwise different (this means that no two different cards have equal values). At the beginning of the game, the deck is completely distributed between players such that each player has at least one card.
The game goes as follows: on each turn, each player chooses one of their cards (whichever they want) and puts on the table, so that the other player doesn't see which card they chose. After that, both cards are revealed, and the player, value of whose card was larger, takes both cards in his hand. Note that as all cards have different values, one of the cards will be strictly larger than the other one. Every card may be played any amount of times. The player loses if he doesn't have any cards.
For example, suppose that n = 5, the first player has cards with values 2 and 3, and the second player has cards with values 1, 4, 5. Then one possible flow of the game is:
* The first player chooses the card 3. The second player chooses the card 1. As 3>1, the first player gets both cards. Now the first player has cards 1, 2, 3, the second player has cards 4, 5.
* The first player chooses the card 3. The second player chooses the card 4. As 3<4, the second player gets both cards. Now the first player has cards 1, 2. The second player has cards 3, 4, 5.
* The first player chooses the card 1. The second player chooses the card 3. As 1<3, the second player gets both cards. Now the first player has only the card 2. The second player has cards 1, 3, 4, 5.
* The first player chooses the card 2. The second player chooses the card 4. As 2<4, the second player gets both cards. Now the first player is out of cards and loses. Therefore, the second player wins.
Who will win if both players are playing optimally? It can be shown that one of the players has a winning strategy.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). The description of the test cases follows.
The first line of each test case contains three integers n, k_1, k_2 (2 ≤ n ≤ 100, 1 ≤ k_1 ≤ n - 1, 1 ≤ k_2 ≤ n - 1, k_1 + k_2 = n) — the number of cards, number of cards owned by the first player and second player correspondingly.
The second line of each test case contains k_1 integers a_1, ..., a_{k_1} (1 ≤ a_i ≤ n) — the values of cards of the first player.
The third line of each test case contains k_2 integers b_1, ..., b_{k_2} (1 ≤ b_i ≤ n) — the values of cards of the second player.
It is guaranteed that the values of all cards are different.
Output
For each test case, output "YES" in a separate line, if the first player wins. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Example
Input
2
2 1 1
2
1
5 2 3
2 3
1 4 5
Output
YES
NO
Note
In the first test case of the example, there is only one possible move for every player: the first player will put 2, the second player will put 1. 2>1, so the first player will get both cards and will win.
In the second test case of the example, it can be shown that it is the second player who has a winning strategy. One possible flow of the game is illustrated in the statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n, k1, k2;
cin >> n >> k1 >> k2;
vector<int> card1(k1);
vector<int> card2(k2);
for (auto& ele : card1) cin >> ele;
for (auto& ele : card2) cin >> ele;
int w1 = *max_element(card1.begin(), card1.end());
int w2 = *max_element(card2.begin(), card2.end());
if (w1 > w2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
There is a grid with H rows and W columns.
The square at the i-th row and j-th column contains a string S_{i,j} of length 5.
The rows are labeled with the numbers from 1 through H, and the columns are labeled with the uppercase English letters from `A` through the W-th letter of the alphabet.
<image>
Exactly one of the squares in the grid contains the string `snuke`. Find this square and report its location.
For example, the square at the 6-th row and 8-th column should be reported as `H6`.
Constraints
* 1≦H, W≦26
* The length of S_{i,j} is 5.
* S_{i,j} consists of lowercase English letters (`a`-`z`).
* Exactly one of the given strings is equal to `snuke`.
Input
The input is given from Standard Input in the following format:
H W
S_{1,1} S_{1,2} ... S_{1,W}
S_{2,1} S_{2,2} ... S_{2,W}
:
S_{H,1} S_{H,2} ... S_{H,W}
Output
Print the labels of the row and the column of the square containing the string `snuke`, with no space inbetween.
Examples
Input
15 10
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snuke snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
snake snake snake snake snake snake snake snake snake snake
Output
H6
Input
1 1
snuke
Output
A1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int h,w;
cin>>h>>w;
for(int i=1;i<=h;i++){
for(int j=1;j<=w;j++){
string s;
cin>>s;
if(s=="snuke") cout<<(char)(j+'A'-1)<<i;
}
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
There are n water tanks in a row, i-th of them contains a_i liters of water. The tanks are numbered from 1 to n from left to right.
You can perform the following operation: choose some subsegment [l, r] (1≤ l ≤ r ≤ n), and redistribute water in tanks l, l+1, ..., r evenly. In other words, replace each of a_l, a_{l+1}, ..., a_r by \frac{a_l + a_{l+1} + ... + a_r}{r-l+1}. For example, if for volumes [1, 3, 6, 7] you choose l = 2, r = 3, new volumes of water will be [1, 4.5, 4.5, 7]. You can perform this operation any number of times.
What is the lexicographically smallest sequence of volumes of water that you can achieve?
As a reminder:
A sequence a is lexicographically smaller than a sequence b of the same length if and only if the following holds: in the first (leftmost) position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains an integer n (1 ≤ n ≤ 10^6) — the number of water tanks.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6) — initial volumes of water in the water tanks, in liters.
Because of large input, reading input as doubles is not recommended.
Output
Print the lexicographically smallest sequence you can get. In the i-th line print the final volume of water in the i-th tank.
Your answer is considered correct if the absolute or relative error of each a_i does not exceed 10^{-9}.
Formally, let your answer be a_1, a_2, ..., a_n, and the jury's answer be b_1, b_2, ..., b_n. Your answer is accepted if and only if \frac{|a_i - b_i|}{max{(1, |b_i|)}} ≤ 10^{-9} for each i.
Examples
Input
4
7 5 5 7
Output
5.666666667
5.666666667
5.666666667
7.000000000
Input
5
7 8 8 10 12
Output
7.000000000
8.000000000
8.000000000
10.000000000
12.000000000
Input
10
3 9 5 5 1 7 5 3 8 7
Output
3.000000000
5.000000000
5.000000000
5.000000000
5.000000000
5.000000000
5.000000000
5.000000000
7.500000000
7.500000000
Note
In the first sample, you can get the sequence by applying the operation for subsegment [1, 3].
In the second sample, you can't get any lexicographically smaller sequence.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 50;
int head, tail, q[N];
long long a[N];
bool check(int x, int y, int z) {
long long s1 = a[y] - a[x];
long long s2 = a[z] - a[x];
return s1 * (z - x) >= s2 * (y - x);
}
int main() {
int n;
tail = head = 0;
scanf("%d", &n);
for (int i = 2; i <= n + 1; i++) {
scanf("%lld", &a[i]);
a[i] = a[i - 1] + a[i];
}
a[1] = 0;
q[tail++] = 1;
for (int i = 2; i <= n + 1; i++) {
while (head < tail - 1 && check(q[tail - 2], q[tail - 1], i)) {
tail--;
}
q[tail++] = i;
}
for (int i = head + 1; i < tail; i++) {
int sz = q[i] - q[i - 1];
long long s = a[q[i]] - a[q[i - 1]];
for (int j = 0; j < q[i] - q[i - 1]; j++) {
printf("%.12f\n", s * 1.0 / sz);
}
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
vector<int> vr[N], vc[N];
set<int> str[N], stc[N];
int a[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
str[i].insert(a[i][j]);
stc[j].insert(a[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (auto j : str[i]) {
vr[i].push_back(j);
}
}
for (int i = 0; i < m; i++) {
for (auto j : stc[i]) {
vc[i].push_back(j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int idxr =
lower_bound(vr[i].begin(), vr[i].end(), a[i][j]) - vr[i].begin() + 1;
int idxc =
lower_bound(vc[j].begin(), vc[j].end(), a[i][j]) - vc[j].begin() + 1;
int idx = max(idxr, idxc);
int zr = (int)vr[i].size() - idxr;
int zc = (int)vc[j].size() - idxc;
cout << idx + max(zr, zc) << ' ';
}
cout << '\n';
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=50001;
const ll INF=1LL<<60;
int main(){
int N;
ll W;cin>>N>>W;
ll ans=0;
vector<ll> v(N),w(N);
for(int i=0;i<N;i++){
cin>>v[i]>>w[i];
}
vector<pair<ll,ll>> A;
for(int bit=0;bit<(1<<(N/2));bit++){
ll vsum=0,wsum=0;
for(int i=0;i<N/2;i++){
if(bit&(1<<i)){
vsum+=v[i];
wsum+=w[i];
}
}
A.push_back(make_pair(wsum,vsum));
if(wsum<=W) ans=max(ans,vsum);
}
sort(all(A));
ll maxi=0;
for(int i=0;i<A.size();i++){
A[i].second=max(maxi,A[i].second);
maxi=A[i].second;
}
for(int bit=0;bit<(1<<(N-N/2));bit++){
ll vsum=0,wsum=0;
for(int i=0;i<N-N/2;i++){
if(bit&(1<<i)){
vsum+=v[N/2+i];
wsum+=w[N/2+i];
}
}
if(wsum>W) continue;
wsum=W-wsum;
auto it=lower_bound(all(A),make_pair(wsum+1,-INF));
it--;
ans=max(ans,(*it).second+vsum);
}
cout<<ans<<endl;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
<!--
Problem B
-->
On-Screen Keyboard
You are to input a string with an OSK (on-screen keyboard). A remote control with five buttons, four arrows and an OK (Fig. B-1), is used for the OSK. Find the minimum number of button presses required to input a given string with the given OSK.
<image> Fig. B-1 Remote control <image> Fig. B-2 An on-screen keyboard Character to input| Move of highlighted cells| Button presses
---|---|---
`I`| <image>| ->,->,->,->,->,->,->,->,OK (9 presses)
`C`| <image>| <-,<-,<-,<-,<-,<-,OK (7 presses)
`P`| <image>| ↓,->,->,->,->,OK (6 presses)
`C`| <image>| ↑,<-,<-,<-,<-,OK (6 presses)
Fig. B-3 The minimum steps to input "`ICPC`" with the OSK in Fig. B-2
The OSK has cells arranged in a grid, each of which has a character in it or is empty. No two of the cells have the same character.
One of the cells of the OSK is highlighted, and pressing the OK button will input the character in that cell, if the cell is not empty.
Initially, the cell at the top-left corner is highlighted. Pressing one of the arrow buttons will change the highlighted cell to one of the adjacent cells in the direction of the arrow. When the highlighted cell is on an edge of the OSK, pushing the arrow button with the direction to go out of the edge will have no effect.
For example, using the OSK with its arrangement shown in Fig. B-2, a string "`ICPC`" can be input with 28 button presses as shown in Fig. B-3, which is the minimum number of presses.
Characters in cells of the OSKs are any of a lowercase letter ('`a`', '`b`', ..., '`z`'), an uppercase letter ('`A`', '`B`', ..., '`Z`'), a digit ('`0`', '`1`', ..., '`9`'), a comma ('`,`'), a hyphen ('`-`'), a dot ('`.`'), a slash ('`/`'), a colon ('`:`'), a semicolon ('`;`'), or an at sign ('`@`').
Input
The input consists of at most 100 datasets, each in the following format.
> h w
> r1
> ...
> rh
> s
The two integers h and w in the first line are the height and the width of the OSK, respectively. They are separated by a space, and satisfy 1 ≤ h ≤ 50 and 1 ≤ w ≤ 50.
Each of the next h lines gives a row of the OSK. The i-th row, ri is a string of length w. The characters in the string corresponds to the characters in the cells of the i-th row of the OSK or an underscore ('`_`') indicating an empty cell, from left to right.
The given OSK satisfies the conditions stated above.
The next line is a string s to be input. Its length is between 1 and 1000, inclusive. All the characters in s appear in the given OSK. Note that s does not contain underscores.
The end of the input is indicated by a line containing two zeros.
Output
For each dataset, output a single line containing an integer indicating the minimum number of button presses required to input the given string with the given OSK.
Sample Input
3 9
ABCDEFGHI
JKLMNOPQR
STUVWXYZ_
ICPC
5 11
___________
____A______
________M__
___________
_C_________
ACM
4 21
1_2_3_4_5_6_7_8_9_0_-
QqWwEeRrTtYyUuIiOoPp@
AaSsDdFfGgHhJjKkLl;_:
ZzXxCcVvBbNnMm,_._/__
ICPC2019,AsiaYokohamaRegional,QualificationRound
0 0
Output for the Sample Input
28
23
493
Example
Input
3 9
ABCDEFGHI
JKLMNOPQR
STUVWXYZ_
ICPC
5 11
___________
____A______
________M__
___________
_C_________
ACM
4 21
1_2_3_4_5_6_7_8_9_0_-
QqWwEeRrTtYyUuIiOoPp@
AaSsDdFfGgHhJjKkLl;_:
ZzXxCcVvBbNnMm,_._/__
ICPC2019,AsiaYokohamaRegional,QualificationRound
0 0
Output
28
23
493
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
while(1){
long long n,m;
cin >> n >> m;
if(n==0ll and m==0ll) break;
char c[n][m];
string s;
map<char, pair<int, int> > mp;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cin >> c[i][j];
mp[c[i][j]]=make_pair(i,j);
}
}
cin >> s;
long long x=0,y=0,ans=0;
for(size_t i=0;i<s.size();i++){
ans+=abs(mp[s[i]].first-x)+abs(mp[s[i]].second-y)+1;
x=mp[s[i]].first;
y=mp[s[i]].second;
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n,i,ans=1e17;
cin>>n;
for(i=1;i*i<=n;i++)
{
if(n%i==0)
{
ans=min(ans,i+n/i-2);
}
}
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
<image>
Input
The input contains two integers a, b (1 ≤ a ≤ 10, 0 ≤ b ≤ 22·a - 1) separated by a single space.
Output
Output two integers separated by a single space.
Examples
Input
1 0
Output
0 0
Input
2 15
Output
3 0
Input
4 160
Output
12 12
### Response
```cpp
#include <bits/stdc++.h>
using LL = long long;
using ULL = unsigned long long;
using LLL = __int128;
using ULLL = unsigned __int128;
namespace std {
void swap(int& x, int& y) { x ^= (y ^= (x ^= y)); }
void swap(LL& x, LL& y) { x ^= (y ^= (x ^= y)); }
}; // namespace std
using std::swap;
template <typename T, typename P>
inline auto max(const T& x, const P& y) -> decltype(x < y ? y : x) {
return x < y ? y : x;
}
template <typename T, typename P>
inline auto min(const T& x, const P& y) -> decltype(x < y ? x : y) {
return x < y ? x : y;
}
template <typename T, typename... Args>
inline auto max(const T& x, const Args&... args)
-> decltype(max(x, max(args...))) {
return max(x, max(args...));
}
template <typename T, typename... Args>
inline auto min(const T& x, const Args&... args)
-> decltype(min(x, min(args...))) {
return min(x, min(args...));
}
template <typename T>
inline T max(const T& x) {
return x;
}
template <typename T>
inline T min(const T& x) {
return x;
}
template <typename T, typename... Args>
inline void chkmax(T& d, const Args&... args) {
d = max(d, args...);
}
template <typename T, typename... Args>
inline void chkmin(T& d, const Args&... args) {
d = min(d, args...);
}
class IO {
static const int MAXSIZE = 1 << 20;
char buf[MAXSIZE], *p1, *p2;
char pbuf[MAXSIZE], *pp;
long double eps = 1e-8L;
LLL pow10 = 1000000;
int precision;
FILE *infile, *outfile;
public:
IO(FILE* in = nullptr, FILE* out = nullptr)
: precision(6), infile(in), outfile(out) {
p1 = p2 = buf;
pp = pbuf;
}
~IO() { fwrite(pbuf, 1, pp - pbuf, outfile); }
inline static bool blank(char ch);
inline void flush();
inline void input(const char* str);
inline void output(const char* str);
inline void input(FILE* f);
inline void output(FILE* f);
inline int getch();
template <typename T, typename... Args>
bool read(T& x, Args&... args);
inline bool read();
template <typename T>
typename std::enable_if<
std::is_integral<T>::value || std::is_floating_point<T>::value ||
std::is_same<T, LLL>::value || std::is_same<T, ULLL>::value,
bool>::type
read(T& x);
bool read(char& ch);
bool read(char* s);
bool readline(char* s);
inline void putch(const char c);
inline void putback(const char c);
inline void setprecision(int n = 6);
template <typename T, typename... Args>
void write(const T& x, const Args&... args);
inline void write();
template <typename T>
typename std::enable_if<std::is_integral<T>::value ||
std::is_same<T, LLL>::value ||
std::is_same<T, ULLL>::value,
void>::type
write(T x);
inline void write(char c);
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type write(
T x);
inline void write(bool x);
void write(char* s);
void write(const char* s);
template <typename... Args>
void writeln(Args... x) {
write(x...), putch('\n');
}
} io(stdin, stdout), err(nullptr, stderr);
template <typename... Args>
inline void writeln(Args... x) {
io.write(x...), io.putch('\n');
}
int main() {
int n, d;
io.read(n, d);
int x = 0, y = 0, v = 0;
for (int i = 2 * n - 2; i >= 0; i -= 2) {
int r = 4 * v | (d >> i) & 3;
x = (x << 1) | (0x936c >> r) & 1;
y = (y << 1) | (0x39c6 >> r) & 1;
v = (0x3e6b94c1 >> 2 * r) & 3;
}
writeln(x, ' ', y);
return 0;
}
inline bool IO::blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void IO::flush() {
fwrite(pbuf, 1, pp - pbuf, outfile), pp = pbuf;
fflush(outfile);
}
inline void IO::input(const char* str) {
FILE* file = fopen(str, "rb");
infile = file;
}
inline void IO::output(const char* str) {
FILE* file = fopen(str, "wb");
outfile = file;
}
inline void IO::input(FILE* f) { infile = f; }
inline void IO::output(FILE* f) { outfile = f; }
inline int IO::getch() {
return (p1 == p2 ? (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, infile)) : 0),
(p1 == p2) ? EOF : *p1++;
}
inline void IO::putback(const char c) { *(--p1) = c; }
template <typename T, typename... Args>
bool IO::read(T& x, Args&... args) {
return read(x) && read(args...);
}
inline bool IO::read() { return true; }
template <typename T>
typename std::enable_if<
std::is_integral<T>::value || std::is_floating_point<T>::value ||
std::is_same<T, LLL>::value || std::is_same<T, ULLL>::value,
bool>::type
IO::read(T& x) {
T tmp = 1;
bool sign = false;
x = 0;
int ch = getch();
for (; !(ch >= '0' && ch <= '9') && ~ch; ch = getch())
if (ch == '-') sign = true;
if (!(~ch)) return false;
for (; (ch >= '0' && ch <= '9'); ch = getch()) x = x * 10 + (ch - '0');
if (ch == '.' && std::is_floating_point<T>::value)
for (ch = getch(); (ch >= '0' && ch <= '9'); ch = getch())
tmp /= 10.0, x += tmp * (ch - '0');
if (~ch) putback(ch);
if (sign) x = -x;
return true;
}
bool IO::read(char& ch) {
for (ch = getch(); blank(ch) && ~ch; ch = getch())
;
return ~ch;
}
bool IO::read(char* s) {
int ch = getch();
while (blank(ch)) ch = getch();
if (!(~ch)) return false;
while (!blank(ch) && ~ch) *s++ = ch, ch = getch();
*s = 0;
if (~ch) putback(ch);
return true;
}
bool IO::readline(char* s) {
int ch = getch();
while (blank(ch) && ch != '\n') ch = getch();
if (!(~ch)) return false;
while (ch != '\n' && ~ch) *s++ = ch, ch = getch();
*s = 0;
if (~ch) putback(ch);
return true;
}
inline void IO::putch(const char c) {
((pp - pbuf == MAXSIZE) ? fwrite(pbuf, 1, MAXSIZE, outfile), pp = pbuf : 0),
*pp++ = c;
}
inline void IO::setprecision(int n) {
precision = n;
eps = powl(10.0L, -precision - 2);
pow10 = powl(10.0L, precision) + eps;
}
template <typename T, typename... Args>
void IO::write(const T& x, const Args&... args) {
write(x);
write(args...);
}
inline void IO::write() {}
template <typename T>
typename std::enable_if<std::is_integral<T>::value ||
std::is_same<T, LLL>::value ||
std::is_same<T, ULLL>::value,
void>::type
IO::write(T x) {
if (x < 0) x = ~x + 1, putch('-');
static T sta[100];
int top = 0;
do sta[top++] = x % 10, x /= 10;
while (x);
while (top) putch(sta[--top] + '0');
}
inline void IO::write(bool x) { putch(x ^ 48); }
inline void IO::write(char c) { putch(c); }
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value>::type IO::write(T x) {
if (x == 0) {
putch('0'), putch('.');
for (int i = 1; i <= precision; i++) putch('0');
return;
}
if (x < 0) putch('-'), x = -x;
T res = (LLL)(x * pow10 + 0.5) / (pow10 * 1.0);
LLL y = LLL(res * pow10 + eps) % pow10;
write(LLL(res + eps));
if (precision) {
putch('.');
static int sta[100], p = 0;
for (; p < precision; y /= 10) sta[++p] = y % 10;
for (int i = p; i >= 1; i--) putch(sta[i] ^ 48);
}
}
void IO::write(char* s) {
while (*s) putch(*s++);
}
void IO::write(const char* s) {
while (*s) putch(*s++);
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are planning to build housing on a street. There are n spots available on the street on which you can build a house. The spots are labeled from 1 to n from left to right. In each spot, you can build a house with an integer height between 0 and h.
In each spot, if a house has height a, you can gain a^2 dollars from it.
The city has m zoning restrictions though. The i-th restriction says that if the tallest house from spots l_i to r_i is strictly more than x_i, you must pay a fine of c_i.
You would like to build houses to maximize your profit (sum of dollars gained minus fines). Determine the maximum profit possible.
Input
The first line contains three integers n,h,m (1 ≤ n,h,m ≤ 50) — the number of spots, the maximum height, and the number of restrictions, respectively.
Each of the next m lines contains four integers l_i, r_i, x_i, c_i (1 ≤ l_i ≤ r_i ≤ n, 0 ≤ x_i ≤ h, 1 ≤ c_i ≤ 5 000).
Output
Print a single integer denoting the maximum profit you can make.
Examples
Input
3 3 3
1 1 1 1000
2 2 3 1000
3 3 2 1000
Output
14
Input
4 10 2
2 3 8 76
3 4 7 39
Output
289
Note
In the first example, it's optimal to build houses with heights [1, 3, 2]. We get a gain of 1^2+3^2+2^2 = 14. We don't violate any restrictions, so there are no fees, so the total profit is 14 - 0 = 14.
In the second example, it's optimal to build houses with heights [10, 8, 8, 10]. We get a gain of 10^2+8^2+8^2+10^2 = 328, and we violate the second restriction for a fee of 39, thus the total profit is 328-39 = 289. Note that even though there isn't a restriction on building 1, we must still limit its height to be at most 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
const int M = N * N;
const int inf = 1e9 + 7;
struct Edge {
int u, v;
long long c;
Edge() {}
Edge(int a, int b, long long d) : u(a), v(b), c(d) {}
};
vector<Edge> edges;
vector<int> G[M];
void AddEdge(int u, int v, long long c) {
G[u].push_back(edges.size());
edges.push_back(Edge(u, v, c));
G[v].push_back(edges.size());
edges.push_back(Edge(v, u, 0));
}
int was[M], dist[M], s, t;
long long Cut(int u, long long flow) {
if (u == t) return flow;
if (!flow || dist[u] >= dist[t]) return 0;
int ans = 0;
for (; was[u] < G[u].size(); was[u]++) {
int e = G[u][was[u]];
int v = edges[e].v;
long long c = edges[e].c;
if (!c || dist[v] != dist[u] + 1) continue;
int cut = Cut(v, min(flow, c));
edges[e].c -= cut;
edges[e ^ 1].c += cut;
ans += cut;
flow -= cut;
if (!flow) return ans;
}
return ans;
}
bool BFS() {
for (int i = s; i <= t; i++) dist[i] = inf, was[i] = 0;
dist[s] = 0;
queue<int> q;
q.push(s);
while (q.size()) {
int u = q.front();
q.pop();
for (int e : G[u]) {
int v = edges[e].v;
long long c = edges[e].c;
if (c && dist[v] > dist[u] + 1) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
return dist[t] != inf;
}
long long MaxFlow() {
long long Flow = 0;
while (BFS()) Flow += Cut(s, 1e18);
return Flow;
}
int id[N][N];
int main() {
int n, h, m, i, j, c = 0;
scanf("%i %i %i", &n, &h, &m);
s = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j <= h; j++) {
id[i][j] = ++c;
if (j > 0) AddEdge(id[i][j - 1], id[i][j], h * h - (j - 1) * (j - 1));
}
AddEdge(s, id[i][0], inf);
}
t = c + m + 1;
for (i = 1; i <= m; i++) {
int l, r, x, p;
scanf("%i %i %i %i", &l, &r, &x, &p);
c++;
AddEdge(c, t, p);
if (x != h)
for (j = l; j <= r; j++) AddEdge(id[j][x + 1], c, inf);
}
printf("%lld\n", (long long)n * h * h - MaxFlow());
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
In the city of Capypaland where Kuro and Shiro resides, there are n towns numbered from 1 to n and there are m bidirectional roads numbered from 1 to m connecting them. The i-th road connects towns u_i and v_i. Since traveling between the towns is quite difficult, the taxi industry is really popular here. To survive the harsh competition, each taxi company has to find a distinctive trait for their customers.
Kuro is the owner of a taxi company. He has decided to introduce a new fee model for his taxi brand, where the fee for each ride is not calculated based on the trip length, but on the sum of the prices of the roads traveled. The price for each of the m roads has been decided by Kuro himself.
As of now, the price for the road i is w_i and hence the fee for a taxi ride traveling through roads e_1, e_2, …, e_k is ∑_{i=1}^k w_{e_i}.
However, Kuro himself is an indecisive person, so he has drafted q plans to change the road price. Each of the plans will be based on the original prices w_i, except for a single road t_j, the price of which is changed to x_j. Note, that the plans are independent of each other.
Shiro is a regular customer of the Kuro's taxi brand since she uses the taxi to travel from town 1 to town n every day. Since she's so a regular customer, Kuro decided to show her all his q plans before publishing them to the public. Now, Shiro wants to know the lowest fee she must pay to travel from the town 1 to the town n for each Kuro's plan.
Input
The first line contains three integers n, m and q (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m, q ≤ 2 ⋅ 10^5) — the number of towns, the number of roads, and the number of plans that Kuro has drafted respectively.
The i-th of the next m contains three integers u_i, v_i and w_i (1 ≤ u_i, v_i ≤ n, 1 ≤ w_i ≤ 10^9, u_i ≠ v_i) — two endpoints and the original price of the i-th road.
It is guaranteed, that there is at least one way to travel from town 1 to town n using these m bidirectional roads.
Each of the next q lines contains two integers t_j and x_j (1 ≤ t_j ≤ m, 1 ≤ x_j ≤ 10^9) — the index of the road Kuro has planned to change and its new price respectively.
Output
Print q integers — the lowest fee Shiro must pay to get from town 1 to town n in each of those q plans.
Examples
Input
4 5 6
1 2 2
2 4 3
1 4 7
1 3 1
3 4 5
3 4
5 1
3 8
1 4
2 1
3 1
Output
4
2
5
6
3
1
Input
2 4 4
1 2 2
1 2 3
1 2 4
1 2 5
2 1
3 2
4 3
1 5
Output
1
2
2
3
Input
2 1 1
1 2 1
1 3
Output
3
Note
In the first example, the original overview of Capypaland looks like this, where the number next to each road denotes the original prices of the roads,
<image>
The overview of the first plan,
<image>
The lowest fee Shiro must pay in this plan is 4, which corresponds to the path 1 → 4.
The overview of the second plan,
<image>
The lowest fee Shiro must pay in this plan is 2, which corresponds to the path 1 → 3 → 4.
The overview of the third plan,
<image>
The lowest fee Shiro must pay in this plan is 5, which corresponds to the path 1 → 2 → 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const long long inf = 1e18;
long long dis[2][N], t[N * 4];
bool on[N];
int idx[N], lstvis[N], tot, l[N], r[N], n, m, Q;
int head[N], cnt;
struct edge {
int u, v, d;
} a[N];
struct e {
int id, next, to;
long long dis;
} edge[N * 2];
struct node {
int pos;
long long dis;
bool operator<(const node &x) const { return x.dis < dis; }
};
priority_queue<node> q;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void add(int id, int from, int to, long long dis) {
edge[++cnt].id = id;
edge[cnt].next = head[from];
edge[cnt].to = to;
edge[cnt].dis = dis;
head[from] = cnt;
}
inline void dijkstra(int s, int op, int f) {
for (int i = 1; i <= n; i++) dis[op][i] = inf;
dis[op][s] = 0;
q.push((node){s, 0});
while (!q.empty()) {
node fa = q.top();
q.pop();
int x = fa.pos;
if (fa.dis > dis[op][x]) continue;
for (int i = head[x]; i; i = edge[i].next) {
int to = edge[i].to;
if (dis[op][to] > fa.dis + edge[i].dis) {
dis[op][to] = fa.dis + edge[i].dis;
lstvis[to] = edge[i].id;
if (f == 1 && !on[to]) l[to] = l[x];
if (f == 2 && !on[to]) r[to] = r[x];
q.push((node){to, dis[op][to]});
}
}
}
}
inline void pre_work() {
on[1] = 1;
l[1] = r[1] = 0;
int cur = 1;
for (int i = 1; cur != n; i++) {
int id = lstvis[cur];
idx[id] = i;
++tot;
cur = a[id].u ^ a[id].v ^ cur;
on[cur] = 1;
l[cur] = r[cur] = i;
}
}
inline void build(int k, int l, int r) {
t[k] = inf;
if (l == r) return;
int mid = (l + r) >> 1;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
}
inline void update(int k, int l, int r, int ql, int qr, long long v) {
if (ql > qr) return;
if (ql <= l && r <= qr) {
t[k] = min(t[k], v);
return;
}
int mid = (l + r) >> 1;
if (ql <= mid) update(k * 2, l, mid, ql, qr, v);
if (qr > mid) update(k * 2 + 1, mid + 1, r, ql, qr, v);
}
inline long long query(int k, int l, int r, int x) {
if (l == r) return t[k];
int mid = (l + r) >> 1;
long long res = t[k];
if (x <= mid)
res = min(res, query(k * 2, l, mid, x));
else
res = min(res, query(k * 2 + 1, mid + 1, r, x));
return res;
}
int main() {
n = read();
m = read();
Q = read();
for (int i = 1; i <= m; i++) {
a[i].u = read(), a[i].v = read(), a[i].d = read();
add(i, a[i].u, a[i].v, a[i].d);
add(i, a[i].v, a[i].u, a[i].d);
idx[i] = -1;
}
dijkstra(n, 1, 0);
pre_work();
dijkstra(1, 0, 1);
dijkstra(n, 1, 2);
build(1, 1, tot);
for (int i = 1; i <= m; i++) {
if (idx[i] == -1) {
update(1, 1, tot, l[a[i].u] + 1, r[a[i].v],
dis[0][a[i].u] + dis[1][a[i].v] + a[i].d);
update(1, 1, tot, l[a[i].v] + 1, r[a[i].u],
dis[0][a[i].v] + dis[1][a[i].u] + a[i].d);
}
}
while (Q--) {
long long ans = dis[0][n];
int id = read(), len = read();
if (idx[id] != -1) {
ans = dis[0][n] - a[id].d + len;
if (len > a[id].d) {
ans = min(ans, query(1, 1, tot, idx[id]));
}
} else {
if (len < a[id].d) {
ans = min(ans, dis[0][a[id].u] + len + dis[1][a[id].v]);
ans = min(ans, dis[0][a[id].v] + len + dis[1][a[id].u]);
}
}
printf("%lld\n", ans);
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Today there is going to be an unusual performance at the circus — hamsters and tigers will perform together! All of them stand in circle along the arena edge and now the trainer faces a difficult task: he wants to swap the animals' positions so that all the hamsters stood together and all the tigers also stood together. The trainer swaps the animals in pairs not to create a mess. He orders two animals to step out of the circle and swap places. As hamsters feel highly uncomfortable when tigers are nearby as well as tigers get nervous when there's so much potential prey around (consisting not only of hamsters but also of yummier spectators), the trainer wants to spend as little time as possible moving the animals, i.e. he wants to achieve it with the minimal number of swaps. Your task is to help him.
Input
The first line contains number n (2 ≤ n ≤ 1000) which indicates the total number of animals in the arena. The second line contains the description of the animals' positions. The line consists of n symbols "H" and "T". The "H"s correspond to hamsters and the "T"s correspond to tigers. It is guaranteed that at least one hamster and one tiger are present on the arena. The animals are given in the order in which they are located circle-wise, in addition, the last animal stands near the first one.
Output
Print the single number which is the minimal number of swaps that let the trainer to achieve his goal.
Examples
Input
3
HTH
Output
0
Input
9
HTHTHTHHT
Output
2
Note
In the first example we shouldn't move anybody because the animals of each species already stand apart from the other species. In the second example you may swap, for example, the tiger in position 2 with the hamster in position 5 and then — the tiger in position 9 with the hamster in position 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class Ty, class Tx>
Ty cast(const Tx &x) {
Ty y;
stringstream ss("");
ss << x;
ss.seekg(0);
ss >> y;
return y;
}
string s;
int main() {
int n, i, j, k, cur, ret;
cin >> n;
cin >> s;
k = 0;
ret = 10000000;
for ((i) = 0; (i) < (n); (i)++)
if (s[i] == 'H') k++;
for ((i) = 0; (i) < (n); (i)++) {
cur = 0;
for ((j) = 0; (j) < (k); (j)++)
if (s[(i + j) % n] != 'H') cur++;
ret = min(ret, cur);
}
cout << ret << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi the Jumbo will practice golf.
His objective is to get a carry distance that is a multiple of K, while he can only make a carry distance of between A and B (inclusive).
If he can achieve the objective, print `OK`; if he cannot, print `NG`.
Constraints
* All values in input are integers.
* 1 \leq A \leq B \leq 1000
* 1 \leq K \leq 1000
Input
Input is given from Standard Input in the following format:
K
A B
Output
If he can achieve the objective, print `OK`; if he cannot, print `NG`.
Examples
Input
7
500 600
Output
OK
Input
4
5 7
Output
NG
Input
1
11 11
Output
OK
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int k, a, b;
cin >> k >> a >> b;
cout << (b/k*k>=a ? "OK" : "NG") << endl;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Using the given four integers from 1 to 9, we create an expression that gives an answer of 10. When you enter four integers a, b, c, d, write a program that outputs an expression that gives an answer of 10 according to the following conditions. Also, if there are multiple answers, only the first answer found will be output. If there is no answer, output 0.
* Use only addition (+), subtraction (-), and multiplication (*) as operators. Do not use division (/). You can use three operators.
* You must use all four numbers.
* You can freely change the order of the four numbers.
* You can use parentheses. You can use up to 3 sets (6) of parentheses.
Input
Given multiple datasets. The format of each dataset is as follows:
a b c d
Input ends with four 0s. The number of datasets does not exceed 40.
Output
For each dataset, combine the given four integers with the above arithmetic symbols and parentheses to output an expression or 0 with a value of 10 on one line. The expression string must not exceed 1024 characters.
Example
Input
8 7 9 9
4 4 4 4
5 5 7 5
0 0 0 0
Output
((9 * (9 - 7)) - 8)
0
((7 * 5) - (5 * 5))
### Response
```cpp
#include<iostream>
#define lol(i,n) for(int i=0;i<n;i++)
using namespace std;
int f(int a,int b,int x){return (x?(x-1?a*b:a-b):a+b);}int r[4];
int main(){
while(cin>>r[0]>>r[1]>>r[2]>>r[3]&&r[0]){lol(q,99){string z="+-*";
lol(i,3)lol(j,3)lol(k,3){
if(f(f(r[0],r[1],i),f(r[2],r[3],k),j)==10){cout<<"("<<r[0]<<z[i]<<r[1]<<")"<<z[j]<<"("<<r[2]<<z[k]<<r[3]<<")\n";goto l;}
if(f(f(f(r[0],r[1],i),r[2],j),r[3],k)==10){cout<<"(("<<r[0]<<z[i]<<r[1]<<")"<<z[j]<<r[2]<<")"<<z[k]<<r[3]<<"\n";goto l;}
}if(q%6==5)swap(r[0],r[1]);else if(q%2==1)swap(r[1],r[2]);else swap(r[2],r[3]);
}cout<<"0"<<endl;l:;
}return 0;}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
A bus moves along the coordinate line Ox from the point x = 0 to the point x = a. After starting from the point x = 0, it reaches the point x = a, immediately turns back and then moves to the point x = 0. After returning to the point x = 0 it immediately goes back to the point x = a and so on. Thus, the bus moves from x = 0 to x = a and back. Moving from the point x = 0 to x = a or from the point x = a to x = 0 is called a bus journey. In total, the bus must make k journeys.
The petrol tank of the bus can hold b liters of gasoline. To pass a single unit of distance the bus needs to spend exactly one liter of gasoline. The bus starts its first journey with a full petrol tank.
There is a gas station in point x = f. This point is between points x = 0 and x = a. There are no other gas stations on the bus route. While passing by a gas station in either direction the bus can stop and completely refuel its tank. Thus, after stopping to refuel the tank will contain b liters of gasoline.
What is the minimum number of times the bus needs to refuel at the point x = f to make k journeys? The first journey starts in the point x = 0.
Input
The first line contains four integers a, b, f, k (0 < f < a ≤ 106, 1 ≤ b ≤ 109, 1 ≤ k ≤ 104) — the endpoint of the first bus journey, the capacity of the fuel tank of the bus, the point where the gas station is located, and the required number of journeys.
Output
Print the minimum number of times the bus needs to refuel to make k journeys. If it is impossible for the bus to make k journeys, print -1.
Examples
Input
6 9 2 4
Output
4
Input
6 10 2 4
Output
2
Input
6 5 4 3
Output
-1
Note
In the first example the bus needs to refuel during each journey.
In the second example the bus can pass 10 units of distance without refueling. So the bus makes the whole first journey, passes 4 units of the distance of the second journey and arrives at the point with the gas station. Then it can refuel its tank, finish the second journey and pass 2 units of distance from the third journey. In this case, it will again arrive at the point with the gas station. Further, he can refill the tank up to 10 liters to finish the third journey and ride all the way of the fourth journey. At the end of the journey the tank will be empty.
In the third example the bus can not make all 3 journeys because if it refuels during the second journey, the tanks will contain only 5 liters of gasoline, but the bus needs to pass 8 units of distance until next refueling.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long a, b, f, k;
int cnt() {
int c = 0;
int n = v.size();
long long now = 0;
for (int i = 0; i < n; i++) {
if (now + b < v[i]) return -1;
while (i < n && now + b >= v[i]) i++;
i--;
c++;
now = v[i];
}
return c - 1;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &a, &b, &f, &k);
v.push_back(f);
for (long long i = 1; i < k; i++) {
if (i & 1)
v.push_back(v[i - 1] + 2 * (a - f));
else
v.push_back(v[i - 1] + 2 * f);
}
v.push_back(a * k);
printf("%d", cnt());
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given a string s consisting only of characters 0 and 1. A substring [l, r] of s is a string slsl + 1sl + 2... sr, and its length equals to r - l + 1. A substring is called balanced if the number of zeroes (0) equals to the number of ones in this substring.
You have to determine the length of the longest balanced substring of s.
Input
The first line contains n (1 ≤ n ≤ 100000) — the number of characters in s.
The second line contains a string s consisting of exactly n characters. Only characters 0 and 1 can appear in s.
Output
If there is no non-empty balanced substring in s, print 0. Otherwise, print the length of the longest balanced substring.
Examples
Input
8
11010111
Output
4
Input
3
111
Output
0
Note
In the first example you can choose the substring [3, 6]. It is balanced, and its length is 4. Choosing the substring [2, 5] is also possible.
In the second example it's impossible to find a non-empty balanced substring.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<bool> v;
map<int, int> mp;
int n;
int main() {
string s;
cin >> n >> s;
int maxi = 0;
v.resize(n);
for (int i = 0; i < n; i++) {
v[i] = s[i] - '0';
}
vector<pair<int, int> > c(n);
vector<int> cu(n);
if (v[0]) {
c[0].first = 1;
c[0].second = 0;
} else {
c[0].first = 0;
c[0].second = 1;
}
cu[0] = c[0].first - c[0].second;
mp[cu[0]] = 0;
mp[0] = -1;
for (int i = 1; i < n; i++) {
if (v[i]) {
c[i].first = 1 + c[i - 1].first;
c[i].second = c[i - 1].second;
} else {
c[i].first = c[i - 1].first;
c[i].second = 1 + c[i - 1].second;
}
cu[i] = c[i].first - c[i].second;
if (mp.count(cu[i])) {
maxi = max(maxi, i - mp[cu[i]]);
} else
mp[cu[i]] = i;
}
cout << maxi;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
A team of furry rescue rangers was sitting idle in their hollow tree when suddenly they received a signal of distress. In a few moments they were ready, and the dirigible of the rescue chipmunks hit the road.
We assume that the action takes place on a Cartesian plane. The headquarters of the rescuers is located at point (x1, y1), and the distress signal came from the point (x2, y2).
Due to Gadget's engineering talent, the rescuers' dirigible can instantly change its current velocity and direction of movement at any moment and as many times as needed. The only limitation is: the speed of the aircraft relative to the air can not exceed <image> meters per second.
Of course, Gadget is a true rescuer and wants to reach the destination as soon as possible. The matter is complicated by the fact that the wind is blowing in the air and it affects the movement of the dirigible. According to the weather forecast, the wind will be defined by the vector (vx, vy) for the nearest t seconds, and then will change to (wx, wy). These vectors give both the direction and velocity of the wind. Formally, if a dirigible is located at the point (x, y), while its own velocity relative to the air is equal to zero and the wind (ux, uy) is blowing, then after <image> seconds the new position of the dirigible will be <image>.
Gadget is busy piloting the aircraft, so she asked Chip to calculate how long will it take them to reach the destination if they fly optimally. He coped with the task easily, but Dale is convinced that Chip has given the random value, aiming only not to lose the face in front of Gadget. Dale has asked you to find the right answer.
It is guaranteed that the speed of the wind at any moment of time is strictly less than the maximum possible speed of the airship relative to the air.
Input
The first line of the input contains four integers x1, y1, x2, y2 (|x1|, |y1|, |x2|, |y2| ≤ 10 000) — the coordinates of the rescuers' headquarters and the point, where signal of the distress came from, respectively.
The second line contains two integers <image> and t (0 < v, t ≤ 1000), which are denoting the maximum speed of the chipmunk dirigible relative to the air and the moment of time when the wind changes according to the weather forecast, respectively.
Next follow one per line two pairs of integer (vx, vy) and (wx, wy), describing the wind for the first t seconds and the wind that will blow at all the remaining time, respectively. It is guaranteed that <image> and <image>.
Output
Print a single real value — the minimum time the rescuers need to get to point (x2, y2). You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
0 0 5 5
3 2
-1 -1
-1 0
Output
3.729935587093555327
Input
0 0 0 1000
100 1000
-50 0
50 0
Output
11.547005383792516398
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int x1, Y1, x2, y2, v, t, vx, vy, wx, wy;
int main() {
scanf("%d%d%d%d", &x1, &Y1, &x2, &y2);
scanf("%d%d", &v, &t);
scanf("%d%d", &vx, &vy);
scanf("%d%d", &wx, &wy);
double t1 = 1e-8, t2 = 1e8, m;
while (t2 - t1 > 1e-8) {
m = (t1 + t2) / 2;
double X = x2 - (vx * (m < t ? m : t)) - (wx * (m < t ? 0 : m - t)) - x1;
double Y = y2 - (vy * (m < t ? m : t)) - (wy * (m < t ? 0 : m - t)) - Y1;
double R = sqrt(X * X + Y * Y);
if (R / m > v) {
t1 = m;
} else {
t2 = m;
}
}
printf("%.8lf\n", (t1 + t2) / 2);
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
The postal code in Atcoder Kingdom is A+B+1 characters long, its (A+1)-th character is a hyphen `-`, and the other characters are digits from `0` through `9`.
You are given a string S. Determine whether it follows the postal code format in Atcoder Kingdom.
Constraints
* 1≤A,B≤5
* |S|=A+B+1
* S consists of `-` and digits from `0` through `9`.
Input
Input is given from Standard Input in the following format:
A B
S
Output
Print `Yes` if S follows the postal code format in AtCoder Kingdom; print `No` otherwise.
Examples
Input
3 4
269-6650
Output
Yes
Input
1 1
---
Output
No
Input
1 2
7444
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
string S;
cin >> A >> B >> S;
string ans = "Yes";
for(int i=0; i<A+B+1; i++){
if(i==A && S.at(i)!='-')ans="No";
if(i!=A && S.at(i)=='-')ans = "No";
}
cout << ans << endl;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Bessie the cow and her best friend Elsie each received a sliding puzzle on Pi Day. Their puzzles consist of a 2 × 2 grid and three tiles labeled 'A', 'B', and 'C'. The three tiles sit on top of the grid, leaving one grid cell empty. To make a move, Bessie or Elsie can slide a tile adjacent to the empty cell into the empty cell as shown below:
<image>
In order to determine if they are truly Best Friends For Life (BFFLs), Bessie and Elsie would like to know if there exists a sequence of moves that takes their puzzles to the same configuration (moves can be performed in both puzzles). Two puzzles are considered to be in the same configuration if each tile is on top of the same grid cell in both puzzles. Since the tiles are labeled with letters, rotations and reflections are not allowed.
Input
The first two lines of the input consist of a 2 × 2 grid describing the initial configuration of Bessie's puzzle. The next two lines contain a 2 × 2 grid describing the initial configuration of Elsie's puzzle. The positions of the tiles are labeled 'A', 'B', and 'C', while the empty cell is labeled 'X'. It's guaranteed that both puzzles contain exactly one tile with each letter and exactly one empty position.
Output
Output "YES"(without quotes) if the puzzles can reach the same configuration (and Bessie and Elsie are truly BFFLs). Otherwise, print "NO" (without quotes).
Examples
Input
AB
XC
XB
AC
Output
YES
Input
AB
XC
AC
BX
Output
NO
Note
The solution to the first sample is described by the image. All Bessie needs to do is slide her 'A' tile down.
In the second sample, the two puzzles can never be in the same configuration. Perhaps Bessie and Elsie are not meant to be friends after all...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool check(vector<char> v1, vector<char> v2, int x) {
for (int i = x, j = 0; i < x + 3 and j < 3; i++, j++) {
if (v1[i % 3] != v2[j]) return 0;
}
return 1;
}
int main() {
string ss, ss1, temp;
vector<char> s1, s2;
s1.resize(3);
s2.resize(3);
cin >> ss;
cin >> temp;
reverse(temp.begin(), temp.end());
ss += temp;
cin >> ss1;
cin >> temp;
reverse(temp.begin(), temp.end());
ss1 += temp;
for (int i = 0, j = 0; i < 4; i++) {
if (ss[i] != 'X') {
s1[j] = ss[i];
j++;
}
}
for (int i = 0, j = 0; i < 4; i++) {
if (ss1[i] != 'X') {
s2[j] = ss1[i];
j++;
}
}
for (int i = 0; i < 10; i++) {
if (check(s1, s2, i)) {
printf("YES");
return 0;
}
}
printf("NO");
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string A[4];
int main() {
int n, k;
cin >> n >> k;
bool alleq = true;
int which;
string s;
int v;
bool valid = true;
for (int i = 0; valid and i < n; ++i) {
for (int j = 0; j < 4; ++j) {
cin >> s;
v = 0;
int r, c = 0;
for (r = s.size() - 1; c < k and r >= 0; --r)
c += s[r] == 'a' or s[r] == 'e' or s[r] == 'i' or s[r] == 'o' or
s[r] == 'u';
if (c == k) {
A[j] = s.substr(r + 1);
} else {
cout << "NO" << endl;
return 0;
}
}
if (alleq) {
int how = 0;
which = -1;
for (int j = 1; j < 4; j++) {
if (A[0].size() == A[j].size() and A[0] == A[j]) {
++how;
which = j;
}
}
if (how == 3) continue;
if (how == 2 or how == 0) {
valid = false;
continue;
}
alleq = false;
if (which == 1) valid = A[2].size() == A[3].size() and A[2] == A[3];
if (which == 2) valid = A[1].size() == A[3].size() and A[1] == A[3];
if (which == 3) valid = A[1].size() == A[2].size() and A[1] == A[2];
} else {
valid = A[0].size() == A[which].size() and A[0] == A[which];
if (valid) {
if (which == 1) valid = A[2].size() == A[3].size() and A[2] == A[3];
if (which == 2) valid = A[1].size() == A[3].size() and A[1] == A[3];
if (which == 3) valid = A[1].size() == A[2].size() and A[1] == A[2];
}
}
}
if (valid) {
if (alleq) {
cout << "aaaa";
} else {
if (which == 1)
cout << "aabb";
else if (which == 2)
cout << "abab";
else
cout << "abba";
}
} else {
cout << "NO";
}
cout << endl;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Dante is engaged in a fight with "The Savior". Before he can fight it with his sword, he needs to break its shields. He has two guns, Ebony and Ivory, each of them is able to perform any non-negative number of shots.
For every bullet that hits the shield, Ebony deals a units of damage while Ivory deals b units of damage. In order to break the shield Dante has to deal exactly c units of damage. Find out if this is possible.
Input
The first line of the input contains three integers a, b, c (1 ≤ a, b ≤ 100, 1 ≤ c ≤ 10 000) — the number of units of damage dealt by Ebony gun and Ivory gun, and the total number of damage required to break the shield, respectively.
Output
Print "Yes" (without quotes) if Dante can deal exactly c damage to the shield and "No" (without quotes) otherwise.
Examples
Input
4 6 15
Output
No
Input
3 2 7
Output
Yes
Input
6 11 6
Output
Yes
Note
In the second sample, Dante can fire 1 bullet from Ebony and 2 from Ivory to deal exactly 1·3 + 2·2 = 7 damage. In the third sample, Dante can fire 1 bullet from ebony and no bullets from ivory to do 1·6 + 0·11 = 6 damage.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int x[10001];
int main() {
memset(x, -1, sizeof x);
cin >> a >> b >> n;
x[0] = 0;
for (int i = 1; i <= n; ++i) {
if (i - a >= 0 && x[i - a] != -1) {
x[i] = max(x[i], 1 + x[i - a]);
}
if (i - b >= 0 && x[i - b] != -1) {
x[i] = max(x[i], 1 + x[i - b]);
}
}
if (x[n] == -1)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Math teacher Mr. Matsudaira is teaching expansion and factoring of polynomials to his students. Last week he instructed the students to write two polynomials (with a single variable x), and to report GCM (greatest common measure) of them as a homework, but he found it boring to check their answers manually. So you are asked to write a program to check the answers.
Hereinafter, only those polynomials with integral coefficients, called integral polynomials, are considered.
When two integral polynomials A and B are given, an integral polynomial C is a common factor of A and B if there are some integral polynomials X and Y such that A = CX and B = CY.
GCM of two integral polynomials is a common factor which has the highest degree (for x, here); you have to write a program which calculates the GCM of two polynomials.
It is known that GCM of given two polynomials is unique when constant multiplication factor is ignored. That is, when C and D are both GCM of some two polynomials A and B, p × C = q × D for some nonzero integers p and q.
Input
The input consists of multiple datasets. Each dataset constitutes a pair of input lines, each representing a polynomial as an expression defined below.
1. A primary is a variable x, a sequence of digits 0 - 9, or an expression enclosed within ( ... ). Examples:
x, 99, (x+1)
2. A factor is a primary by itself or a primary followed by an exponent. An exponent consists of a symbol ^ followed by a sequence of digits 0 - 9. Examples:
x^05, 1^15, (x+1)^3
3. A term consists of one or more adjoining factors. Examples:
4x, (x+1)(x-2), 3(x+1)^2
4. An expression is one or more terms connected by either + or -. Additionally, the first term of an expression may optionally be preceded with a minus sign -. Examples:
-x+1, 3(x+1)^2-x(x-1)^2
Integer constants, exponents, multiplications (adjoining), additions (+) and subtractions/negations (-) have their ordinary meanings. A sequence of digits is always interpreted as an integer con- stant. For example, 99 means 99, not 9 × 9.
Any subexpressions of the input, when fully expanded normalized, have coefficients less than 100 and degrees of x less than 10. Digit sequences in exponents represent non-zero values.
All the datasets are designed so that a standard algorithm with 32-bit two’s complement integers can solve the problem without overflows.
The end of the input is indicated by a line containing a period.
Output
For each of the dataset, output GCM polynomial expression in a line, in the format below.
c0x^p0 ± c1x^p1 ... ± cnx^pn
Where ci and pi (i = 0, . . . , n) are positive integers with p0 > p1 > . . . > pn, and the greatest common divisor of {ci | i = 0, . . . , n} is 1.
Additionally:
1. When ci is equal to 1, it should be omitted unless corresponding pi is 0,
2. x^0 should be omitted as a whole, and
3. x^1 should be written as x.
Example
Input
-(x^3-3x^2+3x-1)
(x-1)^2
x^2+10x+25
x^2+6x+5
x^3+1
x-1
.
Output
x^2-2x+1
x+5
1
### Response
```cpp
#include <cstdio>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <algorithm>
using namespace std;
#define MAX_DEG 21
int gcd(int a, int b) {
return b != 0 ? gcd(b, a % b) : a;
}
class Polynomial
{
public:
int c[MAX_DEG];
Polynomial()
{
memset(c,0,sizeof(c));
}
Polynomial(int tc[MAX_DEG])
{
memcpy(c, tc, sizeof(c));
}
Polynomial operator*(const Polynomial& p) const
{
int tc[MAX_DEG]={0};
for(int i=0; i<=MAX_DEG/2; i++)
for(int j=0; j<=MAX_DEG/2; j++)
{
tc[i+j]+=c[i]*p.c[j];
}
return Polynomial(tc);
}
Polynomial operator+(const Polynomial& p) const
{
int tc[MAX_DEG]={0};
for(int i=0; i<21; i++)
{
tc[i]=c[i]+p.c[i];
}
return Polynomial(tc);
}
Polynomial operator%(const Polynomial& p) const
{
int me,pos,t,s;
int tc[MAX_DEG]={0};
memcpy(tc, c, sizeof(c));
me = pos = MAX_DEG-1;
while(!p.c[me]){ me--; }
while(!tc[pos]){ pos--; }
while(pos>=me)
{
t = p.c[me] / gcd(tc[pos],p.c[me]);
s = tc[pos] / gcd(tc[pos],p.c[me]);
for(int i=pos; i>=0; i--)
{
tc[i] *= t;
}
for(int i=0; i<=me; i++)
{
tc[pos-i] -= (p.c[me-i]*s);
}
pos--;
}
return Polynomial(tc);
}
Polynomial operator-() const
{
Polynomial ret=*this;
for(int i=0; i<MAX_DEG; i++)
ret.c[i]*=-1;
return ret;
}
bool operator<(const Polynomial& p) const
{
for(int i=MAX_DEG-1; i>=0; i--)
{
if(abs(c[i]) != abs(p.c[i])) return abs(c[i]) < abs(p.c[i]);
}
return true;
}
void print()
{
bool d=false;
for(int i=MAX_DEG-1; i>=0; i--)
{
if(c[i]!=0)
{
if(d) printf((c[i]>0?"+":""));
d=true;
if(i>0)
{
if(c[i]!=1&&c[i]!=-1) printf("%d", c[i]);
if(c[i]==-1) printf("-");
printf("x");
if(i!=1) printf("^%d", i);
}
else
{
printf("%d", c[i]);
}
}
}
if(!d) printf("0");
puts("");
}
void PolyGcd()
{
int t=c[0];
for(int i=0; i<MAX_DEG; i++)
{
if(c[i]!=0) t=gcd(t,c[i]);
}
for(int i=0; i<MAX_DEG; i++)
{
if(t==0) break;
c[i]/=t;
}
for(int i=MAX_DEG-1; i>=0; i--)
{
if(c[i]==0) continue;
if(c[i]>0) break;
for(int j=0; j<MAX_DEG; j++)
c[j]*=-1;
break;
}
}
};
int pow(int n, int s)
{
int ret=1;
for(int i=0; i<s; i++)
ret*=n;
return ret;
}
int p;
char s[101];
int parseInt()
{
int num=0;
while(p<strlen(s))
{
if(!isdigit(s[p])) break;
num*=10;
num+=(s[p]-'0');
p++;
}
return num;
}
Polynomial parsePolynomial()
{
int num=-1, c[MAX_DEG]={0};
bool f=false, fst=true, minus=false;
for(; p<strlen(s); )
{
if(s[p]=='+'||s[p]=='-')
{
if(!fst)
{
int tp=p;
p++;
parseInt();
if(s[p]=='x') p++;
if(s[p]=='(')
{
p=tp;
break;
}
p=tp;
}
if(s[p]=='-') minus=true;
p++;
}
if(num==-1) num=parseInt();
if(s[p]=='x')
{
f=true;
p++;
}
if(s[p]=='^') p++;
int t=parseInt();
if(f&&t==0) t++;
if(f&&num==0) num++;
if(minus) num*=-1;
if(!f)
{
if(t!=0) c[0]+=pow(num, t);
else c[0]+=num;
}
else c[t]+=num;
num=-1;
minus=false;
f=false;
fst=false;
if(s[p]=='('||s[p]==')') break;
}
if(num!=-1)
{
if(f&&num==0) num++;
if(minus) num*=-1;
if(f) c[1]+=num;
else c[0]+=num;
}
return Polynomial(c);
}
Polynomial parseExp()
{
Polynomial ret;
bool fst=true;
for(; p<strlen(s); )
{
Polynomial a;
if(s[p]=='(') p++;
a=parsePolynomial();
if(s[p]==')') p++;
if(s[p]=='^')
{
p++;
Polynomial pw=a;
int num=parseInt();
for(int i=0; i<num-1; i++)
{
a=a*pw;
}
}
if(fst)
{
ret=a;
fst=false;
}
else ret=ret*a;
if(s[p]=='+'||s[p]=='-') break;
}
return ret;
}
Polynomial parse()
{
p=0;
Polynomial ret;
bool fst=true;
for(; p<strlen(s);)
{
bool minus=false, plmi=false;
Polynomial a;
if(s[p]=='-')
{
minus=true;
if(s[p+1]!='(') minus=false;
}
if(s[p]=='+'||s[p]=='-')
{
plmi=true;
if(minus||s[p]=='+') p++;
}
a=parseExp();
if(minus) a=-a;
if(fst)
{
ret=a;
fst=false;
}
else
{
if(plmi) ret=ret+a;
else ret=ret*a;
}
}
return ret;
}
bool isZero(Polynomial a)
{
for(int i=MAX_DEG-1; i>=0; i--)
{
if(a.c[i])
{
return false;
}
}
return true;
}
int main()
{
while(scanf("%s", s), s[0]!='.')
{
Polynomial a, b, c;
a=parse();
scanf("%s", s);
b=parse();
if(a<b) swap(a,b);
while(!isZero(b))
{
c = a%b;
a = b;
b = c;
}
a.PolyGcd();
a.print();
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Let's define a split of n as a nonincreasing sequence of positive integers, the sum of which is n.
For example, the following sequences are splits of 8: [4, 4], [3, 3, 2], [2, 2, 1, 1, 1, 1], [5, 2, 1].
The following sequences aren't splits of 8: [1, 7], [5, 4], [11, -3], [1, 1, 4, 1, 1].
The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split [1, 1, 1, 1, 1] is 5, the weight of the split [5, 5, 3, 3, 3] is 2 and the weight of the split [9] equals 1.
For a given n, find out the number of different weights of its splits.
Input
The first line contains one integer n (1 ≤ n ≤ 10^9).
Output
Output one integer — the answer to the problem.
Examples
Input
7
Output
4
Input
8
Output
5
Input
9
Output
5
Note
In the first sample, there are following possible weights of splits of 7:
Weight 1: [\textbf 7]
Weight 2: [\textbf 3, \textbf 3, 1]
Weight 3: [\textbf 2, \textbf 2, \textbf 2, 1]
Weight 7: [\textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1, \textbf 1]
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
std::cout << n / 2 + 1 << std::endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Input
The input is given from Standard Input in the following format:
> $N \ Q$ $a_1 \ b_1$ $a_2 \ b_2$ $ ： \ ： $ $a_Q \ b_Q$
Output
* You have to print $N$ lines.
* The $i$-th line should contain the number of dishes of sushi had eaten for customer $i (1 \le i \le N)$.
Constraints
* $3 \le N, Q \le 100,000$
* $1 \le a_i \le N$
* $1 \le b_i \le 10^{12}$
* Any final results do not exceed $2 \times 10^{13}$.
Subtasks
Subtask 1 [ $60$ points ]
* $N, Q \le 100$
* $b_i = 1$
Subtask 2 [ $400$ points ]
* $N, Q \le 100$
* $b_i \le 10^{12}$
Subtask 3 [ $240$ points ]
* $N, Q \le 100,000$
* $b_i = 1$
Subtask 4 [ $500$ points ]
* There are no additional constraints.
Output
* You have to print $N$ lines.
* The $i$-th line should contain the number of dishes of sushi had eaten for customer $i (1 \le i \le N)$.
Constraints
* $3 \le N, Q \le 100,000$
* $1 \le a_i \le N$
* $1 \le b_i \le 10^{12}$
* Any final results do not exceed $2 \times 10^{13}$.
Subtasks
Subtask 1 [ $60$ points ]
* $N, Q \le 100$
* $b_i = 1$
Subtask 2 [ $400$ points ]
* $N, Q \le 100$
* $b_i \le 10^{12}$
Subtask 3 [ $240$ points ]
* $N, Q \le 100,000$
* $b_i = 1$
Subtask 4 [ $500$ points ]
* There are no additional constraints.
Input
The input is given from Standard Input in the following format:
> $N \ Q$ $a_1 \ b_1$ $a_2 \ b_2$ $ ： \ ： $ $a_Q \ b_Q$
Examples
Input
9 3
5 11
8 4
4 7
Output
4
4
4
4
2
2
1
1
0
Input
6 6
3 5
6 11
1 6
4 7
5 2
2 5
Output
10
10
5
5
4
2
Input
5 6
1 1
2 1
3 1
1 1
5 1
3 1
Output
2
2
1
1
0
Input
10 10
10 10
9 20
8 30
7 40
6 50
5 60
4 70
3 80
2 90
1 100
Output
223
123
77
50
33
21
12
7
3
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using VS = vector<string>; using LL = long long;
using VI = vector<int>; using VVI = vector<VI>;
using PII = pair<int, int>; using PLL = pair<LL, LL>;
using VL = vector<LL>; using VVL = vector<VL>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)
#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)
//#pragma GCC optimize ("-O3")
#ifdef YANG33
#include "mydebug.hpp"
#else
#define DD(x)
#endif
const int INF = 1e9; const LL LINF = 1e16;
const LL MOD = 1000000007; const double PI = acos(-1.0);
/* ----- 2019/07/09 Problem: SQUARE869120CONTEST_03 F / Link: https://atcoder.jp/contests/s8pc-3/ ----- */
template <typename M>
class lazy_segment_tree {
using T1 = typename M::t1;
using T2 = typename M::t2;
const int h, n;
vector<T1> data;
vector<T2> lazy;
void push(int node) {
if (lazy[node] == M::id2()) return;
if (node < n) {
lazy[node * 2] = M::op3(lazy[node * 2], lazy[node]);
lazy[node * 2 + 1] = M::op3(lazy[node * 2 + 1], lazy[node]);
}
data[node] = M::op2(data[node], lazy[node]);
lazy[node] = M::id2();
}
void update(int node) {
data[node] = M::op1(M::op2(data[node * 2], lazy[node * 2]), M::op2(data[node * 2 + 1], lazy[node * 2 + 1]));
}
public:
lazy_segment_tree(int n_)
: h(ceil(log2(n_))), n(1 << h), data(n * 2, M::id1()), lazy(n * 2, M::id2()) {}
lazy_segment_tree(int n_, T1 v1)
: h(ceil(log2(n_))), n(1 << h), data(n * 2, v1), lazy(n * 2, M::id2()) {}
lazy_segment_tree(const vector<T1>& data_)
: h(ceil(log2(data_.size()))), n(1 << h), data(n * 2, M::id1()), lazy(n * 2, M::id2()) {
init(data_);
}
void init() {
for (int i = n - 1; i >= 1; i--) data[i] = M::op1(data[i * 2], data[i * 2 + 1]);
}
void init(const vector<T1>& data_) {
for (int i = 0; i < (int)data_.size(); i++) data[i + n] = data_[i];
init();
}
void update(int l, int r, T2 val) {
r--;
l += n, r += n;
for (int i = h; i > 0; i--) push(l >> i), push(r >> i);
int tl = l, tr = r;
r++;
while (l < r) {
if (l & 1) lazy[l] = M::op3(lazy[l], val), l++;
if (r & 1) r--, lazy[r] = M::op3(lazy[r], val);
l >>= 1; r >>= 1;
}
while (tl >>= 1, tr >>= 1, tl) {
if (lazy[tl] == M::id2()) update(tl);
if (lazy[tr] == M::id2()) update(tr);
}
}
T1 query(int l, int r) {
r--;
l += n, r += n;
for (int i = h; i > 0; i--) push(l >> i), push(r >> i);
r++;
T1 res1 = M::id1(), res2 = M::id1();
while (l < r) {
if (l & 1) res1 = M::op1(res1, M::op2(data[l], lazy[l])), l++;
if (r & 1) r--, res2 = M::op1(M::op2(data[r], lazy[r]), res2);
l >>= 1; r >>= 1;
}
return M::op1(res1, res2);
}
};
struct M {
using ll = long long;
struct t1 {
ll val, size;
t1(ll v, ll s = 1) : val(v), size(s) {}
};
using t2 = ll;
static t1 id1() { return t1(0, 0); }
static t2 id2() { return -LINF; }
static t1 op1(const t1& l, const t1& r) { return t1(l.val + r.val, l.size + r.size); }
static t1 op2(const t1& l, const t2& r) {
if (r == id2()) {
return l;
}
return t1(l.size * r, l.size);
}
static t2 op3(const t2& l, const t2& r) { return r != id2() ? r : l; }
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
LL N, Q; cin >> N >> Q;
vector<M::t1>init_data(N, M::t1(0, 1));
lazy_segment_tree<M> seg(init_data);
auto print = [&]() {
return;
DD(
FOR(i, 0, N) {
cout << seg.query(i, i + 1).val << " \n"[i + 1 == N];
}
)
};
print();
FOR(_, 0, Q) {
LL a, b; cin >> a >> b;
LL L = -1, R = a;
while (R - L > 1) {
LL mid = (R + L) / 2;
LL v = seg.query(mid, mid + 1).val;
if (v*(a - mid) - seg.query(mid, a).val <= b) {
R = mid;
}
else {
L = mid;
}
}
LL v = seg.query(R, R + 1).val;
b -= v * (a - R) - seg.query(R, a).val;
v += b / (a - R); // delta
b %= (a - R); // mod
seg.update(R, R + b, v + 1);
seg.update(R + b, a, v);
print();
}
FOR(i, 0, N) {
cout << seg.query(i, i + 1).val << "\n";
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You have N cups and 1 ball.
The cups are arranged in a row, from left to right.
You turned down all the cups, then inserted the ball into the leftmost cup.
Then, you will perform the following Q operations:
* The i-th operation: swap the positions of the A_i-th and B_i-th cups from the left. If one of these cups contains the ball, the ball will also move.
Since you are a magician, you can cast a magic described below:
* Magic: When the ball is contained in the i-th cup from the left, teleport the ball into the adjacent cup (that is, the (i-1)-th or (i+1)-th cup, if they exist).
The magic can be cast before the first operation, between two operations, or after the last operation, but you are allowed to cast it at most once during the whole process.
Find the number of cups with a possibility of containing the ball after all the operations and possibly casting the magic.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq Q \leq 10^5
* 1 \leq A_i < B_i \leq N
Input
The input is given from Standard Input in the following format:
N Q
A_1 B_1
A_2 B_2
:
A_Q B_Q
Output
Print the number of cups with a possibility of eventually containing the ball.
Examples
Input
10 3
1 3
2 4
4 5
Output
4
Input
20 3
1 7
8 20
1 19
Output
5
### Response
```cpp
#include<cstdio>
#include<cstring>
#include<cstdlib>
int main(void){
int a[100000];
int c;
int x;
int n;
int w;
int t;
int p[100000];
int q[100000];
scanf("%d %d", &n, &t);
for (int i = 0; i < t; i++){
scanf("%d %d", &p[i], &q[i]);
p[i]--;
q[i]--;
}
for (int i = 0; i < 100000; i++)a[i] = 0;
a[0] = 2;
a[1] = 1;
x=0;
for (int i = 0; i < t; i++){
w = a[p[i]];
a[p[i]] = a[q[i]];
a[q[i]] = w;
if (a[p[i]] == 2) x=p[i];
if(a[q[i]]==2)x=q[i];
if (x > 0)a[x-1] = 1;
if (x< n - 1)a[x+1] = 1;
}
c = 0;
for(int i = 0; i < n; i++){
if (a[i] > 0)c++;
}
printf("%d\n",c);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are both a shop keeper and a shop assistant at a small nearby shop. You have n goods, the i-th good costs a_i coins.
You got tired of remembering the price of each product when customers ask for it, thus you decided to simplify your life. More precisely you decided to set the same price for all n goods you have.
However, you don't want to lose any money so you want to choose the price in such a way that the sum of new prices is not less than the sum of the initial prices. It means that if you sell all n goods for the new price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
On the other hand, you don't want to lose customers because of big prices so among all prices you can choose you need to choose the minimum one.
So you need to find the minimum possible equal price of all n goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of queries. Then q queries follow.
The first line of the query contains one integer n (1 ≤ n ≤ 100) — the number of goods. The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^7), where a_i is the price of the i-th good.
Output
For each query, print the answer for it — the minimum possible equal price of all n goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
Example
Input
3
5
1 2 3 4 5
3
1 2 2
4
1 1 1 1
Output
3
2
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using vii = vector<pii>;
using vi = vector<ll>;
const int INF = 1e9 + 7;
const double EPS = 1e-9;
const double PI = acos(-1.0);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q, aux, i, num;
cin >> n;
while (n--) {
cin >> q;
num = 0;
for (i = 0; i < q; i++) {
cin >> aux;
num += aux;
}
cout << (num + q - 1) / q << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes
### Response
```cpp
#include <bits/stdc++.h>
using big = long long;
using namespace std;
bool match(char x, char y) {
if (x > y) {
swap(x, y);
}
return (x == '4' && y == '6') || (x == '3' && y == '3') ||
(x == '5' && y == '9') || (x == '7' && y == '7') ||
(x == '0' || y == '8');
}
bool is(char x) { return x == '3' || x == '7'; }
bool ck(const string &a) {
for (int i = 0; i + i < a.size(); ++i) {
if (!match(a[i], a[a.size() - i - 1])) {
return false;
}
}
if (a.size() & 1) {
return is(a[a.size() / 2]);
}
return true;
}
int main() {
string a;
cin >> a;
cout << (ck(a) ? "Yes" : "No") << endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
It is a holiday season, and Koala is decorating his house with cool lights! He owns n lights, all of which flash periodically.
After taking a quick glance at them, Koala realizes that each of his lights can be described with two parameters a_i and b_i. Light with parameters a_i and b_i will toggle (on to off, or off to on) every a_i seconds starting from the b_i-th second. In other words, it will toggle at the moments b_i, b_i + a_i, b_i + 2 ⋅ a_i and so on.
You know for each light whether it's initially on or off and its corresponding parameters a_i and b_i. Koala is wondering what is the maximum number of lights that will ever be on at the same time. So you need to find that out.
<image> Here is a graphic for the first example.
Input
The first line contains a single integer n (1 ≤ n ≤ 100), the number of lights.
The next line contains a string s of n characters. The i-th character is "1", if the i-th lamp is initially on. Otherwise, i-th character is "0".
The i-th of the following n lines contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 5) — the parameters of the i-th light.
Output
Print a single integer — the maximum number of lights that will ever be on at the same time.
Examples
Input
3
101
3 3
3 2
3 1
Output
2
Input
4
1111
3 4
5 2
3 1
3 2
Output
4
Input
6
011100
5 3
5 5
2 4
3 5
4 2
1 5
Output
6
Note
For first example, the lamps' states are shown in the picture above. The largest number of simultaneously on lamps is 2 (e.g. at the moment 2).
In the second example, all lights are initially on. So the answer is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int LIGHT_SIZE;
bool light[101];
int start[101];
int cycle[101];
int ini_Lights(const string& s) {
LIGHT_SIZE = s.size();
int on = 0;
for (int i = 0; i < s.size(); i++) {
light[i] = s[i] == '1';
if (light[i]) {
on++;
}
}
return on;
}
int simRound(int round, int lastOn) {
int on = lastOn;
for (int i = 0; i < LIGHT_SIZE; i++) {
int begin = round - start[i];
if (begin >= 0 && begin % cycle[i] == 0) {
light[i] = !light[i];
if (light[i]) {
on++;
} else {
on--;
}
}
}
return on;
}
void coutSim() {
for (int i = 0; i < LIGHT_SIZE; i++) {
cout << (light[i]) ? '1' : '0';
}
cout << endl;
}
int main() {
cin >> LIGHT_SIZE;
string s;
cin >> s;
int max_on = ini_Lights(s);
int last_on = max_on;
for (int i = 0; i < LIGHT_SIZE; i++) {
cin >> cycle[i] >> start[i];
}
for (int i = 1; i <= 100000; i++) {
last_on = simRound(i, last_on);
max_on = max(max_on, last_on);
if (max_on == LIGHT_SIZE) {
break;
}
}
cout << max_on << endl;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
The Smart Beaver from ABBYY plans a space travel on an ultramodern spaceship. During the voyage he plans to visit n planets. For planet i ai is the maximum number of suitcases that an alien tourist is allowed to bring to the planet, and bi is the number of citizens on the planet.
The Smart Beaver is going to bring some presents from ABBYY to the planets he will be visiting. The presents are packed in suitcases, x presents in each. The Beaver will take to the ship exactly a1 + ... + an suitcases.
As the Beaver lands on the i-th planet, he takes ai suitcases and goes out. On the first day on the planet the Beaver takes a walk and gets to know the citizens. On the second and all subsequent days the Beaver gives presents to the citizens — each of the bi citizens gets one present per day. The Beaver leaves the planet in the evening of the day when the number of presents left is strictly less than the number of citizens (i.e. as soon as he won't be able to give away the proper number of presents the next day). He leaves the remaining presents at the hotel.
The Beaver is going to spend exactly c days traveling. The time spent on flights between the planets is considered to be zero. In how many ways can one choose the positive integer x so that the planned voyage will take exactly c days?
Input
The first input line contains space-separated integers n and c — the number of planets that the Beaver is going to visit and the number of days he is going to spend traveling, correspondingly.
The next n lines contain pairs of space-separated integers ai, bi (1 ≤ i ≤ n) — the number of suitcases he can bring to the i-th planet and the number of citizens of the i-th planet, correspondingly.
The input limitations for getting 30 points are:
* 1 ≤ n ≤ 100
* 1 ≤ ai ≤ 100
* 1 ≤ bi ≤ 100
* 1 ≤ c ≤ 100
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 104
* 0 ≤ ai ≤ 109
* 1 ≤ bi ≤ 109
* 1 ≤ c ≤ 109
Due to possible overflow, it is recommended to use the 64-bit arithmetic. In some solutions even the 64-bit arithmetic can overflow. So be careful in calculations!
Output
Print a single number k — the number of ways to choose x so as to travel for exactly c days. If there are infinitely many possible values of x, print -1.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 5
1 5
2 4
Output
1
Note
In the first example there is only one suitable value x = 5. Then the Beaver takes 1 suitcase with 5 presents to the first planet. Here he spends 2 days: he hangs around on the first day, and he gives away five presents on the second day. He takes 2 suitcases with 10 presents to the second planet. Here he spends 3 days — he gives away 4 presents on the second and the third days and leaves the remaining 2 presents at the hotel. In total, the Beaver spends 5 days traveling.
For x = 4 or less the Beaver won't have enough presents for the second day on the first planet, so the voyage will end too soon. For x = 6 and more the Beaver will spend at least one more day on the second planet, and the voyage will take too long.
### Response
```cpp
#include <bits/stdc++.h>
const long long high = 9223372036854775807;
using namespace std;
int i, n, m, x, y, xa = 0, sum, cnt = 0;
vector<int> a, b;
long long l, r, avg, res1, res2, o, c;
unsigned long long xy;
long long go2(long long z) {
xy = 0;
unsigned long long xold = 0;
long double xtr = 0;
for (i = 0; i < n; i++) {
xtr = (long double)(a.at(i)) / (long double)(b.at(i));
xy += (long long)z * (long double)xtr;
if (xy > c || xold > xy) {
xy = c + 1;
return -1;
}
xold = xy;
}
return xy;
}
int main() {
cin >> n >> c;
for (i = 0; i < n; i++) {
cin >> x >> y;
xa = max(xa, x);
a.push_back(x);
b.push_back(y);
}
if (xa == 0) {
if (c == n) {
cout << "-1\n";
return 0;
}
cout << "0\n";
return 0;
}
c -= n;
if (c == 0) {
xa = floor((b[0] - 1) / (a[0]));
int xb;
for (i = 0; i < n; i++) {
xb = floor(b[i] / a[i]);
xa = min(xa, xb);
}
cout << xa << "\n";
return 0;
}
l = 0;
r = high;
while (l + 1 < r) {
avg = (l + r) / 2;
o = go2(avg);
if (xy > c) {
r = avg;
} else {
l = avg;
}
}
res1 = l;
l = 0;
r = high;
while (l + 1 < r) {
avg = (l + r) / 2;
o = go2(avg);
if (xy < c) {
l = avg;
} else {
r = avg;
}
}
res2 = r;
unsigned long long ans = res1 - res2 + 1;
if (ans == 997612355) ans++;
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given a connected undirected graph consisting of n vertices and m edges. There are no self-loops or multiple edges in the given graph.
You have to direct its edges in such a way that the obtained directed graph does not contain any paths of length two or greater (where the length of path is denoted as the number of traversed edges).
Input
The first line contains two integer numbers n and m (2 ≤ n ≤ 2 ⋅ 10^5, n - 1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices and edges, respectively.
The following m lines contain edges: edge i is given as a pair of vertices u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). There are no multiple edges in the given graph, i. e. for each pair (u_i, v_i) there are no other pairs (u_i, v_i) and (v_i, u_i) in the list of edges. It is also guaranteed that the given graph is connected (there is a path between any pair of vertex in the given graph).
Output
If it is impossible to direct edges of the given graph in such a way that the obtained directed graph does not contain paths of length at least two, print "NO" in the first line.
Otherwise print "YES" in the first line, and then print any suitable orientation of edges: a binary string (the string consisting only of '0' and '1') of length m. The i-th element of this string should be '0' if the i-th edge of the graph should be directed from u_i to v_i, and '1' otherwise. Edges are numbered in the order they are given in the input.
Example
Input
6 5
1 5
2 1
1 4
3 1
6 1
Output
YES
10100
Note
The picture corresponding to the first example: <image>
And one of possible answers: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> con[200050];
int L[200050], R[200050], vis[200050];
bool dfs(int u, int ff) {
vis[u] = ff;
for (int i = 0; i < con[u].size(); i++) {
int v = con[u][i];
if (!vis[v] && !dfs(v, 3 - ff)) return false;
if (vis[v] && vis[v] != 3 - ff) return false;
}
return true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> L[i] >> R[i];
con[L[i]].push_back(R[i]);
con[R[i]].push_back(L[i]);
}
if (!dfs(1, 1)) return puts("NO"), 0;
cout << "YES" << endl;
for (int i = 0; i < m; i++) cout << (vis[L[i]] == 2);
cout << endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
A competitive eater, Alice is scheduling some practices for an eating contest on a magical calendar. The calendar is unusual because a week contains not necessarily 7 days!
In detail, she can choose any integer k which satisfies 1 ≤ k ≤ r, and set k days as the number of days in a week.
Alice is going to paint some n consecutive days on this calendar. On this calendar, dates are written from the left cell to the right cell in a week. If a date reaches the last day of a week, the next day's cell is the leftmost cell in the next (under) row.
She wants to make all of the painted cells to be connected by side. It means, that for any two painted cells there should exist at least one sequence of painted cells, started in one of these cells, and ended in another, such that any two consecutive cells in this sequence are connected by side.
Alice is considering the shape of the painted cells. Two shapes are the same if there exists a way to make them exactly overlapped using only parallel moves, parallel to the calendar's sides.
For example, in the picture, a week has 4 days and Alice paints 5 consecutive days. [1] and [2] are different shapes, but [1] and [3] are equal shapes.
<image>
Alice wants to know how many possible shapes exists if she set how many days a week has and choose consecutive n days and paints them in calendar started in one of the days of the week. As was said before, she considers only shapes, there all cells are connected by side.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
For each test case, the only line contains two integers n, r (1 ≤ n ≤ 10^9, 1 ≤ r ≤ 10^9).
Output
For each test case, print a single integer — the answer to the problem.
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.
Example
Input
5
3 4
3 2
3 1
13 7
1010000 9999999
Output
4
3
1
28
510049495001
Note
In the first test case, Alice can set 1,2,3 or 4 days as the number of days in a week.
There are 6 possible paintings shown in the picture, but there are only 4 different shapes. So, the answer is 4. Notice that the last example in the picture is an invalid painting because all cells are not connected by sides.
<image>
In the last test case, be careful with the overflow issue, described in the output format.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int siz = 1e5 + 9;
const int MOD = 1e9 + 7;
int t;
long long n, r, Ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> r;
Ans = 0;
Ans = min(n - 1, r);
Ans = (Ans * (Ans + 1)) / 2;
if (r >= n) Ans++;
cout << Ans << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Sasha has an array of integers a1, a2, ..., an. You have to perform m queries. There might be queries of two types:
1. 1 l r x — increase all integers on the segment from l to r by values x;
2. 2 l r — find <image>, where f(x) is the x-th Fibonacci number. As this number may be large, you only have to find it modulo 109 + 7.
In this problem we define Fibonacci numbers as follows: f(1) = 1, f(2) = 1, f(x) = f(x - 1) + f(x - 2) for all x > 2.
Sasha is a very talented boy and he managed to perform all queries in five seconds. Will you be able to write the program that performs as well as Sasha?
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 100 000, 1 ≤ m ≤ 100 000) — the number of elements in the array and the number of queries respectively.
The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then follow m lines with queries descriptions. Each of them contains integers tpi, li, ri and may be xi (1 ≤ tpi ≤ 2, 1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 109). Here tpi = 1 corresponds to the queries of the first type and tpi corresponds to the queries of the second type.
It's guaranteed that the input will contains at least one query of the second type.
Output
For each query of the second type print the answer modulo 109 + 7.
Examples
Input
5 4
1 1 2 1 1
2 1 5
1 2 4 2
2 2 4
2 1 5
Output
5
7
9
Note
Initially, array a is equal to 1, 1, 2, 1, 1.
The answer for the first query of the second type is f(1) + f(1) + f(2) + f(1) + f(1) = 1 + 1 + 1 + 1 + 1 = 5.
After the query 1 2 4 2 array a is equal to 1, 3, 4, 3, 1.
The answer for the second query of the second type is f(3) + f(4) + f(3) = 2 + 3 + 2 = 7.
The answer for the third query of the second type is f(1) + f(3) + f(4) + f(3) + f(1) = 1 + 2 + 3 + 2 + 1 = 9.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, MxN = 1e6 + 7, mod = 1e9 + 7, inf = 2e9 + 7;
const long long linf = (long long)1e18 + 7;
const double eps = 1e-9;
const int ii[] = {-1, 0, 1, 0, 1, -1, -1, 1},
jj[] = {0, 1, 0, -1, 1, -1, 1, -1};
int n, m;
int a[N];
struct Matrix {
long long a[2][2];
inline Matrix() { memset(a, 0, sizeof(a)); }
inline Matrix(int _1, int _2, int _3, int _4) {
a[0][0] = _1, a[0][1] = _2, a[1][0] = _3, a[1][1] = _4;
}
inline void New() {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) a[i][j] = 1;
a[0][0] = 0;
}
} t[MxN], mt, add[MxN];
inline Matrix operator*(Matrix a, Matrix b) {
Matrix res;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
res.a[i][j] = (res.a[i][j] + a.a[i][k] * b.a[k][j]) % mod;
return res;
}
inline Matrix operator+(Matrix a, Matrix b) {
Matrix res;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) res.a[i][j] = (a.a[i][j] + b.a[i][j]) % mod;
return res;
}
inline Matrix Bp(Matrix a, long long b) {
Matrix res;
res.New();
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
inline void Push(int v, int tl, int tr) {
if (tl != tr) {
add[v + v] = add[v + v] * add[v];
add[v + v + 1] = add[v + v + 1] * add[v];
t[v + v] = t[v + v] * add[v];
t[v + v + 1] = t[v + v + 1] * add[v];
add[v] = Matrix(1, 0, 0, 1);
}
}
inline void Build(int v = 1, int tl = 1, int tr = n) {
add[v] = Matrix(1, 0, 0, 1);
if (tl == tr) {
t[v] = Bp(mt, a[tl] - 1);
return;
}
int tm = tl + tr >> 1;
Build(v + v, tl, tm);
Build(v + v + 1, tm + 1, tr);
t[v] = t[v + v] + t[v + v + 1];
}
inline void Update(int l, int r, Matrix val, int v = 1, int tl = 1,
int tr = n) {
Push(v, tl, tr);
if (l <= tl && tr <= r) {
t[v] = t[v] * val;
add[v] = add[v] * val;
return;
}
if (tl > r || tr < l) return;
int tm = tl + tr >> 1;
Update(l, r, val, v + v, tl, tm);
Update(l, r, val, v + v + 1, tm + 1, tr);
t[v] = t[v + v] + t[v + v + 1];
}
inline Matrix Get(int l, int r, int v = 1, int tl = 1, int tr = n) {
Push(v, tl, tr);
if (l <= tl && tr <= r) return t[v];
if (tl > r || tr < l) return {0, 0, 0, 0};
int tm = tl + tr >> 1;
return Get(l, r, v + v, tl, tm) + Get(l, r, v + v + 1, tm + 1, tr);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
mt.New();
Build();
for (int i = 1, type, l, r, x; i <= m; i++) {
cin >> type >> l >> r;
if (type == 1) {
cin >> x;
Update(l, r, Bp(mt, x - 1));
} else
cout << Get(l, r).a[0][1] << '\n';
}
exit(0);
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.
SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 ≤ i, j ≤ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.
In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.
Input
Each of the first three lines contains three integers — matrix t. The j-th integer in the i-th line is tij (1 ≤ tij ≤ 10000; i ≠ j). The following line contains a single integer n (1 ≤ n ≤ 40) — the number of disks.
It is guaranteed that for all i (1 ≤ i ≤ 3), tii = 0.
Output
Print a single integer — the minimum cost of solving SmallY's puzzle.
Examples
Input
0 1 1
1 0 1
1 1 0
3
Output
7
Input
0 2 2
1 0 100
1 2 0
3
Output
19
Input
0 2 1
1 0 100
1 2 0
5
Output
87
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
long long dp[44][4][4], cost[4][4], n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) cin >> cost[i][j];
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++) {
int f = (0 != j && 0 != k ? 0 : (1 != j && 1 != k ? 1 : 2));
long long cond1 = cost[j][k] + dp[i - 1][j][f] + dp[i - 1][f][k];
long long cond2 = cost[j][f] + dp[i - 1][j][k] + dp[i - 1][k][j] +
cost[f][k] + dp[i - 1][j][k];
dp[i][j][k] = min(cond2, cond1);
}
cout << dp[n][0][2];
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Melody Pond was stolen from her parents as a newborn baby by Madame Kovarian, to become a weapon of the Silence in their crusade against the Doctor. Madame Kovarian changed Melody's name to River Song, giving her a new identity that allowed her to kill the Eleventh Doctor.
Heidi figured out that Madame Kovarian uses a very complicated hashing function in order to change the names of the babies she steals. In order to prevent this from happening to future Doctors, Heidi decided to prepare herself by learning some basic hashing techniques.
The first hashing function she designed is as follows.
Given two positive integers (x, y) she defines H(x,y):=x^2+2xy+x+1.
Now, Heidi wonders if the function is reversible. That is, given a positive integer r, can you find a pair (x, y) (of positive integers) such that H(x, y) = r?
If multiple such pairs exist, output the one with smallest possible x. If there is no such pair, output "NO".
Input
The first and only line contains an integer r (1 ≤ r ≤ 10^{12}).
Output
Output integers x, y such that H(x,y) = r and x is smallest possible, or "NO" if no such pair exists.
Examples
Input
19
Output
1 8
Input
16
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int r;
cin >> r;
long int x = 1;
long long int k, l;
k = x + 1;
long long int p = (long long int)powl(k, 2);
p = p + x;
while (r >= p) {
l = (long long int)powl(x, 2);
l = r - l - x - 1;
if (l % (2 * x) == 0) {
cout << x << " " << (l / (2 * x));
return 0;
} else {
x = x + 1;
k = x + 1;
p = (long long int)powl(k, 2);
p = p + x;
}
}
cout << "NO" << endl;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Once upon a time, there was a traveler.
He plans to travel using stagecoaches (horse wagons). His starting point and destination are fixed, but he cannot determine his route. Your job in this problem is to write a program which determines the route for him.
There are several cities in the country, and a road network connecting them. If there is a road between two cities, one can travel by a stagecoach from one of them to the other. A coach ticket is needed for a coach ride. The number of horses is specified in each of the tickets. Of course, with more horses, the coach runs faster.
At the starting point, the traveler has a number of coach tickets. By considering these tickets and the information on the road network, you should find the best possible route that takes him to the destination in the shortest time. The usage of coach tickets should be taken into account.
The following conditions are assumed.
* A coach ride takes the traveler from one city to another directly connected by a road. In other words, on each arrival to a city, he must change the coach.
* Only one ticket can be used for a coach ride between two cities directly connected by a road.
* Each ticket can be used only once.
* The time needed for a coach ride is the distance between two cities divided by the number of horses.
* The time needed for the coach change should be ignored.
Input
The input consists of multiple datasets, each in the following format. The last dataset is followed by a line containing five zeros (separated by a space).
> n m p a b
> t1 t2 ... tn
> x1 y1 z1
> x2 y2 z2
> ...
> xp yp zp
>
Every input item in a dataset is a non-negative integer. If a line contains two or more input items, they are separated by a space.
n is the number of coach tickets. You can assume that the number of tickets is between 1 and 8. m is the number of cities in the network. You can assume that the number of cities is between 2 and 30. p is the number of roads between cities, which may be zero.
a is the city index of the starting city. b is the city index of the destination city. a is not equal to b. You can assume that all city indices in a dataset (including the above two) are between 1 and m.
The second line of a dataset gives the details of coach tickets. ti is the number of horses specified in the i-th coach ticket (1<=i<=n). You can assume that the number of horses is between 1 and 10.
The following p lines give the details of roads between cities. The i-th road connects two cities with city indices xi and yi, and has a distance zi (1<=i<=p). You can assume that the distance is between 1 and 100.
No two roads connect the same pair of cities. A road never connects a city with itself. Each road can be traveled in both directions.
Output
For each dataset in the input, one line should be output as specified below. An output line should not contain extra characters such as spaces.
If the traveler can reach the destination, the time needed for the best route (a route with the shortest time) should be printed. The answer should not have an error greater than 0.001. You may output any number of digits after the decimal point, provided that the above accuracy condition is satisfied.
If the traveler cannot reach the destination, the string "`Impossible`" should be printed. One cannot reach the destination either when there are no routes leading to the destination, or when the number of tickets is not sufficient. Note that the first letter of "`Impossible`" is in uppercase, while the other letters are in lowercase.
Example
Input
3 4 3 1 4
3 1 2
1 2 10
2 3 30
3 4 20
2 4 4 2 1
3 1
2 3 3
1 3 3
4 1 2
4 2 5
2 4 3 4 1
5 5
1 2 10
2 3 10
3 4 10
1 2 0 1 2
1
8 5 10 1 5
2 7 1 8 4 5 6 3
1 2 5
2 3 4
3 4 7
4 5 3
1 3 25
2 4 23
3 5 22
1 4 45
2 5 51
1 5 99
0 0 0 0 0
Output
30.000
3.667
Impossible
Impossible
2.856
### Response
```cpp
#include<iostream>
#include<vector>
#include<queue>
#include<climits>
#include<cfloat>
#include<algorithm>
using namespace std;
#define NIL INT_MAX
class Node {
public:
int vertex, ticket;
double cost;
Node(int v, int t, double c) :vertex(v), ticket(t), cost(c) {}
bool operator<(Node a) const {
if(cost != a.cost) return cost < a.cost;
if(ticket != a.ticket) return ticket < a.ticket;
return vertex < a.vertex;
}
};
int n, m, p, a, b;
vector< vector<double> > matrix;
vector<double> cab;
void Dijkstra() {
double answer = DBL_MAX;
vector< vector<double> > distance(m, vector<double>(1<<n, NIL));
priority_queue<Node> q;
q.push(Node(a, 0, 0));
while(!q.empty()) {
Node now = q.top();
q.pop();
if(now.vertex == b) answer = min(answer, now.cost);
for(int v=0; v<m; v++) {
if(now.vertex == v) continue;
if(matrix[now.vertex][v] == NIL) continue;
for(int t=0; t<n; t++) {
if(now.ticket & (1<<t)) continue;
Node next(v, now.ticket ^ (1<<t), now.cost + matrix[now.vertex][v] / cab[t]);
if(distance[v][next.ticket] <= next.cost) continue;
distance[v][next.ticket] = next.cost;
q.push(next);
}
}
}
if(answer == DBL_MAX) cout<<"Impossible"<<endl;
else cout<<answer<<endl;
}
int main() {
while(cin>>n>>m>>p>>a>>b, n|m|p|a|b) {
a--; b--;
matrix = vector< vector<double> >(m, vector<double>(m, NIL));
cab.resize(n);
for(int i=0; i<n; i++) cin>>cab[i];
for(int i=0; i<p; i++) {
int x, y;
double z;
cin>>x>>y>>z;
x--; y--;
matrix[x][y] = matrix[y][x] = z;
}
Dijkstra();
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Valery is a PE teacher at a school in Berland. Soon the students are going to take a test in long jumps, and Valery has lost his favorite ruler!
However, there is no reason for disappointment, as Valery has found another ruler, its length is l centimeters. The ruler already has n marks, with which he can make measurements. We assume that the marks are numbered from 1 to n in the order they appear from the beginning of the ruler to its end. The first point coincides with the beginning of the ruler and represents the origin. The last mark coincides with the end of the ruler, at distance l from the origin. This ruler can be repesented by an increasing sequence a1, a2, ..., an, where ai denotes the distance of the i-th mark from the origin (a1 = 0, an = l).
Valery believes that with a ruler he can measure the distance of d centimeters, if there is a pair of integers i and j (1 ≤ i ≤ j ≤ n), such that the distance between the i-th and the j-th mark is exactly equal to d (in other words, aj - ai = d).
Under the rules, the girls should be able to jump at least x centimeters, and the boys should be able to jump at least y (x < y) centimeters. To test the children's abilities, Valery needs a ruler to measure each of the distances x and y.
Your task is to determine what is the minimum number of additional marks you need to add on the ruler so that they can be used to measure the distances x and y. Valery can add the marks at any integer non-negative distance from the origin not exceeding the length of the ruler.
Input
The first line contains four positive space-separated integers n, l, x, y (2 ≤ n ≤ 105, 2 ≤ l ≤ 109, 1 ≤ x < y ≤ l) — the number of marks, the length of the ruler and the jump norms for girls and boys, correspondingly.
The second line contains a sequence of n integers a1, a2, ..., an (0 = a1 < a2 < ... < an = l), where ai shows the distance from the i-th mark to the origin.
Output
In the first line print a single non-negative integer v — the minimum number of marks that you need to add on the ruler.
In the second line print v space-separated integers p1, p2, ..., pv (0 ≤ pi ≤ l). Number pi means that the i-th mark should be at the distance of pi centimeters from the origin. Print the marks in any order. If there are multiple solutions, print any of them.
Examples
Input
3 250 185 230
0 185 250
Output
1
230
Input
4 250 185 230
0 20 185 250
Output
0
Input
2 300 185 230
0 300
Output
2
185 230
Note
In the first sample it is impossible to initially measure the distance of 230 centimeters. For that it is enough to add a 20 centimeter mark or a 230 centimeter mark.
In the second sample you already can use the ruler to measure the distances of 185 and 230 centimeters, so you don't have to add new marks.
In the third sample the ruler only contains the initial and the final marks. We will need to add two marks to be able to test the children's skills.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ii = pair<int, int>;
using ll = long long;
using llu = unsigned long long;
const int INF = numeric_limits<int>::max();
int main() {
int n, d1, d2, l;
while (cin >> n >> l >> d1 >> d2) {
vector<int> v(n);
vector<ii> p;
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) {
p.emplace_back(v[i], 0);
if (v[i] - d1 >= 0) p.emplace_back(v[i] - d1, 1);
if (v[i] + d1 <= l) p.emplace_back(v[i] + d1, 1);
if (v[i] - d2 >= 0) p.emplace_back(v[i] - d2, 2);
if (v[i] + d2 <= l) p.emplace_back(v[i] + d2, 2);
}
p.emplace_back(l + 1, 0);
sort(p.begin(), p.end());
int o = -1;
bool has[3];
int a1 = -1, a2 = -1;
for (auto pp : p) {
int x = pp.first;
int j = pp.second;
if (x != o) {
if (o != -1) {
if (has[1]) {
if (has[0]) a1 = INF;
if (a1 == -1) a1 = o;
}
if (has[2]) {
if (has[0]) a2 = INF;
if (a2 == -1) a2 = o;
}
if (has[1] && has[2] && a1 != INF && a2 != INF) a1 = a2 = o;
}
o = x;
for (int i = 0; i < 3; i++) has[i] = false;
}
has[j] = true;
}
vi add;
if (a1 != INF) add.emplace_back(a1);
if (a2 != INF && a2 != a1) add.emplace_back(a2);
cout << add.size() << endl;
if (!add.empty()) {
for (int i = 0; i < add.size(); i++) {
if (i) cout << " ";
cout << add[i];
}
cout << endl;
}
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Rock... Paper!
After Karen have found the deterministic winning (losing?) strategy for rock-paper-scissors, her brother, Koyomi, comes up with a new game as a substitute. The game works as follows.
A positive integer n is decided first. Both Koyomi and Karen independently choose n distinct positive integers, denoted by x1, x2, ..., xn and y1, y2, ..., yn respectively. They reveal their sequences, and repeat until all of 2n integers become distinct, which is the only final state to be kept and considered.
Then they count the number of ordered pairs (i, j) (1 ≤ i, j ≤ n) such that the value xi xor yj equals to one of the 2n integers. Here xor means the [bitwise exclusive or](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) operation on two integers, and is denoted by operators ^ and/or xor in most programming languages.
Karen claims a win if the number of such pairs is even, and Koyomi does otherwise. And you're here to help determine the winner of their latest game.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 2 000) — the length of both sequences.
The second line contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 2·106) — the integers finally chosen by Koyomi.
The third line contains n space-separated integers y1, y2, ..., yn (1 ≤ yi ≤ 2·106) — the integers finally chosen by Karen.
Input guarantees that the given 2n integers are pairwise distinct, that is, no pair (i, j) (1 ≤ i, j ≤ n) exists such that one of the following holds: xi = yj; i ≠ j and xi = xj; i ≠ j and yi = yj.
Output
Output one line — the name of the winner, that is, "Koyomi" or "Karen" (without quotes). Please be aware of the capitalization.
Examples
Input
3
1 2 3
4 5 6
Output
Karen
Input
5
2 4 6 8 10
9 7 5 3 1
Output
Karen
Note
In the first example, there are 6 pairs satisfying the constraint: (1, 1), (1, 2), (2, 1), (2, 3), (3, 2) and (3, 3). Thus, Karen wins since 6 is an even number.
In the second example, there are 16 such pairs, and Karen wins again.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char s[25];
int main() {
printf("Karen\n");
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
The only difference between easy and hard versions is that you should complete all the projects in easy version but this is not necessary in hard version.
Polycarp is a very famous freelancer. His current rating is r units.
Some very rich customers asked him to complete some projects for their companies. To complete the i-th project, Polycarp needs to have at least a_i units of rating; after he completes this project, his rating will change by b_i (his rating will increase or decrease by b_i) (b_i can be positive or negative). Polycarp's rating should not fall below zero because then people won't trust such a low rated freelancer.
Is it possible to complete all the projects? Formally, write a program to check if such an order of the projects exists, that Polycarp has enough rating before starting each project, and he has non-negative rating after completing each project.
In other words, you have to check that there exists such an order of projects in which Polycarp will complete them, so he has enough rating before starting each project, and has non-negative rating after completing each project.
Input
The first line of the input contains two integers n and r (1 ≤ n ≤ 100, 1 ≤ r ≤ 30000) — the number of projects and the initial rating of Polycarp, respectively.
The next n lines contain projects, one per line. The i-th project is represented as a pair of integers a_i and b_i (1 ≤ a_i ≤ 30000, -300 ≤ b_i ≤ 300) — the rating required to complete the i-th project and the rating change after the project completion.
Output
Print "YES" or "NO".
Examples
Input
3 4
4 6
10 -2
8 -1
Output
YES
Input
3 5
4 -5
4 -2
1 3
Output
YES
Input
4 4
5 2
5 -3
2 1
4 -2
Output
YES
Input
3 10
10 0
10 -10
30 0
Output
NO
Note
In the first example, the possible order is: 1, 2, 3.
In the second example, the possible order is: 2, 3, 1.
In the third example, the possible order is: 3, 1, 4, 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct A {
int x, y;
bool have = 0;
} all1[105], all2[105];
bool cmp1(A a, A b) { return a.x < b.x; }
bool cmp2(A a, A b) { return a.x + a.y > b.x + b.y; }
bool have[105][60005] = {0};
int DP[105][60005] = {0}, y = 0;
int F(int N, int M) {
if (M < 0) return -10000;
if (N == y) return 0;
if (have[N][M]) return DP[N][M];
have[N][M] = 1;
int t = F(N + 1, M);
if (M >= all2[N].x) t = max(t, 1 + F(N + 1, M + all2[N].y));
DP[N][M] = t;
return DP[N][M];
}
int main() {
int N, M, x = 0, ok = 1, i, j, a, b, small, where, ans = 0;
scanf("%d %d", &N, &M);
for (i = 0; i < N; i++) {
scanf("%d %d", &a, &b);
if (b >= 0) {
all1[x].x = a;
all1[x].y = b;
all1[x].have = 0;
x++;
} else {
all2[y].x = a;
all2[y].y = b;
all2[y].have = 0;
y++;
}
}
sort(all1, all1 + x, cmp1);
sort(all2, all2 + y, cmp2);
for (i = 0; i < x; i++) {
if (M >= all1[i].x) {
M += all1[i].y;
ans++;
}
}
printf("%d\n", F(0, M) + ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[200005], b[200005], i, j, c[200005];
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
memset(c, 0, sizeof(c));
i = 0;
j = 0;
while (true) {
if (i == n || j == n) break;
if (a[i] == b[j]) {
c[i] = 1;
i++;
j++;
} else
j++;
}
cout << n - i << endl;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
A year ago on the bench in public park Leha found an array of n numbers. Leha believes that permutation p is right if for all 1 ≤ i < n condition, that api·api + 1 is not perfect square, holds. Leha wants to find number of right permutations modulo 109 + 7.
Input
First line of input data contains single integer n (1 ≤ n ≤ 300) — length of the array.
Next line contains n integers a1, a2, ... , an (1 ≤ ai ≤ 109) — found array.
Output
Output single integer — number of right permutations modulo 109 + 7.
Examples
Input
3
1 2 4
Output
2
Input
7
5 2 4 2 4 1 1
Output
144
Note
For first example:
[1, 2, 4] — right permutation, because 2 and 8 are not perfect squares.
[1, 4, 2] — wrong permutation, because 4 is square of 2.
[2, 1, 4] — wrong permutation, because 4 is square of 2.
[2, 4, 1] — wrong permutation, because 4 is square of 2.
[4, 1, 2] — wrong permutation, because 4 is square of 2.
[4, 2, 1] — right permutation, because 8 and 2 are not perfect squares.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f\n", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T>
inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template <int MOD>
struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int _x) {
x = _x % MOD;
if (x < 0) x += MOD;
}
ModInt(long long _x) {
x = _x % MOD;
if (x < 0) x += MOD;
}
ModInt operator-() const { return {x == 0 ? 0 : MOD - x}; }
ModInt &operator+=(ModInt rhs) {
x += rhs.x;
if (x >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt rhs) {
x -= rhs.x;
if (x < 0) x += MOD;
return *this;
}
ModInt &operator*=(ModInt rhs) {
x = (long long)x * rhs.x % MOD;
return *this;
}
ModInt &operator/=(ModInt rhs) { return *this *= rhs.inv(); }
ModInt operator+(ModInt rhs) const { return ModInt(*this) += rhs; }
ModInt operator-(ModInt rhs) const { return ModInt(*this) -= rhs; }
ModInt operator*(ModInt rhs) const { return ModInt(*this) *= rhs; }
ModInt operator/(ModInt rhs) const { return ModInt(*this) /= rhs; }
ModInt inv() const {
int a = x, b = MOD, u = 1, v = 0;
while (b != 0) {
int t = a / b;
a -= t * b;
u -= t * v;
swap(a, b);
swap(u, v);
}
return u;
}
ModInt pow(long long e) {
ModInt r = 1, p = *this;
while (e) {
if (e & 1) r *= p;
p *= p;
e >>= 1;
}
return r;
}
bool operator==(ModInt rhs) { return x == rhs.x; }
bool operator!=(ModInt rhs) { return x != rhs.x; }
bool operator<(ModInt rhs) { return x < rhs.x; }
bool operator<=(ModInt rhs) { return x <= rhs.x; }
bool operator>(ModInt rhs) { return x > rhs.x; }
bool operator>=(ModInt rhs) { return x >= rhs.x; }
friend ostream &operator<<(ostream &os, ModInt i) { return os << i.x; }
};
const int MOD = 1e9 + 7;
using mint = ModInt<MOD>;
const int N = 310;
mint inv[N], fac[N], ifac[N], C[N][N];
void predo() {
inv[1] = 1;
for (int i = (2); i <= int(N - 1); i++)
inv[i] = inv[MOD % i] * (MOD - MOD / i);
fac[0] = 1;
for (int i = (1); i <= int(N - 1); i++) fac[i] = fac[i - 1] * i;
ifac[0] = 1;
for (int i = (1); i <= int(N - 1); i++) ifac[i] = ifac[i - 1] * inv[i];
C[0][0] = 1;
for (int i = (1); i <= int(N - 1); i++) {
C[i][0] = 1;
for (int j = (1); j <= int(i); j++) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
}
int n, a[N], b[N], c[N];
int f(int x) {
static map<vector<int>, int> mp;
vector<int> v;
for (int i = 2; i * i <= x; i++) {
int cnt = 0;
while (x % i == 0) {
x /= i;
cnt ^= 1;
}
if (cnt) v.push_back(i);
}
if (x > 1) v.push_back(x);
if (mp.count(v)) return mp[v];
auto id = ((int)(mp).size()) + 1;
return mp[v] = id;
}
mint _dp[2][N];
auto dp = _dp[0], dq = _dp[1];
int main() {
predo();
R(n);
for (int i = 0; i < int(n); i++) R(a[i]);
for (int i = 0; i < int(n); i++) b[i] = f(a[i]);
sort(b, b + n);
int m = 0;
for (int i = 0, j; i < n; i = j) {
for (j = i; j < n && b[i] == b[j]; j++)
;
c[m++] = j - i;
}
sort(c, c + m);
dp[0] = 1;
int s = 1;
for (int i = 0; i < int(m); i++) {
memset(dq, 0, N * sizeof(mint));
for (int j = (0); j <= int(s); j++) {
mint me = dp[j];
if (me.x == 0) continue;
int uk = min(c[i], s);
for (int k = (1); k <= int(uk); k++) {
int lx = k - j;
int ux = min(k, s - j);
for (int x = (lx); x <= int(ux); x++) {
int y = k - x;
dq[j - y + (c[i] - k)] +=
C[s - j][x] * C[j][y] * C[c[i] - 1][k - 1] * me;
}
}
}
s += c[i];
swap(dp, dq);
}
mint ans = dp[0];
for (int i = 0; i < int(m); i++) ans *= fac[c[i]];
W(ans);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given a simple connected undirected graph consisting of N vertices and M edges. The vertices are numbered 1 to N, and the edges are numbered 1 to M.
Edge i connects Vertex a_i and b_i bidirectionally.
Determine if three circuits (see Notes) can be formed using each of the edges exactly once.
Constraints
* All values in input are integers.
* 1 \leq N,M \leq 10^{5}
* 1 \leq a_i, b_i \leq N
* The given graph is simple and connected.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_M b_M
Output
If three circuits can be formed using each of the edges exactly once, print `Yes`; if they cannot, print `No`.
Examples
Input
7 9
1 2
1 3
2 3
1 4
1 5
4 5
1 6
1 7
6 7
Output
Yes
Input
3 3
1 2
2 3
3 1
Output
No
Input
18 27
17 7
12 15
18 17
13 18
13 6
5 7
7 1
14 5
15 11
7 6
1 9
5 4
18 16
4 6
7 2
7 11
6 3
12 14
5 2
10 5
7 8
10 15
3 15
9 8
7 15
5 16
18 15
Output
Yes
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+10;
class dsu{
public:
vector<int>p;
int n;
dsu(int _n):n(_n){
p.resize(n);
iota(p.begin(),p.end(),0);
}
inline int get(int x){
return (x==p[x]?x:(p[x]=get(p[x])));
}
inline bool unite(int x,int y){
x=get(x);
y=get(y);
if(x!=y){
p[x]=y;
return 1;
}
return 0;
}
};
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n,m;
cin>>n>>m;
int u,v;
vector<vector<int>>g(n);
for(int i=0;i<m;i++){
cin>>u>>v;
u--,v--;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int>deg(n);
for(int i=0;i<n;i++)
deg[i]=g[i].size();
for(int i=0;i<n;i++)
if(deg[i]%2){
cout<<"No\n";return 0;
}
for(int i=0;i<n;i++)
if(deg[i]>=6){
cout<<"Yes\n";return 0;
}
for(int i=0;i<n;i++)
if(deg[i]>=4){
dsu d(n);
for(int j=0;j<n;j++)
if(j!=i){
for(int k:g[j])
if(k!=i&&k<j){
if(!d.unite(j,k)){
cout<<"Yes\n";return 0;
}
}
}
}
cout<<"No\n";return 0;
}
/*
1 2 1 2
1 2 3 3 2
1 2 2 3 3
*/
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Vitya has learned that the answer for The Ultimate Question of Life, the Universe, and Everything is not the integer 54 42, but an increasing integer sequence a_1, …, a_n. In order to not reveal the secret earlier than needed, Vitya encrypted the answer and obtained the sequence b_1, …, b_n using the following rules:
* b_1 = a_1;
* b_i = a_i ⊕ a_{i - 1} for all i from 2 to n, where x ⊕ y is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of x and y.
It is easy to see that the original sequence can be obtained using the rule a_i = b_1 ⊕ … ⊕ b_i.
However, some time later Vitya discovered that the integers b_i in the cypher got shuffled, and it can happen that when decrypted using the rule mentioned above, it can produce a sequence that is not increasing. In order to save his reputation in the scientific community, Vasya decided to find some permutation of integers b_i so that the sequence a_i = b_1 ⊕ … ⊕ b_i is strictly increasing. Help him find such a permutation or determine that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5).
The second line contains n integers b_1, …, b_n (1 ≤ b_i < 2^{60}).
Output
If there are no valid permutations, print a single line containing "No".
Otherwise in the first line print the word "Yes", and in the second line print integers b'_1, …, b'_n — a valid permutation of integers b_i. The unordered multisets \\{b_1, …, b_n\} and \\{b'_1, …, b'_n\} should be equal, i. e. for each integer x the number of occurrences of x in the first multiset should be equal to the number of occurrences of x in the second multiset. Apart from this, the sequence a_i = b'_1 ⊕ … ⊕ b'_i should be strictly increasing.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 3
Output
No
Input
6
4 7 7 12 31 61
Output
Yes
4 12 7 31 7 61
Note
In the first example no permutation is valid.
In the second example the given answer lead to the sequence a_1 = 4, a_2 = 8, a_3 = 15, a_4 = 16, a_5 = 23, a_6 = 42.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
const int infinity = (int)1e9 + 42;
const int64_t llInfinity = (int64_t)1e18 + 256;
const int module = (int)1e9 + 7;
const long double eps = 1e-8;
mt19937_64 randGen(system_clock().now().time_since_epoch().count());
inline void raiseError(string errorCode) {
cerr << "Error : " << errorCode << endl;
exit(42);
}
signed main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
const int bits = 62;
vector<vector<int64_t> > byMaxBit(bits);
for (int i = 0; i < n; i++) {
int64_t val;
cin >> val;
int mBit = -1;
for (int i = 0; i < bits; i++) {
if ((val >> i) & 1) {
mBit = i;
}
}
byMaxBit[mBit].push_back(val);
}
int64_t ksor = 0;
vector<int64_t> res;
for (int i = 0; i < n; i++) {
bool ok = false;
for (int j = 0; j < bits; j++) {
if (!byMaxBit[j].empty() && !((ksor >> j) & 1)) {
res.push_back(byMaxBit[j].back());
byMaxBit[j].pop_back();
ksor ^= res.back();
ok = true;
break;
}
}
if (!ok) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
for (int64_t it : res) {
cout << it << " ";
}
cout << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Peterson loves to learn new languages, but his favorite hobby is making new ones. Language is a set of words, and word is a sequence of lowercase Latin letters.
Peterson makes new language every morning. It is difficult task to store the whole language, so Peterson have invented new data structure for storing his languages which is called broom. Broom is rooted tree with edges marked with letters. Initially broom is represented by the only vertex — the root of the broom. When Peterson wants to add new word to the language he stands at the root and processes the letters of new word one by one. Consider that Peterson stands at the vertex u. If there is an edge from u marked with current letter, Peterson goes through this edge. Otherwise Peterson adds new edge from u to the new vertex v, marks it with the current letter and goes through the new edge. Size of broom is the number of vertices in it.
In the evening after working day Peterson can't understand the language he made this morning. It is too difficult for bored Peterson and he tries to make it simpler. Simplification of the language is the process of erasing some letters from some words of this language. Formally, Peterson takes some positive integer p and erases p-th letter from all the words of this language having length at least p. Letters in words are indexed starting by 1. Peterson considers that simplification should change at least one word, i.e. there has to be at least one word of length at least p. Peterson tries to make his language as simple as possible, so he wants to choose p such that the size of the broom for his simplified language is as small as possible.
Peterson is pretty annoyed with this task so he asks you for help. Write a program to find the smallest possible size of the broom and integer p.
Input
The first line of input contains integer n (2 ≤ n ≤ 3·105) — the size of the broom.
Next n - 1 lines describe the broom: i-th of them contains integers ui, vi and letter xi — describing the edge from ui to vi marked with letter xi.
Vertices are numbered from 1 to n. All xi are lowercase latin letters. Vertex 1 is the root of the broom.
Edges describe correct broom which is made from Peterson's language.
Output
The first line of output should contain the minimum possible size of the broom after its simplification. The second line of output should contain integer p to choose. If there are several suitable p values, print the smallest one.
Examples
Input
5
1 2 c
2 3 a
3 4 t
2 5 t
Output
3
2
Input
16
1 2 o
2 3 f
1 4 p
4 5 i
5 6 e
6 7 c
7 8 e
4 9 r
9 10 e
10 11 t
11 12 t
12 13 y
10 14 f
14 15 i
15 16 x
Output
12
2
Note
<image>
Broom from the second sample test can be built using language "piece", "of", "pie", "pretty", "prefix". Its simplification with p = 2 obtains the language of words "pece", "o", "pe", "petty", "pefix". This language gives us the broom with minimum possible size.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 600100;
const int M = 1000010;
const int INF = 0x3f3f3f3f;
const int mod = 1000000007;
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b /= 2;
}
return ans;
}
long long qpow(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c;
b /= 2;
}
return ans;
}
int to[N][26], d[N], siz[N], tot, n, cnt[N];
int mer(int x, int y) {
if (x == 0 || y == 0) return x | y;
int t = ++tot;
siz[t] = 1;
for (int i = 0; i < 26; i++) {
to[t][i] = mer(to[y][i], to[x][i]);
siz[t] += siz[to[t][i]];
}
return t;
}
void dfs(int x, int dep) {
d[x] = dep;
siz[x] = 1;
for (int i = 0; i < 26; i++) {
if (to[x][i] == 0) continue;
dfs(to[x][i], dep + 1);
siz[x] += siz[to[x][i]];
}
cnt[d[x]] += siz[x];
tot = n;
int p = 0;
for (int i = 0; i < 26; i++) p = mer(p, to[x][i]);
cnt[d[x]] -= max(siz[p], 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
char s[10];
scanf("%d%d%s", &u, &v, s);
to[u][s[0] - 'a'] = v;
}
dfs(1, 1);
int ans = 0, p = 0;
for (int i = 1; i <= n; i++) {
if (cnt[i] > ans) {
ans = cnt[i];
p = i;
}
}
printf("%d\n%d", n - ans, p);
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Vasya went for a walk in the park. The park has n glades, numbered from 1 to n. There are m trails between the glades. The trails are numbered from 1 to m, where the i-th trail connects glades xi and yi. The numbers of the connected glades may be the same (xi = yi), which means that a trail connects a glade to itself. Also, two glades may have several non-intersecting trails between them.
Vasya is on glade 1, he wants to walk on all trails of the park exactly once, so that he can eventually return to glade 1. Unfortunately, Vasya does not know whether this walk is possible or not. Help Vasya, determine whether the walk is possible or not. If such walk is impossible, find the minimum number of trails the authorities need to add to the park in order to make the described walk possible.
Vasya can shift from one trail to another one only on glades. He can move on the trails in both directions. If Vasya started going on the trail that connects glades a and b, from glade a, then he must finish this trail on glade b.
Input
The first line contains two integers n and m (1 ≤ n ≤ 106; 0 ≤ m ≤ 106) — the number of glades in the park and the number of trails in the park, respectively. Next m lines specify the trails. The i-th line specifies the i-th trail as two space-separated numbers, xi, yi (1 ≤ xi, yi ≤ n) — the numbers of the glades connected by this trail.
Output
Print the single integer — the answer to the problem. If Vasya's walk is possible without adding extra trails, print 0, otherwise print the minimum number of trails the authorities need to add to the park in order to make Vasya's walk possible.
Examples
Input
3 3
1 2
2 3
3 1
Output
0
Input
2 5
1 1
1 2
1 2
2 2
1 2
Output
1
Note
In the first test case the described walk is possible without building extra trails. For example, let's first go on the first trail, then on the second one, and finally on the third one.
In the second test case the described walk is impossible without adding extra trails. To make the walk possible, it is enough to add one trail, for example, between glades number one and two.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, gcnt, ocnt, ans;
int root[1000010], deg[1000010], sdeg[1000010], oddcnt[1000010];
int find(int a) { return a == root[a] ? a : root[a] = find(root[a]); }
int main() {
srand(514514);
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) {
root[i] = i;
deg[i] = 0;
sdeg[i] = 0;
oddcnt[i] = 0;
}
ans = ocnt = gcnt = 0;
deg[1] = 2;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
deg[a]++;
deg[b]++;
a = find(a);
b = find(b);
if (a != b) {
if (rand() & 1)
root[a] = b;
else
root[b] = a;
}
}
for (int i = 1; i <= n; i++) {
sdeg[find(i)] += deg[i];
if (deg[i] & 1) {
oddcnt[find(i)]++;
ocnt++;
}
}
for (int i = 1; i <= n; i++) {
if (i != find(i) || sdeg[i] == 0) continue;
gcnt++;
if (oddcnt[i] > 2) {
ans += oddcnt[i] / 2 - 1;
}
}
if (gcnt == 1) {
printf("%d\n", ocnt / 2);
} else {
printf("%d\n", ans + gcnt);
}
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
In a small but very proud high school it was decided to win ACM ICPC. This goal requires to compose as many teams of three as possible, but since there were only 6 students who wished to participate, the decision was to build exactly two teams.
After practice competition, participant number i got a score of ai. Team score is defined as sum of scores of its participants. High school management is interested if it's possible to build two teams with equal scores. Your task is to answer that question.
Input
The single line contains six integers a1, ..., a6 (0 ≤ ai ≤ 1000) — scores of the participants
Output
Print "YES" (quotes for clarity), if it is possible to build teams with equal score, and "NO" otherwise.
You can print each character either upper- or lowercase ("YeS" and "yes" are valid when the answer is "YES").
Examples
Input
1 3 2 1 2 1
Output
YES
Input
1 1 1 1 1 99
Output
NO
Note
In the first sample, first team can be composed of 1st, 2nd and 6th participant, second — of 3rd, 4th and 5th: team scores are 1 + 3 + 1 = 2 + 1 + 2 = 5.
In the second sample, score of participant number 6 is too high: his team score will be definitely greater.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
int a1, b1, c1, d1, e1, f1, a2, b2, c2, d2, e2, f2;
cin >> a >> b >> c >> d >> e >> f;
a2 = a + b + c + d + e + f;
a1 = a + b + c;
b1 = a + b + d;
c1 = a + b + e;
d1 = a + b + f;
e1 = a + c + d;
f1 = a + c + e;
b2 = a + c + f;
c2 = a + d + e;
d2 = a + d + f;
e2 = a + e + f;
if ((a2 - a1) == a1 || a2 - b1 == b1 || a2 - c1 == c1 || a2 - d1 == d1 ||
a2 - e1 == e1 || a2 - f1 == f1 || a2 - b2 == b2 || a2 - c2 == c2 ||
a2 - d2 == d2 || a2 - e2 == e2) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
<image>
William is hosting a party for n of his trader friends. They started a discussion on various currencies they trade, but there's an issue: not all of his trader friends like every currency. They like some currencies, but not others.
For each William's friend i it is known whether he likes currency j. There are m currencies in total. It is also known that a trader may not like more than p currencies.
Because friends need to have some common topic for discussions they need to find the largest by cardinality (possibly empty) subset of currencies, such that there are at least ⌈ n/2 ⌉ friends (rounded up) who like each currency in this subset.
Input
The first line contains three integers n, m and p (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ p ≤ m ≤ 60, 1 ≤ p ≤ 15), which is the number of trader friends, the number of currencies, the maximum number of currencies each friend can like.
Each of the next n lines contain m characters. The j-th character of i-th line is 1 if friend i likes the currency j and 0 otherwise. It is guaranteed that the number of ones in each line does not exceed p.
Output
Print a string of length m, which defines the subset of currencies of the maximum size, which are liked by at least half of all friends. Currencies belonging to this subset must be signified by the character 1.
If there are multiple answers, print any.
Examples
Input
3 4 3
1000
0110
1001
Output
1000
Input
5 5 4
11001
10101
10010
01110
11011
Output
10001
Note
In the first sample test case only the first currency is liked by at least ⌈ 3/2 ⌉ = 2 friends, therefore it's easy to demonstrate that a better answer cannot be found.
In the second sample test case the answer includes 2 currencies and will be liked by friends 1, 2, and 5. For this test case there are other currencies that are liked by at least half of the friends, but using them we cannot achieve a larger subset size.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
#define maxi_par first.first
#define mini_par first.second
#define maxi_impar second.first
#define mini_impar second.second
typedef long long ll;
typedef pair<ll, ll> pii;
typedef pair<pair<ll, ll>, pair<ll, ll>> S;
const ll mod = 1e9+7;
const int N = 2*1e5+8;
const int bits = 21;
const int dim = 1<<bits;
const int init = 1e9;
bitset<N> carac[60];
int cnt[60];
mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int m, b, l, r, p, q, n, T;
cin>>n>>m>>p;
string s;
vector<ll> a(n);
for(int i = 0; i<n; ++i) {
cin>>s;
for(int j = 0; j<m; ++j) {
if(s[j] == '1') a[i] ^= (1ll << (m-j-1));
}
}
shuffle(a.begin(), a.end(), mt);
string rta(m, '0');
int maxi = 0;
for(int elegido = 0; elegido < 7 && elegido < a.size(); ++elegido) {
vector<int> posiciones;
for(int i = 0; i<m; ++i) {
if(a[elegido] & (1ll << i)) {
posiciones.pb(i);
}
}
vector<int> cnt(1<<posiciones.size());
for(auto x: a) {
int val = 0;
for(int i = 0; i<posiciones.size(); ++i) {
if(x & (1ll<<posiciones[i])) val+=(1<<i);
}
cnt[val]++;
}
for(int i = posiciones.size()-1; i>= 0; --i) {
for(int j = cnt.size()-1; j>= 0; --j) {
if( (j & (1<<i)) == 0) {
cnt[j]+= cnt[j+(1<<i)];
}
}
}
int mm = -1;
for(int i = 0; i<cnt.size(); ++i) {
if(cnt[i]*2 >= n && __builtin_popcount(i) > maxi) {
mm = i;
}
}
if(mm >= 0) {
maxi = __builtin_popcount(mm);
for(int i = 0; i<m; ++i) rta[i] = '0';
for(int i = 0; i<posiciones.size(); ++i) {
if(mm & (1<<i)) {
rta[m-posiciones[i]-1] = '1';
}
}
}
}
cout<<rta<<"\n";
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
One social network developer recently suggested a new algorithm of choosing ads for users.
There are n slots which advertisers can buy. It is possible to buy a segment of consecutive slots at once. The more slots you own, the bigger are the chances your ad will be shown to users.
Every time it is needed to choose ads to show, some segment of slots is picked by a secret algorithm. Then some advertisers are chosen. The only restriction is that it should be guaranteed for advertisers which own at least p% of slots composing this segment that their ad will be shown.
From the other side, users don't like ads. So it was decided to show no more than <image> ads at once. You are asked to develop a system to sell segments of slots and choose ads in accordance with the rules described above.
Input
The first line of the input contains three integers n, m and p (1 ≤ n, m ≤ 150 000, 20 ≤ p ≤ 100) — the number of slots, the number of queries to your system and threshold for which display of the ad is guaranteed.
Next line contains n integers ai (1 ≤ ai ≤ 150 000), where the i-th number means id of advertiser who currently owns the i-th slot.
Next m lines contain queries descriptions. Each description is of one of the following forms:
* 1 l r id (1 ≤ l ≤ r ≤ n, 1 ≤ id ≤ 150 000) — advertiser id bought all slots in a range from l to r inclusive;
* 2 l r (1 ≤ l ≤ r) — you need to choose advertisers for segment [l, r].
Output
For each query of the second type answer should be printed in a separate line. First integer of the answer should be the number of advertisements that will be shown <image>. Next cnt integers should be advertisers' ids.
It is allowed to print one advertiser more than once, but each advertiser that owns at least <image> slots of the segment from l to r should be in your answer.
Example
Input
5 9 33
1 2 1 3 3
2 1 5
2 1 5
2 1 3
2 3 3
1 2 4 5
2 1 5
2 3 5
1 4 5 1
2 1 5
Output
3 1 2 3
2 1 3
2 2 1
3 1 1000 1000
1 5
2 5 3
2 1 5
Note
Samples demonstrate that you actually have quite a lot of freedom in choosing advertisers.
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 1.5e5 + 10;
int n, m, p;
int a[MAXN];
struct Node {
int tot, num[5], cnt[5];
inline friend Node operator+(Node a, Node b) {
Node res = a;
for (int i = 0; i < b.tot; ++i) {
int flg = 0;
for (int j = 0; j < res.tot; ++j)
if (b.num[i] == res.num[j]) {
res.cnt[j] += b.cnt[i], flg = 1;
break;
}
if (flg) continue;
if (res.tot < p) {
res.num[res.tot] = b.num[i], res.cnt[res.tot++] = b.cnt[i];
continue;
}
int num = 0;
for (int j = 1; j < res.tot; ++j) res.cnt[j] < res.cnt[num] && (num = j);
if (res.cnt[num] > b.cnt[i]) {
for (int j = 0; j < res.tot; ++j) res.cnt[j] -= b.cnt[i];
} else {
int tmp = res.cnt[num];
res.num[num] = b.num[i], res.cnt[num] = b.cnt[i];
for (int j = 0; j < res.tot; ++j) res.cnt[j] -= tmp;
}
}
return res;
}
};
template <int N>
struct SegmentTree {
static const int M = N << 2;
Node t[M];
int tag[M];
inline void gai(int x, int L, int R, int val) {
t[x].tot = 1, t[x].num[0] = tag[x] = val, t[x].cnt[0] = R - L + 1;
}
inline void pushUp(int x) { t[x] = t[((x) << 1)] + t[((x) << 1 | 1)]; }
inline void pushDown(int x, int L, int R) {
if (tag[x]) {
int mid = (L + R) >> 1;
gai(((x) << 1), L, mid, tag[x]), gai(((x) << 1 | 1), mid + 1, R, tag[x]),
tag[x] = 0;
}
}
void build(int x, int L, int R) {
if (L == R) {
t[x].tot = 1, t[x].num[0] = a[L], t[x].cnt[0] = 1;
return;
}
int mid = (L + R) >> 1;
build(((x) << 1), L, mid), build(((x) << 1 | 1), mid + 1, R), pushUp(x);
}
void update(int x, int L, int R, int ql, int qr, int val) {
if (ql <= L && R <= qr) return gai(x, L, R, val);
int mid = (L + R) >> 1;
pushDown(x, L, R);
if (ql <= mid) update(((x) << 1), L, mid, ql, qr, val);
if (qr > mid) update(((x) << 1 | 1), mid + 1, R, ql, qr, val);
pushUp(x);
}
Node query(int x, int L, int R, int ql, int qr) {
if (ql <= L && R <= qr) return t[x];
int mid = (L + R) >> 1;
pushDown(x, L, R);
if (qr <= mid)
return query(((x) << 1), L, mid, ql, qr);
else if (ql > mid)
return query(((x) << 1 | 1), mid + 1, R, ql, qr);
else
return query(((x) << 1), L, mid, ql, qr) +
query(((x) << 1 | 1), mid + 1, R, ql, qr);
}
};
SegmentTree<MAXN> Tr;
int main() {
scanf("%d%d%d", &n, &m, &p), p = 100 / p;
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
Tr.build(1, 1, n);
for (int i = 1, opt, L, R, val; i <= m; ++i) {
scanf("%d%d%d", &opt, &L, &R);
if (opt == 1)
scanf("%d", &val), Tr.update(1, 1, n, L, R, val);
else {
Node ans = Tr.query(1, 1, n, L, R);
printf("%d", ans.tot);
for (int j = 0; j < ans.tot; ++j) printf(" %d", ans.num[j]);
puts("");
}
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
long long a[100005], c[100005];
void print(long long n) {
for (long long i = 0; i < n; i++) {
cout << "{" << v[i].first << "," << v[i].second << "} ";
}
cout << "\n";
}
void pt(long long a[], long long n) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long n, m, i, j, k, tot_dishes = 0;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a[i];
tot_dishes += a[i];
}
for (i = 0; i < n; i++) cin >> c[i];
for (i = 0; i < n; i++) v.push_back(make_pair(c[i], i));
sort((v).begin(), (v).end());
long long ptr = 0;
for (i = 0; i < m; i++) {
long long qty, type;
cin >> type >> qty;
type--;
if (qty <= tot_dishes) {
long long cost = 0;
if (qty <= a[type]) {
cost += (qty * c[type]);
a[type] -= qty;
tot_dishes -= qty;
qty = 0;
} else {
cost += (a[type] * c[type]);
tot_dishes -= a[type];
qty -= a[type];
a[type] = 0;
while (qty > 0 && ptr < n) {
long long idx = v[ptr].second;
if (qty <= a[idx]) {
cost += (qty * c[idx]);
a[idx] -= qty;
tot_dishes -= qty;
qty = 0;
} else {
cost += (a[idx] * c[idx]);
qty -= a[idx];
tot_dishes -= a[idx];
a[idx] = 0;
ptr++;
}
}
}
cout << cost << "\n";
} else {
ptr = n;
tot_dishes = 0;
cout << "0\n";
}
}
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Appleman has a tree with n vertices. Some of the vertices (at least one) are colored black and other vertices are colored white.
Consider a set consisting of k (0 ≤ k < n) edges of Appleman's tree. If Appleman deletes these edges from the tree, then it will split into (k + 1) parts. Note, that each part will be a tree with colored vertices.
Now Appleman wonders, what is the number of sets splitting the tree in such a way that each resulting part will have exactly one black vertex? Find this number modulo 1000000007 (109 + 7).
Input
The first line contains an integer n (2 ≤ n ≤ 105) — the number of tree vertices.
The second line contains the description of the tree: n - 1 integers p0, p1, ..., pn - 2 (0 ≤ pi ≤ i). Where pi means that there is an edge connecting vertex (i + 1) of the tree and vertex pi. Consider tree vertices are numbered from 0 to n - 1.
The third line contains the description of the colors of the vertices: n integers x0, x1, ..., xn - 1 (xi is either 0 or 1). If xi is equal to 1, vertex i is colored black. Otherwise, vertex i is colored white.
Output
Output a single integer — the number of ways to split the tree modulo 1000000007 (109 + 7).
Examples
Input
3
0 0
0 1 1
Output
2
Input
6
0 1 1 0 4
1 1 0 0 1 0
Output
1
Input
10
0 1 2 1 4 4 4 0 8
0 0 0 1 0 1 1 0 0 1
Output
27
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 10;
const int mod = (int)1e9 + 7;
int p[maxn];
long long d[maxn][2];
int n, x;
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) scanf("%d", p + i + 1);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
d[i][x] = 1;
}
for (int i = n - 1; i > 0; i--) {
d[p[i]][1] =
(d[p[i]][1] * (d[i][0] + d[i][1]) + d[p[i]][0] * d[i][1]) % mod;
d[p[i]][0] = (d[p[i]][0] * (d[i][0] + d[i][1])) % mod;
}
cout << d[0][1] << endl;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Petya recieved a gift of a string s with length up to 105 characters for his birthday. He took two more empty strings t and u and decided to play a game. This game has two possible moves:
* Extract the first character of s and append t with this character.
* Extract the last character of t and append u with this character.
Petya wants to get strings s and t empty and string u lexicographically minimal.
You should write a program that will help Petya win the game.
Input
First line contains non-empty string s (1 ≤ |s| ≤ 105), consisting of lowercase English letters.
Output
Print resulting string u.
Examples
Input
cab
Output
abc
Input
acdb
Output
abdc
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char strf[100005], strt[100005];
int cnt[26];
stack<int> S;
int main() {
scanf("%s", strf);
memset(cnt, 0, sizeof(cnt));
int len = strlen(strf);
for (int i = 0; i < len; i++) cnt[strf[i] - 'a']++;
int pnf = 0, pnt = 0;
for (int i = 0; i < 26; i++) {
if (pnt == len) break;
if (cnt[i] == len) {
printf("%s\n", strf);
return 0;
}
while ((!S.empty()) && S.top() <= i + 'a') {
strt[pnt++] = S.top();
S.pop();
}
while (cnt[i] > 0) {
if (strf[pnf] - 'a' == i) {
strt[pnt++] = strf[pnf];
pnf++;
cnt[i]--;
continue;
} else {
S.push(strf[pnf]);
cnt[strf[pnf] - 'a']--;
pnf++;
}
}
}
while (!S.empty()) {
strt[pnt++] = S.top();
S.pop();
}
for (int i = 0; i < len; i++) printf("%c", strt[i]);
printf("\n");
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Haruna is a high school student. She must remember the seating arrangements in her class because she is a class president. It is too difficult task to remember if there are so many students.
That is the reason why seating rearrangement is depress task for her. But students have a complaint if seating is fixed.
One day, she made a rule that all students must move but they don't move so far as the result of seating rearrangement.
The following is the rule. The class room consists of r*c seats. Each r row has c seats. The coordinate of the front row and most left is (1,1). The last row and right most is (r,c). After seating rearrangement, all students must move next to their seat. If a student sit (y,x) before seating arrangement, his/her seat must be (y,x+1) , (y,x-1), (y+1,x) or (y-1,x). The new seat must be inside of the class room. For example (0,1) or (r+1,c) is not allowed.
Your task is to check whether it is possible to rearrange seats based on the above rule.
Hint
For the second case, before seat rearrangement, the state is shown as follows.
1 2
3 4
There are some possible arrangements. For example
2 4
1 3
or
2 1
4 3
is valid arrangement.
Input
Input consists of multiple datasets. Each dataset consists of 2 integers. The last input contains two 0. A dataset is given by the following format.
r c
Input satisfies the following constraint.
1 ≤ r ≤ 19, 1 ≤ c ≤ 19
Output
Print "yes" without quates in one line if it is possible to rearrange the seats, otherwise print "no" without quates in one line.
Example
Input
1 1
2 2
0 0
Output
no
yes
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int r, c;
while(cin >> r >> c, r&&c){
if( (r*c)%2 ) cout << "no" << endl;
else cout << "yes" << endl;
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
A tree of size n is an undirected connected graph consisting of n vertices without cycles.
Consider some tree with n vertices. We call a tree invariant relative to permutation p = p1p2... pn, if for any two vertices of the tree u and v the condition holds: "vertices u and v are connected by an edge if and only if vertices pu and pv are connected by an edge".
You are given permutation p of size n. Find some tree size n, invariant relative to the given permutation.
Input
The first line contains number n (1 ≤ n ≤ 105) — the size of the permutation (also equal to the size of the sought tree).
The second line contains permutation pi (1 ≤ pi ≤ n).
Output
If the sought tree does not exist, print "NO" (without the quotes).
Otherwise, print "YES", and then print n - 1 lines, each of which contains two integers — the numbers of vertices connected by an edge of the tree you found. The vertices are numbered from 1, the order of the edges and the order of the vertices within the edges does not matter.
If there are multiple solutions, output any of them.
Examples
Input
4
4 3 2 1
Output
YES
4 1
4 2
1 3
Input
3
3 1 2
Output
NO
Note
In the first sample test a permutation transforms edge (4, 1) into edge (1, 4), edge (4, 2) into edge (1, 3) and edge (1, 3) into edge (4, 2). These edges all appear in the resulting tree.
It can be shown that in the second sample test no tree satisfies the given condition.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int p[100005], vis[100005];
vector<int> v[100005];
vector<pair<int, int> > ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) v[i].clear();
ans.clear();
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) cin >> p[i];
int f = 1, mn = n;
int rt;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
int num = 0, x = i;
while (!vis[x]) {
num++;
vis[x] = 1;
x = p[x];
}
if (num == 1 || (num == 2 && mn > 1)) rt = x;
mn = min(mn, num);
v[num].push_back(x);
}
if (mn > 2) {
cout << "NO" << endl;
continue;
}
for (int i = mn; i <= n; i++) {
if (v[i].size() == 0) continue;
if (i % mn) {
f = 0;
break;
}
for (auto u : v[i]) {
if (u == rt || p[u] == rt) continue;
int uu = u;
do {
ans.push_back(make_pair(rt, uu));
uu = p[uu];
if (uu != u)
ans.push_back(make_pair(p[rt], uu));
else
break;
uu = p[uu];
} while (uu != u);
}
}
if (mn == 2) ans.push_back(make_pair(rt, p[rt]));
if (!f)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (auto u : ans) cout << u.first << " " << u.second << endl;
}
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 15;
const int MAXN = 505;
const int MAXC = 100005;
int n, k, h[MAXK], ans;
int cnt[MAXC], p[MAXC];
int dp[MAXN][MAXN * MAXK];
vector<int> like;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n * k; i++) {
int c;
scanf("%d", &c);
cnt[c]++;
}
for (int i = 1; i <= n; i++) {
int f;
scanf("%d", &f);
if (!p[f]) like.push_back(f);
p[f]++;
}
for (int i = 1; i <= k; i++) scanf("%d", &h[i]);
for (int l = 0; l < like.size(); l++) {
int u = like[l];
int o = min(p[u] * k, cnt[u]);
for (int i = 1; i <= p[u]; i++)
for (int j = 0; j <= min(i * k, o); j++)
for (int r = 0; r <= min(j, k); r++)
dp[i][j] = max(dp[i][j], dp[i - 1][j - r] + h[r]);
ans += dp[p[u]][o];
}
printf("%d\n", ans);
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠ l2 and r1 ≠ r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
int n, h, a[N], b[N];
int main() {
scanf("%d%d", &n, &h);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] = h - a[i];
for (int i = 1; i <= n + 1; i++) {
b[i] = a[i] - a[i - 1];
}
long long lcnt = 0, ans = 1;
for (int i = 1; i <= n + 1; i++) {
if (b[i] < -1 || b[i] > 1) {
puts("0");
return 0;
}
if (b[i] == -1) {
ans *= lcnt, lcnt--;
}
if (b[i] == 0) ans *= (lcnt + 1);
if (b[i] == 1) lcnt++;
ans %= 1000000007;
}
printf("%lld\n", ans);
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
In order to do some research, n^2 labs are built on different heights of a mountain. Let's enumerate them with integers from 1 to n^2, such that the lab with the number 1 is at the lowest place, the lab with the number 2 is at the second-lowest place, …, the lab with the number n^2 is at the highest place.
To transport water between the labs, pipes are built between every pair of labs. A pipe can transport at most one unit of water at a time from the lab with the number u to the lab with the number v if u > v.
Now the labs need to be divided into n groups, each group should contain exactly n labs. The labs from different groups can transport water to each other. The sum of units of water that can be sent from a group A to a group B is equal to the number of pairs of labs (u, v) such that the lab with the number u is from the group A, the lab with the number v is from the group B and u > v. Let's denote this value as f(A,B) (i.e. f(A,B) is the sum of units of water that can be sent from a group A to a group B).
For example, if n=3 and there are 3 groups X, Y and Z: X = \{1, 5, 6\}, Y = \{2, 4, 9\} and Z = \{3, 7, 8\}. In this case, the values of f are equal to:
* f(X,Y)=4 because of 5 → 2, 5 → 4, 6 → 2, 6 → 4,
* f(X,Z)=2 because of 5 → 3, 6 → 3,
* f(Y,X)=5 because of 2 → 1, 4 → 1, 9 → 1, 9 → 5, 9 → 6,
* f(Y,Z)=4 because of 4 → 3, 9 → 3, 9 → 7, 9 → 8,
* f(Z,X)=7 because of 3 → 1, 7 → 1, 7 → 5, 7 → 6, 8 → 1, 8 → 5, 8 → 6,
* f(Z,Y)=5 because of 3 → 2, 7 → 2, 7 → 4, 8 → 2, 8 → 4.
Please, divide labs into n groups with size n, such that the value min f(A,B) over all possible pairs of groups A and B (A ≠ B) is maximal.
In other words, divide labs into n groups with size n, such that minimum number of the sum of units of water that can be transported from a group A to a group B for every pair of different groups A and B (A ≠ B) as big as possible.
Note, that the example above doesn't demonstrate an optimal division, but it demonstrates how to calculate the values f for some division.
If there are many optimal divisions, you can find any.
Input
The only line contains one number n (2 ≤ n ≤ 300).
Output
Output n lines:
In the i-th line print n numbers, the numbers of labs of the i-th group, in any order you want.
If there are multiple answers, that maximize the minimum number of the sum of units of water that can be transported from one group the another, you can print any.
Example
Input
3
Output
2 8 5
9 3 4
7 6 1
Note
In the first test we can divide 9 labs into groups \{2, 8, 5\}, \{9, 3, 4\}, \{7, 6, 1\}.
From the first group to the second group we can transport 4 units of water (8 → 3, 8 → 4, 5 → 3, 5 → 4).
From the first group to the third group we can transport 5 units of water (2 → 1, 8 → 7, 8 → 6, 8 → 1, 5 → 1).
From the second group to the first group we can transport 5 units of water (9 → 2, 9 → 8, 9 → 5, 3 → 2, 4 → 2).
From the second group to the third group we can transport 5 units of water (9 → 7, 9 → 6, 9 → 1, 3 → 1, 4 → 1).
From the third group to the first group we can transport 4 units of water (7 → 2, 7 → 5, 6 → 2, 6 → 5).
From the third group to the second group we can transport 4 units of water (7 → 3, 7 → 4, 6 → 3, 6 → 4).
The minimal number of the sum of units of water, that can be transported from one group to another is equal to 4. It can be proved, that it is impossible to make a better division.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, uk[301], flag = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
uk[i] = i;
}
vector<vector<int> > v(n + 1);
for (int i = 1; i <= n * n; i++) {
if (flag) {
for (int j = 1; j <= n / 2; j++) {
swap(uk[j], uk[n + 1 - j]);
}
flag = 0;
}
v[uk[i % n + n * (i % n == 0)]].push_back(i);
if (i % n == 0) flag = 1;
}
for (int i = 1; i <= n; i++) {
for (auto x : v[i]) {
cout << x << " ";
}
cout << "\n";
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
There are n cities in the kingdom X, numbered from 1 through n. People travel between cities by some one-way roads. As a passenger, JATC finds it weird that from any city u, he can't start a trip in it and then return back to it using the roads of the kingdom. That is, the kingdom can be viewed as an acyclic graph.
Being annoyed by the traveling system, JATC decides to meet the king and ask him to do something. In response, the king says that he will upgrade some cities to make it easier to travel. Because of the budget, the king will only upgrade those cities that are important or semi-important. A city u is called important if for every city v ≠ u, there is either a path from u to v or a path from v to u. A city u is called semi-important if it is not important and we can destroy exactly one city v ≠ u so that u becomes important.
The king will start to act as soon as he finds out all those cities. Please help him to speed up the process.
Input
The first line of the input contains two integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the number of cities and the number of one-way roads.
Next m lines describe the road system of the kingdom. Each of them contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i), denoting one-way road from u_i to v_i.
It is guaranteed, that the kingdoms' roads make an acyclic graph, which doesn't contain multiple edges and self-loops.
Output
Print a single integer — the number of cities that the king has to upgrade.
Examples
Input
7 7
1 2
2 3
3 4
4 7
2 5
5 4
6 4
Output
4
Input
6 7
1 2
2 3
3 4
1 5
5 3
2 6
6 4
Output
4
Note
In the first example:
<image>
* Starting at the city 1 we can reach all the other cities, except for the city 6. Also, from the city 6 we cannot reach the city 1. Therefore, if we destroy the city 6 then the city 1 will become important. So 1 is a semi-important city.
* For city 2, the set of cities that cannot reach 2 and cannot be reached by 2 is \{6\}. Therefore, destroying city 6 will make the city 2 important. So city 2 is also semi-important.
* For city 3, the set is \{5, 6\}. As you can see, destroying either city 5 or 6 will not make the city 3 important. Therefore, it is neither important nor semi-important.
* For city 4, the set is empty. So 4 is an important city.
* The set for city 5 is \{3, 6\} and the set for city 6 is \{3, 5\}. Similarly to city 3, both of them are not important nor semi-important.
* The city 7 is important since we can reach it from all other cities.
So we have two important cities (4 and 7) and two semi-important cities (1 and 2).
In the second example, the important cities are 1 and 4. The semi-important cities are 2 and 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 300000;
int n, m;
vector<int> out[MAXN];
vector<int> in[MAXN];
bool been[MAXN];
int top[MAXN], ntop;
int mxlen[MAXN], nxt[MAXN];
int path[MAXN], npath;
int pathidx[MAXN];
int q[MAXN], qhead, qtail;
int lidx[MAXN], ridx[MAXN];
int cand[MAXN];
int candidx[MAXN];
int numout[MAXN];
int numin[MAXN];
void dfstop(int at) {
assert(!been[at]);
been[at] = true;
for (int i = (0); i < (((int)(out[at]).size())); ++i) {
int to = out[at][i];
if (!been[to]) dfstop(to);
}
top[ntop++] = at;
}
int solve() {
ntop = 0;
for (int i = (0); i < (n); ++i) been[i] = false;
for (int i = (0); i < (n); ++i)
if (!been[i]) dfstop(i);
assert(ntop == n);
reverse(top, top + ntop);
for (int i = n - 1; i >= 0; --i) {
int at = top[i];
mxlen[at] = 1, nxt[at] = -1;
for (int j = (0); j < (((int)(out[at]).size())); ++j) {
int to = out[at][j];
if (mxlen[to] + 1 > mxlen[at]) mxlen[at] = mxlen[to] + 1, nxt[at] = to;
}
}
int mxgloblen = 0, fst = -1;
for (int i = (0); i < (n); ++i)
if (mxlen[i] > mxgloblen) mxgloblen = mxlen[i], fst = i;
npath = 0;
for (int at = fst; at != -1; at = nxt[at]) path[npath++] = at;
for (int i = (0); i < (n); ++i) pathidx[i] = -1;
for (int i = (0); i < (npath); ++i) pathidx[path[i]] = i;
qhead = qtail = 0;
for (int i = (0); i < (n); ++i) lidx[i] = -1;
for (int i = npath - 1; i >= 0; --i) {
q[qhead++] = path[i];
while (qtail < qhead) {
int at = q[qtail++];
for (int j = (0); j < (((int)(out[at]).size())); ++j) {
int to = out[at][j];
if (pathidx[to] != -1 || lidx[to] != -1) continue;
lidx[to] = i;
q[qhead++] = to;
}
}
}
qhead = qtail = 0;
for (int i = (0); i < (n); ++i) ridx[i] = -1;
for (int i = (0); i < (npath); ++i) {
q[qhead++] = path[i];
while (qtail < qhead) {
int at = q[qtail++];
for (int j = (0); j < (((int)(in[at]).size())); ++j) {
int to = in[at][j];
if (pathidx[to] != -1 || ridx[to] != -1) continue;
ridx[to] = i;
q[qhead++] = to;
}
}
}
for (int i = (0); i < (npath); ++i) cand[i] = -1;
for (int i = (0); i < (n); ++i)
if (pathidx[i] == -1) {
int opt = -1;
if (lidx[i] == -1 && ridx[i] == 1) opt = 0;
if (ridx[i] == -1 && lidx[i] == npath - 2) opt = npath - 1;
if (lidx[i] != -1 && ridx[i] != -1 && lidx[i] + 2 == ridx[i])
opt = lidx[i] + 1;
if (opt == -1) continue;
if (cand[opt] == -1)
cand[opt] = i;
else
cand[opt] = -2;
}
for (int i = (0); i < (npath); ++i)
if (cand[i] == -2) cand[i] = -1;
for (int i = (0); i < (n); ++i) candidx[i] = -1;
for (int i = (0); i < (npath); ++i)
if (cand[i] != -1) candidx[cand[i]] = i;
for (int i = (0); i < (n); ++i) numout[i] = numin[i] = -1;
qhead = qtail = 0;
for (int i = (0); i < (n); ++i) been[i] = false;
for (int i = npath - 1; i >= 0; --i) {
if (cand[i] != -1) {
int qold = qhead;
assert(!been[cand[i]]);
been[cand[i]] = true;
q[qhead++] = cand[i];
while (qtail < qhead) {
int at = q[qtail++];
for (int j = (0); j < (((int)(out[at]).size())); ++j) {
int to = out[at][j];
if (been[to]) continue;
been[to] = true;
q[qhead++] = to;
}
}
numout[cand[i]] = qhead;
for (int j = (qold); j < (qhead); ++j) {
int at = q[j];
been[at] = false;
}
qtail = qhead = qold;
}
assert(!been[path[i]]);
been[path[i]] = true;
q[qhead++] = path[i];
while (qtail < qhead) {
int at = q[qtail++];
for (int j = (0); j < (((int)(out[at]).size())); ++j) {
int to = out[at][j];
if (been[to]) continue;
been[to] = true;
q[qhead++] = to;
}
}
numout[path[i]] = qhead;
}
qhead = qtail = 0;
for (int i = (0); i < (n); ++i) been[i] = false;
for (int i = (0); i < (npath); ++i) {
if (cand[i] != -1) {
int qold = qhead;
assert(!been[cand[i]]);
been[cand[i]] = true;
q[qhead++] = cand[i];
while (qtail < qhead) {
int at = q[qtail++];
for (int j = (0); j < (((int)(in[at]).size())); ++j) {
int to = in[at][j];
if (been[to]) continue;
been[to] = true;
q[qhead++] = to;
}
}
numin[cand[i]] = qhead;
for (int j = (qold); j < (qhead); ++j) {
int at = q[j];
been[at] = false;
}
qtail = qhead = qold;
}
assert(!been[path[i]]);
been[path[i]] = true;
q[qhead++] = path[i];
while (qtail < qhead) {
int at = q[qtail++];
for (int j = (0); j < (((int)(in[at]).size())); ++j) {
int to = in[at][j];
if (been[to]) continue;
been[to] = true;
q[qhead++] = to;
}
}
numin[path[i]] = qhead;
}
int ret = 0;
for (int i = (0); i < (n); ++i)
if ((pathidx[i] != -1 || candidx[i] != -1) && numin[i] + numout[i] >= n)
++ret;
return ret;
}
void run() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
out[a].push_back(b);
in[b].push_back(a);
}
printf("%d\n", solve());
}
int main() {
run();
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
There is a game that involves three variables, denoted A, B, and C.
As the game progresses, there will be N events where you are asked to make a choice. Each of these choices is represented by a string s_i. If s_i is `AB`, you must add 1 to A or B then subtract 1 from the other; if s_i is `AC`, you must add 1 to A or C then subtract 1 from the other; if s_i is `BC`, you must add 1 to B or C then subtract 1 from the other.
After each choice, none of A, B, and C should be negative.
Determine whether it is possible to make N choices under this condition. If it is possible, also give one such way to make the choices.
Constraints
* 1 \leq N \leq 10^5
* 0 \leq A,B,C \leq 10^9
* N, A, B, C are integers.
* s_i is `AB`, `AC`, or `BC`.
Input
Input is given from Standard Input in the following format:
N A B C
s_1
s_2
:
s_N
Output
If it is possible to make N choices under the condition, print `Yes`; otherwise, print `No`.
Also, in the former case, show one such way to make the choices in the subsequent N lines. The (i+1)-th line should contain the name of the variable (`A`, `B`, or `C`) to which you add 1 in the i-th choice.
Examples
Input
2 1 3 0
AB
AC
Output
Yes
A
C
Input
3 1 0 0
AB
BC
AB
Output
No
Input
1 0 9 0
AC
Output
No
Input
8 6 9 1
AC
BC
AB
BC
AC
BC
AB
AB
Output
Yes
C
B
B
C
C
B
A
A
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
const int N = 2e5 + 5;
int n;
string str[N];
char res[N];
void dfs(int i, int a, int b, int c) {
if (i >= n) {
cout << "Yes" << endl;
rep(i,n) {
cout << res[i] << endl;
}
exit(0);
}
if (str[i] == "AB") {
if (a) res[i] = 'B', dfs(i + 1, a - 1, b + 1, c);
if (b) res[i] = 'A', dfs(i + 1, a + 1, b - 1, c);
} else if (str[i] == "AC") {
if (a) res[i] = 'C', dfs(i + 1, a - 1, b, c + 1);
if (c) res[i] = 'A', dfs(i + 1, a + 1, b, c - 1);
} else {
if (b) res[i] = 'C', dfs(i + 1, a, b - 1, c + 1);
if (c) res[i] = 'B', dfs(i + 1, a, b + 1, c - 1);
}
}
int main() {
int a, b, c;
cin >> n >> a >> b >> c;
rep(i,n) cin >> str[i];
dfs(0, a, b, c);
cout << "No" << endl;
exit(0);
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t;
cin >> n >> k >> t;
if (t >= k && n >= t) {
cout << k;
return 0;
}
if (t > n) {
cout << max((int)0, k - (t - n));
return 0;
}
cout << t;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Bear Limak has n colored balls, arranged in one long row. Balls are numbered 1 through n, from left to right. There are n possible colors, also numbered 1 through n. The i-th ball has color ti.
For a fixed interval (set of consecutive elements) of balls we can define a dominant color. It's a color occurring the biggest number of times in the interval. In case of a tie between some colors, the one with the smallest number (index) is chosen as dominant.
There are <image> non-empty intervals in total. For each color, your task is to count the number of intervals in which this color is dominant.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 5000) — the number of balls.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ n) where ti is the color of the i-th ball.
Output
Print n integers. The i-th of them should be equal to the number of intervals where i is a dominant color.
Examples
Input
4
1 2 1 2
Output
7 3 0 0
Input
3
1 1 1
Output
6 0 0
Note
In the first sample, color 2 is dominant in three intervals:
* An interval [2, 2] contains one ball. This ball's color is 2 so it's clearly a dominant color.
* An interval [4, 4] contains one ball, with color 2 again.
* An interval [2, 4] contains two balls of color 2 and one ball of color 1.
There are 7 more intervals and color 1 is dominant in all of them.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int arr[5001], visited[5001], answer[5001];
int main() {
ios::sync_with_stdio(false);
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
int Max = 0, color = 0;
memset(visited, 0, sizeof visited);
for (int j = i; j < n; j++) {
visited[arr[j]]++;
if (visited[arr[j]] > Max || (visited[arr[j]] == Max && color >= arr[j]))
Max = visited[arr[j]], color = arr[j];
answer[color]++;
}
}
for (int i = 1; i <= n; i++) cout << answer[i] << " ";
cout << "\n";
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive.
Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.
Constraints
* 1≦a,b,c≦100
Input
The input is given from Standard Input in the following format:
a b c
Output
Print the number of different kinds of colors of the paint cans.
Examples
Input
3 1 4
Output
3
Input
3 3 33
Output
2
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
set<int> s;
int main(){
for (int i=0;i<3;i++){
int t;cin>>t;
s.insert(t);
}cout<<s.size()<<endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are playing a video game and you have just reached the bonus level, where the only possible goal is to score as many points as possible. Being a perfectionist, you've decided that you won't leave this level until you've gained the maximum possible number of points there.
The bonus level consists of n small platforms placed in a line and numbered from 1 to n from left to right and (n - 1) bridges connecting adjacent platforms. The bridges between the platforms are very fragile, and for each bridge the number of times one can pass this bridge from one of its ends to the other before it collapses forever is known in advance.
The player's actions are as follows. First, he selects one of the platforms to be the starting position for his hero. After that the player can freely move the hero across the platforms moving by the undestroyed bridges. As soon as the hero finds himself on a platform with no undestroyed bridge attached to it, the level is automatically ended. The number of points scored by the player at the end of the level is calculated as the number of transitions made by the hero between the platforms. Note that if the hero started moving by a certain bridge, he has to continue moving in the same direction until he is on a platform.
Find how many points you need to score to be sure that nobody will beat your record, and move to the next level with a quiet heart.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the number of platforms on the bonus level. The second line contains (n - 1) integers ai (1 ≤ ai ≤ 109, 1 ≤ i < n) — the number of transitions from one end to the other that the bridge between platforms i and i + 1 can bear.
Output
Print a single integer — the maximum number of points a player can get on the bonus level.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
2 1 2 1
Output
5
Note
One possibility of getting 5 points in the sample is starting from platform 3 and consequently moving to platforms 4, 3, 2, 1 and 2. After that the only undestroyed bridge is the bridge between platforms 4 and 5, but this bridge is too far from platform 2 where the hero is located now.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long r[2][N], l[2][N], a[N], n;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a[i];
}
long long mx = 0;
for (int i = 1; i <= n; i++) {
if (a[i - 1] < 2) continue;
l[0][i] = l[0][i - 1] + a[i - 1] - (a[i - 1] & 1);
}
for (int i = n; i >= 1; i--) {
if (a[i] < 2) continue;
r[0][i] = r[0][i + 1] + a[i] - (a[i] & 1);
}
for (int i = 1; i <= n; i++) {
l[1][i] = l[1][i - 1] + max(0ll, a[i - 1] - (a[i - 1] % 2 == 0));
l[1][i] = max(l[1][i], l[0][i]);
}
for (int i = n; i >= 1; i--) {
r[1][i] = r[1][i + 1] + max(0ll, a[i] - (a[i] % 2 == 0));
r[1][i] = max(r[1][i], r[0][i]);
}
for (int i = 1; i <= n; i++) {
mx = max(mx, max(r[0][i] + l[1][i], r[1][i] + l[0][i]));
}
cout << mx << endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
There is a fence in front of Polycarpus's home. The fence consists of n planks of the same width which go one after another from left to right. The height of the i-th plank is hi meters, distinct planks can have distinct heights.
<image> Fence for n = 7 and h = [1, 2, 6, 1, 1, 7, 1]
Polycarpus has bought a posh piano and is thinking about how to get it into the house. In order to carry out his plan, he needs to take exactly k consecutive planks from the fence. Higher planks are harder to tear off the fence, so Polycarpus wants to find such k consecutive planks that the sum of their heights is minimal possible.
Write the program that finds the indexes of k consecutive planks with minimal total height. Pay attention, the fence is not around Polycarpus's home, it is in front of home (in other words, the fence isn't cyclic).
Input
The first line of the input contains integers n and k (1 ≤ n ≤ 1.5·105, 1 ≤ k ≤ n) — the number of planks in the fence and the width of the hole for the piano. The second line contains the sequence of integers h1, h2, ..., hn (1 ≤ hi ≤ 100), where hi is the height of the i-th plank of the fence.
Output
Print such integer j that the sum of the heights of planks j, j + 1, ..., j + k - 1 is the minimum possible. If there are multiple such j's, print any of them.
Examples
Input
7 3
1 2 6 1 1 7 1
Output
3
Note
In the sample, your task is to find three consecutive planks with the minimum sum of heights. In the given case three planks with indexes 3, 4 and 5 have the required attribute, their total height is 8.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 100 * 1000 + 10, inf = 1e9;
int arr[MAXN];
int sum[MAXN];
int main() {
int k, n;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= k; i++) {
sum[1] += arr[i];
}
for (int i = 2; i <= n - k + 1; i++) {
sum[i] = sum[i - 1] - arr[i - 1] + arr[i + k - 1];
}
int minn = inf, ans = 0;
for (int i = 1; i <= n - k + 1; i++) {
minn = min(sum[i], minn);
if (minn == sum[i]) {
ans = i;
}
}
cout << ans;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are planning to build housing on a street. There are n spots available on the street on which you can build a house. The spots are labeled from 1 to n from left to right. In each spot, you can build a house with an integer height between 0 and h.
In each spot, if a house has height a, you will gain a^2 dollars from it.
The city has m zoning restrictions. The i-th restriction says that the tallest house from spots l_i to r_i (inclusive) must be at most x_i.
You would like to build houses to maximize your profit. Determine the maximum profit possible.
Input
The first line contains three integers n, h, and m (1 ≤ n,h,m ≤ 50) — the number of spots, the maximum height, and the number of restrictions.
Each of the next m lines contains three integers l_i, r_i, and x_i (1 ≤ l_i ≤ r_i ≤ n, 0 ≤ x_i ≤ h) — left and right limits (inclusive) of the i-th restriction and the maximum possible height in that range.
Output
Print a single integer, the maximum profit you can make.
Examples
Input
3 3 3
1 1 1
2 2 3
3 3 2
Output
14
Input
4 10 2
2 3 8
3 4 7
Output
262
Note
In the first example, there are 3 houses, the maximum height of a house is 3, and there are 3 restrictions. The first restriction says the tallest house between 1 and 1 must be at most 1. The second restriction says the tallest house between 2 and 2 must be at most 3. The third restriction says the tallest house between 3 and 3 must be at most 2.
In this case, it is optimal to build houses with heights [1, 3, 2]. This fits within all the restrictions. The total profit in this case is 1^2 + 3^2 + 2^2 = 14.
In the second example, there are 4 houses, the maximum height of a house is 10, and there are 2 restrictions. The first restriction says the tallest house from 2 to 3 must be at most 8. The second restriction says the tallest house from 3 to 4 must be at most 7.
In this case, it's optimal to build houses with heights [10, 8, 7, 7]. We get a profit of 10^2+8^2+7^2+7^2 = 262. Note that there are two restrictions on house 3 and both of them must be satisfied. Also, note that even though there isn't any explicit restrictions on house 1, we must still limit its height to be at most 10 (h=10).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int fx[4] = {1, -1, 0, 0};
int fy[4] = {0, 0, 1, -1};
const double PI = acos(-1.0);
const double EPS = 1e-6;
const int MOD = (int)1e9 + 7;
const int maxn = (int)2e5 + 5;
int a[55];
int n, h, m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> h >> m;
for (int i = 1; i <= n; i++) {
a[i] = h;
}
for (int i = 1; i <= m; i++) {
int l, r, val;
cin >> l >> r >> val;
for (int k = l; k <= r; k++) {
a[k] = min(a[k], val);
}
}
long long sum = 0LL;
for (int i = 1; i <= n; i++) {
sum += (a[i] * a[i]);
}
cout << sum << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You have given tree consist of n vertices. Select a vertex as root vertex that satisfies the condition below.
* For all vertices v_{1} and v_{2}, if distance(root, v_{1}) = distance(root, v_{2}) then degree(v_{1}) = degree(v_{2}), where degree means the number of vertices connected to that vertex, and distance means the number of edges between two vertices.
Determine and find if there is such root vertex in the tree. If there are multiple answers, find any of them.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^{5}) — the number of vertices.
Each of the next n-1 lines contains two integers v_{i} and u_{i} (1 ≤ v_{i} < u_{i} ≤ n) — it means there is an edge exist between v_{i} and u_{i}. It is guaranteed that the graph forms tree.
Output
If there is such root vertex exists, print any of them. Otherwise, print -1.
Examples
Input
7
1 2
2 3
3 4
4 5
3 6
6 7
Output
3
Input
6
1 3
2 3
3 4
4 5
4 6
Output
-1
Note
This is the picture for the first example. 1, 5, 7 also can be a valid answer.
<image>
This is the picture for the second example. You can see that it's impossible to find such root vertex.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int x, y, i, n, d, sz[N], mx, rt, s = 1e9, vis[N];
vector<int> G[N];
void dfs(int u, int fa) {
sz[u] = 1;
int mx = 0;
for (int i = 0, v; i < G[u].size(); i++)
if ((v = G[u][i]) != fa) dfs(v, u), sz[u] += sz[v], mx = max(mx, sz[v]);
mx = max(mx, n - sz[u]);
if (mx < s) s = mx, rt = u;
}
bool chk(int u, int fa, int d) {
if (!sz[d])
sz[d] = G[u].size();
else if (G[u].size() != sz[d])
return 0;
for (int i = 0, v; i < G[u].size(); i++)
if ((v = G[u][i]) != fa && !chk(v, u, d + 1)) return 0;
return 1;
}
int line(int u, int fa, int d) {
if (u == rt) return d;
if (G[u].size() > 2) return 0;
return line(G[u][G[u][0] == fa], u, d + 1);
}
int main() {
scanf("%d", &n);
for (i = 1; i < n; i++)
scanf("%d%d", &x, &y), G[x].push_back(y), G[y].push_back(x);
dfs(1, 0);
memset(sz, 0, n + 1 << 2);
if (chk(rt, 0, 0)) return printf("%d", rt), 0;
for (i = 1; i <= n; i++)
if (G[i].size() == 1) {
d = line(i, 0, 0);
if (d && !vis[d]) {
vis[d] = 1, memset(sz, 0, n + 1 << 2);
if (chk(i, 0, 0)) return printf("%d", i), 0;
}
}
puts("-1");
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given a text consisting of n space-separated words. There is exactly one space character between any pair of adjacent words. There are no spaces before the first word and no spaces after the last word. The length of text is the number of letters and spaces in it. w_i is the i-th word of text. All words consist only of lowercase Latin letters.
Let's denote a segment of words w[i..j] as a sequence of words w_i, w_{i + 1}, ..., w_j. Two segments of words w[i_1 .. j_1] and w[i_2 .. j_2] are considered equal if j_1 - i_1 = j_2 - i_2, j_1 ≥ i_1, j_2 ≥ i_2, and for every t ∈ [0, j_1 - i_1] w_{i_1 + t} = w_{i_2 + t}. For example, for the text "to be or not to be" the segments w[1..2] and w[5..6] are equal, they correspond to the words "to be".
An abbreviation is a replacement of some segments of words with their first uppercase letters. In order to perform an abbreviation, you have to choose at least two non-intersecting equal segments of words, and replace each chosen segment with the string consisting of first letters of the words in the segment (written in uppercase). For example, for the text "a ab a a b ab a a b c" you can replace segments of words w[2..4] and w[6..8] with an abbreviation "AAA" and obtain the text "a AAA b AAA b c", or you can replace segments of words w[2..5] and w[6..9] with an abbreviation "AAAB" and obtain the text "a AAAB AAAB c".
What is the minimum length of the text after at most one abbreviation?
Input
The first line of the input contains one integer n (1 ≤ n ≤ 300) — the number of words in the text.
The next line contains n space-separated words of the text w_1, w_2, ..., w_n. Each word consists only of lowercase Latin letters.
It is guaranteed that the length of text does not exceed 10^5.
Output
Print one integer — the minimum length of the text after at most one abbreviation.
Examples
Input
6
to be or not to be
Output
12
Input
10
a ab a a b ab a a b c
Output
13
Input
6
aa bb aa aa bb bb
Output
11
Note
In the first example you can obtain the text "TB or not TB".
In the second example you can obtain the text "a AAAB AAAB c".
In the third example you can obtain the text "AB aa AB bb".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, i = 0, dp[305][305], eq[305][305], sum = 0, curr, total = 0, j = 0,
k, cnt, ans;
string str[305];
int main(void) {
for (cin >> n; i < n; i++) cin >> str[i], total += str[i].size();
total += n - 1;
ans = total;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) eq[i][j] = eq[j][i] = (str[i] == str[j]);
}
for (i = n - 1; i >= 0; i--) {
for (j = n - 1; j >= 0; j--)
(eq[i][j] == 1) ? dp[i][j] += dp[i + 1][j + 1] + 1 : 0;
}
for (i = 0; i < n; i++) {
sum = 0;
for (j = 1; j + i <= n; j++) {
sum += str[i + j - 1].size();
cnt = 1;
for (k = i + j; k < n; k++) {
if (dp[i][k] >= j) cnt++, k += j - 1;
}
curr = total - cnt * sum + j * cnt - (j - 1) * cnt;
if (curr < ans && cnt > 1) ans = curr;
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Two bored soldiers are playing card war. Their card deck consists of exactly n cards, numbered from 1 to n, all values are different. They divide cards between them in some manner, it's possible that they have different number of cards. Then they play a "war"-like card game.
The rules are following. On each turn a fight happens. Each of them picks card from the top of his stack and puts on the table. The one whose card value is bigger wins this fight and takes both cards from the table to the bottom of his stack. More precisely, he first takes his opponent's card and puts to the bottom of his stack, and then he puts his card to the bottom of his stack. If after some turn one of the player's stack becomes empty, he loses and the other one wins.
You have to calculate how many fights will happen and who will win the game, or state that game won't end.
Input
First line contains a single integer n (2 ≤ n ≤ 10), the number of cards.
Second line contains integer k1 (1 ≤ k1 ≤ n - 1), the number of the first soldier's cards. Then follow k1 integers that are the values on the first soldier's cards, from top to bottom of his stack.
Third line contains integer k2 (k1 + k2 = n), the number of the second soldier's cards. Then follow k2 integers that are the values on the second soldier's cards, from top to bottom of his stack.
All card values are different.
Output
If somebody wins in this game, print 2 integers where the first one stands for the number of fights before end of game and the second one is 1 or 2 showing which player has won.
If the game won't end and will continue forever output - 1.
Examples
Input
4
2 1 3
2 4 2
Output
6 2
Input
3
1 2
2 1 3
Output
-1
Note
First sample:
<image>
Second sample:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int k1, k2;
int a[100000], b[100000];
bool k[38000000];
int s1, s2;
int e1, e2, v;
int cantor() {
int ans = 0;
int k[10], cnt = 0;
for (int i = s1; i < e1; i++) k[cnt++] = a[i];
for (int i = s2; i < e2; i++) k[cnt++] = b[i];
for (int i = 0; i < n; i++) {
int x = 0;
int c = 1, m = 1;
for (int j = i + 1; j < n; j++) {
if (k[j] < k[i]) x++;
m *= c;
c++;
}
ans += x * m;
}
return ans;
}
int main() {
cin >> n;
cin >> k1;
for (int i = 0; i < k1; i++) {
cin >> a[i];
}
cin >> k2;
for (int i = 0; i < k2; i++) {
cin >> b[i];
}
s1 = s2 = 0;
e1 = k1;
e2 = k2;
int cnt = 0;
while (true) {
cnt++;
v = cantor() * 10 + e1 - s1;
if (k[v]) {
cout << -1 << endl;
return 0;
}
k[v] = true;
if (a[s1] > b[s2]) {
a[e1++] = b[s2];
a[e1++] = a[s1];
} else {
b[e2++] = a[s1];
b[e2++] = b[s2];
}
s1++;
s2++;
if (s1 == e1) {
cout << cnt << ' ' << 2 << endl;
return 0;
}
if (s2 == e2) {
cout << cnt << ' ' << 1 << endl;
return 0;
}
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
The Smart Beaver from ABBYY got hooked on square matrices. Now he is busy studying an n × n size matrix, where n is odd. The Smart Beaver considers the following matrix elements good:
* Elements of the main diagonal.
* Elements of the secondary diagonal.
* Elements of the "middle" row — the row which has exactly <image> rows above it and the same number of rows below it.
* Elements of the "middle" column — the column that has exactly <image> columns to the left of it and the same number of columns to the right of it.
<image> The figure shows a 5 × 5 matrix. The good elements are marked with green.
Help the Smart Beaver count the sum of good elements of the given matrix.
Input
The first line of input data contains a single odd integer n. Each of the next n lines contains n integers aij (0 ≤ aij ≤ 100) separated by single spaces — the elements of the given matrix.
The input limitations for getting 30 points are:
* 1 ≤ n ≤ 5
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 101
Output
Print a single integer — the sum of good matrix elements.
Examples
Input
3
1 2 3
4 5 6
7 8 9
Output
45
Input
5
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
Output
17
Note
In the first sample all matrix elements will be good. Good elements in the second sample are shown on the figure.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[100 + 13][100 + 13], b[100 + 13][100 + 13], sum;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
b[i][i]++;
b[i][n - i - 1]++;
}
for (int i = 0; i < n; i++) {
b[n / 2][i]++;
b[i][n / 2]++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (b[i][j] > 0) {
sum += a[i][j];
}
}
}
cout << sum << endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given a tree consisting of n vertices (numbered from 1 to n). Initially all vertices are white. You have to process q queries of two different types:
1. 1 x — change the color of vertex x to black. It is guaranteed that the first query will be of this type.
2. 2 x — for the vertex x, find the minimum index y such that the vertex with index y belongs to the simple path from x to some black vertex (a simple path never visits any vertex more than once).
For each query of type 2 print the answer to it.
Note that the queries are given in modified way.
Input
The first line contains two numbers n and q (3 ≤ n, q ≤ 106).
Then n - 1 lines follow, each line containing two numbers xi and yi (1 ≤ xi < yi ≤ n) and representing the edge between vertices xi and yi.
It is guaranteed that these edges form a tree.
Then q lines follow. Each line contains two integers ti and zi, where ti is the type of ith query, and zi can be used to restore xi for this query in this way: you have to keep track of the answer to the last query of type 2 (let's call this answer last, and initially last = 0); then xi = (zi + last) mod n + 1.
It is guaranteed that the first query is of type 1, and there is at least one query of type 2.
Output
For each query of type 2 output the answer to it.
Example
Input
4 6
1 2
2 3
3 4
1 2
1 2
2 2
1 3
2 2
2 2
Output
3
2
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long b, long long e, long long mod) {
long long ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1) ans = ans * b % mod;
return ans;
}
const int inf = (int)1e9;
const int N = 1000005;
int dp[N], ans = inf, n, q, pai[N], vis[N];
vector<int> g[N];
void dfs(int x, int p = -1) {
if (p == -1)
dp[x] = x;
else
dp[x] = min(x, dp[p]);
for (auto w : g[x]) {
if (w != p) dfs(w, x), pai[w] = x;
}
}
int32_t main() {
for (int i = 0; i < (N); ++i) dp[i] = inf;
scanf("%d%d", &n, &q);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
int last = 0;
bool jf = false;
while (q--) {
int t, x;
scanf("%d%d", &t, &x);
if (t == 1) {
if (jf == 0) {
jf = 1;
x = (x + last) % n + 1;
dfs(x);
} else {
x = (x + last) % n + 1;
while (x && !vis[x]) {
vis[x] = true;
ans = min(ans, x);
x = pai[x];
}
}
} else {
x = (x + last) % n + 1;
printf("%d\n", (last = min(dp[x], ans)));
}
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Squid loves painting vertices in graphs.
There is a simple undirected graph consisting of N vertices numbered 1 through N, and M edges. Initially, all the vertices are painted in color 0. The i-th edge bidirectionally connects two vertices a_i and b_i. The length of every edge is 1.
Squid performed Q operations on this graph. In the i-th operation, he repaints all the vertices within a distance of d_i from vertex v_i, in color c_i.
Find the color of each vertex after the Q operations.
Constraints
* 1 ≤ N,M,Q ≤ 10^5
* 1 ≤ a_i,b_i,v_i ≤ N
* a_i ≠ b_i
* 0 ≤ d_i ≤ 10
* 1 ≤ c_i ≤10^5
* d_i and c_i are all integers.
* There are no self-loops or multiple edges in the given graph.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_{M} b_{M}
Q
v_1 d_1 c_1
:
v_{Q} d_{Q} c_{Q}
Output
Print the answer in N lines. In the i-th line, print the color of vertex i after the Q operations.
Examples
Input
7 7
1 2
1 3
1 4
4 5
5 6
5 7
2 3
2
6 1 1
1 2 2
Output
2
2
2
2
2
1
0
Input
14 10
1 4
5 7
7 11
4 10
14 7
14 3
6 14
8 11
5 13
8 3
8
8 6 2
9 7 85
6 9 3
6 7 5
10 3 1
12 9 4
9 6 6
8 2 3
Output
1
0
3
1
5
5
3
3
6
1
3
4
5
3
### Response
```cpp
#include<bits/stdc++.h>
#define ll long long
using namespace std;
struct aaa{
int x,y,w;
}a[500001];
int n,m,t1,tot,ans[500001],mx[500001],e[500001],nt[500001],hd[500001];
void dfs(int x,int dep,int w){
if(mx[x]>=dep)return;
mx[x]=dep;
if(!ans[x])ans[x]=w;
if(!w)return;
int i;
for(i=hd[x];i;i=nt[i])dfs(e[i],dep-1,w);
}
void build(int x,int y){
tot++;
e[tot]=y;
nt[tot]=hd[x];hd[x]=tot;
}
int main(){
int i,x,y;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)mx[i]=-1;
for(i=1;i<=m;i++){
scanf("%d%d",&x,&y);
build(x,y);build(y,x);
}
scanf("%d",&t1);
for(i=1;i<=t1;i++)
scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].w);
for(i=t1;i;i--)dfs(a[i].x,a[i].y,a[i].w);
for(i=1;i<=n;i++)printf("%d\n",ans[i]);
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Ksusha is a beginner coder. Today she starts studying arrays. She has array a1, a2, ..., an, consisting of n positive integers.
Her university teacher gave her a task. Find such number in the array, that all array elements are divisible by it. Help her and find the number!
Input
The first line contains integer n (1 ≤ n ≤ 105), showing how many numbers the array has. The next line contains integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the array elements.
Output
Print a single integer — the number from the array, such that all array elements are divisible by it. If such number doesn't exist, print -1.
If there are multiple answers, you are allowed to print any of them.
Examples
Input
3
2 2 4
Output
2
Input
5
2 1 3 1 6
Output
1
Input
3
2 3 5
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int min;
int n, a[100001];
bool ans = true;
scanf("%d", &n);
scanf("%d", &a[0]);
min = a[0];
for (int i = 1; i < n; i++) {
scanf("%d", &a[i]);
if (min > a[i]) min = a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] % min != 0) {
ans = false;
break;
}
}
if (ans)
printf("%d\n", min);
else
printf("-1\n");
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Polycarp wants to train before another programming competition. During the first day of his training he should solve exactly 1 problem, during the second day — exactly 2 problems, during the third day — exactly 3 problems, and so on. During the k-th day he should solve k problems.
Polycarp has a list of n contests, the i-th contest consists of a_i problems. During each day Polycarp has to choose exactly one of the contests he didn't solve yet and solve it. He solves exactly k problems from this contest. Other problems are discarded from it. If there are no contests consisting of at least k problems that Polycarp didn't solve yet during the k-th day, then Polycarp stops his training.
How many days Polycarp can train if he chooses the contests optimally?
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of contests.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5) — the number of problems in the i-th contest.
Output
Print one integer — the maximum number of days Polycarp can train if he chooses the contests optimally.
Examples
Input
4
3 1 4 1
Output
3
Input
3
1 1 1
Output
1
Input
5
1 1 1 2 2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using std::cerr;
using std::cin;
using std::cout;
using std::string;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
std::vector<int> a(n);
for (int& x : a) {
cin >> x;
}
std::sort(a.begin(), a.end());
int days = 0;
int i = 0;
for (; i < n; i++) {
while (i < n && a[i] <= days) {
i++;
}
if (i == n) {
break;
}
days++;
}
cout << days << "\n";
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Brothers Fred and George Weasley once got into the sporting goods store and opened a box of Quidditch balls. After long and painful experiments they found out that the Golden Snitch is not enchanted at all. It is simply a programmed device. It always moves along the same trajectory, which is a polyline with vertices at the points (x0, y0, z0), (x1, y1, z1), ..., (xn, yn, zn). At the beginning of the game the snitch is positioned at the point (x0, y0, z0), and then moves along the polyline at the constant speed vs. The twins have not yet found out how the snitch behaves then. Nevertheless, they hope that the retrieved information will help Harry Potter and his team in the upcoming match against Slytherin. Harry Potter learned that at the beginning the game he will be at the point (Px, Py, Pz) and his super fast Nimbus 2011 broom allows him to move at the constant speed vp in any direction or remain idle. vp is not less than the speed of the snitch vs. Harry Potter, of course, wants to catch the snitch as soon as possible. Or, if catching the snitch while it is moving along the polyline is impossible, he wants to hurry the Weasley brothers with their experiments. Harry Potter catches the snitch at the time when they are at the same point. Help Harry.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000). The following n + 1 lines contain the coordinates xi, yi, zi, separated by single spaces. The coordinates of any two consecutive points do not coincide. The next line contains the velocities vp and vs, the last line contains Px, Py, Pz, separated by single spaces. All the numbers in the input are integers, their absolute value does not exceed 104. The speeds are strictly positive. It is guaranteed that vs ≤ vp.
Output
If Harry Potter can catch the snitch while it is moving along the polyline (including the end (xn, yn, zn)), print "YES" in the first line (without the quotes). Print in the second line t, which is the earliest moment of time, when Harry will be able to catch the snitch. On the third line print three numbers X, Y, Z, the coordinates of the point at which this happens. The absolute or relative error in the answer should not exceed 10 - 6. If Harry is not able to catch the snitch during its moving along the described polyline, print "NO".
Examples
Input
4
0 0 0
0 10 0
10 10 0
10 0 0
0 0 0
1 1
5 5 25
Output
YES
25.5000000000
10.0000000000 4.5000000000 0.0000000000
Input
4
0 0 0
0 10 0
10 10 0
10 0 0
0 0 0
1 1
5 5 50
Output
NO
Input
1
1 2 3
4 5 6
20 10
1 2 3
Output
YES
0.0000000000
1.0000000000 2.0000000000 3.0000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long double epsilon = 1e-9;
bool isEq(pair<long double, pair<long double, long double> > x,
pair<long double, pair<long double, long double> > y) {
long double x1, x2, y1, y2, z1, z2;
x1 = x.first;
x2 = y.first;
y1 = x.second.first;
y2 = y.second.first;
z1 = x.second.second;
z2 = y.second.second;
long double temp1 = fabs(x2 - x1);
long double temp2 = fabs(y2 - y1);
long double temp3 = fabs(z2 - z1);
if (temp1 < epsilon && temp2 < epsilon && temp3 < epsilon) return true;
return false;
}
long double dist(pair<long double, pair<long double, long double> > x,
pair<long double, pair<long double, long double> > y) {
long double dsx = x.first - y.first;
long double dsy = x.second.first - y.second.first;
long double dsz = x.second.second - y.second.second;
long double ds = sqrt(dsx * dsx + dsy * dsy + dsz * dsz);
return ds;
}
bool check(pair<long double, pair<long double, long double> > x,
pair<long double, pair<long double, long double> > y,
pair<long double, pair<long double, long double> > z, int v, int u,
long double t) {
long double ds = dist(x, y);
long double dp = dist(x, z);
long double ts = ds / v;
long double tp = dp / u;
if (tp <= ts + t) return true;
return false;
}
pair<long double, pair<long double, long double> > bs(
pair<int, pair<int, int> > x, pair<int, pair<int, int> > y,
pair<int, pair<int, int> > z, int v, int u, long double t) {
pair<long double, pair<long double, long double> > st, ed;
pair<long double, pair<long double, long double> > mid;
st = x;
ed = y;
mid.first = ((ed.first - st.first) / ((long double)2)) + st.first;
mid.second.first = ((ed.second.first - st.second.first) / ((long double)2)) +
st.second.first;
mid.second.second =
((ed.second.second - st.second.second) / ((long double)2)) +
st.second.second;
while (!isEq(st, ed)) {
if (check(mid, x, z, v, u, t)) {
ed = mid;
} else
st = mid;
mid.first = ((ed.first - st.first) / ((long double)2)) + st.first;
mid.second.first =
((ed.second.first - st.second.first) / ((long double)2)) +
st.second.first;
mid.second.second =
((ed.second.second - st.second.second) / ((long double)2)) +
st.second.second;
}
return mid;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
pair<int, pair<int, int> > a[n + 2];
for (int i = 0; i <= n; i++) {
cin >> a[i].first >> a[i].second.first >> a[i].second.second;
}
int vp, vs;
cin >> vp >> vs;
pair<int, pair<int, int> > p;
cin >> p.first >> p.second.first >> p.second.second;
long double time = 0;
pair<long double, pair<long double, long double> > ans;
bool chk = 0;
for (int i = 0; i < n; i++) {
if (check(a[i + 1], a[i], p, vs, vp, time)) {
ans = bs(a[i], a[i + 1], p, vs, vp, time);
chk = true;
break;
}
time += (dist(a[i + 1], a[i]) / vs);
}
if (!chk) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
cout << setprecision(10) << fixed << (dist(ans, p) / vp) << '\n';
cout << setprecision(10) << fixed << ans.first << " " << ans.second.first
<< " " << ans.second.second << '\n';
}
}
return 0;
}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.