text
stringlengths 424
69.5k
|
|---|
### Prompt
Develop a solution in cpp to the problem described below:
It’s riot time on football stadium Ramacana! Raging fans have entered the field and the police find themselves in a difficult situation. The field can be represented as a square in the coordinate system defined by two diagonal vertices in (0,0) and (105, 105). The sides of that square are also considered to be inside the field, everything else is outside.
In the beginning, there are N fans on the field. For each fan we are given his speed, an integer vi as well as his integer coordinates (xi, yi). A fan with those coordinates might move and after one second he might be at any point (xi + p, yi + q) where 0 ≤ |p| + |q| ≤ vi. p, q are both integers.
Points that go outside of the square that represents the field are excluded and all others have equal probability of being the location of that specific fan after one second.
Andrej, a young and promising police officer, has sent a flying drone to take a photo of the riot from above. The drone’s camera works like this:
1. It selects three points with integer coordinates such that there is a chance of a fan appearing there after one second. They must not be collinear or the camera won’t work. It is guaranteed that not all of the initial positions of fans will be on the same line.
2. Camera focuses those points and creates a circle that passes through those three points. A photo is taken after one second (one second after the initial state).
3. Everything that is on the circle or inside it at the moment of taking the photo (one second after focusing the points) will be on the photo.
Your goal is to select those three points so that the expected number of fans seen on the photo is maximized. If there are more such selections, select those three points that give the circle with largest radius among them. If there are still more suitable selections, any one of them will be accepted. If your answer follows conditions above and radius of circle you return is smaller then the optimal one by 0.01, your output will be considered as correct.
No test will have optimal radius bigger than 1010.
Input
The first line contains the number of fans on the field, N. The next N lines contain three integers: xi ,yi, vi. They are the x-coordinate, y-coordinate and speed of fan i at the beginning of the one second interval considered in the task.
* 3 ≤ N ≤ 105
* 0 ≤ xi, yi ≤ 105
* 0 ≤ vi ≤ 1000
* All numbers are integers
Output
You need to output the three points that camera needs to select. Print them in three lines, with every line containing the x-coordinate, then y-coordinate, separated by a single space. The order of points does not matter.
Examples
Input
3
1 1 1
1 1 1
1 2 1
Output
2 2
2 1
1 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int N = 100000;
int n;
int m;
vector<pair<int, int> > v;
void add(int x, int y) { v.push_back(make_pair(x, y)); }
long long vect(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
return (long long)(b.first - a.first) * (c.second - b.second) -
(long long)(b.second - a.second) * (c.first - b.first);
}
long double dist(pair<int, int> a, pair<int, int> b) {
return sqrt(abs(
(((long double)a.first - b.first) * ((long double)a.first - b.first)) +
(((long double)a.second - b.second) *
((long double)a.second - b.second))));
}
long double getr(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
long double A = dist(a, b);
long double B = dist(a, c);
long double C = dist(b, c);
long double p = (A + B + C) / 2;
long double S = 4 * sqrt(abs(p * (p - A) * (p - B) * (p - C)));
return A * B * C / S;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y, d;
scanf("%d%d%d", &x, &y, &d);
if (x >= d)
add(x - d, y);
else {
int h = d - x;
if (y + h > N)
add(0, N);
else
add(0, y + h);
if (y - h < 0)
add(0, 0);
else
add(0, y - h);
}
if (x + d <= N)
add(x + d, y);
else {
int h = x + d - N;
if (y + h > N)
add(N, N);
else
add(N, y + h);
if (y - h < 0)
add(N, 0);
else
add(N, y - h);
}
if (y >= d)
add(x, y - d);
else {
int h = d - y;
if (x + h > N)
add(N, 0);
else
add(x + h, 0);
if (x - h < 0)
add(0, 0);
else
add(x - h, 0);
}
if (y + d <= N)
add(x, y + d);
else {
int h = y + d - N;
if (x + h > N)
add(N, N);
else
add(x + h, N);
if (x - h < 0)
add(0, N);
else
add(x - h, N);
}
}
sort((v).begin(), (v).end());
v.resize(unique((v).begin(), (v).end()) - v.begin());
vector<pair<int, int> > q1, q2;
for (int i = 0; i < ((int)(v).size()); i++) {
while (((int)(q1).size()) > 1 &&
vect(q1[((int)(q1).size()) - 2], q1[((int)(q1).size()) - 1], v[i]) >=
0)
q1.pop_back();
while (((int)(q2).size()) > 1 &&
vect(q2[((int)(q2).size()) - 2], q2[((int)(q2).size()) - 1], v[i]) <=
0)
q2.pop_back();
q1.push_back(v[i]);
q2.push_back(v[i]);
}
q2.pop_back();
reverse((q2).begin(), (q2).end());
q2.pop_back();
for (int i = 0; i < ((int)(q2).size()); i++) q1.push_back(q2[i]);
pair<long double, int> best(-1e100, 0);
q1.push_back(q1[0]);
q1.push_back(q1[1]);
for (int i = 0; i + 2 < ((int)(q1).size()); i++) {
long double r = getr(q1[i], q1[i + 1], q1[i + 2]);
best = max(best, make_pair(r, i));
}
printf("%d %d\n", q1[best.second].first, q1[best.second].second);
printf("%d %d\n", q1[best.second + 1].first, q1[best.second + 1].second);
printf("%d %d\n", q1[best.second + 2].first, q1[best.second + 2].second);
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
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;
long long dp[110][101000];
long long d[100010];
long long sumd[100010];
int n, m, p;
int dis[100010];
int tot = 1;
struct STA {
struct Sta {
long long x, y;
Sta(long long a, long long b) : x(a), y(b) {}
Sta() {}
} s[100010];
int top, now;
void init() {
top = -1;
now = 0;
}
void P(long long a, long long b) {
if (top < 1)
s[++top] = Sta(a, b);
else {
while (1) {
if (top == 0) {
s[++top] = Sta(a, b);
break;
}
long long y1 = b - s[top].y;
long long x1 = a - s[top].x;
long long y2 = s[top].y - s[top - 1].y;
long long x2 = s[top].x - s[top - 1].x;
if (y1 * x2 > y2 * x1) {
s[++top] = Sta(a, b);
break;
} else {
top--;
}
}
}
}
} S;
double cal(int x) {
return double(S.s[x + 1].y - S.s[x].y) / double(S.s[x + 1].x - S.s[x].x);
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 2; i < n + 1; ++i) {
scanf("%d", &dis[i]);
dis[i] = dis[i - 1] + dis[i];
}
int h, t;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &h, &t);
d[tot++] = t - dis[h];
}
sort(d + 1, d + tot);
S.init();
for (int i = 1; i < tot; ++i) sumd[i] = sumd[i - 1] + d[i];
for (int i = 1; i < tot; ++i) dp[1][i] = d[i] * i - sumd[i];
for (int k = 2; k < p + 1; ++k) {
for (int i = k; i < tot; ++i) {
S.P(i - 1, dp[k - 1][i - 1] + sumd[i - 1]);
while (S.now < S.top && cal(S.now) < double(d[i])) {
S.now++;
}
dp[k][i] = S.s[S.now].y - S.s[S.now].x * d[i] + i * d[i] - sumd[i];
}
S.init();
}
if (p >= tot) {
puts("0");
return 0;
}
printf("%I64d\n", dp[p][tot - 1]);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
In the famous Oh-Suit-United tournament, two teams are playing against each other for the grand prize of precious pepper points.
The first team consists of n players, and the second team consists of m players. Each player has a potential: the potential of the i-th player in the first team is a_i, and the potential of the i-th player in the second team is b_i.
In the tournament, all players will be on the stage in some order. There will be a scoring device, initially assigned to an integer k, which will be used to value the performance of all players.
The scores for all players will be assigned in the order they appear on the stage. Let the potential of the current player be x, and the potential of the previous player be y (y equals x for the first player). Then, x-y is added to the value in the scoring device, Afterwards, if the value in the scoring device becomes negative, the value will be reset to 0. Lastly, the player's score is assigned to the current value on the scoring device. The score of a team is the sum of the scores of all its members.
As an insane fan of the first team, Nezzar desperately wants the biggest win for the first team. He now wonders what is the maximum difference between scores of the first team and the second team.
Formally, let the score of the first team be score_f and the score of the second team be score_s. Nezzar wants to find the maximum value of score_f - score_s over all possible orders of players on the stage.
However, situation often changes and there are q events that will happen. There are three types of events:
* 1 pos x — change a_{pos} to x;
* 2 pos x — change b_{pos} to x;
* 3 x — tournament is held with k = x and Nezzar wants you to compute the maximum value of score_f - score_s.
Can you help Nezzar to answer the queries of the third type?
Input
The first line contains three integers n, m, and q (1 ≤ n,m ≤ 2 ⋅ 10^5, 1 ≤ q ≤ 5 ⋅ 10^5).
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6).
The third line contains m integers b_1, b_2, …, b_m (0 ≤ b_i ≤ 10^6).
The following q lines contain descriptions of events, described in the statement, each in one of the three possible formats:
* 1 pos x (1 ≤ pos ≤ n, 0 ≤ x ≤ 10^6);
* 2 pos x (1 ≤ pos ≤ m, 0 ≤ x ≤ 10^6);
* 3 x (0 ≤ x ≤ 10^6).
Output
For each query of the third type print the answer to this query.
Examples
Input
3 4 3
1 2 7
3 4 5 6
3 5
1 1 10
3 5
Output
-4
9
Input
7 8 12
958125 14018 215153 35195 90380 30535 204125
591020 930598 252577 333333 999942 1236 9456 82390
3 123458
2 4 444444
3 123456
1 2 355555
3 123478
3 1111
2 6 340324
3 1111
2 8 999999
2 7 595959
3 222222
3 100
Output
1361307
1361311
1702804
1879305
1821765
1078115
1675180
Note
In the first query of the first test, the tournament is held with k = 5. It would be optimal to arrange players in such way (here their potentials are written):
\underline{7}, 3, 5, 4, 6, \underline{1}, \underline{2} (underlined numbers are potentials of players that are from the first team).
The individual scores of players, numbered in the order of their appearance, are:
* max(5 + (7 - 7), 0) = 5 for the \underline{1}-st player;
* max(5 + (3 - 7), 0) = 1 for the 2-nd player;
* max(1 + (5 - 3), 0) = 3 for the 3-rd player;
* max(3 + (4 - 5), 0) = 2 for the 4-th player;
* max(2 + (6 - 4), 0) = 4 for the 5-th player;
* max(4 + (1 - 6), 0) = 0 for the \underline{6}-th player;
* max(0 + (2 - 1), 0) = 1 for the \underline{7}-th player.
So, score_f = 5 + 0 + 1 = 6 and score_s = 1 + 3 + 2 + 4 = 10. The score difference is 6 - 10 = -4. It can be proven, that it is the maximum possible score difference.
### Response
```cpp
//Awwawa! Dis cold yis ratten buy tEMMIE!
#include <bits/stdc++.h>
#define ll long long
#define maxn 1100005 /*rem*/
#define mod 998244353
#define db double
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define pi pair<int, int>
#define fi first
#define se second
template <typename T> bool chkmax(T &x,T y){return x<y?x=y,true:false;}
template <typename T> bool chkmin(T &x,T y){return x>y?x=y,true:false;}
using namespace std;
struct bit {
ll d[maxn + 105];
int lb(int a) {
return a & -a;
}
void ins(int pl, int x) {
pl++;
while (pl < maxn)
d[pl] += x,
pl += lb(pl);
}
ll q(int pl) {
pl++;
ll ans = 0;
while (pl) {
ans += d[pl];
pl -= lb(pl);
}
return ans;
}
ll q(int l, int r) {
chkmax(l, 0);
chkmin(r, maxn + 10);
return q(r) - q(l - 1);
}
}s[2];
ll calc(int a) {
ll ans = s[1].q(a, maxn + 50) - 1ll * a * s[0].q(a, maxn + 50);
return ans;
}
ll sum[2];
int e[2][maxn];
ll sz[2];
multiset<int> tot;
multiset<int> us[2];
#define iter multiset<int>::iterator
int main() {
int q;
cin >> sz[0] >> sz[1] >> q;
for (int i = 0; i < 2; i++)
for (int j = 1; j <= sz[i]; j++) {
scanf("%d", &e[i][j]),
sum[i] += e[i][j],
us[i].insert(e[i][j]),
tot.insert(e[i][j]);
}
for (int j = 1; j <= sz[1]; j++)
s[0].ins(e[1][j], 1),
s[1].ins(e[1][j], e[1][j]);
while (q--) {
int t, u;
scanf("%d%d", &t, &u);
t--;
if (t <= 1) {
int to;
scanf("%d", &to);
tot.erase(tot.find(e[t][u]));
us[t].erase(us[t].find(e[t][u]));
sum[t] -= e[t][u];
if (t == 1)
s[0].ins(e[t][u], -1),
s[1].ins(e[t][u], -e[t][u]);
e[t][u] = to;
tot.insert(e[t][u]);
us[t].insert(e[t][u]);
sum[t] += e[t][u];
if (t == 1)
s[0].ins(e[t][u], 1),
s[1].ins(e[t][u], e[t][u]);
}
else {
// 第一种 ： <= min + k
int mn = *tot.begin();
int k = u;
ll ans = -6e18;
chkmax(ans, sum[0] - 1ll * sz[0] * (mn - k) - (sum[1] - 1ll * sz[1] * (mn - k)));
iter cur = tot.lower_bound(mn + k + 1);
if (cur != tot.begin()) {
cur--;
int cr = *cur;
assert(cr <= mn + k);
chkmax(ans, (sum[0] - 1ll * sz[0] * (cr - k)) - (sum[1] - 1ll * sz[1] * (cr - k)));
}
int mx = *(--us[0].end());
ll dsum = sum[0] - 1ll * sz[0] * mn;
int um = *(--us[1].end());
if (mx > mn + k) {
chkmax(ans, -calc(mx - k) + dsum - (mx - mn) + k);
iter h = us[0].lower_bound(um + k);
if (h != us[0].end()) {
mx = *h;
if (mx > mn + k)
chkmax(ans, -calc(mx - k) + dsum - (mx - mn) + k);
}
if (h != us[0].begin()) {
h--;
mx = *h;
if (mx > mn + k)
chkmax(ans, -calc(mx - k) + dsum - (mx - mn) + k);
}
}
mx = um;
if (mx > mn + k)
chkmax(ans, -calc(mx - k) + dsum);
printf("%lld\n", ans);
}
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Vasya and Petya have invented a new game. Vasya takes a stripe consisting of 1 × n square and paints the squares black and white. After that Petya can start moves — during a move he may choose any two neighboring squares of one color and repaint these two squares any way he wants, perhaps in different colors. Petya can only repaint the squares in white and black colors. Petya’s aim is to repaint the stripe so that no two neighboring squares were of one color. Help Petya, using the given initial coloring, find the minimum number of moves Petya needs to win.
Input
The first line contains number n (1 ≤ n ≤ 1000) which represents the stripe’s length. The second line contains exactly n symbols — the line’s initial coloring. 0 corresponds to a white square, 1 corresponds to a black one.
Output
If Petya cannot win with such an initial coloring, print -1. Otherwise print the minimum number of moves Petya needs to win.
Examples
Input
6
111010
Output
1
Input
5
10001
Output
1
Input
7
1100010
Output
2
Input
5
00100
Output
2
Note
In the first sample Petya can take squares 1 and 2. He repaints square 1 to black and square 2 to white.
In the second sample Petya can take squares 2 and 3. He repaints square 2 to white and square 3 to black.
### Response
```cpp
#include <bits/stdc++.h>
int arr[1024];
int narr;
int func(int x) {
int i, count = 0;
for (i = 0; i < narr; i++) {
("ele = %d : %d\n", i, arr[i]);
if ((i % 2) == 0) {
if (arr[i] != x) {
count++;
}
} else {
if (arr[i] != (!x)) {
("%d : %d : ( !x not matched = %d ) \n", i, arr[i], !x);
count++;
}
}
}
return count;
}
int main() {
int t, i;
int v1, v2;
scanf("%d\n", &narr);
for (i = 0; i < narr; i++) {
t = getchar();
arr[i] = t - '0';
}
v1 = func(1);
v2 = func(0);
("1 at even pos = %d\n", func(1));
("1 at odd pos = %d\n", func(0));
printf("%d\n", (v1 > v2) ? v2 : v1);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You already know that Valery's favorite sport is biathlon. Due to your help, he learned to shoot without missing, and his skills are unmatched at the shooting range. But now a smaller task is to be performed, he should learn to complete the path fastest.
The track's map is represented by a rectangle n × m in size divided into squares. Each square is marked with a lowercase Latin letter (which means the type of the plot), with the exception of the starting square (it is marked with a capital Latin letters S) and the terminating square (it is marked with a capital Latin letter T). The time of movement from one square to another is equal to 1 minute. The time of movement within the cell can be neglected. We can move from the cell only to side-adjacent ones, but it is forbidden to go beyond the map edges. Also the following restriction is imposed on the path: it is not allowed to visit more than k different types of squares (squares of one type can be visited an infinite number of times). Squares marked with S and T have no type, so they are not counted. But S must be visited exactly once — at the very beginning, and T must be visited exactly once — at the very end.
Your task is to find the path from the square S to the square T that takes minimum time. Among all shortest paths you should choose the lexicographically minimal one. When comparing paths you should lexicographically represent them as a sequence of characters, that is, of plot types.
Input
The first input line contains three integers n, m and k (1 ≤ n, m ≤ 50, n·m ≥ 2, 1 ≤ k ≤ 4). Then n lines contain the map. Each line has the length of exactly m characters and consists of lowercase Latin letters and characters S and T. It is guaranteed that the map contains exactly one character S and exactly one character T.
Pretest 12 is one of the maximal tests for this problem.
Output
If there is a path that satisfies the condition, print it as a sequence of letters — the plot types. Otherwise, print "-1" (without quotes). You shouldn't print the character S in the beginning and T in the end.
Note that this sequence may be empty. This case is present in pretests. You can just print nothing or print one "End of line"-character. Both will be accepted.
Examples
Input
5 3 2
Sba
ccc
aac
ccc
abT
Output
bcccc
Input
3 4 1
Sxyy
yxxx
yyyT
Output
xxxx
Input
1 3 3
TyS
Output
y
Input
1 4 1
SxyT
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int GetBit(int mask, int num) { return (mask >> num) & 1; }
inline int GetAmountOfBits(int mask) {
int ans = 0;
while (mask > 0) {
ans += (mask & 1);
mask >>= 1;
}
return ans;
}
const int kAlphabetSize = 26;
const int kDx[4] = {-1, 0, 0, 1};
const int kDy[4] = {0, -1, 1, 0};
int n, m, k;
vector<vector<char> > field;
int si, sj;
int fi, fj;
bool ans_found;
int ans_len;
string ans_path;
vector<vector<bool> > used;
vector<vector<bool> > inused;
vector<vector<int> > dist;
vector<int> char_posses_i[kAlphabetSize];
vector<int> char_posses_j[kAlphabetSize];
void ClearUsed(int mask, vector<vector<bool> >& used) {
for (int c = 0; c < kAlphabetSize; ++c) {
if (!GetBit(mask, c)) {
continue;
}
for (int i = 0; i < (int)char_posses_i[c].size(); ++i) {
used[char_posses_i[c][i]][char_posses_j[c][i]] = false;
}
}
used[si][sj] = false;
used[fi][fj] = false;
}
void UpdateAns(int mask) {
if (dist[fi][fj] == 1) {
ans_found = true;
ans_len = 1;
ans_path = "";
return;
}
string cur_path;
cur_path.reserve(dist[fi][fj] - 1);
deque<int> qi;
deque<int> qj;
qi.push_back(fi);
qj.push_back(fj);
inused[fi][fj] = true;
while (!qi.empty()) {
int ci = qi.front();
qi.pop_front();
int cj = qj.front();
qj.pop_front();
for (int step_index = 0; step_index < 4; ++step_index) {
int ni = ci + kDx[step_index];
int nj = cj + kDy[step_index];
if (ni >= 0 && ni < n && nj >= 0 && nj < m && !inused[ni][nj] &&
used[ni][nj] && dist[ni][nj] + 1 == dist[ci][cj]) {
inused[ni][nj] = true;
qi.push_back(ni);
qj.push_back(nj);
}
}
}
qi.push_back(si);
qj.push_back(sj);
used[si][sj] = false;
while (!qi.empty()) {
char min_char = field[qi[0]][qj[0]];
for (int i = 1; i < (int)qi.size(); ++i) {
min_char = min(min_char, field[qi[i]][qj[i]]);
}
if (min_char != 'S' && min_char != 'T') {
cur_path.push_back(min_char);
}
int sz = qi.size();
for (int itr = 0; itr < (int)sz; ++itr) {
int ci = qi.front();
qi.pop_front();
int cj = qj.front();
qj.pop_front();
if (field[ci][cj] != min_char) {
continue;
}
for (int step_index = 0; step_index < 4; ++step_index) {
int ni = ci + kDx[step_index];
int nj = cj + kDy[step_index];
if (ni >= 0 && ni < n && nj >= 0 && nj < m && inused[ni][nj] &&
used[ni][nj] && dist[ni][nj] == dist[ci][cj] + 1) {
used[ni][nj] = false;
qi.push_back(ni);
qj.push_back(nj);
}
}
}
}
ClearUsed(mask, inused);
if (!ans_found || dist[fi][fj] < ans_len || cur_path < ans_path) {
ans_found = true;
ans_len = dist[fi][fj];
ans_path = cur_path;
}
}
void Solve(int mask) {
queue<int> qi;
queue<int> qj;
used[si][sj] = true;
dist[si][sj] = 0;
qi.push(si);
qj.push(sj);
while (!qi.empty()) {
int ci = qi.front();
qi.pop();
int cj = qj.front();
qj.pop();
for (int step_index = 0; step_index < 4; ++step_index) {
int ni = ci + kDx[step_index];
int nj = cj + kDy[step_index];
if (ni >= 0 && ni < n && nj >= 0 && nj < m &&
(field[ni][nj] == 'T' || field[ni][nj] == 'S' ||
GetBit(mask, field[ni][nj] - 'a')) &&
!used[ni][nj]) {
used[ni][nj] = true;
dist[ni][nj] = dist[ci][cj] + 1;
qi.push(ni);
qj.push(nj);
}
}
}
if (used[fi][fj]) {
if (!ans_found || dist[fi][fj] <= ans_len) {
UpdateAns(mask);
}
}
ClearUsed(mask, used);
}
void Dfs(int c, int mask, int num) {
if (c == kAlphabetSize) {
Solve(mask);
return;
}
if (num + 1 <= k) {
Dfs(c + 1, mask + (1 << c), num + 1);
}
Dfs(c + 1, mask, num);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> k;
field.resize(n, vector<char>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> field[i][j];
if (field[i][j] == 'S') {
si = i;
sj = j;
}
if (field[i][j] == 'T') {
fi = i;
fj = j;
}
}
}
used.assign(n, vector<bool>(m, false));
inused.assign(n, vector<bool>(m, false));
dist.resize(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (field[i][j] >= 'a' && field[i][j] <= 'z') {
char_posses_i[field[i][j] - 'a'].push_back(i);
char_posses_j[field[i][j] - 'a'].push_back(j);
}
}
}
ans_found = false;
Dfs(0, 0, 0);
if (!ans_found) {
cout << -1 << endl;
} else {
cout << ans_path << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
There is a light source on the plane. This source is so small that it can be represented as point. The light source is moving from point (a, s_y) to the (b, s_y) (s_y < 0) with speed equal to 1 unit per second. The trajectory of this light source is a straight segment connecting these two points.
There is also a fence on OX axis represented as n segments (l_i, r_i) (so the actual coordinates of endpoints of each segment are (l_i, 0) and (r_i, 0)). The point (x, y) is in the shade if segment connecting (x,y) and the current position of the light source intersects or touches with any segment of the fence.
<image>
You are given q points. For each point calculate total time of this point being in the shade, while the light source is moving from (a, s_y) to the (b, s_y).
Input
First line contains three space separated integers s_y, a and b (-10^9 ≤ s_y < 0, 1 ≤ a < b ≤ 10^9) — corresponding coordinates of the light source.
Second line contains single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — number of segments in the fence.
Next n lines contain two integers per line: l_i and r_i (1 ≤ l_i < r_i ≤ 10^9, r_{i - 1} < l_i) — segments in the fence in increasing order. Segments don't intersect or touch each other.
Next line contains single integer q (1 ≤ q ≤ 2 ⋅ 10^5) — number of points to check.
Next q lines contain two integers per line: x_i and y_i (1 ≤ x_i, y_i ≤ 10^9) — points to process.
Output
Print q lines. The i-th line should contain one real number — total time of the i-th point being in the shade, while the light source is moving from (a, s_y) to the (b, s_y). The answer is considered as correct if its absolute of relative error doesn't exceed 10^{-6}.
Example
Input
-3 1 6
2
2 4
6 7
5
3 1
1 3
6 1
6 4
7 6
Output
5.000000000000000
3.000000000000000
0.000000000000000
1.500000000000000
2.000000000000000
Note
* The 1-st point is always in the shade;
* the 2-nd point is in the shade while light source is moving from (3, -3) to (6, -3);
* the 3-rd point is in the shade while light source is at point (6, -3).
* the 4-th point is in the shade while light source is moving from (1, -3) to (2.5, -3) and at point (6, -3);
* the 5-th point is in the shade while light source is moving from (1, -3) to (2.5, -3) and from (5.5, -3) to (6, -3);
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long double sy, a, b;
int n;
long double l[200005], r[200005];
long double acc[200005];
long double x, y;
void solve() {
long double L = (a * y + x * sy) / (y + sy);
long double R = (b * y + x * sy) / (y + sy);
int lc = 0;
int rc = n;
int lb, rb;
while (rc - lc > 1) {
int mid = (lc + rc) >> 1;
if (r[mid] >= L) {
rc = mid;
} else {
lc = mid;
}
}
lb = rc;
lc = 1;
rc = n + 1;
while (rc - lc > 1) {
int mid = (lc + rc) >> 1;
if (l[mid] <= R) {
lc = mid;
} else {
rc = mid;
}
}
rb = lc;
long double ans;
if (lb == rb) {
long double LL = l[lb] + (l[lb] - x) / y * sy;
long double RR = r[lb] + (r[lb] - x) / y * sy;
if (RR < a || LL > b)
ans = 0;
else
ans = min(RR, b) - max(LL, a);
} else {
ans = (acc[rb] - acc[lb - 1]) / y * (y + sy);
long double LL = l[lb] + (l[lb] - x) / y * sy;
long double RR = r[rb] + (r[rb] - x) / y * sy;
if (LL < a) {
ans -= a - LL;
}
if (RR > b) {
ans -= RR - b;
}
}
printf("%.13LF\n", ans);
}
int main() {
cin >> sy >> a >> b;
sy = -sy;
cin >> n;
acc[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%LF%LF", &l[i], &r[i]);
acc[i] = acc[i - 1] + r[i] - l[i];
}
int Q;
scanf("%d", &Q);
;
while (Q--) {
scanf("%LF%LF", &x, &y);
solve();
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
problem
There are $ N $ propositions, named $ 1, 2, \ cdots, N $, respectively. Also, $ M $ information about the propositions is given. The $ i $ th information is "$ a_i $$". Given in the form "b_i $", which means that $ a_i $ is $ b_i $. ("If" is a logical conditional and the transition law holds.) $ For each proposition $ i $ Output all propositions that have the same value as i $ in ascending order. However, proposition $ i $ and proposition $ i $ are always the same value. Proposition $ X $ and proposition $ Y $ have the same value as "$ if $ X $". It means "Y $" and "$ X $ if $ Y $".
output
On the $ i $ line, output all propositions that have the same value as the proposition $ i $, separated by blanks in ascending order. Also, output a line break at the end of each line.
Example
Input
5 2
1 2
2 1
Output
1 2
1 2
3
4
5
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
namespace SCC{
void visit(const vector<vector<int>>&G,vector<int>&vs,vector<int>&used,int v){
used[v]=true;
for(auto u:G[v]){
if(!used[u])visit(G,vs,used,u);
}
vs.push_back(v);
}
void visit2(const vector<vector<int>>&T,vector<int>&used,vector<int>&comp,vector<int>&vec,int k,int v){
comp[v]=k;
used[v]=true;
vec.push_back(v);
for(auto u:T[v]){
if(!used[u])visit2(T,used,comp,vec,k,u);
}
}
void decompose(const vector<vector<int>>&G,vector<vector<int>>&H,vector<int>&comp){
vector<vector<int>>T(G.size());
for(int i=0;i<G.size();i++){
for(auto v:G[i]){
T[v].push_back(i);
}
}
comp.resize(G.size());
vector<int>vs(G.size());
vector<int>used(G.size());
for(int i=0;i<G.size();i++){
if(!used[i])visit(G,vs,used,i);
}
reverse(vs.begin(),vs.end());
fill(used.begin(),used.end(),0);
int K=0;
vector<vector<int>>S;
for(auto v:vs){
if(!used[v]){
S.push_back(vector<int>());
visit2(T,used,comp,S.back(),K++,v);
}
}
H.resize(K);
fill(used.begin(),used.end(),0);
for(int i=0;i<K;i++){
for(auto v:S[i]){
for(auto u:G[v]){
if(used[comp[u]]||comp[v]==comp[u])continue;
used[comp[u]]=true;
H[comp[v]].push_back(comp[u]);
}
}
for(auto v:H[i])used[v]=false;
}
}
}
signed main(){
int N,M;
cin>>N>>M;
vector<vint>G(N);
rep(i,M){
int a,b;cin>>a>>b;a--;b--;
G[a].pb(b);
}
vector<vint>H;
vint comp;
SCC::decompose(G,H,comp);
rep(i,N){
bool f=false;
rep(j,N){
if(comp[i]!=comp[j])continue;
if(f)cout<<" ";
f=true;
cout<<j+1;
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Jzzhu has a big rectangular chocolate bar that consists of n × m unit squares. He wants to cut this bar exactly k times. Each cut must meet the following requirements:
* each cut should be straight (horizontal or vertical);
* each cut should go along edges of unit squares (it is prohibited to divide any unit chocolate square with cut);
* each cut should go inside the whole chocolate bar, and all cuts must be distinct.
The picture below shows a possible way to cut a 5 × 6 chocolate for 5 times.
<image>
Imagine Jzzhu have made k cuts and the big chocolate is splitted into several pieces. Consider the smallest (by area) piece of the chocolate, Jzzhu wants this piece to be as large as possible. What is the maximum possible area of smallest piece he can get with exactly k cuts? The area of a chocolate piece is the number of unit squares in it.
Input
A single line contains three integers n, m, k (1 ≤ n, m ≤ 109; 1 ≤ k ≤ 2·109).
Output
Output a single integer representing the answer. If it is impossible to cut the big chocolate k times, print -1.
Examples
Input
3 4 1
Output
6
Input
6 4 2
Output
8
Input
2 3 4
Output
-1
Note
In the first sample, Jzzhu can cut the chocolate following the picture below:
<image>
In the second sample the optimal division looks like this:
<image>
In the third sample, it's impossible to cut a 2 × 3 chocolate 4 times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, a;
scanf("%I64d%I64d%I64d", &n, &m, &k);
if (n + m - 2 < k)
printf("-1");
else {
if (n > m) {
a = n;
n = m;
m = a;
}
if (n >= k + 1) {
printf("%I64d", max((m / (k + 1)) * n, (n / (k + 1)) * m));
} else {
if (m >= k + 1)
printf("%I64d", (m / (k + 1)) * n);
else
printf("%I64d", n / (k - m + 2));
}
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
On a chessboard with a width of n and a height of n, rows are numbered from bottom to top from 1 to n, columns are numbered from left to right from 1 to n. Therefore, for each cell of the chessboard, you can assign the coordinates (r,c), where r is the number of the row, and c is the number of the column.
The white king has been sitting in a cell with (1,1) coordinates for a thousand years, while the black king has been sitting in a cell with (n,n) coordinates. They would have sat like that further, but suddenly a beautiful coin fell on the cell with coordinates (x,y)...
Each of the monarchs wanted to get it, so they decided to arrange a race according to slightly changed chess rules:
As in chess, the white king makes the first move, the black king makes the second one, the white king makes the third one, and so on. However, in this problem, kings can stand in adjacent cells or even in the same cell at the same time.
The player who reaches the coin first will win, that is to say, the player who reaches the cell with the coordinates (x,y) first will win.
Let's recall that the king is such a chess piece that can move one cell in all directions, that is, if the king is in the (a,b) cell, then in one move he can move from (a,b) to the cells (a + 1,b), (a - 1,b), (a,b + 1), (a,b - 1), (a + 1,b - 1), (a + 1,b + 1), (a - 1,b - 1), or (a - 1,b + 1). Going outside of the field is prohibited.
Determine the color of the king, who will reach the cell with the coordinates (x,y) first, if the white king moves first.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^{18}) — the length of the side of the chess field.
The second line contains two integers x and y (1 ≤ x,y ≤ n) — coordinates of the cell, where the coin fell.
Output
In a single line print the answer "White" (without quotes), if the white king will win, or "Black" (without quotes), if the black king will win.
You can print each letter in any case (upper or lower).
Examples
Input
4
2 3
Output
White
Input
5
3 5
Output
Black
Input
2
2 2
Output
Black
Note
An example of the race from the first sample where both the white king and the black king move optimally:
1. The white king moves from the cell (1,1) into the cell (2,2).
2. The black king moves form the cell (4,4) into the cell (3,3).
3. The white king moves from the cell (2,2) into the cell (2,3). This is cell containing the coin, so the white king wins.
<image>
An example of the race from the second sample where both the white king and the black king move optimally:
1. The white king moves from the cell (1,1) into the cell (2,2).
2. The black king moves form the cell (5,5) into the cell (4,4).
3. The white king moves from the cell (2,2) into the cell (3,3).
4. The black king moves from the cell (4,4) into the cell (3,5). This is the cell, where the coin fell, so the black king wins.
<image>
In the third example, the coin fell in the starting cell of the black king, so the black king immediately wins.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a, b;
cin >> a >> b;
long long x = abs(1 - a);
long long xx = abs(n - b);
if (x == xx)
cout << "White" << endl;
else if (x < xx)
cout << "White" << endl;
else
cout << "Black" << endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Write a program which manipulates a sequence A = {a1, a2, . . . , an} with the following operations:
* add(s, t, x): add x to as, as+1, ..., at.
* get(i): output the value of ai.
Note that the initial values of ai (i = 1, 2, . . . , n) are 0.
Constraints
* 1 ≤ n ≤ 100000
* 1 ≤ q ≤ 100000
* 1 ≤ s ≤ t ≤ n
* 1 ≤ i ≤ n
* 0 ≤ x ≤ 1000
Input
n q
query1
query2
:
queryq
In the first line, n (the number of elements in A) and q (the number of queries) are given. Then, ith query queryi is given in the following format:
0 s t x
or
1 t
The first digit represents the type of the query. '0' denotes add(s, t, x) and '1' denotes get(i).
Output
For each get operation, print the value.
Examples
Input
3 5
0 1 2 1
0 2 3 2
0 3 3 3
1 2
1 3
Output
3
5
Input
4 3
1 2
0 1 4 1
1 2
Output
0
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T = long long>
struct BIT_Range_Add_Point_Get {
// 区間更新・点取得
//階差数列のBITを作って端から足す方針 vec[i] = data[i-1]-data[i-2];
vector<T> vec;
int n;
BIT_Range_Add_Point_Get(int sz) : vec(sz + 1, 0), n(sz) {}
//元の値に足す 更新は不可
void add(int lef, int rig, T val, int index = 0) {
if(!index) {
lef++;
rig++;
}
for(int x = lef; x <= n; x += x & -x) vec[x] += val;
for(int x = rig; x <= n; x += x & -x) vec[x] -= val;
}
//端からの合計値 = 値計算
T get(int a, int index = 0) {
a += 1 - index;
T ret = 0;
for(int x = a; x > 0; x -= x & -x) ret += vec[x];
return ret;
}
};
int main() {
int n, q;
cin >> n >> q;
BIT_Range_Add_Point_Get<int> b(n);
for(int i = 0; i < q; i++) {
int com;
cin >> com;
if(com) {
int idx;
cin >> idx;
cout << b.get(idx - 1) << endl;
} else {
int s, t, x;
cin >> s >> t >> x;
b.add(s - 1, t, x);
}
}
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Note that the difference between easy and hard versions is that in hard version unavailable cells can become available again and in easy version can't. You can make hacks only if all versions are solved.
Ildar and Ivan are tired of chess, but they really like the chessboard, so they invented a new game. The field is a chessboard 2n × 2m: it has 2n rows, 2m columns, and the cell in row i and column j is colored white if i+j is even, and is colored black otherwise.
The game proceeds as follows: Ildar marks some of the white cells of the chessboard as unavailable, and asks Ivan to place n × m kings on the remaining white cells in such way, so that there are no kings attacking each other. A king can attack another king if they are located in the adjacent cells, sharing an edge or a corner.
Ildar would like to explore different combinations of cells. Initially all cells are marked as available, and then he has q queries. In each query he either marks a cell as unavailable, or marks the previously unavailable cell as available. After each query he would like to know whether it is possible to place the kings on the available cells in a desired way. Please help him!
Input
The first line of input contains three integers n, m, q (1 ≤ n, m, q ≤ 200 000) — the size of the board and the number of queries.
q lines follow, each of them contains a description of a query: two integers i and j, denoting a white cell on the board (1 ≤ i ≤ 2n, 1 ≤ j ≤ 2m, i + j is even). If the cell (i, j) was available before the query, then it becomes unavailable. Otherwise, if the cell was unavailable, it becomes available.
Output
Output q lines, i-th line should contain answer for a board after i queries of Ildar. This line should contain "YES" if it is possible to place the kings on the available cells in the desired way, or "NO" otherwise.
Examples
Input
1 3 3
1 1
1 5
2 4
Output
YES
YES
NO
Input
3 2 10
4 2
6 4
1 3
4 2
6 4
2 2
2 4
1 3
4 4
3 1
Output
YES
YES
NO
NO
YES
YES
NO
YES
YES
NO
Note
In the first example case after the second query only cells (1, 1) and (1, 5) are unavailable. Then Ivan can place three kings on cells (2, 2), (2, 4) and (2, 6).
After the third query three cells (1, 1), (1, 5) and (2, 4) are unavailable, so there remain only 3 available cells: (2, 2), (1, 3) and (2, 6). Ivan can not put 3 kings on those cells, because kings on cells (2, 2) and (1, 3) attack each other, since these cells share a corner.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
set<int> a[400005];
set<int> b[400005];
struct Interval {
int flag, minn, maxx;
};
Interval arbint[1600005];
int n;
Interval create(int value1, int value2) {
return Interval{
((value1 != 0 ? value1 : INF) > (value2 != 0 ? value2 : 0)),
value1 != 0 ? value1 : INF,
value2 != 0 ? value2 : 0,
};
}
Interval join(const Interval &left, const Interval &right) {
return Interval{
(left.minn > right.maxx) & (left.flag == 1) & (right.flag == 1),
min(left.minn, right.minn),
max(left.maxx, right.maxx),
};
}
void update(int nod, int st, int dr, int index) {
if (st == dr) {
if (a[st].size() == 0) {
if (b[st].size() == 0)
arbint[nod] = create(0, 0);
else
arbint[nod] = create(0, *(b[st].rbegin()));
} else {
if (b[st].size() == 0)
arbint[nod] = create(*a[st].begin(), 0);
else
arbint[nod] = create(*a[st].begin(), *(b[st].rbegin()));
}
} else {
int mij = (st + dr) / 2;
if (index <= mij)
update(2 * nod, st, mij, index);
else
update(2 * nod + 1, mij + 1, dr, index);
arbint[nod] = join(arbint[2 * nod], arbint[2 * nod + 1]);
}
}
void update(int index) { update(1, 1, n, index); }
Interval query(int nod, int st, int dr, int left, int right) {
if (st == left && dr == right)
return arbint[nod];
else {
int mij = (st + dr) / 2;
if (right <= mij)
return query(2 * nod, st, mij, left, right);
else {
if (mij < left)
return query(2 * nod + 1, mij + 1, dr, left, right);
else
return join(query(2 * nod, st, mij, left, mij),
query(2 * nod + 1, mij + 1, dr, mij + 1, right));
}
}
}
Interval query(int left, int right) { return query(1, 1, n, left, right); }
int main() {
int m, q, i, x, y;
scanf("%d%d%d", &n, &m, &q);
n *= 2;
for (i = 1; i <= 4 * n; i++) {
arbint[i].minn = INF;
arbint[i].flag = 1;
}
for (i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
set<int>::iterator it;
if (x % 2 == 1 && y % 2 == 1) {
it = a[x].find(y);
if (it != a[x].end()) {
a[x].erase(it);
update(x);
} else {
a[x].insert(y);
update(x);
}
} else {
it = b[x - 1].find(y);
if (it != b[x - 1].end()) {
b[x - 1].erase(it);
update(x - 1);
} else {
b[x - 1].insert(y);
update(x - 1);
}
}
if (arbint[1].flag == 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Mr. Kitayuta has kindly given you a string s consisting of lowercase English letters. You are asked to insert exactly n lowercase English letters into s to make it a palindrome. (A palindrome is a string that reads the same forward and backward. For example, "noon", "testset" and "a" are all palindromes, while "test" and "kitayuta" are not.) You can choose any n lowercase English letters, and insert each of them to any position of s, possibly to the beginning or the end of s. You have to insert exactly n letters even if it is possible to turn s into a palindrome by inserting less than n letters.
Find the number of the palindromes that can be obtained in this way, modulo 10007.
Input
The first line contains a string s (1 ≤ |s| ≤ 200). Each character in s is a lowercase English letter.
The second line contains an integer n (1 ≤ n ≤ 109).
Output
Print the number of the palindromes that can be obtained, modulo 10007.
Examples
Input
revive
1
Output
1
Input
add
2
Output
28
Note
For the first sample, you can obtain the palindrome "reviver" by inserting 'r' to the end of "revive".
For the second sample, the following 28 palindromes can be obtained: "adada", "adbda", ..., "adzda", "dadad" and "ddadd".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool solve(string a) {
int f = 0;
if (a.size() % 2) {
for (int i = 0; i < a.size() / 2; i++) {
if (a[i] != a[a.size() - 1 - i]) f = 1;
}
if (f)
return 0;
else
return 1;
} else {
for (int i = 0; i < a.size() / 2; i++) {
if (a[i] != a[a.size() - 1 - i]) f = 1;
}
if (f)
return 0;
else
return 1;
}
}
set<char> st1, st2;
int main() {
string s1;
while (cin >> s1) {
if (solve(s1)) {
if (s1.size() % 2) {
for (int i = 0; i <= s1.size() / 2; i++) {
cout << s1[i];
}
for (int i = s1.size() / 2; i < s1.size(); i++) {
cout << s1[i];
}
cout << endl;
} else {
for (int i = 0; i <= s1.size() / 2; i++) {
cout << s1[i];
}
for (int i = s1.size() / 2; i < s1.size(); i++) {
cout << s1[i];
}
cout << endl;
}
} else {
int f = 0;
string s;
for (int i = 0; i <= s1.size(); i++) {
for (int j = 0; j < 26; j++) {
s.clear();
char b = 'a' + j;
for (int k = 0; k < i; k++) s += s1[k];
s += b;
for (int k = i; k < s1.size(); k++) s += s1[k];
if (solve(s)) {
cout << s << endl;
return 0;
}
}
}
cout << "NA" << endl;
}
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Given two binary trees, we consider the “intersection” and “union” of them. Here, we distinguish the left and right child of a node when it has only one child. The definitions of them are very simple. First of all, draw a complete binary tree (a tree whose nodes have either 0 or 2 children and leaves have the same depth) with sufficiently large depth. Then, starting from its root, write on it a number, say, 1 for each position of first tree, and draw different number, say, 2 for second tree. The “intersection” of two trees is a tree with nodes numbered both 1 and 2, and the “union” is a tree with nodes numbered either 1 or 2, or both. For example, the intersection of trees in Figures 1 and 2 is a tree in Figure 3, and the union of them is a tree in Figure 4.
<image>
A node of a tree is expressed by a sequence of characters, “(,)“. If a node has a left child, the expression of the child is inserted between ’(’ and ’,’. The expression of a right child is inserted between ’,’ and ’)’. For exam- ple, the expression of trees in Figures 1 and 2 are “((,),(,))“ and “((,(,)),)“, respectively.
Input
Each line of the input contains an operation. An operation starts with a character which specifies the type of operation, either ’i’ or ’u’: ’i’ means intersection, and ’u’ means union. Following the character and a space, two tree expressions are given, separated by a space. It is assumed that 1 <= #nodes in a tree <= 100, and no tree expression contains spaces and syntax errors. Input is terminated by EOF.
Output
For each line of the input, output a tree expression, without any space, for the result of the operation.
Example
Input
i ((,),(,)) ((,(,)),)
u ((,),(,)) ((,(,)),)
Output
((,),)
((,(,)),(,))
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <numeric>
#include <cctype>
#include <tuple>
#ifdef _MSC_VER
#include <agents.h>
#endif
#define FOR(i, a, b) for(int i = (a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define REV(v) rbegin(v), rend(v)
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define X first
#define Y second
using namespace std;
string tree(const string &s, int &pos){
string chl, chr;
++pos;
if (s[pos] == '(') chl = tree(s, pos);
++pos;
if (s[pos] == '(') chr = tree(s, pos);
++pos;
return "(" + chl + "," + chr + ")";
}
char c;
string a, b;
int p1, p2;
string AND(){
++p1, ++p2;
string chl, chr;
if (a[p1] == '(' && b[p2] == '('){
chl = AND();
}
else if (a[p1] == '('){
tree(a, p1);
}
else if (b[p2] == '('){
tree(b, p2);
}
++p1, ++p2;
if (a[p1] == '(' && b[p2] == '('){
chr = AND();
}
else if (a[p1] == '('){
tree(a, p1);
}
else if (b[p2] == '('){
tree(b, p2);
}
++p1, ++p2;
return "(" + chl + "," + chr + ")";
}
string OR(){
++p1, ++p2;
string chl, chr;
if (a[p1] == '(' && b[p2] == '('){
chl = OR();
}
else if (a[p1] == '('){
chl = tree(a, p1);
}
else if (b[p2] == '('){
chl = tree(b, p2);
}
++p1, ++p2;
if (a[p1] == '(' && b[p2] == '('){
chr = OR();
}
else if (a[p1] == '('){
chr = tree(a, p1);
}
else if (b[p2] == '('){
chr = tree(b, p2);
}
++p1, ++p2;
return "(" + chl + "," + chr + ")";
}
int main(){
while (cin >> c >> a >> b){
p1 = p2 = 0;
if (c == 'i') cout << AND() << endl;
else cout << OR() << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Bob got a job as a system administrator in X corporation. His first task was to connect n servers with the help of m two-way direct connection so that it becomes possible to transmit data from one server to any other server via these connections. Each direct connection has to link two different servers, each pair of servers should have at most one direct connection. Y corporation, a business rival of X corporation, made Bob an offer that he couldn't refuse: Bob was asked to connect the servers in such a way, that when server with index v fails, the transmission of data between some other two servers becomes impossible, i.e. the system stops being connected. Help Bob connect the servers.
Input
The first input line contains 3 space-separated integer numbers n, m, v (3 ≤ n ≤ 105, 0 ≤ m ≤ 105, 1 ≤ v ≤ n), n — amount of servers, m — amount of direct connections, v — index of the server that fails and leads to the failure of the whole system.
Output
If it is impossible to connect the servers in the required way, output -1. Otherwise output m lines with 2 numbers each — description of all the direct connections in the system. Each direct connection is described by two numbers — indexes of two servers, linked by this direct connection. The servers are numbered from 1. If the answer is not unique, output any.
Examples
Input
5 6 3
Output
1 2
2 3
3 4
4 5
1 3
3 5
Input
6 100 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, v;
vector<pair<long long, long long> > a;
long long f(long long x) {
if (x == 1) return v;
if (x == v) return 1;
return x;
}
int main() {
cin >> n >> m >> v;
long long max_edge = (((n - 1) * (n - 2)) / 2) + 1;
if ((max_edge < m) || (n - 1 > m))
cout << "-1" << endl;
else {
bool flag = 1;
a.push_back(make_pair(1, n));
for (long long i = 1; (i < n - 1) && flag; i++) {
for (long long j = i + 1; (j <= n - 1) && flag; j++) {
a.push_back(make_pair(i, j));
if (a.size() == m) flag = 0;
}
}
for (long long i = 0; i < a.size(); i++) {
cout << f(a[i].first) << " " << f(a[i].second) << endl;
}
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int C1, C2, C3;
while(cin >> C1 >> C2 >> C3){
int sum = C1 + C2;
int num[11] = {0};
num[C1] = num[C2] = num[C3] = 1;
int cnt = 0;
for(int i=1;i<=10;i++){
if(num[i] == 0){
if(sum+i <= 20) cnt++;
}
}
if((double)cnt/7 >= 0.5) cout << "YES" << endl;
else cout << "NO" << endl;
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Let's assume that set S consists of m distinct intervals [l1, r1], [l2, r2], ..., [lm, rm] (1 ≤ li ≤ ri ≤ n; li, ri are integers).
Let's assume that f(S) is the maximum number of intervals that you can choose from the set S, such that every two of them do not intersect. We assume that two intervals, [l1, r1] and [l2, r2], intersect if there is an integer x, which meets two inequalities: l1 ≤ x ≤ r1 and l2 ≤ x ≤ r2.
Sereja wonders, how many sets S are there, such that f(S) = k? Count this number modulo 1000000007 (109 + 7).
Input
The first line contains integers n, k (1 ≤ n ≤ 500; 0 ≤ k ≤ 500).
Output
In a single line, print the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 1
Output
23
Input
3 2
Output
32
Input
2 0
Output
1
Input
2 2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Mo = (int)1e9 + 7;
const int Maxn = 1000005;
int i, j, m, n, p, k;
int Two[10000010];
int f[505][505];
int main() {
scanf("%d%d", &n, &k);
Two[0] = 1;
for (i = 1; i <= Maxn; i++) Two[i] = 1ll * Two[i - 1] * 2ll % Mo;
for (i = 0; i <= n; i++) f[i][0] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= min(i, k); j++)
for (p = j - 1; p <= i; p++)
(f[i][j] += 1ll * f[p][j - 1] * (Two[i - p] - 1 + Mo) % Mo *
Two[(i - p) * p] % Mo) %= Mo;
printf("%d\n", f[n][k]);
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
T is playing a game with his friend, HL.
There are n piles of stones, the i-th pile initially has a_i stones.
T and HL will take alternating turns, with T going first. In each turn, a player chooses a non-empty pile and then removes a single stone from it. However, one cannot choose a pile that has been chosen in the previous turn (the pile that was chosen by the other player, or if the current turn is the first turn then the player can choose any non-empty pile). The player who cannot choose a pile in his turn loses, and the game ends.
Assuming both players play optimally, given the starting configuration of t games, determine the winner of each game.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 100) — the number of games. The description of the games follows. Each description contains two lines:
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of piles.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100).
Output
For each game, print on a single line the name of the winner, "T" or "HL" (without quotes)
Example
Input
2
1
2
2
1 1
Output
T
HL
Note
In the first game, T removes a single stone from the only pile in his first turn. After that, although the pile still contains 1 stone, HL cannot choose from this pile because it has been chosen by T in the previous turn. Therefore, T is the winner.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a, b, m, n, k;
int p[101];
int main() {
scanf("%d", &a);
for (int i = 0; i < a; i++) {
scanf("%d", &b);
for (int j = 0; j < b; j++) {
scanf("%d", &p[j]);
}
std::sort(p, p + b);
for (int j = 0; j < b - 1; j++) {
m += p[j];
}
if (m < p[b - 1]) {
printf("T\n");
} else if (m == p[b - 1]) {
printf("HL\n");
} else {
n = m + p[b - 1];
if (n % 2 == 0) {
printf("HL\n");
} else {
printf("T\n");
}
}
for (int j = 0; j < b; j++) {
p[j] = 0;
}
m = 0;
n = 0;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Bob is playing a game of Spaceship Solitaire. The goal of this game is to build a spaceship. In order to do this, he first needs to accumulate enough resources for the construction. There are n types of resources, numbered 1 through n. Bob needs at least a_i pieces of the i-th resource to build the spaceship. The number a_i is called the goal for resource i.
Each resource takes 1 turn to produce and in each turn only one resource can be produced. However, there are certain milestones that speed up production. Every milestone is a triple (s_j, t_j, u_j), meaning that as soon as Bob has t_j units of the resource s_j, he receives one unit of the resource u_j for free, without him needing to spend a turn. It is possible that getting this free resource allows Bob to claim reward for another milestone. This way, he can obtain a large number of resources in a single turn.
The game is constructed in such a way that there are never two milestones that have the same s_j and t_j, that is, the award for reaching t_j units of resource s_j is at most one additional resource.
A bonus is never awarded for 0 of any resource, neither for reaching the goal a_i nor for going past the goal — formally, for every milestone 0 < t_j < a_{s_j}.
A bonus for reaching certain amount of a resource can be the resource itself, that is, s_j = u_j.
Initially there are no milestones. You are to process q updates, each of which adds, removes or modifies a milestone. After every update, output the minimum number of turns needed to finish the game, that is, to accumulate at least a_i of i-th resource for each i ∈ [1, n].
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of types of resources.
The second line contains n space separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), the i-th of which is the goal for the i-th resource.
The third line contains a single integer q (1 ≤ q ≤ 10^5) — the number of updates to the game milestones.
Then q lines follow, the j-th of which contains three space separated integers s_j, t_j, u_j (1 ≤ s_j ≤ n, 1 ≤ t_j < a_{s_j}, 0 ≤ u_j ≤ n). For each triple, perform the following actions:
* First, if there is already a milestone for obtaining t_j units of resource s_j, it is removed.
* If u_j = 0, no new milestone is added.
* If u_j ≠ 0, add the following milestone: "For reaching t_j units of resource s_j, gain one free piece of u_j."
* Output the minimum number of turns needed to win the game.
Output
Output q lines, each consisting of a single integer, the i-th represents the answer after the i-th update.
Example
Input
2
2 3
5
2 1 1
2 2 1
1 1 1
2 1 2
2 2 0
Output
4
3
3
2
3
Note
After the first update, the optimal strategy is as follows. First produce 2 once, which gives a free resource 1. Then, produce 2 twice and 1 once, for a total of four turns.
After the second update, the optimal strategy is to produce 2 three times — the first two times a single unit of resource 1 is also granted.
After the third update, the game is won as follows.
* First produce 2 once. This gives a free unit of 1. This gives additional bonus of resource 1. After the first turn, the number of resources is thus [2, 1].
* Next, produce resource 2 again, which gives another unit of 1.
* After this, produce one more unit of 2.
The final count of resources is [3, 3], and three turns are needed to reach this situation. Notice that we have more of resource 1 than its goal, which is of no use.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target(sse, sse2, sse3, ssse3, sse4, popcnt, tune = native)
using namespace std;
const long long inf = 2e9 + 47, MAXN = 3e5 + 47;
long long n, m;
vector<long long> val;
void solve() {
cin >> n;
val.resize(n);
for (long long i = 0; i < n; i++) cin >> val[i];
cin >> m;
map<pair<long long, long long>, long long> was;
vector<long long> cnt(n, 0);
long long ans = 0;
for (long long i = 0; i < n; i++) {
cnt[i] = val[i];
ans += cnt[i];
}
for (long long i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
a--, c--;
if (was.find({a, b}) != was.end()) {
long long k = was[{a, b}];
cnt[k]++;
if (cnt[k] > 0) ans++;
was.erase({a, b});
}
if (c != -1) {
was[{a, b}] = c;
cnt[c]--;
if (cnt[c] >= 0) ans--;
}
cout << ans << endl;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
solve();
}
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 ≤ a1 ≤ a2 ≤ ... ≤ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 ≤ ai ≤ 109; ai ≤ ai + 1).
The next line contains integer m (1 ≤ m ≤ 105) — the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 ≤ wi ≤ n; 1 ≤ hi ≤ 109) — the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers — for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100001], i, ans, q, w, h;
long long int max_occ = 1, max[100001], max_h;
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
max[i] = a[i];
}
max_h = a[1];
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d%d", &w, &h);
if (max_h > a[w]) {
cout << max_h << endl;
max_h += h;
} else {
cout << a[w] << endl;
long long int temp = a[w];
max_h = temp + h;
}
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Let's arrange a deck of cards. Your task is to sort totally n cards. A card consists of a part of a suit (S, H, C or D) and an number. Write a program which sorts such cards based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Quicksort(A, p, r)
1 if p < r
2 then q = Partition(A, p, r)
3 run Quicksort(A, p, q-1)
4 run Quicksort(A, q+1, r)
Here, A is an array which represents a deck of cards and comparison operations are performed based on the numbers.
Your program should also report the stability of the output for the given input (instance). Here, 'stability of the output' means that: cards with the same value appear in the output in the same order as they do in the input (instance).
Constraints
* 1 ≤ n ≤ 100,000
* 1 ≤ the number of a card ≤ 109
* There are no identical card in the input
Input
The first line contains an integer n, the number of cards.
n cards are given in the following lines. Each card is given in a line and represented by a pair of a character and an integer separated by a single space.
Output
In the first line, print the stability ("Stable" or "Not stable") of this output.
In the following lines, print the arranged cards in the same manner of that of the input.
Examples
Input
6
D 3
H 2
D 1
S 3
D 2
C 1
Output
Not stable
D 1
C 1
D 2
H 2
D 3
S 3
Input
2
S 1
H 1
Output
Stable
S 1
H 1
### Response
```cpp
#include<algorithm>
template<class T>
int partition(T &A, int first, int last){
const int pivot = A[last-1].second;
int bound = first-1;
for(int i=first;i<last;++i)
if(A[i].second<=pivot) std::swap(A[++bound], A[i]);
return bound;
}
template<class T>
void quickSort(T &A, int first, int last){
if(last-first<2) return;
const int bound = partition(A,first,last);
quickSort(A,first,bound);
quickSort(A,bound,last);
}
#include<iostream>
#include<vector>
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin>>N;
vector<pair<char,int>> A(N),B(N);
for(int i=0;i<N;++i) cin>>A[i].first>>A[i].second;
copy(A.begin(),A.end(),B.begin());
quickSort(A,0,N);
stable_sort(B.begin(),B.end(),[](pair<char,int>a,pair<char,int>b){return a.second<b.second;});
cout<<(mismatch(A.begin(),A.end(),B.begin()).first==A.end()?"Stable":"Not stable")<<endl;
for(auto &a:A) cout<<a.first<<' '<<a.second<<endl;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Alice and Bob like games. And now they are ready to start a new game. They have placed n chocolate bars in a line. Alice starts to eat chocolate bars one by one from left to right, and Bob — from right to left. For each chocololate bar the time, needed for the player to consume it, is known (Alice and Bob eat them with equal speed). When the player consumes a chocolate bar, he immediately starts with another. It is not allowed to eat two chocolate bars at the same time, to leave the bar unfinished and to make pauses. If both players start to eat the same bar simultaneously, Bob leaves it to Alice as a true gentleman.
How many bars each of the players will consume?
Input
The first line contains one integer n (1 ≤ n ≤ 105) — the amount of bars on the table. The second line contains a sequence t1, t2, ..., tn (1 ≤ ti ≤ 1000), where ti is the time (in seconds) needed to consume the i-th bar (in the order from left to right).
Output
Print two numbers a and b, where a is the amount of bars consumed by Alice, and b is the amount of bars consumed by Bob.
Examples
Input
5
2 9 8 2 7
Output
2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 2e5 + 10;
int lsum[N];
int rsum[N];
int a[N];
int main() {
memset((lsum), (0), sizeof(lsum));
memset((rsum), (0), sizeof(rsum));
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) lsum[i] = a[i] + lsum[i - 1];
for (int i = n; i >= 1; i--) rsum[i] = a[i] + rsum[i + 1];
int key = 1;
for (int i = 1; i <= n; i++) {
if (lsum[i] <= rsum[i]) key = i;
}
cout << key << ' ' << n - key << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
A tree is an undirected connected graph without cycles. The distance between two vertices is the number of edges in a simple path between them.
Limak is a little polar bear. He lives in a tree that consists of n vertices, numbered 1 through n.
Limak recently learned how to jump. He can jump from a vertex to any vertex within distance at most k.
For a pair of vertices (s, t) we define f(s, t) as the minimum number of jumps Limak needs to get from s to t. Your task is to find the sum of f(s, t) over all pairs of vertices (s, t) such that s < t.
Input
The first line of the input contains two integers n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ 5) — the number of vertices in the tree and the maximum allowed jump distance respectively.
The next n - 1 lines describe edges in the tree. The i-th of those lines contains two integers ai and bi (1 ≤ ai, bi ≤ n) — the indices on vertices connected with i-th edge.
It's guaranteed that the given edges form a tree.
Output
Print one integer, denoting the sum of f(s, t) over all pairs of vertices (s, t) such that s < t.
Examples
Input
6 2
1 2
1 3
2 4
2 5
4 6
Output
20
Input
13 3
1 2
3 2
4 2
5 2
3 6
10 6
6 7
6 13
5 8
5 9
9 11
11 12
Output
114
Input
3 5
2 1
3 1
Output
3
Note
In the first sample, the given tree has 6 vertices and it's displayed on the drawing below. Limak can jump to any vertex within distance at most 2. For example, from the vertex 5 he can jump to any of vertices: 1, 2 and 4 (well, he can also jump to the vertex 5 itself).
<image>
There are <image> pairs of vertices (s, t) such that s < t. For 5 of those pairs Limak would need two jumps: (1, 6), (3, 4), (3, 5), (3, 6), (5, 6). For other 10 pairs one jump is enough. So, the answer is 5·2 + 10·1 = 20.
In the third sample, Limak can jump between every two vertices directly. There are 3 pairs of vertices (s < t), so the answer is 3·1 = 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int n, k;
long long dp[maxn][6], ans;
long long segment[maxn], sonNumber[maxn];
vector<int> G[maxn];
void dfs(int u, int fa) {
sonNumber[u] = 1;
dp[u][0] = 1;
int Size = G[u].size();
for (int i = 0; i < Size; i++) {
int to = G[u][i];
if (to == fa) continue;
dfs(to, u);
ans += segment[to] * sonNumber[u] + segment[u] * sonNumber[to];
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
ans += dp[u][i] * dp[to][j];
if (i + j >= k) ans += dp[u][i] * dp[to][j];
}
}
sonNumber[u] += sonNumber[to];
segment[u] += segment[to];
segment[u] += dp[to][k - 1];
for (int i = 0; i < k; i++) dp[u][(i + 1) % k] += dp[to][i];
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int e, s;
scanf("%d%d", &e, &s);
G[e].push_back(s);
G[s].push_back(e);
}
ans = 0;
dfs(1, 0);
printf("%I64d\n", ans);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Vasya has the square chessboard of size n × n and m rooks. Initially the chessboard is empty. Vasya will consequently put the rooks on the board one after another.
The cell of the field is under rook's attack, if there is at least one rook located in the same row or in the same column with this cell. If there is a rook located in the cell, this cell is also under attack.
You are given the positions of the board where Vasya will put rooks. For each rook you have to determine the number of cells which are not under attack after Vasya puts it on the board.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 100 000, 1 ≤ m ≤ min(100 000, n2)) — the size of the board and the number of rooks.
Each of the next m lines contains integers xi and yi (1 ≤ xi, yi ≤ n) — the number of the row and the number of the column where Vasya will put the i-th rook. Vasya puts rooks on the board in the order they appear in the input. It is guaranteed that any cell will contain no more than one rook.
Output
Print m integer, the i-th of them should be equal to the number of cells that are not under attack after first i rooks are put.
Examples
Input
3 3
1 1
3 1
2 2
Output
4 2 0
Input
5 2
1 5
5 1
Output
16 9
Input
100000 1
300 400
Output
9999800001
Note
On the picture below show the state of the board after put each of the three rooks. The cells which painted with grey color is not under the attack.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, tot, x, y;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
tot = n * n;
map<long long, long long> mr;
map<long long, long long> mc;
vector<long long> v;
long long sr = 0, sc = 0;
while (m--) {
cin >> x >> y;
if (mr[x] == 1 && mc[y] == 1) {
} else if (mr[x] == 1) {
if (tot > 0) {
tot = (tot - n) + 1 + (sr - 1);
}
sc++;
mc[y]++;
} else if (mc[y] == 1) {
if (tot > 0) {
tot = (tot - n) + 1 + (sc - 1);
}
sr++;
mr[x]++;
} else {
if (tot > 0) {
tot = ((tot - (n + n)) + 1) + sr + sc;
}
sr++;
sc++;
mr[x]++;
mc[y]++;
}
v.push_back(tot);
}
for (long long i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
There are n people and k keys on a straight line. Every person wants to get to the office which is located on the line as well. To do that, he needs to reach some point with a key, take the key and then go to the office. Once a key is taken by somebody, it couldn't be taken by anybody else.
You are to determine the minimum time needed for all n people to get to the office with keys. Assume that people move a unit distance per 1 second. If two people reach a key at the same time, only one of them can take the key. A person can pass through a point with a key without taking it.
Input
The first line contains three integers n, k and p (1 ≤ n ≤ 1 000, n ≤ k ≤ 2 000, 1 ≤ p ≤ 109) — the number of people, the number of keys and the office location.
The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 109) — positions in which people are located initially. The positions are given in arbitrary order.
The third line contains k distinct integers b1, b2, ..., bk (1 ≤ bj ≤ 109) — positions of the keys. The positions are given in arbitrary order.
Note that there can't be more than one person or more than one key in the same point. A person and a key can be located in the same point.
Output
Print the minimum time (in seconds) needed for all n to reach the office with keys.
Examples
Input
2 4 50
20 100
60 10 40 80
Output
50
Input
1 2 10
11
15 7
Output
7
Note
In the first example the person located at point 20 should take the key located at point 40 and go with it to the office located at point 50. He spends 30 seconds. The person located at point 100 can take the key located at point 80 and go to the office with it. He spends 50 seconds. Thus, after 50 seconds everybody is in office with keys.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, p;
cin >> n >> k >> p;
int a[n], b[k];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
int ans = INT_MAX;
for (int i = 0; i < k - n + 1; i++) {
int cur = 0;
for (int j = 0; j < n; j++)
cur = max(cur, abs(a[j] - b[i + j]) + abs(b[i + j] - p));
ans = min(ans, cur);
}
cout << ans << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There are n models in the shop numbered from 1 to n, with sizes s_1, s_2, …, s_n.
Orac will buy some of the models and will arrange them in the order of increasing numbers (i.e. indices, but not sizes).
Orac thinks that the obtained arrangement is beatiful, if for any two adjacent models with indices i_j and i_{j+1} (note that i_j < i_{j+1}, because Orac arranged them properly), i_{j+1} is divisible by i_j and s_{i_j} < s_{i_{j+1}}.
For example, for 6 models with sizes \{3, 6, 7, 7, 7, 7\}, he can buy models with indices 1, 2, and 6, and the obtained arrangement will be beautiful. Also, note that the arrangement with exactly one model is also considered beautiful.
Orac wants to know the maximum number of models that he can buy, and he may ask you these queries many times.
Input
The first line contains one integer t\ (1 ≤ t≤ 100): the number of queries.
Each query contains two lines. The first line contains one integer n\ (1≤ n≤ 100 000): the number of models in the shop, and the second line contains n integers s_1,...,s_n\ (1≤ s_i≤ 10^9): the sizes of models.
It is guaranteed that the total sum of n is at most 100 000.
Output
Print t lines, the i-th of them should contain the maximum number of models that Orac can buy for the i-th query.
Example
Input
4
4
5 3 4 6
7
1 4 2 3 6 4 9
5
5 4 3 2 1
1
9
Output
2
3
1
1
Note
In the first query, for example, Orac can buy models with indices 2 and 4, the arrangement will be beautiful because 4 is divisible by 2 and 6 is more than 3. By enumerating, we can easily find that there are no beautiful arrangements with more than two models.
In the second query, Orac can buy models with indices 1, 3, and 6. By enumerating, we can easily find that there are no beautiful arrangements with more than three models.
In the third query, there are no beautiful arrangements with more than one model.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int tt, n, ans;
cin >> tt;
while (tt--) {
cin >> n;
vector<int> v(n + 1), cnt(n + 1, 1);
for (int i = 1; i <= n; i++) cin >> v[i];
ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + i; j <= n; j += i) {
if (v[i] < v[j]) cnt[j] = max(cnt[j], cnt[i] + 1);
}
ans = max(ans, cnt[i]);
}
cout << ans << '\n';
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Celebrating the new year, many people post videos of falling dominoes; Here's a list of them: https://www.youtube.com/results?search_query=New+Years+Dominos
User ainta, who lives in a 2D world, is going to post a video as well.
There are n dominoes on a 2D Cartesian plane. i-th domino (1 ≤ i ≤ n) can be represented as a line segment which is parallel to the y-axis and whose length is li. The lower point of the domino is on the x-axis. Let's denote the x-coordinate of the i-th domino as pi. Dominoes are placed one after another, so p1 < p2 < ... < pn - 1 < pn holds.
User ainta wants to take a video of falling dominoes. To make dominoes fall, he can push a single domino to the right. Then, the domino will fall down drawing a circle-shaped orbit until the line segment totally overlaps with the x-axis.
<image>
Also, if the s-th domino touches the t-th domino while falling down, the t-th domino will also fall down towards the right, following the same procedure above. Domino s touches domino t if and only if the segment representing s and t intersects.
<image>
See the picture above. If he pushes the leftmost domino to the right, it falls down, touching dominoes (A), (B) and (C). As a result, dominoes (A), (B), (C) will also fall towards the right. However, domino (D) won't be affected by pushing the leftmost domino, but eventually it will fall because it is touched by domino (C) for the first time.
<image>
The picture above is an example of falling dominoes. Each red circle denotes a touch of two dominoes.
User ainta has q plans of posting the video. j-th of them starts with pushing the xj-th domino, and lasts until the yj-th domino falls. But sometimes, it could be impossible to achieve such plan, so he has to lengthen some dominoes. It costs one dollar to increase the length of a single domino by 1. User ainta wants to know, for each plan, the minimum cost needed to achieve it. Plans are processed independently, i. e. if domino's length is increased in some plan, it doesn't affect its length in other plans. Set of dominos that will fall except xj-th domino and yj-th domino doesn't matter, but the initial push should be on domino xj.
Input
The first line contains an integer n (2 ≤ n ≤ 2 × 105)— the number of dominoes.
Next n lines describe the dominoes. The i-th line (1 ≤ i ≤ n) contains two space-separated integers pi, li (1 ≤ pi, li ≤ 109)— the x-coordinate and the length of the i-th domino. It is guaranteed that p1 < p2 < ... < pn - 1 < pn.
The next line contains an integer q (1 ≤ q ≤ 2 × 105) — the number of plans.
Next q lines describe the plans. The j-th line (1 ≤ j ≤ q) contains two space-separated integers xj, yj (1 ≤ xj < yj ≤ n). It means the j-th plan is, to push the xj-th domino, and shoot a video until the yj-th domino falls.
Output
For each plan, print a line containing the minimum cost needed to achieve it. If no cost is needed, print 0.
Examples
Input
6
1 5
3 3
4 4
9 2
10 1
12 1
4
1 2
2 4
2 5
2 6
Output
0
1
1
2
Note
Consider the example. The dominoes are set like the picture below.
<image>
Let's take a look at the 4th plan. To make the 6th domino fall by pushing the 2nd domino, the length of the 3rd domino (whose x-coordinate is 4) should be increased by 1, and the 5th domino (whose x-coordinate is 9) should be increased by 1 (other option is to increase 4th domino instead of 5th also by 1). Then, the dominoes will fall like in the picture below. Each cross denotes a touch between two dominoes.
<image> <image> <image> <image> <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} debug1;
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
const int NN = (1 << 18);
const int inf = numeric_limits<int>::max();
int seg[NN << 1], lazy[NN << 1];
int cnt[NN << 1];
int bit[NN];
vector<pair<int, int>> adj[NN];
int out[NN], x[NN], len[NN];
void update(int i, int v) {
for (i += 5; i < NN; i += i & -i) bit[i] += v;
}
int query(int i) {
int ans = 0;
for (i += 5; i > 0; i -= i & -i) ans += bit[i];
return ans;
}
void pushdown(int node, int st, int en) {
if (!lazy[node]) return;
seg[node] = max(seg[node], lazy[node]);
if (st != en) {
lazy[2 * node] = max(lazy[2 * node], lazy[node]);
lazy[2 * node + 1] = max(lazy[2 * node + 1], lazy[node]);
}
lazy[node] = 0;
}
void update(int node, int st, int en, int L, int R, int vv) {
pushdown(node, st, en);
if (st > en or st > R or en < L) return;
if (st >= L and en <= R) {
lazy[node] = max(lazy[node], vv);
pushdown(node, st, en);
return;
}
int mid = (st + en) / 2;
update(2 * node, st, mid, L, R, vv);
update(2 * node + 1, mid + 1, en, L, R, vv);
}
int query(int node, int st, int en, int pos) {
pushdown(node, st, en);
if (st == en) return seg[node];
int mid = (st + en) / 2;
if (mid >= pos) return query(2 * node, st, mid, pos);
return query(2 * node + 1, mid + 1, en, pos);
}
void solve() {
int n, m;
cin >> n;
for (int i = 0; i < n; ++i) cin >> x[i] >> len[i];
cin >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
adj[b].push_back({a, i});
}
update(1, 0, n - 1, 0, 0, x[0] + len[0]);
for (int i = 1; i < n; ++i) {
int st = 0, en = i - 1;
int res = NN;
while (st <= en) {
int mid = (st + en) / 2;
if (query(1, 0, n - 1, mid) < x[i]) {
res = mid;
en = mid - 1;
} else
st = mid + 1;
}
while (res < i) {
int vv = query(1, 0, n - 1, res);
st = res, en = i - 1;
int tmp = i;
while (st <= en) {
int mid = (st + en) / 2;
if (query(1, 0, n - 1, mid) < vv) {
tmp = mid;
en = mid - 1;
} else
st = mid + 1;
}
int add = x[i] - vv;
update(res, add);
update(tmp, -add);
res = tmp;
}
update(1, 0, n - 1, 0, i, x[i] + len[i]);
for (auto tmp : adj[i]) {
int bg = tmp.first;
int k = tmp.second;
out[k] = query(bg);
}
}
for (int i = 0; i < m; ++i) cout << out[i] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n < 3 || n == 4)
cout << -1 << endl;
else {
int a = n % 7;
if (a == 0)
cout << "0 0 " << n / 7 << endl;
else if (a == 1)
cout << "1 1 " << n / 7 - 1 << endl;
else if (a == 2)
cout << "3 0 " << n / 7 - 1 << endl;
else if (a == 3)
cout << "1 0 " << n / 7 << endl;
else if (a == 4)
cout << "2 1 " << n / 7 - 1 << endl;
else if (a == 5)
cout << "0 1 " << n / 7 << endl;
else
cout << "2 0 " << n / 7 << endl;
}
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given an integer N that has exactly four digits in base ten. How many times does `2` occur in the base-ten representation of N?
Constraints
* 1000 \leq N \leq 9999
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
1222
Output
3
Input
3456
Output
0
Input
9592
Output
1
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int l = 0;
for (auto c : s) l += c == '2';
cout << l << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1·2.5 + a2·0 + a3·2.5 = 6·2.5 + 1·0 + 2·2.5 = 20 and b1·2.5 + b2·0 + b3·2.5 = 2·2.5 + 3·0 + 6·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 ≤ n ≤ 100 000, 1 ≤ p, q ≤ 1 000 000) — the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 1 000 000) — the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value — the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
long double p, q;
long double a[N], b[N];
inline long double F(long double x) {
long double y = 1e130;
for (int i = 1; i <= n; i++) y = min(y, (1.0 - a[i] * x) / b[i]);
return p * x + q * y;
}
int main() {
double _p, _q, _a, _b;
scanf("%d%lf%lf", &n, &_p, &_q), p = _p, q = _q;
for (int i = 1; i <= n; i++) scanf("%lf%lf", &_a, &_b), a[i] = _a, b[i] = _b;
long double L = 0, R = 1e130, m1, m2;
for (int i = 1; i <= n; i++) R = min(R, 1.0 / a[i]);
while (R - L > 1e-15)
if (F(m1 = L + (R - L) / 3.0) < F(m2 = R - (R - L) / 3.0))
L = m1;
else
R = m2;
printf("%.15lf\n", (double)F((R + L) / 2));
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
The Little Elephant loves numbers.
He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations.
Help the Little Elephant to find the described number.
Input
A single line contains a single integer x (1 ≤ x ≤ 109).
Output
In a single line print an integer — the answer to the problem.
Examples
Input
1
Output
1
Input
10
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool visited[10];
void solve(int n) {
while (n != 0) {
visited[n % 10] = 1;
n /= 10;
}
}
bool check(int y) {
while (y != 0) {
if (visited[y % 10]) {
return 1;
}
y /= 10;
}
return 0;
}
int main() {
int n, c = 0, k = 0;
cin >> n;
solve(n);
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (check(i)) {
c++;
}
if (i * i != n) {
if (check(n / i)) {
c++;
}
}
}
}
cout << c << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
You are taking a computer-based examination. The examination consists of N questions, and the score allocated to the i-th question is s_i. Your answer to each question will be judged as either "correct" or "incorrect", and your grade will be the sum of the points allocated to questions that are answered correctly. When you finish answering the questions, your answers will be immediately judged and your grade will be displayed... if everything goes well.
However, the examination system is actually flawed, and if your grade is a multiple of 10, the system displays 0 as your grade. Otherwise, your grade is displayed correctly. In this situation, what is the maximum value that can be displayed as your grade?
Constraints
* All input values are integers.
* 1 ≤ N ≤ 100
* 1 ≤ s_i ≤ 100
Input
Input is given from Standard Input in the following format:
N
s_1
s_2
:
s_N
Output
Print the maximum value that can be displayed as your grade.
Examples
Input
3
5
10
15
Output
25
Input
3
10
10
15
Output
35
Input
3
10
20
30
Output
0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,sum=0;cin>>n;
vector<int> s(n);
for(int i=0;i<n;i++){
cin>>s[i];
sum+=s[i];
}
sort(s.begin(),s.end());
if(sum%10==0){
for(int i=0;i<n;i++){
sum-=s[i];
if(sum%10!=0) break;
sum+=s[i];
}
}
if(sum%10==0) sum=0;
cout<<sum<<endl;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You wrote down all integers from 0 to 10^n - 1, padding them with leading zeroes so their lengths are exactly n. For example, if n = 3 then you wrote out 000, 001, ..., 998, 999.
A block in an integer x is a consecutive segment of equal digits that cannot be extended to the left or to the right.
For example, in the integer 00027734000 there are three blocks of length 1, one block of length 2 and two blocks of length 3.
For all integers i from 1 to n count the number of blocks of length i among the written down integers.
Since these integers may be too large, print them modulo 998244353.
Input
The only line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
Output
In the only line print n integers. The i-th integer is equal to the number of blocks of length i.
Since these integers may be too large, print them modulo 998244353.
Examples
Input
1
Output
10
Input
2
Output
180 10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353LL;
int n;
long long getpw(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b /= 2;
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
if (i == n) {
cout << 10 << endl;
} else {
long long res = 0LL;
if (i <= n - 2) {
res = 810LL * getpw(10, n - i - 2) % mod;
res = res * (long long)(n - i - 1) % mod;
}
long long res2 = 180LL * getpw(10, n - i - 1) % mod;
res = (res + res2) % mod;
printf("%lld ", res);
}
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Income Inequality
We often compute the average as the first step in processing statistical data. Yes, the average is a good tendency measure of data, but it is not always the best. In some cases, the average may hinder the understanding of the data.
For example, consider the national income of a country. As the term income inequality suggests, a small number of people earn a good portion of the gross national income in many countries. In such cases, the average income computes much higher than the income of the vast majority. It is not appropriate to regard the average as the income of typical people.
Let us observe the above-mentioned phenomenon in some concrete data. Incomes of n people, a1, ... , an, are given. You are asked to write a program that reports the number of people whose incomes are less than or equal to the average (a1 + ... + an) / n.
Input
The input consists of multiple datasets, each in the following format.
> n
> a1 a2 ... an
A dataset consists of two lines. In the first line, the number of people n is given. n is an integer satisfying 2 ≤ n ≤ 10 000. In the second line, incomes of n people are given. ai (1 ≤ i ≤ n) is the income of the i-th person. This value is an integer greater than or equal to 1 and less than or equal to 100 000.
The end of the input is indicated by a line containing a zero. The sum of n's of all the datasets does not exceed 50 000.
Output
For each dataset, output the number of people whose incomes are less than or equal to the average.
Sample Input
7
15 15 15 15 15 15 15
4
10 20 30 60
10
1 1 1 1 1 1 1 1 1 100
7
90 90 90 90 90 90 10
7
2 7 1 8 2 8 4
0
Output for the Sample Input
7
3
9
1
4
Example
Input
7
15 15 15 15 15 15 15
4
10 20 30 60
10
1 1 1 1 1 1 1 1 1 100
7
90 90 90 90 90 90 10
7
2 7 1 8 2 8 4
0
Output
7
3
9
1
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int64 i = 0; i < (n); i++)
using int64 = int_fast64_t;
int main(void){
cin.tie(0);
int n;
while(cin >> n && n){
int a[n];
double ave = 0;
REP(i,n){
cin >> a[i];
ave += a[i];
}
ave /= n;
int cnt = 0;
REP(i,n){
if(a[i] <= ave)cnt++;
}
cout << cnt << endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
We define the sum of prefix sums of an array [s_1, s_2, ..., s_k] as s_1 + (s_1 + s_2) + (s_1 + s_2 + s_3) + ... + (s_1 + s_2 + ... + s_k).
You are given a tree consisting of n vertices. Each vertex i has an integer a_i written on it. We define the value of the simple path from vertex u to vertex v as follows: consider all vertices appearing on the path from u to v, write down all the numbers written on these vertices in the order they appear on the path, and compute the sum of prefix sums of the resulting sequence.
Your task is to calculate the maximum value over all paths in the tree.
Input
The first line contains one integer n (2 ≤ n ≤ 150000) — the number of vertices in the tree.
Then n - 1 lines follow, representing the edges of the tree. Each line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i), denoting an edge between vertices u_i and v_i. It is guaranteed that these edges form a tree.
The last line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6).
Output
Print one integer — the maximum value over all paths in the tree.
Example
Input
4
4 2
3 2
4 1
1 3 3 7
Output
36
Note
The best path in the first example is from vertex 3 to vertex 1. It gives the sequence [3, 3, 7, 1], and the sum of prefix sums is 36.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using posteriority_queue = priority_queue<T, vector<T>, greater<T> >;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-8;
const int MOD = 1000000007;
const int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
const int dy8[] = {1, 1, 0, -1, -1, -1, 0, 1},
dx8[] = {0, -1, -1, -1, 0, 1, 1, 1};
template <typename T, typename U>
inline bool chmax(T &a, U b) {
return a < b ? (a = b, true) : false;
}
template <typename T, typename U>
inline bool chmin(T &a, U b) {
return a > b ? (a = b, true) : false;
}
template <typename T>
void unique(vector<T> &a) {
a.erase(unique((a).begin(), (a).end()), a.end());
}
struct IOSetup {
IOSetup() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} iosetup;
using CostType = ll;
struct Edge {
int src, dst;
CostType cost;
Edge(int src, int dst, CostType cost = 0) : src(src), dst(dst), cost(cost) {}
inline bool operator<(const Edge &rhs) const {
return cost != rhs.cost ? cost < rhs.cost
: dst != rhs.dst ? dst < rhs.dst
: src < rhs.src;
}
inline bool operator<=(const Edge &rhs) const { return !(rhs < *this); }
inline bool operator>(const Edge &rhs) const { return rhs < *this; }
inline bool operator>=(const Edge &rhs) const { return !(*this < rhs); }
};
struct CentroidDecomposition {
int root;
vector<vector<int> > comp;
vector<int> par;
CentroidDecomposition(const vector<vector<Edge> > &graph) : graph(graph) {
int n = graph.size();
alive.assign(n, true);
subtree.resize(n);
comp.resize(n);
par.assign(n, -1);
root = build(0);
}
private:
const vector<vector<Edge> > graph;
vector<bool> alive;
vector<int> subtree;
int build(int s) {
int centroid = search_centroid(-1, s, calc_subtree(-1, s) / 2);
alive[centroid] = false;
for (const Edge &e : graph[centroid]) {
if (alive[e.dst]) {
comp[centroid].emplace_back(build(e.dst));
par[e.dst] = centroid;
}
}
alive[centroid] = true;
return centroid;
}
int calc_subtree(int par, int ver) {
subtree[ver] = 1;
for (const Edge &e : graph[ver]) {
if (e.dst != par && alive[e.dst])
subtree[ver] += calc_subtree(ver, e.dst);
}
return subtree[ver];
}
int search_centroid(int par, int ver, int half) {
for (const Edge &e : graph[ver]) {
if (e.dst != par && alive[e.dst]) {
if (subtree[e.dst] > half) return search_centroid(ver, e.dst, half);
}
}
return ver;
}
};
template <typename T>
struct LiChaoTree {
struct Line {
T a, b;
Line(T a, T b) : a(a), b(b) {}
inline T get(T x) const { return a * x + b; }
inline bool over(const Line &b, const T &x) const {
return get(x) < b.get(x);
}
};
vector<T> xs;
vector<Line> seg;
int sz;
LiChaoTree(const vector<T> &x, T INF) : xs(x) {
sz = 1;
while (sz < xs.size()) sz <<= 1;
while (xs.size() < sz) xs.push_back(xs.back() + 1);
seg.assign(2 * sz - 1, Line(0, INF));
}
void update(Line &x, int k, int l, int r) {
int mid = (l + r) >> 1;
auto latte = x.over(seg[k], xs[l]), malta = x.over(seg[k], xs[mid]);
if (malta) swap(seg[k], x);
if (l + 1 >= r)
return;
else if (latte != malta)
update(x, 2 * k + 1, l, mid);
else
update(x, 2 * k + 2, mid, r);
}
void update(T a, T b) {
Line l(a, b);
update(l, 0, 0, sz);
}
T query(int k) {
const T x = xs[k];
k += sz - 1;
T ret = seg[k].get(x);
while (k > 0) {
k = (k - 1) >> 1;
ret = min(ret, seg[k].get(x));
}
return ret;
}
};
int main() {
int n;
cin >> n;
vector<vector<Edge> > graph(n);
for (int _ = (0); _ < (n - 1); ++_) {
int u, v;
cin >> u >> v;
--u;
--v;
graph[u].emplace_back(u, v);
graph[v].emplace_back(v, u);
}
vector<int> a(n);
for (int i = (0); i < (n); ++i) cin >> a[i];
CentroidDecomposition cent(graph);
vector<bool> visited(n, false);
ll ans = 0;
function<void(int)> dfs = [&](int root) {
visited[root] = true;
chmax(ans, a[root]);
vector<vector<ll> > sum_a, psum_a;
vector<vector<pair<ll, int> > > psum_b;
function<void(int, int, int, ll, ll, ll, int)> dfs2 =
[&](int par, int ver, int idx, ll sum, ll A, ll B, int len) {
sum += a[ver];
A += 1LL * a[ver] * len;
B += sum - a[root];
bool leaf = true;
for (const Edge &e : graph[ver]) {
if (e.dst == par || visited[e.dst]) continue;
dfs2(ver, e.dst, idx, sum, A, B, len + 1);
leaf = false;
}
if (leaf) {
sum_a[idx].emplace_back(sum);
psum_a[idx].emplace_back(A);
psum_b[idx].emplace_back(B, len - 1);
}
};
for (const Edge &e : graph[root]) {
if (visited[e.dst]) continue;
int sz = sum_a.size();
sum_a.emplace_back();
psum_a.emplace_back();
psum_b.emplace_back();
dfs2(-1, e.dst, sz, a[root], a[root], 0, 2);
}
int m = sum_a.size();
vector<ll> xs;
for (int i = (0); i < (m); ++i) {
for (ll e : sum_a[i]) xs.emplace_back(e);
for (ll e : psum_a[i]) chmax(ans, e);
for (auto pr : psum_b[i])
chmax(ans, pr.first + 1LL * a[root] * (pr.second + 1));
}
if (!xs.empty()) {
sort((xs).begin(), (xs).end());
unique(xs);
LiChaoTree<ll> lct1(xs, LINF);
for (int i = (0); i < (m); ++i) {
int sz = sum_a[i].size();
for (int j = (0); j < (sz); ++j) {
chmax(ans,
-lct1.query(lower_bound((xs).begin(), (xs).end(), sum_a[i][j]) -
xs.begin()) +
psum_a[i][j]);
}
for (int j = (0); j < (sz); ++j) {
lct1.update(-psum_b[i][j].second, -psum_b[i][j].first);
}
}
LiChaoTree<ll> lct2(xs, LINF);
for (int i = m - 1; i >= 0; --i) {
int sz = sum_a[i].size();
for (int j = (0); j < (sz); ++j)
chmax(ans,
-lct2.query(lower_bound((xs).begin(), (xs).end(), sum_a[i][j]) -
xs.begin()) +
psum_a[i][j]);
for (int j = (0); j < (sz); ++j)
lct2.update(-psum_b[i][j].second, -psum_b[i][j].first);
}
}
for (int e : cent.comp[root]) dfs(e);
};
dfs(cent.root);
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Apart from Nian, there is a daemon named Sui, which terrifies children and causes them to become sick. Parents give their children money wrapped in red packets and put them under the pillow, so that when Sui tries to approach them, it will be driven away by the fairies inside.
Big Banban is hesitating over the amount of money to give out. He considers loops to be lucky since it symbolizes unity and harmony.
He would like to find a positive integer n not greater than 1018, such that there are exactly k loops in the decimal representation of n, or determine that such n does not exist.
A loop is a planar area enclosed by lines in the digits' decimal representation written in Arabic numerals. For example, there is one loop in digit 4, two loops in 8 and no loops in 5. Refer to the figure below for all exact forms.
<image>
Input
The first and only line contains an integer k (1 ≤ k ≤ 106) — the desired number of loops.
Output
Output an integer — if no such n exists, output -1; otherwise output any such n. In the latter case, your output should be a positive decimal integer not exceeding 1018.
Examples
Input
2
Output
462
Input
6
Output
8080
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, m, n, i, j, x;
while (scanf("%lld", &k) != EOF) {
x = 0;
if (k > 36)
printf("-1\n");
else {
if (k % 2 == 1) printf("4");
for (i = 1; i <= k / 2; i++) printf("8");
printf("\n");
}
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya got an array consisting of n numbers, it is the gift for his birthday. Now he wants to sort it in the non-decreasing order. However, a usual sorting is boring to perform, that's why Petya invented the following limitation: one can swap any two numbers but only if at least one of them is lucky. Your task is to sort the array according to the specified limitation. Find any possible sequence of the swaps (the number of operations in the sequence should not exceed 2n).
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n positive integers, not exceeding 109 — the array that needs to be sorted in the non-decreasing order.
Output
On the first line print number k (0 ≤ k ≤ 2n) — the number of the swaps in the sorting. On the following k lines print one pair of distinct numbers (a pair per line) — the indexes of elements to swap. The numbers in the array are numbered starting from 1. If it is impossible to sort the given sequence, print the single number -1.
If there are several solutions, output any. Note that you don't have to minimize k. Any sorting with no more than 2n swaps is accepted.
Examples
Input
2
4 7
Output
0
Input
3
4 2 1
Output
1
1 3
Input
7
77 66 55 44 33 22 11
Output
7
1 7
7 2
2 6
6 7
3 4
5 3
4 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 50;
unordered_map<int, set<int>> mp;
vector<pair<int, int>> res;
int a[N];
int b[N];
bool isLucky(int num) {
while (num) {
if (num % 10 != 4 && num % 10 != 7) {
return false;
}
num /= 10;
}
return true;
}
int main() {
int n;
while (~scanf("%d", &n)) {
mp.clear();
res.clear();
int index = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
if (isLucky(a[i])) {
index = i;
}
mp[a[i]].insert(i);
}
bool sorted = true;
sort(b, b + n);
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
sorted = false;
break;
}
}
if (sorted) {
printf("0\n");
continue;
} else if (index == -1) {
printf("-1\n");
continue;
}
for (int i = 0; i < n; i++) {
set<int> &set1 = mp[a[i]];
if (a[i] != b[i]) {
set<int> &set2 = mp[b[i]];
set<int> &set3 = mp[a[index]];
int j = *set2.begin();
if (index != i && index != j) {
swap(a[index], a[i]);
res.emplace_back(index, i);
swap(a[i], a[j]);
res.emplace_back(i, j);
set1.erase(i);
set2.erase(j);
set3.erase(index);
set1.insert(index);
set3.insert(j);
index = j;
} else {
swap(a[i], a[j]);
res.emplace_back(i, j);
set1.erase(i);
set2.erase(j);
set1.insert(j);
index = index == i ? j : i;
}
} else {
set1.erase(i);
}
}
for (auto it = res.begin(); it != res.end();) {
auto itNext = it;
itNext++;
if (it->first == it->second) {
it = res.erase(it);
} else if (itNext != res.end() && itNext->first == it->first &&
itNext->second == it->second) {
it = res.erase(it);
it = res.erase(it);
} else {
it++;
}
}
printf("%lu\n", res.size());
for (const auto &p : res) {
printf("%d %d\n", p.first + 1, p.second + 1);
}
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, i, mlc;
bool prime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
int lgpow(int a, int b) {
int r = 1;
for (int i = 1; i <= b; i <<= 1) {
if (i & b) r = (1LL * r * a) % n;
a = (1LL * a * a) % n;
}
return r;
}
int main() {
cin.sync_with_stdio(false);
cin >> n;
if (n == 1) {
cout << "YES\n1\n";
return 0;
}
if (n == 4) {
cout << "YES\n1\n3\n2\n4\n";
return 0;
}
if (!prime(n)) {
cout << "NO\n";
return 0;
}
cout << "YES\n1\n";
for (i = 2; i < n; i++) {
mlc = (1LL * i * lgpow((i - 1), n - 2)) % n;
cout << mlc << '\n';
}
cout << n << '\n';
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
There is a sequence X of length N, where every element is initially 0. Let X_i denote the i-th element of X.
You are given a sequence A of length N. The i-th element of A is A_i. Determine if we can make X equal to A by repeating the operation below. If we can, find the minimum number of operations required.
* Choose an integer i such that 1\leq i\leq N-1. Replace the value of X_{i+1} with the value of X_i plus 1.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 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_N
Output
If we can make X equal to A by repeating the operation, print the minimum number of operations required. If we cannot, print -1.
Examples
Input
4
0
1
1
2
Output
3
Input
3
1
2
1
Output
-1
Input
9
0
1
1
0
1
2
2
1
2
Output
8
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, a[N];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
if (a[1]) {
cout << -1; return 0;
}
int mx = a[n];
long long res = a[n];
for (int i = n - 1; i >= 1; --i) {
mx--;
if (mx > a[i]) {
cout << -1; return 0;
}
if (mx == a[i]) continue;
mx = a[i], res += a[i];
}
cout << res;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Little penguin Polo loves his home village. The village has n houses, indexed by integers from 1 to n. Each house has a plaque containing an integer, the i-th house has a plaque containing integer pi (1 ≤ pi ≤ n).
Little penguin Polo loves walking around this village. The walk looks like that. First he stands by a house number x. Then he goes to the house whose number is written on the plaque of house x (that is, to house px), then he goes to the house whose number is written on the plaque of house px (that is, to house ppx), and so on.
We know that:
1. When the penguin starts walking from any house indexed from 1 to k, inclusive, he can walk to house number 1.
2. When the penguin starts walking from any house indexed from k + 1 to n, inclusive, he definitely cannot walk to house number 1.
3. When the penguin starts walking from house number 1, he can get back to house number 1 after some non-zero number of walks from a house to a house.
You need to find the number of ways you may write the numbers on the houses' plaques so as to fulfill the three above described conditions. Print the remainder after dividing this number by 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ min(8, n)) — the number of the houses and the number k from the statement.
Output
In a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
5 2
Output
54
Input
7 4
Output
1728
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000 * 1000 * 1000 + 7LL;
const double EXP = 1e-6;
const int MAX = 100001;
int mark[9];
long long n, k;
bool vis[9];
bool all[9];
int dfs(int u) {
if (u == 1) return 1;
if (vis[u] == 1) return 0;
vis[u] = 1;
return dfs(mark[u]);
}
long long f(int u) {
if (k == 1) return 1;
if (k == 2) return 2;
if (k == 3) return 9;
if (k == 4) return 64;
if (k == 5) return 625;
if (k == 6) return 7776;
if (k == 7) return 117649;
if (k == 8) return 2097152;
if (u == k + 1) {
long long b = 1LL;
for (int i = 1; i <= k; i++) {
memset(vis, 0, sizeof vis);
if (!dfs(i)) b = 0;
}
return b;
}
long long ans = 0LL;
for (int i = 1; i <= k; i++) {
mark[u] = i;
ans = (ans + f(u + 1)) % mod;
}
return ans % mod;
}
int main() {
cin >> n >> k;
long long ans = 1;
for (int i = k + 1; i <= n; i++) {
ans = (ans * (n - k)) % mod;
}
ans = (ans * f(1)) % mod;
cout << ans << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
It's now the season of TAKOYAKI FESTIVAL!
This year, N takoyaki (a ball-shaped food with a piece of octopus inside) will be served. The deliciousness of the i-th takoyaki is d_i.
As is commonly known, when you eat two takoyaki of deliciousness x and y together, you restore x \times y health points.
There are \frac{N \times (N - 1)}{2} ways to choose two from the N takoyaki served in the festival. For each of these choices, find the health points restored from eating the two takoyaki, then compute the sum of these \frac{N \times (N - 1)}{2} values.
Constraints
* All values in input are integers.
* 2 \leq N \leq 50
* 0 \leq d_i \leq 100
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the sum of the health points restored from eating two takoyaki over all possible choices of two takoyaki from the N takoyaki served.
Examples
Input
3
3 1 2
Output
11
Input
7
5 0 7 8 3 3 2
Output
312
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int v[101];
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
cin>>v[i];
}
long s=0;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
s+=(v[i]*v[j]);
}
}
cout<<s<<'\n';
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
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<cstdio>
#include<algorithm>
using std::min;
int main()
{
long long a,b,c;
scanf("%lld %lld %lld",&a,&b,&c);
if( !(a&1 && b&1 && c&1) )
puts("0");
else
printf("%lld\n",min(a*b,min(a*c,b*c)));
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
John Doe has a field, which is a rectangular table of size n × m. We assume that the field rows are numbered from 1 to n from top to bottom, and the field columns are numbered from 1 to m from left to right. Then the cell of the field at the intersection of the x-th row and the y-th column has coordinates (x; y).
We know that some cells of John's field are painted white, and some are painted black. Also, John has a tortoise, which can move along the white cells of the field. The tortoise can get from a white cell with coordinates (x; y) into cell (x + 1; y) or (x; y + 1), if the corresponding cell is painted white. In other words, the turtle can move only along the white cells of the field to the right or down. The turtle can not go out of the bounds of the field.
In addition, John has q queries, each of them is characterized by four numbers x1, y1, x2, y2 (x1 ≤ x2, y1 ≤ y2). For each query John wants to know whether the tortoise can start from the point with coordinates (x1; y1), and reach the point with coordinates (x2; y2), moving only along the white squares of the field.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 500) — the field sizes.
Each of the next n lines contains m characters "#" and ".": the j-th character of the i-th line equals "#", if the cell (i; j) is painted black and ".", if it is painted white.
The next line contains integer q (1 ≤ q ≤ 6·105) — the number of queries. Next q lines contain four space-separated integers x1, y1, x2 and y2 (1 ≤ x1 ≤ x2 ≤ n, 1 ≤ y1 ≤ y2 ≤ m) — the coordinates of the starting and the finishing cells. It is guaranteed that cells (x1; y1) and (x2; y2) are white.
Output
For each of q queries print on a single line "Yes", if there is a way from cell (x1; y1) to cell (x2; y2), that meets the requirements, and "No" otherwise. Print the answers to the queries in the order, in which the queries are given in the input.
Examples
Input
3 3
...
.##
.#.
5
1 1 3 3
1 1 1 3
1 1 3 1
1 1 1 2
1 1 2 1
Output
No
Yes
Yes
Yes
Yes
Input
5 5
.....
.###.
.....
.###.
.....
5
1 1 5 5
1 1 1 5
1 1 3 4
2 1 2 5
1 1 2 5
Output
Yes
Yes
Yes
No
Yes
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int intmax = 0x3f3f3f3f;
const long long lldmax = 0x3f3f3f3f3f3f3f3fll;
double eps = 1e-8;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T checkmod(T n, T m) {
return (n % m + m) % m;
}
inline int rand(int a, int b) {
if (a >= b) return a;
return rand() % (b - a) + a;
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T euclid(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclid(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclid(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclid(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > factorize(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline bool isPrimeNumber(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T eularFunction(T n) {
vector<pair<T, int> > R = factorize(n);
T r = n;
for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
return r;
}
template <class T>
inline int dblcmp(T a, const T b) {
a -= b;
return a > eps ? 1 : (a < -eps ? -1 : 0);
}
template <class T>
inline int sgn(T a) {
return a > eps ? 1 : (a < -eps ? -1 : 0);
}
const int N = 512;
const int Q = 600010;
char in[N][N];
bitset<N> dpl[N][N], dpr[N][N];
int l[Q], r[Q], u[Q], d[Q];
bool ans[Q];
int n, m, q;
void gao(int L, int R, vector<int> v) {
if (v.size() == 0 || L > R) return;
vector<int> vl, vr;
int M = (L + R) / 2;
for (int i = n - 1; i >= 0; --i) {
if (in[i][M] == '#')
dpl[i][M].reset();
else {
dpl[i][M] = dpl[i + 1][M];
dpl[i][M].set(i);
}
}
for (int i = 0; i < n; ++i) {
if (in[i][M] == '#')
dpr[i][M].reset();
else {
if (i) dpr[i][M] = dpr[i - 1][M];
dpr[i][M].set(i);
}
}
for (int i = n - 1; i >= 0; --i) {
for (int j = M - 1; j >= L; --j) {
if (in[i][j] == '#') {
dpl[i][j].reset();
} else {
dpl[i][j] = dpl[i + 1][j] | dpl[i][j + 1];
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = M + 1; j <= R; ++j) {
if (in[i][j] == '#') {
dpr[i][j].reset();
} else {
if (i)
dpr[i][j] = dpr[i - 1][j] | dpr[i][j - 1];
else
dpr[i][j] = dpr[i][j - 1];
}
}
}
for (int i = 0; i < v.size(); ++i) {
int p = v[i];
if (r[p] < M) {
vl.push_back(p);
} else if (l[p] > M) {
vr.push_back(p);
} else {
ans[p] = (dpl[u[p]][l[p]] & dpr[d[p]][r[p]]).any();
}
}
gao(L, M - 1, vl);
gao(M + 1, R, vr);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> in[i];
cin >> q;
for (int i = 0; i < q; ++i) {
cin >> u[i] >> l[i] >> d[i] >> r[i];
l[i]--, u[i]--, r[i]--, d[i]--;
}
vector<int> v;
for (int i = 0; i < q; ++i) v.push_back(i);
gao(0, m - 1, v);
for (int i = 0; i < q; ++i) puts(ans[i] ? "Yes" : "No");
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
<image>
For given three points p0, p1, p2, print
COUNTER_CLOCKWISE
if p0, p1, p2 make a counterclockwise turn (1),
CLOCKWISE
if p0, p1, p2 make a clockwise turn (2),
ONLINE_BACK
if p2 is on a line p2, p0, p1 in this order (3),
ONLINE_FRONT
if p2 is on a line p0, p1, p2 in this order (4),
ON_SEGMENT
if p2 is on a segment p0p1 (5).
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p0 and p1 are not identical.
Input
xp0 yp0 xp1 yp1
q
xp20 yp20
xp21 yp21
...
xp2q-1 yp2q-1
In the first line, integer coordinates of p0 and p1 are given. Then, q queries are given for integer coordinates of p2.
Output
For each query, print the above mentioned status.
Examples
Input
0 0 2 0
2
-1 1
-1 -1
Output
COUNTER_CLOCKWISE
CLOCKWISE
Input
0 0 2 0
3
-1 0
0 0
3 0
Output
ONLINE_BACK
ON_SEGMENT
ONLINE_FRONT
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pairInt;
#define FOR(i, n) for (int i = 0; i < int(n); i++)
#define FOR1(i, m, n) for (int i = int(m); i < int(n); i++)
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
int main(int argc, char *argv[]) {
array<int, 2> p0, p1, v1;
int q;
scanf("%d%d%d%d%d", &p0[0], &p0[1], &p1[0], &p1[1], &q);
v1[0] = p1[0] - p0[0];
v1[1] = p1[1] - p0[1];
FOR(i, q) {
array<int, 2> p2, v2;
scanf("%d%d", &p2[0], &p2[1]);
v2[0] = p2[0] - p0[0];
v2[1] = p2[1] - p0[1];
int op = v1[0] * v2[1] - v1[1] * v2[0];
int ip = v1[0] * v2[0] + v1[1] * v2[1];
#ifdef DEBUG
printf("v1=(%d,%d),v2=(%d,%d),op=%d,ip=%d\n", v1[0], v1[1], v2[0], v2[1],
op, ip);
#endif
if (op > 0)
printf("COUNTER_CLOCKWISE\n");
else if (op < 0)
printf("CLOCKWISE\n");
else if (ip < 0)
printf("ONLINE_BACK\n");
else if (abs(v2[0]) > abs(v1[0]) || abs(v2[1]) > abs(v1[1]))
printf("ONLINE_FRONT\n");
else
printf("ON_SEGMENT\n");
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Linda likes to change her hair color from time to time, and would be pleased if her boyfriend Archie would notice the difference between the previous and the new color. Archie always comments on Linda's hair color if and only if he notices a difference — so Linda always knows whether Archie has spotted the difference or not.
There is a new hair dye series in the market where all available colors are numbered by integers from 1 to N such that a smaller difference of the numerical values also means less visual difference.
Linda assumes that for these series there should be some critical color difference C (1 ≤ C ≤ N) for which Archie will notice color difference between the current color color_{new} and the previous color color_{prev} if \left|color_{new} - color_{prev}\right| ≥ C and will not if \left|color_{new} - color_{prev}\right| < C.
Now she has bought N sets of hair dye from the new series — one for each of the colors from 1 to N, and is ready to set up an experiment. Linda will change her hair color on a regular basis and will observe Archie's reaction — whether he will notice the color change or not. Since for the proper dye each set should be used completely, each hair color can be obtained no more than once.
Before the experiment, Linda was using a dye from a different series which is not compatible with the new one, so for the clearness of the experiment Archie's reaction to the first used color is meaningless.
Her aim is to find the precise value of C in a limited number of dyes. Write a program which finds the value of C by experimenting with the given N colors and observing Archie's reactions to color changes.
Interaction
This is an interactive task. In the beginning you are given a single integer T (1 ≤ T ≤ 100), the number of cases in the test.
For each test case, the input first contains a single integer — the value of N (1 < N ≤ 10^{18}). The value of C is kept secret by the grading system.
Then your program should make queries writing output in the following format: "? P", where P is an integer (1 ≤ P ≤ N) denoting the next color used. For each query the grading system gives an answer in the next line of the input. The answer is 1 if Archie notices the color difference between the last two colors and 0 otherwise. No two queries should have the same P value.
When your program determines C, it should output its value in the following format: "= C". The grading system will not respond to this output and will proceed with the next test case.
Your program may use at most 64 queries "?" for each test case to find the correct value of C.
To establish proper communication between your program and the grading system, you should flush the output stream after each query.
$$$\begin{array}{ll} Language & Command \\\ \hline C++ & std::cout << std::endl; \\\ Java & System.out.flush(); \\\ Python & sys.stdout.flush() \end{array}$$$ Flush commands
Note that std::endl writes a newline and flushes the stream.
It is possible to receive an "Output isn't correct" outcome even after printing a correct answer, if task constraints were violated during the communication. Violating the communication protocol itself may result in an "Execution killed" outcome.
Submitting user tests requires specifying an input file with the testcase parameters. The format of the input file is "T" in the first line, and then "N C" on a single line for each of the T cases.
Scoring
Subtasks:
1. (9 points) N ≤ 64
2. (13 points) N ≤ 125
3. (21 points) N ≤ 1000
4. (24 points) N ≤ 10^9
5. (33 points) No further constraints.
Example
Input
1
7
1
1
0
0
1
Output
? 2
? 7
? 4
? 1
? 5
= 4
Note
Comments to the example input line by line:
1. N = 7.
2. Answer to the first query is meaningless (can also be 0).
3. C ≤ 5.
4. 3 < C ≤ 5. It would be wise to check difference 4. However, this can not be done in the next query since 4 + 4 = 8 and 4 - 4 = 0 both are outside the allowed interval 1 ≤ P ≤ 7.
5. 3 < C ≤ 5.
6. 3 < C ≤ 4. Therefore, C = 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int ask(long long x) {
printf("? %lld\n", x);
fflush(stdout);
int y;
scanf("%d", &y);
return y;
}
long long calc(long long n) {
if (n == 1) return 1;
return (n + 1) / 2 + 1 - calc((n + 1) / 2);
}
void solve(long long n) {
long long pos = calc(n);
long long l = 1, r = n, u = 1;
ask(pos);
while (l < r) {
long long mid = (l + r - 1) >> 1;
pos += mid * u;
if (ask(pos))
r = mid;
else
l = mid + 1;
u *= -1;
}
printf("= %lld\n", r);
fflush(stdout);
}
inline void rd(int &x) {
x = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
int main() {
int T;
scanf("%d", &T);
long long n;
while (T--) {
scanf("%lld", &n);
solve(n);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are going to eat X red apples and Y green apples.
You have A red apples of deliciousness p_1,p_2, \dots, p_A, B green apples of deliciousness q_1,q_2, \dots, q_B, and C colorless apples of deliciousness r_1,r_2, \dots, r_C.
Before eating a colorless apple, you can paint it red or green, and it will count as a red or green apple, respectively.
From the apples above, you will choose the apples to eat while making the sum of the deliciousness of the eaten apples as large as possible.
Find the maximum possible sum of the deliciousness of the eaten apples that can be achieved when optimally coloring zero or more colorless apples.
Constraints
* 1 \leq X \leq A \leq 10^5
* 1 \leq Y \leq B \leq 10^5
* 1 \leq C \leq 10^5
* 1 \leq p_i \leq 10^9
* 1 \leq q_i \leq 10^9
* 1 \leq r_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X Y A B C
p_1 p_2 ... p_A
q_1 q_2 ... q_B
r_1 r_2 ... r_C
Output
Print the maximum possible sum of the deliciousness of the eaten apples.
Examples
Input
1 2 2 2 1
2 4
5 1
3
Output
12
Input
2 2 2 2 2
8 6
9 1
2 1
Output
25
Input
2 2 4 4 4
11 12 13 14
21 22 23 24
1 2 3 4
Output
74
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<int> p(a), q(b), r(c);
rep(i, a) cin >> p[i];
rep(i, b) cin >> q[i];
rep(i, c) cin >> r[i];
sort(p.rbegin(),p.rend());
sort(q.rbegin(),q.rend());
vector<int> sum;
rep(i,x) sum.push_back(p[i]);
rep(i,y) sum.push_back(q[i]);
rep(i,c) sum.push_back(r[i]);
sort(sum.rbegin(), sum.rend());
ll ans = 0;
rep(i, x+y) ans += sum[i];
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct l_r_points {
int l_point[2];
int r_point[2];
};
struct minn_l_r {
public:
minn_l_r() {
minn_left = 1000000000000000000;
minn_right = 1000000000000000000;
}
long long int minn_left;
long long int minn_right;
};
int n_points;
map<int, l_r_points> mapp;
int read_x, read_y;
int compare_fraction(long long int a, long long int b, long long int a1,
long long int b1) {
if (b == 0) {
return 1;
}
if (b1 == 0) {
return 0;
}
if (a * b1 >= b * a1) {
return 1;
}
return 0;
}
void insert_point_mapp(int maxx, int minn) {
if (mapp.find(maxx) == mapp.end()) {
l_r_points &reff_struct = mapp[maxx];
reff_struct.l_point[0] = read_x;
reff_struct.l_point[1] = read_y;
reff_struct.r_point[0] = read_x;
reff_struct.r_point[1] = read_y;
} else {
l_r_points &reff_struct = mapp[maxx];
int cmp = compare_fraction(reff_struct.l_point[0], reff_struct.l_point[1],
read_x, read_y);
if (cmp) {
reff_struct.l_point[0] = read_x;
reff_struct.l_point[1] = read_y;
}
cmp = compare_fraction(reff_struct.r_point[0], reff_struct.r_point[1],
read_x, read_y);
if (!cmp) {
reff_struct.r_point[0] = read_x;
reff_struct.r_point[1] = read_y;
}
}
}
void read_in() {
scanf("%d", &n_points);
for (int i = 0; i < n_points; i++) {
int x, y;
scanf("%d %d", &x, &y);
read_x = x;
read_y = y;
int maxx, minn;
maxx = x;
minn = y;
if (maxx < minn) {
maxx = y;
minn = x;
}
insert_point_mapp(maxx, minn);
}
}
int dist_between_points(int a, int b, int a1, int b1) {
int dist = (int)abs(a - a1) + (int)abs(b - b1);
return dist;
}
minn_l_r minn_l_r_dist(int curr_x, int curr_y, int (*ptr_left)[2],
int (*ptr_right)[2]) {
minn_l_r temp;
long long int tot = 0;
tot += dist_between_points(curr_x, curr_y, (*ptr_right)[0], (*ptr_right)[1]);
tot += dist_between_points((*ptr_right)[0], (*ptr_right)[1], (*ptr_left)[0],
(*ptr_left)[1]);
if (temp.minn_left > tot) {
temp.minn_left = tot;
}
tot = 0;
tot += dist_between_points(curr_x, curr_y, (*ptr_left)[0], (*ptr_left)[1]);
tot += dist_between_points((*ptr_left)[0], (*ptr_left)[1], (*ptr_right)[0],
(*ptr_right)[1]);
tot += dist_between_points((*ptr_right)[0], (*ptr_right)[1], (*ptr_left)[0],
(*ptr_left)[1]);
if (temp.minn_left > tot) {
temp.minn_left = tot;
}
tot = 0;
tot += dist_between_points(curr_x, curr_y, (*ptr_left)[0], (*ptr_left)[1]);
tot += dist_between_points((*ptr_left)[0], (*ptr_left)[1], (*ptr_right)[0],
(*ptr_right)[1]);
if (temp.minn_right > tot) {
temp.minn_right = tot;
}
tot = 0;
tot += dist_between_points(curr_x, curr_y, (*ptr_right)[0], (*ptr_right)[1]);
tot += dist_between_points((*ptr_right)[0], (*ptr_right)[1], (*ptr_left)[0],
(*ptr_left)[1]);
tot += dist_between_points((*ptr_left)[0], (*ptr_left)[1], (*ptr_right)[0],
(*ptr_right)[1]);
if (temp.minn_right > tot) {
temp.minn_right = tot;
}
return temp;
}
void solve() {
long long int accm_minn_l = 0, accm_minn_r = 0;
l_r_points prev_l_r_points;
prev_l_r_points.l_point[0] = 0;
prev_l_r_points.l_point[1] = 0;
prev_l_r_points.r_point[0] = 0;
prev_l_r_points.r_point[1] = 0;
for (map<int, l_r_points>::iterator iter = mapp.begin(); iter != mapp.end();
iter++) {
int curr_level = iter->first;
l_r_points curr_l_r_points = iter->second;
minn_l_r start_from_left;
minn_l_r local1 =
minn_l_r_dist(curr_level, prev_l_r_points.l_point[1],
&curr_l_r_points.l_point, &curr_l_r_points.r_point);
int dist = dist_between_points(prev_l_r_points.l_point[0],
prev_l_r_points.l_point[1], curr_level,
prev_l_r_points.l_point[1]);
local1.minn_left += dist;
local1.minn_right += dist;
minn_l_r local2 =
minn_l_r_dist(prev_l_r_points.l_point[0], curr_level,
&curr_l_r_points.l_point, &curr_l_r_points.r_point);
dist = dist_between_points(prev_l_r_points.l_point[0],
prev_l_r_points.l_point[1],
prev_l_r_points.l_point[0], curr_level);
local2.minn_left += dist;
local2.minn_right += dist;
start_from_left = local1;
if (start_from_left.minn_left > local2.minn_left) {
start_from_left.minn_left = local2.minn_left;
}
if (start_from_left.minn_right > local2.minn_right) {
start_from_left.minn_right = local2.minn_right;
}
minn_l_r start_from_right;
local1 = minn_l_r_dist(curr_level, prev_l_r_points.r_point[1],
&curr_l_r_points.l_point, &curr_l_r_points.r_point);
dist = dist_between_points(prev_l_r_points.r_point[0],
prev_l_r_points.r_point[1], curr_level,
prev_l_r_points.r_point[1]);
local1.minn_left += dist;
local1.minn_right += dist;
local2 = minn_l_r_dist(prev_l_r_points.r_point[0], curr_level,
&curr_l_r_points.l_point, &curr_l_r_points.r_point);
dist = dist_between_points(prev_l_r_points.r_point[0],
prev_l_r_points.r_point[1],
prev_l_r_points.r_point[0], curr_level);
local2.minn_left += dist;
local2.minn_right += dist;
start_from_right = local1;
if (start_from_right.minn_left > local2.minn_left) {
start_from_right.minn_left = local2.minn_left;
}
if (start_from_right.minn_right > local2.minn_right) {
start_from_right.minn_right = local2.minn_right;
}
long long int new_accm_minn_l, new_accm_minn_r;
if (accm_minn_l + start_from_left.minn_left >=
accm_minn_r + start_from_right.minn_left) {
new_accm_minn_l = accm_minn_r + start_from_right.minn_left;
} else {
new_accm_minn_l = accm_minn_l + start_from_left.minn_left;
}
if (accm_minn_l + start_from_left.minn_right >=
accm_minn_r + start_from_right.minn_right) {
new_accm_minn_r = accm_minn_r + start_from_right.minn_right;
} else {
new_accm_minn_r = accm_minn_l + start_from_left.minn_right;
}
accm_minn_r = new_accm_minn_r;
accm_minn_l = new_accm_minn_l;
prev_l_r_points = curr_l_r_points;
}
if (accm_minn_l >= accm_minn_r) {
printf("%I64d", accm_minn_r);
return;
}
printf("%I64d", accm_minn_l);
}
int main() {
read_in();
solve();
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You are given a tuple generator f^{(k)} = (f_1^{(k)}, f_2^{(k)}, ..., f_n^{(k)}), where f_i^{(k)} = (a_i ⋅ f_i^{(k - 1)} + b_i) mod p_i and f^{(0)} = (x_1, x_2, ..., x_n). Here x mod y denotes the remainder of x when divided by y. All p_i are primes.
One can see that with fixed sequences x_i, y_i, a_i the tuples f^{(k)} starting from some index will repeat tuples with smaller indices. Calculate the maximum number of different tuples (from all f^{(k)} for k ≥ 0) that can be produced by this generator, if x_i, a_i, b_i are integers in the range [0, p_i - 1] and can be chosen arbitrary. The answer can be large, so print the remainder it gives when divided by 10^9 + 7
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the tuple.
The second line contains n space separated prime numbers — the modules p_1, p_2, …, p_n (2 ≤ p_i ≤ 2 ⋅ 10^6).
Output
Print one integer — the maximum number of different tuples modulo 10^9 + 7.
Examples
Input
4
2 3 5 7
Output
210
Input
3
5 3 3
Output
30
Note
In the first example we can choose next parameters: a = [1, 1, 1, 1], b = [1, 1, 1, 1], x = [0, 0, 0, 0], then f_i^{(k)} = k mod p_i.
In the second example we can choose next parameters: a = [1, 1, 2], b = [1, 1, 0], x = [0, 0, 1].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 7, M = 1e9 + 7;
vector<int> primes;
bool isp[N];
void sieve() {
fill(isp, isp + N, 1);
isp[0] = isp[1] = 0;
for (int i = 2; i * i < N; i++)
if (isp[i])
for (int j = i * i; j < N; j += i) isp[j] = 0;
for (int i = 2; i < N; i++)
if (isp[i]) primes.push_back(i);
}
vector<pair<int, int> > factorize(int x) {
vector<pair<int, int> > ans;
for (int i : primes) {
if (i * i > x) break;
int cnt = 0;
while (x % i == 0) cnt++, x /= i;
if (cnt) ans.push_back(make_pair(i, cnt));
}
if (x > 1) ans.push_back(make_pair(x, 1));
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
sieve();
int n;
cin >> n;
long long ans = 1;
map<int, int> fac;
map<int, int> cnt;
vector<vector<pair<int, int> > > factors;
int pp[n];
for (int i = 0; i < n; i++) cin >> pp[i];
sort(pp, pp + n);
reverse(pp, pp + n);
for (int i = 1; i <= n; i++) {
int p = pp[i - 1];
if (fac.count(p) == 0) {
ans = (ans * p) % M;
fac[p] = 1;
cnt[p] = 1;
vector<pair<int, int> > v;
v.push_back(make_pair(p, 1));
factors.push_back(v);
} else {
vector<pair<int, int> > pf = factorize(p - 1);
factors.push_back(pf);
for (auto pr : pf) {
int p = pr.first;
int e = pr.second;
int dif = e - fac[p];
if (dif < 0) continue;
if (dif == 0) {
cnt[p]++;
continue;
}
fac[p] += dif;
cnt[p] = 1;
for (int i = 0; i < dif; i++) ans = (ans * p) % M;
}
}
}
for (auto pf : factors) {
bool found = true;
for (auto pr : pf) {
int p = pr.first;
int e = pr.second;
int mx = fac[p];
assert(e <= mx);
if (e == mx && cnt[p] == 1) {
found = false;
break;
}
}
if (found) {
ans++;
break;
}
}
cout << ans << endl;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Given the number n, find the smallest positive integer which has exactly n divisors. It is guaranteed that for the given n the answer will not exceed 1018.
Input
The first line of the input contains integer n (1 ≤ n ≤ 1000).
Output
Output the smallest positive integer with exactly n divisors.
Examples
Input
4
Output
6
Input
6
Output
12
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
int dp[1005][12];
int prime[10] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
long long power(int x, int y) {
if (y == 0) return 1;
if (y % 2) return x * power(x, y / 2) * power(x, y / 2);
return power(x, y / 2) * power(x, y / 2);
}
long long calc(vector<int> arr, int n) {
long long ans = 1;
long long ans2 = 1;
for (int i = 1; i <= 10; i++) {
long long x = prime[i - 1];
for (int j = 0; j < arr[i]; j++) {
if (ans * x > 1e18) return 2e18;
ans *= x;
}
}
for (int i = 1; i <= 10; i++) ans2 *= arr[i] + 1;
if (ans2 != n) return 2e18;
return ans;
}
vector<int> solve(int x, int y, int n) {
vector<int> temp(11);
long long minn = 2e18;
for (int i = 1; i <= 10; i++) temp[i] = dp[x][i];
for (int i = 1; i <= 10; i++) {
if (dp[x][i] == 0) {
temp[i] += y - 1;
minn = min(minn, calc(temp, n));
temp[i] -= y - 1;
break;
} else {
temp[i] += y;
minn = min(minn, calc(temp, n));
temp[i] -= y;
}
}
for (int i = 1; i <= 10; i++) {
if (dp[x][i] == 0) {
temp[i] += y - 1;
if (minn == calc(temp, n)) return temp;
temp[i] -= y - 1;
break;
} else {
temp[i] += y;
if (minn == calc(temp, n)) return temp;
temp[i] -= y;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long ans = 1;
for (int i = 2; i <= n; i++) {
int x = i;
vector<int> fac;
long long minn = 2e18;
for (int j = 2; j * j <= i; j++) {
while (x % j == 0) {
fac.push_back(j);
x /= j;
}
}
if (x > 1) fac.push_back(x);
vector<int> temp(11);
for (int j = 0; j < fac.size(); j++) {
if (minn >= calc(solve(i / fac[j], fac[j], i), i)) {
minn = calc(solve(i / fac[j], fac[j], i), i);
temp = solve(i / fac[j], fac[j], i);
}
}
for (int j = 1; j <= 10; j++) dp[i][j] = temp[j];
}
for (int i = 1; i <= 10; i++) ans *= power(prime[i - 1], dp[n][i]);
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Alyona has built n towers by putting small cubes some on the top of others. Each cube has size 1 × 1 × 1. A tower is a non-zero amount of cubes standing on the top of each other. The towers are next to each other, forming a row.
Sometimes Alyona chooses some segment towers, and put on the top of each tower several cubes. Formally, Alyouna chooses some segment of towers from li to ri and adds di cubes on the top of them.
Let the sequence a1, a2, ..., an be the heights of the towers from left to right. Let's call as a segment of towers al, al + 1, ..., ar a hill if the following condition holds: there is integer k (l ≤ k ≤ r) such that al < al + 1 < al + 2 < ... < ak > ak + 1 > ak + 2 > ... > ar.
After each addition of di cubes on the top of the towers from li to ri, Alyona wants to know the maximum width among all hills. The width of a hill is the number of towers in it.
Input
The first line contain single integer n (1 ≤ n ≤ 3·105) — the number of towers.
The second line contain n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the number of cubes in each tower.
The third line contain single integer m (1 ≤ m ≤ 3·105) — the number of additions.
The next m lines contain 3 integers each. The i-th of these lines contains integers li, ri and di (1 ≤ l ≤ r ≤ n, 1 ≤ di ≤ 109), that mean that Alyona puts di cubes on the tio of each of the towers from li to ri.
Output
Print m lines. In i-th line print the maximum width of the hills after the i-th addition.
Example
Input
5
5 5 5 5 5
3
1 3 2
2 2 1
4 4 1
Output
2
4
5
Note
The first sample is as follows:
After addition of 2 cubes on the top of each towers from the first to the third, the number of cubes in the towers become equal to [7, 7, 7, 5, 5]. The hill with maximum width is [7, 5], thus the maximum width is 2.
After addition of 1 cube on the second tower, the number of cubes in the towers become equal to [7, 8, 7, 5, 5]. The hill with maximum width is now [7, 8, 7, 5], thus the maximum width is 4.
After addition of 1 cube on the fourth tower, the number of cubes in the towers become equal to [7, 8, 7, 6, 5]. The hill with maximum width is now [7, 8, 7, 6, 5], thus the maximum width is 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long> a;
struct SegTree {
struct Node {
long long left, right, mid, size;
};
Node combine(const Node& A, const Node& B, long long m) {
Node C;
if (A.left < A.size) {
C.left = A.left;
} else {
if ((a[m - 1] > 0) <= (a[m] > 0)) {
C.left = A.size + B.left;
} else {
C.left = A.size;
}
}
if (B.right < B.size) {
C.right = B.right;
} else {
if ((a[m - 1] > 0) <= (a[m] > 0)) {
C.right = B.size + A.right;
} else {
C.right = B.size;
}
}
C.mid = max(A.mid, B.mid);
if ((a[m - 1] > 0) <= (a[m] > 0)) {
C.mid = max(C.mid, A.right + B.left);
}
C.size = A.size + B.size;
return C;
}
long long size;
vector<Node> t;
void init(long long n) {
size = n;
t.resize(4 * size);
}
void build(long long x, long long lx, long long rx) {
if (lx + 1 == rx) {
if (a[lx] == 0) {
t[x] = {0, 0, 0, 1};
} else {
t[x] = {1, 1, 1, 1};
}
} else {
long long m = (lx + rx) / 2;
build(2 * x + 1, lx, m);
build(2 * x + 2, m, rx);
t[x] = combine(t[2 * x + 1], t[2 * x + 2], m);
}
}
void build(long long n) {
init(n);
build(0, 0, size);
}
void set(long long v, long long x, long long lx, long long rx) {
if (lx + 1 == rx) {
if (a[lx] == 0) {
t[x] = {0, 0, 0, 1};
} else {
t[x] = {1, 1, 1, 1};
}
} else {
long long m = (lx + rx) / 2;
if (v < m) {
set(v, 2 * x + 1, lx, m);
} else {
set(v, 2 * x + 2, m, rx);
}
t[x] = combine(t[2 * x + 1], t[2 * x + 2], m);
}
}
void set(long long v) { set(v, 0, 0, size); }
};
void solve() {
long long Q;
Q = 1;
while (Q--) {
long long n;
cin >> n;
vector<long long> b(n);
for (long long i = 0; i < n; ++i) cin >> b[i];
;
a.resize(n - 1);
for (long long i = 0; i < n - 1; ++i) {
a[i] = b[i] - b[i + 1];
}
SegTree tree;
if (a.size() != 0) {
tree.build(a.size());
}
long long m;
cin >> m;
while (m--) {
long long l, r, d;
cin >> l >> r >> d;
--l, --r;
if (a.size() == 0) {
cout << 1 << " ";
continue;
}
if (l > 0) {
a[l - 1] -= d;
tree.set(l - 1);
}
if (r < a.size()) {
a[r] += d;
tree.set(r);
}
cout << tree.t[0].mid + 1 << " ";
}
}
}
signed main(signed argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
if (argc > 1 && (string)argv[1] == "local") {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
solve();
while (cin.peek() != EOF) {
if (isspace(cin.peek()))
cin.get();
else {
cout << '\n';
solve();
}
}
} else {
solve();
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Do you know a story about the three musketeers? Anyway, you will learn about its origins now.
Richelimakieu is a cardinal in the city of Bearis. He is tired of dealing with crime by himself. He needs three brave warriors to help him to fight against bad guys.
There are n warriors. Richelimakieu wants to choose three of them to become musketeers but it's not that easy. The most important condition is that musketeers must know each other to cooperate efficiently. And they shouldn't be too well known because they could be betrayed by old friends. For each musketeer his recognition is the number of warriors he knows, excluding other two musketeers.
Help Richelimakieu! Find if it is possible to choose three musketeers knowing each other, and what is minimum possible sum of their recognitions.
Input
The first line contains two space-separated integers, n and m (3 ≤ n ≤ 4000, 0 ≤ m ≤ 4000) — respectively number of warriors and number of pairs of warriors knowing each other.
i-th of the following m lines contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi). Warriors ai and bi know each other. Each pair of warriors will be listed at most once.
Output
If Richelimakieu can choose three musketeers, print the minimum possible sum of their recognitions. Otherwise, print "-1" (without the quotes).
Examples
Input
5 6
1 2
1 3
2 3
2 4
3 4
4 5
Output
2
Input
7 4
2 1
3 6
5 1
1 7
Output
-1
Note
In the first sample Richelimakieu should choose a triple 1, 2, 3. The first musketeer doesn't know anyone except other two musketeers so his recognition is 0. The second musketeer has recognition 1 because he knows warrior number 4. The third musketeer also has recognition 1 because he knows warrior 4. Sum of recognitions is 0 + 1 + 1 = 2.
The other possible triple is 2, 3, 4 but it has greater sum of recognitions, equal to 1 + 1 + 1 = 3.
In the second sample there is no triple of warriors knowing each other.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 5;
int degree[mx];
int graph[4005][4005];
int a[mx];
int b[mx];
int32_t main() {
int n, m;
cin >> n >> m;
memset(degree, 0, sizeof(degree));
memset(graph, 0, sizeof(graph));
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
degree[a[i]]++;
degree[b[i]]++;
graph[a[i]][b[i]] = graph[b[i]][a[i]] = 1;
}
int ans = INT_MAX;
for (int i = 0; i < m; i++) {
int x = a[i];
int y = b[i];
for (int j = 1; j < n + 1; j++) {
if (j != x && j != y) {
if (graph[x][j] == 1 && graph[y][j] == 1) {
ans = min(degree[x] + degree[y] + degree[j] - 6, ans);
}
}
}
}
if (ans != INT_MAX) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Snuke loves flags.
Snuke is placing N flags on a line.
The i-th flag can be placed at either coordinate x_i or coordinate y_i.
Snuke thinks that the flags look nicer when the smallest distance between two of them, d, is larger. Find the maximum possible value of d.
Constraints
* 2 ≤ N ≤ 10^{4}
* 1 ≤ x_i, y_i ≤ 10^{9}
* x_i and y_i are integers.
Input
The input is given from Standard Input in the following format:
N
x_1 y_1
:
x_N y_N
Output
Print the answer.
Examples
Input
3
1 3
2 5
1 9
Output
4
Input
5
2 2
2 2
2 2
2 2
2 2
Output
0
Input
22
93 6440
78 6647
862 11
8306 9689
798 99
801 521
188 206
6079 971
4559 209
50 94
92 6270
5403 560
803 83
1855 99
42 504
75 484
629 11
92 122
3359 37
28 16
648 14
11 269
Output
17
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <vector>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#define rep(i,a,b) for(int i = a; i <= b; i++)
#define dep(i,a,b) for(int i = a; i >= b; i--)
#define Rep(i,a) for(int i = 0; i < a; i++)
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define ab(x) ((x) < 0 ? -(x) : (x))
using namespace std;
typedef long long LL;
typedef map<int, int>::iterator mit;
typedef set<int>::iterator sit;
const int N = 10010, B = N * 16, M = B + N * 2;
int n, x[N], y[N];
struct edge{ int to, pre; }e[(N * 2 * 4 + N * 2 * 16 * 2) * 2 * 2]; int u[M], l = 0;
void ins(int a, int b) { e[++l] = (edge){b, u[a]}, u[a] = l; }
#define v e[i].to
#define reg(i,a) for(int i = u[a]; i; i = e[i].pre)
void add(int a, int b) { ins(a, b), ins(b^1, a^1); }
pair<int, int> nd[N * 2];
#define mid ((l + r) >> 1)
#define lc (x << 1)
#define rc (lc | 1)
#define lcq lc, l, mid
#define rcq rc, mid + 1, r
void build(int x, int l, int r) {
if (l == r)
add(x << 1, nd[l].second ^ 1);
else
build(lcq), build(rcq),
add(x << 1, lc << 1), add(x << 1, rc << 1);
}
int a, b, c;
void modi(int x, int l, int r) {
if (a <= l && r <= b) add(c, x << 1);
else {
if (a <= mid) modi(lcq);
if (b > mid) modi(rcq);
}
}
int pre[M], low[M], dfn = 0;
int st[M], top = 0, cnt = 0, scc[M];
void dfs(int x) {
pre[x] = low[x] = ++dfn; st[top++] = x;
reg(i,x) if (!pre[v]) dfs(v), low[x] = min(low[x], low[v]);
else if (!scc[v]) low[x] = min(low[x], pre[v]);
if (pre[x] == low[x]) {
cnt++; st[top] = 0;
while (st[top] != x) top--, scc[st[top]] = cnt;
}
}
void tarjan() {
memset(pre, 0, sizeof(pre)), memset(scc,0,sizeof(scc));dfn = 0;
rep(i,1,n * 2) if (!pre[nd[i].second]) dfs(nd[i].second);
}
bool check(int m) {
memset(u, 0, sizeof(u)); l = 0;
rep(i,1,n)
nd[i*2-1] = mp(x[i], B + (i << 1)),
nd[i*2] = mp(y[i],B + ((i << 1) | 1));
sort(nd + 1, nd + 2 * n + 1);
build(1, 1, n * 2);
rep(i,1,n * 2) {
int t = lower_bound(nd + 1, nd + n * 2 + 1, mp(nd[i].first - m + 1, 0)) - nd;
a = t, b = i - 1, c = nd[i].second; if (a <= b) modi(1, 1, n * 2);
t = lower_bound(nd + 1, nd + n * 2 + 1, mp(nd[i].first + m - 1, int(1e9))) - nd;
a = i + 1, b = t - 1, c = nd[i].second; if (a <= b) modi(1, 1, n * 2);
}
tarjan();
rep(i,1,2 * n) if (scc[nd[i].second] == scc[nd[i].second ^ 1]) return false;
return true;
}
int main() {
scanf("%d",&n); rep(i,1,n) scanf("%d%d",&x[i],&y[i]);
int l = 0, r = 1e9 + 1;
while (l + 1 < r) {
int m = (l + r) >> 1;
if (check(m)) l = m; else r = m;
}
printf("%d\n",l);
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Toad Rash has a binary string s. A binary string consists only of zeros and ones.
Let n be the length of s.
Rash needs to find the number of such pairs of integers l, r that 1 ≤ l ≤ r ≤ n and there is at least one pair of integers x, k such that 1 ≤ x, k ≤ n, l ≤ x < x + 2k ≤ r, and s_x = s_{x+k} = s_{x+2k}.
Find this number of pairs for Rash.
Input
The first line contains the string s (1 ≤ |s| ≤ 300 000), consisting of zeros and ones.
Output
Output one integer: the number of such pairs of integers l, r that 1 ≤ l ≤ r ≤ n and there is at least one pair of integers x, k such that 1 ≤ x, k ≤ n, l ≤ x < x + 2k ≤ r, and s_x = s_{x+k} = s_{x+2k}.
Examples
Input
010101
Output
3
Input
11001100
Output
0
Note
In the first example, there are three l, r pairs we need to count: 1, 6; 2, 6; and 1, 5.
In the second example, there are no values x, k for the initial string, so the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
long long ans = 0;
int r = n;
for (int i = n - 1; i >= 0; i--) {
for (int k = 1; i + 2 * k < r; k++)
if (s[i] == s[i + k] && s[i] == s[i + 2 * k]) {
r = i + 2 * k;
break;
}
ans += n - r;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
An autumn sports festival is held. There are four events: foot race, ball-carrying, obstacle race, and relay. There are n teams participating, and we would like to commend the team with the shortest total time in this 4th event as the "winner", the next smallest team as the "runner-up", and the second team from the bottom as the "booby prize". think.
Create a program that outputs the teams of "Winner", "Runner-up", and "Booby Award" by inputting the results of each team. However, each team is assigned a team number from 1 to n.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
record1
record2
::
recordn
The first line gives the number of teams of interest n (4 ≤ n ≤ 100000), and the following n lines give information about the i-th team. Information for each team is given in the following format:
id m1 s1 m2 s2 m3 s3 m4 s4
id (1 ≤ id ≤ n) is the team number, m1 and s1 are the minutes and seconds of the foot race time, m2 and s2 are the minutes and seconds of the ball-carrying time, and m3 and s3 are the time of the obstacle race. Minutes and seconds, m4 and s4 represent minutes and seconds of relay time, respectively. Both minutes and seconds are integers between 0 and 59. Also, assume that no input is such that the total time is the same for multiple teams.
Output
The team number is output in the following format for each input dataset.
1st line winning team number
2nd line 2nd place team number
Line 3 Booby Award Team Number
Example
Input
8
34001 3 20 3 8 6 27 2 25
20941 3 5 2 41 7 19 2 42
90585 4 8 3 12 6 46 2 34
92201 3 28 2 47 6 37 2 58
10001 3 50 2 42 7 12 2 54
63812 4 11 3 11 6 53 2 22
54092 3 33 2 54 6 18 2 19
25012 3 44 2 58 6 45 2 46
4
1 3 23 1 23 1 34 4 44
2 5 12 2 12 3 41 2 29
3 5 24 1 24 2 0 3 35
4 4 49 2 22 4 41 4 23
0
Output
54092
34001
10001
1
3
2
### Response
```cpp
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int a, b, n;
pair<int, int>x[8000000];
int main() {
while (true) {
memset(x, 0, sizeof(x));
cin >> n;
if (n == 0) { break; }
for (int i = 0; i < n; i++) {
cin >> x[i].second;
for (int j = 0; j < 4; j++) {
cin >> a >> b;
x[i].first += a * 60 + b;
}
}
sort(x, x + n);
cout << x[0].second << endl << x[1].second << endl << x[n - 2].second << endl;
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Lenny is playing a game on a 3 × 3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the lights off. We consider the toggling as follows: if the light was switched on then it will be switched off, if it was switched off then it will be switched on.
Lenny has spent some time playing with the grid and by now he has pressed each light a certain number of times. Given the number of times each light is pressed, you have to print the current state of each light.
Input
The input consists of three rows. Each row contains three integers each between 0 to 100 inclusive. The j-th number in the i-th row is the number of times the j-th light of the i-th row of the grid is pressed.
Output
Print three lines, each containing three characters. The j-th character of the i-th line is "1" if and only if the corresponding light is switched on, otherwise it's "0".
Examples
Input
1 0 0
0 0 0
0 0 1
Output
001
010
100
Input
1 0 1
8 8 8
2 0 3
Output
010
011
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline const T MAX(T a, T b) {
return ((a) > (b) ? (a) : (b));
}
template <typename T>
inline const T MIN(T a, T b) {
return ((a) > (b) ? (b) : (a));
}
template <typename T>
inline const T ABS(T a) {
return (((a) > 0) ? (a) : (-(a)));
}
int adjacent[5][2] = {{0, 0}, {0, -1}, {0, 1}, {1, 0}, {-1, 0}};
vector<vector<int> > bulb;
void press(int y, int x) {
for (int i = 0; i < 5; ++i) {
int dy = y + adjacent[i][0], dx = x + adjacent[i][1];
if (dy < 0 || dx < 0 || dy > 2 || dx > 2) continue;
bulb[dy][dx] = (bulb[dy][dx] == 1) ? 0 : 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<vector<int> > pressed = vector<vector<int> >(3, vector<int>(3, 0));
for (int i = 0; i < (int)3; ++i)
for (int j = 0; j < (int)3; ++j) cin >> pressed[i][j];
bulb = vector<vector<int> >(3, vector<int>(3, 1));
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (pressed[i][j] & 1) press(i, j);
}
}
for (int i = 0; i < (int)3; ++i) {
for (int j = 0; j < (int)3; ++j) cout << bulb[i][j];
cout << endl;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Karl is developing a key storage service. Each user has a positive integer key.
Karl knows that storing keys in plain text is bad practice. So, instead of storing a key, he decided to store a fingerprint of a key. However, using some existing fingerprint algorithm looked too boring to him, so he invented his own one.
Karl's fingerprint is calculated by the following process: divide the given integer by 2, then divide the result by 3, then divide the result by 4, and so on, until we get a result that equals zero (we are speaking about integer division each time). The fingerprint is defined as the multiset of the remainders of these divisions.
For example, this is how Karl's fingerprint algorithm is applied to the key 11: 11 divided by 2 has remainder 1 and result 5, then 5 divided by 3 has remainder 2 and result 1, and 1 divided by 4 has remainder 1 and result 0. Thus, the key 11 produces the sequence of remainders [1, 2, 1] and has the fingerprint multiset \{1, 1, 2\}.
Ksenia wants to prove that Karl's fingerprint algorithm is not very good. For example, she found that both keys 178800 and 123456 produce the fingerprint of \{0, 0, 0, 0, 2, 3, 3, 4\}. Thus, users are at risk of fingerprint collision with some commonly used and easy to guess keys like 123456.
Ksenia wants to make her words more persuasive. She wants to calculate the number of other keys that have the same fingerprint as the keys in the given list of some commonly used keys. Your task is to help her.
Input
The first line contains an integer t (1 ≤ t ≤ 50 000) — the number of commonly used keys to examine. Each of the next t lines contains one integer k_i (1 ≤ k_i ≤ 10^{18}) — the key itself.
Output
For each of the keys print one integer — the number of other keys that have the same fingerprint.
Example
Input
3
1
11
123456
Output
0
1
127
Note
The other key with the same fingerprint as 11 is 15. 15 produces a sequence of remainders [1, 1, 2]. So both numbers have the fingerprint multiset \{1, 1, 2\}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
vector<vector<long long> > c(31, vector<long long>(31, 0));
c[0][0] = 1;
for (int i = 1; i <= 30; i++) {
c[i][0] = 1;
for (int j = 1; j <= 30; j++) c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
int t;
cin >> t;
while (t--) {
long long k;
cin >> k;
vector<int> key;
for (int i = 2; k; i++) {
key.emplace_back(k % i);
k /= i;
}
vector<int> num((int)key.size() + 1, 0);
for (auto i : key) num[i]++;
auto cal = [&](int n) -> long long {
if (n == 0) return 0;
long long ans = 1;
int placed = 0;
for (int i = (int)key.size(); i; i--) {
if (!num[i]) continue;
if (n - placed - i + 1 < num[i]) return 0;
ans *= c[n - placed - i + 1][num[i]];
placed += num[i];
}
return ans;
};
long long res = cal((int)key.size());
num[0]--;
res -= cal((int)key.size() - 1);
cout << res - 1 << '\n';
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Once when Gerald studied in the first year at school, his teacher gave the class the following homework. She offered the students a string consisting of n small Latin letters; the task was to learn the way the letters that the string contains are written. However, as Gerald is too lazy, he has no desire whatsoever to learn those letters. That's why he decided to lose some part of the string (not necessarily a connected part). The lost part can consist of any number of segments of any length, at any distance from each other. However, Gerald knows that if he loses more than k characters, it will be very suspicious.
Find the least number of distinct characters that can remain in the string after no more than k characters are deleted. You also have to find any possible way to delete the characters.
Input
The first input data line contains a string whose length is equal to n (1 ≤ n ≤ 105). The string consists of lowercase Latin letters. The second line contains the number k (0 ≤ k ≤ 105).
Output
Print on the first line the only number m — the least possible number of different characters that could remain in the given string after it loses no more than k characters.
Print on the second line the string that Gerald can get after some characters are lost. The string should have exactly m distinct characters. The final string should be the subsequence of the initial string. If Gerald can get several different strings with exactly m distinct characters, print any of them.
Examples
Input
aaaaa
4
Output
1
aaaaa
Input
abacaba
4
Output
1
aaaa
Input
abcdefgh
10
Output
0
Note
In the first sample the string consists of five identical letters but you are only allowed to delete 4 of them so that there was at least one letter left. Thus, the right answer is 1 and any string consisting of characters "a" from 1 to 5 in length.
In the second sample you are allowed to delete 4 characters. You cannot delete all the characters, because the string has length equal to 7. However, you can delete all characters apart from "a" (as they are no more than four), which will result in the "aaaa" string.
In the third sample you are given a line whose length is equal to 8, and k = 10, so that the whole line can be deleted. The correct answer is 0 and an empty string.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int cmp(pair<char, int> a, pair<char, int> b) { return a.second < b.second; }
int main() {
string str;
cin >> str;
int k;
cin >> k;
if (k >= str.length()) {
cout << 0 << endl << endl;
return 0;
}
pair<char, int> c[26];
for (int i = 0; i < 26; i++) {
c[i] = make_pair(char(i + 'a'), 0);
}
for (int i = 0; i < str.length(); i++) {
int ind = str[i] - 'a';
c[ind].second++;
}
sort(c, c + 26, cmp);
map<char, int> toDel;
for (int i = 0; i < 26; i++)
if (k > 0 && c[i].second > 0) {
char q = c[i].first;
toDel[q] = min(c[i].second, k);
k -= c[i].second;
}
string ans = "";
set<char> x;
for (int i = 0; i < str.length(); i++) {
if (toDel[str[i]] > 0) {
toDel[str[i]]--;
} else {
ans += str[i];
x.insert(str[i]);
}
}
cout << x.size() << endl;
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given an integer n (n > 1).
Your task is to find a sequence of integers a_1, a_2, …, a_k such that:
* each a_i is strictly greater than 1;
* a_1 ⋅ a_2 ⋅ … ⋅ a_k = n (i. e. the product of this sequence is n);
* a_{i + 1} is divisible by a_i for each i from 1 to k-1;
* k is the maximum possible (i. e. the length of this sequence is the maximum possible).
If there are several such sequences, any of them is acceptable. It can be proven that at least one valid sequence always exists for any integer n > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 5000) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (2 ≤ n ≤ 10^{10}).
It is guaranteed that the sum of n does not exceed 10^{10} (∑ n ≤ 10^{10}).
Output
For each test case, print the answer: in the first line, print one positive integer k — the maximum possible length of a. In the second line, print k integers a_1, a_2, …, a_k — the sequence of length k satisfying the conditions from the problem statement.
If there are several answers, you can print any. It can be proven that at least one valid sequence always exists for any integer n > 1.
Example
Input
4
2
360
4999999937
4998207083
Output
1
2
3
2 2 90
1
4999999937
1
4998207083
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using namespace std::chrono;
#define fast_io ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define F first
#define S second
#define pb push_back
#define mk make_pair
#define fp(i,a,b) for (int i = a; i <b; i++)
#define fn(i,a,b) for (int i = a; i >b; i--)
#define mod 1000000007
#define multiple_testcases_t int t;cin>>t;while(t--){solve();}
#define single_testcase_t solve();
typedef long long int ll;
typedef pair<int,int> pii;
// <----- Actual solve() function to print output -----> //
void solve()
{
ll n,m,ans=INT_MIN,my_num;
cin>>n;
m=n;
map<ll,ll> mp;
while(n%2==0)
{
n/=2;
mp[2]++;
my_num=2;
ans=max(ans,mp[2]);
}
for(ll i=3;i<=sqrt(n);i+=2)
{
while(n%i==0)
{
n/=i;
mp[i]++;
if(ans<mp[i])
{
ans=mp[i];
my_num=i;
}
}
}
if(n>2)
{
mp[n]++;
if(ans<mp[n])
{
ans=mp[n];
my_num=n;
}
}
cout<<ans<<"\n";
while(mp[my_num]>1)
{
cout<<my_num<<" ";
m/=my_num;
mp[my_num]--;
}
cout<<m;
cout<<"\n"; //if t>1 uncomment this
}
// MAIN function --------------------------------------------------------------------------//
int main()
{
// auto start = high_resolution_clock::now();
fast_io
//func();
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// single_testcase_t //Uncomment this if only single testcase & single answer to print
multiple_testcases_t //Uncomment this if t>1(t is given in question)(multiple testcases)
// auto stop = high_resolution_clock::now();
// auto duration = duration_cast<microseconds>(stop - start);
// cout << "Time taken by function: "
// << duration.count() << " microseconds" << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Natalia Romanova is trying to test something on the new gun S.H.I.E.L.D gave her. In order to determine the result of the test, she needs to find the number of answers to a certain equation. The equation is of form:
<image>
Where <image> represents logical OR and <image> represents logical exclusive OR (XOR), and vi, j are some boolean variables or their negations. Natalia calls the left side of the equation a XNF formula. Each statement in brackets is called a clause, and vi, j are called literals.
In the equation Natalia has, the left side is actually a 2-XNF-2 containing variables x1, x2, ..., xm and their negations. An XNF formula is 2-XNF-2 if:
1. For each 1 ≤ i ≤ n, ki ≤ 2, i.e. the size of each clause doesn't exceed two.
2. Each variable occurs in the formula at most two times (with negation and without negation in total). Please note that it's possible that a variable occurs twice but its negation doesn't occur in any clause (or vice versa).
Natalia is given a formula of m variables, consisting of n clauses. Please, make sure to check the samples in order to properly understand how the formula looks like.
Natalia is more into fight than theory, so she asked you to tell her the number of answers to this equation. More precisely, you need to find the number of ways to set x1, ..., xm with true and false (out of total of 2m ways) so that the equation is satisfied. Since this number can be extremely large, you need to print the answer modulo 109 + 7.
Please, note that some variable may appear twice in one clause, or not appear in the equation at all (but still, setting it to false or true gives different ways to set variables).
Input
The first line of input contains two integers n and m (1 ≤ n, m ≤ 100 000) — the number of clauses and the number of variables respectively.
The next n lines contain the formula. The i-th of them starts with an integer ki — the number of literals in the i-th clause. It is followed by ki non-zero integers ai, 1, ..., ai, ki. If ai, j > 0 then vi, j is xai, j otherwise it's negation of x - ai, j (1 ≤ ki ≤ 2, - m ≤ ai, j ≤ m, ai, j ≠ 0).
Output
Print the answer modulo 1 000 000 007 (109 + 7) in one line.
Examples
Input
6 7
2 4 -2
2 6 3
2 -7 1
2 -5 1
2 3 6
2 -2 -5
Output
48
Input
8 10
1 -5
2 4 -6
2 -2 -6
2 -7 9
2 10 -1
2 3 -1
2 -8 9
2 5 8
Output
544
Input
2 3
2 1 1
2 -3 3
Output
4
Note
The equation in the first sample is:
<image>
The equation in the second sample is:
<image>
The equation in the third sample is:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, mod = 1e9 + 7;
int fl[N], la[N], V[N], c[N];
int pr[N], to[N], pdu, pdv;
int cnt = 1, m, n, u, v, ans0, ans1, vis[N], f[N][2][2], del, x, y;
inline void ins(int x, int y, int z) {
to[++cnt] = y;
pr[cnt] = la[x];
la[x] = cnt;
V[cnt] = z;
}
inline void add(int x, int y, int v1, int v2) {
x = abs(x);
y = abs(y);
ins(x, y, v1);
ins(y, x, v2);
}
int check(int x, int y, int z) {
if (!(z & 2)) x ^= 1;
if (!(z & 1)) y ^= 1;
return x | y;
}
void dfs(int x, int fr) {
vis[x] = 1;
for (int i = la[x]; i; i = pr[i])
if (!vis[to[i]])
dfs(to[i], i);
else if (i != (fr ^ 1)) {
u = x;
v = to[i];
del = i;
}
}
void tdp(int x, int fa) {
for (int i = la[x]; i; i = pr[i])
if (to[i] != fa && (i ^ del) && (i ^ del ^ 1))
if (to[i] != fa && (i ^ del) && (i ^ del ^ 1)) tdp(to[i], x);
memset(f[x], 0, sizeof(f[x]));
for (int w = 0; w < 2; ++w) {
if (x == u && w != pdu) continue;
if (x == v && w != pdv) continue;
int ans0 = 1, ans1 = 0;
for (int i = la[x]; i; i = pr[i]) {
if (to[i] == fa || !(i ^ del) || !(i ^ del ^ 1)) continue;
int an0 = ans0, an1 = ans1;
ans0 = 0;
ans1 = 0;
for (int w1 = 0; w1 < 2; ++w1) {
int A = f[to[i]][w1][0], B = f[to[i]][w1][1];
if (check(w, w1, V[i])) swap(A, B);
ans0 = (ans0 + (long long)A * an0 + (long long)B * an1) % mod;
ans1 = (ans1 + (long long)A * an1 + (long long)B * an0) % mod;
}
}
if (fl[x] & (1 << w)) swap(ans0, ans1);
f[x][w][0] = (f[x][w][0] + ans0) % mod;
f[x][w][1] = (f[x][w][1] + ans1) % mod;
}
}
void work(int x) {
cnt = 0;
del = -2;
dfs(x, -1);
int an0 = 0, an1 = 0;
if (del == -2) {
v = 0;
u = x;
pdu = 0;
pdv = 1;
tdp(x, 0);
an0 = (an0 + (long long)f[x][0][0] + f[x][1][0]) % mod;
an1 = (an1 + (long long)f[x][0][1] + f[x][1][1]) % mod;
pdu = 1;
tdp(x, 0);
an0 = (an0 + (long long)f[x][0][0] + f[x][1][0]) % mod;
an1 = (an1 + (long long)f[x][0][1] + f[x][1][1]) % mod;
} else {
for (pdu = 0; pdu < 2; ++pdu)
for (pdv = 0; pdv < 2; ++pdv) {
tdp(u, 0);
if (check(pdu, pdv, V[del])) {
swap(f[u][0][0], f[u][0][1]);
swap(f[u][1][0], f[u][1][1]);
}
an0 = (an0 + (long long)f[u][0][0] + f[u][1][0]) % mod;
an1 = (an1 + (long long)f[u][0][1] + f[u][1][1]) % mod;
}
}
int k0 = ans0, k1 = ans1;
ans0 = ((long long)an0 * k0 + (long long)an1 * k1) % mod;
ans1 = ((long long)an0 * k1 + (long long)an1 * k0) % mod;
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= m; ++i) {
scanf("%d", &x);
if (x == 1) {
scanf("%d", &y);
if (y > 0)
fl[y] |= 2;
else
fl[-y] |= 1;
} else {
scanf("%d%d", &x, &y);
if (x < 0) {
if (y < 0)
add(x, y, 0, 0);
else
add(x, y, 1, 2);
} else {
if (y < 0)
add(x, y, 2, 1);
else
add(x, y, 3, 3);
}
}
}
ans0 = 1;
ans1 = 0;
for (int i = 1; i <= n; ++i)
if (!vis[i]) work(i);
cout << ans1;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (n > m) {
swap(n, m);
}
if (n % 2 == 0) {
cout << "Malvika" << endl;
} else {
cout << "Akshat" << endl;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There is an empty array. The following N operations will be performed to insert integers into the array. In the i-th operation (1≤i≤N), b_i copies of an integer a_i are inserted into the array. Find the K-th smallest integer in the array after the N operations. For example, the 4-th smallest integer in the array \\{1,2,2,3,3,3\\} is 3.
Constraints
* 1≤N≤10^5
* 1≤a_i,b_i≤10^5
* 1≤K≤b_1…+…b_n
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
a_1 b_1
:
a_N b_N
Output
Print the K-th smallest integer in the array after the N operations.
Examples
Input
3 4
1 1
2 2
3 3
Output
3
Input
10 500000
1 100000
1 100000
1 100000
1 100000
1 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
Output
1
### Response
```cpp
#include<iostream>
#include<vector>
using namespace std;
using ll = long long;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> a(n), b(n), c(100002);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[a[i]] += b[i];
}
for (int i = 1; i < 100003; i++) {
if (k <= c[i]) {
cout << i << endl;
return 0;
}
k -= c[i];
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Now Fox Ciel becomes a commander of Tree Land. Tree Land, like its name said, has n cities connected by n - 1 undirected roads, and for any two cities there always exists a path between them.
Fox Ciel needs to assign an officer to each city. Each officer has a rank — a letter from 'A' to 'Z'. So there will be 26 different ranks, and 'A' is the topmost, so 'Z' is the bottommost.
There are enough officers of each rank. But there is a special rule must obey: if x and y are two distinct cities and their officers have the same rank, then on the simple path between x and y there must be a city z that has an officer with higher rank. The rule guarantee that a communications between same rank officers will be monitored by higher rank officer.
Help Ciel to make a valid plan, and if it's impossible, output "Impossible!".
Input
The first line contains an integer n (2 ≤ n ≤ 105) — the number of cities in Tree Land.
Each of the following n - 1 lines contains two integers a and b (1 ≤ a, b ≤ n, a ≠ b) — they mean that there will be an undirected road between a and b. Consider all the cities are numbered from 1 to n.
It guaranteed that the given graph will be a tree.
Output
If there is a valid plane, output n space-separated characters in a line — i-th character is the rank of officer in the city with number i.
Otherwise output "Impossible!".
Examples
Input
4
1 2
1 3
1 4
Output
A B B B
Input
10
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
Output
D C B A D C B D C D
Note
In the first example, for any two officers of rank 'B', an officer with rank 'A' will be on the path between them. So it is a valid solution.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 17;
int n, sz[MAXN];
bool mark[MAXN];
vector<int> adj[MAXN], all;
char ans[MAXN];
void dfs_sz(int v, int par = 0) {
sz[v] = 1;
for (auto i : adj[v])
if (!mark[i] && i != par) dfs_sz(i, v), sz[v] += sz[i];
}
int centroid(int v, int par, int tree_size) {
int res = 0;
bool isok = false;
for (auto i : adj[v])
if (!mark[i] && i != par)
res = max(res, centroid(i, v, tree_size)),
isok |= (sz[i] > tree_size / 2);
isok = !isok;
if (sz[v] >= tree_size / 2 && isok) res = max(res, v);
return res;
}
void dfs(int v, int par, vector<int> &comp) {
comp.push_back(v);
for (auto i : adj[v])
if (i != par && !mark[i]) dfs(i, v, comp);
}
void DC(vector<int> &ver, int lev = 0) {
if (ver.size() == 1) {
ans[ver.back()] = 'A' + lev;
return;
}
dfs_sz(ver.back());
int C = centroid(ver.back(), 0, ver.size());
mark[C] = true;
ans[C] = 'A' + lev;
vector<int> comp;
for (auto i : adj[C])
if (!mark[i]) dfs(i, 0, comp), DC(comp, lev + 1), comp.clear();
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
adj[v].push_back(u);
adj[u].push_back(v);
all.push_back(i);
}
all.push_back(n);
DC(all);
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
The School №0 of the capital of Berland has n children studying in it. All the children in this school are gifted: some of them are good at programming, some are good at maths, others are good at PE (Physical Education). Hence, for each child we know value ti:
* ti = 1, if the i-th child is good at programming,
* ti = 2, if the i-th child is good at maths,
* ti = 3, if the i-th child is good at PE
Each child happens to be good at exactly one of these three subjects.
The Team Scientific Decathlon Olympias requires teams of three students. The school teachers decided that the teams will be composed of three children that are good at different subjects. That is, each team must have one mathematician, one programmer and one sportsman. Of course, each child can be a member of no more than one team.
What is the maximum number of teams that the school will be able to present at the Olympiad? How should the teams be formed for that?
Input
The first line contains integer n (1 ≤ n ≤ 5000) — the number of children in the school. The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 3), where ti describes the skill of the i-th child.
Output
In the first line output integer w — the largest possible number of teams.
Then print w lines, containing three numbers in each line. Each triple represents the indexes of the children forming the team. You can print both the teams, and the numbers in the triplets in any order. The children are numbered from 1 to n in the order of their appearance in the input. Each child must participate in no more than one team. If there are several solutions, print any of them.
If no teams can be compiled, print the only line with value w equal to 0.
Examples
Input
7
1 3 1 3 2 1 2
Output
2
3 5 2
6 7 4
Input
4
2 1 1 2
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, h, d1, l = 1;
cin >> n;
int t[n];
for (i = 1; i <= n; i++) {
cin >> t[i];
}
int a[n], na = 0, b[n], nb = 0, c[n], nc = 0;
for (i = 1; i <= n; i++) {
if (t[i] == 1)
a[na++] = i;
else if (t[i] == 2)
b[nb++] = i;
else
c[nc++] = i;
}
cout << min(na, min(nb, nc)) << endl;
while (na > 0 && nb > 0 && nc > 0) {
cout << a[--na] << " " << b[--nb] << " " << c[--nc] << endl;
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Find a cycle in a directed graph G(V, E).
Constraints
* 1 ≤ |V| ≤ 100
* 0 ≤ |E| ≤ 1,000
* si ≠ ti
Input
A directed graph G is given in the following format:
|V| |E|
s0 t0
s1 t1
:
s|E|-1 t|E|-1
|V| is the number of nodes and |E| is the number of edges in the graph. The graph nodes are named with the numbers 0, 1,..., |V|-1 respectively.
si and ti represent source and target nodes of i-th edge (directed).
Output
Print 1 if G has cycle(s), 0 otherwise.
Examples
Input
3 3
0 1
0 2
1 2
Output
0
Input
3 3
0 1
1 2
2 0
Output
1
### Response
```cpp
#include <iostream>
#include <vector>
#include <cstring>
const int N = 100 + 1;
std::vector<int> G[N];
int vis[N];
bool go(int v) {
bool f = false;
vis[v] = 1;
for (auto &d : G[v]) {
if (vis[d] == 1) return true;
if (vis[d] == 2) continue;
f |= go(d);
}
vis[v] = 2;
return f;
}
int main() {
int n, e;
while (std::cin >> n >> e) {
for (int i = 0; i < N; ++i) G[i].clear();
memset(vis, 0, sizeof(vis));
for (int i = 0; i < e; ++i) {
int s, t;
std::cin >> s >> t;
G[s].emplace_back(t);
}
bool flag = false;
for (int i = 0; i < n; ++i) {
if (vis[i] == 2) continue;
flag |= go(i);
}
std::cout << flag << std::endl;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Before the start of the football season in Berland a strange magic ritual is held. The most experienced magicians have to find a magic matrix of the size n × n (n is even number). Gods will never allow to start the championship without it. Matrix should contain integers from 0 to n - 1, main diagonal should contain only zeroes and matrix should be symmetric. Moreover, all numbers in each row should be different. Magicians are very tired of the thinking process, so they ask you to write a program to find such matrix.
Input
The first line contains one integer n (2 ≤ n ≤ 1000), n is even.
Output
Output n lines with n numbers each — the required matrix. Separate numbers with spaces. If there are several solutions, output any.
Examples
Input
2
Output
0 1
1 0
Input
4
Output
0 1 3 2
1 0 2 3
3 2 0 1
2 3 1 0
### Response
```cpp
#include <bits/stdc++.h>
int mat[1000][1000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (int)(n - 1); i++)
for (int j = 0; j < (int)(n - 1); j++) mat[i][j] = (i + j) % (n - 1) + 1;
for (int i = 0; i < (int)(n - 1); i++) {
mat[i][n - 1] = mat[n - 1][i] = mat[i][i];
mat[i][i] = 0;
}
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
printf("%d%c", mat[i][j], j < n - 1 ? ' ' : '\n');
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:2000000")
#pragma comment(linker, "/HEAP:2000000")
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
long long m[n][n], a[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> m[i][j];
}
}
long long x = sqrt((m[0][1] * m[0][2]) / m[1][2]);
cout << x << " ";
for (int i = 1; i < n; i++) {
cout << m[0][i] / x << " ";
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Roland loves growing flowers. He has recently grown a beautiful rose at point (0, 0) of the Cartesian coordinate system. The rose is so beautiful that Roland is afraid that the evil forces can try and steal it.
To protect the rose, Roland wants to build n watch towers. Let's assume that a tower is a point on the plane at the distance of at most r from the rose. Besides, Roland assumes that the towers should be built at points with integer coordinates and the sum of squares of distances between all pairs of towers must be as large as possible. Note, that Roland may build several towers at the same point, also he may build some of them at point (0, 0).
Help Roland build the towers at the integer points so that the sum of squares of distances between all towers is maximum possible. Note that the distance in this problem is defined as the Euclidian distance between points.
Input
The first line contains two integers, n and r (2 ≤ n ≤ 8; 1 ≤ r ≤ 30).
Output
In the first line print an integer — the maximum possible sum of squared distances. In the i-th of the following n lines print two integers, xi, yi — the coordinates of the i-th tower. Each tower must be inside or on the border of the circle with radius r. Note that there may be several towers located at the same point of the plane, also some towers can be located at point (0, 0).
If there are multiple valid optimal arrangements, choose any of them.
Examples
Input
4 1
Output
16
0 1
0 1
0 -1
0 -1
Input
3 6
Output
312
0 6
5 -3
-5 -3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
friend bool operator<(const Point& a, const Point& b) {
return a.x * a.x + a.y * a.y > b.x * b.x + b.y * b.y;
}
};
int n, r, sz;
vector<Point> p;
int vis[10], choose[10], ans;
void dfs(int pos, int now) {
if (now == 0) {
int sum = 0;
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++)
sum += (p[vis[i]].x - p[vis[j]].x) * (p[vis[i]].x - p[vis[j]].x) +
(p[vis[i]].y - p[vis[j]].y) * (p[vis[i]].y - p[vis[j]].y);
}
if (sum > ans) {
ans = sum;
for (int i = 1; i <= n; i++) choose[i] = vis[i];
}
return;
}
for (int i = pos; i < sz; i++) {
vis[now] = i;
dfs(i, now - 1);
}
}
int main() {
scanf("%d%d", &n, &r);
for (int i = -r; i <= r; i++) {
for (int j = -r; j <= r; j++) {
if (i * i + j * j <= r * r) p.push_back({i, j});
}
}
sort(p.begin(), p.end());
sz = min(17, (int)p.size());
ans = 0;
dfs(0, n);
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
printf("%d %d\n", p[choose[i]].x, p[choose[i]].y);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Snuke loves colorful balls. He has a total of N×K balls, K in each of his favorite N colors. The colors are numbered 1 through N.
He will arrange all of the balls in a row from left to right, in arbitrary order. Then, for each of the N colors, he will paint the leftmost ball of that color into color 0, a color different from any of the N original colors.
After painting, how many sequences of the colors of the balls are possible? Find this number modulo 10^9+7.
Constraints
* 1≤N,K≤2,000
Input
The input is given from Standard Input in the following format:
N K
Output
Print the number of the possible sequences of the colors of the balls after painting, modulo 10^9+7.
Examples
Input
2 2
Output
4
Input
3 1
Output
1
Input
2 3
Output
14
Input
2000 2000
Output
546381702
### Response
```cpp
#pragma GCC optimize(3)
#include <cstdio>
const int N = 2010;
const int mod = 1e9 + 7;
int n, k, fac[N * N], inv[N * N], f[N][N];
inline int C(int x, int y) {
return 1ll * fac[x] * inv[y] % mod * inv[x - y] % mod;
}
int main() {
scanf("%d%d", &n, &k);
if (k == 1) {
puts("1");
return 0;
}
fac[0] = fac[1] = 1; for (int i = 2; i <= n * k; ++ i) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[0] = inv[1] = 1; for (int i = 2; i <= n * k; ++ i) inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 2; i <= n * k; ++ i) inv[i] = 1ll * inv[i] * inv[i - 1] % mod;
for (int i = 0; i <= n; ++ i) f[i][0] = 1;
for (int i = 1; i <= n; ++ i)
for (int j = 1; j <= i; ++ j) {
f[i][j] = (f[i - 1][j] + (1ll * f[i][j - 1] * (n - j + 1) % mod * C(n - i + (n - j + 1) * (k - 1) - 1, k - 2) % mod)) % mod;
}
printf("%d\n", f[n][n]);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Vadim loves decorating the Christmas tree, so he got a beautiful garland as a present. It consists of n light bulbs in a single row. Each bulb has a number from 1 to n (in arbitrary order), such that all the numbers are distinct. While Vadim was solving problems, his home Carp removed some light bulbs from the garland. Now Vadim wants to put them back on.
<image>
Vadim wants to put all bulb back on the garland. Vadim defines complexity of a garland to be the number of pairs of adjacent bulbs with numbers with different parity (remainder of the division by 2). For example, the complexity of 1 4 2 3 5 is 2 and the complexity of 1 3 5 7 6 4 2 is 1.
No one likes complexity, so Vadim wants to minimize the number of such pairs. Find the way to put all bulbs back on the garland, such that the complexity is as small as possible.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of light bulbs on the garland.
The second line contains n integers p_1,\ p_2,\ …,\ p_n (0 ≤ p_i ≤ n) — the number on the i-th bulb, or 0 if it was removed.
Output
Output a single number — the minimum complexity of the garland.
Examples
Input
5
0 5 0 2 3
Output
2
Input
7
1 0 0 5 0 0 2
Output
1
Note
In the first example, one should place light bulbs as 1 5 4 2 3. In that case, the complexity would be equal to 2, because only (5, 4) and (2, 3) are the pairs of adjacent bulbs that have different parity.
In the second case, one of the correct answers is 1 7 3 5 6 4 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[101], complexity, first, last;
int used[101];
int p[2];
vector<int> h[2], m[2];
int main() {
cin >> n;
if (n == 1) {
cout << 0;
return 0;
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
used[a[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (used[i]) continue;
p[i % 2]++;
}
if (p[0] + p[1] == n) {
cout << 1;
return 0;
}
for (int i = 0; i < n; ++i) {
if (a[i] == 0) continue;
first = i;
break;
}
for (int i = n - 1; i >= 0; --i) {
if (a[i] == 0) continue;
last = i;
break;
}
if (first > 0) m[a[first] % 2].push_back(first);
if (last < n - 1) m[a[last] % 2].push_back(n - 1 - last);
int prev = a[first], size = 0;
for (int i = first + 1; i < n; i++) {
if (a[i] == 0) {
size++;
} else {
bool same_parity = prev % 2 == a[i] % 2;
complexity += !same_parity;
if (same_parity && size > 0) h[a[i] % 2].push_back(size);
prev = a[i];
size = 0;
}
}
for (int i = 0; i < 2; ++i) {
sort(h[i].begin(), h[i].end());
for (auto hole_size : h[i]) {
if (hole_size > p[i])
complexity += 2;
else
p[i] -= hole_size;
}
sort(m[i].begin(), m[i].end());
for (auto hole_size : m[i]) {
if (hole_size > p[i])
complexity += 1;
else
p[i] -= hole_size;
}
}
cout << complexity;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Ikta loves fast programs. Recently, I'm trying to speed up the division program. However, it doesn't get much faster, so I thought it would be better to make it faster only for "common sense and typical" inputs. The problem Ikta is trying to solve is as follows.
For a given non-negative integer n, divide p (n) − 1-digit positive integer 11 ... 1 by p (n) in decimal notation. However, p (n) represents the smallest prime number larger than 22 {... 2} (n 2). Let p (0) = 2.
Your job is to complete the program faster than Ikta.
Input
The input is given in the following format.
n
Given the non-negative integer n of the input in question.
Constraints
Each variable being input satisfies the following constraints.
* 0 ≤ n <1000
Output
Print the solution to the problem on one line.
Examples
Input
0
Output
1
Input
1
Output
2
Input
2
Output
1
### Response
```cpp
#include <algorithm>
#include <cmath>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
//#define LOG(...)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define RSORT(c) sort((c).rbegin(),(c).rend())
#define CLR(a) memset((a), 0 ,sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[] = { -1, 0, 1, 0 }; const int dy[] = { 0, 1, 0, -1 };
struct UnionFind {
vector<int> v;
UnionFind(int n) : v(n) { for (int i = 0; i < n; i++) v[i] = i; }
int find(int x) { return v[x] == x ? x : v[x] = find(v[x]); }
void unite(int x, int y) { v[find(x)] = find(y); }
};
int main() {
int n;
cin >> n;
if (n == 0)
cout << 1 << endl;
if (n == 1)
cout << 2 << endl;
if (n == 2)
cout << 1 << endl;
if (n >=3)
cout << 0 << endl;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Recently Vasya found a golden ticket — a sequence which consists of n digits a_1a_2... a_n. Vasya considers a ticket to be lucky if it can be divided into two or more non-intersecting segments with equal sums. For example, ticket 350178 is lucky since it can be divided into three segments 350, 17 and 8: 3+5+0=1+7=8. Note that each digit of sequence should belong to exactly one segment.
Help Vasya! Tell him if the golden ticket he found is lucky or not.
Input
The first line contains one integer n (2 ≤ n ≤ 100) — the number of digits in the ticket.
The second line contains n digits a_1 a_2 ... a_n (0 ≤ a_i ≤ 9) — the golden ticket. Digits are printed without spaces.
Output
If the golden ticket is lucky then print "YES", otherwise print "NO" (both case insensitive).
Examples
Input
5
73452
Output
YES
Input
4
1248
Output
NO
Note
In the first example the ticket can be divided into 7, 34 and 52: 7=3+4=5+2.
In the second example it is impossible to divide ticket into segments with equal sum.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
bool flag = 0;
string c;
int a[105];
cin >> x;
cin >> c;
for (int i = 1; i <= x; i++) a[i] = c[i - 1] - '0';
for (int i = 0; i <= 450; i++) {
int sum = 0, ans = 0;
for (int j = 1; j <= x; j++) {
sum += a[j];
if (sum == i)
sum = 0, ans++;
else if (sum > i)
break;
}
if (sum == 0 && ans >= 2) {
flag = 1;
break;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya has n number segments [l1; r1], [l2; r2], ..., [ln; rn]. During one move Petya can take any segment (let it be segment number i) and replace it with segment [li + 1; ri + 1] or [li - 1; ri - 1]. In other words, during one move Petya can shift any segment to the left or to the right by a unit distance. Petya calls a number full if it belongs to each segment. That is, number x is full if for any i (1 ≤ i ≤ n) the condition li ≤ x ≤ ri is fulfilled.
Petya makes no more than k moves. After that he counts the quantity of full lucky numbers. Find the maximal quantity that he can get.
Input
The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 1018) — the number of segments and the maximum number of moves. Next n lines contain pairs of integers li and ri (1 ≤ li ≤ ri ≤ 1018).
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the %I64d specificator.
Output
Print on the single line the single number — the answer to the problem.
Examples
Input
4 7
1 4
6 9
4 7
3 5
Output
1
Input
2 7
40 45
47 74
Output
2
Note
In the first sample Petya shifts the second segment by two units to the left (it turns into [4; 7]), after that number 4 becomes full.
In the second sample Petya shifts the first segment by two units to the right (it turns into [42; 47]), and shifts the second segment by three units to the left (it turns into [44; 71]), after that numbers 44 and 47 become full.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const long long Max = 1100000000000000000LL;
struct Tnode {
long long l, r;
};
long long a[600000];
long long s1[600000], s2[600000];
Tnode p[110000];
int tot, n;
long long m;
void Prepare(long long now, int x, int y) {
if (x == y) {
a[++tot] = now;
return;
}
Prepare(now * 10 + (long long)4, x + 1, y);
Prepare(now * 10 + (long long)7, x + 1, y);
}
bool Cmp1(Tnode A, Tnode B) { return A.r < B.r; }
bool Cmp2(Tnode A, Tnode B) { return A.l > B.l; }
void Add(long long &xx, long long yy) {
xx += yy;
if (xx >= Max) xx = Max;
}
long long Mul(long long xx, long long yy) {
if (!xx || !yy) return 0;
if (Max / xx < yy) return Max;
return xx * yy;
}
int main() {
tot = 0;
for (int i = 1; i <= 18; ++i) Prepare(0, 0, i);
scanf("%d%I64d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%I64d%I64d", &p[i].l, &p[i].r);
sort(p + 1, p + n + 1, Cmp1);
int node = 1;
memset(s1, 0, sizeof(s1));
for (int i = 1; i <= tot; ++i) {
long long D = Mul(a[i] - a[i - 1], node - 1);
Add(s1[i], s1[i - 1] + D);
while (p[node].r <= a[i] && node <= n) {
Add(s1[i], a[i] - p[node].r);
++node;
}
}
sort(p + 1, p + n + 1, Cmp2);
memset(s2, 0, sizeof(s2));
node = 1;
for (int i = tot; i >= 1; --i) {
long long D = Mul(a[i + 1] - a[i], node - 1);
Add(s2[i], s2[i + 1] + D);
while (p[node].l >= a[i] && node <= n) {
Add(s2[i], p[node].l - a[i]);
++node;
}
}
long long len = Max;
for (int i = 1; i <= n; ++i) len = min(len, p[i].r - p[i].l);
int ans = 0;
for (int i = 1; i <= tot; ++i) {
long long cost = s1[i] + s2[i];
if (cost <= m) {
cost = s1[i];
int l, r;
l = 1;
r = i;
while (l < r) {
int mid = (l + r) / 2;
if (a[i] - a[mid] > len)
l = mid + 1;
else
r = mid;
}
r = i;
while (l < r) {
int mid = (l + r) / 2;
if (cost + s2[mid] <= m)
r = mid;
else
l = mid + 1;
}
if (i - l + 1 > ans) ans = i - l + 1;
}
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (size_t i = 0; i < v.size(); ++i) {
os << v[i];
if (i + 1 != v.size()) {
os << " ";
}
}
return os;
}
void solve() {
int n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<ll> v = a;
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
--k;
int mn = v[k];
int j = k - 1;
while (j >= 0 && v[k] == v[j]) {
--j;
}
int cnt = k - j;
for (int i = 0; i < n; ++i) {
if (a[i] > mn) {
--pos;
} else if (a[i] == mn) {
if (cnt > 0) {
--pos;
--cnt;
}
}
if (pos == 0) {
cout << a[i] << "\n";
break;
}
}
}
}
int main() {
solve();
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Recently, Anton has found a set. The set consists of small English letters. Anton carefully wrote out all the letters from the set in one line, separated by a comma. He also added an opening curved bracket at the beginning of the line and a closing curved bracket at the end of the line.
Unfortunately, from time to time Anton would forget writing some letter and write it again. He asks you to count the total number of distinct letters in his set.
Input
The first and the single line contains the set of letters. The length of the line doesn't exceed 1000. It is guaranteed that the line starts from an opening curved bracket and ends with a closing curved bracket. Between them, small English letters are listed, separated by a comma. Each comma is followed by a space.
Output
Print a single number — the number of distinct letters in Anton's set.
Examples
Input
{a, b, c}
Output
3
Input
{b, a, b, a}
Output
2
Input
{}
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int dist = 0, change;
char a;
string x;
getline(cin, x);
for (int i = 1; i < x.length(); i += 3) {
a = x[i];
if (x[i] != '~' && x[i] != '}') ++dist;
while (x.find(a) != -1 && a != '~') {
change = x.find(a);
x[change] = '~';
}
}
cout << dist;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Recently, Duff has been practicing weight lifting. As a hard practice, Malek gave her a task. He gave her a sequence of weights. Weight of i-th of them is 2wi pounds. In each step, Duff can lift some of the remaining weights and throw them away. She does this until there's no more weight left. Malek asked her to minimize the number of steps.
<image>
Duff is a competitive programming fan. That's why in each step, she can only lift and throw away a sequence of weights 2a1, ..., 2ak if and only if there exists a non-negative integer x such that 2a1 + 2a2 + ... + 2ak = 2x, i. e. the sum of those numbers is a power of two.
Duff is a competitive programming fan, but not a programmer. That's why she asked for your help. Help her minimize the number of steps.
Input
The first line of input contains integer n (1 ≤ n ≤ 106), the number of weights.
The second line contains n integers w1, ..., wn separated by spaces (0 ≤ wi ≤ 106 for each 1 ≤ i ≤ n), the powers of two forming the weights values.
Output
Print the minimum number of steps in a single line.
Examples
Input
5
1 1 2 3 3
Output
2
Input
4
0 1 2 3
Output
4
Note
In the first sample case: One optimal way would be to throw away the first three in the first step and the rest in the second step. Also, it's not possible to do it in one step because their sum is not a power of two.
In the second sample case: The only optimal way is to throw away one weight in each step. It's not possible to do it in less than 4 steps because there's no subset of weights with more than one weight and sum equal to a power of two.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int f[int(1e6 + 100) + 100];
int res;
int main() {
scanf("%d", &n);
for (int i = (1), _b = (n); i <= _b; i++) {
int x;
scanf("%d", &x);
f[x]++;
}
for (int x = (0), _b = (int(1e6 + 100)); x <= _b; x++) {
f[x + 1] += f[x] / 2;
f[x] = f[x] % 2;
}
for (int x = (0), _b = (int(1e6 + 100)); x <= _b; x++) res += f[x];
cout << res << endl;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Create a program that outputs all leap years between the year a and year b.
The leap year conditions are as follows. However, 0 <a ≤ b <3,000. If there is no leap year in the given period, output "NA".
* The year is divisible by 4.
* However, a year divisible by 100 is not a leap year.
* However, a year divisible by 400 is a leap year.
Input
Given multiple datasets. The format of each dataset is as follows:
a b
Input ends when both a and b are 0. The number of datasets does not exceed 50.
Output
Print the year or NA for each dataset.
Insert one blank line between the datasets.
Example
Input
2001 2010
2005 2005
2001 2010
0 0
Output
2004
2008
NA
2004
2008
### Response
```cpp
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int a,b,c = 0;
while( cin >> a >> b , a+b){
int f = 1;
if(c)cout << endl;
for(int i = a ; i <= b ; i++){
if(i%4 == 0){
if(i%100 != 0 || i%400 == 0){
cout << i << endl;
f = 0;
}
}
}
if(f) cout << "NA" << endl;
c = 1;
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Hands that shed innocent blood!
There are n guilty people in a line, the i-th of them holds a claw with length Li. The bell rings and every person kills some of people in front of him. All people kill others at the same time. Namely, the i-th person kills the j-th person if and only if j < i and j ≥ i - Li.
You are given lengths of the claws. You need to find the total number of alive people after the bell rings.
Input
The first line contains one integer n (1 ≤ n ≤ 106) — the number of guilty people.
Second line contains n space-separated integers L1, L2, ..., Ln (0 ≤ Li ≤ 109), where Li is the length of the i-th person's claw.
Output
Print one integer — the total number of alive people after the bell rings.
Examples
Input
4
0 1 0 10
Output
1
Input
2
0 0
Output
2
Input
10
1 1 3 0 0 0 2 1 0 3
Output
3
Note
In first sample the last person kills everyone in front of him.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int gn;
int gl[1000010];
int main(int argc, char **argv) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
;
cin >> gn;
for (int i = 1; i <= gn; i++) {
cin >> gl[i];
}
int vt = 0;
for (int vi = gn, vj = gn + 1; vi >= 1; vi--) {
if (vi >= vj) {
vt++;
}
if (vi - gl[vi] < vj) vj = vi - gl[vi];
}
cout << gn - vt << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
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 s;
cin >> s;
if (s < 0) {
int a = s / 10;
int b = s / 100 * 10;
b += s % 10;
if (a > b)
cout << a;
else
cout << b;
} else
cout << s;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Let us consider a grid of squares with 10^9 rows and N columns. Let (i, j) be the square at the i-th column (1 \leq i \leq N) from the left and j-th row (1 \leq j \leq 10^9) from the bottom.
Snuke has cut out some part of the grid so that, for each i = 1, 2, ..., N, the bottom-most h_i squares are remaining in the i-th column from the left. Now, he will paint the remaining squares in red and blue. Find the number of the ways to paint the squares so that the following condition is satisfied:
* Every remaining square is painted either red or blue.
* For all 1 \leq i \leq N-1 and 1 \leq j \leq min(h_i, h_{i+1})-1, there are exactly two squares painted red and two squares painted blue among the following four squares: (i, j), (i, j+1), (i+1, j) and (i+1, j+1).
Since the number of ways can be extremely large, print the count modulo 10^9+7.
Constraints
* 1 \leq N \leq 100
* 1 \leq h_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 ... h_N
Output
Print the number of the ways to paint the squares, modulo 10^9+7.
Examples
Input
9
2 3 5 4 1 2 4 2 1
Output
12800
Input
2
2 2
Output
6
Input
5
2 1 2 1 2
Output
256
Input
9
27 18 28 18 28 45 90 45 23
Output
844733013
### Response
```cpp
#include <bits/stdc++.h>
#define mod 1000000007
#define fir first
#define sec second
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
inline int add(int x,int y){
x += y;if (x >= mod) x -= mod;
return x;
}
inline int sub(int x,int y){
x -= y;if (x < 0) x += mod;
return x;
}
inline int qpow(int x,int y){
int res = 1;
while (y){
if (y & 1) res = 1ll * res * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return res;
}
const int N = 1e5 + 10;
int n , h[N];
pii solve(int l,int r,int lim){//first not ababab second ababa
int minm = 0x3f3f3f3f , cntminm = 0 , block = 0;
for (int i = l;i <= r;i++){
if (h[i] < minm){
minm = h[i];
cntminm = 0;
}
if (h[i] == minm) cntminm++;
}
if (cntminm == r - l + 1){
// printf("%d %d %d [%d %d]\n",l,r,lim,qpow(2,r-l+1)-2,qpow(2,h[l]-lim));
return mp(qpow(2 , r - l + 1) - 2 , qpow(2 , h[l] - lim));
}
pii res = mp(1 , 1);
for (int i = l;i <= r;i++){
if (h[i] == minm) continue;
int j = i;while (j + 1 <= r && h[j + 1] != minm)j++;
pii tmp = solve(i , j , minm);
res.first = 1ll * res.first * add(tmp.first , 2ll * tmp.second % mod) % mod;
res.second = 1ll * res.second * tmp.second % mod;
block++;
i = j;
}
res.first = 1ll * qpow(2 , cntminm) * res.first % mod;
res.first = sub(res.first , 2ll * res.second % mod);
res.second = 1ll * qpow(2 , minm - lim) * res.second % mod;
// printf("%d %d %d %d %d\n",l,r,lim,res.fir,res.sec);
return res;
}
int main() {
cin >> n;
for (int i = 1;i <= n;i++) cin >> h[i];
pii res = solve(1 , n , 0);
cout<<add(res.first,res.second);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You and your n - 1 friends have found an array of integers a_1, a_2, ..., a_n. You have decided to share it in the following way: All n of you stand in a line in a particular order. Each minute, the person at the front of the line chooses either the first or the last element of the array, removes it, and keeps it for himself. He then gets out of line, and the next person in line continues the process.
You are standing in the m-th position in the line. Before the process starts, you may choose up to k different people in the line, and persuade them to always take either the first or the last element in the array on their turn (for each person his own choice, not necessarily equal for all people), no matter what the elements themselves are. Once the process starts, you cannot persuade any more people, and you cannot change the choices for the people you already persuaded.
Suppose that you're doing your choices optimally. What is the greatest integer x such that, no matter what are the choices of the friends you didn't choose to control, the element you will take from the array will be greater than or equal to x?
Please note that the friends you don't control may do their choice arbitrarily, and they will not necessarily take the biggest element available.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains three space-separated integers n, m and k (1 ≤ m ≤ n ≤ 3500, 0 ≤ k ≤ n - 1) — the number of elements in the array, your position in line and the number of people whose choices you can fix.
The second line of each test case contains n positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3500.
Output
For each test case, print the largest integer x such that you can guarantee to obtain at least x.
Example
Input
4
6 4 2
2 9 2 3 8 5
4 4 1
2 13 60 4
4 1 3
1 2 2 1
2 2 0
1 2
Output
8
4
1
1
Note
In the first test case, an optimal strategy is to force the first person to take the last element and the second person to take the first element.
* the first person will take the last element (5) because he or she was forced by you to take the last element. After this turn the remaining array will be [2, 9, 2, 3, 8];
* the second person will take the first element (2) because he or she was forced by you to take the first element. After this turn the remaining array will be [9, 2, 3, 8];
* if the third person will choose to take the first element (9), at your turn the remaining array will be [2, 3, 8] and you will take 8 (the last element);
* if the third person will choose to take the last element (8), at your turn the remaining array will be [9, 2, 3] and you will take 9 (the first element).
Thus, this strategy guarantees to end up with at least 8. We can prove that there is no strategy that guarantees to end up with at least 9. Hence, the answer is 8.
In the second test case, an optimal strategy is to force the first person to take the first element. Then, in the worst case, both the second and the third person will take the first element: you will end up with 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
char myHeap[200 * 1024 * 1024];
long long sz = 0;
void assert_tle(bool q) {
while (!q)
;
}
void *operator new(std::size_t count) {
sz += count;
assert_tle(sz <= 200 * 1024 * 1024);
return myHeap + sz - count;
}
void operator delete(void *ptr) {}
void fastIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long n, m, k;
cin >> n >> m >> k;
long long ar[n];
for (long long i = 0; i < n; i++) {
cin >> ar[i];
}
if (m <= k) {
long long ans = -1e18;
for (long long i = 0; i < m; i++) {
long long a = max(ar[i], ar[n - i - 1]);
ans = max(ans, a);
}
cout << ans;
return;
}
long long ans = -1e18;
for (long long i = 0; i <= k; i++) {
long long val = 1e18;
long long r = m - k - 1;
for (long long j = i; j < m - k + i; j++) {
long long t = max(ar[j], ar[n - (m - j)]);
val = min(val, t);
}
ans = max(ans, val);
}
cout << ans;
}
int32_t main() {
fastIO();
long long t;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Shaass has decided to hunt some birds. There are n horizontal electricity wires aligned parallel to each other. Wires are numbered 1 to n from top to bottom. On each wire there are some oskols sitting next to each other. Oskol is the name of a delicious kind of birds in Shaass's territory. Supposed there are ai oskols sitting on the i-th wire.
<image>
Sometimes Shaass shots one of the birds and the bird dies (suppose that this bird sat at the i-th wire). Consequently all the birds on the i-th wire to the left of the dead bird get scared and jump up on the wire number i - 1, if there exists no upper wire they fly away. Also all the birds to the right of the dead bird jump down on wire number i + 1, if there exists no such wire they fly away.
Shaass has shot m birds. You're given the initial number of birds on each wire, tell him how many birds are sitting on each wire after the shots.
Input
The first line of the input contains an integer n, (1 ≤ n ≤ 100). The next line contains a list of space-separated integers a1, a2, ..., an, (0 ≤ ai ≤ 100).
The third line contains an integer m, (0 ≤ m ≤ 100). Each of the next m lines contains two integers xi and yi. The integers mean that for the i-th time Shaass shoot the yi-th (from left) bird on the xi-th wire, (1 ≤ xi ≤ n, 1 ≤ yi). It's guaranteed there will be at least yi birds on the xi-th wire at that moment.
Output
On the i-th line of the output print the number of birds on the i-th wire.
Examples
Input
5
10 10 10 10 10
5
2 5
3 13
2 12
1 13
4 6
Output
0
12
5
0
16
Input
3
2 4 1
1
2 2
Output
3
0
3
### Response
```cpp
#include <bits/stdc++.h>
int a[101];
int main() {
int n, m, x, y, i, up, down;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
up = y - 1;
down = a[x] - y;
if ((x - 1) >= 1) a[x - 1] += up;
if ((x + 1) <= n) a[x + 1] += down;
a[x] = 0;
}
for (i = 1; i <= n; i++) printf("%d\n", a[i]);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Takahashi loves the number 7 and multiples of K.
Where is the first occurrence of a multiple of K in the sequence 7,77,777,\ldots? (Also see Output and Sample Input/Output below.)
If the sequence contains no multiples of K, print `-1` instead.
Constraints
* 1 \leq K \leq 10^6
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print an integer representing the position of the first occurrence of a multiple of K. (For example, if the first occurrence is the fourth element of the sequence, print `4`.)
Examples
Input
101
Output
4
Input
2
Output
-1
Input
999983
Output
999982
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int k;
cin>>k;
int x=7%k;
for(int i=1;i<=k;i++){
if(x==0){
cout<<i<<endl;
return 0;
}
x=(x*10+7)%k;
}
cout<<-1<<endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Little Johnny has recently learned about set theory. Now he is studying binary relations. You've probably heard the term "equivalence relation". These relations are very important in many areas of mathematics. For example, the equality of the two numbers is an equivalence relation.
A set ρ of pairs (a, b) of elements of some set A is called a binary relation on set A. For two elements a and b of the set A we say that they are in relation ρ, if pair <image>, in this case we use a notation <image>.
Binary relation is equivalence relation, if:
1. It is reflexive (for any a it is true that <image>);
2. It is symmetric (for any a, b it is true that if <image>, then <image>);
3. It is transitive (if <image> and <image>, than <image>).
Little Johnny is not completely a fool and he noticed that the first condition is not necessary! Here is his "proof":
Take any two elements, a and b. If <image>, then <image> (according to property (2)), which means <image> (according to property (3)).
It's very simple, isn't it? However, you noticed that Johnny's "proof" is wrong, and decided to show him a lot of examples that prove him wrong.
Here's your task: count the number of binary relations over a set of size n such that they are symmetric, transitive, but not an equivalence relations (i.e. they are not reflexive).
Since their number may be very large (not 0, according to Little Johnny), print the remainder of integer division of this number by 109 + 7.
Input
A single line contains a single integer n (1 ≤ n ≤ 4000).
Output
In a single line print the answer to the problem modulo 109 + 7.
Examples
Input
1
Output
1
Input
2
Output
3
Input
3
Output
10
Note
If n = 1 there is only one such relation — an empty one, i.e. <image>. In other words, for a single element x of set A the following is hold: <image>.
If n = 2 there are three such relations. Let's assume that set A consists of two elements, x and y. Then the valid relations are <image>, ρ = {(x, x)}, ρ = {(y, y)}. It is easy to see that the three listed binary relations are symmetric and transitive relations, but they are not equivalence relations.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int first;
scanf("%d", &first);
return first;
}
const int mod = 1000000007;
const int N = 4444;
int c[N][N];
long long f[N];
int main() {
c[0][0] = 1;
for (int i = 1; i < N; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
c[i][j] %= mod;
}
}
f[0] = 1;
for (int i = 1; i < N; i++) {
for (int j = 0; j < i; j++) {
f[i] += f[i - j - 1] * c[i - 1][j];
;
f[i] %= mod;
}
}
int n = nxt();
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += 1ll * c[n][i] * f[n - i];
ans %= mod;
}
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Create a program that reads the attendance numbers of students in a class and the data that stores the ABO blood group and outputs the number of people for each blood type. There are four types of ABO blood types: A, B, AB, and O.
Input
A comma-separated pair of attendance numbers and blood types is given over multiple lines. The attendance number is an integer between 1 and 50, and the blood type is one of the strings "A", "B", "AB" or "O". The number of students does not exceed 50.
Output
Number of people of type A on the first line
Number of people of type B on the second line
Number of people of AB type on the 3rd line
Number of O-shaped people on the 4th line
Is output.
Example
Input
1,B
2,A
3,B
4,AB
5,B
6,O
7,A
8,O
9,AB
10,A
11,A
12,B
13,AB
14,A
Output
5
4
3
2
### Response
```cpp
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
int main(){
int a,e=0,b=0,c=0,d=0;
char h;
string s;
while(cin>>a>>h>>s){
if(s=="A")e++;
if(s=="B")b++;
if(s=="AB")c++;
if(s=="O")d++;
}
cout<<e<<endl<<b<<endl<<c<<endl<<d<<endl;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Mike has a frog and a flower. His frog is named Xaniar and his flower is named Abol. Initially(at time 0), height of Xaniar is h1 and height of Abol is h2. Each second, Mike waters Abol and Xaniar.
<image>
So, if height of Xaniar is h1 and height of Abol is h2, after one second height of Xaniar will become <image> and height of Abol will become <image> where x1, y1, x2 and y2 are some integer numbers and <image> denotes the remainder of a modulo b.
Mike is a competitive programmer fan. He wants to know the minimum time it takes until height of Xania is a1 and height of Abol is a2.
Mike has asked you for your help. Calculate the minimum time or say it will never happen.
Input
The first line of input contains integer m (2 ≤ m ≤ 106).
The second line of input contains integers h1 and a1 (0 ≤ h1, a1 < m).
The third line of input contains integers x1 and y1 (0 ≤ x1, y1 < m).
The fourth line of input contains integers h2 and a2 (0 ≤ h2, a2 < m).
The fifth line of input contains integers x2 and y2 (0 ≤ x2, y2 < m).
It is guaranteed that h1 ≠ a1 and h2 ≠ a2.
Output
Print the minimum number of seconds until Xaniar reaches height a1 and Abol reaches height a2 or print -1 otherwise.
Examples
Input
5
4 2
1 1
0 1
2 3
Output
3
Input
1023
1 2
1 0
1 2
1 1
Output
-1
Note
In the first sample, heights sequences are following:
Xaniar: <image>
Abol: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n) { return (n % 1000000007); }
long long gcd(long long a, long long b) {
if (a == 0 || b == 0) return 0;
if (b == 1)
return b;
else
return gcd(b, a % b);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long m;
cin >> m;
long long h1, a1, x1, y1, h2, a2, x2, y2;
cin >> h1 >> a1 >> x1 >> y1 >> h2 >> a2 >> x2 >> y2;
long long start = h2;
long long t1 = -1;
long long cur = h1;
cur %= m;
for (long long i = 1; i <= m; i++) {
cur = cur * x1 + y1;
cur %= m;
if (cur == a1) {
t1 = i;
break;
}
}
if (t1 == -1) {
cout << -1 << '\n';
return 0;
}
h2 %= m;
for (long long i = 1; i <= t1; i++) {
h2 = h2 * x2 + y2;
h2 %= m;
}
if (h2 == a2) {
cout << t1 << '\n';
return 0;
}
long long t2 = -1;
cur = a1 * x1 + y1;
cur %= m;
if (cur == a1) {
t2 = 1;
} else {
for (long long i = 2; i <= m; i++) {
cur = cur * x1 + y1;
cur %= m;
if (cur == a1) {
t2 = i;
break;
}
}
}
if (t2 == -1) {
cout << -1 << '\n';
return 0;
}
long long a = 1, b = 0;
for (long long i = 0; i < t2; i++) {
a = a * x2;
a %= m;
b = b * x2 + y2;
b %= m;
}
long long steps = -1;
for (long long i = 1; i <= m; i++) {
h2 = h2 * a + b;
h2 %= m;
if (h2 == a2) {
steps = i;
break;
}
}
if (steps == -1) {
cout << -1 << '\n';
return 0;
}
cout << steps * t2 + t1 << '\n';
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here, it is abbreviated as JOI.
JOI is conducting research to confine many microorganisms in one petri dish alive. There are N microorganisms to be investigated, and they are numbered 1, 2, ..., N. When each microorganism is trapped in a petri dish, it instantly releases a harmful substance called foo (fatally odd object) into the petri dish. The amount of foo released by each microorganism is known. The foo released by all the microorganisms trapped in the petri dish is evenly ingested by each microorganism in the petri dish. The foo tolerance of each microorganism is known, and if foo is ingested in excess of this amount, the microorganism will die.
The foo release amount of the microorganism i is ai milligrams, and the foo tolerance is bi milligrams. That is, when the microorganisms i1, i2, ..., ik are trapped in the petri dish, each microorganism in the petri dish ingests (ai1 + ai2 + ... + aik) / k milligrams of foo, and the microorganisms in the petri dish ingest. i will die if this intake is greater than bi.
On behalf of JOI, you must keep as many microorganisms alive in the petri dish as possible. However, no microbes in the petri dish should die from ingestion of foo, as carcasses of microorganisms adversely affect the environment in the petri dish.
It is still a mystery how JOI profits from making "just a strange invention", and no one in JOI knows except the president.
input
Read the following input from standard input.
* The integer N is written on the first line, which indicates that there are N microorganisms to be investigated.
* The following N lines contain information on each microorganism. On the first line of i + (1 ≤ i ≤ N), the positive integers ai and bi are written separated by blanks, and the foo emission amount of the microorganism i is ai milligrams and the foo tolerance is bi milligrams. Represent.
output
Output the maximum number of microorganisms that can be confined in one petri dish to the standard output in one line.
Example
Input
6
12 8
5 9
2 4
10 12
6 7
13 9
Output
3
### Response
```cpp
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<set>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
int n;
P f[300001];
int k[300001];
bool C(int num){
multiset<int> S;
ll sum=0;
for(int i=n-1;i>=0;i--){
sum+=f[i].second;
S.insert(f[i].second);
if(S.size()<num)continue;
if(S.size()>num){
sum-=*S.rbegin();
S.erase(--S.end());
}
if((ll)num*f[i].first>=sum)return true;
}
return false;
}
int main(void){
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d%d",&f[i].second,&f[i].first);
}
sort(f,f+n);
int lb=0,ub=n+1;
while(ub-lb>1){
int mid=(lb+ub)/2;
if(C(mid))lb=mid;
else ub=mid;
}
printf("%d\n",lb);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Autocomplete is a program function that enables inputting the text (in editors, command line shells, browsers etc.) completing the text by its inputted part. Vasya is busy working on a new browser called 'BERowser'. He happens to be working on the autocomplete function in the address line at this very moment. A list consisting of n last visited by the user pages and the inputted part s are known. Your task is to complete s to make it an address of one of the pages from the list. You have to find the lexicographically smallest address having a prefix s.
Input
The first line contains the s line which is the inputted part. The second line contains an integer n (1 ≤ n ≤ 100) which is the number of visited pages. Then follow n lines which are the visited pages, one on each line. All the lines have lengths of from 1 to 100 symbols inclusively and consist of lowercase Latin letters only.
Output
If s is not the beginning of any of n addresses of the visited pages, print s. Otherwise, print the lexicographically minimal address of one of the visited pages starting from s.
The lexicographical order is the order of words in a dictionary. The lexicographical comparison of lines is realized by the '<' operator in the modern programming languages.
Examples
Input
next
2
nextpermutation
nextelement
Output
nextelement
Input
find
4
find
findfirstof
findit
fand
Output
find
Input
find
4
fondfind
fondfirstof
fondit
fand
Output
find
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 100;
vector<string> arr;
int main() {
string s, w;
int x;
cin >> s >> x;
for (int i = 0; i < x; ++i) {
cin >> w;
if (s.size() <= w.size() && w.substr(0, s.size()) == s) arr.push_back(w);
}
sort(arr.begin(), arr.end());
if (arr.size())
cout << arr[0] << endl;
else
cout << s << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
N ladies attend the ball in the King's palace. Every lady can be described with three values: beauty, intellect and richness. King's Master of Ceremonies knows that ladies are very special creatures. If some lady understands that there is other lady at the ball which is more beautiful, smarter and more rich, she can jump out of the window. He knows values of all ladies and wants to find out how many probable self-murderers will be on the ball. Lets denote beauty of the i-th lady by Bi, her intellect by Ii and her richness by Ri. Then i-th lady is a probable self-murderer if there is some j-th lady that Bi < Bj, Ii < Ij, Ri < Rj. Find the number of probable self-murderers.
Input
The first line contains one integer N (1 ≤ N ≤ 500000). The second line contains N integer numbers Bi, separated by single spaces. The third and the fourth lines contain sequences Ii and Ri in the same format. It is guaranteed that 0 ≤ Bi, Ii, Ri ≤ 109.
Output
Output the answer to the problem.
Examples
Input
3
1 4 2
4 3 2
2 5 3
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
const int maxn = 5e5 + 1, inf = 1e9 + 1;
int fen[3 * maxn], n, x[maxn], y[maxn], z[maxn], ans;
vector<int> w;
vector<pair<int, int> > query[maxn];
int ID(int x) { return upper_bound(w.begin(), w.end(), x) - w.begin(); }
void mini(int x, int y) {
for (; x < maxn; x = x + (x & (-x))) {
fen[x] = max(fen[x], y);
}
return;
}
int get(int x) {
int res = 0;
for (; x > 0; x = x - (x & (-x))) {
res = max(res, fen[x]);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int t1;
cin >> t1;
x[i] = t1;
w.push_back(t1);
}
for (int i = 1; i <= n; i++) {
int t1;
cin >> t1;
y[i] = t1;
w.push_back(t1);
}
for (int i = 1; i <= n; i++) {
int t1;
cin >> t1;
z[i] = t1;
w.push_back(t1);
}
sort(w.begin(), w.end());
w.resize(unique(w.begin(), w.end()) - w.begin());
for (int i = 1; i <= n; i++) {
x[i] = ID(x[i]);
y[i] = ID(y[i]);
z[i] = ID(z[i]);
query[x[i]].push_back({y[i], z[i]});
}
for (int i = maxn - 1; i >= 1; i--) {
for (auto tmp : query[i]) {
int t = get(maxn - 1 - tmp.first);
if (t > tmp.second) {
ans++;
}
}
for (auto tmp : query[i]) {
mini(maxn - tmp.first, tmp.second);
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Ivan wants to have a good dinner. A good dinner should consist of a first course, a second course, a drink, and a dessert.
There are n_1 different types of first courses Ivan can buy (the i-th of them costs a_i coins), n_2 different types of second courses (the i-th of them costs b_i coins), n_3 different types of drinks (the i-th of them costs c_i coins) and n_4 different types of desserts (the i-th of them costs d_i coins).
Some dishes don't go well with each other. There are m_1 pairs of first courses and second courses that don't go well with each other, m_2 pairs of second courses and drinks, and m_3 pairs of drinks and desserts that don't go well with each other.
Ivan wants to buy exactly one first course, one second course, one drink, and one dessert so that they go well with each other, and the total cost of the dinner is the minimum possible. Help him to find the cheapest dinner option!
Input
The first line contains four integers n_1, n_2, n_3 and n_4 (1 ≤ n_i ≤ 150000) — the number of types of first courses, second courses, drinks and desserts, respectively.
Then four lines follow. The first line contains n_1 integers a_1, a_2, ..., a_{n_1} (1 ≤ a_i ≤ 10^8), where a_i is the cost of the i-th type of first course. Three next lines denote the costs of second courses, drinks, and desserts in the same way (1 ≤ b_i, c_i, d_i ≤ 10^8).
The next line contains one integer m_1 (0 ≤ m_1 ≤ 200000) — the number of pairs of first and second courses that don't go well with each other. Each of the next m_1 lines contains two integers x_i and y_i (1 ≤ x_i ≤ n_1; 1 ≤ y_i ≤ n_2) denoting that the first course number x_i doesn't go well with the second course number y_i. All these pairs are different.
The block of pairs of second dishes and drinks that don't go well with each other is given in the same format. The same for pairs of drinks and desserts that don't go well with each other (0 ≤ m_2, m_3 ≤ 200000).
Output
If it's impossible to choose a first course, a second course, a drink, and a dessert so that they go well with each other, print -1. Otherwise, print one integer — the minimum total cost of the dinner.
Examples
Input
4 3 2 1
1 2 3 4
5 6 7
8 9
10
2
1 2
1 1
2
3 1
3 2
1
1 1
Output
26
Input
1 1 1 1
1
1
1
1
1
1 1
0
0
Output
-1
Note
The best option in the first example is to take the first course 2, the second course 1, the drink 2 and the dessert 1.
In the second example, the only pair of the first course and the second course is bad, so it's impossible to have dinner.
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <string>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <complex>
#include <functional>
using namespace std;
typedef long long ll;
typedef struct node {
int num;
int val;
int mini;
node(int nn = 0, int v = 0, int m = 0) : num(nn), val(v), mini(m) { }
} node;
typedef struct edge {
int x, y;
edge(int xx = 0, int yy = 0) : x(xx), y(yy) { }
} edge;
inline bool cmp1(node a, node b) {
if(a.val == b.val) return a.num < b.num;
return a.val < b.val;
}
inline bool cmp2(edge a, edge b) {
if(a.y == b.y) return a.x < b.x;
return a.y < b.y;
}
int n[4];
node v[4][150000 + 10];
int match[4][150000 + 10];
int m[4];
vector<int> e[4][150000];
int ans = 0x3f3f3f3f;
int main()
{
for(int i = 0;i < 4; i++) {
scanf("%d", &n[i]);
}
int vv;
for(int i = 0;i < 4; i++) {
for(int j = 0;j < n[i]; j++) {
scanf("%d", &vv);
v[i][j] = node(j, vv, 0);
}
}
for(int i = 1;i < 4; i++) {
scanf("%d", &m[i]);
sort(v[i - 1], v[i - 1] + n[i - 1], cmp1);
for(int j = 0;j < n[i - 1]; j++) {
match[i - 1][v[i - 1][j].num] = j;
}
for(int j = 0;j < m[i]; j++) {
int x, y;
scanf("%d%d", &x, &y);
x--; //输入下标从1开始，我下标从0开始
y--;
e[i][y].push_back(match[i - 1][x]);
}
for(int j = 0;j < n[i]; j++) {
sort(e[i][j].begin(), e[i][j].end());
if(e[i][j].size() == 0) continue;
int tot = e[i][j].size();
int cur = 0;
while(v[i][j].mini == e[i][j][cur]) {
cur++;
v[i][j].mini++;
if(cur >= tot) break;
}
}
for(int j = 0;j < n[i]; j++) {
int front = v[i][j].mini;
if(front >= n[i - 1]) v[i][j].val = 0x3f3f3f3f;
v[i][j].val += v[i - 1][front].val;
if(i == 3) ans = min(ans, v[i][j].val);
}
}
if(ans >= 0x3f3f3f3f) printf("-1\n");
else printf("%d\n", ans);
return 0;
}
/*
4 3 2 1
4 3 2 1
7 6 5
9 8
10
2
1 2
1 1
2
3 1
3 2
1
1 1
*/
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You have matrix a of size n × n. Let's number the rows of the matrix from 1 to n from top to bottom, let's number the columns from 1 to n from left to right. Let's use aij to represent the element on the intersection of the i-th row and the j-th column.
Matrix a meets the following two conditions:
* for any numbers i, j (1 ≤ i, j ≤ n) the following inequality holds: aij ≥ 0;
* <image>.
Matrix b is strictly positive, if for any numbers i, j (1 ≤ i, j ≤ n) the inequality bij > 0 holds. You task is to determine if there is such integer k ≥ 1, that matrix ak is strictly positive.
Input
The first line contains integer n (2 ≤ n ≤ 2000) — the number of rows and columns in matrix a.
The next n lines contain the description of the rows of matrix a. The i-th line contains n non-negative integers ai1, ai2, ..., ain (0 ≤ aij ≤ 50). It is guaranteed that <image>.
Output
If there is a positive integer k ≥ 1, such that matrix ak is strictly positive, print "YES" (without the quotes). Otherwise, print "NO" (without the quotes).
Examples
Input
2
1 0
0 1
Output
NO
Input
5
4 5 6 1 2
1 2 3 4 5
6 4 1 2 4
1 1 1 1 1
4 4 4 4 4
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g, gr;
vector<char> used;
vector<int> order, component;
void dfs1(int v) {
used[v] = true;
for (size_t i = 0; i < g[v].size(); ++i)
if (!used[g[v][i]]) dfs1(g[v][i]);
order.push_back(v);
}
void dfs2(int v) {
used[v] = true;
component.push_back(v);
for (size_t i = 0; i < gr[v].size(); ++i)
if (!used[gr[v][i]]) dfs2(gr[v][i]);
}
int main() {
int n;
scanf("%d", &n);
g.resize(n + 5);
gr.resize(n + 5);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; ++j) {
int k;
scanf("%d", &k);
if (k > 0 && i != j) {
g[i].push_back(j);
gr[j].push_back(i);
}
}
}
used.assign(n, false);
for (int i = 0; i < n; ++i)
if (!used[i]) dfs1(i);
used.assign(n, false);
int cc = 0;
for (int i = 0; i < n; ++i) {
int v = order[n - 1 - i];
if (!used[v]) {
dfs2(v);
++cc;
component.clear();
}
}
if (cc == 1) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Lunar New Year is approaching, and you bought a matrix with lots of "crosses".
This matrix M of size n × n contains only 'X' and '.' (without quotes). The element in the i-th row and the j-th column (i, j) is defined as M(i, j), where 1 ≤ i, j ≤ n. We define a cross appearing in the i-th row and the j-th column (1 < i, j < n) if and only if M(i, j) = M(i - 1, j - 1) = M(i - 1, j + 1) = M(i + 1, j - 1) = M(i + 1, j + 1) = 'X'.
The following figure illustrates a cross appearing at position (2, 2) in a 3 × 3 matrix.
X.X
.X.
X.X
Your task is to find out the number of crosses in the given matrix M. Two crosses are different if and only if they appear in different rows or columns.
Input
The first line contains only one positive integer n (1 ≤ n ≤ 500), denoting the size of the matrix M.
The following n lines illustrate the matrix M. Each line contains exactly n characters, each of them is 'X' or '.'. The j-th element in the i-th line represents M(i, j), where 1 ≤ i, j ≤ n.
Output
Output a single line containing only one integer number k — the number of crosses in the given matrix M.
Examples
Input
5
.....
.XXX.
.XXX.
.XXX.
.....
Output
1
Input
2
XX
XX
Output
0
Input
6
......
X.X.X.
.X.X.X
X.X.X.
.X.X.X
......
Output
4
Note
In the first sample, a cross appears at (3, 3), so the answer is 1.
In the second sample, no crosses appear since n < 3, so the answer is 0.
In the third sample, crosses appear at (3, 2), (3, 4), (4, 3), (4, 5), so the answer is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char a[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
if (n < 3) {
cout << "0";
return 0;
}
int c = 0;
int x, y;
for (int i = 2; i <= n - 1; i++) {
for (int j = 2; j <= n - 1; j++) {
if (a[i][j] == 'X' && a[i + 1][j + 1] == 'X' && a[i + 1][j - 1] == 'X' &&
a[i - 1][j + 1] == 'X' && a[i - 1][j - 1] == 'X' &&
(x != i || y != j)) {
x = i;
y = j;
c++;
}
}
}
cout << c;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
void print(T1 a[], T2 n) {
for (T2 i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
template <class T1, class T2>
void print(vector<T1> a, T2 n) {
for (T2 i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
long long int modexpo(long long int a, long long int b, long long int m) {
if (b == 0) {
return 1;
} else if (a == 1) {
return 1;
}
if (b % 2 == 0) {
long long int t = modexpo(a, b / 2, m);
t = (t * t) % m;
return t;
} else {
long long int t = modexpo(a, b / 2, m);
t = (t * t) % m;
t = (t * a) % m;
return t;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int cntTest;
cin >> cntTest;
for (int test = 0; test < cntTest; test++) {
long long int n, t, a, b;
cin >> n >> t >> a >> b;
vector<pair<long long int, long long int>> v;
vector<int> hard(n);
int cntA = 0, cntB = 0;
for (int i = 0; i < n; i++) {
cin >> hard[i];
if (hard[i]) {
cntB++;
} else {
cntA++;
}
}
for (int i = 0; i < n; i++) {
long long int time;
cin >> time;
v.push_back({time, hard[i]});
}
v.push_back({t + 1, 0});
sort(v.begin(), v.end());
long long int cnt1 = 0, cnt2 = 0;
long long int ans = 0;
for (int i = 0; i <= n; i++) {
long long int need = cnt1 * a + cnt2 * b;
long long int has = v[i].first - 1 - need;
if (has >= 0) {
long long int canA = min((cntA - cnt1), has / a);
has -= canA * a;
long long int canB = min((cntB - cnt2), has / b);
ans = max(ans, cnt1 + cnt2 + canA + canB);
}
if (v[i].second) {
cnt2++;
} else {
cnt1++;
}
}
cout << ans << "\n";
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
We have N cards. A number a_i is written on the i-th card.
Alice and Bob will play a game using these cards. In this game, Alice and Bob alternately take one card. Alice goes first.
The game ends when all the cards are taken by the two players, and the score of each player is the sum of the numbers written on the cards he/she has taken. When both players take the optimal strategy to maximize their scores, find Alice's score minus Bob's score.
Constraints
* N is an integer between 1 and 100 (inclusive).
* a_i \ (1 \leq i \leq N) is an integer between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 a_3 ... a_N
Output
Print Alice's score minus Bob's score when both players take the optimal strategy to maximize their scores.
Examples
Input
2
3 1
Output
2
Input
3
2 7 4
Output
5
Input
4
20 18 2 18
Output
18
### Response
```cpp
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n,a[100],sa=0,i,j;
cin>>n;
for(i=0;i<n;i++)cin>>a[i];
sort(a,a+n,greater<int>());
for(j=0;j<n;j++){
if(j%2!=0)sa-=a[j];
else sa+=a[j];
}
cout<<sa<<endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Instructors of Some Informatics School make students go to bed.
The house contains n rooms, in each room exactly b students were supposed to sleep. However, at the time of curfew it happened that many students are not located in their assigned rooms. The rooms are arranged in a row and numbered from 1 to n. Initially, in i-th room there are ai students. All students are currently somewhere in the house, therefore a1 + a2 + ... + an = nb. Also 2 instructors live in this house.
The process of curfew enforcement is the following. One instructor starts near room 1 and moves toward room n, while the second instructor starts near room n and moves toward room 1. After processing current room, each instructor moves on to the next one. Both instructors enter rooms and move simultaneously, if n is odd, then only the first instructor processes the middle room. When all rooms are processed, the process ends.
When an instructor processes a room, she counts the number of students in the room, then turns off the light, and locks the room. Also, if the number of students inside the processed room is not equal to b, the instructor writes down the number of this room into her notebook (and turns off the light, and locks the room). Instructors are in a hurry (to prepare the study plan for the next day), so they don't care about who is in the room, but only about the number of students.
While instructors are inside the rooms, students can run between rooms that are not locked and not being processed. A student can run by at most d rooms, that is she can move to a room with number that differs my at most d. Also, after (or instead of) running each student can hide under a bed in a room she is in. In this case the instructor will not count her during the processing. In each room any number of students can hide simultaneously.
Formally, here is what's happening:
* A curfew is announced, at this point in room i there are ai students.
* Each student can run to another room but not further than d rooms away from her initial room, or stay in place. After that each student can optionally hide under a bed.
* Instructors enter room 1 and room n, they count students there and lock the room (after it no one can enter or leave this room).
* Each student from rooms with numbers from 2 to n - 1 can run to another room but not further than d rooms away from her current room, or stay in place. Each student can optionally hide under a bed.
* Instructors move from room 1 to room 2 and from room n to room n - 1.
* This process continues until all rooms are processed.
Let x1 denote the number of rooms in which the first instructor counted the number of non-hidden students different from b, and x2 be the same number for the second instructor. Students know that the principal will only listen to one complaint, therefore they want to minimize the maximum of numbers xi. Help them find this value if they use the optimal strategy.
Input
The first line contains three integers n, d and b (2 ≤ n ≤ 100 000, 1 ≤ d ≤ n - 1, 1 ≤ b ≤ 10 000), number of rooms in the house, running distance of a student, official number of students in a room.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109), i-th of which stands for the number of students in the i-th room before curfew announcement.
It is guaranteed that a1 + a2 + ... + an = nb.
Output
Output one integer, the minimal possible value of the maximum of xi.
Examples
Input
5 1 1
1 0 0 0 4
Output
1
Input
6 1 2
3 8 0 1 0 0
Output
2
Note
In the first sample the first three rooms are processed by the first instructor, and the last two are processed by the second instructor. One of the optimal strategies is the following: firstly three students run from room 5 to room 4, on the next stage two of them run to room 3, and one of those two hides under a bed. This way, the first instructor writes down room 2, and the second writes down nothing.
In the second sample one of the optimal strategies is the following: firstly all students in room 1 hide, all students from room 2 run to room 3. On the next stage one student runs from room 3 to room 4, and 5 students hide. This way, the first instructor writes down rooms 1 and 2, the second instructor writes down rooms 5 and 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, d, b;
int a[200007], cnt[200007], aa[200007];
bool calc(int dis, int pos) {
int t = (dis + d - 1) / d, tot = min(pos, n - pos + 1);
return (t <= tot);
}
bool check(int x) {
for (int i = 1; i <= n; i++) a[i] = aa[i];
for (int i = x + 1; i <= n; i++) cnt[i] = b;
int pos = x + 1;
for (int i = 1; i <= n; i++) {
while (a[i] > 0) {
if (calc(abs(pos - i), pos)) {
int del = min(a[i], cnt[pos]);
a[i] -= del;
cnt[pos] -= del;
if (cnt[pos] == 0) ++pos;
if (pos + x - 1 >= n) return true;
} else
break;
}
}
return false;
}
int main() {
scanf("%d%d%d", &n, &d, &b);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) aa[i] = a[i];
int lx = 0, rx = (n + 1) / 2;
while (rx - lx > 1) {
int mid = (lx + rx) / 2;
if (check(mid))
rx = mid;
else
lx = mid;
}
if (check(lx))
printf("%d\n", lx);
else
printf("%d\n", rx);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
### Response
```cpp
#include<iostream>
#include<vector>
using namespace std;
bool flags[10];
int solved[1024][331];
int trans(){
int a=0;
for(int i=0;i<10;i++)
a+= ( int(flags[i])<<i );
return a;
}
int solve(int index,int sum,int max){
int a=trans();
if(sum < 0 || sum>330 || index > max){ return 0; }
if(index == max && sum == 0){
return solved[a][0]=1;
}
if(solved[a][sum]!=-1) return solved[a][sum];
int count=0;
for(int i=0;i<10;i++){
if(!flags[i]){
flags[i]=true;
int s=solve(index+1,sum-index*i,max);
count+=s;
flags[i]=false;
}
}
return solved[a][sum]=count;
}
int main(){
int n,s;
while(cin>>n>>s){
for(int i=0;i<1024;i++)
for(int j=0;j<331;j++)
solved[i][j]=-1;
cout<<solve(1,s,n+1)<<endl;
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Grigoriy, like the hero of one famous comedy film, found a job as a night security guard at the museum. At first night he received embosser and was to take stock of the whole exposition.
Embosser is a special devise that allows to "print" the text of a plastic tape. Text is printed sequentially, character by character. The device consists of a wheel with a lowercase English letters written in a circle, static pointer to the current letter and a button that print the chosen letter. At one move it's allowed to rotate the alphabetic wheel one step clockwise or counterclockwise. Initially, static pointer points to letter 'a'. Other letters are located as shown on the picture:
<image>
After Grigoriy add new item to the base he has to print its name on the plastic tape and attach it to the corresponding exhibit. It's not required to return the wheel to its initial position with pointer on the letter 'a'.
Our hero is afraid that some exhibits may become alive and start to attack him, so he wants to print the names as fast as possible. Help him, for the given string find the minimum number of rotations of the wheel required to print it.
Input
The only line of input contains the name of some exhibit — the non-empty string consisting of no more than 100 characters. It's guaranteed that the string consists of only lowercase English letters.
Output
Print one integer — the minimum number of rotations of the wheel, required to print the name given in the input.
Examples
Input
zeus
Output
18
Input
map
Output
35
Input
ares
Output
34
Note
<image>
To print the string from the first sample it would be optimal to perform the following sequence of rotations:
1. from 'a' to 'z' (1 rotation counterclockwise),
2. from 'z' to 'e' (5 clockwise rotations),
3. from 'e' to 'u' (10 rotations counterclockwise),
4. from 'u' to 's' (2 counterclockwise rotations).
In total, 1 + 5 + 10 + 2 = 18 rotations are required.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
{
string s;
cin >> s;
int moves = 0;
int start = 0;
for (int i = 0; i < s.length(); i++) {
int value = s[i] - 97;
int m = abs(start - value);
if (m > 13) {
moves += 26 - m;
} else {
moves += m;
}
start = value;
}
cout << moves;
return 0;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Vanya has a scales for weighing loads and weights of masses w0, w1, w2, ..., w100 grams where w is some integer not less than 2 (exactly one weight of each nominal value). Vanya wonders whether he can weight an item with mass m using the given weights, if the weights can be put on both pans of the scales. Formally speaking, your task is to determine whether it is possible to place an item of mass m and some weights on the left pan of the scales, and some weights on the right pan of the scales so that the pans of the scales were in balance.
Input
The first line contains two integers w, m (2 ≤ w ≤ 109, 1 ≤ m ≤ 109) — the number defining the masses of the weights and the mass of the item.
Output
Print word 'YES' if the item can be weighted and 'NO' if it cannot.
Examples
Input
3 7
Output
YES
Input
100 99
Output
YES
Input
100 50
Output
NO
Note
Note to the first sample test. One pan can have an item of mass 7 and a weight of mass 3, and the second pan can have two weights of masses 9 and 1, correspondingly. Then 7 + 3 = 9 + 1.
Note to the second sample test. One pan of the scales can have an item of mass 99 and the weight of mass 1, and the second pan can have the weight of mass 100.
Note to the third sample test. It is impossible to measure the weight of the item in the manner described in the input.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int w, m;
bool solve(int a) {
if (a == 0 || a == 1) return true;
if ((a + 1) % w == 0 && solve((a + 1) / w)) return true;
if ((a) % w == 0 && solve((a) / w)) return true;
if ((a - 1) % w == 0 && solve((a - 1) / w)) return true;
return false;
}
int main() {
cin >> w >> m;
if (solve(m))
cout << "YES";
else
cout << "NO";
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e10 + 6;
const long long MOD = 1e9 + 7;
const long long mod = 998244353;
const int MX = 1e6 + 5;
const int LG = 25;
template <typename t>
void fff(const char* x, t&& val1) {
cout << x << " : " << val1 << "\n";
}
template <typename t1, typename... t2>
void fff(const char* x, t1&& val1, t2&&... val2) {
const char* xd = strchr(x + 1, ',');
cout.write(x, xd - x) << " : " << val1 << " | ";
fff(xd + 1, val2...);
}
long long a[MX];
long long b[MX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long tc;
cin >> tc;
while (tc--) {
long long n;
cin >> n;
map<char, long long> mapa;
for (int i = 0; i < n; i++) {
string a;
cin >> a;
for (int i = 0; i < a.size(); i++) {
mapa[a[i]]++;
}
}
long long flag = 0;
for (auto xd : mapa) {
if (xd.second % n != 0) flag = 1;
}
if (flag == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
int a[N], b[N];
int ans, n;
int calc(int L, int R) {
if (L > R) return 0;
long long res = 0;
for (int i = n, l = 1, r = 1; i >= 1; i--) {
for (; l <= n && b[i] + b[l] < L; l++)
;
for (; r <= n && b[i] + b[r] <= R; r++)
;
res += r - l - (l <= i && i < r);
}
return res >> 1 & 1;
}
int sol(int x) {
for (int i = 1; i <= n; i++) b[i] = a[i] & (1 << x + 1) - 1;
sort(b + 1, b + n + 1);
return (calc(1 << x, (1 << x + 1) - 1) ^ calc(3 << x, (1 << x + 2) - 2)) << x;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < 30; i++) ans |= sol(i);
printf("%d\n", ans);
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Niwel is a little golden bear. As everyone knows, bears live in forests, but Niwel got tired of seeing all the trees so he decided to move to the city.
In the city, Niwel took on a job managing bears to deliver goods. The city that he lives in can be represented as a directed graph with n nodes and m edges. Each edge has a weight capacity. A delivery consists of a bear carrying weights with their bear hands on a simple path from node 1 to node n. The total weight that travels across a particular edge must not exceed the weight capacity of that edge.
Niwel has exactly x bears. In the interest of fairness, no bear can rest, and the weight that each bear carries must be exactly the same. However, each bear may take different paths if they like.
Niwel would like to determine, what is the maximum amount of weight he can deliver (it's the sum of weights carried by bears). Find the maximum weight.
Input
The first line contains three integers n, m and x (2 ≤ n ≤ 50, 1 ≤ m ≤ 500, 1 ≤ x ≤ 100 000) — the number of nodes, the number of directed edges and the number of bears, respectively.
Each of the following m lines contains three integers ai, bi and ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ci ≤ 1 000 000). This represents a directed edge from node ai to bi with weight capacity ci. There are no self loops and no multiple edges from one city to the other city. More formally, for each i and j that i ≠ j it's guaranteed that ai ≠ aj or bi ≠ bj. It is also guaranteed that there is at least one path from node 1 to node n.
Output
Print one real value on a single line — the maximum amount of weight Niwel can deliver if he uses exactly x bears. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 4 3
1 2 2
2 4 1
1 3 1
3 4 2
Output
1.5000000000
Input
5 11 23
1 2 3
2 3 4
3 4 5
4 5 6
1 3 4
2 4 5
3 5 6
1 4 2
2 5 3
1 5 2
3 2 30
Output
10.2222222222
Note
In the first sample, Niwel has three bears. Two bears can choose the path <image>, while one bear can choose the path <image>. Even though the bear that goes on the path <image> can carry one unit of weight, in the interest of fairness, he is restricted to carry 0.5 units of weight. Thus, the total weight is 1.5 units overall. Note that even though Niwel can deliver more weight with just 2 bears, he must use exactly 3 bears on this day.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int ans;
int m, n, maxflow;
const int length = 1000;
const int mymax = -1;
int path[2000];
int id[2000];
int thetop = 0;
int a[505][3];
class mincostMaxFlow {
private:
int flow[length * 2];
int capacity[length * 2];
int value[length * 2];
int head[length];
int next[length];
bool isvisited[length * 2];
int queue[length * 5];
int dist[length];
int cost[length];
int pos;
int e[length];
int prev[length];
int source;
int target;
int prev_vec[length];
double smallest;
public:
void init(int s, int e) {
source = s;
target = e;
pos = 0;
clear();
}
void clear() {
memset(head, -1, sizeof(head));
memset(flow, 0, sizeof(flow));
memset(capacity, 0, sizeof(capacity));
pos = 0;
}
void reset(double d) {
for (int i = 0; i < pos; i++) {
flow[i] = 0.0;
}
smallest = d;
}
void add(int s, int t, int cap, int v) {
e[pos] = t;
cost[pos] = v;
capacity[pos] = (double)cap;
next[pos] = head[s];
head[s] = pos++;
e[pos] = s;
cost[pos] = -v;
next[pos] = head[t];
head[t] = pos++;
}
bool find() {
memset(isvisited, false, sizeof(isvisited));
int start = 0;
int end = 1;
queue[start] = source;
int l = 0;
while (start < end) {
int t = queue[start++];
for (int i = head[t]; i != -1; i = next[i]) {
if (capacity[i] - flow[i] > 0 && !isvisited[e[i]]) {
prev[e[i]] = i;
queue[end++] = e[i];
isvisited[e[i]] = true;
if (e[i] == target) return true;
}
}
}
return false;
}
int getmaxflow_mincost() {
int i = 0;
int j = 1;
ans = 0;
i = 0;
;
int l = 0;
while (find()) {
int max = INT_MAX;
int t = target;
while (t != source) {
int i = prev[t];
if (max > capacity[i] - flow[i]) {
max = capacity[i] - flow[i];
}
t = e[i ^ 1];
}
ans += max;
t = target;
while (t != source) {
int i = prev[t];
flow[i] += max;
flow[i ^ 1] = -flow[i];
prev_vec[t] = e[i ^ 1];
t = e[i ^ 1];
}
j++;
}
return ans;
}
void getcost() {
int s, t;
for (int i = 0; i < pos; i++) {
if (flow[i] > 0) {
t = e[i] / 2;
s = e[i ^ 1] / 2;
path[t] = s;
}
}
int cnt = 1;
for (int i = 0; i < n; i++) {
if (path[i] >= n) {
id[i] = cnt++;
} else {
id[i] = id[path[i]];
}
}
}
};
mincostMaxFlow solution;
void process() {
int i, j, t;
int ret = 0;
}
void input() {
int i, j, t, k, u, v;
int s;
scanf("%d %d %d", &n, &m, &thetop);
t = 0;
solution.init(1, n);
for (i = 0; i < m; i++) {
scanf("%d %d %d", &a[i][0], &a[i][1], &a[i][2]);
if (a[i][2] > t) t = a[i][2];
}
double l = 0;
double h = (double)t;
double mid;
double diff = 0.00000000001;
int c = 0;
while (l + diff < h) {
mid = (l + h) / 2;
solution.clear();
for (i = 0; i < m; i++) {
k = (int)((double)a[i][2] / mid);
if (k > 0)
solution.add(a[i][0], a[i][1], k, 0);
else if (k == -2147483648)
solution.add(a[i][0], a[i][1], INT_MAX, 0);
}
v = solution.getmaxflow_mincost();
if (v >= thetop) {
l = mid;
} else {
h = mid;
}
c++;
if (c >= 100) break;
}
printf("%lf\n", l * thetop);
}
int main() {
input();
process();
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Based on the information of the time when study started and the time when study ended, check whether the total time studied in one day is t or more, and if not, create a program to find the shortage time. Time is one unit per hour, and minutes and seconds are not considered. The time is expressed in 24-hour notation in 1-hour units.
Enter the target time of study per day and the information of the time actually studied (number of studies n, start time s and end time f of each study), and check whether the total study time has reached the target. If it has reached, write "OK", and if it has not reached, write a program that outputs the insufficient time. However, the study time spent on each will not overlap.
Example: Target time | Study time | Judgment
--- | --- | ---
10 hours | 6:00 to 11:00 = 5 hours
12:00 to 15:00 = 3 hours
18:00 to 22:00 = 4 hours | OK
14 hours | 6:00 to 11:00 = 5 hours
13:00 to 20:00 = 7 hours
| 2 hours shortage
Input example
Ten
3
6 11
12 15
18 22
14
2
6 11
13 20
0
Output example
OK
2
input
Given a sequence of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
t
n
s1 f1
s2 f2
::
sn fn
The first line gives the target time of the day t (0 ≤ t ≤ 22), and the second line gives the number of studies n (1 ≤ n ≤ 10). The following n lines are given the start time si and end time f (6 ≤ si, fi ≤ 22) of the i-th study.
The number of datasets does not exceed 100.
output
Outputs OK or missing time on one line for each dataset.
Example
Input
10
3
6 11
12 15
18 22
14
2
6 11
13 20
0
Output
OK
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, s, f;
while (cin >> t, t) {
cin >> n;
int sum = 0;
while (n--) {
cin >> s >> f;
sum += f - s;
}
if (sum >= t) cout << "OK\n";
else cout << t - sum << "\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.