text
stringlengths 424
69.5k
|
|---|
### Prompt
Generate a cpp solution to the following problem:
There are n balls. They are arranged in a row. Each ball has a color (for convenience an integer) and an integer value. The color of the i-th ball is ci and the value of the i-th ball is vi.
Squirrel Liss chooses some balls and makes a new sequence without changing the relative order of the balls. She wants to maximize the value of this sequence.
The value of the sequence is defined as the sum of following values for each ball (where a and b are given constants):
* If the ball is not in the beginning of the sequence and the color of the ball is same as previous ball's color, add (the value of the ball) Γ a.
* Otherwise, add (the value of the ball) Γ b.
You are given q queries. Each query contains two integers ai and bi. For each query find the maximal value of the sequence she can make when a = ai and b = bi.
Note that the new sequence can be empty, and the value of an empty sequence is defined as zero.
Input
The first line contains two integers n and q (1 β€ n β€ 105; 1 β€ q β€ 500). The second line contains n integers: v1, v2, ..., vn (|vi| β€ 105). The third line contains n integers: c1, c2, ..., cn (1 β€ ci β€ n).
The following q lines contain the values of the constants a and b for queries. The i-th of these lines contains two integers ai and bi (|ai|, |bi| β€ 105).
In each line integers are separated by single spaces.
Output
For each query, output a line containing an integer β the answer to the query. The i-th line contains the answer to the i-th query in the input order.
Please, do not write 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
6 3
1 -2 3 4 0 -1
1 2 1 2 1 1
5 1
-2 1
1 0
Output
20
9
4
Input
4 1
-3 6 -1 2
1 2 3 1
1 -1
Output
5
Note
In the first example, to achieve the maximal value:
* In the first query, you should select 1st, 3rd, and 4th ball.
* In the second query, you should select 3rd, 4th, 5th and 6th ball.
* In the third query, you should select 2nd and 4th ball.
Note that there may be other ways to achieve the maximal value.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
set<pair<long long, long long> > s;
long long dp[200005], val[200005], a, b, tmp, ans, mx[200005];
pair<long long, long long> ls[5];
int v[200005], pre[200005], cur, n, q, cl[200005], now;
long long gt(int c) {
long long res = -(long long)1e18;
for (int i = 0; i < now; i++)
if (ls[i].first != c) res = max(res, ls[i].second);
return res;
}
void ins(pair<long long, long long> P) {
for (int i = 0; i < now; i++)
if (ls[i].first == P.first) {
ls[i].second = max(ls[i].second, P.second);
return;
}
if (now < 2)
ls[now++] = P;
else {
if (ls[1].second < ls[0].second) swap(ls[0], ls[1]);
if (ls[0].second < P.second) ls[0] = P;
}
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &val[i]);
for (int i = 1; i <= n; i++) scanf("%d", &cl[i]);
v[0] = 200005;
dp[0] = 0;
while (q--) {
scanf("%lld%lld", &a, &b);
for (int i = 1; i <= n; i++) mx[i] = -(long long)1e18;
now = 1;
ls[0] = make_pair(-1, 0);
ans = 0LL;
for (int i = 1; i <= n; i++) {
tmp = gt(cl[i]);
if (mx[cl[i]] == -(long long)1e18) {
dp[i] = tmp + val[i] * b;
ins(make_pair(cl[i], dp[i]));
} else {
if (mx[cl[i]] + val[i] * a > tmp + val[i] * b)
dp[i] = mx[cl[i]] + val[i] * a;
else
dp[i] = tmp + val[i] * b;
ins(make_pair(cl[i], dp[i]));
}
mx[cl[i]] = max(mx[cl[i]], dp[i]);
ans = max(ans, dp[i]);
}
printf("%lld\n", ans);
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x β
2
* x β
4
* x β
8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 1000) β the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 β€ a, b β€ 10^{18}) β the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
long long a, b;
cin >> a >> b;
if (a > b) swap(a, b);
int ans = 0;
while (a < b) {
if (a * 8 <= b)
a *= 8;
else if (a * 4 <= b)
a *= 4;
else
a *= 2;
ans++;
}
if (a == b)
cout << ans << endl;
else
cout << -1 << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
It is known that passages in Singer house are complex and intertwined. Let's define a Singer k-house as a graph built by the following process: take complete binary tree of height k and add edges from each vertex to all its successors, if they are not yet present.
<image> Singer 4-house
Count the number of non-empty paths in Singer k-house which do not pass the same vertex twice. Two paths are distinct if the sets or the orders of visited vertices are different. Since the answer can be large, output it modulo 109 + 7.
Input
The only line contains single integer k (1 β€ k β€ 400).
Output
Print single integer β the answer for the task modulo 109 + 7.
Examples
Input
2
Output
9
Input
3
Output
245
Input
20
Output
550384565
Note
There are 9 paths in the first example (the vertices are numbered on the picture below): 1, 2, 3, 1-2, 2-1, 1-3, 3-1, 2-1-3, 3-1-2.
<image> Singer 2-house
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long dp[400 + 5][400 + 5];
void init() {
memset(dp, 0, sizeof(dp));
dp[1][1] = dp[1][0] = 1;
for (int i = 2; i <= 400; i++)
for (int j = 0; j <= 400; j++)
for (int k = 0; k + j <= 400; k++) {
long long temp = (dp[i - 1][j] * dp[i - 1][k]) % 1000000007;
dp[i][j + k] = (dp[i][j + k] + temp) % 1000000007;
dp[i][j + k - 1] =
(dp[i][j + k - 1] + temp * (k + j) * (k + j - 1)) % 1000000007;
dp[i][j + k + 1] = (dp[i][j + k + 1] + temp) % 1000000007;
dp[i][j + k] = (dp[i][j + k] + (temp * (k + j) * 2)) % 1000000007;
}
}
int main() {
init();
int n;
while (~scanf("%d", &n)) {
printf("%lld\n", dp[n][1]);
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 β€ n β€ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 β€ u, v β€ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k β the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)3e3 + 111;
const int N = (int)3e5 + 111;
const int INF = (int)1e9 + 111;
const int MOD = (int)1e9 + 7;
vector<int> g[N];
bool used[N];
int cnt[N], ans;
int dfs(int v) {
used[v] = 1;
for (int to : g[v])
if (!used[to])
if (!dfs(to)) cnt[v] = 1 - cnt[v];
return cnt[v];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0, x, y; i < n - 1; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
if (n % 2) {
cout << -1;
return 0;
}
dfs(1);
for (int i = 1; i <= n; i++) ans += cnt[i];
cout << --ans;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given n points on a line with their coordinates xi. Find the point x so the sum of distances to the given points is minimal.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of points on the line.
The second line contains n integers xi ( - 109 β€ xi β€ 109) β the coordinates of the given n points.
Output
Print the only integer x β the position of the optimal point on the line. If there are several optimal points print the position of the leftmost one. It is guaranteed that the answer is always the integer.
Example
Input
4
1 2 3 4
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
sort(arr.begin(), arr.end());
cout << arr[(n - 1) / 2] << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
The Smart Beaver has recently designed and built an innovative nanotechnologic all-purpose beaver mass shaving machine, "Beavershave 5000". Beavershave 5000 can shave beavers by families! How does it work? Very easily!
There are n beavers, each of them has a unique id from 1 to n. Consider a permutation a1, a2, ..., an of n these beavers. Beavershave 5000 needs one session to shave beavers with ids from x to y (inclusive) if and only if there are such indices i1 < i2 < ... < ik, that ai1 = x, ai2 = x + 1, ..., aik - 1 = y - 1, aik = y. And that is really convenient. For example, it needs one session to shave a permutation of beavers 1, 2, 3, ..., n.
If we can't shave beavers from x to y in one session, then we can split these beavers into groups [x, p1], [p1 + 1, p2], ..., [pm + 1, y] (x β€ p1 < p2 < ... < pm < y), in such a way that the machine can shave beavers in each group in one session. But then Beavershave 5000 needs m + 1 working sessions to shave beavers from x to y.
All beavers are restless and they keep trying to swap. So if we consider the problem more formally, we can consider queries of two types:
* what is the minimum number of sessions that Beavershave 5000 needs to shave beavers with ids from x to y, inclusive?
* two beavers on positions x and y (the beavers ax and ay) swapped.
You can assume that any beaver can be shaved any number of times.
Input
The first line contains integer n β the total number of beavers, 2 β€ n. The second line contains n space-separated integers β the initial beaver permutation.
The third line contains integer q β the number of queries, 1 β€ q β€ 105. The next q lines contain the queries. Each query i looks as pi xi yi, where pi is the query type (1 is to shave beavers from xi to yi, inclusive, 2 is to swap beavers on positions xi and yi). All queries meet the condition: 1 β€ xi < yi β€ n.
* to get 30 points, you need to solve the problem with constraints: n β€ 100 (subproblem B1);
* to get 100 points, you need to solve the problem with constraints: n β€ 3Β·105 (subproblems B1+B2).
Note that the number of queries q is limited 1 β€ q β€ 105 in both subproblem B1 and subproblem B2.
Output
For each query with pi = 1, print the minimum number of Beavershave 5000 sessions.
Examples
Input
5
1 3 4 2 5
6
1 1 5
1 3 4
2 2 3
1 1 5
2 1 5
1 1 5
Output
2
1
3
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int A[300010];
int I[300010];
void TheSolution(istream& input, ostream& output) {
int n, m, a, b, t;
input >> n;
for (int i = 1; i < n + 1; ++i) {
input >> A[i];
I[A[i]] = i;
}
input >> m;
for (int i = 0; i < m; ++i) {
input >> t >> a >> b;
if (t == 1) {
int cnt = 1;
for (int j = a; j < b; ++j) {
if (I[j + 1] < I[j]) cnt++;
}
output << cnt << "\n";
} else {
swap(I[A[a]], I[A[b]]);
swap(A[a], A[b]);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
TheSolution(cin, cout);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int x;
cin>>x;
for(int i=-119;i<119;i++){
for(int j=-119;j<119;j++){
if(x==i*i*i*i*i-j*j*j*j*j){
cout<<i<<endl;
cout<<j<<endl;
return 0;
}
}
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
There is a robot on a coordinate plane. Initially, the robot is located at the point (0, 0). Its path is described as a string s of length n consisting of characters 'L', 'R', 'U', 'D'.
Each of these characters corresponds to some move:
* 'L' (left): means that the robot moves from the point (x, y) to the point (x - 1, y);
* 'R' (right): means that the robot moves from the point (x, y) to the point (x + 1, y);
* 'U' (up): means that the robot moves from the point (x, y) to the point (x, y + 1);
* 'D' (down): means that the robot moves from the point (x, y) to the point (x, y - 1).
The company that created this robot asked you to optimize the path of the robot somehow. To do this, you can remove any non-empty substring of the path. But this company doesn't want their customers to notice the change in the robot behavior. It means that if before the optimization the robot ended its path at the point (x_e, y_e), then after optimization (i.e. removing some single substring from s) the robot also ends its path at the point (x_e, y_e).
This optimization is a low-budget project so you need to remove the shortest possible non-empty substring to optimize the robot's path such that the endpoint of his path doesn't change. It is possible that you can't optimize the path. Also, it is possible that after the optimization the target path is an empty string (i.e. deleted substring is the whole string s).
Recall that the substring of s is such string that can be obtained from s by removing some amount of characters (possibly, zero) from the prefix and some amount of characters (possibly, zero) from the suffix. For example, the substrings of "LURLLR" are "LU", "LR", "LURLLR", "URL", but not "RR" and "UL".
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The next 2t lines describe test cases. Each test case is given on two lines. The first line of the test case contains one integer n (1 β€ n β€ 2 β
10^5) β the length of the robot's path. The second line of the test case contains one string s consisting of n characters 'L', 'R', 'U', 'D' β the robot's path.
It is guaranteed that the sum of n over all test cases does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer on it. If you cannot remove such non-empty substring that the endpoint of the robot's path doesn't change, print -1. Otherwise, print two integers l and r such that 1 β€ l β€ r β€ n β endpoints of the substring you remove. The value r-l+1 should be minimum possible. If there are several answers, print any of them.
Example
Input
4
4
LRUD
4
LURD
5
RRUDU
5
LLDDR
Output
1 2
1 4
3 4
-1
### Response
```cpp
#include <bits/stdc++.h>
const long long MAX_SIZE = 2005;
using namespace std;
int main() {
long long i, j, k, t, n, x, y;
string a, s;
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
cin >> s;
k = 100000007;
long long ans1 = 100000007, ans2 = 100000007;
map<long long, map<long long, long long> > m;
x = y = 0;
m[0][0] = 1;
for (i = 0; i < n; i++) {
if (s[i] == 'L')
x--;
else if (s[i] == 'R')
x++;
else if (s[i] == 'U')
y++;
else
y--;
if (m[x][y] == 0) {
m[x][y] = i + 2;
continue;
}
j = i + 2 - m[x][y];
if (j < k) {
k = j;
ans1 = m[x][y];
ans2 = i + 2;
}
m[x][y] = i + 2;
}
if (ans1 == 100000007)
cout << "-1\n";
else
cout << ans1 << " " << --ans2 << "\n";
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
A dice is a cube, its faces contain distinct integers from 1 to 6 as black points. The sum of numbers at the opposite dice faces always equals 7. Please note that there are only two dice (these dices are mirror of each other) that satisfy the given constraints (both of them are shown on the picture on the left).
<image>
Alice and Bob play dice. Alice has built a tower from n dice. We know that in this tower the adjacent dice contact with faces with distinct numbers. Bob wants to uniquely identify the numbers written on the faces of all dice, from which the tower is built. Unfortunately, Bob is looking at the tower from the face, and so he does not see all the numbers on the faces. Bob sees the number on the top of the tower and the numbers on the two adjacent sides (on the right side of the picture shown what Bob sees).
Help Bob, tell whether it is possible to uniquely identify the numbers on the faces of all the dice in the tower, or not.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of dice in the tower.
The second line contains an integer x (1 β€ x β€ 6) β the number Bob sees at the top of the tower. Next n lines contain two space-separated integers each: the i-th line contains numbers ai, bi (1 β€ ai, bi β€ 6; ai β bi) β the numbers Bob sees on the two sidelong faces of the i-th dice in the tower.
Consider the dice in the tower indexed from top to bottom from 1 to n. That is, the topmost dice has index 1 (the dice whose top face Bob can see). It is guaranteed that it is possible to make a dice tower that will look as described in the input.
Output
Print "YES" (without the quotes), if it is possible to to uniquely identify the numbers on the faces of all the dice in the tower. If it is impossible, print "NO" (without the quotes).
Examples
Input
3
6
3 2
5 4
2 4
Output
YES
Input
3
3
2 6
4 1
5 3
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
int n;
int top;
int a[199], b[199];
void suru() {
scanf("%d", &n);
scanf("%d", &top);
for (int i = 0; i < n; i++) scanf("%d %d", a + i, b + i);
}
int c[10];
void truli() {
int flag = 1;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 6; j++) c[j] = 0;
c[a[i]]++;
c[b[i]]++;
c[7 - a[i]]++;
c[7 - b[i]]++;
int ff = 1, da = -1, db = -1;
for (int j = 1; j <= 6; j++) {
if (c[j] == 0) {
if (da == -1)
da = j;
else
db = j;
}
}
if (da == top) std::swap(da, db);
if (db != top) {
flag = 0;
break;
} else
top = db;
}
if (flag)
puts("YES");
else
puts("NO");
}
void sutru() {}
int main() {
suru();
truli();
sutru();
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Ivan wants to make a necklace as a present to his beloved girl. A necklace is a cyclic sequence of beads of different colors. Ivan says that necklace is beautiful relative to the cut point between two adjacent beads, if the chain of beads remaining after this cut is a palindrome (reads the same forward and backward).
<image>
Ivan has beads of n colors. He wants to make a necklace, such that it's beautiful relative to as many cuts as possible. He certainly wants to use all the beads. Help him to make the most beautiful necklace.
Input
The first line of the input contains a single number n (1 β€ n β€ 26) β the number of colors of beads. The second line contains after n positive integers ai β the quantity of beads of i-th color. It is guaranteed that the sum of ai is at least 2 and does not exceed 100 000.
Output
In the first line print a single number β the maximum number of beautiful cuts that a necklace composed from given beads may have. In the second line print any example of such necklace.
Each color of the beads should be represented by the corresponding lowercase English letter (starting with a). As the necklace is cyclic, print it starting from any point.
Examples
Input
3
4 2 1
Output
1
abacaba
Input
1
4
Output
4
aaaa
Input
2
1 1
Output
0
ab
Note
In the first sample a necklace can have at most one beautiful cut. The example of such a necklace is shown on the picture.
In the second sample there is only one way to compose a necklace.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
int n, arr[1001];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
cin >> n;
int odd = 0, g = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
g = gcd(arr[i], g);
if (arr[i] & 1) odd++;
}
if (odd > 1) {
cout << 0 << endl;
for (int i = 0; i < n; i++)
for (int j = 0; j < arr[i]; j++) cout << char('a' + i);
return 0;
}
if (odd == 1) {
char center;
string Left;
for (int i = 0; i < n; i++) {
if (arr[i] & 1)
center = 'a' + i;
else {
for (int j = 0; j < arr[i] / g / 2; j++) Left += char('a' + i);
}
}
string ans = Left;
for (int i = 0; i < arr[center - 'a'] / g; i++) ans += center;
reverse((Left).begin(), (Left).end());
ans += Left;
cout << g << endl;
for (int i = 0; i < g; i++) cout << ans;
return 0;
}
cout << g << endl;
string ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < arr[i] / g; j++) ans += char('a' + i);
}
for (int i = 0; i < g; i++) {
cout << ans;
reverse((ans).begin(), (ans).end());
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
A prime number is an integer that is greater than 1 and can only be divided by itself or 1. For example, 2 is a prime number because it is divisible only by 2 and 1, but 12 is not a prime number because it is divisible by 2, 3, 4, 6 in addition to 12 and 1.
When you enter the integer n, write a program that outputs the largest prime number less than n and the smallest prime number greater than n.
Input
Given multiple datasets. Each dataset is given n (3 β€ n β€ 50,000) on one row.
The number of datasets does not exceed 50.
Output
For each dataset, output the largest prime number less than n and the smallest prime number greater than n on one line, separated by a space.
Example
Input
19
3517
Output
17 23
3511 3527
### Response
```cpp
#include<iostream>
#include<string.h>
using namespace std;
int isprime[50101];
int main() {
memset(isprime, 0, sizeof(isprime));
for(int i=4; i<50101; i+=2) isprime[i] = 1;
isprime[1] = 1;
for(int i=3; i*i<50101; i+=2)
if(isprime[i] == 0)
for(int j=2; i*j<50101; ++j)
isprime[i*j] = 1;
int n;
while(cin>>n) {
for(int k=n-1; k>0; --k)
if(isprime[k] == 0) {
cout<<k<<" ";
break;
}
for(int k=n+1; k<50101; ++k)
if(isprime[k] == 0) {
cout<<k<<endl;
break;
}
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are given a string of length n. Each character is one of the first p lowercase Latin letters.
You are also given a matrix A with binary values of size p Γ p. This matrix is symmetric (A_{ij} = A_{ji}). A_{ij} = 1 means that the string can have the i-th and j-th letters of Latin alphabet adjacent.
Let's call the string crisp if all of the adjacent characters in it can be adjacent (have 1 in the corresponding cell of matrix A).
You are allowed to do the following move. Choose any letter, remove all its occurrences and join the remaining parts of the string without changing their order. For example, removing letter 'a' from "abacaba" will yield "bcb".
The string you are given is crisp. The string should remain crisp after every move you make.
You are allowed to do arbitrary number of moves (possible zero). What is the shortest resulting string you can obtain?
Input
The first line contains two integers n and p (1 β€ n β€ 10^5, 1 β€ p β€ 17) β the length of the initial string and the length of the allowed prefix of Latin alphabet.
The second line contains the initial string. It is guaranteed that it contains only first p lowercase Latin letters and that is it crisp. Some of these p first Latin letters might not be present in the string.
Each of the next p lines contains p integer numbers β the matrix A (0 β€ A_{ij} β€ 1, A_{ij} = A_{ji}). A_{ij} = 1 means that the string can have the i-th and j-th letters of Latin alphabet adjacent.
Output
Print a single integer β the length of the shortest string after you make arbitrary number of moves (possible zero).
Examples
Input
7 3
abacaba
0 1 1
1 0 0
1 0 0
Output
7
Input
7 3
abacaba
1 1 1
1 0 0
1 0 0
Output
0
Input
7 4
bacadab
0 1 1 1
1 0 0 0
1 0 0 0
1 0 0 0
Output
5
Input
3 3
cbc
0 0 0
0 0 1
0 1 0
Output
0
Note
In the first example no letter can be removed from the initial string.
In the second example you can remove letters in order: 'b', 'c', 'a'. The strings on the intermediate steps will be: "abacaba" β "aacaa" β "aaaa" β "".
In the third example you can remove letter 'b' and that's it.
In the fourth example you can remove letters in order 'c', 'b', but not in the order 'b', 'c' because two letters 'c' can't be adjacent.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, p;
cin >> n >> p;
string S;
cin >> S;
vector<int> s(n);
int a[p][p];
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> a[i][j];
}
}
vector<int> cnt(p);
for (int i = 0; i < n; i++) {
s[i] = S[i] - 'a';
cnt[s[i]]++;
}
vector<bool> valid(1 << p, 1);
for (int c1 = 0; c1 < p; c1++) {
for (int c2 = 0; c2 < p; c2++) {
if (a[c1][c2]) continue;
vector<bool> gud(1 << p, 1);
for (int i = 0; i < n; i++) {
if (s[i] != c1) continue;
int j = i + 1;
for (; j < n; j++) {
if (s[j] == c1 || s[j] == c2) break;
}
if (j == n) break;
if (c1 != c2 && s[i] == s[j]) continue;
int mask = (1 << p) - 1;
for (int k = i + 1; k < j; k++) {
if (mask & (1 << s[k])) {
mask ^= (1 << s[k]);
}
}
gud[mask] = 0;
}
for (int mask = (1 << p) - 1; mask >= 0; mask--) {
if (gud[mask]) continue;
for (int i = 0; i < p; i++) {
if (c1 == i) continue;
if (c2 == i) continue;
if (mask & (1 << i)) gud[mask ^ (1 << i)] = 0;
}
valid[mask] = 0;
}
}
}
int initial = 0;
for (int i = 0; i < p; i++) {
if (cnt[i]) initial |= (1 << i);
}
vector<int> dp(1 << p);
dp[initial] = 1;
for (int mask = initial; mask >= 0; mask--) {
if (!dp[mask]) continue;
for (int i = 0; i < p; i++) {
if (mask & (1 << i)) {
int nxt = mask ^ (1 << i);
if (valid[nxt]) dp[nxt] = 1;
}
}
}
int ans = 100000000;
for (int mask = 0; mask < (1 << p); mask++) {
if (dp[mask]) {
int tmp = 0;
for (int i = 0; i < p; i++) {
if (mask & (1 << i)) tmp += cnt[i];
}
ans = min(ans, tmp);
}
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
We have a rectangular parallelepiped of size AΓBΓC, built with blocks of size 1Γ1Γ1. Snuke will paint each of the AΓBΓC blocks either red or blue, so that:
* There is at least one red block and at least one blue block.
* The union of all red blocks forms a rectangular parallelepiped.
* The union of all blue blocks forms a rectangular parallelepiped.
Snuke wants to minimize the difference between the number of red blocks and the number of blue blocks. Find the minimum possible difference.
Constraints
* 2β€A,B,Cβ€10^9
Input
The input is given from Standard Input in the following format:
A B C
Output
Print the minimum possible difference between the number of red blocks and the number of blue blocks.
Examples
Input
3 3 3
Output
9
Input
2 2 4
Output
0
Input
5 3 5
Output
15
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long A, B, C;
cin >> A >> B >> C;
cout << min(min((A%2!=0)*B*C, (B%2!=0)*A*C), (C%2!=0)*A*B) << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
In programming languages like C/C++, a goto statement provides an unconditional jump from the "goto" to a labeled statement. For example, a statement "goto CHECK_NUM;" is executed, control of the program jumps to CHECK_NUM. Using these constructs, you can implement, for example, loops.
Note that use of goto statement is highly discouraged, because it is difficult to trace the control flow of a program which includes goto.
Write a program which does precisely the same thing as the following program (this example is wrtten in C++). Let's try to write the program without goto statements.
void call(int n){
int i = 1;
CHECK_NUM:
int x = i;
if ( x % 3 == 0 ){
cout << " " << i;
goto END_CHECK_NUM;
}
INCLUDE3:
if ( x % 10 == 3 ){
cout << " " << i;
goto END_CHECK_NUM;
}
x /= 10;
if ( x ) goto INCLUDE3;
END_CHECK_NUM:
if ( ++i <= n ) goto CHECK_NUM;
cout << endl;
}
Constraints
* 3 β€ n β€ 10000
Input
An integer n is given in a line.
Output
Print the output result of the above program for given integer n.
Example
Input
30
Output
3 6 9 12 13 15 18 21 23 24 27 30
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int i, x, n;
cin >> n;
for (i = 1; i <= n; i++) {
x = i;
if (x % 3 == 0) cout << " " << i;
else {
while(x) {
if (x % 10 == 3) {
cout << " " << i;
break;
}
x /= 10;
}
}
}
cout << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
This problem is same as the next one, but has smaller constraints.
Aki is playing a new video game. In the video game, he will control Neko, the giant cat, to fly between planets in the Catniverse.
There are n planets in the Catniverse, numbered from 1 to n. At the beginning of the game, Aki chooses the planet where Neko is initially located. Then Aki performs k - 1 moves, where in each move Neko is moved from the current planet x to some other planet y such that:
* Planet y is not visited yet.
* 1 β€ y β€ x + m (where m is a fixed constant given in the input)
This way, Neko will visit exactly k different planets. Two ways of visiting planets are called different if there is some index i such that the i-th planet visited in the first way is different from the i-th planet visited in the second way.
What is the total number of ways to visit k planets this way? Since the answer can be quite large, print it modulo 10^9 + 7.
Input
The only line contains three integers n, k and m (1 β€ n β€ 10^5, 1 β€ k β€ min(n, 12), 1 β€ m β€ 4) β the number of planets in the Catniverse, the number of planets Neko needs to visit and the said constant m.
Output
Print exactly one integer β the number of different ways Neko can visit exactly k planets. Since the answer can be quite large, print it modulo 10^9 + 7.
Examples
Input
3 3 1
Output
4
Input
4 2 1
Output
9
Input
5 5 4
Output
120
Input
100 1 2
Output
100
Note
In the first example, there are 4 ways Neko can visit all the planets:
* 1 β 2 β 3
* 2 β 3 β 1
* 3 β 1 β 2
* 3 β 2 β 1
In the second example, there are 9 ways Neko can visit exactly 2 planets:
* 1 β 2
* 2 β 1
* 2 β 3
* 3 β 1
* 3 β 2
* 3 β 4
* 4 β 1
* 4 β 2
* 4 β 3
In the third example, with m = 4, Neko can visit all the planets in any order, so there are 5! = 120 ways Neko can visit all the planets.
In the fourth example, Neko only visit exactly 1 planet (which is also the planet he initially located), and there are 100 ways to choose the starting planet for Neko.
### Response
```cpp
#include <bits/stdc++.h>
long long n, k, m, cnt;
long long id[15][20];
struct matrix {
long long c[210][210];
matrix() { memset(c, 0, sizeof(c)); }
matrix operator*(matrix &v) {
matrix ans;
for (long long i = 1; i <= cnt; i++)
for (long long j = 1; j <= cnt; j++)
for (long long k = 1; k <= cnt; k++)
ans[i][j] = (ans[i][j] + c[i][k] * v[k][j] % 1000000007) % 1000000007;
return ans;
}
long long *operator[](long long x) { return c[x]; }
} g, f;
signed main() {
scanf("%lld %lld %lld", &n, &k, &m);
for (long long i = 0; i <= k; i++)
for (long long j = 0; j < (1 << m); j++) id[i][j] = ++cnt;
for (long long i = 0; i <= k; i++)
for (long long s = 0; s < (1 << m); s++) {
long long t = s << 1 & ((1 << m) - 1);
(g[id[i][s]][id[i][t]] += 1) %= 1000000007;
if (i < k)
(g[id[i][s]][id[i + 1][t | 1]] += __builtin_popcount(s) + 1) %=
1000000007;
}
f[1][1] = 1;
while (n) {
if (n & 1) f = f * g;
g = g * g;
n >>= 1;
}
long long ret = 0;
for (long long i = 0; i < (1 << m); i++)
ret = (ret + f[1][id[k][i]]) % 1000000007;
printf("%lld\n", ret);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Sereja showed an interesting game to his friends. The game goes like that. Initially, there is a table with an empty cup and n water mugs on it. Then all players take turns to move. During a move, a player takes a non-empty mug of water and pours all water from it into the cup. If the cup overfills, then we assume that this player lost.
As soon as Sereja's friends heard of the game, they wanted to play it. Sereja, on the other hand, wanted to find out whether his friends can play the game in such a way that there are no losers. You are given the volumes of all mugs and the cup. Also, you know that Sereja has (n - 1) friends. Determine if Sereja's friends can play the game so that nobody loses.
Input
The first line contains integers n and s (2 β€ n β€ 100; 1 β€ s β€ 1000) β the number of mugs and the volume of the cup. The next line contains n integers a1, a2, ..., an (1 β€ ai β€ 10). Number ai means the volume of the i-th mug.
Output
In a single line, print "YES" (without the quotes) if his friends can play in the described manner, and "NO" (without the quotes) otherwise.
Examples
Input
3 4
1 1 1
Output
YES
Input
3 4
3 1 3
Output
YES
Input
3 4
4 4 4
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, s, sum, ma;
int main() {
scanf("%d%d", &n, &s);
for (int i(0); i < n; ++i) {
int a;
scanf("%d", &a);
sum += a, ma = ma > a ? ma : a;
}
sum -= ma;
if (sum > s)
puts("NO");
else
puts("YES");
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Ancient Egyptians are known to have understood difficult concepts in mathematics. The ancient Egyptian mathematician Ahmes liked to write a kind of arithmetic expressions on papyrus paper which he called as Ahmes arithmetic expression.
An Ahmes arithmetic expression can be defined as:
* "d" is an Ahmes arithmetic expression, where d is a one-digit positive integer;
* "(E1 op E2)" is an Ahmes arithmetic expression, where E1 and E2 are valid Ahmes arithmetic expressions (without spaces) and op is either plus ( + ) or minus ( - ).
For example 5, (1-1) and ((1+(2-3))-5) are valid Ahmes arithmetic expressions.
On his trip to Egypt, Fafa found a piece of papyrus paper having one of these Ahmes arithmetic expressions written on it. Being very ancient, the papyrus piece was very worn out. As a result, all the operators were erased, keeping only the numbers and the brackets. Since Fafa loves mathematics, he decided to challenge himself with the following task:
Given the number of plus and minus operators in the original expression, find out the maximum possible value for the expression on the papyrus paper after putting the plus and minus operators in the place of the original erased operators.
Input
The first line contains a string E (1 β€ |E| β€ 104) β a valid Ahmes arithmetic expression. All operators are erased and replaced with '?'.
The second line contains two space-separated integers P and M (0 β€ min(P, M) β€ 100) β the number of plus and minus operators, respectively.
It is guaranteed that P + M = the number of erased operators.
Output
Print one line containing the answer to the problem.
Examples
Input
(1?1)
1 0
Output
2
Input
(2?(1?2))
1 1
Output
1
Input
((1?(5?7))?((6?2)?7))
3 2
Output
18
Input
((1?(5?7))?((6?2)?7))
2 3
Output
16
Note
* The first sample will be (1 + 1) = 2.
* The second sample will be (2 + (1 - 2)) = 1.
* The third sample will be ((1 - (5 - 7)) + ((6 + 2) + 7)) = 18.
* The fourth sample will be ((1 + (5 + 7)) - ((6 - 2) - 7)) = 16.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int p, m;
string str;
vector<vector<int>> f1(int& ind) {
if (('1' <= str[ind]) && (str[ind] <= '9')) {
vector<vector<int>> ans(2, vector<int>(m + 1));
ans[0][0] = ans[1][0] = str[ind] - '0';
for (int i = 1; i <= m; ++i) {
ans[0][i] = -INF;
ans[1][i] = INF;
}
ind++;
return ans;
} else {
ind++;
auto a1 = f1(ind);
ind++;
auto a2 = f1(ind);
ind++;
vector<vector<int>> ans(2, vector<int>(m + 1));
for (int i = 0; i <= m; ++i) {
ans[0][i] = -INF;
ans[1][i] = INF;
}
for (int i = 0; i <= m; ++i) {
for (int j = 0; j + i <= m; ++j) {
ans[0][i + j] = max(ans[0][i + j], a1[0][i] + a2[0][j]);
ans[1][i + j] = min(ans[1][i + j], a1[1][i] + a2[1][j]);
}
}
for (int i = 0; i <= m; ++i) {
for (int j = 0; j + i < m; ++j) {
ans[0][i + j + 1] = max(ans[0][i + j + 1], a1[0][i] - a2[1][j]);
ans[1][i + j + 1] = min(ans[1][i + j + 1], a1[1][i] - a2[0][j]);
}
}
return ans;
}
}
vector<vector<int>> f2(int& ind) {
if (('1' <= str[ind]) && (str[ind] <= '9')) {
vector<vector<int>> ans(2, vector<int>(p + 1));
ans[0][0] = ans[1][0] = str[ind] - '0';
for (int i = 1; i <= p; ++i) {
ans[0][i] = -INF;
ans[1][i] = INF;
}
ind++;
return ans;
} else {
ind++;
auto a1 = f2(ind);
ind++;
auto a2 = f2(ind);
ind++;
vector<vector<int>> ans(2, vector<int>(p + 1));
for (int i = 0; i <= p; ++i) {
ans[0][i] = -INF;
ans[1][i] = INF;
}
for (int i = 0; i <= p; ++i) {
for (int j = 0; j + i <= p; ++j) {
ans[0][i + j] = max(ans[0][i + j], a1[0][i] - a2[1][j]);
ans[1][i + j] = min(ans[1][i + j], a1[1][i] - a2[0][j]);
}
}
for (int i = 0; i <= p; ++i) {
for (int j = 0; j + i < p; ++j) {
ans[0][i + j + 1] = max(ans[0][i + j + 1], a1[0][i] + a2[0][j]);
ans[1][i + j + 1] = min(ans[1][i + j + 1], a1[1][i] + a2[1][j]);
}
}
return ans;
}
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> str;
cin >> p >> m;
int ind = 0;
if (m <= 100) {
auto ans = f1(ind);
cout << ans[0][m] << endl;
} else {
auto ans = f2(ind);
cout << ans[0][p] << endl;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
### Response
```cpp
#include <bits/stdc++.h>
class Data {
public:
int left;
int right;
int res;
};
Data tree[1048576];
void init(int i, int t) {
if (i >= (1 << 19)) return;
int left = (i << 1) + 0;
int right = (i << 1) + 1;
init(left, t / 2);
init(right, t / 2);
Data &L = tree[left];
Data &R = tree[right];
bool INL = L.left == L.right && L.left == t;
bool INR = R.left == R.right && R.left == t;
tree[i].res = L.res + R.res;
if (not(INL || INR)) {
tree[i].res += std::max(0, L.right + R.left - 1);
}
if (INL) {
tree[i].left = L.left + R.left;
} else {
tree[i].left = L.left;
}
if (INR) {
tree[i].right = R.right + L.right;
} else {
tree[i].right = R.right;
}
return;
}
void update(int i, int t) {
if (i <= 1) return;
int left = i / 2 * 2;
int right = i / 2 * 2 + 1;
Data &L = tree[left];
Data &R = tree[right];
i /= 2;
bool INL = L.left == L.right && L.left == t;
bool INR = R.left == R.right && R.left == t;
tree[i].res = L.res + R.res;
if (not(INL || INR)) {
tree[i].res += std::max(0, L.right + R.left - 1);
}
if (INL) {
tree[i].left = L.left + R.left;
} else {
tree[i].left = L.left;
}
if (INR) {
tree[i].right = R.right + L.right;
} else {
tree[i].right = R.right;
}
update(i, t * 2);
}
int ans(void) {
return tree[1].res + std::max(0, tree[1].right - 1) +
std::max(0, tree[1].left - 1);
}
void change(int i, char c) {
Data &temp = tree[i + (1 << 19)];
if (c == '.') {
temp.left = temp.right = 1;
} else {
temp.left = temp.right = 0;
}
temp.res = 0;
return;
}
char str[1048576];
int main() {
int n, m;
std::cin >> n >> m;
scanf("%s", str);
for (int i = 0; i < n; ++i) {
change(i, str[i]);
}
init(1, (1 << 18));
for (int i = 0; i < m; ++i) {
int index;
char c[1];
scanf("%d %s", &index, c);
change(index - 1, c[0]);
update(index - 1 + (1 << 19), 1);
printf("%d\n", ans());
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
At Akabe High School, a programmer training school, there is a unique study session run by the students themselves. It is important for programmers to constantly adopt new technologies, so the aim of this activity is to develop the habit of self-study through this study session.
There are a total of N students, each with a score obtained as a result of the programming contest at the time of admission. At the study session, some of the N students will become leaders, and each leader will run their own group and join the group they run.
Students other than the leader cannot join a group run by a leader with a score lower than their own. In addition, one value r that is 0 or more is decided so that the difference between the scores of the students participating in the group and the leader is within r. That is, if the leader of a group has a score of s and your score is greater than or less than s --r, you will not be able to join the group.
You are the executive committee chair of the study session and decided to do a simulation to prepare for the operation. In the simulation, start with no leader and repeat the following operations several times.
* Add students as leaders.
* Remove the student from the leader.
* For the combination of leaders at the time of request, find the minimum r such that the number of students who cannot participate in any group is x or less.
Create a program that performs such a simulation.
input
The input consists of one dataset. The input is given in the following format.
N Q
s1
s2
::
sN
QUERY1
QUERY2
::
QUERYQ
The first line gives the number of students N (1 β€ N β€ 1000000) and the number of processing requests Q (0 β€ Q β€ 1000).
The following N lines are given the integer si (0 β€ si β€ 1,000,000,000) indicating the score of the i-th student. Students shall be numbered 1,2, ..., N.
The processing request QUERYi is given to the following Q line. Processing requests are given in chronological order. There are three types of processing requests: ADD, REMOVE, and CHECK, and each QUERYi is given in one of the following formats.
ADD a
Or
REMOVE a
Or
CHECK x
ADD a stands for adding a student with the number a (1 β€ a β€ N) to the leader.
REMOVE a represents removing the student with the number a (1 β€ a β€ N) from the leader.
CHECK x represents an output request. An upper limit on the number of students who cannot join any group x (0 β€ x β€ N) is given.
The input shall satisfy the following conditions.
* At any given time, the number of leaders will not exceed 100.
* Do not add students who are leaders at that time to leaders.
* Students who are not leaders at that time will not be removed from the leader.
output
At the time of each output request in chronological order, the minimum r is output on one line so that the number of students who cannot join any group is x or less. However, if it is impossible to reduce the number of people to x or less no matter what r is selected, NA is output.
Example
Input
5 8
5
10
8
7
3
ADD 1
ADD 3
CHECK 0
CHECK 1
CHECK 2
CHECK 3
CHECK 4
CHECK 5
Output
NA
2
1
0
0
0
### Response
```cpp
# define _CRT_SECUREj_NO_WARNINGS 1
# define _USE_MATH_DEFINES
# include <iostream>
# include <numeric>
# include <string>
# include <bitset>
# include <vector>
# include <algorithm>
# include <cstdlib>
# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iomanip>
# include <queue>
# include <sstream>
# include <climits>
# include <cmath>
# include <list>
# include <functional>
# include <string>
# include <ctime>
# include <set>
# include <forward_list>
# include <map>
# include <stack>
using namespace std;
# define INF ((int)(1<<25))
# define REP(i,n) for(int i=0;i<(int)n;i++)
# define FOR(i,n) REP(i,n)
# define TORAD 2.0*M_PI/360.0
# define INT(x) int x;cin>>x;
# define ALL(x) (x).begin(),(x).end()
# define RALL(x) (x).rbegin(),(x).rend()
# define DEBUG(x) cout<<#x<<" :"<<x<<endl;
# define EPS 1e-12
typedef long long lint;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
const int dx[4] = { 0,1,0,-1 }, dy[4] = { -1,0,1,0 };
template<class T> void debug(T a) { for (auto i : a)cout << i << endl; }
int main()
{
const lint MAXS = 1000000000;
int n, q;
multiset<lint> ms;
vector<lint> a, b;
cin >> n >> q;
FOR(i, n)
{
lint x; cin >> x;
a.push_back(x);
b.push_back(x);
}
sort(ALL(a));
FOR(c, q)
{
string s; lint x;
cin >> s >> x;
if (s == "ADD")
{
x--;
ms.insert(b[x]);
}
if (s == "REMOVE")
{
x--;
auto it = ms.lower_bound(b[x]);
ms.erase(it);
}
if (s == "CHECK")
{
lint l = 0, r = MAXS + 1, m;
while (l != r)
{
m = (l + r) / 2;
int prev = 0, st = 0;
for (auto it : ms)
{
int d = lower_bound(ALL(a), it - m) - a.begin();
st += max(d - prev, 0);
prev = upper_bound(ALL(a), it) - a.begin();
}
st += max(n - prev, 0);
if (st <= x)r = m;
else l = m + 1;
}
if (l == MAXS + 1)cout << "NA" << endl;
else cout << l << endl;
}
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Anna is a girl so brave that she is loved by everyone in the city and citizens love her cookies. She is planning to hold a party with cookies. Now she has a vanilla cookies and b chocolate cookies for the party.
She invited n guests of the first type and m guests of the second type to the party. They will come to the party in some order. After coming to the party, each guest will choose the type of cookie (vanilla or chocolate) to eat. There is a difference in the way how they choose that type:
If there are v vanilla cookies and c chocolate cookies at the moment, when the guest comes, then
* if the guest of the first type: if v>c the guest selects a vanilla cookie. Otherwise, the guest selects a chocolate cookie.
* if the guest of the second type: if v>c the guest selects a chocolate cookie. Otherwise, the guest selects a vanilla cookie.
After that:
* If there is at least one cookie of the selected type, the guest eats one.
* Otherwise (there are no cookies of the selected type), the guest gets angry and returns to home.
Anna wants to know if there exists some order of guests, such that no one guest gets angry. Your task is to answer her question.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contain descriptions of test cases.
For each test case, the only line contains four integers a, b, n, m (0 β€ a,b,n,m β€ 10^{18}, n+m β 0).
Output
For each test case, print the answer in one line. If there exists at least one valid order, print "Yes". Otherwise, print "No".
You can print each letter in any case (upper or lower).
Example
Input
6
2 2 1 2
0 100 0 1
12 13 25 1
27 83 14 25
0 0 1 0
1000000000000000000 1000000000000000000 1000000000000000000 1000000000000000000
Output
Yes
No
No
Yes
No
Yes
Note
In the first test case, let's consider the order \{1, 2, 2\} of types of guests. Then:
* The first guest eats a chocolate cookie. After that, there are 2 vanilla cookies and 1 chocolate cookie.
* The second guest eats a chocolate cookie. After that, there are 2 vanilla cookies and 0 chocolate cookies.
* The last guest selects a chocolate cookie, but there are no chocolate cookies. So, the guest gets angry.
So, this order can't be chosen by Anna.
Let's consider the order \{2, 2, 1\} of types of guests. Then:
* The first guest eats a vanilla cookie. After that, there is 1 vanilla cookie and 2 chocolate cookies.
* The second guest eats a vanilla cookie. After that, there are 0 vanilla cookies and 2 chocolate cookies.
* The last guest eats a chocolate cookie. After that, there are 0 vanilla cookies and 1 chocolate cookie.
So, the answer to this test case is "Yes".
In the fifth test case, it is illustrated, that the number of cookies (a + b) can be equal to zero, but the number of guests (n + m) can't be equal to zero.
In the sixth test case, be careful about the overflow of 32-bit integer type.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f3f3f3f3f;
long long power(long long a, long long b) {
long long res = 1;
while (b != 0) {
if (b & 1) {
res *= a;
}
a = (a * a);
b = (b / 2);
}
return res;
}
int32_t main() {
long long i, j, k, l, n, m, t;
t = 1;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b >> n >> m;
if (m <= min(a, b) && m + n <= a + b) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
In Summer Informatics School, if a student doesn't behave well, teachers make a hole in his badge. And today one of the teachers caught a group of n students doing yet another trick.
Let's assume that all these students are numbered from 1 to n. The teacher came to student a and put a hole in his badge. The student, however, claimed that the main culprit is some other student p_a.
After that, the teacher came to student p_a and made a hole in his badge as well. The student in reply said that the main culprit was student p_{p_a}.
This process went on for a while, but, since the number of students was finite, eventually the teacher came to the student, who already had a hole in his badge.
After that, the teacher put a second hole in the student's badge and decided that he is done with this process, and went to the sauna.
You don't know the first student who was caught by the teacher. However, you know all the numbers p_i. Your task is to find out for every student a, who would be the student with two holes in the badge if the first caught student was a.
Input
The first line of the input contains the only integer n (1 β€ n β€ 1000) β the number of the naughty students.
The second line contains n integers p_1, ..., p_n (1 β€ p_i β€ n), where p_i indicates the student who was reported to the teacher by student i.
Output
For every student a from 1 to n print which student would receive two holes in the badge, if a was the first student caught by the teacher.
Examples
Input
3
2 3 2
Output
2 2 3
Input
3
1 2 3
Output
1 2 3
Note
The picture corresponds to the first example test case.
<image>
When a = 1, the teacher comes to students 1, 2, 3, 2, in this order, and the student 2 is the one who receives a second hole in his badge.
When a = 2, the teacher comes to students 2, 3, 2, and the student 2 gets a second hole in his badge. When a = 3, the teacher will visit students 3, 2, 3 with student 3 getting a second hole in his badge.
For the second example test case it's clear that no matter with whom the teacher starts, that student would be the one who gets the second hole in his badge.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1010], n;
map<int, int> s;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
int t = i;
while (true) {
s[t]++;
if (s[t] == 2) {
i == n ? printf("%d\n", t) : printf("%d ", t);
s.clear();
break;
}
t = a[t];
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
One day Alice was cleaning up her basement when she noticed something very curious: an infinite set of wooden pieces! Each piece was made of five square tiles, with four tiles adjacent to the fifth center tile:
<image> By the pieces lay a large square wooden board. The board is divided into n^2 cells arranged into n rows and n columns. Some of the cells are already occupied by single tiles stuck to it. The remaining cells are free.
Alice started wondering whether she could fill the board completely using the pieces she had found. Of course, each piece has to cover exactly five distinct cells of the board, no two pieces can overlap and every piece should fit in the board entirely, without some parts laying outside the board borders. The board however was too large for Alice to do the tiling by hand. Can you help determine if it's possible to fully tile the board?
Input
The first line of the input contains a single integer n (3 β€ n β€ 50) β the size of the board.
The following n lines describe the board. The i-th line (1 β€ i β€ n) contains a single string of length n. Its j-th character (1 β€ j β€ n) is equal to "." if the cell in the i-th row and the j-th column is free; it is equal to "#" if it's occupied.
You can assume that the board contains at least one free cell.
Output
Output YES if the board can be tiled by Alice's pieces, or NO otherwise. You can print each letter in any case (upper or lower).
Examples
Input
3
#.#
...
#.#
Output
YES
Input
4
##.#
#...
####
##.#
Output
NO
Input
5
#.###
....#
#....
###.#
#####
Output
YES
Input
5
#.###
....#
#....
....#
#..##
Output
NO
Note
The following sketches show the example boards and their tilings if such tilings exist:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 1; i < n - 1; ++i) {
for (int j = 1; j < n - 1; ++j) {
if (s[i][j] == '.' && s[i - 1][j] == '.' && s[i][j - 1] == '.' &&
s[i + 1][j] == '.' && s[i][j + 1] == '.') {
s[i][j] = '#', s[i - 1][j] = '#', s[i][j - 1] = '#', s[i + 1][j] = '#',
s[i][j + 1] = '#';
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (s[i][j] == '.') {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
The only difference between easy and hard versions is the size of the input.
You are given a string s consisting of n characters, each character is 'R', 'G' or 'B'.
You are also given an integer k. Your task is to change the minimum number of characters in the initial string s so that after the changes there will be a string of length k that is a substring of s, and is also a substring of the infinite string "RGBRGBRGB ...".
A string a is a substring of string b if there exists a positive integer i such that a_1 = b_i, a_2 = b_{i + 1}, a_3 = b_{i + 2}, ..., a_{|a|} = b_{i + |a| - 1}. For example, strings "GBRG", "B", "BR" are substrings of the infinite string "RGBRGBRGB ..." while "GR", "RGR" and "GGG" are not.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 β€ q β€ 2000) β the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 β€ k β€ n β€ 2000) β the length of the string s and the length of the substring.
The second line of the query contains a string s consisting of n characters 'R', 'G' and 'B'.
It is guaranteed that the sum of n over all queries does not exceed 2000 (β n β€ 2000).
Output
For each query print one integer β the minimum number of characters you need to change in the initial string s so that after changing there will be a substring of length k in s that is also a substring of the infinite string "RGBRGBRGB ...".
Example
Input
3
5 2
BGGGG
5 3
RBRGR
5 5
BBBRR
Output
1
0
3
Note
In the first example, you can change the first character to 'R' and obtain the substring "RG", or change the second character to 'R' and obtain "BR", or change the third, fourth or fifth character to 'B' and obtain "GB".
In the second example, the substring is "BRG".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
string r;
r.push_back('R');
r.push_back('G');
r.push_back('B');
while (t--) {
int n, k;
string a;
int ans = 1e9;
scanf("%d%d", &n, &k);
cin >> a;
for (int i = 0; i < n - k + 1; i++) {
for (int j = 0; j < 3; j++) {
int cur = 0;
for (int l = 0; l < k; l++) {
if (a[l + i] != r[(l + j) % 3]) ++cur;
}
ans = min(ans, cur);
}
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
()
Problem Statement
There is a string S. Initially, S is an empty string.
Perform the following processing in order of n.
* Add x_i p_i (=" (" or") ") to the end of S.
After processing, determine if S is a well-balanced string.
"The string is balanced" is defined as follows.
* The empty string is well-balanced.
* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.
* For a balanced string a, "(" + a + ")" is balanced.
Constraints
* 1 β€ n β€ 1,000
* 1 β€ x_i β€ 10 ^ 6
* p_i is "(" or ")"
Input
Input follows the following format. All given numbers are integers.
n
p_1 x_1
.. ..
p_n x_n
Output
Output "YES" if balanced, otherwise output "NO" on one line.
Examples
Input
3
( 5
) 4
) 1
Output
YES
Input
5
( 2
) 2
( 3
) 1
) 2
Output
YES
Input
2
) 1
( 1
Output
NO
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int check[2] = {0};
int ans = 0;
for(int i = 0;i < n;++i){
char pa;
int x;
cin>>pa;
cin>>x;
if(pa == '('){
check[0] += x;
}
else{
check[1] += x;
if(check[1] > check[0]){
ans = 1;
}
}
}
if(check[1] != check[0]){
ans = 1;
}
if(ans == 1){
cout<<"NO"<<endl;
}
else{
cout<<"YES"<<endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Write a program which print coordinates $(x_i, y_i)$ of given $n$ points on the plane by the following criteria.
1. first by $x$-coordinate
2. in case of a tie, by $y$-coordinate
Constraints
* $1 \leq n \leq 100,000$
* $-1,000,000,000 \leq x_i, y_i \leq 1,000,000,000$
Input
The input is given in the following format.
$n$
$x_0 \; y_0$
$x_1 \; y_1$
:
$x_{n-1} \; y_{n-1}$
In the first line, the number of points $n$ is given. In the following $n$ lines, coordinates of each point are given.
Output
Print coordinate of given points in order.
Example
Input
5
4 7
5 5
2 3
6 8
2 1
Output
2 1
2 3
4 7
5 5
6 8
### Response
```cpp
#include <iostream>
#include <utility>
#include <tuple>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std;
int main() {
int n; cin >> n;
int x, y;
using P = pair<int,int>;
vector<P> v;
while(cin >> x >> y) {
v.push_back({x, y});
}
std::sort(v.begin(), v.end());
for(auto& p : v) cout << p.first << " " << p.second << endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
In this problem, we use the 24-hour clock.
Takahashi gets up exactly at the time H_1 : M_1 and goes to bed exactly at the time H_2 : M_2. (See Sample Inputs below for clarity.) He has decided to study for K consecutive minutes while he is up. What is the length of the period in which he can start studying?
Constraints
* 0 \le H_1, H_2 \le 23
* 0 \le M_1, M_2 \le 59
* The time H_1 : M_1 comes before the time H_2 : M_2.
* K \ge 1
* Takahashi is up for at least K minutes.
* All values in input are integers (without leading zeros).
Input
Input is given from Standard Input in the following format:
H_1 M_1 H_2 M_2 K
Output
Print the length of the period in which he can start studying, as an integer.
Examples
Input
10 0 15 0 30
Output
270
Input
10 0 12 0 120
Output
0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int h1,m1,h2,m2,k;
cin>>h1>>m1>>h2>>m2>>k;
cout<<max((h2*60+m2-k)-(h1*60+m1),0)<<endl;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Tsumugi brought n delicious sweets to the Light Music Club. They are numbered from 1 to n, where the i-th sweet has a sugar concentration described by an integer a_i.
Yui loves sweets, but she can eat at most m sweets each day for health reasons.
Days are 1-indexed (numbered 1, 2, 3, β¦). Eating the sweet i at the d-th day will cause a sugar penalty of (d β
a_i), as sweets become more sugary with time. A sweet can be eaten at most once.
The total sugar penalty will be the sum of the individual penalties of each sweet eaten.
Suppose that Yui chooses exactly k sweets, and eats them in any order she wants. What is the minimum total sugar penalty she can get?
Since Yui is an undecided girl, she wants you to answer this question for every value of k between 1 and n.
Input
The first line contains two integers n and m (1 β€ m β€ n β€ 200\ 000).
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 200\ 000).
Output
You have to output n integers x_1, x_2, β¦, x_n on a single line, separed by spaces, where x_k is the minimum total sugar penalty Yui can get if she eats exactly k sweets.
Examples
Input
9 2
6 19 3 4 4 2 6 7 8
Output
2 5 11 18 30 43 62 83 121
Input
1 1
7
Output
7
Note
Let's analyze the answer for k = 5 in the first example. Here is one of the possible ways to eat 5 sweets that minimize total sugar penalty:
* Day 1: sweets 1 and 4
* Day 2: sweets 5 and 3
* Day 3 : sweet 6
Total penalty is 1 β
a_1 + 1 β
a_4 + 2 β
a_5 + 2 β
a_3 + 3 β
a_6 = 6 + 4 + 8 + 6 + 6 = 30. We can prove that it's the minimum total sugar penalty Yui can achieve if she eats 5 sweets, hence x_5 = 30.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
vector<long long> a(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (int i = 1; i <= n; i++) a[i] += a[i - 1];
for (int i = 1; i <= n; i++) {
if (m <= i) a[i] += a[i - m];
cout << a[i] << ' ';
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a rooted tree consisting of n vertices numbered from 1 to n. The root of the tree is a vertex number 1.
A tree is a connected undirected graph with n-1 edges.
You are given m queries. The i-th query consists of the set of k_i distinct vertices v_i[1], v_i[2], ..., v_i[k_i]. Your task is to say if there is a path from the root to some vertex u such that each of the given k vertices is either belongs to this path or has the distance 1 to some vertex of this path.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 2 β
10^5, 1 β€ m β€ 2 β
10^5) β the number of vertices in the tree and the number of queries.
Each of the next n-1 lines describes an edge of the tree. Edge i is denoted by two integers u_i and v_i, the labels of vertices it connects (1 β€ u_i, v_i β€ n, u_i β v_i).
It is guaranteed that the given edges form a tree.
The next m lines describe queries. The i-th line describes the i-th query and starts with the integer k_i (1 β€ k_i β€ n) β the number of vertices in the current query. Then k_i integers follow: v_i[1], v_i[2], ..., v_i[k_i] (1 β€ v_i[j] β€ n), where v_i[j] is the j-th vertex of the i-th query.
It is guaranteed that all vertices in a single query are distinct.
It is guaranteed that the sum of k_i does not exceed 2 β
10^5 (β_{i=1}^{m} k_i β€ 2 β
10^5).
Output
For each query, print the answer β "YES", if there is a path from the root to some vertex u such that each of the given k vertices is either belongs to this path or has the distance 1 to some vertex of this path and "NO" otherwise.
Example
Input
10 6
1 2
1 3
1 4
2 5
2 6
3 7
7 8
7 9
9 10
4 3 8 9 10
3 2 4 6
3 2 1 5
3 4 8 2
2 6 10
3 5 4 7
Output
YES
YES
YES
YES
NO
NO
Note
The picture corresponding to the example:
<image>
Consider the queries.
The first query is [3, 8, 9, 10]. The answer is "YES" as you can choose the path from the root 1 to the vertex u=10. Then vertices [3, 9, 10] belong to the path from 1 to 10 and the vertex 8 has distance 1 to the vertex 7 which also belongs to this path.
The second query is [2, 4, 6]. The answer is "YES" as you can choose the path to the vertex u=2. Then the vertex 4 has distance 1 to the vertex 1 which belongs to this path and the vertex 6 has distance 1 to the vertex 2 which belongs to this path.
The third query is [2, 1, 5]. The answer is "YES" as you can choose the path to the vertex u=5 and all vertices of the query belong to this path.
The fourth query is [4, 8, 2]. The answer is "YES" as you can choose the path to the vertex u=9 so vertices 2 and 4 both have distance 1 to the vertex 1 which belongs to this path and the vertex 8 has distance 1 to the vertex 7 which belongs to this path.
The fifth and the sixth queries both have answer "NO" because you cannot choose suitable vertex u.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = (long long int)1e9 + 7;
vector<vector<long long int> > adj;
vector<vector<long long int> > dp;
vector<long long int> dis;
vector<long long int> vis;
vector<long long int> tin, tout;
long long int n;
long long int l;
long long int timer = 0;
void dfs(long long int p, long long int c) {
tin[c] = timer++;
dp[c][0] = p;
vis[c] = 1;
for (long long int(i) = 1; (i) <= (l); ++(i)) {
dp[c][i] = dp[dp[c][i - 1]][i - 1];
}
for (auto &&child : adj[c]) {
if (!vis[child]) {
dis[child] = dis[c] + 1;
dfs(c, child);
}
}
tout[c] = timer++;
}
bool is_ances(long long int u, long long int v) {
return tin[u] <= tin[v] && tout[u] >= tout[v];
}
void solve(vector<long long int> a) {
long long int far = -1, d = -1;
for (auto &&i : a) {
if (dis[i] > d) {
d = dis[i];
far = i;
}
}
long long int f = 1;
for (auto &&nodes : a) {
if (nodes != far) {
if (!is_ances(dp[nodes][0], far)) {
f = 0;
break;
}
}
}
if (f)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) {
long long int x, ans = 0, c = 0, sum = 0;
long long int q, u, v;
cin >> n >> q;
l = ceill(log2(n));
adj.resize(n + 1);
dis.resize(n + 1);
vis.resize(n + 1);
tin.resize(n + 1);
tout.resize(n + 1);
dp.resize(n + 1, vector<long long int>(l + 1));
for (long long int(i) = 0; (i) < (n - 1); ++(i)) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
while (q--) {
long long int k;
cin >> k;
vector<long long int> a(k);
for (long long int(i) = 0; (i) < (k); ++(i)) {
cin >> a[i];
}
solve(a);
}
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
To learn as soon as possible the latest news about their favourite fundamentally new operating system, BolgenOS community from Nizhni Tagil decided to develop a scheme. According to this scheme a community member, who is the first to learn the news, calls some other member, the latter, in his turn, calls some third member, and so on; i.e. a person with index i got a person with index fi, to whom he has to call, if he learns the news. With time BolgenOS community members understood that their scheme doesn't work sometimes β there were cases when some members didn't learn the news at all. Now they want to supplement the scheme: they add into the scheme some instructions of type (xi, yi), which mean that person xi has to call person yi as well. What is the minimum amount of instructions that they need to add so, that at the end everyone learns the news, no matter who is the first to learn it?
Input
The first input line contains number n (2 β€ n β€ 105) β amount of BolgenOS community members. The second line contains n space-separated integer numbers fi (1 β€ fi β€ n, i β fi) β index of a person, to whom calls a person with index i.
Output
In the first line output one number β the minimum amount of instructions to add. Then output one of the possible variants to add these instructions into the scheme, one instruction in each line. If the solution is not unique, output any.
Examples
Input
3
3 3 2
Output
1
3 1
Input
7
2 3 1 3 4 4 1
Output
3
2 5
2 6
3 7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <int Size>
struct UF {
UF() {
for (int i = 0; i < Size; i++) {
rep[i] = i;
}
}
int find(int a) {
while (rep[a] != a) {
a = rep[a] = rep[rep[a]];
}
return a;
}
int rep[Size];
bool uni(int a, int b) {
a = find(a);
b = find(b);
if (a == b) {
return false;
}
rep[a] = b;
return true;
}
};
const int L = 1e5 + 2;
bool in[L];
vector<int> fs[L];
int main() {
UF<L> uf;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int d;
scanf("%d", &d);
uf.uni(i, d);
in[d] = true;
}
vector<int> rs;
for (int i = 1; i <= n; i++) {
int a = uf.find(i);
if (i == a) {
rs.push_back(i);
}
if (!in[i]) {
fs[a].push_back(i);
}
}
vector<pair<int, int> > ret;
for (int i = 0; i < rs.size(); i++) {
int r = rs[i];
int s = rs[(i + 1) % rs.size()];
if (fs[r].size() == 0 && r != s) {
ret.push_back(pair<int, int>(s, r));
} else {
for (auto p : fs[r]) {
ret.push_back(pair<int, int>(s, p));
}
}
}
printf("%d\n", (int)ret.size());
for (auto p : ret) {
printf("%d %d\n", p.first, p.second);
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
In the house where Krosh used to live, he had n cupboards standing in a line, the i-th cupboard had the height of h_i. Krosh moved recently, but he wasn't able to move the cupboards with him. Now he wants to buy n new cupboards so that they look as similar to old ones as possible.
Krosh does not remember the exact heights of the cupboards, but for every three consecutive cupboards he remembers the height difference between the tallest and the shortest of them. In other words, if the cupboards' heights were h_1, h_2, β¦, h_n, then Krosh remembers the values w_i = max(h_{i}, h_{i + 1}, h_{i + 2}) - min(h_{i}, h_{i + 1}, h_{i + 2}) for all 1 β€ i β€ n - 2.
Krosh wants to buy such n cupboards that all the values w_i remain the same. Help him determine the required cupboards' heights, or determine that he remembers something incorrectly and there is no suitable sequence of heights.
Input
The first line contains two integers n and C (3 β€ n β€ 10^6, 0 β€ C β€ 10^{12}) β the number of cupboards and the limit on possible w_i.
The second line contains n - 2 integers w_1, w_2, β¦, w_{n - 2} (0 β€ w_i β€ C) β the values defined in the statement.
Output
If there is no suitable sequence of n cupboards, print "NO".
Otherwise print "YES" in the first line, then in the second line print n integers h'_1, h'_2, β¦, h'_n (0 β€ h'_i β€ 10^{18}) β the heights of the cupboards to buy, from left to right.
We can show that if there is a solution, there is also a solution satisfying the constraints on heights.
If there are multiple answers, print any.
Examples
Input
7 20
4 8 12 16 20
Output
YES
4 8 8 16 20 4 0
Input
11 10
5 7 2 3 4 5 2 1 8
Output
YES
1 1 6 8 6 5 2 0 0 1 8
Input
6 9
1 6 9 0
Output
NO
Note
Consider the first example:
* w_1 = max(4, 8, 8) - min(4, 8, 8) = 8 - 4 = 4
* w_2 = max(8, 8, 16) - min(8, 8, 16) = 16 - 8 = 8
* w_3 = max(8, 16, 20) - min(8, 16, 20) = 20 - 8 = 12
* w_4 = max(16, 20, 4) - min(16, 20, 4) = 20 - 4 = 16
* w_5 = max(20, 4, 0) - min(20, 4, 0) = 20 - 0 = 20
There are other possible solutions, for example, the following: 0, 1, 4, 9, 16, 25, 36.
### Response
```cpp
#include <bits/stdc++.h>
[[noreturn]] void FAIL() {
std::cout << "NO" << '\n';
exit(0);
}
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int N; int64_t C; cin >> N >> C;
vector<int64_t> W(N-2); for (auto& w : W) cin >> w;
/*
vector<int64_t> A(N);
std::mt19937 mt(48);
for (auto& a : A) a = mt() % 1;
for (int i = 0; i < N-2; i++) {
W[i] = max({A[i], A[i+1], A[i+2]}) - min({A[i], A[i+1], A[i+2]});
}
*/
W.push_back(W.back());
// there are 2 types of nontrivial events:
// either we take the full range at a particular interval, or we take a full range at a location
// Either way, we can store it by the original loc
vector<bool> can_full(N-1);
vector<int> prv(N-1, -1);
vector<int64_t> prv_val(N-1);
int cur_sign = 1;
int64_t cur_plus = 0;
deque<pair<array<int64_t, 2>, int>> cur_poss;
cur_poss.push_back({{0, W[0]}, -1}); // inclusive interval
for (int i = 0; i < N-1; i++) {
// first, trim the high and low
if (cur_sign == 1) {
while (!cur_poss.empty() && cur_poss.back().first[0] + cur_plus > W[i]) {
cur_poss.pop_back();
}
if (!cur_poss.empty() && cur_poss.back().first[1] + cur_plus > W[i]) {
cur_poss.back().first[1] = W[i] - cur_plus;
}
while (!cur_poss.empty() && cur_poss.front().first[1] + cur_plus < 0) {
cur_poss.pop_front();
}
if (!cur_poss.empty() && cur_poss.front().first[0] + cur_plus < 0) {
cur_poss.front().first[0] = 0 - cur_plus;
}
} else if (cur_sign == -1) {
while (!cur_poss.empty() && -cur_poss.front().first[1] + cur_plus > W[i]) {
cur_poss.pop_front();
}
if (!cur_poss.empty() && -cur_poss.front().first[0] + cur_plus > W[i]) {
cur_poss.front().first[0] = -(W[i] - cur_plus);
}
while (!cur_poss.empty() && -cur_poss.back().first[0] + cur_plus < 0) {
cur_poss.pop_back();
}
if (!cur_poss.empty() && -cur_poss.back().first[1] + cur_plus < 0) {
cur_poss.back().first[1] = -(0 - cur_plus);
}
} else assert(false);
if (cur_poss.empty()) {
FAIL();
}
if (cur_sign == 1) {
if (cur_poss.back().first[1] + cur_plus == W[i]) {
can_full[i] = true;
prv[i] = cur_poss.back().second;
prv_val[i] = W[i];
}
} else if (cur_sign == -1) {
if (-cur_poss.front().first[0] + cur_plus == W[i]) {
can_full[i] = true;
prv[i] = cur_poss.front().second;
prv_val[i] = W[i];
}
} else assert(false);
if (can_full[i]) {
cur_sign = 1;
cur_plus = 0;
cur_poss.clear();
cur_poss.push_back({{0, W[i]}, i});
} else {
// pick something arbitrary to be +
if (cur_sign == 1) {
if (cur_poss.front().first[0] + cur_plus != 0) {
prv_val[i] = cur_poss.front().first[0] + cur_plus;
prv[i] = cur_poss.front().second;
cur_poss.push_front({{0 - cur_plus, 0 - cur_plus}, i});
}
} else if (cur_sign == -1) {
if (-cur_poss.back().first[1] + cur_plus != 0) {
prv_val[i] = -cur_poss.back().first[1] + cur_plus;
prv[i] = cur_poss.back().second;
cur_poss.push_back({{-(0 - cur_plus), -(0 - cur_plus)}, i});
}
} else assert(false);
assert(prv[i] == -1 || (0 < prv_val[i] && prv_val[i] < W[i]));
cur_sign = -cur_sign;
cur_plus = W[i] - cur_plus;
}
}
assert(can_full[0]);
assert(can_full[N-2]);
vector<int64_t> H(N);
vector<int64_t> deltas(N);
deltas[N-1] = W[N-2];
for (int cur = N-2; ; ) {
if (!can_full[cur]) {
assert(deltas[cur+1] == W[cur]);
assert(0 < prv_val[cur] && prv_val[cur] < W[cur]);
} else {
assert(0 <= deltas[cur+1] && deltas[cur+1] <= W[cur]);
assert(prv_val[cur] == W[cur]);
}
if (cur == 0) break;
int p = prv[cur];
assert(p != -1);
deltas[cur] = prv_val[cur];
while (cur-1 != p) {
cur--;
deltas[cur] = W[cur] - deltas[cur+1];
}
cur--;
}
deltas[0] = W[0];
H[0] = 0;
H[1] = deltas[0];
for (int i = 0; i < N-2; i++) {
H[i+2] = H[i+1] + deltas[i+1];
if (max({H[i], H[i+1], H[i+2]}) - min({H[i], H[i+1], H[i+2]}) != W[i]) {
H[i+2] = H[i+1] - deltas[i+1];
}
if (max({H[i], H[i+1], H[i+2]}) - min({H[i], H[i+1], H[i+2]}) != W[i]) {
assert(false);
}
}
int64_t min_H = *min_element(H.begin(), H.end());
cout << "YES" << '\n';
for (int i = 0; i < N; i++) {
H[i] -= min_H;
cout << H[i] << " \n"[i+1==N];
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Twin adventurers Rin and Len are searching for treasure in the Mirror Cave. The cave has two pairs of rooms, the Hall of Mirrors, and an expensive treasure lies behind the door of the room.
For convenience, each of the two rooms is considered to have W Γ H cells arranged in a grid pattern. The outside of the room is surrounded by a wall. In addition, walls are installed in places inside the room, and it is not possible to enter the cells where the walls are located. To open the door to the treasure room, the two must move symmetrically to reach a particular cell at the same time. Moreover, if only one arrives first, the door will be locked and will not open.
Symmetrical movement means moving north and north, west and east, east and west, and south and south at the same time. However, it is recognized that the movement is symmetrical even in a situation where one has a wall at the end where it is trying to move and the other has no wall at the end. In this case, those with a wall will stay there, and those without a wall will move to the next cell.
As inputs, the initial position of the twins, the destination, and the placement of obstacles are given. Your job is to write a program to determine if the twins can open the door.
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> W H
> RoomL1 RoomR1
> RoomL2 RoomR2
> ...
> RoomLH RoomRH
The first line gives two positive integers W, H (1 β€ W, H β€ 50) separated by a single space. After that, information on two rooms is given over H lines. RoomLi and RoomRi correspond to the i-th row of the left and right rooms, respectively. Both are strings of length W, with the jth character corresponding to the jth column of the room. Each character is one of the following:
* `.`: Freely moveable cell
* `#`: Cell with wall (cannot enter)
* `%`: Destination
* `R`: Initial position of Rin
* `L`: Initial position of Len
In each room, the first row corresponds to the north end of the room and the first row corresponds to the west end of the room. Also, each room always has exactly one destination, with exactly one initial position for Len in the left room and one for Rin in the right room.
The end of the input is indicated by a line containing two zeros separated by a blank.
Output
For each dataset, print Yes if the twins can open the door, and No if they can't.
Sample Input
5 5
% # ... ... #%
. #. #.. #. #.
. #. #.. #. #.
. #. #.. #. #.
... # L R # ...
3 2
.L. .R #
% .. .%.
4 1
L.%.% .. R
0 0
Output for the Sample Input
Yes
Yes
No
Example
Input
5 5
%#... ...#%
.#.#. .#.#.
.#.#. .#.#.
.#.#. .#.#.
...#L R#...
3 2
.L. .R#
%.. .%.
4 1
L.%. %..R
0 0
Output
Yes
Yes
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int LDY[4] = {-1, 0, 1, 0};
int LDX[4] = {0, 1, 0, -1};
int RDY[4] = {-1, 0, 1, 0};
int RDX[4] = {0, -1, 0, 1};
int W, H;
char used[52][52][52][52]; // ly, lx, ry, rx
char L[52][52], R[52][52];
class State {
public:
int ly, lx, ry, rx;
State() {}
State(int ly, int lx, int ry, int rx) : ly(ly), lx(lx), ry(ry), rx(rx) {}
bool operator==(const State& a) { return ly == a.ly && lx == a.lx && ry == a.ry && rx == a.rx; }
};
void init() {
memset(used, 0, 52*52*52*52);
for (int i=0; i<52; ++i) {
for (int j=0; j<52; ++j) {
L[i][j] = R[i][j] = '#';
}
}
}
int main() {
while (cin >> W >> H, W) {
init();
State S, G;
for (int i=1; i<=H; ++i) {
string rl, rr;
cin >> rl >> rr;
for (int j=1; j<=W; ++j) {
L[i][j] = rl[j-1];
R[i][j] = rr[j-1];
if (L[i][j] == 'L') {
S.ly = i;
S.lx = j;
} else if (L[i][j] == '%') {
G.ly = i;
G.lx = j;
}
if (R[i][j] == 'R') {
S.ry = i;
S.rx = j;
} else if (R[i][j] == '%') {
G.ry = i;
G.rx = j;
}
}
}
bool ok = false;
queue<State> q;
q.push(S);
while ( ! ok && ! q.empty()) {
State t = q.front(); q.pop();
if (used[t.ly][t.lx][t.ry][t.rx]) continue;
used[t.ly][t.lx][t.ry][t.rx] = 1;
for (int i=0; i<4; ++i) {
State t2 = t;
if (L[t.ly + LDY[i]][t.lx + LDX[i]] != '#') {
t2.ly += LDY[i];
t2.lx += LDX[i];
}
if (R[t.ry + RDY[i]][t.rx + RDX[i]] != '#') {
t2.ry += RDY[i];
t2.rx += RDX[i];
}
if (t2 == G) {
ok = true;
break;
}
if ((L[t2.ly][t2.lx] == '%' && R[t2.ry][t2.rx] != '%')
|| (L[t2.ly][t2.lx] != '%' && R[t2.ry][t2.rx] == '%')) {
continue;
}
if ( ! used[t2.ly][t2.lx][t2.ry][t2.rx]) q.push(t2);
}
}
cout << (ok ? "Yes" : "No") << endl;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is Β«x:yΒ», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 β€ n β€ 10000) β the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 β€ a_i, b_i β€ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
long long ans = 1;
int n, pa = 0, pb = 0, pd = 0;
scanf("%d", &n);
while (n--) {
int a, b;
scanf("%d%d", &a, &b);
if (std::min(a, b) - std::max(pa, pb) >= 0) {
ans += std::min(a, b) - std::max(pa, pb) + (pd != std::max(pa, pb));
pd = std::min(a, b);
}
pa = a;
pb = b;
}
printf("%I64d\n", ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Read the coordinates of four different points on the plane, $ A (x_A, y_A) $, $ B (x_B, y_B) $, $ C (x_C, y_C) $, $ D (x_D, y_D) $, and straight line $ Create a program that outputs YES if AB $ and $ CD $ are orthogonal, and NO if they are not orthogonal. Here, "straight line" does not mean a line segment. Please refer to the figure below.
<image>
Input
Given multiple datasets. The format of each dataset is as follows.
$ x_A $ $ y_A $ $ x_B $ $ y_B $ $ x_C $ $ y_C $ $ x_D $ $ y_D $
$ x_A $, $ y_A $, $ x_B $, $ y_B $, $ x_C $, $ y_C $, $ x_D $, $ y_D $ are each -100 or more and 100 or less, and each value has a maximum of 5 digits after the decimal point. It is given as a real number including the number of.
The number of datasets does not exceed 100.
Output
Print YES or NO on one line for each dataset.
Example
Input
1.0 1.0 2.0 2.0 0.0 0.0 1.0 -1.0
0.0 0.0 2.0 0.0 -1.0 2.0 2.0 2.0
10.0 6.0 3.4 5.2 6.8 9.5 4.3 2.1
2.5 3.5 2.5 4.5 -3.3 -2.3 6.8 -2.3
Output
YES
NO
NO
YES
### Response
```cpp
#include <cstdio>
int main() {
double xA,yA,xB,yB,xC,yC,xD,yD;
while (scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&xA,&yA,&xB,&yB,&xC,&yC,&xD,&yD)!=EOF) {
if ((xA-xB)*(xC-xD)+(yA-yB)*(yC-yD)==0) {
puts("YES");
} else {
puts("NO");
}
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given a picture consisting of n rows and m columns. Rows are numbered from 1 to n from the top to the bottom, columns are numbered from 1 to m from the left to the right. Each cell is painted either black or white.
You think that this picture is not interesting enough. You consider a picture to be interesting if there is at least one cross in it. A cross is represented by a pair of numbers x and y, where 1 β€ x β€ n and 1 β€ y β€ m, such that all cells in row x and all cells in column y are painted black.
For examples, each of these pictures contain crosses:
<image>
The fourth picture contains 4 crosses: at (1, 3), (1, 5), (3, 3) and (3, 5).
Following images don't contain crosses:
<image>
You have a brush and a can of black paint, so you can make this picture interesting. Each minute you may choose a white cell and paint it black.
What is the minimum number of minutes you have to spend so the resulting picture contains at least one cross?
You are also asked to answer multiple independent queries.
Input
The first line contains an integer q (1 β€ q β€ 5 β
10^4) β the number of queries.
The first line of each query contains two integers n and m (1 β€ n, m β€ 5 β
10^4, n β
m β€ 4 β
10^5) β the number of rows and the number of columns in the picture.
Each of the next n lines contains m characters β '.' if the cell is painted white and '*' if the cell is painted black.
It is guaranteed that β n β€ 5 β
10^4 and β n β
m β€ 4 β
10^5.
Output
Print q lines, the i-th line should contain a single integer β the answer to the i-th query, which is the minimum number of minutes you have to spend so the resulting picture contains at least one cross.
Example
Input
9
5 5
..*..
..*..
*****
..*..
..*..
3 4
****
.*..
.*..
4 3
***
*..
*..
*..
5 5
*****
*.*.*
*****
..*.*
..***
1 4
****
5 5
.....
..*..
.***.
..*..
.....
5 3
...
.*.
.*.
***
.*.
3 3
.*.
*.*
.*.
4 4
*.**
....
*.**
*.**
Output
0
0
0
0
0
4
1
1
2
Note
The example contains all the pictures from above in the same order.
The first 5 pictures already contain a cross, thus you don't have to paint anything.
You can paint (1, 3), (3, 1), (5, 3) and (3, 5) on the 6-th picture to get a cross in (3, 3). That'll take you 4 minutes.
You can paint (1, 2) on the 7-th picture to get a cross in (4, 2).
You can paint (2, 2) on the 8-th picture to get a cross in (2, 2). You can, for example, paint (1, 3), (3, 1) and (3, 3) to get a cross in (3, 3) but that will take you 3 minutes instead of 1.
There are 9 possible crosses you can get in minimum time on the 9-th picture. One of them is in (1, 1): paint (1, 2) and (2, 1).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 * 1e4 + 5;
int a[maxn], b[maxn];
char s[maxn];
vector<int> v[maxn];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, m;
scanf("%d %d", &n, &m);
char c;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (int i = 0; i < n; i++) v[i].clear();
for (int i = 0; i < n; i++) {
getchar();
for (int j = 0; j < m; j++) {
scanf("%c", &c);
if (c == '*')
v[i].push_back(1);
else
v[i].push_back(0);
}
}
int x = 0, maxx = 0, y = 0, maxy = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (v[i][j] == 1) {
a[i]++;
b[j]++;
if (b[j] > maxy) {
maxy = b[j];
y = j;
}
if (a[i] > maxx) {
maxx = a[i];
x = i;
}
}
}
}
bool legal = true;
int ans = (n - maxy) + (m - maxx);
for (int i = 0; i < n && legal; i++) {
if (a[i] == maxx) {
for (int j = 0; j < m && legal; j++) {
if (b[j] == maxy) {
if (v[i][j] == 0) {
ans--;
legal = false;
}
}
}
}
}
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
We have a grid with N rows and M columns of squares. Each integer from 1 to NM is written in this grid once. The number written in the square at the i-th row from the top and the j-th column from the left is A_{ij}.
You need to rearrange these numbers as follows:
1. First, for each of the N rows, rearrange the numbers written in it as you like.
2. Second, for each of the M columns, rearrange the numbers written in it as you like.
3. Finally, for each of the N rows, rearrange the numbers written in it as you like.
After rearranging the numbers, you want the number written in the square at the i-th row from the top and the j-th column from the left to be M\times (i-1)+j. Construct one such way to rearrange the numbers. The constraints guarantee that it is always possible to achieve the objective.
Constraints
* 1 \leq N,M \leq 100
* 1 \leq A_{ij} \leq NM
* A_{ij} are distinct.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print one way to rearrange the numbers in the following format:
B_{11} B_{12} ... B_{1M}
:
B_{N1} B_{N2} ... B_{NM}
C_{11} C_{12} ... C_{1M}
:
C_{N1} C_{N2} ... C_{NM}
Here B_{ij} is the number written in the square at the i-th row from the top and the j-th column from the left after Step 1, and C_{ij} is the number written in that square after Step 2.
Examples
Input
3 2
2 6
4 3
1 5
Output
2 6
4 3
5 1
2 1
4 3
5 6
Input
3 4
1 4 7 10
2 5 8 11
3 6 9 12
Output
1 4 7 10
5 8 11 2
9 12 3 6
1 4 3 2
5 8 7 6
9 12 11 10
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int N=205,M=2e4+10;
int mat[N];
int w[N][N];
int n,m,a[N][N],il[N],ir[N],t,b[N][N],c[N][N];
int vis[N];
int ext(int x){
if (vis[x])return 0;vis[x]=1;
for (int z=1;z<=n;z++){
if (!w[x][z])continue;
if (!mat[z+n]||ext(mat[z+n])){
mat[z+n]=x;
mat[x]=z+n;
return 1;
}
}
return 0;
}
int main(){
cin>>n>>m;
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++){
scanf("%d",&a[i][j]);
w[i][(a[i][j]-1)/m+1]++;
}
}
for (int j=1;j<=m;j++){
for (int i=1;i<=n;i++){
ext(i);
memset(vis,0,sizeof vis);
}
for (int i=1;i<=n;i++){
for (int k=1;k<=m;k++)
if (a[i][k]&&(a[i][k]-1)/m+1==mat[i]-n){
b[i][j]=a[i][k];
a[i][k]=0;
break;
}
w[i][mat[i]-n]--;
mat[i]=mat[mat[i]]=0;
}
}
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++)printf("%d ",b[i][j]),c[j][i]=b[i][j];
printf("\n");
}
for (int i=1;i<=m;i++)
sort(c[i]+1,c[i]+n+1);
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++)printf("%d ",c[j][i]);
printf("\n");
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Petya is a big fan of mathematics, especially its part related to fractions. Recently he learned that a fraction <image> is called proper iff its numerator is smaller than its denominator (a < b) and that the fraction is called irreducible if its numerator and its denominator are coprime (they do not have positive common divisors except 1).
During his free time, Petya thinks about proper irreducible fractions and converts them to decimals using the calculator. One day he mistakenly pressed addition button ( + ) instead of division button (Γ·) and got sum of numerator and denominator that was equal to n instead of the expected decimal notation.
Petya wanted to restore the original fraction, but soon he realized that it might not be done uniquely. That's why he decided to determine maximum possible proper irreducible fraction <image> such that sum of its numerator and denominator equals n. Help Petya deal with this problem.
Input
In the only line of input there is an integer n (3 β€ n β€ 1000), the sum of numerator and denominator of the fraction.
Output
Output two space-separated positive integers a and b, numerator and denominator of the maximum possible proper irreducible fraction satisfying the given sum.
Examples
Input
3
Output
1 2
Input
4
Output
1 3
Input
12
Output
5 7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
cin >> n;
for (int i = 1; n - i > i; i++) {
if (gcd(i, n - i) != 1) continue;
a = i, b = n - i;
}
cout << a << " " << b;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
In an attempt to make peace with the Mischievious Mess Makers, Bessie and Farmer John are planning to plant some flower gardens to complement the lush, grassy fields of Bovinia. As any good horticulturist knows, each garden they plant must have the exact same arrangement of flowers. Initially, Farmer John has n different species of flowers he can plant, with ai flowers of the i-th species.
On each of the next q days, Farmer John will receive a batch of flowers of a new species. On day j, he will receive cj flowers of the same species, but of a different species from those Farmer John already has.
Farmer John, knowing the right balance between extravagance and minimalism, wants exactly k species of flowers to be used. Furthermore, to reduce waste, each flower of the k species Farmer John chooses must be planted in some garden. And each of the gardens must be identical; that is to say that each of the k chosen species should have an equal number of flowers in each garden. As Farmer John is a proponent of national equality, he would like to create the greatest number of gardens possible.
After receiving flowers on each of these q days, Farmer John would like to know the sum, over all possible choices of k species, of the maximum number of gardens he could create. Since this could be a large number, you should output your result modulo 109 + 7.
Input
The first line of the input contains three integers n, k and q (1 β€ k β€ n β€ 100 000, 1 β€ q β€ 100 000).
The i-th (1 β€ i β€ n) of the next n lines of the input contains an integer ai (1 β€ ai β€ 1 000 000), the number of flowers of species i Farmer John has initially.
The j-th (1 β€ j β€ q) of the next q lines of the input contains an integer cj (1 β€ cj β€ 1 000 000), the number of flowers of a new species Farmer John receives on day j.
Output
After each of the q days, output the sum of the maximum possible number of gardens, where the sum is taken over all possible choices of k species, modulo 109 + 7.
Examples
Input
3 3 2
4
6
9
8
6
Output
5
16
Input
4 1 2
6
5
4
3
2
1
Output
20
21
Note
In the first sample case, after the first day Farmer John has (4, 6, 9, 8) of each type of flower, and k = 3.
Choosing (4, 6, 8) lets him make 2 gardens, each with (2, 3, 4) of each flower, respectively. Choosing (4, 6, 9), (4, 9, 8) and (6, 9, 8) each only let him make one garden, since there is no number of gardens that each species can be evenly split into. So the sum over all choices of k = 3 flowers is 2 + 1 + 1 + 1 = 5.
After the second day, Farmer John has (4, 6, 9, 8, 6) of each flower. The sum over all choices is 1 + 2 + 2 + 1 + 1 + 2 + 2 + 3 + 1 + 1 = 16.
In the second sample case, k = 1. With x flowers Farmer John can make x gardens. So the answers to the queries are 6 + 5 + 4 + 3 + 2 = 20 and 6 + 5 + 4 + 3 + 2 + 1 = 21.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int V = 1000005;
const int N = 200005;
const int MOD = 1000000007;
vector<int> divs[V];
bool mark[V];
int phi[V], cnt[V], inv[N], bin[N], val[N];
int add(int x, int y) {
if ((x += y) >= MOD) x -= MOD;
return x;
}
int mul(int x, int y) { return (long long)x * y % MOD; }
int main() {
cin.tie(0)->sync_with_stdio(0);
int n, k, q, res = 0;
cin >> n >> k >> q;
for (int i = 0; i < n + q; i++) {
cin >> val[i];
mark[val[i]] = 1;
}
for (int i = 1; i < V; i++) {
phi[i] += i;
for (int j = i; j < V; j += i) {
if (mark[j]) divs[j].push_back(i);
if (i != j) phi[j] -= phi[i];
}
}
inv[1] = 1;
for (int i = 2; i < N; i++) inv[i] = MOD - mul(MOD / i, inv[MOD % i]);
bin[k - 1] = 1;
for (int i = k; i < N; i++) bin[i] = mul(bin[i - 1], mul(i, inv[i - k + 1]));
for (int i = 0; i < n + q; i++) {
for (int d : divs[val[i]]) {
res = add(res, mul(phi[d], bin[cnt[d]]));
cnt[d]++;
}
if (i >= n) cout << res << '\n';
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Osaki
Osaki
English text is not available in this practice contest.
The Yamanote Line is a circular railway line laid in the 23 wards of Tokyo. The total route distance is 34.5km, and one lap takes about one hour. There are 29 stations in total. The line color is Uguisu color. The peak congestion rate exceeds 200%, making it one of the busiest railway lines in Japan. One train runs every three minutes during the busiest hours, and people who come to Tokyo for the first time are amazed at the sight.
Mr. Tetsuko loves the Yamanote Line and loves genuine railways. One day, she came up with the following question while reading her favorite book, the JR timetable. "How many vehicles are used a day on the Yamanote Line?"
She tried to figure out the minimum number of vehicles required for operation from the timetable. However, the number of trains was so large that she couldn't count it by herself. So she turned to you, a good programmer, for help.
Your job is to write a program to find the minimum number of cars required to operate the Yamanote Line from a given timetable. Since the Yamanote Line is a circular line, the timetable is often written with "Osaki Station" as the starting and ending stations for convenience. Therefore, only the departure and arrival times of each train at Osaki Station are recorded in the timetable given by her.
Although this cannot happen on the actual Yamanote Line, in order to simplify the situation setting, we will consider that the train can depart from Osaki Station immediately after it arrives at Osaki Station. In addition, there are cases where the time taken by Mr. Tetsuko is incorrect, or the train added by Mr. Tetsuko's delusion is mixed in the timetable, but you can not see them, so to the last The number must be calculated for the time as written.
If you write a program that works, she may invite you to a date on the train. However, it is up to you to accept or decline the invitation.
Input
The input consists of multiple datasets. Each dataset has the following format.
> n
> hh: mm: ss hh: mm: ss
> hh: mm: ss hh: mm: ss
> ...
> hh: mm: ss hh: mm: ss
The integer n in the first line is the number of trains included in the timetable. This value is guaranteed not to exceed 10,000. The departure time and arrival time of each train at Osaki Station are given in this order on the n lines from the 2nd line to the n + 1st line, and the departure time and arrival time are separated by a single space. Each time is expressed in the format hh: mm: ss, where hh is the hour, mm is the minute, and ss is the second. The range of each value is 0 β€ hh <24, 0 β€ mm <60, 0 β€ ss <60. All of these numbers are prefixed with 0s as needed to be two digits.
Trains that run across 24:00 at night are not included. Therefore, the departure time is always before the arrival time.
The end of input is indicated by n = 0. It is not included in the dataset.
Output
For each dataset, output the minimum number of vehicles required on one line.
Sample Input
3
05:47:15 09:54:40
12:12:59 12:13:00
16:30:20 21:18:53
6
00:00:00 03:00:00
01:00:00 03:00:00
02:00:00 03:00:00
03:00:00 04:00:00
03:00:00 05:00:00
03:00:00 06:00:00
0
Output for the Sample Input
1
3
Example
Input
3
05:47:15 09:54:40
12:12:59 12:13:00
16:30:20 21:18:53
6
00:00:00 03:00:00
01:00:00 03:00:00
02:00:00 03:00:00
03:00:00 04:00:00
03:00:00 05:00:00
03:00:00 06:00:00
0
Output
1
3
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define MAX 86400
int main(){
int n, t[MAX+1];
while(cin >> n, n){
memset(t, 0, sizeof(t));
int H1, H2, M1, M2, S1, S2;
for(int i = 0 ; i < n ; i++){
scanf("%d:%d:%d %d:%d:%d", &H1, &M1, &S1, &H2, &M2, &S2);
t[H1*3600+M1*60+S1]++, t[H2*3600+M2*60+S2]--;
}
int ans = 0;
for(int i = 1 ; i <= MAX ; i++){
t[i] += t[i-1];
ans = max(ans, t[i]);
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
One day a bear lived on the Oxy axis. He was afraid of the dark, so he couldn't move at night along the plane points that aren't lit. One day the bear wanted to have a night walk from his house at point (l, 0) to his friend's house at point (r, 0), along the segment of length (r - l). Of course, if he wants to make this walk, he needs each point of the segment to be lit. That's why the bear called his friend (and yes, in the middle of the night) asking for a very delicate favor.
The Oxy axis contains n floodlights. Floodlight i is at point (xi, yi) and can light any angle of the plane as large as ai degree with vertex at point (xi, yi). The bear asked his friend to turn the floodlights so that he (the bear) could go as far away from his house as possible during the walking along the segment. His kind friend agreed to fulfill his request. And while he is at it, the bear wonders: what is the furthest he can go away from his house? Hep him and find this distance.
Consider that the plane has no obstacles and no other light sources besides the floodlights. The bear's friend cannot turn the floodlights during the bear's walk. Assume that after all the floodlights are turned in the correct direction, the bear goes for a walk and his friend goes to bed.
Input
The first line contains three space-separated integers n, l, r (1 β€ n β€ 20; - 105 β€ l β€ r β€ 105). The i-th of the next n lines contain three space-separated integers xi, yi, ai ( - 1000 β€ xi β€ 1000; 1 β€ yi β€ 1000; 1 β€ ai β€ 90) β the floodlights' description.
Note that two floodlights can be at the same point of the plane.
Output
Print a single real number β the answer to the problem. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
2 3 5
3 1 45
5 1 45
Output
2.000000000
Input
1 0 1
1 1 30
Output
0.732050808
Input
1 0 1
1 1 45
Output
1.000000000
Input
1 0 2
0 2 90
Output
2.000000000
Note
In the first sample, one of the possible solutions is:
<image>
In the second sample, a single solution is:
<image>
In the third sample, a single solution is:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double dp[1 << 21], l, r, ans;
int n;
struct Light {
double x, y;
double alpha;
Light(double _x = 0, double _y = 0, double _alpha = 0) {
x = _x;
y = _y;
alpha = _alpha;
}
} p[21];
double calc(int idx, double s) {
double beta = p[idx].alpha - atan2(p[idx].x - s, p[idx].y);
if (beta >= M_PI_2) return r;
return p[idx].x + tan(beta) * p[idx].y;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> l >> r;
for (__typeof(n - 1) i = (0); i <= (n - 1); i++) {
cin >> p[i].x >> p[i].y >> p[i].alpha;
p[i].alpha *= M_PI / 180.0;
}
for (__typeof((1 << n) - 1) mask = (0); mask <= ((1 << n) - 1); mask++) {
dp[mask] = l;
for (__typeof(n - 1) i = (0); i <= (n - 1); i++) {
if (mask & (1 << i)) {
int mask2 = mask - (1 << i);
dp[mask] = max(dp[mask], calc(i, dp[mask2]));
}
ans = max(ans, dp[mask] - l);
}
}
cout.precision(9);
cout << fixed << min(ans, r - l) << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Not so long ago as a result of combat operations the main Berland place of interest β the magic clock β was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y β the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1200];
int main() {
a[0] = 0;
int x, y;
scanf("%d%d", &x, &y);
int m = x * x + y * y;
int l = sqrt(m);
if (l * l == m || x * y == 0)
printf("black\n");
else {
if (l % 2 == 1) {
if (x * y > 0)
printf("white\n");
else
printf("black\n");
} else {
if (x * y < 0)
printf("white\n");
else
printf("black\n");
}
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
This is an interactive problem.
Vasya and Petya are going to play the following game: Petya has some positive integer number a. After that Vasya should guess this number using the following questions. He can say a pair of non-negative integer numbers (x, y). Petya will answer him:
* "x", if (x mod a) β₯ (y mod a).
* "y", if (x mod a) < (y mod a).
We define (x mod a) as a remainder of division x by a.
Vasya should guess the number a using no more, than 60 questions.
It's guaranteed that Petya has a number, that satisfies the inequality 1 β€ a β€ 10^9.
Help Vasya playing this game and write a program, that will guess the number a.
Interaction
Your program should play several games.
Before the start of any game your program should read the string:
* "start" (without quotes) β the start of the new game.
* "mistake" (without quotes) β in the previous game, you found the wrong answer. Your program should terminate after reading this string and it will get verdict "Wrong answer".
* "end" (without quotes) β all games finished. Your program should terminate after reading this string.
After reading the string "start" (without quotes) the new game starts.
At the beginning, your program should ask several questions about pairs of non-negative integer numbers (x, y). You can only ask the numbers, that satisfy the inequalities 0 β€ x, y β€ 2 β
10^9. To ask a question print "? x y" (without quotes). As the answer, you should read one symbol:
* "x" (without quotes), if (x mod a) β₯ (y mod a).
* "y" (without quotes), if (x mod a) < (y mod a).
* "e" (without quotes) β you asked more than 60 questions. Your program should terminate after reading this string and it will get verdict "Wrong answer".
After your program asked several questions your program should print the answer in form "! a" (without quotes). You should print the number a satisfying the inequalities 1 β€ a β€ 10^9. It's guaranteed that Petya's number a satisfied this condition. After that, the current game will finish.
We recall that your program can't ask more than 60 questions during one game.
If your program doesn't terminate after reading "mistake" (without quotes), "end" (without quotes) or "e" (without quotes), it can get any verdict, because it will continue reading from closed input. Also, if your program prints answer or question in the incorrect format it can get any verdict, too. Be careful.
Don't forget to flush the output after printing questions and answers.
To flush the output, you can use:
* fflush(stdout) in C++.
* System.out.flush() in Java.
* stdout.flush() in Python.
* flush(output) in Pascal.
* See the documentation for other languages.
It's guaranteed that you should play at least 1 and no more than 100 games.
Hacks:
In hacks, you can use only one game. To hack a solution with Petya's number a (1 β€ a β€ 10^9) in the first line you should write a single number 1 and in the second line you should write a single number a.
Example
Input
start
x
x
start
x
x
y
start
x
x
y
y
end
Output
? 0 0
? 10 1
! 1
? 0 0
? 3 4
? 2 5
! 2
? 2 4
? 2 5
? 3 10
? 9 1
! 3
Note
In the first test, you should play 3 games with Petya's numbers 1, 2 and 3.
In the first game, Petya will answer "x" (without quotes) to any question, because (x mod 1) = 0 for any integer x.
In the second game, if you will ask pair (0, 0), the answer will be "x" (without quotes), because (0 mod 2) β₯ (0 mod 2). But if you will ask pair (2, 5), the answer will be "y" (without quotes), because (2 mod 2) < (5 mod 2), because (2 mod 2) = 0 and (5 mod 2) = 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
while (cin >> s) {
if (s == "start") {
cout << "? " << 0 << ' ' << 1 << endl;
char res;
cin >> res;
if (res == 'x') {
cout << "! 1" << endl;
continue;
}
int x = 1;
while (1) {
cout << "? " << x << " " << 2 * x << endl;
cin >> res;
if (res == 'y') {
x = 2 * x;
} else {
int l = x + 1, r = 2 * x;
while (l <= r) {
int m = (l + r) / 2;
cout << "? " << x << " " << m << endl;
cin >> res;
if (res == 'x') {
r = m - 1;
} else {
l = m + 1;
}
}
cout << "! " << l << endl;
break;
}
}
} else {
break;
}
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Students Vasya and Petya are studying at the BSU (Byteland State University). At one of the breaks they decided to order a pizza. In this problem pizza is a circle of some radius. The pizza was delivered already cut into n pieces. The i-th piece is a sector of angle equal to ai. Vasya and Petya want to divide all pieces of pizza into two continuous sectors in such way that the difference between angles of these sectors is minimal. Sector angle is sum of angles of all pieces in it. Pay attention, that one of sectors can be empty.
Input
The first line contains one integer n (1 β€ n β€ 360) β the number of pieces into which the delivered pizza was cut.
The second line contains n integers ai (1 β€ ai β€ 360) β the angles of the sectors into which the pizza was cut. The sum of all ai is 360.
Output
Print one integer β the minimal difference between angles of sectors that will go to Vasya and Petya.
Examples
Input
4
90 90 90 90
Output
0
Input
3
100 100 160
Output
40
Input
1
360
Output
360
Input
4
170 30 150 10
Output
0
Note
In first sample Vasya can take 1 and 2 pieces, Petya can take 3 and 4 pieces. Then the answer is |(90 + 90) - (90 + 90)| = 0.
In third sample there is only one piece of pizza that can be taken by only one from Vasya and Petya. So the answer is |360 - 0| = 360.
In fourth sample Vasya can take 1 and 4 pieces, then Petya will take 2 and 3 pieces. So the answer is |(170 + 10) - (30 + 150)| = 0.
Picture explaning fourth sample:
<image>
Both red and green sectors consist of two adjacent pieces of pizza. So Vasya can take green sector, then Petya will take red sector.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[1000];
int num;
cin >> num;
for (int i = 0; i < num; i++) {
cin >> arr[i];
arr[num + i] = arr[i];
}
int ans = 360;
for (int i = 0; i < num; i++) {
int temp = 0;
for (int j = i; j < num * 2; j++) {
temp += arr[j];
ans = min(ans, abs(360 - 2 * temp));
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
PCK Taxi in Aizu city, owned by PCK company, has adopted a unique billing system: the user can decide the taxi fare. Today as usual, many people are waiting in a queue at the taxi stand in front of the station.
In front of the station, there are $N$ parking spaces in row for PCK taxis, each with an index running from $1$ to $N$. Each of the parking areas is occupied by a taxi, and a queue of potential passengers is waiting for the ride. Each one in the queue has his/her own plan for how much to pay for the ride.
To increase the companyβs gain, the taxi driver is given the right to select the passenger who offers the highest taxi fare, rejecting others.
The driver in the $i$-th parking space can perform the following actions any number of times in any sequence before he finally selects a passenger and starts driving.
1. Offer a ride to the passenger who is at the head of the $i$-th parking spaceβs queue.
2. Reject to offer a ride to the passenger who is at the head of the $i$-th parking spaceβs queue. The passenger is removed from the queue.
3. Move to the $i + 1$-th parking area if it is empty. If he is in the $N$-th parking area, he leaves the taxi stand to cruise the open road.
A preliminary listening is made as to the fare the users offer. Your task is to maximize the sales volume of PCK Taxi in reference to the table of offered fares. A taxi cannot accommodate more than one passenger.
Given the number of taxi parking spaces and information regarding the persons waiting in the parking areas, calculate the maximum possible volume of sales.
Input
The input is given in the following format.
$N$
$s_1$
$s_2$
$...$
$s_N$
The first line provides the number of taxi parking areas $N$ ($1 \leq N \leq 300,000$). Each of the subsequent $N$ lines provides information on the customers queueing in the $i$-th taxi parking area in the following format:
$M$ $c_1$ $c_2$ ... $c_M$
The first integer $M$ ($1 \leq M \leq 300,000$) indicates the number of customers in the queue, and the subsequent array of integers $c_j$ ($1 \leq c_j \leq 10,000$) indicates the fare the $j$-th customer in the queue is willing to pay. The total number of customers in the taxi stand is equal to or less than $300,000$.
Output
Output the maximum volume of sales.
Example
Input
3
3 8 10 1
4 7 1 2 15
3 11 8 19
Output
45
### Response
```cpp
#include <iostream>
#include <queue>
using namespace std;
int main()
{
int n, m, c;
long s = 0;
priority_queue <int, vector<int>, greater<int> > d;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
for (int j = 0; j < m; j++) {
cin >> c;
d.push(c);
}
while(d.size() > i + 1)
d.pop();
}
for (int i = 0; i < n; i++) {
s += d.top();
d.pop();
}
cout << s << endl;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Vasya and Kolya play a game with a string, using the following rules. Initially, Kolya creates a string s, consisting of small English letters, and uniformly at random chooses an integer k from a segment [0, len(s) - 1]. He tells Vasya this string s, and then shifts it k letters to the left, i. e. creates a new string t = sk + 1sk + 2... sns1s2... sk. Vasya does not know the integer k nor the string t, but he wants to guess the integer k. To do this, he asks Kolya to tell him the first letter of the new string, and then, after he sees it, open one more letter on some position, which Vasya can choose.
Vasya understands, that he can't guarantee that he will win, but he wants to know the probability of winning, if he plays optimally. He wants you to compute this probability.
Note that Vasya wants to know the value of k uniquely, it means, that if there are at least two cyclic shifts of s that fit the information Vasya knowns, Vasya loses. Of course, at any moment of the game Vasya wants to maximize the probability of his win.
Input
The only string contains the string s of length l (3 β€ l β€ 5000), consisting of small English letters only.
Output
Print the only number β the answer for the problem. You answer is considered correct, if its absolute or relative error does not exceed 10 - 6.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>
Examples
Input
technocup
Output
1.000000000000000
Input
tictictactac
Output
0.333333333333333
Input
bbaabaabbb
Output
0.100000000000000
Note
In the first example Vasya can always open the second letter after opening the first letter, and the cyclic shift is always determined uniquely.
In the second example if the first opened letter of t is "t" or "c", then Vasya can't guess the shift by opening only one other letter. On the other hand, if the first letter is "i" or "a", then he can open the fourth letter and determine the shift uniquely.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int Add(int &a, int b) { a = (a + b) % 1000000007; }
int Min(int &a, int b) { a = (a + 1000000007 - b) % 1000000007; }
int Mul(int &a, int b) { a = (long long)a * b % 1000000007; }
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long pow(long long a, long long b) {
long long res(1);
while (b) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
long long powM(long long a, long long b, long long mod) {
long long res(1);
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
const int infi = 2147483647;
const long long infl = 9223372036854775807;
int n, m, k, T;
char s[5011];
int p[26][5011];
int vis[26];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < (n); ++i) {
int idx = s[i] - 'a';
p[idx][++p[idx][0]] = i;
}
int ans = 0;
for (int k = 0; k < (26); ++k) {
int num = 0;
for (int i = 1; i <= (n); ++i) {
memset(vis, 0, sizeof vis);
int ok = 1;
for (int j = 1; j <= (p[k][0]); ++j) {
int tmp = (p[k][j] + i) % n;
int idx = s[tmp] - 'a';
vis[idx]++;
}
int x = 0;
for (int j = 0; j < (26); ++j) x += vis[j] == 1;
num = max(num, x);
}
ans += num;
}
printf("%f\n", ans * 1.0 / n);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 β€ i β€ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 β€ i β€ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 β€ n β€ 105) β the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 β€ ai β€ 105; ai < ai + 1).
Output
Print a single integer β the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1000 * 100 + 100], n;
int calc(int x) {
int y = x, Max = 0;
for (int i = 2; i <= sqrt(x); i++)
if (x % i == 0) {
while (x % i == 0) {
x /= i;
}
if (a[i] != 0) Max = max(Max, a[i]);
}
if (x != 1 && x != y) Max = max(Max, a[x]);
Max++;
x = y;
for (int i = 2; i <= sqrt(x); i++)
if (x % i == 0) {
while (x % i == 0) {
x /= i;
}
a[i] = max(a[i], Max);
}
if (x != 1 && x != y) a[x] = max(a[x], Max);
Max--;
return Max;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
vector<int> v;
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
a[t] = 1;
v.push_back(t);
}
for (int i = 2; i <= 1000 * 100; i++)
if (a[i] != 0) {
a[i] += calc(i);
}
int Max = -1;
for (int i = 0; i < v.size(); i++) Max = max(Max, a[v[i]]);
cout << Max;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given names of two days of the week.
Please, determine whether it is possible that during some non-leap year the first day of some month was equal to the first day of the week you are given, while the first day of the next month was equal to the second day of the week you are given. Both months should belong to one year.
In this problem, we consider the Gregorian calendar to be used. The number of months in this calendar is equal to 12. The number of days in months during any non-leap year is: 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31.
Names of the days of the week are given with lowercase English letters: "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday".
Input
The input consists of two lines, each of them containing the name of exactly one day of the week. It's guaranteed that each string in the input is from the set "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday".
Output
Print "YES" (without quotes) if such situation is possible during some non-leap year. Otherwise, print "NO" (without quotes).
Examples
Input
monday
tuesday
Output
NO
Input
sunday
sunday
Output
YES
Input
saturday
tuesday
Output
YES
Note
In the second sample, one can consider February 1 and March 1 of year 2015. Both these days were Sundays.
In the third sample, one can consider July 1 and August 1 of year 2017. First of these two days is Saturday, while the second one is Tuesday.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int monthdays[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
string days[] = {"monday", "tuesday", "wednesday", "thursday",
"friday", "saturday", "sunday"};
bool flag = false;
string fir, sec;
cin >> fir >> sec;
int ind1, ind2;
for (int i = 0; i < 7; i++) {
if (fir == days[i]) ind1 = i;
if (sec == days[i]) ind2 = i;
}
for (int i = 0; i < 12; i++) {
int temp = ind1;
temp += monthdays[i];
temp = temp % 7;
if (temp == ind2) {
flag = true;
break;
}
}
if (flag)
cout << "YES";
else
cout << "NO";
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Given are integers A, B, and N.
Find the maximum possible value of floor(Ax/B) - A Γ floor(x/B) for a non-negative integer x not greater than N.
Here floor(t) denotes the greatest integer not greater than the real number t.
Constraints
* 1 β€ A β€ 10^{6}
* 1 β€ B β€ 10^{12}
* 1 β€ N β€ 10^{12}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B N
Output
Print the maximum possible value of floor(Ax/B) - A Γ floor(x/B) for a non-negative integer x not greater than N, as an integer.
Examples
Input
5 7 4
Output
2
Input
11 10 9
Output
9
### Response
```cpp
#include<bits/stdc++.h>
#define ll long long
const int N=100005;
using namespace std;
ll a,b,n;
int main(){
cin>>a>>b>>n;
cout<<a*min(b-1,n)/b;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
There is a rectangle in a coordinate plane. The coordinates of the four vertices are (0,0), (W,0), (W,H), and (0,H). You are given a point (x,y) which is within the rectangle or on its border. We will draw a straight line passing through (x,y) to cut the rectangle into two parts. Find the maximum possible area of the part whose area is not larger than that of the other. Additionally, determine if there are multiple ways to cut the rectangle and achieve that maximum.
Constraints
* 1 \leq W,H \leq 10^9
* 0\leq x\leq W
* 0\leq y\leq H
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
W H x y
Output
Print the maximum possible area of the part whose area is not larger than that of the other, followed by `1` if there are multiple ways to cut the rectangle and achieve that maximum, and `0` otherwise.
The area printed will be judged correct when its absolute or relative error is at most 10^{-9}.
Examples
Input
2 3 1 2
Output
3.000000 0
Input
2 2 1 1
Output
2.000000 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
double h,w,x,y;
cin >> w >> h >> x >> y;
int ans = 0;
if(w / 2 == x && h / 2 == y)ans = 1;
printf("%.10f %d\n",(h*w)/2,ans);
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Zxr960115 is owner of a large farm. He feeds m cute cats and employs p feeders. There's a straight road across the farm and n hills along the road, numbered from 1 to n from left to right. The distance between hill i and (i - 1) is di meters. The feeders live in hill 1.
One day, the cats went out to play. Cat i went on a trip to hill hi, finished its trip at time ti, and then waited at hill hi for a feeder. The feeders must take all the cats. Each feeder goes straightly from hill 1 to n without waiting at a hill and takes all the waiting cats at each hill away. Feeders walk at a speed of 1 meter per unit time and are strong enough to take as many cats as they want.
For example, suppose we have two hills (d2 = 1) and one cat that finished its trip at time 3 at hill 2 (h1 = 2). Then if the feeder leaves hill 1 at time 2 or at time 3, he can take this cat, but if he leaves hill 1 at time 1 he can't take it. If the feeder leaves hill 1 at time 2, the cat waits him for 0 time units, if the feeder leaves hill 1 at time 3, the cat waits him for 1 time units.
Your task is to schedule the time leaving from hill 1 for each feeder so that the sum of the waiting time of all cats is minimized.
Input
The first line of the input contains three integers n, m, p (2 β€ n β€ 105, 1 β€ m β€ 105, 1 β€ p β€ 100).
The second line contains n - 1 positive integers d2, d3, ..., dn (1 β€ di < 104).
Each of the next m lines contains two integers hi and ti (1 β€ hi β€ n, 0 β€ ti β€ 109).
Output
Output an integer, the minimum sum of waiting time of all cats.
Please, do not write 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
4 6 2
1 3 5
1 0
2 1
4 9
1 10
2 10
3 12
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
auto fio = (ios::sync_with_stdio(0), cin.tie(0), cout.tie(0));
struct Line {
long long m, p;
Line(long long m, long long p) : m(m), p(p) {}
long long eval(long long x) { return m * x + p; }
double intersectX(Line& o) { return (double)(p - o.p) / (o.m - m); }
};
int32_t main() {
long long n, m, p;
cin >> n >> m >> p;
vector<long long> d(n);
for (long long i = 1; i < n; i++) cin >> d[i];
partial_sum(d.begin(), d.end(), d.begin());
vector<long long> vec(m);
for (long long i = 0; i < m; i++) {
long long h;
cin >> h;
h--;
long long t;
cin >> t;
vec[i] = t - d[h];
}
sort(vec.begin(), vec.end());
vector<long long> pfx(m), dp(m, 1e17);
partial_sum(vec.begin(), vec.end(), pfx.begin());
while (p--) {
deque<Line> dq;
dq.push_back(Line(0, 0));
for (long long i = 0; i < m; i++) {
long long m = dq.size();
Line cur(-(i + 1), dp[i] + pfx[i]);
while (m >= 2 &&
dq[m - 2].intersectX(cur) <= dq[m - 1].intersectX(dq[m - 2]))
dq.pop_back(), m--;
dq.push_back(cur);
m++;
long long x = vec[i];
while (m >= 2 && dq[1].eval(x) <= dq[0].eval(x)) dq.pop_front(), m--;
long long r = dq.front().eval(x) + (i + 1) * vec[i] - pfx[i];
dp[i] = r;
}
}
cout << dp.back() << endl;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Nauuo is a girl who loves playing cards.
One day she was playing cards but found that the cards were mixed with some empty ones.
There are n cards numbered from 1 to n, and they were mixed with another n empty cards. She piled up the 2n cards and drew n of them. The n cards in Nauuo's hands are given. The remaining n cards in the pile are also given in the order from top to bottom.
In one operation she can choose a card in her hands and play it β put it at the bottom of the pile, then draw the top card from the pile.
Nauuo wants to make the n numbered cards piled up in increasing order (the i-th card in the pile from top to bottom is the card i) as quickly as possible. Can you tell her the minimum number of operations?
Input
The first line contains a single integer n (1β€ nβ€ 2β
10^5) β the number of numbered cards.
The second line contains n integers a_1,a_2,β¦,a_n (0β€ a_iβ€ n) β the initial cards in Nauuo's hands. 0 represents an empty card.
The third line contains n integers b_1,b_2,β¦,b_n (0β€ b_iβ€ n) β the initial cards in the pile, given in order from top to bottom. 0 represents an empty card.
It is guaranteed that each number from 1 to n appears exactly once, either in a_{1..n} or b_{1..n}.
Output
The output contains a single integer β the minimum number of operations to make the n numbered cards piled up in increasing order.
Examples
Input
3
0 2 0
3 0 1
Output
2
Input
3
0 2 0
1 0 3
Output
4
Input
11
0 0 0 5 0 0 0 4 0 0 11
9 2 6 0 8 1 7 0 3 0 10
Output
18
Note
Example 1
We can play the card 2 and draw the card 3 in the first operation. After that, we have [0,3,0] in hands and the cards in the pile are [0,1,2] from top to bottom.
Then, we play the card 3 in the second operation. The cards in the pile are [1,2,3], in which the cards are piled up in increasing order.
Example 2
Play an empty card and draw the card 1, then play 1, 2, 3 in order.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> a(n + 1), b(n + 1), p(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[a[i]] = 0;
}
for (int i = 1; i <= n; ++i) {
cin >> b[i];
p[b[i]] = i;
}
if (p[1]) {
int k = 1, i;
for (i = 2; p[i] == p[1] + i - 1; ++i) {
k++;
}
if (p[i - 1] == n) {
set<int> s;
for (auto x : a) {
if (x) {
s.insert(x);
}
}
int f = 1;
int ind = 1;
for (; i <= n; ++i) {
auto it = s.find(i);
if (it == s.end()) {
f = 0;
break;
}
s.erase(it);
s.insert(b[ind]);
ind++;
}
if (f == 1) {
cout << n - k;
return 0;
}
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
ans = max(ans, p[i] - i + 1 + n);
}
cout << ans;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Mahmoud was trying to solve the vertex cover problem on trees. The problem statement is:
Given an undirected tree consisting of n nodes, find the minimum number of vertices that cover all the edges. Formally, we need to find a set of vertices such that for each edge (u, v) that belongs to the tree, either u is in the set, or v is in the set, or both are in the set. Mahmoud has found the following algorithm:
* Root the tree at node 1.
* Count the number of nodes at an even depth. Let it be evenCnt.
* Count the number of nodes at an odd depth. Let it be oddCnt.
* The answer is the minimum between evenCnt and oddCnt.
The depth of a node in a tree is the number of edges in the shortest path between this node and the root. The depth of the root is 0.
Ehab told Mahmoud that this algorithm is wrong, but he didn't believe because he had tested his algorithm against many trees and it worked, so Ehab asked you to find 2 trees consisting of n nodes. The algorithm should find an incorrect answer for the first tree and a correct answer for the second one.
Input
The only line contains an integer n (2 β€ n β€ 105), the number of nodes in the desired trees.
Output
The output should consist of 2 independent sections, each containing a tree. The algorithm should find an incorrect answer for the tree in the first section and a correct answer for the tree in the second. If a tree doesn't exist for some section, output "-1" (without quotes) for that section only.
If the answer for a section exists, it should contain n - 1 lines, each containing 2 space-separated integers u and v (1 β€ u, v β€ n), which means that there's an undirected edge between node u and node v. If the given graph isn't a tree or it doesn't follow the format, you'll receive wrong answer verdict.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
-1
1 2
Input
8
Output
1 2
1 3
2 4
2 5
3 6
4 7
4 8
1 2
1 3
2 4
2 5
2 6
3 7
6 8
Note
In the first sample, there is only 1 tree with 2 nodes (node 1 connected to node 2). The algorithm will produce a correct answer in it so we printed - 1 in the first section, but notice that we printed this tree in the second section.
In the second sample:
In the first tree, the algorithm will find an answer with 4 nodes, while there exists an answer with 3 nodes like this: <image> In the second tree, the algorithm will find an answer with 3 nodes which is correct: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k, m, a[100001];
string s[100001];
map<string, int> m2;
long long ans;
int main() {
cin >> n;
if (n >= 6) {
for (int i = 2; i <= n - 2; i++) {
cout << 1 << " " << i << '\n';
}
cout << 2 << " " << n - 1 << '\n';
cout << 2 << " " << n << '\n';
}
if (n < 6) {
cout << -1 << '\n';
}
cout << 1 << " " << 2 << '\n';
for (int i = 3; i <= n; i++) {
cout << 2 << " " << i << '\n';
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
The Little Elephant loves Ukraine very much. Most of all he loves town Rozdol (ukr. "Rozdil").
However, Rozdil is dangerous to settle, so the Little Elephant wants to go to some other town. The Little Elephant doesn't like to spend much time on travelling, so for his journey he will choose a town that needs minimum time to travel to. If there are multiple such cities, then the Little Elephant won't go anywhere.
For each town except for Rozdil you know the time needed to travel to this town. Find the town the Little Elephant will go to or print "Still Rozdil", if he stays in Rozdil.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of cities. The next line contains n integers, separated by single spaces: the i-th integer represents the time needed to go from town Rozdil to the i-th town. The time values are positive integers, not exceeding 109.
You can consider the cities numbered from 1 to n, inclusive. Rozdil is not among the numbered cities.
Output
Print the answer on a single line β the number of the town the Little Elephant will go to. If there are multiple cities with minimum travel time, print "Still Rozdil" (without the quotes).
Examples
Input
2
7 4
Output
2
Input
7
7 4 47 100 4 9 12
Output
Still Rozdil
Note
In the first sample there are only two cities where the Little Elephant can go. The travel time for the first town equals 7, to the second one β 4. The town which is closest to Rodzil (the only one) is the second one, so the answer is 2.
In the second sample the closest cities are cities two and five, the travelling time to both of them equals 4, so the answer is "Still Rozdil".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, l = 1, b = 0;
cin >> n;
long int a[n];
cin >> a[0];
int m = a[0];
for (int k = 1; k < n; ++k) {
cin >> a[k];
if (a[k] < m) {
m = a[k];
l = k + 1;
}
}
for (int i = 0; i < n; ++i) {
if (a[i] == m) b++;
}
if (b > 1) {
cout << "Still Rozdil";
return 0;
}
cout << l;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
There are n students standing in a row. Two coaches are forming two teams β the first coach chooses the first team and the second coach chooses the second team.
The i-th student has integer programming skill a_i. All programming skills are distinct and between 1 and n, inclusive.
Firstly, the first coach will choose the student with maximum programming skill among all students not taken into any team, and k closest students to the left of him and k closest students to the right of him (if there are less than k students to the left or to the right, all of them will be chosen). All students that are chosen leave the row and join the first team. Secondly, the second coach will make the same move (but all students chosen by him join the second team). Then again the first coach will make such move, and so on. This repeats until the row becomes empty (i. e. the process ends when each student becomes to some team).
Your problem is to determine which students will be taken into the first team and which students will be taken into the second team.
Input
The first line of the input contains two integers n and k (1 β€ k β€ n β€ 2 β
10^5) β the number of students and the value determining the range of chosen students during each move, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n), where a_i is the programming skill of the i-th student. It is guaranteed that all programming skills are distinct.
Output
Print a string of n characters; i-th character should be 1 if i-th student joins the first team, or 2 otherwise.
Examples
Input
5 2
2 4 5 3 1
Output
11111
Input
5 1
2 1 3 5 4
Output
22111
Input
7 1
7 2 1 3 5 4 6
Output
1121122
Input
5 1
2 4 5 3 1
Output
21112
Note
In the first example the first coach chooses the student on a position 3, and the row becomes empty (all students join the first team).
In the second example the first coach chooses the student on position 4, and the row becomes [2, 1] (students with programming skills [3, 4, 5] join the first team). Then the second coach chooses the student on position 1, and the row becomes empty (and students with programming skills [1, 2] join the second team).
In the third example the first coach chooses the student on position 1, and the row becomes [1, 3, 5, 4, 6] (students with programming skills [2, 7] join the first team). Then the second coach chooses the student on position 5, and the row becomes [1, 3, 5] (students with programming skills [4, 6] join the second team). Then the first coach chooses the student on position 3, and the row becomes [1] (students with programming skills [3, 5] join the first team). And then the second coach chooses the remaining student (and the student with programming skill 1 joins the second team).
In the fourth example the first coach chooses the student on position 3, and the row becomes [2, 1] (students with programming skills [3, 4, 5] join the first team). Then the second coach chooses the student on position 1, and the row becomes empty (and students with programming skills [1, 2] join the second team).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct number_iterator : iterator<random_access_iterator_tag, T> {
T v;
number_iterator(T v) : v(v) {}
operator T&() { return v; }
T operator*() { return v; }
};
template <typename T>
struct number_range {
T b, e;
number_range(T b, T e) : b(b), e(e) {}
number_iterator<T> begin() { return b; }
number_iterator<T> end() { return e; }
};
template <typename T>
number_range<T> range(T b, T e) {
return number_range<T>(b, e);
}
template <typename T>
number_range<T> range(T e) {
return number_range<T>(0, e);
}
template <typename T>
T read_() {
T t;
cin >> t;
return t;
}
template <typename T>
T read(T& t) {
cin >> t;
return t;
}
template <typename T>
vector<T> read_n(int n) {
vector<T> v(n);
generate_n(v.begin(), n, read_<T>);
return v;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n = read_<int>();
int k = read_<int>();
auto s = read_n<int>(n);
auto order = vector<int>(n);
iota((order).begin(), (order).end(), 0);
sort((order).begin(), (order).end(),
[&](int i, int j) { return s[i] > s[j]; });
auto prev = vector<int>(n);
auto next = vector<int>(n);
for (int i : range(n)) {
next[i] = i + 1;
prev[i] = i - 1;
}
next[n - 1] = -1;
prev[0] = -1;
auto team = vector<int>(n);
int T = 1;
for (int idx : order) {
if (team[idx] == 0) {
int cur = next[idx];
for (int i : range(k)) {
if (cur < 0) break;
int nxt = next[cur];
int prv = prev[cur];
team[cur] = T;
if (nxt != -1) prev[nxt] = prev[cur];
if (prv != -1) next[prv] = next[cur];
cur = nxt;
}
cur = prev[idx];
for (int i : range(k)) {
if (cur < 0) break;
int nxt = next[cur];
int prv = prev[cur];
team[cur] = T;
if (nxt != -1) prev[nxt] = prev[cur];
if (prv != -1) next[prv] = next[cur];
cur = prv;
}
cur = idx;
int nxt = next[cur];
int prv = prev[cur];
team[cur] = T;
if (nxt != -1) prev[nxt] = prev[cur];
if (prv != -1) next[prv] = next[cur];
T = 3 - T;
}
}
for (int x : team) cout << x;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
This is the easy version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 3n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1β€ tβ€ 1000) β the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 1000) β the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 1000.
Output
For each test case, output an integer k (0β€ kβ€ 3n), followed by k integers p_1,β¦,p_k (1β€ p_iβ€ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01β 11β 00β 10.
In the second test case, we have 01011β 00101β 11101β 01000β 10100β 00100β 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n;
vector<int> res;
cin >> n;
vector<char> a(n), b(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
if (i == 0) {
res.push_back(1);
} else {
res.push_back(i + 1);
res.push_back(1);
res.push_back(i + 1);
}
}
}
cout << res.size() << " ";
for (int i : res) {
cout << i << " ";
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given a sequence of n integers S and a sequence of different q integers T. Write a program which outputs C, the number of integers in T which are also in the set S.
Notes
Constraints
* Elements in S is sorted in ascending order
* n β€ 100000
* q β€ 50000
* 0 β€ an element in S β€ 109
* 0 β€ an element in T β€ 109
Input
In the first line n is given. In the second line, n integers are given. In the third line q is given. Then, in the fourth line, q integers are given.
Output
Print C in a line.
Examples
Input
5
1 2 3 4 5
3
3 4 1
Output
3
Input
3
1 2 3
1
5
Output
0
Input
5
1 1 2 2 3
2
1 2
Output
2
### Response
```cpp
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n;
cin >> n;
int S[n];
for (int i = 0; i < n; i++) {
cin >> S[i];
}
int q;
cin >> q;
int C = 0;
for (int i = 0; i < q; i++) {
int T;
cin >> T;
if (binary_search(S, S + n, T)) {
C++;
}
}
cout << C << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
I am a craftsman specialized in interior works. A customer asked me to perform wiring work on a wall whose entire rectangular surface is tightly pasted with pieces of panels. The panels are all of the same size (2 m in width, 1 m in height) and the wall is filled with an x (horizontal) by y (vertical) array of the panels. The customer asked me to stretch a wire from the left top corner of the wall to the right bottom corner whereby the wire is tied up at the crossing points with the panel boundaries (edges and vertexes) as shown in the figure. There are nine tied-up points in the illustrative figure shown below.
<image>
Fig: The wire is tied up at the edges and vertexes of the panels (X: 4 panels, Y: 6 panels)
Write a program to provide the number of points where the wire intersects with the panel boundaries. Assume that the wire and boundary lines have no thickness.
Input
The input is given in the following format.
x y
A line of data is given that contains the integer number of panels in the horizontal direction x (1 β€ x β€ 1000) and those in the vertical direction y (1 β€ y β€ 1000).
Output
Output the number of points where the wire intersects with the panel boundaries.
Examples
Input
4 4
Output
5
Input
4 6
Output
9
### Response
```cpp
#include<iostream>
#include<stdio.h>
#include<string>
#include<cmath>
#include<math.h>
#include<vector>
#include<algorithm>
#include<map>
#include<unordered_map>
#pragma warning(disable: 4996)
#define rep(i,n) for(int i = 0; i < (n); i++)
#define rep2(j,a,b) for(int j = a; j < (b); j++)
using namespace std;
using ll = long long;
int gcd(int x, int y) {
if (y > x)swap(x, y);
if (x % y==0) { return y; }
else gcd(y, x % y);
}
int main() {
int x, y;
cin >> x >> y;
cout << x + y - gcd(x, y) + 1 << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
There is an infinite 2-dimensional grid. The robot stands in cell (0, 0) and wants to reach cell (x, y). Here is a list of possible commands the robot can execute:
* move north from cell (i, j) to (i, j + 1);
* move east from cell (i, j) to (i + 1, j);
* move south from cell (i, j) to (i, j - 1);
* move west from cell (i, j) to (i - 1, j);
* stay in cell (i, j).
The robot wants to reach cell (x, y) in as few commands as possible. However, he can't execute the same command two or more times in a row.
What is the minimum number of commands required to reach (x, y) from (0, 0)?
Input
The first line contains a single integer t (1 β€ t β€ 100) β the number of testcases.
Each of the next t lines contains two integers x and y (0 β€ x, y β€ 10^4) β the destination coordinates of the robot.
Output
For each testcase print a single integer β the minimum number of commands required for the robot to reach (x, y) from (0, 0) if no command is allowed to be executed two or more times in a row.
Example
Input
5
5 5
3 4
7 1
0 0
2 0
Output
10
7
13
0
3
Note
The explanations for the example test:
We use characters N, E, S, W and 0 to denote going north, going east, going south, going west and staying in the current cell, respectively.
In the first test case, the robot can use the following sequence: NENENENENE.
In the second test case, the robot can use the following sequence: NENENEN.
In the third test case, the robot can use the following sequence: ESENENE0ENESE.
In the fourth test case, the robot doesn't need to go anywhere at all.
In the fifth test case, the robot can use the following sequence: E0E.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pi;
typedef vector<int> vi;
typedef vector<pi> vpi;
#define mp make_pair
#define sz(x) (int)(x).size()
#define all(x) begin(x), end(x)
#define rsz resize
#define bk back()
#define pb push_back
#define ins insert
#define del erase
#define inf INT_MAX
#define db cout << "here" << endl;
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)
#define nl endl
const int MOD = 1e9+7;
const ld PI = acos((ld)-1);
mt19937 rng; // or mt19937_64
template<class T> bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0; }
ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down
void DBG() { cerr << "]" << endl; }
template<class H, class... T> void DBG(H h, T... t) {
cerr << h; if (sizeof...(t)) cerr << ", ";
DBG(t...); }
#ifdef LOCAL // compile with -DLOCAL
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif
const int MX = 300002;
const int INF = MX+MX;
void solve() {
int x,y;
cin >> x >> y;
int a = min(x,y);
int b = max(x,y);
if((a+1)>=b)
cout << a+b << endl;
else
cout << (b-a)+a+b-1 << endl;
}
int main() {
int t;
cin>>t;
for(int i = 1; i <= t ; i++) {
solve();
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Yash has recently learnt about the Fibonacci sequence and is very excited about it. He calls a sequence Fibonacci-ish if
1. the sequence consists of at least two elements
2. f0 and f1 are arbitrary
3. fn + 2 = fn + 1 + fn for all n β₯ 0.
You are given some sequence of integers a1, a2, ..., an. Your task is rearrange elements of this sequence in such a way that its longest possible prefix is Fibonacci-ish sequence.
Input
The first line of the input contains a single integer n (2 β€ n β€ 1000) β the length of the sequence ai.
The second line contains n integers a1, a2, ..., an (|ai| β€ 109).
Output
Print the length of the longest possible Fibonacci-ish prefix of the given sequence after rearrangement.
Examples
Input
3
1 2 -1
Output
3
Input
5
28 35 7 14 21
Output
4
Note
In the first sample, if we rearrange elements of the sequence as - 1, 2, 1, the whole sequence ai would be Fibonacci-ish.
In the second sample, the optimal way to rearrange elements is <image>, <image>, <image>, <image>, 28.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct _ {
ios_base::Init i;
_() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); }
} _;
vector<long long> a;
long long n, pp, p, curr, len, max_len;
unordered_map<long long, long long> vis;
unordered_map<long long, long long> vis2;
stack<long long> st;
int main() {
cin >> n;
a.resize(n, 0);
for (int i = 0; i <= n - 1; i++) cin >> a[i], vis[a[i]]++;
for (int i = 1; i <= n - 1; i++) {
for (int j = 0; j <= i - 1; j++) {
if (a[i] == 0 and a[j] == 0) {
max_len = max(max_len, vis[0]);
continue;
}
pp = a[j], p = a[i], curr = a[i] + a[j];
vis[pp]--;
st.push(pp);
vis[p]--;
st.push(p);
len = 2;
while (vis[curr] > 0) {
vis[curr]--;
st.push(curr);
pp = p, p = curr;
curr = pp + p;
len++;
}
max_len = max(max_len, len);
while (!st.empty()) vis[st.top()]++, st.pop();
pp = a[i], p = a[j], curr = a[i] + a[j];
vis[pp]--;
st.push(pp);
vis[p]--;
st.push(p);
len = 2;
while (vis[curr] > 0) {
vis[curr]--;
st.push(curr);
pp = p, p = curr;
curr = pp + p;
len++;
}
max_len = max(max_len, len);
while (!st.empty()) vis[st.top()]++, st.pop();
}
}
cout << max_len;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Polycarpus enjoys studying Berland hieroglyphs. Once Polycarp got hold of two ancient Berland pictures, on each of which was drawn a circle of hieroglyphs. We know that no hieroglyph occurs twice in either the first or the second circle (but in can occur once in each of them).
Polycarpus wants to save these pictures on his laptop, but the problem is, laptops do not allow to write hieroglyphs circles. So Polycarp had to break each circle and write down all of its hieroglyphs in a clockwise order in one line. A line obtained from the first circle will be called a, and the line obtained from the second one will be called b.
There are quite many ways to break hieroglyphic circles, so Polycarpus chooses the method, that makes the length of the largest substring of string a, which occurs as a subsequence in string b, maximum.
Help Polycarpus β find the maximum possible length of the desired substring (subsequence) if the first and the second circles are broken optimally.
The length of string s is the number of characters in it. If we denote the length of string s as |s|, we can write the string as s = s1s2... s|s|.
A substring of s is a non-empty string x = s[a... b] = sasa + 1... sb (1 β€ a β€ b β€ |s|). For example, "code" and "force" are substrings of "codeforces", while "coders" is not.
A subsequence of s is a non-empty string y = s[p1p2... p|y|] = sp1sp2... sp|y| (1 β€ p1 < p2 < ... < p|y| β€ |s|). For example, "coders" is a subsequence of "codeforces".
Input
The first line contains two integers la and lb (1 β€ la, lb β€ 1000000) β the number of hieroglyphs in the first and second circles, respectively.
Below, due to difficulties with encoding of Berland hieroglyphs, they are given as integers from 1 to 106.
The second line contains la integers β the hieroglyphs in the first picture, in the clockwise order, starting with one of them.
The third line contains lb integers β the hieroglyphs in the second picture, in the clockwise order, starting with one of them.
It is guaranteed that the first circle doesn't contain a hieroglyph, which occurs twice. The second circle also has this property.
Output
Print a single number β the maximum length of the common substring and subsequence. If at any way of breaking the circles it does not exist, print 0.
Examples
Input
5 4
1 2 3 4 5
1 3 5 6
Output
2
Input
4 6
1 3 5 2
1 2 3 4 5 6
Output
3
Input
3 3
1 2 3
3 2 1
Output
2
Note
In the first test Polycarpus picks a string that consists of hieroglyphs 5 and 1, and in the second sample β from hieroglyphs 1, 3 and 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int A[1000010];
int B[1000010];
long long pos[2000010];
int pos_in_B[1000010];
int main() {
cin.sync_with_stdio(false);
int N, M;
cin >> N >> M;
for (int i = 0; i < N; ++i) cin >> A[i];
for (int i = 0; i < M; ++i) cin >> B[i];
memset(pos_in_B, -1, sizeof(pos_in_B));
for (int i = 0; i < M; ++i) pos_in_B[B[i]] = i;
int ma = 0;
int st = 0;
for (int i = 0; i < 2 * N; ++i) {
int id = i % N;
if (i == 0)
pos[i] = pos_in_B[A[id]];
else {
if (pos_in_B[A[id]] == -1)
pos[i] = -1;
else {
long long b = (pos[i - 1] / M) * M + pos_in_B[A[id]];
if (b <= pos[i - 1]) b += M;
pos[i] = b;
}
}
if (pos[i] == -1) {
st = i + 1;
continue;
}
st = max(st, i + 1 - N);
int p = lower_bound(pos + st, pos + i + 1, pos[i] - M + 1) - pos;
ma = max(ma, i - p + 1);
}
cout << ma << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" β "bba".
The second example: "aab" β "abba" β "bbaba" β "bbbbaa".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
char s[1000005];
constexpr ll MOD = 1000000007;
template <typename T>
T modpow(T base, T exp, T modulus) {
base %= modulus;
T result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
int main(void) {
int n;
scanf("%s%n", s, &n);
ll a_count = 0, b_count = 0;
ll ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'a') {
a_count++;
} else {
b_count++;
ans = (ans + modpow(2LL, a_count, MOD) + MOD - 1) % MOD;
}
}
printf("%" PRId64 "\n", ans % MOD);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Petya has a polygon consisting of n vertices. All sides of the Petya's polygon are parallel to the coordinate axes, and each two adjacent sides of the Petya's polygon are perpendicular. It is guaranteed that the polygon is simple, that is, it doesn't have self-intersections and self-touches. All internal area of the polygon (borders are not included) was painted in black color by Petya.
Also, Petya has a rectangular window, defined by its coordinates, through which he looks at the polygon. A rectangular window can not be moved. The sides of the rectangular window are parallel to the coordinate axes.
<image> Blue color represents the border of a polygon, red color is the Petya's window. The answer in this case is 2.
Determine the number of black connected areas of Petya's polygon, which can be seen through the rectangular window.
Input
The first line contain four integers x_1, y_1, x_2, y_2 (x_1 < x_2, y_2 < y_1) β the coordinates of top-left and bottom-right corners of the rectangular window.
The second line contains a single integer n (4 β€ n β€ 15 000) β the number of vertices in Petya's polygon.
Each of the following n lines contains two integers β the coordinates of vertices of the Petya's polygon in counterclockwise order. Guaranteed, that the given polygon satisfies the conditions described in the statement.
All coordinates of the rectangular window and all coordinates of the vertices of the polygon are non-negative and do not exceed 15 000.
Output
Print the number of black connected areas of Petya's polygon, which can be seen through the rectangular window.
Example
Input
5 7 16 3
16
0 0
18 0
18 6
16 6
16 1
10 1
10 4
7 4
7 2
2 2
2 6
12 6
12 12
10 12
10 8
0 8
Output
2
Note
The example corresponds to the picture above.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pi = pair<int, int>;
const int MAXN = 15005;
struct disj {
int pa[MAXN];
void init(int n) { iota(pa, pa + n + 1, 0); }
int find(int x) { return pa[x] = (pa[x] == x ? x : find(pa[x])); }
bool uni(int p, int q) {
p = find(p);
q = find(q);
if (p == q) return 0;
pa[q] = p;
return 1;
}
} disj;
struct rect {
int sx, ex, sy, ey;
};
struct block {
int pos, s, e;
bool operator<(const block &b) const { return pi(s, e) < pi(b.s, b.e); }
};
struct swp {
int yc, xs, xe, act;
bool operator<(const swp &b) const { return pi(yc, -act) < pi(b.yc, -b.act); }
};
int n;
pi a[MAXN];
vector<rect> ans;
void make_rect() {
vector<swp> event;
set<block> s;
for (int i = 0; i < n; i++) {
pi p1 = a[i];
pi p2 = a[(i + 1) % n];
if (p1.second == p2.second) continue;
if (p1.second < p2.second) {
event.push_back({p1.first, p1.second, p2.second, -1});
} else {
event.push_back({p1.first, p2.second, p1.second, +1});
}
}
sort(event.begin(), event.end());
auto rect_close = [&](block b, int pos) {
if (b.pos < pos) {
ans.push_back({b.pos, pos, b.s, b.e});
}
};
for (int i = 0; i < event.size();) {
int e = i;
while (e < event.size() && event[e].yc == event[i].yc) {
if (event[e].act == 1) {
auto lbnd = s.lower_bound({-1, event[e].xs, event[e].xe});
int curs = event[e].xs;
int cure = event[e].xe;
if (lbnd != s.begin() && prev(lbnd)->e == event[e].xs) {
curs = prev(lbnd)->s;
rect_close(*prev(lbnd), event[e].yc);
s.erase(prev(lbnd));
}
if (lbnd != s.end() && lbnd->s == event[e].xe) {
cure = lbnd->e;
rect_close(*lbnd, event[e].yc);
s.erase(lbnd);
}
s.insert({event[e].yc, curs, cure});
} else {
auto lbnd = --s.lower_bound({-1, event[e].xe + 1, -1});
if (pi(lbnd->s, lbnd->e) == pi(event[e].xs, event[e].xe)) {
rect_close(*lbnd, event[e].yc);
s.erase(lbnd);
} else if (lbnd->s == event[e].xs) {
rect_close(*lbnd, event[e].yc);
s.erase(lbnd);
s.insert({event[e].yc, event[e].xe, lbnd->e});
} else if (lbnd->e == event[e].xe) {
rect_close(*lbnd, event[e].yc);
s.erase(lbnd);
s.insert({event[e].yc, lbnd->s, event[e].xs});
} else {
rect_close(*lbnd, event[e].yc);
block nxt1 = {event[e].yc, lbnd->s, event[e].xs};
block nxt2 = {event[e].yc, event[e].xe, lbnd->e};
s.erase(lbnd);
s.insert(nxt1);
s.insert(nxt2);
}
}
e++;
}
i = e;
}
for (auto &i : ans) {
}
}
bool insec_by_edge(rect x, rect y) {
x.sx = max(x.sx, y.sx);
x.ex = min(x.ex, y.ex);
x.sy = max(x.sy, y.sy);
x.ey = min(x.ey, y.ey);
if (x.sx > x.ex || x.sy > x.ey) return 0;
if (x.sx < x.ex && x.sy < x.ey) assert(0);
if (pi(x.sx, x.sy) == pi(x.ex, x.ey)) return 0;
return 1;
}
int main() {
pi x, y;
scanf("%d %d %d %d %d", &x.first, &y.second, &y.first, &x.second, &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
}
a[n] = a[0];
make_rect();
vector<rect> comp = ans;
ans.clear();
for (auto &i : comp) {
i.sx = max(i.sx, x.first);
i.ex = min(i.ex, y.first);
i.sy = max(i.sy, x.second);
i.ey = min(i.ey, y.second);
if (i.sx < i.ex && i.sy < i.ey) ans.push_back(i);
}
disj.init(ans.size());
int cnt = 0;
for (int i = 0; i < ans.size(); i++) {
for (int j = 0; j < i; j++) {
if (insec_by_edge(ans[i], ans[j])) {
cnt += disj.uni(i, j);
}
}
}
cout << ans.size() - cnt << endl;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Adilbek was assigned to a special project. For Adilbek it means that he has n days to run a special program and provide its results. But there is a problem: the program needs to run for d days to calculate the results.
Fortunately, Adilbek can optimize the program. If he spends x (x is a non-negative integer) days optimizing the program, he will make the program run in \leftβ (d)/(x + 1) \rightβ days (\leftβ a \rightβ is the ceiling function: \leftβ 2.4 \rightβ = 3, \leftβ 2 \rightβ = 2). The program cannot be run and optimized simultaneously, so the total number of days he will spend is equal to x + \leftβ (d)/(x + 1) \rightβ.
Will Adilbek be able to provide the generated results in no more than n days?
Input
The first line contains a single integer T (1 β€ T β€ 50) β the number of test cases.
The next T lines contain test cases β one per line. Each line contains two integers n and d (1 β€ n β€ 10^9, 1 β€ d β€ 10^9) β the number of days before the deadline and the number of days the program runs.
Output
Print T answers β one per test case. For each test case print YES (case insensitive) if Adilbek can fit in n days or NO (case insensitive) otherwise.
Example
Input
3
1 1
4 5
5 11
Output
YES
YES
NO
Note
In the first test case, Adilbek decides not to optimize the program at all, since d β€ n.
In the second test case, Adilbek can spend 1 day optimizing the program and it will run \leftβ 5/2 \rightβ = 3 days. In total, he will spend 4 days and will fit in the limit.
In the third test case, it's impossible to fit in the limit. For example, if Adilbek will optimize the program 2 days, it'll still work \leftβ (11)/(2+1) \rightβ = 4 days.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
for (long long f = 0; f < t; ++f) {
long long n, d;
cin >> n >> d;
long long mini = d;
long long x = 1;
while (true) {
if (mini >= x + (d + x) / (x + 1)) {
mini = x + (d + x) / (x + 1);
x++;
} else
break;
}
if (mini <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
If the girl doesn't go to Denis, then Denis will go to the girl. Using this rule, the young man left home, bought flowers and went to Nastya.
On the way from Denis's house to the girl's house is a road of n lines. This road can't be always crossed in one green light. Foreseeing this, the good mayor decided to place safety islands in some parts of the road. Each safety island is located after a line, as well as at the beginning and at the end of the road. Pedestrians can relax on them, gain strength and wait for a green light.
Denis came to the edge of the road exactly at the moment when the green light turned on. The boy knows that the traffic light first lights up g seconds green, and then r seconds red, then again g seconds green and so on.
Formally, the road can be represented as a segment [0, n]. Initially, Denis is at point 0. His task is to get to point n in the shortest possible time.
He knows many different integers d_1, d_2, β¦, d_m, where 0 β€ d_i β€ n β are the coordinates of points, in which the safety islands are located. Only at one of these points, the boy can be at a time when the red light is on.
Unfortunately, Denis isn't always able to control himself because of the excitement, so some restrictions are imposed:
* He must always move while the green light is on because it's difficult to stand when so beautiful girl is waiting for you. Denis can change his position by Β± 1 in 1 second. While doing so, he must always stay inside the segment [0, n].
* He can change his direction only on the safety islands (because it is safe). This means that if in the previous second the boy changed his position by +1 and he walked on a safety island, then he can change his position by Β± 1. Otherwise, he can change his position only by +1. Similarly, if in the previous second he changed his position by -1, on a safety island he can change position by Β± 1, and at any other point by -1.
* At the moment when the red light is on, the boy must be on one of the safety islands. He can continue moving in any direction when the green light is on.
Denis has crossed the road as soon as his coordinate becomes equal to n.
This task was not so simple, because it's possible that it is impossible to cross the road. Since Denis has all thoughts about his love, he couldn't solve this problem and asked us to help him. Find the minimal possible time for which he can cross the road according to these rules, or find that it is impossible to do.
Input
The first line contains two integers n and m (1 β€ n β€ 10^6, 2 β€ m β€ min(n + 1, 10^4)) β road width and the number of safety islands.
The second line contains m distinct integers d_1, d_2, β¦, d_m (0 β€ d_i β€ n) β the points where the safety islands are located. It is guaranteed that there are 0 and n among them.
The third line contains two integers g, r (1 β€ g, r β€ 1000) β the time that the green light stays on and the time that the red light stays on.
Output
Output a single integer β the minimum time for which Denis can cross the road with obeying all the rules.
If it is impossible to cross the road output -1.
Examples
Input
15 5
0 3 7 14 15
11 11
Output
45
Input
13 4
0 3 7 13
9 9
Output
-1
Note
In the first test, the optimal route is:
* for the first green light, go to 7 and return to 3. In this case, we will change the direction of movement at the point 7, which is allowed, since there is a safety island at this point. In the end, we will be at the point of 3, where there is also a safety island. The next 11 seconds we have to wait for the red light.
* for the second green light reaches 14. Wait for the red light again.
* for 1 second go to 15. As a result, Denis is at the end of the road.
In total, 45 seconds are obtained.
In the second test, it is impossible to cross the road according to all the rules.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct P {
int x, y, z;
bool operator<(const P &a) const { return z > a.z; };
};
int a, b, c, d, i, k, n, m, e[10012][1010],
dx[10] = {1, 0, -1, 0, 1, 1, -1, -1}, dy[10] = {0, 1, 0, -1, 1, -1, 1, -1};
int o[10010];
int l[10033][1010];
int j[10011];
long long x, y, z, mod = 1000000007;
char r[10][18];
P u[1];
priority_queue<P> q;
stack<int> s;
map<int, int> p;
vector<int> v[1];
bool as(P a, P b) { return a.x < b.x; }
int main() {
scanf("%d %d", &b, &a);
for (int t = 1; t <= a; t++) scanf("%d", &o[t]);
sort(o + 1, o + a + 1);
q.push({1, 0, 0});
scanf("%d %d", &c, &d);
for (int t = 1; t <= a; t++)
for (int w = 0; w < c; w++) l[t][w] = mod;
l[1][0] = 0;
for (; q.size();)
if (l[q.top().x][q.top().y] == q.top().z) {
P s = q.top();
e[s.x][s.y] = 1;
q.pop();
if (s.x > 1) {
if (c - s.y >= o[s.x] - o[s.x - 1]) {
if (c - s.y == o[s.x] - o[s.x - 1] &&
l[s.x - 1][0] > l[s.x][s.y] + 1) {
l[s.x - 1][0] = l[s.x][s.y] + 1;
q.push({s.x - 1, 0, s.z + 1});
} else if (c - s.y > o[s.x] - o[s.x - 1] &&
l[s.x - 1][s.y + o[s.x] - o[s.x - 1]] > l[s.x][s.y]) {
l[s.x - 1][s.y + o[s.x] - o[s.x - 1]] = l[s.x][s.y];
q.push({s.x - 1, s.y + o[s.x] - o[s.x - 1], s.z});
}
}
}
if (s.x < a - 1) {
if (c - s.y >= o[s.x + 1] - o[s.x]) {
if (c - s.y == o[s.x + 1] - o[s.x] &&
l[s.x + 1][0] > l[s.x][s.y] + 1) {
l[s.x + 1][0] = l[s.x][s.y] + 1;
q.push({s.x + 1, 0, s.z + 1});
} else if (c - s.y > o[s.x + 1] - o[s.x] &&
l[s.x + 1][s.y + o[s.x + 1] - o[s.x]] > l[s.x][s.y]) {
l[s.x + 1][s.y + o[s.x + 1] - o[s.x]] = l[s.x][s.y];
q.push({s.x + 1, s.y + o[s.x + 1] - o[s.x], s.z});
}
}
}
} else
q.pop();
x = mod;
for (int t = 1; t < a; t++)
if (o[a] - o[t] <= c)
x = min(x, (long long)l[t][0] * (c + d) + o[a] - o[t]);
if (x < mod)
printf("%lld", x);
else
puts("-1");
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 Γ n table).
At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 Γ a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.
After that Bob makes a sequence of "shots". He names cells of the field and Alice either says that the cell is empty ("miss"), or that the cell belongs to some ship ("hit").
But here's the problem! Alice like to cheat. May be that is why she responds to each Bob's move with a "miss".
Help Bob catch Alice cheating β find Bob's first move, such that after it you can be sure that Alice cheated.
Input
The first line of the input contains three integers: n, k and a (1 β€ n, k, a β€ 2Β·105) β the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.
The second line contains integer m (1 β€ m β€ n) β the number of Bob's moves.
The third line contains m distinct integers x1, x2, ..., xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.
Output
Print a single integer β the number of such Bob's first move, after which you can be sure that Alice lied. Bob's moves are numbered from 1 to m in the order the were made. If the sought move doesn't exist, then print "-1".
Examples
Input
11 3 3
5
4 8 6 1 11
Output
3
Input
5 1 3
2
1 5
Output
-1
Input
5 1 3
1
3
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MAXN = 200000 + 10;
int a[MAXN], n, k, s, m;
set<int> vis;
int get_sum(int len) { return (len + 1) / (s + 1); }
int sloved() {
int cnt = get_sum(n);
vis.insert(0), vis.insert(n + 1);
for (int i = 1; i <= m; i++) {
auto it = vis.lower_bound(a[i]);
int ed = *it;
if (ed == a[i]) continue;
it--;
int st = *it;
int len = ed - st - 1;
vis.insert(a[i]);
if (len < s) continue;
cnt -= get_sum(len);
cnt += get_sum(a[i] - st - 1) + get_sum(ed - a[i] - 1);
if (cnt < k) return i;
}
return -1;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
printf("%d\n", sloved());
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Programming teacher Dmitry Olegovich is going to propose the following task for one of his tests for students:
You are given a tree T with n vertices, specified by its adjacency matrix a[1... n, 1... n]. What is the output of the following pseudocode?
used[1 ... n] = {0, ..., 0};
procedure dfs(v):
print v;
used[v] = 1;
for i = 1, 2, ..., n:
if (a[v][i] == 1 and used[i] == 0):
dfs(i);
dfs(1);
In order to simplify the test results checking procedure, Dmitry Olegovich decided to create a tree T such that the result is his favorite sequence b. On the other hand, Dmitry Olegovich doesn't want to provide students with same trees as input, otherwise they might cheat. That's why Dmitry Olegovich is trying to find out the number of different trees T such that the result of running the above pseudocode with T as input is exactly the sequence b. Can you help him?
Two trees with n vertices are called different if their adjacency matrices a1 and a2 are different, i. e. there exists a pair (i, j), such that 1 β€ i, j β€ n and a1[i][j] β a2[i][j].
Input
The first line contains the positive integer n (1 β€ n β€ 500) β the length of sequence b.
The second line contains n positive integers b1, b2, ..., bn (1 β€ bi β€ n). It is guaranteed that b is a permutation, or in other words, each of the numbers 1, 2, ..., n appears exactly once in the sequence b. Also it is guaranteed that b1 = 1.
Output
Output the number of trees satisfying the conditions above modulo 109 + 7.
Examples
Input
3
1 2 3
Output
2
Input
3
1 3 2
Output
1
### Response
```cpp
#include <bits/stdc++.h>
const int N = 510;
const int mod = (int)1e9 + 7;
int n, a[N];
long long dp[N][N];
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", a + i);
memset(dp, 0, sizeof(dp));
dp[n][n] = 1;
a[n + 1] = 10000;
for (int i = n - 1; i >= 1; i--) {
dp[i][i] = 1;
for (int j = i + 1; j <= n; j++) {
for (int k = i + 1; k <= j; k++) {
if (a[i + 1] < a[k + 1] || k == j) {
dp[i][j] = (dp[i][j] + dp[i + 1][k] * dp[k][j]) % mod;
}
}
}
}
printf("%I64d\n", dp[1][n]);
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Polycarp was given an array of a[1 ... n] of n integers. He can perform the following operation with the array a no more than n times:
* Polycarp selects the index i and adds the value a_i to one of his choice of its neighbors. More formally, Polycarp adds the value of a_i to a_{i-1} or to a_{i+1} (if such a neighbor does not exist, then it is impossible to add to it).
* After adding it, Polycarp removes the i-th element from the a array. During this step the length of a is decreased by 1.
The two items above together denote one single operation.
For example, if Polycarp has an array a = [3, 1, 6, 6, 2], then it can perform the following sequence of operations with it:
* Polycarp selects i = 2 and adds the value a_i to (i-1)-th element: a = [4, 6, 6, 2].
* Polycarp selects i = 1 and adds the value a_i to (i+1)-th element: a = [10, 6, 2].
* Polycarp selects i = 3 and adds the value a_i to (i-1)-th element: a = [10, 8].
* Polycarp selects i = 2 and adds the value a_i to (i-1)-th element: a = [18].
Note that Polycarp could stop performing operations at any time.
Polycarp wondered how many minimum operations he would need to perform to make all the elements of a equal (i.e., he wants all a_i are equal to each other).
Input
The first line contains a single integer t (1 β€ t β€ 3000) β the number of test cases in the test. Then t test cases follow.
The first line of each test case contains a single integer n (1 β€ n β€ 3000) β the length of the array. The next line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^5) β array a.
It is guaranteed that the sum of n over all test cases does not exceed 3000.
Output
For each test case, output a single number β the minimum number of operations that Polycarp needs to perform so that all elements of the a array are the same (equal).
Example
Input
4
5
3 1 6 6 2
4
1 2 2 1
3
2 2 2
4
6 3 2 1
Output
4
2
0
2
Note
In the first test case of the example, the answer can be constructed like this (just one way among many other ways):
[3, 1, 6, 6, 2] \xrightarrow[]{i=4,~add~to~left} [3, 1, 12, 2] \xrightarrow[]{i=2,~add~to~right} [3, 13, 2] \xrightarrow[]{i=1,~add~to~right} [16, 2] \xrightarrow[]{i=2,~add~to~left} [18]. All elements of the array [18] are the same.
In the second test case of the example, the answer can be constructed like this (just one way among other ways):
[1, 2, 2, 1] \xrightarrow[]{i=1,~add~to~right} [3, 2, 1] \xrightarrow[]{i=3,~add~to~left} [3, 3]. All elements of the array [3, 3] are the same.
In the third test case of the example, Polycarp doesn't need to perform any operations since [2, 2, 2] contains equal (same) elements only.
In the fourth test case of the example, the answer can be constructed like this (just one way among other ways):
[6, 3, 2, 1] \xrightarrow[]{i=3,~add~to~right} [6, 3, 3] \xrightarrow[]{i=3,~add~to~left} [6, 6]. All elements of the array [6, 6] are the same.
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
long long t, n, ans, b, sum, indx, summ, summa, a[200005], abgd, abgc;
int main(){
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
cin>>t;
while(t--){
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
cin>>n;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=n; i++)
cin>>a[i];
ans=1e15;
summ=0;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=n; i++){
summ+=a[i];
summa=0;
sum=i-1;
indx=0;
b=0;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long j=i+1; j<=n; j++){
indx++;
summa+=a[j];
if(summa>summ){
b=1;
break;
}
else if(summa==summ){
sum+=indx-1;
summa=0;
indx=0;
}
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
}
if(b==1 || summa!=0) continue;
else ans=min(sum, ans);
}
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
cout<<ans<<endl;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
for(long long i=1; i<=8; i++)
abgd++;
for(long long i=1; i<=9; i++)
abgc--;
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You are solving the crossword problem K from IPSC 2014. You solved all the clues except for one: who does Eevee evolve into? You are not very into pokemons, but quick googling helped you find out, that Eevee can evolve into eight different pokemons: Vaporeon, Jolteon, Flareon, Espeon, Umbreon, Leafeon, Glaceon, and Sylveon.
You know the length of the word in the crossword, and you already know some letters. Designers of the crossword made sure that the answer is unambiguous, so you can assume that exactly one pokemon out of the 8 that Eevee evolves into fits the length and the letters given. Your task is to find it.
Input
First line contains an integer n (6 β€ n β€ 8) β the length of the string.
Next line contains a string consisting of n characters, each of which is either a lower case english letter (indicating a known letter) or a dot character (indicating an empty cell in the crossword).
Output
Print a name of the pokemon that Eevee can evolve into that matches the pattern in the input. Use lower case letters only to print the name (in particular, do not capitalize the first letter).
Examples
Input
7
j......
Output
jolteon
Input
7
...feon
Output
leafeon
Input
7
.l.r.o.
Output
flareon
Note
Here's a set of names in a form you can paste into your solution:
["vaporeon", "jolteon", "flareon", "espeon", "umbreon", "leafeon", "glaceon", "sylveon"]
{"vaporeon", "jolteon", "flareon", "espeon", "umbreon", "leafeon", "glaceon", "sylveon"}
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
unsigned long long int n, a[11111], m, ans, ans1, b[11111], leaf, jolt, flar,
umbr, glac, sylv;
bool used[11111];
vector<int> v;
int main() {
string s;
cin >> n;
cin >> s;
if (s.size() == 8) {
cout << "vaporeon";
return 0;
}
if (s.size() == 6) {
cout << "espeon";
return 0;
}
s.erase(4, 3);
for (int i = 0; i <= 3; ++i) {
if (s[0] == 's') {
sylv++;
}
if (s[0] == 'g') {
glac++;
}
if (s[0] == 'u') {
umbr++;
}
if (s[0] == 'l') {
leaf++;
}
if (s[0] == 'j') {
jolt++;
}
if (s[0] == 'f') {
flar++;
}
if (s[1] == 'y') {
sylv++;
}
if (s[1] == 'l') {
glac++;
}
if (s[1] == 'm') {
umbr++;
}
if (s[1] == 'e') {
leaf++;
}
if (s[1] == 'o') {
jolt++;
}
if (s[1] == 'l') {
flar++;
}
if (s[2] == 's') {
sylv++;
}
if (s[2] == 'a') {
glac++;
}
if (s[2] == 'b') {
umbr++;
}
if (s[2] == 'a') {
leaf++;
}
if (s[2] == 'l') {
jolt++;
}
if (s[2] == 'a') {
flar++;
}
if (s[3] == 'v') {
sylv++;
}
if (s[3] == 'c') {
glac++;
}
if (s[3] == 'r') {
umbr++;
}
if (s[3] == 'f') {
leaf++;
}
if (s[3] == 't') {
jolt++;
}
if (s[3] == 'r') {
flar++;
}
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == glac) {
cout << "glaceon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == flar) {
cout << "flareon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == sylv) {
cout << "sylveon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == leaf) {
cout << "leafeon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == umbr) {
cout << "umbreon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == jolt) {
cout << "jolteon";
return 0;
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You've got an array consisting of n integers: a[1], a[2], ..., a[n]. Moreover, there are m queries, each query can be described by three integers li, ri, ki. Query li, ri, ki means that we should add <image> to each element a[j], where li β€ j β€ ri.
Record <image> means the binomial coefficient, or the number of combinations from y elements into groups of x elements.
You need to fulfil consecutively all queries and then print the final array.
Input
The first line contains integers n, m (1 β€ n, m β€ 105).
The second line contains n integers a[1], a[2], ..., a[n] (0 β€ ai β€ 109) β the initial array.
Next m lines contain queries in the format li, ri, ki β to all elements of the segment li... ri add number <image> (1 β€ li β€ ri β€ n; 0 β€ k β€ 100).
Output
Print n integers: the i-th number is the value of element a[i] after all the queries. As the values can be rather large, print them modulo 1000000007 (109 + 7).
Examples
Input
5 1
0 0 0 0 0
1 5 0
Output
1 1 1 1 1
Input
10 2
1 2 3 4 5 0 0 0 0 0
1 6 1
6 10 2
Output
2 4 6 8 10 7 3 6 10 15
### Response
```cpp
#include <bits/stdc++.h>
using namespace ::std;
const long long M = 1000000007;
const int N = 100000, K = 100;
int n, m;
long long a[N + 5];
vector<long long> lq[N + 5], rq[N + 5];
vector<pair<int, int> > qry[K + 5];
long long dp[K + 2][N + 2];
long long c[K + 2][N + 2];
void input() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int l, r, k;
scanf("%d %d %d", &l, &r, &k);
qry[k].push_back(pair<int, int>(l, r));
}
for (int i = 0; i <= K; i++)
for (int j = 0; j <= N; j++) {
if (i == 0 || j == 0)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j] + c[i][j - 1]) % M;
}
}
int main() {
input();
for (int i = K; i >= 0; i--) {
for (int j = K; j >= i; j--) {
for (int k = 0; k < qry[j].size(); k++) {
int l = qry[j][k].first, r = qry[j][k].second;
if (j - i == 0) dp[i][l]++;
dp[i][r + 1] = (dp[i][r + 1] + M - c[j - i][r - l]) % M;
}
}
for (int j = 1; j <= n; j++)
dp[i][j] = (dp[i][j] + dp[i + 1][j] + dp[i][j - 1]) % M;
}
for (int i = 1; i <= n; i++) printf("%d ", (a[i] + dp[0][i]) % M);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Ilya is a very clever lion, he lives in an unusual city ZooVille. In this city all the animals have their rights and obligations. Moreover, they even have their own bank accounts. The state of a bank account is an integer. The state of a bank account can be a negative number. This means that the owner of the account owes the bank money.
Ilya the Lion has recently had a birthday, so he got a lot of gifts. One of them (the gift of the main ZooVille bank) is the opportunity to delete the last digit or the digit before last from the state of his bank account no more than once. For example, if the state of Ilya's bank account is -123, then Ilya can delete the last digit and get his account balance equal to -12, also he can remove its digit before last and get the account balance equal to -13. Of course, Ilya is permitted not to use the opportunity to delete a digit from the balance.
Ilya is not very good at math, and that's why he asks you to help him maximize his bank account. Find the maximum state of the bank account that can be obtained using the bank's gift.
Input
The single line contains integer n (10 β€ |n| β€ 109) β the state of Ilya's bank account.
Output
In a single line print an integer β the maximum state of the bank account that Ilya can get.
Examples
Input
2230
Output
2230
Input
-10
Output
0
Input
-100003
Output
-10000
Note
In the first test sample Ilya doesn't profit from using the present.
In the second test sample you can delete digit 1 and get the state of the account equal to 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = 0;
int y = 0;
x = n / 10;
int u = n % 10;
y = (x / 10) * 10 + u;
cout << max(x, max(y, n)) << "\n";
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Tyndex is again well ahead of the rivals! The reaction to the release of Zoozle Chrome browser was the release of a new browser Tyndex.Brome!
The popularity of the new browser is growing daily. And the secret is not even the Tyndex.Bar installed (the Tyndex.Bar automatically fills the glass with the finest 1664 cognac after you buy Tyndex.Bottles and insert in into a USB port). It is highly popular due to the well-thought interaction with the user.
Let us take, for example, the system of automatic address correction. Have you entered codehorses instead of codeforces? The gloomy Zoozle Chrome will sadly say that the address does not exist. Tyndex.Brome at the same time will automatically find the closest address and sent you there. That's brilliant!
How does this splendid function work? That's simple! For each potential address a function of the F error is calculated by the following rules:
* for every letter ci from the potential address c the closest position j of the letter ci in the address (s) entered by the user is found. The absolute difference |i - j| of these positions is added to F. So for every i (1 β€ i β€ |c|) the position j is chosen such, that ci = sj, and |i - j| is minimal possible.
* if no such letter ci exists in the address entered by the user, then the length of the potential address |c| is added to F.
After the values of the error function have been calculated for all the potential addresses the most suitable one is found.
To understand the special features of the above described method better, it is recommended to realize the algorithm of calculating the F function for an address given by the user and some set of potential addresses. Good luck!
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ 105). They are the number of potential addresses and the length of the address entered by the user. The next line contains k lowercase Latin letters. They are the address entered by the user (s). Each next i-th (1 β€ i β€ n) line contains a non-empty sequence of lowercase Latin letters. They are the potential address. It is guaranteed that the total length of all the lines does not exceed 2Β·105.
Output
On each n line of the output file print a single number: the value of the error function when the current potential address is chosen.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Examples
Input
2 10
codeforces
codeforces
codehorses
Output
0
12
Input
9 9
vkontakte
vcontacte
vkontrakte
vkollapse
vkrokodile
vtopke
vkapuste
vpechke
vk
vcodeforcese
Output
18
14
36
47
14
29
30
0
84
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int N, K;
long long nextL[110000][26], nextR[110000][26];
char addr[210000];
int main() {
scanf("%d%d", &N, &K);
scanf("%s", addr);
for (int i = (0); i < (26); i++)
for (int j = (0); j < (K); j++) {
if (addr[j] - 'a' == i) {
nextL[j][i] = j;
} else if (j == 0) {
nextL[j][i] = -1;
} else {
nextL[j][i] = nextL[j - 1][i];
}
}
for (int i = (0); i < (26); i++)
for (int j = int(K) - 1; j >= (0); j--) {
if (addr[j] - 'a' == i) {
nextR[j][i] = j;
} else if (j == K - 1) {
nextR[j][i] = -1;
} else {
nextR[j][i] = nextR[j + 1][i];
}
}
for (int i = (0); i < (N); i++) {
scanf("%s", addr);
long long v = 0;
int n = strlen(addr);
for (int j = (0); j < (n); j++) {
int c = addr[j] - 'a';
long long d = LLONG_MAX;
if (j <= K - 1 && nextL[j][c] != -1) d = min(d, j - nextL[j][c]);
if (j >= K && nextL[K - 1][c] != -1) d = min(d, j - nextL[K - 1][c]);
if (j <= K - 1 && nextR[j][c] != -1) d = min(d, nextR[j][c] - j);
if (d == LLONG_MAX) d = n;
v += d;
}
cout << v << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 β€ k, b, n, t β€ 106) β the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number β the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, b, n, t, a = 1, i = 0;
cin >> k >> b >> n >> t;
while (a <= t) a = a * k + b, i++;
cout << (n - i + 1 > 0 ? n - i + 1 : 0) << endl;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Kilani and Abd are neighbors for 3000 years, but then the day came and Kilani decided to move to another house. As a farewell gift, Kilani is going to challenge Abd with a problem written by their other neighbor with the same name Abd.
<image>
The problem is:
You are given a connected tree rooted at node 1.
You should assign a character a or b to every node in the tree so that the total number of a's is equal to x and the total number of b's is equal to n - x.
Let's define a string for each node v of the tree as follows:
* if v is root then the string is just one character assigned to v:
* otherwise, let's take a string defined for the v's parent p_v and add to the end of it a character assigned to v.
You should assign every node a character in a way that minimizes the number of distinct strings among the strings of all nodes.
Input
The first line contains two integers n and x (1 β€ n β€ 10^5; 0 β€ x β€ n) β the number of vertices in the tree the number of a's.
The second line contains n - 1 integers p_2, p_3, ..., p_{n} (1 β€ p_i β€ n; p_i β i), where p_i is the parent of node i.
It is guaranteed that the input describes a connected tree.
Output
In the first line, print the minimum possible total number of distinct strings.
In the second line, print n characters, where all characters are either a or b and the i-th character is the character assigned to the i-th node.
Make sure that the total number of a's is equal to x and the total number of b's is equal to n - x.
If there is more than one answer you can print any of them.
Example
Input
9 3
1 2 2 4 4 4 3 1
Output
4
aabbbbbba
Note
The tree from the sample is shown below:
<image>
The tree after assigning characters to every node (according to the output) is the following:
<image>
Strings for all nodes are the following:
* string of node 1 is: a
* string of node 2 is: aa
* string of node 3 is: aab
* string of node 4 is: aab
* string of node 5 is: aabb
* string of node 6 is: aabb
* string of node 7 is: aabb
* string of node 8 is: aabb
* string of node 9 is: aa
The set of unique strings is \{a, aa, aab, aabb\}, so the number of distinct strings is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define mod 998244353
#define oo 1000000010
const int N = 100010;
const int SQ = 500;
int n , x , p;
vector< int > g[N] , cur[N];
char c[N];
int mx;
vector< pair<int,int> > v , v2;
pair< int , char > a , b;
int sz[N];
bool comp(int u,int v){
return (sz[u] < sz[v]);
}
int DFS(int node,int d){
mx = max(mx,d);
cur[d].push_back(node);
sz[node] = 1;
for(int i = 0 ;i < (int)g[node].size();i++)
sz[node] += DFS(g[node][i] , d + 1);
return sz[node];
}
bool dp[SQ][N];
int f[N];
void build_path(int i,int j){
if(i == (int)v2.size())
return;
while(!dp[i + 1][j]){
f[v2[i].first]++;
j -= v2[i].first;
}
build_path(i + 1 , j);
}
int main(){
scanf("%d%d",&n,&x);
a = make_pair(x , 'a');
b = make_pair(n - x , 'b');
if(a > b) swap(a , b);
for(int i = 2 ;i <= n;i++){
scanf("%d",&p);
g[p].push_back(i);
}
DFS(1 , 0);
for(int i = 0 ;i <= mx;i++)
v.push_back(make_pair((int)cur[i].size() , i));
sort(v.begin(),v.end());
for(int i = 0 ;i < (int)v.size();i++){
if(i == 0 || v[i].first != v[i - 1].first)
v2.push_back(make_pair(v[i].first , 1));
else
v2.back().second++;
}
dp[(int)v2.size()][0] = true;
int val , frq;
for(int i = (int)v2.size() - 1;i >= 0;i--){
val = v2[i].first;
frq = v2[i].second;
vector< int > last(val , -1);
for(int j = 0 ;j <= a.first;j++){
if(dp[i + 1][j] == true)
last[j % val] = j;
if(last[j % val] == -1 || ((j - last[j % val]) / val) > frq)
dp[i][j] = false;
else
dp[i][j] = true;
}
}
if(dp[0][a.first]){
build_path(0 , a.first);
for(int i = 1;i <= n;i++) c[i - 1] = b.second;
for(int i = 0 ;i <= mx;i++){
if(f[(int)cur[i].size()] == 0) continue;
f[(int)cur[i].size()]--;
for(int j = 0 ;j < (int)cur[i].size();j++)
c[cur[i][j] - 1] = a.second;
}
printf("%d\n",mx + 1);
c[n] = '\0';
puts(c);
return 0;
}
printf("%d\n",mx + 2);
for(int i = 0 ;i <= mx;i++){
sort(cur[i].begin(),cur[i].end(),comp);
if(a.first < b.first) swap(a , b);
while((int)cur[i].size() > 0 && a.first > 0){
c[cur[i].back() - 1] = a.second;
cur[i].pop_back();
a.first--;
}
while((int)cur[i].size() > 0 && b.first > 0){
c[cur[i].back() - 1] = b.second;
cur[i].pop_back();
b.first--;
}
}
c[n] = '\0';
puts(c);
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Joisino is planning on touring Takahashi Town. The town is divided into square sections by north-south and east-west lines. We will refer to the section that is the x-th from the west and the y-th from the north as (x,y).
Joisino thinks that a touring plan is good if it satisfies the following conditions:
* Let (p,q) be the section where she starts the tour. Then, X_1 \leq p \leq X_2 and Y_1 \leq q \leq Y_2 hold.
* Let (s,t) be the section where she has lunch. Then, X_3 \leq s \leq X_4 and Y_3 \leq t \leq Y_4 hold.
* Let (u,v) be the section where she ends the tour. Then, X_5 \leq u \leq X_6 and Y_5 \leq v \leq Y_6 hold.
* By repeatedly moving to the adjacent section (sharing a side), she travels from the starting section to the ending section in the shortest distance, passing the lunch section on the way.
Two touring plans are considered different if at least one of the following is different: the starting section, the lunch section, the ending section, and the sections that are visited on the way. Joisino would like to know how many different good touring plans there are. Find the number of the different good touring plans. Since it may be extremely large, find the count modulo 10^9+7.
Constraints
* 1 \leq X_1 \leq X_2 < X_3 \leq X_4 < X_5 \leq X_6 \leq 10^6
* 1 \leq Y_1 \leq Y_2 < Y_3 \leq Y_4 < Y_5 \leq Y_6 \leq 10^6
Input
Input is given from Standard Input in the following format:
X_1 X_2 X_3 X_4 X_5 X_6
Y_1 Y_2 Y_3 Y_4 Y_5 Y_6
Output
Print the number of the different good touring plans, modulo 10^9+7.
Examples
Input
1 1 2 2 3 4
1 1 2 2 3 3
Output
10
Input
1 2 3 4 5 6
1 2 3 4 5 6
Output
2346
Input
77523 89555 420588 604360 845669 973451
2743 188053 544330 647651 709337 988194
Output
137477680
### Response
```cpp
#include<bits/stdc++.h>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define ED(x) ((int)x.size()-1)
#define _for(i,a,b) for(int i=(a);i<=(b);++i)
#define _rep(i,a,b) for(int i=(a);i>=(b);--i)
#define changxv ios::sync_with_stdio(0);cin.tie(0);
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
template<typename T>
void dbg(const char*s,T h){cerr<<s<<'='<<h<<'\n';}
template<typename T,typename...A>
void dbg(const char*s,T h,A...t){
while(*s!=',')cerr<<*s++;
cerr<<'='<<h<<", ";
dbg(s+1,t...);
}
#define put(...) dbg(#__VA_ARGS__,__VA_ARGS__);
const int maxn=1e6+3;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
int x[7],y[7];
struct node{
int x,y,flag;
}a[5],b[5];
int ans;
int fac[maxn<<1],invfac[maxn<<1];
int Qpow(int x,int k){
int tmp=1;
for(;k;k>>=1,x=(ll)x*x%mod)if(k&1)tmp=(ll)tmp*x%mod;
return tmp;
}
void Pre(){
const int lim=2e6;
fac[0]=invfac[0]=1;
_for(i,1,lim)fac[i]=(ll)fac[i-1]*i%mod;
invfac[lim]=Qpow(fac[lim],mod-2);
_rep(i,lim-1,1)invfac[i]=(ll)invfac[i+1]*(i+1)%mod;
}
int C(int a,int b,int c,int d){
return (ll)fac[c+d-a-b]*invfac[c-a]%mod*invfac[d-b]%mod;
}
int Cal(const node&a,const node&b){
int tmp=0;
_for(i,x[3],x[4])(tmp+=(ll)C(a.x,a.y,i,y[3]-1)*C(i,y[3],b.x,b.y)%mod*(-i-y[3])%mod)%=mod;
_for(i,y[3],y[4])(tmp+=(ll)C(a.x,a.y,x[3]-1,i)*C(x[3],i,b.x,b.y)%mod*(-i-x[3])%mod)%=mod;
_for(i,x[3],x[4])(tmp+=(ll)C(a.x,a.y,i,y[4])*C(i,y[4]+1,b.x,b.y)%mod*(i+y[4]+1)%mod)%=mod;
_for(i,y[3],y[4])(tmp+=(ll)C(a.x,a.y,x[4],i)*C(x[4]+1,i,b.x,b.y)%mod*(i+x[4]+1)%mod)%=mod;
return tmp;
}
int main(){changxv
Pre();
_for(i,1,6)cin>>x[i];
_for(i,1,6)cin>>y[i];
int cnt=1;
a[1]=(node){x[2],y[2],1};
a[2]=(node){x[1]-1,y[1]-1,1};
a[3]=(node){x[1]-1,y[2],-1};
a[4]=(node){x[2],y[1]-1,-1};
b[1]=(node){x[6]+1,y[6]+1,1};
b[2]=(node){x[5],y[5],1};
b[3]=(node){x[5],y[6]+1,-1};
b[4]=(node){x[6]+1,y[5],-1};
_for(i,1,4){
_for(j,1,4){
(ans+=a[i].flag*b[j].flag*Cal(a[i],b[j]))%=mod;
if(ans<0)(ans+=mod)%=mod;
}
}
cout<<ans<<'\n';
return 0; }
``` |
### Prompt
Generate a Cpp solution to the following problem:
Arkady words in a large company. There are n employees working in a system of a strict hierarchy. Namely, each employee, with an exception of the CEO, has exactly one immediate manager. The CEO is a manager (through a chain of immediate managers) of all employees.
Each employee has an integer rank. The CEO has rank equal to 1, each other employee has rank equal to the rank of his immediate manager plus 1.
Arkady has a good post in the company, however, he feels that he is nobody in the company's structure, and there are a lot of people who can replace him. He introduced the value of replaceability. Consider an employee a and an employee b, the latter being manager of a (not necessarily immediate). Then the replaceability r(a, b) of a with respect to b is the number of subordinates (not necessarily immediate) of the manager b, whose rank is not greater than the rank of a. Apart from replaceability, Arkady introduced the value of negligibility. The negligibility za of employee a equals the sum of his replaceabilities with respect to all his managers, i.e. <image>, where the sum is taken over all his managers b.
Arkady is interested not only in negligibility of himself, but also in negligibility of all employees in the company. Find the negligibility of each employee for Arkady.
Input
The first line contains single integer n (1 β€ n β€ 5Β·105) β the number of employees in the company.
The second line contains n integers p1, p2, ..., pn (0 β€ pi β€ n), where pi = 0 if the i-th employee is the CEO, otherwise pi equals the id of the immediate manager of the employee with id i. The employees are numbered from 1 to n. It is guaranteed that there is exactly one 0 among these values, and also that the CEO is a manager (not necessarily immediate) for all the other employees.
Output
Print n integers β the negligibilities of all employees in the order of their ids: z1, z2, ..., zn.
Examples
Input
4
0 1 2 1
Output
0 2 4 2
Input
5
2 3 4 5 0
Output
10 6 3 1 0
Input
5
0 1 1 1 3
Output
0 3 3 3 5
Note
Consider the first example:
* The CEO has no managers, thus z1 = 0.
* r(2, 1) = 2 (employees 2 and 4 suit the conditions, employee 3 has too large rank). Thus z2 = r(2, 1) = 2.
* Similarly, z4 = r(4, 1) = 2.
* r(3, 2) = 1 (employee 3 is a subordinate of 2 and has suitable rank). r(3, 1) = 3 (employees 2, 3, 4 suit the conditions). Thus z3 = r(3, 2) + r(3, 1) = 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, rt, fa[500010], d[500010];
int tot, son[500010], id[500010], len[500010], b[500010];
int a[500010], l[500010], r[500010];
long long ans[500010], s[500010];
int cnt, head[500010], to[1000010], nxt[1000010];
void add(int x, int y) {
cnt++;
to[cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt;
}
void dfs1(int x) {
len[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
d[y] = d[x] + 1;
dfs1(y);
if (len[y] + 1 > len[x]) {
son[x] = y;
len[x] = len[y] + 1;
}
}
}
void dfs2(int x) {
tot++;
id[x] = tot;
b[x] = 1;
if (!son[x]) {
return;
}
dfs2(son[x]);
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (y == son[x]) {
continue;
}
dfs2(y);
}
}
void bfs() {
queue<int> q;
while (!q.empty()) {
q.pop();
}
tot = 0;
q.push(rt);
while (!q.empty()) {
int x = q.front();
q.pop();
tot++;
a[x] = tot;
l[id[x]] = r[id[x]] = tot;
if (!son[x]) {
continue;
}
q.push(son[x]);
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (y == son[x]) {
continue;
}
q.push(y);
}
}
}
void merge(int x) {
if (!son[x]) {
return;
}
merge(son[x]);
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (y == son[x]) {
continue;
}
merge(y);
for (int j = 1; j <= len[y]; j++) {
s[l[id[x] + j]] += 1LL * b[id[y] + j - 1] * d[x];
s[r[id[x] + j] + 1] -= 1LL * b[id[y] + j - 1] * d[x];
s[l[id[y] + j - 1]] += 1LL * b[id[x] + j] * d[x];
s[r[id[y] + j - 1] + 1] -= 1LL * b[id[x] + j] * d[x];
b[id[x] + j] += b[id[y] + j - 1];
r[id[x] + j] = r[id[y] + j - 1];
}
}
}
void work(int x) {
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
ans[y] += ans[x];
work(y);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &fa[i]);
add(fa[i], i);
if (!fa[i]) {
rt = i;
}
}
d[rt] = 1;
dfs1(rt);
dfs2(rt);
bfs();
merge(rt);
for (int i = 1; i <= n; i++) {
s[i] += s[i - 1];
}
for (int i = 1; i <= n; i++) {
ans[i] = s[a[i]] + d[i] - 1;
}
work(rt);
for (int i = 1; i <= n; i++) {
printf("%I64d ", ans[i]);
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Given are a sequence of N integers A_1, A_2, \ldots, A_N and a positive integer S.
For a pair of integers (L, R) such that 1\leq L \leq R \leq N, let us define f(L, R) as follows:
* f(L, R) is the number of sequences of integers (x_1, x_2, \ldots , x_k) such that L \leq x_1 < x_2 < \cdots < x_k \leq R and A_{x_1}+A_{x_2}+\cdots +A_{x_k} = S.
Find the sum of f(L, R) over all pairs of integers (L, R) such that 1\leq L \leq R\leq N. Since this sum can be enormous, print it modulo 998244353.
Constraints
* All values in input are integers.
* 1 \leq N \leq 3000
* 1 \leq S \leq 3000
* 1 \leq A_i \leq 3000
Input
Input is given from Standard Input in the following format:
N S
A_1 A_2 ... A_N
Output
Print the sum of f(L, R), modulo 998244353.
Examples
Input
3 4
2 2 4
Output
5
Input
5 8
9 9 9 9 9
Output
0
Input
10 10
3 1 4 1 5 9 2 6 5 3
Output
152
### Response
```cpp
#include <iostream>
using namespace std;
using ll = long long;
const ll M = 998244353;
ll dp[3010];
signed main() {
ll n, s;
cin >> n >> s;
ll x = 0;
for (ll i = 0; i < n; i++) {
ll a;
cin >> a;
(dp[0] += 1) %= M;
for (ll v = s; v >= a; v--) {
(dp[v] += dp[v - a]) %= M;
}
(x += dp[s]) %= M;
}
cout << x << endl;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Ayoub had an array a of integers of size n and this array had two interesting properties:
* All the integers in the array were between l and r (inclusive).
* The sum of all the elements was divisible by 3.
Unfortunately, Ayoub has lost his array, but he remembers the size of the array n and the numbers l and r, so he asked you to find the number of ways to restore the array.
Since the answer could be very large, print it modulo 10^9 + 7 (i.e. the remainder when dividing by 10^9 + 7). In case there are no satisfying arrays (Ayoub has a wrong memory), print 0.
Input
The first and only line contains three integers n, l and r (1 β€ n β€ 2 β
10^5 , 1 β€ l β€ r β€ 10^9) β the size of the lost array and the range of numbers in the array.
Output
Print the remainder when dividing by 10^9 + 7 the number of ways to restore the array.
Examples
Input
2 1 3
Output
3
Input
3 2 2
Output
1
Input
9 9 99
Output
711426616
Note
In the first example, the possible arrays are : [1,2], [2,1], [3, 3].
In the second example, the only possible array is [2, 2, 2].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long dp[200005][3], a[3], n, l, r;
long long cal(long long mx, long long rem) {
if (mx < rem) return 0;
long long dif = mx - rem;
dif /= 3;
return dif + 1;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n >> l >> r;
for (int i = 0; i < 3; ++i) {
a[i] = (cal(r, i) - cal(l - 1, i) + 1000000007ll) % 1000000007ll;
}
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
dp[i][(j + k) % 3] =
(dp[i][(j + k) % 3] + (a[k] * dp[i - 1][j]) % 1000000007ll) %
1000000007ll;
}
}
}
cout << dp[n][0] << '\n';
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
As you know, Bob's brother lives in Flatland. In Flatland there are n cities, connected by n - 1 two-way roads. The cities are numbered from 1 to n. You can get from one city to another moving along the roads.
The Β«Two PathsΒ» company, where Bob's brother works, has won a tender to repair two paths in Flatland. A path is a sequence of different cities, connected sequentially by roads. The company is allowed to choose by itself the paths to repair. The only condition they have to meet is that the two paths shouldn't cross (i.e. shouldn't have common cities).
It is known that the profit, the Β«Two PathsΒ» company will get, equals the product of the lengths of the two paths. Let's consider the length of each road equals 1, and the length of a path equals the amount of roads in it. Find the maximum possible profit for the company.
Input
The first line contains an integer n (2 β€ n β€ 200), where n is the amount of cities in the country. The following n - 1 lines contain the information about the roads. Each line contains a pair of numbers of the cities, connected by the road ai, bi (1 β€ ai, bi β€ n).
Output
Output the maximum possible profit.
Examples
Input
4
1 2
2 3
3 4
Output
1
Input
7
1 2
1 3
1 4
1 5
1 6
1 7
Output
0
Input
6
1 2
2 3
2 4
5 4
6 4
Output
4
### Response
```cpp
#include <bits/stdc++.h>
void recorrido();
int trabajo(int k, int fa);
int sin_u[212];
int sin_f[212];
int aux[212];
int map[212][212];
int dob[212][212];
int dob_f[212][2];
int n;
int main() {
int i, o, j, p = 0;
recorrido();
for (i = 1; i <= n; ++i) {
for (o = 0; o < 212; ++o) {
aux[o] = 0;
sin_f[o] = 0;
sin_u[o] = 0;
dob_f[o][0] = 0;
dob_f[o][1] = 0;
for (j = 0; j < 212; ++j) dob[o][j] = 0;
}
o = trabajo(i, 0);
if (o > p) p = o;
}
printf("%d\n", p);
return 0;
}
void recorrido() {
int i;
int x, y;
scanf("%d", &n);
for (i = 1; i < n; ++i) {
scanf("%d %d", &x, &y);
map[x][y] = 1;
map[y][x] = 1;
}
}
int trabajo(int k, int fa) {
int i, o, p, j;
int a[212];
int x, y;
aux[k] = 1;
a[0] = 0;
for (i = 1; i <= n; ++i) {
if (aux[i] == 0 && map[k][i] == 1) {
trabajo(i, k);
a[++a[0]] = i;
}
}
if (a[0] == 0) {
for (i = 1; i < 212; ++i) dob[k][i] = -1;
return 0;
}
for (i = 1; i <= a[0]; ++i)
if (sin_u[a[i]] > sin_u[k]) sin_u[k] = sin_u[a[i]];
++sin_u[k];
if (a[0] >= 2) {
p = -1;
for (i = 1; i <= a[0]; ++i)
if (sin_u[a[i]] > p) {
x = i;
p = sin_u[a[i]];
}
p = -1;
for (i = 1; i <= a[0]; ++i)
if (sin_u[a[i]] > p && i != x) {
y = i;
p = sin_u[a[i]];
}
sin_f[k] = sin_u[a[x]] + sin_u[a[y]] + 2;
}
for (i = 1; i <= a[0]; ++i)
if (sin_f[a[i]] > sin_f[k]) sin_f[k] = sin_f[a[i]];
if (sin_u[k] > sin_f[k]) sin_f[k] = sin_u[k];
for (i = 0; i < 212; ++i) dob[k][i] = -1;
for (i = 1; i <= a[0]; ++i)
if (dob[k][0] < sin_f[a[i]]) dob[k][0] = sin_f[a[i]];
for (i = 1; i <= a[0]; ++i)
for (j = 0; dob[a[i]][j] != -1; ++j)
if (dob[k][j + 1] < dob[a[i]][j]) dob[k][j + 1] = dob[a[i]][j];
for (i = 1; i <= a[0]; ++i)
for (j = 1; j <= a[0]; ++j)
if (i != j) {
x = sin_u[a[i]] + 1;
y = sin_f[a[j]];
for (o = x; o >= 1; --o)
if (dob[k][o] < y) {
dob[k][o] = y;
}
}
for (i = 1; i <= a[0]; ++i)
for (j = 1; j <= a[0]; ++j)
if (i != j) {
for (o = 0; dob[a[i]][o] != -1; ++o) {
x = sin_u[a[j]] + 2 + o;
y = dob[a[i]][o];
if (x * y > dob_f[k][0] * dob_f[k][1]) {
dob_f[k][0] = x;
dob_f[k][1] = y;
}
}
if (sin_f[a[i]] * sin_f[a[j]] > dob_f[k][0] * dob_f[k][1]) {
dob_f[k][0] = sin_f[a[i]];
dob_f[k][1] = sin_f[a[j]];
}
}
for (i = 1; i <= a[0]; ++i) {
if (dob_f[a[i]][0] * dob_f[a[i]][1] > dob_f[k][0] * dob_f[k][1]) {
dob_f[k][0] = dob_f[a[i]][0];
dob_f[k][1] = dob_f[a[i]][1];
}
}
for (i = 0; dob[k][i] != -1; ++i) {
if (dob[k][i] * i > dob_f[k][0] * dob_f[k][1]) {
dob_f[k][0] = dob[k][i];
dob_f[k][1] = i;
}
}
return (dob_f[k][0] * dob_f[k][1]);
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are N one-off jobs available. If you take the i-th job and complete it, you will earn the reward of B_i after A_i days from the day you do it.
You can take and complete at most one of these jobs in a day.
However, you cannot retake a job that you have already done.
Find the maximum total reward that you can earn no later than M days from today.
You can already start working today.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq B_i \leq 10^4
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
\vdots
A_N B_N
Output
Print the maximum total reward that you can earn no later than M days from today.
Examples
Input
3 4
4 3
4 1
2 2
Output
5
Input
5 3
1 2
1 3
1 4
2 1
2 3
Output
10
Input
1 1
2 1
Output
0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define M 100005
int a[M],b[M];
vector<int>d[M];
priority_queue<int>q;
int main(){
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i)scanf("%d%d",&a[i],&b[i]);
for(int i=1;i<=n;++i)d[a[i]].push_back(b[i]);
int ans=0;
for(int i=1;i<=m;++i){
for(int j=0;j<(int)d[i].size();++j)q.push(d[i][j]);
if(!q.empty())ans+=q.top(),q.pop();
}
printf("%d",ans);
}
``` |
### Prompt
Create a solution in CPP for the following problem:
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;
const long long MOD = 1000000009;
long long pot(int m) {
long long res = 1;
long long dois = 2;
while (m) {
if (m & 1) res *= dois, res %= MOD;
dois *= dois;
dois %= MOD;
m >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
long long t = pot(m);
long long ans = 1LL;
for (int i = 0; i < n; ++i) {
long long m = (t - i - 1 + MOD) % MOD;
ans *= m;
ans %= MOD;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
One day, Okazaki Tomoya has bought a tree for Furukawa Nagisa's birthday. The tree is so strange that every node of the tree has a value. The value of the i-th node is vi. Now Furukawa Nagisa and Okazaki Tomoya want to play a game on the tree.
Let (s, e) be the path from node s to node e, we can write down the sequence of the values of nodes on path (s, e), and denote this sequence as S(s, e). We define the value of the sequence G(S(s, e)) as follows. Suppose that the sequence is z0, z1...zl - 1, where l is the length of the sequence. We define G(S(s, e)) = z0 Γ k0 + z1 Γ k1 + ... + zl - 1 Γ kl - 1. If the path (s, e) satisfies <image>, then the path (s, e) belongs to Furukawa Nagisa, otherwise it belongs to Okazaki Tomoya.
Calculating who has more paths is too easy, so they want to play something more difficult. Furukawa Nagisa thinks that if paths (p1, p2) and (p2, p3) belong to her, then path (p1, p3) belongs to her as well. Also, she thinks that if paths (p1, p2) and (p2, p3) belong to Okazaki Tomoya, then path (p1, p3) belongs to Okazaki Tomoya as well. But in fact, this conclusion isn't always right. So now Furukawa Nagisa wants to know how many triplets (p1, p2, p3) are correct for the conclusion, and this is your task.
Input
The first line contains four integers n, y, k and x (1 β€ n β€ 105; 2 β€ y β€ 109; 1 β€ k < y; 0 β€ x < y) β n being the number of nodes on the tree. It is guaranteed that y is a prime number.
The second line contains n integers, the i-th integer is vi (0 β€ vi < y).
Then follow n - 1 lines, each line contains two integers, denoting an edge of the tree. The nodes of the tree are numbered from 1 to n.
Output
Output a single integer β the number of triplets that are correct for Furukawa Nagisa's conclusion.
Examples
Input
1 2 1 0
1
Output
1
Input
3 5 2 1
4 3 1
1 2
2 3
Output
14
Input
8 13 8 12
0 12 7 4 12 0 8 12
1 8
8 4
4 6
6 2
2 3
8 5
2 7
Output
341
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int gi() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
const int N = 1e5 + 5;
int n, mod, k, x, pw[N], ipw[N], a[N], to[N << 1], nxt[N << 1], head[N], cnt;
int sz[N], w[N], root, sum, vis[N], val1[N], val2[N], in[N], out[N];
map<int, int> M1, M2;
int fastpow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return res;
}
void getroot(int u, int f) {
sz[u] = 1;
w[u] = 0;
for (int e = head[u]; e; e = nxt[e])
if (to[e] != f && !vis[to[e]]) {
getroot(to[e], u);
sz[u] += sz[to[e]];
w[u] = max(w[u], sz[to[e]]);
}
w[u] = max(w[u], sum - sz[u]);
if (w[u] < w[root]) root = u;
}
void dfs1(int u, int f, int d) {
++M1[1ll * (x - val1[u] + mod) * ipw[d + 1] % mod];
++M2[val2[u]];
for (int e = head[u]; e; e = nxt[e])
if (to[e] != f && !vis[to[e]]) {
val1[to[e]] = (1ll * val1[u] * k + a[to[e]]) % mod;
val2[to[e]] = (val2[u] + 1ll * pw[d] * a[to[e]]) % mod;
dfs1(to[e], u, d + 1);
}
}
void dfs2(int u, int f, int d, int op) {
out[u] += op * M2[1ll * (x - val1[u] + mod) * ipw[d + 1] % mod];
in[u] += op * M1[val2[u]];
for (int e = head[u]; e; e = nxt[e])
if (to[e] != f && !vis[to[e]]) dfs2(to[e], u, d + 1, op);
}
void calc(int u, int d, int op, int s1, int s2) {
M1.clear();
M2.clear();
val1[u] = s1;
val2[u] = s2;
dfs1(u, 0, d);
dfs2(u, 0, d, op);
}
void solve(int u) {
vis[u] = 1;
calc(u, 0, 1, a[u], 0);
for (int e = head[u]; e; e = nxt[e])
if (!vis[to[e]]) {
calc(to[e], 1, -1, (1ll * a[u] * k + a[to[e]]) % mod, a[to[e]]);
getroot(to[e], 0);
root = 0;
sum = sz[to[e]];
getroot(to[e], 0);
solve(root);
}
}
int main() {
n = gi();
mod = gi();
k = gi();
x = gi();
for (int i = pw[0] = ipw[0] = 1, inv = fastpow(k, mod - 2); i <= n; ++i)
pw[i] = 1ll * pw[i - 1] * k % mod, ipw[i] = 1ll * ipw[i - 1] * inv % mod;
for (int i = 1; i <= n; ++i) a[i] = gi();
for (int i = 1; i < n; ++i) {
int u = gi(), v = gi();
to[++cnt] = v;
nxt[cnt] = head[u];
head[u] = cnt;
to[++cnt] = u;
nxt[cnt] = head[v];
head[v] = cnt;
}
sum = w[0] = n;
getroot(1, 0);
solve(root);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += 1ll * in[i] * (n - out[i]) + 1ll * out[i] * (n - in[i]) +
2ll * in[i] * (n - in[i]) + 2ll * out[i] * (n - out[i]);
}
printf("%I64d\n", 1ll * n * n * n - ans / 2);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Print the K-th element of the following sequence of length 32:
1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51
Constraints
* 1 \leq K \leq 32
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
K
Output
Print the K-th element.
Examples
Input
6
Output
2
Input
27
Output
5
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a[33]={1,1,1,2,1,2,1,5,2,2,1,5,1,2,1,14,1,5,1,5,2,2,1,15,2,2,5,4,1,4,1,51};
int k;
cin>>k;
cout<<a[k-1]<<endl;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Shrek and the Donkey (as you can guess, they also live in the far away kingdom) decided to play a card game called YAGame. The rules are very simple: initially Shrek holds m cards and the Donkey holds n cards (the players do not see each other's cards), and one more card lies on the table face down so that both players cannot see it as well. Thus, at the beginning of the game there are overall m + n + 1 cards. Besides, the players know which cards the pack of cards consists of and their own cards (but they do not know which card lies on the table and which ones the other player has). The players move in turn and Shrek starts. During a move a player can:
* Try to guess which card is lying on the table. If he guesses correctly, the game ends and he wins. If his guess is wrong, the game also ends but this time the other player wins.
* Name any card from the pack. If the other player has such card, he must show it and put it aside (so that this card is no longer used in the game). If the other player doesn't have such card, he says about that.
Recently Donkey started taking some yellow pills and winning over Shrek. Now Shrek wants to evaluate his chances to win if he too starts taking the pills.
Help Shrek assuming the pills are good in quality and that both players using them start playing in the optimal manner.
Input
The first line contains space-separated integers m and n (0 β€ m, n β€ 1000).
Output
Print space-separated probabilities that Shrek wins and Donkey wins correspondingly; the absolute error should not exceed 10 - 9.
Examples
Input
0 3
Output
0.25 0.75
Input
1 0
Output
1 0
Input
1 1
Output
0.5 0.5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N = 1000 + 10;
int n, m;
double dp[N][N];
inline double dfs(int n, int m) {
if (!n) return 1.0 / (m + 1);
if (!m) return 1.0;
if (dp[n][m]) return dp[n][m];
double A = 1.0 * m / (m + 1) * (1.0 - dfs(m - 1, n)), B = 1.0;
double C = 1.0 / (m + 1) + A, D = 1.0 - dfs(m, n - 1);
double P = (D - B) / (A - B - C + D);
return dp[n][m] = P * A + (1 - P) * B;
}
int main() {
n = read(), m = read();
printf("%.10lf %.10lf\n", dfs(n, m), 1 - dfs(n, m));
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
There are n cities in the country where the Old Peykan lives. These cities are located on a straight line, we'll denote them from left to right as c1, c2, ..., cn. The Old Peykan wants to travel from city c1 to cn using roads. There are (n - 1) one way roads, the i-th road goes from city ci to city ci + 1 and is di kilometers long.
The Old Peykan travels 1 kilometer in 1 hour and consumes 1 liter of fuel during this time.
Each city ci (except for the last city cn) has a supply of si liters of fuel which immediately transfers to the Old Peykan if it passes the city or stays in it. This supply refreshes instantly k hours after it transfers. The Old Peykan can stay in a city for a while and fill its fuel tank many times.
Initially (at time zero) the Old Peykan is at city c1 and s1 liters of fuel is transferred to it's empty tank from c1's supply. The Old Peykan's fuel tank capacity is unlimited. Old Peykan can not continue its travel if its tank is emptied strictly between two cities.
Find the minimum time the Old Peykan needs to reach city cn.
Input
The first line of the input contains two space-separated integers m and k (1 β€ m, k β€ 1000). The value m specifies the number of roads between cities which is equal to n - 1.
The next line contains m space-separated integers d1, d2, ..., dm (1 β€ di β€ 1000) and the following line contains m space-separated integers s1, s2, ..., sm (1 β€ si β€ 1000).
Output
In the only line of the output print a single integer β the minimum time required for The Old Peykan to reach city cn from city c1.
Examples
Input
4 6
1 2 5 2
2 3 3 4
Output
10
Input
2 3
5 6
5 5
Output
14
Note
In the second sample above, the Old Peykan stays in c1 for 3 hours.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int city[1000 + 10];
int fuel[1000 + 10];
int time(int m, int k) {
int ans = 0;
int temp = 0;
int maxfuel = 0;
int i;
for (i = 0; i < m; i++) {
temp += fuel[i];
if (fuel[i] > maxfuel) {
maxfuel = fuel[i];
}
while (temp < city[i + 1]) {
temp += maxfuel;
ans += k;
}
temp -= city[i + 1];
ans += city[i + 1];
}
return ans;
}
int main() {
int m, k;
int i;
while (scanf("%d%d", &m, &k) != EOF) {
for (i = 1; i <= m; i++) {
scanf("%d", &city[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &fuel[i]);
}
printf("%d\n", time(m, k));
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
This problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.
Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions:
* It only allows owning either zero or one shares of stock at a time;
* It only allows buying or selling a share of this stock once per day;
* It allows a maximum of k buy orders over the next n days;
For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.
Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.
Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.
Input
The first line contains two integers n and k, separated by a single space, with <image>. The i-th of the following n lines contains a single integer pi (0 β€ pi β€ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem F1 (8 points), n will be between 1 and 3000, inclusive.
* In subproblem F2 (15 points), n will be between 1 and 100000, inclusive.
* In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive.
Output
For this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.
Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.
Examples
Input
10 2
2
7
3
9
8
7
9
7
1
9
Output
15
Input
10 5
2
7
3
9
8
7
9
7
1
9
Output
21
Note
In the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | | | sell | | | | | buy | sell
The total profit is then (9 - 2) + (9 - 1) = 15.
In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4:
2 | 7 | 3 | 9 | 8 | 7 | 9 | 7 | 1 | 9
buy | sell | buy | sell | | buy | sell | | buy | sell
The total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k, cnt = 0;
long long a[4000000];
int nx[4000000], pr[4000000];
struct Cmp {
bool operator()(const int &lhs, const int &rhs) const {
long long lval = abs(a[nx[lhs]] - a[lhs]);
long long rval = abs(a[nx[rhs]] - a[rhs]);
if (lval != rval) return lval < rval;
return lhs < rhs;
}
};
set<int, Cmp> se;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (int)(n); ++i) {
long long x;
scanf("%I64d", &x);
if ((cnt == 1 && x <= a[0]) ||
(cnt > 1 &&
(x == a[cnt - 1] || (x > a[cnt - 1] && a[cnt - 1] > a[cnt - 2]) ||
(x < a[cnt - 1] && a[cnt - 1] < a[cnt - 2]))))
--cnt;
a[cnt++] = x;
}
if (cnt & 1) --cnt;
long long ans = 0;
for (int i = 0; i < cnt; i += 2) ans += a[i + 1] - a[i];
for (int i = 0; i < (int)(cnt); ++i) {
nx[i] = i + 1;
pr[i] = i - 1;
}
nx[cnt - 1] = -1;
pr[0] = -1;
for (int i = 0; i < (int)(cnt - 1); ++i) se.insert(i);
k = cnt / 2 - k;
for (int kk = 0; kk < (int)(k); ++kk) {
int ind = *se.begin();
if (pr[ind] != -1) se.erase(pr[ind]);
se.erase(ind);
se.erase(nx[ind]);
ans -= abs(a[nx[ind]] - a[ind]);
if (pr[ind] == -1) {
if (nx[nx[ind]] != -1) {
pr[nx[nx[ind]]] = -1;
}
} else {
nx[pr[ind]] = nx[nx[ind]];
if (nx[nx[ind]] != -1) {
pr[nx[nx[ind]]] = pr[ind];
se.insert(pr[ind]);
}
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Xenia the vigorous detective faced n (n β₯ 2) foreign spies lined up in a row. We'll consider the spies numbered from 1 to n from left to right.
Spy s has an important note. He has to pass the note to spy f. Xenia interrogates the spies in several steps. During one step the spy keeping the important note can pass the note to one of his neighbours in the row. In other words, if this spy's number is x, he can pass the note to another spy, either x - 1 or x + 1 (if x = 1 or x = n, then the spy has only one neighbour). Also during a step the spy can keep a note and not pass it to anyone.
But nothing is that easy. During m steps Xenia watches some spies attentively. Specifically, during step ti (steps are numbered from 1) Xenia watches spies numbers li, li + 1, li + 2, ..., ri (1 β€ li β€ ri β€ n). Of course, if during some step a spy is watched, he can't do anything: neither give the note nor take it from some other spy. Otherwise, Xenia reveals the spies' cunning plot. Nevertheless, if the spy at the current step keeps the note, Xenia sees nothing suspicious even if she watches him.
You've got s and f. Also, you have the steps during which Xenia watches spies and which spies she is going to watch during each step. Find the best way the spies should act in order to pass the note from spy s to spy f as quickly as possible (in the minimum number of steps).
Input
The first line contains four integers n, m, s and f (1 β€ n, m β€ 105; 1 β€ s, f β€ n; s β f; n β₯ 2). Each of the following m lines contains three integers ti, li, ri (1 β€ ti β€ 109, 1 β€ li β€ ri β€ n). It is guaranteed that t1 < t2 < t3 < ... < tm.
Output
Print k characters in a line: the i-th character in the line must represent the spies' actions on step i. If on step i the spy with the note must pass the note to the spy with a lesser number, the i-th character should equal "L". If on step i the spy with the note must pass it to the spy with a larger number, the i-th character must equal "R". If the spy must keep the note at the i-th step, the i-th character must equal "X".
As a result of applying the printed sequence of actions spy s must pass the note to spy f. The number of printed characters k must be as small as possible. Xenia must not catch the spies passing the note.
If there are miltiple optimal solutions, you can print any of them. It is guaranteed that the answer exists.
Examples
Input
3 5 1 3
1 1 2
2 2 3
3 3 3
4 1 1
10 1 3
Output
XXRR
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, st, ed, tem, p, pt;
long long stp;
bool seeked;
string ch;
struct node {
long long t, l, r;
} a[200000];
bool cmp(node aa, node bb) { return aa.t < bb.t; }
long long i;
int main() {
cin >> n >> m >> st >> ed;
if (st > ed) {
ch = "L";
stp = -1;
} else {
ch = "R";
stp = 1;
}
if (st == ed) {
return 0;
}
for (i = 0; i < m; i++) {
cin >> a[i].t >> a[i].l >> a[i].r;
}
tem = st;
p = 0;
pt = 1;
while (tem != ed) {
seeked = false;
while (a[p].t <= pt && p <= m) {
if ((a[p].l <= tem && a[p].r >= tem) ||
(a[p].l <= tem + stp && a[p].r >= tem + stp))
seeked = true;
p++;
}
pt++;
if (seeked) {
cout << "X";
} else {
cout << ch;
tem += stp;
}
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
### Response
```cpp
#include<cstdio>
#define M 131072
#define N 20
inline long long min(long long x,long long y){return x<y?x:y;}
int e[M],n;long long f[M][N][N],g[M],h[M];bool c[M][N][N];
long long dfs(int u,int v,int w)
{
if(v+1==w)return 0ll;
if(c[u][v][w])return f[u][v][w];
c[u][v][w]=true,f[u][v][w]=0x7fffffffffffffffll;
for(int i=v+1;i<w;i++)f[u][v][w]=min(f[u][v][w],dfs(u<<1,v,i)+dfs(u<<1|1,i,w)+e[i]*(g[u]+h[u]));
return f[u][v][w];
}
int main()
{
scanf("%d",&n),g[1]=h[1]=1;
for(int i=1;i<=n;i++)scanf("%d",e+i);
for(int i=1;i<1<<n-2;i++)g[i<<1]=g[i],h[i<<1]=g[i<<1|1]=g[i]+h[i],h[i<<1|1]=h[i];
return 0&(printf("%lld\n",e[1]+e[n]+dfs(1,1,n)));
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Mahmoud and Ehab continue their adventures! As everybody in the evil land knows, Dr. Evil likes bipartite graphs, especially trees.
A tree is a connected acyclic graph. A bipartite graph is a graph, whose vertices can be partitioned into 2 sets in such a way, that for each edge (u, v) that belongs to the graph, u and v belong to different sets. You can find more formal definitions of a tree and a bipartite graph in the notes section below.
Dr. Evil gave Mahmoud and Ehab a tree consisting of n nodes and asked them to add edges to it in such a way, that the graph is still bipartite. Besides, after adding these edges the graph should be simple (doesn't contain loops or multiple edges). What is the maximum number of edges they can add?
A loop is an edge, which connects a node with itself. Graph doesn't contain multiple edges when for each pair of nodes there is no more than one edge between them. A cycle and a loop aren't the same .
Input
The first line of input contains an integer n β the number of nodes in the tree (1 β€ n β€ 105).
The next n - 1 lines contain integers u and v (1 β€ u, v β€ n, u β v) β the description of the edges of the tree.
It's guaranteed that the given graph is a tree.
Output
Output one integer β the maximum number of edges that Mahmoud and Ehab can add to the tree while fulfilling the conditions.
Examples
Input
3
1 2
1 3
Output
0
Input
5
1 2
2 3
3 4
4 5
Output
2
Note
Tree definition: https://en.wikipedia.org/wiki/Tree_(graph_theory)
Bipartite graph definition: <https://en.wikipedia.org/wiki/Bipartite_graph>
In the first test case the only edge that can be added in such a way, that graph won't contain loops or multiple edges is (2, 3), but adding this edge will make the graph non-bipartite so the answer is 0.
In the second test case Mahmoud and Ehab can add edges (1, 4) and (2, 5).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int vis[100005] = {0}, col[100005];
vector<long long int> a[100005];
void dfs(long long node, long long par) {
vis[node] = 1;
col[node] = 3 - col[par];
for (auto i : a[node])
if (!vis[i]) dfs(i, node);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n;
cin >> n;
long long int m = n - 1;
while (m--) {
long long int n1, n2;
cin >> n1 >> n2;
a[n1].push_back(n2);
a[n2].push_back(n1);
}
col[0] = 2;
dfs(1, 0);
long long int cnt1 = 0, cnt2 = 0;
for (long long int i = 1; i <= n; i++) {
if (col[i] == 2) {
cnt2++;
} else {
cnt1++;
}
}
cout << cnt1 * cnt2 - n + 1;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
A penguin Rocher has n sticks. He has exactly one stick with length i for all 1 β€ i β€ n.
He can connect some sticks. If he connects two sticks that have lengths a and b, he gets one stick with length a + b. Two sticks, that were used in the operation disappear from his set and the new connected stick appears in his set and can be used for the next connections.
He wants to create the maximum number of sticks that have the same length. It is not necessary to make all sticks have the same length, some sticks can have the other length. How many sticks with the equal length he can create?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contain descriptions of test cases.
For each test case, the only line contains a single integer n (1 β€ n β€ 10^{9}).
Output
For each test case, print a single integer β the answer to the problem.
Example
Input
4
1
2
3
4
Output
1
1
2
2
Note
In the third case, he can connect two sticks with lengths 1 and 2 and he will get one stick with length 3. So, he will have two sticks with lengths 3.
In the fourth case, he can connect two sticks with lengths 1 and 3 and he will get one stick with length 4. After that, he will have three sticks with lengths \{2, 4, 4\}, so two sticks have the same length, and one stick has the other length.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans = (ceil(double(n) / (double)2));
cout << ans << endl;
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Welcome to PC Koshien, players. This year marks the 10th anniversary of Computer Koshien, but the number of questions and the total score will vary from year to year. Scores are set for each question according to the difficulty level. When the number of questions is 10 and the score of each question is given, create a program that outputs the total of them.
input
The input is given in the following format.
s1
s2
..
..
s10
The input consists of 10 lines, and the i line is given the integer si (0 β€ si β€ 100) representing the score of problem i.
output
Output the total score on one line.
Example
Input
1
2
3
4
5
6
7
8
9
10
Output
55
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
signed main(){
int sum=0;
for(int i=0;i<10;i++){
int a;
cin>>a;
sum+=a;
}
cout<<sum<<'\n';
return(0);
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
For given $n$ segments which are parallel to X-axis or Y-axis, find the number of intersections of them.
Constraints
* $1 \leq n \leq 100,000$
* $ -1,000,000,000 \leq x_1, y_1, x_2, y_2 \leq 1,000,000,000$
* Two parallel segments never overlap or touch.
* The number of intersections $\leq 1,000,000$
Input
In the first line, the number of segments $n$ is given. In the following $n$ lines, the $i$-th segment is given by coordinates of its end points in the following format:
$x_1 \; y_1 \; x_2 \; y_2$
The coordinates are given in integers.
Output
Print the number of intersections in a line.
Example
Input
6
2 2 2 5
1 3 5 3
4 1 4 4
5 2 7 2
6 1 6 3
6 5 6 7
Output
3
### Response
```cpp
//#include "inspect.hpp"
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
int main(){
vector<pair<int,pair<int,int>>> vx,vy;
int i=0,r=0,n,x1,y1,x2,y2;
for(scanf("%d",&n);i<n;i++){
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
if(x1>x2)swap(x1,x2);
if(y1>y2)swap(y1,y2);
if(x1==x2)vy.emplace_back(make_pair(x1,make_pair(y1,y2)));
else vx.emplace_back(make_pair(y1,make_pair(x1,x2)));
}
//sort(vx.begin(),vx.end());
sort(vy.begin(),vy.end());
for(auto &e:vx){
auto it1=lower_bound(vy.begin(),vy.end(),make_pair(e.second.first,make_pair(-2000000000,-2000000000)));
auto it2=lower_bound(vy.begin(),vy.end(),make_pair(e.second.second+1,make_pair(-2000000000,-2000000000)));
for(;it1!=it2;++it1){
auto &f=*it1;
if(f.second.first<=e.first&&e.first<=f.second.second)r++;
}
}
printf("%d\n",r);
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given a string s consisting of exactly n characters, and each character is either '0', '1' or '2'. Such strings are called ternary strings.
Your task is to replace minimum number of characters in this string with other characters to obtain a balanced ternary string (balanced ternary string is a ternary string such that the number of characters '0' in this string is equal to the number of characters '1', and the number of characters '1' (and '0' obviously) is equal to the number of characters '2').
Among all possible balanced ternary strings you have to obtain the lexicographically (alphabetically) smallest.
Note that you can neither remove characters from the string nor add characters to the string. Also note that you can replace the given characters only with characters '0', '1' and '2'.
It is guaranteed that the answer exists.
Input
The first line of the input contains one integer n (3 β€ n β€ 3 β
10^5, n is divisible by 3) β the number of characters in s.
The second line contains the string s consisting of exactly n characters '0', '1' and '2'.
Output
Print one string β the lexicographically (alphabetically) smallest balanced ternary string which can be obtained from the given one with minimum number of replacements.
Because n is divisible by 3 it is obvious that the answer exists. And it is obvious that there is only one possible answer.
Examples
Input
3
121
Output
021
Input
6
000000
Output
001122
Input
6
211200
Output
211200
Input
6
120110
Output
120120
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int Month[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int A[3];
int B[5000 + 10];
map<pair<int, int>, int> M;
void omae_wa_mou_shindeiru() {
int n;
cin >> n;
string st;
cin >> st;
for (int i = 0; i < n; ++i) {
A[st[i] - '0']++;
}
if (A[0] > n / 3) {
int cnt = n / 3 + 1;
for (int i = 0; i < n; ++i) {
if (A[0] == n / 3) {
break;
}
if (st[i] == '0') --cnt;
if (cnt > 0) continue;
if (st[i] == '0') {
if (A[1] < n / 3) {
st[i] = '1';
--A[0];
++A[1];
continue;
}
if (A[2] < n / 3) {
st[i] = '2';
--A[0];
++A[2];
}
}
}
}
if (A[1] > n / 3) {
int cnt = n / 3 + 1;
for (int i = 0; i < n; ++i) {
if (A[1] == n / 3) break;
if (st[i] == '1') {
if (A[0] < n / 3) {
st[i] = '0';
--A[1];
++A[0];
}
}
if (st[i] == '1') --cnt;
if (cnt > 0) continue;
if (st[i] == '1') {
if (A[2] < n / 3) {
st[i] = '2';
--A[1];
++A[2];
}
}
}
}
if (A[2] > n / 3) {
for (int i = 0; i < n; ++i) {
if (A[2] == n / 3) break;
if (st[i] == '2') {
if (A[0] < n / 3) {
st[i] = '0';
--A[2];
++A[0];
continue;
}
if (A[1] < n / 3) {
st[i] = '1';
--A[2];
++A[1];
}
}
}
}
cout << st;
}
int main() {
ios_base::sync_with_stdio(false);
;
int t = 1;
while (t--) {
omae_wa_mou_shindeiru();
if (t) cout << "\n";
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
An n Γ n square matrix is special, if:
* it is binary, that is, each cell contains either a 0, or a 1;
* the number of ones in each row and column equals 2.
You are given n and the first m rows of the matrix. Print the number of special n Γ n matrices, such that the first m rows coincide with the given ones.
As the required value can be rather large, print the remainder after dividing the value by the given number mod.
Input
The first line of the input contains three integers n, m, mod (2 β€ n β€ 500, 0 β€ m β€ n, 2 β€ mod β€ 109). Then m lines follow, each of them contains n characters β the first rows of the required special matrices. Each of these lines contains exactly two characters '1', the rest characters are '0'. Each column of the given m Γ n table contains at most two numbers one.
Output
Print the remainder after dividing the required value by number mod.
Examples
Input
3 1 1000
011
Output
2
Input
4 4 100500
0110
1010
0101
1001
Output
1
Note
For the first test the required matrices are:
011
101
110
011
110
101
In the second test the required matrix is already fully given, so the answer is 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 510;
int n, m, mod;
int ct[MAX_N];
long long dp[MAX_N][MAX_N];
long long dfs(int one, int two) {
long long &ref = dp[one][two];
if (ref != -1) return ref;
if (one == 0 && two == 0) return ref = 1;
long long r = 0;
if (one >= 2) {
r = (r + (one * (one - 1) / 2) % mod * dfs(one - 2, two)) % mod;
}
if (two >= 2) {
r = (r + (two * (two - 1) / 2) % mod * dfs(one + 2, two - 2)) % mod;
}
if (one >= 1 && two >= 1) {
r = (r + one * two % mod * dfs(one - 1 + 1, two - 1)) % mod;
}
return ref = r;
}
int main() {
cin >> n >> m >> mod;
int s = 0;
for (int i = 0; i < n; i++) {
ct[i] = 2;
s += 2;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
char c;
cin >> c;
if (c == '1') {
ct[j]--;
s -= 1;
}
}
}
int L = n - m;
if (s != 2 * L) {
cout << 0 << endl;
return 0;
} else {
bool ok = true;
int one = 0, two = 0;
for (int i = 0; i < n; i++) {
if (ct[i] == 1) {
one++;
} else if (ct[i] == 2) {
two++;
} else if (ct[i] == 0) {
} else {
ok = false;
}
}
if (!ok) {
cout << 0 << endl;
return 0;
}
memset(dp, -1, sizeof(dp));
cout << dfs(one, two) << endl;
}
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Once Bob took a paper stripe of n squares (the height of the stripe is 1 square). In each square he wrote an integer number, possibly negative. He became interested in how many ways exist to cut this stripe into two pieces so that the sum of numbers from one piece is equal to the sum of numbers from the other piece, and each piece contains positive integer amount of squares. Would you help Bob solve this problem?
Input
The first input line contains integer n (1 β€ n β€ 105) β amount of squares in the stripe. The second line contains n space-separated numbers β they are the numbers written in the squares of the stripe. These numbers are integer and do not exceed 10000 in absolute value.
Output
Output the amount of ways to cut the stripe into two non-empty pieces so that the sum of numbers from one piece is equal to the sum of numbers from the other piece. Don't forget that it's allowed to cut the stripe along the squares' borders only.
Examples
Input
9
1 5 -6 7 9 -16 0 -2 2
Output
3
Input
3
1 1 1
Output
0
Input
2
0 0
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, num[100005], qzh[100005], fa = 0;
int main() {
cin >> n;
cin >> num[0];
qzh[0] = num[0];
for (int i = 1; i < n; ++i) {
cin >> num[i];
qzh[i] = qzh[i - 1] + num[i];
}
for (int i = 0; i < n - 1; ++i) {
int left = qzh[i];
int right = qzh[n - 1] - left;
if (left == right) ++fa;
}
cout << fa << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Write a program of the Selection Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
SelectionSort(A)
1 for i = 0 to A.length-1
2 mini = i
3 for j = i to A.length-1
4 if A[j] < A[mini]
5 mini = j
6 swap A[i] and A[mini]
Note that, indices for array elements are based on 0-origin.
Your program should also print the number of swap operations defined in line 6 of the pseudocode in the case where i β mini.
Constraints
1 β€ N β€ 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by space characters.
Output
The output consists of 2 lines.
In the first line, please print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.
In the second line, please print the number of swap operations.
Examples
Input
6
5 6 4 2 1 3
Output
1 2 3 4 5 6
4
Input
6
5 2 4 6 1 3
Output
1 2 3 4 5 6
3
### Response
```cpp
#include<iostream>
#include<cmath>
using namespace std;
int a[100],n,t;
void xzsort(int n)
{
int i,j,minn,mini;
for(i=0;i<n-1;i++)
{
mini=i;
minn=a[i];
for(j=i+1;j<n;j++)
{
if(a[j]<minn)
{
minn=a[j];
mini=j;
}
}
if(i!=mini)
{
t++;
swap(a[i],a[mini]);
}
}
}
int main()
{
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
xzsort(n);
for(int i=0;i<n-1;i++)
cout<<a[i]<<" ";
cout<<a[n-1]<<endl;
cout<<t<<endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You have a computer literacy course in your university. In the computer system, the login/logout records of all PCs in a day are stored in a file. Although students may use two or more PCs at a time, no one can log in to a PC which has been logged in by someone who has not logged out of that PC yet.
You are asked to write a program that calculates the total time of a student that he/she used at least one PC in a given time period (probably in a laboratory class) based on the records in the file.
The following are example login/logout records.
* The student 1 logged in to the PC 1 at 12:55
* The student 2 logged in to the PC 4 at 13:00
* The student 1 logged in to the PC 2 at 13:10
* The student 1 logged out of the PC 2 at 13:20
* The student 1 logged in to the PC 3 at 13:30
* The student 1 logged out of the PC 1 at 13:40
* The student 1 logged out of the PC 3 at 13:45
* The student 1 logged in to the PC 1 at 14:20
* The student 2 logged out of the PC 4 at 14:30
* The student 1 logged out of the PC 1 at 14:40
For a query such as "Give usage of the student 1 between 13:00 and 14:30", your program should answer "55 minutes", that is, the sum of 45 minutes from 13:00 to 13:45 and 10 minutes from 14:20 to 14:30, as depicted in the following figure.
<image>
Input
The input is a sequence of a number of datasets. The end of the input is indicated by a line containing two zeros separated by a space. The number of datasets never exceeds 10.
Each dataset is formatted as follows.
> N M
> r
> record1
> ...
> recordr
> q
> query1
> ...
> queryq
>
The numbers N and M in the first line are the numbers of PCs and the students, respectively. r is the number of records. q is the number of queries. These four are integers satisfying the following.
> 1 β€ N β€ 1000, 1 β€ M β€ 10000, 2 β€ r β€ 1000, 1 β€ q β€ 50
Each record consists of four integers, delimited by a space, as follows.
> t n m s
s is 0 or 1. If s is 1, this line means that the student m logged in to the PC n at time t . If s is 0, it means that the student m logged out of the PC n at time t . The time is expressed as elapsed minutes from 0:00 of the day. t , n and m satisfy the following.
> 540 β€ t β€ 1260, 1 β€ n β€ N , 1 β€ m β€ M
You may assume the following about the records.
* Records are stored in ascending order of time t.
* No two records for the same PC has the same time t.
* No PCs are being logged in before the time of the first record nor after that of the last record in the file.
* Login and logout records for one PC appear alternatingly, and each of the login-logout record pairs is for the same student.
Each query consists of three integers delimited by a space, as follows.
> ts te m
It represents "Usage of the student m between ts and te ". ts , te and m satisfy the following.
> 540 β€ ts < te β€ 1260, 1 β€ m β€ M
Output
For each query, print a line having a decimal integer indicating the time of usage in minutes. Output lines should not have any character other than this number.
Example
Input
4 2
10
775 1 1 1
780 4 2 1
790 2 1 1
800 2 1 0
810 3 1 1
820 1 1 0
825 3 1 0
860 1 1 1
870 4 2 0
880 1 1 0
1
780 870 1
13 15
12
540 12 13 1
600 12 13 0
650 13 15 1
660 12 15 1
665 11 13 1
670 13 15 0
675 11 13 0
680 12 15 0
1000 11 14 1
1060 12 14 1
1060 11 14 0
1080 12 14 0
3
540 700 13
600 1000 15
1000 1200 11
1 1
2
600 1 1 1
700 1 1 0
5
540 600 1
550 650 1
610 620 1
650 750 1
700 800 1
0 0
Output
55
70
30
0
0
50
10
50
0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int (i)=0;(i)<(n);++(i))
using vi = vector<int>;
using mvi = map<int,vi>;
int main()
{
int n,m;
while(cin >> n >> m,n+m){
mvi mv;
int r;
cin >> r;
REP(i,r){
int t,_n,_m,s;
cin >> t >> _n >> _m >> s;
if(s){
if(mv.find(_m) == mv.end()){
mv[_m].resize(1300,0);
}
mv[_m][t]++;
}else{
mv[_m][t]--;
}
}
for(auto it = mv.begin();it != mv.end();++it){
REP(i,1300-1){
it->second[i+1] += it->second[i];
}
}
int q;
cin >>q;
REP(i,q){
int t1,t2,_m;
cin >> t1 >> t2 >> _m;
int ans = 0;
if(mv.find(_m)!=mv.end()){
auto mc = mv[_m];
for(int i = t1;i < t2;++i){
if(mc[i]>0){
ans++;
}
}
}
cout << ans << endl;
}
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Β«PolygonΒ» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 β€ n β€ 3000) β the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 3000) β indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] != i + 1) {
cout << i + 1;
return 0;
}
}
cout << n + 1;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
For long time scientists study the behavior of sharks. Sharks, as many other species, alternate short movements in a certain location and long movements between locations.
Max is a young biologist. For n days he watched a specific shark, and now he knows the distance the shark traveled in each of the days. All the distances are distinct. Max wants to know now how many locations the shark visited. He assumed there is such an integer k that if the shark in some day traveled the distance strictly less than k, then it didn't change the location; otherwise, if in one day the shark traveled the distance greater than or equal to k; then it was changing a location in that day. Note that it is possible that the shark changed a location for several consecutive days, in each of them the shark traveled the distance at least k.
The shark never returned to the same location after it has moved from it. Thus, in the sequence of n days we can find consecutive nonempty segments when the shark traveled the distance less than k in each of the days: each such segment corresponds to one location. Max wants to choose such k that the lengths of all such segments are equal.
Find such integer k, that the number of locations is as large as possible. If there are several such k, print the smallest one.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the number of days.
The second line contains n distinct positive integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the distance traveled in each of the day.
Output
Print a single integer k, such that
1. the shark was in each location the same number of days,
2. the number of locations is maximum possible satisfying the first condition,
3. k is smallest possible satisfying the first and second conditions.
Examples
Input
8
1 2 7 3 4 8 5 6
Output
7
Input
6
25 1 2 3 14 36
Output
2
Note
In the first example the shark travels inside a location on days 1 and 2 (first location), then on 4-th and 5-th days (second location), then on 7-th and 8-th days (third location). There are three locations in total.
In the second example the shark only moves inside a location on the 2-nd day, so there is only one location.
### Response
```cpp
#include <bits/stdc++.h>
#pragma warning(disable : 4018)
using namespace std;
const int Inf = (int)1e9 + 7;
namespace {
const int N = (int)1e5 + 7;
int n;
int a[N];
int dsu[N], rnk[N], sz[N];
int make(int x) {
dsu[x] = x;
rnk[x] = 0;
sz[x] = 1;
return dsu[x];
}
int find(int x) {
if (dsu[x] == -1) return -1;
if (x == dsu[x]) return x;
return find(dsu[x]);
}
void unite(int x, int y) {
int xset = find(x);
int yset = find(y);
if (xset == yset) return;
if (rnk[xset] < rnk[yset]) {
dsu[xset] = yset;
sz[yset] += sz[xset];
} else if (rnk[xset] > rnk[yset]) {
dsu[yset] = xset;
sz[xset] += sz[yset];
} else {
dsu[yset] = xset;
sz[xset] += sz[yset];
++rnk[xset];
}
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> b(n);
for (int i = 0; i < n; i++) b[i] = a[i];
sort(b.begin(), b.end());
b.resize(unique(b.begin(), b.end()) - b.begin());
for (int i = 0; i < n; i++)
a[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
memset(dsu, -1, sizeof(dsu));
multiset<int> ms;
vector<int> p(n);
for (int i = 0; i < n; i++) p[a[i]] = i;
int lmax = -1;
int maxi = -1;
for (int x = 0; x < n; x++) {
int xset = make(x);
ms.insert(1);
int pos = p[x];
int lef = p[x] - 1;
int rig = p[x] + 1;
if (lef >= 0) {
int lset = find(a[lef]);
if (lset != -1) {
ms.erase(sz[xset]);
ms.erase(sz[lset]);
ms.insert(sz[lset] + sz[xset]);
unite(xset, lset);
}
}
if (rig < n) {
int xset = find(a[pos]);
int rset = find(a[rig]);
if (rset != -1) {
ms.erase(sz[xset]);
ms.erase(sz[rset]);
ms.insert(sz[xset] + sz[rset]);
unite(xset, rset);
}
}
if (*ms.begin() == *prev(ms.end())) {
int lnow = ms.size();
if (lnow > lmax) {
lmax = lnow;
maxi = b[x] + 1;
}
}
}
cout << maxi << "\n";
}
} // namespace
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(9);
cout << fixed;
solve();
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
The athletics competition 200M semi-final three races were held. Eight players (24 players in total) will participate in each group. A total of eight players, including the top two players in each group and the top two players from all the players in each group who are third or lower, will advance to the final.
Create a program that inputs the player numbers and times and outputs the numbers and times of the eight finalists.
Input
The input is given in the following format:
p1 t1
p2 t2
::
p24 t24
Lines 1-8, 1st set player number pi (integer, 1 β€ pi β€ 10000) and time ti (real number measured to 1/100, 1 β€ ti β€ 100), lines 9-16 Is given the player number pi and time ti of the second group, and the player number pi and time ti of the third group on the 17th to 24th lines. It is assumed that there are no players with the same player number or the same time.
Output
In the following order, please output the player numbers and times of the finalists on one line, separated by blanks.
1st place player in the 1st group
2nd place player in the 1st group
1st place player in the 2nd group
2nd place player in the 2nd group
1st place player in the 3rd group
Second place player in the third group
The player with the fastest time among the players who are 3rd or lower in each group
The player with the second fastest time among the players who are third or lower in each group
Example
Input
18 25.46
16 26.23
3 23.00
10 24.79
5 22.88
11 23.87
19 23.90
1 25.11
23 23.88
4 23.46
7 24.12
12 22.91
13 21.99
14 22.86
21 23.12
9 24.09
17 22.51
22 23.49
6 23.02
20 22.23
24 21.89
15 24.14
8 23.77
2 23.42
Output
5 22.88
3 23.00
13 21.99
14 22.86
24 21.89
20 22.23
17 22.51
12 22.91
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair<double, int> P;
void solve()
{
vector<P> second;
vector<P> a(8);
vector<P> b(8);
vector<P> c(8);
for(int i = 0; i < 8; ++i)
{
cin >> a[i].second >> a[i].first;
}
for(int i = 0; i < 8; ++i)
{
cin >> b[i].second >> b[i].first;
}
for(int i = 0; i < 8; ++i)
{
cin >> c[i].second >> c[i].first;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
second.push_back(a[2]);
second.push_back(a[3]);
second.push_back(b[2]);
second.push_back(b[3]);
second.push_back(c[2]);
second.push_back(c[3]);
sort(second.begin(), second.end());
cout << a[0].second << " " << a[0].first << endl;
cout << a[1].second << " " << a[1].first << endl;
cout << b[0].second << " " << b[0].first << endl;
cout << b[1].second << " " << b[1].first << endl;
cout << c[0].second << " " << c[0].first << endl;
cout << c[1].second << " " << c[1].first << endl;
cout << second[0].second << " " << second[0].first << endl;
cout << second[1].second << " " << second[1].first << endl;
}
int main()
{
solve();
return(0);
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You are given one integer n (n > 1).
Recall that a permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation of length 5, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n = 3 but there is 4 in the array).
Your task is to find a permutation p of length n that there is no index i (1 β€ i β€ n) such that p_i = i (so, for all i from 1 to n the condition p_i β i should be satisfied).
You have to answer t independent test cases.
If there are several answers, you can print any. It can be proven that the answer exists for each n > 1.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 β€ n β€ 100) β the length of the permutation you have to find.
Output
For each test case, print n distinct integers p_1, p_2, β¦, p_n β a permutation that there is no index i (1 β€ i β€ n) such that p_i = i (so, for all i from 1 to n the condition p_i β i should be satisfied).
If there are several answers, you can print any. It can be proven that the answer exists for each n > 1.
Example
Input
2
2
5
Output
2 1
2 1 5 3 4
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1e5+10;
int main(){
// freopen("in.txt","r",stdin);
// ios::sync_with_stdio(false);
int t;
int n;
scanf("%d",&t);
while(t--){
scanf("%d",&n);
for(int i=2;i<=n;++i)
printf("%d ",i);
printf("1\n");
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
VK news recommendation system daily selects interesting publications of one of n disjoint categories for each user. Each publication belongs to exactly one category. For each category i batch algorithm selects a_i publications.
The latest A/B test suggests that users are reading recommended publications more actively if each category has a different number of publications within daily recommendations. The targeted algorithm can find a single interesting publication of i-th category within t_i seconds.
What is the minimum total time necessary to add publications to the result of batch algorithm execution, so all categories have a different number of publications? You can't remove publications recommended by the batch algorithm.
Input
The first line of input consists of single integer n β the number of news categories (1 β€ n β€ 200 000).
The second line of input consists of n integers a_i β the number of publications of i-th category selected by the batch algorithm (1 β€ a_i β€ 10^9).
The third line of input consists of n integers t_i β time it takes for targeted algorithm to find one new publication of category i (1 β€ t_i β€ 10^5).
Output
Print one integer β the minimal required time for the targeted algorithm to get rid of categories with the same size.
Examples
Input
5
3 7 9 7 8
5 2 5 7 5
Output
6
Input
5
1 2 3 4 5
1 1 1 1 1
Output
0
Note
In the first example, it is possible to find three publications of the second type, which will take 6 seconds.
In the second example, all news categories contain a different number of publications.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long res[300000];
int cd;
map<long long, long long> ok;
pair<long long, long long> a[300000];
priority_queue<long long> pq;
int main() {
int t = 1;
while (t--) {
cin >> cd;
for (int i = 1; i <= cd; i++) {
cin >> a[i].first;
ok[a[i].first] = 1;
}
for (int i = 1; i <= cd; i++) {
cin >> a[i].second;
}
sort(a + 1, a + 1 + cd);
cd++;
a[cd].first = 1e17;
long long kq = 0;
long long cur = 0;
int i = 1;
while (i < cd) {
pq.push(a[i].second);
cur += a[i].second;
while (a[i + 1].first == a[i].first) {
i++;
pq.push(a[i].second);
cur += a[i].second;
}
cur -= pq.top();
pq.pop();
for (long long e = a[i].first + 1; e <= 1000000000000; e++) {
if (pq.size() == 0) {
break;
}
kq += cur;
if (ok[e] == 1) {
break;
}
cur -= pq.top();
pq.pop();
}
i++;
}
cout << kq << '\n';
}
}
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.