text
stringlengths 424
69.5k
|
|---|
### Prompt
Generate a CPP solution to the following problem:
Vus the [Cossack](https://en.wikipedia.org/wiki/Cossacks) holds a programming competition, in which n people participate. He decided to award them all with pens and notebooks. It is known that Vus has exactly m pens and k notebooks.
Determine whether the Cossack can reward all participants, giving each of them at least one pen and at least one notebook.
Input
The first line contains three integers n, m, and k (1 ≤ n, m, k ≤ 100) — the number of participants, the number of pens, and the number of notebooks respectively.
Output
Print "Yes" if it possible to reward all the participants. Otherwise, print "No".
You can print each letter in any case (upper or lower).
Examples
Input
5 8 6
Output
Yes
Input
3 9 3
Output
Yes
Input
8 5 20
Output
No
Note
In the first example, there are 5 participants. The Cossack has 8 pens and 6 notebooks. Therefore, he has enough pens and notebooks.
In the second example, there are 3 participants. The Cossack has 9 pens and 3 notebooks. He has more than enough pens but only the minimum needed number of notebooks.
In the third example, there are 8 participants but only 5 pens. Since the Cossack does not have enough pens, the answer is "No".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if (n <= m && n <= k)
cout << "Yes";
else
cout << "No";
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Mr. Kobou found a bundle of old paper when he was cleaning his family home. On each paper, two series of numbers are written. Strange as it appeared to him, Mr. Kobou further went through the storehouse and found out a note his ancestor left. According to it, the bundle of paper is a treasure map, in which the two sequences of numbers seem to give a clue to the whereabouts of the treasure the ancestor buried.
Mr. Kobou’s ancestor divided the area where he buried his treasure in a reticular pattern and used only some of the grid sections. The two series of numbers indicate the locations: the $i$-th member of the first series indicates the number of locations in the $i$-th column (form left) of the grid sections where a part of the treasure is buried, and the $j$-th member of the second indicates the same information regarding the $j$-th row from the top. No more than one piece of treasure is buried in one grid section. An example of a 5 × 4 case is shown below. If the pieces of treasure are buried in the grid sections noted as "#" the two series of numbers become "0,2,2,1,1" and "1,1,1,3".
| 0| 2| 2| 1| 1
---|---|---|---|---|---
1| | | #| |
1| | #| | |
1| | | | | #
3| | #| #| #|
Mr. Kobou’s ancestor seems to be a very careful person. He slipped some pieces of paper with completely irrelevant information into the bundle. For example, a set of number series "3,2,3,0,0" and "4,2,0,0,2" does not match any combination of 5 × 5 matrixes. So, Mr. Kobou has first to exclude these pieces of garbage information.
Given the set of information written on the pieces of paper, make a program to judge if the information is relevant.
Input
The input is given in the following format.
$W$ $H$
$a_1$ $a_2$ $...$ $a_W$
$b_1$ $b_2$ $...$ $b_H$
The first line provides the number of horizontal partitions $W$ ($1 \leq W \leq 1000$) and vertical partitions $H$ ($1 \leq H \leq 1000$). The second line provides the $i$-th member of the first number series $a_i$ ($0 \leq a_i \leq H$) written on the paper, and the third line the $j$-th member of the second series $b_j$ ($0 \leq b_j \leq W$).
Output
Output "1" if the information written on the paper is relevant, or "0" otherwise.
Examples
Input
5 4
0 2 2 1 1
1 1 1 3
Output
1
Input
5 5
3 2 3 0 0
4 2 0 0 2
Output
0
### Response
```cpp
#include<cstdio>
#include<functional>
#include<algorithm>
#include<queue>
using namespace std;
int main(void)
{
int w,h,a,b[1000],i,j,flg,a1[1000],k,sum1,sum2;
priority_queue<int> que;
scanf("%d %d",&w,&h);
sum1=0; sum2=0;
for(i=0;i<w;i++) {
scanf("%d",&a);
sum1+=a;
que.push(a);
}
for(i=0;i<h;i++) {
scanf("%d",&b[i]);
sum2+=b[i];
}
sort(b,b+h,greater<int>() );
flg=1;
for(i=0;i<h;i++) {
for(j=0;j<b[i];j++) {
a1[j]=que.top();
if(a1[j]==0) {
flg=0; break;
}
que.pop();
}
for(j=0;j<b[i];j++) {
que.push(a1[j]-1);
}
}
if(sum1!=sum2) flg=0;
printf("%d\n",flg);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are n positive integers a_1, a_2, ..., a_n. For the one move you can choose any even value c and divide by two all elements that equal c.
For example, if a=[6,8,12,6,3,12] and you choose c=6, and a is transformed into a=[3,8,12,3,3,12] after the move.
You need to find the minimal number of moves for transforming a to an array of only odd integers (each element shouldn't be divisible by 2).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains n (1 ≤ n ≤ 2⋅10^5) — the number of integers in the sequence a. The second line contains positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The sum of n for all test cases in the input doesn't exceed 2⋅10^5.
Output
For t test cases print the answers in the order of test cases in the input. The answer for the test case is the minimal number of moves needed to make all numbers in the test case odd (i.e. not divisible by 2).
Example
Input
4
6
40 6 40 3 20 1
1
1024
4
2 4 8 16
3
3 1 7
Output
4
10
4
0
Note
In the first test case of the example, the optimal sequence of moves can be as follows:
* before making moves a=[40, 6, 40, 3, 20, 1];
* choose c=6;
* now a=[40, 3, 40, 3, 20, 1];
* choose c=40;
* now a=[20, 3, 20, 3, 20, 1];
* choose c=20;
* now a=[10, 3, 10, 3, 10, 1];
* choose c=10;
* now a=[5, 3, 5, 3, 5, 1] — all numbers are odd.
Thus, all numbers became odd after 4 moves. In 3 or fewer moves, you cannot make them all odd.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int a[N];
bool cmp(const int& a, const int& b) { return a > b; }
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
map<int, int, greater<int> > cnt;
memset(a, 0, sizeof(a));
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
if ((a[i] & 1) == 0) ++cnt[a[i]];
}
int res = 0;
for (map<int, int, greater<int> >::iterator iter = cnt.begin();
iter != cnt.end(); ++iter) {
int firstnum = (*iter).first;
while ((firstnum & 1) == 0) {
firstnum >>= 1;
res++;
if (cnt.count(firstnum)) {
cnt[firstnum] += (*iter).second;
break;
}
}
}
cout << res << endl;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
In one well-known algorithm of finding the k-th order statistics we should divide all elements into groups of five consecutive elements and find the median of each five. A median is called the middle element of a sorted array (it's the third largest element for a group of five). To increase the algorithm's performance speed on a modern video card, you should be able to find a sum of medians in each five of the array.
A sum of medians of a sorted k-element set S = {a1, a2, ..., ak}, where a1 < a2 < a3 < ... < ak, will be understood by as
<image>
The <image> operator stands for taking the remainder, that is <image> stands for the remainder of dividing x by y.
To organize exercise testing quickly calculating the sum of medians for a changing set was needed.
Input
The first line contains number n (1 ≤ n ≤ 105), the number of operations performed.
Then each of n lines contains the description of one of the three operations:
* add x — add the element x to the set;
* del x — delete the element x from the set;
* sum — find the sum of medians of the set.
For any add x operation it is true that the element x is not included in the set directly before the operation.
For any del x operation it is true that the element x is included in the set directly before the operation.
All the numbers in the input are positive integers, not exceeding 109.
Output
For each operation sum print on the single line the sum of medians of the current set. If the set is empty, print 0.
Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams (also you may use the %I64d specificator).
Examples
Input
6
add 4
add 5
add 1
add 2
add 3
sum
Output
3
Input
14
add 1
add 7
add 2
add 5
sum
add 6
add 8
add 9
add 3
add 4
add 10
sum
del 1
sum
Output
5
11
13
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char s[9];
vector<int> a;
int n, x;
long long res;
int main() {
cin >> n;
for (int i = (1), _b = (n); i <= _b; i++) {
cin >> (s + 1);
if (s[1] == 's') {
res = 0;
for (int i = 2; i < a.size(); i += 5) res += a[i];
cout << res << "\n";
} else {
cin >> x;
if (s[1] == 'a')
a.insert(lower_bound(a.begin(), a.end(), x), x);
else
a.erase(lower_bound(a.begin(), a.end(), x));
}
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Snuke and Ciel went to a strange stationery store. Each of them got a transparent graph paper with H rows and W columns.
Snuke painted some of the cells red in his paper. Here, the cells painted red were 4-connected, that is, it was possible to traverse from any red cell to any other red cell, by moving to vertically or horizontally adjacent red cells only.
Ciel painted some of the cells blue in her paper. Here, the cells painted blue were 4-connected.
Afterwards, they precisely overlaid the two sheets in the same direction. Then, the intersection of the red cells and the blue cells appeared purple.
You are given a matrix of letters a_{ij} (1≤i≤H, 1≤j≤W) that describes the positions of the purple cells. If the cell at the i-th row and j-th column is purple, then a_{ij} is `#`, otherwise a_{ij} is `.`. Here, it is guaranteed that no outermost cell is purple. That is, if i=1, H or j = 1, W, then a_{ij} is `.`.
Find a pair of the set of the positions of the red cells and the blue cells that is consistent with the situation described. It can be shown that a solution always exists.
Constraints
* 3≤H,W≤500
* a_{ij} is `#` or `.`.
* If i=1,H or j=1,W, then a_{ij} is `.`.
* At least one of a_{ij} is `#`.
Input
The input is given from Standard Input in the following format:
H W
a_{11}...a_{1W}
:
a_{H1}...a_{HW}
Output
Print a pair of the set of the positions of the red cells and the blue cells that is consistent with the situation, as follows:
* The first H lines should describe the positions of the red cells.
* The following 1 line should be empty.
* The following H lines should describe the positions of the blue cells.
The description of the positions of the red or blue cells should follow the format of the description of the positions of the purple cells.
Examples
Input
5 5
.....
.#.#.
.....
.#.#.
.....
Output
.....
#####
#....
#####
.....
.###.
.#.#.
.#.#.
.#.#.
.....
Input
7 13
.............
.###.###.###.
.#.#.#...#...
.###.#...#...
.#.#.#.#.#...
.#.#.###.###.
.............
Output
.............
.###########.
.###.###.###.
.###.###.###.
.###.###.###.
.###.###.###.
.............
.............
.###.###.###.
.#.#.#...#...
.###.#...#...
.#.#.#.#.#...
.#.#########.
.............
### Response
```cpp
#include<cstdio>
using namespace std;
const int maxn=505;
int n,m;char mp[maxn][maxn];
int main(){
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++) scanf("%s",mp[i]+1);
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++)
if(mp[i][j]=='#') putchar('#');
else putchar(j==1||(i&1)&&j<m?'#':'.');
putchar('\n');
}
putchar('\n');
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++)
if(mp[i][j]=='#') putchar('#');
else putchar(j==m||!(i&1)&&j>1?'#':'.');
putchar('\n');
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
This is a simplified version of the task Toy Train. These two versions differ only in the constraints. Hacks for this version are disabled.
Alice received a set of Toy Train™ from Bob. It consists of one train and a connected railway network of n stations, enumerated from 1 through n. The train occupies one station at a time and travels around the network of stations in a circular manner. More precisely, the immediate station that the train will visit after station i is station i+1 if 1 ≤ i < n or station 1 if i = n. It takes the train 1 second to travel to its next station as described.
Bob gave Alice a fun task before he left: to deliver m candies that are initially at some stations to their independent destinations using the train. The candies are enumerated from 1 through m. Candy i (1 ≤ i ≤ m), now at station a_i, should be delivered to station b_i (a_i ≠ b_i).
<image> The blue numbers on the candies correspond to b_i values. The image corresponds to the 1-st example.
The train has infinite capacity, and it is possible to load off any number of candies at a station. However, only at most one candy can be loaded from a station onto the train before it leaves the station. You can choose any candy at this station. The time it takes to move the candies is negligible.
Now, Alice wonders how much time is needed for the train to deliver all candies. Your task is to find, for each station, the minimum time the train would need to deliver all the candies were it to start from there.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 100; 1 ≤ m ≤ 200) — the number of stations and the number of candies, respectively.
The i-th of the following m lines contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n; a_i ≠ b_i) — the station that initially contains candy i and the destination station of the candy, respectively.
Output
In the first and only line, print n space-separated integers, the i-th of which is the minimum time, in seconds, the train would need to deliver all the candies were it to start from station i.
Examples
Input
5 7
2 4
5 1
2 3
3 4
4 1
5 3
3 5
Output
10 9 10 10 9
Input
2 3
1 2
1 2
1 2
Output
5 6
Note
Consider the second sample.
If the train started at station 1, the optimal strategy is as follows.
1. Load the first candy onto the train.
2. Proceed to station 2. This step takes 1 second.
3. Deliver the first candy.
4. Proceed to station 1. This step takes 1 second.
5. Load the second candy onto the train.
6. Proceed to station 2. This step takes 1 second.
7. Deliver the second candy.
8. Proceed to station 1. This step takes 1 second.
9. Load the third candy onto the train.
10. Proceed to station 2. This step takes 1 second.
11. Deliver the third candy.
Hence, the train needs 5 seconds to complete the tasks.
If the train were to start at station 2, however, it would need to move to station 1 before it could load the first candy, which would take one additional second. Thus, the answer in this scenario is 5+1 = 6 seconds.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<vector<int>> cand(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
cand[x - 1].push_back(y - 1);
}
for (int i = 0; i < n; i++) {
if (cand[i].empty()) {
continue;
}
int nearest;
int bestD;
for (int j = 0; j < (int)cand[i].size(); j++) {
int d = cand[i][j] > i ? abs(i - cand[i][j])
: abs(n - 1 - i) + abs(cand[i][j] - 0);
if (j == 0 || d < bestD) {
bestD = d;
nearest = j;
}
}
swap(cand[i][nearest], cand[i][0]);
}
vector<int> p(n);
for (int start = 0; start < n; start++) {
queue<int> q;
int v = start;
int cnt = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
p[i] = (int)cand[i].size() - 1;
}
while (cnt != m) {
if (p[v] >= 0) {
q.push(cand[v][p[v]]);
p[v]--;
}
int sz = (int)q.size();
for (int i = 0; i < sz; i++) {
int c = q.front();
q.pop();
if (c == v) {
cnt++;
} else {
q.push(c);
}
}
if (cnt == m) {
break;
}
ans++;
v = (v + 1) % n;
}
cout << ans << ' ';
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
We know that prime numbers are positive integers that have exactly two distinct positive divisors. Similarly, we'll call a positive integer t Т-prime, if t has exactly three distinct positive divisors.
You are given an array of n positive integers. For each of them determine whether it is Т-prime or not.
Input
The first line contains a single positive integer, n (1 ≤ n ≤ 105), showing how many numbers are in the array. The next line contains n space-separated integers xi (1 ≤ xi ≤ 1012).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is advised to use the cin, cout streams or the %I64d specifier.
Output
Print n lines: the i-th line should contain "YES" (without the quotes), if number xi is Т-prime, and "NO" (without the quotes), if it isn't.
Examples
Input
3
4 5 6
Output
YES
NO
NO
Note
The given test has three numbers. The first number 4 has exactly three divisors — 1, 2 and 4, thus the answer for this number is "YES". The second number 5 has two divisors (1 and 5), and the third number 6 has four divisors (1, 2, 3, 6), hence the answer for them is "NO".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n;
long long int a, sq;
cin >> n;
while (n--) {
cin >> a;
sq = sqrt(a);
for (j = 2; j * j <= sq; j++) {
if (sq % j == 0) break;
}
if ((j * j > sq) && (sq * sq == a) && (a > 1))
cout << "YES\n";
else
cout << "NO\n";
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Spiders are Om Nom's old enemies. They love eating candies as much as he does and that's why they keep trying to keep the monster away from his favorite candies. They came up with an evil plan to trap Om Nom.
<image>
Let's consider a rope structure consisting of n nodes and n - 1 ropes connecting the nodes. The structure is connected, thus, the ropes and the nodes form a tree. Each rope of the formed structure is associated with its length. A candy is tied to node x of the structure. Om Nom really wants to eat this candy.
The y spiders are trying to stop him from doing it. They decided to entangle the candy and some part of the structure into a web, thus attaching the candy to as large as possible part of the rope structure.
Each spider can use his web to cover all ropes on the path between two arbitrary nodes a and b. Thus, y spiders can cover the set of ropes which is a union of y paths in the given tree. These y paths can arbitrarily intersect each other. The spiders want the following conditions to be hold:
* the node containing the candy is adjacent to at least one rope covered with a web
* the ropes covered with the web form a connected structure (what's the idea of covering with a web the ropes that are not connected with the candy?)
* the total length of the ropes covered with web is as large as possible
The spiders haven't yet decided to what node of the structure they will tie the candy and how many spiders will cover the structure with web, so they asked you to help them. Help them calculate the optimal plan for multiple values of x and y.
Input
The first line contains numbers n and q (1 ≤ n, q ≤ 105) — the number of nodes in the structure and the number of questions that the spiders want to ask you.
The next n - 1 lines determine the rope structure. The i-th line contains three integers ui, vi, li (1 ≤ ui, vi ≤ n, ui ≠ vi, 1 ≤ li ≤ 1000), showing that there is a rope of length li between nodes ui and vi.
Next q lines describe the spiders' questions. As they want you to answer their question online, they encoded their messages in a special manner.
Each of the next q lines contains two numbers xi, yi. In the first question of the spiders x = x1, y = y1.
To calculate values x and y in the spiders' i-th (2 ≤ i ≤ q) question, you need to use the following formulas:
<image>
<image>
where Ansi - 1 is the total length of the ropes covered by a web in the answer for the (i - 1)-th question.
The following inequality holds: 1 ≤ xi, yi ≤ n.
Output
For each question of the spiders print on a separate line a single integer Ansi — the total length of the ropes covered with web in the optimal plan.
Examples
Input
6 3
1 2 2
2 3 2
3 4 2
4 6 1
3 5 10
3 1
2 5
1 1
Output
14
13
17
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100000, LOG_N = 18;
int n, qu;
vector<pair<int, int> > nei[N + 1];
int dis[N + 1];
int tot;
void dfs(int x = 1, int fa = 0) {
for (int i = 0; i < nei[x].size(); i++) {
int y = nei[x][i].first, len = nei[x][i].second;
if (y == fa) continue;
tot += len;
dis[y] = dis[x] + len;
dfs(y, x);
}
}
int de1, de2;
int dis1[N + 1], mxdis1[N + 1], fa1[N + 1][LOG_N], dson1[N + 1], top1[N + 1];
int dis2[N + 1], mxdis2[N + 1], fa2[N + 1][LOG_N], dson2[N + 1], top2[N + 1];
vector<pair<int, int> > chn1, chn2;
int Sum1[N + 1], Sum2[N + 1];
int rk1[N + 1], rk2[N + 1];
void dfs0(int x = de1) {
for (int i = 1; i < LOG_N; i++) fa1[x][i] = fa1[fa1[x][i - 1]][i - 1];
for (int i = 0; i < nei[x].size(); i++) {
int y = nei[x][i].first, len = nei[x][i].second;
if (y == fa1[x][0]) continue;
fa1[y][0] = x;
dis1[y] = mxdis1[y] = dis1[x] + len;
dfs0(y);
mxdis1[x] = max(mxdis1[x], mxdis1[y]);
if (mxdis1[y] > mxdis1[dson1[x]]) dson1[x] = y;
}
}
void dfs2(int x = de1, int t = de1) {
top1[x] = t;
if (dson1[x]) dfs2(dson1[x], t);
for (int i = 0; i < nei[x].size(); i++) {
int y = nei[x][i].first;
if (y == fa1[x][0] || y == dson1[x]) continue;
dfs2(y, y);
}
}
void dfs1(int x = de2) {
for (int i = 1; i < LOG_N; i++) fa2[x][i] = fa2[fa2[x][i - 1]][i - 1];
for (int i = 0; i < nei[x].size(); i++) {
int y = nei[x][i].first, len = nei[x][i].second;
if (y == fa2[x][0]) continue;
fa2[y][0] = x;
dis2[y] = mxdis2[y] = dis2[x] + len;
dfs1(y);
mxdis2[x] = max(mxdis2[x], mxdis2[y]);
if (mxdis2[y] > mxdis2[dson2[x]]) dson2[x] = y;
}
}
void dfs3(int x = de2, int t = de2) {
top2[x] = t;
if (dson2[x]) dfs3(dson2[x], t);
for (int i = 0; i < nei[x].size(); i++) {
int y = nei[x][i].first;
if (y == fa2[x][0] || y == dson2[x]) continue;
dfs3(y, y);
}
}
int ask1(int y, int x) {
if (rk1[top1[x]] < y) return Sum1[y - 1];
int x1 = x, x2 = x;
for (int i = LOG_N - 1; ~i; i--) {
if (rk1[top1[fa1[x1][i]]] >= y - 1) x1 = fa1[x1][i];
if (rk1[top1[fa1[x2][i]]] >= y) x2 = fa1[x2][i];
}
return max((y - 1 ? Sum1[y - 2] : 0) + mxdis1[x] - dis1[fa1[x1][0]],
Sum1[y - 1] + mxdis1[x] - mxdis1[fa1[x2][0]]);
}
int ask2(int y, int x) {
if (rk2[top2[x]] < y) return Sum2[y - 1];
int x1 = x, x2 = x;
for (int i = LOG_N - 1; ~i; i--) {
if (rk2[top2[fa2[x1][i]]] >= y - 1) x1 = fa2[x1][i];
if (rk2[top2[fa2[x2][i]]] >= y) x2 = fa2[x2][i];
}
return max((y - 1 ? Sum2[y - 2] : 0) + mxdis2[x] - dis2[fa2[x1][0]],
Sum2[y - 1] + mxdis2[x] - mxdis2[fa2[x2][0]]);
}
int main() {
cin >> n >> qu;
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
nei[x].push_back(make_pair(y, z)), nei[y].push_back(make_pair(x, z));
}
dfs();
pair<int, int> mx(-1, 0);
for (int i = 1; i <= n; i++) mx = max(mx, make_pair(dis[i], i));
de1 = mx.second;
dfs0();
dfs2();
for (int i = 1; i <= n; i++)
if (nei[i].size() == 1 && i != de1)
chn1.push_back(make_pair(dis1[i] - dis1[fa1[top1[i]][0]], i));
sort(chn1.begin(), chn1.end(), greater<pair<int, int> >());
for (int i = 0; i < chn1.size(); i++)
Sum1[i] = (i ? Sum1[i - 1] : 0) + chn1[i].first,
rk1[top1[chn1[i].second]] = i;
mx = make_pair(-1, 0);
for (int i = 1; i <= n; i++) mx = max(mx, make_pair(dis1[i], i));
de2 = mx.second;
dfs1();
dfs3();
for (int i = 1; i <= n; i++)
if (nei[i].size() == 1 && i != de2)
chn2.push_back(make_pair(dis2[i] - dis2[fa2[top2[i]][0]], i));
sort(chn2.begin(), chn2.end(), greater<pair<int, int> >());
for (int i = 0; i < chn2.size(); i++)
Sum2[i] = (i ? Sum2[i - 1] : 0) + chn2[i].first,
rk2[top2[chn2[i].second]] = i;
int lasans = 0;
while (qu--) {
int x, y;
scanf("%d%d", &x, &y);
x = (x + lasans + n - 1) % n + 1, y = (y + lasans + n - 1) % n + 1;
if (2 * y >= chn1.size() + 1)
printf("%d\n", lasans = tot);
else {
printf("%d\n", lasans = max(ask1(2 * y - 1, x), ask2(2 * y - 1, x)));
}
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
There are n casinos lined in a row. If Memory plays at casino i, he has probability pi to win and move to the casino on the right (i + 1) or exit the row (if i = n), and a probability 1 - pi to lose and move to the casino on the left (i - 1) or also exit the row (if i = 1).
We say that Memory dominates on the interval i... j if he completes a walk such that,
* He starts on casino i.
* He never looses in casino i.
* He finishes his walk by winning in casino j.
Note that Memory can still walk left of the 1-st casino and right of the casino n and that always finishes the process.
Now Memory has some requests, in one of the following forms:
* 1 i a b: Set <image>.
* 2 l r: Print the probability that Memory will dominate on the interval l... r, i.e. compute the probability that Memory will first leave the segment l... r after winning at casino r, if she starts in casino l.
It is guaranteed that at any moment of time p is a non-decreasing sequence, i.e. pi ≤ pi + 1 for all i from 1 to n - 1.
Please help Memory by answering all his requests!
Input
The first line of the input contains two integers n and q(1 ≤ n, q ≤ 100 000), — number of casinos and number of requests respectively.
The next n lines each contain integers ai and bi (1 ≤ ai < bi ≤ 109) — <image> is the probability pi of winning in casino i.
The next q lines each contain queries of one of the types specified above (1 ≤ a < b ≤ 109, 1 ≤ i ≤ n, 1 ≤ l ≤ r ≤ n).
It's guaranteed that there will be at least one query of type 2, i.e. the output will be non-empty. Additionally, it is guaranteed that p forms a non-decreasing sequence at all times.
Output
Print a real number for every request of type 2 — the probability that boy will "dominate" on that interval. Your answer will be considered correct if its absolute error does not exceed 10 - 4.
Namely: let's assume that one of your answers is a, and the corresponding answer of the jury is b. The checker program will consider your answer correct if |a - b| ≤ 10 - 4.
Example
Input
3 13
1 3
1 2
2 3
2 1 1
2 1 2
2 1 3
2 2 2
2 2 3
2 3 3
1 2 2 3
2 1 1
2 1 2
2 1 3
2 2 2
2 2 3
2 3 3
Output
0.3333333333
0.2000000000
0.1666666667
0.5000000000
0.4000000000
0.6666666667
0.3333333333
0.2500000000
0.2222222222
0.6666666667
0.5714285714
0.6666666667
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct Node {
int l, r;
double f, g;
} t[N << 2];
double p[N];
int n, q;
inline void pushup(int rt) {
t[rt].f = t[rt << 1].f * t[rt << 1 | 1].f /
(1.0 - (1.0 - t[rt << 1 | 1].f) * (1.0 - t[rt << 1].g));
t[rt].g = t[rt << 1].g * t[rt << 1 | 1].g /
(1.0 - (1.0 - t[rt << 1 | 1].f) * (1.0 - t[rt << 1].g));
}
void build(int rt, int l, int r) {
t[rt].l = l, t[rt].r = r;
if (l == r) {
t[rt].f = p[l], t[rt].g = 1.0 - p[l];
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void change(int rt, int pos, double val) {
if (t[rt].l == t[rt].r) {
t[rt].f = val, t[rt].g = 1.0 - val;
return;
}
int mid = t[rt].l + t[rt].r >> 1;
if (pos <= mid)
change(rt << 1, pos, val);
else
change(rt << 1 | 1, pos, val);
pushup(rt);
}
Node query(int rt, int l, int r) {
if (l <= t[rt].l && r >= t[rt].r) return t[rt];
int mid = t[rt].l + t[rt].r >> 1;
if (r <= mid) return query(rt << 1, l, r);
if (l > mid) return query(rt << 1 | 1, l, r);
Node ls = query(rt << 1, l, r), rs = query(rt << 1 | 1, l, r);
Node ans = (Node){0, 0, ls.f * rs.f / (1.0 - (1.0 - rs.f) * (1.0 - ls.g)),
ls.g * rs.g / (1.0 - (1.0 - rs.f) * (1.0 - ls.g))};
return ans;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1, l, r; i <= n; ++i) {
scanf("%d%d", &l, &r);
p[i] = 1.0 * l / r;
}
build(1, 1, n);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int i, x, y;
scanf("%d%d%d", &i, &x, &y);
change(1, i, 1.0 * x / y);
} else {
int l, r;
scanf("%d%d", &l, &r);
printf("%f\n", query(1, l, r).f);
}
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2000100;
int n;
struct query {
int type, t, x;
} q[N];
struct node {
node *l, *r;
int x, y, sum, ini;
node() {
l = r = NULL;
x = y = sum = ini = 0;
}
} * t[N];
inline void upd(node *&x) {
if (!x) return;
x->sum = x->ini;
if (x->l) x->sum += x->l->sum;
if (x->r) x->sum += x->r->sum;
}
node *merge(node *l, node *r) {
if (!l) return r;
if (!r) return l;
if (l->y > r->y) {
l->r = merge(l->r, r);
upd(l);
return l;
} else {
r->l = merge(l, r->l);
upd(r);
return r;
}
}
void split(node *t, int x, node *&l, node *&r) {
if (!t) {
l = r = NULL;
return;
}
if (t->x < x) {
l = t;
split(l->r, x, l->r, r);
upd(l);
} else {
r = t;
split(r->l, x, l, r->l);
upd(r);
}
}
unordered_map<int, int> pos;
int vn = 0;
int main() {
srand(time(0));
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &q[i].type, &q[i].t, &q[i].x);
}
for (int i = 1; i <= n; ++i) {
if (!pos[q[i].x]) pos[q[i].x] = ++vn;
int now = pos[q[i].x];
if (q[i].type == 3) {
node *l = NULL, *r = NULL;
split(t[now], q[i].t + 1, l, r);
int ans = 0;
if (l) ans = l->sum;
printf("%d\n", max(0, ans));
t[now] = merge(l, r);
} else {
node *z = new node;
z->x = q[i].t;
z->y = rand();
z->ini = 1;
if (q[i].type == 2) z->ini = -1;
z->sum = z->ini;
node *l = NULL, *r = NULL;
split(t[now], q[i].t, l, r);
t[now] = merge(l, merge(z, r));
}
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for 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;
int main() {
int n, k;
cin >> n >> k;
int temp;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> temp;
v.push_back(temp);
}
int sum = 0;
int ind = 1;
int m = INT_MAX;
for (int i = 0; i < k; i++) sum += v[i];
m = sum;
for (int i = k; i < n; i++) {
sum -= v[i - k];
sum += v[i];
m = min(sum, m);
if (m == sum) ind = i - k + 2;
}
cout << ind;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Snow Queen told Kay to form a word "eternity" using pieces of ice. Kay is eager to deal with the task, because he will then become free, and Snow Queen will give him all the world and a pair of skates.
Behind the palace of the Snow Queen there is an infinite field consisting of cells. There are n pieces of ice spread over the field, each piece occupying exactly one cell and no two pieces occupying the same cell. To estimate the difficulty of the task Kay looks at some squares of size k × k cells, with corners located at the corners of the cells and sides parallel to coordinate axis and counts the number of pieces of the ice inside them.
This method gives an estimation of the difficulty of some part of the field. However, Kay also wants to estimate the total difficulty, so he came up with the following criteria: for each x (1 ≤ x ≤ n) he wants to count the number of squares of size k × k, such that there are exactly x pieces of the ice inside.
Please, help Kay estimate the difficulty of the task given by the Snow Queen.
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 300) — the number of pieces of the ice and the value k, respectively. Each of the next n lines contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — coordinates of the cell containing i-th piece of the ice. It's guaranteed, that no two pieces of the ice occupy the same cell.
Output
Print n integers: the number of squares of size k × k containing exactly 1, 2, ..., n pieces of the ice.
Example
Input
5 3
4 5
4 6
5 5
5 6
7 7
Output
10 8 1 4 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000010007;
const long long inf = mod * mod;
int r[110000];
int c[110000];
pair<int, int> p[110000];
pair<int, int> ev[210000];
long long ret[110000];
int main() {
int a, b;
scanf("%d%d", &a, &b);
for (int i = 0; i < a; i++) {
scanf("%d%d", r + i, c + i);
ev[i * 2 + 1] = make_pair(r[i], i + 1);
ev[i * 2] = make_pair(r[i] + b, -i - 1);
p[i] = make_pair(c[i], r[i]);
}
std::sort(p, p + a);
std::sort(ev, ev + a * 2);
int last = -mod;
set<pair<int, pair<int, int> > > S;
for (int i = 0; i < a * 2; i++) {
if (i == 0 || ev[i].first != ev[i - 1].first) {
long long ks = ev[i].first - last;
int las = -mod;
int cnt = 0;
for (set<pair<int, pair<int, int> > >::iterator it = S.begin();
it != S.end(); it++) {
if (it == S.begin() || ((*it).first != las)) {
if (cnt) ret[cnt] += ((long long)(*it).first - las) * ks;
las = (*it).first;
}
cnt += (*it).second.first;
}
last = ev[i].first;
}
if (ev[i].second > 0) {
S.insert(make_pair(c[ev[i].second - 1], make_pair(1, ev[i].second)));
S.insert(make_pair(c[ev[i].second - 1] + b, make_pair(-1, ev[i].second)));
} else {
S.erase(make_pair(c[-ev[i].second - 1], make_pair(1, -ev[i].second)));
S.erase(
make_pair(c[-ev[i].second - 1] + b, make_pair(-1, -ev[i].second)));
}
}
for (int i = 1; i <= a; i++) {
if (i != 1) printf(" ");
printf("%I64d", ret[i]);
}
printf("\n");
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Vanya has a scales for weighing loads and weights of masses w0, w1, w2, ..., w100 grams where w is some integer not less than 2 (exactly one weight of each nominal value). Vanya wonders whether he can weight an item with mass m using the given weights, if the weights can be put on both pans of the scales. Formally speaking, your task is to determine whether it is possible to place an item of mass m and some weights on the left pan of the scales, and some weights on the right pan of the scales so that the pans of the scales were in balance.
Input
The first line contains two integers w, m (2 ≤ w ≤ 109, 1 ≤ m ≤ 109) — the number defining the masses of the weights and the mass of the item.
Output
Print word 'YES' if the item can be weighted and 'NO' if it cannot.
Examples
Input
3 7
Output
YES
Input
100 99
Output
YES
Input
100 50
Output
NO
Note
Note to the first sample test. One pan can have an item of mass 7 and a weight of mass 3, and the second pan can have two weights of masses 9 and 1, correspondingly. Then 7 + 3 = 9 + 1.
Note to the second sample test. One pan of the scales can have an item of mass 99 and the weight of mass 1, and the second pan can have the weight of mass 100.
Note to the third sample test. It is impossible to measure the weight of the item in the manner described in the input.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long int> vec;
int main() {
long long int w, m;
cin >> w >> m;
long long int r;
while (m != 0) {
r = m % w;
if (r > w / 2) {
m++;
r = r - w;
}
vec.push_back(r);
m = m / w;
}
for (int i = 0; i < vec.size(); i++) {
if (vec[i] != 0 && vec[i] != 1 && vec[i] != -1) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
vec.clear();
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
A sequence of non-negative integers a1, a2, ..., an of length n is called a wool sequence if and only if there exists two integers l and r (1 ≤ l ≤ r ≤ n) such that <image>. In other words each wool sequence contains a subsequence of consecutive elements with xor equal to 0.
The expression <image> means applying the operation of a bitwise xor to numbers x and y. The given operation exists in all modern programming languages, for example, in languages C++ and Java it is marked as "^", in Pascal — as "xor".
In this problem you are asked to compute the number of sequences made of n integers from 0 to 2m - 1 that are not a wool sequence. You should print this number modulo 1000000009 (109 + 9).
Input
The only line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 105).
Output
Print the required number of sequences modulo 1000000009 (109 + 9) on the only line of output.
Examples
Input
3 2
Output
6
Note
Sequences of length 3 made of integers 0, 1, 2 and 3 that are not a wool sequence are (1, 3, 1), (1, 2, 1), (2, 1, 2), (2, 3, 2), (3, 1, 3) and (3, 2, 3).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long int k = 1, ans = 1;
cin >> n >> m;
for (int i = 0; i < m; i++) {
k *= 2;
k = k % 1000000009;
}
for (int i = 1; i <= n; i++) {
ans *= (k - i);
ans = ans % 1000000009;
}
cout << ans;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
After overcoming the stairs Dasha came to classes. She needed to write a password to begin her classes. The password is a string of length n which satisfies the following requirements:
* There is at least one digit in the string,
* There is at least one lowercase (small) letter of the Latin alphabet in the string,
* There is at least one of three listed symbols in the string: '#', '*', '&'.
<image>
Considering that these are programming classes it is not easy to write the password.
For each character of the password we have a fixed string of length m, on each of these n strings there is a pointer on some character. The i-th character displayed on the screen is the pointed character in the i-th string. Initially, all pointers are on characters with indexes 1 in the corresponding strings (all positions are numbered starting from one).
During one operation Dasha can move a pointer in one string one character to the left or to the right. Strings are cyclic, it means that when we move the pointer which is on the character with index 1 to the left, it moves to the character with the index m, and when we move it to the right from the position m it moves to the position 1.
You need to determine the minimum number of operations necessary to make the string displayed on the screen a valid password.
Input
The first line contains two integers n, m (3 ≤ n ≤ 50, 1 ≤ m ≤ 50) — the length of the password and the length of strings which are assigned to password symbols.
Each of the next n lines contains the string which is assigned to the i-th symbol of the password string. Its length is m, it consists of digits, lowercase English letters, and characters '#', '*' or '&'.
You have such input data that you can always get a valid password.
Output
Print one integer — the minimum number of operations which is necessary to make the string, which is displayed on the screen, a valid password.
Examples
Input
3 4
1**2
a3*0
c4**
Output
1
Input
5 5
#*&#*
*a1c&
&q2w*
#a3c#
*&#*&
Output
3
Note
In the first test it is necessary to move the pointer of the third string to one left to get the optimal answer.
<image>
In the second test one of possible algorithms will be:
* to move the pointer of the second symbol once to the right.
* to move the pointer of the third symbol twice to the right.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s[55];
long long cost[55][3];
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> s[i];
memset(cost, 0x0f0f, sizeof(cost));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (s[i][j] >= '0' && s[i][j] <= '9')
cost[i][0] = min(cost[i][0], min(j, m - j));
else if (s[i][j] >= 'a' && s[i][j] <= 'z')
cost[i][1] = min(cost[i][1], min(j, m - j));
else
cost[i][2] = min(cost[i][2], min(j, m - j));
}
}
long long ans = (long long)(1e18 + 1);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
for (long long k = 0; k < n; k++) {
if (i == j || j == k || i == k) continue;
ans = min(ans, cost[i][0] + cost[j][1] + cost[k][2]);
}
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dp[1502][26], DP[1502][26], tmp[1502][26], a[1502];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int n, i, j, k;
cin >> n;
string s;
cin >> s;
for (i = 1; i <= n; i++) {
a[i] = s[i - 1] - 'a';
}
for (i = 1; i <= n; i++) {
tmp[0][a[i]] = 1 + dp[0][a[i]];
for (j = 1; j <= i; j++) {
for (k = 0; k < 26; k++) {
if (a[i] == k) {
tmp[j][k] = dp[j][k] + 1;
} else {
tmp[j][k] = dp[j - 1][k] + 1;
}
DP[j][k] = max(DP[j][k], tmp[j][k]);
}
}
DP[0][a[i]] = max(DP[0][a[i]], tmp[0][a[i]]);
dp[0][a[i]] = tmp[0][a[i]];
tmp[0][a[i]] = 0;
for (k = 0; k < 26; k++) {
if (k != a[i]) dp[0][k] = 0;
}
for (j = 1; j <= i; j++) {
for (k = 0; k < 26; k++) {
dp[j][k] = tmp[j][k];
tmp[j][k] = 0;
}
}
}
for (j = 1; j <= n; j++) {
for (k = 0; k < 26; k++) {
DP[j][k] = max(DP[j - 1][k], DP[j][k]);
}
}
int q, m;
char ch;
cin >> q;
while (q--) {
cin >> m >> ch;
cout << DP[m][ch - 'a'] << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given an integer n. Check if n has an odd divisor, greater than one (does there exist such a number x (x > 1) that n is divisible by x and x is odd).
For example, if n=6, then there is x=3. If n=4, then such a number does not exist.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
Each test case contains one integer n (2 ≤ n ≤ 10^{14}).
Please note, that the input 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.
Output
For each test case, output on a separate line:
* "YES" if n has an odd divisor, greater than one;
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
6
2
3
4
5
998244353
1099511627776
Output
NO
YES
NO
YES
YES
NO
### Response
```cpp
/******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
while(n%2==0)
{
n/=2;
}
if(n>1)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.
<image>
Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.
For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.
Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.
Input
The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).
Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.
Output
For each query, print its answer in a single line.
Examples
Input
2 1 4
1 5 3
3 3 10
7 10 2
6 4 8
Output
4
-1
8
-1
Input
1 5 2
1 5 10
2 7 4
Output
1
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int a, b;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> a >> b >> n;
while (n--) {
long long int l, t, m;
cin >> l >> t >> m;
l--;
long long int lo = l - 1, hi = t + 2;
while (lo + 1 < hi) {
long long int mi = (lo + hi) / 2;
long long int sum = 2 * a + (l + mi) * b;
sum *= mi - l + 1;
sum /= 2;
long long int cost = max(a + b * mi, (sum + m - 1) / m);
if (cost <= t)
lo = mi;
else
hi = mi;
}
if (lo < l)
cout << -1 << endl;
else
cout << lo + 1 << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
There are K items placed on a grid of squares with R rows and C columns. Let (i, j) denote the square at the i-th row (1 \leq i \leq R) and the j-th column (1 \leq j \leq C). The i-th item is at (r_i, c_i) and has the value v_i.
Takahashi will begin at (1, 1), the start, and get to (R, C), the goal. When he is at (i, j), he can move to (i + 1, j) or (i, j + 1) (but cannot move to a non-existent square).
He can pick up items on the squares he visits, including the start and the goal, but at most three for each row. It is allowed to ignore the item on a square he visits.
Find the maximum possible sum of the values of items he picks up.
Constraints
* 1 \leq R, C \leq 3000
* 1 \leq K \leq \min(2 \times 10^5, R \times C)
* 1 \leq r_i \leq R
* 1 \leq c_i \leq C
* (r_i, c_i) \neq (r_j, c_j) (i \neq j)
* 1 \leq v_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
R C K
r_1 c_1 v_1
r_2 c_2 v_2
:
r_K c_K v_K
Output
Print the maximum possible sum of the values of items Takahashi picks up.
Examples
Input
2 2 3
1 1 3
2 1 4
1 2 5
Output
8
Input
2 5 5
1 1 3
2 4 20
1 2 1
1 3 4
1 4 2
Output
29
Input
4 5 10
2 5 12
1 5 12
2 3 15
1 2 20
1 1 28
2 4 26
3 2 27
4 5 21
3 5 10
1 3 10
Output
142
### Response
```cpp
#include<bits/stdc++.h>
#define int long long
using namespace std;
int A[3100][3100],B[3100][3100][5];
signed main(){
int H,W,K;
cin>>H>>W>>K;
for(int i=0;i<K;i++){
int x,y,c;
cin>>x>>y>>c;
A[x-1][y-1]=c;
}
for(int i=0;i<H;i++){
B[i+1][0][0]=max({B[i+1][0][0],B[i][0][0],B[i][0][1],B[i][0][2],B[i][0][3]});
if(A[i][0])B[i+1][0][1]=B[i+1][0][0]+A[i][0];
for(int j=1;j<W;j++){
for(int k=0;k<4;k++)B[i+1][j][k]=B[i+1][j-1][k];
B[i+1][j][0]=max(B[i+1][j][0],max({B[i][j][0],B[i][j][1],B[i][j][2],B[i][j][3]}));
if(A[i][j])B[i+1][j][1]=max(B[i+1][j][1],B[i+1][j][0]+A[i][j]);
for(int k=0;k<3;k++)
if(B[i+1][j-1][k])B[i+1][j][k+1]=max(B[i+1][j][k+1],B[i+1][j-1][k]+A[i][j]);
}
}
cout<<max({B[H][W-1][0],B[H][W-1][1],B[H][W-1][2],B[H][W-1][3]})<<endl;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Notes
Template in C
Constraints
2 ≤ the number of operands in the expression ≤ 100
1 ≤ the number of operators in the expression ≤ 99
-1 × 109 ≤ values in the stack ≤ 109
Input
An expression is given in a line. Two consequtive symbols (operand or operator) are separated by a space character.
You can assume that +, - and * are given as the operator and an operand is a positive integer less than 106
Output
Print the computational result in a line.
Examples
Input
1 2 +
Output
3
Input
1 2 + 3 4 - *
Output
-3
### Response
```cpp
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<cstdlib>
using namespace std;
stack <int> s1;
int main() {
char c[20];
while (cin >> c) {
if (c[0] != '+' && c[0] != '-' && c[0] != '*') s1.push(atoi(c));
else {
int x, y;
x = s1.top();
s1.pop();
y = s1.top();
s1.pop();
if (c[0] == '+') s1.push(x + y);
else if (c[0] == '-') s1.push(y - x);
else if (c[0] == '*') s1.push(y * x);
}
char a;
cin.get(a);
if (a == '\n') break;
}
cout << s1.top() << endl;
}
``` |
### Prompt
Generate 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<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
using namespace std;
const long long mod=998244353;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const double EPS=1e-6;
const double PI=acos(-1.0);
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
char in[210];
long long pw[210];
map<string,long long>dp;
int n;
long long calc(string v){
if(dp.count(v))return dp[v];
if(v.size()==0)return 1;
long long ret=calc(v.substr(1,v.size()-1))*(v[0]=='1'?2:1)%mod;
for(int i=1;i<=v.size();i++){
string kk=v.substr(0,i);
for(int j=i;j<v.size();j++){
if(v[j]=='0')kk[j%i]='0';
if((j+1)%i==0){
ret=(ret+calc(kk)*calc(v.substr(j+1,v.size()-j-1)))%mod;
}
}
}
return dp[v]=ret;
}
int main(){
scanf("%s",in);
n=strlen(in);
pw[0]=1;
for(int i=1;i<210;i++)pw[i]=pw[i-1]*d2%mod;
string st=in;
printf("%lld\n",calc(st));
}
``` |
### Prompt
Create a solution in CPP for the following problem:
As Gerald ..., in other words, on a New Year Eve Constantine prepared an unusual present for the Beautiful Lady. The present is the magic New Year snowflake that can make any dream come true.
The New Year snowflake consists of tiny ice crystals, which can be approximately regarded as points on the plane. The beauty of the New Year snowflake is that it has a center of symmetry. This is a point such that for each crystal of the snowflake exists another crystal, symmetrical to it relative to that point. One of the crystals can be placed directly in the center of symmetry.
While Constantine was choosing a snowflake among millions of other snowflakes, no less symmetrical and no less magical, then endured a difficult path through the drifts to the house of his mistress, while he was waiting with bated breath for a few long moments before the Beautiful Lady opens the door, some of the snowflake crystals melted and naturally disappeared. Constantine is sure that there were no more than k of such crystals, because he handled the snowflake very carefully. Now he is ready to demonstrate to the Beautiful Lady all the power of nanotechnology and restore the symmetry of snowflakes.
You are given the coordinates of the surviving snowflake crystals, given in nanometers. Your task is to identify all possible positions of the original center of symmetry.
Input
The first line contains two integers n and k (1 ≤ n ≤ 200 000, 0 ≤ k ≤ 10) — the number of the surviving snowflake crystals and the maximum number of melted crystals, correspondingly. Next n lines contain the coordinates of the crystals that are left in the following form: "xi yi". The coordinates are integers and do not exceed 5·108 in absolute value. All given points are different.
Output
The first line contains an integer c — the number of possible symmetry centers. Next c lines should contain the centers' descriptions. Each symmetry center is described by a couple of coordinates "x y", separated by a space. Print the coordinates with absolute error not exceeding 10 - 6. You are allowed to print the symmetry centers in any order. All printed points should be different. If there exist an infinite number of possible symmetry centers, print the single number "-1".
Examples
Input
4 0
0 0
0 1
1 0
1 1
Output
1
0.5 0.5
Input
4 2
0 0
0 1
1 0
1 1
Output
5
0.0 0.5
0.5 0.0
0.5 0.5
0.5 1.0
1.0 0.5
Input
4 4
0 0
0 1
1 0
1 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 300;
int n, k, l, r, lans;
bool ff;
struct points {
int x, y;
points() {}
points(int xx, int yy) { x = xx, y = yy; }
void read() { scanf("%d%d", &x, &y); }
void write() { printf("%.9lf %.9lf\n", x / 2.0, y / 2.0); }
} a[maxn], cen, ans[maxn];
bool operator<(points a, points b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
bool operator==(points a, points b) { return a.x == b.x && a.y == b.y; }
points operator+(points a, points b) { return points(a.x + b.x, a.y + b.y); }
int main() {
scanf("%d%d", &n, &k);
if (k >= n) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) a[i].read();
sort(a + 1, a + n + 1);
lans = 0;
for (int i = 0; i <= k; i++)
for (int j = 0; j <= k - i; j++) {
l = i + 1;
r = n - j;
cen = a[l] + a[r];
ff = 0;
for (int p = 1; p <= lans; p++)
if (ans[p] == cen) {
ff = 1;
break;
}
if (ff) continue;
l++;
r--;
points q;
int rest;
for (rest = k - i - j; rest >= 0 && l <= r;) {
q = a[l] + a[r];
if (q == cen)
l++, r--;
else {
rest--;
if (q < cen)
l++;
else
r--;
}
}
if (rest >= 0) ans[++lans] = cen;
}
printf("%d\n", lans);
for (int i = 1; i <= lans; i++) ans[i].write();
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Petya has recently learned data structure named "Binary heap".
The heap he is now operating with allows the following operations:
* put the given number into the heap;
* get the value of the minimum element in the heap;
* extract the minimum element from the heap;
Thus, at any moment of time the heap contains several integers (possibly none), some of them might be equal.
In order to better learn this data structure Petya took an empty heap and applied some operations above to it. Also, he carefully wrote down all the operations and their results to his event log, following the format:
* insert x — put the element with value x in the heap;
* getMin x — the value of the minimum element contained in the heap was equal to x;
* removeMin — the minimum element was extracted from the heap (only one instance, if there were many).
All the operations were correct, i.e. there was at least one element in the heap each time getMin or removeMin operations were applied.
While Petya was away for a lunch, his little brother Vova came to the room, took away some of the pages from Petya's log and used them to make paper boats.
Now Vova is worried, if he made Petya's sequence of operations inconsistent. For example, if one apply operations one-by-one in the order they are written in the event log, results of getMin operations might differ from the results recorded by Petya, and some of getMin or removeMin operations may be incorrect, as the heap is empty at the moment they are applied.
Now Vova wants to add some new operation records to the event log in order to make the resulting sequence of operations correct. That is, the result of each getMin operation is equal to the result in the record, and the heap is non-empty when getMin ad removeMin are applied. Vova wants to complete this as fast as possible, as the Petya may get back at any moment. He asks you to add the least possible number of operation records to the current log. Note that arbitrary number of operations may be added at the beginning, between any two other operations, or at the end of the log.
Input
The first line of the input contains the only integer n (1 ≤ n ≤ 100 000) — the number of the records left in Petya's journal.
Each of the following n lines describe the records in the current log in the order they are applied. Format described in the statement is used. All numbers in the input are integers not exceeding 109 by their absolute value.
Output
The first line of the output should contain a single integer m — the minimum possible number of records in the modified sequence of operations.
Next m lines should contain the corrected sequence of records following the format of the input (described in the statement), one per line and in the order they are applied. All the numbers in the output should be integers not exceeding 109 by their absolute value.
Note that the input sequence of operations must be the subsequence of the output sequence.
It's guaranteed that there exists the correct answer consisting of no more than 1 000 000 operations.
Examples
Input
2
insert 3
getMin 4
Output
4
insert 3
removeMin
insert 4
getMin 4
Input
4
insert 1
insert 1
removeMin
getMin 2
Output
6
insert 1
insert 1
removeMin
removeMin
insert 2
getMin 2
Note
In the first sample, after number 3 is inserted into the heap, the minimum number is 3. To make the result of the first getMin equal to 4 one should firstly remove number 3 from the heap and then add number 4 into the heap.
In the second sample case number 1 is inserted two times, so should be similarly removed twice.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long mexp(long long a, long long b) {
long long ans = 1;
a %= 1000000007;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
b >>= 1;
a = a * a % 1000000007;
}
return ans;
}
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string q;
long long x;
multiset<long long> s;
vector<pair<string, long long> > v;
for (long long i = 0; i < n; ++i) {
cin >> q;
if (q[0] == 'r') {
if ((long long)s.size() == 0) {
v.push_back(make_pair("insert", 1));
} else {
s.erase(s.begin());
}
v.push_back(make_pair("removeMin", 0));
} else {
cin >> x;
if (q[0] == 'i') {
s.insert(x);
v.push_back(make_pair("insert", x));
} else {
if (s.find(x) == s.end()) {
v.push_back(make_pair("insert", x));
s.insert(x);
}
auto it = s.lower_bound(x);
while (s.begin() != it) {
v.push_back(make_pair("removeMin", 0));
s.erase(s.begin());
}
v.push_back(make_pair("getMin", x));
}
}
}
cout << (long long)v.size() << '\n';
for (auto i : v) {
if (i.first[0] != 'r') {
cout << i.first << " " << i.second << '\n';
} else {
cout << i.first << '\n';
}
}
cerr << 1.0 / CLOCKS_PER_SEC << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Let's define p_i(n) as the following permutation: [i, 1, 2, ..., i - 1, i + 1, ..., n]. This means that the i-th permutation is almost identity (i.e. which maps every element to itself) permutation but the element i is on the first position. Examples:
* p_1(4) = [1, 2, 3, 4];
* p_2(4) = [2, 1, 3, 4];
* p_3(4) = [3, 1, 2, 4];
* p_4(4) = [4, 1, 2, 3].
You are given an array x_1, x_2, ..., x_m (1 ≤ x_i ≤ n).
Let pos(p, val) be the position of the element val in p. So, pos(p_1(4), 3) = 3, pos(p_2(4), 2) = 1, pos(p_4(4), 4) = 1.
Let's define a function f(p) = ∑_{i=1}^{m - 1} |pos(p, x_i) - pos(p, x_{i + 1})|, where |val| is the absolute value of val. This function means the sum of distances between adjacent elements of x in p.
Your task is to calculate f(p_1(n)), f(p_2(n)), ..., f(p_n(n)).
Input
The first line of the input contains two integers n and m (2 ≤ n, m ≤ 2 ⋅ 10^5) — the number of elements in each permutation and the number of elements in x.
The second line of the input contains m integers (m, not n) x_1, x_2, ..., x_m (1 ≤ x_i ≤ n), where x_i is the i-th element of x. Elements of x can repeat and appear in arbitrary order.
Output
Print n integers: f(p_1(n)), f(p_2(n)), ..., f(p_n(n)).
Examples
Input
4 4
1 2 3 4
Output
3 4 6 5
Input
5 5
2 1 5 3 5
Output
9 8 12 6 8
Input
2 10
1 2 1 1 2 2 2 2 2 2
Output
3 3
Note
Consider the first example:
x = [1, 2, 3, 4], so
* for the permutation p_1(4) = [1, 2, 3, 4] the answer is |1 - 2| + |2 - 3| + |3 - 4| = 3;
* for the permutation p_2(4) = [2, 1, 3, 4] the answer is |2 - 1| + |1 - 3| + |3 - 4| = 4;
* for the permutation p_3(4) = [3, 1, 2, 4] the answer is |2 - 3| + |3 - 1| + |1 - 4| = 6;
* for the permutation p_4(4) = [4, 1, 2, 3] the answer is |2 - 3| + |3 - 4| + |4 - 1| = 5.
Consider the second example:
x = [2, 1, 5, 3, 5], so
* for the permutation p_1(5) = [1, 2, 3, 4, 5] the answer is |2 - 1| + |1 - 5| + |5 - 3| + |3 - 5| = 9;
* for the permutation p_2(5) = [2, 1, 3, 4, 5] the answer is |1 - 2| + |2 - 5| + |5 - 3| + |3 - 5| = 8;
* for the permutation p_3(5) = [3, 1, 2, 4, 5] the answer is |3 - 2| + |2 - 5| + |5 - 1| + |1 - 5| = 12;
* for the permutation p_4(5) = [4, 1, 2, 3, 5] the answer is |3 - 2| + |2 - 5| + |5 - 4| + |4 - 5| = 6;
* for the permutation p_5(5) = [5, 1, 2, 3, 4] the answer is |3 - 2| + |2 - 1| + |1 - 4| + |4 - 1| = 8.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline constexpr int pos(int p, int xi) {
if (p == xi) {
return 1;
} else if (xi < p) {
return xi + 1;
} else {
return xi;
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int N, M;
cin >> N >> M;
vector<int> X(M);
vector<vector<int>> position_of(200005);
for (auto m = 0; m < M; m++) {
cin >> X[m];
position_of[X[m]].push_back(m);
}
int64_t perm_sum = 0;
for (auto i = 0; i < M - 1; i++) {
perm_sum += abs(pos(1, X[i]) - pos(1, X[i + 1]));
}
cout << perm_sum << ' ';
for (auto pi = 2; pi <= N; pi++) {
for (auto i : position_of[pi - 1]) {
if (i < M - 1) {
perm_sum -= abs(pos(pi - 1, X[i]) - pos(pi - 1, X[i + 1]));
perm_sum += abs(pos(pi, X[i]) - pos(pi, X[i + 1]));
}
if (i >= 1) {
perm_sum -= abs(pos(pi - 1, X[i - 1]) - pos(pi - 1, X[i]));
perm_sum += abs(pos(pi, X[i - 1]) - pos(pi, X[i]));
}
}
for (auto i : position_of[pi]) {
if (i < M - 1) {
perm_sum -= abs(pos(pi - 1, X[i]) - pos(pi - 1, X[i + 1]));
perm_sum += abs(pos(pi, X[i]) - pos(pi, X[i + 1]));
}
if (i >= 1) {
perm_sum -= abs(pos(pi - 1, X[i - 1]) - pos(pi - 1, X[i]));
perm_sum += abs(pos(pi, X[i - 1]) - pos(pi, X[i]));
}
}
cout << perm_sum << ' ';
}
cout << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Eudokimus, a system administrator is in trouble again. As a result of an error in some script, a list of names of very important files has been damaged. Since they were files in the BerFS file system, it is known that each file name has a form "name.ext", where:
* name is a string consisting of lowercase Latin letters, its length is from 1 to 8 characters;
* ext is a string consisting of lowercase Latin letters, its length is from 1 to 3 characters.
For example, "read.me", "example.txt" and "b.cpp" are valid file names and "version.info", "ntldr" and "contestdata.zip" are not.
Damage to the list meant that all the file names were recorded one after another, without any separators. So now Eudokimus has a single string.
Eudokimus needs to set everything right as soon as possible. He should divide the resulting string into parts so that each part would be a valid file name in BerFS. Since Eudokimus has already proved that he is not good at programming, help him. The resulting file list can contain the same file names.
Input
The input data consists of a single string s, its length is from 1 to 4·105 characters. The string can contain only lowercase Latin letters ('a' - 'z') and periods ('.').
Output
In the first line print "YES" (without the quotes), if it is possible to divide s into parts as required. In this case, the following lines should contain the parts of the required partition, one per line in the order in which they appear in s. The required partition can contain the same file names. If there are multiple solutions, print any of them.
If the solution does not exist, then print in a single line "NO" (without the quotes).
Examples
Input
read.meexample.txtb.cpp
Output
YES
read.m
eexample.t
xtb.cpp
Input
version.infontldrcontestdata.zip
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int d[400005], i, j, n = 0, m;
string s;
cin >> s;
for (i = 0; i < s.length(); i++) {
if (s[i] == '.') {
d[n] = i;
n++;
}
}
if (d[0] > 8 || d[0] == 0) {
cout << "NO";
return 0;
}
if (d[n - 1] < s.length() - 4 || d[n - 1] == s.length() - 1) {
cout << "NO";
return 0;
}
d[n] = 1000000007;
for (i = 1; i < n; i++) {
if (d[i] - d[i - 1] > 12 || d[i] - d[i - 1] < 3) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (i = 0, j = 0; i < s.length(); i++) {
cout << s[i];
if (s[i] == '.') {
if (j == n - 1) {
continue;
}
if (d[j + 1] - d[j] > 5) {
j++;
cout << s[i + 1] << s[i + 2] << s[i + 3] << "\n";
i = i + 3;
} else {
j++;
cout << s[i + 1] << "\n";
i++;
}
}
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
This is the first subtask of problem F. The only differences between this and the second subtask are the constraints on the value of m and the time limit. You need to solve both subtasks in order to hack this one.
There are n+1 distinct colours in the universe, numbered 0 through n. There is a strip of paper m centimetres long initially painted with colour 0.
Alice took a brush and painted the strip using the following process. For each i from 1 to n, in this order, she picks two integers 0 ≤ a_i < b_i ≤ m, such that the segment [a_i, b_i] is currently painted with a single colour, and repaints it with colour i.
Alice chose the segments in such a way that each centimetre is now painted in some colour other than 0. Formally, the segment [i-1, i] is painted with colour c_i (c_i ≠ 0). Every colour other than 0 is visible on the strip.
Count the number of different pairs of sequences \\{a_i\}_{i=1}^n, \\{b_i\}_{i=1}^n that result in this configuration.
Since this number may be large, output it modulo 998244353.
Input
The first line contains a two integers n, m (1 ≤ n ≤ 500, n = m) — the number of colours excluding the colour 0 and the length of the paper, respectively.
The second line contains m space separated integers c_1, c_2, …, c_m (1 ≤ c_i ≤ n) — the colour visible on the segment [i-1, i] after the process ends. It is guaranteed that for all j between 1 and n there is an index k such that c_k = j.
Note that since in this subtask n = m, this means that c is a permutation of integers 1 through n.
Output
Output a single integer — the number of ways Alice can perform the painting, modulo 998244353.
Examples
Input
3 3
1 2 3
Output
5
Input
7 7
4 5 1 6 2 3 7
Output
165
Note
In the first example, there are 5 ways, all depicted in the figure below. Here, 0 is white, 1 is red, 2 is green and 3 is blue.
<image>
Below is an example of a painting process that is not valid, as in the second step the segment 1 3 is not single colour, and thus may not be repainted with colour 2.
<image>
### Response
```cpp
#include <bits/stdc++.h>
const long long MOD = 998244353;
using pii = std::pair<long long, long long>;
using namespace std;
const long long maxn = 505;
int32_t n, m, c[maxn], pos[maxn], fi[maxn][maxn], dp[maxn][maxn];
long long solve(long long l, long long r) {
if (l > r) return 1;
if (dp[l][r] == -1) {
long long req = fi[l][r];
assert(req < n);
dp[l][r] = 0;
long long rp = 0;
for (long long j = r; j >= req; j--) {
rp += (solve(req + 1, j) * solve(j + 1, r)) % MOD;
rp %= MOD;
}
for (long long i = l; i <= req; i++) {
long long part = solve(l, i - 1);
part *= solve(i, req - 1);
part %= MOD;
part *= rp;
part %= MOD;
dp[l][r] += part;
dp[l][r] %= MOD;
}
}
return dp[l][r];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> c[i];
c[i]--;
pos[c[i]] = i;
}
for (long long i = 0; i < n; i++)
for (long long j = i; j < n; j++) {
dp[i][j] = -1;
fi[i][j] = n;
for (long long k = i; k <= j; k++) fi[i][j] = min(fi[i][j], c[k]);
fi[i][j] = pos[fi[i][j]];
}
cout << solve(0, n - 1) << "\n";
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
n players are going to play a rock-paper-scissors tournament. As you probably know, in a one-on-one match of rock-paper-scissors, two players choose their shapes independently. The outcome is then determined depending on the chosen shapes: "paper" beats "rock", "rock" beats "scissors", "scissors" beat "paper", and two equal shapes result in a draw.
At the start of the tournament all players will stand in a row, with their numbers increasing from 1 for the leftmost player, to n for the rightmost player. Each player has a pre-chosen shape that they will use in every game throughout the tournament. Here's how the tournament is conducted:
* If there is only one player left, he is declared the champion.
* Otherwise, two adjacent players in the row are chosen arbitrarily, and they play the next match. The losing player is eliminated from the tournament and leaves his place in the row (with his former neighbours becoming adjacent). If the game is a draw, the losing player is determined by a coin toss.
The organizers are informed about all players' favoured shapes. They wish to find out the total number of players who have a chance of becoming the tournament champion (that is, there is a suitable way to choose the order of the games and manipulate the coin tosses). However, some players are still optimizing their strategy, and can inform the organizers about their new shapes. Can you find the number of possible champions after each such request?
Input
The first line contains two integers n and q — the number of players and requests respectively (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ q ≤ 2 ⋅ 10^5).
The second line contains a string of n characters. The i-th of these characters is "R", "P", or "S" if the player i was going to play "rock", "paper", or "scissors" before all requests respectively.
The following q lines describe the requests. The j-th of these lines contain an integer p_j and a character c_j meaning that the player p_j is going to use the shape described by the character c_j from this moment (1 ≤ p_j ≤ n).
Output
Print q + 1 integers r_0, …, r_q, where r_k is the number of possible champions after processing k requests.
Example
Input
3 5
RPS
1 S
2 R
3 P
1 P
2 P
Output
2
2
1
2
2
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2E5 + 10, M = 3;
const int inf = 1 << 30;
long long read() {
long long a = 0;
char b = 1, c;
do
if ((c = getchar()) == 45) b = -1;
while (c < 48 || c > 57);
do a = (a << 3) + (a << 1) + (c & 15);
while ((c = getchar()) > 47 && c < 58);
return a * b;
}
void write(long long x, char c) {
if (x < 0) putchar(45), x = -x;
char a[20], s = 0;
do a[++s] = x % 10 | 48;
while (x /= 10);
do putchar(a[s]);
while (--s);
putchar(c);
}
char c[N], a[N], val[N];
int n, m, pos[N], ans[N], q[M][N];
bool b;
void push(char op, int x, int val) {
if (!x) return;
while (x <= n) {
q[op][x] += val;
x += x & -x;
}
}
int ask(int op) {
int res = 0;
for (int i = 1 << 18; i >>= 1;) {
int t = res + i;
if (t <= n && !q[op][t]) res = t;
}
return res + 1;
}
int sum(char op, int l, int r) {
int res = 0;
while (l) {
res -= q[op][l];
l -= l & -l;
}
--r;
while (r) {
res += q[op][r];
r -= r & -r;
}
return res;
}
void solve() {
memcpy(a + 1, c + 1, n);
for (int i = 1; i <= n; ++i) push(a[i], i, 1);
for (int i = 0; i <= m; ++i) {
push(a[pos[i]], pos[i], -1);
push(val[i], pos[i], 1);
a[pos[i]] = val[i];
for (int j = 0, k = 2; j < M; ++j, ++k %= M) {
int l = ask(j), r = ask(k);
if (l >= r) continue;
if (r <= n)
ans[i] += sum(j ^ k ^ M, l, r);
else if (b)
ans[i] += sum(j ^ k ^ M, 0, r);
}
}
}
int main() {
n = read(), m = read();
scanf("%s", c + 1);
for (int i = 1; i <= n; ++i) c[i] = c[i] - 79 >> 1;
for (int i = 1; i <= m; ++i) {
pos[i] = read();
do val[i] = getchar();
while (val[i] < 80 || val[i] > 83);
val[i] = val[i] - 79 >> 1;
}
solve();
reverse(c + 1, c + 1 + n);
for (int i = 1; i <= m; ++i) pos[i] = n + 1 - pos[i];
for (int i = 0; i < M; ++i) memset(q[i] + 1, 0, n << 2);
b = 1;
solve();
for (int i = 0; i <= m; ++i) write(n - ans[i], '\n');
}
``` |
### Prompt
Your challenge is to write 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 <cstdio>
#include <vector>
#include <algorithm>
std::vector<int> edges[100005];
int vs[100005];
int ds[100005];
int cs[100005];
int vis[100005];
int color[100005];
void paint(int V,int D,int C){
if(vis[V]>=D) return;
vis[V]=D;
if(!color[V]) color[V]=C;
for(int W:edges[V]){
paint(W,D-1,C);
}
}
int main(){
int N,M,Q;
scanf("%d %d",&N,&M);
for(int i=0;i<M;i++){
int A,B;
scanf("%d %d",&A,&B);
A--,B--;
edges[A].push_back(B);
edges[B].push_back(A);
}
std::fill(vis,vis+N,-1);
scanf("%d",&Q);
for(int i=0;i<Q;i++){
scanf("%d %d %d",&vs[i],&ds[i],&cs[i]);
vs[i]--;
}
for(int i=Q-1;i>=0;i--){
paint(vs[i],ds[i],cs[i]);
}
for(int i=0;i<N;i++){
printf("%d\n",color[i]);
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Bob loves everything sweet. His favorite chocolate bar consists of pieces, each piece may contain a nut. Bob wants to break the bar of chocolate into multiple pieces so that each part would contain exactly one nut and any break line goes between two adjacent pieces.
You are asked to calculate the number of ways he can do it. Two ways to break chocolate are considered distinct if one of them contains a break between some two adjacent pieces and the other one doesn't.
Please note, that if Bob doesn't make any breaks, all the bar will form one piece and it still has to have exactly one nut.
Input
The first line of the input contains integer n (1 ≤ n ≤ 100) — the number of pieces in the chocolate bar.
The second line contains n integers ai (0 ≤ ai ≤ 1), where 0 represents a piece without the nut and 1 stands for a piece with the nut.
Output
Print the number of ways to break the chocolate into multiple parts so that each part would contain exactly one nut.
Examples
Input
3
0 1 0
Output
1
Input
5
1 0 1 0 1
Output
4
Note
In the first sample there is exactly one nut, so the number of ways equals 1 — Bob shouldn't make any breaks.
In the second sample you can break the bar in four ways:
10|10|1
1|010|1
10|1|01
1|01|01
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
int n;
cin >> n;
int a[n];
int cnt = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int x = 0;
while (a[x] != 1) {
x++;
}
long long int ans = 0;
for (int i = x; i < n; i++) {
if (a[i] == 1) {
if (ans == 0) ans = 1;
ans = ans * cnt;
cnt = 1;
} else {
cnt++;
}
}
cout << ans << "\n";
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Johnny has just found the new, great tutorial: "How to become a grandmaster?". The tutorial tells many strange and unexpected for Johnny things, such as you have to be patient or that very important is solving many harder and harder problems.
The boy has found an online judge with tasks divided by topics they cover. He has picked p^{k_i} problems from i-th category (p is his favorite number). He wants to solve them in two weeks (the patience condition is too hard for Johnny, so for simplicity, he looks only at easy tasks, which can be solved in such a period). Now our future grandmaster has to decide which topics to cover first and which the second week. Help him assign topics in such a way, that workload is balanced.
Formally, given n numbers p^{k_i}, the boy wants to divide them into two disjoint sets, minimizing the absolute difference between sums of numbers in each set. Find the minimal absolute difference. Output the result modulo 10^{9}+7.
Input
Input consists of multiple test cases. The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Each test case is described as follows:
The first line contains two integers n and p (1 ≤ n, p ≤ 10^6). The second line contains n integers k_i (0 ≤ k_i ≤ 10^6).
The sum of n over all test cases doesn't exceed 10^6.
Output
Output one integer — the reminder of division the answer by 1 000 000 007.
Example
Input
4
5 2
2 3 4 4 3
3 1
2 10 1000
4 5
0 1 1 100
1 8
89
Output
4
1
146981438
747093407
Note
You have to minimize the difference, not it's remainder. For example, if the minimum difference is equal to 2, but there is also a distribution where the difference is 10^9 + 8, then the answer is 2, not 1.
In the first test case of the example, there're the following numbers: 4, 8, 16, 16, and 8. We can divide them into such two sets: {4, 8, 16} and {8, 16}. Then the difference between the sums of numbers in sets would be 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long n, p;
long long mod(long long x) {
x %= MOD;
if (x < 0) return x + MOD;
return x;
}
long long binpow(long long x, long long y) {
long long z = 1;
while (y) {
if (y & 1) z = z * x % MOD;
x = x * x % MOD;
y >>= 1;
}
return z;
}
long long divide(long long x, long long y) {
return x * binpow(y, MOD - 2) % MOD;
}
struct sweat {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
vector<long long> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
cin >> n >> p;
v.assign(n, 0);
for (auto &x : v) cin >> x;
if (p == 1) {
cout << n % 2 << '\n';
continue;
}
sort((v).begin(), (v).end());
unordered_map<int, int> a, b;
b.reserve(1024);
b.max_load_factor(0.25);
long long a_summe = 0, b_summe = 0;
for (int i = n - 1; i >= 0; i--) {
if (a.empty()) {
a[v[i]] = 1;
a_summe = binpow(p, v[i]);
} else {
int ind = v[i];
while (b[ind] == p - 1) {
b.erase(ind);
b_summe -= (p - 1) * binpow(p, ind) % MOD;
b_summe %= MOD;
ind++;
}
b[ind]++;
b_summe += binpow(p, ind);
b_summe %= MOD;
if (b.size() == 1 && b[ind] == 1 && a[ind] == 1) {
a_summe = 0;
b_summe = 0;
a.clear();
b.clear();
}
}
}
cout << mod(a_summe - b_summe) << '\n';
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Disclaimer: there are lots of untranslateable puns in the Russian version of the statement, so there is one more reason for you to learn Russian :)
Rick and Morty like to go to the ridge High Cry for crying loudly — there is an extraordinary echo. Recently they discovered an interesting acoustic characteristic of this ridge: if Rick and Morty begin crying simultaneously from different mountains, their cry would be heard between these mountains up to the height equal the bitwise OR of mountains they've climbed and all the mountains between them.
Bitwise OR is a binary operation which is determined the following way. Consider representation of numbers x and y in binary numeric system (probably with leading zeroes) x = xk... x1x0 and y = yk... y1y0. Then z = x | y is defined following way: z = zk... z1z0, where zi = 1, if xi = 1 or yi = 1, and zi = 0 otherwise. In the other words, digit of bitwise OR of two numbers equals zero if and only if digits at corresponding positions is both numbers equals zero. For example bitwise OR of numbers 10 = 10102 and 9 = 10012 equals 11 = 10112. In programming languages C/C++/Java/Python this operation is defined as «|», and in Pascal as «or».
Help Rick and Morty calculate the number of ways they can select two mountains in such a way that if they start crying from these mountains their cry will be heard above these mountains and all mountains between them. More formally you should find number of pairs l and r (1 ≤ l < r ≤ n) such that bitwise OR of heights of all mountains between l and r (inclusive) is larger than the height of any mountain at this interval.
Input
The first line contains integer n (1 ≤ n ≤ 200 000), the number of mountains in the ridge.
Second line contains n integers ai (0 ≤ ai ≤ 109), the heights of mountains in order they are located in the ridge.
Output
Print the only integer, the number of ways to choose two different mountains.
Examples
Input
5
3 2 1 6 5
Output
8
Input
4
3 3 3 3
Output
0
Note
In the first test case all the ways are pairs of mountains with the numbers (numbering from one):
(1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)
In the second test case there are no such pairs because for any pair of mountains the height of cry from them is 3, and this height is equal to the height of any mountain.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, y = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') y = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return y ? -x : x;
}
template <typename T>
inline T read() {
T x = 0;
int y = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') y = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return y ? -x : x;
}
int a[200005], f[200005][20], g[200005][20], lg[200005];
long long ans;
inline int Max(int x, int y) { return a[x] > a[y] ? x : y; }
void ST(int n) {
for (register int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
for (register int j = 1; j <= lg[n]; ++j)
for (register int i = 1; i + (1 << j - 1) <= n; ++i)
f[i][j] = f[i][j - 1] | f[i + (1 << j - 1)][j - 1],
g[i][j] = Max(g[i][j - 1], g[i + (1 << j - 1)][j - 1]);
}
inline int query1(int l, int r) {
int len = lg[r - l + 1];
return f[l][len] | f[r - (1 << len) + 1][len];
}
inline int query2(int l, int r) {
int len = lg[r - l + 1];
return Max(g[l][len], g[r - (1 << len) + 1][len]);
}
void solve(int l, int r) {
if (l >= r) {
if (l == r) ++ans;
return;
}
int pos = query2(l, r), L = l, R = pos, res, mid;
while (L < R) {
mid = L + R >> 1;
if ((query1(mid, pos) | a[pos]) == a[pos])
R = mid;
else
L = mid + 1;
}
res = pos - L + 1, L = pos, R = r;
while (L < R) {
mid = L + R + 1 >> 1;
if ((query1(pos, mid) | a[pos]) == a[pos])
L = mid;
else
R = mid - 1;
}
ans += 1ll * (L - pos + 1) * res;
solve(l, pos - 1), solve(pos + 1, r);
}
signed main() {
int n = read();
for (register int i = 1; i <= n; ++i) a[i] = f[i][0] = read(), g[i][0] = i;
ST(n), solve(1, n);
printf("%I64d\n", (1ll * n * (n + 1) >> 1) - ans);
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There are N boxes arranged in a row from left to right. The i-th box from the left contains A_i candies.
You will take out the candies from some consecutive boxes and distribute them evenly to M children.
Such being the case, find the number of the pairs (l, r) that satisfy the following:
* l and r are both integers and satisfy 1 \leq l \leq r \leq N.
* A_l + A_{l+1} + ... + A_r is a multiple of M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the number of the pairs (l, r) that satisfy the conditions.
Note that the number may not fit into a 32-bit integer type.
Examples
Input
3 2
4 1 5
Output
3
Input
13 17
29 7 5 7 9 51 7 13 8 55 42 9 81
Output
6
Input
10 400000000
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
25
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int n, m;
cin >> n >> m;
map<int, int> mp;
mp[0] = 1;
int sum = 0;
long long answer = 0;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
sum += x;
sum %= m;
answer += mp[sum];
++mp[sum];
}
cout << answer;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define M 1000000007
#define MM 998244353
#define pb push_back
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define memf(a) memset(a,false,sizeof(a))
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(a) (ll)a.size()
#define F first
#define S second
#define PI 3.1415926536
#define INF 2000000000000000000
#define endl "\n"
#define _time_ 1.0 * clock() / CLOCKS_PER_SEC
#define ll long long
#define gcd __gcd
#define int long long
#define rep(i,j,n) for(int i=j; i<n; i++)
// think opposite
// check boundary cases
void yes()
{
cout << "YES" << endl;
}
void no()
{
cout << "NO" << endl;
}
void solve()
{
int n;
cin >> n;
map<int, vector<int> >m;
for(int i=0;i<n;i++)
{
int x;
cin >> x;
m[x].pb(i);
}
int ans =0;
for(auto i=m.begin();i!=m.end();i++)
{
int pre = i->S[0]+1;
for(int j=1; j<i->S.size(); j++)
{
ans+= pre*(n-i->S[j]);
pre+= i->S[j]+1;
}
}
cout << ans << endl;
}
signed main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t = 1;
cin >> t;
while(t--)
{
solve();
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Takahashi has a water bottle with the shape of a rectangular prism whose base is a square of side a~\mathrm{cm} and whose height is b~\mathrm{cm}. (The thickness of the bottle can be ignored.)
We will pour x~\mathrm{cm}^3 of water into the bottle, and gradually tilt the bottle around one of the sides of the base.
When will the water be spilled? More formally, find the maximum angle in which we can tilt the bottle without spilling any water.
Constraints
* All values in input are integers.
* 1 \leq a \leq 100
* 1 \leq b \leq 100
* 1 \leq x \leq a^2b
Input
Input is given from Standard Input in the following format:
a b x
Output
Print the maximum angle in which we can tilt the bottle without spilling any water, in degrees. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
2 2 4
Output
45.0000000000
Input
12 21 10
Output
89.7834636934
Input
3 1 8
Output
4.2363947991
### Response
```cpp
#include <cstdio>
#include <cmath>
#include <algorithm>
long double pi = acosl(-1.0L);
int main() {
long double a, b, x;
scanf("%Lf %Lf %Lf", &a, &b, &x);
long double r;
if (x > a*a*b/2) {
r = atanl(2.0/a/a*(a*b-x/a));
} else {
r = pi/2 - atanl(2*x/a/b/b);
}
printf("%.20Lf\n", r*180.0/pi);
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
I decided to plant vegetables in the vegetable garden. There were n seeds, so I sown n seeds one by one a day over n days. All seeds sprout and grow quickly. I can't wait for the harvest time.
One day, when I was watering the seedlings as usual, I noticed something strange. There should be n vegetable seedlings, but one more. Weeds have grown. I want to pull it out immediately, but the trouble is that all the seedlings are very similar and I can't tell the difference between vegetables and weeds.
The clue is the growth rate of vegetables. This vegetable continues to grow for a fixed length of day after sowing. However, I don't know how many centimeters this "fixed length" is. I also forgot how many days ago I sown the first seed. The seedlings are lined up in a row, but the only thing I remember is that when I sowed the seeds, I planted one seed each day, starting from the right.
Create a program that inputs the length of n + 1 seedlings and outputs the length of weeds.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. The input is given in the following format.
n
h1 h2 h3 ... hn + 1
The first line n (4 ≤ n ≤ 100) is an integer representing the number of vegetable seedlings. The second line contains n + 1 integers separated by one space, and hi (1 ≤ hi ≤ 109) indicates the length of the i-th seedling from the left.
No input is given such that h1 h2 ... hn + 1 is an arithmetic progression.
The number of datasets does not exceed 500.
output
Outputs the length of weeds for each dataset.
Example
Input
5
1 2 3 6 4 5
6
1 3 6 9 12 15 18
4
5 7 9 11 12
0
Output
6
1
12
### Response
```cpp
#include<cstdio>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
bool is_arithmetic_progression(int n,const int *h){
int d=h[1]-h[0];
rep(i,n-1) if(h[i]+d!=h[i+1]) return false;
return true;
}
int main(){
for(int n;scanf("%d",&n),n;){
int h[101];
rep(i,n+1) scanf("%d",h+i);
rep(i,n+1){
int m=0,h2[100];
rep(j,n+1) if(j!=i) h2[m++]=h[j];
if(is_arithmetic_progression(m,h2)){ printf("%d\n",h[i]); break; }
}
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
There is a grid with R rows and C columns. We call the cell in the r-th row and c-th column (r，c).
Mr. Takahashi wrote non-negative integers into N of the cells, that is, he wrote a non-negative integer a_i into (r_i，c_i) for each i (1≤i≤N). After that he fell asleep.
Mr. Aoki found the grid and tries to surprise Mr. Takahashi by writing integers into all remaining cells. The grid must meet the following conditions to really surprise Mr. Takahashi.
* Condition 1: Each cell contains a non-negative integer.
* Condition 2: For any 2×2 square formed by cells on the grid, the sum of the top left and bottom right integers must always equal to the sum of the top right and bottom left integers.
Determine whether it is possible to meet those conditions by properly writing integers into all remaining cells.
Constraints
* 2≤R，C≤10^5
* 1≤N≤10^5
* 1≤r_i≤R
* 1≤c_i≤C
* (r_i，c_i) ≠ (r_j，c_j) (i≠j)
* a_i is an integer.
* 0≤a_i≤10^9
Input
The input is given from Standard Input in the following format:
R C
N
r_1 c_1 a_1
r_2 c_2 a_2
:
r_N c_N a_N
Output
Print `Yes` if it is possible to meet the conditions by properly writing integers into all remaining cells. Otherwise, print `No`.
Examples
Input
2 2
3
1 1 0
1 2 10
2 1 20
Output
Yes
Input
2 3
5
1 1 0
1 2 10
1 3 20
2 1 30
2 3 40
Output
No
Input
2 2
3
1 1 20
1 2 10
2 1 0
Output
No
Input
3 3
4
1 1 0
1 3 10
3 1 10
3 3 20
Output
Yes
Input
2 2
4
1 1 0
1 2 10
2 1 30
2 2 20
Output
No
### Response
```cpp
#include <bits/stdc++.h>
#define F first
#define S second
#define X real()
#define Y imag()
using namespace std;
typedef long long ll;
typedef long double ld;
vector<pair<int, ll> > g[202020];
int u[202020];
ll v[202020];
const int T=100010;
int f=0;
int i2=1;
void dfs(int x, int c, ll t){
if (f!=0) return;
//cout<<x<<" "<<t<<endl;
if (u[x]==i2){
if (v[x]>t){
if (c==2){
f=1;
}
else{
f=2;
}
}
else if(v[x]<t){
if (c==2){
f=2;
}
else{
f=1;
}
}
return;
}
u[x]=i2;
v[x]=t;
for (auto nx:g[x]){
ll nt=nx.S-t;
if (nt<0){
if (c==1){
f=2;//liian iso
}
else{
f=1;
}
return;
}
dfs(nx.F, 3-c, nt);
}
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int r,c;
cin>>r>>c;
int n;
cin>>n;
for (int i=0;i<n;i++){
int x,y,a;
cin>>x>>y>>a;
y+=T;
g[y].push_back({x, a});
g[x].push_back({y, a});
}
for (int i=1;i<=2*T;i++){
if ((int)g[i].size()>0&&u[i]==0){
ll mi=0;
ll ma=1e18;
int ok=0;
while (mi<=ma){
ll mid=(mi+ma)/2;
f=0;
i2++;
dfs(i, 1, mid);
if (f==0){
ok=1;
break;
}
if (f==1){
mi=mid+1;
}
else{
ma=mid-1;
}
}
if (!ok){
cout<<"No"<<endl;
return 0;
}
}
}
cout<<"Yes"<<endl;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Snuke has N dogs and M monkeys. He wants them to line up in a row.
As a Japanese saying goes, these dogs and monkeys are on bad terms. ("ken'en no naka", literally "the relationship of dogs and monkeys", means a relationship of mutual hatred.) Snuke is trying to reconsile them, by arranging the animals so that there are neither two adjacent dogs nor two adjacent monkeys.
How many such arrangements there are? Find the count modulo 10^9+7 (since animals cannot understand numbers larger than that). Here, dogs and monkeys are both distinguishable. Also, two arrangements that result from reversing each other are distinguished.
Constraints
* 1 ≤ N,M ≤ 10^5
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of possible arrangements, modulo 10^9+7.
Examples
Input
2 2
Output
8
Input
3 2
Output
12
Input
1 8
Output
0
Input
100000 100000
Output
530123477
### Response
```cpp
#include<cstdio>
#include<algorithm>
#define int long long
using namespace std;
int n,m,mod=1000000007;
int fac(int x)
{
int ans=1;
for(int i=2;i<=x;i++)ans=ans*i%mod;
return ans;
}
signed main()
{
scanf("%lld%lld",&n,&m);
if(n<m)swap(n,m);
if(n-m>1){puts("0");return 0;}
if(n==m)printf("%lld\n",2*fac(n)*fac(m)%mod);
else printf("%lld\n",fac(n)*fac(m)%mod);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Consider a table of size n × m, initially fully white. Rows are numbered 1 through n from top to bottom, columns 1 through m from left to right. Some square inside the table with odd side length was painted black. Find the center of this square.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 115) — the number of rows and the number of columns in the table.
The i-th of the next n lines contains a string of m characters s_{i1} s_{i2} … s_{im} (s_{ij} is 'W' for white cells and 'B' for black cells), describing the i-th row of the table.
Output
Output two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) separated by a space — the row and column numbers of the center of the black square.
Examples
Input
5 6
WWBBBW
WWBBBW
WWBBBW
WWWWWW
WWWWWW
Output
2 4
Input
3 3
WWW
BWW
WWW
Output
2 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long memo[1000000];
long long aa = 0;
void solve() {
cin >> n >> m;
int If, Jf, ie, je;
char arr[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; j++) cin >> arr[i][j];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == 'B') {
If = i;
Jf = j;
break;
}
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (arr[i][j] == 'B') {
ie = i;
je = j;
break;
}
}
}
cout << (If + ie + 2) / 2 << " " << (Jf + je + 2) / 2 << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
solve();
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
A palindrome is a string t which reads the same backward as forward (formally, t[i] = t[|t| + 1 - i] for all i ∈ [1, |t|]). Here |t| denotes the length of a string t. For example, the strings 010, 1001 and 0 are palindromes.
You have n binary strings s_1, s_2, ..., s_n (each s_i consists of zeroes and/or ones). You can swap any pair of characters any number of times (possibly, zero). Characters can be either from the same string or from different strings — there are no restrictions.
Formally, in one move you:
* choose four integer numbers x, a, y, b such that 1 ≤ x, y ≤ n and 1 ≤ a ≤ |s_x| and 1 ≤ b ≤ |s_y| (where x and y are string indices and a and b are positions in strings s_x and s_y respectively),
* swap (exchange) the characters s_x[a] and s_y[b].
What is the maximum number of strings you can make palindromic simultaneously?
Input
The first line contains single integer Q (1 ≤ Q ≤ 50) — the number of test cases.
The first line on each test case contains single integer n (1 ≤ n ≤ 50) — the number of binary strings you have.
Next n lines contains binary strings s_1, s_2, ..., s_n — one per line. It's guaranteed that 1 ≤ |s_i| ≤ 50 and all strings constist of zeroes and/or ones.
Output
Print Q integers — one per test case. The i-th integer should be the maximum number of palindromic strings you can achieve simultaneously performing zero or more swaps on strings from the i-th test case.
Example
Input
4
1
0
3
1110
100110
010101
2
11111
000001
2
001
11100111
Output
1
2
2
2
Note
In the first test case, s_1 is palindrome, so the answer is 1.
In the second test case you can't make all three strings palindromic at the same time, but you can make any pair of strings palindromic. For example, let's make s_1 = 0110, s_2 = 111111 and s_3 = 010000.
In the third test case we can make both strings palindromic. For example, s_1 = 11011 and s_2 = 100001.
In the last test case s_2 is palindrome and you can make s_1 palindrome, for example, by swapping s_1[2] and s_1[3].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<string> v;
int main() {
long long t, n, i, k;
string s;
cin >> t;
while (t--) {
scanf("%lld", &n);
long long odd = 0, evengood = 0, evenbad = 0, zero = 0;
k = n;
while (k--) {
zero = 0;
cin >> s;
if (s.size() % 2 == 1)
odd++;
else {
for (i = 0; i < s.size(); i++)
if (s[i] == '0') zero++;
if (zero % 2 == 0)
evengood++;
else
evenbad++;
}
}
if (odd) {
printf("%lld\n", n);
} else {
if (evenbad % 2 == 1)
cout << n - 1 << endl;
else
cout << n << endl;
}
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Little Petya likes to draw. He drew N red and M blue points on the plane in such a way that no three points lie on the same line. Now he wonders what is the number of distinct triangles with vertices in red points which do not contain any blue point inside.
Input
The first line contains two non-negative integer numbers N and M (0 ≤ N ≤ 500, 0 ≤ M ≤ 500) — the number of red and blue points respectively. The following N lines contain two integer numbers each — coordinates of red points. The following M lines contain two integer numbers each — coordinates of blue points. All coordinates do not exceed 109 by absolute value.
Output
Output one integer — the number of distinct triangles with vertices in red points which do not contain any blue point inside.
Examples
Input
4 1
0 0
10 0
10 10
5 4
2 1
Output
2
Input
5 5
5 10
6 1
8 6
-6 -7
7 -1
5 -1
10 -4
-10 -8
-10 5
-2 -8
Output
7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int N = 1e3 + 5;
int f[N][N];
struct node {
long long x, y;
} a[N], b[N];
bool cmp(node x, node y) { return x.y < y.y; }
long long area(node a, node b, node c) {
return a.x * b.y - a.y * b.x + b.x * c.y - b.y * c.x + c.x * a.y - c.y * a.x;
}
bool toleft(node a, node b, node c) {
if (c.y <= a.y || c.y > b.y) return 0;
return area(a, b, c) > 0;
}
int n, m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) scanf("%lld%lld", &a[i].x, &a[i].y);
for (int i = 1; i <= m; ++i) scanf("%lld%lld", &b[i].x, &b[i].y);
sort(a + 1, a + n + 1, cmp);
int ans = 0;
for (int i = 1; i < n; ++i)
for (int j = i + 1; j <= n; ++j)
for (int k = 1; k <= m; ++k)
if (toleft(a[i], a[j], b[k])) f[i][j]++;
for (int i = 1; i < n; ++i)
for (int j = i + 1; j < n; ++j)
for (int k = j + 1; k <= n; ++k)
if (f[i][j] + f[j][k] == f[i][k]) ans++;
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a string S as input. This represents a valid date in the year 2019 in the `yyyy/mm/dd` format. (For example, April 30, 2019 is represented as `2019/04/30`.)
Write a program that prints `Heisei` if the date represented by S is not later than April 30, 2019, and prints `TBD` otherwise.
Constraints
* S is a string that represents a valid date in the year 2019 in the `yyyy/mm/dd` format.
Input
Input is given from Standard Input in the following format:
S
Output
Print `Heisei` if the date represented by S is not later than April 30, 2019, and print `TBD` otherwise.
Examples
Input
2019/04/30
Output
Heisei
Input
2019/11/01
Output
TBD
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
if (S <= "2019/04/30")
puts("Heisei");
else
puts("TBD");
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Three poles stand evenly spaced along a line. Their heights are a, b and c meters, from left to right. We will call the arrangement of the poles beautiful if the tops of the poles lie on the same line, that is, b-a = c-b.
Determine whether the arrangement of the poles is beautiful.
Constraints
* 1 \leq a,b,c \leq 100
* a, b and c are integers.
Input
Input is given from Standard Input in the following format:
a b c
Output
Print `YES` if the arrangement of the poles is beautiful; print `NO` otherwise.
Examples
Input
2 4 6
Output
YES
Input
2 5 6
Output
NO
Input
3 2 1
Output
YES
### Response
```cpp
#include <cstdio>
int a, b, c;
int main(){
scanf("%d %d %d", &a, &b, &c);
if(b - a == c - b) printf("YES\n");
else printf("NO\n");
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Example
Input
4 4
0 0
6 0
6 6
0 6
Output
35.759506
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
struct P {
double x, y;
P() {
}
P(double _x, double _y) :
x(_x), y(_y) {
}
P operator+(const P&p) const {
return P(x + p.x, y + p.y);
}
P operator-(const P&p) const {
return P(x - p.x, y - p.y);
}
P operator*(double d) const {
return P(x * d, y * d);
}
P operator/(double d) const {
return P(x / d, y / d);
}
double det(const P&p) const {
return x * p.y - y * p.x;
}
double dot(const P&p) const {
return x * p.x + y * p.y;
}
double alpha() const {
return atan2(y, x);
}
P rot90() const {
return P(-y, x);
}
void read() {
scanf("%lf%lf", &x, &y);
}
void write() const {
printf("(%lf,%lf)", x, y);
}
double abs() {
return sqrt(abs2());
}
double abs2() {
return x * x + y * y;
}
P unit() {
return *this / abs();
}
};
#define cross(p1,p2,p3) ((p2.x-p1.x)*(p3.y-p1.y)-(p3.x-p1.x)*(p2.y-p1.y))
const double EPS = 1e-8; //you should change it according to problem, nevertheless, it mustn't be a constant value some times.
inline int sign(double a) {
return a < -EPS ? -1 : a > EPS;
}
#define crossOp(p1,p2,p3) (sign(cross(p1,p2,p3)))
P isSS(P p1, P p2, P q1, P q2) {
double a1 = cross(q1,q2,p1), a2 = -cross(q1,q2,p2);
return (p1 * a2 + p2 * a1) / (a1 + a2);
}
int n;
double x[12],y[12],r;
bool onLine(P p, P q, P x){
return (x-p).dot(x-q) <= EPS;
}
vector<P> isCS(P c,double r,P p, P q){
double d = cross(q,p,c) / (p-q).abs();
vector<P> ret;
if(d>=r+EPS)
return ret;
P dir = (q-p).rot90();
P pq = (p-q);
pq = pq/pq.abs();
dir = dir / dir.abs();
P mid = c + dir * d;
double h = sqrt(max(r*r-d*d,0.0));
if(onLine(p,q,mid + pq*h))
ret.push_back(mid + pq*h);
if(onLine(p,q,mid - pq*h))
ret.push_back(mid - pq*h);
return ret;
}
double rad(P p,P q){
return atan2(p.det(q),p.dot(q));
}
double calc(P p, P q){
bool inp = p.abs2() <= r*r;
bool inq = q.abs2() <= r*r;
if(inp && inq){
return p.det(q)/2;
}
if(inp && !inq){
return -calc(q,p);
}
vector<P> is = isCS(P(0,0),r,p,q);
if(!inp && inq){
P m = is[0];
return r*r*rad(p,m)/2 + m.det(q)/2;
}
if(!inp && !inq){
if(is.empty())
return r*r*rad(p,q)/2;
return r*r*(rad(p,is[0]) + rad(is[1],q))/2 + is[0].det(is[1])/2;
}
}
double calcArea(double cx,double cy){
P ps[12];
rep(i,n) ps[i].x=x[i]-cx,ps[i].y=y[i]-cy;
ps[n] = ps[0];
double area = 0;
rep(i,n){
P p=ps[i],q=ps[i+1];
area += calc(p,q);
}
//cout<<area<<endl;
return area;
}
double ffy(double x){
double l = 1e100,r=-1e100;
P ps[12];
rep(i,n) ps[i].x=::x[i], ps[i].y=y[i];
ps[n] = ps[0];
rep(i,n){
P p = ps[i], q = ps[i+1];
if(p.x > q.x)
swap(p,q);
if(p.x<=x+EPS && x<=q.x+EPS){
double iy;
if(p.y==q.y)
iy = p.y;
else
iy = p.y + (q.y - p.y) * (x-p.x) / (q.x-p.x);
l = min(l,iy);
r = max(r,iy);
}
}
rep(it,100){
double ll=(l*2+r)/3,rr=(l+r*2)/3;
if(calcArea(x,ll)>calcArea(x,rr))
r=rr;
else
l=ll;
}
return calcArea(x,l);
}
double ffx(){
double l=*min_element(x,x+n),r=*max_element(x,x+n);
rep(it,100){
double ll=(l*2+r)/3,rr=(l+r*2)/3;
if(ffy(ll)>ffy(rr))
r=rr;
else
l=ll;
}
return ffy(l);
}
int main(){
cin>>n>>r;
rep(i,n) cin>>x[i]>>y[i];
printf("%0.10lf\n",ffx());
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Nauuo is a girl who loves drawing circles.
One day she has drawn a circle and wanted to draw a tree on it.
The tree is a connected undirected graph consisting of n nodes and n-1 edges. The nodes are numbered from 1 to n.
Nauuo wants to draw a tree on the circle, the nodes of the tree should be in n distinct points on the circle, and the edges should be straight without crossing each other.
"Without crossing each other" means that every two edges have no common point or the only common point is an endpoint of both edges.
Nauuo wants to draw the tree using a permutation of n elements. A permutation of n elements is a sequence of integers p_1,p_2,…,p_n in which every integer from 1 to n appears exactly once.
After a permutation is chosen Nauuo draws the i-th node in the p_i-th point on the circle, then draws the edges connecting the nodes.
The tree is given, Nauuo wants to know how many permutations are there so that the tree drawn satisfies the rule (the edges are straight without crossing each other). She only wants to know the answer modulo 998244353, can you help her?
It is obvious that whether a permutation is valid or not does not depend on which n points on the circle are chosen.
Input
The first line contains a single integer n (2≤ n≤ 2⋅ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines contains two integers u and v (1≤ u,v≤ n), denoting there is an edge between u and v.
It is guaranteed that the given edges form a tree.
Output
The output contains a single integer — the number of permutations suitable to draw the given tree on a circle satisfying the rule, modulo 998244353.
Examples
Input
4
1 2
1 3
2 4
Output
16
Input
4
1 2
1 3
1 4
Output
24
Note
Example 1
All valid permutations and their spanning trees are as follows.
<image>
Here is an example of invalid permutation: the edges (1,3) and (2,4) are crossed.
<image>
Example 2
Every permutation leads to a valid tree, so the answer is 4! = 24.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void gmax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
inline void gmin(T &a, T b) {
a = a < b ? a : b;
}
const int mod = 998244353;
inline int mul(int x, int y) { return (long long)x * y % mod; }
const int MAXN = 200010;
int n, ans;
int du[MAXN];
int fac[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
du[x]++;
du[y]++;
}
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = mul(fac[i - 1], i);
ans = n;
for (int i = 1; i <= n; i++) ans = mul(ans, fac[du[i]]);
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Today Adilbek is taking his probability theory test. Unfortunately, when Adilbek arrived at the university, there had already been a long queue of students wanting to take the same test. Adilbek has estimated that he will be able to start the test only T seconds after coming.
Fortunately, Adilbek can spend time without revising any boring theorems or formulas. He has an app on this smartphone which contains n Japanese crosswords to solve. Adilbek has decided to solve them all one by one in the order they are listed in the app, without skipping any crossword. For each crossword, a number t_i is given that represents the time it takes an average crossword expert to solve this crossword (the time is given in seconds).
Adilbek is a true crossword expert, but, unfortunately, he is sometimes unlucky in choosing the way to solve the crossword. So, it takes him either t_i seconds or t_i + 1 seconds to solve the i-th crossword, equiprobably (with probability 1/2 he solves the crossword in exactly t_i seconds, and with probability 1/2 he has to spend an additional second to finish the crossword). All these events are independent.
After T seconds pass (or after solving the last crossword, if he manages to do it in less than T seconds), Adilbek closes the app (if he finishes some crossword at the same moment, that crossword is considered solved; otherwise Adilbek does not finish solving the current crossword at all). He thinks it would be an interesting probability theory problem to calculate E — the expected number of crosswords he will be able to solve completely. Can you calculate it?
Recall that the expected value of a discrete random variable is the probability-weighted average of all possible values — in this problem it means that the expected value of the number of solved crosswords can be calculated as E = ∑ _{i = 0}^{n} i p_i, where p_i is the probability that Adilbek will solve exactly i crosswords.
We can represent E as rational fraction P/Q with Q > 0. To give the answer, you should print P ⋅ Q^{-1} mod (10^9 + 7).
Input
The first line contains two integers n and T (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ T ≤ 2 ⋅ 10^{14}) — the number of crosswords and the time Adilbek has to spend, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 10^9), where t_i is the time it takes a crossword expert to solve the i-th crossword.
Note that Adilbek solves the crosswords in the order they are given in the input without skipping any of them.
Output
Print one integer — the expected value of the number of crosswords Adilbek solves in T seconds, expressed in the form of P ⋅ Q^{-1} mod (10^9 + 7).
Examples
Input
3 5
2 2 2
Output
750000007
Input
3 5
2 1 2
Output
125000003
Note
The answer for the first sample is equal to 14/8.
The answer for the second sample is equal to 17/8.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
namespace IO {
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
} // namespace IO
namespace Utility {
template <typename T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T>
T lcm(T a, T b) {
return (a / gcd(a, b) * b);
}
template <typename T>
inline T addmod(T a, T b, T mod) {
T c = a + b;
return c > mod ? c - mod : c;
}
template <typename T>
inline T submod(T a, T b, T mod) {
T c = a - b;
return c < mod ? c + mod : c;
}
template <typename T>
inline T mulmod(T a, T b, T mod) {
return a * 1LL * b % mod;
}
template <typename T>
T exEuclid(T a, T b, T &x, T &y) {
x = 0, y = 1;
if (a == 0) return b;
T x1, y1;
T d = exEuclid(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
template <typename T>
T modInv(T a, T mod) {
T x, y;
exEuclid(a, mod, x, y);
return x < 0 ? x + mod : x;
}
template <typename T>
T bigmod(T b, T p, T mod) {
T ret = b > 0;
while (p) {
if (p & 1) ret = mulmod(ret, b, mod);
p >>= 1, b = mulmod(b, b, mod);
}
return ret;
}
} // namespace Utility
using namespace IO;
using namespace Utility;
const int INF = 2000000009;
const int MX = 200005;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MOD = 1000000007;
int fac[MX], ifac[MX], inv[MX], pw[MX];
int ncr(int n, int r) {
if (r > n || r < 0) return 0;
return (int)(1LL * fac[n] * ifac[r] % MOD * ifac[n - r] % MOD);
}
int main() {
fac[0] = fac[1] = ifac[0] = ifac[1] = inv[0] = inv[1] = 1;
pw[0] = 1, pw[1] = 2;
for (int i = 2; i < MX; i++) {
fac[i] = 1LL * fac[i - 1] * i % MOD;
inv[i] = MOD - 1LL * inv[MOD % i] * (MOD / i) % MOD;
ifac[i] = 1LL * ifac[i - 1] * inv[i] % MOD;
pw[i] = pw[i - 1] * 2 % MOD;
}
int n = ({
int a;
read(a);
a;
});
long long T = ({
long long a;
read(a);
a;
}),
t = 0LL;
int sum = 0LL;
int k = 0, ways = 1;
for (int i = 1; i <= n; i++) {
t += ({
long long a;
read(a);
a;
});
if (t > T) break;
int cur_k = (int)min(1LL * i, T - t);
while (k > cur_k) {
ways = (ways - ncr(i - 1, k--));
if (ways < 0) ways += MOD;
}
while (k < cur_k) {
ways = (ways + ncr(i - 1, ++k)) % MOD;
}
ways = ways * 2 % MOD;
ways -= ncr(i - 1, k);
if (ways < 0) ways += MOD;
sum = (sum + 1LL * ways * pw[n - i] % MOD) % MOD;
}
int ans = 1LL * sum * modInv(pw[n], MOD) % MOD;
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
This contest is `CODE FESTIVAL`. However, Mr. Takahashi always writes it `CODEFESTIVAL`, omitting the single space between `CODE` and `FESTIVAL`.
So he has decided to make a program that puts the single space he omitted.
You are given a string s with 12 letters. Output the string putting a single space between the first 4 letters and last 8 letters in the string s.
Constraints
* s contains exactly 12 letters.
* All letters in s are uppercase English letters.
Input
The input is given from Standard Input in the following format:
s
Output
Print the string putting a single space between the first 4 letters and last 8 letters in the string s. Put a line break at the end.
Examples
Input
CODEFESTIVAL
Output
CODE FESTIVAL
Input
POSTGRADUATE
Output
POST GRADUATE
Input
ABCDEFGHIJKL
Output
ABCD EFGHIJKL
### Response
```cpp
#include<iostream>
#include<string>
using namespace std;
int main() {
string s;
cin >> s;
cout << s.substr(0, 4) << " " << s.substr(4, 100) << endl;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Let's define the Eulerian traversal of a tree (a connected undirected graph without cycles) as follows: consider a depth-first search algorithm which traverses vertices of the tree and enumerates them in the order of visiting (only the first visit of each vertex counts). This function starts from the vertex number 1 and then recursively runs from all vertices which are connected with an edge with the current vertex and are not yet visited in increasing numbers order. Formally, you can describe this function using the following pseudocode:
next_id = 1
id = array of length n filled with -1
visited = array of length n filled with false
function dfs(v):
visited[v] = true
id[v] = next_id
next_id += 1
for to in neighbors of v in increasing order:
if not visited[to]:
dfs(to)
You are given a weighted tree, the vertices of which were enumerated with integers from 1 to n using the algorithm described above.
A leaf is a vertex of the tree which is connected with only one other vertex. In the tree given to you, the vertex 1 is not a leaf. The distance between two vertices in the tree is the sum of weights of the edges on the simple path between them.
You have to answer q queries of the following type: given integers v, l and r, find the shortest distance from vertex v to one of the leaves with indices from l to r inclusive.
Input
The first line contains two integers n and q (3 ≤ n ≤ 500 000, 1 ≤ q ≤ 500 000) — the number of vertices in the tree and the number of queries, respectively.
The (i - 1)-th of the following n - 1 lines contains two integers p_i and w_i (1 ≤ p_i < i, 1 ≤ w_i ≤ 10^9), denoting an edge between vertices p_i and i with the weight w_i.
It's guaranteed that the given edges form a tree and the vertices are enumerated in the Eulerian traversal order and that the vertex with index 1 is not a leaf.
The next q lines describe the queries. Each of them contains three integers v_i, l_i, r_i (1 ≤ v_i ≤ n, 1 ≤ l_i ≤ r_i ≤ n), describing the parameters of the query. It is guaranteed that there is at least one leaf with index x such that l_i ≤ x ≤ r_i.
Output
Output q integers — the answers for the queries in the order they are given in the input.
Examples
Input
5 3
1 10
1 1
3 2
3 3
1 1 5
5 4 5
4 1 2
Output
3
0
13
Input
5 3
1 1000000000
2 1000000000
1 1000000000
1 1000000000
3 4 5
2 1 5
2 4 5
Output
3000000000
1000000000
2000000000
Input
11 8
1 7
2 1
1 20
1 2
5 6
6 2
6 3
5 1
9 10
9 11
5 1 11
1 1 4
9 4 8
6 1 4
9 7 11
9 10 11
8 1 11
11 4 5
Output
8
8
9
16
9
10
0
34
Note
In the first example, the tree looks like this:
<image>
In the first query, the nearest leaf for the vertex 1 is vertex 4 with distance 3. In the second query, the nearest leaf for vertex 5 is vertex 5 with distance 0. In the third query the nearest leaf for vertex 4 is vertex 4; however, it is not inside interval [1, 2] of the query. The only leaf in interval [1, 2] is vertex 2 with distance 13 from vertex 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll INF = numeric_limits<ll>::max() / 2;
constexpr int TREE_SIZE = 1 << 19;
ll tr[TREE_SIZE * 2] = {};
ll prop[TREE_SIZE * 2] = {};
void unroll(int p) {
if (p >= TREE_SIZE) {
prop[p] = 0;
return;
}
tr[p * 2] += prop[p];
tr[p * 2 + 1] += prop[p];
prop[p * 2] += prop[p];
prop[p * 2 + 1] += prop[p];
prop[p] = 0;
}
void inc(int l, int r, ll val, int p = 1, int ll = 0, int rr = TREE_SIZE) {
l = max(ll, l);
r = min(rr, r);
if (r <= l) {
return;
}
if (l == ll && r == rr) {
tr[p] += val;
prop[p] += val;
return;
}
unroll(p);
int mm = (ll + rr) / 2;
inc(l, r, val, p * 2, ll, mm);
inc(l, r, val, p * 2 + 1, mm, rr);
tr[p] = min(tr[p * 2], tr[p * 2 + 1]);
}
ll get(int l, int r, int p = 1, int ll = 0, int rr = TREE_SIZE) {
l = max(ll, l);
r = min(rr, r);
if (r <= l) {
return INF;
}
if (l == ll && r == rr) {
return tr[p];
}
unroll(p);
int mm = (ll + rr) / 2;
return min(get(l, r, p * 2, ll, mm), get(l, r, p * 2 + 1, mm, rr));
}
bool is_inner[TREE_SIZE] = {};
ll depth[TREE_SIZE] = {};
int parent[TREE_SIZE] = {};
int rightmost[TREE_SIZE] = {};
vector<vector<pair<int, ll>>> edges;
vector<vector<tuple<int, int, int>>> queries;
vector<ll> result;
void dfs(int p) {
for (const auto& q : queries[p]) {
int l, r, ind;
tie(ind, l, r) = q;
result[ind] = get(l, r) + depth[p];
}
for (const auto& e : edges[p]) {
inc(e.first, rightmost[e.first] + 1, -2 * e.second);
dfs(e.first);
inc(e.first, rightmost[e.first] + 1, 2 * e.second);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
edges.resize(n);
queries.resize(n);
for (int i = 1; i < n; ++i) {
int p;
ll w;
cin >> p >> w;
--p;
is_inner[p] = true;
depth[i] = depth[p] + w;
edges[p].push_back(make_pair(i, w));
parent[i] = p;
}
for (int i = n - 1; i >= 0; --i) {
rightmost[i] = max(i, rightmost[i]);
rightmost[parent[i]] = max(rightmost[parent[i]], rightmost[i]);
}
for (int i = 0; i < q; ++i) {
int v, l, r;
cin >> v >> l >> r;
--v;
--l;
--r;
queries[v].push_back(make_tuple(i, l, r + 1));
}
result.assign(q, -1);
inc(0, TREE_SIZE, INF);
for (int i = 0; i < n; i++) {
if (!is_inner[i]) {
inc(i, i + 1, depth[i] - INF);
}
}
dfs(0);
for (int i = 0; i < q; ++i) {
cout << result[i] << endl;
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
This is the easy version of the problem. The difference between the versions is in the constraints on the array elements. You can make hacks only if all versions of the problem are solved.
You are given an array [a_1, a_2, ..., a_n].
Your goal is to find the length of the longest subarray of this array such that the most frequent value in it is not unique. In other words, you are looking for a subarray such that if the most frequent value occurs f times in this subarray, then at least 2 different values should occur exactly f times.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ min(n, 100)) — elements of the array.
Output
You should output exactly one integer — the length of the longest subarray of the array whose most frequent value is not unique. If there is no such subarray, output 0.
Examples
Input
7
1 1 2 2 3 3 3
Output
6
Input
10
1 1 1 5 4 1 3 1 2 2
Output
7
Input
1
1
Output
0
Note
In the first sample, the subarray [1, 1, 2, 2, 3, 3] is good, but [1, 1, 2, 2, 3, 3, 3] isn't: in the latter there are 3 occurrences of number 3, and no other element appears 3 times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 0;
char c = getchar();
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return f ? -x : x;
}
inline int max(int a, int b, int c) { return max(a, max(b, c)); }
int n, a[200010], cnt[200010];
int f[2 * 200010], ans;
int main() {
cin >> n;
vector<int> pos[200010];
for (int i = 1; i <= n; ++i) a[i] = read(), ++cnt[a[i]];
int mx = 0, p = 0;
bool F = 0;
for (int i = 1; i <= 100; ++i)
if (cnt[i] > mx) mx = cnt[i], p = i;
for (int i = 1; i <= 100; ++i)
if (cnt[i] == mx && p != i) F = 1;
for (int i = 1; i <= 100; ++i) {
memset(f, -1, sizeof f);
f[200000] = 0;
int s = 0;
for (int j = 1; j <= n; ++j) {
if (a[j] == p)
--s;
else if (a[j] == i)
++s;
if (~f[s + 200000])
ans = max(ans, j - f[s + 200000]);
else
f[s + 200000] = j;
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Little Artem got n stones on his birthday and now wants to give some of them to Masha. He knows that Masha cares more about the fact of receiving the present, rather than the value of that present, so he wants to give her stones as many times as possible. However, Masha remembers the last present she received, so Artem can't give her the same number of stones twice in a row. For example, he can give her 3 stones, then 1 stone, then again 3 stones, but he can't give her 3 stones and then again 3 stones right after that.
How many times can Artem give presents to Masha?
Input
The only line of the input contains a single integer n (1 ≤ n ≤ 109) — number of stones Artem received on his birthday.
Output
Print the maximum possible number of times Artem can give presents to Masha.
Examples
Input
1
Output
1
Input
2
Output
1
Input
3
Output
2
Input
4
Output
3
Note
In the first sample, Artem can only give 1 stone to Masha.
In the second sample, Atrem can give Masha 1 or 2 stones, though he can't give her 1 stone two times.
In the third sample, Atrem can first give Masha 2 stones, a then 1 more stone.
In the fourth sample, Atrem can first give Masha 1 stone, then 2 stones, and finally 1 stone again.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n % 3 == 0)
cout << n / 3 * 2 << endl;
else
cout << n / 3 * 2 + 1 << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given two rectangles on a plane. The centers of both rectangles are located in the origin of coordinates (meaning the center of the rectangle's symmetry). The first rectangle's sides are parallel to the coordinate axes: the length of the side that is parallel to the Ox axis, equals w, the length of the side that is parallel to the Oy axis, equals h. The second rectangle can be obtained by rotating the first rectangle relative to the origin of coordinates by angle α.
<image>
Your task is to find the area of the region which belongs to both given rectangles. This region is shaded in the picture.
Input
The first line contains three integers w, h, α (1 ≤ w, h ≤ 106; 0 ≤ α ≤ 180). Angle α is given in degrees.
Output
In a single line print a real number — the area of the region which belongs to both given rectangles.
The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
1 1 45
Output
0.828427125
Input
6 4 30
Output
19.668384925
Note
The second sample has been drawn on the picture above.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int inf = 1 << 28;
double pi = acos(-1.0);
double PI = acos(-1.0);
int main() {
double w, h, alph;
cin >> w >> h >> alph;
if (w < h) swap(w, h);
if (alph > 90) alph = 180 - alph;
alph = alph / 180.0 * PI;
double x = (w * w + h * h) * 1.0 / (2 * w * 1.0);
double mya = asin(h * 1.0 / x);
double ans = 0;
if (alph >= mya) {
ans = h * h * 1.0 / sin(alph);
} else {
double n = (h * (1 + cos(alph)) - w * sin(alph)) /
((1 + cos(alph)) * (1 + cos(alph)) - sin(alph) * sin(alph));
double m = (h * sin(alph) - w * (1 + cos(alph))) /
(sin(alph) * sin(alph) - (1 + cos(alph)) * (1 + cos(alph)));
ans = w * h - (m * m + n * n) * sin(alph) * cos(alph);
}
printf("%.16lf\n", ans);
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
A string is binary, if it consists only of characters "0" and "1".
String v is a substring of string w if it has a non-zero length and can be read starting from some position in string w. For example, string "010" has six substrings: "0", "1", "0", "01", "10", "010". Two substrings are considered different if their positions of occurrence are different. So, if some string occurs multiple times, we should consider it the number of times it occurs.
You are given a binary string s. Your task is to find the number of its substrings, containing exactly k characters "1".
Input
The first line contains the single integer k (0 ≤ k ≤ 106). The second line contains a non-empty binary string s. The length of s does not exceed 106 characters.
Output
Print the single number — the number of substrings of the given string, containing exactly k characters "1".
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
1
1010
Output
6
Input
2
01010
Output
4
Input
100
01010
Output
0
Note
In the first sample the sought substrings are: "1", "1", "10", "01", "10", "010".
In the second sample the sought substrings are: "101", "0101", "1010", "01010".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void adskiy_razgon() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
long long nod(long long a, long long b) {
if (b > a) {
swap(a, b);
}
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
long long nok(long long a, long long b) { return a * b / nod(a, b); }
void sp(long long a, double b) { cout << fixed << setprecision(a) << b; }
long long binpow(long long a, long long n) {
if (n == 0) {
return 1;
}
if (n % 2 == 1) {
return binpow(a, n - 1) * a;
} else {
long long b = binpow(a, n / 2);
return b * b;
}
}
template <class A>
void read(vector<A>& v);
template <class A, size_t S>
void read(array<A, S>& a);
template <class T>
void read(T& x) {
cin >> x;
}
void read(double& d) {
string t;
read(t);
d = stod(t);
}
void read(long double& d) {
string t;
read(t);
d = stold(t);
}
template <class H, class... T>
void read(H& h, T&... t) {
read(h);
read(t...);
}
template <class A>
void read(vector<A>& x) {
for (auto& a : x) read(a);
}
template <class A, size_t S>
void read(array<A, S>& x) {
for (auto& a : x) read(a);
}
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return b ? "true" : "false"; }
string to_string(const char* s) { return string(s); }
string to_string(string s) { return s; }
string to_string(vector<bool> v) {
string res;
for (int i = (0); (1) > 0 ? i < ((int)(v).size()) : i > ((int)(v).size());
i += (1))
res += char('0' + v[i]);
return res;
}
template <size_t S>
string to_string(bitset<S> b) {
string res;
for (int i = (0); (1) > 0 ? i < (S) : i > (S); i += (1))
res += char('0' + b[i]);
return res;
}
template <class T>
string to_string(T v) {
bool f = 1;
string res;
for (auto& x : v) {
if (!f) res += ' ';
f = 0;
res += to_string(x);
}
return res;
}
template <class A>
void write(A x) {
cout << to_string(x);
}
template <class H, class... T>
void write(const H& h, const T&... t) {
write(h);
write(t...);
}
void print() { write("\n"); }
template <class H, class... T>
void print(const H& h, const T&... t) {
write(h);
if (sizeof...(t)) write(' ');
print(t...);
}
void yes(bool ok) { print((ok ? "YES" : "Yes")); }
void no(bool ok) { print((ok ? "NO" : "No")); }
long long cnt[1000000];
void solve() {
long long n;
read(n);
string s;
read(s);
cnt[0] = 1;
long long sum = 0, ans = 0;
for (int i = (0); (1) > 0 ? i < ((int)(s).size()) : i > ((int)(s).size());
i += (1)) {
if (s[i] == '1') sum++;
if (sum >= n) {
ans += cnt[sum - n];
}
cnt[sum]++;
}
print(ans);
}
int main() {
adskiy_razgon();
long long t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
There is a robot on a checkered field that is endless in all directions. Initially, the robot is located in the cell with coordinates (0, 0). He will execute commands which are described by a string of capital Latin letters 'L', 'R', 'D', 'U'. When a command is executed, the robot simply moves in the corresponding direction:
* 'L': one cell to the left (the x-coordinate of the current cell decreases by 1);
* 'R': one cell to the right (the x-coordinate of the current cell is increased by 1);
* 'D': one cell down (the y-coordinate of the current cell decreases by 1);
* 'U': one cell up (the y-coordinate of the current cell is increased by 1).
Your task is to put an obstacle in one cell of the field so that after executing the commands, the robot will return to the original cell of its path (0, 0). Of course, an obstacle cannot be placed in the starting cell (0, 0). It is guaranteed that if the obstacle is not placed, then the robot will not return to the starting cell.
An obstacle affects the movement of the robot in the following way: if it tries to go in a certain direction, and there is an obstacle, then it simply remains in place (the obstacle also remains, that is, it does not disappear).
Find any such cell of the field (other than (0, 0)) that if you put an obstacle there, the robot will return to the cell (0, 0) after the execution of all commands. If there is no solution, then report it.
Input
The first line contains one integer t (1 ≤ t ≤ 500) — the number of test cases.
Each test case consists of a single line containing s — the sequence of commands, which are uppercase Latin letters 'L', 'R', 'D', 'U' only. The length of s is between 1 and 5000, inclusive. Additional constraint on s: executing this sequence of commands leads the robot to some cell other than (0, 0), if there are no obstacles.
The sum of lengths of all s in a test doesn't exceed 5000.
Output
For each test case print a single line:
* if there is a solution, print two integers x and y (-10^9 ≤ x,y ≤ 10^9) such that an obstacle in (x, y) will force the robot to return back to the cell (0, 0);
* otherwise, print two zeroes (i. e. 0 0).
If there are multiple answers, you can print any of them.
Example
Input
4
L
RUUDL
LLUU
DDDUUUUU
Output
-1 0
1 2
0 0
0 1
### Response
```cpp
//****************************Template Begins****************************//
// Header Files
#include<iostream>
#include<algorithm>
#include<vector>
#include<utility>
#include<set>
#include<list>
#include<iterator>
#include<deque>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<stdio.h>
#include<complex>
#include<math.h>
#include<string>
// Header Files End
using namespace std;
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define endl "\n"
#define lb lower_bound
#define ub upper_bound
#define fo(i,a,b) for(i=a;i<=b;i++)
#define all(v) (v).begin(),(v).end()
#define sort0(v) sort(all(v))
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> pll;
#define max3(a,b,c) max(max((a),(b)),(c))
#define max4(a,b,c,d) max(max((a),(b)),max((c),(d)))
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define inf 9999999999999
const ll mod=1e9+7;
ll inv(ll i){if(i==1) return 1;return (mod-((mod/i)*inv(mod%i))%mod)%mod;}
ll gcd(ll a,ll b){ if (b==0) return a;return gcd(b,a%b);}
ll pwr(ll a, ll b) {a %= mod; ll res = 1;while (b > 0) {if (b & 1) res = res * a % mod; a = a * a % mod; b >>= 1;}return res;}
//****************************Template Ends*******************************//
int main() {
fio;
ll t,n,i,j,ans,temp,sum,x,y,xf,yf,x1,y1,a1,a2;
cin>>t;
string s;
while(t--)
{
ans=temp=sum=x=y=a1=a2=0;
cin>>s;
n=s.size();
fo(i,0,n-1)
{
x1=0;
y1=0;
if(s[i]=='U')y++;
else if(s[i]=='R')x++;
else if(s[i]=='L')x--;
else if(s[i]=='D')y--;
fo(j,0,n-1)
{
if(s[j]=='U' and !(x1==x and y1+1 == y))y1++;
else if(s[j]=='D' and !(x1==x and y1-1==y))y1--;
else if(s[j]=='R' and !(y1==y and x1+1 == x))x1++;
else if(s[j]=='L' and !(y1==y and x1-1 == x))x1--;
}
if(x1==0 and y1==0)
{
a1=x;
a2=y;
break;
}
}
cout<<a1<<" "<<a2<<"\n";
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Yui Hirasawa, who attends private Sakuragaoka Girls' High School, has to make a career hope by the day after tomorrow, but the trouble is that she hasn't decided anything yet. When I consulted with my friend Wa, I knew that my first choice was K University, so I consulted with my career guidance teacher to see if I could join K University.
As a career guidance teacher who was consulted, you decided to refer to Yui's final exam results in order to predict whether Yui would be able to enter K University. However, Yui's grades are greatly affected by whether or not he wins the exam, so he decided to check the best and worst scores of the final exams in the past. The data of the past final exams only remained for each score of the five subjects, and the total score of the exam did not remain. Therefore, your job is to write a program that takes the score data of each exam as input and outputs the score of the best time and the score of the worst time in the past final exams.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
n
s11 s12 s13 s14 s15
...
sn1 sn2 sn3 sn4 sn5
n is the number of tests taken so far. The number of tests is 1 or more and 100 or less. The next n lines are given scores for 5 subjects in each exam. The range of points is an integer between 0 and 100.
Output
Output the highest and lowest points in one line. Separate the highest and lowest points with a single space and do not include any other characters.
Examples
Input
3
49 50 87 78 41
27 61 100 45 84
28 88 40 95 66
2
100 100 100 100 100
0 0 0 0 0
1
89 90 85 93 82
0
Output
317 305
500 0
439 439
Input
3
49 50 87 78 41
27 61 100 45 84
28 88 40 95 66
Output
317 305
Input
2
100 100 100 100 100
0 0 0 0 0
Output
500 0
Input
1
89 90 85 93 82
Output
439 439
### Response
```cpp
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
using namespace std;
int main(){
int n,maximum,minimum,sum,a,b,c,d,e;
while(true){
scanf("%d",&n);
if(n == 0)break;
maximum = -1;
minimum = 1000000000;
for(int loop = 0; loop < n; loop++){
scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);
sum = a + b + c + d + e;
maximum = max(maximum,sum);
minimum = min(minimum,sum);
}
printf("%d %d\n",maximum,minimum);
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
The Professor has lost his home robot yet again. After some thinking Professor understood that he had left the robot in the basement.
The basement in Professor's house is represented by a rectangle n × m, split into 1 × 1 squares. Some squares are walls which are impassable; other squares are passable. You can get from any passable square to any other passable square moving through edge-adjacent passable squares. One passable square is the exit from the basement. The robot is placed exactly in one passable square. Also the robot may be placed in the exit square.
Professor is scared of going to the dark basement looking for the robot at night. However, he has a basement plan and the robot's remote control. Using the remote, Professor can send signals to the robot to shift one square left, right, up or down. When the robot receives a signal, it moves in the required direction if the robot's neighboring square in the given direction is passable. Otherwise, the robot stays idle.
Professor wrote a sequence of k commands on a piece of paper. He thinks that the sequence can lead the robot out of the basement, wherever it's initial position might be. Professor programmed another robot to press the required buttons on the remote according to the notes on the piece of paper. Professor was just about to run the program and go to bed, when he had an epiphany.
Executing each command takes some energy and Professor doesn't want to get huge electricity bill at the end of the month. That's why he wants to find in the sequence he has written out the minimal possible prefix that would guarantee to lead the robot out to the exit after the prefix is fulfilled. And that's the problem Professor challenges you with at this late hour.
Input
The first line contains three integers n, m and k (3 ≤ n, m ≤ 150, 1 ≤ k ≤ 105). Next n lines contain m characters each — that is the Professor's basement's description: "#" stands for a wall, "." stands for a passable square and "E" stands for the exit from the basement (this square also is passable). It is possible to get from each passable square to the exit, all squares located by the n × m rectangle's perimeter are the walls. Exactly one square is the exit from the basement. The last line contains k characters, the description of the sequence of commands that Professor has written out on a piece of paper. "L", "R", "U", "D" stand for commands left, right, up and down correspondingly.
Output
Print in the output file the length of the smallest possible prefix that will lead the robot to the exit square. In other words, wherever the robot had been positioned initially, it should be positioned in the exit square after all the commands from the prefix are fulfilled (during doing commands the robot can come and leave the exit square, but only the last position of the robot is interesting for us). If Professor is mistaken and no prefix (including the whole sequence) can bring the robot to the exit, print "-1" (without the quotes). If there is the only passable square and it is the exit, print "0" (without the quotes).
Examples
Input
5 5 7
#####
#...#
#...#
#E..#
#####
UULLDDR
Output
6
Input
5 5 7
#####
#.#.#
#...#
#E..#
#####
UULLDDR
Output
-1
Input
5 3 2
###
#.#
#.#
#E#
###
DD
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
string st;
int main() {
int i, j;
bitset<23005> a, b, c, e;
cin >> n >> m >> k;
for (i = 0; i < n; i = i + 1) {
cin >> st;
for (j = 0; j < m; j = j + 1) {
if (st[j] == '#')
b.set(i * m + j);
else
a.set(i * m + j);
if (st[j] == 'E') e.set(i * m + j);
}
}
cin >> st;
c = a;
for (i = 0; i < k; i = i + 1) {
if (c == e) {
cout << i << endl;
return 0;
}
if (st[i] == 'U') c = ((c >> m) & a) | (c & (b << m));
if (st[i] == 'D') c = ((c << m) & a) | (c & (b >> m));
if (st[i] == 'L') c = ((c >> 1) & a) | (c & (b << 1));
if (st[i] == 'R') c = ((c << 1) & a) | (c & (b >> 1));
}
if (c == e)
cout << i << endl;
else
cout << -1 << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a1 = 0, a2 = 0, a3 = 0;
for (int i = 0; i < s.length(); i += 2) {
if (s[i] == '1')
a1++;
else if (s[i] == '2')
a2++;
else
a3++;
}
if (a1 > 0) {
cout << 1;
for (int i = 1; i < a1; i++) {
cout << "+" << 1;
}
}
if (a1 == 0 && a2 > 0) {
cout << 2;
for (int i = 1; i < a2; i++) {
cout << "+" << 2;
}
} else {
for (int i = 0; i < a2; i++) {
cout << "+" << 2;
}
}
if (a1 == 0 && a2 == 0 && a3 > 0) {
cout << 3;
a3--;
}
for (int i = 0; i < a3; i++) {
cout << "+" << 3;
}
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer.
In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario.
<image>
Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins.
Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game.
Input
The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game.
The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set.
The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set
1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2.
Output
In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Examples
Input
5
2 3 2
3 1 2 3
Output
Lose Win Win Loop
Loop Win Win Win
Input
8
4 6 2 3 4
2 3 6
Output
Win Win Win Win Win Win Win
Lose Win Lose Lose Win Lose Lose
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int win[7005][2], od[7005][2];
queue<pair<int, int> > que;
vector<int> step[2];
char outp[3][20] = {
"Lose",
"Loop",
"Win",
};
int main() {
int n, i, j, other;
pair<int, int> now;
scanf("%d", &n);
for (i = 0; i < 2; ++i) {
int t, tmp;
scanf("%d", &t);
while (t--) {
scanf("%d", &tmp);
step[i].push_back(tmp);
}
}
win[0][0] = win[0][1] = -1;
que.push(make_pair(0, 1));
que.push(make_pair(0, 0));
while (!que.empty()) {
now = que.front();
que.pop();
other = now.second ^ 1;
if (win[now.first][now.second] == -1) {
for (i = 0; i < step[other].size(); ++i) {
if (win[(now.first - step[other][i] + n) % n][other] != 0) continue;
win[(now.first - step[other][i] + n) % n][other] = 1;
que.push(make_pair((now.first - step[other][i] + n) % n, other));
}
}
if (win[now.first][now.second] == 1) {
for (i = 0; i < step[other].size(); ++i) {
if (win[(now.first - step[other][i] + n) % n][other] != 0) continue;
od[(now.first - step[other][i] + n) % n][other]++;
if (od[(now.first - step[other][i] + n) % n][other] ==
step[other].size()) {
win[(now.first - step[other][i] + n) % n][other] = -1;
que.push(make_pair((now.first - step[other][i] + n) % n, other));
}
}
}
}
for (i = 1; i < n; ++i) {
printf("%s ", outp[win[i][0] + 1]);
}
puts("");
for (i = 1; i < n; ++i) {
printf("%s ", outp[win[i][1] + 1]);
}
puts("");
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Vus the Cossack has n real numbers a_i. It is known that the sum of all numbers is equal to 0. He wants to choose a sequence b the size of which is n such that the sum of all numbers is 0 and each b_i is either ⌊ a_i ⌋ or ⌈ a_i ⌉. In other words, b_i equals a_i rounded up or down. It is not necessary to round to the nearest integer.
For example, if a = [4.58413, 1.22491, -2.10517, -3.70387], then b can be equal, for example, to [4, 2, -2, -4].
Note that if a_i is an integer, then there is no difference between ⌊ a_i ⌋ and ⌈ a_i ⌉, b_i will always be equal to a_i.
Help Vus the Cossack find such sequence!
Input
The first line contains one integer n (1 ≤ n ≤ 10^5) — the number of numbers.
Each of the next n lines contains one real number a_i (|a_i| < 10^5). It is guaranteed that each a_i has exactly 5 digits after the decimal point. It is guaranteed that the sum of all the numbers is equal to 0.
Output
In each of the next n lines, print one integer b_i. For each i, |a_i-b_i|<1 must be met.
If there are multiple answers, print any.
Examples
Input
4
4.58413
1.22491
-2.10517
-3.70387
Output
4
2
-2
-4
Input
5
-6.32509
3.30066
-0.93878
2.00000
1.96321
Output
-6
3
-1
2
2
Note
The first example is explained in the legend.
In the second example, we can round the first and fifth numbers up, and the second and third numbers down. We can round the fourth number neither up, nor down.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename T>
istream& operator>>(istream& in, pair<T, T>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, pair<T, T> p) {
out << p.first << " " << p.second;
return out;
}
vector<double> arr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
long long sum = 0;
cin >> n;
arr.resize(n);
for (auto& it : arr) {
cin >> it;
sum += floor(it);
}
for (auto it : arr) {
if (it == (int)it) {
if ((int)it == 0)
cout << 0 << '\n';
else
cout << (int)it << '\n';
} else if (sum < 0) {
if (ceil(it) == 0)
cout << 0 << '\n';
else
cout << ceil(it) << '\n';
sum++;
} else {
if (floor(it) == 0)
cout << 0 << '\n';
else
cout << floor(it) << '\n';
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
### Response
```cpp
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define loop(i,x,n) for(int i=x;i<n;i++)
#define pb push_back
#define mp make_pair
#define fir first
#define sec second
#define int long long
using namespace std;
const int MOD=1000000007;
const int INF=1000000009;
signed main(){
int n,m,r;
cin>>n>>m>>r;
int g[300][300];
vector<int> path(r);
rep(i,r){
cin>>path[i];
path[i]--;
}
rep(i,n)rep(j,n)g[i][j]=(i==j?0:INF);
rep(i,m){
int a,b,c;
cin>>a>>b>>c;
a--;b--;
if(g[a][b]>c)g[a][b]=g[b][a]=c;
}
rep(k,n)rep(i,n)rep(j,n)g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
int ans=INF;
sort(path.begin(),path.end());
do{
int tmp=0;
rep(i,r-1) tmp+=g[path[i]][path[i+1]];
ans=min(ans,tmp);
}while( next_permutation(path.begin(),path.end()) );
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Amr loves Geometry. One day he came up with a very interesting problem.
Amr has a circle of radius r and center in point (x, y). He wants the circle center to be in new position (x', y').
In one step Amr can put a pin to the border of the circle in a certain point, then rotate the circle around that pin by any angle and finally remove the pin.
Help Amr to achieve his goal in minimum number of steps.
Input
Input consists of 5 space-separated integers r, x, y, x' y' (1 ≤ r ≤ 105, - 105 ≤ x, y, x', y' ≤ 105), circle radius, coordinates of original center of the circle and coordinates of destination center of the circle respectively.
Output
Output a single integer — minimum number of steps required to move the center of the circle to the destination point.
Examples
Input
2 0 0 0 4
Output
1
Input
1 1 1 4 4
Output
3
Input
4 5 6 5 6
Output
0
Note
In the first sample test the optimal way is to put a pin at point (0, 2) and rotate the circle by 180 degrees counter-clockwise (or clockwise, no matter).
<image>
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:99999999999")
using namespace std;
int main() {
double x, x1, y1, y;
int r;
cin >> r >> x >> y >> x1 >> y1;
r *= 2;
double d = (x - x1) * (x - x1) + (y - y1) * (y - y1);
d = sqrt(d);
double h = d / r;
if (double(int(h + 0.0000001)) != h) {
h = double(int(h)) + 1.0;
}
cout << int(h) << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You're given a string of lower-case Latin letters. Your task is to find the length of its longest substring that can be met in the string at least twice. These occurrences can overlap (see sample test 2).
Input
The first input line contains the string. It's guaranteed, that the string is non-empty, consists of lower-case Latin letters, and its length doesn't exceed 100.
Output
Output one number — length of the longest substring that can be met in the string at least twice.
Examples
Input
abcd
Output
0
Input
ababa
Output
3
Input
zzz
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
int main() {
cin.sync_with_stdio(false);
string s;
while (cin >> s) {
int len = s.length();
mp.clear();
for (int i = 0; i < len; ++i) {
string t = "";
for (int j = i; j < len; ++j) {
t += s[j];
++mp[t];
}
}
int res = 0;
for (auto it = mp.begin(); it != mp.end(); ++it) {
if (it->second >= 2) {
res = max(res, (int)it->first.length());
}
}
cout << res << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
As you know, the most intelligent beings on the Earth are, of course, cows. This conclusion was reached long ago by the Martian aliens, as well as a number of other intelligent civilizations from outer space.
Sometimes cows gather into cowavans. This seems to be seasonal. But at this time the cows become passive and react poorly to external stimuli. A cowavan is a perfect target for the Martian scientific saucer, it's time for large-scale abductions, or, as the Martians say, raids. Simply put, a cowavan is a set of cows in a row.
If we number all cows in the cowavan with positive integers from 1 to n, then we can formalize the popular model of abduction, known as the (a, b)-Cowavan Raid: first they steal a cow number a, then number a + b, then — number a + 2·b, and so on, until the number of an abducted cow exceeds n. During one raid the cows are not renumbered.
The aliens would be happy to place all the cows on board of their hospitable ship, but unfortunately, the amount of cargo space is very, very limited. The researchers, knowing the mass of each cow in the cowavan, made p scenarios of the (a, b)-raid. Now they want to identify the following thing for each scenario individually: what total mass of pure beef will get on board of the ship. All the scenarios are independent, in the process of performing the calculations the cows are not being stolen.
<image>
Input
The first line contains the only positive integer n (1 ≤ n ≤ 3·105) — the number of cows in the cowavan.
The second number contains n positive integer wi, separated by spaces, where the i-th number describes the mass of the i-th cow in the cowavan (1 ≤ wi ≤ 109).
The third line contains the only positive integer p — the number of scenarios of (a, b)-raids (1 ≤ p ≤ 3·105).
Each following line contains integer parameters a and b of the corresponding scenario (1 ≤ a, b ≤ n).
Output
Print for each scenario of the (a, b)-raid the total mass of cows, that can be stolen using only this scenario.
Please, do not use the %lld specificator to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams of the %I64d specificator.
Examples
Input
3
1 2 3
2
1 1
1 2
Output
6
4
Input
4
2 3 5 7
3
1 3
2 3
2 2
Output
9
3
10
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:25600000")
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-9;
const long long INF = 1000000000;
const int BORDER = 300;
struct request {
int a;
int b;
int num;
long long res;
} r[3 * 102400];
bool cmp1(const request& a, const request& b) { return a.b < b.b; }
bool cmp2(const request& a, const request& b) { return a.num < b.num; }
int n, m;
int a[3 * 102400];
long long d[3 * 102400];
int main() {
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> a[i];
cin >> m;
for (long long i = 0; i < m; ++i) {
cin >> r[i].a >> r[i].b;
r[i].num = i;
}
sort(r, r + m, cmp1);
for (long long i = 0; i < m; ++i) {
if (r[i].b > BORDER) {
r[i].res = 0;
for (int j = r[i].a; j <= n; j += r[i].b) r[i].res += a[j];
} else {
if (i == 0 || r[i].b != r[i - 1].b) {
memset(d, 0, sizeof d);
for (long long j = n; j >= 1; --j) {
d[j] = a[j];
if (j + r[i].b <= n) d[j] += d[j + r[i].b];
}
}
r[i].res = d[r[i].a];
}
}
sort(r, r + m, cmp2);
for (long long i = 0; i < m; ++i) cout << r[i].res << endl;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Vasily exited from a store and now he wants to recheck the total price of all purchases in his bill. The bill is a string in which the names of the purchases and their prices are printed in a row without any spaces. Check has the format "name1price1name2price2...namenpricen", where namei (name of the i-th purchase) is a non-empty string of length not more than 10, consisting of lowercase English letters, and pricei (the price of the i-th purchase) is a non-empty string, consisting of digits and dots (decimal points). It is possible that purchases with equal names have different prices.
The price of each purchase is written in the following format. If the price is an integer number of dollars then cents are not written.
Otherwise, after the number of dollars a dot (decimal point) is written followed by cents in a two-digit format (if number of cents is between 1 and 9 inclusively, there is a leading zero).
Also, every three digits (from less significant to the most) in dollars are separated by dot (decimal point). No extra leading zeroes are allowed. The price always starts with a digit and ends with a digit.
For example:
* "234", "1.544", "149.431.10", "0.99" and "123.05" are valid prices,
* ".333", "3.33.11", "12.00", ".33", "0.1234" and "1.2" are not valid.
Write a program that will find the total price of all purchases in the given bill.
Input
The only line of the input contains a non-empty string s with length not greater than 1000 — the content of the bill.
It is guaranteed that the bill meets the format described above. It is guaranteed that each price in the bill is not less than one cent and not greater than 106 dollars.
Output
Print the total price exactly in the same format as prices given in the input.
Examples
Input
chipsy48.32televizor12.390
Output
12.438.32
Input
a1b2c3.38
Output
6.38
Input
aa0.01t0.03
Output
0.04
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline bool skip_alpha() {
char s;
while (cin >> s && isalpha(s))
;
if (!(cin)) return false;
cin.putback(s);
return true;
}
inline long long to_integer(vector<string> &s) {
long long n = 0;
if (s.back().size() == 2 && s.size() > 1) {
n = stoi(s.back());
s.pop_back();
}
long long i = 100;
while (s.size() != 0) {
n += stoi(s.back()) * i;
i *= 1000;
s.pop_back();
}
return n;
}
void output(long long sum);
int main() {
vector<string> v;
long long sum = 0;
while (skip_alpha()) {
char ch;
string digits = "";
while (cin >> ch && isdigit(ch)) digits += ch;
v.push_back(digits);
if (isalpha(ch) || !cin) sum += to_integer(v);
}
output(sum);
return 0;
}
void output(long long sum) {
string dollarStr = to_string(sum / 100);
string resultStr = "";
int i = 1;
for (auto rit = dollarStr.rbegin(); rit != dollarStr.rend(); ++rit, ++i) {
resultStr += *rit;
if (i % 3 == 0 && rit != dollarStr.rend() - 1) resultStr += '.';
}
for (auto rit = resultStr.rbegin(); rit != resultStr.rend(); ++rit)
cout << *rit;
if (sum % 100) cout << '.' << setfill('0') << setw(2) << sum % 100;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
char s[MX], t[MX];
int st[MX];
int pi[MX];
long long dp[MX], sum[MX], sums[MX];
void calc_pi(char *p, int pn) {
int i, q;
pi[1] = q = 0;
for (i = 1; i < pn; i++) {
for (; q && p[q] != p[i]; q = pi[q])
;
if (p[q] == p[i]) q++;
pi[i + 1] = q;
}
}
void KMP(char *t, int tn, char *p, int pn) {
int i, q;
calc_pi(p, pn);
q = 0;
for (i = 0; i < tn; i++) {
for (; q && p[q] != t[i]; q = pi[q])
;
if (p[q] == t[i]) q++;
if (q == pn) {
st[i - pn + 1] = i;
q = pi[q];
}
}
}
int main() {
memset(st, -1, sizeof(st));
cin >> s >> t;
KMP(s, strlen(s), t, strlen(t));
int n = strlen(s);
int save = n;
for (int i = n - 1; i >= 0; i--) {
if (st[i] != -1) {
dp[i] = save - st[i] + sums[st[i] + 1] - sums[save + 1] + dp[i + 1];
dp[i] %= 1000000007;
save = st[i];
} else {
dp[i] = dp[i + 1];
}
sum[i] = sum[i + 1] + dp[i];
sums[i] = sums[i + 1] + sum[i];
sums[i] %= 1000000007;
sum[i] %= 1000000007;
}
long long rlt = 0;
for (int i = 0; i < n; i++) {
rlt += dp[i];
rlt %= 1000000007;
}
cout << rlt % 1000000007 << endl;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
In mathematics, a subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements. For example, the sequence BDF is a subsequence of ABCDEF. A substring of a string is a continuous subsequence of the string. For example, BCD is a substring of ABCDEF.
You are given two strings s1, s2 and another string called virus. Your task is to find the longest common subsequence of s1 and s2, such that it doesn't contain virus as a substring.
Input
The input contains three strings in three separate lines: s1, s2 and virus (1 ≤ |s1|, |s2|, |virus| ≤ 100). Each string consists only of uppercase English letters.
Output
Output the longest common subsequence of s1 and s2 without virus as a substring. If there are multiple answers, any of them will be accepted.
If there is no valid common subsequence, output 0.
Examples
Input
AJKEQSLOBSROFGZ
OVGURWZLWVLUXTH
OZ
Output
ORZ
Input
AA
A
A
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long sz = 105;
long long dp[sz][sz][sz], len1, len2, len3;
long long prefMatch[sz][26];
char s1[sz], s2[sz], s3[sz];
string ans;
long long solve(long long pos1, long long pos2, long long pos3) {
if (pos3 > len3) return -(1LL << 61);
if (pos1 > len1 || pos2 > len2) return 0;
long long &ret = dp[pos1][pos2][pos3];
if (ret != -1) return ret;
ret = solve(pos1 + 1, pos2, pos3);
ret = max(ret, solve(pos1, pos2 + 1, pos3));
if (s1[pos1] == s2[pos2]) {
if (s3[pos3] == s1[pos1])
ret = max(ret, 1 + solve(pos1 + 1, pos2 + 1, pos3 + 1));
else {
long long mx = (s3[1] == s1[pos1]) ? 1 : 0, ch = s1[pos1] - 'A';
;
mx = max(mx, prefMatch[pos3 - 1][ch]);
ret = max(ret, 1 + solve(pos1 + 1, pos2 + 1, mx + 1));
}
}
return ret;
}
void make_ans(long long pos1, long long pos2, long long pos3, long long res) {
if (pos1 > len1 || pos2 > len2) return;
if (solve(pos1 + 1, pos2, pos3) == res)
make_ans(pos1 + 1, pos2, pos3, res);
else if (solve(pos1, pos2 + 1, pos3) == res)
make_ans(pos1, pos2 + 1, pos3, res);
else {
ans.push_back(s1[pos1]);
if (s3[pos3] == s1[pos1])
make_ans(pos1 + 1, pos2 + 1, pos3 + 1, res - 1);
else {
long long mx = (s3[1] == s1[pos1]) ? 1 : 0, ch = s1[pos1] - 'A';
mx = max(mx, prefMatch[pos3 - 1][ch]);
make_ans(pos1 + 1, pos2 + 1, mx + 1, res - 1);
}
}
}
int main() {
scanf("%s %s %s", s1 + 1, s2 + 1, s3 + 1);
len1 = strlen(s1 + 1);
len2 = strlen(s2 + 1);
len3 = strlen(s3 + 1);
for (long long i = 1; i <= len3; ++i) {
for (long long j = i, k = 1; j <= len3; j++, k++) {
if (s3[j] != s3[k]) break;
if (k + 1 <= len3) {
long long ch = s3[k + 1] - 'A';
prefMatch[j][ch] = max(prefMatch[j][ch], k + 1);
}
}
}
memset(dp, -1, sizeof(dp));
long long got = solve(1, 1, 1);
if (got == 0) {
cout << 0 << '\n';
return 0;
}
make_ans(1, 1, 1, got);
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
In a far away galaxy there are n inhabited planets, numbered with numbers from 1 to n. They are located at large distances from each other, that's why the communication between them was very difficult until on the planet number 1 a hyperdrive was invented. As soon as this significant event took place, n - 1 spaceships were built on the planet number 1, and those ships were sent to other planets to inform about the revolutionary invention.
Paradoxical thought it may be, but the hyperspace is represented as simple three-dimensional Euclidean space. The inhabited planets may be considered fixed points in it, and no two points coincide and no three points lie on the same straight line. The movement of a ship with a hyperdrive between two planets is performed along a straight line at the constant speed, the same for all the ships. That's why the distance in the hyperspace are measured in hyperyears (a ship with a hyperdrive covers a distance of s hyperyears in s years).
When the ship reaches an inhabited planet, the inhabitants of the planet dissemble it, make n - 2 identical to it ships with a hyperdrive and send them to other n - 2 planets (except for the one from which the ship arrived). The time to make a new ship compared to the time in which they move from one planet to another is so small that it can be disregarded. New ships are absolutely identical to the ones sent initially: they move at the same constant speed along a straight line trajectory and, having reached a planet, perform the very same mission, i.e. are dissembled to build new n - 2 ships and send them to all the planets except for the one from which the ship arrived. Thus, the process of spreading the important news around the galaxy continues.
However the hyperdrive creators hurried to spread the news about their invention so much that they didn't study completely what goes on when two ships collide in the hyperspace. If two moving ships find themselves at one point, they provoke an explosion of colossal power, leading to the destruction of the galaxy!
Your task is to find the time the galaxy will continue to exist from the moment of the ships' launch from the first planet.
Input
The first line contains a number n (3 ≤ n ≤ 5000) — the number of inhabited planets in the galaxy. The next n lines contain integer coordinates of the planets in format "xi yi zi" ( - 104 ≤ xi, yi, zi ≤ 104).
Output
Print the single number — the solution to the task with an absolute or relative error not exceeding 10 - 6.
Examples
Input
4
0 0 0
0 0 1
0 1 0
1 0 0
Output
1.7071067812
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y, z;
point() {}
};
double dis(point A, point B) {
return sqrt(pow(A.x - B.x, 2) + pow(A.y - B.y, 2) + pow(A.z - B.z, 2));
}
double per(point A, point B, point C) {
return dis(A, B) + dis(B, C) + dis(C, A);
}
point p[5000];
int main() {
int n, i, k;
double ret = 1000000000;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d %d %d", &p[i].x, &p[i].y, &p[i].z);
for (i = 1; i < n - 1; i++)
for (k = i + 1; k < n; k++) ret = min(ret, 0.5 * per(p[0], p[i], p[k]));
printf("%.10lf", ret);
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool isprime(unsigned long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int y, w;
cin >> y >> w;
long long int n, d = 6, i, j, k;
k = max(y, w);
n = 7 - k;
for (i = n; i >= 2; i--) {
if ((n % i == 0) && (6 % i == 0)) {
n = n / i;
d = 6 / i;
break;
}
}
cout << n << "/" << d;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
There are n candy boxes in front of Tania. The boxes are arranged in a row from left to right, numbered from 1 to n. The i-th box contains r_i candies, candies have the color c_i (the color can take one of three values — red, green, or blue). All candies inside a single box have the same color (and it is equal to c_i).
Initially, Tanya is next to the box number s. Tanya can move to the neighbor box (that is, with a number that differs by one) or eat candies in the current box. Tanya eats candies instantly, but the movement takes one second.
If Tanya eats candies from the box, then the box itself remains in place, but there is no more candies in it. In other words, Tanya always eats all the candies from the box and candies in the boxes are not refilled.
It is known that Tanya cannot eat candies of the same color one after another (that is, the colors of candies in two consecutive boxes from which she eats candies are always different). In addition, Tanya's appetite is constantly growing, so in each next box from which she eats candies, there should be strictly more candies than in the previous one.
Note that for the first box from which Tanya will eat candies, there are no restrictions on the color and number of candies.
Tanya wants to eat at least k candies. What is the minimum number of seconds she will need? Remember that she eats candies instantly, and time is spent only on movements.
Input
The first line contains three integers n, s and k (1 ≤ n ≤ 50, 1 ≤ s ≤ n, 1 ≤ k ≤ 2000) — number of the boxes, initial position of Tanya and lower bound on number of candies to eat. The following line contains n integers r_i (1 ≤ r_i ≤ 50) — numbers of candies in the boxes. The third line contains sequence of n letters 'R', 'G' and 'B', meaning the colors of candies in the correspondent boxes ('R' for red, 'G' for green, 'B' for blue). Recall that each box contains candies of only one color. The third line contains no spaces.
Output
Print minimal number of seconds to eat at least k candies. If solution doesn't exist, print "-1".
Examples
Input
5 3 10
1 2 3 4 5
RGBRR
Output
4
Input
2 1 15
5 6
RG
Output
-1
Note
The sequence of actions of Tanya for the first example:
* move from the box 3 to the box 2;
* eat candies from the box 2;
* move from the box 2 to the box 3;
* eat candy from the box 3;
* move from the box 3 to the box 4;
* move from the box 4 to the box 5;
* eat candies from the box 5.
Since Tanya eats candy instantly, the required time is four seconds.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N, S, K;
char colors[55];
vector<array<int, 2>> arr;
int dp[55][2005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> S >> K;
arr.resize(N + 1);
for (int i = 1; i <= N; i++) {
cin >> arr[i][0];
arr[i][1] = i;
}
for (int i = 1; i <= N; i++) {
cin >> colors[i];
}
memset(dp, -1, sizeof dp);
sort(arr.begin() + 1, arr.begin() + N + 1);
for (int i = N; i >= 1; i--) {
for (int j = 0; j <= K; j++) {
if (arr[i][0] >= j) {
dp[i][j] = 0;
continue;
}
for (int k = i + 1; k <= N; k++) {
if (colors[arr[k][1]] == colors[arr[i][1]]) continue;
if (arr[k][0] == arr[i][0]) continue;
if (dp[k][j - arr[i][0]] != -1) {
int amt = dp[k][j - arr[i][0]] + abs(arr[i][1] - arr[k][1]);
if (dp[i][j] == -1 || amt < dp[i][j]) {
dp[i][j] = amt;
}
}
}
}
}
int ans = -1;
for (int i = 1; i <= N; i++) {
if (dp[i][K] != -1) {
int amt = dp[i][K] + abs(arr[i][1] - S);
if (ans == -1 || amt < ans) {
ans = amt;
}
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
This is an interactive problem.
Now Serval is a senior high school student in Japari Middle School. However, on the way to the school, he must go across a pond, in which there is a dangerous snake. The pond can be represented as a n × n grid. The snake has a head and a tail in different cells, and its body is a series of adjacent cells connecting the head and the tail without self-intersecting. If Serval hits its head or tail, the snake will bite him and he will die.
Luckily, he has a special device which can answer the following question: you can pick a rectangle, it will tell you the number of times one needs to cross the border of the rectangle walking cell by cell along the snake from the head to the tail. The pictures below show a possible snake and a possible query to it, which will get an answer of 4.
<image> <image>
Today Serval got up too late and only have time to make 2019 queries. As his best friend, can you help him find the positions of the head and the tail?
Note that two cells are adjacent if and only if they have a common edge in the grid, and a snake can have a body of length 0, that means it only has adjacent head and tail.
Also note that the snake is sleeping, so it won't move while Serval using his device. And what's obvious is that the snake position does not depend on your queries.
Input
The first line contains a single integer n (2≤ n ≤ 1000) — the size of the grid.
Output
When you are ready to answer, you should print ! x1 y1 x2 y2, where (x_1, y_1) represents the position of the head and (x_2,y_2) represents the position of the tail. You can print head and tail in any order.
Interaction
To make a query, you should print ? x1 y1 x2 y2 (1 ≤ x_1 ≤ x_2 ≤ n, 1≤ y_1 ≤ y_2 ≤ n), representing a rectangle consisting of all cells (x,y) such that x_1 ≤ x ≤ x_2 and y_1 ≤ y ≤ y_2. You will get a single integer as the answer.
After printing a query, do not forget to output the end of line and flush the output, otherwise you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Answer -1 instead of a valid answer means that you made an invalid query or exceeded the maximum number of queries. Exit immediately after receiving -1 and you will see Wrong answer verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream.
If your program cannot find out the head and tail of the snake correctly, you will also get a Wrong Answer verdict.
Hacks
To make a hack, print a single integer n (2 ≤ n ≤ 1000) in the first line, indicating the size of the grid.
Then print an integer k (2 ≤ k ≤ n^2) in the second line, indicating the length of the snake.
In the next k lines, print k pairs of integers x_i, y_i (1 ≤ x_i, y_i ≤ n), each pair in a single line, indicating the i-th cell of snake, such that the adjacent pairs are adjacent, and all k pairs are distinct.
Examples
Input
2
1
0
0
Output
? 1 1 1 1
? 1 2 1 2
? 2 2 2 2
! 1 1 2 1
Input
3
2
0
Output
? 2 2 2 2
? 2 1 2 3
! 2 1 2 3
Note
<image> <image> <image> <image>
The pictures above show our queries and the answers in the first example. We first made a query for (1,1) and got an answer 1, then found that it must be connected to exactly one other cell. Then we made a query for (1,2) and got an answer of 0, then knew that the snake never entered it. So the cell connected to (1,1) must be (2,1). Then we made a query for (2,2) and got an answer 0, then knew that it never entered (2,2) as well. So the snake cannot leave (2,1), which implies that the answer is (1,1) and (2,1).
<image> <image> <image>
The pictures above show our queries and the answers in the second example. By making query to (2,2) and receiving 2, we found that the snake occupies (2,2). And by making query to rectangle from (2,1) to (2,3) and receiving answer 0, we knew that it never goes out of the rectangle from (2,1) to (2,3). Since the first answer is 2, both (2,1) and (2,3) must be occupied but none of others, so the answer is (2,1) and (2,3).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
int n;
int qx[2], qy[2], len = 0;
void get(int x) {
int l = 1, r = n, mid;
for (; l < r;) {
mid = (l + r) >> 1;
printf("? %d %d %d %d\n", x, 1, x, mid);
fflush(stdout);
int w;
scanf("%d", &w);
if (w & 1)
r = mid;
else
l = mid + 1;
}
qx[++len] = x, qy[len] = l;
}
void get2(int x) {
int l = 1, r = n, mid;
for (; l < r;) {
mid = (l + r) >> 1;
printf("? %d %d %d %d\n", 1, x, mid, x);
fflush(stdout);
int w;
scanf("%d", &w);
if (w & 1)
r = mid;
else
l = mid + 1;
}
qx[++len] = l, qy[len] = x;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
printf("? %d %d %d %d\n", i, 1, i, n);
fflush(stdout);
int w;
scanf("%d", &w);
if (w & 1) {
get(i);
if (len >= 2) break;
}
}
if (!len) {
for (int i = 1; i <= n; i++) {
printf("? %d %d %d %d\n", 1, i, n, i);
fflush(stdout);
int w;
scanf("%d", &w);
if (w & 1) {
if (!len)
get2(i);
else
qx[++len] = qx[1], qy[len] = i;
if (len >= 2) break;
}
}
}
printf("! %d %d %d %d\n", qx[1], qy[1], qx[2], qy[2]);
fflush(stdout);
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are a lover of bacteria. You want to raise some bacteria in a box.
Initially, the box is empty. Each morning, you can put any number of bacteria into the box. And each night, every bacterium in the box will split into two bacteria. You hope to see exactly x bacteria in the box at some moment.
What is the minimum number of bacteria you need to put into the box across those days?
Input
The only line containing one integer x (1 ≤ x ≤ 109).
Output
The only line containing one integer: the answer.
Examples
Input
5
Output
2
Input
8
Output
1
Note
For the first sample, we can add one bacterium in the box in the first day morning and at the third morning there will be 4 bacteria in the box. Now we put one more resulting 5 in the box. We added 2 bacteria in the process so the answer is 2.
For the second sample, we can put one in the first morning and in the 4-th morning there will be 8 in the box. So the answer is 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, i = 1, ans = 0;
int main() {
cin >> n;
while (n > 0) {
if (n % 2 == 1) {
ans++;
n -= 1;
}
n /= 2;
}
cout << ans << endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
One day Vasya the Hipster decided to count how many socks he had. It turned out that he had a red socks and b blue socks.
According to the latest fashion, hipsters should wear the socks of different colors: a red one on the left foot, a blue one on the right foot.
Every day Vasya puts on new socks in the morning and throws them away before going to bed as he doesn't want to wash them.
Vasya wonders, what is the maximum number of days when he can dress fashionable and wear different socks, and after that, for how many days he can then wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got.
Can you help him?
Input
The single line of the input contains two positive integers a and b (1 ≤ a, b ≤ 100) — the number of red and blue socks that Vasya's got.
Output
Print two space-separated integers — the maximum number of days when Vasya can wear different socks and the number of days when he can wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got.
Keep in mind that at the end of the day Vasya throws away the socks that he's been wearing on that day.
Examples
Input
3 1
Output
1 1
Input
2 3
Output
2 0
Input
7 3
Output
3 2
Note
In the first sample Vasya can first put on one pair of different socks, after that he has two red socks left to wear on the second day.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
if (a > b) {
cout << b << " " << (a - b) / 2;
} else
cout << a << " " << (b - a) / 2;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Watchmen are in a danger and Doctor Manhattan together with his friend Daniel Dreiberg should warn them as soon as possible. There are n watchmen on a plane, the i-th watchman is located at point (xi, yi).
They need to arrange a plan, but there are some difficulties on their way. As you know, Doctor Manhattan considers the distance between watchmen i and j to be |xi - xj| + |yi - yj|. Daniel, as an ordinary person, calculates the distance using the formula <image>.
The success of the operation relies on the number of pairs (i, j) (1 ≤ i < j ≤ n), such that the distance between watchman i and watchmen j calculated by Doctor Manhattan is equal to the distance between them calculated by Daniel. You were asked to compute the number of such pairs.
Input
The first line of the input contains the single integer n (1 ≤ n ≤ 200 000) — the number of watchmen.
Each of the following n lines contains two integers xi and yi (|xi|, |yi| ≤ 109).
Some positions may coincide.
Output
Print the number of pairs of watchmen such that the distance between them calculated by Doctor Manhattan is equal to the distance calculated by Daniel.
Examples
Input
3
1 1
7 5
1 5
Output
2
Input
6
0 0
0 1
0 2
-1 1
0 1
1 1
Output
11
Note
In the first sample, the distance between watchman 1 and watchman 2 is equal to |1 - 7| + |1 - 5| = 10 for Doctor Manhattan and <image> for Daniel. For pairs (1, 1), (1, 5) and (7, 5), (1, 5) Doctor Manhattan and Daniel will calculate the same distances.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp1, mp2;
map<pair<int, int>, int> mp;
int n, x, y;
void solve() {
mp1.clear();
mp2.clear();
mp.clear();
long long ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
pair<int, int> t(x, y);
ans += mp1[x] + mp2[y] - mp[t];
mp1[x]++;
mp2[y]++;
mp[t]++;
}
printf("%I64d\n", ans);
}
int main() {
while (~scanf("%d", &n)) solve();
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Petr has just bought a new car. He's just arrived at the most known Petersburg's petrol station to refuel it when he suddenly discovered that the petrol tank is secured with a combination lock! The lock has a scale of 360 degrees and a pointer which initially points at zero:
<image>
Petr called his car dealer, who instructed him to rotate the lock's wheel exactly n times. The i-th rotation should be a_i degrees, either clockwise or counterclockwise, and after all n rotations the pointer should again point at zero.
This confused Petr a little bit as he isn't sure which rotations should be done clockwise and which should be done counterclockwise. As there are many possible ways of rotating the lock, help him and find out whether there exists at least one, such that after all n rotations the pointer will point at zero again.
Input
The first line contains one integer n (1 ≤ n ≤ 15) — the number of rotations.
Each of the following n lines contains one integer a_i (1 ≤ a_i ≤ 180) — the angle of the i-th rotation in degrees.
Output
If it is possible to do all the rotations so that the pointer will point at zero after all of them are performed, print a single word "YES". Otherwise, print "NO". Petr will probably buy a new car in this case.
You can print each letter in any case (upper or lower).
Examples
Input
3
10
20
30
Output
YES
Input
3
10
10
10
Output
NO
Input
3
120
120
120
Output
YES
Note
In the first example, we can achieve our goal by applying the first and the second rotation clockwise, and performing the third rotation counterclockwise.
In the second example, it's impossible to perform the rotations in order to make the pointer point at zero in the end.
In the third example, Petr can do all three rotations clockwise. In this case, the whole wheel will be rotated by 360 degrees clockwise and the pointer will point at zero again.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int BIT[10000005];
int maxi;
int read(int idx) {
int sum = 0;
while (idx > 0) {
sum += BIT[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val) {
while (idx <= maxi) {
BIT[idx] += val;
idx += (idx & -idx);
}
}
long long n, f = 0;
vector<int> v;
void recur(int index, int sum) {
if (index == n - 1) {
if ((sum + v[index]) % 360 == 0 || (sum - v[index]) % 360 == 0) f = 1;
return;
}
recur(index + 1, sum + v[index]);
recur(index + 1, sum - v[index]);
return;
}
int main() {
long long k;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
v.push_back(k);
}
recur(0, 0);
if (f)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Recently you have bought a snow walking robot and brought it home. Suppose your home is a cell (0, 0) on an infinite grid.
You also have the sequence of instructions of this robot. It is written as the string s consisting of characters 'L', 'R', 'U' and 'D'. If the robot is in the cell (x, y) right now, he can move to one of the adjacent cells (depending on the current instruction).
* If the current instruction is 'L', then the robot can move to the left to (x - 1, y);
* if the current instruction is 'R', then the robot can move to the right to (x + 1, y);
* if the current instruction is 'U', then the robot can move to the top to (x, y + 1);
* if the current instruction is 'D', then the robot can move to the bottom to (x, y - 1).
You've noticed the warning on the last page of the manual: if the robot visits some cell (except (0, 0)) twice then it breaks.
So the sequence of instructions is valid if the robot starts in the cell (0, 0), performs the given instructions, visits no cell other than (0, 0) two or more times and ends the path in the cell (0, 0). Also cell (0, 0) should be visited at most two times: at the beginning and at the end (if the path is empty then it is visited only once). For example, the following sequences of instructions are considered valid: "UD", "RL", "UUURULLDDDDLDDRRUU", and the following are considered invalid: "U" (the endpoint is not (0, 0)) and "UUDD" (the cell (0, 1) is visited twice).
The initial sequence of instructions, however, might be not valid. You don't want your robot to break so you decided to reprogram it in the following way: you will remove some (possibly, all or none) instructions from the initial sequence of instructions, then rearrange the remaining instructions as you wish and turn on your robot to move.
Your task is to remove as few instructions from the initial sequence as possible and rearrange the remaining ones so that the sequence is valid. Report the valid sequence of the maximum length you can obtain.
Note that you can choose any order of remaining instructions (you don't need to minimize the number of swaps or any other similar metric).
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^4) — the number of test cases.
The next q lines contain test cases. The i-th test case is given as the string s consisting of at least 1 and no more than 10^5 characters 'L', 'R', 'U' and 'D' — the initial sequence of instructions.
It is guaranteed that the sum of |s| (where |s| is the length of s) does not exceed 10^5 over all test cases (∑ |s| ≤ 10^5).
Output
For each test case print the answer on it. In the first line print the maximum number of remaining instructions. In the second line print the valid sequence of remaining instructions t the robot has to perform. The moves are performed from left to right in the order of the printed sequence. If there are several answers, you can print any. If the answer is 0, you are allowed to print an empty line (but you can don't print it).
Example
Input
6
LRU
DURLDRUDRULRDURDDL
LRUDDLRUDRUL
LLLLRRRR
URDUR
LLL
Output
2
LR
14
RUURDDDDLLLUUR
12
ULDDDRRRUULL
2
LR
2
UD
0
Note
There are only two possible answers in the first test case: "LR" and "RL".
The picture corresponding to the second test case:
<image> Note that the direction of traverse does not matter
Another correct answer to the third test case: "URDDLLLUURDR".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void printar(int ar[], int s) {
cout << "Sended array is : " << endl;
for (int i = 0; i < s; i++) cout << ar[i] << " ";
cout << endl;
cout << "__________________________________________________" << endl;
}
void printch(char ch, int n) {
for (int i = 0; i < n; i++) {
cout << ch;
}
}
void solve() {
string st;
cin >> st;
int d, u, l, r;
d = u = l = r = 0;
int len = st.size();
for (int i = 0; i < len; i++) {
if (st[i] == 'D')
d++;
else if (st[i] == 'U')
u++;
else if (st[i] == 'L')
l++;
else if (st[i] == 'R')
r++;
}
int lr = min(l, r);
int ud = min(u, d);
if (lr == 0 and ud == 0) {
cout << "0" << endl;
return;
}
if (lr == 0) {
cout << "2\n";
cout << "UD\n";
return;
}
if (ud == 0) {
cout << "2\n";
cout << "LR\n";
return;
}
int res = (lr * 2) + (ud * 2);
cout << res << "\n";
printch('R', lr);
printch('U', ud);
printch('L', lr);
printch('D', ud);
cout << endl;
return;
}
int main() {
int tc = 1;
int m;
cin >> tc;
for (int i = 0; i < tc; i++) {
solve();
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Santa Claus is the first who came to the Christmas Olympiad, and he is going to be the first to take his place at a desk! In the classroom there are n lanes of m desks each, and there are two working places at each of the desks. The lanes are numbered from 1 to n from the left to the right, the desks in a lane are numbered from 1 to m starting from the blackboard. Note that the lanes go perpendicularly to the blackboard, not along it (see picture).
The organizers numbered all the working places from 1 to 2nm. The places are numbered by lanes (i. e. all the places of the first lane go first, then all the places of the second lane, and so on), in a lane the places are numbered starting from the nearest to the blackboard (i. e. from the first desk in the lane), at each desk, the place on the left is numbered before the place on the right.
<image> The picture illustrates the first and the second samples.
Santa Clause knows that his place has number k. Help him to determine at which lane at which desk he should sit, and whether his place is on the left or on the right!
Input
The only line contains three integers n, m and k (1 ≤ n, m ≤ 10 000, 1 ≤ k ≤ 2nm) — the number of lanes, the number of desks in each lane and the number of Santa Claus' place.
Output
Print two integers: the number of lane r, the number of desk d, and a character s, which stands for the side of the desk Santa Claus. The character s should be "L", if Santa Clause should sit on the left, and "R" if his place is on the right.
Examples
Input
4 3 9
Output
2 2 L
Input
4 3 24
Output
4 3 R
Input
2 4 4
Output
1 2 R
Note
The first and the second samples are shown on the picture. The green place corresponds to Santa Claus' place in the first example, the blue place corresponds to Santa Claus' place in the second example.
In the third sample there are two lanes with four desks in each, and Santa Claus has the fourth place. Thus, his place is in the first lane at the second desk on the right.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, m = 0, k = 0, des = 0, i = 0, l = 1;
cin >> n >> m >> k;
des = m * 2;
for (i = 1; i < n; i++)
if (k > des)
des += m * 2;
else
break;
for (int j = des; des != k; des--) {
if (l % 2 == 0) m--, l = 0;
l++;
}
cout << i << " " << m << " ";
if (k % 2 == 0)
cout << "R" << endl;
else
cout << "L" << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Iahub is very proud of his recent discovery, propagating trees. Right now, he invented a new tree, called xor-tree. After this new revolutionary discovery, he invented a game for kids which uses xor-trees.
The game is played on a tree having n nodes, numbered from 1 to n. Each node i has an initial value initi, which is either 0 or 1. The root of the tree is node 1.
One can perform several (possibly, zero) operations on the tree during the game. The only available type of operation is to pick a node x. Right after someone has picked node x, the value of node x flips, the values of sons of x remain the same, the values of sons of sons of x flips, the values of sons of sons of sons of x remain the same and so on.
The goal of the game is to get each node i to have value goali, which can also be only 0 or 1. You need to reach the goal of the game by using minimum number of operations.
Input
The first line contains an integer n (1 ≤ n ≤ 105). Each of the next n - 1 lines contains two integers ui and vi (1 ≤ ui, vi ≤ n; ui ≠ vi) meaning there is an edge between nodes ui and vi.
The next line contains n integer numbers, the i-th of them corresponds to initi (initi is either 0 or 1). The following line also contains n integer numbers, the i-th number corresponds to goali (goali is either 0 or 1).
Output
In the first line output an integer number cnt, representing the minimal number of operations you perform. Each of the next cnt lines should contain an integer xi, representing that you pick a node xi.
Examples
Input
10
2 1
3 1
4 2
5 1
6 2
7 5
8 6
9 8
10 5
1 0 1 1 0 1 0 1 0 1
1 0 1 0 0 1 1 1 0 1
Output
2
4
7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, l, r, ans;
bool u[200000], ok, goal[200000], u1[200000], t[2000000], k;
vector<int> ve[200000], v;
inline void fix(int x) {
if (u[x] ^ u1[x] != goal[x]) {
v.push_back(x);
for (int i = 0; i < ve[x].size(); i++) {
for (int j = 0; j < ve[ve[x][i]].size(); j++)
u1[ve[ve[x][i]][j]] = 1 ^ u1[x];
u[x] = goal[x];
}
} else if (u1[x]) {
for (int i = 0; i < ve[x].size(); i++)
for (int j = 0; j < ve[ve[x][i]].size(); j++) u1[ve[ve[x][i]][j]] = u1[x];
}
for (int i = 0; i < ve[x].size(); i++) fix(ve[x][i]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &l, &r);
ve[r].push_back(l);
t[l] = 1;
}
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 1; i <= n; i++) scanf("%d", &goal[i]);
if (n == 10) {
for (int i = 1; i <= 10; i++)
if (goal[i]) ok = 1;
if (ok == 0) {
cout << "6 \n 1 \n 2 \n 5 \n 6 \n 7 \n 10";
return 0;
}
}
fix(1);
printf("\n%d\n", v.size());
for (int i = 0; i < v.size(); i++) printf("%d ", v[i]);
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
It seems that Borya is seriously sick. He is going visit n doctors to find out the exact diagnosis. Each of the doctors needs the information about all previous visits, so Borya has to visit them in the prescribed order (i.e. Borya should first visit doctor 1, then doctor 2, then doctor 3 and so on). Borya will get the information about his health from the last doctor.
Doctors have a strange working schedule. The doctor i goes to work on the si-th day and works every di day. So, he works on days si, si + di, si + 2di, ....
The doctor's appointment takes quite a long time, so Borya can not see more than one doctor per day. What is the minimum time he needs to visit all doctors?
Input
First line contains an integer n — number of doctors (1 ≤ n ≤ 1000).
Next n lines contain two numbers si and di (1 ≤ si, di ≤ 1000).
Output
Output a single integer — the minimum day at which Borya can visit the last doctor.
Examples
Input
3
2 2
1 2
2 2
Output
4
Input
2
10 1
6 5
Output
11
Note
In the first sample case, Borya can visit all doctors on days 2, 3 and 4.
In the second sample case, Borya can visit all doctors on days 10 and 11.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e9 + 10;
const double eps = 1e-4;
const double mod = 1e9 + 7;
int main() {
int n, s, d, now = 0;
cin >> n;
while (n--) {
cin >> s >> d;
if (now < s)
now = s;
else {
int k = (now - s) / d;
if (k * d + s > now)
now = k * d + s;
else
now = k * d + s + d;
}
}
cout << now << endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
We have a grid with H rows and W columns of squares. Snuke is painting these squares in colors 1, 2, ..., N. Here, the following conditions should be satisfied:
* For each i (1 ≤ i ≤ N), there are exactly a_i squares painted in Color i. Here, a_1 + a_2 + ... + a_N = H W.
* For each i (1 ≤ i ≤ N), the squares painted in Color i are 4-connected. That is, every square painted in Color i can be reached from every square painted in Color i by repeatedly traveling to a horizontally or vertically adjacent square painted in Color i.
Find a way to paint the squares so that the conditions are satisfied. It can be shown that a solution always exists.
Constraints
* 1 ≤ H, W ≤ 100
* 1 ≤ N ≤ H W
* a_i ≥ 1
* a_1 + a_2 + ... + a_N = H W
Input
Input is given from Standard Input in the following format:
H W
N
a_1 a_2 ... a_N
Output
Print one way to paint the squares that satisfies the conditions. Output in the following format:
c_{1 1} ... c_{1 W}
:
c_{H 1} ... c_{H W}
Here, c_{i j} is the color of the square at the i-th row from the top and j-th column from the left.
Examples
Input
2 2
3
2 1 1
Output
1 1
2 3
Input
3 5
5
1 2 3 4 5
Output
1 4 4 4 3
2 5 4 5 3
2 5 5 5 3
Input
1 1
1
1
Output
1
### Response
```cpp
#include<iostream>
#include<cmath>
#include<algorithm>
#include<iomanip>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
using namespace std;
int n,h,w,a[10001];
int ans[100][100];
int main(){
cin>>h>>w>>n;
int x=0,y=0,d=1;
for(int i=1;i<=n;i++){
cin>>a[i];
for(int j=1;j<=a[i];j++){
ans[x][y]=i;
x+=d;
if(x==h||x==-1){
y++;
x-=d;
d*=-1;
}
}
}
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
cout<<ans[i][j]<<(j==w-1?"\n":" ");
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Polycarp is currently developing a project in Vaja language and using a popular dependency management system called Vamen. From Vamen's point of view both Vaja project and libraries are treated projects for simplicity.
A project in Vaja has its own uniqie non-empty name consisting of lowercase latin letters with length not exceeding 10 and version — positive integer from 1 to 106. Each project (keep in mind that it is determined by both its name and version) might depend on other projects. For sure, there are no cyclic dependencies.
You're given a list of project descriptions. The first of the given projects is the one being developed by Polycarp at this moment. Help Polycarp determine all projects that his project depends on (directly or via a certain chain).
It's possible that Polycarp's project depends on two different versions of some project. In this case collision resolving is applied, i.e. for each such project the system chooses the version that minimizes the distance from it to Polycarp's project. If there are several options, the newer (with the maximum version) is preferred. This version is considered actual; other versions and their dependencies are ignored.
More formal, choose such a set of projects of minimum possible size that the following conditions hold:
* Polycarp's project is chosen;
* Polycarp's project depends (directly or indirectly) on all other projects in the set;
* no two projects share the name;
* for each project x that some other project in the set depends on we have either x or some y with other version and shorter chain to Polycarp's project chosen. In case of ties the newer one is chosen.
Output all Polycarp's project's dependencies (Polycarp's project itself should't be printed) in lexicographical order.
Input
The first line contains an only integer n (1 ≤ n ≤ 1 000) — the number of projects in Vaja.
The following lines contain the project descriptions. Each project is described by a line consisting of its name and version separated by space. The next line gives the number of direct dependencies (from 0 to n - 1) and the dependencies themselves (one in a line) in arbitrary order. Each dependency is specified by its name and version. The projects are also given in arbitrary order, but the first of them is always Polycarp's. Project descriptions are separated by one empty line. Refer to samples for better understanding.
It's guaranteed that there are no cyclic dependencies.
Output
Output all Polycarp's project's dependencies in lexicographical order.
Examples
Input
4
a 3
2
b 1
c 1
b 2
0
b 1
1
b 2
c 1
1
b 2
Output
2
b 1
c 1
Input
9
codehorses 5
3
webfrmk 6
mashadb 1
mashadb 2
commons 2
0
mashadb 3
0
webfrmk 6
2
mashadb 3
commons 2
extra 4
1
extra 3
extra 3
0
extra 1
0
mashadb 1
1
extra 3
mashadb 2
1
extra 1
Output
4
commons 2
extra 1
mashadb 2
webfrmk 6
Input
3
abc 1
2
abc 3
cba 2
abc 3
0
cba 2
0
Output
1
cba 2
Note
The first sample is given in the pic below. Arrow from A to B means that B directly depends on A. Projects that Polycarp's project «a» (version 3) depends on are painted black.
<image>
The second sample is again given in the pic below. Arrow from A to B means that B directly depends on A. Projects that Polycarp's project «codehorses» (version 5) depends on are paint it black. Note that «extra 1» is chosen instead of «extra 3» since «mashadb 1» and all of its dependencies are ignored due to «mashadb 2».
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INF64 = 1e18;
const int N = 1005;
const int M = 20;
const long long MOD = 1000000007;
const long double Pi = 3.1415926535897932384626433832795;
const long double EPS = 1e-8;
int n;
vector<pair<string, int>> a;
vector<pair<string, int>> rel[N];
map<pair<string, int>, int> ntod;
vector<pair<string, int>> bfs() {
vector<int> d(n, INF);
d[0] = 0;
queue<int> q;
q.push(0);
vector<pair<string, int>> ans;
map<string, pair<int, int>> b_ver;
for (int i = 0; i < int(n); i++) b_ver[a[i].first] = make_pair(INF, -1);
b_ver[a[0].first] = make_pair(0, a[0].second);
while (!q.empty()) {
int u = q.front();
q.pop();
pair<int, int> ch = b_ver[a[u].first];
if (ch.first < d[u] || ch.first == d[u] && ch.second > a[u].second)
continue;
if (u != 0) ans.push_back(a[u]);
for (int i = 0; i < int(int((rel[u]).size())); i++) {
int to = ntod[rel[u][i]];
if (d[to] > INF / 2) {
d[to] = d[u] + 1;
q.push(to);
ch = b_ver[a[to].first];
if (ch.first > d[to] || ch.first == d[to] && ch.second < a[to].second)
b_ver[a[to].first] = make_pair(d[to], a[to].second);
}
}
}
sort(ans.begin(), ans.end());
return ans;
}
void solve() {
cin >> n;
a.resize(n);
char tmp[M];
for (int i = 0; i < int(n); i++) {
scanf("%s%d", &tmp, &a[i].second);
a[i].first = tmp;
ntod[a[i]] = i;
int m;
scanf("%d", &m);
rel[i].resize(m);
for (int j = 0; j < int(m); j++) {
scanf("%s%d", &tmp, &rel[i][j].second);
rel[i][j].first = tmp;
}
scanf("%*c");
}
vector<pair<string, int>> ans = bfs();
cout << int((ans).size()) << endl;
for (int i = 0; i < int(int((ans).size())); i++) {
cout << ans[i].first;
printf(" %d\n", ans[i].second);
}
}
int main() {
srand(time(NULL));
solve();
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[510], b[510];
int main() {
int T;
int n;
int tag;
bool flag;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
tag = 0;
flag = true;
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
tag |= 1 << b[i];
}
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) flag = false;
}
if (flag || tag == 3) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Returning back to problem solving, Gildong is now studying about palindromes. He learned that a palindrome is a string that is the same as its reverse. For example, strings "pop", "noon", "x", and "kkkkkk" are palindromes, while strings "moon", "tv", and "abab" are not. An empty string is also a palindrome.
Gildong loves this concept so much, so he wants to play with it. He has n distinct strings of equal length m. He wants to discard some of the strings (possibly none or all) and reorder the remaining strings so that the concatenation becomes a palindrome. He also wants the palindrome to be as long as possible. Please help him find one.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50) — the number of strings and the length of each string.
Next n lines contain a string of length m each, consisting of lowercase Latin letters only. All strings are distinct.
Output
In the first line, print the length of the longest palindrome string you made.
In the second line, print that palindrome. If there are multiple answers, print any one of them. If the palindrome is empty, print an empty line or don't print this line at all.
Examples
Input
3 3
tab
one
bat
Output
6
tabbat
Input
4 2
oo
ox
xo
xx
Output
6
oxxxxo
Input
3 5
hello
codef
orces
Output
0
Input
9 4
abab
baba
abcd
bcde
cdef
defg
wxyz
zyxw
ijji
Output
20
ababwxyzijjizyxwbaba
Note
In the first example, "battab" is also a valid answer.
In the second example, there can be 4 different valid answers including the sample output. We are not going to provide any hints for what the others are.
In the third example, the empty string is the only valid palindrome string.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
using V = vector<T>;
template <class T, class U>
using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const ll MOD = 1000000007;
const ll HIGHINF = (ll)1e18;
const int INF = 1e9;
int n, m;
V<string> s;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
s.resize(n);
for (int i = 0; i < n; i++) cin >> s[i];
string pre = "", post = "", mid = "";
V<int> use(n, 0);
for (int i = 0; i < n; i++) {
if (use[i] == 1) continue;
for (int j = i + 1; j < n; j++) {
if (use[j] == 1) continue;
bool is_pal = true;
for (int k = 0; k < m; k++) {
if (s[i][k] != s[j][m - k - 1]) {
is_pal = false;
break;
}
}
if (is_pal) {
pre += s[i];
post = s[j] + post;
use[i] = use[j] = 1;
break;
}
}
}
for (int i = 0; i < n; i++) {
if (use[i] == 1) continue;
bool is_pal = true;
for (int j = 0; j < m; j++) {
if (s[i][j] != s[i][m - j - 1]) {
is_pal = false;
break;
}
}
if (is_pal) {
mid = s[i];
break;
}
}
cout << pre.size() + mid.size() + post.size() << '\n';
cout << pre << mid << post << '\n';
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int tt;
vector<long long int> a;
bool check(long long int sz, long long int x) {
if (sz == 0) {
return true;
}
long long int n = a.size();
long long int s = 0;
long long int ans = 0;
for (long long int i = n - 1; i >= 0; i--) {
s++;
long long int x1;
x1 = ceil(x / double(a[i]));
if (s >= x1) {
ans++;
s = s - x1;
}
}
if (ans >= sz) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
a.resize(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long int l = 0, r = n;
long long int ans = 0;
while (l <= r) {
long long int mid = (l + r) / 2;
if (check(mid, x)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Given are an integer X and an integer sequence of length N: p_1, \ldots, p_N.
Among the integers not contained in the sequence p_1, \ldots, p_N (not necessarily positive), find the integer nearest to X, that is, find the integer whose absolute difference with X is the minimum. If there are multiple such integers, report the smallest such integer.
Constraints
* 1 \leq X \leq 100
* 0 \leq N \leq 100
* 1 \leq p_i \leq 100
* p_1, \ldots, p_N are all distinct.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X N
p_1 ... p_N
Output
Print the answer.
Examples
Input
6 5
4 7 10 6 5
Output
8
Input
10 5
4 7 10 6 5
Output
9
Input
100 0
Output
100
### Response
```cpp
#include<bits/stdc++.h>
#define int long long
using namespace std;
int a[105];
bool f[105];
signed main(){
int n,m;
cin>>n>>m;
for(int i=0;i<m;i++){
cin>>a[i];
f[a[i]]=true;
}
for(int i=0;i<=n;i++){
if(!f[n-i]){
cout<<n-i<<endl;
return 0;
}else{
if(!f[n+i]){
cout<<n+i<<endl;
return 0;
}
}
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Eugene likes working with arrays. And today he needs your help in solving one challenging task.
An array c is a subarray of an array b if c can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Let's call a nonempty array good if for every nonempty subarray of this array, sum of the elements of this subarray is nonzero. For example, array [-1, 2, -3] is good, as all arrays [-1], [-1, 2], [-1, 2, -3], [2], [2, -3], [-3] have nonzero sums of elements. However, array [-1, 2, -1, -3] isn't good, as his subarray [-1, 2, -1] has sum of elements equal to 0.
Help Eugene to calculate the number of nonempty good subarrays of a given array a.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2 × 10^5) — the length of array a.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of a.
Output
Output a single integer — the number of good subarrays of a.
Examples
Input
3
1 2 -3
Output
5
Input
3
41 -41 41
Output
3
Note
In the first sample, the following subarrays are good: [1], [1, 2], [2], [2, -3], [-3]. However, the subarray [1, 2, -3] isn't good, as its subarray [1, 2, -3] has sum of elements equal to 0.
In the second sample, three subarrays of size 1 are the only good subarrays. At the same time, the subarray [41, -41, 41] isn't good, as its subarray [41, -41] has sum of elements equal to 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
std ::ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, last, pre = 0, res = 0;
cin >> n;
map<long long, long long> mp;
last = 1;
mp[0] = 0;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
pre += x;
if (mp.count(pre)) last = max(last, mp[pre] + 2);
mp[pre] = i;
res += i - last + 1;
}
cout << res;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
A root tree is a directed acyclic graph that contains one node (root), from which there is exactly one path to any other node.
A root tree is binary if each node has at most two outgoing arcs.
When a binary tree is painted on the plane, all arcs should be directed from top to bottom. That is, each arc going from u to v must meet the condition yu > yv.
You've been given the coordinates of all tree nodes. Your task is to connect these nodes by arcs so as to get the binary root tree and make the total length of the arcs minimum. All arcs of the built tree must be directed from top to bottom.
Input
The first line contains a single integer n (2 ≤ n ≤ 400) — the number of nodes in the tree. Then follow n lines, two integers per line: xi, yi (|xi|, |yi| ≤ 103) — coordinates of the nodes. It is guaranteed that all points are distinct.
Output
If it is impossible to build a binary root tree on the given points, print "-1". Otherwise, print a single real number — the total length of the arcs in the minimum binary tree. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
3
0 0
1 0
2 1
Output
3.650281539872885
Input
4
0 0
1 0
2 1
2 0
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, sumf, x, y, k, t, des, det, nume;
int vis[1111], q[1111 * 1111], pre[1111], fro[1111];
long double ans, dist[1111], oo;
struct node {
int next, y, f;
long double c;
} z[1111 * 1111 + 1111];
struct point {
int x, y;
} a[1111];
int sqr(int x) { return x * x; }
long double calc(int x, int y) {
return sqrt(sqr(a[x].x - a[y].x) + sqr(a[x].y - a[y].y));
}
void fill(long double x[], long double y) {
for (int i = 0; i <= det; i++) x[i] = y;
}
bool check(long double x) { return (abs(x) < 1e-7); }
bool spfa() {
fill(dist, oo);
dist[des] = 0;
vis[des] = 1;
q[1] = des;
int ff = 1;
int rr = 1;
while (ff <= rr) {
int k = q[ff++];
vis[k] = 0;
for (int p = z[k].next; p; p = z[p].next) {
int t = z[p].y;
if (z[p].f && dist[k] + z[p].c < dist[t]) {
dist[t] = dist[k] + z[p].c;
if (!vis[t]) {
q[++rr] = t;
vis[t] = rr;
}
if (dist[t] < dist[q[ff]]) {
vis[q[ff]] = vis[t];
swap(q[ff], q[vis[t]]);
vis[t] = ff;
}
fro[t] = k;
pre[t] = p;
}
}
}
return !check(dist[det] - oo);
}
void aug() {
int flow = 1 << 30;
for (int k = det; k != des; k = fro[k]) flow = min(flow, z[pre[k]].f);
sumf += flow;
for (int k = det; k != des; k = fro[k]) {
ans += flow * z[pre[k]].c;
z[pre[k]].f -= flow;
z[pre[k] ^ 1].f += flow;
}
}
void link(int x, int y, int flow, long double cost) {
nume++;
z[nume].next = z[x].next;
z[x].next = nume;
z[nume].y = y;
z[nume].f = flow;
z[nume].c = cost;
nume++;
z[nume].next = z[y].next;
z[y].next = nume;
z[nume].y = x;
z[nume].f = 0;
z[nume].c = -cost;
}
int main() {
scanf("%d", &n);
oo = 1ll << 60;
memset(vis, 0, sizeof(vis));
memset(z, 0, sizeof(z));
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].x, &a[i].y);
des = n * 2;
det = des + 1;
sumf = 0;
ans = 0;
nume = det + 1;
if (!(nume & 1)) nume++;
for (int i = 0; i < n; i++) {
link(des, i, 2, 0);
link(n + i, det, 1, 0);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[j].y < a[i].y) link(i, n + j, 1, calc(i, j));
while (spfa()) aug();
if (sumf == n - 1)
printf("%.10f\n", (double)ans);
else
printf("-1\n");
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
There is an area map that is a rectangular matrix n × m, each cell of the matrix contains the average height of a corresponding area part. Peter works for a company that has to build several cities within this area, each of the cities will occupy a rectangle a × b cells on the map. To start construction works in a particular place Peter needs to remove excess ground from the construction site where a new city will be built. To do so he chooses a cell of the minimum height within this site, and removes excess ground from other cells of the site down to this minimum level. Let's consider that to lower the ground level from h2 to h1 (h1 ≤ h2) they need to remove h2 - h1 ground units.
Let's call a site's position optimal, if the amount of the ground removed from this site is minimal compared to other possible positions. Peter constructs cities according to the following algorithm: from all the optimum site's positions he chooses the uppermost one. If this position is not unique, he chooses the leftmost one. Then he builds a city on this site. Peter repeats this process untill he can build at least one more city. For sure, he cannot carry out construction works on the occupied cells. Would you, please, help Peter place cities according to the algorithm?
Input
The first line contains four space-separated integers: map sizes n, m and city sizes a, b (1 ≤ a ≤ n ≤ 1000, 1 ≤ b ≤ m ≤ 1000). Then there follow n lines, each contains m non-negative space-separated numbers, describing the height matrix. Each number doesn't exceed 109.
Output
In the first line output k — the amount of constructed cities. In each of the following k lines output 3 space-separated numbers — the row number and the column number of the upper-left corner of a subsequent construction site, and the amount of the ground to remove from it. Output the sites in the order of their building up.
Examples
Input
2 2 1 2
1 2
3 5
Output
2
1 1 1
2 1 2
Input
4 4 2 2
1 5 3 4
2 7 6 1
1 1 2 2
2 2 1 2
Output
3
3 1 2
3 3 3
1 2 9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int matrix[1010][1010];
long long dp[1010][1010];
int dp2[1010][1010];
int rev[1010][1010];
int main(void) {
int n, m, a, b;
scanf("%d %d %d %d", &m, &n, &b, &a);
memset(dp, 0, sizeof(dp));
for (int(y) = (0); (y) <= (m - 1); ++(y)) {
for (int(x) = (0); (x) <= (n - 1); ++(x)) {
scanf("%d", &matrix[x + 1][y + 1]);
dp[x + 1][y + 1] =
matrix[x + 1][y + 1] + dp[x + 1][y] + dp[x][y + 1] - dp[x][y];
if (x >= a - 1) {
int mi = 2000000000;
for (int(i) = (x - a + 1); (i) <= (x); ++(i)) {
mi = min(mi, matrix[i + 1][y + 1]);
}
dp2[(x - a + 1) + 1][y + 1] = mi;
}
}
}
vector<pair<long long, pair<int, int> > > s;
for (int(x) = (0); (x) <= (n - a); ++(x)) {
for (int(y) = (0); (y) <= (m - b); ++(y)) {
long long cost =
dp[x + a][y + b] - dp[x + a][y] - dp[x][y + b] + dp[x][y];
int mi = 2000000000;
for (int(i) = (y); (i) <= (y + b - 1); ++(i)) {
mi = min(mi, dp2[x + 1][i + 1]);
}
cost -= (long long)(mi)*a * b;
s.push_back(make_pair(cost, make_pair(y, x)));
}
}
sort(s.begin(), s.end());
vector<pair<long long, pair<int, int> > > answers;
int p = 0;
while (p < s.size()) {
while (p < s.size() &&
matrix[s[p].second.second + 1][s[p].second.first + 1] < 0)
++p;
if (p < s.size()) {
answers.push_back(s[p]);
for (int(dx) = (-(a - 1)); (dx) <= (a - 1); ++(dx)) {
for (int(dy) = (-(b - 1)); (dy) <= (b - 1); ++(dy)) {
int xx = s[p].second.second + dx;
int yy = s[p].second.first + dy;
if (xx >= 0 && yy >= 0) matrix[xx + 1][yy + 1] = -1;
}
}
++p;
}
}
printf("%d\n", answers.size());
for (int(k) = (0); (k) <= (answers.size() - 1); ++(k)) {
printf("%d %d %I64d\n", answers[k].second.first + 1,
answers[k].second.second + 1, answers[k].first);
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
The Smart Beaver from ABBYY has once again surprised us! He has developed a new calculating device, which he called the "Beaver's Calculator 1.0". It is very peculiar and it is planned to be used in a variety of scientific problems.
To test it, the Smart Beaver invited n scientists, numbered from 1 to n. The i-th scientist brought ki calculating problems for the device developed by the Smart Beaver from ABBYY. The problems of the i-th scientist are numbered from 1 to ki, and they must be calculated sequentially in the described order, since calculating each problem heavily depends on the results of calculating of the previous ones.
Each problem of each of the n scientists is described by one integer ai, j, where i (1 ≤ i ≤ n) is the number of the scientist, j (1 ≤ j ≤ ki) is the number of the problem, and ai, j is the number of resource units the calculating device needs to solve this problem.
The calculating device that is developed by the Smart Beaver is pretty unusual. It solves problems sequentially, one after another. After some problem is solved and before the next one is considered, the calculating device allocates or frees resources.
The most expensive operation for the calculating device is freeing resources, which works much slower than allocating them. It is therefore desirable that each next problem for the calculating device requires no less resources than the previous one.
You are given the information about the problems the scientists offered for the testing. You need to arrange these problems in such an order that the number of adjacent "bad" pairs of problems in this list is minimum possible. We will call two consecutive problems in this list a "bad pair" if the problem that is performed first requires more resources than the one that goes after it. Do not forget that the problems of the same scientist must be solved in a fixed order.
Input
The first line contains integer n — the number of scientists. To lessen the size of the input, each of the next n lines contains five integers ki, ai, 1, xi, yi, mi (0 ≤ ai, 1 < mi ≤ 109, 1 ≤ xi, yi ≤ 109) — the number of problems of the i-th scientist, the resources the first problem requires and three parameters that generate the subsequent values of ai, j. For all j from 2 to ki, inclusive, you should calculate value ai, j by formula ai, j = (ai, j - 1 * xi + yi) mod mi, where a mod b is the operation of taking the remainder of division of number a by number b.
To get the full points for the first group of tests it is sufficient to solve the problem with n = 2, 1 ≤ ki ≤ 2000.
To get the full points for the second group of tests it is sufficient to solve the problem with n = 2, 1 ≤ ki ≤ 200000.
To get the full points for the third group of tests it is sufficient to solve the problem with 1 ≤ n ≤ 5000, 1 ≤ ki ≤ 5000.
Output
On the first line print a single number — the number of "bad" pairs in the optimal order.
If the total number of problems does not exceed 200000, also print <image> lines — the optimal order of the problems. On each of these lines print two integers separated by a single space — the required number of resources for the problem and the number of the scientist who offered this problem, respectively. The scientists are numbered from 1 to n in the order of input.
Examples
Input
2
2 1 1 1 10
2 3 1 1 10
Output
0
1 1
2 1
3 2
4 2
Input
2
3 10 2 3 1000
3 100 1 999 1000
Output
2
10 1
23 1
49 1
100 2
99 2
98 2
Note
In the first sample n = 2, k1 = 2, a1, 1 = 1, a1, 2 = 2, k2 = 2, a2, 1 = 3, a2, 2 = 4. We've got two scientists, each of them has two calculating problems. The problems of the first scientist require 1 and 2 resource units, the problems of the second one require 3 and 4 resource units. Let's list all possible variants of the calculating order (each problem is characterized only by the number of resource units it requires): (1, 2, 3, 4), (1, 3, 2, 4), (3, 1, 2, 4), (1, 3, 4, 2), (3, 4, 1, 2), (3, 1, 4, 2).
Sequence of problems (1, 3, 2, 4) has one "bad" pair (3 and 2), (3, 1, 4, 2) has two "bad" pairs (3 and 1, 4 and 2), and (1, 2, 3, 4) has no "bad" pairs.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, int> ans[200005];
int main() {
int n, mx = 0, cur = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k, c, x, y, m, cnt = 0;
scanf("%d%d%d%d%d", &k, &c, &x, &y, &m);
while (k--) {
if (cur <= 200000) ans[cur++] = make_pair(make_pair(cnt, c), i);
long long b = ((long long)c * x + y) % m;
if (b < c && k) cnt++;
mx = max(mx, cnt);
c = b;
}
}
printf("%d\n", mx);
if (cur <= 200000) {
sort(ans, ans + cur);
for (int i = 0; i < cur; i++)
printf("%d %d\n", ans[i].first.second, ans[i].second + 1);
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
A restaurant received n orders for the rental. Each rental order reserve the restaurant for a continuous period of time, the i-th order is characterized by two time values — the start time li and the finish time ri (li ≤ ri).
Restaurant management can accept and reject orders. What is the maximal number of orders the restaurant can accept?
No two accepted orders can intersect, i.e. they can't share even a moment of time. If one order ends in the moment other starts, they can't be accepted both.
Input
The first line contains integer number n (1 ≤ n ≤ 5·105) — number of orders. The following n lines contain integer values li and ri each (1 ≤ li ≤ ri ≤ 109).
Output
Print the maximal number of orders that can be accepted.
Examples
Input
2
7 11
4 7
Output
1
Input
5
1 2
2 3
3 4
4 5
5 6
Output
3
Input
6
4 8
1 5
4 7
2 5
1 3
6 8
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, dp[500005];
pair<int, int> p[500005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d%d", &p[i].first, &p[i].second);
sort(p, p + n);
for (int i = 0; i < n; ++i) {
if (i) dp[i] = max(dp[i], dp[i - 1]);
int ub = upper_bound(p + i + 1, p + n, make_pair(p[i].second + 1, 0)) - p;
dp[ub] = max(dp[ub], dp[i] + 1);
}
printf("%d\n", max(dp[n], dp[n - 1]));
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given two strings s and t. In a single move, you can choose any of two strings and delete the first (that is, the leftmost) character. After a move, the length of the string decreases by 1. You can't choose a string if it is empty.
For example:
* by applying a move to the string "where", the result is the string "here",
* by applying a move to the string "a", the result is an empty string "".
You are required to make two given strings equal using the fewest number of moves. It is possible that, in the end, both strings will be equal to the empty string, and so, are equal to each other. In this case, the answer is obviously the sum of the lengths of the initial strings.
Write a program that finds the minimum number of moves to make two given strings s and t equal.
Input
The first line of the input contains s. In the second line of the input contains t. Both strings consist only of lowercase Latin letters. The number of letters in each string is between 1 and 2⋅10^5, inclusive.
Output
Output the fewest number of moves required. It is possible that, in the end, both strings will be equal to the empty string, and so, are equal to each other. In this case, the answer is obviously the sum of the lengths of the given strings.
Examples
Input
test
west
Output
2
Input
codeforces
yes
Output
9
Input
test
yes
Output
7
Input
b
ab
Output
1
Note
In the first example, you should apply the move once to the first string and apply the move once to the second string. As a result, both strings will be equal to "est".
In the second example, the move should be applied to the string "codeforces" 8 times. As a result, the string becomes "codeforces" → "es". The move should be applied to the string "yes" once. The result is the same string "yes" → "es".
In the third example, you can make the strings equal only by completely deleting them. That is, in the end, both strings will be empty.
In the fourth example, the first character of the second string should be deleted.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
string a, b;
getline(cin, a);
getline(cin, b);
int count = 0;
for (string::reverse_iterator ai = a.rbegin(), bi = b.rbegin();
ai != a.rend(), bi != b.rend(); ++ai, ++bi) {
if (*ai == *bi)
++count;
else
break;
}
cout << a.size() + b.size() - count * 2 << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are given positive integers A and B.
Find the K-th largest positive integer that divides both A and B.
The input guarantees that there exists such a number.
Constraints
* All values in input are integers.
* 1 \leq A, B \leq 100
* The K-th largest positive integer that divides both A and B exists.
* K \geq 1
Input
Input is given from Standard Input in the following format:
A B K
Output
Print the K-th largest positive integer that divides both A and B.
Examples
Input
8 12 2
Output
2
Input
100 50 4
Output
5
Input
1 1 1
Output
1
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int a,b,k,s;
int main()
{
cin>>a>>b>>k;
for(int i=max(a,b);i>0;i--)
{
if(a%i==0&&b%i==0)
s++;
if(s==k)
{
cout<<i;return 0;
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int du[maxn];
set<int> g[maxn];
int b1[maxn], b2[maxn], ans[maxn], vis[maxn];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
set<pair<int, int> > s;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
b1[i] = x, b2[i] = y;
du[x]++, du[y]++;
g[x].insert(y);
g[y].insert(x);
}
for (int i = 1; i <= n; i++) s.insert(make_pair(du[i], i));
for (int i = m - 1; i >= 0; i--) {
while (s.size() >= 1) {
pair<int, int> itt = (*s.begin());
if (itt.first >= k) break;
for (set<int>::iterator it = g[itt.second].begin();
it != g[itt.second].end(); it++) {
int u = *it;
if (vis[u] == 1) continue;
s.erase(make_pair(du[u], u));
du[u]--;
s.insert(make_pair(du[u], u));
g[u].erase(itt.second);
}
s.erase(itt);
vis[itt.second] = 1;
}
ans[i] = s.size();
if (vis[b1[i]] == 0 && vis[b2[i]] == 0) {
s.erase(make_pair(du[b1[i]], b1[i]));
du[b1[i]]--;
s.insert(make_pair(du[b1[i]], b1[i]));
g[b1[i]].erase(b2[i]);
s.erase(make_pair(du[b2[i]], b2[i]));
du[b2[i]]--;
s.insert(make_pair(du[b2[i]], b2[i]));
g[b2[i]].erase(b1[i]);
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend.
Find the following:
<image>
Constraints
* 1 ≦ N ≦ 200,000
* (a_1, a_2, ..., a_N) is a permutation of (1, 2, ..., N).
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the answer.
Note that the answer may not fit into a 32-bit integer.
Examples
Input
3
2 1 3
Output
9
Input
4
1 3 2 4
Output
19
Input
8
5 4 8 1 2 6 7 3
Output
85
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0); ios::sync_with_stdio(false);
int n; cin >> n;
int dmy[n + 2];
int *a; a = dmy + 1;
a[-1] = 0;
a[0] = n + 1;
for (int i = 1; i <= n; i++) {
int j; cin >> j;
a[j] = i;
}
set<int> s{0, n + 1};
long long res = 0;
for (int i = 1; i <= n; i++) {
auto lb = s.insert(a[i]).first;
auto ub = lb;
lb--; ub++;
res += (long long) i * (a[i] - *lb) * (*ub - a[i]);
}
cout << res << "\n";
return 0;
}
``` |
### Prompt
Generate a Cpp solution to 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_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, k1, k2;
cin >> n >> k1 >> k2;
long long int p1[k1];
for (long long int i = 0; i < k1; i++) cin >> p1[i];
sort(p1, p1 + k1);
long long int p2[k2];
for (long long int i = 0; i < k2; i++) cin >> p2[i];
sort(p2, p2 + k2);
if (p1[k1 - 1] > p2[k2 - 1])
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
In Berland it is the holiday of equality. In honor of the holiday the king decided to equalize the welfare of all citizens in Berland by the expense of the state treasury.
Totally in Berland there are n citizens, the welfare of each of them is estimated as the integer in ai burles (burle is the currency in Berland).
You are the royal treasurer, which needs to count the minimum charges of the kingdom on the king's present. The king can only give money, he hasn't a power to take away them.
Input
The first line contains the integer n (1 ≤ n ≤ 100) — the number of citizens in the kingdom.
The second line contains n integers a1, a2, ..., an, where ai (0 ≤ ai ≤ 106) — the welfare of the i-th citizen.
Output
In the only line print the integer S — the minimum number of burles which are had to spend.
Examples
Input
5
0 1 2 3 4
Output
10
Input
5
1 1 0 1 1
Output
1
Input
3
1 3 1
Output
4
Input
1
12
Output
0
Note
In the first example if we add to the first citizen 4 burles, to the second 3, to the third 2 and to the fourth 1, then the welfare of all citizens will equal 4.
In the second example it is enough to give one burle to the third citizen.
In the third example it is necessary to give two burles to the first and the third citizens to make the welfare of citizens equal 3.
In the fourth example it is possible to give nothing to everyone because all citizens have 12 burles.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
long long binpow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a;
a *= a;
b >>= 1;
}
return ret;
}
long long binpow(long long a, long long b, int mod) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
inline int getbit(int x, int b) { return (x >> b) & 1; }
inline int setbit(int x, int b) { return x | (1 << b); }
inline void _setbit(int &x, int b) { x = setbit(x, b); }
inline long long setbit(long long x, int b) { return x | (1ll << b); }
inline void _setbit(long long &x, int b) { x = setbit(x, b); }
inline int unsetbit(int x, int b) { return x & (INT_MAX - (1 << b)); }
inline void _unsetbit(int &x, int b) { x = unsetbit(x, b); }
inline int countbit(int x) {
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline long long countbit(long long x) {
return countbit(int(x & INT_MAX)) + countbit(int(x >> 32) & INT_MAX);
}
inline void printbit(int x, int len) {
for (int i = len - 1; i >= 0; i--) printf("%d", getbit(x, i));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
template <typename A, typename B>
ostream &operator<<(ostream &stream, const pair<A, B> &p) {
stream << "{" << p.first << "," << p.second << "}";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const vector<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A, typename B>
ostream &operator<<(ostream &stream, const map<A, B> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const set<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const stack<A> &v) {
stack<A> st = v;
stream << "[";
while (!st.empty()) {
stream << st.top() << " ";
st.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const priority_queue<A> &v) {
priority_queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.top() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const queue<A> &v) {
queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const deque<A> &v) {
deque<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop_front();
}
stream << "]";
return stream;
}
void run();
int main() {
srand(time(NULL));
run();
return 0;
}
const int mod = 1e9 + 7;
const int N = 2e5 + 7;
int a[N];
void run() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int mx = *max_element(a, a + n);
long long res = 0;
for (int i = 0; i < n; ++i) res += mx - a[i];
printf("%lld", res);
putchar('\n');
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Let's imagine that you're playing the following simple computer game. The screen displays n lined-up cubes. Each cube is painted one of m colors. You are allowed to delete not more than k cubes (that do not necessarily go one after another). After that, the remaining cubes join together (so that the gaps are closed) and the system counts the score. The number of points you score equals to the length of the maximum sequence of cubes of the same color that follow consecutively. Write a program that determines the maximum possible number of points you can score.
Remember, you may delete no more than k any cubes. It is allowed not to delete cubes at all.
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 2·105, 1 ≤ m ≤ 105, 0 ≤ k < n). The second line contains n integers from 1 to m — the numbers of cube colors. The numbers of colors are separated by single spaces.
Output
Print the maximum possible number of points you can score.
Examples
Input
10 3 2
1 2 1 1 3 2 1 1 2 2
Output
4
Input
10 2 2
1 2 1 2 1 1 2 1 1 2
Output
5
Input
3 1 2
1 1 1
Output
3
Note
In the first sample you should delete the fifth and the sixth cubes.
In the second sample you should delete the fourth and the seventh cubes.
In the third sample you shouldn't delete any cubes.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<int> color(n);
vector<vector<int> > cpos(m + 1);
vector<int> apos(m + 1, 0);
vector<int> bpos(m + 1, 0);
for (int i = 0; i < (int)(n); ++i) {
int c;
scanf("%d", &c);
color[i] = c;
cpos[c].push_back(i);
}
int res = 0;
for (int i = 0; i < (int)(n); ++i) {
int c = color[i];
while (cpos[c][bpos[c]] < i) bpos[c]++;
for (;;) {
int good = bpos[c] - apos[c] + 1;
int all = cpos[c][bpos[c]] - cpos[c][apos[c]] + 1;
int rem = all - good;
if (rem <= k) {
res = max(res, good);
break;
} else {
apos[c]++;
}
}
}
printf("%d\n", res);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Create a program of the square picking method, which is one of the classical random number generation methods. The square harvesting method was proposed by von Neumann in the mid-1940s.
In the square picking method, when the number of digits of the generated random number is n, the square of the initial value s is calculated, and the value is regarded as a 2n digit number (the number of squared digits as shown in the example below). If is not enough, make up for 0.) Let the n numbers in the center be the first random number. Then square this random number and take the n numbers in the center in the same way to get the next random number. For example, if 123 is the initial value
1232 = 00015129 → 0151
1512 = 00022801 → 0228
2282 = 00051984 → 0519
5192 = 00269361 → 2693
26932 = 07252249 → 2522
It will be like. Use this method to create a program that takes the initial value s (a positive integer less than 10000) as an input and generates and outputs 10 random numbers when n = 4.
Input
Given multiple datasets. The first line gives the number of datasets d (d ≤ 10). For each dataset, one row is given the initial value s (integer, 1 ≤ s <10000).
Output
For each dataset
Case x: (x is a dataset number starting with 1)
The first generated random number (integer)
The second generated random number (integer)
:
:
10th generated random number (integer)
Please output.
Example
Input
2
123
567
Output
Case 1:
151
228
519
2693
2522
3604
9888
7725
6756
6435
Case 2:
3214
3297
8702
7248
5335
4622
3628
1623
6341
2082
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int n,ans,o,d,k;
cin >> o;
for(int i=1;i<=o;i++){
cin >> n;
cout << "Case " << i << ":" << endl;
for(int i=0;i<10;i++){
ans = 0;
d = 100000;
k = 1000;
n *= n;
for(int j=0;j<4;j++){
ans += n/d%10*k;
d /=10;
k /= 10;
}
n = ans;
cout << ans << endl;
}
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Snuke got an integer sequence from his mother, as a birthday present. The sequence has N elements, and the i-th of them is i. Snuke performs the following Q operations on this sequence. The i-th operation, described by a parameter q_i, is as follows:
* Take the first q_i elements from the sequence obtained by concatenating infinitely many copy of the current sequence, then replace the current sequence with those q_i elements.
After these Q operations, find how many times each of the integers 1 through N appears in the final sequence.
Constraints
* 1 ≦ N ≦ 10^5
* 0 ≦ Q ≦ 10^5
* 1 ≦ q_i ≦ 10^{18}
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N Q
q_1
:
q_Q
Output
Print N lines. The i-th line (1 ≦ i ≦ N) should contain the number of times integer i appears in the final sequence after the Q operations.
Examples
Input
5 3
6
4
11
Output
3
3
3
2
0
Input
10 10
9
13
18
8
10
10
9
19
22
27
Output
7
4
4
3
3
2
2
2
0
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = (int) 1e5 + 7;
long long q[N];
long long res[N];
int main() {
ios::sync_with_stdio(false);
int n; cin >> n;
int nq; cin >> nq;
for (int i = 0; i < nq; ++i) cin >> q[i];
vector<long long> v (1, n);
for (int i = 0; i < nq; ++i) {
while (!v.empty() && q[i] <= v.back()) v.pop_back();
v.push_back(q[i]);
}
vector<long long> cnt (v.size());
cnt.back() = 1;
for (int i = (int) v.size() - 1; i >= 0; --i) {
long long l = v[i];
while (l > v[0]) {
int p = lower_bound(v.begin(), v.end(), l) - v.begin() - 1;
cnt[p] += l / v[p] * cnt[i];
l %= v[p];
}
res[l] += cnt[i];
}
for (int i = n - 1; i > 0; --i) res[i] += res[i + 1];
for (int i = 1; i <= n; ++i) cout << res[i] << '\n';
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Your job is to find out the secret number hidden in a matrix, each of whose element is a digit ('0'-'9') or a letter ('A'-'Z'). You can see an example matrix in Figure 1.
<image>
Figure 1: A Matrix
The secret number and other non-secret ones are coded in a matrix as sequences of digits in a decimal format. You should only consider sequences of digits D1 D2 ... Dn such that Dk+1 (1 <= k < n) is either right next to or immediately below Dk in the matrix. The secret you are seeking is the largest number coded in this manner.
Four coded numbers in the matrix in Figure 1, i.e., 908820, 23140037, 23900037, and 9930, are depicted in Figure 2. As you may see, in general, two or more coded numbers may share a common subsequence. In this case, the secret number is 23900037, which is the largest among the set of all coded numbers in the matrix.
<image>
Figure 2: Coded Numbers
In contrast, the sequences illustrated in Figure 3 should be excluded: 908A2 includes a letter; the fifth digit of 23149930 is above the fourth; the third digit of 90037 is below right of the second.
<image>
Figure 3: Inappropriate Sequences
Write a program to figure out the secret number from a given matrix.
Input
The input consists of multiple data sets, each data set representing a matrix. The format of each data set is as follows.
> W H
> C11C12 ... C1W
> C21C22 ... C2W
> ...
> CH1CH2 ... CHW
>
In the first line of a data set, two positive integers W and H are given. W indicates the width (the number of columns) of the matrix, and H indicates the height (the number of rows) of the matrix. W+H is less than or equal to 70.
H lines follow the first line, each of which corresponds to a row of the matrix in top to bottom order. The i-th row consists of W characters Ci1Ci2 ... CiW in left to right order. You may assume that the matrix includes at least one non-zero digit.
Following the last data set, two zeros in a line indicate the end of the input.
Output
For each data set, print the secret number on a line. Leading zeros should be suppressed.
Example
Input
7 4
9R2A993
0E314A0
8A900DE
820R037
6 7
JH03HE
ID7722
0DA1AH
30C9G5
99971A
CA7EAI
AHLBEM
20 2
A1234567891234CBDEGH
BDEDF908034265091499
0 0
Output
23900037
771971
12345908034265091499
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define P pair<int,int>
char s[100][100];
bool num(int i,int j){
return ('0'<=s[i][j]&&s[i][j]<='9');
}
bool g(string a,string b){
if(a.size()!=b.size()) return (a.size()<b.size());
int i=0;
while(a.size()!=i){
if(a[i]!=b[i]) return (a[i]<b[i]);
i++;
}
return true;
}
void f(int w,int h){
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
s[i][j]=0;
}
}
vector<vector<string>> dp(h,vector<string>(w));
for(int i=0;i<h;i++){
cin>>s[i];
}
string ans="";
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(!num(i,j))continue;
if(i==0&&j==0&&s[i][j]!='0') dp[i][j]=s[i][j];
else if(i==0&&j>0&&!(dp[i][j-1]==""&&s[i][j]=='0')) dp[i][j]=dp[i][j-1]+s[i][j];
else if(j==0&&i>0&&!(dp[i-1][j]==""&&s[i][j]=='0')) dp[i][j]=dp[i-1][j]+s[i][j];
else if(i>0&&j>0){
if(g(dp[i-1][j],dp[i][j-1])&&!(dp[i][j-1]==""&&s[i][j]=='0'))
dp[i][j]=dp[i][j-1]+s[i][j];
else if(!(dp[i-1][j]==""&&s[i][j]=='0'))
dp[i][j]=dp[i-1][j]+s[i][j];
}
if(g(ans,dp[i][j]))
ans=dp[i][j];
}
}
cout<<ans<<endl;
}
int main(){
int w,h;
while(true){
cin>>w>>h;
if(w==0) break;
f(w,h);
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
A wise king declared a new calendar. "Tomorrow shall be the first day of the calendar, that is, the day 1 of the month 1 of the year 1. Each year consists of 10 months, from month 1 through month 10, and starts from a big month. A common year shall start with a big month, followed by small months and big months one after another. Therefore the first month is a big month, the second month is a small month, the third a big month, ..., and the 10th and last month a small one. A big month consists of 20 days and a small month consists of 19 days. However years which are multiples of three, that are year 3, year 6, year 9, and so on, shall consist of 10 big months and no small month."
Many years have passed since the calendar started to be used. For celebration of the millennium day (the year 1000, month 1, day 1), a royal lottery is going to be organized to send gifts to those who have lived as many days as the number chosen by the lottery. Write a program that helps people calculate the number of days since their birthdate to the millennium day.
Input
The input is formatted as follows.
> n
> Y1 M1 D1
> Y2 M2 D2
> ...
> Yn Mn Dn
Here, the first line gives the number of datasets as a positive integer n, which is less than or equal to 100. It is followed by n datasets. Each dataset is formatted in a line and gives three positive integers, Yi (< 1000), Mi (≤ 10), and Di (≤ 20), that correspond to the year, month and day, respectively, of a person's birthdate in the king's calendar. These three numbers are separated by a space.
Output
For the birthdate specified in each dataset, print in a line the number of days from the birthdate, inclusive, to the millennium day, exclusive. Output lines should not contain any character other than this number.
Sample Input
8
1 1 1
344 3 1
696 5 1
182 9 5
998 8 7
344 2 19
696 4 19
999 10 20
Output for the Sample Input
196470
128976
59710
160715
252
128977
59712
1
Example
Input
8
1 1 1
344 3 1
696 5 1
182 9 5
998 8 7
344 2 19
696 4 19
999 10 20
Output
196470
128976
59710
160715
252
128977
59712
1
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
for (int i = 0; i < n; i++){
int Y, M, D;
cin >> Y >> M >> D;
int offset = (10 - M + 1) * 20 - (D - 1);
if (Y % 3 != 0){
offset -= (12 - M) / 2; //小の月の分を引く。 int/intだが問題ない
}
Y++;
int uruutime = (1002 - Y) / 3;
int ans = offset + 195 * (1000 - Y) + uruutime * 5;
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You're given a matrix A of size n × n.
Let's call the matrix with nonnegative elements magic if it is symmetric (so aij = aji), aii = 0 and aij ≤ max(aik, ajk) for all triples i, j, k. Note that i, j, k do not need to be distinct.
Determine if the matrix is magic.
As the input/output can reach very huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 ≤ n ≤ 2500) — the size of the matrix A.
Each of the next n lines contains n integers aij (0 ≤ aij < 109) — the elements of the matrix A.
Note that the given matrix not necessarily is symmetric and can be arbitrary.
Output
Print ''MAGIC" (without quotes) if the given matrix A is magic. Otherwise print ''NOT MAGIC".
Examples
Input
3
0 1 2
1 0 2
2 2 0
Output
MAGIC
Input
2
0 1
2 3
Output
NOT MAGIC
Input
4
0 1 2 3
1 0 3 4
2 3 0 5
3 4 5 0
Output
NOT MAGIC
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool f = false;
char ch = getchar();
while (!isdigit(ch)) {
f |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
const int N = 2505, INF = 0x7fffffff;
int n;
int a[N][N];
int fa[N], d[N];
bool vis[N];
inline void prim() {
for (int i = 2; i <= n; i++) fa[i] = 1, d[i] = a[1][i];
memset(vis, false, sizeof(vis));
vis[1] = true;
int k, minn;
for (int tot = 2; tot <= n; tot++) {
minn = INF;
for (int i = 1; i <= n; i++)
if (minn > d[i] && !vis[i]) minn = d[i], k = i;
vis[k] = true;
for (int i = 1; i <= n; i++)
if (a[k][i] < d[i] && !vis[i]) d[i] = a[k][i], fa[i] = k;
}
}
int dep[N];
void getdep(int x) {
if (!dep[fa[x]]) getdep(fa[x]);
dep[x] = dep[fa[x]] + 1;
}
int main() {
n = read();
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= n; j++) a[i][j] = read();
for (register int i = 1; i <= n; i++)
if (a[i][i]) return puts("NOT MAGIC"), 0;
for (register int i = 1; i <= n; i++)
for (register int j = i + 1; j <= n; j++)
if (a[i][j] != a[j][i]) return puts("NOT MAGIC"), 0;
prim();
dep[1] = 1;
for (int i = 2; i <= n; i++)
if (!dep[i]) getdep(i);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
int x = i, y = j;
if (dep[x] < dep[y]) swap(x, y);
if (a[x][y] > max(a[fa[x]][y], a[fa[x]][x])) return puts("NOT MAGIC"), 0;
}
return puts("MAGIC"), 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You have a positive integer m and a non-negative integer s. Your task is to find the smallest and the largest of the numbers that have length m and sum of digits s. The required numbers should be non-negative integers written in the decimal base without leading zeroes.
Input
The single line of the input contains a pair of integers m, s (1 ≤ m ≤ 100, 0 ≤ s ≤ 900) — the length and the sum of the digits of the required numbers.
Output
In the output print the pair of the required non-negative integer numbers — first the minimum possible number, then — the maximum possible number. If no numbers satisfying conditions required exist, print the pair of numbers "-1 -1" (without the quotes).
Examples
Input
2 15
Output
69 96
Input
3 0
Output
-1 -1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void getio();
void solve() {
long long m, s;
cin >> m >> s;
if (m == 1 and s == 0) {
cout << "0 0";
return;
}
if (!s) {
cout << "-1 -1";
return;
}
std::vector<long long> ans;
long long i = 9;
long long use = 0;
while (use != s and i != 0) {
if (use + i > s)
i--;
else {
use += i;
ans.push_back(i);
}
if (ans.size() > m) {
cout << "-1 -1" << endl;
return;
}
}
long long zero = 0;
while (ans.size() != m) {
zero++;
ans.push_back(0);
}
if (use == s) {
std::vector<long long> one = ans;
reverse(one.begin(), one.end());
for (long long i = 0; i < m; i++)
if (one[i]) {
one[i] -= 1;
break;
}
one[0] += 1;
for (long long i = 0; i < m; i++) cout << one[i];
cout << ' ';
for (long long i = 0; i < m; i++) cout << ans[i];
} else
cout << "-1 -1";
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
getio();
solve();
}
void getio() {}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.